From 0c0ca8c47cbb468350b2e7ca77be09b47c64d12c Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 9 Oct 2024 11:59:01 +0100 Subject: [PATCH 001/291] Grid_malawi.py: Loads shap files and creates a graph of Malawi. Have then gridded over this graph in (1x1 degrees), which will be used as a reference for climate data retrieval. Have additionally loaded in facilities from the ResourceFile_Master_Facilities_List, and mapped them onto specific districts (from the ResourceFile_mwi_admbnda_adm2_nso_20181016 shap file) --- src/scripts/climate_change/grid_malawi.py | 61 +++++++++++++++++++++++ 1 file changed, 61 insertions(+) create mode 100644 src/scripts/climate_change/grid_malawi.py diff --git a/src/scripts/climate_change/grid_malawi.py b/src/scripts/climate_change/grid_malawi.py new file mode 100644 index 0000000000..6f5bdde8a7 --- /dev/null +++ b/src/scripts/climate_change/grid_malawi.py @@ -0,0 +1,61 @@ +import geopandas as gpd +import pandas as pd +from shapely.geometry import Polygon +import numpy as np +import matplotlib.pyplot as plt + +# Load Malawi shapefile +malawi = gpd.read_file("/Users/rem76/PycharmProjects/TLOmodel/resources/mapping/ResourceFile_mwi_admbnda_adm0_nso_20181016.shp") +malawi_admin1 = gpd.read_file("/Users/rem76/PycharmProjects/TLOmodel/resources/mapping/ResourceFile_mwi_admbnda_adm1_nso_20181016.shp") +malawi_admin2 = gpd.read_file("/Users/rem76/PycharmProjects/TLOmodel/resources/mapping/ResourceFile_mwi_admbnda_adm2_nso_20181016.shp") +print(malawi_admin2) +grid_size = 1 +minx, miny, maxx, maxy = malawi.total_bounds +x_coords = np.arange(minx, maxx, grid_size) +y_coords = np.arange(miny, maxy, grid_size) +polygons = [Polygon([(x, y), (x + grid_size, y), (x + grid_size, y + grid_size), (x, y + grid_size)]) for x in x_coords for y in y_coords] + +grid = gpd.GeoDataFrame({'geometry': polygons}, crs=malawi.crs) + +grid_clipped = gpd.overlay(grid, malawi, how='intersection') +grid_clipped_ADM1 = gpd.overlay(grid, malawi_admin1, how='intersection') + + +cmap = plt.cm.get_cmap('tab20', len(grid_clipped_ADM1['ADM1_EN'].unique())) + +fig, ax = plt.subplots(figsize=(10, 10)) +malawi_admin2.plot(ax=ax, edgecolor='black', color='white') +grid_clipped.plot(ax=ax, edgecolor='#1C6E8C', color='#9AC4F8', alpha=0.5) +grid_clipped_ADM1.plot(column='ADM1_EN', ax=ax, cmap=cmap, edgecolor='#1C6E8C', alpha=0.7, legend=True) + +# Finalize plot +plt.title("Malawi with Overlaying Grids - 1 degree") +plt.xlabel("Longitude") +plt.ylabel("Latitude") +plt.show() + + +########### Create new table with facilities and add coordinates to each facility + +facilities_by_area = pd.read_csv("/Users/rem76/PycharmProjects/TLOmodel/resources/healthsystem/organisation/ResourceFile_Master_Facilities_List.csv") + +# Referral hospitals have no assigned district - assign biggest city in region? +facilities_by_area.loc[facilities_by_area['Facility_Name'] == 'Referral Hospital_Southern', 'District'] = 'Blantyre City' +facilities_by_area.loc[facilities_by_area['Facility_Name'] == 'Referral Hospital_Central', 'District'] = 'Lilongwe City' +facilities_by_area.loc[facilities_by_area['Facility_Name'] == 'Referral Hospital_Northern', 'District'] = 'Mzuzu City' + +# Mental hospital is in Zomba +facilities_by_area.loc[facilities_by_area['Facility_Name'] == 'Zomba Mental Hospital', 'District'] = 'Zomba City' +facilities_by_area.loc[facilities_by_area['Facility_Name'] == 'Zomba Mental Hospital', 'Region'] = 'Southern' + +# HQ based in Lilongwe? +facilities_by_area.loc[facilities_by_area['Facility_Name'] == 'Headquarter', 'District'] = 'Lilongwe City' +facilities_by_area.loc[facilities_by_area['Facility_Name'] == 'Headquarter', 'Region'] = 'Central' + + +facilities_with_districts = facilities_by_area.merge(malawi_admin2, + how='left', + left_on='District', + right_on='ADM2_EN') + +print(facilities_with_districts) From 32134f65152122c11005e2e1c3910fa5b743dd47 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 9 Oct 2024 11:59:49 +0100 Subject: [PATCH 002/291] Initial plot of heaviest precipitation days from CCKP. Will abandon due to lack of clarity on data distributions --- .../plotting_heavy_precipitation.py | 53 +++++++++++++++++++ 1 file changed, 53 insertions(+) create mode 100644 src/scripts/climate_change/plotting_heavy_precipitation.py diff --git a/src/scripts/climate_change/plotting_heavy_precipitation.py b/src/scripts/climate_change/plotting_heavy_precipitation.py new file mode 100644 index 0000000000..0db4fb9c53 --- /dev/null +++ b/src/scripts/climate_change/plotting_heavy_precipitation.py @@ -0,0 +1,53 @@ +import argparse +from pathlib import Path + +import numpy as np +import pandas as pd +from matplotlib import pyplot as plt + +# +# def apply(results_folder: Path, output_folder: Path): +output_folder = Path("/Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/Climate_health") + +all_data_max_5_day_precip = pd.ExcelFile( + '/Users/rem76/Documents/Climate_change_data/Max_5_day_precip/ssp126/cmip6-x0.25_timeseries_rx5day_timeseries_seasonal_2015-2100_p90_ssp126_ensemble_all.xlsx') +median_max_5_day_precip = pd.read_excel(all_data_max_5_day_precip, 'median') +median_max_5_day_precip.drop("code", inplace=True, axis=1) +p10_max_5_day_precip = pd.read_excel(all_data_max_5_day_precip, 'p10') +p10_max_5_day_precip.drop("code", inplace=True, axis=1) +p90_max_5_day_precip = pd.read_excel(all_data_max_5_day_precip, 'p90') +p90_max_5_day_precip.drop("code", inplace=True, axis=1) + +median_values = pd.to_numeric( + median_max_5_day_precip[median_max_5_day_precip['name'] == 'Central Region'].iloc[0, 1:].values, errors='coerce') +p10_values = pd.to_numeric(p10_max_5_day_precip[median_max_5_day_precip['name'] == 'Central Region'].iloc[0, 1:].values, + errors='coerce') +p90_values = pd.to_numeric(p90_max_5_day_precip[median_max_5_day_precip['name'] == 'Central Region'].iloc[0, 1:].values, + errors='coerce') +median_values = np.nan_to_num(median_values, nan=0.0, posinf=0.0, neginf=0.0) +p10_values = np.nan_to_num(p10_values, nan=0.0, posinf=0.0, neginf=0.0) +p90_values = np.nan_to_num(p90_values, nan=0.0, posinf=0.0, neginf=0.0) +name_of_plot = f'Max 5-day precipitation (mm) under ssp126' +x_labels = [p10_max_5_day_precip.columns[i] if i % 4 == 0 and i >= 2 else "" for i in range(len(median_values))] + +make_graph_file_name = lambda stub: output_folder / f"Precipitation_by_region_{stub}.png" # noqa: E731 + +fig, ax = plt.subplots(figsize=(20, 10)) +ax.plot(range(len(median_values)), median_values, label='Central Region', color='red', marker='o') +ax.fill_between(range(len(median_values)), p10_values, p90_values, color="grey", alpha=0.3) +ax.set_title(name_of_plot, {'size': 12, 'color': 'black'}) +ax.set_xticks(range(len(x_labels))) +ax.set_xticklabels(x_labels, rotation=45, ha='right') +fig.savefig(make_graph_file_name(name_of_plot)) +ax.set_title(name_of_plot, {'size': 12, 'color': 'black'}) +print(make_graph_file_name(name_of_plot)) +fig.savefig(make_graph_file_name(name_of_plot)) +plt.close(fig) +# +# if __name__ == "__main__": +# parser = argparse.ArgumentParser() +# parser.add_argument("results_folder", type=Path) +# args = parser.parse_args() +# apply( +# results_folder=args.results_folder, +# output_folder=args.results_folder) From caa77da4da4b6a804c11aef6fa443fd0ca010e84 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 9 Oct 2024 12:00:06 +0100 Subject: [PATCH 003/291] Plot of precipitation over all of malawi --- .../climate_change/plot_raw_data_CMIP6.py | 24 +++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 src/scripts/climate_change/plot_raw_data_CMIP6.py diff --git a/src/scripts/climate_change/plot_raw_data_CMIP6.py b/src/scripts/climate_change/plot_raw_data_CMIP6.py new file mode 100644 index 0000000000..390605d939 --- /dev/null +++ b/src/scripts/climate_change/plot_raw_data_CMIP6.py @@ -0,0 +1,24 @@ +import matplotlib.pyplot as plt +import numpy as np +from netCDF4 import Dataset + +# Load the dataset and the variable +file_path = "/Users/rem76/Downloads/821bebfbcee0609d233c09e8b2bbc1f3/pr_Amon_UKESM1-0-LL_ssp119_r1i1p1f2_gn_20150116-20991216.nc" +dataset = Dataset(file_path, mode='r') +pr_data = dataset.variables['pr'][:] +print(pr_data.dim) +# Average over time to get a 2D array (lat, lon) +pr_data_time_series = np.mean(pr_data, axis=(1, 2)) + +# Plot the 2D data +#plt.imshow(pr_data_avg, cmap='viridis', aspect='auto') +#plt.colorbar(label='Precipitation (kg m-2 s-1)') +plt.plot(pr_data_time_series) + +plt.title('Average Precipitation Over Time') +plt.ylabel('Precip (mm)') +plt.xlabel('Time') +plt.show() + +# Close the dataset +dataset.close() From 23ca94e99d2a8458bc1192cff194a70c3da13308 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 9 Oct 2024 13:59:57 +0100 Subject: [PATCH 004/291] Attempt to subdivide by region --- .../climate_change/plot_raw_data_CMIP6.py | 41 ++++++++++++++++++- 1 file changed, 40 insertions(+), 1 deletion(-) diff --git a/src/scripts/climate_change/plot_raw_data_CMIP6.py b/src/scripts/climate_change/plot_raw_data_CMIP6.py index 390605d939..1d702aa618 100644 --- a/src/scripts/climate_change/plot_raw_data_CMIP6.py +++ b/src/scripts/climate_change/plot_raw_data_CMIP6.py @@ -6,7 +6,8 @@ file_path = "/Users/rem76/Downloads/821bebfbcee0609d233c09e8b2bbc1f3/pr_Amon_UKESM1-0-LL_ssp119_r1i1p1f2_gn_20150116-20991216.nc" dataset = Dataset(file_path, mode='r') pr_data = dataset.variables['pr'][:] -print(pr_data.dim) + + # Average over time to get a 2D array (lat, lon) pr_data_time_series = np.mean(pr_data, axis=(1, 2)) @@ -22,3 +23,41 @@ # Close the dataset dataset.close() + + +################ Now do it by specific regions + + +latitudes = dataset.variables['latitude'][:] # Adjust variable name if necessary +longitudes = dataset.variables['longitude'][:] # Adjust variable name if necessary + +# Define your coordinate bounds +lat_min, lat_max = -10, 10 # Adjust these values as needed +lon_min, lon_max = 30, 50 # Adjust these values as needed + +# Create a mask for the coordinates within the specified bounds +lat_mask = (latitudes >= lat_min) & (latitudes <= lat_max) +lon_mask = (longitudes >= lon_min) & (longitudes <= lon_max) + +# Use np.ix_ to create a grid of indices +lat_indices = np.where(lat_mask)[0] +lon_indices = np.where(lon_mask)[0] + +# Select the data within the specified coordinate bounds +filtered_pr_data = pr_data[np.ix_(lat_indices, lon_indices)] + +# Average over time to get a 2D array (lat, lon) +filtered_pr_data_time_series = np.mean(pr_data, axis=(1, 2)) + +# Plot the 2D data +#plt.imshow(pr_data_avg, cmap='viridis', aspect='auto') +#plt.colorbar(label='Precipitation (kg m-2 s-1)') +plt.plot(filtered_pr_data_time_series) + +plt.title('Average Precipitation Over Time') +plt.ylabel('Precip (mm)') +plt.xlabel('Time') +plt.show() + +# Close the dataset +dataset.close() From 7fd413a28c5a2d0134f85f2ac7fa08ab438f89a8 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 9 Oct 2024 14:33:37 +0100 Subject: [PATCH 005/291] Found intersection between grid and the admin areas, so now can say which grid cell each facility falls into --- src/scripts/climate_change/grid_malawi.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/src/scripts/climate_change/grid_malawi.py b/src/scripts/climate_change/grid_malawi.py index 6f5bdde8a7..7de94c5951 100644 --- a/src/scripts/climate_change/grid_malawi.py +++ b/src/scripts/climate_change/grid_malawi.py @@ -34,6 +34,9 @@ plt.ylabel("Latitude") plt.show() +### Intersection between the grid and the admin areas ### + +grid_with_facilities_with_districts = gpd.sjoin(malawi_admin2, grid, how='left', predicate='intersects') ########### Create new table with facilities and add coordinates to each facility @@ -53,9 +56,9 @@ facilities_by_area.loc[facilities_by_area['Facility_Name'] == 'Headquarter', 'Region'] = 'Central' -facilities_with_districts = facilities_by_area.merge(malawi_admin2, +facilities_with_districts = facilities_by_area.merge(grid_with_facilities_with_districts, how='left', left_on='District', - right_on='ADM2_EN') + right_on='ADM2_EN') # will have what grid cell they're in + -print(facilities_with_districts) From 97e404f50efc934327b6be06b8f04e330fd02c27 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 10 Oct 2024 11:48:05 +0100 Subject: [PATCH 006/291] Script for retrieving data from each CMIP6 projection model and write to folder. NB - can only work for ssp1_1_9, as there are different models available for each ssp so need to collate. Also produces zipped files --- .../climate_change/data_retrieval_CMIP.py | 63 +++++++++++++++++++ 1 file changed, 63 insertions(+) create mode 100644 src/scripts/climate_change/data_retrieval_CMIP.py diff --git a/src/scripts/climate_change/data_retrieval_CMIP.py b/src/scripts/climate_change/data_retrieval_CMIP.py new file mode 100644 index 0000000000..9699460d3d --- /dev/null +++ b/src/scripts/climate_change/data_retrieval_CMIP.py @@ -0,0 +1,63 @@ +import cdsapi +import os +models = ["cams_csm1_0", "ec_earth3_veg", "giss_e2_1_g", "ipsl_cm6a_lr", "miroc6","miroc_es2l", "mri_esm2_0", "canesm5", "cnrm_esm2_1", "ec_earth3", "ec_earth3_veg_lr", "gfdl_esm4", "ukesm1_0_ll"] +scenarios = ["ssp1_1_9","ssp1_2_6", "ssp4_3_4", "ssp5_3_4OS", "ssp2_4_5", "ssp4_6_0", "ssp3_7_0", "ssp5_8_5"] +base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/" +os.chdir(base_dir) +for scenario in scenarios: + scenario_dir = os.path.join(base_dir, scenario) + if not os.path.exists(scenario_dir): + os.makedirs(scenario_dir) + os.chdir(scenario_dir) + for model in models: + dataset = "projections-cmip6" + request = { + "temporal_resolution": "monthly", + "experiment": scenario, + "variable": "precipitation", + "model": model, + "year": [ + "2050", "2051", "2052", + "2053", "2054", "2055", + "2056", "2057", "2058", + "2059", "2060", "2061", + "2062", "2063", "2064", + "2065", "2066", "2067", + "2068", "2069", "2070", + "2071", "2072", "2073", + "2074", "2075", "2076", + "2077", "2078", "2079", + "2080", "2081", "2082", + "2083", "2084", "2085", + "2086", "2087", "2088", + "2089", "2090", "2091", + "2092", "2093", "2094", + "2095", "2096", "2097", + "2098", "2099", "2015", + "2016", "2017", "2018", + "2019", "2020", "2021", + "2022", "2023", "2024", + "2025", "2026", "2027", + "2028", "2029", "2030", + "2031", "2032", "2033", + "2034", "2035", "2036", + "2037", "2038", "2039", + "2040", "2041", "2042", + "2043", "2044", "2045", + "2046", "2047", "2048", + "2049" + ], + "month": [ + "01", "02", "03", + "04", "05", "06", + "07", "08", "09", + "10", "11", "12" + ], + + + 'area': [-9.36366167, 35.91841716, -17.12627881, 32.67161823, ] # boundaries for all of Malawi + } + + client = cdsapi.Client() + client.retrieve(dataset, request).download() + From 0cbfbb3470d37339524b0746f0700c1dbd081211 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 10 Oct 2024 12:53:44 +0100 Subject: [PATCH 007/291] Functions and process for unzipping file directories and extracting netCDF files NB - can only work for ssp1_1_9 at the moment --- .../climate_change/process_CMIP6_data.py | 51 +++++++++++++++++++ 1 file changed, 51 insertions(+) create mode 100644 src/scripts/climate_change/process_CMIP6_data.py diff --git a/src/scripts/climate_change/process_CMIP6_data.py b/src/scripts/climate_change/process_CMIP6_data.py new file mode 100644 index 0000000000..f0d2960e27 --- /dev/null +++ b/src/scripts/climate_change/process_CMIP6_data.py @@ -0,0 +1,51 @@ +import os +import shutil +import zipfile + + +def unzip_all_in_directory(directory): + """ + Unzips all .zip files in the specified directory, extracting each into a separate folder. + Parameters: + directory (str): The path to the folder containing the .zip files. + """ + for filename in os.listdir(directory): + if filename.endswith('.zip'): + file_path = os.path.join(directory, filename) + extract_dir = os.path.join(directory, filename[:-4]) + os.makedirs(extract_dir, exist_ok=True) + + with zipfile.ZipFile(file_path, 'r') as zip_ref: + zip_ref.extractall(extract_dir) + + +def extract_nc_files_from_unzipped_folders(directory): + """ + Searches for .nc files in the specified directory and all its subfolders, + and copies them to the output directory, maintaining the folder structure. + + Parameters: + directory (str): The path to the folder containing the unzipped folders. + output_directory (str): The path to the folder where .nc files should be copied. + """ + output_directory = os.path.join(directory, 'nc_files') + if not os.path.exists(output_directory): + os.makedirs(output_directory) + for root, _, files in os.walk(directory): + for filename in files: + if filename.endswith('.nc'): + source_file_path = os.path.join(root, filename) + # Copy the .nc file to the 'nc_files' directory + shutil.copy2(source_file_path, output_directory) + + + +# unzip files and extract the netCDF files + +base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/" + +scenarios = ["ssp1_1_9"] #,"ssp1_2_6", "ssp4_3_4", "ssp5_3_4OS", "ssp2_4_5", "ssp4_6_0", "ssp3_7_0", "ssp5_8_5"] +for scenario in scenarios: + scenario_directory = os.path.join(base_dir, scenario) + unzip_all_in_directory(scenario_directory) + extract_nc_files_from_unzipped_folders(scenario_directory) From ccb5178fcba73e515502fb4656cd8426b1b69129 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 10 Oct 2024 13:05:24 +0100 Subject: [PATCH 008/291] isort --- src/scripts/climate_change/data_retrieval_CMIP.py | 4 +++- src/scripts/climate_change/grid_malawi.py | 6 +++--- src/scripts/climate_change/process_CMIP6_data.py | 1 + 3 files changed, 7 insertions(+), 4 deletions(-) diff --git a/src/scripts/climate_change/data_retrieval_CMIP.py b/src/scripts/climate_change/data_retrieval_CMIP.py index 9699460d3d..9f430343c9 100644 --- a/src/scripts/climate_change/data_retrieval_CMIP.py +++ b/src/scripts/climate_change/data_retrieval_CMIP.py @@ -1,5 +1,7 @@ -import cdsapi import os + +import cdsapi + models = ["cams_csm1_0", "ec_earth3_veg", "giss_e2_1_g", "ipsl_cm6a_lr", "miroc6","miroc_es2l", "mri_esm2_0", "canesm5", "cnrm_esm2_1", "ec_earth3", "ec_earth3_veg_lr", "gfdl_esm4", "ukesm1_0_ll"] scenarios = ["ssp1_1_9","ssp1_2_6", "ssp4_3_4", "ssp5_3_4OS", "ssp2_4_5", "ssp4_6_0", "ssp3_7_0", "ssp5_8_5"] base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/" diff --git a/src/scripts/climate_change/grid_malawi.py b/src/scripts/climate_change/grid_malawi.py index 7de94c5951..92f7101521 100644 --- a/src/scripts/climate_change/grid_malawi.py +++ b/src/scripts/climate_change/grid_malawi.py @@ -1,16 +1,16 @@ import geopandas as gpd +import matplotlib.pyplot as plt +import numpy as np import pandas as pd from shapely.geometry import Polygon -import numpy as np -import matplotlib.pyplot as plt # Load Malawi shapefile malawi = gpd.read_file("/Users/rem76/PycharmProjects/TLOmodel/resources/mapping/ResourceFile_mwi_admbnda_adm0_nso_20181016.shp") malawi_admin1 = gpd.read_file("/Users/rem76/PycharmProjects/TLOmodel/resources/mapping/ResourceFile_mwi_admbnda_adm1_nso_20181016.shp") malawi_admin2 = gpd.read_file("/Users/rem76/PycharmProjects/TLOmodel/resources/mapping/ResourceFile_mwi_admbnda_adm2_nso_20181016.shp") -print(malawi_admin2) grid_size = 1 minx, miny, maxx, maxy = malawi.total_bounds +print(malawi.total_bounds) x_coords = np.arange(minx, maxx, grid_size) y_coords = np.arange(miny, maxy, grid_size) polygons = [Polygon([(x, y), (x + grid_size, y), (x + grid_size, y + grid_size), (x, y + grid_size)]) for x in x_coords for y in y_coords] diff --git a/src/scripts/climate_change/process_CMIP6_data.py b/src/scripts/climate_change/process_CMIP6_data.py index f0d2960e27..382a8bf296 100644 --- a/src/scripts/climate_change/process_CMIP6_data.py +++ b/src/scripts/climate_change/process_CMIP6_data.py @@ -49,3 +49,4 @@ def extract_nc_files_from_unzipped_folders(directory): scenario_directory = os.path.join(base_dir, scenario) unzip_all_in_directory(scenario_directory) extract_nc_files_from_unzipped_folders(scenario_directory) + From 61a1ec29ccc5432d6e5ac62de2fa2d78653ffff2 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 10 Oct 2024 13:06:08 +0100 Subject: [PATCH 009/291] Downloaded facility-level reporting data from DHIS2. extracted into areas of interest. from 2000-2024, but only really reliable after 2011 --- .../reporting_and_weather_data.py | 22 +++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 src/scripts/climate_change/reporting_and_weather_data.py diff --git a/src/scripts/climate_change/reporting_and_weather_data.py b/src/scripts/climate_change/reporting_and_weather_data.py new file mode 100644 index 0000000000..027014e478 --- /dev/null +++ b/src/scripts/climate_change/reporting_and_weather_data.py @@ -0,0 +1,22 @@ +import pandas as pd + +# Data accessed from https://dhis2.health.gov.mw/dhis-web-data-visualizer/#/YiQK65skxjz +# Reporting rate is expected reporting vs actual reporting +reporting_data = pd.read_csv('/Users/rem76/Desktop/Climate_change_health/Data/Reporting_Rate/Reporting_Rate_Central_Hospital_2000_2024.csv') + +# Divide dataset based on what is being reported +# get metrics recorded +all_columns = reporting_data.columns +metrics = set([col.split(" - Reporting rate")[0] for col in all_columns]) +metrics = {metric for metric in metrics if not metric.startswith("organisation")} # inlcude only reporting data + + +monthly_reporting_data_by_metric = {} + +for metric in metrics: + columns_of_interest = [reporting_data.columns[1]] + reporting_data.columns[reporting_data.columns.str.startswith(metric)].tolist() + data_of_interest = reporting_data[columns_of_interest] + data_of_interest.columns = [col.replace(metric, "") for col in data_of_interest.columns] + data_of_interest.columns = [col.replace(" - Reporting rate ", "") for col in data_of_interest.columns] + monthly_reporting_data_by_metric[metric] = data_of_interest + From 52f243a00c63adfceaa21c947f82fb7c949367cd Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 10 Oct 2024 13:28:43 +0100 Subject: [PATCH 010/291] Added file path to write facilities doc --- src/scripts/climate_change/grid_malawi.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/scripts/climate_change/grid_malawi.py b/src/scripts/climate_change/grid_malawi.py index 92f7101521..2c4d2b031c 100644 --- a/src/scripts/climate_change/grid_malawi.py +++ b/src/scripts/climate_change/grid_malawi.py @@ -61,4 +61,5 @@ left_on='District', right_on='ADM2_EN') # will have what grid cell they're in - +# write csv file of facilities with districts +facilities_with_districts.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_districts.csv") From a25aefa3ca7058d2e4eb9c68f934e317fe39ea96 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 10 Oct 2024 14:06:25 +0100 Subject: [PATCH 011/291] renamed variable for clarity --- src/scripts/climate_change/grid_malawi.py | 15 ++++++--------- 1 file changed, 6 insertions(+), 9 deletions(-) diff --git a/src/scripts/climate_change/grid_malawi.py b/src/scripts/climate_change/grid_malawi.py index 2c4d2b031c..cd2e5e7973 100644 --- a/src/scripts/climate_change/grid_malawi.py +++ b/src/scripts/climate_change/grid_malawi.py @@ -10,17 +10,14 @@ malawi_admin2 = gpd.read_file("/Users/rem76/PycharmProjects/TLOmodel/resources/mapping/ResourceFile_mwi_admbnda_adm2_nso_20181016.shp") grid_size = 1 minx, miny, maxx, maxy = malawi.total_bounds -print(malawi.total_bounds) x_coords = np.arange(minx, maxx, grid_size) y_coords = np.arange(miny, maxy, grid_size) polygons = [Polygon([(x, y), (x + grid_size, y), (x + grid_size, y + grid_size), (x, y + grid_size)]) for x in x_coords for y in y_coords] grid = gpd.GeoDataFrame({'geometry': polygons}, crs=malawi.crs) - grid_clipped = gpd.overlay(grid, malawi, how='intersection') grid_clipped_ADM1 = gpd.overlay(grid, malawi_admin1, how='intersection') - cmap = plt.cm.get_cmap('tab20', len(grid_clipped_ADM1['ADM1_EN'].unique())) fig, ax = plt.subplots(figsize=(10, 10)) @@ -35,10 +32,9 @@ plt.show() ### Intersection between the grid and the admin areas ### +grid_with_admin_areas = gpd.sjoin(malawi_admin2, grid_clipped, how='left', predicate='intersects') -grid_with_facilities_with_districts = gpd.sjoin(malawi_admin2, grid, how='left', predicate='intersects') - -########### Create new table with facilities and add coordinates to each facility +########### Create new table with facilities and add coordinates to each facility ######### facilities_by_area = pd.read_csv("/Users/rem76/PycharmProjects/TLOmodel/resources/healthsystem/organisation/ResourceFile_Master_Facilities_List.csv") @@ -54,12 +50,13 @@ # HQ based in Lilongwe? facilities_by_area.loc[facilities_by_area['Facility_Name'] == 'Headquarter', 'District'] = 'Lilongwe City' facilities_by_area.loc[facilities_by_area['Facility_Name'] == 'Headquarter', 'Region'] = 'Central' +# max/min of each polygon - -facilities_with_districts = facilities_by_area.merge(grid_with_facilities_with_districts, +# join so each facility has a grid +facilities_with_districts_shap_files = facilities_by_area.merge(grid_with_admin_areas, how='left', left_on='District', right_on='ADM2_EN') # will have what grid cell they're in # write csv file of facilities with districts -facilities_with_districts.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_districts.csv") +facilities_with_districts_shap_files.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_districts.csv") From fda157e31ea03cc6aef8e1f2a29a648815762bc3 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 10 Oct 2024 15:38:18 +0100 Subject: [PATCH 012/291] # So, because of the fact one district may overlap with many grids, there are many "duplicates" # in facilities_with_districts_shap_files (as each facility is paired with any matching grid) # removing the duplicates PENDING a better system (e.g. assigning based on size) --- src/scripts/climate_change/grid_malawi.py | 34 ++++++++++++++++------- 1 file changed, 24 insertions(+), 10 deletions(-) diff --git a/src/scripts/climate_change/grid_malawi.py b/src/scripts/climate_change/grid_malawi.py index cd2e5e7973..2ab0a5c1e9 100644 --- a/src/scripts/climate_change/grid_malawi.py +++ b/src/scripts/climate_change/grid_malawi.py @@ -13,17 +13,18 @@ x_coords = np.arange(minx, maxx, grid_size) y_coords = np.arange(miny, maxy, grid_size) polygons = [Polygon([(x, y), (x + grid_size, y), (x + grid_size, y + grid_size), (x, y + grid_size)]) for x in x_coords for y in y_coords] + # 32 polygons in total grid = gpd.GeoDataFrame({'geometry': polygons}, crs=malawi.crs) -grid_clipped = gpd.overlay(grid, malawi, how='intersection') -grid_clipped_ADM1 = gpd.overlay(grid, malawi_admin1, how='intersection') - +grid_clipped = gpd.overlay(grid, malawi, how='intersection') # for graphing +grid_clipped_ADM1 = gpd.overlay(grid, malawi_admin1, how='intersection') # for graphing +grid_clipped_ADM2 = gpd.overlay(grid, malawi_admin2, how='intersection') # for graphing cmap = plt.cm.get_cmap('tab20', len(grid_clipped_ADM1['ADM1_EN'].unique())) fig, ax = plt.subplots(figsize=(10, 10)) malawi_admin2.plot(ax=ax, edgecolor='black', color='white') grid_clipped.plot(ax=ax, edgecolor='#1C6E8C', color='#9AC4F8', alpha=0.5) -grid_clipped_ADM1.plot(column='ADM1_EN', ax=ax, cmap=cmap, edgecolor='#1C6E8C', alpha=0.7, legend=True) +grid_clipped_ADM1.plot(column='ADM1_EN', ax=ax, cmap=cmap, edgecolor='#1C6E8C', alpha=0.7) # Finalize plot plt.title("Malawi with Overlaying Grids - 1 degree") @@ -32,7 +33,11 @@ plt.show() ### Intersection between the grid and the admin areas ### -grid_with_admin_areas = gpd.sjoin(malawi_admin2, grid_clipped, how='left', predicate='intersects') +intersections = gpd.overlay(grid, malawi_admin2, how='intersection') # 80 intersections between districts and major grid squares +print(len(intersections)) # 80 intersections between administrative districts and the overall grid + +#admin_area_with_major_grid = gpd.sjoin(malawi_admin2, grid, how='inner') +admin_area_with_major_grid = gpd.overlay(malawi_admin2, grid, how='intersection') ########### Create new table with facilities and add coordinates to each facility ######### @@ -50,13 +55,22 @@ # HQ based in Lilongwe? facilities_by_area.loc[facilities_by_area['Facility_Name'] == 'Headquarter', 'District'] = 'Lilongwe City' facilities_by_area.loc[facilities_by_area['Facility_Name'] == 'Headquarter', 'Region'] = 'Central' -# max/min of each polygon - # join so each facility has a grid -facilities_with_districts_shap_files = facilities_by_area.merge(grid_with_admin_areas, + +facilities_with_districts_shap_files = facilities_by_area.merge(admin_area_with_major_grid, how='left', left_on='District', - right_on='ADM2_EN') # will have what grid cell they're in + right_on = 'ADM2_EN') # will have what grid cell they're in + +# So, because of the fact one district may overlap with many grids, there are many "duplicates" +# in facilities_with_districts_shap_files (as each facility is paired with any matching grid) +# removing the duplicates PENDING a better system (e.g. assigning based on size) + +facilities_with_districts_shap_files_no_duplicates = facilities_with_districts_shap_files.drop_duplicates(subset=['District', 'Facility_Level', 'Region', 'Facility_ID', 'Facility_Name']) +facilities_with_districts_shap_files_no_duplicates.reset_index(drop=True, inplace=True) # write csv file of facilities with districts -facilities_with_districts_shap_files.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_districts.csv") +facilities_with_districts_shap_files_no_duplicates.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_districts.csv") + +# Facilities do not go smaller than region... Which may have multiple polygons + From 1a0c615259063dabc2ba9fe4beced87fe3eb7838 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 10 Oct 2024 16:04:49 +0100 Subject: [PATCH 013/291] Updated comments --- src/scripts/climate_change/grid_malawi.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/src/scripts/climate_change/grid_malawi.py b/src/scripts/climate_change/grid_malawi.py index 2ab0a5c1e9..ecc5deddba 100644 --- a/src/scripts/climate_change/grid_malawi.py +++ b/src/scripts/climate_change/grid_malawi.py @@ -61,7 +61,7 @@ how='left', left_on='District', right_on = 'ADM2_EN') # will have what grid cell they're in - +# Facilities do not go smaller than region... Which may have multiple polygons # So, because of the fact one district may overlap with many grids, there are many "duplicates" # in facilities_with_districts_shap_files (as each facility is paired with any matching grid) # removing the duplicates PENDING a better system (e.g. assigning based on size) @@ -72,5 +72,3 @@ # write csv file of facilities with districts facilities_with_districts_shap_files_no_duplicates.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_districts.csv") -# Facilities do not go smaller than region... Which may have multiple polygons - From e98f1fb01357ae3a780e8916aa0da997f021bf65 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 10 Oct 2024 16:10:32 +0100 Subject: [PATCH 014/291] Wrote to shapefile --- src/scripts/climate_change/grid_malawi.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/scripts/climate_change/grid_malawi.py b/src/scripts/climate_change/grid_malawi.py index ecc5deddba..3050626998 100644 --- a/src/scripts/climate_change/grid_malawi.py +++ b/src/scripts/climate_change/grid_malawi.py @@ -69,6 +69,11 @@ facilities_with_districts_shap_files_no_duplicates = facilities_with_districts_shap_files.drop_duplicates(subset=['District', 'Facility_Level', 'Region', 'Facility_ID', 'Facility_Name']) facilities_with_districts_shap_files_no_duplicates.reset_index(drop=True, inplace=True) + # write csv file of facilities with districts facilities_with_districts_shap_files_no_duplicates.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_districts.csv") +facilities_gdf = gpd.GeoDataFrame(facilities_with_districts_shap_files_no_duplicates, + geometry='geometry', + crs="EPSG:4326") +facilities_gdf.to_file("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_districts.shp") From 94c569d84559a4e010bd6b0c7855a71314dd5064 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 11 Oct 2024 10:27:17 +0100 Subject: [PATCH 015/291] So, can't use the shap file for Malawi to get my grids for the healthcare facilities, as a different gridding system is used. Though I requested the netCDF the max/min x/y coordinates for Malawi, I suppose they were rounded up/down to (e.g., from the NetCDF file, the lowest latitude is -16 ish, but from the Shap file it should be -17). SO have regrided Malawi/reassign facilities based on the NetCDF file. --- src/scripts/climate_change/grid_malawi.py | 39 +++++++++++++++++++---- 1 file changed, 32 insertions(+), 7 deletions(-) diff --git a/src/scripts/climate_change/grid_malawi.py b/src/scripts/climate_change/grid_malawi.py index 3050626998..d5a95c226b 100644 --- a/src/scripts/climate_change/grid_malawi.py +++ b/src/scripts/climate_change/grid_malawi.py @@ -3,16 +3,41 @@ import numpy as np import pandas as pd from shapely.geometry import Polygon +from netCDF4 import Dataset + + +# Load netCDF data for gridding info +file_path = "/Users/rem76/Downloads/821bebfbcee0609d233c09e8b2bbc1f3/pr_Amon_UKESM1-0-LL_ssp119_r1i1p1f2_gn_20150116-20991216.nc" +dataset = Dataset(file_path, mode='r') +print(dataset.variables.keys()) +pr_data = dataset.variables['pr'][:] +time_data = dataset.variables['time'][:] +lat_data = dataset.variables['lat'][:] +long_data = dataset.variables['lon'][:] +meshgrid_from_netCDF = np.meshgrid(long_data, lat_data) # Load Malawi shapefile malawi = gpd.read_file("/Users/rem76/PycharmProjects/TLOmodel/resources/mapping/ResourceFile_mwi_admbnda_adm0_nso_20181016.shp") malawi_admin1 = gpd.read_file("/Users/rem76/PycharmProjects/TLOmodel/resources/mapping/ResourceFile_mwi_admbnda_adm1_nso_20181016.shp") malawi_admin2 = gpd.read_file("/Users/rem76/PycharmProjects/TLOmodel/resources/mapping/ResourceFile_mwi_admbnda_adm2_nso_20181016.shp") -grid_size = 1 -minx, miny, maxx, maxy = malawi.total_bounds -x_coords = np.arange(minx, maxx, grid_size) -y_coords = np.arange(miny, maxy, grid_size) -polygons = [Polygon([(x, y), (x + grid_size, y), (x + grid_size, y + grid_size), (x, y + grid_size)]) for x in x_coords for y in y_coords] +#grid_size = 1 +#minx, miny, maxx, maxy = malawi.total_bounds +#x_coords = np.arange(minx, maxx, grid_size) my gridding doesn't work - based on a different projection, maybe? +#y_coords = np.arange(miny, maxy, grid_size) +#polygons = [Polygon([(x, y), (x + grid_size, y), (x + grid_size, y + grid_size), (x, y + grid_size)]) for x in x_coords for y in y_coords] + +difference_lat = lat_data[1] - lat_data[0] # as is a grid, the difference is the same for all sequential coordinates +difference_long = long_data[1] - long_data[0] + +polygons = [] +for x in long_data: + for y in lat_data: + bottom_left = (x, y) + bottom_right = (x + difference_long, y) + top_right = (x + difference_long, y + difference_lat) + top_left = (x, y + difference_lat) + polygon = Polygon([bottom_left, bottom_right, top_right, top_left]) + polygons.append(polygon) # 32 polygons in total grid = gpd.GeoDataFrame({'geometry': polygons}, crs=malawi.crs) @@ -23,11 +48,11 @@ fig, ax = plt.subplots(figsize=(10, 10)) malawi_admin2.plot(ax=ax, edgecolor='black', color='white') -grid_clipped.plot(ax=ax, edgecolor='#1C6E8C', color='#9AC4F8', alpha=0.5) +grid.plot(ax=ax, edgecolor='#1C6E8C', color='white') grid_clipped_ADM1.plot(column='ADM1_EN', ax=ax, cmap=cmap, edgecolor='#1C6E8C', alpha=0.7) # Finalize plot -plt.title("Malawi with Overlaying Grids - 1 degree") +plt.title("Malawi with Overlaying Grids") plt.xlabel("Longitude") plt.ylabel("Latitude") plt.show() From db73168f6ce0691088846e6e276311020d6b1bbd Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 11 Oct 2024 10:34:06 +0100 Subject: [PATCH 016/291] Fixed aesthetics of overlap --- src/scripts/climate_change/grid_malawi.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/scripts/climate_change/grid_malawi.py b/src/scripts/climate_change/grid_malawi.py index d5a95c226b..2bb78e6395 100644 --- a/src/scripts/climate_change/grid_malawi.py +++ b/src/scripts/climate_change/grid_malawi.py @@ -38,7 +38,6 @@ top_left = (x, y + difference_lat) polygon = Polygon([bottom_left, bottom_right, top_right, top_left]) polygons.append(polygon) - # 32 polygons in total grid = gpd.GeoDataFrame({'geometry': polygons}, crs=malawi.crs) grid_clipped = gpd.overlay(grid, malawi, how='intersection') # for graphing @@ -49,6 +48,7 @@ fig, ax = plt.subplots(figsize=(10, 10)) malawi_admin2.plot(ax=ax, edgecolor='black', color='white') grid.plot(ax=ax, edgecolor='#1C6E8C', color='white') +grid_clipped_ADM2.plot(ax=ax,edgecolor='#1C6E8C', alpha=0.4) grid_clipped_ADM1.plot(column='ADM1_EN', ax=ax, cmap=cmap, edgecolor='#1C6E8C', alpha=0.7) # Finalize plot From a67f31ed0826c913fa995295fa3c0f8921a8483b Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 11 Oct 2024 11:08:17 +0100 Subject: [PATCH 017/291] Changed to daily data retrieval (historical can be monthly) --- src/scripts/climate_change/data_retrieval_CMIP.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/scripts/climate_change/data_retrieval_CMIP.py b/src/scripts/climate_change/data_retrieval_CMIP.py index 9f430343c9..d0b8cdd3ec 100644 --- a/src/scripts/climate_change/data_retrieval_CMIP.py +++ b/src/scripts/climate_change/data_retrieval_CMIP.py @@ -14,7 +14,7 @@ for model in models: dataset = "projections-cmip6" request = { - "temporal_resolution": "monthly", + "temporal_resolution": "daily", "experiment": scenario, "variable": "precipitation", "model": model, From 892120454a4bb22ca5bbfef23dfdcab360a20394 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 11 Oct 2024 11:12:24 +0100 Subject: [PATCH 018/291] Changed to daily data retrieval (historical can be monthly) --- src/scripts/climate_change/data_retrieval_CMIP.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/scripts/climate_change/data_retrieval_CMIP.py b/src/scripts/climate_change/data_retrieval_CMIP.py index d0b8cdd3ec..9d14ffbd9a 100644 --- a/src/scripts/climate_change/data_retrieval_CMIP.py +++ b/src/scripts/climate_change/data_retrieval_CMIP.py @@ -2,7 +2,7 @@ import cdsapi -models = ["cams_csm1_0", "ec_earth3_veg", "giss_e2_1_g", "ipsl_cm6a_lr", "miroc6","miroc_es2l", "mri_esm2_0", "canesm5", "cnrm_esm2_1", "ec_earth3", "ec_earth3_veg_lr", "gfdl_esm4", "ukesm1_0_ll"] +models = ["cams_csm1_0", "ipsl_cm6a_lr", "miroc6","miroc_es2l", "mri_esm2_0", "canesm5", "cnrm_esm2_1", "ec_earth3", "ec_earth3_veg_lr", "fgoals2-g3", "gfdl_esm4", "ukesm1_0_ll"] scenarios = ["ssp1_1_9","ssp1_2_6", "ssp4_3_4", "ssp5_3_4OS", "ssp2_4_5", "ssp4_6_0", "ssp3_7_0", "ssp5_8_5"] base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/" os.chdir(base_dir) From 61c8c595d043cdd26411c362b0177d4f83c699e4 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 11 Oct 2024 11:29:31 +0100 Subject: [PATCH 019/291] Typo --- src/scripts/climate_change/data_retrieval_CMIP.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/scripts/climate_change/data_retrieval_CMIP.py b/src/scripts/climate_change/data_retrieval_CMIP.py index 9d14ffbd9a..6947ece3bc 100644 --- a/src/scripts/climate_change/data_retrieval_CMIP.py +++ b/src/scripts/climate_change/data_retrieval_CMIP.py @@ -2,7 +2,7 @@ import cdsapi -models = ["cams_csm1_0", "ipsl_cm6a_lr", "miroc6","miroc_es2l", "mri_esm2_0", "canesm5", "cnrm_esm2_1", "ec_earth3", "ec_earth3_veg_lr", "fgoals2-g3", "gfdl_esm4", "ukesm1_0_ll"] +models = ["cams_csm1_0", "ipsl_cm6a_lr", "miroc6","miroc_es2l", "mri_esm2_0", "canesm5", "cnrm_esm2_1", "ec_earth3", "ec_earth3_veg_lr", "fgoals_g3", "gfdl_esm4", "ukesm1_0_ll"] scenarios = ["ssp1_1_9","ssp1_2_6", "ssp4_3_4", "ssp5_3_4OS", "ssp2_4_5", "ssp4_6_0", "ssp3_7_0", "ssp5_8_5"] base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/" os.chdir(base_dir) From 29af34f6c13c610d1954af6fecfd6f43af16ff76 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 11 Oct 2024 11:40:30 +0100 Subject: [PATCH 020/291] Added actual days for dates --- src/scripts/climate_change/data_retrieval_CMIP.py | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/src/scripts/climate_change/data_retrieval_CMIP.py b/src/scripts/climate_change/data_retrieval_CMIP.py index 6947ece3bc..ef219aa359 100644 --- a/src/scripts/climate_change/data_retrieval_CMIP.py +++ b/src/scripts/climate_change/data_retrieval_CMIP.py @@ -55,6 +55,19 @@ "07", "08", "09", "10", "11", "12" ], + "day": [ + "01", "02", "03", + "04", "05", "06", + "07", "08", "09", + "10", "11", "12", + "13", "14", "15", + "16", "17", "18", + "19", "20", "21", + "22", "23", "24", + "25", "26", "27", + "28", "29", "30", + "31" + ], 'area': [-9.36366167, 35.91841716, -17.12627881, 32.67161823, ] # boundaries for all of Malawi From 2eb0ce731a0bb1df8f9c3cd39f957f02d2383e7c Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 11 Oct 2024 11:48:57 +0100 Subject: [PATCH 021/291] Creating dictionaries of data by model and grid --- .../climate_change/process_CMIP6_data.py | 34 +++++++++++++++++-- 1 file changed, 32 insertions(+), 2 deletions(-) diff --git a/src/scripts/climate_change/process_CMIP6_data.py b/src/scripts/climate_change/process_CMIP6_data.py index 382a8bf296..753cd7f8e6 100644 --- a/src/scripts/climate_change/process_CMIP6_data.py +++ b/src/scripts/climate_change/process_CMIP6_data.py @@ -1,8 +1,10 @@ +import glob import os import shutil import zipfile - - +import glob +from netCDF4 import Dataset +import pandas as pd def unzip_all_in_directory(directory): """ Unzips all .zip files in the specified directory, extracting each into a separate folder. @@ -50,3 +52,31 @@ def extract_nc_files_from_unzipped_folders(directory): unzip_all_in_directory(scenario_directory) extract_nc_files_from_unzipped_folders(scenario_directory) + +# Put all into one csv file + +#### Multiple files +file_list = glob.glob(os.path.join(base_dir, "*.nc")) +data_by_model_and_grid = {} +models = ["cams_csm1_0", "ipsl_cm6a_lr", "miroc6","miroc_es2l", "mri_esm2_0", "canesm5", "cnrm_esm2_1", "ec_earth3", "ec_earth3_veg_lr", "fgoals_g3", "gfdl_esm4", "ukesm1_0_ll"] +model = 0 +for file in glob.glob(os.path.join(base_dir, "*.nc")): + data_per_model = Dataset(file, mode='r') + pr_data = data_per_model.variables['pr'][:] # in kg m-2 s-1 = mm s-1 x 86400 to get to day + lat_data = data_per_model.variables['lat'][:] + long_data = data_per_model.variables['lon'][:] + grid_dictionary = {} + grid = 0 + for i in range(len(long_data)): + for j in range(len(lat_data)): + precip_data_for_grid = pr_data[:,i,j] # across all time points + precip_data_for_grid = precip_data_for_grid * 86400 # to get from per second to per day + grid_dictionary[grid] = precip_data_for_grid + grid += 1 + data_by_model_and_grid[models[model]] = grid_dictionary + model += 1 + + + + + From 590a39c5c8d93b15d1307d93ce57c509496f763b Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 11 Oct 2024 12:08:06 +0100 Subject: [PATCH 022/291] Added csv --- src/scripts/climate_change/process_CMIP6_data.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/scripts/climate_change/process_CMIP6_data.py b/src/scripts/climate_change/process_CMIP6_data.py index 753cd7f8e6..1f1149af6c 100644 --- a/src/scripts/climate_change/process_CMIP6_data.py +++ b/src/scripts/climate_change/process_CMIP6_data.py @@ -77,6 +77,11 @@ def extract_nc_files_from_unzipped_folders(directory): model += 1 +data_by_model_and_grid_df = pd.DataFrame.from_dict(data_by_model_and_grid) +data_by_model_and_grid.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/data_by_model_and_grid.csv") + + + From 4a10441be01aa9fae1480a447f8fad0cfb1fad8a Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 11 Oct 2024 12:12:11 +0100 Subject: [PATCH 023/291] Fixed setting directory --- src/scripts/climate_change/process_CMIP6_data.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/scripts/climate_change/process_CMIP6_data.py b/src/scripts/climate_change/process_CMIP6_data.py index 1f1149af6c..be0c53386f 100644 --- a/src/scripts/climate_change/process_CMIP6_data.py +++ b/src/scripts/climate_change/process_CMIP6_data.py @@ -5,6 +5,8 @@ import glob from netCDF4 import Dataset import pandas as pd +from pathlib import Path + def unzip_all_in_directory(directory): """ Unzips all .zip files in the specified directory, extracting each into a separate folder. @@ -76,9 +78,8 @@ def extract_nc_files_from_unzipped_folders(directory): data_by_model_and_grid[models[model]] = grid_dictionary model += 1 - -data_by_model_and_grid_df = pd.DataFrame.from_dict(data_by_model_and_grid) -data_by_model_and_grid.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/data_by_model_and_grid.csv") +data_by_model_and_grid = pd.DataFrame.from_dict(data_by_model_and_grid) +data_by_model_and_grid.to_csv(Path(scenario_directory)/"data_by_model_and_grid.csv") From 75633163f0c9c95fb17c63d29ec6db7d5702d345 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 11 Oct 2024 12:13:57 +0100 Subject: [PATCH 024/291] Changed some comments for clarity --- src/scripts/climate_change/grid_malawi.py | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/src/scripts/climate_change/grid_malawi.py b/src/scripts/climate_change/grid_malawi.py index 2bb78e6395..5222e9950d 100644 --- a/src/scripts/climate_change/grid_malawi.py +++ b/src/scripts/climate_change/grid_malawi.py @@ -55,14 +55,12 @@ plt.title("Malawi with Overlaying Grids") plt.xlabel("Longitude") plt.ylabel("Latitude") -plt.show() +#plt.show() ### Intersection between the grid and the admin areas ### -intersections = gpd.overlay(grid, malawi_admin2, how='intersection') # 80 intersections between districts and major grid squares -print(len(intersections)) # 80 intersections between administrative districts and the overall grid +intersections = gpd.overlay(grid, malawi_admin2, how='intersection') # 56 intersections between districts and major grid squares -#admin_area_with_major_grid = gpd.sjoin(malawi_admin2, grid, how='inner') -admin_area_with_major_grid = gpd.overlay(malawi_admin2, grid, how='intersection') +admin_area_with_major_grid = gpd.overlay( grid, malawi_admin2, how='intersection') # finding which grid each facility falls into ########### Create new table with facilities and add coordinates to each facility ######### From 9542bdd644e91e5cd9da656c1a2fb2b09b5767dc Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 11 Oct 2024 12:14:40 +0100 Subject: [PATCH 025/291] Extracted more variables. Converted from seconds to days. --- .../climate_change/plot_raw_data_CMIP6.py | 105 ++++++++++-------- 1 file changed, 57 insertions(+), 48 deletions(-) diff --git a/src/scripts/climate_change/plot_raw_data_CMIP6.py b/src/scripts/climate_change/plot_raw_data_CMIP6.py index 1d702aa618..59a9cdd4ae 100644 --- a/src/scripts/climate_change/plot_raw_data_CMIP6.py +++ b/src/scripts/climate_change/plot_raw_data_CMIP6.py @@ -1,63 +1,72 @@ import matplotlib.pyplot as plt import numpy as np +import geopandas as gpd +import pandas as pd from netCDF4 import Dataset # Load the dataset and the variable file_path = "/Users/rem76/Downloads/821bebfbcee0609d233c09e8b2bbc1f3/pr_Amon_UKESM1-0-LL_ssp119_r1i1p1f2_gn_20150116-20991216.nc" dataset = Dataset(file_path, mode='r') -pr_data = dataset.variables['pr'][:] +pr_data = dataset.variables['pr'][:] # in kg m-2 s-1 = mm s-1 x 86400 to get to day +time_data = dataset.variables['time'][:] +lat_data = dataset.variables['lat'][:] +long_data = dataset.variables['lon'][:] - -# Average over time to get a 2D array (lat, lon) -pr_data_time_series = np.mean(pr_data, axis=(1, 2)) - -# Plot the 2D data -#plt.imshow(pr_data_avg, cmap='viridis', aspect='auto') -#plt.colorbar(label='Precipitation (kg m-2 s-1)') -plt.plot(pr_data_time_series) - -plt.title('Average Precipitation Over Time') -plt.ylabel('Precip (mm)') -plt.xlabel('Time') -plt.show() - -# Close the dataset -dataset.close() - - -################ Now do it by specific regions - - -latitudes = dataset.variables['latitude'][:] # Adjust variable name if necessary -longitudes = dataset.variables['longitude'][:] # Adjust variable name if necessary - -# Define your coordinate bounds -lat_min, lat_max = -10, 10 # Adjust these values as needed -lon_min, lon_max = 30, 50 # Adjust these values as needed - -# Create a mask for the coordinates within the specified bounds -lat_mask = (latitudes >= lat_min) & (latitudes <= lat_max) -lon_mask = (longitudes >= lon_min) & (longitudes <= lon_max) - -# Use np.ix_ to create a grid of indices -lat_indices = np.where(lat_mask)[0] -lon_indices = np.where(lon_mask)[0] - -# Select the data within the specified coordinate bounds -filtered_pr_data = pr_data[np.ix_(lat_indices, lon_indices)] - -# Average over time to get a 2D array (lat, lon) -filtered_pr_data_time_series = np.mean(pr_data, axis=(1, 2)) +## Initial plot +pr_data_time_series_grid_1 = pr_data[:,5,1] +pr_data_time_series_grid_1 *= 86400 # to get to days # Plot the 2D data -#plt.imshow(pr_data_avg, cmap='viridis', aspect='auto') -#plt.colorbar(label='Precipitation (kg m-2 s-1)') -plt.plot(filtered_pr_data_time_series) +plt.plot(pr_data_time_series_grid_1) -plt.title('Average Precipitation Over Time') +plt.title('Average Precipitation Over Time - Grid 1') plt.ylabel('Precip (mm)') plt.xlabel('Time') plt.show() -# Close the dataset -dataset.close() +################ Now do it by specific regions ################# +# get regions from facilities file +facilities_with_grid = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_districts.csv") +facilities_with_grid = gpd.read_file("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_districts.shp") +print(facilities_with_grid) +bounds_data = [] +for geometry in facilities_with_grid["geometry"]: + minx, miny, maxx, maxy = geometry.bounds # Get bounding box + bounds_data.append({'minx': minx, 'miny': miny, 'maxx': maxx, 'maxy': maxy}) +bounds_df = pd.DataFrame(bounds_data) +facilities_with_bounds = pd.concat([facilities_with_grid.reset_index(drop=True), bounds_df], axis=1) + +# could get centroids of the grid and see if they overlap with +centroid_data = [] +for geometry in facilities_with_grid["geometry"]: + central_x = geometry.centroid.x + central_y = geometry.centroid.y + centroid_data.append({'central_x': central_x, 'central_y': central_y}) + + +## can find min square distance and index to get relavent indices +diff_northern_lat = [] +diff_southern_lat = [] +diff_eastern_lon = [] +diff_western_lon = [] + +max_latitudes = facilities_with_bounds['maxy'].values +min_latitudes = facilities_with_bounds['miny'].values +max_longitudes = facilities_with_bounds['maxx'].values +min_longitudes = facilities_with_bounds['minx'].values +# Iterate over each facility to calculate differences +for i in range(len(facilities_with_bounds)): + # Calculate the square differences for latitude and longitude, to then find nearest index + northern_diff = (lat_data - max_latitudes[i]) ** 2 + southern_diff = (lat_data - min_latitudes[i]) ** 2 + eastern_diff = (long_data - max_longitudes[i]) ** 2 + western_diff = (long_data - min_longitudes[i]) ** 2 + + diff_northern_lat.append(northern_diff.argmin()) + diff_southern_lat.append(southern_diff.argmin()) + diff_eastern_lon.append(eastern_diff.argmin()) + diff_western_lon.append(western_diff.argmin()) + +print(diff_northern_lat) +print(diff_southern_lat) +print(diff_eastern_lon) From 3b02dbd75b99f53774a299e717b913e89b25139c Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 11 Oct 2024 12:22:39 +0100 Subject: [PATCH 026/291] API request for accessing ERA5 reanalysis data. --- .../data_retrieval_ERA5_reanalysis_monthly.py | 30 +++++++++++++++++++ 1 file changed, 30 insertions(+) create mode 100644 src/scripts/climate_change/data_retrieval_ERA5_reanalysis_monthly.py diff --git a/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_monthly.py b/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_monthly.py new file mode 100644 index 0000000000..7ed7826754 --- /dev/null +++ b/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_monthly.py @@ -0,0 +1,30 @@ +import os +import cdsapi + +base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical" +os.chdir(base_dir) +dataset = "reanalysis-era5-single-levels-monthly-means" +request = { + "product_type": ["monthly_averaged_reanalysis"], + "variable": ["total_precipitation"], + "year": [ + "2011", "2012", "2013", + "2014", "2015", "2016", + "2017", "2018", "2019", + "2020", "2021", "2022", + "2023", "2024" + ], + "month": [ + "01", "02", "03", + "04", "05", "06", + "07", "08", "09", + "10", "11", "12" + ], + "time": ["00:00"], + "data_format": "netcdf", + "download_format": "unarchived", + "area": [-9.36366167, 32.67161823, -17.12627881, 35.91841716] +} + +client = cdsapi.Client() +client.retrieve(dataset, request).download() From c5e9e21ac2f851eeeb516a6621ff827c6e2f48db Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 11 Oct 2024 12:25:36 +0100 Subject: [PATCH 027/291] isort --- .../data_retrieval_ERA5_reanalysis_monthly.py | 1 + src/scripts/climate_change/grid_malawi.py | 3 +-- src/scripts/climate_change/plot_raw_data_CMIP6.py | 4 ++-- src/scripts/climate_change/process_CMIP6_data.py | 7 ++++--- .../climate_change/reporting_and_weather_data.py | 13 +++++++++++++ 5 files changed, 21 insertions(+), 7 deletions(-) diff --git a/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_monthly.py b/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_monthly.py index 7ed7826754..293b13fe00 100644 --- a/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_monthly.py +++ b/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_monthly.py @@ -1,4 +1,5 @@ import os + import cdsapi base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical" diff --git a/src/scripts/climate_change/grid_malawi.py b/src/scripts/climate_change/grid_malawi.py index 5222e9950d..5a7d353c2f 100644 --- a/src/scripts/climate_change/grid_malawi.py +++ b/src/scripts/climate_change/grid_malawi.py @@ -2,9 +2,8 @@ import matplotlib.pyplot as plt import numpy as np import pandas as pd -from shapely.geometry import Polygon from netCDF4 import Dataset - +from shapely.geometry import Polygon # Load netCDF data for gridding info file_path = "/Users/rem76/Downloads/821bebfbcee0609d233c09e8b2bbc1f3/pr_Amon_UKESM1-0-LL_ssp119_r1i1p1f2_gn_20150116-20991216.nc" diff --git a/src/scripts/climate_change/plot_raw_data_CMIP6.py b/src/scripts/climate_change/plot_raw_data_CMIP6.py index 59a9cdd4ae..53ce1ffc7b 100644 --- a/src/scripts/climate_change/plot_raw_data_CMIP6.py +++ b/src/scripts/climate_change/plot_raw_data_CMIP6.py @@ -1,6 +1,6 @@ +import geopandas as gpd import matplotlib.pyplot as plt import numpy as np -import geopandas as gpd import pandas as pd from netCDF4 import Dataset @@ -13,7 +13,7 @@ long_data = dataset.variables['lon'][:] ## Initial plot -pr_data_time_series_grid_1 = pr_data[:,5,1] +pr_data_time_series_grid_1 = pr_data[:,2,1] pr_data_time_series_grid_1 *= 86400 # to get to days # Plot the 2D data diff --git a/src/scripts/climate_change/process_CMIP6_data.py b/src/scripts/climate_change/process_CMIP6_data.py index be0c53386f..a7cde9d813 100644 --- a/src/scripts/climate_change/process_CMIP6_data.py +++ b/src/scripts/climate_change/process_CMIP6_data.py @@ -2,11 +2,12 @@ import os import shutil import zipfile -import glob -from netCDF4 import Dataset -import pandas as pd from pathlib import Path +import pandas as pd +from netCDF4 import Dataset + + def unzip_all_in_directory(directory): """ Unzips all .zip files in the specified directory, extracting each into a separate folder. diff --git a/src/scripts/climate_change/reporting_and_weather_data.py b/src/scripts/climate_change/reporting_and_weather_data.py index 027014e478..2fd437696f 100644 --- a/src/scripts/climate_change/reporting_and_weather_data.py +++ b/src/scripts/climate_change/reporting_and_weather_data.py @@ -1,4 +1,7 @@ +import os + import pandas as pd +from netCDF4 import Dataset # Data accessed from https://dhis2.health.gov.mw/dhis-web-data-visualizer/#/YiQK65skxjz # Reporting rate is expected reporting vs actual reporting @@ -20,3 +23,13 @@ data_of_interest.columns = [col.replace(" - Reporting rate ", "") for col in data_of_interest.columns] monthly_reporting_data_by_metric[metric] = data_of_interest +# Weather data +directory = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical" +weather_by_month = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical" +files = os.listdir(directory) + +for file in files: + if file.endswith('.nc'): + file_path = os.path.join(directory, file) + # Open the NetCDF file + dataset = Dataset(file_path, mode='r') From 8e5ad0f1e9a1ecf979487ab5ba04bc70581bd98e Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 11 Oct 2024 14:29:16 +0100 Subject: [PATCH 028/291] Re-organized data by month, averaged across all reporting types for the facility --- .../reporting_and_weather_data.py | 39 ++++++++++++++++++- 1 file changed, 37 insertions(+), 2 deletions(-) diff --git a/src/scripts/climate_change/reporting_and_weather_data.py b/src/scripts/climate_change/reporting_and_weather_data.py index 2fd437696f..8c36df92b1 100644 --- a/src/scripts/climate_change/reporting_and_weather_data.py +++ b/src/scripts/climate_change/reporting_and_weather_data.py @@ -23,13 +23,48 @@ data_of_interest.columns = [col.replace(" - Reporting rate ", "") for col in data_of_interest.columns] monthly_reporting_data_by_metric[metric] = data_of_interest +### Actually don't want by metric - instead look across all dates for a given row and average (i.e. want to average by month by facility, not by metric by facility) + +monthly_reporting_data_by_facility = {} +months = set(col.split(" - Reporting rate ")[1] for col in all_columns if " - Reporting rate " in col) +# put in order +months = [date.strip() for date in months] # extra spaces?? +dates = pd.to_datetime(months, format='%B %Y', errors='coerce') +months = dates.sort_values().strftime('%B %Y').tolist() + +for month in months: + print(month) + columns_of_interest_all_metrics = [reporting_data.columns[1]] + reporting_data.columns[reporting_data.columns.str.endswith(month)].tolist() + data_of_interest_by_month = reporting_data[columns_of_interest_all_metrics] + numeric_data = data_of_interest_by_month.select_dtypes(include='number') + monthly_mean_by_facility = numeric_data.mean(axis=1) + monthly_reporting_data_by_facility[month] = monthly_mean_by_facility + +monthly_reporting_by_facility = pd.DataFrame(monthly_reporting_data_by_facility) + # Weather data directory = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical" weather_by_month = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical" files = os.listdir(directory) - +weather_by_grid = {} for file in files: if file.endswith('.nc'): file_path = os.path.join(directory, file) # Open the NetCDF file - dataset = Dataset(file_path, mode='r') + weather_monthly_all_grids = Dataset(file_path, mode='r') + pr_data = weather_monthly_all_grids.variables['tp'][:] # total precipitation in kg m-2 s-1 = mm s-1 x 86400 to get to day + lat_data = weather_monthly_all_grids.variables['latitude'][:] + long_data = weather_monthly_all_grids.variables['longitude'][:] + print(len(long_data)) + grid = 0 + for i in range(len(long_data) - 1): + for j in range(len(lat_data) - 1): + precip_data_for_grid = pr_data[:, i, j] # across all time points + precip_data_for_grid = precip_data_for_grid * 86400 # to get from per second to per day + weather_by_grid[grid] = precip_data_for_grid + grid += 1 + + +print(weather_by_grid) + +# From 7bef52a31a8db6277837377997b23de43cbced2a Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 11 Oct 2024 15:33:17 +0100 Subject: [PATCH 029/291] Saving shap file of malawi grid --- src/scripts/climate_change/grid_malawi.py | 1 + 1 file changed, 1 insertion(+) diff --git a/src/scripts/climate_change/grid_malawi.py b/src/scripts/climate_change/grid_malawi.py index 5a7d353c2f..436dc1299e 100644 --- a/src/scripts/climate_change/grid_malawi.py +++ b/src/scripts/climate_change/grid_malawi.py @@ -43,6 +43,7 @@ grid_clipped_ADM1 = gpd.overlay(grid, malawi_admin1, how='intersection') # for graphing grid_clipped_ADM2 = gpd.overlay(grid, malawi_admin2, how='intersection') # for graphing cmap = plt.cm.get_cmap('tab20', len(grid_clipped_ADM1['ADM1_EN'].unique())) +grid.to_file("/Users/rem76/Desktop/Climate_change_health/Data/malawi_grid.shp") fig, ax = plt.subplots(figsize=(10, 10)) malawi_admin2.plot(ax=ax, edgecolor='black', color='white') From 02f2b206676e4187adbad79315c856d520e0c8d1 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 11 Oct 2024 15:37:31 +0100 Subject: [PATCH 030/291] Saving shap file of malawi grid, removed print --- src/scripts/climate_change/grid_malawi.py | 1 - 1 file changed, 1 deletion(-) diff --git a/src/scripts/climate_change/grid_malawi.py b/src/scripts/climate_change/grid_malawi.py index 436dc1299e..119435acef 100644 --- a/src/scripts/climate_change/grid_malawi.py +++ b/src/scripts/climate_change/grid_malawi.py @@ -8,7 +8,6 @@ # Load netCDF data for gridding info file_path = "/Users/rem76/Downloads/821bebfbcee0609d233c09e8b2bbc1f3/pr_Amon_UKESM1-0-LL_ssp119_r1i1p1f2_gn_20150116-20991216.nc" dataset = Dataset(file_path, mode='r') -print(dataset.variables.keys()) pr_data = dataset.variables['pr'][:] time_data = dataset.variables['time'][:] lat_data = dataset.variables['lat'][:] From 22f46b0519da77293f2c72e815910cdea7f7892d Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 11 Oct 2024 16:10:54 +0100 Subject: [PATCH 031/291] Imported malawi shap file and did an initial regrid to get correct resolution for historical data --- .../reporting_and_weather_data.py | 46 ++++++++++++++----- 1 file changed, 34 insertions(+), 12 deletions(-) diff --git a/src/scripts/climate_change/reporting_and_weather_data.py b/src/scripts/climate_change/reporting_and_weather_data.py index 8c36df92b1..b10654f613 100644 --- a/src/scripts/climate_change/reporting_and_weather_data.py +++ b/src/scripts/climate_change/reporting_and_weather_data.py @@ -1,7 +1,8 @@ import os - +import geopandas as gpd import pandas as pd from netCDF4 import Dataset +from shapely.geometry import Polygon # Data accessed from https://dhis2.health.gov.mw/dhis-web-data-visualizer/#/YiQK65skxjz # Reporting rate is expected reporting vs actual reporting @@ -33,7 +34,6 @@ months = dates.sort_values().strftime('%B %Y').tolist() for month in months: - print(month) columns_of_interest_all_metrics = [reporting_data.columns[1]] + reporting_data.columns[reporting_data.columns.str.endswith(month)].tolist() data_of_interest_by_month = reporting_data[columns_of_interest_all_metrics] numeric_data = data_of_interest_by_month.select_dtypes(include='number') @@ -44,27 +44,49 @@ # Weather data directory = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical" -weather_by_month = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical" +malawi_grid = gpd.read_file("/Users/rem76/Desktop/Climate_change_health/Data/malawi_grid.shp") +# find indices of interest from the malawi file + files = os.listdir(directory) weather_by_grid = {} for file in files: if file.endswith('.nc'): file_path = os.path.join(directory, file) - # Open the NetCDF file + # Open the NetCDF file - unsure of name, should only be one though weather_monthly_all_grids = Dataset(file_path, mode='r') - pr_data = weather_monthly_all_grids.variables['tp'][:] # total precipitation in kg m-2 s-1 = mm s-1 x 86400 to get to day - lat_data = weather_monthly_all_grids.variables['latitude'][:] - long_data = weather_monthly_all_grids.variables['longitude'][:] - print(len(long_data)) - grid = 0 - for i in range(len(long_data) - 1): + +# the historical data is at a different resolution to the projections. so try and find the closest possible indicses +# to create a new grid for the historical data +pr_data = weather_monthly_all_grids.variables['tp'][:] # total precipitation in kg m-2 s-1 = mm s-1 x 86400 to get to day +lat_data = weather_monthly_all_grids.variables['latitude'][:] +long_data = weather_monthly_all_grids.variables['longitude'][:] +regridded_lat_long = [] +for polygon in malawi_grid["geometry"]: + minx, miny, maxx, maxy = polygon.bounds + index_for_x_min = ((long_data - minx)**2).argmin() + index_for_y_min = ((lat_data - miny)**2).argmin() + index_for_x_max = ((long_data - maxx)**2).argmin() + index_for_y_max = ((lat_data - maxy)**2).argmin() + print(lat_data[index_for_y_min]) + polygon_new = Polygon([ + (long_data[index_for_x_min], lat_data[index_for_y_min]), + (long_data[index_for_x_max], lat_data[index_for_y_min]), + (long_data[index_for_x_max], lat_data[index_for_y_max]), + (long_data[index_for_x_min], lat_data[index_for_y_max]), + (long_data[index_for_x_min], lat_data[index_for_y_min]) + ]) + regridded_lat_long.append(polygon_new) + +regridded_lat_long = gpd.GeoDataFrame({'geometry': regridded_lat_long}, crs=malawi_grid.crs) + +grid = 0 +for i in range(len(long_data) - 1): for j in range(len(lat_data) - 1): - precip_data_for_grid = pr_data[:, i, j] # across all time points + precip_data_for_grid = pr_data[:, j, i] # across all time points precip_data_for_grid = precip_data_for_grid * 86400 # to get from per second to per day weather_by_grid[grid] = precip_data_for_grid grid += 1 -print(weather_by_grid) # From d6c3d624a5336b8544216308053a96b6ff762029 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 11 Oct 2024 17:34:33 +0100 Subject: [PATCH 032/291] Edited months to make sure no mental health data inlcuded (only relavent for Zomba Mental Health Hospital) Also excluded months before 2011 (bad data) --- .../reporting_and_weather_data.py | 52 +++++++++---------- 1 file changed, 24 insertions(+), 28 deletions(-) diff --git a/src/scripts/climate_change/reporting_and_weather_data.py b/src/scripts/climate_change/reporting_and_weather_data.py index b10654f613..b18d560637 100644 --- a/src/scripts/climate_change/reporting_and_weather_data.py +++ b/src/scripts/climate_change/reporting_and_weather_data.py @@ -25,22 +25,30 @@ monthly_reporting_data_by_metric[metric] = data_of_interest ### Actually don't want by metric - instead look across all dates for a given row and average (i.e. want to average by month by facility, not by metric by facility) - +### But need to drop mental health, as that is only relevant for the Zomba Mental Hospital and otherwise brings down averages +# extract mental health data +mental_health_columns = reporting_data.columns[reporting_data.columns.str.startswith("Mental")].tolist() +reporting_data_no_mental = reporting_data.drop(mental_health_columns, axis = 1) +mental_health_data = reporting_data[[reporting_data.columns[1]] + mental_health_columns] +all_columns_no_mental_health = reporting_data_no_mental.columns + +### now aggregate over months monthly_reporting_data_by_facility = {} -months = set(col.split(" - Reporting rate ")[1] for col in all_columns if " - Reporting rate " in col) +months = set(col.split(" - Reporting rate ")[1] for col in all_columns_no_mental_health if " - Reporting rate " in col) + # put in order months = [date.strip() for date in months] # extra spaces?? dates = pd.to_datetime(months, format='%B %Y', errors='coerce') months = dates.sort_values().strftime('%B %Y').tolist() - +months = months[12*11:] # only want from 2011 on for month in months: - columns_of_interest_all_metrics = [reporting_data.columns[1]] + reporting_data.columns[reporting_data.columns.str.endswith(month)].tolist() - data_of_interest_by_month = reporting_data[columns_of_interest_all_metrics] + columns_of_interest_all_metrics = [reporting_data_no_mental.columns[1]] + reporting_data_no_mental.columns[reporting_data_no_mental.columns.str.endswith(month)].tolist() + data_of_interest_by_month = reporting_data_no_mental[columns_of_interest_all_metrics] numeric_data = data_of_interest_by_month.select_dtypes(include='number') monthly_mean_by_facility = numeric_data.mean(axis=1) monthly_reporting_data_by_facility[month] = monthly_mean_by_facility - monthly_reporting_by_facility = pd.DataFrame(monthly_reporting_data_by_facility) +monthly_reporting_by_facility["facility"] = reporting_data_no_mental["organisationunitname"].values # Weather data directory = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical" @@ -60,33 +68,21 @@ pr_data = weather_monthly_all_grids.variables['tp'][:] # total precipitation in kg m-2 s-1 = mm s-1 x 86400 to get to day lat_data = weather_monthly_all_grids.variables['latitude'][:] long_data = weather_monthly_all_grids.variables['longitude'][:] -regridded_lat_long = [] +grid = 0 + +regridded_weather_data = [] for polygon in malawi_grid["geometry"]: minx, miny, maxx, maxy = polygon.bounds index_for_x_min = ((long_data - minx)**2).argmin() index_for_y_min = ((lat_data - miny)**2).argmin() index_for_x_max = ((long_data - maxx)**2).argmin() index_for_y_max = ((lat_data - maxy)**2).argmin() - print(lat_data[index_for_y_min]) - polygon_new = Polygon([ - (long_data[index_for_x_min], lat_data[index_for_y_min]), - (long_data[index_for_x_max], lat_data[index_for_y_min]), - (long_data[index_for_x_max], lat_data[index_for_y_max]), - (long_data[index_for_x_min], lat_data[index_for_y_max]), - (long_data[index_for_x_min], lat_data[index_for_y_min]) - ]) - regridded_lat_long.append(polygon_new) - -regridded_lat_long = gpd.GeoDataFrame({'geometry': regridded_lat_long}, crs=malawi_grid.crs) - -grid = 0 -for i in range(len(long_data) - 1): - for j in range(len(lat_data) - 1): - precip_data_for_grid = pr_data[:, j, i] # across all time points - precip_data_for_grid = precip_data_for_grid * 86400 # to get from per second to per day - weather_by_grid[grid] = precip_data_for_grid - grid += 1 - + precip_data_for_grid = pr_data[:, index_for_y_min,index_for_x_min] # across all time points + precip_data_for_grid = precip_data_for_grid * 86400 # to get from per second to per day + weather_by_grid[grid] = precip_data_for_grid + grid += 1 -# +# Load facilities file +general_facilities = gpd.read_file("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_districts.shp") +print(monthly_reporting_by_facility) From e773e6ad8b45d119f3e22eca77c84d6770db9ae8 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 14 Oct 2024 09:20:18 +0100 Subject: [PATCH 033/291] Added grid index to the facilities list for referral later --- src/scripts/climate_change/grid_malawi.py | 1 + 1 file changed, 1 insertion(+) diff --git a/src/scripts/climate_change/grid_malawi.py b/src/scripts/climate_change/grid_malawi.py index 119435acef..29b693b56d 100644 --- a/src/scripts/climate_change/grid_malawi.py +++ b/src/scripts/climate_change/grid_malawi.py @@ -60,6 +60,7 @@ intersections = gpd.overlay(grid, malawi_admin2, how='intersection') # 56 intersections between districts and major grid squares admin_area_with_major_grid = gpd.overlay( grid, malawi_admin2, how='intersection') # finding which grid each facility falls into +admin_area_with_major_grid = admin_area_with_major_grid.reset_index().rename(columns={'index': 'Grid_Index'}) # want this to be a column for reference ########### Create new table with facilities and add coordinates to each facility ######### From 270a294e21ac9f545a3c7d85ae2ae87dc0bd5286 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 14 Oct 2024 09:34:17 +0100 Subject: [PATCH 034/291] Changed numerical grid reference so that it is the major grid, not the grid intersections --- src/scripts/climate_change/grid_malawi.py | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/src/scripts/climate_change/grid_malawi.py b/src/scripts/climate_change/grid_malawi.py index 29b693b56d..646969ed4c 100644 --- a/src/scripts/climate_change/grid_malawi.py +++ b/src/scripts/climate_change/grid_malawi.py @@ -57,10 +57,8 @@ #plt.show() ### Intersection between the grid and the admin areas ### -intersections = gpd.overlay(grid, malawi_admin2, how='intersection') # 56 intersections between districts and major grid squares - -admin_area_with_major_grid = gpd.overlay( grid, malawi_admin2, how='intersection') # finding which grid each facility falls into -admin_area_with_major_grid = admin_area_with_major_grid.reset_index().rename(columns={'index': 'Grid_Index'}) # want this to be a column for reference +grid['Grid_Index'] = grid.index +admin_area_with_major_grid = gpd.overlay(grid, malawi_admin2, how='intersection') #56 intersections between districts and major grid squares, finding which grid each facility falls into ########### Create new table with facilities and add coordinates to each facility ######### From 42c985c78b6c11203c271af95d6e69ee715f2db4 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 14 Oct 2024 10:07:51 +0100 Subject: [PATCH 035/291] Added linear regression but need to investigate as uneven numbers of observations --- .../reporting_and_weather_data.py | 51 +++++++++++++++++-- 1 file changed, 47 insertions(+), 4 deletions(-) diff --git a/src/scripts/climate_change/reporting_and_weather_data.py b/src/scripts/climate_change/reporting_and_weather_data.py index b18d560637..3971a93337 100644 --- a/src/scripts/climate_change/reporting_and_weather_data.py +++ b/src/scripts/climate_change/reporting_and_weather_data.py @@ -2,7 +2,9 @@ import geopandas as gpd import pandas as pd from netCDF4 import Dataset -from shapely.geometry import Polygon +import numpy as np +from sklearn.linear_model import LinearRegression +from sklearn.metrics import r2_score # Data accessed from https://dhis2.health.gov.mw/dhis-web-data-visualizer/#/YiQK65skxjz # Reporting rate is expected reporting vs actual reporting @@ -70,7 +72,7 @@ long_data = weather_monthly_all_grids.variables['longitude'][:] grid = 0 -regridded_weather_data = [] +regridded_weather_data = {} for polygon in malawi_grid["geometry"]: minx, miny, maxx, maxy = polygon.bounds index_for_x_min = ((long_data - minx)**2).argmin() @@ -82,7 +84,48 @@ precip_data_for_grid = precip_data_for_grid * 86400 # to get from per second to per day weather_by_grid[grid] = precip_data_for_grid grid += 1 - # Load facilities file general_facilities = gpd.read_file("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_districts.shp") -print(monthly_reporting_by_facility) +# find relavent shap file +weather_data_by_facility = {} +for reporting_facility in monthly_reporting_by_facility["facility"]: + if (reporting_facility == "Central Hospital") or reporting_facility == "Kamuzu Central Hospital": + # which malawi grid this is + grid = general_facilities[general_facilities["District"] == "Lilongwe City"]["Grid_Index"].iloc[0] # all labelled X City will be in the same grid + elif reporting_facility == "Mzuzu Central Hospital": + grid = general_facilities[general_facilities["District"] == "Mzuzu City"]["Grid_Index"].iloc[0] + elif reporting_facility == "Queen Elizabeth Central Hospital": + grid = general_facilities[general_facilities["District"] == "Blantyre City"]["Grid_Index"].iloc[0] + elif (reporting_facility == "Zomba Central Hospital") or (reporting_facility == "Zomba Mental Hospital"): + grid = general_facilities[general_facilities["District"] == "Zomba City"]["Grid_Index"].iloc[0] + elif reporting_facility == "Central East Zone": + grid = general_facilities[general_facilities["District"] == "Nkhotakota"]["Grid_Index"].iloc[0] # furtherst east zone + + weather_data_by_facility[reporting_facility] = weather_by_grid[grid] + + +### Linear regression between reporting and weather data +# prep for linear regression +weather_df = pd.DataFrame.from_dict(weather_data_by_facility, orient='index').T +weather_df.columns = monthly_reporting_by_facility["facility"] +monthly_reporting_by_facility = monthly_reporting_by_facility.set_index('facility').T + +X = weather_df.values.flatten() +y = monthly_reporting_by_facility.values.flatten() +if X.ndim == 1: + X = X.reshape(-1, 1) +if y.ndim == 1: + y = y.reshape(-1, 1) + +print(len(X), len(y)) + +# Perform linear regression +model = LinearRegression() +model.fit(X[0:len(y)], y) +y_pred = model.predict(X[0:len(y)]) + +# Evaluate the model +r2 = r2_score(y, y_pred) +print(f'R-squared: {r2:.2f}') +print(f'Coefficient: {model.coef_[0]:.2f}') +print(f'Intercept: {model.intercept_:.2f}') From 25bd34c01c44ba741c262156e8494edd418a86c6 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 14 Oct 2024 10:08:23 +0100 Subject: [PATCH 036/291] Dropped division by metric as unneeded --- .../climate_change/reporting_and_weather_data.py | 16 ---------------- 1 file changed, 16 deletions(-) diff --git a/src/scripts/climate_change/reporting_and_weather_data.py b/src/scripts/climate_change/reporting_and_weather_data.py index 3971a93337..c8650dce6f 100644 --- a/src/scripts/climate_change/reporting_and_weather_data.py +++ b/src/scripts/climate_change/reporting_and_weather_data.py @@ -10,22 +10,6 @@ # Reporting rate is expected reporting vs actual reporting reporting_data = pd.read_csv('/Users/rem76/Desktop/Climate_change_health/Data/Reporting_Rate/Reporting_Rate_Central_Hospital_2000_2024.csv') -# Divide dataset based on what is being reported -# get metrics recorded -all_columns = reporting_data.columns -metrics = set([col.split(" - Reporting rate")[0] for col in all_columns]) -metrics = {metric for metric in metrics if not metric.startswith("organisation")} # inlcude only reporting data - - -monthly_reporting_data_by_metric = {} - -for metric in metrics: - columns_of_interest = [reporting_data.columns[1]] + reporting_data.columns[reporting_data.columns.str.startswith(metric)].tolist() - data_of_interest = reporting_data[columns_of_interest] - data_of_interest.columns = [col.replace(metric, "") for col in data_of_interest.columns] - data_of_interest.columns = [col.replace(" - Reporting rate ", "") for col in data_of_interest.columns] - monthly_reporting_data_by_metric[metric] = data_of_interest - ### Actually don't want by metric - instead look across all dates for a given row and average (i.e. want to average by month by facility, not by metric by facility) ### But need to drop mental health, as that is only relevant for the Zomba Mental Hospital and otherwise brings down averages # extract mental health data From ecca012c983cd37421c26e446a5484f89ca94b09 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 14 Oct 2024 10:23:25 +0100 Subject: [PATCH 037/291] Dropped October-December 2024 from the reporting data as do not have that "historical" weather data yet. Also wrote the lm-ready datafiles to csvs --- .../reporting_and_weather_data.py | 33 ++++++------------- 1 file changed, 10 insertions(+), 23 deletions(-) diff --git a/src/scripts/climate_change/reporting_and_weather_data.py b/src/scripts/climate_change/reporting_and_weather_data.py index c8650dce6f..1e96a5084f 100644 --- a/src/scripts/climate_change/reporting_and_weather_data.py +++ b/src/scripts/climate_change/reporting_and_weather_data.py @@ -5,12 +5,16 @@ import numpy as np from sklearn.linear_model import LinearRegression from sklearn.metrics import r2_score +import matplotlib.pyplot as plt # Data accessed from https://dhis2.health.gov.mw/dhis-web-data-visualizer/#/YiQK65skxjz # Reporting rate is expected reporting vs actual reporting -reporting_data = pd.read_csv('/Users/rem76/Desktop/Climate_change_health/Data/Reporting_Rate/Reporting_Rate_Central_Hospital_2000_2024.csv') +reporting_data = pd.read_csv('/Users/rem76/Desktop/Climate_change_health/Data/Reporting_Rate/Reporting_Rate_Central_Hospital_2000_2024.csv') #January 2000 - January 2024 +# ANALYSIS DONE IN OCTOBER 2024 - so drop October, November, December 2024 +columns_to_drop = reporting_data.columns[reporting_data.columns.str.endswith(('October 2024', 'November 2024', 'December 2024'))] + +reporting_data = reporting_data.drop(columns=columns_to_drop) -### Actually don't want by metric - instead look across all dates for a given row and average (i.e. want to average by month by facility, not by metric by facility) ### But need to drop mental health, as that is only relevant for the Zomba Mental Hospital and otherwise brings down averages # extract mental health data mental_health_columns = reporting_data.columns[reporting_data.columns.str.startswith("Mental")].tolist() @@ -88,28 +92,11 @@ weather_data_by_facility[reporting_facility] = weather_by_grid[grid] -### Linear regression between reporting and weather data -# prep for linear regression +### Get data ready for linear regression between reporting and weather data weather_df = pd.DataFrame.from_dict(weather_data_by_facility, orient='index').T weather_df.columns = monthly_reporting_by_facility["facility"] monthly_reporting_by_facility = monthly_reporting_by_facility.set_index('facility').T -X = weather_df.values.flatten() -y = monthly_reporting_by_facility.values.flatten() -if X.ndim == 1: - X = X.reshape(-1, 1) -if y.ndim == 1: - y = y.reshape(-1, 1) - -print(len(X), len(y)) - -# Perform linear regression -model = LinearRegression() -model.fit(X[0:len(y)], y) -y_pred = model.predict(X[0:len(y)]) - -# Evaluate the model -r2 = r2_score(y, y_pred) -print(f'R-squared: {r2:.2f}') -print(f'Coefficient: {model.coef_[0]:.2f}') -print(f'Intercept: {model.intercept_:.2f}') +### Save CSVs +monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_facility_lm.csv") +weather_df.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_facility_lm.csv") From c18c1299cd1440ee134115b864fde4e32d47853e Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 14 Oct 2024 10:23:52 +0100 Subject: [PATCH 038/291] removed imports --- src/scripts/climate_change/reporting_and_weather_data.py | 4 ---- 1 file changed, 4 deletions(-) diff --git a/src/scripts/climate_change/reporting_and_weather_data.py b/src/scripts/climate_change/reporting_and_weather_data.py index 1e96a5084f..58595df9a7 100644 --- a/src/scripts/climate_change/reporting_and_weather_data.py +++ b/src/scripts/climate_change/reporting_and_weather_data.py @@ -2,10 +2,6 @@ import geopandas as gpd import pandas as pd from netCDF4 import Dataset -import numpy as np -from sklearn.linear_model import LinearRegression -from sklearn.metrics import r2_score -import matplotlib.pyplot as plt # Data accessed from https://dhis2.health.gov.mw/dhis-web-data-visualizer/#/YiQK65skxjz # Reporting rate is expected reporting vs actual reporting From 0785843565cba1abbeafcf4878fe508937782ce4 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 14 Oct 2024 10:33:41 +0100 Subject: [PATCH 039/291] File for examination of trend between weather and reporting --- ...al_realtionship_reporting_precipitation.py | 42 +++++++++++++++++++ 1 file changed, 42 insertions(+) create mode 100644 src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py new file mode 100644 index 0000000000..c90a05bcd0 --- /dev/null +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -0,0 +1,42 @@ +import pandas as pd +from sklearn.linear_model import LinearRegression +from sklearn.metrics import r2_score +import matplotlib.pyplot as plt +import pandas as pd + +monthly_reporting_by_facility = pd.read_csv_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_facility_lm.csv") +weather_data_historical = pd.read_csv_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_facility_lm.csv") +plt.figure(figsize=(12, 6)) + +# Plot each facility's reporting data against weather data +for facility in weather_data_historical.columns: + plt.plot(weather_data_historical.index, monthly_reporting_by_facility[facility], label=facility) + +plt.xlabel('Weather Data') +plt.ylabel('Reporting') +plt.title('Reporting vs. Weather Data by Facility') +plt.legend(title='Facilities', bbox_to_anchor=(1.05, 1), loc='upper left') +plt.grid() +plt.tight_layout() +plt.show() + +X = weather_data_historical.values +y = monthly_reporting_by_facility.values +if X.ndim == 1: + X = X.reshape(-1, 1) +if y.ndim == 1: + y = y.reshape(-1, 1) + + +# Perform linear regression +model = LinearRegression() +model.fit(X, y) +y_pred = model.predict(X) +print(X) +print(y) +# Evaluate the model +r2 = r2_score(y, y_pred) +print(f'R-squared: {r2:.2f}') +print(model.coef_) +print(model.intercept_) +print(model.fit) From 0c077a9559b1a8dfdc5550546026d2f722e1b40e Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 14 Oct 2024 10:53:52 +0100 Subject: [PATCH 040/291] Added labels to graph removed September 2024 (bad quality data) --- ...ical_realtionship_reporting_precipitation.py | 17 ++++++++++++++--- 1 file changed, 14 insertions(+), 3 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index c90a05bcd0..dd3b4002de 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -4,14 +4,18 @@ import matplotlib.pyplot as plt import pandas as pd -monthly_reporting_by_facility = pd.read_csv_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_facility_lm.csv") -weather_data_historical = pd.read_csv_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_facility_lm.csv") +# data is from 2011 - 2024 +monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_facility_lm.csv", index_col=0) +weather_data_historical = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_facility_lm.csv", index_col=0) plt.figure(figsize=(12, 6)) # Plot each facility's reporting data against weather data for facility in weather_data_historical.columns: plt.plot(weather_data_historical.index, monthly_reporting_by_facility[facility], label=facility) - +months = weather_data_historical.index +year_labels = range(2011, 2025, 1) +year_ticks = range(0, len(months), 12) +plt.xticks(year_ticks, year_labels, rotation=90) plt.xlabel('Weather Data') plt.ylabel('Reporting') plt.title('Reporting vs. Weather Data by Facility') @@ -20,6 +24,10 @@ plt.tight_layout() plt.show() +## Drop Mental Hospital - no reporting before 2011 maybe +weather_data_historical = weather_data_historical.drop("Zomba Mental Hospital", axis=1) +monthly_reporting_by_facility = monthly_reporting_by_facility.drop("Zomba Mental Hospital", axis=1) + X = weather_data_historical.values y = monthly_reporting_by_facility.values if X.ndim == 1: @@ -27,6 +35,9 @@ if y.ndim == 1: y = y.reshape(-1, 1) +# Remove September 2024, bad quality data +X = X[0:len(X) - 1] +y = y[0:len(y) - 1] # Perform linear regression model = LinearRegression() From a25a0fc8cdda575ae95e2c033c887ef634b5eb63 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 14 Oct 2024 10:54:12 +0100 Subject: [PATCH 041/291] Comments for clarity --- src/scripts/climate_change/reporting_and_weather_data.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/scripts/climate_change/reporting_and_weather_data.py b/src/scripts/climate_change/reporting_and_weather_data.py index 58595df9a7..51c32b0ea4 100644 --- a/src/scripts/climate_change/reporting_and_weather_data.py +++ b/src/scripts/climate_change/reporting_and_weather_data.py @@ -37,7 +37,7 @@ monthly_reporting_by_facility["facility"] = reporting_data_no_mental["organisationunitname"].values # Weather data -directory = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical" +directory = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical" # from 2011 on malawi_grid = gpd.read_file("/Users/rem76/Desktop/Climate_change_health/Data/malawi_grid.shp") # find indices of interest from the malawi file From 81caf49bebfb6a7f00995714accdffa888614983 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 14 Oct 2024 11:27:29 +0100 Subject: [PATCH 042/291] Added year as a fixed effect - as reporting goes up over time anyway --- ...al_realtionship_reporting_precipitation.py | 50 +++++++++++++++---- 1 file changed, 39 insertions(+), 11 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index dd3b4002de..7b12fd9bac 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -1,15 +1,17 @@ -import pandas as pd from sklearn.linear_model import LinearRegression from sklearn.metrics import r2_score import matplotlib.pyplot as plt import pandas as pd +import numpy as np + # data is from 2011 - 2024 monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_facility_lm.csv", index_col=0) weather_data_historical = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_facility_lm.csv", index_col=0) +# +# Plot each facility's reporting data against weather data plt.figure(figsize=(12, 6)) -# Plot each facility's reporting data against weather data for facility in weather_data_historical.columns: plt.plot(weather_data_historical.index, monthly_reporting_by_facility[facility], label=facility) months = weather_data_historical.index @@ -22,32 +24,58 @@ plt.legend(title='Facilities', bbox_to_anchor=(1.05, 1), loc='upper left') plt.grid() plt.tight_layout() -plt.show() +#plt.show() -## Drop Mental Hospital - no reporting before 2011 maybe +## Drop Mental Hospital - bad reporting generally weather_data_historical = weather_data_historical.drop("Zomba Mental Hospital", axis=1) monthly_reporting_by_facility = monthly_reporting_by_facility.drop("Zomba Mental Hospital", axis=1) +## Drop September 2024 +weather_data_historical = weather_data_historical.drop(weather_data_historical.index[-1]) +monthly_reporting_by_facility = monthly_reporting_by_facility.drop(monthly_reporting_by_facility.index[-1]) +## Drop before 2014? 12*4 +weather_data_historical = weather_data_historical.drop(weather_data_historical.index[0:48]).reset_index(drop=True) +monthly_reporting_by_facility = monthly_reporting_by_facility.drop(monthly_reporting_by_facility.index[0:48]).reset_index(drop=True) + +# Plot each facility's reporting data against weather data +plt.figure(figsize=(12, 6)) + +for facility in weather_data_historical.columns: + plt.plot(weather_data_historical.index, monthly_reporting_by_facility[facility], label=facility) +months = weather_data_historical.index +year_labels = range(2015, 2025, 1) +year_ticks = range(0, len(months), 12) +plt.xticks(year_ticks, year_labels, rotation=90) +plt.xlabel('Weather Data') +plt.ylabel('Reporting') +plt.title('Reporting vs. Weather Data by Facility') +plt.legend(title='Facilities', bbox_to_anchor=(1.05, 1), loc='upper left') +plt.grid() +plt.tight_layout() +#plt.show() + +## Linear regression +print(monthly_reporting_by_facility) +year = range(2014, 2024, 1) # year as a fixed effect +year_repeated = [y for y in year for _ in range(12)] +year = year_repeated[:-4] X = weather_data_historical.values y = monthly_reporting_by_facility.values if X.ndim == 1: X = X.reshape(-1, 1) if y.ndim == 1: y = y.reshape(-1, 1) - -# Remove September 2024, bad quality data -X = X[0:len(X) - 1] -y = y[0:len(y) - 1] +print(len(year)) +print(len(X)) +X = np.column_stack((X, year)) # Perform linear regression model = LinearRegression() model.fit(X, y) y_pred = model.predict(X) -print(X) -print(y) + # Evaluate the model r2 = r2_score(y, y_pred) print(f'R-squared: {r2:.2f}') print(model.coef_) print(model.intercept_) -print(model.fit) From c53faf2d46809a1b02bf9b23bdcc4e2c222b29fa Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 14 Oct 2024 11:31:09 +0100 Subject: [PATCH 043/291] Included year and month as fixed effects --- ...historical_realtionship_reporting_precipitation.py | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 7b12fd9bac..49370fb6fa 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -55,10 +55,15 @@ ## Linear regression -print(monthly_reporting_by_facility) +# year as a fixed effect year = range(2014, 2024, 1) # year as a fixed effect year_repeated = [y for y in year for _ in range(12)] year = year_repeated[:-4] +# add month as a fixed effect +month = range(12) +month_repeated = [m for m in month for _ in range(2014, 2024, 1)] +month = month_repeated[:-4] + X = weather_data_historical.values y = monthly_reporting_by_facility.values if X.ndim == 1: @@ -67,7 +72,8 @@ y = y.reshape(-1, 1) print(len(year)) print(len(X)) -X = np.column_stack((X, year)) +print(len(month)) +X = np.column_stack((X, year, month)) # Perform linear regression model = LinearRegression() @@ -79,3 +85,4 @@ print(f'R-squared: {r2:.2f}') print(model.coef_) print(model.intercept_) + From 3d88f3b66f88de3699b55a4c6d315b7dd1a0b651 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 14 Oct 2024 11:58:07 +0100 Subject: [PATCH 044/291] isort --- src/scripts/climate_change/reporting_and_weather_data.py | 1 + 1 file changed, 1 insertion(+) diff --git a/src/scripts/climate_change/reporting_and_weather_data.py b/src/scripts/climate_change/reporting_and_weather_data.py index 51c32b0ea4..0fc0abe3c7 100644 --- a/src/scripts/climate_change/reporting_and_weather_data.py +++ b/src/scripts/climate_change/reporting_and_weather_data.py @@ -1,4 +1,5 @@ import os + import geopandas as gpd import pandas as pd from netCDF4 import Dataset From a8ed9c62e9b3d0ce218626e63d10f0d463950f5e Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 14 Oct 2024 13:47:59 +0100 Subject: [PATCH 045/291] Two versions of linear regression - one by facility (year and month as fixed effects) and one using all data, with facility as a fixed effect Give very different result s --- ...al_realtionship_reporting_precipitation.py | 65 +++++++++++++------ 1 file changed, 45 insertions(+), 20 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 49370fb6fa..1abd3f39e9 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -1,9 +1,12 @@ -from sklearn.linear_model import LinearRegression -from sklearn.metrics import r2_score import matplotlib.pyplot as plt -import pandas as pd import numpy as np - +import pandas as pd +import scipy as sp +from sklearn.linear_model import LinearRegression +from sklearn.metrics import r2_score +from sklearn.compose import TransformedTargetRegressor +from sklearn.linear_model import Ridge +from sklearn.pipeline import make_pipeline # data is from 2011 - 2024 monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_facility_lm.csv", index_col=0) @@ -54,35 +57,57 @@ #plt.show() -## Linear regression + +## Linear regression - flattened # year as a fixed effect year = range(2014, 2024, 1) # year as a fixed effect year_repeated = [y for y in year for _ in range(12)] year = year_repeated[:-4] +year_flattened = year*len(weather_data_historical.columns) # to get flattened data + # add month as a fixed effect month = range(12) month_repeated = [m for m in month for _ in range(2014, 2024, 1)] month = month_repeated[:-4] +month_flattened = month*len(weather_data_historical.columns) -X = weather_data_historical.values -y = monthly_reporting_by_facility.values -if X.ndim == 1: - X = X.reshape(-1, 1) -if y.ndim == 1: - y = y.reshape(-1, 1) -print(len(year)) -print(len(X)) -print(len(month)) -X = np.column_stack((X, year, month)) - -# Perform linear regression +# facility as fixed effect +facility_flattened = list(range(len(weather_data_historical.columns))) * len(month) +# location as a fixed effect + +# linear regression - flatten for more data points +X = weather_data_historical.values.flatten().reshape(-1, 1) +y = monthly_reporting_by_facility.values.flatten() + +#X = np.column_stack((X)) #, year_flattened, month_flattened, facility_flattened)) +print("X shape:", X.shape) +print("y shape:", y.shape) +# # Perform linear regression model = LinearRegression() model.fit(X, y) y_pred = model.predict(X) -# Evaluate the model r2 = r2_score(y, y_pred) -print(f'R-squared: {r2:.2f}') +print(r2 ) print(model.coef_) -print(model.intercept_) + +# ## Linear regression - by facility +results_list = [] + +for facility in monthly_reporting_by_facility.columns: + y = monthly_reporting_by_facility[facility].values + X = weather_data_historical.values + X = np.column_stack((X, year, month)) + + model = LinearRegression() + model.fit(X, y) + y_pred = model.predict(X) + + r2 = r2_score(y, y_pred) + coefficients = model.coef_ + + results_list.append({'Facility': facility, 'R2': r2, 'Coefficients': coefficients}) + +results = pd.DataFrame(results_list) +print(results) From e5d468b9224688e96afd3033ffe5ed678c3959b0 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 14 Oct 2024 14:26:30 +0100 Subject: [PATCH 046/291] One-hot encoded the facilities variable for fixed effect --- ...al_realtionship_reporting_precipitation.py | 27 +++++++++++-------- 1 file changed, 16 insertions(+), 11 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 1abd3f39e9..1b2b0a4e4b 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -1,12 +1,9 @@ import matplotlib.pyplot as plt import numpy as np import pandas as pd -import scipy as sp from sklearn.linear_model import LinearRegression from sklearn.metrics import r2_score -from sklearn.compose import TransformedTargetRegressor -from sklearn.linear_model import Ridge -from sklearn.pipeline import make_pipeline +from sklearn.preprocessing import OneHotEncoder # data is from 2011 - 2024 monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_facility_lm.csv", index_col=0) @@ -59,13 +56,13 @@ ## Linear regression - flattened -# year as a fixed effect +# year year = range(2014, 2024, 1) # year as a fixed effect year_repeated = [y for y in year for _ in range(12)] year = year_repeated[:-4] year_flattened = year*len(weather_data_historical.columns) # to get flattened data -# add month as a fixed effect +# month month = range(12) month_repeated = [m for m in month for _ in range(2014, 2024, 1)] month = month_repeated[:-4] @@ -73,15 +70,23 @@ # facility as fixed effect facility_flattened = list(range(len(weather_data_historical.columns))) * len(month) -# location as a fixed effect # linear regression - flatten for more data points -X = weather_data_historical.values.flatten().reshape(-1, 1) +weather_data = weather_data_historical.values.flatten() y = monthly_reporting_by_facility.values.flatten() +X = pd.DataFrame({ + 'weather_data': weather_data, + 'year': year_flattened, + 'month': month_flattened, + 'facility': facility_flattened +}) + +# One-hot encode the 'facility' column for a fixed effect +encoder = OneHotEncoder() +facility_encoded = pd.get_dummies(X['facility']) + +X = np.column_stack((X[['weather_data', 'year', 'month']], facility_encoded)) -#X = np.column_stack((X)) #, year_flattened, month_flattened, facility_flattened)) -print("X shape:", X.shape) -print("y shape:", y.shape) # # Perform linear regression model = LinearRegression() model.fit(X, y) From 7106542ba3d3cc567d7dc17e79218301c80a3e84 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 14 Oct 2024 15:27:43 +0100 Subject: [PATCH 047/291] Changed to statsmodel to get summary data --- ...al_realtionship_reporting_precipitation.py | 34 +++++++------------ 1 file changed, 13 insertions(+), 21 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 1b2b0a4e4b..4ab1ed8096 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -3,7 +3,7 @@ import pandas as pd from sklearn.linear_model import LinearRegression from sklearn.metrics import r2_score -from sklearn.preprocessing import OneHotEncoder +import statsmodels.api as sm # data is from 2011 - 2024 monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_facility_lm.csv", index_col=0) @@ -82,37 +82,29 @@ }) # One-hot encode the 'facility' column for a fixed effect -encoder = OneHotEncoder() facility_encoded = pd.get_dummies(X['facility']) X = np.column_stack((X[['weather_data', 'year', 'month']], facility_encoded)) # # Perform linear regression -model = LinearRegression() -model.fit(X, y) -y_pred = model.predict(X) +mod = sm.OLS(y,X) +results = mod.fit() -r2 = r2_score(y, y_pred) -print(r2 ) -print(model.coef_) +print(results.summary()) - -# ## Linear regression - by facility +# # ## Linear regression - by facility results_list = [] - +# for facility in monthly_reporting_by_facility.columns: y = monthly_reporting_by_facility[facility].values - X = weather_data_historical.values - X = np.column_stack((X, year, month)) + weather = weather_data_historical[facility].values + X = np.column_stack((weather, year, month)) + + mod = sm.OLS(y, X) + results = mod.fit() + + print(results.summary()) - model = LinearRegression() - model.fit(X, y) - y_pred = model.predict(X) - r2 = r2_score(y, y_pred) - coefficients = model.coef_ - results_list.append({'Facility': facility, 'R2': r2, 'Coefficients': coefficients}) -results = pd.DataFrame(results_list) -print(results) From 0e5e6fc57c0f24d8d990eff62b1cce9231e7d46a Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 14 Oct 2024 16:20:03 +0100 Subject: [PATCH 048/291] Added binary predictor of above/below average precipitation for that facility for that year --- ...al_realtionship_reporting_precipitation.py | 64 +++++++++++++++---- 1 file changed, 52 insertions(+), 12 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 4ab1ed8096..d26f2c4f50 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -29,12 +29,15 @@ ## Drop Mental Hospital - bad reporting generally weather_data_historical = weather_data_historical.drop("Zomba Mental Hospital", axis=1) monthly_reporting_by_facility = monthly_reporting_by_facility.drop("Zomba Mental Hospital", axis=1) +## Drop Queen Elizabeth - bad reporting generally, also have one represented for Lilongwe +weather_data_historical = weather_data_historical.drop("Queen Elizabeth Central Hospital", axis=1) +monthly_reporting_by_facility = monthly_reporting_by_facility.drop("Queen Elizabeth Central Hospital", axis=1) ## Drop September 2024 weather_data_historical = weather_data_historical.drop(weather_data_historical.index[-1]) monthly_reporting_by_facility = monthly_reporting_by_facility.drop(monthly_reporting_by_facility.index[-1]) -## Drop before 2014? 12*4 -weather_data_historical = weather_data_historical.drop(weather_data_historical.index[0:48]).reset_index(drop=True) -monthly_reporting_by_facility = monthly_reporting_by_facility.drop(monthly_reporting_by_facility.index[0:48]).reset_index(drop=True) +## Drop before 2016? 12*6 +weather_data_historical = weather_data_historical.drop(weather_data_historical.index[0:72]).reset_index(drop=True) +monthly_reporting_by_facility = monthly_reporting_by_facility.drop(monthly_reporting_by_facility.index[0:72]).reset_index(drop=True) # Plot each facility's reporting data against weather data plt.figure(figsize=(12, 6)) @@ -42,7 +45,7 @@ for facility in weather_data_historical.columns: plt.plot(weather_data_historical.index, monthly_reporting_by_facility[facility], label=facility) months = weather_data_historical.index -year_labels = range(2015, 2025, 1) +year_labels = range(2017, 2025, 1) year_ticks = range(0, len(months), 12) plt.xticks(year_ticks, year_labels, rotation=90) plt.xlabel('Weather Data') @@ -57,14 +60,14 @@ ## Linear regression - flattened # year -year = range(2014, 2024, 1) # year as a fixed effect +year = range(2016, 2024, 1) # year as a fixed effect year_repeated = [y for y in year for _ in range(12)] year = year_repeated[:-4] year_flattened = year*len(weather_data_historical.columns) # to get flattened data # month month = range(12) -month_repeated = [m for m in month for _ in range(2014, 2024, 1)] +month_repeated = [m for m in month for _ in range(2016, 2024, 1)] month = month_repeated[:-4] month_flattened = month*len(weather_data_historical.columns) @@ -86,9 +89,8 @@ X = np.column_stack((X[['weather_data', 'year', 'month']], facility_encoded)) -# # Perform linear regression -mod = sm.OLS(y,X) -results = mod.fit() +model = sm.OLS(y,X) +results = model.fit() print(results.summary()) @@ -100,11 +102,49 @@ weather = weather_data_historical[facility].values X = np.column_stack((weather, year, month)) - mod = sm.OLS(y, X) - results = mod.fit() + model = sm.OLS(y, X) + results = model.fit() - print(results.summary()) + #print(results.summary()) +## Binary above/below average for that month +X_df = pd.DataFrame({ + 'weather_data': weather_data, + 'year': year_flattened, + 'month': month_flattened, + 'facility': facility_flattened +}) + +grouped_data = X_df.groupby(['facility', 'month'])['weather_data'].mean().reset_index() +above_below_average = [] +for facility in range(len(monthly_reporting_by_facility.columns)): + for month in range(12): + average_for_month = grouped_data[(grouped_data["facility"] == facility) & (grouped_data["month"] == month)][ + "weather_data"] + X_data = X_df[(X_df["month"] == month) & (X_df["facility"] == facility)] + for value in X_data["weather_data"]: + above_below_average.append(1 if value > average_for_month.values[0] else 0) + + +# Add the binary variable to the predictors +X = pd.DataFrame({ + 'weather_data': weather_data, + 'year': year_flattened, + 'month': month_flattened, + 'facility': facility_flattened, + 'precip_above_average': above_below_average +}) +# One-hot encode the 'facility' column for a fixed effect +facility_encoded = pd.get_dummies(X['facility']) + +X = np.column_stack((X[['weather_data', 'year', 'month', 'precip_above_average']], facility_encoded)) +y = monthly_reporting_by_facility.values.flatten() + +print(len(y)) +model = sm.OLS(y,X) +results = model.fit() + +print(results.summary()) From ae6a5bc13dece66539480ebc5ded3e055ae42fd8 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 14 Oct 2024 16:29:50 +0100 Subject: [PATCH 049/291] Added whether in top 80 percentile... But too few observations --- ...al_realtionship_reporting_precipitation.py | 42 +++++++++++++++++++ 1 file changed, 42 insertions(+) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index d26f2c4f50..cfdddc5bc2 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -148,3 +148,45 @@ print(results.summary()) +### Top 80 percentile? +X_df = pd.DataFrame({ + 'weather_data': weather_data, + 'year': year_flattened, + 'month': month_flattened, + 'facility': facility_flattened +}) + +grouped_data_based_on_percentiles = X_df.groupby(['facility', 'month'])['weather_data'].quantile(0.8).reset_index() + +above_80_percentile = [] +for facility in range(len(monthly_reporting_by_facility.columns)): + for month in range(12): + percentile_for_month = grouped_data_based_on_percentiles[(grouped_data_based_on_percentiles["facility"] == facility) & (grouped_data_based_on_percentiles["month"] == month)][ + "weather_data"] + X_data = X_df[(X_df["month"] == month) & (X_df["facility"] == facility)] + for value in X_data["weather_data"]: + above_80_percentile.append(1 if value > percentile_for_month.values[0] else 0) + + +# Add the binary variable to the predictors +X = pd.DataFrame({ + 'weather_data': weather_data, + 'year': year_flattened, + 'month': month_flattened, + 'facility': facility_flattened, + 'precip_above_average': above_below_average, + 'above_80_percentile': above_80_percentile +}) +# One-hot encode the 'facility' column for a fixed effect +facility_encoded = pd.get_dummies(X['facility']) + +X = np.column_stack((X[['weather_data', 'year', 'month', 'precip_above_average', 'above_80_percentile']], facility_encoded)) +y = monthly_reporting_by_facility.values.flatten() + +print(len(y)) +model = sm.OLS(y,X) +results = model.fit() + +print(results.summary()) + + From 25be63198b8f22d003a7c545c7a32219af9a0dba Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 15 Oct 2024 09:18:14 +0100 Subject: [PATCH 050/291] Retrieval script for daily (sampled hourly) analysis data. Returns maximum daily rainfall --- .../data_retrieval_ERA5_reanalysis_daily.py | 44 +++++++++++++++++++ 1 file changed, 44 insertions(+) create mode 100644 src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py diff --git a/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py b/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py new file mode 100644 index 0000000000..369f4936b4 --- /dev/null +++ b/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py @@ -0,0 +1,44 @@ +import os + +import cdsapi + +base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical" +os.chdir(base_dir) +dataset = "derived-era5-single-levels-daily-statistics" +request = { + "product_type": ["monthly_averaged_reanalysis"], + "variable": ["total_precipitation"], + "year": [ + "2011", "2012", "2013", + "2014", "2015", "2016", + "2017", "2018", "2019", + "2020", "2021", "2022", + "2023", "2024" + ], + "month": [ + "01", "02", "03", + "04", "05", "06", + "07", "08", "09", + "10", "11", "12" + ], + "day": [ + "01", "02", "03", + "04", "05", "06", + "07", "08", "09", + "10", "11", "12", + "13", "14", "15", + "16", "17", "18", + "19", "20", "21", + "22", "23", "24", + "25", "26", "27", + "28", "29", "30", + "31" + ], + "daily_statistic": "daily_maximum", + "time_zone": "utc+00:00", + "frequency": "1_hourly", + "area": [-9.36366167, 32.67161823, -17.12627881, 35.91841716] +} + +client = cdsapi.Client() +client.retrieve(dataset, request).download() From e74ff7c79df952d8fdb9a73faf4b37f0a8317b94 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 15 Oct 2024 09:23:01 +0100 Subject: [PATCH 051/291] Request was too large must loop over years --- .../data_retrieval_ERA5_reanalysis_daily.py | 80 ++++++++++--------- 1 file changed, 41 insertions(+), 39 deletions(-) diff --git a/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py b/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py index 369f4936b4..1914f5bbac 100644 --- a/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py +++ b/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py @@ -1,44 +1,46 @@ import os import cdsapi - +years = ["2011", "2012", "2013", "2014", "2015", "2016", "2017", "2018", "2019", "2020", "2021", + "2022", "2023", "2024"] base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical" -os.chdir(base_dir) -dataset = "derived-era5-single-levels-daily-statistics" -request = { - "product_type": ["monthly_averaged_reanalysis"], - "variable": ["total_precipitation"], - "year": [ - "2011", "2012", "2013", - "2014", "2015", "2016", - "2017", "2018", "2019", - "2020", "2021", "2022", - "2023", "2024" - ], - "month": [ - "01", "02", "03", - "04", "05", "06", - "07", "08", "09", - "10", "11", "12" - ], - "day": [ - "01", "02", "03", - "04", "05", "06", - "07", "08", "09", - "10", "11", "12", - "13", "14", "15", - "16", "17", "18", - "19", "20", "21", - "22", "23", "24", - "25", "26", "27", - "28", "29", "30", - "31" - ], - "daily_statistic": "daily_maximum", - "time_zone": "utc+00:00", - "frequency": "1_hourly", - "area": [-9.36366167, 32.67161823, -17.12627881, 35.91841716] -} -client = cdsapi.Client() -client.retrieve(dataset, request).download() +for year in years: + year_dir = os.path.join(base_dir, year) + if not os.path.exists(year_dir): + os.makedirs(year_dir) + os.chdir(year_dir) + dataset = "derived-era5-single-levels-daily-statistics" + request = { + "product_type": ["monthly_averaged_reanalysis"], + "variable": ["total_precipitation"], + "year": [ + "2024" + ], + "month": [ + "01", "02", "03", + "04", "05", "06", + "07", "08", "09", + "10", "11", "12" + ], + "day": [ + "01", "02", "03", + "04", "05", "06", + "07", "08", "09", + "10", "11", "12", + "13", "14", "15", + "16", "17", "18", + "19", "20", "21", + "22", "23", "24", + "25", "26", "27", + "28", "29", "30", + "31" + ], + "daily_statistic": "daily_maximum", + "time_zone": "utc+00:00", + "frequency": "1_hourly", + "area": [-9.36366167, 32.67161823, -17.12627881, 35.91841716] + } + + client = cdsapi.Client() + client.retrieve(dataset, request).download() From 5e37b42659217e6262b63c5e072919f566be5cf3 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 15 Oct 2024 10:05:56 +0100 Subject: [PATCH 052/291] Couldn't access the newest dataset (https://cds.climate.copernicus.eu/datasets/derived-era5-single-levels-daily-statistics?tab=download), which is daily aggregated, so updated to "just" get the hourly data which I will then aggregate myself whilst waiting. --- .../data_retrieval_ERA5_reanalysis_daily.py | 23 ++++++++++++------- 1 file changed, 15 insertions(+), 8 deletions(-) diff --git a/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py b/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py index 1914f5bbac..14ba11de30 100644 --- a/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py +++ b/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py @@ -10,13 +10,11 @@ if not os.path.exists(year_dir): os.makedirs(year_dir) os.chdir(year_dir) - dataset = "derived-era5-single-levels-daily-statistics" + dataset = "reanalysis-era5-single-levels" request = { - "product_type": ["monthly_averaged_reanalysis"], + "product_type": ["reanalysis"], "variable": ["total_precipitation"], - "year": [ - "2024" - ], + "year": year, "month": [ "01", "02", "03", "04", "05", "06", @@ -36,9 +34,18 @@ "28", "29", "30", "31" ], - "daily_statistic": "daily_maximum", - "time_zone": "utc+00:00", - "frequency": "1_hourly", + "time": [ + "00:00", "01:00", "02:00", + "03:00", "04:00", "05:00", + "06:00", "07:00", "08:00", + "09:00", "10:00", "11:00", + "12:00", "13:00", "14:00", + "15:00", "16:00", "17:00", + "18:00", "19:00", "20:00", + "21:00", "22:00", "23:00" + ], + "data_format": "netcdf", + "download_format": "zip", "area": [-9.36366167, 32.67161823, -17.12627881, 35.91841716] } From e51d31874e24a0fb365bbd934144d300e09f1086 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 15 Oct 2024 10:12:20 +0100 Subject: [PATCH 053/291] Whitespace --- src/scripts/climate_change/process_CMIP6_data.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/scripts/climate_change/process_CMIP6_data.py b/src/scripts/climate_change/process_CMIP6_data.py index a7cde9d813..496306366a 100644 --- a/src/scripts/climate_change/process_CMIP6_data.py +++ b/src/scripts/climate_change/process_CMIP6_data.py @@ -78,7 +78,7 @@ def extract_nc_files_from_unzipped_folders(directory): grid += 1 data_by_model_and_grid[models[model]] = grid_dictionary model += 1 - +print(data_by_model_and_grid) data_by_model_and_grid = pd.DataFrame.from_dict(data_by_model_and_grid) data_by_model_and_grid.to_csv(Path(scenario_directory)/"data_by_model_and_grid.csv") From 0273979886e76ca24a77567c11667f29e0ac25ab Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 15 Oct 2024 15:26:22 +0100 Subject: [PATCH 054/291] Updated fpr ssp2_4_5 --- src/scripts/climate_change/data_retrieval_CMIP.py | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/src/scripts/climate_change/data_retrieval_CMIP.py b/src/scripts/climate_change/data_retrieval_CMIP.py index ef219aa359..456297057c 100644 --- a/src/scripts/climate_change/data_retrieval_CMIP.py +++ b/src/scripts/climate_change/data_retrieval_CMIP.py @@ -2,16 +2,23 @@ import cdsapi -models = ["cams_csm1_0", "ipsl_cm6a_lr", "miroc6","miroc_es2l", "mri_esm2_0", "canesm5", "cnrm_esm2_1", "ec_earth3", "ec_earth3_veg_lr", "fgoals_g3", "gfdl_esm4", "ukesm1_0_ll"] +#models_ssp119 = ["cams_csm1_0", "ipsl_cm6a_lr", "miroc6","miroc_es2l", "mri_esm2_0", "canesm5", "cnrm_esm2_1", "ec_earth3", "ec_earth3_veg_lr", "fgoals_g3", "gfdl_esm4", "ukesm1_0_ll"] scenarios = ["ssp1_1_9","ssp1_2_6", "ssp4_3_4", "ssp5_3_4OS", "ssp2_4_5", "ssp4_6_0", "ssp3_7_0", "ssp5_8_5"] +scenarios = ["ssp2_4_5"] +models_ssp245 = ["access_cm2", "awi_cm_1_1_mr", "bcc_csm2_mr","cams_csm1_0", "cmcc_esm2", "hadgem3_gc31_ll", "iitm_esm", "inm_cm5_0", "ipsl_cm6a_lr", "kiost_esm", "miroc6", "miroc_es2l", + "mri_esm2_0", "noresm2_mm", "canesm5", "cesm2", "cmcc_cm2_sr5", "cnrm_cm6_1", "cnrm_esm2_1", "ec_earth3_cc", "ec_earth3_veg_lr", "fgoals_g3", + "gfdl_esm4", "inm_cm4_8", "kace_1_0_g", "mpi_esm1_2_lr", "nesm3", "noresm2_lm", "ukesm1_0_ll"] + + base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/" + os.chdir(base_dir) for scenario in scenarios: scenario_dir = os.path.join(base_dir, scenario) if not os.path.exists(scenario_dir): os.makedirs(scenario_dir) os.chdir(scenario_dir) - for model in models: + for model in models_ssp245: dataset = "projections-cmip6" request = { "temporal_resolution": "daily", From dfd6dbfb7dbb2e653034dded4df5c7d55158dd06 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 16 Oct 2024 08:49:08 +0100 Subject: [PATCH 055/291] changed back to the max daily precip (even though it is still not working) --- .../data_retrieval_ERA5_reanalysis_daily.py | 26 +++++++++++-------- 1 file changed, 15 insertions(+), 11 deletions(-) diff --git a/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py b/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py index 14ba11de30..1578f8fdf6 100644 --- a/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py +++ b/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py @@ -34,18 +34,22 @@ "28", "29", "30", "31" ], - "time": [ - "00:00", "01:00", "02:00", - "03:00", "04:00", "05:00", - "06:00", "07:00", "08:00", - "09:00", "10:00", "11:00", - "12:00", "13:00", "14:00", - "15:00", "16:00", "17:00", - "18:00", "19:00", "20:00", - "21:00", "22:00", "23:00" + "day": [ + "01", "02", "03", + "04", "05", "06", + "07", "08", "09", + "10", "11", "12", + "13", "14", "15", + "16", "17", "18", + "19", "20", "21", + "22", "23", "24", + "25", "26", "27", + "28", "29", "30", + "31" ], - "data_format": "netcdf", - "download_format": "zip", + "daily_statistic": "daily_maximum", + "time_zone": "utc+00:00", + "frequency": "1_hourly", "area": [-9.36366167, 32.67161823, -17.12627881, 35.91841716] } From 441af24d23743bdd03fc677721b33e819707f033 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 16 Oct 2024 08:55:15 +0100 Subject: [PATCH 056/291] removed double request for days updated directory --- .../data_retrieval_ERA5_reanalysis_daily.py | 15 +-------------- 1 file changed, 1 insertion(+), 14 deletions(-) diff --git a/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py b/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py index 1578f8fdf6..b0f79f2303 100644 --- a/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py +++ b/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py @@ -3,7 +3,7 @@ import cdsapi years = ["2011", "2012", "2013", "2014", "2015", "2016", "2017", "2018", "2019", "2020", "2021", "2022", "2023", "2024"] -base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical" +base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_maximum" for year in years: year_dir = os.path.join(base_dir, year) @@ -34,19 +34,6 @@ "28", "29", "30", "31" ], - "day": [ - "01", "02", "03", - "04", "05", "06", - "07", "08", "09", - "10", "11", "12", - "13", "14", "15", - "16", "17", "18", - "19", "20", "21", - "22", "23", "24", - "25", "26", "27", - "28", "29", "30", - "31" - ], "daily_statistic": "daily_maximum", "time_zone": "utc+00:00", "frequency": "1_hourly", From b86b88e5dc7efcf2104f78dc925a9e9efddbfbbf Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 16 Oct 2024 10:22:00 +0100 Subject: [PATCH 057/291] rename for specificity --- ...r_data.py => reporting_and_weather_data_central_facilities.py} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename src/scripts/climate_change/{reporting_and_weather_data.py => reporting_and_weather_data_central_facilities.py} (100%) diff --git a/src/scripts/climate_change/reporting_and_weather_data.py b/src/scripts/climate_change/reporting_and_weather_data_central_facilities.py similarity index 100% rename from src/scripts/climate_change/reporting_and_weather_data.py rename to src/scripts/climate_change/reporting_and_weather_data_central_facilities.py From c5267f334a24f18aa83daafed8b193e6324cc078 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 16 Oct 2024 11:15:37 +0100 Subject: [PATCH 058/291] New file that has finer-grid facilities. Have broad mapping to grids; need it to be more detailed. --- .../reporting_and_weather_data_by_DHO.py | 102 ++++++++++++++++++ 1 file changed, 102 insertions(+) create mode 100644 src/scripts/climate_change/reporting_and_weather_data_by_DHO.py diff --git a/src/scripts/climate_change/reporting_and_weather_data_by_DHO.py b/src/scripts/climate_change/reporting_and_weather_data_by_DHO.py new file mode 100644 index 0000000000..5599e2c8ad --- /dev/null +++ b/src/scripts/climate_change/reporting_and_weather_data_by_DHO.py @@ -0,0 +1,102 @@ +import os + +import geopandas as gpd +import pandas as pd +from netCDF4 import Dataset +from random import randint +# Data accessed from https://dhis2.health.gov.mw/dhis-web-data-visualizer/#/YiQK65skxjz +# Reporting rate is expected reporting vs actual reporting - for DHO ("by district") +reporting_data = pd.read_csv('/Users/rem76/Desktop/Climate_change_health/Data/Reporting_Rate/Reporting_Rate_by_District_DHO_2015_2024.csv') #January 2000 - January 2024 +# ANALYSIS DONE IN OCTOBER 2024 - so drop October, November, December 2024 +columns_to_drop = reporting_data.columns[reporting_data.columns.str.endswith(('October 2024', 'November 2024', 'December 2024'))] + +reporting_data = reporting_data.drop(columns=columns_to_drop) + +### But need to drop mental health, as that is only relevant for the Zomba Mental Hospital and otherwise brings down averages +# extract mental health data +mental_health_columns = reporting_data.columns[reporting_data.columns.str.startswith("Mental")].tolist() +reporting_data_no_mental = reporting_data.drop(mental_health_columns, axis = 1) +mental_health_data = reporting_data[[reporting_data.columns[1]] + mental_health_columns] +all_columns_no_mental_health = reporting_data_no_mental.columns + +### now aggregate over months +monthly_reporting_data_by_facility = {} +months = set(col.split(" - Reporting rate ")[1] for col in all_columns_no_mental_health if " - Reporting rate " in col) + +# put in order +months = [date.strip() for date in months] # extra spaces?? +dates = pd.to_datetime(months, format='%B %Y', errors='coerce') +months = dates.sort_values().strftime('%B %Y').tolist() +months = months[12*11:] # only want from 2011 on +for month in months: + columns_of_interest_all_metrics = [reporting_data_no_mental.columns[1]] + reporting_data_no_mental.columns[reporting_data_no_mental.columns.str.endswith(month)].tolist() + data_of_interest_by_month = reporting_data_no_mental[columns_of_interest_all_metrics] + numeric_data = data_of_interest_by_month.select_dtypes(include='number') + monthly_mean_by_facility = numeric_data.mean(axis=1) + monthly_reporting_data_by_facility[month] = monthly_mean_by_facility +monthly_reporting_by_DHO = pd.DataFrame(monthly_reporting_data_by_facility) +monthly_reporting_by_DHO["facility"] = reporting_data_no_mental["organisationunitname"].values +monthly_reporting_by_DHO["region"] = reporting_data_no_mental["organisationunitcode"].values + +# Weather data +directory = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical" # from 2011 on +malawi_grid = gpd.read_file("/Users/rem76/Desktop/Climate_change_health/Data/malawi_grid.shp") +# find indices of interest from the malawi file + +files = os.listdir(directory) +weather_by_grid = {} +for file in files: + if file.endswith('.nc'): + file_path = os.path.join(directory, file) + # Open the NetCDF file - unsure of name, should only be one though + weather_monthly_all_grids = Dataset(file_path, mode='r') + +# the historical data is at a different resolution to the projections. so try and find the closest possible indicses +# to create a new grid for the historical data +pr_data = weather_monthly_all_grids.variables['tp'][:] # total precipitation in kg m-2 s-1 = mm s-1 x 86400 to get to day +lat_data = weather_monthly_all_grids.variables['latitude'][:] +long_data = weather_monthly_all_grids.variables['longitude'][:] +grid = 0 + +regridded_weather_data = {} +for polygon in malawi_grid["geometry"]: + minx, miny, maxx, maxy = polygon.bounds + index_for_x_min = ((long_data - minx)**2).argmin() + index_for_y_min = ((lat_data - miny)**2).argmin() + index_for_x_max = ((long_data - maxx)**2).argmin() + index_for_y_max = ((lat_data - maxy)**2).argmin() + + precip_data_for_grid = pr_data[:, index_for_y_min,index_for_x_min] # across all time points + precip_data_for_grid = precip_data_for_grid * 86400 # to get from per second to per day + weather_by_grid[grid] = precip_data_for_grid + grid += 1 +# Load mapped facilities and find relevant shap file - Malawi grid goes from SE -> NE -> SW -> NW +weather_data_by_region = {} +for reporting_facility in range(len(monthly_reporting_by_DHO)): + facility_data = monthly_reporting_by_DHO.loc[reporting_facility] + region = facility_data["region"] + + if region in ["Central East Zone", "Central West Zone"]: + grid = malawi_grid.iloc[2] + + elif region == "North Zone": + grid_to_choose = randint(3,6) + grid = malawi_grid.iloc[grid_to_choose] + + elif region == "South East Zone": + grid_to_choose = randint(7,9) + grid = malawi_grid.iloc[grid_to_choose] + + elif region == "South West Zone": + grid = malawi_grid.iloc[0] + + weather_data_by_region[facility_data["facility"]] = grid + +### Get data ready for linear regression between reporting and weather data +weather_df = pd.DataFrame.from_dict(weather_data_by_region, orient='index').T +weather_df.columns = monthly_reporting_by_DHO["facility"] +monthly_reporting_by_DHO = monthly_reporting_by_DHO.set_index('facility').T + +### Save CSVs +monthly_reporting_by_DHO.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_DHO_lm.csv") +weather_df.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_DHO_lm.csv") From ed47a96e0fec44802a25a4cc3b2d6c31ada2c0a8 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 16 Oct 2024 11:58:05 +0100 Subject: [PATCH 059/291] Edited to correspond directly to the malawi grid --- .../reporting_and_weather_data_by_DHO.py | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) diff --git a/src/scripts/climate_change/reporting_and_weather_data_by_DHO.py b/src/scripts/climate_change/reporting_and_weather_data_by_DHO.py index 5599e2c8ad..02d07e1f20 100644 --- a/src/scripts/climate_change/reporting_and_weather_data_by_DHO.py +++ b/src/scripts/climate_change/reporting_and_weather_data_by_DHO.py @@ -77,20 +77,18 @@ region = facility_data["region"] if region in ["Central East Zone", "Central West Zone"]: - grid = malawi_grid.iloc[2] + grid = 2 # correspond directly to the grids in malawi_grid elif region == "North Zone": - grid_to_choose = randint(3,6) - grid = malawi_grid.iloc[grid_to_choose] + grid = randint(3,6) elif region == "South East Zone": - grid_to_choose = randint(7,9) - grid = malawi_grid.iloc[grid_to_choose] + grid = randint(7,9) elif region == "South West Zone": - grid = malawi_grid.iloc[0] + grid = 0 - weather_data_by_region[facility_data["facility"]] = grid + weather_data_by_region[facility_data["facility"]] = weather_by_grid[grid] ### Get data ready for linear regression between reporting and weather data weather_df = pd.DataFrame.from_dict(weather_data_by_region, orient='index').T From ae81b8ab2b6e3426ab79951075c389dce6f39345 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 16 Oct 2024 12:05:34 +0100 Subject: [PATCH 060/291] removed accidental filtering of data --- src/scripts/climate_change/reporting_and_weather_data_by_DHO.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/scripts/climate_change/reporting_and_weather_data_by_DHO.py b/src/scripts/climate_change/reporting_and_weather_data_by_DHO.py index 02d07e1f20..5081d1c2fb 100644 --- a/src/scripts/climate_change/reporting_and_weather_data_by_DHO.py +++ b/src/scripts/climate_change/reporting_and_weather_data_by_DHO.py @@ -11,7 +11,6 @@ columns_to_drop = reporting_data.columns[reporting_data.columns.str.endswith(('October 2024', 'November 2024', 'December 2024'))] reporting_data = reporting_data.drop(columns=columns_to_drop) - ### But need to drop mental health, as that is only relevant for the Zomba Mental Hospital and otherwise brings down averages # extract mental health data mental_health_columns = reporting_data.columns[reporting_data.columns.str.startswith("Mental")].tolist() @@ -27,7 +26,6 @@ months = [date.strip() for date in months] # extra spaces?? dates = pd.to_datetime(months, format='%B %Y', errors='coerce') months = dates.sort_values().strftime('%B %Y').tolist() -months = months[12*11:] # only want from 2011 on for month in months: columns_of_interest_all_metrics = [reporting_data_no_mental.columns[1]] + reporting_data_no_mental.columns[reporting_data_no_mental.columns.str.endswith(month)].tolist() data_of_interest_by_month = reporting_data_no_mental[columns_of_interest_all_metrics] From 2c35964cd8b055ec7224172db255904c172b1c86 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 16 Oct 2024 12:30:11 +0100 Subject: [PATCH 061/291] Updated to include the 2011 data --- .../reporting_and_weather_data_by_DHO.py | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-) diff --git a/src/scripts/climate_change/reporting_and_weather_data_by_DHO.py b/src/scripts/climate_change/reporting_and_weather_data_by_DHO.py index 5081d1c2fb..0e2d17a1a7 100644 --- a/src/scripts/climate_change/reporting_and_weather_data_by_DHO.py +++ b/src/scripts/climate_change/reporting_and_weather_data_by_DHO.py @@ -6,7 +6,7 @@ from random import randint # Data accessed from https://dhis2.health.gov.mw/dhis-web-data-visualizer/#/YiQK65skxjz # Reporting rate is expected reporting vs actual reporting - for DHO ("by district") -reporting_data = pd.read_csv('/Users/rem76/Desktop/Climate_change_health/Data/Reporting_Rate/Reporting_Rate_by_District_DHO_2015_2024.csv') #January 2000 - January 2024 +reporting_data = pd.read_csv('/Users/rem76/Desktop/Climate_change_health/Data/Reporting_Rate/Reporting_Rate_by_District_DHO_2011_2024.csv') #January 2000 - January 2024 # ANALYSIS DONE IN OCTOBER 2024 - so drop October, November, December 2024 columns_to_drop = reporting_data.columns[reporting_data.columns.str.endswith(('October 2024', 'November 2024', 'December 2024'))] @@ -73,20 +73,18 @@ for reporting_facility in range(len(monthly_reporting_by_DHO)): facility_data = monthly_reporting_by_DHO.loc[reporting_facility] region = facility_data["region"] - if region in ["Central East Zone", "Central West Zone"]: - grid = 2 # correspond directly to the grids in malawi_grid + grid_to_match = 2 # correspond directly to the grids in malawi_grid elif region == "North Zone": - grid = randint(3,6) + grid_to_match = randint(3,6) elif region == "South East Zone": - grid = randint(7,9) + grid_to_match = randint(7,9) elif region == "South West Zone": - grid = 0 - - weather_data_by_region[facility_data["facility"]] = weather_by_grid[grid] + grid_to_match = 0 + weather_data_by_region[facility_data["facility"]] = weather_by_grid[grid_to_match] ### Get data ready for linear regression between reporting and weather data weather_df = pd.DataFrame.from_dict(weather_data_by_region, orient='index').T From 7ca170ffec3839a7f969e6468fd7678b48a20da0 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 16 Oct 2024 12:38:46 +0100 Subject: [PATCH 062/291] Tidied --- .../climate_change/reporting_and_weather_data_by_DHO.py | 3 ++- .../reporting_and_weather_data_central_facilities.py | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/src/scripts/climate_change/reporting_and_weather_data_by_DHO.py b/src/scripts/climate_change/reporting_and_weather_data_by_DHO.py index 0e2d17a1a7..e4910f2c59 100644 --- a/src/scripts/climate_change/reporting_and_weather_data_by_DHO.py +++ b/src/scripts/climate_change/reporting_and_weather_data_by_DHO.py @@ -70,7 +70,7 @@ grid += 1 # Load mapped facilities and find relevant shap file - Malawi grid goes from SE -> NE -> SW -> NW weather_data_by_region = {} -for reporting_facility in range(len(monthly_reporting_by_DHO)): +for reporting_facility in monthly_reporting_by_DHO: facility_data = monthly_reporting_by_DHO.loc[reporting_facility] region = facility_data["region"] if region in ["Central East Zone", "Central West Zone"]: @@ -86,6 +86,7 @@ grid_to_match = 0 weather_data_by_region[facility_data["facility"]] = weather_by_grid[grid_to_match] +print(len(weather_data_by_region)) ### Get data ready for linear regression between reporting and weather data weather_df = pd.DataFrame.from_dict(weather_data_by_region, orient='index').T weather_df.columns = monthly_reporting_by_DHO["facility"] diff --git a/src/scripts/climate_change/reporting_and_weather_data_central_facilities.py b/src/scripts/climate_change/reporting_and_weather_data_central_facilities.py index 0fc0abe3c7..a8f237d0f2 100644 --- a/src/scripts/climate_change/reporting_and_weather_data_central_facilities.py +++ b/src/scripts/climate_change/reporting_and_weather_data_central_facilities.py @@ -88,7 +88,7 @@ weather_data_by_facility[reporting_facility] = weather_by_grid[grid] - +print(len(weather_data_by_facility)) ### Get data ready for linear regression between reporting and weather data weather_df = pd.DataFrame.from_dict(weather_data_by_facility, orient='index').T weather_df.columns = monthly_reporting_by_facility["facility"] From 1ce484ffc81fb920641c42ea7d4ac6094b3a3f8f Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 16 Oct 2024 12:39:10 +0100 Subject: [PATCH 063/291] Added new data for finer grain on facilities --- ...al_realtionship_reporting_precipitation.py | 44 +++++++++++-------- 1 file changed, 25 insertions(+), 19 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index cfdddc5bc2..9d613bf4cc 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -5,22 +5,27 @@ from sklearn.metrics import r2_score import statsmodels.api as sm -# data is from 2011 - 2024 -monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_facility_lm.csv", index_col=0) -weather_data_historical = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_facility_lm.csv", index_col=0) -# +# # data is from 2011 - 2024 - for facility +# monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_facility_lm.csv", index_col=0) +# weather_data_historical = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_facility_lm.csv", index_col=0) + +monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_DHO_lm.csv", index_col=0) +weather_data_historical = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_DHO_lm.csv", index_col=0) +print(len(monthly_reporting_by_facility)) +print(len(weather_data_historical)) +# weather data is from 2011 - but report # Plot each facility's reporting data against weather data plt.figure(figsize=(12, 6)) for facility in weather_data_historical.columns: - plt.plot(weather_data_historical.index, monthly_reporting_by_facility[facility], label=facility) + plt.plot(weather_data_historical.index, monthly_reporting_by_facility, label=facility) months = weather_data_historical.index year_labels = range(2011, 2025, 1) year_ticks = range(0, len(months), 12) plt.xticks(year_ticks, year_labels, rotation=90) -plt.xlabel('Weather Data') -plt.ylabel('Reporting') -plt.title('Reporting vs. Weather Data by Facility') +plt.xlabel('Year') +plt.ylabel('Reporting %') +plt.title('Reporting by Facility') plt.legend(title='Facilities', bbox_to_anchor=(1.05, 1), loc='upper left') plt.grid() plt.tight_layout() @@ -29,23 +34,20 @@ ## Drop Mental Hospital - bad reporting generally weather_data_historical = weather_data_historical.drop("Zomba Mental Hospital", axis=1) monthly_reporting_by_facility = monthly_reporting_by_facility.drop("Zomba Mental Hospital", axis=1) -## Drop Queen Elizabeth - bad reporting generally, also have one represented for Lilongwe -weather_data_historical = weather_data_historical.drop("Queen Elizabeth Central Hospital", axis=1) -monthly_reporting_by_facility = monthly_reporting_by_facility.drop("Queen Elizabeth Central Hospital", axis=1) +## Drop MOH MALAWI Govt +weather_data_historical = weather_data_historical.drop("MOH MALAWI Govt", axis=1) +monthly_reporting_by_facility = monthly_reporting_by_facility.drop("MOH MALAWI Govt", axis=1) ## Drop September 2024 weather_data_historical = weather_data_historical.drop(weather_data_historical.index[-1]) monthly_reporting_by_facility = monthly_reporting_by_facility.drop(monthly_reporting_by_facility.index[-1]) -## Drop before 2016? 12*6 -weather_data_historical = weather_data_historical.drop(weather_data_historical.index[0:72]).reset_index(drop=True) -monthly_reporting_by_facility = monthly_reporting_by_facility.drop(monthly_reporting_by_facility.index[0:72]).reset_index(drop=True) # Plot each facility's reporting data against weather data plt.figure(figsize=(12, 6)) for facility in weather_data_historical.columns: - plt.plot(weather_data_historical.index, monthly_reporting_by_facility[facility], label=facility) + plt.plot(weather_data_historical.index, monthly_reporting_by_facility, label=facility) months = weather_data_historical.index -year_labels = range(2017, 2025, 1) +year_labels = range(2011, 2025, 1) year_ticks = range(0, len(months), 12) plt.xticks(year_ticks, year_labels, rotation=90) plt.xlabel('Weather Data') @@ -60,14 +62,14 @@ ## Linear regression - flattened # year -year = range(2016, 2024, 1) # year as a fixed effect +year = range(2011, 2025, 1) # year as a fixed effect year_repeated = [y for y in year for _ in range(12)] year = year_repeated[:-4] year_flattened = year*len(weather_data_historical.columns) # to get flattened data # month month = range(12) -month_repeated = [m for m in month for _ in range(2016, 2024, 1)] +month_repeated = [m for m in month for _ in range(2011, 2025, 1)] month = month_repeated[:-4] month_flattened = month*len(weather_data_historical.columns) @@ -77,6 +79,10 @@ # linear regression - flatten for more data points weather_data = weather_data_historical.values.flatten() y = monthly_reporting_by_facility.values.flatten() +print(len(weather_data)) +print(len(year_flattened)) +print(len(month_flattened)) +print(len(facility_flattened)) X = pd.DataFrame({ 'weather_data': weather_data, 'year': year_flattened, @@ -88,7 +94,7 @@ facility_encoded = pd.get_dummies(X['facility']) X = np.column_stack((X[['weather_data', 'year', 'month']], facility_encoded)) - +print(len(y)) model = sm.OLS(y,X) results = model.fit() From 618a1920534be58cba9899be939881d04ba1190c Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 16 Oct 2024 13:48:06 +0100 Subject: [PATCH 064/291] See nothing by DHO --- ...al_realtionship_reporting_precipitation.py | 73 ++++++++++--------- 1 file changed, 37 insertions(+), 36 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 9d613bf4cc..c7198daf78 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -11,25 +11,22 @@ monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_DHO_lm.csv", index_col=0) weather_data_historical = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_DHO_lm.csv", index_col=0) -print(len(monthly_reporting_by_facility)) -print(len(weather_data_historical)) -# weather data is from 2011 - but report + # Plot each facility's reporting data against weather data -plt.figure(figsize=(12, 6)) - -for facility in weather_data_historical.columns: - plt.plot(weather_data_historical.index, monthly_reporting_by_facility, label=facility) -months = weather_data_historical.index -year_labels = range(2011, 2025, 1) -year_ticks = range(0, len(months), 12) -plt.xticks(year_ticks, year_labels, rotation=90) -plt.xlabel('Year') -plt.ylabel('Reporting %') -plt.title('Reporting by Facility') -plt.legend(title='Facilities', bbox_to_anchor=(1.05, 1), loc='upper left') -plt.grid() -plt.tight_layout() -#plt.show() +# plt.figure(figsize=(12, 6)) +# for facility in weather_data_historical.columns: +# plt.plot(weather_data_historical.index, monthly_reporting_by_facility, label=facility) +# months = weather_data_historical.index +# year_labels = range(2011, 2025, 1) +# year_ticks = range(0, len(months), 12) +# plt.xticks(year_ticks, year_labels, rotation=90) +# plt.xlabel('Year') +# plt.ylabel('Reporting %') +# plt.title('Reporting by Facility') +# plt.legend(title='Facilities', bbox_to_anchor=(1.05, 1), loc='upper left') +# plt.grid() +# plt.tight_layout() +# #plt.show() ## Drop Mental Hospital - bad reporting generally weather_data_historical = weather_data_historical.drop("Zomba Mental Hospital", axis=1) @@ -41,35 +38,39 @@ weather_data_historical = weather_data_historical.drop(weather_data_historical.index[-1]) monthly_reporting_by_facility = monthly_reporting_by_facility.drop(monthly_reporting_by_facility.index[-1]) -# Plot each facility's reporting data against weather data -plt.figure(figsize=(12, 6)) +## Drop 2011-2019 9*12 +weather_data_historical = weather_data_historical.drop(weather_data_historical.index[0:108]).reset_index(drop=True) +monthly_reporting_by_facility = monthly_reporting_by_facility.drop(monthly_reporting_by_facility.index[0:108]).reset_index(drop=True) -for facility in weather_data_historical.columns: - plt.plot(weather_data_historical.index, monthly_reporting_by_facility, label=facility) -months = weather_data_historical.index -year_labels = range(2011, 2025, 1) -year_ticks = range(0, len(months), 12) -plt.xticks(year_ticks, year_labels, rotation=90) -plt.xlabel('Weather Data') -plt.ylabel('Reporting') -plt.title('Reporting vs. Weather Data by Facility') -plt.legend(title='Facilities', bbox_to_anchor=(1.05, 1), loc='upper left') -plt.grid() -plt.tight_layout() -#plt.show() +# Plot each facility's reporting data against weather data +# plt.figure(figsize=(12, 6)) +# +# for facility in weather_data_historical.columns: +# plt.plot(weather_data_historical.index, monthly_reporting_by_facility, label=facility) +# months = weather_data_historical.index +# year_labels = range(2015, 2025, 1) +# year_ticks = range(0, len(months), 12) +# plt.xticks(year_ticks, year_labels, rotation=90) +# plt.xlabel('Weather Data') +# plt.ylabel('Reporting') +# plt.title('Reporting vs. Weather Data by Facility') +# plt.legend(title='Facilities', bbox_to_anchor=(1.05, 1), loc='upper left') +# plt.grid() +# plt.tight_layout() +# #plt.show() ## Linear regression - flattened # year -year = range(2011, 2025, 1) # year as a fixed effect -year_repeated = [y for y in year for _ in range(12)] +year_range = range(2020, 2025, 1) # year as a fixed effect +year_repeated = [y for y in year_range for _ in range(12)] year = year_repeated[:-4] year_flattened = year*len(weather_data_historical.columns) # to get flattened data # month month = range(12) -month_repeated = [m for m in month for _ in range(2011, 2025, 1)] +month_repeated = [m for m in month for _ in year_range] month = month_repeated[:-4] month_flattened = month*len(weather_data_historical.columns) From a62075dee23c9b946cdcc5d2a6b1868a32bbca24 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 16 Oct 2024 16:18:12 +0100 Subject: [PATCH 065/291] added district level, but dropped central hospitals --- ...al_realtionship_reporting_precipitation.py | 168 +++++++----------- 1 file changed, 68 insertions(+), 100 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index c7198daf78..f21023f4da 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -34,13 +34,24 @@ ## Drop MOH MALAWI Govt weather_data_historical = weather_data_historical.drop("MOH MALAWI Govt", axis=1) monthly_reporting_by_facility = monthly_reporting_by_facility.drop("MOH MALAWI Govt", axis=1) +## Looking at district level - drop central hospitals, as they do not report everything +weather_data_historical = weather_data_historical.drop("Central Hospital", axis=1) +monthly_reporting_by_facility = monthly_reporting_by_facility.drop("Central Hospital", axis=1) +weather_data_historical = weather_data_historical.drop("Kamuzu Central Hospital", axis=1) +monthly_reporting_by_facility = monthly_reporting_by_facility.drop("Kamuzu Central Hospital", axis=1) +weather_data_historical = weather_data_historical.drop("Mzuzu Central Hospital", axis=1) +monthly_reporting_by_facility = monthly_reporting_by_facility.drop("Mzuzu Central Hospital", axis=1) +weather_data_historical = weather_data_historical.drop("Queen Elizabeth Central Hospital", axis=1) +monthly_reporting_by_facility = monthly_reporting_by_facility.drop("Queen Elizabeth Central Hospital", axis=1) +weather_data_historical = weather_data_historical.drop("Zomba Central Hospital", axis=1) +monthly_reporting_by_facility = monthly_reporting_by_facility.drop("Zomba Central Hospital", axis=1) ## Drop September 2024 weather_data_historical = weather_data_historical.drop(weather_data_historical.index[-1]) monthly_reporting_by_facility = monthly_reporting_by_facility.drop(monthly_reporting_by_facility.index[-1]) -## Drop 2011-2019 9*12 -weather_data_historical = weather_data_historical.drop(weather_data_historical.index[0:108]).reset_index(drop=True) -monthly_reporting_by_facility = monthly_reporting_by_facility.drop(monthly_reporting_by_facility.index[0:108]).reset_index(drop=True) +## Drop 2011-2017 7*12 +weather_data_historical = weather_data_historical.drop(weather_data_historical.index[0:84]).reset_index(drop=True) +monthly_reporting_by_facility = monthly_reporting_by_facility.drop(monthly_reporting_by_facility.index[0:84]).reset_index(drop=True) # Plot each facility's reporting data against weather data # plt.figure(figsize=(12, 6)) @@ -63,7 +74,7 @@ ## Linear regression - flattened # year -year_range = range(2020, 2025, 1) # year as a fixed effect +year_range = range(2018, 2025, 1) # year as a fixed effect year_repeated = [y for y in year_range for _ in range(12)] year = year_repeated[:-4] year_flattened = year*len(weather_data_historical.columns) # to get flattened data @@ -100,100 +111,57 @@ results = model.fit() print(results.summary()) - -# # ## Linear regression - by facility -results_list = [] # -for facility in monthly_reporting_by_facility.columns: - y = monthly_reporting_by_facility[facility].values - weather = weather_data_historical[facility].values - X = np.column_stack((weather, year, month)) - - model = sm.OLS(y, X) - results = model.fit() - - #print(results.summary()) - - -## Binary above/below average for that month -X_df = pd.DataFrame({ - 'weather_data': weather_data, - 'year': year_flattened, - 'month': month_flattened, - 'facility': facility_flattened -}) - -grouped_data = X_df.groupby(['facility', 'month'])['weather_data'].mean().reset_index() -above_below_average = [] -for facility in range(len(monthly_reporting_by_facility.columns)): - for month in range(12): - average_for_month = grouped_data[(grouped_data["facility"] == facility) & (grouped_data["month"] == month)][ - "weather_data"] - X_data = X_df[(X_df["month"] == month) & (X_df["facility"] == facility)] - for value in X_data["weather_data"]: - above_below_average.append(1 if value > average_for_month.values[0] else 0) - - -# Add the binary variable to the predictors -X = pd.DataFrame({ - 'weather_data': weather_data, - 'year': year_flattened, - 'month': month_flattened, - 'facility': facility_flattened, - 'precip_above_average': above_below_average -}) -# One-hot encode the 'facility' column for a fixed effect -facility_encoded = pd.get_dummies(X['facility']) - -X = np.column_stack((X[['weather_data', 'year', 'month', 'precip_above_average']], facility_encoded)) -y = monthly_reporting_by_facility.values.flatten() - -print(len(y)) -model = sm.OLS(y,X) -results = model.fit() - -print(results.summary()) - - -### Top 80 percentile? -X_df = pd.DataFrame({ - 'weather_data': weather_data, - 'year': year_flattened, - 'month': month_flattened, - 'facility': facility_flattened -}) - -grouped_data_based_on_percentiles = X_df.groupby(['facility', 'month'])['weather_data'].quantile(0.8).reset_index() - -above_80_percentile = [] -for facility in range(len(monthly_reporting_by_facility.columns)): - for month in range(12): - percentile_for_month = grouped_data_based_on_percentiles[(grouped_data_based_on_percentiles["facility"] == facility) & (grouped_data_based_on_percentiles["month"] == month)][ - "weather_data"] - X_data = X_df[(X_df["month"] == month) & (X_df["facility"] == facility)] - for value in X_data["weather_data"]: - above_80_percentile.append(1 if value > percentile_for_month.values[0] else 0) - - -# Add the binary variable to the predictors -X = pd.DataFrame({ - 'weather_data': weather_data, - 'year': year_flattened, - 'month': month_flattened, - 'facility': facility_flattened, - 'precip_above_average': above_below_average, - 'above_80_percentile': above_80_percentile -}) -# One-hot encode the 'facility' column for a fixed effect -facility_encoded = pd.get_dummies(X['facility']) - -X = np.column_stack((X[['weather_data', 'year', 'month', 'precip_above_average', 'above_80_percentile']], facility_encoded)) -y = monthly_reporting_by_facility.values.flatten() - -print(len(y)) -model = sm.OLS(y,X) -results = model.fit() - -print(results.summary()) - - +# # # ## Linear regression - by facility +# results_list = [] +# # +# for facility in monthly_reporting_by_facility.columns: +# y = monthly_reporting_by_facility[facility].values +# weather = weather_data_historical[facility].values +# X = np.column_stack((weather, year, month)) +# +# model = sm.OLS(y, X) +# results = model.fit() +# +# #print(results.summary()) +# +# +# ## Binary above/below average for that month +# X_df = pd.DataFrame({ +# 'weather_data': weather_data, +# 'year': year_flattened, +# 'month': month_flattened, +# 'facility': facility_flattened +# }) +# +# grouped_data = X_df.groupby(['facility', 'month'])['weather_data'].mean().reset_index() +# above_below_average = [] +# for facility in range(len(monthly_reporting_by_facility.columns)): +# for month in range(12): +# average_for_month = grouped_data[(grouped_data["facility"] == facility) & (grouped_data["month"] == month)][ +# "weather_data"] +# X_data = X_df[(X_df["month"] == month) & (X_df["facility"] == facility)] +# for value in X_data["weather_data"]: +# above_below_average.append(1 if value > average_for_month.values[0] else 0) +# +# +# # Add the binary variable to the predictors +# X = pd.DataFrame({ +# 'weather_data': weather_data, +# 'year': year_flattened, +# 'month': month_flattened, +# 'facility': facility_flattened, +# 'precip_above_average': above_below_average +# }) +# # One-hot encode the 'facility' column for a fixed effect +# facility_encoded = pd.get_dummies(X['facility']) +# +# X = np.column_stack((X[['weather_data', 'year', 'month', 'precip_above_average']], facility_encoded)) +# y = monthly_reporting_by_facility.values.flatten() +# +# print(len(y)) +# model = sm.OLS(y,X) +# results = model.fit() +# +# print(results.summary()) +# From 2c9c4399ff126c6d0dfa841b0c5d7642a63bafcb Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 16 Oct 2024 16:19:16 +0100 Subject: [PATCH 066/291] ssp245 --- src/scripts/climate_change/data_retrieval_CMIP.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/scripts/climate_change/data_retrieval_CMIP.py b/src/scripts/climate_change/data_retrieval_CMIP.py index 456297057c..c4957d4416 100644 --- a/src/scripts/climate_change/data_retrieval_CMIP.py +++ b/src/scripts/climate_change/data_retrieval_CMIP.py @@ -4,12 +4,10 @@ #models_ssp119 = ["cams_csm1_0", "ipsl_cm6a_lr", "miroc6","miroc_es2l", "mri_esm2_0", "canesm5", "cnrm_esm2_1", "ec_earth3", "ec_earth3_veg_lr", "fgoals_g3", "gfdl_esm4", "ukesm1_0_ll"] scenarios = ["ssp1_1_9","ssp1_2_6", "ssp4_3_4", "ssp5_3_4OS", "ssp2_4_5", "ssp4_6_0", "ssp3_7_0", "ssp5_8_5"] -scenarios = ["ssp2_4_5"] models_ssp245 = ["access_cm2", "awi_cm_1_1_mr", "bcc_csm2_mr","cams_csm1_0", "cmcc_esm2", "hadgem3_gc31_ll", "iitm_esm", "inm_cm5_0", "ipsl_cm6a_lr", "kiost_esm", "miroc6", "miroc_es2l", "mri_esm2_0", "noresm2_mm", "canesm5", "cesm2", "cmcc_cm2_sr5", "cnrm_cm6_1", "cnrm_esm2_1", "ec_earth3_cc", "ec_earth3_veg_lr", "fgoals_g3", "gfdl_esm4", "inm_cm4_8", "kace_1_0_g", "mpi_esm1_2_lr", "nesm3", "noresm2_lm", "ukesm1_0_ll"] - base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/" os.chdir(base_dir) From 3de67c7499fd59c653f5a41d481f041d9885bbf9 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 16 Oct 2024 16:40:18 +0100 Subject: [PATCH 067/291] Added accessing of historical grids --- src/scripts/climate_change/grid_malawi.py | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/src/scripts/climate_change/grid_malawi.py b/src/scripts/climate_change/grid_malawi.py index 646969ed4c..22b41495ab 100644 --- a/src/scripts/climate_change/grid_malawi.py +++ b/src/scripts/climate_change/grid_malawi.py @@ -6,12 +6,13 @@ from shapely.geometry import Polygon # Load netCDF data for gridding info -file_path = "/Users/rem76/Downloads/821bebfbcee0609d233c09e8b2bbc1f3/pr_Amon_UKESM1-0-LL_ssp119_r1i1p1f2_gn_20150116-20991216.nc" -dataset = Dataset(file_path, mode='r') -pr_data = dataset.variables['pr'][:] -time_data = dataset.variables['time'][:] -lat_data = dataset.variables['lat'][:] -long_data = dataset.variables['lon'][:] +#file_path = "/Users/rem76/Downloads/821bebfbcee0609d233c09e8b2bbc1f3/pr_Amon_UKESM1-0-LL_ssp119_r1i1p1f2_gn_20150116-20991216.nc" +file_path_historical_data = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/139ef85ab4df0a12fc01854395fc9a6d.nc" +dataset = Dataset(file_path_historical_data, mode='r') +print(dataset.variables.keys()) +pr_data = dataset.variables['tp'][:] # ['pr'][:] pr for projections, tp for historical +lat_data = dataset.variables['latitude'][:] #['lat'][:] +long_data = dataset.variables['longitude'][:] #['lon'][:] meshgrid_from_netCDF = np.meshgrid(long_data, lat_data) # Load Malawi shapefile @@ -42,7 +43,7 @@ grid_clipped_ADM1 = gpd.overlay(grid, malawi_admin1, how='intersection') # for graphing grid_clipped_ADM2 = gpd.overlay(grid, malawi_admin2, how='intersection') # for graphing cmap = plt.cm.get_cmap('tab20', len(grid_clipped_ADM1['ADM1_EN'].unique())) -grid.to_file("/Users/rem76/Desktop/Climate_change_health/Data/malawi_grid.shp") +grid.to_file("/Users/rem76/Desktop/Climate_change_health/Data/malawi_grid_0_025.shp") fig, ax = plt.subplots(figsize=(10, 10)) malawi_admin2.plot(ax=ax, edgecolor='black', color='white') @@ -92,9 +93,9 @@ # write csv file of facilities with districts -facilities_with_districts_shap_files_no_duplicates.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_districts.csv") +facilities_with_districts_shap_files_no_duplicates.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_districts_historical.csv") facilities_gdf = gpd.GeoDataFrame(facilities_with_districts_shap_files_no_duplicates, geometry='geometry', crs="EPSG:4326") -facilities_gdf.to_file("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_districts.shp") +facilities_gdf.to_file("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_districts_historical.shp") From 12eb3c0680a1d208df9944e9f54e6c4900e2b0ce Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 16 Oct 2024 18:51:34 +0100 Subject: [PATCH 068/291] Updated to use data from new file that has lat/long for each facility. From here can match to most central facilities (some e.g. Central Hospital still manually input) --- ...ing_and_weather_data_central_facilities.py | 43 +++++++++++++------ 1 file changed, 30 insertions(+), 13 deletions(-) diff --git a/src/scripts/climate_change/reporting_and_weather_data_central_facilities.py b/src/scripts/climate_change/reporting_and_weather_data_central_facilities.py index a8f237d0f2..cc0bfda098 100644 --- a/src/scripts/climate_change/reporting_and_weather_data_central_facilities.py +++ b/src/scripts/climate_change/reporting_and_weather_data_central_facilities.py @@ -3,6 +3,7 @@ import geopandas as gpd import pandas as pd from netCDF4 import Dataset +import difflib # Data accessed from https://dhis2.health.gov.mw/dhis-web-data-visualizer/#/YiQK65skxjz # Reporting rate is expected reporting vs actual reporting @@ -69,26 +70,42 @@ precip_data_for_grid = precip_data_for_grid * 86400 # to get from per second to per day weather_by_grid[grid] = precip_data_for_grid grid += 1 -# Load facilities file + + +############### NOW HAVE LAT/LONG OF FACILITIES ##################### general_facilities = gpd.read_file("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_districts.shp") -# find relavent shap file + +facilities_with_lat_long = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_lat_long_region.csv") + weather_data_by_facility = {} for reporting_facility in monthly_reporting_by_facility["facility"]: - if (reporting_facility == "Central Hospital") or reporting_facility == "Kamuzu Central Hospital": - # which malawi grid this is - grid = general_facilities[general_facilities["District"] == "Lilongwe City"]["Grid_Index"].iloc[0] # all labelled X City will be in the same grid - elif reporting_facility == "Mzuzu Central Hospital": - grid = general_facilities[general_facilities["District"] == "Mzuzu City"]["Grid_Index"].iloc[0] - elif reporting_facility == "Queen Elizabeth Central Hospital": - grid = general_facilities[general_facilities["District"] == "Blantyre City"]["Grid_Index"].iloc[0] - elif (reporting_facility == "Zomba Central Hospital") or (reporting_facility == "Zomba Mental Hospital"): - grid = general_facilities[general_facilities["District"] == "Zomba City"]["Grid_Index"].iloc[0] + print(reporting_facility) + matching_facility_name = difflib.get_close_matches(reporting_facility, facilities_with_lat_long['Fname'], n=3, cutoff=0.90) + print(matching_facility_name) + if matching_facility_name: + match_name = matching_facility_name[0] # Access the string directly + lat_for_facility = facilities_with_lat_long.loc[ + facilities_with_lat_long['Fname'] == match_name, "A109__Latitude"].squeeze() + long_for_facility = facilities_with_lat_long.loc[ + facilities_with_lat_long['Fname'] == match_name, "A109__Longitude"].squeeze() + index_for_x = ((long_data - lat_for_facility)**2).argmin() + index_for_y= ((lat_data - long_for_facility)**2).argmin() + + precip_data_for_facility = pr_data[:, index_for_y,index_for_x] # across all time points + precip_data_for_facility = precip_data_for_facility * 86400 # to get from per second to per day +## below are not in facilities file? elif reporting_facility == "Central East Zone": grid = general_facilities[general_facilities["District"] == "Nkhotakota"]["Grid_Index"].iloc[0] # furtherst east zone + precip_data_for_facility = weather_by_grid[grid] + elif (reporting_facility == "Central Hospital"): + # which malawi grid this is + grid = general_facilities[general_facilities["District"] == "Lilongwe City"]["Grid_Index"].iloc[0] # all labelled X City will be in the same grid + precip_data_for_facility = weather_by_grid[grid] + + weather_data_by_facility[reporting_facility] = precip_data_for_facility - weather_data_by_facility[reporting_facility] = weather_by_grid[grid] +print(weather_data_by_facility) -print(len(weather_data_by_facility)) ### Get data ready for linear regression between reporting and weather data weather_df = pd.DataFrame.from_dict(weather_data_by_facility, orient='index').T weather_df.columns = monthly_reporting_by_facility["facility"] From 46193b3ab32bec2fcab02c2861c5e07bd5fcaad0 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 16 Oct 2024 18:53:48 +0100 Subject: [PATCH 069/291] Back to central facilities (not more accurate) --- .../climate_change/reporting_and_weather_data_by_DHO.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/scripts/climate_change/reporting_and_weather_data_by_DHO.py b/src/scripts/climate_change/reporting_and_weather_data_by_DHO.py index e4910f2c59..471b9c3dd3 100644 --- a/src/scripts/climate_change/reporting_and_weather_data_by_DHO.py +++ b/src/scripts/climate_change/reporting_and_weather_data_by_DHO.py @@ -38,7 +38,7 @@ # Weather data directory = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical" # from 2011 on -malawi_grid = gpd.read_file("/Users/rem76/Desktop/Climate_change_health/Data/malawi_grid.shp") +malawi_grid = gpd.read_file("/Users/rem76/Desktop/Climate_change_health/Data/malawi_grid_0_025.shp") # find indices of interest from the malawi file files = os.listdir(directory) @@ -70,7 +70,7 @@ grid += 1 # Load mapped facilities and find relevant shap file - Malawi grid goes from SE -> NE -> SW -> NW weather_data_by_region = {} -for reporting_facility in monthly_reporting_by_DHO: +for reporting_facility in range(len(monthly_reporting_by_DHO)): facility_data = monthly_reporting_by_DHO.loc[reporting_facility] region = facility_data["region"] if region in ["Central East Zone", "Central West Zone"]: From aba7ece99f90c9fb65248dc431f6217e6686f054 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 17 Oct 2024 10:45:29 +0100 Subject: [PATCH 070/291] Added extra variables, e.g. if rain was above/below a certain threshold. No help --- ...al_realtionship_reporting_precipitation.py | 165 +++++++++++------- 1 file changed, 100 insertions(+), 65 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index f21023f4da..be882574c9 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -6,11 +6,11 @@ import statsmodels.api as sm # # data is from 2011 - 2024 - for facility -# monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_facility_lm.csv", index_col=0) -# weather_data_historical = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_facility_lm.csv", index_col=0) +monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_facility_lm.csv", index_col=0) +weather_data_historical = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_facility_lm.csv", index_col=0) -monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_DHO_lm.csv", index_col=0) -weather_data_historical = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_DHO_lm.csv", index_col=0) +# monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_DHO_lm.csv", index_col=0) +# weather_data_historical = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_DHO_lm.csv", index_col=0) # Plot each facility's reporting data against weather data # plt.figure(figsize=(12, 6)) @@ -31,20 +31,20 @@ ## Drop Mental Hospital - bad reporting generally weather_data_historical = weather_data_historical.drop("Zomba Mental Hospital", axis=1) monthly_reporting_by_facility = monthly_reporting_by_facility.drop("Zomba Mental Hospital", axis=1) -## Drop MOH MALAWI Govt -weather_data_historical = weather_data_historical.drop("MOH MALAWI Govt", axis=1) -monthly_reporting_by_facility = monthly_reporting_by_facility.drop("MOH MALAWI Govt", axis=1) -## Looking at district level - drop central hospitals, as they do not report everything -weather_data_historical = weather_data_historical.drop("Central Hospital", axis=1) -monthly_reporting_by_facility = monthly_reporting_by_facility.drop("Central Hospital", axis=1) -weather_data_historical = weather_data_historical.drop("Kamuzu Central Hospital", axis=1) -monthly_reporting_by_facility = monthly_reporting_by_facility.drop("Kamuzu Central Hospital", axis=1) -weather_data_historical = weather_data_historical.drop("Mzuzu Central Hospital", axis=1) -monthly_reporting_by_facility = monthly_reporting_by_facility.drop("Mzuzu Central Hospital", axis=1) -weather_data_historical = weather_data_historical.drop("Queen Elizabeth Central Hospital", axis=1) -monthly_reporting_by_facility = monthly_reporting_by_facility.drop("Queen Elizabeth Central Hospital", axis=1) -weather_data_historical = weather_data_historical.drop("Zomba Central Hospital", axis=1) -monthly_reporting_by_facility = monthly_reporting_by_facility.drop("Zomba Central Hospital", axis=1) +# ## Drop MOH MALAWI Govt +# weather_data_historical = weather_data_historical.drop("MOH MALAWI Govt", axis=1) +# monthly_reporting_by_facility = monthly_reporting_by_facility.drop("MOH MALAWI Govt", axis=1) +# ## Looking at district level - drop central hospitals, as they do not report everything +# weather_data_historical = weather_data_historical.drop("Central Hospital", axis=1) +# monthly_reporting_by_facility = monthly_reporting_by_facility.drop("Central Hospital", axis=1) +# weather_data_historical = weather_data_historical.drop("Kamuzu Central Hospital", axis=1) +# monthly_reporting_by_facility = monthly_reporting_by_facility.drop("Kamuzu Central Hospital", axis=1) +# weather_data_historical = weather_data_historical.drop("Mzuzu Central Hospital", axis=1) +# monthly_reporting_by_facility = monthly_reporting_by_facility.drop("Mzuzu Central Hospital", axis=1) +# weather_data_historical = weather_data_historical.drop("Queen Elizabeth Central Hospital", axis=1) +# monthly_reporting_by_facility = monthly_reporting_by_facility.drop("Queen Elizabeth Central Hospital", axis=1) +# weather_data_historical = weather_data_historical.drop("Zomba Central Hospital", axis=1) +# monthly_reporting_by_facility = monthly_reporting_by_facility.drop("Zomba Central Hospital", axis=1) ## Drop September 2024 weather_data_historical = weather_data_historical.drop(weather_data_historical.index[-1]) monthly_reporting_by_facility = monthly_reporting_by_facility.drop(monthly_reporting_by_facility.index[-1]) @@ -91,10 +91,7 @@ # linear regression - flatten for more data points weather_data = weather_data_historical.values.flatten() y = monthly_reporting_by_facility.values.flatten() -print(len(weather_data)) -print(len(year_flattened)) -print(len(month_flattened)) -print(len(facility_flattened)) + X = pd.DataFrame({ 'weather_data': weather_data, 'year': year_flattened, @@ -106,12 +103,11 @@ facility_encoded = pd.get_dummies(X['facility']) X = np.column_stack((X[['weather_data', 'year', 'month']], facility_encoded)) -print(len(y)) model = sm.OLS(y,X) results = model.fit() print(results.summary()) -# + # # # ## Linear regression - by facility # results_list = [] # # @@ -124,44 +120,83 @@ # results = model.fit() # # #print(results.summary()) -# -# -# ## Binary above/below average for that month -# X_df = pd.DataFrame({ -# 'weather_data': weather_data, -# 'year': year_flattened, -# 'month': month_flattened, -# 'facility': facility_flattened -# }) -# -# grouped_data = X_df.groupby(['facility', 'month'])['weather_data'].mean().reset_index() -# above_below_average = [] -# for facility in range(len(monthly_reporting_by_facility.columns)): -# for month in range(12): -# average_for_month = grouped_data[(grouped_data["facility"] == facility) & (grouped_data["month"] == month)][ -# "weather_data"] -# X_data = X_df[(X_df["month"] == month) & (X_df["facility"] == facility)] -# for value in X_data["weather_data"]: -# above_below_average.append(1 if value > average_for_month.values[0] else 0) -# -# -# # Add the binary variable to the predictors -# X = pd.DataFrame({ -# 'weather_data': weather_data, -# 'year': year_flattened, -# 'month': month_flattened, -# 'facility': facility_flattened, -# 'precip_above_average': above_below_average -# }) -# # One-hot encode the 'facility' column for a fixed effect -# facility_encoded = pd.get_dummies(X['facility']) -# -# X = np.column_stack((X[['weather_data', 'year', 'month', 'precip_above_average']], facility_encoded)) -# y = monthly_reporting_by_facility.values.flatten() -# -# print(len(y)) -# model = sm.OLS(y,X) -# results = model.fit() -# -# print(results.summary()) -# + + +## Binary above/below average for that month +X_df = pd.DataFrame({ + 'weather_data': weather_data, + 'year': year_flattened, + 'month': month_flattened, + 'facility': facility_flattened +}) + +grouped_data = X_df.groupby(['facility', 'month'])['weather_data'].mean().reset_index() +above_below_average = [] +for facility in range(len(monthly_reporting_by_facility.columns)): + for month in range(12): + average_for_month = grouped_data[(grouped_data["facility"] == facility) & (grouped_data["month"] == month)][ + "weather_data"] + X_data = X_df[(X_df["month"] == month) & (X_df["facility"] == facility)] + for value in X_data["weather_data"]: + above_below_average.append(1 if value > average_for_month.values[0] else 0) + + +# Add the binary variable to the predictors +X = pd.DataFrame({ + 'weather_data': weather_data, + 'year': year_flattened, + 'month': month_flattened, + 'facility': facility_flattened, + 'precip_above_average': above_below_average +}) +# One-hot encode the 'facility' column for a fixed effect +facility_encoded = pd.get_dummies(X['facility']) + +X = np.column_stack((X[['weather_data', 'year', 'month', 'precip_above_average']], facility_encoded)) +y = monthly_reporting_by_facility.values.flatten() + +model = sm.OLS(y,X) +results = model.fit() + +print(results.summary()) + + + + +## Binary above/below 300mm for that month (very heavy rain) +X_df = pd.DataFrame({ + 'weather_data': weather_data, + 'year': year_flattened, + 'month': month_flattened, + 'facility': facility_flattened +}) + +grouped_data = X_df.groupby(['facility', 'month'])['weather_data'].mean().reset_index() +above_below_700 = [] +for facility in range(len(monthly_reporting_by_facility.columns)): + for month in range(12): + X_data = X_df[(X_df["month"] == month) & (X_df["facility"] == facility)] + for value in X_data["weather_data"]: + + above_below_700.append(1 if value > 700 else 0) + + +# Add the binary variable to the predictors +X = pd.DataFrame({ + 'weather_data': weather_data, + 'year': year_flattened, + 'month': month_flattened, + 'facility': facility_flattened, + 'precip_above_300': above_below_700 +}) +# One-hot encode the 'facility' column for a fixed effect +facility_encoded = pd.get_dummies(X['facility']) + +X = np.column_stack((X[['weather_data', 'year', 'month', 'precip_above_300']], facility_encoded)) +y = monthly_reporting_by_facility.values.flatten() + +model = sm.OLS(y,X) +results = model.fit() + +print(results.summary()) + From cad17be6af903e66654b06e48e64a5c12fb691ef Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 17 Oct 2024 10:46:06 +0100 Subject: [PATCH 071/291] tidied --- src/scripts/climate_change/process_CMIP6_data.py | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/src/scripts/climate_change/process_CMIP6_data.py b/src/scripts/climate_change/process_CMIP6_data.py index 496306366a..e9229fbb0a 100644 --- a/src/scripts/climate_change/process_CMIP6_data.py +++ b/src/scripts/climate_change/process_CMIP6_data.py @@ -40,11 +40,11 @@ def extract_nc_files_from_unzipped_folders(directory): for filename in files: if filename.endswith('.nc'): source_file_path = os.path.join(root, filename) - # Copy the .nc file to the 'nc_files' directory shutil.copy2(source_file_path, output_directory) + # unzip files and extract the netCDF files base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/" @@ -57,13 +57,17 @@ def extract_nc_files_from_unzipped_folders(directory): # Put all into one csv file +base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/" +scenario = "ssp1_1_9" +scenario_directory = os.path.join(base_dir, scenario) +nc_file_directory = os.path.join(scenario_directory, 'nc_files') #### Multiple files -file_list = glob.glob(os.path.join(base_dir, "*.nc")) +file_list = glob.glob(os.path.join(nc_file_directory, "*.nc")) data_by_model_and_grid = {} models = ["cams_csm1_0", "ipsl_cm6a_lr", "miroc6","miroc_es2l", "mri_esm2_0", "canesm5", "cnrm_esm2_1", "ec_earth3", "ec_earth3_veg_lr", "fgoals_g3", "gfdl_esm4", "ukesm1_0_ll"] model = 0 -for file in glob.glob(os.path.join(base_dir, "*.nc")): +for file in file_list: data_per_model = Dataset(file, mode='r') pr_data = data_per_model.variables['pr'][:] # in kg m-2 s-1 = mm s-1 x 86400 to get to day lat_data = data_per_model.variables['lat'][:] @@ -72,14 +76,15 @@ def extract_nc_files_from_unzipped_folders(directory): grid = 0 for i in range(len(long_data)): for j in range(len(lat_data)): - precip_data_for_grid = pr_data[:,i,j] # across all time points + precip_data_for_grid = pr_data[:,j,i] # across all time points precip_data_for_grid = precip_data_for_grid * 86400 # to get from per second to per day grid_dictionary[grid] = precip_data_for_grid + grid += 1 data_by_model_and_grid[models[model]] = grid_dictionary model += 1 -print(data_by_model_and_grid) data_by_model_and_grid = pd.DataFrame.from_dict(data_by_model_and_grid) + data_by_model_and_grid.to_csv(Path(scenario_directory)/"data_by_model_and_grid.csv") From 89562b2bd013ed63d416b8d49e29e7ced34a8bb6 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 17 Oct 2024 10:46:36 +0100 Subject: [PATCH 072/291] First stab at aggregating across all of CMIP data. However, not everything is on same grid --- .../aggregate_processs_CMIP6_data.py | 36 +++++++++++++++++++ 1 file changed, 36 insertions(+) create mode 100644 src/scripts/climate_change/aggregate_processs_CMIP6_data.py diff --git a/src/scripts/climate_change/aggregate_processs_CMIP6_data.py b/src/scripts/climate_change/aggregate_processs_CMIP6_data.py new file mode 100644 index 0000000000..a0e3a54796 --- /dev/null +++ b/src/scripts/climate_change/aggregate_processs_CMIP6_data.py @@ -0,0 +1,36 @@ +# Put all into one csv file + +import glob +import os +import shutil +import zipfile +from pathlib import Path + +import pandas as pd +from netCDF4 import Dataset + +base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/" + +#### Multiple files +file_list = glob.glob(os.path.join(base_dir, "*.nc")) +data_by_model_and_grid = {} +models = ["cams_csm1_0", "ipsl_cm6a_lr", "miroc6","miroc_es2l", "mri_esm2_0", "canesm5", "cnrm_esm2_1", "ec_earth3", "ec_earth3_veg_lr", "fgoals_g3", "gfdl_esm4", "ukesm1_0_ll"] +model = 0 +for file in glob.glob(os.path.join(base_dir, "*.nc")): + data_per_model = Dataset(file, mode='r') + pr_data = data_per_model.variables['pr'][:] # in kg m-2 s-1 = mm s-1 x 86400 to get to day + lat_data = data_per_model.variables['lat'][:] + long_data = data_per_model.variables['lon'][:] + grid_dictionary = {} + grid = 0 + for i in range(len(long_data)): + for j in range(len(lat_data)): + precip_data_for_grid = pr_data[:,i,j] # across all time points + precip_data_for_grid = precip_data_for_grid * 86400 # to get from per second to per day + grid_dictionary[grid] = precip_data_for_grid + grid += 1 + data_by_model_and_grid[models[model]] = grid_dictionary + model += 1 +print(data_by_model_and_grid) +data_by_model_and_grid = pd.DataFrame.from_dict(data_by_model_and_grid) +data_by_model_and_grid.to_csv(Path(scenario_directory)/"data_by_model_and_grid.csv") From 2bdfe1563f6370707e73f4aad4dd536ec9490bb4 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 17 Oct 2024 13:21:50 +0100 Subject: [PATCH 073/291] File that collects data from "smaller" facilities (all District/Rural/Central hospitals, clinics, health centres). Includes extra filtering steps, as not all facilities actually report. Also collects extra info on the name of the zone, urban/rural, who runs it, etc --- ...rting_and_weather_data_small_facilities.py | 133 ++++++++++++++++++ 1 file changed, 133 insertions(+) create mode 100644 src/scripts/climate_change/reporting_and_weather_data_small_facilities.py diff --git a/src/scripts/climate_change/reporting_and_weather_data_small_facilities.py b/src/scripts/climate_change/reporting_and_weather_data_small_facilities.py new file mode 100644 index 0000000000..f681b04a94 --- /dev/null +++ b/src/scripts/climate_change/reporting_and_weather_data_small_facilities.py @@ -0,0 +1,133 @@ +import os + +import geopandas as gpd +import pandas as pd +from netCDF4 import Dataset +import difflib +import numpy as np + +# Data accessed from https://dhis2.health.gov.mw/dhis-web-data-visualizer/#/YiQK65skxjz +# Reporting rate is expected reporting vs actual reporting +reporting_data = pd.read_csv('/Users/rem76/Desktop/Climate_change_health/Data/Reporting_Rate/Reporting_Rate_by_smaller_facilities_2011_2024.csv') #January 2011 - January 2024 +# ANALYSIS DONE IN OCTOBER 2024 - so drop October, November, December 2024 +columns_to_drop = reporting_data.columns[reporting_data.columns.str.endswith(('October 2024', 'November 2024', 'December 2024'))] +reporting_data = reporting_data.drop(columns=columns_to_drop) +# drop NAs +reporting_data = reporting_data.dropna(subset = reporting_data.columns[3:], how='all') # drops 90 clinics + +### But need to drop mental health, as that is only relevant for the Zomba Mental Hospital and otherwise brings down averages +# extract mental health data +mental_health_columns = reporting_data.columns[reporting_data.columns.str.startswith("Mental")].tolist() +reporting_data_no_mental = reporting_data.drop(mental_health_columns, axis = 1) +mental_health_data = reporting_data[[reporting_data.columns[1]] + mental_health_columns] +all_columns_no_mental_health = reporting_data_no_mental.columns + +### now aggregate over months +monthly_reporting_data_by_facility = {} +months = set(col.split(" - Reporting rate ")[1] for col in all_columns_no_mental_health if " - Reporting rate " in col) + +# put in order +months = [date.strip() for date in months] # extra spaces?? +dates = pd.to_datetime(months, format='%B %Y', errors='coerce') +months = dates.sort_values().strftime('%B %Y').tolist() +for month in months: + columns_of_interest_all_metrics = [reporting_data_no_mental.columns[1]] + reporting_data_no_mental.columns[reporting_data_no_mental.columns.str.endswith(month)].tolist() + data_of_interest_by_month = reporting_data_no_mental[columns_of_interest_all_metrics] + numeric_data = data_of_interest_by_month.select_dtypes(include='number') + monthly_mean_by_facility = numeric_data.mean(axis=1) + monthly_reporting_data_by_facility[month] = monthly_mean_by_facility +monthly_reporting_by_facility = pd.DataFrame(monthly_reporting_data_by_facility) +monthly_reporting_by_facility["facility"] = reporting_data_no_mental["organisationunitname"].values + +# Weather data +directory = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical" # from 2011 on +malawi_grid = gpd.read_file("/Users/rem76/Desktop/Climate_change_health/Data/malawi_grid.shp") +# find indices of interest from the malawi file + +files = os.listdir(directory) +weather_by_grid = {} +for file in files: + if file.endswith('.nc'): + file_path = os.path.join(directory, file) + # Open the NetCDF file - unsure of name, should only be one though + weather_monthly_all_grids = Dataset(file_path, mode='r') + +# the historical data is at a different resolution to the projections. so try and find the closest possible indicses +# to create a new grid for the historical data +pr_data = weather_monthly_all_grids.variables['tp'][:] # total precipitation in kg m-2 s-1 = mm s-1 x 86400 to get to day +lat_data = weather_monthly_all_grids.variables['latitude'][:] +long_data = weather_monthly_all_grids.variables['longitude'][:] +grid = 0 + +regridded_weather_data = {} +for polygon in malawi_grid["geometry"]: + minx, miny, maxx, maxy = polygon.bounds + index_for_x_min = ((long_data - minx)**2).argmin() + index_for_y_min = ((lat_data - miny)**2).argmin() + index_for_x_max = ((long_data - maxx)**2).argmin() + index_for_y_max = ((lat_data - maxy)**2).argmin() + + precip_data_for_grid = pr_data[:, index_for_y_min,index_for_x_min] # across all time points + precip_data_for_grid = precip_data_for_grid * 86400 # to get from per second to per day + weather_by_grid[grid] = precip_data_for_grid + grid += 1 + + +############### NOW HAVE LAT/LONG OF FACILITIES ##################### +general_facilities = gpd.read_file("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_districts.shp") + +facilities_with_lat_long = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_lat_long_region.csv") + +weather_data_by_facility = {} +facilities_with_location = [] +for reporting_facility in monthly_reporting_by_facility["facility"]: + matching_facility_name = difflib.get_close_matches(reporting_facility, facilities_with_lat_long['Fname'], n=3, cutoff=0.90) + if matching_facility_name: + match_name = matching_facility_name[0] # Access the string directly + facilities_with_location.append(match_name) + lat_for_facility = facilities_with_lat_long.loc[ + facilities_with_lat_long['Fname'] == match_name, "A109__Latitude"].iloc[0] + long_for_facility = facilities_with_lat_long.loc[ + facilities_with_lat_long['Fname'] == match_name, "A109__Longitude"].iloc[0] + index_for_x = ((long_data - lat_for_facility)**2).argmin() + index_for_y= ((lat_data - long_for_facility)**2).argmin() + + precip_data_for_facility = pr_data[:, index_for_y,index_for_x] # across all time points + precip_data_for_facility = precip_data_for_facility * 86400 # to get from per second to per day +## below are not in facilities file? + elif reporting_facility == "Central East Zone": + grid = general_facilities[general_facilities["District"] == "Nkhotakota"]["Grid_Index"].iloc[0] # furtherst east zone + precip_data_for_facility = weather_by_grid[grid] + elif (reporting_facility == "Central Hospital"): + grid = general_facilities[general_facilities["District"] == "Lilongwe City"]["Grid_Index"].iloc[0] # all labelled X City will be in the same grid + precip_data_for_facility = weather_by_grid[grid] + else: + continue + weather_data_by_facility[reporting_facility] = precip_data_for_facility + +len(weather_data_by_facility) + +### Get data ready for linear regression between reporting and weather data +weather_df = pd.DataFrame.from_dict(weather_data_by_facility, orient='index').T +weather_df.columns = facilities_with_location +monthly_reporting_by_facility = monthly_reporting_by_facility.set_index('facility').T +monthly_reporting_by_facility.index.name = "date" + +# ### Save CSVs +# monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_facility_lm.csv") +# weather_df.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_facility_lm.csv") + +## Get additional data - e.g. which zone it is in, altitude +included_facilities_with_lat_long = facilities_with_lat_long[ + facilities_with_lat_long["Fname"].isin(facilities_with_location) +] + +additional_rows = ["Zonename", "Resid", "A105", "A109__Altitude"] +expanded_facility_info = included_facilities_with_lat_long[["Fname"] + additional_rows] + +expanded_facility_info.columns = ["Fname"] + additional_rows +expanded_facility_info.set_index("Fname", inplace=True) +expanded_facility_info = expanded_facility_info.T +expanded_facility_info = expanded_facility_info.reindex(columns=facilities_with_location) + +expanded_facility_info.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm.csv") From aa025cdb7377b2320d7f9787a3c9dc5ab660f0d8 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 17 Oct 2024 13:27:13 +0100 Subject: [PATCH 074/291] allowed writing csv --- .../reporting_and_weather_data_small_facilities.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/scripts/climate_change/reporting_and_weather_data_small_facilities.py b/src/scripts/climate_change/reporting_and_weather_data_small_facilities.py index f681b04a94..ab02bab88e 100644 --- a/src/scripts/climate_change/reporting_and_weather_data_small_facilities.py +++ b/src/scripts/climate_change/reporting_and_weather_data_small_facilities.py @@ -114,8 +114,8 @@ monthly_reporting_by_facility.index.name = "date" # ### Save CSVs -# monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_facility_lm.csv") -# weather_df.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_facility_lm.csv") +monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm.csv") +weather_df.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facility_lm.csv") ## Get additional data - e.g. which zone it is in, altitude included_facilities_with_lat_long = facilities_with_lat_long[ From 3e7c0786fae3a9e8e8d8ed89805bfc8f398d50d5 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 17 Oct 2024 18:53:57 +0100 Subject: [PATCH 075/291] Edited to allow for small facilities. Included extra independent variables (whether urban/rural, who runs the facility, which zone it is in) --- ...al_realtionship_reporting_precipitation.py | 138 ++++++++++++------ ...rting_and_weather_data_small_facilities.py | 31 ++-- 2 files changed, 105 insertions(+), 64 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index be882574c9..1e288ad0f6 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -6,9 +6,10 @@ import statsmodels.api as sm # # data is from 2011 - 2024 - for facility -monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_facility_lm.csv", index_col=0) -weather_data_historical = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_facility_lm.csv", index_col=0) - +monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm.csv", index_col=0) +weather_data_historical = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facility_lm.csv", index_col=0) +print(len(monthly_reporting_by_facility.columns)) +print(len(weather_data_historical.columns)) # monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_DHO_lm.csv", index_col=0) # weather_data_historical = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_DHO_lm.csv", index_col=0) @@ -28,30 +29,13 @@ # plt.tight_layout() # #plt.show() -## Drop Mental Hospital - bad reporting generally -weather_data_historical = weather_data_historical.drop("Zomba Mental Hospital", axis=1) -monthly_reporting_by_facility = monthly_reporting_by_facility.drop("Zomba Mental Hospital", axis=1) -# ## Drop MOH MALAWI Govt -# weather_data_historical = weather_data_historical.drop("MOH MALAWI Govt", axis=1) -# monthly_reporting_by_facility = monthly_reporting_by_facility.drop("MOH MALAWI Govt", axis=1) -# ## Looking at district level - drop central hospitals, as they do not report everything -# weather_data_historical = weather_data_historical.drop("Central Hospital", axis=1) -# monthly_reporting_by_facility = monthly_reporting_by_facility.drop("Central Hospital", axis=1) -# weather_data_historical = weather_data_historical.drop("Kamuzu Central Hospital", axis=1) -# monthly_reporting_by_facility = monthly_reporting_by_facility.drop("Kamuzu Central Hospital", axis=1) -# weather_data_historical = weather_data_historical.drop("Mzuzu Central Hospital", axis=1) -# monthly_reporting_by_facility = monthly_reporting_by_facility.drop("Mzuzu Central Hospital", axis=1) -# weather_data_historical = weather_data_historical.drop("Queen Elizabeth Central Hospital", axis=1) -# monthly_reporting_by_facility = monthly_reporting_by_facility.drop("Queen Elizabeth Central Hospital", axis=1) -# weather_data_historical = weather_data_historical.drop("Zomba Central Hospital", axis=1) -# monthly_reporting_by_facility = monthly_reporting_by_facility.drop("Zomba Central Hospital", axis=1) ## Drop September 2024 -weather_data_historical = weather_data_historical.drop(weather_data_historical.index[-1]) -monthly_reporting_by_facility = monthly_reporting_by_facility.drop(monthly_reporting_by_facility.index[-1]) +weather_data_historical = weather_data_historical.drop(weather_data_historical.index[1]) +monthly_reporting_by_facility = monthly_reporting_by_facility.drop(monthly_reporting_by_facility.index[1]) ## Drop 2011-2017 7*12 -weather_data_historical = weather_data_historical.drop(weather_data_historical.index[0:84]).reset_index(drop=True) -monthly_reporting_by_facility = monthly_reporting_by_facility.drop(monthly_reporting_by_facility.index[0:84]).reset_index(drop=True) +# weather_data_historical = weather_data_historical.drop(weather_data_historical.index[0:84]).reset_index(drop=True) +# monthly_reporting_by_facility = monthly_reporting_by_facility.drop(monthly_reporting_by_facility.index[0:84]).reset_index(drop=True) # Plot each facility's reporting data against weather data # plt.figure(figsize=(12, 6)) @@ -74,7 +58,7 @@ ## Linear regression - flattened # year -year_range = range(2018, 2025, 1) # year as a fixed effect +year_range = range(2011, 2025, 1) # year as a fixed effect year_repeated = [y for y in year_range for _ in range(12)] year = year_repeated[:-4] year_flattened = year*len(weather_data_historical.columns) # to get flattened data @@ -82,7 +66,7 @@ # month month = range(12) month_repeated = [m for m in month for _ in year_range] -month = month_repeated[:-4] +month = month_repeated[4:] month_flattened = month*len(weather_data_historical.columns) # facility as fixed effect @@ -91,7 +75,6 @@ # linear regression - flatten for more data points weather_data = weather_data_historical.values.flatten() y = monthly_reporting_by_facility.values.flatten() - X = pd.DataFrame({ 'weather_data': weather_data, 'year': year_flattened, @@ -103,24 +86,12 @@ facility_encoded = pd.get_dummies(X['facility']) X = np.column_stack((X[['weather_data', 'year', 'month']], facility_encoded)) -model = sm.OLS(y,X) +mask = ~np.isnan(X).any(axis=1) & ~np.isnan(y) +model = sm.OLS(y[mask],X[mask]) results = model.fit() print(results.summary()) -# # # ## Linear regression - by facility -# results_list = [] -# # -# for facility in monthly_reporting_by_facility.columns: -# y = monthly_reporting_by_facility[facility].values -# weather = weather_data_historical[facility].values -# X = np.column_stack((weather, year, month)) -# -# model = sm.OLS(y, X) -# results = model.fit() -# -# #print(results.summary()) - ## Binary above/below average for that month X_df = pd.DataFrame({ @@ -140,7 +111,6 @@ for value in X_data["weather_data"]: above_below_average.append(1 if value > average_for_month.values[0] else 0) - # Add the binary variable to the predictors X = pd.DataFrame({ 'weather_data': weather_data, @@ -155,9 +125,9 @@ X = np.column_stack((X[['weather_data', 'year', 'month', 'precip_above_average']], facility_encoded)) y = monthly_reporting_by_facility.values.flatten() -model = sm.OLS(y,X) +mask = ~np.isnan(X).any(axis=1) & ~np.isnan(y) +model = sm.OLS(y[mask],X[mask]) results = model.fit() - print(results.summary()) @@ -187,16 +157,90 @@ 'year': year_flattened, 'month': month_flattened, 'facility': facility_flattened, - 'precip_above_300': above_below_700 + 'precip_above_700': above_below_700 }) # One-hot encode the 'facility' column for a fixed effect facility_encoded = pd.get_dummies(X['facility']) -X = np.column_stack((X[['weather_data', 'year', 'month', 'precip_above_300']], facility_encoded)) +X = np.column_stack((X[['weather_data', 'year', 'month', 'precip_above_700']], facility_encoded)) +y = monthly_reporting_by_facility.values.flatten() + +mask = ~np.isnan(X).any(axis=1) & ~np.isnan(y) +model = sm.OLS(y[mask],X[mask]) +results = model.fit() +print(results.summary()) + +######### Now has it exceeded in previous 12 months + + +exceeds_700_last_12_weather = [] + +for facility in weather_data_historical.columns: + facility_data = weather_data_historical[facility] + + for i in range(len(facility_data)): + if i >= 12: + last_12_values = facility_data[i - 12:i] + exceeds_700_last_12_weather.append(1 if (last_12_values > 700).any() else 0) + else: + exceeds_700_last_12_weather.append(np.nan) + +X = pd.DataFrame({ + 'weather_data': weather_data, + 'year': year_flattened, + 'month': month_flattened, + 'facility': facility_flattened, + 'precip_above_700': above_below_700, + 'exceeds_700_last_12_weather': exceeds_700_last_12_weather +}) +facility_encoded = pd.get_dummies(X['facility']) + +X = np.column_stack( + (X[['weather_data', 'year', 'month', 'precip_above_700', 'exceeds_700_last_12_weather']], facility_encoded)) y = monthly_reporting_by_facility.values.flatten() -model = sm.OLS(y,X) +mask = ~np.isnan(X).any(axis=1) & ~np.isnan(y) +model = sm.OLS(y[mask], X[mask]) results = model.fit() print(results.summary()) +########### Add other covariates + +expanded_facility_info = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm.csv", index_col=0) +expanded_facility_info = expanded_facility_info.T.reindex(columns=expanded_facility_info.index) +print(len(expanded_facility_info)) +zone_info = expanded_facility_info["Zonename"] +zone_info_each_month = [z for z in zone_info for _ in range(12) for _ in year_range] +zone_info_each_month = zone_info_each_month[4*len(monthly_reporting_by_facility.columns):] # first four months, no data (Sept - Dec 2024) + +zone_encoded = pd.get_dummies(zone_info_each_month) +resid_info = expanded_facility_info['Resid'] +resid_info_each_month = [r for r in resid_info for _ in range(12) for _ in year_range] +resid_info_each_month = resid_info_each_month[4*len(monthly_reporting_by_facility.columns):] # first four months, no data (Sept - Dec 2024) +resid_encoded = pd.get_dummies(resid_info_each_month) +owner_info = expanded_facility_info['A105'] +owner_info_each_month = [o for o in owner_info for _ in range(12) for _ in year_range] +owner_info_each_month = owner_info_each_month[4*len(monthly_reporting_by_facility.columns):] # first four months, no data (Sept - Dec 2024) + +owner_encoded = pd.get_dummies(owner_info_each_month) +X = pd.DataFrame({ + 'weather_data': weather_data, + 'year': year_flattened, + 'month': month_flattened, + 'facility': facility_flattened, + 'precip_above_700': above_below_700, + 'exceeds_700_last_12_weather': exceeds_700_last_12_weather +}) +print(X) +facility_encoded = pd.get_dummies(X['facility']) + +X = np.column_stack( + (X[['weather_data', 'year', 'month', 'precip_above_700', 'exceeds_700_last_12_weather']], facility_encoded, resid_encoded,zone_encoded, owner_encoded)) +y = monthly_reporting_by_facility.values.flatten() + +mask = ~np.isnan(X).any(axis=1) & ~np.isnan(y) +model = sm.OLS(y[mask], X[mask]) +results = model.fit() + +print(results.summary()) diff --git a/src/scripts/climate_change/reporting_and_weather_data_small_facilities.py b/src/scripts/climate_change/reporting_and_weather_data_small_facilities.py index ab02bab88e..a084939081 100644 --- a/src/scripts/climate_change/reporting_and_weather_data_small_facilities.py +++ b/src/scripts/climate_change/reporting_and_weather_data_small_facilities.py @@ -15,29 +15,22 @@ # drop NAs reporting_data = reporting_data.dropna(subset = reporting_data.columns[3:], how='all') # drops 90 clinics -### But need to drop mental health, as that is only relevant for the Zomba Mental Hospital and otherwise brings down averages -# extract mental health data -mental_health_columns = reporting_data.columns[reporting_data.columns.str.startswith("Mental")].tolist() -reporting_data_no_mental = reporting_data.drop(mental_health_columns, axis = 1) -mental_health_data = reporting_data[[reporting_data.columns[1]] + mental_health_columns] -all_columns_no_mental_health = reporting_data_no_mental.columns - ### now aggregate over months monthly_reporting_data_by_facility = {} -months = set(col.split(" - Reporting rate ")[1] for col in all_columns_no_mental_health if " - Reporting rate " in col) +months = set(col.split(" - Reporting rate ")[1] for col in reporting_data.columns if " - Reporting rate " in col) # put in order months = [date.strip() for date in months] # extra spaces?? dates = pd.to_datetime(months, format='%B %Y', errors='coerce') months = dates.sort_values().strftime('%B %Y').tolist() for month in months: - columns_of_interest_all_metrics = [reporting_data_no_mental.columns[1]] + reporting_data_no_mental.columns[reporting_data_no_mental.columns.str.endswith(month)].tolist() - data_of_interest_by_month = reporting_data_no_mental[columns_of_interest_all_metrics] + columns_of_interest_all_metrics = [reporting_data.columns[1]] + reporting_data.columns[reporting_data.columns.str.endswith(month)].tolist() + data_of_interest_by_month = reporting_data[columns_of_interest_all_metrics] numeric_data = data_of_interest_by_month.select_dtypes(include='number') monthly_mean_by_facility = numeric_data.mean(axis=1) monthly_reporting_data_by_facility[month] = monthly_mean_by_facility monthly_reporting_by_facility = pd.DataFrame(monthly_reporting_data_by_facility) -monthly_reporting_by_facility["facility"] = reporting_data_no_mental["organisationunitname"].values +monthly_reporting_by_facility["facility"] = reporting_data["organisationunitname"].values # Weather data directory = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical" # from 2011 on @@ -84,7 +77,7 @@ matching_facility_name = difflib.get_close_matches(reporting_facility, facilities_with_lat_long['Fname'], n=3, cutoff=0.90) if matching_facility_name: match_name = matching_facility_name[0] # Access the string directly - facilities_with_location.append(match_name) + facilities_with_location.append(reporting_facility) lat_for_facility = facilities_with_lat_long.loc[ facilities_with_lat_long['Fname'] == match_name, "A109__Latitude"].iloc[0] long_for_facility = facilities_with_lat_long.loc[ @@ -93,19 +86,17 @@ index_for_y= ((lat_data - long_for_facility)**2).argmin() precip_data_for_facility = pr_data[:, index_for_y,index_for_x] # across all time points - precip_data_for_facility = precip_data_for_facility * 86400 # to get from per second to per day + weather_data_by_facility[reporting_facility] = precip_data_for_facility * 86400 # to get from per second to per day ## below are not in facilities file? elif reporting_facility == "Central East Zone": grid = general_facilities[general_facilities["District"] == "Nkhotakota"]["Grid_Index"].iloc[0] # furtherst east zone - precip_data_for_facility = weather_by_grid[grid] + weather_data_by_facility[reporting_facility] = weather_by_grid[grid] elif (reporting_facility == "Central Hospital"): grid = general_facilities[general_facilities["District"] == "Lilongwe City"]["Grid_Index"].iloc[0] # all labelled X City will be in the same grid - precip_data_for_facility = weather_by_grid[grid] + weather_data_by_facility[reporting_facility] = weather_by_grid[grid] else: continue - weather_data_by_facility[reporting_facility] = precip_data_for_facility -len(weather_data_by_facility) ### Get data ready for linear regression between reporting and weather data weather_df = pd.DataFrame.from_dict(weather_data_by_facility, orient='index').T @@ -114,6 +105,12 @@ monthly_reporting_by_facility.index.name = "date" # ### Save CSVs +monthly_reporting_by_facility = monthly_reporting_by_facility.loc[:, monthly_reporting_by_facility.columns.isin(facilities_with_location)] +monthly_reporting_by_facility = monthly_reporting_by_facility[facilities_with_location] + +print(len(facilities_with_location)) +print(len(monthly_reporting_by_facility.columns)) +print(len(weather_df.columns)) monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm.csv") weather_df.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facility_lm.csv") From fc21fade006006b5764d51acd0fcc4591d0601c2 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 17 Oct 2024 19:47:55 +0100 Subject: [PATCH 076/291] notes --- .../reporting_and_weather_data_small_facilities.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/scripts/climate_change/reporting_and_weather_data_small_facilities.py b/src/scripts/climate_change/reporting_and_weather_data_small_facilities.py index a084939081..4eababee6c 100644 --- a/src/scripts/climate_change/reporting_and_weather_data_small_facilities.py +++ b/src/scripts/climate_change/reporting_and_weather_data_small_facilities.py @@ -14,7 +14,6 @@ reporting_data = reporting_data.drop(columns=columns_to_drop) # drop NAs reporting_data = reporting_data.dropna(subset = reporting_data.columns[3:], how='all') # drops 90 clinics - ### now aggregate over months monthly_reporting_data_by_facility = {} months = set(col.split(" - Reporting rate ")[1] for col in reporting_data.columns if " - Reporting rate " in col) @@ -22,7 +21,7 @@ # put in order months = [date.strip() for date in months] # extra spaces?? dates = pd.to_datetime(months, format='%B %Y', errors='coerce') -months = dates.sort_values().strftime('%B %Y').tolist() +months = dates.sort_values().strftime('%B %Y').tolist() # puts them in ascending order for month in months: columns_of_interest_all_metrics = [reporting_data.columns[1]] + reporting_data.columns[reporting_data.columns.str.endswith(month)].tolist() data_of_interest_by_month = reporting_data[columns_of_interest_all_metrics] @@ -50,6 +49,8 @@ pr_data = weather_monthly_all_grids.variables['tp'][:] # total precipitation in kg m-2 s-1 = mm s-1 x 86400 to get to day lat_data = weather_monthly_all_grids.variables['latitude'][:] long_data = weather_monthly_all_grids.variables['longitude'][:] +date = weather_monthly_all_grids['date'][:] +print(date) grid = 0 regridded_weather_data = {} From 7b7b56188a9e72579f01281e67f928c4ca84bfd0 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 18 Oct 2024 10:12:32 +0100 Subject: [PATCH 077/291] notes --- ...al_realtionship_reporting_precipitation.py | 219 +++++++----------- 1 file changed, 79 insertions(+), 140 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 1e288ad0f6..820ae59995 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -30,10 +30,10 @@ # #plt.show() ## Drop September 2024 -weather_data_historical = weather_data_historical.drop(weather_data_historical.index[1]) -monthly_reporting_by_facility = monthly_reporting_by_facility.drop(monthly_reporting_by_facility.index[1]) +weather_data_historical = weather_data_historical.drop(weather_data_historical.index[-1]) +monthly_reporting_by_facility = monthly_reporting_by_facility.drop(monthly_reporting_by_facility.index[-1]) -## Drop 2011-2017 7*12 +# ## Drop 2011-2017 7*12 # weather_data_historical = weather_data_historical.drop(weather_data_historical.index[0:84]).reset_index(drop=True) # monthly_reporting_by_facility = monthly_reporting_by_facility.drop(monthly_reporting_by_facility.index[0:84]).reset_index(drop=True) @@ -58,6 +58,8 @@ ## Linear regression - flattened # year +month_range = range(12) +num_facilities = len(weather_data_historical.columns) year_range = range(2011, 2025, 1) # year as a fixed effect year_repeated = [y for y in year_range for _ in range(12)] year = year_repeated[:-4] @@ -66,181 +68,118 @@ # month month = range(12) month_repeated = [m for m in month for _ in year_range] -month = month_repeated[4:] +month = month_repeated[:-4] month_flattened = month*len(weather_data_historical.columns) # facility as fixed effect facility_flattened = list(range(len(weather_data_historical.columns))) * len(month) -# linear regression - flatten for more data points +# Flatten data weather_data = weather_data_historical.values.flatten() y = monthly_reporting_by_facility.values.flatten() -X = pd.DataFrame({ - 'weather_data': weather_data, - 'year': year_flattened, - 'month': month_flattened, - 'facility': facility_flattened -}) -# One-hot encode the 'facility' column for a fixed effect -facility_encoded = pd.get_dummies(X['facility']) +# Function to build model +def build_model(predictors, dependent_var, scale_y=True, binomial=True): + X = np.column_stack(predictors) + y_scaled = (dependent_var / 100) if scale_y else dependent_var + mask = ~np.isnan(X).any(axis=1) & ~np.isnan(y_scaled) + model = sm.GLM(y_scaled[mask], X[mask], family=sm.families.Binomial()) if binomial else sm.OLS(y_scaled[mask], X[mask]) + return model.fit() -X = np.column_stack((X[['weather_data', 'year', 'month']], facility_encoded)) -mask = ~np.isnan(X).any(axis=1) & ~np.isnan(y) -model = sm.OLS(y[mask],X[mask]) -results = model.fit() - -print(results.summary()) +# One-hot encode facilities +facility_encoded = pd.get_dummies(facility_flattened) +print(len(facility_flattened)) +print(len(month_flattened)) +print(len(weather_data)) -## Binary above/below average for that month -X_df = pd.DataFrame({ - 'weather_data': weather_data, - 'year': year_flattened, - 'month': month_flattened, - 'facility': facility_flattened -}) - -grouped_data = X_df.groupby(['facility', 'month'])['weather_data'].mean().reset_index() -above_below_average = [] -for facility in range(len(monthly_reporting_by_facility.columns)): - for month in range(12): - average_for_month = grouped_data[(grouped_data["facility"] == facility) & (grouped_data["month"] == month)][ - "weather_data"] - X_data = X_df[(X_df["month"] == month) & (X_df["facility"] == facility)] - for value in X_data["weather_data"]: - above_below_average.append(1 if value > average_for_month.values[0] else 0) - -# Add the binary variable to the predictors -X = pd.DataFrame({ - 'weather_data': weather_data, - 'year': year_flattened, - 'month': month_flattened, +# Above/below average for each month +grouped_data = pd.DataFrame({ 'facility': facility_flattened, - 'precip_above_average': above_below_average -}) -# One-hot encode the 'facility' column for a fixed effect -facility_encoded = pd.get_dummies(X['facility']) - -X = np.column_stack((X[['weather_data', 'year', 'month', 'precip_above_average']], facility_encoded)) -y = monthly_reporting_by_facility.values.flatten() - -mask = ~np.isnan(X).any(axis=1) & ~np.isnan(y) -model = sm.OLS(y[mask],X[mask]) -results = model.fit() -print(results.summary()) - + 'month': month_flattened, + 'weather_data': weather_data +}).groupby(['facility', 'month'])['weather_data'].mean().reset_index() +def create_binary_feature(threshold, weather_data_df, recent_months): + binary_feature_list = [] + for facility in weather_data_df.columns: + facility_data = weather_data_df[facility] -## Binary above/below 300mm for that month (very heavy rain) -X_df = pd.DataFrame({ - 'weather_data': weather_data, - 'year': year_flattened, - 'month': month_flattened, - 'facility': facility_flattened -}) + for i in range(len(facility_data)): + if hasattr(threshold, "__len__"): # Check if threshold is iterable + facility_threshold = threshold[i] + else: + facility_threshold = threshold # Use scalar threshold if it's not iterable -grouped_data = X_df.groupby(['facility', 'month'])['weather_data'].mean().reset_index() -above_below_700 = [] -for facility in range(len(monthly_reporting_by_facility.columns)): - for month in range(12): - X_data = X_df[(X_df["month"] == month) & (X_df["facility"] == facility)] - for value in X_data["weather_data"]: + if i >= recent_months: + last_x_values = facility_data[i - recent_months:i] + binary_feature_list.append(1 if (last_x_values > facility_threshold).any() else 0) + else: + binary_feature_list.append(np.nan) - above_below_700.append(1 if value > 700 else 0) + return binary_feature_list +above_below_average = create_binary_feature( + grouped_data.groupby(['facility', 'month'])['weather_data'].transform('mean'), weather_data_historical, 0 +) +above_below_700 = create_binary_feature(700, weather_data_historical, 12) -# Add the binary variable to the predictors -X = pd.DataFrame({ +# Build models +X_base = pd.DataFrame({ 'weather_data': weather_data, 'year': year_flattened, 'month': month_flattened, - 'facility': facility_flattened, + 'precip_above_average': above_below_average, 'precip_above_700': above_below_700 }) -# One-hot encode the 'facility' column for a fixed effect -facility_encoded = pd.get_dummies(X['facility']) - -X = np.column_stack((X[['weather_data', 'year', 'month', 'precip_above_700']], facility_encoded)) -y = monthly_reporting_by_facility.values.flatten() -mask = ~np.isnan(X).any(axis=1) & ~np.isnan(y) -model = sm.OLS(y[mask],X[mask]) -results = model.fit() +X = np.column_stack([X_base[['weather_data', 'year', 'month', 'precip_above_average', 'precip_above_700']], facility_encoded]) +results = build_model([X], y) print(results.summary()) -######### Now has it exceeded in previous 12 months - - -exceeds_700_last_12_weather = [] - -for facility in weather_data_historical.columns: - facility_data = weather_data_historical[facility] - - for i in range(len(facility_data)): - if i >= 12: - last_12_values = facility_data[i - 12:i] - exceeds_700_last_12_weather.append(1 if (last_12_values > 700).any() else 0) - else: - exceeds_700_last_12_weather.append(np.nan) - -X = pd.DataFrame({ - 'weather_data': weather_data, - 'year': year_flattened, - 'month': month_flattened, - 'facility': facility_flattened, - 'precip_above_700': above_below_700, - 'exceeds_700_last_12_weather': exceeds_700_last_12_weather -}) -facility_encoded = pd.get_dummies(X['facility']) - -X = np.column_stack( - (X[['weather_data', 'year', 'month', 'precip_above_700', 'exceeds_700_last_12_weather']], facility_encoded)) -y = monthly_reporting_by_facility.values.flatten() - -mask = ~np.isnan(X).any(axis=1) & ~np.isnan(y) -model = sm.OLS(y[mask], X[mask]) -results = model.fit() - +# Exceeds threshold in last 12 months +exceeds_700_last_12 = [ + 1 if (weather_data_historical[facility][i-12:i] > 700).any() else 0 + if i >= 12 else np.nan + for facility in weather_data_historical.columns for i in range(len(weather_data_historical[facility])) +] +print(exceeds_700_last_12) +print(above_below_700) +X_base['exceeds_700_last_12_weather'] = exceeds_700_last_12 +X = np.column_stack([X_base, facility_encoded]) +results = build_model([X], y) print(results.summary()) -########### Add other covariates +# Add additional covariates (zone, resid, etc.) +expanded_facility_info = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm.csv", index_col=0).T expanded_facility_info = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm.csv", index_col=0) expanded_facility_info = expanded_facility_info.T.reindex(columns=expanded_facility_info.index) -print(len(expanded_facility_info)) -zone_info = expanded_facility_info["Zonename"] -zone_info_each_month = [z for z in zone_info for _ in range(12) for _ in year_range] -zone_info_each_month = zone_info_each_month[4*len(monthly_reporting_by_facility.columns):] # first four months, no data (Sept - Dec 2024) +def repeat_info(info, num_facilities, year_range): + repeated_info = [i for i in info for _ in range(12) for _ in year_range] + return repeated_info[4 * num_facilities:] # Exclude first 4 months (Sept - Dec 2024) +# Zone information encoding +zone_info_each_month = repeat_info(expanded_facility_info["Zonename"], num_facilities, year_range) zone_encoded = pd.get_dummies(zone_info_each_month) -resid_info = expanded_facility_info['Resid'] -resid_info_each_month = [r for r in resid_info for _ in range(12) for _ in year_range] -resid_info_each_month = resid_info_each_month[4*len(monthly_reporting_by_facility.columns):] # first four months, no data (Sept - Dec 2024) + +# Resid information encoding +resid_info_each_month = repeat_info(expanded_facility_info['Resid'], num_facilities, year_range) resid_encoded = pd.get_dummies(resid_info_each_month) -owner_info = expanded_facility_info['A105'] -owner_info_each_month = [o for o in owner_info for _ in range(12) for _ in year_range] -owner_info_each_month = owner_info_each_month[4*len(monthly_reporting_by_facility.columns):] # first four months, no data (Sept - Dec 2024) +# Owner information encoding +owner_info_each_month = repeat_info(expanded_facility_info['A105'], num_facilities, year_range) owner_encoded = pd.get_dummies(owner_info_each_month) -X = pd.DataFrame({ - 'weather_data': weather_data, - 'year': year_flattened, - 'month': month_flattened, - 'facility': facility_flattened, - 'precip_above_700': above_below_700, - 'exceeds_700_last_12_weather': exceeds_700_last_12_weather -}) -print(X) -facility_encoded = pd.get_dummies(X['facility']) -X = np.column_stack( - (X[['weather_data', 'year', 'month', 'precip_above_700', 'exceeds_700_last_12_weather']], facility_encoded, resid_encoded,zone_encoded, owner_encoded)) -y = monthly_reporting_by_facility.values.flatten() +X = np.column_stack([X_base, facility_encoded, resid_encoded, resid_encoded, owner_encoded]) +results = build_model([X], y) +print(results.summary()) -mask = ~np.isnan(X).any(axis=1) & ~np.isnan(y) -model = sm.OLS(y[mask], X[mask]) -results = model.fit() +# Add lagged model +lag_1_month = weather_data_historical.shift(1).values.flatten() +lag_3_month = weather_data_historical.shift(3).values.flatten() +X_lagged = np.column_stack([X_base[['weather_data', 'year', 'month', 'precip_above_700', 'exceeds_700_last_12_weather']], lag_1_month, lag_3_month, facility_encoded]) +results = build_model([X_lagged], y) print(results.summary()) From f540d13d1bf839e3091ba14921ce5b195c2b351c Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 18 Oct 2024 12:02:55 +0100 Subject: [PATCH 078/291] Removed the actually facility as a predictor, as it introduced a lot of collinearity and made the model worse. --- ...al_realtionship_reporting_precipitation.py | 142 +++++------------- 1 file changed, 34 insertions(+), 108 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 820ae59995..8b370961ae 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -1,98 +1,45 @@ -import matplotlib.pyplot as plt import numpy as np import pandas as pd -from sklearn.linear_model import LinearRegression -from sklearn.metrics import r2_score import statsmodels.api as sm +from sklearn.preprocessing import StandardScaler # # data is from 2011 - 2024 - for facility monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm.csv", index_col=0) weather_data_historical = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facility_lm.csv", index_col=0) -print(len(monthly_reporting_by_facility.columns)) -print(len(weather_data_historical.columns)) -# monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_DHO_lm.csv", index_col=0) -# weather_data_historical = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_DHO_lm.csv", index_col=0) - -# Plot each facility's reporting data against weather data -# plt.figure(figsize=(12, 6)) -# for facility in weather_data_historical.columns: -# plt.plot(weather_data_historical.index, monthly_reporting_by_facility, label=facility) -# months = weather_data_historical.index -# year_labels = range(2011, 2025, 1) -# year_ticks = range(0, len(months), 12) -# plt.xticks(year_ticks, year_labels, rotation=90) -# plt.xlabel('Year') -# plt.ylabel('Reporting %') -# plt.title('Reporting by Facility') -# plt.legend(title='Facilities', bbox_to_anchor=(1.05, 1), loc='upper left') -# plt.grid() -# plt.tight_layout() -# #plt.show() + ## Drop September 2024 weather_data_historical = weather_data_historical.drop(weather_data_historical.index[-1]) monthly_reporting_by_facility = monthly_reporting_by_facility.drop(monthly_reporting_by_facility.index[-1]) -# ## Drop 2011-2017 7*12 -# weather_data_historical = weather_data_historical.drop(weather_data_historical.index[0:84]).reset_index(drop=True) -# monthly_reporting_by_facility = monthly_reporting_by_facility.drop(monthly_reporting_by_facility.index[0:84]).reset_index(drop=True) - -# Plot each facility's reporting data against weather data -# plt.figure(figsize=(12, 6)) -# -# for facility in weather_data_historical.columns: -# plt.plot(weather_data_historical.index, monthly_reporting_by_facility, label=facility) -# months = weather_data_historical.index -# year_labels = range(2015, 2025, 1) -# year_ticks = range(0, len(months), 12) -# plt.xticks(year_ticks, year_labels, rotation=90) -# plt.xlabel('Weather Data') -# plt.ylabel('Reporting') -# plt.title('Reporting vs. Weather Data by Facility') -# plt.legend(title='Facilities', bbox_to_anchor=(1.05, 1), loc='upper left') -# plt.grid() -# plt.tight_layout() -# #plt.show() - - - -## Linear regression - flattened -# year +## Linear regression month_range = range(12) num_facilities = len(weather_data_historical.columns) year_range = range(2011, 2025, 1) # year as a fixed effect year_repeated = [y for y in year_range for _ in range(12)] year = year_repeated[:-4] year_flattened = year*len(weather_data_historical.columns) # to get flattened data - -# month month = range(12) month_repeated = [m for m in month for _ in year_range] month = month_repeated[:-4] month_flattened = month*len(weather_data_historical.columns) -# facility as fixed effect facility_flattened = list(range(len(weather_data_historical.columns))) * len(month) # Flatten data weather_data = weather_data_historical.values.flatten() y = monthly_reporting_by_facility.values.flatten() -# Function to build model -def build_model(predictors, dependent_var, scale_y=True, binomial=True): - X = np.column_stack(predictors) - y_scaled = (dependent_var / 100) if scale_y else dependent_var - mask = ~np.isnan(X).any(axis=1) & ~np.isnan(y_scaled) +def build_model(X, y, scale_y=True, binomial=True, X_mask_mm = 0): + y += 1e-10 # account for zeros in binomial data + y_scaled = (y / 100) if scale_y else y + mask = ~np.isnan(X).any(axis=1) & ~np.isnan(y_scaled) & (X[:, 0] >= X_mask_mm) model = sm.GLM(y_scaled[mask], X[mask], family=sm.families.Binomial()) if binomial else sm.OLS(y_scaled[mask], X[mask]) return model.fit() # One-hot encode facilities facility_encoded = pd.get_dummies(facility_flattened) -print(len(facility_flattened)) -print(len(month_flattened)) -print(len(weather_data)) - # Above/below average for each month grouped_data = pd.DataFrame({ 'facility': facility_flattened, @@ -100,17 +47,13 @@ def build_model(predictors, dependent_var, scale_y=True, binomial=True): 'weather_data': weather_data }).groupby(['facility', 'month'])['weather_data'].mean().reset_index() - def create_binary_feature(threshold, weather_data_df, recent_months): binary_feature_list = [] for facility in weather_data_df.columns: facility_data = weather_data_df[facility] for i in range(len(facility_data)): - if hasattr(threshold, "__len__"): # Check if threshold is iterable - facility_threshold = threshold[i] - else: - facility_threshold = threshold # Use scalar threshold if it's not iterable + facility_threshold = threshold[i] if hasattr(threshold, "__len__") else threshold if i >= recent_months: last_x_values = facility_data[i - recent_months:i] @@ -119,67 +62,50 @@ def create_binary_feature(threshold, weather_data_df, recent_months): binary_feature_list.append(np.nan) return binary_feature_list + above_below_average = create_binary_feature( grouped_data.groupby(['facility', 'month'])['weather_data'].transform('mean'), weather_data_historical, 0 ) +above_below_X = create_binary_feature(800, weather_data_historical, 12) -above_below_700 = create_binary_feature(700, weather_data_historical, 12) - -# Build models -X_base = pd.DataFrame({ - 'weather_data': weather_data, - 'year': year_flattened, - 'month': month_flattened, - 'precip_above_average': above_below_average, - 'precip_above_700': above_below_700 -}) - -X = np.column_stack([X_base[['weather_data', 'year', 'month', 'precip_above_average', 'precip_above_700']], facility_encoded]) -results = build_model([X], y) -print(results.summary()) - -# Exceeds threshold in last 12 months -exceeds_700_last_12 = [ - 1 if (weather_data_historical[facility][i-12:i] > 700).any() else 0 - if i >= 12 else np.nan - for facility in weather_data_historical.columns for i in range(len(weather_data_historical[facility])) -] -print(exceeds_700_last_12) -print(above_below_700) -X_base['exceeds_700_last_12_weather'] = exceeds_700_last_12 -X = np.column_stack([X_base, facility_encoded]) -results = build_model([X], y) -print(results.summary()) - -# Add additional covariates (zone, resid, etc.) -expanded_facility_info = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm.csv", index_col=0).T - +# Prepare additional facility info expanded_facility_info = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm.csv", index_col=0) expanded_facility_info = expanded_facility_info.T.reindex(columns=expanded_facility_info.index) + def repeat_info(info, num_facilities, year_range): repeated_info = [i for i in info for _ in range(12) for _ in year_range] return repeated_info[4 * num_facilities:] # Exclude first 4 months (Sept - Dec 2024) -# Zone information encoding zone_info_each_month = repeat_info(expanded_facility_info["Zonename"], num_facilities, year_range) zone_encoded = pd.get_dummies(zone_info_each_month) - -# Resid information encoding resid_info_each_month = repeat_info(expanded_facility_info['Resid'], num_facilities, year_range) resid_encoded = pd.get_dummies(resid_info_each_month) - -# Owner information encoding owner_info_each_month = repeat_info(expanded_facility_info['A105'], num_facilities, year_range) owner_encoded = pd.get_dummies(owner_info_each_month) -X = np.column_stack([X_base, facility_encoded, resid_encoded, resid_encoded, owner_encoded]) -results = build_model([X], y) -print(results.summary()) - -# Add lagged model +# Lagged weather lag_1_month = weather_data_historical.shift(1).values.flatten() lag_3_month = weather_data_historical.shift(3).values.flatten() -X_lagged = np.column_stack([X_base[['weather_data', 'year', 'month', 'precip_above_700', 'exceeds_700_last_12_weather']], lag_1_month, lag_3_month, facility_encoded]) -results = build_model([X_lagged], y) +X = np.column_stack([ + weather_data, + year_flattened, + month_flattened, + above_below_average, + above_below_X, + #facility_encoded, + resid_encoded, + zone_encoded, + owner_encoded, + lag_1_month, + lag_3_month +]) + +#scaler = StandardScaler() # as weather is at such different levels +#X_scaled = scaler.fit_transform(X) +results = build_model(X, y, scale_y=False, binomial=False, X_mask_mm = 0) +print(results.summary()) + +results = build_model(X, y, X_mask_mm = 0) + print(results.summary()) From c636da014173e05b257914eb482517eea7a082d3 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 18 Oct 2024 13:10:35 +0100 Subject: [PATCH 079/291] tidied --- ...del_historical_realtionship_reporting_precipitation.py | 8 ++++---- .../reporting_and_weather_data_small_facilities.py | 5 +---- 2 files changed, 5 insertions(+), 8 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 8b370961ae..ef235ccd3d 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -66,7 +66,7 @@ def create_binary_feature(threshold, weather_data_df, recent_months): above_below_average = create_binary_feature( grouped_data.groupby(['facility', 'month'])['weather_data'].transform('mean'), weather_data_historical, 0 ) -above_below_X = create_binary_feature(800, weather_data_historical, 12) +above_below_X = create_binary_feature(1000, weather_data_historical, 12) # Prepare additional facility info expanded_facility_info = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm.csv", index_col=0) @@ -92,7 +92,7 @@ def repeat_info(info, num_facilities, year_range): year_flattened, month_flattened, above_below_average, - above_below_X, + #above_below_X, #facility_encoded, resid_encoded, zone_encoded, @@ -103,9 +103,9 @@ def repeat_info(info, num_facilities, year_range): #scaler = StandardScaler() # as weather is at such different levels #X_scaled = scaler.fit_transform(X) -results = build_model(X, y, scale_y=False, binomial=False, X_mask_mm = 0) +results = build_model(X, y, scale_y=False, binomial=False, X_mask_mm = 800) print(results.summary()) -results = build_model(X, y, X_mask_mm = 0) +results = build_model(X, y, X_mask_mm = 800) print(results.summary()) diff --git a/src/scripts/climate_change/reporting_and_weather_data_small_facilities.py b/src/scripts/climate_change/reporting_and_weather_data_small_facilities.py index 4eababee6c..f4574473fa 100644 --- a/src/scripts/climate_change/reporting_and_weather_data_small_facilities.py +++ b/src/scripts/climate_change/reporting_and_weather_data_small_facilities.py @@ -109,9 +109,6 @@ monthly_reporting_by_facility = monthly_reporting_by_facility.loc[:, monthly_reporting_by_facility.columns.isin(facilities_with_location)] monthly_reporting_by_facility = monthly_reporting_by_facility[facilities_with_location] -print(len(facilities_with_location)) -print(len(monthly_reporting_by_facility.columns)) -print(len(weather_df.columns)) monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm.csv") weather_df.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facility_lm.csv") @@ -120,7 +117,7 @@ facilities_with_lat_long["Fname"].isin(facilities_with_location) ] -additional_rows = ["Zonename", "Resid", "A105", "A109__Altitude"] +additional_rows = ["Zonename", "Resid", "A105", "A109__Altitude", "Ftype"] expanded_facility_info = included_facilities_with_lat_long[["Fname"] + additional_rows] expanded_facility_info.columns = ["Fname"] + additional_rows From 17b77286e494423ef06f50168ca28edb32bae531 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 18 Oct 2024 13:48:59 +0100 Subject: [PATCH 080/291] Changed to beta regression model - no avail --- ...al_realtionship_reporting_precipitation.py | 30 ++++++++++++++----- 1 file changed, 22 insertions(+), 8 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index ef235ccd3d..e8cf5c9312 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -1,7 +1,7 @@ import numpy as np import pandas as pd import statsmodels.api as sm -from sklearn.preprocessing import StandardScaler +from statsmodels.othermod.betareg import BetaModel # # data is from 2011 - 2024 - for facility monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm.csv", index_col=0) @@ -30,11 +30,11 @@ weather_data = weather_data_historical.values.flatten() y = monthly_reporting_by_facility.values.flatten() -def build_model(X, y, scale_y=True, binomial=True, X_mask_mm = 0): - y += 1e-10 # account for zeros in binomial data +def build_model(X, y, scale_y=True, beta=True, X_mask_mm = 0): + y += 1e-10 y_scaled = (y / 100) if scale_y else y mask = ~np.isnan(X).any(axis=1) & ~np.isnan(y_scaled) & (X[:, 0] >= X_mask_mm) - model = sm.GLM(y_scaled[mask], X[mask], family=sm.families.Binomial()) if binomial else sm.OLS(y_scaled[mask], X[mask]) + model = BetaModel(y_scaled[mask], X[mask]) if beta else sm.OLS(y_scaled[mask], X[mask]) return model.fit() # One-hot encode facilities @@ -74,7 +74,7 @@ def create_binary_feature(threshold, weather_data_df, recent_months): def repeat_info(info, num_facilities, year_range): repeated_info = [i for i in info for _ in range(12) for _ in year_range] - return repeated_info[4 * num_facilities:] # Exclude first 4 months (Sept - Dec 2024) + return repeated_info[:-4 * num_facilities] # Exclude first final months (Sept - Dec 2024) zone_info_each_month = repeat_info(expanded_facility_info["Zonename"], num_facilities, year_range) zone_encoded = pd.get_dummies(zone_info_each_month) @@ -82,11 +82,13 @@ def repeat_info(info, num_facilities, year_range): resid_encoded = pd.get_dummies(resid_info_each_month) owner_info_each_month = repeat_info(expanded_facility_info['A105'], num_facilities, year_range) owner_encoded = pd.get_dummies(owner_info_each_month) - +ftype_info_each_month = repeat_info(expanded_facility_info['Ftype'], num_facilities, year_range) +ftype_encoded = pd.get_dummies(ftype_info_each_month) +print(len(owner_encoded)) # Lagged weather lag_1_month = weather_data_historical.shift(1).values.flatten() lag_3_month = weather_data_historical.shift(3).values.flatten() - +print(year_flattened) X = np.column_stack([ weather_data, year_flattened, @@ -97,15 +99,27 @@ def repeat_info(info, num_facilities, year_range): resid_encoded, zone_encoded, owner_encoded, + ftype_encoded, lag_1_month, lag_3_month ]) #scaler = StandardScaler() # as weather is at such different levels #X_scaled = scaler.fit_transform(X) -results = build_model(X, y, scale_y=False, binomial=False, X_mask_mm = 800) +results = build_model(X, y, scale_y=False, beta=False, X_mask_mm = 1000) print(results.summary()) results = build_model(X, y, X_mask_mm = 800) print(results.summary()) + + +# Collinearity check + +X = sm.add_constant(X) + +# Calculate VIF +vif_data = pd.DataFrame() +vif_data['Variable'] = X.columns +vif_data['VIF'] = [sm.stats.outliers_influence.variance_inflation_factor(X.values, i) for i in range(X.shape[1])] +print(vif_data['VIF']) From 4bccfd258486159be6fc56cd3c210b05c51c8b87 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 18 Oct 2024 14:41:31 +0100 Subject: [PATCH 081/291] Kept at 1000mm level --- ...rical_realtionship_reporting_precipitation.py | 16 +--------------- 1 file changed, 1 insertion(+), 15 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index e8cf5c9312..1bed6683c3 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -2,6 +2,7 @@ import pandas as pd import statsmodels.api as sm from statsmodels.othermod.betareg import BetaModel +from statsmodels.stats.outliers_influence import variance_inflation_factor # # data is from 2011 - 2024 - for facility monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm.csv", index_col=0) @@ -108,18 +109,3 @@ def repeat_info(info, num_facilities, year_range): #X_scaled = scaler.fit_transform(X) results = build_model(X, y, scale_y=False, beta=False, X_mask_mm = 1000) print(results.summary()) - -results = build_model(X, y, X_mask_mm = 800) - -print(results.summary()) - - -# Collinearity check - -X = sm.add_constant(X) - -# Calculate VIF -vif_data = pd.DataFrame() -vif_data['Variable'] = X.columns -vif_data['VIF'] = [sm.stats.outliers_influence.variance_inflation_factor(X.values, i) for i in range(X.shape[1])] -print(vif_data['VIF']) From bfeed74b50005e209ce94894e329ee2fc7d5fcc0 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 21 Oct 2024 09:56:16 +0100 Subject: [PATCH 082/291] Linear model for rain and reporting --- ...al_realtionship_reporting_precipitation.py | 38 +++++++++++++------ 1 file changed, 26 insertions(+), 12 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 1bed6683c3..3ea76db3da 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -39,7 +39,7 @@ def build_model(X, y, scale_y=True, beta=True, X_mask_mm = 0): return model.fit() # One-hot encode facilities -facility_encoded = pd.get_dummies(facility_flattened) +facility_encoded = pd.get_dummies(facility_flattened, drop_first=True) # Above/below average for each month grouped_data = pd.DataFrame({ @@ -78,34 +78,48 @@ def repeat_info(info, num_facilities, year_range): return repeated_info[:-4 * num_facilities] # Exclude first final months (Sept - Dec 2024) zone_info_each_month = repeat_info(expanded_facility_info["Zonename"], num_facilities, year_range) -zone_encoded = pd.get_dummies(zone_info_each_month) +zone_encoded = pd.get_dummies(zone_info_each_month, drop_first=True) resid_info_each_month = repeat_info(expanded_facility_info['Resid'], num_facilities, year_range) -resid_encoded = pd.get_dummies(resid_info_each_month) +resid_encoded = pd.get_dummies(resid_info_each_month, drop_first=True) owner_info_each_month = repeat_info(expanded_facility_info['A105'], num_facilities, year_range) -owner_encoded = pd.get_dummies(owner_info_each_month) +owner_encoded = pd.get_dummies(owner_info_each_month, drop_first=True) ftype_info_each_month = repeat_info(expanded_facility_info['Ftype'], num_facilities, year_range) -ftype_encoded = pd.get_dummies(ftype_info_each_month) -print(len(owner_encoded)) +ftype_encoded = pd.get_dummies(ftype_info_each_month, drop_first=True) + +altitude = [float(x) for x in repeat_info(expanded_facility_info['A109__Altitude'], num_facilities, year_range)] # Lagged weather lag_1_month = weather_data_historical.shift(1).values.flatten() lag_3_month = weather_data_historical.shift(3).values.flatten() -print(year_flattened) X = np.column_stack([ weather_data, year_flattened, month_flattened, above_below_average, - #above_below_X, - #facility_encoded, + above_below_X, + facility_encoded, resid_encoded, zone_encoded, owner_encoded, ftype_encoded, lag_1_month, - lag_3_month + lag_3_month, + altitude +]) + +results = build_model(X, y, scale_y=False, beta=False, X_mask_mm = 1000) +#print(results.summary()) + +# remove facility + +X = np.column_stack([ + weather_data, + year_flattened, + month_flattened, + # lag_1_month, + # lag_3_month, + # altitude ]) -#scaler = StandardScaler() # as weather is at such different levels -#X_scaled = scaler.fit_transform(X) results = build_model(X, y, scale_y=False, beta=False, X_mask_mm = 1000) print(results.summary()) +print(y.mean()) From 9df09d29285d2d6d9a337077d1744a847971a3db Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 21 Oct 2024 15:22:52 +0100 Subject: [PATCH 083/291] Accidentally was comparing latitude and longitude --- .../reporting_and_weather_data_small_facilities.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/src/scripts/climate_change/reporting_and_weather_data_small_facilities.py b/src/scripts/climate_change/reporting_and_weather_data_small_facilities.py index f4574473fa..3410cfa323 100644 --- a/src/scripts/climate_change/reporting_and_weather_data_small_facilities.py +++ b/src/scripts/climate_change/reporting_and_weather_data_small_facilities.py @@ -52,7 +52,6 @@ date = weather_monthly_all_grids['date'][:] print(date) grid = 0 - regridded_weather_data = {} for polygon in malawi_grid["geometry"]: minx, miny, maxx, maxy = polygon.bounds @@ -83,8 +82,12 @@ facilities_with_lat_long['Fname'] == match_name, "A109__Latitude"].iloc[0] long_for_facility = facilities_with_lat_long.loc[ facilities_with_lat_long['Fname'] == match_name, "A109__Longitude"].iloc[0] - index_for_x = ((long_data - lat_for_facility)**2).argmin() - index_for_y= ((lat_data - long_for_facility)**2).argmin() + index_for_x = ((long_data - long_for_facility)**2).argmin() + index_for_y= ((lat_data - lat_for_facility)**2).argmin() + print(lat_for_facility) + print(long_for_facility) + print(index_for_x) + print(index_for_y) precip_data_for_facility = pr_data[:, index_for_y,index_for_x] # across all time points weather_data_by_facility[reporting_facility] = precip_data_for_facility * 86400 # to get from per second to per day From bd9a5213a2201087fa0c4f148447c361106c078c Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 21 Oct 2024 16:40:09 +0100 Subject: [PATCH 084/291] Have correct data now... but association is gone --- ...al_realtionship_reporting_precipitation.py | 30 +++++++------------ 1 file changed, 10 insertions(+), 20 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 3ea76db3da..8727a69f07 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -32,8 +32,9 @@ y = monthly_reporting_by_facility.values.flatten() def build_model(X, y, scale_y=True, beta=True, X_mask_mm = 0): - y += 1e-10 + epsilon = 1e-5 y_scaled = (y / 100) if scale_y else y + y_scaled = np.clip(y_scaled, epsilon, 1 - epsilon) mask = ~np.isnan(X).any(axis=1) & ~np.isnan(y_scaled) & (X[:, 0] >= X_mask_mm) model = BetaModel(y_scaled[mask], X[mask]) if beta else sm.OLS(y_scaled[mask], X[mask]) return model.fit() @@ -85,7 +86,6 @@ def repeat_info(info, num_facilities, year_range): owner_encoded = pd.get_dummies(owner_info_each_month, drop_first=True) ftype_info_each_month = repeat_info(expanded_facility_info['Ftype'], num_facilities, year_range) ftype_encoded = pd.get_dummies(ftype_info_each_month, drop_first=True) - altitude = [float(x) for x in repeat_info(expanded_facility_info['A109__Altitude'], num_facilities, year_range)] # Lagged weather lag_1_month = weather_data_historical.shift(1).values.flatten() @@ -94,32 +94,22 @@ def repeat_info(info, num_facilities, year_range): weather_data, year_flattened, month_flattened, - above_below_average, - above_below_X, - facility_encoded, resid_encoded, zone_encoded, owner_encoded, ftype_encoded, lag_1_month, - lag_3_month, + # lag_3_month, altitude ]) -results = build_model(X, y, scale_y=False, beta=False, X_mask_mm = 1000) -#print(results.summary()) - -# remove facility +results = build_model(X, y, scale_y=False, beta=False, X_mask_mm = 800) -X = np.column_stack([ - weather_data, - year_flattened, - month_flattened, - # lag_1_month, - # lag_3_month, - # altitude -]) +print(results.summary()) -results = build_model(X, y, scale_y=False, beta=False, X_mask_mm = 1000) +##### Try difference in monthly reporting +monthly_reporting_by_facility_diff = monthly_reporting_by_facility.diff() +y_diff = monthly_reporting_by_facility_diff.values.flatten() +results = build_model(X, y_diff, scale_y=True, beta=True) +print(y_diff) print(results.summary()) -print(y.mean()) From 19077e8361b26de691bdb4272b0dc127dc374793 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 21 Oct 2024 16:44:44 +0100 Subject: [PATCH 085/291] Added beta model check --- ...near_model_historical_realtionship_reporting_precipitation.py | 1 + 1 file changed, 1 insertion(+) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 8727a69f07..c238c1bb16 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -104,6 +104,7 @@ def repeat_info(info, num_facilities, year_range): ]) results = build_model(X, y, scale_y=False, beta=False, X_mask_mm = 800) +results = build_model(X, y, scale_y=True, beta=True, X_mask_mm = 00) print(results.summary()) From b57ed4913ea5635af5a5638e4e4f6f178f8c5520 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 22 Oct 2024 11:44:43 +0100 Subject: [PATCH 086/291] plotting --- .../data_retrieval_ERA5_reanalysis_daily.py | 4 +- ...al_realtionship_reporting_precipitation.py | 50 ++++++++++++++---- .../plot_raw_reanalysis_data.py | 52 +++++++++++++++++++ 3 files changed, 93 insertions(+), 13 deletions(-) create mode 100644 src/scripts/climate_change/plot_raw_reanalysis_data.py diff --git a/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py b/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py index b0f79f2303..526dfb10f2 100644 --- a/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py +++ b/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py @@ -10,9 +10,9 @@ if not os.path.exists(year_dir): os.makedirs(year_dir) os.chdir(year_dir) - dataset = "reanalysis-era5-single-levels" + dataset = "derived-era5-single-levels-daily-statistics" request = { - "product_type": ["reanalysis"], + "product_type": "reanalysis", "variable": ["total_precipitation"], "year": year, "month": [ diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index c238c1bb16..dfe71d4e0d 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -13,15 +13,21 @@ weather_data_historical = weather_data_historical.drop(weather_data_historical.index[-1]) monthly_reporting_by_facility = monthly_reporting_by_facility.drop(monthly_reporting_by_facility.index[-1]) +## Drop before 2017 +weather_data_historical = weather_data_historical.iloc[48:] +monthly_reporting_by_facility = monthly_reporting_by_facility.iloc[48:] + ## Linear regression month_range = range(12) num_facilities = len(weather_data_historical.columns) -year_range = range(2011, 2025, 1) # year as a fixed effect +year_range = range(2015, 2025, 1) # year as a fixed effect year_repeated = [y for y in year_range for _ in range(12)] year = year_repeated[:-4] year_flattened = year*len(weather_data_historical.columns) # to get flattened data month = range(12) -month_repeated = [m for m in month for _ in year_range] +month_repeated = [] +for _ in year_range: + month_repeated.extend(range(1, 13)) month = month_repeated[:-4] month_flattened = month*len(weather_data_historical.columns) @@ -90,6 +96,10 @@ def repeat_info(info, num_facilities, year_range): # Lagged weather lag_1_month = weather_data_historical.shift(1).values.flatten() lag_3_month = weather_data_historical.shift(3).values.flatten() + +altitude = np.array(altitude) +altitude = np.where(altitude < 0, np.nan, altitude) +altitude = list(altitude) X = np.column_stack([ weather_data, year_flattened, @@ -99,18 +109,36 @@ def repeat_info(info, num_facilities, year_range): owner_encoded, ftype_encoded, lag_1_month, - # lag_3_month, + lag_3_month, + facility_encoded, altitude ]) +results = build_model(X, y, scale_y=False, beta=False, X_mask_mm = 1000) +#results = build_model(X, y, scale_y=True, beta=True, X_mask_mm = 1000) -results = build_model(X, y, scale_y=False, beta=False, X_mask_mm = 800) -results = build_model(X, y, scale_y=True, beta=True, X_mask_mm = 00) +#print(results.summary()) + +print(sum(X[:, 0] >= 1000)/len(X)) + + +### Now include only significant predictors + +X = np.column_stack([ + weather_data, + year_flattened, + #month_flattened, + #resid_encoded, + #zone_encoded, + #owner_encoded, + #ftype_encoded, + #lag_1_month, + #lag_3_month, + altitude +]) +results = build_model(X, y, scale_y=False, beta=False, X_mask_mm = 1000) -print(results.summary()) -##### Try difference in monthly reporting -monthly_reporting_by_facility_diff = monthly_reporting_by_facility.diff() -y_diff = monthly_reporting_by_facility_diff.values.flatten() -results = build_model(X, y_diff, scale_y=True, beta=True) -print(y_diff) print(results.summary()) + +print(sum(X[:, 0] >= 1000)/len(X)) + diff --git a/src/scripts/climate_change/plot_raw_reanalysis_data.py b/src/scripts/climate_change/plot_raw_reanalysis_data.py new file mode 100644 index 0000000000..ae2d10c483 --- /dev/null +++ b/src/scripts/climate_change/plot_raw_reanalysis_data.py @@ -0,0 +1,52 @@ +import geopandas as gpd +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd +from netCDF4 import Dataset + +# Load the dataset and the variable +file_path = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/139ef85ab4df0a12fc01854395fc9a6d.nc" +dataset = Dataset(file_path, mode='r') +pr_data = dataset.variables['tp'][:] # in kg m-2 s-1 = mm s-1 x 86400 to get to day +time_data = dataset.variables['date'][:] +lat_data = dataset.variables['latitude'][:] +long_data = dataset.variables['longitude'][:] + +## Initial plot +for i in range(len(lat_data)): + for j in range(len(long_data)): + pr_data_time_series_grid_1 = pr_data[:, i, j] + pr_data_time_series_grid_1 *= 86400 # to get to days + plt.plot(pr_data_time_series_grid_1) + +plt.title('Average Precipitation Over Time - Grid ') +plt.ylabel('Precip (mm)') +plt.xlabel('Time') +# plt.show() + + +weather_data_historical = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facility_lm.csv", index_col=0) + +for i in range(len(weather_data_historical.columns)): + plt.plot(weather_data_historical.iloc[:, i], label = weather_data_historical.columns[i]) + +plt.title('Average Precipitation Over Time - Facility ') +plt.ylabel('Precip (mm)') +plt.xlabel('Time') +plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) +plt.show() + + + +monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm.csv", index_col=0) +print(print(monthly_reporting_by_facility.columns) +) +for i in range(len(monthly_reporting_by_facility.columns)): + plt.plot(monthly_reporting_by_facility.iloc[:, i], label = monthly_reporting_by_facility.columns[i]) + +plt.title('Average Reprting Over Time - Facility ') +plt.ylabel('Precip (mm)') +plt.xlabel('Time') +plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) +plt.show() + From d0a6bb7819176fda1a80c072fcb048e9e1be1d1a Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 22 Oct 2024 14:45:50 +0100 Subject: [PATCH 087/291] Plots raw reanalysis data against reporting --- src/scripts/climate_change/plot_raw_reanalysis_data.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/scripts/climate_change/plot_raw_reanalysis_data.py b/src/scripts/climate_change/plot_raw_reanalysis_data.py index ae2d10c483..93537fb177 100644 --- a/src/scripts/climate_change/plot_raw_reanalysis_data.py +++ b/src/scripts/climate_change/plot_raw_reanalysis_data.py @@ -50,3 +50,5 @@ plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) plt.show() + + From 524c9f721c246d3a6c7a8508064d4af22829411e Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 23 Oct 2024 09:16:43 +0100 Subject: [PATCH 088/291] Inlcuded plot of y_pred --- ...al_realtionship_reporting_precipitation.py | 35 ++++++++++++++----- 1 file changed, 26 insertions(+), 9 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index dfe71d4e0d..ab381669ca 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -2,8 +2,7 @@ import pandas as pd import statsmodels.api as sm from statsmodels.othermod.betareg import BetaModel -from statsmodels.stats.outliers_influence import variance_inflation_factor - +import matplotlib.pyplot as plt # # data is from 2011 - 2024 - for facility monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm.csv", index_col=0) weather_data_historical = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facility_lm.csv", index_col=0) @@ -43,7 +42,8 @@ def build_model(X, y, scale_y=True, beta=True, X_mask_mm = 0): y_scaled = np.clip(y_scaled, epsilon, 1 - epsilon) mask = ~np.isnan(X).any(axis=1) & ~np.isnan(y_scaled) & (X[:, 0] >= X_mask_mm) model = BetaModel(y_scaled[mask], X[mask]) if beta else sm.OLS(y_scaled[mask], X[mask]) - return model.fit() + model_fit = model.fit() + return model_fit, model_fit.predict(X[mask]), mask # One-hot encode facilities facility_encoded = pd.get_dummies(facility_flattened, drop_first=True) @@ -74,7 +74,7 @@ def create_binary_feature(threshold, weather_data_df, recent_months): above_below_average = create_binary_feature( grouped_data.groupby(['facility', 'month'])['weather_data'].transform('mean'), weather_data_historical, 0 ) -above_below_X = create_binary_feature(1000, weather_data_historical, 12) +above_below_X = create_binary_feature(2000, weather_data_historical, 12) # Prepare additional facility info expanded_facility_info = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm.csv", index_col=0) @@ -113,10 +113,10 @@ def repeat_info(info, num_facilities, year_range): facility_encoded, altitude ]) -results = build_model(X, y, scale_y=False, beta=False, X_mask_mm = 1000) +results, y_pred, mask = build_model(X, y, scale_y=False, beta=False, X_mask_mm = 1000) #results = build_model(X, y, scale_y=True, beta=True, X_mask_mm = 1000) -#print(results.summary()) +print(results.summary()) print(sum(X[:, 0] >= 1000)/len(X)) @@ -135,10 +135,27 @@ def repeat_info(info, num_facilities, year_range): #lag_3_month, altitude ]) -results = build_model(X, y, scale_y=False, beta=False, X_mask_mm = 1000) - +results, y_pred, mask = build_model(X, y, scale_y=False, beta=False, X_mask_mm = 1000) print(results.summary()) -print(sum(X[:, 0] >= 1000)/len(X)) + +##### Plot y_predic + +X_filtered = X[mask] + +print(len(y_pred)) +print(len(X_filtered)) + +plt.scatter(X_filtered[:, 0], y_pred) + +plt.title('Predicted Reporting Over Time - Facility ') +plt.ylabel('Reporting (%)') +plt.xlabel('Precip (mm)') +plt.ylim(0.9,1) +plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) +plt.show() + + + From 2a8be78af0eec3ceab3ef55c3570ba8f2c19df9f Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 23 Oct 2024 09:19:22 +0100 Subject: [PATCH 089/291] Plot of reporting vs precip --- .../plot_raw_reanalysis_data.py | 20 ++++++++++++++++--- 1 file changed, 17 insertions(+), 3 deletions(-) diff --git a/src/scripts/climate_change/plot_raw_reanalysis_data.py b/src/scripts/climate_change/plot_raw_reanalysis_data.py index 93537fb177..4f6b868ba3 100644 --- a/src/scripts/climate_change/plot_raw_reanalysis_data.py +++ b/src/scripts/climate_change/plot_raw_reanalysis_data.py @@ -39,16 +39,30 @@ monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm.csv", index_col=0) -print(print(monthly_reporting_by_facility.columns) -) + for i in range(len(monthly_reporting_by_facility.columns)): plt.plot(monthly_reporting_by_facility.iloc[:, i], label = monthly_reporting_by_facility.columns[i]) plt.title('Average Reprting Over Time - Facility ') -plt.ylabel('Precip (mm)') +plt.ylabel('Reporting (%)') plt.xlabel('Time') plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) plt.show() +for i in range(len(monthly_reporting_by_facility.columns)): + for j in range(len(monthly_reporting_by_facility.iloc[:, i])): + if weather_data_historical.iloc[j, i] > 1000: + plt.scatter(weather_data_historical.iloc[j, i], monthly_reporting_by_facility.iloc[j, i]) + +plt.title('Average Reprting Over Time - Facility ') +plt.ylabel('Reporting(%)') +plt.xlabel('Precip (mm)') +plt.xlim(1000,4000) +plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) +plt.show() + + + + From 7236ac2e6fa5aa5781d593b9ee48b6efd13ac5f8 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 24 Oct 2024 09:34:05 +0100 Subject: [PATCH 090/291] isort --- .../climate_change/data_retrieval_ERA5_reanalysis_daily.py | 1 + ...r_model_historical_realtionship_reporting_precipitation.py | 3 ++- .../climate_change/reporting_and_weather_data_by_DHO.py | 3 ++- .../reporting_and_weather_data_central_facilities.py | 2 +- .../reporting_and_weather_data_small_facilities.py | 4 ++-- 5 files changed, 8 insertions(+), 5 deletions(-) diff --git a/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py b/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py index 526dfb10f2..f517eb7b9e 100644 --- a/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py +++ b/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py @@ -1,6 +1,7 @@ import os import cdsapi + years = ["2011", "2012", "2013", "2014", "2015", "2016", "2017", "2018", "2019", "2020", "2021", "2022", "2023", "2024"] base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_maximum" diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index ab381669ca..df42eff711 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -1,8 +1,9 @@ +import matplotlib.pyplot as plt import numpy as np import pandas as pd import statsmodels.api as sm from statsmodels.othermod.betareg import BetaModel -import matplotlib.pyplot as plt + # # data is from 2011 - 2024 - for facility monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm.csv", index_col=0) weather_data_historical = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facility_lm.csv", index_col=0) diff --git a/src/scripts/climate_change/reporting_and_weather_data_by_DHO.py b/src/scripts/climate_change/reporting_and_weather_data_by_DHO.py index 471b9c3dd3..e93238cf4f 100644 --- a/src/scripts/climate_change/reporting_and_weather_data_by_DHO.py +++ b/src/scripts/climate_change/reporting_and_weather_data_by_DHO.py @@ -1,9 +1,10 @@ import os +from random import randint import geopandas as gpd import pandas as pd from netCDF4 import Dataset -from random import randint + # Data accessed from https://dhis2.health.gov.mw/dhis-web-data-visualizer/#/YiQK65skxjz # Reporting rate is expected reporting vs actual reporting - for DHO ("by district") reporting_data = pd.read_csv('/Users/rem76/Desktop/Climate_change_health/Data/Reporting_Rate/Reporting_Rate_by_District_DHO_2011_2024.csv') #January 2000 - January 2024 diff --git a/src/scripts/climate_change/reporting_and_weather_data_central_facilities.py b/src/scripts/climate_change/reporting_and_weather_data_central_facilities.py index cc0bfda098..6a2a2d1e5c 100644 --- a/src/scripts/climate_change/reporting_and_weather_data_central_facilities.py +++ b/src/scripts/climate_change/reporting_and_weather_data_central_facilities.py @@ -1,9 +1,9 @@ +import difflib import os import geopandas as gpd import pandas as pd from netCDF4 import Dataset -import difflib # Data accessed from https://dhis2.health.gov.mw/dhis-web-data-visualizer/#/YiQK65skxjz # Reporting rate is expected reporting vs actual reporting diff --git a/src/scripts/climate_change/reporting_and_weather_data_small_facilities.py b/src/scripts/climate_change/reporting_and_weather_data_small_facilities.py index 3410cfa323..c5b7484b9d 100644 --- a/src/scripts/climate_change/reporting_and_weather_data_small_facilities.py +++ b/src/scripts/climate_change/reporting_and_weather_data_small_facilities.py @@ -1,10 +1,10 @@ +import difflib import os import geopandas as gpd +import numpy as np import pandas as pd from netCDF4 import Dataset -import difflib -import numpy as np # Data accessed from https://dhis2.health.gov.mw/dhis-web-data-visualizer/#/YiQK65skxjz # Reporting rate is expected reporting vs actual reporting From 7955ebfd96c6752f585213fcab463512efa67978 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 24 Oct 2024 10:31:31 +0100 Subject: [PATCH 091/291] file to calculate the 5- day average from the historical ERA5 reanalysis data. Daily data with max precip sampled hourly --- .../climate_change/process_daily_max_data.py | 31 +++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 src/scripts/climate_change/process_daily_max_data.py diff --git a/src/scripts/climate_change/process_daily_max_data.py b/src/scripts/climate_change/process_daily_max_data.py new file mode 100644 index 0000000000..f8153f6117 --- /dev/null +++ b/src/scripts/climate_change/process_daily_max_data.py @@ -0,0 +1,31 @@ +import glob +import os +import shutil +import zipfile +from pathlib import Path + +import pandas as pd +from netCDF4 import Dataset + + + +base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_maximum" + +years = range(2011, 2025) + +# access each nc file, and calculate a 5-day cumulative maximum for each month + +for year in years: + year_directory = os.path.join(base_dir, str(year)) + precip_datafile = glob.glob(os.path.join(year_directory, "*.nc")) # only one reanalysis dataset, do not need to loop over files + data_per_model = Dataset(precip_datafile[0], mode='r') + print(data_per_model.variables.keys()) + pr_data = data_per_model.variables['tp'][:] # in kg m-2 s-1 = mm s-1 x 86400 to get to day + lat_data = data_per_model.variables['latitude'][:] + long_data = data_per_model.variables['longitude'][:] + time_days = data_per_model.variables['valid_time'][:] + for j in len(long_data): + for i in len(lat_data): + pr_data_for_square = pr_data[:,i,j] + #### Multiple files + #file_list = glob.glob(os.path.join(nc_file_directory, "*.nc")) From d148786917b9e78e3a8e37740f6f9506ba63852e Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 25 Oct 2024 09:27:53 +0100 Subject: [PATCH 092/291] file to calculate the 5- day average from the historical ERA5 reanalysis data. Daily data with max precip sampled hourly. Returns a csv of the monthly 5-day average max precipitation for each grid square. --- .../climate_change/process_daily_max_data.py | 58 +++++++++++++------ 1 file changed, 40 insertions(+), 18 deletions(-) diff --git a/src/scripts/climate_change/process_daily_max_data.py b/src/scripts/climate_change/process_daily_max_data.py index f8153f6117..55300f3676 100644 --- a/src/scripts/climate_change/process_daily_max_data.py +++ b/src/scripts/climate_change/process_daily_max_data.py @@ -1,31 +1,53 @@ import glob import os -import shutil -import zipfile +from netCDF4 import Dataset from pathlib import Path - import pandas as pd -from netCDF4 import Dataset - - base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_maximum" - years = range(2011, 2025) -# access each nc file, and calculate a 5-day cumulative maximum for each month +# month lengths, account for leap years for February in 2012, 2016, and 2020 +month_lengths = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] +leap_year_month_lengths = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] +window_size = 5 +max_average_by_grid = {} for year in years: year_directory = os.path.join(base_dir, str(year)) - precip_datafile = glob.glob(os.path.join(year_directory, "*.nc")) # only one reanalysis dataset, do not need to loop over files - data_per_model = Dataset(precip_datafile[0], mode='r') - print(data_per_model.variables.keys()) - pr_data = data_per_model.variables['tp'][:] # in kg m-2 s-1 = mm s-1 x 86400 to get to day + precip_datafile = glob.glob(os.path.join(year_directory, "*.nc")) + data_per_model = Dataset(precip_datafile[0], mode='r') + pr_data = data_per_model.variables['tp'][:] # precipitation data in kg m-2 s-1 lat_data = data_per_model.variables['latitude'][:] long_data = data_per_model.variables['longitude'][:] - time_days = data_per_model.variables['valid_time'][:] - for j in len(long_data): - for i in len(lat_data): - pr_data_for_square = pr_data[:,i,j] - #### Multiple files - #file_list = glob.glob(os.path.join(nc_file_directory, "*.nc")) + + if year % 4 == 0 and (year % 100 != 0 or year % 400 == 0): + current_month_lengths = leap_year_month_lengths + else: + current_month_lengths = month_lengths + + grid = 0 + for j in range(len(long_data)): + for i in range(len(lat_data)): + pr_data_for_square = pr_data[:, i, j] + if grid not in max_average_by_grid: + max_average_by_grid[grid] = [] + + begin_day = 0 + for month_idx, month_length in enumerate(current_month_lengths): + days_for_grid = pr_data_for_square[begin_day:begin_day + month_length] + moving_averages = [] + for day in range(month_length - window_size + 1): + window_average = sum(days_for_grid[day:day + window_size]) / window_size + moving_averages.append(window_average) + + max_moving_average = max(moving_averages) + max_average_by_grid[grid].append(max_moving_average* 86400) + + begin_day += month_length + print(len(max_average_by_grid)) + grid += 1 + +df = pd.DataFrame.from_dict(max_average_by_grid, orient='index') +df = df.T +df.to_csv(Path(base_dir)/"historical_daily_max_by_grid.csv") From 83c54146a2457a68b415d9215f1db553184fc2f9 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 25 Oct 2024 09:28:03 +0100 Subject: [PATCH 093/291] renamed --- ...y_DHO.py => reporting_and_monthly_weather_data_by_DHO.py} | 0 ...reporting_and_monthly_weather_data_central_facilities.py} | 0 ...> reporting_and_monthly_weather_data_small_facilities.py} | 5 +---- 3 files changed, 1 insertion(+), 4 deletions(-) rename src/scripts/climate_change/{reporting_and_weather_data_by_DHO.py => reporting_and_monthly_weather_data_by_DHO.py} (100%) rename src/scripts/climate_change/{reporting_and_weather_data_central_facilities.py => reporting_and_monthly_weather_data_central_facilities.py} (100%) rename src/scripts/climate_change/{reporting_and_weather_data_small_facilities.py => reporting_and_monthly_weather_data_small_facilities.py} (98%) diff --git a/src/scripts/climate_change/reporting_and_weather_data_by_DHO.py b/src/scripts/climate_change/reporting_and_monthly_weather_data_by_DHO.py similarity index 100% rename from src/scripts/climate_change/reporting_and_weather_data_by_DHO.py rename to src/scripts/climate_change/reporting_and_monthly_weather_data_by_DHO.py diff --git a/src/scripts/climate_change/reporting_and_weather_data_central_facilities.py b/src/scripts/climate_change/reporting_and_monthly_weather_data_central_facilities.py similarity index 100% rename from src/scripts/climate_change/reporting_and_weather_data_central_facilities.py rename to src/scripts/climate_change/reporting_and_monthly_weather_data_central_facilities.py diff --git a/src/scripts/climate_change/reporting_and_weather_data_small_facilities.py b/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py similarity index 98% rename from src/scripts/climate_change/reporting_and_weather_data_small_facilities.py rename to src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py index c5b7484b9d..0acdac5de8 100644 --- a/src/scripts/climate_change/reporting_and_weather_data_small_facilities.py +++ b/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py @@ -71,6 +71,7 @@ facilities_with_lat_long = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_lat_long_region.csv") + weather_data_by_facility = {} facilities_with_location = [] for reporting_facility in monthly_reporting_by_facility["facility"]: @@ -84,10 +85,6 @@ facilities_with_lat_long['Fname'] == match_name, "A109__Longitude"].iloc[0] index_for_x = ((long_data - long_for_facility)**2).argmin() index_for_y= ((lat_data - lat_for_facility)**2).argmin() - print(lat_for_facility) - print(long_for_facility) - print(index_for_x) - print(index_for_y) precip_data_for_facility = pr_data[:, index_for_y,index_for_x] # across all time points weather_data_by_facility[reporting_facility] = precip_data_for_facility * 86400 # to get from per second to per day From 606be18da69526176282834a423e0c09018d9703 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 25 Oct 2024 10:15:05 +0100 Subject: [PATCH 094/291] added association to facilities based on grid squares --- .../climate_change/process_daily_max_data.py | 91 ++++++++++++++++--- 1 file changed, 80 insertions(+), 11 deletions(-) diff --git a/src/scripts/climate_change/process_daily_max_data.py b/src/scripts/climate_change/process_daily_max_data.py index 55300f3676..62ef859b35 100644 --- a/src/scripts/climate_change/process_daily_max_data.py +++ b/src/scripts/climate_change/process_daily_max_data.py @@ -3,13 +3,44 @@ from netCDF4 import Dataset from pathlib import Path import pandas as pd +import geopandas as gpd +import difflib +# facility data +general_facilities = gpd.read_file("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_districts.shp") + +facilities_with_lat_long = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_lat_long_region.csv") + +# Data accessed from https://dhis2.health.gov.mw/dhis-web-data-visualizer/#/YiQK65skxjz +# Reporting rate is expected reporting vs actual reporting +reporting_data = pd.read_csv('/Users/rem76/Desktop/Climate_change_health/Data/Reporting_Rate/Reporting_Rate_by_smaller_facilities_2011_2024.csv') #January 2011 - January 2024 +# ANALYSIS DONE IN OCTOBER 2024 - so drop October, November, December 2024 +columns_to_drop = reporting_data.columns[reporting_data.columns.str.endswith(('October 2024', 'November 2024', 'December 2024'))] +reporting_data = reporting_data.drop(columns=columns_to_drop) +# drop NAs +reporting_data = reporting_data.dropna(subset = reporting_data.columns[3:], how='all') # drops 90 clinics +### now aggregate over months +monthly_reporting_data_by_facility = {} +months = set(col.split(" - Reporting rate ")[1] for col in reporting_data.columns if " - Reporting rate " in col) + +# put in order +months = [date.strip() for date in months] # extra spaces?? +dates = pd.to_datetime(months, format='%B %Y', errors='coerce') +months = dates.sort_values().strftime('%B %Y').tolist() # puts them in ascending order +for month in months: + columns_of_interest_all_metrics = [reporting_data.columns[1]] + reporting_data.columns[reporting_data.columns.str.endswith(month)].tolist() + data_of_interest_by_month = reporting_data[columns_of_interest_all_metrics] + numeric_data = data_of_interest_by_month.select_dtypes(include='number') + monthly_mean_by_facility = numeric_data.mean(axis=1) + monthly_reporting_data_by_facility[month] = monthly_mean_by_facility +monthly_reporting_by_facility = pd.DataFrame(monthly_reporting_data_by_facility) +monthly_reporting_by_facility["facility"] = reporting_data["organisationunitname"].values + +# historical weather directory base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_maximum" -years = range(2011, 2025) -# month lengths, account for leap years for February in 2012, 2016, and 2020 +years = range(2011, 2025) month_lengths = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] -leap_year_month_lengths = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] window_size = 5 max_average_by_grid = {} @@ -20,12 +51,6 @@ pr_data = data_per_model.variables['tp'][:] # precipitation data in kg m-2 s-1 lat_data = data_per_model.variables['latitude'][:] long_data = data_per_model.variables['longitude'][:] - - if year % 4 == 0 and (year % 100 != 0 or year % 400 == 0): - current_month_lengths = leap_year_month_lengths - else: - current_month_lengths = month_lengths - grid = 0 for j in range(len(long_data)): for i in range(len(lat_data)): @@ -34,7 +59,7 @@ max_average_by_grid[grid] = [] begin_day = 0 - for month_idx, month_length in enumerate(current_month_lengths): + for month_idx, month_length in enumerate(month_lengths): days_for_grid = pr_data_for_square[begin_day:begin_day + month_length] moving_averages = [] for day in range(month_length - window_size + 1): @@ -45,9 +70,53 @@ max_average_by_grid[grid].append(max_moving_average* 86400) begin_day += month_length - print(len(max_average_by_grid)) grid += 1 df = pd.DataFrame.from_dict(max_average_by_grid, orient='index') df = df.T df.to_csv(Path(base_dir)/"historical_daily_max_by_grid.csv") + + +########## add in reporting data ################## + +max_average_by_facility = {} +for year in years: + year_directory = os.path.join(base_dir, str(year)) + precip_datafile = glob.glob(os.path.join(year_directory, "*.nc")) + data_per_model = Dataset(precip_datafile[0], mode='r') + pr_data = data_per_model.variables['tp'][:] # precipitation data in kg m-2 s-1 + lat_data = data_per_model.variables['latitude'][:] + long_data = data_per_model.variables['longitude'][:] + # loop over clinics + for reporting_facility in monthly_reporting_by_facility["facility"]: + matching_facility_name = difflib.get_close_matches(reporting_facility, facilities_with_lat_long['Fname'], n=3, + cutoff=0.90) + if matching_facility_name: + match_name = matching_facility_name[0] # Access the string directly + # Initialize facility key if not already + if reporting_facility not in max_average_by_facility: + max_average_by_facility[reporting_facility] = [] + lat_for_facility = facilities_with_lat_long.loc[ + facilities_with_lat_long['Fname'] == match_name, "A109__Latitude"].iloc[0] + long_for_facility = facilities_with_lat_long.loc[ + facilities_with_lat_long['Fname'] == match_name, "A109__Longitude"].iloc[0] + index_for_x = ((long_data - long_for_facility) ** 2).argmin() + index_for_y = ((lat_data - lat_for_facility) ** 2).argmin() + pr_data_for_square = pr_data[:, index_for_y, index_for_x] + begin_day = 0 + for month_idx, month_length in enumerate(month_lengths): + days_for_grid = pr_data_for_square[begin_day:begin_day + month_length] + moving_averages = [] + for day in range(month_length - window_size + 1): + window_average = sum(days_for_grid[day:day + window_size]) / window_size + moving_averages.append(window_average) + + max_moving_average = max(moving_averages) + max_average_by_facility[reporting_facility].append(max_moving_average * 86400) + + begin_day += month_length +# +print(max_average_by_facility) +df_of_facilities = pd.DataFrame.from_dict(max_average_by_facility, orient='index') +df_of_facilities = df_of_facilities.T +df_of_facilities.to_csv(Path(base_dir) / "historical_daily_max_by_facility.csv") From 1c02b9670ebcd1518f9790004d981d4d47fd578b Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 25 Oct 2024 10:29:56 +0100 Subject: [PATCH 095/291] changed to remove oct 2024 --- src/scripts/climate_change/process_daily_max_data.py | 1 + 1 file changed, 1 insertion(+) diff --git a/src/scripts/climate_change/process_daily_max_data.py b/src/scripts/climate_change/process_daily_max_data.py index 62ef859b35..e06884d4a9 100644 --- a/src/scripts/climate_change/process_daily_max_data.py +++ b/src/scripts/climate_change/process_daily_max_data.py @@ -118,5 +118,6 @@ # print(max_average_by_facility) df_of_facilities = pd.DataFrame.from_dict(max_average_by_facility, orient='index') +df_of_facilities = df_of_facilities.iloc[:, :-3] ## THESE ARE OCT/NOV/DEC OF 2024, and for moment don't have that reporting data df_of_facilities = df_of_facilities.T df_of_facilities.to_csv(Path(base_dir) / "historical_daily_max_by_facility.csv") From 6e54dabd651aabfd88a31e23a395b2e48dfa80a1 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 25 Oct 2024 11:54:42 +0100 Subject: [PATCH 096/291] changed so that a seperate file is created if it is using the ANC data --- .../climate_change/process_daily_max_data.py | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/src/scripts/climate_change/process_daily_max_data.py b/src/scripts/climate_change/process_daily_max_data.py index e06884d4a9..160b6d0ff0 100644 --- a/src/scripts/climate_change/process_daily_max_data.py +++ b/src/scripts/climate_change/process_daily_max_data.py @@ -6,6 +6,7 @@ import geopandas as gpd import difflib +ANC = False # facility data general_facilities = gpd.read_file("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_districts.shp") @@ -13,7 +14,10 @@ # Data accessed from https://dhis2.health.gov.mw/dhis-web-data-visualizer/#/YiQK65skxjz # Reporting rate is expected reporting vs actual reporting -reporting_data = pd.read_csv('/Users/rem76/Desktop/Climate_change_health/Data/Reporting_Rate/Reporting_Rate_by_smaller_facilities_2011_2024.csv') #January 2011 - January 2024 +if ANC: + reporting_data = pd.read_csv('/Users/rem76/Desktop/Climate_change_health/Data/ANC_data/ANC_data_2011_2024.csv') #January 2011 - January 2024 +else: + reporting_data = pd.read_csv('/Users/rem76/Desktop/Climate_change_health/Data/Reporting_Rate/Reporting_Rate_by_smaller_facilities_2011_2024.csv') #January 2011 - January 2024 # ANALYSIS DONE IN OCTOBER 2024 - so drop October, November, December 2024 columns_to_drop = reporting_data.columns[reporting_data.columns.str.endswith(('October 2024', 'November 2024', 'December 2024'))] reporting_data = reporting_data.drop(columns=columns_to_drop) @@ -120,4 +124,9 @@ df_of_facilities = pd.DataFrame.from_dict(max_average_by_facility, orient='index') df_of_facilities = df_of_facilities.iloc[:, :-3] ## THESE ARE OCT/NOV/DEC OF 2024, and for moment don't have that reporting data df_of_facilities = df_of_facilities.T -df_of_facilities.to_csv(Path(base_dir) / "historical_daily_max_by_facility.csv") + +if ANC: + df_of_facilities.to_csv(Path(base_dir) / "historical_daily_max_by_facilities_with_ANC.csv") +else: + df_of_facilities.to_csv(Path(base_dir) / "historical_daily_max_by_facility.csv") + From 123099394bec5ea6fd1cea36be635054fb8382a3 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 25 Oct 2024 12:08:17 +0100 Subject: [PATCH 097/291] Reduced window to max weather for that month --- src/scripts/climate_change/process_daily_max_data.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/scripts/climate_change/process_daily_max_data.py b/src/scripts/climate_change/process_daily_max_data.py index 160b6d0ff0..42456247bf 100644 --- a/src/scripts/climate_change/process_daily_max_data.py +++ b/src/scripts/climate_change/process_daily_max_data.py @@ -45,7 +45,7 @@ years = range(2011, 2025) month_lengths = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] -window_size = 5 +window_size = 1 max_average_by_grid = {} for year in years: From feaa71a490fec95b6c639300f12256d1ee8d443f Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 25 Oct 2024 12:08:35 +0100 Subject: [PATCH 098/291] Added check to see if it was ANC data, so then changed how files were written --- ...d_monthly_weather_data_small_facilities.py | 24 +++++++++++++++---- 1 file changed, 20 insertions(+), 4 deletions(-) diff --git a/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py b/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py index 0acdac5de8..4fd1cc486b 100644 --- a/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py +++ b/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py @@ -8,15 +8,26 @@ # Data accessed from https://dhis2.health.gov.mw/dhis-web-data-visualizer/#/YiQK65skxjz # Reporting rate is expected reporting vs actual reporting -reporting_data = pd.read_csv('/Users/rem76/Desktop/Climate_change_health/Data/Reporting_Rate/Reporting_Rate_by_smaller_facilities_2011_2024.csv') #January 2011 - January 2024 +ANC = True +if ANC: + reporting_data = pd.read_csv('/Users/rem76/Desktop/Climate_change_health/Data/ANC_data/ANC_data_2011_2024.csv') +else: + reporting_data = pd.read_csv('/Users/rem76/Desktop/Climate_change_health/Data/Reporting_Rate/Reporting_Rate_by_smaller_facilities_2011_2024.csv') #January 2011 - January 2024 + # ANALYSIS DONE IN OCTOBER 2024 - so drop October, November, December 2024 columns_to_drop = reporting_data.columns[reporting_data.columns.str.endswith(('October 2024', 'November 2024', 'December 2024'))] reporting_data = reporting_data.drop(columns=columns_to_drop) # drop NAs reporting_data = reporting_data.dropna(subset = reporting_data.columns[3:], how='all') # drops 90 clinics + ### now aggregate over months monthly_reporting_data_by_facility = {} -months = set(col.split(" - Reporting rate ")[1] for col in reporting_data.columns if " - Reporting rate " in col) + +if ANC: + months = set(col.split("HMIS Total Antenatal Visits ")[1] for col in reporting_data.columns if "HMIS Total Antenatal Visits " in col) + +else: + months = set(col.split(" - Reporting rate ")[1] for col in reporting_data.columns if " - Reporting rate " in col) # put in order months = [date.strip() for date in months] # extra spaces?? @@ -50,7 +61,6 @@ lat_data = weather_monthly_all_grids.variables['latitude'][:] long_data = weather_monthly_all_grids.variables['longitude'][:] date = weather_monthly_all_grids['date'][:] -print(date) grid = 0 regridded_weather_data = {} for polygon in malawi_grid["geometry"]: @@ -109,7 +119,13 @@ monthly_reporting_by_facility = monthly_reporting_by_facility.loc[:, monthly_reporting_by_facility.columns.isin(facilities_with_location)] monthly_reporting_by_facility = monthly_reporting_by_facility[facilities_with_location] -monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm.csv") +#monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm.csv") +if ANC: + monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_ANC_by_smaller_facility_lm.csv") +else: + monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm.csv") + + weather_df.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facility_lm.csv") ## Get additional data - e.g. which zone it is in, altitude From 50fc2aa4532f336134ef3fa4a775d9c22fc724f6 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 25 Oct 2024 12:08:46 +0100 Subject: [PATCH 099/291] Added check to see if it was ANC data, so then changed how files were written --- ...al_realtionship_reporting_precipitation.py | 61 +++++++++++-------- 1 file changed, 36 insertions(+), 25 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index df42eff711..7310f61474 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -4,23 +4,35 @@ import statsmodels.api as sm from statsmodels.othermod.betareg import BetaModel -# # data is from 2011 - 2024 - for facility -monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm.csv", index_col=0) -weather_data_historical = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facility_lm.csv", index_col=0) - -## Drop September 2024 +ANC = True +daily_max = True +min_year_for_analyis = 2011 +absolute_min_year = 2011 +# # data is from 2011 - 2024 - for facility +if ANC: + monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_ANC_by_smaller_facility_lm.csv", index_col=0) +else: + monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm.csv", index_col=0) + +if daily_max: + weather_data_historical = pd.read_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_maximum/historical_daily_max_by_facilities_with_ANC.csv", + index_col=0) +else: + weather_data_historical = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facility_lm.csv", index_col=0) + +## Drop September 2024 - weather_data_historical = weather_data_historical.drop(weather_data_historical.index[-1]) monthly_reporting_by_facility = monthly_reporting_by_facility.drop(monthly_reporting_by_facility.index[-1]) ## Drop before 2017 -weather_data_historical = weather_data_historical.iloc[48:] -monthly_reporting_by_facility = monthly_reporting_by_facility.iloc[48:] - +weather_data_historical = weather_data_historical.iloc[(min_year_for_analyis-absolute_min_year)*12 :] +monthly_reporting_by_facility = monthly_reporting_by_facility.iloc[(min_year_for_analyis-absolute_min_year)*12:] ## Linear regression month_range = range(12) num_facilities = len(weather_data_historical.columns) -year_range = range(2015, 2025, 1) # year as a fixed effect +year_range = range(min_year_for_analyis, 2025, 1) # year as a fixed effect year_repeated = [y for y in year_range for _ in range(12)] year = year_repeated[:-4] year_flattened = year*len(weather_data_historical.columns) # to get flattened data @@ -75,7 +87,7 @@ def create_binary_feature(threshold, weather_data_df, recent_months): above_below_average = create_binary_feature( grouped_data.groupby(['facility', 'month'])['weather_data'].transform('mean'), weather_data_historical, 0 ) -above_below_X = create_binary_feature(2000, weather_data_historical, 12) +above_below_X = create_binary_feature(1000, weather_data_historical, 12) # Prepare additional facility info expanded_facility_info = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm.csv", index_col=0) @@ -101,6 +113,7 @@ def repeat_info(info, num_facilities, year_range): altitude = np.array(altitude) altitude = np.where(altitude < 0, np.nan, altitude) altitude = list(altitude) + X = np.column_stack([ weather_data, year_flattened, @@ -114,29 +127,26 @@ def repeat_info(info, num_facilities, year_range): facility_encoded, altitude ]) -results, y_pred, mask = build_model(X, y, scale_y=False, beta=False, X_mask_mm = 1000) +results, y_pred, mask = build_model(X, y, scale_y=False, beta=False, X_mask_mm = 000) #results = build_model(X, y, scale_y=True, beta=True, X_mask_mm = 1000) print(results.summary()) -print(sum(X[:, 0] >= 1000)/len(X)) - ### Now include only significant predictors - X = np.column_stack([ weather_data, year_flattened, - #month_flattened, - #resid_encoded, - #zone_encoded, - #owner_encoded, - #ftype_encoded, - #lag_1_month, - #lag_3_month, - altitude + month_flattened, + # resid_encoded, + # zone_encoded, + # owner_encoded, + # ftype_encoded, + # lag_1_month, + # lag_3_month, + # altitude ]) -results, y_pred, mask = build_model(X, y, scale_y=False, beta=False, X_mask_mm = 1000) +results, y_pred, mask = build_model(X, y, scale_y=False, beta=False, X_mask_mm = 000) print(results.summary()) @@ -147,11 +157,12 @@ def repeat_info(info, num_facilities, year_range): print(len(y_pred)) print(len(X_filtered)) +print(len(X_filtered)/len(X) * 100) plt.scatter(X_filtered[:, 0], y_pred) -plt.title('Predicted Reporting Over Time - Facility ') -plt.ylabel('Reporting (%)') +plt.title(' ') +plt.ylabel('Number of ANC visits (%)') plt.xlabel('Precip (mm)') plt.ylim(0.9,1) plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) From 6c45d2beb48f16d3007dc3f531ed0147d06cbc23 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 25 Oct 2024 14:19:37 +0100 Subject: [PATCH 100/291] Added new weather data writing to account for the fact there are different facilities reporting ANC and reporting % --- .../reporting_and_monthly_weather_data_small_facilities.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py b/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py index 4fd1cc486b..77a12561d3 100644 --- a/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py +++ b/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py @@ -122,11 +122,14 @@ #monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm.csv") if ANC: monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_ANC_by_smaller_facility_lm.csv") + weather_df.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_ANC_lm.csv") + else: monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm.csv") + weather_df.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facility_lm.csv") + -weather_df.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facility_lm.csv") ## Get additional data - e.g. which zone it is in, altitude included_facilities_with_lat_long = facilities_with_lat_long[ From 7bef017793fb168289bb709aca4620690f0dfb0d Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 25 Oct 2024 14:36:14 +0100 Subject: [PATCH 101/291] Allowed for toggle between ANC/reporting and daily max/monthly --- ...al_realtionship_reporting_precipitation.py | 69 +++++++++++++------ 1 file changed, 48 insertions(+), 21 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 7310f61474..26b6ff2bae 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -6,21 +6,31 @@ ANC = True -daily_max = True +daily_max = False min_year_for_analyis = 2011 absolute_min_year = 2011 # # data is from 2011 - 2024 - for facility if ANC: monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_ANC_by_smaller_facility_lm.csv", index_col=0) -else: - monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm.csv", index_col=0) + if daily_max: + weather_data_historical = pd.read_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_maximum/historical_daily_max_by_facilities_with_ANC.csv", + index_col=0) + else: + weather_data_historical = pd.read_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_ANC_lm.csv", + index_col=0) -if daily_max: - weather_data_historical = pd.read_csv( - "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_maximum/historical_daily_max_by_facilities_with_ANC.csv", - index_col=0) else: - weather_data_historical = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facility_lm.csv", index_col=0) + monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm.csv", index_col=0) + if daily_max: + weather_data_historical = pd.read_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_maximum/historical_daily_max_by_facility.csv", + index_col=0) + else: + weather_data_historical = pd.read_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facility_lm.csv", + index_col=0) ## Drop September 2024 - weather_data_historical = weather_data_historical.drop(weather_data_historical.index[-1]) @@ -48,11 +58,12 @@ # Flatten data weather_data = weather_data_historical.values.flatten() y = monthly_reporting_by_facility.values.flatten() - -def build_model(X, y, scale_y=True, beta=True, X_mask_mm = 0): +def build_model(X, y, scale_y=False, beta=False, X_mask_mm = 0): epsilon = 1e-5 - y_scaled = (y / 100) if scale_y else y - y_scaled = np.clip(y_scaled, epsilon, 1 - epsilon) + if scale_y: + y_scaled = np.clip(y / 100, epsilon, 1 - epsilon) + else: + y_scaled = y mask = ~np.isnan(X).any(axis=1) & ~np.isnan(y_scaled) & (X[:, 0] >= X_mask_mm) model = BetaModel(y_scaled[mask], X[mask]) if beta else sm.OLS(y_scaled[mask], X[mask]) model_fit = model.fit() @@ -127,7 +138,7 @@ def repeat_info(info, num_facilities, year_range): facility_encoded, altitude ]) -results, y_pred, mask = build_model(X, y, scale_y=False, beta=False, X_mask_mm = 000) +results, y_pred, mask = build_model(X, y, X_mask_mm = 800) #results = build_model(X, y, scale_y=True, beta=True, X_mask_mm = 1000) print(results.summary()) @@ -145,8 +156,9 @@ def repeat_info(info, num_facilities, year_range): # lag_1_month, # lag_3_month, # altitude + above_below_X ]) -results, y_pred, mask = build_model(X, y, scale_y=False, beta=False, X_mask_mm = 000) +results, y_pred, mask = build_model(X, y, X_mask_mm = 800) print(results.summary()) @@ -158,15 +170,30 @@ def repeat_info(info, num_facilities, year_range): print(len(y_pred)) print(len(X_filtered)) print(len(X_filtered)/len(X) * 100) +print(len(y[mask])) +print(len(y_pred)) + + +if ANC: + plt.scatter(X_filtered[:, 0], y[mask], color='red', alpha=0.5) + plt.scatter(X_filtered[:, 0], y_pred) + plt.title(' ') + plt.ylabel('Number of ANC visits') + plt.xlabel('Precip (mm)') + plt.ylim(0,1000) + plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) + plt.show() +else: -plt.scatter(X_filtered[:, 0], y_pred) + plt.scatter(X_filtered[:, 0], y[mask], color='red', alpha=0.5) + plt.scatter(X_filtered[:, 0], y_pred) + plt.title(' ') + plt.ylabel('Reporting (%)') + plt.xlabel('Precip (mm)') + plt.ylim(0, 100) + plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) + plt.show() -plt.title(' ') -plt.ylabel('Number of ANC visits (%)') -plt.xlabel('Precip (mm)') -plt.ylim(0.9,1) -plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) -plt.show() From 0cb6086b2cc04a363370ca72d30b9a1035862695 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 6 Nov 2024 11:37:28 +0000 Subject: [PATCH 102/291] made more flexible for going between model scenarios --- .../aggregate_processs_CMIP6_data.py | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-) diff --git a/src/scripts/climate_change/aggregate_processs_CMIP6_data.py b/src/scripts/climate_change/aggregate_processs_CMIP6_data.py index a0e3a54796..826d1e60b1 100644 --- a/src/scripts/climate_change/aggregate_processs_CMIP6_data.py +++ b/src/scripts/climate_change/aggregate_processs_CMIP6_data.py @@ -10,11 +10,20 @@ from netCDF4 import Dataset base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/" - +scenario = "ssp2_4_5" #"ssp1_1_9" #### Multiple files file_list = glob.glob(os.path.join(base_dir, "*.nc")) data_by_model_and_grid = {} -models = ["cams_csm1_0", "ipsl_cm6a_lr", "miroc6","miroc_es2l", "mri_esm2_0", "canesm5", "cnrm_esm2_1", "ec_earth3", "ec_earth3_veg_lr", "fgoals_g3", "gfdl_esm4", "ukesm1_0_ll"] +if scenario == "ssp1_1_9": + models = ["cams_csm1_0", "ipsl_cm6a_lr", "miroc6", "miroc_es2l", "mri_esm2_0", "canesm5", "cnrm_esm2_1", + "ec_earth3", "ec_earth3_veg_lr", "fgoals_g3", "gfdl_esm4", "ukesm1_0_ll"] +elif scenario == "ssp2_4_5": + models = ["access_cm2", "awi_cm_1_1_mr", "bcc_csm2_mr", "cams_csm1_0", "cmcc_esm2", "hadgem3_gc31_ll", + "iitm_esm", "inm_cm5_0", "ipsl_cm6a_lr", "kiost_esm", "miroc6", "miroc_es2l", + "mri_esm2_0", "noresm2_mm", "canesm5", "cesm2", "cmcc_cm2_sr5", "cnrm_cm6_1", "cnrm_esm2_1", + "ec_earth3_cc", "ec_earth3_veg_lr", "fgoals_g3", + "gfdl_esm4", "inm_cm4_8", "kace_1_0_g", "mpi_esm1_2_lr", "nesm3", "noresm2_lm", "ukesm1_0_ll"] + model = 0 for file in glob.glob(os.path.join(base_dir, "*.nc")): data_per_model = Dataset(file, mode='r') @@ -33,4 +42,4 @@ model += 1 print(data_by_model_and_grid) data_by_model_and_grid = pd.DataFrame.from_dict(data_by_model_and_grid) -data_by_model_and_grid.to_csv(Path(scenario_directory)/"data_by_model_and_grid.csv") +#data_by_model_and_grid.to_csv(Path(scenario_directory)/"data_by_model_and_grid_CMIP6_projections.csv") From 603e96c8f7d26b0cbe4238fabb826f12f52524f0 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 7 Nov 2024 10:46:09 +0000 Subject: [PATCH 103/291] Changed to allow for ssp245 Still have not aggregated across grids --- .../aggregate_processs_CMIP6_data.py | 11 ++++-- .../climate_change/process_CMIP6_data.py | 35 +++++++++++++++---- 2 files changed, 36 insertions(+), 10 deletions(-) diff --git a/src/scripts/climate_change/aggregate_processs_CMIP6_data.py b/src/scripts/climate_change/aggregate_processs_CMIP6_data.py index 826d1e60b1..c28aeab3dd 100644 --- a/src/scripts/climate_change/aggregate_processs_CMIP6_data.py +++ b/src/scripts/climate_change/aggregate_processs_CMIP6_data.py @@ -11,6 +11,9 @@ base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/" scenario = "ssp2_4_5" #"ssp1_1_9" +scenario_directory = base_dir + scenario + "/" + + #### Multiple files file_list = glob.glob(os.path.join(base_dir, "*.nc")) data_by_model_and_grid = {} @@ -25,8 +28,10 @@ "gfdl_esm4", "inm_cm4_8", "kace_1_0_g", "mpi_esm1_2_lr", "nesm3", "noresm2_lm", "ukesm1_0_ll"] model = 0 -for file in glob.glob(os.path.join(base_dir, "*.nc")): +nc_file_directory = os.path.join(scenario_directory, 'nc_files') +for file in glob.glob(os.path.join(nc_file_directory, "*.nc")): data_per_model = Dataset(file, mode='r') + print(data_per_model.variables) pr_data = data_per_model.variables['pr'][:] # in kg m-2 s-1 = mm s-1 x 86400 to get to day lat_data = data_per_model.variables['lat'][:] long_data = data_per_model.variables['lon'][:] @@ -34,7 +39,7 @@ grid = 0 for i in range(len(long_data)): for j in range(len(lat_data)): - precip_data_for_grid = pr_data[:,i,j] # across all time points + precip_data_for_grid = pr_data[:,j,i] # across all time points precip_data_for_grid = precip_data_for_grid * 86400 # to get from per second to per day grid_dictionary[grid] = precip_data_for_grid grid += 1 @@ -42,4 +47,4 @@ model += 1 print(data_by_model_and_grid) data_by_model_and_grid = pd.DataFrame.from_dict(data_by_model_and_grid) -#data_by_model_and_grid.to_csv(Path(scenario_directory)/"data_by_model_and_grid_CMIP6_projections.csv") +data_by_model_and_grid.to_csv(Path(scenario_directory)/"data_by_model_and_grid_CMIP6_projections.csv") diff --git a/src/scripts/climate_change/process_CMIP6_data.py b/src/scripts/climate_change/process_CMIP6_data.py index e9229fbb0a..24df4f925d 100644 --- a/src/scripts/climate_change/process_CMIP6_data.py +++ b/src/scripts/climate_change/process_CMIP6_data.py @@ -11,17 +11,23 @@ def unzip_all_in_directory(directory): """ Unzips all .zip files in the specified directory, extracting each into a separate folder. + Parameters: directory (str): The path to the folder containing the .zip files. """ for filename in os.listdir(directory): + print(f"Processing {filename}") if filename.endswith('.zip'): file_path = os.path.join(directory, filename) extract_dir = os.path.join(directory, filename[:-4]) os.makedirs(extract_dir, exist_ok=True) - with zipfile.ZipFile(file_path, 'r') as zip_ref: - zip_ref.extractall(extract_dir) + try: + with zipfile.ZipFile(file_path, 'r') as zip_ref: + zip_ref.extractall(extract_dir) + print(f"Extracted {filename} to {extract_dir}") + except zipfile.BadZipFile: + print(f"Skipped {filename}: not a valid zip file.") def extract_nc_files_from_unzipped_folders(directory): @@ -31,18 +37,24 @@ def extract_nc_files_from_unzipped_folders(directory): Parameters: directory (str): The path to the folder containing the unzipped folders. - output_directory (str): The path to the folder where .nc files should be copied. """ output_directory = os.path.join(directory, 'nc_files') if not os.path.exists(output_directory): os.makedirs(output_directory) + for root, _, files in os.walk(directory): + # Skip the output directory to prevent recursive copying + if root == output_directory: + continue + for filename in files: if filename.endswith('.nc'): source_file_path = os.path.join(root, filename) - shutil.copy2(source_file_path, output_directory) - + destination_file_path = os.path.join(output_directory, filename) + # Only copy if the file does not already exist in the output directory + if not os.path.exists(destination_file_path): + shutil.copy2(source_file_path, output_directory) # unzip files and extract the netCDF files @@ -50,6 +62,7 @@ def extract_nc_files_from_unzipped_folders(directory): base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/" scenarios = ["ssp1_1_9"] #,"ssp1_2_6", "ssp4_3_4", "ssp5_3_4OS", "ssp2_4_5", "ssp4_6_0", "ssp3_7_0", "ssp5_8_5"] +scenarios = ["ssp2_4_5"] for scenario in scenarios: scenario_directory = os.path.join(base_dir, scenario) unzip_all_in_directory(scenario_directory) @@ -59,13 +72,21 @@ def extract_nc_files_from_unzipped_folders(directory): # Put all into one csv file base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/" -scenario = "ssp1_1_9" +scenario = scenarios[0] scenario_directory = os.path.join(base_dir, scenario) nc_file_directory = os.path.join(scenario_directory, 'nc_files') #### Multiple files file_list = glob.glob(os.path.join(nc_file_directory, "*.nc")) data_by_model_and_grid = {} -models = ["cams_csm1_0", "ipsl_cm6a_lr", "miroc6","miroc_es2l", "mri_esm2_0", "canesm5", "cnrm_esm2_1", "ec_earth3", "ec_earth3_veg_lr", "fgoals_g3", "gfdl_esm4", "ukesm1_0_ll"] +if scenario == "ssp1_1_9": + models = ["cams_csm1_0", "ipsl_cm6a_lr", "miroc6", "miroc_es2l", "mri_esm2_0", "canesm5", "cnrm_esm2_1", + "ec_earth3", "ec_earth3_veg_lr", "fgoals_g3", "gfdl_esm4", "ukesm1_0_ll"] +elif scenario == "ssp2_4_5": + models = ["access_cm2", "awi_cm_1_1_mr", "bcc_csm2_mr", "cams_csm1_0", "cmcc_esm2", "hadgem3_gc31_ll", + "iitm_esm", "inm_cm5_0", "ipsl_cm6a_lr", "kiost_esm", "miroc6", "miroc_es2l", + "mri_esm2_0", "noresm2_mm", "canesm5", "cesm2", "cmcc_cm2_sr5", "cnrm_cm6_1", "cnrm_esm2_1", + "ec_earth3_cc", "ec_earth3_veg_lr", "fgoals_g3", + "gfdl_esm4", "inm_cm4_8", "kace_1_0_g", "mpi_esm1_2_lr", "nesm3", "noresm2_lm", "ukesm1_0_ll"] model = 0 for file in file_list: data_per_model = Dataset(file, mode='r') From e0383fa77c0b5ba1064e105efec8944df317dc87 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 7 Nov 2024 14:40:17 +0000 Subject: [PATCH 104/291] Changed how data were aggregated (do not need to search over model names, can just extract from file) --- .../aggregate_processs_CMIP6_data.py | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-) diff --git a/src/scripts/climate_change/aggregate_processs_CMIP6_data.py b/src/scripts/climate_change/aggregate_processs_CMIP6_data.py index c28aeab3dd..de2c00c01a 100644 --- a/src/scripts/climate_change/aggregate_processs_CMIP6_data.py +++ b/src/scripts/climate_change/aggregate_processs_CMIP6_data.py @@ -2,9 +2,8 @@ import glob import os -import shutil -import zipfile from pathlib import Path +import re import pandas as pd from netCDF4 import Dataset @@ -26,12 +25,11 @@ "mri_esm2_0", "noresm2_mm", "canesm5", "cesm2", "cmcc_cm2_sr5", "cnrm_cm6_1", "cnrm_esm2_1", "ec_earth3_cc", "ec_earth3_veg_lr", "fgoals_g3", "gfdl_esm4", "inm_cm4_8", "kace_1_0_g", "mpi_esm1_2_lr", "nesm3", "noresm2_lm", "ukesm1_0_ll"] - -model = 0 +print(scenario) nc_file_directory = os.path.join(scenario_directory, 'nc_files') for file in glob.glob(os.path.join(nc_file_directory, "*.nc")): + model = re.search(r'pr_day_(.*?)_ssp245', file).group(1) data_per_model = Dataset(file, mode='r') - print(data_per_model.variables) pr_data = data_per_model.variables['pr'][:] # in kg m-2 s-1 = mm s-1 x 86400 to get to day lat_data = data_per_model.variables['lat'][:] long_data = data_per_model.variables['lon'][:] @@ -43,8 +41,8 @@ precip_data_for_grid = precip_data_for_grid * 86400 # to get from per second to per day grid_dictionary[grid] = precip_data_for_grid grid += 1 - data_by_model_and_grid[models[model]] = grid_dictionary - model += 1 + print(grid_dictionary) + data_by_model_and_grid[model] = grid_dictionary print(data_by_model_and_grid) data_by_model_and_grid = pd.DataFrame.from_dict(data_by_model_and_grid) -data_by_model_and_grid.to_csv(Path(scenario_directory)/"data_by_model_and_grid_CMIP6_projections.csv") +#data_by_model_and_grid.to_csv(Path(scenario_directory)/"data_by_model_and_grid_CMIP6_projections.csv") From 986aa24d33b5a32f897fabdb337990be97266fc1 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 7 Nov 2024 15:12:28 +0000 Subject: [PATCH 105/291] Deleted as now part of "process_CMIP6_data" --- .../aggregate_processs_CMIP6_data.py | 48 ------------------- 1 file changed, 48 deletions(-) delete mode 100644 src/scripts/climate_change/aggregate_processs_CMIP6_data.py diff --git a/src/scripts/climate_change/aggregate_processs_CMIP6_data.py b/src/scripts/climate_change/aggregate_processs_CMIP6_data.py deleted file mode 100644 index de2c00c01a..0000000000 --- a/src/scripts/climate_change/aggregate_processs_CMIP6_data.py +++ /dev/null @@ -1,48 +0,0 @@ -# Put all into one csv file - -import glob -import os -from pathlib import Path -import re - -import pandas as pd -from netCDF4 import Dataset - -base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/" -scenario = "ssp2_4_5" #"ssp1_1_9" -scenario_directory = base_dir + scenario + "/" - - -#### Multiple files -file_list = glob.glob(os.path.join(base_dir, "*.nc")) -data_by_model_and_grid = {} -if scenario == "ssp1_1_9": - models = ["cams_csm1_0", "ipsl_cm6a_lr", "miroc6", "miroc_es2l", "mri_esm2_0", "canesm5", "cnrm_esm2_1", - "ec_earth3", "ec_earth3_veg_lr", "fgoals_g3", "gfdl_esm4", "ukesm1_0_ll"] -elif scenario == "ssp2_4_5": - models = ["access_cm2", "awi_cm_1_1_mr", "bcc_csm2_mr", "cams_csm1_0", "cmcc_esm2", "hadgem3_gc31_ll", - "iitm_esm", "inm_cm5_0", "ipsl_cm6a_lr", "kiost_esm", "miroc6", "miroc_es2l", - "mri_esm2_0", "noresm2_mm", "canesm5", "cesm2", "cmcc_cm2_sr5", "cnrm_cm6_1", "cnrm_esm2_1", - "ec_earth3_cc", "ec_earth3_veg_lr", "fgoals_g3", - "gfdl_esm4", "inm_cm4_8", "kace_1_0_g", "mpi_esm1_2_lr", "nesm3", "noresm2_lm", "ukesm1_0_ll"] -print(scenario) -nc_file_directory = os.path.join(scenario_directory, 'nc_files') -for file in glob.glob(os.path.join(nc_file_directory, "*.nc")): - model = re.search(r'pr_day_(.*?)_ssp245', file).group(1) - data_per_model = Dataset(file, mode='r') - pr_data = data_per_model.variables['pr'][:] # in kg m-2 s-1 = mm s-1 x 86400 to get to day - lat_data = data_per_model.variables['lat'][:] - long_data = data_per_model.variables['lon'][:] - grid_dictionary = {} - grid = 0 - for i in range(len(long_data)): - for j in range(len(lat_data)): - precip_data_for_grid = pr_data[:,j,i] # across all time points - precip_data_for_grid = precip_data_for_grid * 86400 # to get from per second to per day - grid_dictionary[grid] = precip_data_for_grid - grid += 1 - print(grid_dictionary) - data_by_model_and_grid[model] = grid_dictionary -print(data_by_model_and_grid) -data_by_model_and_grid = pd.DataFrame.from_dict(data_by_model_and_grid) -#data_by_model_and_grid.to_csv(Path(scenario_directory)/"data_by_model_and_grid_CMIP6_projections.csv") From 371a0785fb432ccc5cfcd27b74c291d9bbb19f3a Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 7 Nov 2024 15:13:06 +0000 Subject: [PATCH 106/291] Redid so no longer need to list the models, only need to look in directory. Now can loop over --- .../climate_change/process_CMIP6_data.py | 63 ++++++++----------- 1 file changed, 25 insertions(+), 38 deletions(-) diff --git a/src/scripts/climate_change/process_CMIP6_data.py b/src/scripts/climate_change/process_CMIP6_data.py index 24df4f925d..abbf986881 100644 --- a/src/scripts/climate_change/process_CMIP6_data.py +++ b/src/scripts/climate_change/process_CMIP6_data.py @@ -3,6 +3,7 @@ import shutil import zipfile from pathlib import Path +import re import pandas as pd from netCDF4 import Dataset @@ -16,7 +17,6 @@ def unzip_all_in_directory(directory): directory (str): The path to the folder containing the .zip files. """ for filename in os.listdir(directory): - print(f"Processing {filename}") if filename.endswith('.zip'): file_path = os.path.join(directory, filename) extract_dir = os.path.join(directory, filename[:-4]) @@ -25,7 +25,6 @@ def unzip_all_in_directory(directory): try: with zipfile.ZipFile(file_path, 'r') as zip_ref: zip_ref.extractall(extract_dir) - print(f"Extracted {filename} to {extract_dir}") except zipfile.BadZipFile: print(f"Skipped {filename}: not a valid zip file.") @@ -61,8 +60,7 @@ def extract_nc_files_from_unzipped_folders(directory): base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/" -scenarios = ["ssp1_1_9"] #,"ssp1_2_6", "ssp4_3_4", "ssp5_3_4OS", "ssp2_4_5", "ssp4_6_0", "ssp3_7_0", "ssp5_8_5"] -scenarios = ["ssp2_4_5"] +scenarios = ["ssp1_1_9", "ssp2_4_5"] for scenario in scenarios: scenario_directory = os.path.join(base_dir, scenario) unzip_all_in_directory(scenario_directory) @@ -72,42 +70,31 @@ def extract_nc_files_from_unzipped_folders(directory): # Put all into one csv file base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/" -scenario = scenarios[0] -scenario_directory = os.path.join(base_dir, scenario) -nc_file_directory = os.path.join(scenario_directory, 'nc_files') -#### Multiple files -file_list = glob.glob(os.path.join(nc_file_directory, "*.nc")) +file_list = glob.glob(os.path.join(base_dir, "*.nc")) data_by_model_and_grid = {} -if scenario == "ssp1_1_9": - models = ["cams_csm1_0", "ipsl_cm6a_lr", "miroc6", "miroc_es2l", "mri_esm2_0", "canesm5", "cnrm_esm2_1", - "ec_earth3", "ec_earth3_veg_lr", "fgoals_g3", "gfdl_esm4", "ukesm1_0_ll"] -elif scenario == "ssp2_4_5": - models = ["access_cm2", "awi_cm_1_1_mr", "bcc_csm2_mr", "cams_csm1_0", "cmcc_esm2", "hadgem3_gc31_ll", - "iitm_esm", "inm_cm5_0", "ipsl_cm6a_lr", "kiost_esm", "miroc6", "miroc_es2l", - "mri_esm2_0", "noresm2_mm", "canesm5", "cesm2", "cmcc_cm2_sr5", "cnrm_cm6_1", "cnrm_esm2_1", - "ec_earth3_cc", "ec_earth3_veg_lr", "fgoals_g3", - "gfdl_esm4", "inm_cm4_8", "kace_1_0_g", "mpi_esm1_2_lr", "nesm3", "noresm2_lm", "ukesm1_0_ll"] -model = 0 -for file in file_list: - data_per_model = Dataset(file, mode='r') - pr_data = data_per_model.variables['pr'][:] # in kg m-2 s-1 = mm s-1 x 86400 to get to day - lat_data = data_per_model.variables['lat'][:] - long_data = data_per_model.variables['lon'][:] - grid_dictionary = {} - grid = 0 - for i in range(len(long_data)): - for j in range(len(lat_data)): - precip_data_for_grid = pr_data[:,j,i] # across all time points - precip_data_for_grid = precip_data_for_grid * 86400 # to get from per second to per day - grid_dictionary[grid] = precip_data_for_grid - - grid += 1 - data_by_model_and_grid[models[model]] = grid_dictionary - model += 1 -data_by_model_and_grid = pd.DataFrame.from_dict(data_by_model_and_grid) - -data_by_model_and_grid.to_csv(Path(scenario_directory)/"data_by_model_and_grid.csv") +for scenario in scenarios: + print(scenario) + scenario_directory = os.path.join(base_dir, scenario) + nc_file_directory = os.path.join(scenario_directory, 'nc_files') + + for file in glob.glob(os.path.join(nc_file_directory, "*.nc")): + model = re.search(r'pr_day_(.*?)_' + scenario.replace('_', ''), file).group(1) + data_per_model = Dataset(file, mode='r') + pr_data = data_per_model.variables['pr'][:] # in kg m-2 s-1 = mm s-1 x 86400 to get to day + lat_data = data_per_model.variables['lat'][:] + long_data = data_per_model.variables['lon'][:] + grid_dictionary = {} + grid = 0 + for i in range(len(long_data)): + for j in range(len(lat_data)): + precip_data_for_grid = pr_data[:,j,i] # across all time points + precip_data_for_grid = precip_data_for_grid * 86400 # to get from per second to per day + grid_dictionary[grid] = precip_data_for_grid + grid += 1 + data_by_model_and_grid[model] = grid_dictionary + data_by_model_and_grid = pd.DataFrame.from_dict(data_by_model_and_grid) + data_by_model_and_grid.to_csv(Path(scenario_directory)/"data_by_model_and_grid.csv") From 15f1cacf26095115293e29de8fa7c7e8561eec40 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 8 Nov 2024 10:29:29 +0000 Subject: [PATCH 107/291] Added averaging over time points --- .../climate_change/process_CMIP6_data.py | 28 ++++++++++++++++++- 1 file changed, 27 insertions(+), 1 deletion(-) diff --git a/src/scripts/climate_change/process_CMIP6_data.py b/src/scripts/climate_change/process_CMIP6_data.py index abbf986881..ce60ac3b6f 100644 --- a/src/scripts/climate_change/process_CMIP6_data.py +++ b/src/scripts/climate_change/process_CMIP6_data.py @@ -1,10 +1,11 @@ import glob import os +import re import shutil import zipfile from pathlib import Path -import re +import numpy as np import pandas as pd from netCDF4 import Dataset @@ -96,6 +97,31 @@ def extract_nc_files_from_unzipped_folders(directory): data_by_model_and_grid = pd.DataFrame.from_dict(data_by_model_and_grid) data_by_model_and_grid.to_csv(Path(scenario_directory)/"data_by_model_and_grid.csv") + # now find the modal length of data for each model in the dictionary - this tells us the resolution, and most of the models are at different resolutions + non_na_lengths = data_by_model_and_grid.count() + # now drop all columns that are not that length, so the rest can be aggregated over + modal_non_na_length = non_na_lengths.mode()[0] + data_by_model_and_grid_same_length = data_by_model_and_grid.loc[:, non_na_lengths == modal_non_na_length] + data_by_model_and_grid_same_length = data_by_model_and_grid_same_length.dropna(axis=0) + data_by_model_and_grid_same_length.to_csv(Path(scenario_directory)/"data_by_model_and_grid_modal_resolution.csv") + + # Now average across each time point for each grid square. + precip_by_timepoint = {} + for grid in range(len(data_by_model_and_grid_same_length)): + timepoint_values = [] + for model in data_by_model_and_grid_same_length.columns: + model_data = data_by_model_and_grid_same_length.loc[grid, model] + if not timepoint_values: + timepoint_values = [[] for _ in range(len(model_data))] + for i, value in enumerate(model_data): + if not np.ma.is_masked(value): + timepoint_values[i].append(value) + + precip_by_timepoint[grid] = [np.mean(tp_values) if tp_values else np.nan for tp_values in timepoint_values] + + precip_df = pd.DataFrame.from_dict(precip_by_timepoint, orient='index') + average_projected_precip = precip_df.mean(axis=0) + average_projected_precip.to_csv(Path(scenario_directory)/"mean_projected_precip_by_timepoint_modal_resolution.csv") From 14925e2f629456e517e8ae3d8a1b6f4c372f4302 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 8 Nov 2024 10:29:42 +0000 Subject: [PATCH 108/291] isort --- ...odel_historical_realtionship_reporting_precipitation.py | 1 - src/scripts/climate_change/process_daily_max_data.py | 7 ++++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 26b6ff2bae..3c8ba108bb 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -4,7 +4,6 @@ import statsmodels.api as sm from statsmodels.othermod.betareg import BetaModel - ANC = True daily_max = False min_year_for_analyis = 2011 diff --git a/src/scripts/climate_change/process_daily_max_data.py b/src/scripts/climate_change/process_daily_max_data.py index 42456247bf..9c160b1271 100644 --- a/src/scripts/climate_change/process_daily_max_data.py +++ b/src/scripts/climate_change/process_daily_max_data.py @@ -1,10 +1,11 @@ +import difflib import glob import os -from netCDF4 import Dataset from pathlib import Path -import pandas as pd + import geopandas as gpd -import difflib +import pandas as pd +from netCDF4 import Dataset ANC = False # facility data From 4098fa71c35fb0955b5d887d4b423dc4b7416e70 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 8 Nov 2024 12:06:53 +0000 Subject: [PATCH 109/291] realized I averaged over all timepoints --- src/scripts/climate_change/process_CMIP6_data.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/scripts/climate_change/process_CMIP6_data.py b/src/scripts/climate_change/process_CMIP6_data.py index ce60ac3b6f..b728c13f92 100644 --- a/src/scripts/climate_change/process_CMIP6_data.py +++ b/src/scripts/climate_change/process_CMIP6_data.py @@ -120,8 +120,7 @@ def extract_nc_files_from_unzipped_folders(directory): precip_by_timepoint[grid] = [np.mean(tp_values) if tp_values else np.nan for tp_values in timepoint_values] precip_df = pd.DataFrame.from_dict(precip_by_timepoint, orient='index') - average_projected_precip = precip_df.mean(axis=0) - average_projected_precip.to_csv(Path(scenario_directory)/"mean_projected_precip_by_timepoint_modal_resolution.csv") + precip_df.to_csv(Path(scenario_directory)/"mean_projected_precip_by_timepoint_modal_resolution.csv") From 38e1c1c497dfa8322b605fa86fb9965a4090bbe3 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 8 Nov 2024 12:12:05 +0000 Subject: [PATCH 110/291] Realized for daily precipitation, doing an incorrect conversion. The unit is m, not kg m-2 s-1, so only need to multiply by 1000 --- .../plot_raw_reanalysis_data.py | 119 ++++++++++-------- 1 file changed, 69 insertions(+), 50 deletions(-) diff --git a/src/scripts/climate_change/plot_raw_reanalysis_data.py b/src/scripts/climate_change/plot_raw_reanalysis_data.py index 4f6b868ba3..59418842a5 100644 --- a/src/scripts/climate_change/plot_raw_reanalysis_data.py +++ b/src/scripts/climate_change/plot_raw_reanalysis_data.py @@ -4,65 +4,84 @@ import pandas as pd from netCDF4 import Dataset -# Load the dataset and the variable -file_path = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/139ef85ab4df0a12fc01854395fc9a6d.nc" +# # Load the dataset and the variable +# file_path = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/139ef85ab4df0a12fc01854395fc9a6d.nc" +# dataset = Dataset(file_path, mode='r') +# pr_data = dataset.variables['tp'][:] # in kg m-2 s-1 = mm s-1 x 86400 to get to day +# time_data = dataset.variables['date'][:] +# lat_data = dataset.variables['latitude'][:] +# long_data = dataset.variables['longitude'][:] +# +# ## Initial plot +# for i in range(len(lat_data)): +# for j in range(len(long_data)): +# pr_data_time_series_grid_1 = pr_data[:, i, j] +# pr_data_time_series_grid_1 *= 86400 # to get to days +# plt.plot(pr_data_time_series_grid_1) +# +# plt.title('Average Precipitation Over Time - Grid ') +# plt.ylabel('Precip (mm)') +# plt.xlabel('Time') +# # plt.show() +# +# +# weather_data_historical = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facility_lm.csv", index_col=0) +# +# for i in range(len(weather_data_historical.columns)): +# plt.plot(weather_data_historical.iloc[:, i], label = weather_data_historical.columns[i]) +# +# plt.title('Average Precipitation Over Time - Facility ') +# plt.ylabel('Precip (mm)') +# plt.xlabel('Time') +# plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) +# #plt.show() +# +# +# +# monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm.csv", index_col=0) +# +# for i in range(len(monthly_reporting_by_facility.columns)): +# plt.plot(monthly_reporting_by_facility.iloc[:, i], label = monthly_reporting_by_facility.columns[i]) +# +# plt.title('Average Reprting Over Time - Facility ') +# plt.ylabel('Reporting (%)') +# plt.xlabel('Time') +# plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) +# #plt.show() +# +# +# for i in range(len(monthly_reporting_by_facility.columns)): +# for j in range(len(monthly_reporting_by_facility.iloc[:, i])): +# if weather_data_historical.iloc[j, i] > 1000: +# plt.scatter(weather_data_historical.iloc[j, i], monthly_reporting_by_facility.iloc[j, i]) +# +# plt.title('Average Reprting Over Time - Facility ') +# plt.ylabel('Reporting(%)') +# plt.xlabel('Precip (mm)') +# plt.xlim(1000,4000) +# plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) +# #plt.show() + + + +########### Plot daily maximum data - why is it so high? ########## + +file_path = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_maximum/2011/d7caf4e3506d13b9726aa4f77589c384.nc" dataset = Dataset(file_path, mode='r') -pr_data = dataset.variables['tp'][:] # in kg m-2 s-1 = mm s-1 x 86400 to get to day -time_data = dataset.variables['date'][:] +pr_data = dataset.variables['tp'][:] # m per day, so multiply by 1000 to get mm per day +time_data = dataset.variables['valid_time'][:] lat_data = dataset.variables['latitude'][:] long_data = dataset.variables['longitude'][:] ## Initial plot for i in range(len(lat_data)): for j in range(len(long_data)): - pr_data_time_series_grid_1 = pr_data[:, i, j] - pr_data_time_series_grid_1 *= 86400 # to get to days - plt.plot(pr_data_time_series_grid_1) + pr_data_time_series_grid = pr_data[:, i, j] + pr_data_time_series_grid *= 1000 # to get to mm + plt.plot(pr_data_time_series_grid) -plt.title('Average Precipitation Over Time - Grid ') +plt.title('Daily Maximum Precipitation Over Time - Grid ') plt.ylabel('Precip (mm)') plt.xlabel('Time') -# plt.show() - - -weather_data_historical = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facility_lm.csv", index_col=0) - -for i in range(len(weather_data_historical.columns)): - plt.plot(weather_data_historical.iloc[:, i], label = weather_data_historical.columns[i]) - -plt.title('Average Precipitation Over Time - Facility ') -plt.ylabel('Precip (mm)') -plt.xlabel('Time') -plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) plt.show() - - -monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm.csv", index_col=0) - -for i in range(len(monthly_reporting_by_facility.columns)): - plt.plot(monthly_reporting_by_facility.iloc[:, i], label = monthly_reporting_by_facility.columns[i]) - -plt.title('Average Reprting Over Time - Facility ') -plt.ylabel('Reporting (%)') -plt.xlabel('Time') -plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) -plt.show() - - -for i in range(len(monthly_reporting_by_facility.columns)): - for j in range(len(monthly_reporting_by_facility.iloc[:, i])): - if weather_data_historical.iloc[j, i] > 1000: - plt.scatter(weather_data_historical.iloc[j, i], monthly_reporting_by_facility.iloc[j, i]) - -plt.title('Average Reprting Over Time - Facility ') -plt.ylabel('Reporting(%)') -plt.xlabel('Precip (mm)') -plt.xlim(1000,4000) -plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) -plt.show() - - - - - From c494264affac46f89a55cded21a09e8ccab9abcf Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 8 Nov 2024 12:16:16 +0000 Subject: [PATCH 111/291] Realized for daily precipitation, doing an incorrect conversion. The unit is m, not kg m-2 s-1, so only need to multiply by 1000 --- src/scripts/climate_change/process_daily_max_data.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/scripts/climate_change/process_daily_max_data.py b/src/scripts/climate_change/process_daily_max_data.py index 9c160b1271..90550f4f6d 100644 --- a/src/scripts/climate_change/process_daily_max_data.py +++ b/src/scripts/climate_change/process_daily_max_data.py @@ -7,7 +7,7 @@ import pandas as pd from netCDF4 import Dataset -ANC = False +ANC = True # facility data general_facilities = gpd.read_file("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_districts.shp") @@ -53,7 +53,7 @@ year_directory = os.path.join(base_dir, str(year)) precip_datafile = glob.glob(os.path.join(year_directory, "*.nc")) data_per_model = Dataset(precip_datafile[0], mode='r') - pr_data = data_per_model.variables['tp'][:] # precipitation data in kg m-2 s-1 + pr_data = data_per_model.variables['tp'][:] # precipitation data in m for daily reanalysis lat_data = data_per_model.variables['latitude'][:] long_data = data_per_model.variables['longitude'][:] grid = 0 @@ -72,7 +72,7 @@ moving_averages.append(window_average) max_moving_average = max(moving_averages) - max_average_by_grid[grid].append(max_moving_average* 86400) + max_average_by_grid[grid].append(max_moving_average* 1000) begin_day += month_length grid += 1 From 6e235d46ddd96073eba9621ed280676174629d9f Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 8 Nov 2024 12:27:28 +0000 Subject: [PATCH 112/291] Added plot of projected rain by grid point --- .../climate_change/plot_raw_data_CMIP6.py | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/src/scripts/climate_change/plot_raw_data_CMIP6.py b/src/scripts/climate_change/plot_raw_data_CMIP6.py index 53ce1ffc7b..6b7e81a349 100644 --- a/src/scripts/climate_change/plot_raw_data_CMIP6.py +++ b/src/scripts/climate_change/plot_raw_data_CMIP6.py @@ -70,3 +70,23 @@ print(diff_northern_lat) print(diff_southern_lat) print(diff_eastern_lon) + + +### Plot mean precipitation by grid by time point + + +data_by_gridpoint = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/ssp2_4_5/mean_projected_precip_by_timepoint_modal_resolution.csv") +print(data_by_gridpoint.variables) +pr_data = data_by_gridpoint.variables['pr'][:] # in kg m-2 s-1 = mm s-1 x 86400 to get to day +time_data = data_by_gridpoint.variables['time'][:] +lat_data = data_by_gridpoint.variables['lat'][:] +long_data = data_by_gridpoint.variables['lon'][:] + +for lat in range(len(lat_data)): + for long in range(len(long_data)): + pr_data_for_square = pr_data[:, lat, long] + plt.plot(pr_data_for_square.values) # Plot the values in the row + plt.xlabel("Timepoint") # Adjust this label based on your data + plt.ylabel("Precipitation (mm)") + +#plt.show() From dead8bfde49fc0b6046115f9cb15e3b5a5e61276 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 8 Nov 2024 13:06:21 +0000 Subject: [PATCH 113/291] Changed 86400 as the mulitplier to depend on what data source is being used --- ...rting_and_monthly_weather_data_small_facilities.py | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py b/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py index 77a12561d3..31c285fba5 100644 --- a/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py +++ b/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py @@ -9,6 +9,12 @@ # Data accessed from https://dhis2.health.gov.mw/dhis-web-data-visualizer/#/YiQK65skxjz # Reporting rate is expected reporting vs actual reporting ANC = True +daily_max = True + +if daily_max: + multiplier = 1000 +else: + multiplier = 86400 if ANC: reporting_data = pd.read_csv('/Users/rem76/Desktop/Climate_change_health/Data/ANC_data/ANC_data_2011_2024.csv') else: @@ -71,7 +77,7 @@ index_for_y_max = ((lat_data - maxy)**2).argmin() precip_data_for_grid = pr_data[:, index_for_y_min,index_for_x_min] # across all time points - precip_data_for_grid = precip_data_for_grid * 86400 # to get from per second to per day + precip_data_for_grid = precip_data_for_grid * multiplier # to get from per second (monthly data) to per day OR m to mm (daily max data) weather_by_grid[grid] = precip_data_for_grid grid += 1 @@ -81,7 +87,6 @@ facilities_with_lat_long = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_lat_long_region.csv") - weather_data_by_facility = {} facilities_with_location = [] for reporting_facility in monthly_reporting_by_facility["facility"]: @@ -97,7 +102,7 @@ index_for_y= ((lat_data - lat_for_facility)**2).argmin() precip_data_for_facility = pr_data[:, index_for_y,index_for_x] # across all time points - weather_data_by_facility[reporting_facility] = precip_data_for_facility * 86400 # to get from per second to per day + weather_data_by_facility[reporting_facility] = precip_data_for_facility * multiplier # to get from per second to per day ## below are not in facilities file? elif reporting_facility == "Central East Zone": grid = general_facilities[general_facilities["District"] == "Nkhotakota"]["Grid_Index"].iloc[0] # furtherst east zone From 00f5317becfd8bd0785e3c7c0d5551bb20857743 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 11 Nov 2024 12:15:02 +0000 Subject: [PATCH 114/291] Changed to collect daily totals, not daily maximums --- .../data_retrieval_ERA5_reanalysis_daily.py | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py b/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py index f517eb7b9e..fea7109307 100644 --- a/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py +++ b/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py @@ -4,16 +4,16 @@ years = ["2011", "2012", "2013", "2014", "2015", "2016", "2017", "2018", "2019", "2020", "2021", "2022", "2023", "2024"] -base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_maximum" +base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total" for year in years: year_dir = os.path.join(base_dir, year) if not os.path.exists(year_dir): os.makedirs(year_dir) os.chdir(year_dir) - dataset = "derived-era5-single-levels-daily-statistics" + dataset = "reanalysis-era5-single-levels" request = { - "product_type": "reanalysis", + "product_type": ["reanalysis"], "variable": ["total_precipitation"], "year": year, "month": [ @@ -35,9 +35,10 @@ "28", "29", "30", "31" ], - "daily_statistic": "daily_maximum", - "time_zone": "utc+00:00", - "frequency": "1_hourly", + "time": [ + "00:00"], + "data_format": "grib", + "download_format": "unarchived", "area": [-9.36366167, 32.67161823, -17.12627881, 35.91841716] } From a83bf90dc41f6990645ce865d2b95b6bd17340d6 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 11 Nov 2024 13:26:38 +0000 Subject: [PATCH 115/291] Added in median and 25/75 percentiles --- .../climate_change/process_CMIP6_data.py | 37 +++++++++++++++---- 1 file changed, 29 insertions(+), 8 deletions(-) diff --git a/src/scripts/climate_change/process_CMIP6_data.py b/src/scripts/climate_change/process_CMIP6_data.py index b728c13f92..c4b93f0440 100644 --- a/src/scripts/climate_change/process_CMIP6_data.py +++ b/src/scripts/climate_change/process_CMIP6_data.py @@ -105,8 +105,12 @@ def extract_nc_files_from_unzipped_folders(directory): data_by_model_and_grid_same_length = data_by_model_and_grid_same_length.dropna(axis=0) data_by_model_and_grid_same_length.to_csv(Path(scenario_directory)/"data_by_model_and_grid_modal_resolution.csv") - # Now average across each time point for each grid square. - precip_by_timepoint = {} + mean_precip_by_timepoint = {} + median_precip_by_timepoint = {} + percentile_25_by_timepoint = {} + percentile_75_by_timepoint = {} + + # Calculate the statistics for each grid for grid in range(len(data_by_model_and_grid_same_length)): timepoint_values = [] for model in data_by_model_and_grid_same_length.columns: @@ -117,11 +121,28 @@ def extract_nc_files_from_unzipped_folders(directory): if not np.ma.is_masked(value): timepoint_values[i].append(value) - precip_by_timepoint[grid] = [np.mean(tp_values) if tp_values else np.nan for tp_values in timepoint_values] - - precip_df = pd.DataFrame.from_dict(precip_by_timepoint, orient='index') - precip_df.to_csv(Path(scenario_directory)/"mean_projected_precip_by_timepoint_modal_resolution.csv") - - + # Calculate and store statistics for each grid and timepoint + mean_precip_by_timepoint[grid] = [np.mean(tp_values) if tp_values else np.nan for tp_values in timepoint_values] + median_precip_by_timepoint[grid] = [np.median(tp_values) if tp_values else np.nan for tp_values in + timepoint_values] + percentile_25_by_timepoint[grid] = [np.percentile(tp_values, 25) if tp_values else np.nan for tp_values in + timepoint_values] + percentile_75_by_timepoint[grid] = [np.percentile(tp_values, 75) if tp_values else np.nan for tp_values in + timepoint_values] + + # Convert each dictionary to a DataFrame and save to CSV + mean_df = pd.DataFrame.from_dict(mean_precip_by_timepoint, orient='index') + mean_df.to_csv(Path(scenario_directory) / "mean_projected_precip_by_timepoint_modal_resolution.csv") + + median_df = pd.DataFrame.from_dict(median_precip_by_timepoint, orient='index') + median_df.to_csv(Path(scenario_directory) / "median_projected_precip_by_timepoint_modal_resolution.csv") + + percentile_25_df = pd.DataFrame.from_dict(percentile_25_by_timepoint, orient='index') + percentile_25_df.to_csv( + Path(scenario_directory) / "percentile_25_projected_precip_by_timepoint_modal_resolution.csv") + + percentile_75_df = pd.DataFrame.from_dict(percentile_75_by_timepoint, orient='index') + percentile_75_df.to_csv( + Path(scenario_directory) / "percentile_75_projected_precip_by_timepoint_modal_resolution.csv") From 19806324bb69626e38c3ca28777c5d62126e10de Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 11 Nov 2024 13:26:51 +0000 Subject: [PATCH 116/291] added in multiplier variable --- src/scripts/climate_change/process_daily_max_data.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/src/scripts/climate_change/process_daily_max_data.py b/src/scripts/climate_change/process_daily_max_data.py index 90550f4f6d..33eac803fe 100644 --- a/src/scripts/climate_change/process_daily_max_data.py +++ b/src/scripts/climate_change/process_daily_max_data.py @@ -7,8 +7,10 @@ import pandas as pd from netCDF4 import Dataset -ANC = True +ANC = False # facility data +multiplier = 1000 + general_facilities = gpd.read_file("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_districts.shp") facilities_with_lat_long = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_lat_long_region.csv") @@ -72,7 +74,7 @@ moving_averages.append(window_average) max_moving_average = max(moving_averages) - max_average_by_grid[grid].append(max_moving_average* 1000) + max_average_by_grid[grid].append(max_moving_average* multiplier) begin_day += month_length grid += 1 @@ -117,7 +119,7 @@ moving_averages.append(window_average) max_moving_average = max(moving_averages) - max_average_by_facility[reporting_facility].append(max_moving_average * 86400) + max_average_by_facility[reporting_facility].append(max_moving_average * multiplier) begin_day += month_length # From 96ee2efa2f4e54adfa953c041966f60eb1169480 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 11 Nov 2024 14:17:48 +0000 Subject: [PATCH 117/291] intorduced mask level variable also wrote model to pickle --- ...al_realtionship_reporting_precipitation.py | 50 +++++++++++-------- 1 file changed, 29 insertions(+), 21 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 3c8ba108bb..ae76c2dd73 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -1,13 +1,15 @@ import matplotlib.pyplot as plt import numpy as np import pandas as pd +import pickle import statsmodels.api as sm from statsmodels.othermod.betareg import BetaModel ANC = True -daily_max = False +daily_max = True min_year_for_analyis = 2011 absolute_min_year = 2011 +mask_threshold = 0 # # data is from 2011 - 2024 - for facility if ANC: monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_ANC_by_smaller_facility_lm.csv", index_col=0) @@ -100,7 +102,11 @@ def create_binary_feature(threshold, weather_data_df, recent_months): above_below_X = create_binary_feature(1000, weather_data_historical, 12) # Prepare additional facility info -expanded_facility_info = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm.csv", index_col=0) +if ANC: + expanded_facility_info = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_with_ANC.csv", index_col=0) + +else: + expanded_facility_info = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm.csv", index_col=0) expanded_facility_info = expanded_facility_info.T.reindex(columns=expanded_facility_info.index) def repeat_info(info, num_facilities, year_range): @@ -124,6 +130,8 @@ def repeat_info(info, num_facilities, year_range): altitude = np.where(altitude < 0, np.nan, altitude) altitude = list(altitude) + + X = np.column_stack([ weather_data, year_flattened, @@ -137,11 +145,10 @@ def repeat_info(info, num_facilities, year_range): facility_encoded, altitude ]) -results, y_pred, mask = build_model(X, y, X_mask_mm = 800) -#results = build_model(X, y, scale_y=True, beta=True, X_mask_mm = 1000) - -print(results.summary()) +results, y_pred, mask = build_model(X, np.log(y) , X_mask_mm = mask_threshold) +if np.nanmin(y) < 1: + y += 1e-6 # Shift to ensure positivity ### Now include only significant predictors X = np.column_stack([ @@ -154,10 +161,10 @@ def repeat_info(info, num_facilities, year_range): # ftype_encoded, # lag_1_month, # lag_3_month, - # altitude - above_below_X + # altitude, + # above_below_X ]) -results, y_pred, mask = build_model(X, y, X_mask_mm = 800) +results, y_pred, mask = build_model(X, np.log(y) , X_mask_mm = mask_threshold) print(results.summary()) @@ -165,35 +172,36 @@ def repeat_info(info, num_facilities, year_range): ##### Plot y_predic X_filtered = X[mask] - -print(len(y_pred)) -print(len(X_filtered)) -print(len(X_filtered)/len(X) * 100) -print(len(y[mask])) -print(len(y_pred)) - - +print(y_pred) if ANC: - plt.scatter(X_filtered[:, 0], y[mask], color='red', alpha=0.5) + plt.scatter(X_filtered[:, 0], np.log(y) [mask], color='red', alpha=0.5) plt.scatter(X_filtered[:, 0], y_pred) plt.title(' ') plt.ylabel('Number of ANC visits') plt.xlabel('Precip (mm)') - plt.ylim(0,1000) + plt.ylim(0,10) plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) plt.show() else: - plt.scatter(X_filtered[:, 0], y[mask], color='red', alpha=0.5) + plt.scatter(X_filtered[:, 0], np.log(y)[mask], color='red', alpha=0.5) plt.scatter(X_filtered[:, 0], y_pred) plt.title(' ') plt.ylabel('Reporting (%)') plt.xlabel('Precip (mm)') plt.ylim(0, 100) plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) - plt.show() + #plt.show() + +# save model +# Save the model using pickle +with open('linear_model_ANC_daily_max.pkl', 'wb') as file: + pickle.dump(results, file) +# Now you can load the model and use it for predictions +with open('saved_model.pkl', 'rb') as file: + loaded_model = pickle.load(file) From d7b20b48ec96d58247ac4ce87a8fb98cc2b1cb72 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 11 Nov 2024 14:19:44 +0000 Subject: [PATCH 118/291] intorduced mask level variable put years in ascending order --- .../climate_change/data_retrieval_CMIP.py | 56 +++++++------------ 1 file changed, 21 insertions(+), 35 deletions(-) diff --git a/src/scripts/climate_change/data_retrieval_CMIP.py b/src/scripts/climate_change/data_retrieval_CMIP.py index c4957d4416..547f8a5fb9 100644 --- a/src/scripts/climate_change/data_retrieval_CMIP.py +++ b/src/scripts/climate_change/data_retrieval_CMIP.py @@ -3,9 +3,11 @@ import cdsapi #models_ssp119 = ["cams_csm1_0", "ipsl_cm6a_lr", "miroc6","miroc_es2l", "mri_esm2_0", "canesm5", "cnrm_esm2_1", "ec_earth3", "ec_earth3_veg_lr", "fgoals_g3", "gfdl_esm4", "ukesm1_0_ll"] -scenarios = ["ssp1_1_9","ssp1_2_6", "ssp4_3_4", "ssp5_3_4OS", "ssp2_4_5", "ssp4_6_0", "ssp3_7_0", "ssp5_8_5"] -models_ssp245 = ["access_cm2", "awi_cm_1_1_mr", "bcc_csm2_mr","cams_csm1_0", "cmcc_esm2", "hadgem3_gc31_ll", "iitm_esm", "inm_cm5_0", "ipsl_cm6a_lr", "kiost_esm", "miroc6", "miroc_es2l", - "mri_esm2_0", "noresm2_mm", "canesm5", "cesm2", "cmcc_cm2_sr5", "cnrm_cm6_1", "cnrm_esm2_1", "ec_earth3_cc", "ec_earth3_veg_lr", "fgoals_g3", +scenarios = ["ssp1_1_9", "ssp1_2_6", "ssp4_3_4", "ssp5_3_4OS", "ssp2_4_5", "ssp4_6_0", "ssp3_7_0", "ssp5_8_5"] +models_ssp245 = ["access_cm2", "awi_cm_1_1_mr", "bcc_csm2_mr", "cams_csm1_0", "cmcc_esm2", "hadgem3_gc31_ll", + "iitm_esm", "inm_cm5_0", "ipsl_cm6a_lr", "kiost_esm", "miroc6", "miroc_es2l", + "mri_esm2_0", "noresm2_mm", "canesm5", "cesm2", "cmcc_cm2_sr5", "cnrm_cm6_1", "cnrm_esm2_1", + "ec_earth3_cc", "ec_earth3_veg_lr", "fgoals_g3", "gfdl_esm4", "inm_cm4_8", "kace_1_0_g", "mpi_esm1_2_lr", "nesm3", "noresm2_lm", "ukesm1_0_ll"] base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/" @@ -24,35 +26,21 @@ "variable": "precipitation", "model": model, "year": [ - "2050", "2051", "2052", - "2053", "2054", "2055", - "2056", "2057", "2058", - "2059", "2060", "2061", - "2062", "2063", "2064", - "2065", "2066", "2067", - "2068", "2069", "2070", - "2071", "2072", "2073", - "2074", "2075", "2076", - "2077", "2078", "2079", - "2080", "2081", "2082", - "2083", "2084", "2085", - "2086", "2087", "2088", - "2089", "2090", "2091", - "2092", "2093", "2094", - "2095", "2096", "2097", - "2098", "2099", "2015", - "2016", "2017", "2018", - "2019", "2020", "2021", - "2022", "2023", "2024", - "2025", "2026", "2027", - "2028", "2029", "2030", - "2031", "2032", "2033", - "2034", "2035", "2036", - "2037", "2038", "2039", - "2040", "2041", "2042", - "2043", "2044", "2045", - "2046", "2047", "2048", - "2049" + "2015", "2016", "2017", "2018", "2019", "2020", + "2021", "2022", "2023", "2024", "2025", "2026", + "2027", "2028", "2029", "2030", "2031", "2032", + "2033", "2034", "2035", "2036", "2037", "2038", + "2039", "2040", "2041", "2042", "2043", "2044", + "2045", "2046", "2047", "2048", "2049", "2050", + "2051", "2052", "2053", "2054", "2055", "2056", + "2057", "2058", "2059", "2060", "2061", "2062", + "2063", "2064", "2065", "2066", "2067", "2068", + "2069", "2070", "2071", "2072", "2073", "2074", + "2075", "2076", "2077", "2078", "2079", "2080", + "2081", "2082", "2083", "2084", "2085", "2086", + "2087", "2088", "2089", "2090", "2091", "2092", + "2093", "2094", "2095", "2096", "2097", "2098", + "2099" ], "month": [ "01", "02", "03", @@ -74,10 +62,8 @@ "31" ], - - 'area': [-9.36366167, 35.91841716, -17.12627881, 32.67161823, ] # boundaries for all of Malawi + 'area': [-9.36366167, 35.91841716, -17.12627881, 32.67161823, ] # boundaries for all of Malawi } client = cdsapi.Client() client.retrieve(dataset, request).download() - From 53dd04ac6907091e935942f4c2c2268c2a2b5834 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 11 Nov 2024 15:26:33 +0000 Subject: [PATCH 119/291] Plot for median and IQR (needs improving for legibility) first attempt at film --- .../climate_change/plot_raw_data_CMIP6.py | 111 +++++++++++++++--- 1 file changed, 96 insertions(+), 15 deletions(-) diff --git a/src/scripts/climate_change/plot_raw_data_CMIP6.py b/src/scripts/climate_change/plot_raw_data_CMIP6.py index 6b7e81a349..9871d41499 100644 --- a/src/scripts/climate_change/plot_raw_data_CMIP6.py +++ b/src/scripts/climate_change/plot_raw_data_CMIP6.py @@ -3,6 +3,9 @@ import numpy as np import pandas as pd from netCDF4 import Dataset +import matplotlib.animation as animation +import math +import imageio.v2 as imageio # Load the dataset and the variable file_path = "/Users/rem76/Downloads/821bebfbcee0609d233c09e8b2bbc1f3/pr_Amon_UKESM1-0-LL_ssp119_r1i1p1f2_gn_20150116-20991216.nc" @@ -11,7 +14,7 @@ time_data = dataset.variables['time'][:] lat_data = dataset.variables['lat'][:] long_data = dataset.variables['lon'][:] - +years = range(2015, 2101) ## Initial plot pr_data_time_series_grid_1 = pr_data[:,2,1] pr_data_time_series_grid_1 *= 86400 # to get to days @@ -19,10 +22,10 @@ # Plot the 2D data plt.plot(pr_data_time_series_grid_1) -plt.title('Average Precipitation Over Time - Grid 1') +plt.title('Daily precipitation') plt.ylabel('Precip (mm)') plt.xlabel('Time') -plt.show() +#plt.show() ################ Now do it by specific regions ################# # get regions from facilities file @@ -75,18 +78,96 @@ ### Plot mean precipitation by grid by time point -data_by_gridpoint = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/ssp2_4_5/mean_projected_precip_by_timepoint_modal_resolution.csv") -print(data_by_gridpoint.variables) -pr_data = data_by_gridpoint.variables['pr'][:] # in kg m-2 s-1 = mm s-1 x 86400 to get to day -time_data = data_by_gridpoint.variables['time'][:] -lat_data = data_by_gridpoint.variables['lat'][:] -long_data = data_by_gridpoint.variables['lon'][:] - -for lat in range(len(lat_data)): +data_by_gridpoint = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/ssp2_4_5/mean_projected_precip_by_timepoint_modal_resolution.csv", index_col=0) +for grid in range(len(data_by_gridpoint)): for long in range(len(long_data)): - pr_data_for_square = pr_data[:, lat, long] - plt.plot(pr_data_for_square.values) # Plot the values in the row - plt.xlabel("Timepoint") # Adjust this label based on your data - plt.ylabel("Precipitation (mm)") + plt.plot(data_by_gridpoint.columns, data_by_gridpoint.iloc[grid], label=f"Grid {grid + 1}") +plt.xlabel("Timepoint") # Adjust this label based on your data +plt.ylabel("Precipitation (mm)") +print(len(data_by_gridpoint.columns)) +plt.xticks(ticks=np.arange(0, len(data_by_gridpoint.columns), step=365), + labels=years) #plt.show() + + +### Plot median and IQ range precipitation by grid by time point + + +### NOW do median and IQR +median_df = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/ssp2_4_5/median_projected_precip_by_timepoint_modal_resolution.csv", index_col=0) +percentile_25_df = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/ssp2_4_5/percentile_25_projected_precip_by_timepoint_modal_resolution.csv", index_col=0) +percentile_75_df = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/ssp2_4_5/percentile_75_projected_precip_by_timepoint_modal_resolution.csv", index_col=0) + +num_grids = len(median_df.index) +num_cols = math.ceil(math.sqrt(num_grids)) +num_rows = math.ceil(num_grids / num_cols) + +fig, axs = plt.subplots(num_rows, num_cols, figsize=(15, 10)) +fig.suptitle("Median Precipitation with IQR Shaded Area by Grid") +axs = axs.flatten() + +for idx, grid in enumerate(median_df.index): + median_values = median_df.loc[grid].values + timepoints = range(len(median_values)) + + axs[idx].fill_between(timepoints, percentile_25_df.loc[grid], percentile_75_df.loc[grid], alpha=0.5, color = "lightblue") + axs[idx].plot(timepoints, median_values, color="blue") + + axs[idx].set_ylim(0,10) + axs[idx].set_xlim(0,365*10) + + axs[idx].set_title(f"Grid {grid}") + axs[idx].set_xlabel("Year") + axs[idx].set_xticks(ticks=np.arange(0, len(data_by_gridpoint.columns), step=365*5), + labels=[year for i, year in enumerate(years) if i % 5 == 0]) + axs[idx].set_ylabel("Precipitation (mm)") + +for ax in axs[num_grids:]: + ax.set_visible(False) + +plt.tight_layout(rect=[0, 0.03, 1, 0.95]) +plt.show() + +## film for each grid point? + +# Define grid layout +num_grids = len(median_df.index) +num_cols = math.ceil(math.sqrt(num_grids)) +num_rows = math.ceil(num_grids / num_cols) + +# Set up figure +fig, ax = plt.subplots(figsize=(10, 8)) +cbar = None + + +# Create an animation function +def animate(i): + global cbar + ax.clear() # Clear the previous frame + + # Reshape median data and IQR data for heat map + median_values = median_df.iloc[:, i].values.reshape(num_rows, num_cols) + iqr_values = (percentile_75_df.iloc[:, i] - percentile_25_df.iloc[:, i]).values.reshape(num_rows, num_cols) + + # Plot heatmap with IQR as a color gradient + heatmap = ax.imshow(median_values, cmap="coolwarm", interpolation="nearest", vmin=0, vmax=40) + + # Remove old colorbar and add a new one + if cbar: + cbar.remove() + cbar = fig.colorbar(heatmap, ax=ax, fraction=0.046, pad=0.04) + cbar.set_label("Precipitation (mm)") + + # Set title + ax.set_title(f"Median Precipitation with IQR (Time Point {i + 1})") + ax.set_xticks([]) + ax.set_yticks([]) + + +# Create animation +ani = animation.FuncAnimation(fig, animate, frames=median_df.shape[1], repeat=False) + +# Save animation as a movie (e.g., MP4 format) +ani.save("median_precipitation_movie.mp4", writer="ffmpeg", dpi=100) +plt.show() From eaf3ec534262e141f89cbeec98495076a805cde2 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 11 Nov 2024 15:27:03 +0000 Subject: [PATCH 120/291] removed multiplier from reporting (?) --- ...rting_and_monthly_weather_data_small_facilities.py | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py b/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py index 31c285fba5..1ca6b9dedd 100644 --- a/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py +++ b/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py @@ -9,12 +9,8 @@ # Data accessed from https://dhis2.health.gov.mw/dhis-web-data-visualizer/#/YiQK65skxjz # Reporting rate is expected reporting vs actual reporting ANC = True -daily_max = True -if daily_max: - multiplier = 1000 -else: - multiplier = 86400 +multiplier = 86400 if ANC: reporting_data = pd.read_csv('/Users/rem76/Desktop/Climate_change_health/Data/ANC_data/ANC_data_2011_2024.csv') else: @@ -149,4 +145,7 @@ expanded_facility_info = expanded_facility_info.T expanded_facility_info = expanded_facility_info.reindex(columns=facilities_with_location) -expanded_facility_info.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm.csv") +if ANC: + expanded_facility_info.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_with_ANC.csv") +else: + expanded_facility_info.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm.csv") From 1e5d46436750a63c0ef3216ae64e75ebf240f295 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 12 Nov 2024 09:12:29 +0000 Subject: [PATCH 121/291] File for processing the ERA5 historical reanalysis data for daily total precipitation --- .../process_daily_total_historical_data.py | 135 ++++++++++++++++++ 1 file changed, 135 insertions(+) create mode 100644 src/scripts/climate_change/process_daily_total_historical_data.py diff --git a/src/scripts/climate_change/process_daily_total_historical_data.py b/src/scripts/climate_change/process_daily_total_historical_data.py new file mode 100644 index 0000000000..926fab6b34 --- /dev/null +++ b/src/scripts/climate_change/process_daily_total_historical_data.py @@ -0,0 +1,135 @@ +import difflib +import glob +import os +from pathlib import Path + +import geopandas as gpd +import pandas as pd +from netCDF4 import Dataset + +ANC = False +# facility data +multiplier = 1000 + +general_facilities = gpd.read_file("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_districts.shp") + +facilities_with_lat_long = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_lat_long_region.csv") + +# Data accessed from https://dhis2.health.gov.mw/dhis-web-data-visualizer/#/YiQK65skxjz +# Reporting rate is expected reporting vs actual reporting +if ANC: + reporting_data = pd.read_csv('/Users/rem76/Desktop/Climate_change_health/Data/ANC_data/ANC_data_2011_2024.csv') #January 2011 - January 2024 +else: + reporting_data = pd.read_csv('/Users/rem76/Desktop/Climate_change_health/Data/Reporting_Rate/Reporting_Rate_by_smaller_facilities_2011_2024.csv') #January 2011 - January 2024 +# ANALYSIS DONE IN OCTOBER 2024 - so drop October, November, December 2024 +columns_to_drop = reporting_data.columns[reporting_data.columns.str.endswith(('October 2024', 'November 2024', 'December 2024'))] +reporting_data = reporting_data.drop(columns=columns_to_drop) +# drop NAs +reporting_data = reporting_data.dropna(subset = reporting_data.columns[3:], how='all') # drops 90 clinics +### now aggregate over months +monthly_reporting_data_by_facility = {} +months = set(col.split(" - Reporting rate ")[1] for col in reporting_data.columns if " - Reporting rate " in col) + +# put in order +months = [date.strip() for date in months] # extra spaces?? +dates = pd.to_datetime(months, format='%B %Y', errors='coerce') +months = dates.sort_values().strftime('%B %Y').tolist() # puts them in ascending order +for month in months: + columns_of_interest_all_metrics = [reporting_data.columns[1]] + reporting_data.columns[reporting_data.columns.str.endswith(month)].tolist() + data_of_interest_by_month = reporting_data[columns_of_interest_all_metrics] + numeric_data = data_of_interest_by_month.select_dtypes(include='number') + monthly_mean_by_facility = numeric_data.mean(axis=1) + monthly_reporting_data_by_facility[month] = monthly_mean_by_facility +monthly_reporting_by_facility = pd.DataFrame(monthly_reporting_data_by_facility) +monthly_reporting_by_facility["facility"] = reporting_data["organisationunitname"].values + +# historical weather directory +base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total" + +years = range(2011, 2025) +month_lengths = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] +window_size = 1 +max_average_by_grid = {} + +for year in years: + year_directory = os.path.join(base_dir, str(year)) + precip_datafile = glob.glob(os.path.join(year_directory, "*.nc")) + data_per_model = Dataset(precip_datafile[0], mode='r') + pr_data = data_per_model.variables['tp'][:] # precipitation data in m for daily reanalysis + lat_data = data_per_model.variables['latitude'][:] + long_data = data_per_model.variables['longitude'][:] + grid = 0 + for j in range(len(long_data)): + for i in range(len(lat_data)): + pr_data_for_square = pr_data[:, i, j] + if grid not in max_average_by_grid: + max_average_by_grid[grid] = [] + + begin_day = 0 + for month_idx, month_length in enumerate(month_lengths): + days_for_grid = pr_data_for_square[begin_day:begin_day + month_length] + moving_averages = [] + for day in range(month_length - window_size + 1): + window_average = sum(days_for_grid[day:day + window_size]) / window_size + moving_averages.append(window_average) + + max_moving_average = max(moving_averages) + max_average_by_grid[grid].append(max_moving_average* multiplier) + + begin_day += month_length + grid += 1 + +df = pd.DataFrame.from_dict(max_average_by_grid, orient='index') +df = df.T +df.to_csv(Path(base_dir)/"historical_daily_total_by_grid.csv") + + +########## add in reporting data ################## + +max_average_by_facility = {} +for year in years: + year_directory = os.path.join(base_dir, str(year)) + precip_datafile = glob.glob(os.path.join(year_directory, "*.nc")) + data_per_model = Dataset(precip_datafile[0], mode='r') + pr_data = data_per_model.variables['tp'][:] # precipitation data in kg m-2 s-1 + lat_data = data_per_model.variables['latitude'][:] + long_data = data_per_model.variables['longitude'][:] + # loop over clinics + for reporting_facility in monthly_reporting_by_facility["facility"]: + matching_facility_name = difflib.get_close_matches(reporting_facility, facilities_with_lat_long['Fname'], n=3, + cutoff=0.90) + if matching_facility_name: + match_name = matching_facility_name[0] # Access the string directly + # Initialize facility key if not already + if reporting_facility not in max_average_by_facility: + max_average_by_facility[reporting_facility] = [] + lat_for_facility = facilities_with_lat_long.loc[ + facilities_with_lat_long['Fname'] == match_name, "A109__Latitude"].iloc[0] + long_for_facility = facilities_with_lat_long.loc[ + facilities_with_lat_long['Fname'] == match_name, "A109__Longitude"].iloc[0] + index_for_x = ((long_data - long_for_facility) ** 2).argmin() + index_for_y = ((lat_data - lat_for_facility) ** 2).argmin() + pr_data_for_square = pr_data[:, index_for_y, index_for_x] + begin_day = 0 + for month_idx, month_length in enumerate(month_lengths): + days_for_grid = pr_data_for_square[begin_day:begin_day + month_length] + moving_averages = [] + for day in range(month_length - window_size + 1): + window_average = sum(days_for_grid[day:day + window_size]) / window_size + moving_averages.append(window_average) + + max_moving_average = max(moving_averages) + max_average_by_facility[reporting_facility].append(max_moving_average * multiplier) + + begin_day += month_length +# +print(max_average_by_facility) +df_of_facilities = pd.DataFrame.from_dict(max_average_by_facility, orient='index') +df_of_facilities = df_of_facilities.iloc[:, :-3] ## THESE ARE OCT/NOV/DEC OF 2024, and for moment don't have that reporting data +df_of_facilities = df_of_facilities.T + +if ANC: + df_of_facilities.to_csv(Path(base_dir) / "historical_daily_total_by_facilities_with_ANC.csv") +else: + df_of_facilities.to_csv(Path(base_dir) / "historical_daily_total_by_facility.csv") + From 5597d4dce342db39fc3efe0166bf055a8e092dc0 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 12 Nov 2024 09:15:43 +0000 Subject: [PATCH 122/291] Added in daily total data --- .../climate_change/process_daily_total_historical_data.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/scripts/climate_change/process_daily_total_historical_data.py b/src/scripts/climate_change/process_daily_total_historical_data.py index 926fab6b34..104f536724 100644 --- a/src/scripts/climate_change/process_daily_total_historical_data.py +++ b/src/scripts/climate_change/process_daily_total_historical_data.py @@ -7,7 +7,7 @@ import pandas as pd from netCDF4 import Dataset -ANC = False +ANC = True # facility data multiplier = 1000 From 40a10caa6733f343021e9f1d87c426b5a2e9e0b4 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 12 Nov 2024 09:26:42 +0000 Subject: [PATCH 123/291] Added in changes for five day and/or cumulative sum --- .../process_daily_total_historical_data.py | 33 +++++++++++++++---- 1 file changed, 26 insertions(+), 7 deletions(-) diff --git a/src/scripts/climate_change/process_daily_total_historical_data.py b/src/scripts/climate_change/process_daily_total_historical_data.py index 104f536724..e6ec5595d3 100644 --- a/src/scripts/climate_change/process_daily_total_historical_data.py +++ b/src/scripts/climate_change/process_daily_total_historical_data.py @@ -10,11 +10,18 @@ ANC = True # facility data multiplier = 1000 - +five_day = True +cumulative = True general_facilities = gpd.read_file("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_districts.shp") facilities_with_lat_long = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_lat_long_region.csv") +if five_day: + window_size = 5 + if cumulative: + window_size_for_average = 1 + else: + window_size_for_average = 5 # Data accessed from https://dhis2.health.gov.mw/dhis-web-data-visualizer/#/YiQK65skxjz # Reporting rate is expected reporting vs actual reporting if ANC: @@ -70,7 +77,7 @@ days_for_grid = pr_data_for_square[begin_day:begin_day + month_length] moving_averages = [] for day in range(month_length - window_size + 1): - window_average = sum(days_for_grid[day:day + window_size]) / window_size + window_average = sum(days_for_grid[day:day + window_size]) / window_size_for_average moving_averages.append(window_average) max_moving_average = max(moving_averages) @@ -115,7 +122,7 @@ days_for_grid = pr_data_for_square[begin_day:begin_day + month_length] moving_averages = [] for day in range(month_length - window_size + 1): - window_average = sum(days_for_grid[day:day + window_size]) / window_size + window_average = sum(days_for_grid[day:day + window_size]) / window_size_for_average moving_averages.append(window_average) max_moving_average = max(moving_averages) @@ -128,8 +135,20 @@ df_of_facilities = df_of_facilities.iloc[:, :-3] ## THESE ARE OCT/NOV/DEC OF 2024, and for moment don't have that reporting data df_of_facilities = df_of_facilities.T -if ANC: - df_of_facilities.to_csv(Path(base_dir) / "historical_daily_total_by_facilities_with_ANC.csv") -else: - df_of_facilities.to_csv(Path(base_dir) / "historical_daily_total_by_facility.csv") +if five_day: + if cumulative: + if ANC: + df_of_facilities.to_csv(Path(base_dir) / "historical_daily_total_by_facilities_with_ANC_five_day_cumulative.csv") + else: + df_of_facilities.to_csv(Path(base_dir) / "historical_daily_total_by_facility_five_day_cumulative.csv") + else: + if ANC: + df_of_facilities.to_csv(Path(base_dir) / "historical_daily_total_by_facilities_with_ANC_five_day_average.csv") + else: + df_of_facilities.to_csv(Path(base_dir) / "historical_daily_total_by_facility_five_day_average.csv") +else: + if ANC: + df_of_facilities.to_csv(Path(base_dir) / "historical_daily_total_by_facilities_with_ANC.csv") + else: + df_of_facilities.to_csv(Path(base_dir) / "historical_daily_total_by_facility.csv") From f71b7d781d400735e7b49e6c02d900c7c7a0aa34 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 12 Nov 2024 09:33:08 +0000 Subject: [PATCH 124/291] Did all time points --- .../data_retrieval_ERA5_reanalysis_daily.py | 78 ++++++++++--------- 1 file changed, 42 insertions(+), 36 deletions(-) diff --git a/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py b/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py index fea7109307..a4aea25bb2 100644 --- a/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py +++ b/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py @@ -7,40 +7,46 @@ base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total" for year in years: - year_dir = os.path.join(base_dir, year) - if not os.path.exists(year_dir): - os.makedirs(year_dir) - os.chdir(year_dir) - dataset = "reanalysis-era5-single-levels" - request = { - "product_type": ["reanalysis"], - "variable": ["total_precipitation"], - "year": year, - "month": [ - "01", "02", "03", - "04", "05", "06", - "07", "08", "09", - "10", "11", "12" - ], - "day": [ - "01", "02", "03", - "04", "05", "06", - "07", "08", "09", - "10", "11", "12", - "13", "14", "15", - "16", "17", "18", - "19", "20", "21", - "22", "23", "24", - "25", "26", "27", - "28", "29", "30", - "31" - ], - "time": [ - "00:00"], - "data_format": "grib", - "download_format": "unarchived", - "area": [-9.36366167, 32.67161823, -17.12627881, 35.91841716] - } + year_dir = os.path.join(base_dir, year) + if not os.path.exists(year_dir): + os.makedirs(year_dir) + os.chdir(year_dir) + dataset = "reanalysis-era5-single-levels" + request = { + "product_type": ["reanalysis"], + "variable": ["total_precipitation"], + "year": year, + "month": [ + "01", "02", "03", + "04", "05", "06", + "07", "08", "09", + "10", "11", "12" + ], + "day": [ + "01", "02", "03", + "04", "05", "06", + "07", "08", "09", + "10", "11", "12", + "13", "14", "15", + "16", "17", "18", + "19", "20", "21", + "22", "23", "24", + "25", "26", "27", + "28", "29", "30", + "31" + ], + "time": ["00:00", "01:00", "02:00", + "03:00", "04:00", "05:00", + "06:00", "07:00", "08:00", + "09:00", "10:00", "11:00", + "12:00", "13:00", "14:00", + "15:00", "16:00", "17:00", + "18:00", "19:00", "20:00", + "21:00", "22:00", "23:00"], + "data_format": "netcdf", + "download_format": "unarchived", + "area": [-9.36366167, 32.67161823, -17.12627881, 35.91841716] + } - client = cdsapi.Client() - client.retrieve(dataset, request).download() + client = cdsapi.Client() + client.retrieve(dataset, request).download() From a317df120feebba652421c2b78489b62a4c4ea42 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 12 Nov 2024 09:38:57 +0000 Subject: [PATCH 125/291] Changed to allow for fact that data was hourly, so need to add up over all entry points for a day --- .../climate_change/process_daily_total_historical_data.py | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/src/scripts/climate_change/process_daily_total_historical_data.py b/src/scripts/climate_change/process_daily_total_historical_data.py index e6ec5595d3..92526e3e42 100644 --- a/src/scripts/climate_change/process_daily_total_historical_data.py +++ b/src/scripts/climate_change/process_daily_total_historical_data.py @@ -71,7 +71,10 @@ pr_data_for_square = pr_data[:, i, j] if grid not in max_average_by_grid: max_average_by_grid[grid] = [] - + # Aggregate hourly data to daily totals + daily_totals = [ + sum(pr_data_for_square[day*24:(day+1)*24]) for day in range(len(pr_data_for_square) // 24) + ] begin_day = 0 for month_idx, month_length in enumerate(month_lengths): days_for_grid = pr_data_for_square[begin_day:begin_day + month_length] @@ -117,6 +120,9 @@ index_for_x = ((long_data - long_for_facility) ** 2).argmin() index_for_y = ((lat_data - lat_for_facility) ** 2).argmin() pr_data_for_square = pr_data[:, index_for_y, index_for_x] + daily_totals = [ + sum(pr_data_for_square[day*24:(day+1)*24]) for day in range(len(pr_data_for_square) // 24) + ] begin_day = 0 for month_idx, month_length in enumerate(month_lengths): days_for_grid = pr_data_for_square[begin_day:begin_day + month_length] From 8c2d12b0fbc5cdcc5d72acc84e60ad88c4ef952a Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 12 Nov 2024 09:59:28 +0000 Subject: [PATCH 126/291] Removed unnecessary repeat --- src/scripts/climate_change/process_CMIP6_data.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/scripts/climate_change/process_CMIP6_data.py b/src/scripts/climate_change/process_CMIP6_data.py index c4b93f0440..2f2949c959 100644 --- a/src/scripts/climate_change/process_CMIP6_data.py +++ b/src/scripts/climate_change/process_CMIP6_data.py @@ -69,8 +69,6 @@ def extract_nc_files_from_unzipped_folders(directory): # Put all into one csv file -base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/" - file_list = glob.glob(os.path.join(base_dir, "*.nc")) data_by_model_and_grid = {} From 1af6a2259b820bd6dd7d3e75a2edde26cf720c22 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 12 Nov 2024 09:59:46 +0000 Subject: [PATCH 127/291] Added in code to load 5 day cumulative --- ...al_realtionship_reporting_precipitation.py | 59 +++++++++++++------ 1 file changed, 40 insertions(+), 19 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index ae76c2dd73..4f8cdb8fbb 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -6,17 +6,34 @@ from statsmodels.othermod.betareg import BetaModel ANC = True -daily_max = True +daily_max = False +daily_total = True min_year_for_analyis = 2011 absolute_min_year = 2011 mask_threshold = 0 +five_day = True +cumulative = True # # data is from 2011 - 2024 - for facility if ANC: monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_ANC_by_smaller_facility_lm.csv", index_col=0) if daily_max: + if five_day: + if cumulative: + weather_data_historical = pd.read_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_maximum/historical_daily_total_by_facilities_with_ANC_five_day_cumulative.csv", + index_col=0) + else: + weather_data_historical = pd.read_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_maximum/historical_daily_total_by_facilities_with_ANC_five_day_average.csv", + index_col=0) + else: + weather_data_historical = pd.read_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_maximum/historical_daily_max_by_facilities_with_ANC.csv", + index_col=0) + elif daily_total: weather_data_historical = pd.read_csv( - "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_maximum/historical_daily_max_by_facilities_with_ANC.csv", - index_col=0) + "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/historical_daily_total_by_facilities_with_ANC.csv", + index_col=0) else: weather_data_historical = pd.read_csv( "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_ANC_lm.csv", @@ -28,6 +45,10 @@ weather_data_historical = pd.read_csv( "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_maximum/historical_daily_max_by_facility.csv", index_col=0) + elif daily_total: + weather_data_historical = pd.read_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/historical_daily_total_by_facility.csv", + index_col=0) else: weather_data_historical = pd.read_csv( "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facility_lm.csv", @@ -155,14 +176,14 @@ def repeat_info(info, num_facilities, year_range): weather_data, year_flattened, month_flattened, - # resid_encoded, - # zone_encoded, - # owner_encoded, - # ftype_encoded, - # lag_1_month, - # lag_3_month, - # altitude, - # above_below_X + resid_encoded, + zone_encoded, + owner_encoded, + ftype_encoded, + lag_1_month, + lag_3_month, + altitude, + above_below_X ]) results, y_pred, mask = build_model(X, np.log(y) , X_mask_mm = mask_threshold) @@ -194,14 +215,14 @@ def repeat_info(info, num_facilities, year_range): #plt.show() # save model - -# Save the model using pickle -with open('linear_model_ANC_daily_max.pkl', 'wb') as file: - pickle.dump(results, file) - -# Now you can load the model and use it for predictions -with open('saved_model.pkl', 'rb') as file: - loaded_model = pickle.load(file) +# +# # Save the model using pickle +# with open('linear_model_ANC_daily_max.pkl', 'wb') as file: +# pickle.dump(results, file) +# +# # Now you can load the model and use it for predictions +# with open('saved_model.pkl', 'rb') as file: +# loaded_model = pickle.load(file) From fc5b4b528435e9f6deb57e47ec6981a9f1402a7e Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 12 Nov 2024 10:00:09 +0000 Subject: [PATCH 128/291] Data to put CMIP6 models on the Malawi grid --- .../climate_change/grid_malawi_CMIP6.py | 94 +++++++++++++++++++ 1 file changed, 94 insertions(+) create mode 100644 src/scripts/climate_change/grid_malawi_CMIP6.py diff --git a/src/scripts/climate_change/grid_malawi_CMIP6.py b/src/scripts/climate_change/grid_malawi_CMIP6.py new file mode 100644 index 0000000000..aee593ee9c --- /dev/null +++ b/src/scripts/climate_change/grid_malawi_CMIP6.py @@ -0,0 +1,94 @@ +import glob +import os +import re +import geopandas as gpd +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd +from netCDF4 import Dataset +from shapely.geometry import Polygon +import matplotlib.cm as cm + +# Load netCDF data for gridding info +#file_path = "/Users/rem76/Downloads/821bebfbcee0609d233c09e8b2bbc1f3/pr_Amon_UKESM1-0-LL_ssp119_r1i1p1f2_gn_20150116-20991216.nc" +file_path_historical_data = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/139ef85ab4df0a12fc01854395fc9a6d.nc" +dataset = Dataset(file_path_historical_data, mode='r') +print(dataset.variables.keys()) +pr_data = dataset.variables['tp'][:] # ['pr'][:] pr for projections, tp for historical +lat_data = dataset.variables['latitude'][:] #['lat'][:] +long_data = dataset.variables['longitude'][:] #['lon'][:] +meshgrid_from_netCDF = np.meshgrid(long_data, lat_data) + +# Load Malawi shapefile +malawi = gpd.read_file("/Users/rem76/PycharmProjects/TLOmodel/resources/mapping/ResourceFile_mwi_admbnda_adm0_nso_20181016.shp") +malawi_admin1 = gpd.read_file("/Users/rem76/PycharmProjects/TLOmodel/resources/mapping/ResourceFile_mwi_admbnda_adm1_nso_20181016.shp") +malawi_admin2 = gpd.read_file("/Users/rem76/PycharmProjects/TLOmodel/resources/mapping/ResourceFile_mwi_admbnda_adm2_nso_20181016.shp") +#grid_size = 1 +#minx, miny, maxx, maxy = malawi.total_bounds +#x_coords = np.arange(minx, maxx, grid_size) my gridding doesn't work - based on a different projection, maybe? +#y_coords = np.arange(miny, maxy, grid_size) +#polygons = [Polygon([(x, y), (x + grid_size, y), (x + grid_size, y + grid_size), (x, y + grid_size)]) for x in x_coords for y in y_coords] + +difference_lat = lat_data[1] - lat_data[0] # as is a grid, the difference is the same for all sequential coordinates +difference_long = long_data[1] - long_data[0] + +polygons = [] +for x in long_data: + for y in lat_data: + bottom_left = (x, y) + bottom_right = (x + difference_long, y) + top_right = (x + difference_long, y + difference_lat) + top_left = (x, y + difference_lat) + polygon = Polygon([bottom_left, bottom_right, top_right, top_left]) + polygons.append(polygon) + +grid = gpd.GeoDataFrame({'geometry': polygons}, crs=malawi.crs) +grid_clipped = gpd.overlay(grid, malawi, how='intersection') # for graphing +grid_clipped_ADM1 = gpd.overlay(grid, malawi_admin1, how='intersection') # for graphing +grid_clipped_ADM2 = gpd.overlay(grid, malawi_admin2, how='intersection') # for graphing +cmap = plt.cm.get_cmap('tab20', len(grid_clipped_ADM1['ADM1_EN'].unique())) +grid.to_file("/Users/rem76/Desktop/Climate_change_health/Data/malawi_grid_0_025.shp") + +fig, ax = plt.subplots(figsize=(10, 10)) +malawi_admin2.plot(ax=ax, edgecolor='black', color='white') +grid.plot(ax=ax, edgecolor='#1C6E8C', color='white') +grid_clipped_ADM2.plot(ax=ax,edgecolor='#1C6E8C', alpha=0.4) +grid_clipped_ADM1.plot(column='ADM1_EN', ax=ax, cmap=cmap, edgecolor='#1C6E8C', alpha=0.7) + +# Finalize plot +plt.title("Malawi with Overlaying Grids") +plt.xlabel("Longitude") +plt.ylabel("Latitude") +#plt.show() + + +### SSP25 model grid +base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/" +scenarios = ["ssp2_4_5"] + +file_list = glob.glob(os.path.join(base_dir, "*.nc")) +colors = cm.get_cmap("tab20", 20) + +data_by_model_and_grid = {} +for scenario in scenarios: + print(scenario) + scenario_directory = os.path.join(base_dir, scenario) + nc_file_directory = os.path.join(scenario_directory, 'nc_files') + for idx, file in enumerate(glob.glob(os.path.join(nc_file_directory, "*.nc"))): + model = re.search(r'pr_day_(.*?)_' + scenario.replace('_', ''), file).group(1) + data_per_model = Dataset(file, mode='r') + pr_data = data_per_model.variables['pr'][:] # in kg m-2 s-1 = mm s-1 x 86400 to get to day + lat_data = data_per_model.variables['lat'][:] + long_data = data_per_model.variables['lon'][:] + print(colors(idx)) + for lon in long_data: + ax.axvline(x=lon, color=colors(idx), linestyle='--', linewidth=0.5) + for lat in lat_data: + ax.axhline(y=lat, color=colors(idx), linestyle='--', linewidth=0.5) + + # Customize your plot as needed + ax.set_xlabel('Longitude') + ax.set_ylabel('Latitude') + + +plt.show() From 54fbd7ace96c430dd5d4e933252d62cd9083073f Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 12 Nov 2024 10:29:32 +0000 Subject: [PATCH 129/291] Plot individual grids --- .../climate_change/plot_raw_data_CMIP6.py | 119 +++++++++++------- 1 file changed, 75 insertions(+), 44 deletions(-) diff --git a/src/scripts/climate_change/plot_raw_data_CMIP6.py b/src/scripts/climate_change/plot_raw_data_CMIP6.py index 9871d41499..7d3017efd7 100644 --- a/src/scripts/climate_change/plot_raw_data_CMIP6.py +++ b/src/scripts/climate_change/plot_raw_data_CMIP6.py @@ -83,12 +83,12 @@ for long in range(len(long_data)): plt.plot(data_by_gridpoint.columns, data_by_gridpoint.iloc[grid], label=f"Grid {grid + 1}") -plt.xlabel("Timepoint") # Adjust this label based on your data -plt.ylabel("Precipitation (mm)") -print(len(data_by_gridpoint.columns)) -plt.xticks(ticks=np.arange(0, len(data_by_gridpoint.columns), step=365), - labels=years) -#plt.show() + plt.xlabel("Timepoint") # Adjust this label based on your data + plt.ylabel("Precipitation (mm)") + print(len(data_by_gridpoint.columns)) + plt.xticks(ticks=np.arange(0, len(data_by_gridpoint.columns), step=365), + labels=years) + #plt.show() ### Plot median and IQ range precipitation by grid by time point @@ -103,24 +103,25 @@ num_cols = math.ceil(math.sqrt(num_grids)) num_rows = math.ceil(num_grids / num_cols) -fig, axs = plt.subplots(num_rows, num_cols, figsize=(15, 10)) +# first 6 +fig, axs = plt.subplots(2, 2, figsize=(15, 10)) fig.suptitle("Median Precipitation with IQR Shaded Area by Grid") axs = axs.flatten() -for idx, grid in enumerate(median_df.index): +for idx, grid in enumerate(median_df.index[0:4]): median_values = median_df.loc[grid].values timepoints = range(len(median_values)) axs[idx].fill_between(timepoints, percentile_25_df.loc[grid], percentile_75_df.loc[grid], alpha=0.5, color = "lightblue") axs[idx].plot(timepoints, median_values, color="blue") - axs[idx].set_ylim(0,10) - axs[idx].set_xlim(0,365*10) + axs[idx].set_ylim(0,40) + #axs[idx].set_xlim(0,365*10) axs[idx].set_title(f"Grid {grid}") axs[idx].set_xlabel("Year") - axs[idx].set_xticks(ticks=np.arange(0, len(data_by_gridpoint.columns), step=365*5), - labels=[year for i, year in enumerate(years) if i % 5 == 0]) + axs[idx].set_xticks(ticks=np.arange(0, len(data_by_gridpoint.columns), step=365*10), + labels=[year for i, year in enumerate(years) if i % 10 == 0]) axs[idx].set_ylabel("Precipitation (mm)") for ax in axs[num_grids:]: @@ -129,45 +130,75 @@ plt.tight_layout(rect=[0, 0.03, 1, 0.95]) plt.show() -## film for each grid point? -# Define grid layout -num_grids = len(median_df.index) -num_cols = math.ceil(math.sqrt(num_grids)) -num_rows = math.ceil(num_grids / num_cols) +# second 4 -# Set up figure -fig, ax = plt.subplots(figsize=(10, 8)) -cbar = None +fig, axs = plt.subplots(2, 2, figsize=(15, 10)) +fig.suptitle("Median Precipitation with IQR Shaded Area by Grid") +axs = axs.flatten() -# Create an animation function -def animate(i): - global cbar - ax.clear() # Clear the previous frame - - # Reshape median data and IQR data for heat map - median_values = median_df.iloc[:, i].values.reshape(num_rows, num_cols) - iqr_values = (percentile_75_df.iloc[:, i] - percentile_25_df.iloc[:, i]).values.reshape(num_rows, num_cols) - - # Plot heatmap with IQR as a color gradient - heatmap = ax.imshow(median_values, cmap="coolwarm", interpolation="nearest", vmin=0, vmax=40) +for idx, grid in enumerate(median_df.index[4:8]): + median_values = median_df.loc[grid].values + timepoints = range(len(median_values)) - # Remove old colorbar and add a new one - if cbar: - cbar.remove() - cbar = fig.colorbar(heatmap, ax=ax, fraction=0.046, pad=0.04) - cbar.set_label("Precipitation (mm)") + axs[idx].fill_between(timepoints, percentile_25_df.loc[grid], percentile_75_df.loc[grid], alpha=0.5, color = "lightblue") + axs[idx].plot(timepoints, median_values, color="blue") - # Set title - ax.set_title(f"Median Precipitation with IQR (Time Point {i + 1})") - ax.set_xticks([]) - ax.set_yticks([]) + axs[idx].set_ylim(0,40) + #axs[idx].set_xlim(0,365*10) + axs[idx].set_title(f"Grid {grid}") + axs[idx].set_xlabel("Year") + axs[idx].set_xticks(ticks=np.arange(0, len(data_by_gridpoint.columns), step=365*5), + labels=[year for i, year in enumerate(years) if i % 5 == 0]) + axs[idx].set_ylabel("Precipitation (mm)") -# Create animation -ani = animation.FuncAnimation(fig, animate, frames=median_df.shape[1], repeat=False) +for ax in axs[num_grids:]: + ax.set_visible(False) -# Save animation as a movie (e.g., MP4 format) -ani.save("median_precipitation_movie.mp4", writer="ffmpeg", dpi=100) +plt.tight_layout(rect=[0, 0.03, 1, 0.95]) plt.show() +# +# ## film for each grid point? +# +# # Define grid layout +# num_grids = len(median_df.index) +# num_cols = math.ceil(math.sqrt(num_grids)) +# num_rows = math.ceil(num_grids / num_cols) +# +# # Set up figure +# fig, ax = plt.subplots(figsize=(10, 8)) +# cbar = None +# +# +# # Create an animation function +# def animate(i): +# global cbar +# ax.clear() # Clear the previous frame +# +# # Reshape median data and IQR data for heat map +# median_values = median_df.iloc[:, i].values.reshape(num_rows, num_cols) +# iqr_values = (percentile_75_df.iloc[:, i] - percentile_25_df.iloc[:, i]).values.reshape(num_rows, num_cols) +# +# # Plot heatmap with IQR as a color gradient +# heatmap = ax.imshow(median_values, cmap="coolwarm", interpolation="nearest", vmin=0, vmax=40) +# +# # Remove old colorbar and add a new one +# if cbar: +# cbar.remove() +# cbar = fig.colorbar(heatmap, ax=ax, fraction=0.046, pad=0.04) +# cbar.set_label("Precipitation (mm)") +# +# # Set title +# ax.set_title(f"Median Precipitation with IQR (Time Point {i + 1})") +# ax.set_xticks([]) +# ax.set_yticks([]) +# +# +# # Create animation +# ani = animation.FuncAnimation(fig, animate, frames=median_df.shape[1], repeat=False) +# +# # Save animation as a movie (e.g., MP4 format) +# ani.save("median_precipitation_movie.mp4", writer="ffmpeg", dpi=100) +# plt.show() From 94abde81bc5f113f1a4710fee31dd60a04e428ab Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 12 Nov 2024 15:07:01 +0000 Subject: [PATCH 130/291] Added model to generate new y data set. Residuals of model without the rain variable, as this will then give the expected change --- ...al_realtionship_reporting_precipitation.py | 133 +++++++++++++----- 1 file changed, 101 insertions(+), 32 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 4f8cdb8fbb..41502f302e 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -4,10 +4,11 @@ import pickle import statsmodels.api as sm from statsmodels.othermod.betareg import BetaModel +from collections import defaultdict ANC = True daily_max = False -daily_total = True +daily_total = False min_year_for_analyis = 2011 absolute_min_year = 2011 mask_threshold = 0 @@ -54,6 +55,36 @@ "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facility_lm.csv", index_col=0) + +def build_model(X, y, scale_y=False, beta=False, X_mask_mm=0): + epsilon = 1e-5 + if scale_y: + y_scaled = np.clip(y / 100, epsilon, 1 - epsilon) + else: + y_scaled = y + mask = ~np.isnan(X).any(axis=1) & ~np.isnan(y_scaled) & (X[:, 0] >= X_mask_mm) + model = BetaModel(y_scaled[mask], X[mask]) if beta else sm.OLS(y_scaled[mask], X[mask]) + model_fit = model.fit() + predictions = model_fit.predict(X[mask]) + residuals = y_scaled[mask] - predictions + return model_fit, predictions, residuals, mask + +def create_binary_feature(threshold, weather_data_df, recent_months): + binary_feature_list = [] + for facility in weather_data_df.columns: + facility_data = weather_data_df[facility] + + for i in range(len(facility_data)): + facility_threshold = threshold[i] if hasattr(threshold, "__len__") else threshold + + if i >= recent_months: + last_x_values = facility_data[i - recent_months:i] + binary_feature_list.append(1 if (last_x_values > facility_threshold).any() else 0) + else: + binary_feature_list.append(np.nan) + + return binary_feature_list + ## Drop September 2024 - weather_data_historical = weather_data_historical.drop(weather_data_historical.index[-1]) monthly_reporting_by_facility = monthly_reporting_by_facility.drop(monthly_reporting_by_facility.index[-1]) @@ -80,17 +111,6 @@ # Flatten data weather_data = weather_data_historical.values.flatten() y = monthly_reporting_by_facility.values.flatten() -def build_model(X, y, scale_y=False, beta=False, X_mask_mm = 0): - epsilon = 1e-5 - if scale_y: - y_scaled = np.clip(y / 100, epsilon, 1 - epsilon) - else: - y_scaled = y - mask = ~np.isnan(X).any(axis=1) & ~np.isnan(y_scaled) & (X[:, 0] >= X_mask_mm) - model = BetaModel(y_scaled[mask], X[mask]) if beta else sm.OLS(y_scaled[mask], X[mask]) - model_fit = model.fit() - return model_fit, model_fit.predict(X[mask]), mask - # One-hot encode facilities facility_encoded = pd.get_dummies(facility_flattened, drop_first=True) @@ -101,22 +121,6 @@ def build_model(X, y, scale_y=False, beta=False, X_mask_mm = 0): 'weather_data': weather_data }).groupby(['facility', 'month'])['weather_data'].mean().reset_index() -def create_binary_feature(threshold, weather_data_df, recent_months): - binary_feature_list = [] - for facility in weather_data_df.columns: - facility_data = weather_data_df[facility] - - for i in range(len(facility_data)): - facility_threshold = threshold[i] if hasattr(threshold, "__len__") else threshold - - if i >= recent_months: - last_x_values = facility_data[i - recent_months:i] - binary_feature_list.append(1 if (last_x_values > facility_threshold).any() else 0) - else: - binary_feature_list.append(np.nan) - - return binary_feature_list - above_below_average = create_binary_feature( grouped_data.groupby(['facility', 'month'])['weather_data'].transform('mean'), weather_data_historical, 0 ) @@ -151,7 +155,41 @@ def repeat_info(info, num_facilities, year_range): altitude = np.where(altitude < 0, np.nan, altitude) altitude = list(altitude) +#### STEP 1: GENERATE PREDICTIONS OF ANC DATA ########### +X = np.column_stack([ + year_flattened, + month_flattened, + resid_encoded, + zone_encoded, + owner_encoded, + ftype_encoded, + facility_encoded, + altitude +]) +results, y_pred, residuals, mask = build_model(X, np.log(y) , X_mask_mm = mask_threshold) +print(results) +year_month_labels = np.array([f"{y}-{m}" for y, m in zip(year_flattened, month_flattened)]) +X_filtered = X[mask] +y_filtered = y[mask] +year_month_labels_filtered = year_month_labels[mask] +# residuals are the next "y" variable, as they are the defecit in cases +plt.scatter(year_month_labels_filtered, np.log(y_filtered), color='#1C6E8C', alpha=0.5, label='Actual data') +plt.scatter(year_month_labels_filtered, y_pred, color='#9AC4F8', alpha=0.7, label='Predicted data') +#plt.xticks(ticks=, labels=sorted_years, rotation=45, ha='right') + +plt.xticks(rotation=45, ha='right') +plt.xlabel('Year') +plt.ylabel('Log(Number of ANC visits)') +plt.title('Monthly ANC Visits vs. Precipitation') +plt.ylim(0, 10) +plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) +plt.tight_layout() +plt.show() + +### STEP 2 - USE THESE IN PREDICTIONS### + +y = residuals X = np.column_stack([ weather_data, @@ -166,7 +204,7 @@ def repeat_info(info, num_facilities, year_range): facility_encoded, altitude ]) -results, y_pred, mask = build_model(X, np.log(y) , X_mask_mm = mask_threshold) +results, y_pred, residuals, mask = build_model(X, np.log(y) , X_mask_mm = mask_threshold) if np.nanmin(y) < 1: y += 1e-6 # Shift to ensure positivity @@ -185,7 +223,7 @@ def repeat_info(info, num_facilities, year_range): altitude, above_below_X ]) -results, y_pred, mask = build_model(X, np.log(y) , X_mask_mm = mask_threshold) +results, y_pred, residuals, mask = build_model(X, np.log(y) , X_mask_mm = mask_threshold) print(results.summary()) @@ -193,7 +231,6 @@ def repeat_info(info, num_facilities, year_range): ##### Plot y_predic X_filtered = X[mask] -print(y_pred) if ANC: plt.scatter(X_filtered[:, 0], np.log(y) [mask], color='red', alpha=0.5) plt.scatter(X_filtered[:, 0], y_pred) @@ -225,4 +262,36 @@ def repeat_info(info, num_facilities, year_range): # loaded_model = pickle.load(file) - +year_month_labels = np.array([f"{y}-{m}" for y, m in zip(year_flattened, month_flattened)]) +X_filtered = X[mask] +y_filtered = y[mask] +year_month_labels_filtered = year_month_labels[mask] +# first_index_by_year = {} +# years_in_labels = [label[:4] for label in year_month_labels_filtered] +# year_counts = defaultdict(int) +# for year in years_in_labels: +# year_counts[year] += 1 +# print(year_counts) +# sorted_years = sorted(year_counts.keys()) +# print(sorted_years) +# cumulative_counts = [] +# cumulative_sum = 0 +# for year in sorted_years: +# cumulative_sum += year_counts[year] +# cumulative_counts.append(cumulative_sum) +# cumulative_counts = [first_index_by_year[year] for year in sorted_years] +# +print(year_month_labels_filtered) +plt.figure(figsize=(12, 6)) +plt.scatter(year_month_labels_filtered, np.log(y_filtered), color='#1C6E8C', alpha=0.5, label='Actual data') +plt.scatter(year_month_labels_filtered, y_pred, color='#9AC4F8', alpha=0.7, label='Predicted data') +#plt.xticks(ticks=, labels=sorted_years, rotation=45, ha='right') + +plt.xticks(rotation=45, ha='right') +plt.xlabel('Year') +plt.ylabel('Log(Number of ANC visits)') +plt.title('Monthly ANC Visits vs. Precipitation') +plt.ylim(0, 10) +plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) +plt.tight_layout() +plt.show() From a24a8e46014c4c3fb2542cb9f1a13a72878d3393 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 12 Nov 2024 15:55:48 +0000 Subject: [PATCH 131/291] Reordered code for clarity. Introduced second model that uses the outputs from the first (as % change in ANC visits) --- ...al_realtionship_reporting_precipitation.py | 208 +++++++++--------- 1 file changed, 105 insertions(+), 103 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 41502f302e..5351bb65f2 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -55,8 +55,7 @@ "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facility_lm.csv", index_col=0) - -def build_model(X, y, scale_y=False, beta=False, X_mask_mm=0): +def build_model(X, y, scale_y=False, beta=False, X_mask_mm = 0): epsilon = 1e-5 if scale_y: y_scaled = np.clip(y / 100, epsilon, 1 - epsilon) @@ -65,9 +64,7 @@ def build_model(X, y, scale_y=False, beta=False, X_mask_mm=0): mask = ~np.isnan(X).any(axis=1) & ~np.isnan(y_scaled) & (X[:, 0] >= X_mask_mm) model = BetaModel(y_scaled[mask], X[mask]) if beta else sm.OLS(y_scaled[mask], X[mask]) model_fit = model.fit() - predictions = model_fit.predict(X[mask]) - residuals = y_scaled[mask] - predictions - return model_fit, predictions, residuals, mask + return model_fit, model_fit.predict(X[mask]), mask def create_binary_feature(threshold, weather_data_df, recent_months): binary_feature_list = [] @@ -85,6 +82,8 @@ def create_binary_feature(threshold, weather_data_df, recent_months): return binary_feature_list + +###### Tidy data ############ ## Drop September 2024 - weather_data_historical = weather_data_historical.drop(weather_data_historical.index[-1]) monthly_reporting_by_facility = monthly_reporting_by_facility.drop(monthly_reporting_by_facility.index[-1]) @@ -111,6 +110,8 @@ def create_binary_feature(threshold, weather_data_df, recent_months): # Flatten data weather_data = weather_data_historical.values.flatten() y = monthly_reporting_by_facility.values.flatten() +if np.nanmin(y) < 1: + y += 1e-6 # Shift to ensure positivity as taking log # One-hot encode facilities facility_encoded = pd.get_dummies(facility_flattened, drop_first=True) @@ -166,64 +167,65 @@ def repeat_info(info, num_facilities, year_range): facility_encoded, altitude ]) -results, y_pred, residuals, mask = build_model(X, np.log(y) , X_mask_mm = mask_threshold) +results, y_pred, mask_ANC_data = build_model(X, np.log(y) , X_mask_mm = mask_threshold) -print(results) +residuals_percentage = (y[mask_ANC_data] - y_pred)/y[mask_ANC_data] +print(results.summary()) year_month_labels = np.array([f"{y}-{m}" for y, m in zip(year_flattened, month_flattened)]) -X_filtered = X[mask] -y_filtered = y[mask] -year_month_labels_filtered = year_month_labels[mask] -# residuals are the next "y" variable, as they are the defecit in cases -plt.scatter(year_month_labels_filtered, np.log(y_filtered), color='#1C6E8C', alpha=0.5, label='Actual data') -plt.scatter(year_month_labels_filtered, y_pred, color='#9AC4F8', alpha=0.7, label='Predicted data') -#plt.xticks(ticks=, labels=sorted_years, rotation=45, ha='right') - +y_filtered = y[mask_ANC_data] +year_month_labels_filtered = year_month_labels[mask_ANC_data] +data_ANC_predictions = pd.DataFrame({ + 'Year_Month': year_month_labels_filtered, + 'y_filtered': y_filtered +}) +data_ANC_predictions = data_ANC_predictions.sort_values(by='Year_Month').reset_index(drop=True) +# # residuals are the next "y" variable, as they are the defecit in cases +plt.scatter(data_ANC_predictions['Year_Month'], np.log(data_ANC_predictions['y_filtered']), color='#1C6E8C', alpha=0.5, label='Actual data') +plt.scatter(data_ANC_predictions['Year_Month'], residuals_percentage, color='#9AC4F8', alpha=0.7, label='Residuals') plt.xticks(rotation=45, ha='right') plt.xlabel('Year') plt.ylabel('Log(Number of ANC visits)') plt.title('Monthly ANC Visits vs. Precipitation') plt.ylim(0, 10) -plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) +plt.legend(loc='upper left') plt.tight_layout() plt.show() +# +# ### STEP 2 - USE THESE IN PREDICTIONS### +# +y = residuals_percentage -### STEP 2 - USE THESE IN PREDICTIONS### - -y = residuals - +# X = np.column_stack([ - weather_data, - year_flattened, - month_flattened, - resid_encoded, - zone_encoded, - owner_encoded, - ftype_encoded, - lag_1_month, - lag_3_month, - facility_encoded, - altitude + weather_data[mask_ANC_data], + np.array(year_flattened)[mask_ANC_data], + np.array(month_flattened)[mask_ANC_data], + resid_encoded[mask_ANC_data], + zone_encoded[mask_ANC_data], + owner_encoded[mask_ANC_data], + ftype_encoded[mask_ANC_data], + lag_1_month[mask_ANC_data], + lag_3_month[mask_ANC_data], + facility_encoded[mask_ANC_data], + np.array(altitude)[mask_ANC_data] ]) -results, y_pred, residuals, mask = build_model(X, np.log(y) , X_mask_mm = mask_threshold) - -if np.nanmin(y) < 1: - y += 1e-6 # Shift to ensure positivity +results, y_pred, mask = build_model(X, y, X_mask_mm = mask_threshold) +print(results.summary()) +# ### Now include only significant predictors -### Now include only significant predictors X = np.column_stack([ - weather_data, - year_flattened, - month_flattened, - resid_encoded, - zone_encoded, - owner_encoded, - ftype_encoded, - lag_1_month, - lag_3_month, - altitude, - above_below_X + weather_data[mask_ANC_data], + np.array(year_flattened)[mask_ANC_data], + np.array(month_flattened)[mask_ANC_data], + resid_encoded[mask_ANC_data], + zone_encoded[mask_ANC_data], + owner_encoded[mask_ANC_data], + ftype_encoded[mask_ANC_data], + lag_1_month[mask_ANC_data], + lag_3_month[mask_ANC_data], + np.array(altitude)[mask_ANC_data] ]) -results, y_pred, residuals, mask = build_model(X, np.log(y) , X_mask_mm = mask_threshold) +results, y_pred, mask_weather_data = build_model(X, y, X_mask_mm = mask_threshold) print(results.summary()) @@ -232,66 +234,66 @@ def repeat_info(info, num_facilities, year_range): X_filtered = X[mask] if ANC: - plt.scatter(X_filtered[:, 0], np.log(y) [mask], color='red', alpha=0.5) + plt.scatter(X_filtered[:, 0], y [mask], color='red', alpha=0.5) plt.scatter(X_filtered[:, 0], y_pred) plt.title(' ') - plt.ylabel('Number of ANC visits') + plt.ylabel('% change in ANC visits') plt.xlabel('Precip (mm)') - plt.ylim(0,10) + #plt.ylim(-,10) plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) plt.show() -else: - - plt.scatter(X_filtered[:, 0], np.log(y)[mask], color='red', alpha=0.5) - plt.scatter(X_filtered[:, 0], y_pred) - plt.title(' ') - plt.ylabel('Reporting (%)') - plt.xlabel('Precip (mm)') - plt.ylim(0, 100) - plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) - #plt.show() - -# save model +# else: # -# # Save the model using pickle -# with open('linear_model_ANC_daily_max.pkl', 'wb') as file: -# pickle.dump(results, file) +# plt.scatter(X_filtered[:, 0], np.log(y)[mask], color='red', alpha=0.5) +# plt.scatter(X_filtered[:, 0], y_pred) +# plt.title(' ') +# plt.ylabel('Reporting (%)') +# plt.xlabel('Precip (mm)') +# plt.ylim(0, 100) +# plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) +# #plt.show() # -# # Now you can load the model and use it for predictions -# with open('saved_model.pkl', 'rb') as file: -# loaded_model = pickle.load(file) - - -year_month_labels = np.array([f"{y}-{m}" for y, m in zip(year_flattened, month_flattened)]) -X_filtered = X[mask] -y_filtered = y[mask] -year_month_labels_filtered = year_month_labels[mask] -# first_index_by_year = {} -# years_in_labels = [label[:4] for label in year_month_labels_filtered] -# year_counts = defaultdict(int) -# for year in years_in_labels: -# year_counts[year] += 1 -# print(year_counts) -# sorted_years = sorted(year_counts.keys()) -# print(sorted_years) -# cumulative_counts = [] -# cumulative_sum = 0 -# for year in sorted_years: -# cumulative_sum += year_counts[year] -# cumulative_counts.append(cumulative_sum) -# cumulative_counts = [first_index_by_year[year] for year in sorted_years] +# # save model +# # +# # # Save the model using pickle +# # with open('linear_model_ANC_daily_max.pkl', 'wb') as file: +# # pickle.dump(results, file) +# # +# # # Now you can load the model and use it for predictions +# # with open('saved_model.pkl', 'rb') as file: +# # loaded_model = pickle.load(file) # -print(year_month_labels_filtered) -plt.figure(figsize=(12, 6)) -plt.scatter(year_month_labels_filtered, np.log(y_filtered), color='#1C6E8C', alpha=0.5, label='Actual data') -plt.scatter(year_month_labels_filtered, y_pred, color='#9AC4F8', alpha=0.7, label='Predicted data') -#plt.xticks(ticks=, labels=sorted_years, rotation=45, ha='right') - -plt.xticks(rotation=45, ha='right') -plt.xlabel('Year') -plt.ylabel('Log(Number of ANC visits)') -plt.title('Monthly ANC Visits vs. Precipitation') -plt.ylim(0, 10) -plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) -plt.tight_layout() -plt.show() +# +# year_month_labels = np.array([f"{y}-{m}" for y, m in zip(year_flattened, month_flattened)]) +# X_filtered = X[mask] +# y_filtered = y[mask] +# year_month_labels_filtered = year_month_labels[mask] +# # first_index_by_year = {} +# # years_in_labels = [label[:4] for label in year_month_labels_filtered] +# # year_counts = defaultdict(int) +# # for year in years_in_labels: +# # year_counts[year] += 1 +# # print(year_counts) +# # sorted_years = sorted(year_counts.keys()) +# # print(sorted_years) +# # cumulative_counts = [] +# # cumulative_sum = 0 +# # for year in sorted_years: +# # cumulative_sum += year_counts[year] +# # cumulative_counts.append(cumulative_sum) +# # cumulative_counts = [first_index_by_year[year] for year in sorted_years] +# # +# print(year_month_labels_filtered) +# plt.figure(figsize=(12, 6)) +# plt.scatter(year_month_labels_filtered, np.log(y_filtered), color='#1C6E8C', alpha=0.5, label='Actual data') +# plt.scatter(year_month_labels_filtered, y_pred, color='#9AC4F8', alpha=0.7, label='Predicted data') +# #plt.xticks(ticks=, labels=sorted_years, rotation=45, ha='right') +# +# plt.xticks(rotation=45, ha='right') +# plt.xlabel('Year') +# plt.ylabel('Log(Number of ANC visits)') +# plt.title('Monthly ANC Visits vs. Precipitation') +# plt.ylim(0, 10) +# plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) +# plt.tight_layout() +# plt.show() From 41904f26bf34310e2d8f43260f33a9d986cbb2e6 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 13 Nov 2024 13:55:28 +0000 Subject: [PATCH 132/291] Added in if else if not doing 5 day --- .../process_daily_total_historical_data.py | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/src/scripts/climate_change/process_daily_total_historical_data.py b/src/scripts/climate_change/process_daily_total_historical_data.py index 92526e3e42..b8f8f168cd 100644 --- a/src/scripts/climate_change/process_daily_total_historical_data.py +++ b/src/scripts/climate_change/process_daily_total_historical_data.py @@ -10,7 +10,7 @@ ANC = True # facility data multiplier = 1000 -five_day = True +five_day = False cumulative = True general_facilities = gpd.read_file("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_districts.shp") @@ -22,6 +22,10 @@ window_size_for_average = 1 else: window_size_for_average = 5 +else: + window_size = 1 + window_size_for_average = 1 + # Data accessed from https://dhis2.health.gov.mw/dhis-web-data-visualizer/#/YiQK65skxjz # Reporting rate is expected reporting vs actual reporting if ANC: @@ -77,7 +81,7 @@ ] begin_day = 0 for month_idx, month_length in enumerate(month_lengths): - days_for_grid = pr_data_for_square[begin_day:begin_day + month_length] + days_for_grid = daily_totals[begin_day:begin_day + month_length] moving_averages = [] for day in range(month_length - window_size + 1): window_average = sum(days_for_grid[day:day + window_size]) / window_size_for_average @@ -125,7 +129,7 @@ ] begin_day = 0 for month_idx, month_length in enumerate(month_lengths): - days_for_grid = pr_data_for_square[begin_day:begin_day + month_length] + days_for_grid = daily_totals[begin_day:begin_day + month_length] moving_averages = [] for day in range(month_length - window_size + 1): window_average = sum(days_for_grid[day:day + window_size]) / window_size_for_average From a6410d9b5f04c4cbc9d767e1af005d63e6a664f0 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 13 Nov 2024 13:58:02 +0000 Subject: [PATCH 133/291] Added in function for stepwise selection Then saved the model --- ...al_realtionship_reporting_precipitation.py | 272 +++++++++++------- 1 file changed, 171 insertions(+), 101 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 5351bb65f2..9e4bbffd2d 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -1,10 +1,10 @@ import matplotlib.pyplot as plt import numpy as np import pandas as pd -import pickle import statsmodels.api as sm from statsmodels.othermod.betareg import BetaModel -from collections import defaultdict +import joblib + ANC = True daily_max = False @@ -14,6 +14,10 @@ mask_threshold = 0 five_day = True cumulative = True +model_fit_ANC_data = True +model_fit_weather_data = True + +log_y = True # # data is from 2011 - 2024 - for facility if ANC: monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_ANC_by_smaller_facility_lm.csv", index_col=0) @@ -55,8 +59,10 @@ "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facility_lm.csv", index_col=0) -def build_model(X, y, scale_y=False, beta=False, X_mask_mm = 0): +def build_model(X, y, scale_y=False, beta=False, log_y=False, X_mask_mm=0): epsilon = 1e-5 + if log_y: + y = np.log(np.clip(y, epsilon, None)) # Log-transform y with clipping for positivity if scale_y: y_scaled = np.clip(y / 100, epsilon, 1 - epsilon) else: @@ -82,7 +88,38 @@ def create_binary_feature(threshold, weather_data_df, recent_months): return binary_feature_list +def stepwise_selection(X, y): + included = list(range(X.shape[1])) + current_aic = np.inf + + while True: + changed = False + excluded = list(set(range(X.shape[1])) - set(included)) + new_aic = pd.Series(index=excluded, dtype=float) + for new_column in excluded: + subset_X = X[:, included + [new_column]] + results, _, _ = build_model(subset_X, y, log_y=log_y, X_mask_mm=mask_threshold) + new_aic[new_column] = results.aic + best_aic = new_aic.min() + if best_aic < current_aic: + best_feature = new_aic.idxmin() + included.append(best_feature) + current_aic = best_aic + changed = True + results, _, _ = build_model(X[:, included], y, log_y=log_y, X_mask_mm=mask_threshold) + pvalues = results.pvalues + pvalues = pd.Series(pvalues) + worst_pval = pvalues.max() + if worst_pval > 0.05: + worst_feature = pvalues.idxmax() + if worst_feature in included: + included.remove(worst_feature) + changed = True + if not changed: + break + + return included ###### Tidy data ############ ## Drop September 2024 - weather_data_historical = weather_data_historical.drop(weather_data_historical.index[-1]) @@ -156,7 +193,11 @@ def repeat_info(info, num_facilities, year_range): altitude = np.where(altitude < 0, np.nan, altitude) altitude = list(altitude) -#### STEP 1: GENERATE PREDICTIONS OF ANC DATA ########### + +############################################################################################## +########################## STEP 1: GENERATE PREDICTIONS OF ANC DATA ########################## +############################################################################################## + X = np.column_stack([ year_flattened, month_flattened, @@ -167,51 +208,71 @@ def repeat_info(info, num_facilities, year_range): facility_encoded, altitude ]) -results, y_pred, mask_ANC_data = build_model(X, np.log(y) , X_mask_mm = mask_threshold) +model_filename = 'best_model_ANC_prediction_monthly_total_precip.pkl' -residuals_percentage = (y[mask_ANC_data] - y_pred)/y[mask_ANC_data] -print(results.summary()) +if model_fit_ANC_data: + best_predictors = stepwise_selection(X, y) + X_best = X[:, best_predictors] + results, y_pred, mask_ANC_data = build_model(X_best, y, log_y=log_y, X_mask_mm=mask_threshold) + model_data = { + 'model': results, + 'mask': mask_ANC_data + } + joblib.dump(model_data, model_filename) +else: + model_data = joblib.load(model_filename) + results = model_data['model'] + mask_ANC_data = model_data['mask'] + +if log_y: + residuals_percentage = (y[mask_ANC_data] - np.exp(y_pred))/y[mask_ANC_data] * 100 +else: + residuals_percentage = (y[mask_ANC_data] - y_pred)/y[mask_ANC_data] * 100 + +print(max(residuals_percentage)) +print(min(residuals_percentage)) + +# plot year_month_labels = np.array([f"{y}-{m}" for y, m in zip(year_flattened, month_flattened)]) y_filtered = y[mask_ANC_data] year_month_labels_filtered = year_month_labels[mask_ANC_data] -data_ANC_predictions = pd.DataFrame({ - 'Year_Month': year_month_labels_filtered, - 'y_filtered': y_filtered -}) +if log_y: + data_ANC_predictions = pd.DataFrame({ + 'Year_Month': year_month_labels_filtered, + 'y_filtered': y_filtered, + 'y_pred': np.exp(y_pred), + }) +else: + data_ANC_predictions = pd.DataFrame({ + 'Year_Month': year_month_labels_filtered, + 'y_filtered': y_filtered, + 'y_pred': np.exp(y_pred), + }) data_ANC_predictions = data_ANC_predictions.sort_values(by='Year_Month').reset_index(drop=True) -# # residuals are the next "y" variable, as they are the defecit in cases -plt.scatter(data_ANC_predictions['Year_Month'], np.log(data_ANC_predictions['y_filtered']), color='#1C6E8C', alpha=0.5, label='Actual data') -plt.scatter(data_ANC_predictions['Year_Month'], residuals_percentage, color='#9AC4F8', alpha=0.7, label='Residuals') -plt.xticks(rotation=45, ha='right') -plt.xlabel('Year') -plt.ylabel('Log(Number of ANC visits)') -plt.title('Monthly ANC Visits vs. Precipitation') -plt.ylim(0, 10) -plt.legend(loc='upper left') +fig, axs = plt.subplots(1, 2, figsize=(14, 6)) + +# Panel A: Actual data and predictions +axs[0].scatter(data_ANC_predictions['Year_Month'], data_ANC_predictions['y_filtered'], color='#1C6E8C', alpha=0.5, label='Actual data') +axs[0].scatter(data_ANC_predictions['Year_Month'], data_ANC_predictions['y_pred'], color='#9AC4F8', alpha=0.7, label='Predictions') +axs[0].set_xticklabels(data_ANC_predictions['Year_Month'], rotation=45, ha='right') +axs[0].set_xlabel('Year') +axs[0].set_ylabel('Log(Number of ANC visits)') +axs[0].set_title('A: Monthly ANC Visits vs. Precipitation') +axs[0].legend(loc='upper left') + +# Panel B: Residuals (in percentage) +axs[1].scatter(data_ANC_predictions['Year_Month'], residuals_percentage, color='#9AC4F8', alpha=0.7, label='Residuals') +axs[1].set_xticklabels(data_ANC_predictions['Year_Month'], rotation=45, ha='right') +axs[1].set_xlabel('Year') +axs[1].set_ylabel('Residuals (%)') +axs[1].set_title('B: Residuals as Percentage') +axs[1].legend(loc='upper left') plt.tight_layout() plt.show() -# -# ### STEP 2 - USE THESE IN PREDICTIONS### -# -y = residuals_percentage -# -X = np.column_stack([ - weather_data[mask_ANC_data], - np.array(year_flattened)[mask_ANC_data], - np.array(month_flattened)[mask_ANC_data], - resid_encoded[mask_ANC_data], - zone_encoded[mask_ANC_data], - owner_encoded[mask_ANC_data], - ftype_encoded[mask_ANC_data], - lag_1_month[mask_ANC_data], - lag_3_month[mask_ANC_data], - facility_encoded[mask_ANC_data], - np.array(altitude)[mask_ANC_data] -]) -results, y_pred, mask = build_model(X, y, X_mask_mm = mask_threshold) -print(results.summary()) -# ### Now include only significant predictors +############################################################################################## +########################## STEP 2 - USE THESE IN PREDICTIONS ########################## +############################################################################################## X = np.column_stack([ weather_data[mask_ANC_data], @@ -223,77 +284,86 @@ def repeat_info(info, num_facilities, year_range): ftype_encoded[mask_ANC_data], lag_1_month[mask_ANC_data], lag_3_month[mask_ANC_data], + facility_encoded[mask_ANC_data], np.array(altitude)[mask_ANC_data] ]) -results, y_pred, mask_weather_data = build_model(X, y, X_mask_mm = mask_threshold) -print(results.summary()) +model_filename = 'best_model_monthly_total_precip.pkl' +if model_fit_weather_data: + best_predictors = stepwise_selection(X, residuals_percentage) + X_best = X[:, best_predictors] + results, y_pred, mask_ANC_data = build_model(X_best, residuals_percentage, log_y=False, X_mask_mm=mask_threshold) + joblib.dump(results, model_filename) +else: + results = joblib.load(model_filename) -##### Plot y_predic +print(results.summary()) -X_filtered = X[mask] -if ANC: - plt.scatter(X_filtered[:, 0], y [mask], color='red', alpha=0.5) - plt.scatter(X_filtered[:, 0], y_pred) - plt.title(' ') - plt.ylabel('% change in ANC visits') - plt.xlabel('Precip (mm)') - #plt.ylim(-,10) - plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) - plt.show() -# else: +# ##### Plot y_predic # -# plt.scatter(X_filtered[:, 0], np.log(y)[mask], color='red', alpha=0.5) +# X_filtered = X[mask] +# if ANC: +# plt.scatter(X_filtered[:, 0], y[mask], color='red', alpha=0.5) # plt.scatter(X_filtered[:, 0], y_pred) # plt.title(' ') -# plt.ylabel('Reporting (%)') +# plt.ylabel('% change in ANC visits') # plt.xlabel('Precip (mm)') -# plt.ylim(0, 100) +# #plt.ylim(-,10) # plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) -# #plt.show() -# -# # save model +# plt.show() +# # else: # # -# # # Save the model using pickle -# # with open('linear_model_ANC_daily_max.pkl', 'wb') as file: -# # pickle.dump(results, file) +# # plt.scatter(X_filtered[:, 0], np.log(y)[mask], color='red', alpha=0.5) +# # plt.scatter(X_filtered[:, 0], y_pred) +# # plt.title(' ') +# # plt.ylabel('Reporting (%)') +# # plt.xlabel('Precip (mm)') +# # plt.ylim(0, 100) +# # plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) +# # #plt.show() # # -# # # Now you can load the model and use it for predictions -# # with open('saved_model.pkl', 'rb') as file: -# # loaded_model = pickle.load(file) -# -# -# year_month_labels = np.array([f"{y}-{m}" for y, m in zip(year_flattened, month_flattened)]) -# X_filtered = X[mask] -# y_filtered = y[mask] -# year_month_labels_filtered = year_month_labels[mask] -# # first_index_by_year = {} -# # years_in_labels = [label[:4] for label in year_month_labels_filtered] -# # year_counts = defaultdict(int) -# # for year in years_in_labels: -# # year_counts[year] += 1 -# # print(year_counts) -# # sorted_years = sorted(year_counts.keys()) -# # print(sorted_years) -# # cumulative_counts = [] -# # cumulative_sum = 0 -# # for year in sorted_years: -# # cumulative_sum += year_counts[year] -# # cumulative_counts.append(cumulative_sum) -# # cumulative_counts = [first_index_by_year[year] for year in sorted_years] +# # # save model +# # # +# # # # Save the model using pickle +# # # with open('linear_model_ANC_daily_max.pkl', 'wb') as file: +# # # pickle.dump(results, file) +# # # +# # # # Now you can load the model and use it for predictions +# # # with open('saved_model.pkl', 'rb') as file: +# # # loaded_model = pickle.load(file) # # -# print(year_month_labels_filtered) -# plt.figure(figsize=(12, 6)) -# plt.scatter(year_month_labels_filtered, np.log(y_filtered), color='#1C6E8C', alpha=0.5, label='Actual data') -# plt.scatter(year_month_labels_filtered, y_pred, color='#9AC4F8', alpha=0.7, label='Predicted data') -# #plt.xticks(ticks=, labels=sorted_years, rotation=45, ha='right') -# -# plt.xticks(rotation=45, ha='right') -# plt.xlabel('Year') -# plt.ylabel('Log(Number of ANC visits)') -# plt.title('Monthly ANC Visits vs. Precipitation') -# plt.ylim(0, 10) -# plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) -# plt.tight_layout() -# plt.show() +# # +# # year_month_labels = np.array([f"{y}-{m}" for y, m in zip(year_flattened, month_flattened)]) +# # X_filtered = X[mask] +# # y_filtered = y[mask] +# # year_month_labels_filtered = year_month_labels[mask] +# # # first_index_by_year = {} +# # # years_in_labels = [label[:4] for label in year_month_labels_filtered] +# # # year_counts = defaultdict(int) +# # # for year in years_in_labels: +# # # year_counts[year] += 1 +# # # print(year_counts) +# # # sorted_years = sorted(year_counts.keys()) +# # # print(sorted_years) +# # # cumulative_counts = [] +# # # cumulative_sum = 0 +# # # for year in sorted_years: +# # # cumulative_sum += year_counts[year] +# # # cumulative_counts.append(cumulative_sum) +# # # cumulative_counts = [first_index_by_year[year] for year in sorted_years] +# # # +# # print(year_month_labels_filtered) +# # plt.figure(figsize=(12, 6)) +# # plt.scatter(year_month_labels_filtered, np.log(y_filtered), color='#1C6E8C', alpha=0.5, label='Actual data') +# # plt.scatter(year_month_labels_filtered, y_pred, color='#9AC4F8', alpha=0.7, label='Predicted data') +# # #plt.xticks(ticks=, labels=sorted_years, rotation=45, ha='right') +# # +# # plt.xticks(rotation=45, ha='right') +# # plt.xlabel('Year') +# # plt.ylabel('Log(Number of ANC visits)') +# # plt.title('Monthly ANC Visits vs. Precipitation') +# # plt.ylim(0, 10) +# # plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) +# # plt.tight_layout() +# # plt.show() From aef2d351aedc051a788f0d07696ee8d9169182d7 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 13 Nov 2024 16:05:15 +0000 Subject: [PATCH 134/291] changed file name saved best predictors --- ...al_realtionship_reporting_precipitation.py | 131 +++++++----------- 1 file changed, 53 insertions(+), 78 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 9e4bbffd2d..ba1a7c7a20 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -16,6 +16,17 @@ cumulative = True model_fit_ANC_data = True model_fit_weather_data = True +model_filename = ( + f"best_model_{'ANC' if ANC else 'Reporting'}_prediction_" + f"{'5_day' if five_day else 'monthly'}_" + f"{'cumulative' if cumulative else ('max' if daily_max else 'total')}_precip.pkl" +) + +model_filename_weather_model = ( + f"best_model_weather_" + f"{'5_day' if five_day else 'monthly'}_" + f"{'cumulative' if cumulative else ('max' if daily_max else 'total')}_precip.pkl" +) log_y = True # # data is from 2011 - 2024 - for facility @@ -125,7 +136,7 @@ def stepwise_selection(X, y): weather_data_historical = weather_data_historical.drop(weather_data_historical.index[-1]) monthly_reporting_by_facility = monthly_reporting_by_facility.drop(monthly_reporting_by_facility.index[-1]) -## Drop before 2017 +## code if years need to be dropped weather_data_historical = weather_data_historical.iloc[(min_year_for_analyis-absolute_min_year)*12 :] monthly_reporting_by_facility = monthly_reporting_by_facility.iloc[(min_year_for_analyis-absolute_min_year)*12:] ## Linear regression @@ -167,7 +178,6 @@ def stepwise_selection(X, y): # Prepare additional facility info if ANC: expanded_facility_info = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_with_ANC.csv", index_col=0) - else: expanded_facility_info = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm.csv", index_col=0) expanded_facility_info = expanded_facility_info.T.reindex(columns=expanded_facility_info.index) @@ -208,7 +218,6 @@ def repeat_info(info, num_facilities, year_range): facility_encoded, altitude ]) -model_filename = 'best_model_ANC_prediction_monthly_total_precip.pkl' if model_fit_ANC_data: best_predictors = stepwise_selection(X, y) @@ -216,19 +225,26 @@ def repeat_info(info, num_facilities, year_range): results, y_pred, mask_ANC_data = build_model(X_best, y, log_y=log_y, X_mask_mm=mask_threshold) model_data = { 'model': results, - 'mask': mask_ANC_data + 'mask': mask_ANC_data, + 'best_predictors': best_predictors # Save best predictors } joblib.dump(model_data, model_filename) else: model_data = joblib.load(model_filename) results = model_data['model'] mask_ANC_data = model_data['mask'] + best_predictors = model_data['best_predictors'] + +X = X[:, best_predictors] + +y_pred = results.predict(X[mask_ANC_data]) if log_y: residuals_percentage = (y[mask_ANC_data] - np.exp(y_pred))/y[mask_ANC_data] * 100 else: residuals_percentage = (y[mask_ANC_data] - y_pred)/y[mask_ANC_data] * 100 +residuals_percentage = y[mask_ANC_data] - y_pred print(max(residuals_percentage)) print(min(residuals_percentage)) @@ -288,82 +304,41 @@ def repeat_info(info, num_facilities, year_range): np.array(altitude)[mask_ANC_data] ]) -model_filename = 'best_model_monthly_total_precip.pkl' if model_fit_weather_data: best_predictors = stepwise_selection(X, residuals_percentage) X_best = X[:, best_predictors] - results, y_pred, mask_ANC_data = build_model(X_best, residuals_percentage, log_y=False, X_mask_mm=mask_threshold) - joblib.dump(results, model_filename) + results_of_weather_model, y_pred, mask_all_data = build_model(X_best, residuals_percentage, log_y=True, X_mask_mm=mask_threshold) + model_data = { + 'model': results_of_weather_model, + 'mask': mask_all_data, + 'best_predictors': best_predictors # Save best predictors + } + joblib.dump(model_data, model_filename_weather_model) else: - results = joblib.load(model_filename) - -print(results.summary()) - -# ##### Plot y_predic -# -# X_filtered = X[mask] -# if ANC: -# plt.scatter(X_filtered[:, 0], y[mask], color='red', alpha=0.5) -# plt.scatter(X_filtered[:, 0], y_pred) -# plt.title(' ') -# plt.ylabel('% change in ANC visits') -# plt.xlabel('Precip (mm)') -# #plt.ylim(-,10) -# plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) -# plt.show() -# # else: -# # -# # plt.scatter(X_filtered[:, 0], np.log(y)[mask], color='red', alpha=0.5) -# # plt.scatter(X_filtered[:, 0], y_pred) -# # plt.title(' ') -# # plt.ylabel('Reporting (%)') -# # plt.xlabel('Precip (mm)') -# # plt.ylim(0, 100) -# # plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) -# # #plt.show() -# # -# # # save model -# # # -# # # # Save the model using pickle -# # # with open('linear_model_ANC_daily_max.pkl', 'wb') as file: -# # # pickle.dump(results, file) -# # # -# # # # Now you can load the model and use it for predictions -# # # with open('saved_model.pkl', 'rb') as file: -# # # loaded_model = pickle.load(file) -# # -# # -# # year_month_labels = np.array([f"{y}-{m}" for y, m in zip(year_flattened, month_flattened)]) -# # X_filtered = X[mask] -# # y_filtered = y[mask] -# # year_month_labels_filtered = year_month_labels[mask] -# # # first_index_by_year = {} -# # # years_in_labels = [label[:4] for label in year_month_labels_filtered] -# # # year_counts = defaultdict(int) -# # # for year in years_in_labels: -# # # year_counts[year] += 1 -# # # print(year_counts) -# # # sorted_years = sorted(year_counts.keys()) -# # # print(sorted_years) -# # # cumulative_counts = [] -# # # cumulative_sum = 0 -# # # for year in sorted_years: -# # # cumulative_sum += year_counts[year] -# # # cumulative_counts.append(cumulative_sum) -# # # cumulative_counts = [first_index_by_year[year] for year in sorted_years] -# # # -# # print(year_month_labels_filtered) -# # plt.figure(figsize=(12, 6)) -# # plt.scatter(year_month_labels_filtered, np.log(y_filtered), color='#1C6E8C', alpha=0.5, label='Actual data') -# # plt.scatter(year_month_labels_filtered, y_pred, color='#9AC4F8', alpha=0.7, label='Predicted data') -# # #plt.xticks(ticks=, labels=sorted_years, rotation=45, ha='right') -# # -# # plt.xticks(rotation=45, ha='right') -# # plt.xlabel('Year') -# # plt.ylabel('Log(Number of ANC visits)') -# # plt.title('Monthly ANC Visits vs. Precipitation') -# # plt.ylim(0, 10) -# # plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) -# # plt.tight_layout() -# # plt.show() + model_data = joblib.load(model_filename_weather_model) + results_of_weather_model = model_data['model'] + mask_all_data = model_data['mask'] +print(results_of_weather_model.summary()) + +##### Plot y_predic + +X_filtered = X[mask_all_data] +if ANC: + plt.scatter(X_filtered[:, 0], np.log(residuals_percentage[mask_all_data]), color='red', alpha=0.5) + plt.scatter(X_filtered[:, 0], y_pred) + plt.title(' ') + plt.ylabel('log(change in ANC visits)') + plt.xlabel('Precip (mm)') + #plt.ylim(-,10) + plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) + plt.show() + +plt.scatter(X_filtered[:, 0], (residuals_percentage[mask_all_data]), color='red', alpha=0.5) +plt.scatter(X_filtered[:, 0], np.exp(y_pred)) +plt.title(' ') +plt.ylabel('log(change in ANC visits)') +plt.xlabel('Precip (mm)') +#plt.ylim(-,10) +plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) +plt.show() From 37d0f92a3fb3f81433d79a100276446fbeb90398 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 13 Nov 2024 16:48:08 +0000 Subject: [PATCH 135/291] exclude some outliers --- ...al_realtionship_reporting_precipitation.py | 69 +++++++++++-------- 1 file changed, 42 insertions(+), 27 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index ba1a7c7a20..3d072f9c48 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -12,8 +12,8 @@ min_year_for_analyis = 2011 absolute_min_year = 2011 mask_threshold = 0 -five_day = True -cumulative = True +five_day = False +cumulative = False model_fit_ANC_data = True model_fit_weather_data = True model_filename = ( @@ -72,13 +72,14 @@ def build_model(X, y, scale_y=False, beta=False, log_y=False, X_mask_mm=0): epsilon = 1e-5 + if log_y: y = np.log(np.clip(y, epsilon, None)) # Log-transform y with clipping for positivity if scale_y: y_scaled = np.clip(y / 100, epsilon, 1 - epsilon) else: y_scaled = y - mask = ~np.isnan(X).any(axis=1) & ~np.isnan(y_scaled) & (X[:, 0] >= X_mask_mm) + mask = (~np.isnan(X).any(axis=1) & ~np.isnan(y_scaled) & (X[:, 0] >= X_mask_mm) & (y <= 1e5)) model = BetaModel(y_scaled[mask], X[mask]) if beta else sm.OLS(y_scaled[mask], X[mask]) model_fit = model.fit() return model_fit, model_fit.predict(X[mask]), mask @@ -99,47 +100,53 @@ def create_binary_feature(threshold, weather_data_df, recent_months): return binary_feature_list -def stepwise_selection(X, y): - included = list(range(X.shape[1])) +def stepwise_selection(X, y, log_y, p_value_threshold=0.05): + included = [] current_aic = np.inf while True: changed = False + + # Step 1: Try adding each excluded predictor and select the best one by AIC if significant excluded = list(set(range(X.shape[1])) - set(included)) new_aic = pd.Series(index=excluded, dtype=float) for new_column in excluded: subset_X = X[:, included + [new_column]] results, _, _ = build_model(subset_X, y, log_y=log_y, X_mask_mm=mask_threshold) - new_aic[new_column] = results.aic - best_aic = new_aic.min() - if best_aic < current_aic: + if results.pvalues[-1] < p_value_threshold: + new_aic[new_column] = results.aic + + # Add the predictor with the best AIC if it's better than the current model's AIC + if not new_aic.empty and new_aic.min() < current_aic: best_feature = new_aic.idxmin() included.append(best_feature) - current_aic = best_aic + current_aic = new_aic.min() changed = True + + # Step 2: Check significance of each included predictor and remove non-significant ones results, _, _ = build_model(X[:, included], y, log_y=log_y, X_mask_mm=mask_threshold) - pvalues = results.pvalues - pvalues = pd.Series(pvalues) - worst_pval = pvalues.max() - if worst_pval > 0.05: - worst_feature = pvalues.idxmax() - if worst_feature in included: - included.remove(worst_feature) - changed = True + pvalues = pd.Series(results.pvalues, index=included) + for feature in pvalues[pvalues > p_value_threshold].index: + included.remove(feature) + changed = True + # Exit if no changes were made in this iteration if not changed: break return included -###### Tidy data ############ -## Drop September 2024 - + +############################################################################################## +########################## STEP 0: Tidy data ########################## +############################################################################################## +# Drop September 2024 - weather_data_historical = weather_data_historical.drop(weather_data_historical.index[-1]) monthly_reporting_by_facility = monthly_reporting_by_facility.drop(monthly_reporting_by_facility.index[-1]) -## code if years need to be dropped +# code if years need to be dropped weather_data_historical = weather_data_historical.iloc[(min_year_for_analyis-absolute_min_year)*12 :] monthly_reporting_by_facility = monthly_reporting_by_facility.iloc[(min_year_for_analyis-absolute_min_year)*12:] -## Linear regression +# Linear regression month_range = range(12) num_facilities = len(weather_data_historical.columns) year_range = range(min_year_for_analyis, 2025, 1) # year as a fixed effect @@ -197,12 +204,15 @@ def repeat_info(info, num_facilities, year_range): altitude = [float(x) for x in repeat_info(expanded_facility_info['A109__Altitude'], num_facilities, year_range)] # Lagged weather lag_1_month = weather_data_historical.shift(1).values.flatten() +lag_2_month = weather_data_historical.shift(1).values.flatten() lag_3_month = weather_data_historical.shift(3).values.flatten() +lag_4_month = weather_data_historical.shift(4).values.flatten() altitude = np.array(altitude) altitude = np.where(altitude < 0, np.nan, altitude) altitude = list(altitude) +#print(np.nanmax(y) ) ## one y value is > 167,000. So should remove ############################################################################################## ########################## STEP 1: GENERATE PREDICTIONS OF ANC DATA ########################## @@ -220,7 +230,7 @@ def repeat_info(info, num_facilities, year_range): ]) if model_fit_ANC_data: - best_predictors = stepwise_selection(X, y) + best_predictors = stepwise_selection(X, y, log_y=log_y) X_best = X[:, best_predictors] results, y_pred, mask_ANC_data = build_model(X_best, y, log_y=log_y, X_mask_mm=mask_threshold) model_data = { @@ -234,10 +244,8 @@ def repeat_info(info, num_facilities, year_range): results = model_data['model'] mask_ANC_data = model_data['mask'] best_predictors = model_data['best_predictors'] - -X = X[:, best_predictors] - -y_pred = results.predict(X[mask_ANC_data]) + X = X[:, best_predictors] + y_pred = results.predict(X[mask_ANC_data]) if log_y: residuals_percentage = (y[mask_ANC_data] - np.exp(y_pred))/y[mask_ANC_data] * 100 @@ -264,6 +272,7 @@ def repeat_info(info, num_facilities, year_range): 'y_filtered': y_filtered, 'y_pred': np.exp(y_pred), }) + data_ANC_predictions = data_ANC_predictions.sort_values(by='Year_Month').reset_index(drop=True) fig, axs = plt.subplots(1, 2, figsize=(14, 6)) @@ -299,14 +308,16 @@ def repeat_info(info, num_facilities, year_range): owner_encoded[mask_ANC_data], ftype_encoded[mask_ANC_data], lag_1_month[mask_ANC_data], + lag_2_month[mask_ANC_data], lag_3_month[mask_ANC_data], + lag_4_month[mask_ANC_data], facility_encoded[mask_ANC_data], np.array(altitude)[mask_ANC_data] ]) if model_fit_weather_data: - best_predictors = stepwise_selection(X, residuals_percentage) + best_predictors = stepwise_selection(X, residuals_percentage, log_y=log_y) X_best = X[:, best_predictors] results_of_weather_model, y_pred, mask_all_data = build_model(X_best, residuals_percentage, log_y=True, X_mask_mm=mask_threshold) model_data = { @@ -321,6 +332,10 @@ def repeat_info(info, num_facilities, year_range): mask_all_data = model_data['mask'] print(results_of_weather_model.summary()) +results_of_weather_model, y_pred, mask_all_data = build_model(X, residuals_percentage, log_y=True, + X_mask_mm=mask_threshold) +print(results_of_weather_model.summary()) + ##### Plot y_predic X_filtered = X[mask_all_data] From 0a764da37459148665ad9f272305b78496ff4332 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 13 Nov 2024 16:51:32 +0000 Subject: [PATCH 136/291] have somehow lost significant relationship... --- ...near_model_historical_realtionship_reporting_precipitation.py | 1 + 1 file changed, 1 insertion(+) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 3d072f9c48..6b4a2a284f 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -167,6 +167,7 @@ def stepwise_selection(X, y, log_y, p_value_threshold=0.05): y = monthly_reporting_by_facility.values.flatten() if np.nanmin(y) < 1: y += 1e-6 # Shift to ensure positivity as taking log +y[y > 1e5] = np.nan # One-hot encode facilities facility_encoded = pd.get_dummies(facility_flattened, drop_first=True) From f45f5a608aea6fb81ffe741e5c1cb5196dbedb58 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 13 Nov 2024 21:39:52 +0000 Subject: [PATCH 137/291] Checked "all" model and find the R2 is better --- ...al_realtionship_reporting_precipitation.py | 83 +++++++++++++++---- 1 file changed, 66 insertions(+), 17 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 6b4a2a284f..ed2856a052 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -12,8 +12,8 @@ min_year_for_analyis = 2011 absolute_min_year = 2011 mask_threshold = 0 -five_day = False -cumulative = False +five_day = True +cumulative = True model_fit_ANC_data = True model_fit_weather_data = True model_filename = ( @@ -36,15 +36,15 @@ if five_day: if cumulative: weather_data_historical = pd.read_csv( - "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_maximum/historical_daily_total_by_facilities_with_ANC_five_day_cumulative.csv", + "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/historical_daily_total_by_facilities_with_ANC_five_day_cumulative.csv", index_col=0) else: weather_data_historical = pd.read_csv( - "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_maximum/historical_daily_total_by_facilities_with_ANC_five_day_average.csv", + "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/historical_daily_total_by_facilities_with_ANC_five_day_average.csv", index_col=0) else: weather_data_historical = pd.read_csv( - "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_maximum/historical_daily_max_by_facilities_with_ANC.csv", + "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/historical_daily_max_by_facilities_with_ANC.csv", index_col=0) elif daily_total: weather_data_historical = pd.read_csv( @@ -136,6 +136,42 @@ def stepwise_selection(X, y, log_y, p_value_threshold=0.05): return included + +# def stepwise_selection(X, y, log_y, p_value_threshold=0.05): +# included = list(range(X.shape[1])) +# current_r2 = -np.inf # Start with the worst possible R2 value +# while True: +# changed = False +# excluded = list(set(range(X.shape[1])) - set(included)) +# new_r2 = pd.Series(index=excluded, dtype=float) +# for new_column in excluded: +# print(new_column) +# subset_X = X[:, included + [new_column]] +# results, _, _ = build_model(subset_X, y, log_y=log_y, X_mask_mm=mask_threshold) +# new_r2[new_column] = results.rsquared # Use R2 instead of AIC +# best_r2 = new_r2.max() +# #if best_r2 > current_r2: # Maximize R2 +# if 1e-6 < (best_r2 - current_r2): # Maximize R2 +# +# best_feature = new_r2.idxmax() +# included.append(best_feature) +# current_r2 = best_r2 +# changed = True +# # # Evaluate model with current set of included features +# # results, _, _ = build_model(X[:, included], y, log_y=log_y, X_mask_mm=mask_threshold) +# # pvalues = results.pvalues +# # pvalues = pd.Series(pvalues) +# # worst_pval = pvalues.max() +# # +# # if worst_pval > p_value_threshold: # Remove features with p-value > 0.05 +# # worst_feature = pvalues.idxmax() +# # if worst_feature in included: +# # included.remove(worst_feature) +# # changed = True +# +# if not changed: +# break +# return included ############################################################################################## ########################## STEP 0: Tidy data ########################## ############################################################################################## @@ -249,13 +285,11 @@ def repeat_info(info, num_facilities, year_range): y_pred = results.predict(X[mask_ANC_data]) if log_y: - residuals_percentage = (y[mask_ANC_data] - np.exp(y_pred))/y[mask_ANC_data] * 100 + residuals_percentage = (y[mask_ANC_data] - np.exp(y_pred)) else: - residuals_percentage = (y[mask_ANC_data] - y_pred)/y[mask_ANC_data] * 100 + residuals_percentage = (y[mask_ANC_data] - y_pred) + -residuals_percentage = y[mask_ANC_data] - y_pred -print(max(residuals_percentage)) -print(min(residuals_percentage)) # plot year_month_labels = np.array([f"{y}-{m}" for y, m in zip(year_flattened, month_flattened)]) @@ -271,7 +305,7 @@ def repeat_info(info, num_facilities, year_range): data_ANC_predictions = pd.DataFrame({ 'Year_Month': year_month_labels_filtered, 'y_filtered': y_filtered, - 'y_pred': np.exp(y_pred), + 'y_pred': y_pred, }) data_ANC_predictions = data_ANC_predictions.sort_values(by='Year_Month').reset_index(drop=True) @@ -299,7 +333,6 @@ def repeat_info(info, num_facilities, year_range): ############################################################################################## ########################## STEP 2 - USE THESE IN PREDICTIONS ########################## ############################################################################################## - X = np.column_stack([ weather_data[mask_ANC_data], np.array(year_flattened)[mask_ANC_data], @@ -319,8 +352,9 @@ def repeat_info(info, num_facilities, year_range): if model_fit_weather_data: best_predictors = stepwise_selection(X, residuals_percentage, log_y=log_y) + print(best_predictors) X_best = X[:, best_predictors] - results_of_weather_model, y_pred, mask_all_data = build_model(X_best, residuals_percentage, log_y=True, X_mask_mm=mask_threshold) + results_of_weather_model, y_pred, mask_all_data = build_model(X_best, residuals_percentage, log_y=log_y, X_mask_mm=mask_threshold) model_data = { 'model': results_of_weather_model, 'mask': mask_all_data, @@ -331,10 +365,27 @@ def repeat_info(info, num_facilities, year_range): model_data = joblib.load(model_filename_weather_model) results_of_weather_model = model_data['model'] mask_all_data = model_data['mask'] +results_of_weather_model, y_pred, mask_all_data = build_model(X_best, residuals_percentage, log_y=log_y, + X_mask_mm=mask_threshold) print(results_of_weather_model.summary()) -results_of_weather_model, y_pred, mask_all_data = build_model(X, residuals_percentage, log_y=True, - X_mask_mm=mask_threshold) +X = np.column_stack([ + weather_data[mask_ANC_data], + np.array(year_flattened)[mask_ANC_data], + np.array(month_flattened)[mask_ANC_data], + resid_encoded[mask_ANC_data], + zone_encoded[mask_ANC_data], + owner_encoded[mask_ANC_data], + ftype_encoded[mask_ANC_data], + lag_1_month[mask_ANC_data], + lag_2_month[mask_ANC_data], + lag_3_month[mask_ANC_data], + lag_4_month[mask_ANC_data], + facility_encoded[mask_ANC_data], + np.array(altitude)[mask_ANC_data] +]) +results_of_weather_model, y_pred, mask_all_data = build_model(X, residuals_percentage, log_y=log_y, X_mask_mm=mask_threshold) + print(results_of_weather_model.summary()) ##### Plot y_predic @@ -346,7 +397,6 @@ def repeat_info(info, num_facilities, year_range): plt.title(' ') plt.ylabel('log(change in ANC visits)') plt.xlabel('Precip (mm)') - #plt.ylim(-,10) plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) plt.show() @@ -355,6 +405,5 @@ def repeat_info(info, num_facilities, year_range): plt.title(' ') plt.ylabel('log(change in ANC visits)') plt.xlabel('Precip (mm)') -#plt.ylim(-,10) plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) plt.show() From b5955f72c008f520821b67140565dc49482b4b0d Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 14 Nov 2024 09:42:55 +0000 Subject: [PATCH 138/291] File for using the picked models and predicting the shortfall in ANC visits based on the CMIP6 data --- .../linear_model_predicting_CMIP6.py | 91 +++++++++++++++++++ 1 file changed, 91 insertions(+) create mode 100644 src/scripts/climate_change/linear_model_predicting_CMIP6.py diff --git a/src/scripts/climate_change/linear_model_predicting_CMIP6.py b/src/scripts/climate_change/linear_model_predicting_CMIP6.py new file mode 100644 index 0000000000..8ab40ef694 --- /dev/null +++ b/src/scripts/climate_change/linear_model_predicting_CMIP6.py @@ -0,0 +1,91 @@ +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd +import joblib + +# Configuration and constants +ANC = True +min_year_for_analysis = 2015 +absolute_min_year = 2015 +max_year_for_analysis = 2099 +five_day, cumulative, model_fit_ANC_data, model_fit_weather_data = True, True, True, True +data_path = "/Users/rem76/Desktop/Climate_change_health/Data/" + +# Load and preprocess weather data +weather_data_prediction = pd.read_csv(f"{data_path}Precipitation_data/ssp2_4_5/prediction_weather_by_smaller_facilities_with_ANC_lm.csv") +weather_data_prediction = weather_data_prediction.iloc[(min_year_for_analysis - absolute_min_year) * 12:] + +# Flatten data and prepare for regression +num_facilities = len(weather_data_prediction.columns) +year_range = range(min_year_for_analysis, max_year_for_analysis) +month_repeated = [m for _ in year_range for m in range(1, 13)][:-4] +year_flattened = np.repeat(year_range, 12 * num_facilities)[:-4 * num_facilities] +month_flattened = month_repeated * num_facilities +facility_flattened = np.tile(range(num_facilities), len(year_flattened) // num_facilities) + +# Encode facilities and create above/below average weather data +weather_data = weather_data_prediction.values.flatten() +facility_encoded = pd.get_dummies(facility_flattened, drop_first=True) +grouped_data = pd.DataFrame({ + 'facility': facility_flattened, + 'month': month_flattened, + 'weather_data': weather_data +}).groupby(['facility', 'month'])['weather_data'].mean().reset_index() + +# Load and preprocess facility information +info_file = "expanded_facility_info_by_smaller_facility_lm_with_ANC.csv" if ANC else "expanded_facility_info_by_smaller_facility_lm.csv" +expanded_facility_info = pd.read_csv(f"{data_path}{info_file}", index_col=0).T + +def repeat_info(info, num_facilities, year_range): + return [i for i in info for _ in range(12 * len(year_range))][:-4 * num_facilities] + +zone_info = repeat_info(expanded_facility_info["Zonename"], num_facilities, year_range) +zone_encoded = pd.get_dummies(zone_info, drop_first=True) +resid_info = repeat_info(expanded_facility_info['Resid'], num_facilities, year_range) +resid_encoded = pd.get_dummies(resid_info, drop_first=True) +owner_info = repeat_info(expanded_facility_info['A105'], num_facilities, year_range) +owner_encoded = pd.get_dummies(owner_info, drop_first=True) +ftype_info = repeat_info(expanded_facility_info['Ftype'], num_facilities, year_range) +ftype_encoded = pd.get_dummies(ftype_info, drop_first=True) +altitude = np.where(np.array(repeat_info(expanded_facility_info['A109__Altitude'], num_facilities, year_range)) < 0, np.nan, altitude).tolist() + +# Lagged weather data +lags = [weather_data_prediction.shift(i).values.flatten() for i in range(1, 5)] + +# Load and prepare model +model_data = joblib.load('best_model_weather_5_day_cumulative_precip.pkl') +results_of_weather_model = model_data['model'] +mask_all_data = model_data['mask'] + +# Assemble predictors +X = np.column_stack([ + weather_data[mask_all_data], + year_flattened[mask_all_data], + month_flattened[mask_all_data], + resid_encoded[mask_all_data], + zone_encoded[mask_all_data], + owner_encoded[mask_all_data], + ftype_encoded[mask_all_data], + *[lag[mask_all_data] for lag in lags], + facility_encoded[mask_all_data], + np.array(altitude)[mask_all_data] +]) + +# Predictions and formatting output +predictions = results_of_weather_model.predict(X) +year_month_labels = np.array([f"{y}-{m}" for y, m in zip(year_flattened, month_flattened)]) +data_ANC_predictions = pd.DataFrame({ + 'Year_Month': year_month_labels[mask_all_data], + 'y_pred': np.exp(predictions) +}) + +# Plotting results +fig, axs = plt.subplots(1, 2, figsize=(14, 6)) +axs[0].scatter(data_ANC_predictions['Year_Month'], data_ANC_predictions['y_pred'], color='#9AC4F8', alpha=0.7, label='Predictions') +axs[0].set_xticklabels(data_ANC_predictions['Year_Month'], rotation=45, ha='right') +axs[0].set_xlabel('Year') +axs[0].set_ylabel('Number of ANC visits') +axs[0].set_title('Change in Monthly ANC Visits vs. Precipitation') +axs[0].legend(loc='upper left') +plt.tight_layout() +plt.show() From f462a07f1ec3b301f0db7ead1f47daf374338fd3 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 14 Nov 2024 11:20:43 +0000 Subject: [PATCH 139/291] Used ANC data and daily totals for 5-day cumulative. Also tried to improve model for weather prediction. Could use the existing model + add in weather data --- ...al_realtionship_reporting_precipitation.py | 145 ++++++++++++------ 1 file changed, 99 insertions(+), 46 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index ed2856a052..562d65fd7c 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -8,13 +8,13 @@ ANC = True daily_max = False -daily_total = False +daily_total = True min_year_for_analyis = 2011 absolute_min_year = 2011 mask_threshold = 0 five_day = True cumulative = True -model_fit_ANC_data = True +model_fit_ANC_data = False model_fit_weather_data = True model_filename = ( f"best_model_{'ANC' if ANC else 'Reporting'}_prediction_" @@ -44,12 +44,14 @@ index_col=0) else: weather_data_historical = pd.read_csv( - "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/historical_daily_max_by_facilities_with_ANC.csv", + "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/historical_daily_total_by_facility_five_day_cumulative.csv", index_col=0) elif daily_total: - weather_data_historical = pd.read_csv( - "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/historical_daily_total_by_facilities_with_ANC.csv", - index_col=0) + if five_day: + if cumulative: + weather_data_historical = pd.read_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/historical_daily_total_by_facilities_with_ANC_five_day_cumulative.csv", + index_col=0) else: weather_data_historical = pd.read_csv( "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_ANC_lm.csv", @@ -79,7 +81,7 @@ def build_model(X, y, scale_y=False, beta=False, log_y=False, X_mask_mm=0): y_scaled = np.clip(y / 100, epsilon, 1 - epsilon) else: y_scaled = y - mask = (~np.isnan(X).any(axis=1) & ~np.isnan(y_scaled) & (X[:, 0] >= X_mask_mm) & (y <= 1e5)) + mask = (~np.isnan(X).any(axis=1) & ~np.isnan(y_scaled) & (X[:, 0] >= X_mask_mm) & (y <= 1e4)) model = BetaModel(y_scaled[mask], X[mask]) if beta else sm.OLS(y_scaled[mask], X[mask]) model_fit = model.fit() return model_fit, model_fit.predict(X[mask]), mask @@ -135,43 +137,42 @@ def stepwise_selection(X, y, log_y, p_value_threshold=0.05): break return included - - +# +# # def stepwise_selection(X, y, log_y, p_value_threshold=0.05): -# included = list(range(X.shape[1])) -# current_r2 = -np.inf # Start with the worst possible R2 value +# included = [] # Start with an empty set of features +# current_r2 = 0 # Start with a baseline of 0 for R^2 # while True: # changed = False # excluded = list(set(range(X.shape[1])) - set(included)) # new_r2 = pd.Series(index=excluded, dtype=float) # for new_column in excluded: -# print(new_column) # subset_X = X[:, included + [new_column]] -# results, _, _ = build_model(subset_X, y, log_y=log_y, X_mask_mm=mask_threshold) -# new_r2[new_column] = results.rsquared # Use R2 instead of AIC -# best_r2 = new_r2.max() -# #if best_r2 > current_r2: # Maximize R2 -# if 1e-6 < (best_r2 - current_r2): # Maximize R2 +# results, _, _ = build_model(subset_X, y, log_y=log_y) +# new_r2[new_column] = results.rsquared # Evaluate R^2 with the new feature # +# best_r2 = new_r2.max() +# print(best_r2) +# if best_r2 - current_r2 > 1e-4: # best_feature = new_r2.idxmax() # included.append(best_feature) # current_r2 = best_r2 # changed = True -# # # Evaluate model with current set of included features -# # results, _, _ = build_model(X[:, included], y, log_y=log_y, X_mask_mm=mask_threshold) -# # pvalues = results.pvalues -# # pvalues = pd.Series(pvalues) -# # worst_pval = pvalues.max() -# # -# # if worst_pval > p_value_threshold: # Remove features with p-value > 0.05 -# # worst_feature = pvalues.idxmax() -# # if worst_feature in included: -# # included.remove(worst_feature) -# # changed = True +# +# # Backward elimination: remove features with high p-values +# results, _, _ = build_model(X[:, included], y, log_y=log_y) +# pvalues = pd.Series(results.pvalues, index=included) +# worst_pval = pvalues.max() +# if worst_pval > p_value_threshold: +# worst_feature = pvalues.idxmax() +# included.remove(worst_feature) +# changed = True # # if not changed: # break # return included + + ############################################################################################## ########################## STEP 0: Tidy data ########################## ############################################################################################## @@ -241,7 +242,7 @@ def repeat_info(info, num_facilities, year_range): altitude = [float(x) for x in repeat_info(expanded_facility_info['A109__Altitude'], num_facilities, year_range)] # Lagged weather lag_1_month = weather_data_historical.shift(1).values.flatten() -lag_2_month = weather_data_historical.shift(1).values.flatten() +lag_2_month = weather_data_historical.shift(2).values.flatten() lag_3_month = weather_data_historical.shift(3).values.flatten() lag_4_month = weather_data_historical.shift(4).values.flatten() @@ -289,7 +290,7 @@ def repeat_info(info, num_facilities, year_range): else: residuals_percentage = (y[mask_ANC_data] - y_pred) - +print("ANC prediction", results.summary()) # plot year_month_labels = np.array([f"{y}-{m}" for y, m in zip(year_flattened, month_flattened)]) @@ -316,7 +317,7 @@ def repeat_info(info, num_facilities, year_range): axs[0].scatter(data_ANC_predictions['Year_Month'], data_ANC_predictions['y_pred'], color='#9AC4F8', alpha=0.7, label='Predictions') axs[0].set_xticklabels(data_ANC_predictions['Year_Month'], rotation=45, ha='right') axs[0].set_xlabel('Year') -axs[0].set_ylabel('Log(Number of ANC visits)') +axs[0].set_ylabel('Number of ANC visits') axs[0].set_title('A: Monthly ANC Visits vs. Precipitation') axs[0].legend(loc='upper left') @@ -324,8 +325,29 @@ def repeat_info(info, num_facilities, year_range): axs[1].scatter(data_ANC_predictions['Year_Month'], residuals_percentage, color='#9AC4F8', alpha=0.7, label='Residuals') axs[1].set_xticklabels(data_ANC_predictions['Year_Month'], rotation=45, ha='right') axs[1].set_xlabel('Year') -axs[1].set_ylabel('Residuals (%)') -axs[1].set_title('B: Residuals as Percentage') +axs[1].set_ylabel('Residuals') +axs[1].set_title('B: Residuals') +axs[1].legend(loc='upper left') +plt.tight_layout() +plt.show() + +fig, axs = plt.subplots(1, 2, figsize=(14, 6)) + +# Panel A: Actual data and predictions +axs[0].scatter(data_ANC_predictions['Year_Month'], np.log(data_ANC_predictions['y_filtered']), color='#1C6E8C', alpha=0.5, label='Actual data') +axs[0].scatter(data_ANC_predictions['Year_Month'], np.log(data_ANC_predictions['y_pred']), color='#9AC4F8', alpha=0.7, label='Predictions') +axs[0].set_xticklabels(data_ANC_predictions['Year_Month'], rotation=45, ha='right') +axs[0].set_xlabel('Year') +axs[0].set_ylabel('Log(Number of ANC visits)') +axs[0].set_title('A: Monthly ANC Visits vs. Precipitation') +axs[0].legend(loc='upper left') + +# Panel B: Residuals (in percentage) +axs[1].scatter(data_ANC_predictions['Year_Month'], np.log(residuals_percentage), color='#9AC4F8', alpha=0.7, label='Residuals') +axs[1].set_xticklabels(data_ANC_predictions['Year_Month'], rotation=45, ha='right') +axs[1].set_xlabel('Year') +axs[1].set_ylabel('Log(Residual ANC cases)') +axs[1].set_title('B: Residuals cases') axs[1].legend(loc='upper left') plt.tight_layout() plt.show() @@ -349,7 +371,7 @@ def repeat_info(info, num_facilities, year_range): np.array(altitude)[mask_ANC_data] ]) - +log_y = False if model_fit_weather_data: best_predictors = stepwise_selection(X, residuals_percentage, log_y=log_y) print(best_predictors) @@ -365,6 +387,7 @@ def repeat_info(info, num_facilities, year_range): model_data = joblib.load(model_filename_weather_model) results_of_weather_model = model_data['model'] mask_all_data = model_data['mask'] + best_predictors = model_data['best_predictors'] results_of_weather_model, y_pred, mask_all_data = build_model(X_best, residuals_percentage, log_y=log_y, X_mask_mm=mask_threshold) print(results_of_weather_model.summary()) @@ -382,28 +405,58 @@ def repeat_info(info, num_facilities, year_range): lag_3_month[mask_ANC_data], lag_4_month[mask_ANC_data], facility_encoded[mask_ANC_data], - np.array(altitude)[mask_ANC_data] + np.array(altitude)[mask_ANC_data], + ]) -results_of_weather_model, y_pred, mask_all_data = build_model(X, residuals_percentage, log_y=log_y, X_mask_mm=mask_threshold) + +X_weather = np.column_stack([ + weather_data[mask_ANC_data], + np.array(month_flattened)[mask_ANC_data], + X[:,best_predictors], + lag_1_month[mask_ANC_data], + lag_2_month[mask_ANC_data], + lag_3_month[mask_ANC_data], + lag_4_month[mask_ANC_data] +]) +results_of_weather_model, y_pred, mask_all_data = build_model(X_weather, residuals_percentage, log_y=log_y, X_mask_mm=mask_threshold) + +print(results_of_weather_model.summary()) + +##### Plot y_predic + +X_filtered = X[mask_all_data] + +plt.scatter(X_filtered[:, 0], (residuals_percentage[mask_all_data]), color='red', alpha=0.5) +plt.scatter(X_filtered[:, 0],y_pred) +plt.title(' ') +plt.ylabel('Change in ANC visits') +plt.xlabel('Precip (mm)') +plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) +plt.show() + + + +X_weather = np.column_stack([ + weather_data[mask_ANC_data], + X[:,best_predictors], + np.array(month_flattened)[mask_ANC_data], + lag_1_month[mask_ANC_data], + lag_2_month[mask_ANC_data], + lag_3_month[mask_ANC_data], + lag_4_month[mask_ANC_data] +]) +results_of_weather_model, y_pred, mask_all_data = build_model(X_weather, residuals_percentage, log_y=log_y, X_mask_mm=mask_threshold) print(results_of_weather_model.summary()) ##### Plot y_predic X_filtered = X[mask_all_data] -if ANC: - plt.scatter(X_filtered[:, 0], np.log(residuals_percentage[mask_all_data]), color='red', alpha=0.5) - plt.scatter(X_filtered[:, 0], y_pred) - plt.title(' ') - plt.ylabel('log(change in ANC visits)') - plt.xlabel('Precip (mm)') - plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) - plt.show() plt.scatter(X_filtered[:, 0], (residuals_percentage[mask_all_data]), color='red', alpha=0.5) -plt.scatter(X_filtered[:, 0], np.exp(y_pred)) +plt.scatter(X_filtered[:, 0],y_pred) plt.title(' ') -plt.ylabel('log(change in ANC visits)') +plt.ylabel('Change in ANC visits') plt.xlabel('Precip (mm)') plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) plt.show() From c3a993c57a9c1c31d424864a63759738767313a2 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 14 Nov 2024 13:44:13 +0000 Subject: [PATCH 140/291] Added loop to create monthly and 5-day cumulatve data. Needs tidying. --- .../climate_change/process_CMIP6_data.py | 143 +++++++++++++++++- 1 file changed, 141 insertions(+), 2 deletions(-) diff --git a/src/scripts/climate_change/process_CMIP6_data.py b/src/scripts/climate_change/process_CMIP6_data.py index 2f2949c959..a47b93fa13 100644 --- a/src/scripts/climate_change/process_CMIP6_data.py +++ b/src/scripts/climate_change/process_CMIP6_data.py @@ -4,10 +4,24 @@ import shutil import zipfile from pathlib import Path +import difflib import numpy as np import pandas as pd from netCDF4 import Dataset +import geopandas as gpd + +five_day = True +monthly_cumulative = False +multiplier = 86400 +years = range(2015, 2100) +reporting_data = pd.read_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_ANC_by_smaller_facility_lm.csv") + +general_facilities = gpd.read_file("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_districts.shp") + +facilities_with_lat_long = pd.read_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_lat_long_region.csv") def unzip_all_in_directory(directory): @@ -83,12 +97,13 @@ def extract_nc_files_from_unzipped_folders(directory): pr_data = data_per_model.variables['pr'][:] # in kg m-2 s-1 = mm s-1 x 86400 to get to day lat_data = data_per_model.variables['lat'][:] long_data = data_per_model.variables['lon'][:] + #time_data = data_per_model.variables['time'] 31046 days grid_dictionary = {} grid = 0 for i in range(len(long_data)): for j in range(len(lat_data)): precip_data_for_grid = pr_data[:,j,i] # across all time points - precip_data_for_grid = precip_data_for_grid * 86400 # to get from per second to per day + precip_data_for_grid = precip_data_for_grid * multiplier # to get from per second to per day grid_dictionary[grid] = precip_data_for_grid grid += 1 data_by_model_and_grid[model] = grid_dictionary @@ -118,7 +133,6 @@ def extract_nc_files_from_unzipped_folders(directory): for i, value in enumerate(model_data): if not np.ma.is_masked(value): timepoint_values[i].append(value) - # Calculate and store statistics for each grid and timepoint mean_precip_by_timepoint[grid] = [np.mean(tp_values) if tp_values else np.nan for tp_values in timepoint_values] median_precip_by_timepoint[grid] = [np.median(tp_values) if tp_values else np.nan for tp_values in @@ -143,4 +157,129 @@ def extract_nc_files_from_unzipped_folders(directory): percentile_75_df.to_csv( Path(scenario_directory) / "percentile_75_projected_precip_by_timepoint_modal_resolution.csv") + ## now do monthly 5-day max + + month_lengths = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]*len(years) + + if five_day: + window_size = 5 # Set the window size to 5 days + cumulative_sum_by_grid = {} + mean_precip_by_timepoint = pd.DataFrame.from_dict(mean_precip_by_timepoint) + for grid in range(mean_precip_by_timepoint.shape[1]): # columns are grids + pr_data_for_grid = mean_precip_by_timepoint[grid] + if grid not in cumulative_sum_by_grid: + cumulative_sum_by_grid[grid] = [] + begin_day = 0 + for month_idx, month_length in enumerate(month_lengths): + days_for_grid = pr_data_for_grid[begin_day:begin_day + month_length] + cumulative_sums = [] + for day in range(month_length - window_size + 1): + window_sum = sum(days_for_grid[day:day + window_size]) + cumulative_sums.append(window_sum) + max_cumulative_sums = max(cumulative_sums) + cumulative_sum_by_grid[grid].append(max_cumulative_sums) + begin_day += month_length + df_cumulative_sum = pd.DataFrame.from_dict(cumulative_sum_by_grid, orient='index') + df_cumulative_sum = df_cumulative_sum.T + df_cumulative_sum.to_csv(Path(scenario_directory) / "five_day_cumulative_sum_by_grid.csv") + + + ############### NOW HAVE LAT/LONG OF FACILITIES ##################### + facilities_with_location = [] + cumulative_sum_by_facility = {} + for reporting_facility in reporting_data.columns: + matching_facility_name = difflib.get_close_matches(reporting_facility, facilities_with_lat_long['Fname'], n=3, cutoff=0.90) + if matching_facility_name: + match_name = matching_facility_name[0] # Access the string directly + facilities_with_location.append(reporting_facility) + lat_for_facility = facilities_with_lat_long.loc[ + facilities_with_lat_long['Fname'] == match_name, "A109__Latitude"].iloc[0] + long_for_facility = facilities_with_lat_long.loc[ + facilities_with_lat_long['Fname'] == match_name, "A109__Longitude"].iloc[0] + index_for_x = ((long_data - long_for_facility)**2).argmin() + index_for_y= ((lat_data - lat_for_facility)**2).argmin() + # which grid number is it + grid = index_for_x * index_for_y + 1 + cumulative_sum_by_facility[reporting_facility] = df_cumulative_sum[grid] # across all time points + + ## below are not in facilities file? + elif reporting_facility == "Central East Zone": + grid = general_facilities[general_facilities["District"] == "Nkhotakota"]["Grid_Index"].iloc[ + 0] # furtherst east zone + cumulative_sum_by_facility[reporting_facility] = df_cumulative_sum[grid] + elif (reporting_facility == "Central Hospital"): + grid = general_facilities[general_facilities["District"] == "Lilongwe City"]["Grid_Index"].iloc[ + 0] # all labelled X City will be in the same grid + cumulative_sum_by_facility[reporting_facility] = df_cumulative_sum[grid] + else: + continue + + + ### Get data ready for linear regression between reporting and weather data + weather_df = pd.DataFrame.from_dict(cumulative_sum_by_facility, orient='index').T + weather_df.columns = facilities_with_location + weather_df.to_csv(Path(scenario_directory)/"prediction_weather_by_smaller_facilities_with_ANC_lm.csv") + + elif monthly_cumulative: + cumulative_sum_by_grid = {} + mean_precip_by_timepoint = pd.DataFrame.from_dict(mean_precip_by_timepoint) + cumulative_sum_by_facility = {} + for grid in range(mean_precip_by_timepoint.shape[1]): # columns are grids + pr_data_for_grid = mean_precip_by_timepoint[grid] + if grid not in cumulative_sum_by_grid: + cumulative_sum_by_grid[grid] = [] + begin_day = 0 + for month_idx, month_length in enumerate(month_lengths): + window_size = month_length # Set the window size to 5 days + days_for_grid = pr_data_for_grid[begin_day:begin_day + month_length] + cumulative_sums = [] + for day in range(month_length - window_size + 1): + window_sum = sum(days_for_grid[day:day + window_size]) + cumulative_sums.append(window_sum) + max_cumulative_sums = max(cumulative_sums) + cumulative_sum_by_grid[grid].append(max_cumulative_sums) + begin_day += month_length + df_cumulative_sum = pd.DataFrame.from_dict(cumulative_sum_by_grid, orient='index') + df_cumulative_sum = df_cumulative_sum.T + df_cumulative_sum.to_csv(Path(scenario_directory) / "monthly_cumulative_sum_by_grid.csv") + + ## + + ############### NOW HAVE LAT/LONG OF FACILITIES ##################### + facilities_with_location = [] + for reporting_facility in reporting_data.columns: + matching_facility_name = difflib.get_close_matches(reporting_facility, facilities_with_lat_long['Fname'], + n=3, cutoff=0.90) + if matching_facility_name: + match_name = matching_facility_name[0] # Access the string directly + facilities_with_location.append(reporting_facility) + lat_for_facility = facilities_with_lat_long.loc[ + facilities_with_lat_long['Fname'] == match_name, "A109__Latitude"].iloc[0] + long_for_facility = facilities_with_lat_long.loc[ + facilities_with_lat_long['Fname'] == match_name, "A109__Longitude"].iloc[0] + index_for_x = ((long_data - long_for_facility) ** 2).argmin() + index_for_y = ((lat_data - lat_for_facility) ** 2).argmin() + # which grid number is it + grid = index_for_x*index_for_y + 1 + cumulative_sum_by_facility[reporting_facility] = df_cumulative_sum[grid] # across all time points + + ## below are not in facilities file? + elif reporting_facility == "Central East Zone": + grid = general_facilities[general_facilities["District"] == "Nkhotakota"]["Grid_Index"].iloc[ + 0] # furtherst east zone + cumulative_sum_by_facility[reporting_facility] = df_cumulative_sum[grid] + elif (reporting_facility == "Central Hospital"): + grid = general_facilities[general_facilities["District"] == "Lilongwe City"]["Grid_Index"].iloc[ + 0] # all labelled X City will be in the same grid + cumulative_sum_by_facility[reporting_facility] = df_cumulative_sum[grid] + else: + continue + + ### Get data ready for linear regression between reporting and weather data + weather_df = pd.DataFrame.from_dict(cumulative_sum_by_facility, orient='index').T + weather_df.columns = facilities_with_location + weather_df.to_csv(Path(scenario_directory) / "prediction_weather_monthly_by_smaller_facilities_with_ANC_lm.csv") + + + From 1a15b5ad4378ee1f23db1add4050d0a5bd4e1e69 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 3 Jan 2025 11:29:20 +0000 Subject: [PATCH 141/291] Soft reset --- .gitattributes | 1 + .gitignore | 6 + src/scripts/climate_change/.gitignore | 4 + .../CIL_CMIP6_downscaling.ipynb | 7239 +++++++++++++++++ .../climate_change/CIL_CMIP6_downscaling.py | 64 + .../assessing_reporting_data.py.ipynb | 162 + .../carbonplan_CMIP6_downscaling.ipynb | 1389 ++++ src/scripts/climate_change/cohort_model.ipynb | 5314 ++++++++++++ .../compare_historical_era5_cmip6.ipynb | 392 + .../data_retrieval_ERA5_reanalysis_monthly.py | 2 +- .../gridding_data_exploration.ipynb | 1382 ++++ ...al_realtionship_reporting_precipitation.py | 817 +- ...ip_reporting_precipitation_missing_data.py | 360 + .../linear_model_predicting_CMIP6.py | 91 +- .../climate_change/model_development.ipynb | 2977 +++++++ .../plot_raw_reanalysis_data.py | 108 +- .../climate_change/process_CMIP6_data.py | 73 +- .../process_CMIP6_data_KDBall.py | 237 + .../climate_change/process_daily_max_data.py | 2 + .../process_daily_total_historical_data.py | 12 +- ...d_monthly_weather_data_small_facilities.py | 67 +- src/scripts/climate_change/scratch.ipynb | 294 + .../longterm_projections_draws.json | 161 + 23 files changed, 20757 insertions(+), 397 deletions(-) create mode 100644 src/scripts/climate_change/.gitignore create mode 100644 src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb create mode 100644 src/scripts/climate_change/CIL_CMIP6_downscaling.py create mode 100644 src/scripts/climate_change/assessing_reporting_data.py.ipynb create mode 100644 src/scripts/climate_change/carbonplan_CMIP6_downscaling.ipynb create mode 100644 src/scripts/climate_change/cohort_model.ipynb create mode 100644 src/scripts/climate_change/compare_historical_era5_cmip6.ipynb create mode 100644 src/scripts/climate_change/gridding_data_exploration.ipynb create mode 100644 src/scripts/climate_change/linear_model_historical_relationship_reporting_precipitation_missing_data.py create mode 100644 src/scripts/climate_change/model_development.ipynb create mode 100644 src/scripts/climate_change/process_CMIP6_data_KDBall.py create mode 100644 src/scripts/climate_change/scratch.ipynb create mode 100644 src/scripts/longterm_projections/longterm_projections_draws.json diff --git a/.gitattributes b/.gitattributes index e8241c9d42..2198ffb5bb 100644 --- a/.gitattributes +++ b/.gitattributes @@ -9,3 +9,4 @@ *.xlsx filter=lfs diff=lfs merge=lfs -text *.pickle filter=lfs diff=lfs merge=lfs -text resources/** filter=lfs diff=lfs merge=lfs -text +best_model_monthly_total_precip.pkl filter=lfs diff=lfs merge=lfs -text diff --git a/.gitignore b/.gitignore index 9711f1da10..3cd30e3c43 100644 --- a/.gitignore +++ b/.gitignore @@ -129,3 +129,9 @@ docs/parameters.rst docs/reference/modules.rst docs/reference/tlo*.rst docs/resources/**/*.rst + +# Climate data +src/scripts/climate_change/assessing_CMIP6_data_min_med_max.ipynb +best_model_weather_monthly_total_precip.pkl +best_model_ANC_prediction_monthly_total_precip.pkl +best_model_monthly_total_precip.pkl diff --git a/src/scripts/climate_change/.gitignore b/src/scripts/climate_change/.gitignore new file mode 100644 index 0000000000..7f609f54b6 --- /dev/null +++ b/src/scripts/climate_change/.gitignore @@ -0,0 +1,4 @@ +src/scripts/climate_change/assessing_CMIP6_data_min_med_max.ipynb +best_model_weather_monthly_total_precip.pkl +best_model_ANC_prediction_monthly_total_precip.pkl +best_model_monthly_total_precip.pkl diff --git a/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb b/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb new file mode 100644 index 0000000000..5d5adf989b --- /dev/null +++ b/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb @@ -0,0 +1,7239 @@ +{ + "cells": [ + { + "metadata": {}, + "cell_type": "markdown", + "source": "From https://planetarycomputer.microsoft.com/dataset/cil-gdpcir-cc0#Ensemble-example", + "id": "527d7ca56042f1c2" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-20T15:37:32.374596Z", + "start_time": "2024-12-20T15:37:30.837930Z" + } + }, + "cell_type": "code", + "source": [ + "import planetary_computer\n", + "import pystac_client\n", + "\n", + "import xarray as xr\n", + "import numpy as np\n", + "import pandas as pd\n", + "from dask.diagnostics import ProgressBar\n", + "from tqdm.auto import tqdm\n", + "\n", + "import os\n", + "import re\n", + "import glob\n", + "import shutil\n", + "import zipfile\n", + "from pathlib import Path\n", + "\n", + "import difflib\n", + "from scipy.spatial import KDTree\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import geopandas as gpd\n", + "import regionmask\n", + "import cartopy.crs as ccrs\n", + "\n", + "from netCDF4 import Dataset\n", + "\n", + "from carbonplan import styles # noqa: F401\n", + "import intake\n", + "import cmip6_downscaling\n" + ], + "id": "7b5963dac1c0b629", + "outputs": [], + "execution_count": 1 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Load and organise data", + "id": "900df6fa0e1e8d25" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-02T21:43:37.377707Z", + "start_time": "2025-01-02T21:42:39.868201Z" + } + }, + "cell_type": "code", + "source": [ + "catalog = pystac_client.Client.open(\n", + " \"https://planetarycomputer.microsoft.com/api/stac/v1/\",\n", + " modifier=planetary_computer.sign_inplace,\n", + ")\n", + "collection_cc0 = catalog.get_collection(\"cil-gdpcir-cc0\")\n", + "collection_cc0.summaries.to_dict()\n", + "scenarios = [\"ssp245\"]\n", + "for scenario in scenarios:\n", + " search = catalog.search(\n", + " collections=[\"cil-gdpcir-cc0\", \"cil-gdpcir-cc-by\"], # both creative licenses\n", + " query={\"cmip6:experiment_id\": {\"eq\": f\"{scenario}\"}}, # stick with 245 for the moment \n", + " )\n", + " ensemble = search.item_collection()\n", + " print(len(ensemble))\n", + " \n", + " # read in only the precipitation\n", + " variable_id = \"pr\"\n", + " \n", + " datasets_by_model = []\n", + " \n", + " for item in tqdm(ensemble):\n", + " asset = item.assets[variable_id]\n", + " datasets_by_model.append(\n", + " xr.open_dataset(asset.href, **asset.extra_fields[\"xarray:open_kwargs\"])\n", + " )\n", + " \n", + " all_datasets = xr.concat(\n", + " datasets_by_model,\n", + " dim=pd.Index([ds.attrs[\"source_id\"] for ds in datasets_by_model], name=\"model\"),\n", + " combine_attrs=\"drop_conflicts\",\n", + " )\n", + " \n", + " #Subset for Malawi and 2025-2100\n", + " \n", + " subset = all_datasets.pr.sel(\n", + " lon=slice(32.67161823,35.91841716),\n", + " lat=slice(-17.12627881, -9.36366167),\n", + " time=slice(\"2025-01-01\", \"2071-01-01\"),\n", + " )\n", + " \n", + " subset.to_netcdf(f\"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/CIL_subsetted_all_model_{scenario}.nc\")" + ], + "id": "aaa18487dc9d770f", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "23\n" + ] + }, + { + "data": { + "text/plain": [ + " 0%| | 0/23 [00:00 211\u001B[0m file \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_cache\u001B[49m\u001B[43m[\u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_key\u001B[49m\u001B[43m]\u001B[49m\n\u001B[1;32m 212\u001B[0m \u001B[38;5;28;01mexcept\u001B[39;00m \u001B[38;5;167;01mKeyError\u001B[39;00m:\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/backends/lru_cache.py:56\u001B[0m, in \u001B[0;36mLRUCache.__getitem__\u001B[0;34m(self, key)\u001B[0m\n\u001B[1;32m 55\u001B[0m \u001B[38;5;28;01mwith\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_lock:\n\u001B[0;32m---> 56\u001B[0m value \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_cache\u001B[49m\u001B[43m[\u001B[49m\u001B[43mkey\u001B[49m\u001B[43m]\u001B[49m\n\u001B[1;32m 57\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_cache\u001B[38;5;241m.\u001B[39mmove_to_end(key)\n", + "\u001B[0;31mKeyError\u001B[0m: [, ('/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/CIL_subsetted_all_model_ssp245.nc',), 'a', (('clobber', True), ('diskless', False), ('format', 'NETCDF4'), ('persist', False)), '5d9c3923-1729-4151-9ec2-02ebe797fa4f']", + "\nDuring handling of the above exception, another exception occurred:\n", + "\u001B[0;31mPermissionError\u001B[0m Traceback (most recent call last)", + "Cell \u001B[0;32mIn[6], line 41\u001B[0m\n\u001B[1;32m 33\u001B[0m \u001B[38;5;66;03m#Subset for Malawi and 2025-2100\u001B[39;00m\n\u001B[1;32m 35\u001B[0m subset \u001B[38;5;241m=\u001B[39m all_datasets\u001B[38;5;241m.\u001B[39mpr\u001B[38;5;241m.\u001B[39msel(\n\u001B[1;32m 36\u001B[0m lon\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mslice\u001B[39m(\u001B[38;5;241m32.67161823\u001B[39m,\u001B[38;5;241m35.91841716\u001B[39m),\n\u001B[1;32m 37\u001B[0m lat\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mslice\u001B[39m(\u001B[38;5;241m-\u001B[39m\u001B[38;5;241m17.12627881\u001B[39m, \u001B[38;5;241m-\u001B[39m\u001B[38;5;241m9.36366167\u001B[39m),\n\u001B[1;32m 38\u001B[0m time\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mslice\u001B[39m(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124m2025-01-01\u001B[39m\u001B[38;5;124m\"\u001B[39m, \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124m2071-01-01\u001B[39m\u001B[38;5;124m\"\u001B[39m),\n\u001B[1;32m 39\u001B[0m )\n\u001B[0;32m---> 41\u001B[0m \u001B[43msubset\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mto_netcdf\u001B[49m\u001B[43m(\u001B[49m\u001B[38;5;124;43mf\u001B[39;49m\u001B[38;5;124;43m\"\u001B[39;49m\u001B[38;5;124;43m/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/CIL_subsetted_all_model_\u001B[39;49m\u001B[38;5;132;43;01m{\u001B[39;49;00m\u001B[43mscenario\u001B[49m\u001B[38;5;132;43;01m}\u001B[39;49;00m\u001B[38;5;124;43m.nc\u001B[39;49m\u001B[38;5;124;43m\"\u001B[39;49m\u001B[43m)\u001B[49m\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/core/dataarray.py:4211\u001B[0m, in \u001B[0;36mDataArray.to_netcdf\u001B[0;34m(self, path, mode, format, group, engine, encoding, unlimited_dims, compute, invalid_netcdf, auto_complex)\u001B[0m\n\u001B[1;32m 4207\u001B[0m \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[1;32m 4208\u001B[0m \u001B[38;5;66;03m# No problems with the name - so we're fine!\u001B[39;00m\n\u001B[1;32m 4209\u001B[0m dataset \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mto_dataset()\n\u001B[0;32m-> 4211\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[43mto_netcdf\u001B[49m\u001B[43m(\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;66;43;03m# type: ignore[return-value] # mypy cannot resolve the overloads:(\u001B[39;49;00m\n\u001B[1;32m 4212\u001B[0m \u001B[43m \u001B[49m\u001B[43mdataset\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 4213\u001B[0m \u001B[43m \u001B[49m\u001B[43mpath\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 4214\u001B[0m \u001B[43m \u001B[49m\u001B[43mmode\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mmode\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 4215\u001B[0m \u001B[43m \u001B[49m\u001B[38;5;28;43mformat\u001B[39;49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43mformat\u001B[39;49m\u001B[43m,\u001B[49m\n\u001B[1;32m 4216\u001B[0m \u001B[43m \u001B[49m\u001B[43mgroup\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mgroup\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 4217\u001B[0m \u001B[43m \u001B[49m\u001B[43mengine\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mengine\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 4218\u001B[0m \u001B[43m \u001B[49m\u001B[43mencoding\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mencoding\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 4219\u001B[0m \u001B[43m \u001B[49m\u001B[43munlimited_dims\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43munlimited_dims\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 4220\u001B[0m \u001B[43m \u001B[49m\u001B[43mcompute\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mcompute\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 4221\u001B[0m \u001B[43m \u001B[49m\u001B[43mmultifile\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43;01mFalse\u001B[39;49;00m\u001B[43m,\u001B[49m\n\u001B[1;32m 4222\u001B[0m \u001B[43m \u001B[49m\u001B[43minvalid_netcdf\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43minvalid_netcdf\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 4223\u001B[0m \u001B[43m \u001B[49m\u001B[43mauto_complex\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mauto_complex\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 4224\u001B[0m \u001B[43m\u001B[49m\u001B[43m)\u001B[49m\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/backends/api.py:1856\u001B[0m, in \u001B[0;36mto_netcdf\u001B[0;34m(dataset, path_or_file, mode, format, group, engine, encoding, unlimited_dims, compute, multifile, invalid_netcdf, auto_complex)\u001B[0m\n\u001B[1;32m 1853\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m auto_complex \u001B[38;5;129;01mis\u001B[39;00m \u001B[38;5;129;01mnot\u001B[39;00m \u001B[38;5;28;01mNone\u001B[39;00m:\n\u001B[1;32m 1854\u001B[0m kwargs[\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mauto_complex\u001B[39m\u001B[38;5;124m\"\u001B[39m] \u001B[38;5;241m=\u001B[39m auto_complex\n\u001B[0;32m-> 1856\u001B[0m store \u001B[38;5;241m=\u001B[39m \u001B[43mstore_open\u001B[49m\u001B[43m(\u001B[49m\u001B[43mtarget\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mmode\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;28;43mformat\u001B[39;49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mgroup\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mkwargs\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 1858\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m unlimited_dims \u001B[38;5;129;01mis\u001B[39;00m \u001B[38;5;28;01mNone\u001B[39;00m:\n\u001B[1;32m 1859\u001B[0m unlimited_dims \u001B[38;5;241m=\u001B[39m dataset\u001B[38;5;241m.\u001B[39mencoding\u001B[38;5;241m.\u001B[39mget(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124munlimited_dims\u001B[39m\u001B[38;5;124m\"\u001B[39m, \u001B[38;5;28;01mNone\u001B[39;00m)\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/backends/netCDF4_.py:452\u001B[0m, in \u001B[0;36mNetCDF4DataStore.open\u001B[0;34m(cls, filename, mode, format, group, clobber, diskless, persist, auto_complex, lock, lock_maker, autoclose)\u001B[0m\n\u001B[1;32m 448\u001B[0m kwargs[\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mauto_complex\u001B[39m\u001B[38;5;124m\"\u001B[39m] \u001B[38;5;241m=\u001B[39m auto_complex\n\u001B[1;32m 449\u001B[0m manager \u001B[38;5;241m=\u001B[39m CachingFileManager(\n\u001B[1;32m 450\u001B[0m netCDF4\u001B[38;5;241m.\u001B[39mDataset, filename, mode\u001B[38;5;241m=\u001B[39mmode, kwargs\u001B[38;5;241m=\u001B[39mkwargs\n\u001B[1;32m 451\u001B[0m )\n\u001B[0;32m--> 452\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28;43mcls\u001B[39;49m\u001B[43m(\u001B[49m\u001B[43mmanager\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mgroup\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mgroup\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mmode\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mmode\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mlock\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mlock\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mautoclose\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mautoclose\u001B[49m\u001B[43m)\u001B[49m\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/backends/netCDF4_.py:393\u001B[0m, in \u001B[0;36mNetCDF4DataStore.__init__\u001B[0;34m(self, manager, group, mode, lock, autoclose)\u001B[0m\n\u001B[1;32m 391\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_group \u001B[38;5;241m=\u001B[39m group\n\u001B[1;32m 392\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_mode \u001B[38;5;241m=\u001B[39m mode\n\u001B[0;32m--> 393\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mformat \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mds\u001B[49m\u001B[38;5;241m.\u001B[39mdata_model\n\u001B[1;32m 394\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_filename \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mds\u001B[38;5;241m.\u001B[39mfilepath()\n\u001B[1;32m 395\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mis_remote \u001B[38;5;241m=\u001B[39m is_remote_uri(\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_filename)\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/backends/netCDF4_.py:461\u001B[0m, in \u001B[0;36mNetCDF4DataStore.ds\u001B[0;34m(self)\u001B[0m\n\u001B[1;32m 459\u001B[0m \u001B[38;5;129m@property\u001B[39m\n\u001B[1;32m 460\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21mds\u001B[39m(\u001B[38;5;28mself\u001B[39m):\n\u001B[0;32m--> 461\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_acquire\u001B[49m\u001B[43m(\u001B[49m\u001B[43m)\u001B[49m\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/backends/netCDF4_.py:455\u001B[0m, in \u001B[0;36mNetCDF4DataStore._acquire\u001B[0;34m(self, needs_lock)\u001B[0m\n\u001B[1;32m 454\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21m_acquire\u001B[39m(\u001B[38;5;28mself\u001B[39m, needs_lock\u001B[38;5;241m=\u001B[39m\u001B[38;5;28;01mTrue\u001B[39;00m):\n\u001B[0;32m--> 455\u001B[0m \u001B[43m \u001B[49m\u001B[38;5;28;43;01mwith\u001B[39;49;00m\u001B[43m \u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_manager\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43macquire_context\u001B[49m\u001B[43m(\u001B[49m\u001B[43mneeds_lock\u001B[49m\u001B[43m)\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;28;43;01mas\u001B[39;49;00m\u001B[43m \u001B[49m\u001B[43mroot\u001B[49m\u001B[43m:\u001B[49m\n\u001B[1;32m 456\u001B[0m \u001B[43m \u001B[49m\u001B[43mds\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43m \u001B[49m\u001B[43m_nc4_require_group\u001B[49m\u001B[43m(\u001B[49m\u001B[43mroot\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_group\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_mode\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 457\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m ds\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/contextlib.py:137\u001B[0m, in \u001B[0;36m_GeneratorContextManager.__enter__\u001B[0;34m(self)\u001B[0m\n\u001B[1;32m 135\u001B[0m \u001B[38;5;28;01mdel\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39margs, \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mkwds, \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mfunc\n\u001B[1;32m 136\u001B[0m \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[0;32m--> 137\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28mnext\u001B[39m(\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mgen)\n\u001B[1;32m 138\u001B[0m \u001B[38;5;28;01mexcept\u001B[39;00m \u001B[38;5;167;01mStopIteration\u001B[39;00m:\n\u001B[1;32m 139\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m \u001B[38;5;167;01mRuntimeError\u001B[39;00m(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mgenerator didn\u001B[39m\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mt yield\u001B[39m\u001B[38;5;124m\"\u001B[39m) \u001B[38;5;28;01mfrom\u001B[39;00m \u001B[38;5;28;01mNone\u001B[39;00m\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/backends/file_manager.py:199\u001B[0m, in \u001B[0;36mCachingFileManager.acquire_context\u001B[0;34m(self, needs_lock)\u001B[0m\n\u001B[1;32m 196\u001B[0m \u001B[38;5;129m@contextlib\u001B[39m\u001B[38;5;241m.\u001B[39mcontextmanager\n\u001B[1;32m 197\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21macquire_context\u001B[39m(\u001B[38;5;28mself\u001B[39m, needs_lock\u001B[38;5;241m=\u001B[39m\u001B[38;5;28;01mTrue\u001B[39;00m):\n\u001B[1;32m 198\u001B[0m \u001B[38;5;250m \u001B[39m\u001B[38;5;124;03m\"\"\"Context manager for acquiring a file.\"\"\"\u001B[39;00m\n\u001B[0;32m--> 199\u001B[0m file, cached \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_acquire_with_cache_info\u001B[49m\u001B[43m(\u001B[49m\u001B[43mneeds_lock\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 200\u001B[0m \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[1;32m 201\u001B[0m \u001B[38;5;28;01myield\u001B[39;00m file\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/backends/file_manager.py:217\u001B[0m, in \u001B[0;36mCachingFileManager._acquire_with_cache_info\u001B[0;34m(self, needs_lock)\u001B[0m\n\u001B[1;32m 215\u001B[0m kwargs \u001B[38;5;241m=\u001B[39m kwargs\u001B[38;5;241m.\u001B[39mcopy()\n\u001B[1;32m 216\u001B[0m kwargs[\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mmode\u001B[39m\u001B[38;5;124m\"\u001B[39m] \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_mode\n\u001B[0;32m--> 217\u001B[0m file \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_opener\u001B[49m\u001B[43m(\u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_args\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mkwargs\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 218\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_mode \u001B[38;5;241m==\u001B[39m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mw\u001B[39m\u001B[38;5;124m\"\u001B[39m:\n\u001B[1;32m 219\u001B[0m \u001B[38;5;66;03m# ensure file doesn't get overridden when opened again\u001B[39;00m\n\u001B[1;32m 220\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_mode \u001B[38;5;241m=\u001B[39m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124ma\u001B[39m\u001B[38;5;124m\"\u001B[39m\n", + "File \u001B[0;32msrc/netCDF4/_netCDF4.pyx:2470\u001B[0m, in \u001B[0;36mnetCDF4._netCDF4.Dataset.__init__\u001B[0;34m()\u001B[0m\n", + "File \u001B[0;32msrc/netCDF4/_netCDF4.pyx:2107\u001B[0m, in \u001B[0;36mnetCDF4._netCDF4._ensure_nc_success\u001B[0;34m()\u001B[0m\n", + "\u001B[0;31mPermissionError\u001B[0m: [Errno 13] Permission denied: '/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/CIL_subsetted_all_model_ssp245.nc'" + ] + } + ], + "execution_count": 6 + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": " subset.to_netcdf(f\"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/CIL_subsetted_all_model_{scenario}.nc\")", + "id": "6136b5a191f194f1" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Find lowest, median, and highest value model across all lat/long and across all time points", + "id": "8564e555060bf10a" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-03T08:44:03.671513Z", + "start_time": "2025-01-03T08:44:03.284844Z" + } + }, + "cell_type": "code", + "source": [ + "subset_xr = xr.Dataset(\n", + " data_vars=dict(\n", + " pr=([\"time\", \"lat\",\"lon\", \"model\"],np.asarray(subset.data)),\n", + " ),\n", + " coords=dict(\n", + " time=subset.time.data,\n", + " lat=subset.lat.data,\n", + " lon=subset.lon.data,\n", + " model=subset.model.data\n", + " ),\n", + " attrs=dict(description=\"Weather related data.\"),\n", + ")\n" + ], + "id": "5dbaad05c9de5cdf", + "outputs": [ + { + "ename": "ClientAuthenticationError", + "evalue": "Server failed to authenticate the request. Make sure the value of Authorization header is formed correctly including the signature.\nRequestId:356fa9fc-a01e-0046-0fbb-5da77d000000\nTime:2025-01-03T08:44:03.5582125Z\nErrorCode:AuthenticationFailed\nauthenticationerrordetail:Signature not valid in the specified time frame: Start [Wed, 01 Jan 2025 21:42:40 GMT] - Expiry [Thu, 02 Jan 2025 22:27:40 GMT] - Current [Fri, 03 Jan 2025 08:44:03 GMT]\nContent: AuthenticationFailedServer failed to authenticate the request. Make sure the value of Authorization header is formed correctly including the signature.\nRequestId:356fa9fc-a01e-0046-0fbb-5da77d000000\nTime:2025-01-03T08:44:03.5582125ZSignature not valid in the specified time frame: Start [Wed, 01 Jan 2025 21:42:40 GMT] - Expiry [Thu, 02 Jan 2025 22:27:40 GMT] - Current [Fri, 03 Jan 2025 08:44:03 GMT]", + "output_type": "error", + "traceback": [ + "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m", + "\u001B[0;31mClientAuthenticationError\u001B[0m Traceback (most recent call last)", + "Cell \u001B[0;32mIn[7], line 3\u001B[0m\n\u001B[1;32m 1\u001B[0m subset_xr \u001B[38;5;241m=\u001B[39m xr\u001B[38;5;241m.\u001B[39mDataset(\n\u001B[1;32m 2\u001B[0m data_vars\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mdict\u001B[39m(\n\u001B[0;32m----> 3\u001B[0m pr\u001B[38;5;241m=\u001B[39m([\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mtime\u001B[39m\u001B[38;5;124m\"\u001B[39m, \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mlat\u001B[39m\u001B[38;5;124m\"\u001B[39m,\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mlon\u001B[39m\u001B[38;5;124m\"\u001B[39m, \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mmodel\u001B[39m\u001B[38;5;124m\"\u001B[39m],\u001B[43mnp\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43masarray\u001B[49m\u001B[43m(\u001B[49m\u001B[43msubset\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mdata\u001B[49m\u001B[43m)\u001B[49m),\n\u001B[1;32m 4\u001B[0m ),\n\u001B[1;32m 5\u001B[0m coords\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mdict\u001B[39m(\n\u001B[1;32m 6\u001B[0m time\u001B[38;5;241m=\u001B[39msubset\u001B[38;5;241m.\u001B[39mtime\u001B[38;5;241m.\u001B[39mdata,\n\u001B[1;32m 7\u001B[0m lat\u001B[38;5;241m=\u001B[39msubset\u001B[38;5;241m.\u001B[39mlat\u001B[38;5;241m.\u001B[39mdata,\n\u001B[1;32m 8\u001B[0m lon\u001B[38;5;241m=\u001B[39msubset\u001B[38;5;241m.\u001B[39mlon\u001B[38;5;241m.\u001B[39mdata,\n\u001B[1;32m 9\u001B[0m model\u001B[38;5;241m=\u001B[39msubset\u001B[38;5;241m.\u001B[39mmodel\u001B[38;5;241m.\u001B[39mdata\n\u001B[1;32m 10\u001B[0m ),\n\u001B[1;32m 11\u001B[0m attrs\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mdict\u001B[39m(description\u001B[38;5;241m=\u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mWeather related data.\u001B[39m\u001B[38;5;124m\"\u001B[39m),\n\u001B[1;32m 12\u001B[0m )\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/dask/array/core.py:1709\u001B[0m, in \u001B[0;36mArray.__array__\u001B[0;34m(self, dtype, **kwargs)\u001B[0m\n\u001B[1;32m 1708\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21m__array__\u001B[39m(\u001B[38;5;28mself\u001B[39m, dtype\u001B[38;5;241m=\u001B[39m\u001B[38;5;28;01mNone\u001B[39;00m, \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39mkwargs):\n\u001B[0;32m-> 1709\u001B[0m x \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mcompute\u001B[49m\u001B[43m(\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 1710\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m dtype \u001B[38;5;129;01mand\u001B[39;00m x\u001B[38;5;241m.\u001B[39mdtype \u001B[38;5;241m!=\u001B[39m dtype:\n\u001B[1;32m 1711\u001B[0m x \u001B[38;5;241m=\u001B[39m x\u001B[38;5;241m.\u001B[39mastype(dtype)\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/dask/base.py:372\u001B[0m, in \u001B[0;36mDaskMethodsMixin.compute\u001B[0;34m(self, **kwargs)\u001B[0m\n\u001B[1;32m 348\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21mcompute\u001B[39m(\u001B[38;5;28mself\u001B[39m, \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39mkwargs):\n\u001B[1;32m 349\u001B[0m \u001B[38;5;250m \u001B[39m\u001B[38;5;124;03m\"\"\"Compute this dask collection\u001B[39;00m\n\u001B[1;32m 350\u001B[0m \n\u001B[1;32m 351\u001B[0m \u001B[38;5;124;03m This turns a lazy Dask collection into its in-memory equivalent.\u001B[39;00m\n\u001B[0;32m (...)\u001B[0m\n\u001B[1;32m 370\u001B[0m \u001B[38;5;124;03m dask.compute\u001B[39;00m\n\u001B[1;32m 371\u001B[0m \u001B[38;5;124;03m \"\"\"\u001B[39;00m\n\u001B[0;32m--> 372\u001B[0m (result,) \u001B[38;5;241m=\u001B[39m \u001B[43mcompute\u001B[49m\u001B[43m(\u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mtraverse\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43;01mFalse\u001B[39;49;00m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mkwargs\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 373\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m result\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/dask/base.py:660\u001B[0m, in \u001B[0;36mcompute\u001B[0;34m(traverse, optimize_graph, scheduler, get, *args, **kwargs)\u001B[0m\n\u001B[1;32m 657\u001B[0m postcomputes\u001B[38;5;241m.\u001B[39mappend(x\u001B[38;5;241m.\u001B[39m__dask_postcompute__())\n\u001B[1;32m 659\u001B[0m \u001B[38;5;28;01mwith\u001B[39;00m shorten_traceback():\n\u001B[0;32m--> 660\u001B[0m results \u001B[38;5;241m=\u001B[39m \u001B[43mschedule\u001B[49m\u001B[43m(\u001B[49m\u001B[43mdsk\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mkeys\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mkwargs\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 662\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m repack([f(r, \u001B[38;5;241m*\u001B[39ma) \u001B[38;5;28;01mfor\u001B[39;00m r, (f, a) \u001B[38;5;129;01min\u001B[39;00m \u001B[38;5;28mzip\u001B[39m(results, postcomputes)])\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/core/indexing.py:580\u001B[0m, in \u001B[0;36mImplicitToExplicitIndexingAdapter.__array__\u001B[0;34m(self, dtype, copy)\u001B[0m\n\u001B[1;32m 578\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m np\u001B[38;5;241m.\u001B[39masarray(\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mget_duck_array(), dtype\u001B[38;5;241m=\u001B[39mdtype, copy\u001B[38;5;241m=\u001B[39mcopy)\n\u001B[1;32m 579\u001B[0m \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[0;32m--> 580\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m np\u001B[38;5;241m.\u001B[39masarray(\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mget_duck_array\u001B[49m\u001B[43m(\u001B[49m\u001B[43m)\u001B[49m, dtype\u001B[38;5;241m=\u001B[39mdtype)\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/core/indexing.py:583\u001B[0m, in \u001B[0;36mImplicitToExplicitIndexingAdapter.get_duck_array\u001B[0;34m(self)\u001B[0m\n\u001B[1;32m 582\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21mget_duck_array\u001B[39m(\u001B[38;5;28mself\u001B[39m):\n\u001B[0;32m--> 583\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43marray\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mget_duck_array\u001B[49m\u001B[43m(\u001B[49m\u001B[43m)\u001B[49m\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/core/indexing.py:794\u001B[0m, in \u001B[0;36mCopyOnWriteArray.get_duck_array\u001B[0;34m(self)\u001B[0m\n\u001B[1;32m 793\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21mget_duck_array\u001B[39m(\u001B[38;5;28mself\u001B[39m):\n\u001B[0;32m--> 794\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43marray\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mget_duck_array\u001B[49m\u001B[43m(\u001B[49m\u001B[43m)\u001B[49m\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/core/indexing.py:657\u001B[0m, in \u001B[0;36mLazilyIndexedArray.get_duck_array\u001B[0;34m(self)\u001B[0m\n\u001B[1;32m 653\u001B[0m array \u001B[38;5;241m=\u001B[39m apply_indexer(\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39marray, \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mkey)\n\u001B[1;32m 654\u001B[0m \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[1;32m 655\u001B[0m \u001B[38;5;66;03m# If the array is not an ExplicitlyIndexedNDArrayMixin,\u001B[39;00m\n\u001B[1;32m 656\u001B[0m \u001B[38;5;66;03m# it may wrap a BackendArray so use its __getitem__\u001B[39;00m\n\u001B[0;32m--> 657\u001B[0m array \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43marray\u001B[49m\u001B[43m[\u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mkey\u001B[49m\u001B[43m]\u001B[49m\n\u001B[1;32m 659\u001B[0m \u001B[38;5;66;03m# self.array[self.key] is now a numpy array when\u001B[39;00m\n\u001B[1;32m 660\u001B[0m \u001B[38;5;66;03m# self.array is a BackendArray subclass\u001B[39;00m\n\u001B[1;32m 661\u001B[0m \u001B[38;5;66;03m# and self.key is BasicIndexer((slice(None, None, None),))\u001B[39;00m\n\u001B[1;32m 662\u001B[0m \u001B[38;5;66;03m# so we need the explicit check for ExplicitlyIndexed\u001B[39;00m\n\u001B[1;32m 663\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(array, ExplicitlyIndexed):\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/backends/zarr.py:226\u001B[0m, in \u001B[0;36mZarrArrayWrapper.__getitem__\u001B[0;34m(self, key)\u001B[0m\n\u001B[1;32m 224\u001B[0m \u001B[38;5;28;01melif\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(key, indexing\u001B[38;5;241m.\u001B[39mOuterIndexer):\n\u001B[1;32m 225\u001B[0m method \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_oindex\n\u001B[0;32m--> 226\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[43mindexing\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mexplicit_indexing_adapter\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m 227\u001B[0m \u001B[43m \u001B[49m\u001B[43mkey\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43marray\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mshape\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mindexing\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mIndexingSupport\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mVECTORIZED\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mmethod\u001B[49m\n\u001B[1;32m 228\u001B[0m \u001B[43m\u001B[49m\u001B[43m)\u001B[49m\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/core/indexing.py:1018\u001B[0m, in \u001B[0;36mexplicit_indexing_adapter\u001B[0;34m(key, shape, indexing_support, raw_indexing_method)\u001B[0m\n\u001B[1;32m 996\u001B[0m \u001B[38;5;250m\u001B[39m\u001B[38;5;124;03m\"\"\"Support explicit indexing by delegating to a raw indexing method.\u001B[39;00m\n\u001B[1;32m 997\u001B[0m \n\u001B[1;32m 998\u001B[0m \u001B[38;5;124;03mOuter and/or vectorized indexers are supported by indexing a second time\u001B[39;00m\n\u001B[0;32m (...)\u001B[0m\n\u001B[1;32m 1015\u001B[0m \u001B[38;5;124;03mIndexing result, in the form of a duck numpy-array.\u001B[39;00m\n\u001B[1;32m 1016\u001B[0m \u001B[38;5;124;03m\"\"\"\u001B[39;00m\n\u001B[1;32m 1017\u001B[0m raw_key, numpy_indices \u001B[38;5;241m=\u001B[39m decompose_indexer(key, shape, indexing_support)\n\u001B[0;32m-> 1018\u001B[0m result \u001B[38;5;241m=\u001B[39m \u001B[43mraw_indexing_method\u001B[49m\u001B[43m(\u001B[49m\u001B[43mraw_key\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mtuple\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 1019\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m numpy_indices\u001B[38;5;241m.\u001B[39mtuple:\n\u001B[1;32m 1020\u001B[0m \u001B[38;5;66;03m# index the loaded np.ndarray\u001B[39;00m\n\u001B[1;32m 1021\u001B[0m indexable \u001B[38;5;241m=\u001B[39m NumpyIndexingAdapter(result)\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/backends/zarr.py:216\u001B[0m, in \u001B[0;36mZarrArrayWrapper._getitem\u001B[0;34m(self, key)\u001B[0m\n\u001B[1;32m 215\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21m_getitem\u001B[39m(\u001B[38;5;28mself\u001B[39m, key):\n\u001B[0;32m--> 216\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_array\u001B[49m\u001B[43m[\u001B[49m\u001B[43mkey\u001B[49m\u001B[43m]\u001B[49m\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/zarr/core.py:795\u001B[0m, in \u001B[0;36mArray.__getitem__\u001B[0;34m(self, selection)\u001B[0m\n\u001B[1;32m 793\u001B[0m result \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mvindex[selection]\n\u001B[1;32m 794\u001B[0m \u001B[38;5;28;01melif\u001B[39;00m is_pure_orthogonal_indexing(pure_selection, \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mndim):\n\u001B[0;32m--> 795\u001B[0m result \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mget_orthogonal_selection\u001B[49m\u001B[43m(\u001B[49m\u001B[43mpure_selection\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mfields\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mfields\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 796\u001B[0m \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[1;32m 797\u001B[0m result \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mget_basic_selection(pure_selection, fields\u001B[38;5;241m=\u001B[39mfields)\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/zarr/core.py:1077\u001B[0m, in \u001B[0;36mArray.get_orthogonal_selection\u001B[0;34m(self, selection, out, fields)\u001B[0m\n\u001B[1;32m 1074\u001B[0m \u001B[38;5;66;03m# setup indexer\u001B[39;00m\n\u001B[1;32m 1075\u001B[0m indexer \u001B[38;5;241m=\u001B[39m OrthogonalIndexer(selection, \u001B[38;5;28mself\u001B[39m)\n\u001B[0;32m-> 1077\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_get_selection\u001B[49m\u001B[43m(\u001B[49m\u001B[43mindexer\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mindexer\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mout\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mout\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mfields\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mfields\u001B[49m\u001B[43m)\u001B[49m\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/zarr/core.py:1340\u001B[0m, in \u001B[0;36mArray._get_selection\u001B[0;34m(self, indexer, out, fields)\u001B[0m\n\u001B[1;32m 1337\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m math\u001B[38;5;241m.\u001B[39mprod(out_shape) \u001B[38;5;241m>\u001B[39m \u001B[38;5;241m0\u001B[39m:\n\u001B[1;32m 1338\u001B[0m \u001B[38;5;66;03m# allow storage to get multiple items at once\u001B[39;00m\n\u001B[1;32m 1339\u001B[0m lchunk_coords, lchunk_selection, lout_selection \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mzip\u001B[39m(\u001B[38;5;241m*\u001B[39mindexer)\n\u001B[0;32m-> 1340\u001B[0m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_chunk_getitems\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m 1341\u001B[0m \u001B[43m \u001B[49m\u001B[43mlchunk_coords\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 1342\u001B[0m \u001B[43m \u001B[49m\u001B[43mlchunk_selection\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 1343\u001B[0m \u001B[43m \u001B[49m\u001B[43mout\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 1344\u001B[0m \u001B[43m \u001B[49m\u001B[43mlout_selection\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 1345\u001B[0m \u001B[43m \u001B[49m\u001B[43mdrop_axes\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mindexer\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mdrop_axes\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 1346\u001B[0m \u001B[43m \u001B[49m\u001B[43mfields\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mfields\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 1347\u001B[0m \u001B[43m \u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 1348\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m out\u001B[38;5;241m.\u001B[39mshape:\n\u001B[1;32m 1349\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m out\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/zarr/core.py:2181\u001B[0m, in \u001B[0;36mArray._chunk_getitems\u001B[0;34m(self, lchunk_coords, lchunk_selection, out, lout_selection, drop_axes, fields)\u001B[0m\n\u001B[1;32m 2179\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;129;01mnot\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_meta_array, np\u001B[38;5;241m.\u001B[39mndarray):\n\u001B[1;32m 2180\u001B[0m contexts \u001B[38;5;241m=\u001B[39m ConstantMap(ckeys, constant\u001B[38;5;241m=\u001B[39mContext(meta_array\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_meta_array))\n\u001B[0;32m-> 2181\u001B[0m cdatas \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mchunk_store\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mgetitems\u001B[49m\u001B[43m(\u001B[49m\u001B[43mckeys\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mcontexts\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mcontexts\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 2183\u001B[0m \u001B[38;5;28;01mfor\u001B[39;00m ckey, chunk_select, out_select \u001B[38;5;129;01min\u001B[39;00m \u001B[38;5;28mzip\u001B[39m(ckeys, lchunk_selection, lout_selection):\n\u001B[1;32m 2184\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m ckey \u001B[38;5;129;01min\u001B[39;00m cdatas:\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/zarr/storage.py:1435\u001B[0m, in \u001B[0;36mFSStore.getitems\u001B[0;34m(self, keys, contexts)\u001B[0m\n\u001B[1;32m 1432\u001B[0m \u001B[38;5;28;01mcontinue\u001B[39;00m\n\u001B[1;32m 1433\u001B[0m \u001B[38;5;28;01melif\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(v, \u001B[38;5;167;01mException\u001B[39;00m):\n\u001B[1;32m 1434\u001B[0m \u001B[38;5;66;03m# Raise any other exception\u001B[39;00m\n\u001B[0;32m-> 1435\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m v\n\u001B[1;32m 1436\u001B[0m \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[1;32m 1437\u001B[0m \u001B[38;5;66;03m# The function calling this method may not recognize the transformed\u001B[39;00m\n\u001B[1;32m 1438\u001B[0m \u001B[38;5;66;03m# keys, so we send the values returned by self.map.getitems back into\u001B[39;00m\n\u001B[1;32m 1439\u001B[0m \u001B[38;5;66;03m# the original key space.\u001B[39;00m\n\u001B[1;32m 1440\u001B[0m results[keys_transformed[k]] \u001B[38;5;241m=\u001B[39m v\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/adlfs/spec.py:1506\u001B[0m, in \u001B[0;36mAzureBlobFileSystem.cat\u001B[0;34m(self, path, recursive, on_error, **kwargs)\u001B[0m\n\u001B[1;32m 1504\u001B[0m \u001B[38;5;28;01mfor\u001B[39;00m path \u001B[38;5;129;01min\u001B[39;00m paths:\n\u001B[1;32m 1505\u001B[0m \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[0;32m-> 1506\u001B[0m out[path] \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mcat_file\u001B[49m\u001B[43m(\u001B[49m\u001B[43mpath\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mkwargs\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 1507\u001B[0m \u001B[38;5;28;01mexcept\u001B[39;00m \u001B[38;5;167;01mException\u001B[39;00m \u001B[38;5;28;01mas\u001B[39;00m e:\n\u001B[1;32m 1508\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m on_error \u001B[38;5;241m==\u001B[39m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mraise\u001B[39m\u001B[38;5;124m\"\u001B[39m:\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/fsspec/asyn.py:118\u001B[0m, in \u001B[0;36msync_wrapper..wrapper\u001B[0;34m(*args, **kwargs)\u001B[0m\n\u001B[1;32m 115\u001B[0m \u001B[38;5;129m@functools\u001B[39m\u001B[38;5;241m.\u001B[39mwraps(func)\n\u001B[1;32m 116\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21mwrapper\u001B[39m(\u001B[38;5;241m*\u001B[39margs, \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39mkwargs):\n\u001B[1;32m 117\u001B[0m \u001B[38;5;28mself\u001B[39m \u001B[38;5;241m=\u001B[39m obj \u001B[38;5;129;01mor\u001B[39;00m args[\u001B[38;5;241m0\u001B[39m]\n\u001B[0;32m--> 118\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[43msync\u001B[49m\u001B[43m(\u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mloop\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mfunc\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43margs\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mkwargs\u001B[49m\u001B[43m)\u001B[49m\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/fsspec/asyn.py:103\u001B[0m, in \u001B[0;36msync\u001B[0;34m(loop, func, timeout, *args, **kwargs)\u001B[0m\n\u001B[1;32m 101\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m FSTimeoutError \u001B[38;5;28;01mfrom\u001B[39;00m \u001B[38;5;21;01mreturn_result\u001B[39;00m\n\u001B[1;32m 102\u001B[0m \u001B[38;5;28;01melif\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(return_result, \u001B[38;5;167;01mBaseException\u001B[39;00m):\n\u001B[0;32m--> 103\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m return_result\n\u001B[1;32m 104\u001B[0m \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[1;32m 105\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m return_result\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/fsspec/asyn.py:56\u001B[0m, in \u001B[0;36m_runner\u001B[0;34m(event, coro, result, timeout)\u001B[0m\n\u001B[1;32m 54\u001B[0m coro \u001B[38;5;241m=\u001B[39m asyncio\u001B[38;5;241m.\u001B[39mwait_for(coro, timeout\u001B[38;5;241m=\u001B[39mtimeout)\n\u001B[1;32m 55\u001B[0m \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[0;32m---> 56\u001B[0m result[\u001B[38;5;241m0\u001B[39m] \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;01mawait\u001B[39;00m coro\n\u001B[1;32m 57\u001B[0m \u001B[38;5;28;01mexcept\u001B[39;00m \u001B[38;5;167;01mException\u001B[39;00m \u001B[38;5;28;01mas\u001B[39;00m ex:\n\u001B[1;32m 58\u001B[0m result[\u001B[38;5;241m0\u001B[39m] \u001B[38;5;241m=\u001B[39m ex\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/adlfs/spec.py:1466\u001B[0m, in \u001B[0;36mAzureBlobFileSystem._cat_file\u001B[0;34m(self, path, start, end, max_concurrency, **kwargs)\u001B[0m\n\u001B[1;32m 1462\u001B[0m \u001B[38;5;28;01masync\u001B[39;00m \u001B[38;5;28;01mwith\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mservice_client\u001B[38;5;241m.\u001B[39mget_blob_client(\n\u001B[1;32m 1463\u001B[0m container\u001B[38;5;241m=\u001B[39mcontainer_name, blob\u001B[38;5;241m=\u001B[39mblob\n\u001B[1;32m 1464\u001B[0m ) \u001B[38;5;28;01mas\u001B[39;00m bc:\n\u001B[1;32m 1465\u001B[0m \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[0;32m-> 1466\u001B[0m stream \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;01mawait\u001B[39;00m bc\u001B[38;5;241m.\u001B[39mdownload_blob(\n\u001B[1;32m 1467\u001B[0m offset\u001B[38;5;241m=\u001B[39mstart,\n\u001B[1;32m 1468\u001B[0m length\u001B[38;5;241m=\u001B[39mlength,\n\u001B[1;32m 1469\u001B[0m version_id\u001B[38;5;241m=\u001B[39mversion_id,\n\u001B[1;32m 1470\u001B[0m max_concurrency\u001B[38;5;241m=\u001B[39mmax_concurrency \u001B[38;5;129;01mor\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mmax_concurrency,\n\u001B[1;32m 1471\u001B[0m \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39m\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_timeout_kwargs,\n\u001B[1;32m 1472\u001B[0m )\n\u001B[1;32m 1473\u001B[0m \u001B[38;5;28;01mexcept\u001B[39;00m ResourceNotFoundError \u001B[38;5;28;01mas\u001B[39;00m e:\n\u001B[1;32m 1474\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m \u001B[38;5;167;01mFileNotFoundError\u001B[39;00m(\n\u001B[1;32m 1475\u001B[0m errno\u001B[38;5;241m.\u001B[39mENOENT, os\u001B[38;5;241m.\u001B[39mstrerror(errno\u001B[38;5;241m.\u001B[39mENOENT), path\n\u001B[1;32m 1476\u001B[0m ) \u001B[38;5;28;01mfrom\u001B[39;00m \u001B[38;5;21;01me\u001B[39;00m\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/core/tracing/decorator_async.py:114\u001B[0m, in \u001B[0;36mdistributed_trace_async..decorator..wrapper_use_tracer\u001B[0;34m(*args, **kwargs)\u001B[0m\n\u001B[1;32m 112\u001B[0m span_impl_type \u001B[38;5;241m=\u001B[39m settings\u001B[38;5;241m.\u001B[39mtracing_implementation()\n\u001B[1;32m 113\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m span_impl_type \u001B[38;5;129;01mis\u001B[39;00m \u001B[38;5;28;01mNone\u001B[39;00m:\n\u001B[0;32m--> 114\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28;01mawait\u001B[39;00m func(\u001B[38;5;241m*\u001B[39margs, \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39mkwargs)\n\u001B[1;32m 116\u001B[0m \u001B[38;5;66;03m# Merge span is parameter is set, but only if no explicit parent are passed\u001B[39;00m\n\u001B[1;32m 117\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m merge_span \u001B[38;5;129;01mand\u001B[39;00m \u001B[38;5;129;01mnot\u001B[39;00m passed_in_parent:\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_blob_client_async.py:746\u001B[0m, in \u001B[0;36mBlobClient.download_blob\u001B[0;34m(self, offset, length, encoding, **kwargs)\u001B[0m\n\u001B[1;32m 728\u001B[0m options \u001B[38;5;241m=\u001B[39m _download_blob_options(\n\u001B[1;32m 729\u001B[0m blob_name\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mblob_name,\n\u001B[1;32m 730\u001B[0m container_name\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mcontainer_name,\n\u001B[0;32m (...)\u001B[0m\n\u001B[1;32m 743\u001B[0m client\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_client,\n\u001B[1;32m 744\u001B[0m \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39mkwargs)\n\u001B[1;32m 745\u001B[0m downloader \u001B[38;5;241m=\u001B[39m StorageStreamDownloader(\u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39moptions)\n\u001B[0;32m--> 746\u001B[0m \u001B[38;5;28;01mawait\u001B[39;00m downloader\u001B[38;5;241m.\u001B[39m_setup() \u001B[38;5;66;03m# pylint: disable=protected-access\u001B[39;00m\n\u001B[1;32m 747\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m downloader\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py:328\u001B[0m, in \u001B[0;36mStorageStreamDownloader._setup\u001B[0;34m(self)\u001B[0m\n\u001B[1;32m 319\u001B[0m \u001B[38;5;66;03m# pylint: disable-next=attribute-defined-outside-init\u001B[39;00m\n\u001B[1;32m 320\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_initial_range, \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_initial_offset \u001B[38;5;241m=\u001B[39m process_range_and_offset(\n\u001B[1;32m 321\u001B[0m initial_request_start,\n\u001B[1;32m 322\u001B[0m initial_request_end,\n\u001B[0;32m (...)\u001B[0m\n\u001B[1;32m 325\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_encryption_data\n\u001B[1;32m 326\u001B[0m )\n\u001B[0;32m--> 328\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_response \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;01mawait\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_initial_request()\n\u001B[1;32m 329\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mproperties \u001B[38;5;241m=\u001B[39m cast(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mBlobProperties\u001B[39m\u001B[38;5;124m\"\u001B[39m, \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_response\u001B[38;5;241m.\u001B[39mproperties) \u001B[38;5;66;03m# type: ignore [attr-defined]\u001B[39;00m\n\u001B[1;32m 330\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mproperties\u001B[38;5;241m.\u001B[39mname \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mname\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py:410\u001B[0m, in \u001B[0;36mStorageStreamDownloader._initial_request\u001B[0;34m(self)\u001B[0m\n\u001B[1;32m 408\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_file_size \u001B[38;5;241m=\u001B[39m \u001B[38;5;241m0\u001B[39m\n\u001B[1;32m 409\u001B[0m \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[0;32m--> 410\u001B[0m \u001B[43mprocess_storage_error\u001B[49m\u001B[43m(\u001B[49m\u001B[43merror\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 412\u001B[0m \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[1;32m 413\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39msize \u001B[38;5;241m==\u001B[39m \u001B[38;5;241m0\u001B[39m:\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/_shared/response_handlers.py:186\u001B[0m, in \u001B[0;36mprocess_storage_error\u001B[0;34m(storage_error)\u001B[0m\n\u001B[1;32m 183\u001B[0m error\u001B[38;5;241m.\u001B[39margs \u001B[38;5;241m=\u001B[39m (error\u001B[38;5;241m.\u001B[39mmessage,)\n\u001B[1;32m 184\u001B[0m \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[1;32m 185\u001B[0m \u001B[38;5;66;03m# `from None` prevents us from double printing the exception (suppresses generated layer error context)\u001B[39;00m\n\u001B[0;32m--> 186\u001B[0m exec(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mraise error from None\u001B[39m\u001B[38;5;124m\"\u001B[39m) \u001B[38;5;66;03m# pylint: disable=exec-used # nosec\u001B[39;00m\n\u001B[1;32m 187\u001B[0m \u001B[38;5;28;01mexcept\u001B[39;00m \u001B[38;5;167;01mSyntaxError\u001B[39;00m \u001B[38;5;28;01mas\u001B[39;00m exc:\n\u001B[1;32m 188\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m error \u001B[38;5;28;01mfrom\u001B[39;00m \u001B[38;5;21;01mexc\u001B[39;00m\n", + "File \u001B[0;32m:1\u001B[0m\n", + "\u001B[0;31mClientAuthenticationError\u001B[0m: Server failed to authenticate the request. Make sure the value of Authorization header is formed correctly including the signature.\nRequestId:356fa9fc-a01e-0046-0fbb-5da77d000000\nTime:2025-01-03T08:44:03.5582125Z\nErrorCode:AuthenticationFailed\nauthenticationerrordetail:Signature not valid in the specified time frame: Start [Wed, 01 Jan 2025 21:42:40 GMT] - Expiry [Thu, 02 Jan 2025 22:27:40 GMT] - Current [Fri, 03 Jan 2025 08:44:03 GMT]\nContent: AuthenticationFailedServer failed to authenticate the request. Make sure the value of Authorization header is formed correctly including the signature.\nRequestId:356fa9fc-a01e-0046-0fbb-5da77d000000\nTime:2025-01-03T08:44:03.5582125ZSignature not valid in the specified time frame: Start [Wed, 01 Jan 2025 21:42:40 GMT] - Expiry [Thu, 02 Jan 2025 22:27:40 GMT] - Current [Fri, 03 Jan 2025 08:44:03 GMT]" + ] + } + ], + "execution_count": 7 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Now find overall lowest/median/highest for model ensemble", + "id": "f303bfb90133f238" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "# Combine with grids for facilities", + "id": "63aeda9cecaef726" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-03T09:24:55.643333Z", + "start_time": "2025-01-03T09:24:55.442582Z" + } + }, + "cell_type": "code", + "source": [ + "ANC = True\n", + "Inpatient = False\n", + "multiplier = 1 # no need for multiplier \n", + "years = range(2025, 2071) # final date is 1st Jan 2100\n", + "month_lengths = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] * len(years)\n", + "window_size = 5\n", + "\n", + "if ANC:\n", + " reporting_data = pd.read_csv(\n", + " \"/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_ANC_by_smaller_facility_lm.csv\")\n", + "elif Inpatient:\n", + " reporting_data = pd.read_csv(\n", + " \"/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_Inpatient_by_smaller_facility_lm.csv\")\n", + "general_facilities = gpd.read_file(\"/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_districts.shp\")\n", + "\n", + "facilities_with_lat_long = pd.read_csv(\n", + " \"/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_lat_long_region.csv\")" + ], + "id": "5fa6e3fa0dff003a", + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/4112377517.py:16: DtypeWarning: Columns (58,59,105,127,136,142,149,150,258,285,296,319,344,345,360,393,394,427,428,437,449,450,452,453,461,462,478,479,489,490,492,493,494,497,498,499,500,501,502,503,572,580,585,586,587,588,591,592,593,594,607,608,609,610,619,620,621,622,626,634,872,887,967,978,1066,1510) have mixed types. Specify dtype option on import or set low_memory=False.\n", + " facilities_with_lat_long = pd.read_csv(\n" + ] + } + ], + "execution_count": 20 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-03T09:24:56.355595Z", + "start_time": "2025-01-03T09:24:56.349672Z" + } + }, + "cell_type": "code", + "source": [ + "def unzip_all_in_directory(directory):\n", + " \"\"\"\n", + " Unzips all .zip files in the specified directory, extracting each into a separate folder.\n", + "\n", + " Parameters:\n", + " directory (str): The path to the folder containing the .zip files.\n", + " \"\"\"\n", + " for filename in os.listdir(directory):\n", + " if filename.endswith('.zip'):\n", + " file_path = os.path.join(directory, filename)\n", + " extract_dir = os.path.join(directory, filename[:-4])\n", + " os.makedirs(extract_dir, exist_ok=True)\n", + "\n", + " try:\n", + " with zipfile.ZipFile(file_path, 'r') as zip_ref:\n", + " zip_ref.extractall(extract_dir)\n", + " except zipfile.BadZipFile:\n", + " print(f\"Skipped {filename}: not a valid zip file.\")\n", + "\n", + "def get_facility_lat_long(reporting_facility, facilities_df, cutoff=0.90, n_matches=3):\n", + " \"\"\"\n", + " Function to find the closest matching facility name and return its latitude and longitude.\n", + "\n", + " Parameters:\n", + " - reporting_facility: The facility name for which latitude and longitude are needed.\n", + " - facilities_df : DataFrame containing facility names ('Fname') and their corresponding latitudes ('A109__Latitude') and longitudes ('A109__Longitude').\n", + " - cutoff: The minimum similarity score for a match. Default is 0.90.\n", + " - n_matches: The maximum number of matches to consider. Default is 3.\n", + "\n", + " Returns: match_name, lat_for_facility, long_for_facility\n", + "\n", + " \"\"\"\n", + " matching_facility_name = difflib.get_close_matches(reporting_facility, facilities_df['Fname'], n=n_matches,\n", + " cutoff=cutoff)\n", + "\n", + " if matching_facility_name:\n", + " match_name = matching_facility_name[0] # Access the string directly\n", + " lat_for_facility = facilities_df.loc[facilities_df['Fname'] == match_name, \"A109__Latitude\"].iloc[0]\n", + " long_for_facility = facilities_df.loc[facilities_df['Fname'] == match_name, \"A109__Longitude\"].iloc[0]\n", + " return match_name, lat_for_facility, long_for_facility\n", + " else:\n", + " return np.nan, np.nan, np.nan\n", + "\n", + "def extract_nc_files_from_unzipped_folders(directory):\n", + " \"\"\"\n", + " Searches for .nc files in the specified directory and all its subfolders,\n", + " and copies them to the output directory, maintaining the folder structure.\n", + "\n", + " Parameters:\n", + " directory (str): The path to the folder containing the unzipped folders.\n", + " \"\"\"\n", + " output_directory = os.path.join(directory, 'nc_files')\n", + " if not os.path.exists(output_directory):\n", + " os.makedirs(output_directory)\n", + "\n", + " for root, _, files in os.walk(directory):\n", + " # Skip the output directory to prevent recursive copying\n", + " if root == output_directory:\n", + " continue\n", + "\n", + " for filename in files:\n", + " if filename.endswith('.nc'):\n", + " source_file_path = os.path.join(root, filename)\n", + " destination_file_path = os.path.join(output_directory, filename)\n", + "\n", + " # Only copy if the file does not already exist in the output directory\n", + " if not os.path.exists(destination_file_path):\n", + " shutil.copy2(source_file_path, output_directory)" + ], + "id": "a9a92aa8bbb6b45a", + "outputs": [], + "execution_count": 21 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-03T09:28:36.461864Z", + "start_time": "2025-01-03T09:28:22.793075Z" + } + }, + "cell_type": "code", + "source": [ + "base_dir = \"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/\"\n", + "nc_file_directory = os.path.join(base_dir, 'nc_files')\n", + "# NB these are daily \n", + "scenarios = [\"ssp245\", \"ssp585\"] # don't have ssp19 scenario\n", + "\n", + "data_by_model_and_grid = {}\n", + "for scenario in scenarios:\n", + " print(scenario)\n", + " scenario_directory = os.path.join(base_dir, scenario)\n", + "\n", + " grid_centroids = {}\n", + " cumulative_sum_by_models = {}\n", + " file_path_downscaled = f\"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/CIL_subsetted_all_model_{scenario}.nc\"\n", + " data_all_models = xr.open_dataset(file_path_downscaled)\n", + " \n", + " ## Get models of interest - min, med, max\n", + " # Assuming 'pr' is the variable representing precipitation in the dataset\n", + " pr_aggregated = data_all_models.mean(dim=[\"lat\", \"lon\", \"time\"]) # Work with the 'pr' DataArray \n", + "\n", + " # Find the model with the lowest value\n", + " min_model_object = pr_aggregated['pr'].idxmin(dim=\"model\")\n", + " min_model = min_model_object.values.item()\n", + " \n", + " median_value = pr_aggregated['pr'].median(dim=\"model\").values.item()\n", + " # Find the model with the median value\n", + " sorted_models = pr_aggregated.sortby(\"model\")\n", + " n_models = len(pr_aggregated.model)\n", + " median_index = n_models // 2\n", + " median_model_object = sorted_models[\"model\"][median_index]\n", + " median_model = median_model_object.values.item()\n", + " \n", + " # Find the model with the highest value\n", + " max_model_object = pr_aggregated['pr'].idxmax(dim=\"model\")\n", + " max_model = max_model_object.values.item()\n", + "\n", + " models_of_interest = [min_model, median_model, max_model]\n", + " print(\"Models of interest\", models_of_interest)\n", + " # see which facilities have reporting data and data on latitude and longitude\n", + " weather_df_lowest_window = pd.DataFrame()\n", + " weather_df_median_window = pd.DataFrame()\n", + " weather_df_highest_window = pd.DataFrame()\n", + " \n", + " weather_df_lowest_monthly = pd.DataFrame()\n", + " weather_df_median_monthly = pd.DataFrame()\n", + " weather_df_highest_monthly = pd.DataFrame()\n", + " for model in models_of_interest:\n", + " data_per_model = data_all_models.sel(model=model)\n", + " pr_data = data_per_model.variables['pr'][:] # in kg m-2 s-1 = mm s-1 x 86400 to get to day\n", + " lat_data = data_per_model.variables['lat'][:]\n", + " lon_data = data_per_model.variables['lon'][:]\n", + " lon_grid, lat_grid = np.meshgrid(lon_data, lat_data)\n", + " centroids = np.column_stack((lat_grid.ravel(), lon_grid.ravel()))\n", + "\n", + " # Store centroids\n", + " grid_centroids[model] = centroids\n", + " grid_dictionary = {}\n", + " grid = 0\n", + " for i in lat_data:\n", + " for j in lon_data:\n", + " precip_data_for_grid = data_per_model.sel(lat=i, lon=j, method=\"nearest\") # across all time points\n", + " grid_dictionary[grid] = precip_data_for_grid.pr.data\n", + " grid += 1\n", + " data_by_model_and_grid[model] = grid_dictionary\n", + "\n", + " for reporting_facility in reporting_data.columns:\n", + " print(reporting_facility)\n", + " grid_precipitation_for_facility = {}\n", + " match_name, lat_for_facility, long_for_facility = get_facility_lat_long(reporting_facility, facilities_with_lat_long)\n", + " if not np.isnan(long_for_facility) and not np.isnan(lat_for_facility):\n", + " facility_location = np.array([lat_for_facility, long_for_facility])\n", + " kd_trees_by_model = {}\n", + " \n", + " # Loop over each model of interest\n", + " for model in models_of_interest:\n", + " centroids = grid_centroids[model]\n", + " kd_tree = KDTree(centroids)\n", + " distance, closest_grid_index = kd_tree.query(facility_location)\n", + " grid_precipitation_for_facility[model] = data_by_model_and_grid[model][closest_grid_index].data\n", + " \n", + " cumulative_sum_monthly = []\n", + " cumulative_sum_window = []\n", + " \n", + " begin_day = 0\n", + " # Calculate monthly cumulative sums\n", + " for month_idx, month_length in enumerate(month_lengths):\n", + " days_for_grid_monthly = grid_precipitation_for_facility[model][begin_day:begin_day + month_length]\n", + " cumulative_sums_monthly = [\n", + " sum(days_for_grid_monthly)\n", + " ]\n", + " max_cumulative_sums_monthly = max(cumulative_sums_monthly)\n", + " cumulative_sum_monthly.append(max_cumulative_sums_monthly)\n", + " begin_day += month_length\n", + " \n", + " begin_day = 0\n", + " # Calculate windowed cumulative sums\n", + " for month_idx, month_length in enumerate(month_lengths):\n", + " days_for_grid_window = grid_precipitation_for_facility[model][begin_day:begin_day + month_length]\n", + " \n", + " cumulative_sums_window = [\n", + " sum(days_for_grid_window[day:day + window_size])\n", + " for day in range(month_length - window_size + 1)\n", + " ]\n", + " \n", + " max_cumulative_sums_window = max(cumulative_sums_window)\n", + " cumulative_sum_window.append(max_cumulative_sums_window)\n", + " begin_day += month_length\n", + " \n", + " # Assign the calculated data to the correct dataframe based on the model\n", + " if model == min_model:\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + " elif model == median_model:\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + " elif model == max_model:\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + " \n", + " if ANC:\n", + " weather_df_lowest_window.to_csv(Path(scenario_directory) / f\"lowest_model_daily_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{scenario}.csv\", index=False)\n", + " weather_df_median_window.to_csv(Path(scenario_directory) / f\"median_model_daily_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{scenario}.csv\", index=False)\n", + " weather_df_highest_window.to_csv(Path(scenario_directory) / f\"highest_model_daily_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{scenario}.csv\", index=False)\n", + " \n", + " weather_df_lowest_monthly.to_csv(Path(scenario_directory) / f\"lowest_model_monthly_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{scenario}.csv\", index=False)\n", + " weather_df_median_monthly.to_csv(Path(scenario_directory) / f\"median_model_monthly_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{scenario}.csv\", index=False)\n", + " weather_df_highest_monthly.to_csv(Path(scenario_directory) / f\"highest_model_monthly_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{scenario}.csv\", index=False)\n" + ], + "id": "8a6e7f822720bd39", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ssp245\n", + "Models of interest ['HadGEM3-GC31-LL', 'GFDL-CM4', 'MIROC-ES2L']\n", + "date\n", + "Akasale Pvt Clinic\n", + "Area 30 Police Clinic\n", + "Balaka District Hospital\n", + "Bangwe Health Centre\n", + "Benga Health Centre\n", + "Bilira Health Centre\n", + "Bolero Rural Hospital\n", + "Bondo Health Centre\n", + "Bula Health Centre\n", + "Bulala Health Centre\n", + "Bvumbwe Health Centre\n", + "Bwanje Health Centre\n", + "Chadza Health Centre\n", + "Chakhaza Health Centre\n", + "Chamama Health Centre\n", + "Chambe Health Centre\n", + "Chang'ambika Health Centre\n", + "Chapananga Health Centre\n", + "Chifunga Health Centre\n", + "Chikande Health Centre\n", + "Chikole Dispensary\n", + "Chikuse Health Centre\n", + "Chikwawa District Hospital\n", + "Chikweo Health Centre\n", + "Chikwina Health Centre\n", + "Chileka Health Centre\n", + "Chileka Sda Health Centre\n", + "Chilonga Health Centre\n", + "Chilumba Rural Hospital\n", + "Chimatiro Health Centre\n", + "Chimbalanga Health Centre\n", + "Chimoto Health Centre\n", + "Chingale Health Centre\n", + "Chingazi Health Centre\n", + "Chintheche Rural Hospital\n", + "Chinyama Health Centre\n", + "Chioshya Health Centre\n", + "Chipho Health Centre\n", + "Chipoka Health Centre\n", + "Chiradzulu District Hospital\n", + "Chiringa Health Centre\n", + "Chiringa Maternity\n", + "Chisala Health Centre\n", + "Chisepo Health Centre\n", + "Chisi Health Centre\n", + "Chisimuka Health Centre\n", + "Chisitu Health Centre\n", + "Chitala Health Centre\n", + "Chitekesa Health Centre\n", + "Chitera Health Centre\n", + "Chitheka Health Centre\n", + "Chitimba Health Centre\n", + "Chitipa District Hospital\n", + "Chitowo Health Centre\n", + "Chiwamba Health Centre\n", + "Chiwe Health Centre\n", + "Choma Health Centre\n", + "City Clinic Zomba\n", + "Dedza District Hospital\n", + "Diamphwe Health Centre\n", + "Dickson Health Centre\n", + "Domasi Rural Hospital\n", + "Dr David Livingstone Memorial Clinic\n", + "Dwambazi Rural Hospital\n", + "Dzenje Health Centre\n", + "Dzenza Health Centre\n", + "Dziwe Health Centre\n", + "Emsizini Health Centre\n", + "Endindeni Health Centre\n", + "Engucwini Health Centre\n", + "Euthini Rural Hospital\n", + "Fulirwa Health Centre\n", + "Gaga Health Centre\n", + "Ganya Health Centre\n", + "Hora Health Centre\n", + "Ifumbo Health Centre\n", + "Jalasi Health Centre\n", + "Jalawe Health Centre\n", + "Jenda Health Centre\n", + "Kabudula Rural Hospital\n", + "Kabuwa Health Centre\n", + "Kabwafu Health Centre\n", + "Kachere Clinic\n", + "Kachere Health Centre\n", + "Kafele Health Centre\n", + "Kaigwazanga Health Centre\n", + "Kakoma Health Centre\n", + "Kalemba Health Centre\n", + "Kalembo Health Centre\n", + "Kalimanjira Health Centre\n", + "Kalinde Health Centre\n", + "Kalulu Health Centre\n", + "Kaluluma Rural Hospital\n", + "Kambenje Health Centre\n", + "Kamboni Health Centre\n", + "Kameme Health Centre\n", + "Kamsonga Health Centre\n", + "Kamteteka Health Centre\n", + "Kamwe Health Centre\n", + "Kande Health Centre\n", + "Kandeu Health Centre\n", + "Kangolwa Health Centre\n", + "Kanyama Health Centre\n", + "Kanyezi Health Centre\n", + "Kapanga Health Centre\n", + "Kapelula Health Centre\n", + "Kapenda Health Centre\n", + "Kapeni Health Centre\n", + "Kaphuka Health Centre\n", + "Kapire Health Centre\n", + "Kaporo Rural Hospital\n", + "Karonga District Hospital\n", + "Kaseye Mission Hospital\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kasina Health Centre\n", + "Kasinje Health Centre\n", + "Kasoba Health Centre\n", + "Kasungu District Hospital\n", + "Katchale Health Centre\n", + "Katimbila Health Centre\n", + "Katowo Rural Hospital\n", + "Katsekera Health Centre\n", + "Katuli Health Centre\n", + "Kaundu Health Centre\n", + "Kavuzi Health Centre\n", + "Kawamba Health Centre\n", + "Kaweche Health Centre\n", + "Kawinga Dispensary\n", + "Kayembe Health Centre\n", + "Khanda Health Centre\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Khola Health Centre\n", + "Khondowe Health Centre\n", + "Khosolo Health Centre\n", + "Khuwi Health Centre\n", + "Khuyukuyu Health Centre\n", + "Kochilira Rural Hospital\n", + "Kukalanga Dispensary\n", + "Kunenekude Health Centre\n", + "Kwitanda Health Centre\n", + "Lambulira Health Centre\n", + "Lemwe Health Centre\n", + "Lilongwe City Assembly Chinsapo\n", + "Limbe Health Centre\n", + "Lirangwe Health Centre\n", + "Liuzi Health Centre\n", + "Livwezi Health Centre\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Liwonde Medical Clinic\n", + "Lizulu Health Centre\n", + "Lobi Health Centre\n", + "Lulwe Health Centre\n", + "Lundu Health Centre\n", + "Lungwena Health Centre\n", + "Lupembe Health Centre\n", + "Lura Health Centre\n", + "Luwalika Health Centre\n", + "Luwani Health Centre\n", + "Luwawa Health Centre\n", + "Luwerezi Health Centre\n", + "Luzi Health Centre\n", + "Lwazi Health Centre\n", + "M'mambo Heaith Centre\n", + "Mabili Health Centre\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Machinga District Hospital\n", + "Machinjiri Health Centre\n", + "Madziabango Health Centre\n", + "Maganga Health Centre\n", + "Magareta Health Centre\n", + "Makanjira Health Centre\n", + "Makapwa Health Centre\n", + "Makhanga Health Centre\n", + "Makiyoni Health Centre\n", + "Makwapala Health Centre\n", + "Makwasa Estate Clinic\n", + "Malambo Health Centre\n", + "Malembo Health Centre\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Malombe Dispensary\n", + "Malomo Health Centre\n", + "Malukula Health Centre\n", + "Maluwa Health Centre\n", + "Mangamba Health Centre\n", + "Mangochi District Hospital\n", + "Mangunda Health Centre\n", + "Manjawira Health Centre\n", + "Manolo Health Center\n", + "Maonde Health Centre\n", + "Masasa Health Centre\n", + "Masenjere Health Centre\n", + "Matanda Health Centre\n", + "Matapila Health Centre\n", + "Matiki Health Centre\n", + "Matiya Health Centre\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Matuli Health Centre\n", + "Matumba Health Centre\n", + "Maula Health Centre\n", + "Mauwa Health Centre\n", + "Mayaka Health Centre\n", + "Mayani Health Centre\n", + "Mbabvi Health Centre\n", + "Mbalachanda Health Centre\n", + "Mbang'ombe 1 Health Centre\n", + "Mbang'ombe 2 Health Centre\n", + "Mbayani Health Center\n", + "Mbenje Health Centre\n", + "Mbera Health Centre\n", + "Mbingwa Health Centre\n", + "Mbiza Health Centre\n", + "Mchima Clinic\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mchinji District Hospital\n", + "Mchoka Health Centre\n", + "Mdunga Heallth Centre\n", + "Mfera Health Centre\n", + "Mhalaunda Health Centre\n", + "Mhuju Rural Hospital\n", + "Mikolongwe Health Centre\n", + "Mikundi Health Centre\n", + "Milepa Health Centre\n", + "Milonde Health Centre\n", + "Mimosa Dispensary\n", + "Misomali Health Centre (CHAM)\n", + "Misuku Health Centre\n", + "Mkanda Health Centre\n", + "Mkoma Health Centre\n", + "Mkumba Health Centre\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mlanda Health Centre\n", + "Mlangeni Health Centre\n", + "Mlowe Health Centre\n", + "Mnyanja Health Centre\n", + "Monkey-Bay Community Hospital\n", + "Mpala Health Centre\n", + "Mpamba Health Centre\n", + "Mpasa Health Centre\n", + "Mpata Health Centre\n", + "Mpemba Health Centre\n", + "Mpherembe Health Centre\n", + "Mphompha Health Centre\n", + "Mpondasi Health Centre\n", + "Mponela Rural Hospital\n", + "Msenjere Health Centre\n", + "Msese Health Centre\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Msumbe Health Centre\n", + "Mtakataka Health Centre\n", + "Mtende Health Centre\n", + "Mtendere Health Centre\n", + "Mtengowanthenga Hospital\n", + "Mtonda Health Centre\n", + "Mtwalo Health Centre\n", + "Mulanje District Hospital\n", + "Mulomba Health Centre\n", + "Muloza Health Centre\n", + "Mvera Mission Health Centre\n", + "Mwandama Health Centre\n", + "Mwanga Health Centre\n", + "Mwangala Health Centre\n", + "Mwansambo Health Centre\n", + "Mwanza District Hospital\n", + "Mwazisi Health Centre\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mzambazi Rural Hospital\n", + "Mzandu Health Centre\n", + "Mzenga Health Centre\n", + "Mzimba District Hospital\n", + "Mziza Health Centre\n", + "Mzuzu University Clinic\n", + "Naisi Health Centre\n", + "Nalunga Health Centre\n", + "Namadzi Health Centre\n", + "Namalaka Health Centre\n", + "Namandanje Health Centre\n", + "Namanja Health Centre\n", + "Namanolo Health Centre\n", + "Nambazo Health Centre\n", + "Nambuma Health Centre\n", + "Namphungo Health Centre\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Namulenga Health Centre\n", + "Namwera Health Centre\n", + "Nankhwali Health Centre\n", + "Nathenje Health Centre\n", + "Nayuchi Health Centre\n", + "Ndakwela Health Centre\n", + "Ndamera Health Centre\n", + "Ndaula Health Centre\n", + "Neno District Hospital\n", + "Ng'onga Health Centre\n", + "Ngabu Rural Hospital\n", + "Ngala Health Centre\n", + "Ngana Health Centre\n", + "Ngapani Health Centre\n", + "Ngodzi Health Centre\n", + "Ngoni Health Centre\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ngwelero Health Centre\n", + "Nkasala Health Centre\n", + "Nkhata Bay District Hospital\n", + "Nkhotakota District Hospital\n", + "Nkhulambe Health Centre\n", + "Nkhunga Health Centre\n", + "Nkhwazi Health Centre\n", + "Nkomaula Health Centre\n", + "Nkula Health Centre\n", + "Nsanama Health Centre\n", + "Nsanje District Hospital\n", + "Nsiyaludzu Health Centre\n", + "Ntaja Health Centre\n", + "Ntcheu District Hospital\n", + "Ntchisi District Hospital\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Nthalire Health Centre\n", + "Nthungwa Health Centre\n", + "Nyambi Health Centre\n", + "Nyamithuthu Health Centre\n", + "Nyungwe Health Centre\n", + "Nzama Health Centre\n", + "Pensulo Health Centre\n", + "Phalombe Health Centre\n", + "Phirilongwe Health Centre\n", + "Phokera Health Centre\n", + "Raiply Clinic\n", + "Rumphi District Hospital\n", + "Salima District Hospital\n", + "Sankhulani Health Centre\n", + "Sharpe Valley Health Centre\n", + "Somba Health Centre\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sorgin Health Centre\n", + "South Lunzu Health Centre\n", + "Tembwe Health Centre\n", + "Thekerani Rural Hospital\n", + "Thembe Health Centre\n", + "Thomas Health Centre\n", + "Thonje Health Centre\n", + "Thumbwe Health Centre\n", + "Thunduwike Health Centre\n", + "Thyolo District Hospital\n", + "Usisya Health Centre\n", + "Utale 1 Health Centre\n", + "Utale 2 Health Centre\n", + "Wiliro Health Centre\n", + "Wimbe Health Centre\n", + "Zomba Central Prison Clinic\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Zomba Mental Hospital\n", + "ssp585\n", + "Models of interest ['MIROC-ES2L', 'HadGEM3-GC31-LL', 'MIROC6']\n", + "date\n", + "Akasale Pvt Clinic\n", + "Area 30 Police Clinic\n", + "Balaka District Hospital\n", + "Bangwe Health Centre\n", + "Benga Health Centre\n", + "Bilira Health Centre\n", + "Bolero Rural Hospital\n", + "Bondo Health Centre\n", + "Bula Health Centre\n", + "Bulala Health Centre\n", + "Bvumbwe Health Centre\n", + "Bwanje Health Centre\n", + "Chadza Health Centre\n", + "Chakhaza Health Centre\n", + "Chamama Health Centre\n", + "Chambe Health Centre\n", + "Chang'ambika Health Centre\n", + "Chapananga Health Centre\n", + "Chifunga Health Centre\n", + "Chikande Health Centre\n", + "Chikole Dispensary\n", + "Chikuse Health Centre\n", + "Chikwawa District Hospital\n", + "Chikweo Health Centre\n", + "Chikwina Health Centre\n", + "Chileka Health Centre\n", + "Chileka Sda Health Centre\n", + "Chilonga Health Centre\n", + "Chilumba Rural Hospital\n", + "Chimatiro Health Centre\n", + "Chimbalanga Health Centre\n", + "Chimoto Health Centre\n", + "Chingale Health Centre\n", + "Chingazi Health Centre\n", + "Chintheche Rural Hospital\n", + "Chinyama Health Centre\n", + "Chioshya Health Centre\n", + "Chipho Health Centre\n", + "Chipoka Health Centre\n", + "Chiradzulu District Hospital\n", + "Chiringa Health Centre\n", + "Chiringa Maternity\n", + "Chisala Health Centre\n", + "Chisepo Health Centre\n", + "Chisi Health Centre\n", + "Chisimuka Health Centre\n", + "Chisitu Health Centre\n", + "Chitala Health Centre\n", + "Chitekesa Health Centre\n", + "Chitera Health Centre\n", + "Chitheka Health Centre\n", + "Chitimba Health Centre\n", + "Chitipa District Hospital\n", + "Chitowo Health Centre\n", + "Chiwamba Health Centre\n", + "Chiwe Health Centre\n", + "Choma Health Centre\n", + "City Clinic Zomba\n", + "Dedza District Hospital\n", + "Diamphwe Health Centre\n", + "Dickson Health Centre\n", + "Domasi Rural Hospital\n", + "Dr David Livingstone Memorial Clinic\n", + "Dwambazi Rural Hospital\n", + "Dzenje Health Centre\n", + "Dzenza Health Centre\n", + "Dziwe Health Centre\n", + "Emsizini Health Centre\n", + "Endindeni Health Centre\n", + "Engucwini Health Centre\n", + "Euthini Rural Hospital\n", + "Fulirwa Health Centre\n", + "Gaga Health Centre\n", + "Ganya Health Centre\n", + "Hora Health Centre\n", + "Ifumbo Health Centre\n", + "Jalasi Health Centre\n", + "Jalawe Health Centre\n", + "Jenda Health Centre\n", + "Kabudula Rural Hospital\n", + "Kabuwa Health Centre\n", + "Kabwafu Health Centre\n", + "Kachere Clinic\n", + "Kachere Health Centre\n", + "Kafele Health Centre\n", + "Kaigwazanga Health Centre\n", + "Kakoma Health Centre\n", + "Kalemba Health Centre\n", + "Kalembo Health Centre\n", + "Kalimanjira Health Centre\n", + "Kalinde Health Centre\n", + "Kalulu Health Centre\n", + "Kaluluma Rural Hospital\n", + "Kambenje Health Centre\n", + "Kamboni Health Centre\n", + "Kameme Health Centre\n", + "Kamsonga Health Centre\n", + "Kamteteka Health Centre\n", + "Kamwe Health Centre\n", + "Kande Health Centre\n", + "Kandeu Health Centre\n", + "Kangolwa Health Centre\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kanyama Health Centre\n", + "Kanyezi Health Centre\n", + "Kapanga Health Centre\n", + "Kapelula Health Centre\n", + "Kapenda Health Centre\n", + "Kapeni Health Centre\n", + "Kaphuka Health Centre\n", + "Kapire Health Centre\n", + "Kaporo Rural Hospital\n", + "Karonga District Hospital\n", + "Kaseye Mission Hospital\n", + "Kasina Health Centre\n", + "Kasinje Health Centre\n", + "Kasoba Health Centre\n", + "Kasungu District Hospital\n", + "Katchale Health Centre\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Katimbila Health Centre\n", + "Katowo Rural Hospital\n", + "Katsekera Health Centre\n", + "Katuli Health Centre\n", + "Kaundu Health Centre\n", + "Kavuzi Health Centre\n", + "Kawamba Health Centre\n", + "Kaweche Health Centre\n", + "Kawinga Dispensary\n", + "Kayembe Health Centre\n", + "Khanda Health Centre\n", + "Khola Health Centre\n", + "Khondowe Health Centre\n", + "Khosolo Health Centre\n", + "Khuwi Health Centre\n", + "Khuyukuyu Health Centre\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kochilira Rural Hospital\n", + "Kukalanga Dispensary\n", + "Kunenekude Health Centre\n", + "Kwitanda Health Centre\n", + "Lambulira Health Centre\n", + "Lemwe Health Centre\n", + "Lilongwe City Assembly Chinsapo\n", + "Limbe Health Centre\n", + "Lirangwe Health Centre\n", + "Liuzi Health Centre\n", + "Livwezi Health Centre\n", + "Liwonde Medical Clinic\n", + "Lizulu Health Centre\n", + "Lobi Health Centre\n", + "Lulwe Health Centre\n", + "Lundu Health Centre\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Lungwena Health Centre\n", + "Lupembe Health Centre\n", + "Lura Health Centre\n", + "Luwalika Health Centre\n", + "Luwani Health Centre\n", + "Luwawa Health Centre\n", + "Luwerezi Health Centre\n", + "Luzi Health Centre\n", + "Lwazi Health Centre\n", + "M'mambo Heaith Centre\n", + "Mabili Health Centre\n", + "Machinga District Hospital\n", + "Machinjiri Health Centre\n", + "Madziabango Health Centre\n", + "Maganga Health Centre\n", + "Magareta Health Centre\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Makanjira Health Centre\n", + "Makapwa Health Centre\n", + "Makhanga Health Centre\n", + "Makiyoni Health Centre\n", + "Makwapala Health Centre\n", + "Makwasa Estate Clinic\n", + "Malambo Health Centre\n", + "Malembo Health Centre\n", + "Malombe Dispensary\n", + "Malomo Health Centre\n", + "Malukula Health Centre\n", + "Maluwa Health Centre\n", + "Mangamba Health Centre\n", + "Mangochi District Hospital\n", + "Mangunda Health Centre\n", + "Manjawira Health Centre\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Manolo Health Center\n", + "Maonde Health Centre\n", + "Masasa Health Centre\n", + "Masenjere Health Centre\n", + "Matanda Health Centre\n", + "Matapila Health Centre\n", + "Matiki Health Centre\n", + "Matiya Health Centre\n", + "Matuli Health Centre\n", + "Matumba Health Centre\n", + "Maula Health Centre\n", + "Mauwa Health Centre\n", + "Mayaka Health Centre\n", + "Mayani Health Centre\n", + "Mbabvi Health Centre\n", + "Mbalachanda Health Centre\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mbang'ombe 1 Health Centre\n", + "Mbang'ombe 2 Health Centre\n", + "Mbayani Health Center\n", + "Mbenje Health Centre\n", + "Mbera Health Centre\n", + "Mbingwa Health Centre\n", + "Mbiza Health Centre\n", + "Mchima Clinic\n", + "Mchinji District Hospital\n", + "Mchoka Health Centre\n", + "Mdunga Heallth Centre\n", + "Mfera Health Centre\n", + "Mhalaunda Health Centre\n", + "Mhuju Rural Hospital\n", + "Mikolongwe Health Centre\n", + "Mikundi Health Centre\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Milepa Health Centre\n", + "Milonde Health Centre\n", + "Mimosa Dispensary\n", + "Misomali Health Centre (CHAM)\n", + "Misuku Health Centre\n", + "Mkanda Health Centre\n", + "Mkoma Health Centre\n", + "Mkumba Health Centre\n", + "Mlanda Health Centre\n", + "Mlangeni Health Centre\n", + "Mlowe Health Centre\n", + "Mnyanja Health Centre\n", + "Monkey-Bay Community Hospital\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mpala Health Centre\n", + "Mpamba Health Centre\n", + "Mpasa Health Centre\n", + "Mpata Health Centre\n", + "Mpemba Health Centre\n", + "Mpherembe Health Centre\n", + "Mphompha Health Centre\n", + "Mpondasi Health Centre\n", + "Mponela Rural Hospital\n", + "Msenjere Health Centre\n", + "Msese Health Centre\n", + "Msumbe Health Centre\n", + "Mtakataka Health Centre\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mtende Health Centre\n", + "Mtendere Health Centre\n", + "Mtengowanthenga Hospital\n", + "Mtonda Health Centre\n", + "Mtwalo Health Centre\n", + "Mulanje District Hospital\n", + "Mulomba Health Centre\n", + "Muloza Health Centre\n", + "Mvera Mission Health Centre\n", + "Mwandama Health Centre\n", + "Mwanga Health Centre\n", + "Mwangala Health Centre\n", + "Mwansambo Health Centre\n", + "Mwanza District Hospital\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mwazisi Health Centre\n", + "Mzambazi Rural Hospital\n", + "Mzandu Health Centre\n", + "Mzenga Health Centre\n", + "Mzimba District Hospital\n", + "Mziza Health Centre\n", + "Mzuzu University Clinic\n", + "Naisi Health Centre\n", + "Nalunga Health Centre\n", + "Namadzi Health Centre\n", + "Namalaka Health Centre\n", + "Namandanje Health Centre\n", + "Namanja Health Centre\n", + "Namanolo Health Centre\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Nambazo Health Centre\n", + "Nambuma Health Centre\n", + "Namphungo Health Centre\n", + "Namulenga Health Centre\n", + "Namwera Health Centre\n", + "Nankhwali Health Centre\n", + "Nathenje Health Centre\n", + "Nayuchi Health Centre\n", + "Ndakwela Health Centre\n", + "Ndamera Health Centre\n", + "Ndaula Health Centre\n", + "Neno District Hospital\n", + "Ng'onga Health Centre\n", + "Ngabu Rural Hospital\n", + "Ngala Health Centre\n", + "Ngana Health Centre\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ngapani Health Centre\n", + "Ngodzi Health Centre\n", + "Ngoni Health Centre\n", + "Ngwelero Health Centre\n", + "Nkasala Health Centre\n", + "Nkhata Bay District Hospital\n", + "Nkhotakota District Hospital\n", + "Nkhulambe Health Centre\n", + "Nkhunga Health Centre\n", + "Nkhwazi Health Centre\n", + "Nkomaula Health Centre\n", + "Nkula Health Centre\n", + "Nsanama Health Centre\n", + "Nsanje District Hospital\n", + "Nsiyaludzu Health Centre\n", + "Ntaja Health Centre\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ntcheu District Hospital\n", + "Ntchisi District Hospital\n", + "Nthalire Health Centre\n", + "Nthungwa Health Centre\n", + "Nyambi Health Centre\n", + "Nyamithuthu Health Centre\n", + "Nyungwe Health Centre\n", + "Nzama Health Centre\n", + "Pensulo Health Centre\n", + "Phalombe Health Centre\n", + "Phirilongwe Health Centre\n", + "Phokera Health Centre\n", + "Raiply Clinic\n", + "Rumphi District Hospital\n", + "Salima District Hospital\n", + "Sankhulani Health Centre\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sharpe Valley Health Centre\n", + "Somba Health Centre\n", + "Sorgin Health Centre\n", + "South Lunzu Health Centre\n", + "Tembwe Health Centre\n", + "Thekerani Rural Hospital\n", + "Thembe Health Centre\n", + "Thomas Health Centre\n", + "Thonje Health Centre\n", + "Thumbwe Health Centre\n", + "Thunduwike Health Centre\n", + "Thyolo District Hospital\n", + "Usisya Health Centre\n", + "Utale 1 Health Centre\n", + "Utale 2 Health Centre\n", + "Wiliro Health Centre\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Wimbe Health Centre\n", + "Zomba Central Prison Clinic\n", + "Zomba Mental Hospital\n" + ] + } + ], + "execution_count": 24 + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": "", + "id": "2c870698f447d57e" + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/scripts/climate_change/CIL_CMIP6_downscaling.py b/src/scripts/climate_change/CIL_CMIP6_downscaling.py new file mode 100644 index 0000000000..67ca05caec --- /dev/null +++ b/src/scripts/climate_change/CIL_CMIP6_downscaling.py @@ -0,0 +1,64 @@ +#!/usr/bin/env python +# coding: utf-8 + +# From https://planetarycomputer.microsoft.com/dataset/cil-gdpcir-cc0#Ensemble-example + +import planetary_computer +import pystac_client + +# required to load a zarr array using xarray +import xarray as xr +import numpy as np +# optional imports used in this notebook +import pandas as pd +from dask.diagnostics import ProgressBar +from tqdm.auto import tqdm + +import collections + + +# Load and organise data + + +catalog = pystac_client.Client.open( + "https://planetarycomputer.microsoft.com/api/stac/v1/", + modifier=planetary_computer.sign_inplace, +) +collection_cc0 = catalog.get_collection("cil-gdpcir-cc0") + +collection_cc0.summaries.to_dict() +print(collection_cc0) +search = catalog.search( + collections=["cil-gdpcir-cc0", "cil-gdpcir-cc-by"], # both creative licenses + query={"cmip6:experiment_id": {"eq": "ssp585"}}, +) +ensemble = search.item_collection() +print(len(ensemble)) + +collections.Counter(x.collection_id for x in ensemble) + +variable_id = "pr" + +datasets_by_model = [] + +for item in tqdm(ensemble): + asset = item.assets[variable_id] + datasets_by_model.append( + xr.open_dataset(asset.href, **asset.extra_fields["xarray:open_kwargs"]) + ) + +all_datasets = xr.concat( + datasets_by_model, + dim=pd.Index([ds.attrs["source_id"] for ds in datasets_by_model], name="model"), + combine_attrs="drop_conflicts", +) + + +# Subset for Malawi and 2025-2100 +subset = all_datasets.pr.sel( + lon=slice(32.67161823,35.91841716), + lat=slice(-17.12627881, -9.36366167), + time=slice("2025-01-01", "2100-01-01"), +) + +subset.to_netcdf("/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/CIL_subsetted_all_model_ssp585.nc") diff --git a/src/scripts/climate_change/assessing_reporting_data.py.ipynb b/src/scripts/climate_change/assessing_reporting_data.py.ipynb new file mode 100644 index 0000000000..2161ddb637 --- /dev/null +++ b/src/scripts/climate_change/assessing_reporting_data.py.ipynb @@ -0,0 +1,162 @@ +{ + "cells": [ + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-05T09:45:25.999314Z", + "start_time": "2024-12-05T09:45:25.685769Z" + } + }, + "cell_type": "code", + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import statsmodels.api as sm\n", + "from statsmodels.genmod.generalized_linear_model import GLM\n", + "from statsmodels.genmod.families import Poisson, NegativeBinomial\n", + "import joblib\n" + ], + "id": "de9ff7d8e18b7acd", + "outputs": [], + "execution_count": 1 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-05T09:45:26.002001Z", + "start_time": "2024-12-05T09:45:25.999931Z" + } + }, + "cell_type": "code", + "source": [ + "min_year_for_analyis = 2011\n", + "absolute_min_year = 2011\n", + "covid_months = range((2020 - min_year_for_analyis)* 12, (2020 - min_year_for_analyis)* 12 + 20) # Bingling's paper: disruption between April 2020 and Dec 2021" + ], + "id": "8503021b27cd6862", + "outputs": [], + "execution_count": 2 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-05T09:45:40.056058Z", + "start_time": "2024-12-05T09:45:40.018515Z" + } + }, + "cell_type": "code", + "source": [ + "ANC_monthly_reporting_by_facility = pd.read_csv(\"/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_ANC_by_smaller_facility_lm.csv\", index_col=0)\n", + "monthly_reporting_by_facility = pd.read_csv(\"/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm.csv\", index_col=0)\n", + "Inpatient_monthly_reporting_by_facility = pd.read_csv(\"/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_Inpatient_by_smaller_facility_lm.csv\", index_col=0)\n" + ], + "id": "6623b4db917621e5", + "outputs": [], + "execution_count": 4 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-05T09:48:38.675095Z", + "start_time": "2024-12-05T09:48:37.970686Z" + } + }, + "cell_type": "code", + "source": [ + "plt.plot(ANC_monthly_reporting_by_facility.index, ANC_monthly_reporting_by_facility.mean(axis = 1), color = \"green\", label = \"ANC\")\n", + "plt.plot(monthly_reporting_by_facility.index, monthly_reporting_by_facility.mean(axis=1), color=\"red\",\n", + " label=\"Reporting\")\n", + "plt.plot(Inpatient_monthly_reporting_by_facility.index, Inpatient_monthly_reporting_by_facility.mean(axis=1), color=\"blue\", label=\"Inpatient\")" + ], + "id": "f6fa7f24d0fc2ed4", + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj8AAAGdCAYAAAD9kBJPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/OQEPoAAAACXBIWXMAAA9hAAAPYQGoP6dpAACq5klEQVR4nOzdd3hT5dvA8e9JuuiGUsoue5e2gIACMsQBoiJDBcUtKPhzvyjiwIEIuBUVFEFFBVkOVBQHCCJICy17llGgQEtpS3eTPO8fh5w2HdBA0hZ6f66rV9NzTp7zJE1y7tzP0pRSCiGEEEKIasJU2RUQQgghhKhIEvwIIYQQolqR4EcIIYQQ1YoEP0IIIYSoViT4EUIIIUS1IsGPEEIIIaoVCX6EEEIIUa1I8COEEEKIasWjsitQXjabDYvFgslkQtO0yq6OEEIIIcpBKYXNZsPDwwOTqWrkXC6a4MdisbBly5bKroYQQgghzkNERAReXl6VXQ2dukgUFBSomJgYlZeXpywWi0t/8vLyVExMjMrOzjbO4YptVa2c6l7H6v74pY5Vqxypo9SxqpbtrmtsQUFBZYcShosm82Nv6jKbzZjNZrecw15u0fJdsa2qlVPd61jdH7/UsWqVI3WUOla1sotud6Wq1GWlajS+CSGEEEJUEAl+hBBCCFGtSPAjhBBCiGpFgh8hhBBCVCsS/AghhBCiWpHgRwghhBDVigQ/QgghhKhWJPgRQgghRLUiwY8QQgghqhUJfoQQQghRrUjwI4QQQohqRYIfIYQQQlQrEvwI4aRD6Yf4fO/npOWmVXZVhBBCnAcJfoRw0tvr3+b9ne8zb8u8yq6KEEKI8yDBjxBOysjLcPgthBDi4iLBjxBOsimbw28hhBAXFwl+hHCSVVn13zZrJddECCHE+ZDgRwgnGcGPkuBHCCEuRhL8COEke3OXZH6EEOLiJMGPEE6yBz02pM+PEEJcjCT4EcJJ0udHCCEubhL8COEke9AjfX6EEOLiJMGPEE6y9/lRSlVyTYQQQpwPCX6EcJI0ewkhxMVNgh8hnCRD3YUQ4uImwY8QTrI3d8kMz0IIcXGS4EcIJxkdnqXZSwghLkoS/AjhJGn2EkKIi5sEP0I4SWZ4rhiTJpl5+ulm2KR1UQjhYh6VXQEhLjbGDM/S58etPvjAxOnTNdm/30rz5pVdGyHEpUQyP0I4SZq9KobFov+2ytMshHAxp4KfJUuW0Lp16xI/bdq0AWD79u0MHz6cyMhIhg4dytatWx3uv2zZMvr3709kZCTjxo0jNTXVdY9EiAoiwU/FsAc9EvwIIVzNqeBn4MCBrFmzxvhZuXIl4eHh3HnnnWRnZzN69Gi6dOnCkiVLiI6OZsyYMWRnZwOwefNmJk6cyMMPP8yCBQvIyMhgwoQJbnlQQriTvblLmr3cy97XR/r8CCFczangx8fHh9DQUOPnhx9+QCnFU089xc8//4y3tzfjx4+nefPmTJw4ET8/P5YvXw7AvHnzGDBgAIMHD6ZNmzZMmzaNVatWkZiY6JYHJoS7yFD3imHP+EjwI4RwtfPu85OWlsYnn3zCk08+iZeXF/Hx8XTu3BlN0wDQNI1OnToRFxcHQHx8PF26dDHuX69ePerXr098fPyFPQIhKpg0e7mfUqCU/lkizV5CCFc779Fe33zzDXXq1OG6664DIDk5mRYtWjgcExISwp49ewA4ceIEderUKbH/2LFjTp3X6oZPQnuZxX+7altVK6e61/FCy7adSUVYrBa31ae6/4+KZnssFhtWq6pydXRVOVJHqWNVLdtV3FHmhdLUeSxNrZTiqquu4v7772fkyJEA3HXXXXTu3JlHHnnEOO7dd99l06ZNzJ07l7Zt2zJnzhy6d+9u7L/99tvp0aMHY8eOPec5rVarkUUSojIN/nMwh7MPc0XoFbzX7b3Krs4lyWKB7t07A/D55zto3z67kmskhLhQUVFRmM3myq6GTp2H+Ph41a5dO5WWlmZse+CBB9T06dMdjps2bZoaM2aMUkqpyMhItWrVKof9w4YNU5999lm5zmmxWFRMTIzKy8tTFovFpT95eXkqJiZGZWdnG+dwxbaqVk51r6Oryg5/O1wxCdX/8/5Vto4Xw/N4tnL++SdW2Ru/Vq/Or5J1vBieR6lj1SjnYivbXddYi8VyPiGHW5xXs9fq1avp0qULQUFBxrawsDBSUlIcjktJSTGausraHxoa6tS5zWaz2yJHe7lFy3fFtqpWTnWv44WWXXS0l7vqU93/R0Xz0UqZsB9SleroqnKkjlLHqlZ20e2XqvPq8Lx582Y6derksC0yMpJNmzYZK14rpdi4cSORkZHG/tjYWOP4pKQkkpKSjP1CXCxkqLv7Wa2acVtGewkhXO28gp89e/aU6Nx83XXXkZGRweTJk9m7dy+TJ08mJyeHAQMGADBixAi+//57Fi5cyM6dOxk/fjx9+vShUaNGF/4ohKhAxlB3Ge3lNkUzP1Wwr6QQ4iJ3XsFPSkoKgYGBDtv8/f2ZOXMmsbGxDBkyhPj4eGbNmoWvry8A0dHRvPzyy8yYMYMRI0YQFBTElClTLvwRCFHBjKHuMs+P20jmRwjhTufV52fz5s2lbu/YsSNLly4t835DhgxhyJAh53NKIaoMY1V3yfy4jWR+hBDuJAubCuEke9AjfX7cRzI/Qgh3kuBHCCfZm7sk+HEfyfwIIdxJgh8hnGQ0e0mfH7eRzI8Qwp0k+BHCSdLs5X42mwQ/Qgj3keBHCCfJUHf3KxrwSPAjhHA1CX6EcJIMdXe/opkf6fMjhHA1CX6EcJIMdXc/yfwIIdxJgh8hnFC0n4/0+XEfx8yPdpYjhRDCeRL8COGEogGPNHu5j2R+hBDuJMGPEE5wCH6k2cttpM+PEMKdJPgRwgk2pNmrIkjmRwjhThL8COGEotkeyfy4j2R+hBDuJMGPEE5QRdZdkD4/7iOZHyGEO0nwI4QTJPNTMSTzI4RwJwl+hHCCDHWvGJL5EUK4kwQ/QjjBIfMjzV5uI2t7CSHcSYIfIZygKNLnR5q93KZowCPNXkIIV5PgRwgnFA14pNnLfSTzI4RwJwl+hHCCzPBcMSTzI4RwJwl+hHCCzPBcMSTzI4RwJwl+hHBC8dFeRef9Ea4jmR8hhDtJ8COEE4oubwGOHaCF60jmRwjhThL8COGE4p2cpd+Pe0jmRwjhThL8COGEEsGP9PtxC8n8CCHcSYIfIZxQPNiR4e7uUTTbI5kfIYSrSfAjhBOk2atiKCWZHyGE+0jwI4QTind4lmYv95DMjxDCnST4EcIJxTM/0uzlHpL5EUK4kwQ/QjiheKZHmr3cQzI/Qgh3kuBHCCcUn9RQmr3cQzI/Qgh3kuBHCCdI5qdiFM32SPAjhHA1CX6EcELxDs/S58c9JPMjhHAnCX6EcIJMclgxpM+PEMKdnA5+8vPzeemll7jsssu44ooreOutt4x+ENu3b2f48OFERkYydOhQtm7d6nDfZcuW0b9/fyIjIxk3bhypqamueRRCVBCZ56diSOZHCOFOTgc/r776KmvXrmX27Nm8+eabfPvttyxYsIDs7GxGjx5Nly5dWLJkCdHR0YwZM4bs7GwANm/ezMSJE3n44YdZsGABGRkZTJgwweUPSAh3KjHUHbkyu4NkfoQQ7uThzMFpaWksXryYOXPm0LFjRwDuvfde4uPj8fDwwNvbm/Hjx6NpGhMnTuTvv/9m+fLlDBkyhHnz5jFgwAAGDx4MwLRp0+jbty+JiYk0atTI5Q9MCHeQDs8VQzI/Qgh3cirzExsbi7+/P127djW2jR49milTphAfH0/nzp3RNP1DS9M0OnXqRFxcHADx8fF06dLFuF+9evWoX78+8fHxLngYQlQMhQx1rwiS+RFCuJNTmZ/ExEQaNGjAd999x8cff0xBQQFDhgzhoYceIjk5mRYtWjgcHxISwp49ewA4ceIEderUKbH/2LFjTlXY6oZPQnuZxX+7altVK6e61/FCyi4e7BRYCqpcHSuqHHeWXTTzY7Uql75Hq1o5UkepY1Ut21XcUeaF0lTxWdvO4sMPP2T27Nm0bNmSp59+muTkZF544QVGjx7NqlWr6Ny5M4888ohx/LvvvsumTZuYO3cubdu2Zc6cOXTv3t3Yf/vtt9OjRw/Gjh17znNbrVYjiyREZVlxdAUTNhb2Vfuq11e0DmpdiTW6NM2dG8YHHzQEYMCAk7zyyoHKrZAQ4oJFRUVhNpsruxo65YSZM2eqVq1aqcOHDxvb5syZo6655hr1wAMPqOnTpzscP23aNDVmzBillFKRkZFq1apVDvuHDRumPvvss3Kd22KxqJiYGJWXl6csFotLf/Ly8lRMTIzKzs42zuGKbVWtnOpeR1eUPfn7yYpJGD//Hvi3ytXxYngez1XOuHGHFSgFSt1yi2veo1XtsUodpY5VtWx3XWMtFoszIYdbOdXsFRoaire3Nw0aNDC2NW3alKSkJLp27UpKSorD8SkpKUZTV1hYWKn7Q0NDnQrWzGaz2yJHe7lFy3fFtqpWTnWv44WUXXy0l9JUlatjRZXjzrKLZsmV0kocWxXq6KpypI5Sx6pWdtHtlyqnOjxHRkaSl5fH/v37jW0JCQk0aNCAyMhINm3aZMz5o5Ri48aNREZGGveNjY017peUlERSUpKxX4iLgRXHtmuZ4dk9HPv8aGc5UgghnOdU8NOsWTP69OnDhAkT2LlzJ6tXr2bWrFmMGDGC6667joyMDCZPnszevXuZPHkyOTk5DBgwAIARI0bw/fffs3DhQnbu3Mn48ePp06ePDHMXFxWZ4bliFB3eLkPdhRCu5vQkh2+88QaNGzdmxIgRPP3009x+++2MGjUKf39/Zs6cSWxsLEOGDCE+Pp5Zs2bh6+sLQHR0NC+//DIzZsxgxIgRBAUFMWXKFJc/ICHcSWZ4rhhFsz1VcKCIEOIi51SfH4CAgACmTZtW6r6OHTuydOnSMu87ZMgQhgwZ4uwphagyJPNTMYqOQZXMjxDC1WRhUyGcUGJ5C+nz4xaS+RFCuJMEP0I4ofhaXtLs5R6S+RFCuJMEP0I4QZq9KoZkfoQQ7iTBjxBOKB7sSLOXe0jmRwjhThL8COEEVWw1GAl+3EMyP0IId5LgRwgnFM/8SJ8f95DMjxDCnST4EcIJJTo8S58ft5DMjxDCnST4EcIJ0uenYkjmRwjhThL8COGE4n1+pNnLPSTzI4RwJwl+hHCCDHWvGEVjzGLxphBCXDAJfoRwgjR7VQzJ/Agh3EmCHyGcoJBmr4ogfX6EEO4kwY8QTigx1F2avdxCMj9CCHeS4EcIJ5To8yOZH7eQzI8Qwp0k+BHCCSVWdUeuzO4gmR8hhDtJ8COEEyTzUzEk8yOEcCcJfoRwgvT5qRiS+RFCuJMEP0I4oXgzlwx1dw/J/Agh3EmCHyGcIM1eFaNo5keCHyGEq0nwI4QTZIbnilE04JFmLyGEq0nwI4QTJPNTMWw2yfwIIdxHgh8hnCB9fiqGZH6EEO4kwY8QTpBmr4ohmR8hhDtJ8COEE0oMdZdmL7eQzI8Qwp0k+BHCCfbMj4bm8LdwLcn8CCHcSYIfIZxgD3Y8TZ6ANHu5i2R+hBDuJMGPEE6Q4KdiSOZHCOFOEvwI4QQrerDjoXnof0ufH7eQzI8Qwp0k+BHCCerMugseJj34kT4/7iGZHyGEO0nwI4QT7MGOPfMjwY97SOZHCOFOEvwI4QR7Hx975keavdyjaOZHKc1hoVMhhLhQEvwI4QTFmWYvyfy4VfGmLmn6EkK4kgQ/QjjBnvmR0V7uVTTzo/9dSRURQlySnA5+VqxYQevWrR1+HnnkEQC2b9/O8OHDiYyMZOjQoWzdutXhvsuWLaN///5ERkYybtw4UlNTXfMoKpjFZiEpO6myqyEqgdHnR5q93Kp4sCP9foQQruR08LN371769u3LmjVrjJ9XX32V7OxsRo8eTZcuXViyZAnR0dGMGTOG7OxsADZv3szEiRN5+OGHWbBgARkZGUyYMMHlD6giPLniSW748wZeXPmiMfpHVA9Gnx9p9nIrpSTzI4RwH6eDn3379tGqVStCQ0ONn8DAQH7++We8vb0ZP348zZs3Z+LEifj5+bF8+XIA5s2bx4ABAxg8eDBt2rRh2rRprFq1isTERJc/KHfbkbIDgMlrJvP0H09LAFSN2P/X0uzlXsUzPZL5EUK40nkFP02aNCmxPT4+ns6dO6Np+jc2TdPo1KkTcXFxxv4uXboYx9erV4/69esTHx9/fjWvRDmWHOP2W+ve4qNdH1VibURFKtHnR5q93EIyP0IId/Jw5mClFPv372fNmjXMnDkTq9XKddddxyOPPEJycjItWrRwOD4kJIQ9e/YAcOLECerUqVNi/7Fjx5yqsNUNXwHtZRb/Xda2nAI9+Lml7S0s3LGQNSfWnPW+zpRdEeVU9zpeSNk2HOf5sdgsVa6OFVWOe8vGQX6+c+9ReR6ljlWxnIutbFdxR5kXSlNOtNkcOXKEfv36cfPNN3PXXXdx+PBhXn31Va6++mr27NlD586djc7PAO+++y6bNm1i7ty5tG3bljlz5tC9e3dj/+23306PHj0YO3bsOc9ttVqNLFJlG/LXEA5lHeKTyz8h2CuYAM8AavvUruxqiQow8u+R7M7YTa+wXqw+vpr+9frzeufXK7tal5xrrulIaqqn8ffvv8cRHFz1PkCFEOUXFRWF2Wyu7GrolJNOnTqlbDab8ffy5ctVRESEuu+++9T06dMdjp02bZoaM2aMUkqpyMhItWrVKof9w4YNU5999lm5zmuxWFRMTIzKy8tTFovFpT95eXkqJiZGZWdnG+c427YGbzZQTEKtPbD2rMedq5zybnNVOdW9jq4ou8WbLRSTUP0+7qeYhBr8zeAqV8eL4Xk8VznBwfkKlPFz6FDVq+PF8DxKHatGORdb2e66xlosFmdDDrdxqtkLIDg42OHv5s2bk5eXR2hoKCkpKQ77UlJSjKausLCwUveHhoY6dX6z2ey2yNFebtHyS9uWa8kFwM/br8T+0u7rTNkVUU51r+OFlF18qLv976pUx4oqx51l22yOCWlNO/f7TJ5HqWN1rqMryy66/VLlVIfn1atX061bN3JyCjv87tixg+DgYDp37symTZuM0TBKKTZu3EhkZCQAkZGRxMbGGvdLSkoiKSnJ2H8xsXd4ruFRo5JrIipa8T4/MtTdPWSGZyGEOzkV/ERHR+Pt7c1zzz1HQkICq1atYtq0adx///1cd911ZGRkMHnyZPbu3cvkyZPJyclhwIABAIwYMYLvv/+ehQsXsnPnTsaPH0+fPn1o1KiRWx6YuyiljA7PEvxUP/ZgR4a6u1fxGZ6rYH9JIcRFzKngx9/fn9mzZ5OamsrQoUOZOHEit956K/fffz/+/v7MnDmT2NhYhgwZQnx8PLNmzcLX1xfQA6eXX36ZGTNmMGLECIKCgpgyZYpbHpQ7FdgKjPWdanhK8FPdyMKmFUMyP0IId3K6z0/Lli2ZM2dOqfs6duzI0qVLy7zvkCFDGDJkiLOnrFLybHnGbcn8VD9Gn58zzV6S+XEPyfwIIdxJFjZ1Up5VD340NLzMXpVcG1HRijd7SZ8f95DMjxDCnST4cVKuVR/p5W32NmazFtVHiT4/0uzlFpL5EUK4kwQ/TrI3e3mbvCu5JqIyFB/tJc1e7lE8+JHMjxDClST4cZK92cvH7FPJNRGVwZjXx+Q4749wnaKBjtmsDy6QzI8QwpUk+HGSPfjxNkvmpzoymr00GeruLkWDHw8PVWKbEEJcKAl+nCTNXtVb8aHuNrkqu1zRLI89+JHMjxDClST4cVLRDs+i+rHP8SR9ftxHMj9CCHeT4MdJ0uxVvdmDHRnq7j6S+RFCuJsEP06SZq/qrfjCpjLU3fUk8yOEcDcJfpwkmZ/qzejzI81ebiOZHyGEu0nw4yQZ6l69KaVfjKXZy31KG+oumR8hhCtJ8OOkXNuZDs/S7FXtKKWMSQ5lhmf3kcyPEMLdJPhxkjR7VV9FszzS7OU+9iyPyaQwmSTzI4RwPQl+nCTBT/XlEPxIh2e3sWd5TCb9p+g2IYRwBQl+nCSjvaqvolkee+ZH+vy4nj3QMZvBvnawZH6EEK4kwY+TJPNTfRXN8hiZH2n2cjl7oGM2y9peQgj3kODHSTLaq/oqLfMjwY/rFW32ksyPEMIdJPhxkoz2qr6KNnHJUHf3KS3zI8GPEMKVJPhxkjR7VV9Fm71kqLv7SOZHCOFuEvw4SYKf6kuavSqG9PkRQribBD9OktFe1Ze9iUtDw6Tpbx3J/Lhe6ZkfrfIqJIS45Ejw4yTp8Fx92QMds8lsBD/S58f1pM+PEMLdJPhxkjR7VV/2Ji6zVhj8SLOX65WW+ZFmLyGEK0nw4ySj2UuCn2rHnuUxaSbMmhmQZi93kMyPEMLdJPhxUq5VhrpXV0WbvTT0lIQ0e7mePcujaZL5EUK4hwQ/TpJmr+qraLOXPfOjUCilKrNal5yimR9Z2FQI4Q4S/DjBarNiURZAOjxXR/bgx6SZjD4/RbcL15CFTYUQ7ibBjxNyLDnGbWn2qn7sTVxFOzwX3S5cQzI/Qgh3k+DHCTkFRYIfafaqdkob6g5gQ67MrlSY+VGS+RFCuIUEP06wZ368zF4OFz9RPZTW5wck8+NqkvkRQribXMGdYA9+anjUqOSaiMpQdKi7CWn2chfp8yOEcDcJfpxgb/aS4Kd6KrPZS4Ifl5LMjxDC3ST4cYI98+PjKSO9qqOyRntJnx/Xsmd59ODHcZsQQrjCeQc/o0eP5plnnjH+3r59O8OHDycyMpKhQ4eydetWh+OXLVtG//79iYyMZNy4caSmpp5/rSuJZH6qN4dmLxnq7jb2LI/e7CWZHyGE651X8PPTTz+xatUq4+/s7GxGjx5Nly5dWLJkCdHR0YwZM4bs7GwANm/ezMSJE3n44YdZsGABGRkZTJgwwTWPoAJJn5/qzWj2OtPZ2R4AySSHruXY7KXflsyPEMKVnA5+0tLSmDZtGhEREca2n3/+GW9vb8aPH0/z5s2ZOHEifn5+LF++HIB58+YxYMAABg8eTJs2bZg2bRqrVq0iMTHRdY+kAuRa9KUtJPipnozRXiY9+DHW95LMj0s5dniWzI8QwvWcDn6mTp3KTTfdRIsWLYxt8fHxdO7cGe3MQjyaptGpUyfi4uKM/V26dDGOr1evHvXr1yc+Pv4Cq1+x7M1ePh7S56c6smd+7BkfexAkHZ5dSzI/Qgh383Dm4H///ZeYmBh+/PFHJk2aZGxPTk52CIYAQkJC2LNnDwAnTpygTp06JfYfO3bM6Qpb3fApaC+z+O/i27Lys4DC4Kes40qr67nKrshyqnsdz7dsi1Vf2sQIfopkfqpKHSuyHHeVXVCgP7+apozMj9WqnC7H3Y/fVeVIHaWOVbVsV3FHmRdKU+XssJCXl8cNN9zA888/T69evYzOzq+//jp33XUXnTt35pFHHjGOf/fdd9m0aRNz586lbdu2zJkzh+7duxv7b7/9dnr06MHYsWPLVVGr1WpkkirLNwnf8Ob2N7m6/tVM6TSlUusiKt4/J/7h0f8epU1QG+b1mkfv5b3JsmSxtO9SGvk1quzqXTKWL6/Jc881o2vXDJo2zWXBgjrce28SY8cereyqCSEuQFRUFGaz+dwHVgRVTm+88YZ6/PHHjb+ffvpp9fTTTyullHrggQfU9OnTHY6fNm2aGjNmjFJKqcjISLVq1SqH/cOGDVOfffZZeU+vLBaLiomJUXl5ecpisbj0Jy8vT8XExKjs7GzjHKVte3Xlq4pJqDsW3XHW4+zbzrW/vNtcVU51r+OFlr1k6xLFJFTnjzurmJgYFfx6sGISatHKRVWmjhfD83iucj77rECBUv37W9SIEccUKDV+vKVK1fFieB6ljlWnnIutbHddYy0WS7mv+e5W7mavn376iZSUFKKjowHIz88H4Ndff2XQoEGkpKQ4HJ+SkmI0dYWFhZW6PzQ01OlgzWw2uy1ytJdbtPyi23KteodnX0/fsx5XfFt5yq7Icqp7Hc+3bM2k92kr3uHZpmxVpo4VWY77yj7zPJs1o8+PzaadRznV/XmUOla1ci6Wsotuv1SVO/j58ssvsVgsxt9vvPEGAE899RQbNmzgk08+QSmFpmkopdi4cSMPPvggAJGRkcTGxjJkyBAAkpKSSEpKIjIy0pWPxe2Moe6eMtqrOiprqLt0eHYte/cAGe0lhHCXcgc/DRo0cPjbz88PgPDwcEJCQnjzzTeZPHkyt912G/PnzycnJ4cBAwYAMGLECEaNGkVUVBQRERFMnjyZPn360KjRxdVPIrdAhrpXZyWGuttHe8kMzy4lo72EEO7mkuUt/P39mTlzppHdiY+PZ9asWfj66s1D0dHRvPzyy8yYMYMRI0YQFBTElCkXX4dhmeSweis6wzM4NnsJ1ykt8yPzSAohXMmpoe5Fvf766w5/d+zYkaVLl5Z5/JAhQ4xmr4uVMc+PrO1VLZWY50cmOXQLyfwIIdxNFjZ1gmR+qjej2UuWt3CrwsyPkj4/Qgi3kODHCRL8VG9lzfAsmR/XKi3zI8GPEMKVJPhxgqzqXr3Z+/aUNtRduE7RPj+aphy2CSGEK0jw4wR75kf6/FRPZTV7yWgv1yqa+bFPNyKZHyGEK0nw4wRZ1b16M+b5KT7UXTI/LmXP8pjNkvkRQriHBD9OkGav6s2e4ZHRXu5lz/KYTJL5EUK4hwQ/TpAOz9WbzPBcMaTPjxDC3ST4cYIsb1G9Fe/zI81e7iGZHyGEu0nw4wRjkkMP6fBcHRUf6i4dnt1D+vwIIdxNgp9yUkpJs1c1V2Kou2R+3KJos1dh5kervAoJIS45EvyUU541z7gtwU/1VGKoO9Lnxx2KDnWXzI8Qwh0k+Ckne5MXSJ+f6qqsGZ4l+HGt0jM/lVcfIcSlR4KfcrI3eZkw4WnyrOTaiMpgrOpukqHu7iSZHyGEu0nwU072zI+32RtNk/4H1VGZMzxL5selJPMjhHA3CX7KyZ758TZ7V3JNRGUpPs+P0ewlo71cSjI/Qgh3k+CnnIzgxyTBT3VlNHsVm+FZMj+uJfP8CCHcTYKfcira7CWqJ6PZq9hQd+nz41qS+RFCuJsEP+UkmR9RVp8fpVSl1elSVNjnR0nmRwjhFhL8lJN9RXfJ/FRfJYa620d7IWkJV5LMjxDC3ST4KScJfoTM8FwxZLSXEMLdJPgpJ6PPjzR7VVtG8CND3d1KMj9CCHeT4Keccq2S+anuymr2kuDHteyBjqZJ5kcI4R4S/JSTvdnLy+RVyTURlaV45keCH/coLfMjwY8QwpUk+CknGeouZKh7xbBnfsxmvd8PSPAjhHAtCX7KyejwLH1+qq3iMzwbQ92Roe6uVHSSQ5NJMj9CCNeT4KecZHkLUdYMz5L5cS2rVV87r2jmRzo8CyFcSYKfcsqz5AHS56c6swc5xqruMtTdLSTzI4RwNwl+ykkyP6KsZi8JflyrtD4/kvkRQriSBD/lJH1+hJH5KT7UXVZ1dynJ/Agh3E2Cn3KSzI8oMdRdmr3cQjI/Qgh3k+CnnGSeH1F8qLumaQ7bhWsUXd5CMj9CCHeQ4KecZJ4fUdYMz7Kqu2sVneRQMj9CCHeQ4KecjOUtpM9PtVVWs5dkflxLMj9CCHdzOvg5ePAg9913H9HR0fTp04dPP/3U2JeYmMjdd99NVFQUAwcOZM2aNQ73Xbt2LYMGDSIyMpI777yTxMTEC38EFSS3QNb2qu5KzPAsy1u4hWR+hBDu5lTwY7PZGD16NDVr1mTp0qW89NJLfPTRR/z4448opRg3bhy1a9dm8eLF3HTTTTz88MMcPXoUgKNHjzJu3DiGDBnCokWLqFWrFmPHjr1omgykz48oc6i7jPZyqcLMj5LMjxDCLTycOTglJYW2bdsyadIk/P39adKkCZdffjmxsbHUrl2bxMRE5s+fj6+vL82bN+fff/9l8eLF/O9//2PhwoV06NCBe++9F4ApU6bQo0cP/vvvP7p16+aWB+dK9tFePmafSq6JqCwOMzwryfy4S9HMj51kfoQQruRU5qdOnTq88847+Pv7o5QiNjaWDRs20LVrV+Lj42nXrh2+vr7G8Z07dyYuLg6A+Ph4unTpYuyrUaMG7du3N/ZXdUbmxyyZn+rKaPaSPj9uZQ90NE36/Agh3MOpzE9R/fr14+jRo/Tt25drr72W1157jTp16jgcExISwrFjxwBITk4+6/7ysrrhK6C9zOK/i9425vkxeZ/1uNK2nWt/RZdT3et4vmXbm7009CHumtJ/25StytSxIstxV9k2mwZoaJqtRJ+fqlJHV5YjdZQ6VtWyXcUdZV4oTZ1np5stW7aQkpLCpEmTuPrqq8nOzsZqtTJ16lTjmEWLFjFz5kxWrFhB//79eeihhxg6dKixf/z48Xh6ejJ58uRzns9qtVZqlujyny+nwFbAsquWUbdG3Uqrh6g896+9n7jUOF7v9Dr96/dn7t65fLDzA25odAMvRr5Y2dW7ZIwa1YYdO/x45509NGmSy+DBEfj6Wvn777jKrpoQ4gJERUVhLtqeXZnUBfrll19U+/bt1QsvvKAee+wxh31fffWVGjRokFJKqYEDB6qvv/7aYf+jjz6qXnnllXKdx2KxqJiYGJWXl6csFotLf/Ly8lRMTIzKzs42zlF02/oN6xWTUExCrfhnRZnHFd92rv0VXU51r+OFln35J5crJqG+iftGxcTEqNdWvaaYhLr+0+urTB0vhufxXOVERVkVKPX997nqhx82K1CqRg1blarjxfA8Sh2rTjkXW9nuusZaLJYLDTlcxukOz3FxcfTv39/Y1qJFCwoKCggNDSUhIaHE8famrrCwMFJSUkrsb9u2rVPBmtlsdlvkaC+3aPlms5kCW4Hxt5fZq8zjytp2rv0VXU51r+P5lm1FT916eniCBTzNnoDe7FVV6liR5birbL3ZCzw9Tdhsjn1+qkodXVmO1FHqWNXKLrr9UuVUh+fDhw/z8MMPc/z4cWPb1q1bqVWrFp07d2bbtm3k5uYa+2JjY4mMjAQgMjKS2NhYY19OTg7bt2839ldl9gkOQSY5rM5sZ67ApjNvG1nV3T0cFzbVb1fBLgNCiIuYU8FPREQE7du359lnn2Xv3r2sWrWK6dOn8+CDD9K1a1fq1avHhAkT2LNnD7NmzWLz5s0MGzYMgKFDh7Jx40ZmzZrFnj17mDBhAg0bNrwohrnnW/MBMGtmPEzn3UdcXOSMGZ7tkxzKwqZuYQ90zGYZ7SWEcA+ngh+z2cyHH35IjRo1uPXWW5k4cSKjRo3izjvvNPYlJyczZMgQfvjhB2bMmEH9+vUBaNiwIe+//z6LFy9m2LBhpKWlMWPGDGNxyKosz5YHQA3PGpVcE1GZSgx1P/Nbhrq7VmmZH5tN4yKZD1UIcRFwOo0RFhbGBx98UOq+8PBw5s2bV+Z9e/fuTe/evZ09ZaXLs+rBj4+HTHBYnRkzPJ/J+Eizl3sUzfyoIhGPBD9CCFeRhU3Lwcj8eEjmpzqzZ3iKr+ouy1u4VmmZn6LbhRDiQknwUw72Pj+S+aneylrVXTI/rlVanx/AGAUmhBAXSoKfcpDMj4CSzV6ytpd7SOZHCOFuEvyUg73Pj7eHDHOvzoxmr+JD3aXZy6Uk8yOEcDcJfspBMj8CZKh7RbEHP5L5EUK4iwQ/5SB9fgQUafaSoe5uVTibs2R+hBDuIcFPOcg8PwJKjvaSoe7uYc/8aJqSzI8Qwi0k+CkHY54fs2R+qjNp9qoYRTM/RedAlcyPEMJVJPgph3yb3uwlmZ/qrawZniX4ca2ifX40TZa4EEK4ngQ/5SAzPAso7PNjOtMWY1+aRfr8uFbRzA84LnEhhBCuIMFPOdj7/EjwU70VH+pub/ZSyLoLrlQ08wOFQZBkfoQQriLBTzlI5kdAKX1+ZLSXW0jmRwjhbhL8lIO9z48EP9VbWUPdpc+PaxWd5LDob8n8CCFcRYKfcsi15gIyyWF1J0PdK0bR5S2K/pbMjxDCVST4KQfJ/Ag4y1B3Wd7CZZQCpfQgRzI/Qgh38ajsClwM7H1+JPNTvV2KzV4Wm4Ufdv1AYG5gZVcFcAxwJPMjhHAXyfyUg2R+hFLKGNVlz/jYm70u5g7PP+7+kVsW38L0bdMruypAYX8fkMyPEMJ9JPgpB6PPj0xyWG0Vze6UGOquLt6h7rtO7gIgLjWucityhmR+hBAVQYKfcrBnfrw9vCu5JqKyFM3uXEpD3ZNOJwFwMu8kSZlJlVybSy/zs/XEVjILMiu7GkKIYiT4KQfp8yPs/X2gSJ+fS2Btr6OZR43bm45tqsSa6C6lzM/m45uJmhXFhI0TKrsqQohiJPgpB+nzI4pmd0oMda/io73WH1nPzvSdpe47erpqBT+XUubnvyP/AbA1betF3TQqxKVIgp9ykHl+RNHsTvFmr6qc+cnMz6T/l/0Z8+8YcgpySuw/lnnMuF0Vgp9LKfOz59QeAE4XnCYlJ6WSayOEKEqCn3KQzI+4WJu9Ek4lkGPJIcuSRfzxeId9Sim3Z34KrAVOHV8083Oxr+215+Qe4/be1L2VWJOLW0p2Ct0/687cvXMruyriEiLBTzlInx9xtmavqtzh+WD6QeP2xmMbHfalF6RTYNODEw2Nw6cPk5qX6rJz70ndQ+iboby9/e1y38ce4GiaQjuT6LloMz+pEvy4wg+7fiDmaAyf7P6EUzmnKrs64hIhwc85KKUk8yMch7qfCXrsGaCqvKr7ofRDxu2NSY7BT3JuMgC1fWvT2K8xQJl9g87H6oOryczPZOWxleW+T/EV3eHizPxYlZV9p/YZf9ubwITzYpNiAciz5fH1tq8ruTbiUiHBzznkWnKN2zLPT/Vlb/YyYUI7k5K4GIa6O2R+ygh+6vvXp01QG8C1wc+hDD3wOpJ9hKz8rHLdpzD4KQwoL8bMz7GcY+Rb842/JfNz/mKPxRq3P4v7rETn8ZyCHGJPxlbp5mdR9Ujwcw5Fgx/J/FRfxRc1hYujz0/RzM+25G0OnZ7twU+9gHq0DWoLwI70HS47d2J6onF758nyBVXFFzWFizPzk5iV6PD33lMS/JwPi83CluNbAP2Lx9bkrWxL2+ZwzOR/JjPm3zFMX1s1ZikXFwcJfs4hx6JfLEyaCU+TZyXXRlQWe4BTNPipKn1+ZsfN5t5/7nXovGxXNPNjVVY2n9hs/J2Sp49AKpr52ZW+y2X1smd+AHaklC+oulQyPwcz9ee9bW09qNybuleGu5+Hfaf3kWfNI8g7iGsbXAvA0kNLHY75ff/vAHyw4QOnO9iL6kuCn3OwZ358PHyM5g5R/RjNXkUzP1rlL29hUzZe+vslNp/azJy4OSX22zM/Id4hgGPTV0quHvzUC6hH66DWABzNOcrJ7JMuqVvRzM/2lO3lus+lkvk5lKU/71c3uxoTJrIKsoxgU5SfPRMZXTeaIY2HAPDb0d84nXca0Kch2XJCzwwlZSaxdOfS0gsSohgJfs7BHvzISK/qzZ7dsQc8UKTZC1ulBUDb07ZzPOs4AL/s+8VhX64119jXt25fwDH4MZq9/OsR4BlAs+BmAMQkxVxwvZRSJGYUCX6Syxf8lJb5sX/nUOri+fJhb/ZqH9qeer71gMKASJSfvQ9ap3qdiKoVRatarcix5hhBzs70nVhsFuP4GTEzzlre6bzTVbqZWlQcCX7OoWjmR1Rf9uBHo/ACXDQLVFkfqKuOrzJurz+8npTswuzCsRx9AkM/Tz+61e4GOA53T8470+E5oD4Alze8HIDVh1ZfcL1O5Z8ypogA2HGyfM1eZ8v8WKtuv/ISDmbpzV4tarUwRtIV7wckzs2e+elcrzOapjG0zVCgMNDfemorABHBEXiYPPgn8Z8ym27XJq4l7K0wp6ZeEJcuCX7Owd7nRzI/lyalFOsOr3O4UJfGHtw4ZH6K3K6s4Ofv438DemdQheK3fb8Z++zBT3hQOG2D9b4n25K3GY/VaPby1zMTvRr3AlwT/NjP7e/lD8CBtAPGe+lY5jF2pu9k07FNRt8YO3uAYzaX7PNzsWR+8q35JGXri8S2qtXKCH4k8+OcAmsBezL0KQI61esEwHXNrwNgRcIKvTN0mt7k1btub4a00ZvFvj3wbanlvfHvG+Rb8/n1yK/S/0pI8HMukvm5tM3aOIuec3sy5t8xRj+C0thHSRXN9vh5+eFt9gZKTiBYERJOJbDv9D7Mmpmbw28G4Je9hU1f9gtw46DGhPmEUdu3NhabhT0Ze7ApW2GH5zOZn16N9OBnw9ENxuPNteSyLnkdn8d/zhv/vmF80y7u74N/0/KDlvxyWD+/PfhpH9qeWl61ANifuZ+EUwm0+KAFd6y+g+5zujN05VC+3PylUU7hJIeFZduDn4sl85OQloANG/5e/tT1r0sjv0YAHMqsOsFPbFIsSw4ucXsQsPXEVk7lnd/EhDtSdpBvyyfQO5DmNZsDcFn9ywjyDCItN411h9cZr8cOwR0Yd9k4AH4+8jM/7/3ZoaxjOcdYtmcZAKn5qeUefSguXU4FP8ePH+eRRx6ha9eu9OrViylTppCXp3+LTExM5O677yYqKoqBAweyZs0ah/uuXbuWQYMGERkZyZ133kli4sWRAjaCH08Jfi52G45u4MF/H+Tfw/8CUGAr4PV/Xgf0xScHLxxsZCeK+iPpD26YfwMA/h7+xnYvsxfD2w0HYGbsTHdXX6/nia0sP7Ici81ifJj3atyLAQ0GAPBrwq9GE11Sjh78NAlugqZpdKqrf3vemb6TlOwUrMqKhkaYXxgAzWs2J9Q7lHxrPuuOrAPgoZ8f4uH1D3Pfj/fxzB/PcN/a+/h+9/cOdcq15nLfj/exP20/3yV+BxQGP42DGtM0oCkACZkJzNo4i1xLLr5mX0J9QwF45e9XjH4bpWV+7M1eF0vmxz6zc8taLdE0rTDzk101gh+lFLctuY3XtrzGyoMr3Xae+OPxdP6kM/evvf+8RmHZv1B0qtupcGJRk5nuod0Bfc6f47nHMWkm2gW344qGVzC07VAKbAUM/XYo3+8qfJ0uPrjYITt7PtlNm7KVa2Tn6bzTbDq5iTzL2bPJonKVO/hRSvHII4+Qk5PDV199xdtvv81ff/3FO++8g1KKcePGUbt2bRYvXsxNN93Eww8/zNGj+tDbo0ePMm7cOIYMGcKiRYuoVasWY8eOvShSj0bwY5bgp7x2pOwg4XRChZ/3rwN/ccWcK5ixs/ROjy/9/RIxJ2O4fcntnM47zc+HfyYxI5FQ31D8PPxYk7iGJ2OedPigfnHVizwd+zTHs47TtnZbJnea7FDmg50fBODb7d+SmuO6pSFKk2/NZ8A3A3hu03Nc+9W1fLP1GwCub3E9HYI7UNOnJqk5qca3YXvw0zhIv/h2rtcZgI2pG0nK1PfV8auDp1mfwkHTNDqF6AHS3wf/JiU3hW936E0IVzW9ih6NemBVVu747g42pGww6jVr9yz2p+0H9MDKpmxG8NMosBHN/PWO1LvTd/PF5i8AeDn6ZXY9tIsgzyAS0hJYtH0RUDUyP0opPt34KRtPlp7NS8tN4/3/3ictP63U/fYJDVvWaglgBD+Hsw5Xic62e0/vNaYhWH9kvdvO83n851iVlYNZB5m7ea7T9zeCnzNNXnY96vQA4KstXwF6dtHXwxdN05g3eB5X17uaAlsBtyy6hSUHl5BnyeP7Q3ogFF03GnA++DmRc4Kun3Vl2F/DHObK+r/f/4/hK4cbAW++NZ9rv76WB/59gIbvNGTsz2PZmyFzPFVF5Q5+EhISiIuLY8qUKbRs2ZIuXbrwyCOPsGzZMtatW0diYiIvv/wyzZs3Z8yYMURFRbF48WIAFi5cSIcOHbj33ntp2bIlU6ZM4ciRI/z3339ue2CuYoz2cmJ259OnITf34viW6kpbT2zlqQ1PEfVJFHeuubPUeWfcIbsgm+lbp3P1vKv578h/zNk7p0TaOyU3hT8O/AHo88+M/308n+/7HICnLn+K97q+h5+nH/+l/MesjbMAOJp9lDfXvQnAMz2eIeb+GNoFt3Mot1uDbrQKbEWuJZfP4z936+P889ifnMg+AcCqg6vYcFQPQK5veT0eJg+uaXYNAGtO6FnXon1+7McBrD6+2lh6wd7fx84Ifg79zfeJ32OxWYgIjuDX23/lj1F/0LduX/Kt+Ty54UmmrZ3Gsj3L+CpBvwhpaGRZsth3ah/Hc/VRZo2DGtM8QG+y+D7xe05knaCuf1161umJn5cfI5qOAGDq2qkopapE5mdFwgoe/PlBHt/wOOm56Q77bMrGrYtv5fHfHued7e+Uev+imR+AujXq4mnyJN+W7zD8v7L8c+If43bxWb9dxaqsfLu9sO/NlH+mkGvNJbsgm8d+fYwZO2c4zIBd3M70nUZm0x60210eejkampGF6Vq/q7HP0+zJK9GvMCpiFFZl5bUtr9Hz856k5qdSP6A+r/V7DYDViavL/eX7YNpBHvj3Abac2EJidiJrD68F9EBn5saZ7M/cz+AFg0nLTeO9He8ZM1Kfyj3FrI2zGLVmlEPTrl1ieiJ3LL3DpXNrifIrd/ATGhrKp59+Su3atR22Z2ZmEh8fT7t27fD19TW2d+7cmbi4OADi4+Pp0qWLsa9GjRq0b9/e2F+V2ZtBytvnJz0doqJMDB/engIXzbeVkZfB7E2zySzIdNg2/vfxPLvxWW769iae3fis0ZzjCtkF2Wfdt+nkJiMwzLXm8sRvTxA9K5qVx1ca24qmnd1FKcWwRcNYcGABABF1IgB4ePnDDs/Xb0d/w6ZshHrrTS2fbPqEQ1mHqOlTkzGdxxBZK5Ip/aYA8MrqV0jPTefTPZ9SYCugW+1uvNr3Vbw9vEucX9M0hoUPA/T+Q+78Zr/4oP5l4oaGN9AmRJ+UsHlAc6M/xMCWAwG9E7RSqkTmp1uDboQHhZNjzeGzuM8AfY6fojqH6Bea9UfWs+TgEgCGNtFH2HiYPHg1+lX6NulLtjWbZ/98lsELBmNVVoa0GcJlDS4D9NXhjWavwMJmryyLvsTFXR3vwsPkAcAtTW7B38ufLSe2sObEGpdlfnIKcliXvM6Yn8kZ9oxaliWL2fGzHfft/4Y/9utB9IqjK0oER1CY+WkV0grQn7emwfpzUHSx08pSNPixr5vlarEnYzmWeYxaNWpRt0Zdjpw+wpy9c7j2q2v5YMMHzNk7h4FfDyyxUKnVZuX1f17n7jV3c+T0Eer41OHqZlc7HFPTuyZd6hdeT4oGP6A/37NvnM3rV72OWTMbE3s+EP0APRv1xNPkSVJmEolZiSil+HrL1/yQ+AMbkzaSa811KOtA2gH6fdmPI9lHjG1rDulfLranbzcGD+w6uYs+n/dh/oH5ALzZ5U1+vf1Xrmt+HQW2Au7/6X7e3v62w+vxg5gPmL9tPpM3T74oWkEuNeUOfgIDA+nVq5fxt81mY968eXTv3p3k5GTq1KnjcHxISAjHjukfgOfa7wyr1eqWH3vZRc8BhR1dfcw+Zz3O/vuNN+DgQY2kJG+OHTt72eXZppRixOIRjPlpDG9tf8vYP2XNFN5a9xa/Hf2N5fuW89vR3+g1txfXzLuGyZsnc93X13HPmnt4bfVr7Du576znK37uPxP+pO5bdfnf+v9xKvtUiePG/jyWB/59gCbvNuGp357ijtV38N5/76FQXFXvKh6IegCA73Z+d8GP/1z7/0j6gz8O/IG3yZsfb/2Rv+/8m0a+jThy+gjv7njXOG75keUA3NPyHu6Pvt94PT3c5WFqmPWs3l0d7iLcL5yU7BTG/jyWnw7/BMCDrR88ax2ua3AdAV4B7Endw38p/13wYy1t25ZjW9iUugmzZuah1g+x5q41TO4zmZeiXjKOu6bpNfh4+LDv9D7+3P+nMY9PQ/+GgP6etQ8VXrF/BQD1/Oo5nCfcL5w6vnXIteRyPPc4tXxqcXW9q436eJu9WTxkMRMiJtCvST/MmpmaXjV5s/+bRIfpTQqxR2ON4KeBfwMj82N3V8e7jPMFegUyOno0AJ/t+Yz8/DPzKZmVUS/7nD9KaeV+zqatncbD6x/mjX/fcOp5zrXm8t2u74y6vv/f+xTYCrBarcQlxfHBzg8A8PX0Jc+Wx/xt8x3KUUoZs1m3CG5hlN06RJ9Ecv3h9eesw/YT27HYLGett8Vi4fU1r7Pm+Jpzvmf2pOxhV/ourFYrKZkpbD5VOMv3wfSDnDh94qz1KW3b/tT9eh+YM9syczOZ+OdE4lLjsFqt/HJE7/g+pM0Q7m+pv99m75nNv4f/JdgnGF+zLysPruSKOVewPnk9BZYCDmcdps/nfXjur+ewKAs3tryRr3p9RZBXUIn6XNvsWuMxdKnbpUQdlU3xeNfHmX3FbFrUbEGodyj3Rt6Ll8mLDsEdAL3598MNH3Ln93fycvzLXD73cq757RoWb19svBaGLhzKwfSDNPZrzNOXPw3oTWZWq5VNqZv0/21ga2p41GBrst7c/HjXx+ldtzd9Gvdh6fClxuP/KuErZm+abdQxLikO0IOotYlry/3cl3fbhZbj6p+qRlPnGXJOnTqVr776ikWLFjF37lysVitTp0419i9atIiZM2eyYsUK+vfvz0MPPcTQoUON/ePHj8fT05PJkyeXVnwJVqu1UjJFc/fO5YOdHzCo4SAmRU0667EnT3oweHAHcnL0PP38+dto0cLxm4TFZuGPpD/oWLOjMfnZ2Sw8sJCpW/Xn1dPkyU9X/YSvhy/X/3496QXpjGg6ghYBLdh8ajPLDi8rs0PeyKYjeaL9E+c8n03ZuGP1HezO2A1Am6A2vNf1PWp56yN2TuSc4IY/byhxnhDvEF6IfIEedXpwKPMQQ1YOwayZWXH1CgK9Ao3jlFL8evRX2ga1Jdw//Jz1OZtcay5D/xrK8dzjjGk1hgda6UFX7MlYxvw7BoDJ0ZNpHdSaYSuHYdbMLO+/HE+TJ3etuYtsSzbze88nyCvIKHPlsZU8FfOU8XePOj14t+u756zL1C1TWXhwIdfVv45XO716QY+rNNO3TmfBgQX0rduX6V3KXsPotc2vseTQEtoEtWFn+k48TZ78M+Afo8PozvSd3LH6DuP4B1o+wJjWYxzKeDr2af5I0rMbdzS7g8faPVbm+U4XnEZDw9/Tn+8Pfc8rm1+hY82OxgX292t+J9grmGt+u4bU/FS61u7Kh90/dCgjJTeFm/68iTxbHnd6fMIXz91PeHguixfrazg9/nhzVq8O5rnnDjB4cPlmnx63bhzrU9YTERzBnJ4lZ74uy+9Hf+eZjc9Qt0ZdCmwFnMw7yUtRL9GpVif+99//OJB5gF5hvegc0pl3tr9Du6B2fNHrC4fHct3v12HCxN8D/jb6Ci49uJTJWyaXOL645UeW89ym57iv5X081PqhMo+LS43j/rX346F58EWvL2gV2KrU4yw2C9f/cT2n8k7x8eUfczLvJBM2TqCZfzMKbAUkZifyQbcP6B7anVxrLknZSUamriz2//O9Le5lbJuxAHyx7wve2/EeXiYvXuv0Gi/GvUiWJYtZl8+iY82O3LLqFg5lHaK2d20+6PYBCsVj/z1mNI828G1Aal4qOdYc/Dz8+L/2/8f1Da8vc1b97WnbuXPNnQR5BrHimhUOozCLU0pRYCvAy+wFwEe7PmL2ntlE14pmR/oOcq25tAlqw7GcY6Tlp+Fp8uTdru/y65Ff+T7xe2p61WRer3lkWjK5ddWt+Jh9WHntSp7Y8ARrk9fyVPunqO1dm+c2PUfHmh35sPuHRmbT7oMdHzB331yurn81UzrpGWb7ewKgf73+vN759bM+75eCqKgozGbzuQ+sAOc11H369Ol8/vnnTJ8+nVatWuHt7U1+vmP7bX5+Pj4++hu/rP01ajg/d05ERARRUVEu+2nYqiE/pP9ASm4K7drp/TlatGnBytyVHM46TFCIfmGsF1qPiAi9ScV+XEREhMO2zz6rZwQ+AKGhrUrc51TQKSZumsiULVPKLMe+zbO+p9GvIMArgAJbAauyV7H8yHLSC9IJDwrnsXaPMeG6CTwf+TzbH9zOhCsmcH/L+5k1cBbPdXyOvk30mX2/3v81fg38Spyv+Ll/O/obuzN2E+AVQE2vmuxM38n9a++nTrM6REREsPTQUqzKSlStKL4d+i0Dmg/ghoY3sOXBLTx4ld7597qu19EsoJne2dH7oMPjOljjIM9teo7nNz1/zsdfVh3t237J+IXjucdpHNiYUc1HGcd1DunMQ530C8dzm57j9V36h8rVTa+mpndNLu90OZvHbmZpv6X07NzToezeYb3p2ain8T+cet3UctVx7JX6ReCf5H9o2bplue5TdFuHDh3KPK5Z62YsT9IzV4/3evys5bx43YtA4cy4jQIbEdkx0tg/rMcwGvk2Mh5fZPPIEuUM6jDI2D++3/iznu+KTlfg7+lPREQEN3TRR8RtOaXPvVLDowY9O+nPZc9w/fdTvZ8qUU7fy/ryct+XAVh4QG9qM5kU8SqeRQcWERwcAOiZn/K+ZhJz9b4129K30bCFnvmq37w+Xxz/gqlbpvL1ia/5OuFrrKFW2ndob5Tz69FfAbgj8g5ua3obADN3zeTOtXdyIPMAtb1r881t3/DU1U/hoXmwPX07ezP2GufelaH33wj3D+eyqMuM+tx/5f1oaGxP305Q46Ay6/13uj5v069Hfj3rYz1VQ8/IWpSF13a8Rr41v9T3zM70nZzMO4kNG5O3T+bfTL1p/Ma2NxpzP6X66Bfg9w+8z/BVw9nM5jKf2zxrHrMT9KbABQcW0LB5Q2zKxrIkvX9Ovi2fp2KeIsuSRaPARozqPQoPkweLblnEyKYjWXPvGm7ucTMtA1vy3wP/MTp6NH4efhzJPkKONYcrG1/JptGbGNRoEO3bty/z8d/a61a+uPEL3rzsTTq071DiuKK327dvj5fZy9jWqZber21T6iZyrbn0Ce/DFz2/IPGRRK6qdxUFtgIe2/AY3yd+j4bGV0O+IqxGGNd3vZ4gzyByrbnkhuQSfyoegOha0Tx+7eMcfOQgH1/+MR07dCxRhyGd9DmI9mXvIyIigpTcFFLzU41JU/889idJ2UlOfWacz2dmebe58hobFRVlnKMqcTr4eeWVV5gzZw7Tp0/n2mv11GNYWBgpKY7r1qSkpBhNXWXtDw0NdbrCZrPZpT/zt83n5dUvM3HTRExnOhdMXDmRp35/imlbpxltujU8axgRa9Hf9tv795tZvFjvDxUQoCfT0tNNJe5Ts0ZNQJ+5tLRy7L81k8Z9P95Hni2P/k378+FA/dvyJ5s+4Zv9ep+EsV3GYtYK79s8pDmv9HuFB1s/yF2RdzG48WBW3LHCCIAW7lxonGNryla2p213OLcVKx/t+giA/7vi//j0ik8JDwrnUNYhxvw8BouysOSQfnG6pcktDGk7hB9H/MiLUS9SJ6COw2OwL6fww54fHB6XfR6aHek7SM9PL/PxF99W9LZSil8SfuHN9W8CMO2qafiYfRyOe/PqNxkePhyFMpZruD3idqMMP2+/Evcxm81omsZb17yFn6cfNzS8wejHcq46XtHoCkJ9QzldcJq1R9eW+3GBnj2J/jSaW1bewspDK419qbmpfJXwFZfPvZz0vHQa+Dbg6uZXn7Xs9nXaG6NhAMKDwx32e3h4cHX9wj4UDQIblCjn5rY3U6tGLQY2GEjr0NblfiwRYRF4mbxQ6K//xkGN8fDQvwF/NPAjZl8xmyFth5RazmPdHqNjzY7k5OuZ0qTcw9z30328vvV1EtL1PjRW69mfR/u2zIJMjmbqne1tysaqRH0W7KnrpvLehvdYeHAhb/33Fm9tf4tuc7rR4N0GvLfjPY5lHzM6i4+MGMnQxkPx8/TjaM5RTuWe4rL6lzGnxxzqBtSlbkBdrgy7EtA7ctvPbZ+Ur2VgS4c61g+sT2QtPQhdtndZqfXOseSw6qBe18PZh9mfvr/Mx7oleYvxP9yavJWPdn2EFSsnsk9gsVmM+8ScLFyq5GD6QX7Yrb8fB7QcQNsgPfjZdHwTybnJLNqpj7h7+s+nycjPAGDJriXcteYu/jjwB2azme8Tvzee2yxLFvO2zeO/lP9ISEsg0DvQeE4Abm1/K54e+kjCyLqRPNH+CVqEtDAeQ4OgBnx4/Ycs77+czwZ9xqTISfw+6nea1Wp21teZ/ffIjiOJqhVV5nFlvT461uxoZGYCvAKYfcNsTJoJL08vXol6hX5N+hmdsSf1nsQ1LfSBBJ4ensb/8OONH5NlySLIO4gWgfpjCgsIw6SZSq2D/XMkIS2B9Px043XSKqQVXWt3xaZsLDiwoNyfGc5+Zp7PNlf/VDVOBT8ffPAB8+fP56233uL66683tkdGRrJt2zZycwubeGJjY4mMjDT2x8bGGvtycnLYvn27sb8yDW4zGB8PH2JPxrJk5xL2ZOzho1g9AIg9GUtaXhpQ9gzP69fDs882JTraE4vFxFVXKXqcufakppZM2bat3RYNjVP5pziRdaLMeu1M2UlMUgzeJm9m3zCbYW2HEeYTxonsE+w7vQ9fT1/ujbq3XI9xZIeRAHyz7RuUUuxN3cvln13OnWvuZMKfE7DYLCil+CDmA45kH6Guf10e7foo4f7hLB2+FC+TF7/s/YWbv72Zk3knqetX1whuymLf/+u+X41OhEopft2nf7NWKGO4qVKKqf9M5ct9X5Y60eCuk7sY+PVAJm6cyOQ1kxm7biyDFwwm15JL19pdGdx6cIn7mE1mxncYzyt9XgEg0DOQQS0HlTiuNJ3qdSL5qWReiHyhXMfbz2cv/8fdP5bYH5sUy/z980ud72Rm7Ex9eoDMBAbOH8hj/z1G99ndqf92fd7e/ja7Tu7Cz9OPx9s9ftb0vt3IpiON2/aRXkVdU/8a43bx0V4ADQMbcvyJ47wU9dI5z1WUp9mTFgEtjL8bBRZmmGr71jYuHKUxm8y8EPkCnib9fZZryzKaKbal6Bf6oqO9bMqmP29pJZfN2J+53+HvFQkryLfmM2/zPABubHQjj1z2CD3q9MDfy5/UnFS+2PcFHWZ2oMBWQPvQ9kTUiSDQK5Dxl49HQ2Ncl3GsumuVQ1P1TY1vAuDnwz8bc7rYMz+lNUPZ3xNF+xQVFXMyxmGmcXu/rNLEH483HgvAlwlf4jvFl0bvNmLE3yOMeZPswc+19a81Xjt+Hn70aNjDCH42Jm3kh8QfjKbs5OxkXlz1Iv+e+Je7f7ybbWnbGLZoGH8f/Ju5e+cCeud5gA9jPmThAf1L1aiIUUztPJXb2t1GkGeQQ9+6s6nhUYPbI25nUKNB5Xp9X6gaHjXoE94HgHeufYfw4ML3iJfZi8XDFzOyw0hGNB3BhJ4THO5rzxrZR7Jd0fAKh5ne7YovwlurRi0a+uoZyNikWKNbQWRYpPF+XXpoKftPOb52hfuU+5W2b98+PvzwQx544AE6d+5McnKy8dO1a1fq1avHhAkT2LNnD7NmzWLz5s0MG6aPghk6dCgbN25k1qxZ7NmzhwkTJtCwYUO6devmtgdWXuHB4fzf5f8HwDN/PsPUrVONETt5tjz+3P8nUPpor+PHoVcvE7/9Vov8fI127bL48EMbNWvq33xPlTKxqZ+XH81q6t9stiVvK7NeccfiAL3PTYPABniaPRneZLixf1TEKCOLdC5D2gzBy+TFjpQd7M7YzXN/PWd8s5m+djq9P+/NLatuYcKf+hv9+V7P4+elN5G1D23Po20fBeC3BH3phPui7sPT5HnWc7YObE3jwMZkF2SzLlmfMC8hM4HDpw8bx6w6tMood+JfE3l3x7u0/qg1X+z7wmFUxMurXua3hN/49eivvLz6ZTac3IC32ZunLn+KaZ2nldkvQNM0JvScwMo7VzLr8ln4evqWelxpvMxeZZZblhtb6xeiZXuWOYzesCkbI5aO4I1tb/Dqasf+QHnWPN777z0AuoR0waSZWHNiDTFJMSgU7YLa8eGADzn82GH61O1Trnp0rd2VDqF6U0CT4CYl9jcPaM6gloNoFtCM9qHtSy1D0zSnHz9gNKVA4Siz8mri34QHovT+R35eNdg6Zis3NLwBNP21kJZbGBh/u+1bxv0yjsc2PFZiMjn7HFP2juwrElaw8vhKTuacpEFAA56NeJbp/afzbtd3SX4ymSXDl1C/Rn1jhOOt7W81HvszPZ5h9YDVvHvdu0YwZtc9tDv1/OuRXpBuZGx2p+sXtdaBrUs8Pnvws/rQ6lLnCLJnneyv0xUJpQc/+dZ847NjdKvR3Bd1n8P+/Zn7+XXfr+Rb89l0Uu+Ue0+Le3imxzMAXBl2JZ5mT9oE6SMGD6YfNJaEsAdTH8d+zPjY8VhsFoI8g8guyObqeVdzIvcEDQIa8ONtPxLgGUBCWoKxvtwDnR7A0+TJ5zd9zu/X/E6LWi2oqr648Qs+7/k5d0XeVWJfgHcAXwz+gifbP1kiGIuqFQUULmdTtIncbsoUE/36RbK92Fq+9vdGzNEYI/PTMawjV9S5go51OpJlyaL3F73LvQiwuDDlDn7++OMPrFYrH330ET179nT4MZvNfPjhhyQnJzNkyBB++OEHZsyYQf36+rT5DRs25P3332fx4sUMGzaMtLQ0ZsyYcV4fru7wf1f8H2E+YRzKOERcahw+Hj70a9IP0NOUUPo8P/v3g82mERxcwLp1BXzxxU6aN4daet9gUsuY885+wTlr8HM8DnD8Bnlz45vx9/LHhMmYyr08gnyC6FlHf5O+u+NdFu1YpH+bbTMOfy9/1h9Zz/7M/fh4+DAsfFiJjNItTW5hYAt9GLVZM3Nf9H0lzlGcpmnc1Fr/ZmwfafVvst7fwP7hbr9gLNimD1P3NHlyMuck7+14j9fW6PNxpOenG9+URzUbxaiIUdzS5Ba2PbSN1696HX/PwhmXy9KzcU9aBLr/g/iqplfhbfLmUMYh45sd6J1TD6brfZ9e/+d1Y34e0LMGx7OO0zCgIe93e59/7vqHu5vfzWc3fEbio4l80esLRnceTYB3QLnroWkas66fxbX1ry01O6hpGouHLebb3t86NX9VedizCaBnkJx1XTM9oxwe0JDwoHCejniamr56H5lfjxQGA/bs7Mm8kw7zyYAeZANc1+A6vMxeHEw/yMe7Pgbgrsi7HDqjepo9ubH1jXzb51ue7fEs/er2MyautCtrglOzZmZAc31m7eX7lpOVn2Ws39UysGWJ4+v71icqLAqbshlrstkppVhzXA9+xl+h97NadWgVBTY9U5iWm2ZccBMyE7DYLNT0qUmYTxgfXPcB3/X9jmNPHOORro8A+gSD64+sJ8+WR6hvKM0DmvNS75f49fZfGd9BL9/f059WtVoZz2OwTzDjO4zn1na3YlM2cqw59G3SlyV9l9ClXhcjMzT+ivHUqlGLmxvfbNS/R6MedKjTwfi7qny2lyXEN4T2waUH/mfTJqiNw5eo0oKfpUtNZGZ68OOPjs9B+yD9fDFJMcbnQ8ewjpg0E9/f8j3NAppx9PRR+n7RV+b+qQDlDn5Gjx7Nrl27Sv0BCA8PZ968eWzZsoVly5ZxxRVXONy/d+/e/Prrr8THxzN37lwaNWpU2mkqha+nr8OIlqeveJp7ou5xOKa0zM/JMwNP6tXLJzq68Jt+cLD+Oy2t9PMZwU/KuTM/rYMKv0EGeQXx5x1/MvPymbQLbVfGPUtnX/7gvxR9Ysk7O97JPS3uYd296xjdaTTPd3yexEcSeSbiGWPGXztN0/j0hk/p37Q/o1uNpkFAg3Kd0/6t6o+kP9hyYgv/ntCDH/sH9NbkrRzPOc7SnUsB+KDbB0zuo4/+e2f9O6TnprP8yHLyrHl0rNORR9o+wqeDPmV8h/GlZjQqm6+nrzH1ftHV1n8+rE+46GXywqqs3PvDveRac7HarHyZoE9+9lj3x/A0edKpXicebvswd0beWWIOHmd0rteZyZ0mG+t2VRR7NgH0OX6cVXyeHx+zDz0b66vNH8g4xL+H/2Vvxl7+SSycq+a9De85ZNr2n9abDtoFtTMuTvag5J5Ix/e1nY/ZhxevfJFpXaZRq0atctfXvtDmz3t+ZmvyVhSKML8wavvULvX4wW0GA3on6ivmXMHtf9/Oj7t/ZFvyNo7nHsfHw4fHuz1OTa+aZOZnEp8az9KdS6n3Vj1e26x/IbBfGKPqRqFpGibNREO/htT2rc3dkXcDetOrfdbs3uG9jUzeVU2vIsCzMJAuOnvyiPYj8DH7MK3/NOr616VdUDsW3LyAIK8gfrjtByLDImkd2Nr48nNLk1uMJp8xnRxHDF6qPEwedG+gv8e9Td4lZp9WCvbv11+88fGO97VPkLru8DoOZulfhiLr6E3B9QPqM+vyWXSp34WTOSeZv3++Ox+GQBY2NfSv15/7ou6jV51ePHX5U1zV9CqH/aX1+Tl5Un+RBwdbHLafK/Nj/4ZUVnpTKWW06RdPn0eGRRIdEn32B1OKHnV6EOwTDOiB3KTekwBoU7sNHw78kJsa30Sgd2CZ96/jV4flty/nvpbnzvrYRdWNYng7vdPx+D/GG/Ni3BFxhzH3y3s73uN0/mkaBzYmulY0T3R/gmb+zUjPS2dGzAx+SNQ7aN4TdU+V/zYJ+urSAKuO6cFPriWX35N+B+DV6Fep61+XHSk7eGDtAwxbPMyYaLG8/SOquuYBzY3moUZBzn/BsQc/RWd4DvY9c7FWJl5a/ZIx2WO/Jv3wMfuw+cRmh4699sxP04CmDhPk9W/an6Y1zz6M21n9mvTDQ/Ng76m9LNqhBxv2iTZLY195/HjucWKPxbIrYxfDFg7j8d/0UXx9wvvg5+VnBNHf7P+Gu76/iwJbAT8d+YlTOacc+osU1zGsI22C2lBgKzCyY/b+LaUpOnvy/VH6a7BBYAMOPHKAOT3nEOSjZ93q+NUh5v4YvrryK+OLYN0adXnz6jcZGj6UYe2GnfvJukT0atwLgIiaESWaQjMyzGRk6J9TcXGOn1etg1qjoXE86zhWZSWkRojDl5Ngr2BW3L6CN65+g7talGyOE64lwc8Zmqbx4YAPebvr29TwrEEdvzoOgUdpmR/7ALbiwU/NM11xTp0q/WJtz/xsT9le6syex3OPczLnJB4mD5oFNDufh1OCl9mLke31jnWPdXvsvC5M5+Ol3i9h1sz8eeBP8m35hAeF0zqktTGTsH1o8a0dbsWkmTBpJu5tqTfVvP7P6+zK2KXXvcPIMs9RlfSq0wuTZmJXxi5+3vszy3YvI9OSSePAxvSp24eZ18/EpJnYkb7DWILjwc4P4u917ua7i4GnyZM7O95JY7/GXFb/Mqfvb58LrbQZnk3Kk78O/GUsnjr+ivF6nyDg64SvAX1RSfsEi039m3JN88LO3eVprnVWgHeAsSTIrFh9WZTSghK7dqHt+PG2H3km4hkWD1vM9Q2vx6qs/HXgL6Bwlu6iGUR7X6QCWwGLdy42gh/7OlXF2fvt2JvJejfuXWZ9+jfrj1kz6/3EijRbeZg8SnTkLe3Lx0OdH2JCxIQSQcClbGyXsdwdeTcPt3m4xL4jRwpngd+zBzILJ5nHz8OPtrULm4U7hnUs8ZwGeAfwWLfHaOLfxOX1Fo4k+DmLbqGFHbJLy/yUHfzoAU1ZmZ9WIa0wa2Yy8jKMSb6Ksqe129Zui7e55JIK5+u1vq8xo9sMXu7zssvKPJdWIa2MCxTAtc2vRdM0uoR0cTjutva3Gbevrn81LWu1ND70b2p9EyG+IRVT4QtU07smd3e8G4BbF91q9F26rf1tmDQT17e8nrjRcUyKmsQrvfVpCYqPKLnYzbhuBkv6LjlrJrEspWV+7KNk2wXpF+cCWwEta7WkX9N+xlw8q0+sZmfKTnae1Oc3qutXlyCvIDrW6chVTa+iQ3AHbmx14wU8qrLZpxbIKtCX77A3ZZRlQIsBDAsfxqCWg3gx8kUevqzwImrvQ9StduFnT/OazXn6Cn124a+2fnXWzA/oI7vswUgdnzrGGmOliagTwfaHtvNGlzfOWmdRKMQ3hE9v+JQONTuU2Hf0aGEQqJTG5s2O+4suy3G2IFm4nwQ/Z2H/9gWUuq6Tvc9PUFBZmZ/Sy/UyexmzG+87va/EfvuHW1RYlJM1PrsanjXoFtqtQoaTFnV/q/uNIM6++Kb92zJAu9rt6Fino/G3WTMbI1MAox/DxeK9a9+jZ52e5FhyjHWFimau2oW2Y1DDQYy/Yjz3t7zfqVFolzqrVf8mbF/SQr+t/46u2cV4HY3uNBqTZiLcP5zrW+idpKesmcKOZH3oe5vaet8jTdP49fZfmdtzbqnvYVewDyaw6xjWsYwjSzJpJt6+5m1mXj+T5zs+bzTL1fapzY2tbiTEO4SltyxlbJexaGisPbyWLEsW3mZvY8mM4oK8gozBBl1Cupyzubh5reb4eshr0BUOH3Z8jRVv+irazCjBT+WS4OcsImtGGhmf0js8n73PT1nBD2D0eSkt+LFnfiLrXhpvjro16jLnhjmMajaKQa30uXCCvYKNvhFFhxbbjewwkmuaXUOPOj3o37R/hdf5QniaPXm98+tGZ9u2QW0d0t2ibPbMj6nIJ5M98+NrDuD9695nQIMBPNDpAWP/cz2fA+DrrV+zZKc+CWdFPt+N/Robi8t6m7zPmmkpjaZp3Bd9nzFvkN3CoQv56aqfaBfajgaBDbisdmEzYkSdiBIDE4qaetVU7o++n9GtRjtVF3Fhjh7Vgx9PT/2FXHxFpqKZH2eCZOF6EvychbfZm0e7PkqrwFZ0qdelxP6ymr2KBj/FJ7uyO1vw467MT2Ua2nYoj7Z71GGY8dR+U7mx0Y2lDtv3NHvy88ifebfru5hNVW920HPxMfvw/a3f81Lvl3gx8sXKrs5Fw97np7TMj82mL4r6SvQrDn2kOtXrRN+6fVEolu3RZ0+uyOBH0zRjKojmAc1LrOt0IYqWNbDBQOP2ubIGjYMa8/H1H9PQz/npBsT5s/f56d5dnyE7Pt7xS11kWCSNAhtRr0Y9+UJUyST4OYeXer/E11d+bYx6KMre7FVWh2elNDIySi/XPhNu8eDnVM4pjubo08df6mnRq5pexQuRLxij0C41QT5BTOw1sULmGHLWsWOwb1/p89ecj7w8+PZbjbS0CwtUz5b5sdnKbr4Z02qMsU4SVGzwAzC682ha1mrJkPAhbjtH33p9jUz0pZIVvtQcOaL3+enXLw2ALVvAUuTy4OPhQ8z9MczrNa9adRKviiT4uQD2zE9QkOMK597e4OOjbyur07M987P/9H4STiXwzvp3+P3o72w6rg8HbxLUpNwzOAvhDIsFevf25NZb29Orl4kffig7Q1len3+uMXKkiRkzyjcHVFnOlfkpS4vAFtzS7hbj74oOftrWbsuOsTsY3Hiw287h5+HHk92fpIFvA7d13hbnz2qFpCQ983PZZRkEBiry8zX273ccLBPiG0KQV8kv06JiuS4/W83YbIWBTfHMD0BgoJXcXDOnThV+cy2qvm99anjUIMeSQ6sZhbM4+23Rl5WQb3bCXdasCeLAAT1L8u+/GkOGmOnatSXff3/+ZW44M2n19u1+F1S34pMcQtHg5+wdd1/o/QI/7P6BMJ8wQn1DOcaxC6pLVfR8r+cZHDz4vGbPFu51+LDeYd/TUxEaWkBkJKxeDbt2uXYWdeEakvk5T5mZZmNkSvHRXgCBgfq2sjI/Zs3s0KenZ6OeBHoGGsNlL6X+PlVdKVMtVbjTpyE3t2Imcfz+e3324ZtuSuHpp234+Sn++y+Qnj092b///JrCtmzR637ggI+RvSlNfj7ce6/GAw+0YuBAD158sQn7i6zlaL9v0aHu5cn8ALQOac2WB7fwyeWfnM9DEOKC2F/H4eH6F177rP+7dslIuqpIMj/nKS1Nf+oCAhReXiWvnoGB+qf4qVMaoaGll/HRwI+Yt3YeD/R+gOa1mrNmwxpW565m5e6VjO4kozQqQkwMXHedibvvrsPUqZVTh+PHITraRFBQmxJT4rtaUhKsXaun3EeNOsbgwTW59VbF9ddb2LfPm3vuaU23blDfiVUxbDaMRRzz8kwcOFD2scuXwxdfmAD7Egsh7NqlWL3aZpQFjpmf8vT5sWsS3IQ077TyV14IF7Eva9G0qX49iIrSt2/YEMC6dRre7plpQZwnyfycJ3vwU7v0JXyMzM/Zhru3rd2W25reRvNaev8ff09/xl8xnqmdpxLmH+bS+l4MDh3yZvx4M/fe25rY2Io55+LFGmlpGh980ICdOyvmnMW9957GiRMae/b48uef7s3+zJunYbVqXH65jSZN9NXQO3aEL77YSevWisxMD377zbk6HD3qRXZ24X127Ci8feQI5OcX/v3LL/rt3r3T+OwzC/Xr57F3r8aNN5rIzdUuKPMjRGWyZ36aNNFfu5ddpv/eu9eX3r09ueqqKFavrqzaieIk+DlP9uAnpIyJhwMCzt7hWRQqKIA77tAYMqQD775rZvNmf0aNMpGT4/5zb96sX4wtFhOPPupR4U1gmZkmPvqoMDj4/HP3vSWVgjlz9HPddZdjJFGzpoUBA/RtmzY5V+7evY59GuzBT0wMNG1q4oUXmhjntwc/Q4cmc/vtNt57bw+1aik2bNB4/vmmF5z5EaKy2IMfe+anbVuYO9dG376nqFlTkZVlZu5ceQ1XFRL8nKf09LMHP/Z+QGfL/FQEpeDLLzU2baoaa0edOgWDB5v4/vvCJ+6XX2D+fBOaphgwwEbt2vns3q3x0kvu/6DYsqXw9sqVJn77rWJH2C1aFEpGhkadOvoH5vffm0hPd8+8RmvXwu7dGjVqWBk2rGQaxd5HYeNG5573soKf777TsNk0fv+9Fvv26ccdPqxRo4aiU6fTADRpksfSpTY8PBR//VWTbdv0MiTzIy4G69drLFpUG6sVEhIcm70A7rhDMX16Al9+qV8P/vxTqxJ9DIUEP+etsNmr9FdyYZ+fCqtSqSZP1rjnHhP/+18LkpMLt2dlQV5exX8L+fJLjWXLNN56qxHZ+tJdLFyo12PEiBN8952FCRMOAfDWWxrbtrmvs2BampmjRzU0TTFqlD4y6O23GzosRugqK1ZovP9+A3JzC7fl5MA33+jNm1OnKlq1yiY/X+PXX2u5vgLAF1/oz3P//qcICCi5PzJSjy7i4ws7HmdlwY4dZ/8f7NunBz/du+vvhe3b9fOsWlX4+vr0UzP//KOv9dWvH/j4FL5vevSAa86sP7p4sX6f8xntJURFu+ceD15/PZz/+z/N6OvWtGnJ43r0UHh62khM1Ni7t0KryJEjsGXLhY3CvBRJ8HOeztXsVdjnp/I+sH/6qRaTJun/4txcM2+9pWcUjh2DDh1MDBjQkT//rNg6LVumPx9ZWWa++07v5/Hjj/q2q6/WI8XevdMZMcKGzabx0ktN3BKMAOzZo1/UmzeHBx88Sni4IiXFiyVLXPs/y8/XuPtuDz7/vC4zZxaW/eWXJk6e9KRRI8VttyluvFGfOOqHH1y/iGtensaiRfq5r7/+ZKnHtGqlz0+Vna2xW59knMceMzNqVFu+/LLs58Se+bnlFj2g2blTIyvLZAx/B70576+/9KzagAElvzDY75uaqp+ntIVNLzTzY7XCokVw4kTZy0IIUV4ZGWb27dNfr++9Z+L4cf22vc9PUb6+0LGjPpL3jz/K9/myfz+sXBl0QZmibdt86dzZk3vuacOzz0rWqSgJfs7TuYOfyu3z8/ffGq+8oi+e2q+f/or/+GMTqakePPigicREjYwMDwYONPHZZxUToGVmmvj778K/P//cxL//BpGZqdG4saJDhyxj39tvK8LCFAkJNRg1ynTW4dPna/du/aIdEQHe3oq77tJPMn9+4fMxZ46J++9vxeHD53+eVauCSUnRy3z3XQ2LRR/W/vrr+lX9iScUnp5w3XWpeHkpdu70c/mor9Wrg0hP12jUSNGpU+nRpNkMrVrpHa02bdLIz9dYskT/iJg2TSs1+MjLg0OH9OHxN92kf7vNydFYvrwWFot+vrCwfE6e1Ni2Tf/2WVrwc+ONCi+vwhNcaObHZoOEBB+HD/s339S47TYzw4e3Z84ck8svBImJZQdou3fDvHl1yM937TlF5dmzR//8KDohZ0CAxZjhv7jLLtOn+y/voIbHH/fgqada8N13hdtsNjh1qnyDtNeuhbFjWxlfwKdNM3HvvZrDjNPVmQQ/56m8o73S0iqoQsU8/bQZi8XE8OE2li+30a5dFtnZGg8/3JJly/SJuHr2TMNi0Rg92sTHH9dz+7eCtWuDsFg06tVTaJpi5UoTX36pN/sMHaocLni1a8PixTa8vGz8+KPGM8+4PkCzZyw6dtQf+C236FeuP/6AEyf0b3ZPPWUmLi6Ad945//MvXVr4Ijl0SGPxYo358+tw5IhG3bp5PPCAfv7gYCs33KDX4eOPXft4f/pJj9JHjFAOS0cU16aN3ha5cSPExgaQmanXY8cOjeXLSx6/c6c+sVtwsKJxYwgP19v1Fi7U53fo21dx882F7a3t2yvCw0uWExgIV1yRbvx9oZmfadNM3HJLe957T6+/Uvos1KBnHR980IPHH2/u0Ax5IZYvh6ZNzTz2WAsKCkruf/BBD955p5FRH1H1FRRoLFkC48drpKSUDDh279Yzxz176plqKHz9l6ZrV72f28qVlOvLnP1zadaswjfs//2fmWuu6ciPP579vlu2wIABJrKyzPTqZePppw9hNiu+/NLE5MmlvAGrIQl+zpO9U+q5+vxURubn0CFvNm40YTYr3ntPv9iNHq2vF2Z/w06apHj77X0895z+pv300/o8/bTZrQHQ6tX6/DIjRyrjg2DzZr0j9vDhJU/cvTu8+OIBAN5+28Qvv5y7L8yOHZS7w7D9ubB/yLRsCe3aZWG16k1ECxeGGhf/efM08vLKVayDvXvhv/8C0bTCZq0pUzTmzq0LwEMPHcWnyLyC48bp/4/PP9c4etT585UmOblwbp877jj7P9ge/MTFafz9t34fe0bmnXdKflxs3ao/Px066NmaZs30D/+9e/XntndvGDw4BQ8P/bylZX3s7M2ecGGZH6Vg9mz9NfDmmxoFBXq/pV279M7WDz10BG9vxZo1wS4LRj79VK/k2rVBjBvn+D5KSfHgn3/0/V98Ub2aHrZu5YLXe6toViu8/LLGwIER3HKLmbfeMvHJJyUnvrJnjlu3zuaTTxTTp9t4+unEMstt1y6LgABFaqpmfPaczd1369eQ33+HAwf0dcM+/tiEUhrPP28665eBDz7QyMrSiI4+zfffWxg+PJnFi21omuLHH2uXWHC1OpLg5zyVt89PZQQ/9g6z3bplGBMs9uiRwWWX2c5sVzz1lJ5pmTRJ8e67+vZ33zUzdWojt3w4Wyzwzz/6xfSGGwoDAYDwcMVll5V+v2uvPcWzz+r1mzmz3lm/MX32mUZEhJnHHz/3QqIFBXqzCOjz3Nhdc43+D/viCz07A3oWIiVFO+e3rdLMnq2dKVfxv/8dwcdHsXWrRmamBx072hgwwPEF0qOHIjr6NPn5Gm+95ZoPqG+/1ef26dRJ0a7d2Y+1Bz+bNsHffwcD8PjjhzGbFX/+qZWYqn/rVv13hw76i6ZZM8f5CXr3VtSubeH++214e9vOGnz16pVOjRr6/gvJ/GzZ4sehQ/pzd/Sonmn7+Wf9PXHjjYr77jvGRx/pL6QpUzSOHy9fuWXJzDTxyy/6bU1TfP65mU8+qWfsX7ky2Li9fbtGTMyFne9iERcHnTubuP32dhw5Utm1KR+bDcaO1Xj5ZROnTnni76+/DksbLWtv9mrVKgcfH3j8cUXbttlllu3hAVdeqd/+779SRhwU06yZ/hmulMZnn+lfmCwW/XW9dWvZn0f5+ZoxcGDMmKP4nenrPGhQYd+6SZMuroDUHST4OU/nbvbSP1yzszWHSd7cTSn49Ve90dl+IQf9m/Qnn1gYPvwE8+fbHNYbGzdO8dxzB9A0xaJFdXjjjbPXd8kSjTvvbMOkSRqJZX/RcfDvv3ofo5AQxeWXQ58+adSsqb8Rizd5Fff004qaNRWHD/sYHaZ37oQePUy8/nojkpLgr7+CefBBfd/mzf4cOnT2+uzeDQUFJgICHJthrrnmFJqmiInROHXKk/BwxR136FfH2bOde7vk5BQ2tdx/v5WaNS3cdVfhRX3yZGupTVD33KOPPJs168JXSd++HT79VK/D7befO6pt1iwHLy9FerrG8eNe1KihuOGGFIYN0+87b57j5JtFMz/6/QvT/uHhiiZN9Ntvv21l1apNxnGl8fW1cf319uCncLuzmR/7dAXe3vaMlcZvv+nBj/05GDFCbwo+fVrjxRcv7P25cmUweXka7dopnnlGf+HNmlXfGEzw5596feyLHdtH3VWGQ4dg584abN164a+tc5k9Ww+6jx/3YvBgD7KyqvblRimYPr0Rs2ebMJn0z8SdO/XXUEJCDU4WGSdQUFA4yrFly7IDnuLs/S83bDh38AMYTcaffKLx44/6N+1u3fS+Q1OmlN5v7d9/A0lL07sXREc79u978UWF2az4+WdTtR8BVu2XtygogN9+g61bg9mzR+PQoWBjsqoDB4JJSNA4dCjIuJju3x/E/v0aaWn6iJH16zVycgI5fFjjwIFAkpL0QGPv3sIX1ooVNTl1SmP//gBSUvT9+/YFkJKiceCAP6dO2e/jf+Y4fzIy7Mf5kZmp396zx4/MTI2EBD9ycuz38SUnR2PfPl/y8/U1lg4c0N+Udevms3GjXofdu2vQsqXG4MEppKaGkJqqf3OxX2Q6dMhi9GgbM2eamTDBhLe3jUaNfPD0hAMHvKlx5gv/9u2+3HmnJ+DJ9u3w6qtQo0YUwcEmQkKgX78wHnpIn/W3Zk29jseOeRqT93XsqI82S0/3YMwYGx9/bGPwYBPHjunNA8ePQ2qqBydO6PdNSzOTk6M3i82apfHii2beftuDMWNMHDyosX59HRYtAmju8H9dvNhEjx4mYzh9bq5GTo4+6ikvD2Ji9AtQmzZ6mtti0X9CQgro0QPWrNHv98QTVsLDk/n887r8/js88ogXERGlv5aU0i8sP/1k4scfW7J1qz6arXbtfAYO1JvknnxSsXCholOnU1x9tb+ROSnq8ssziI5WbNqksWBBHfr0Kdz3zz8a330Xxrp1GkFBEBpa+ls4Nlbj9tvbsX+//g/29LRx223nDn48PPT/kT07cdVVCh8fxeOPKxYsgF9+CWHePAuRkZCbi9Exu337kpmf3r0d5+rxKMenzbPPKlJTFQMGnASCgbIzP/v2lVwPzWqFFSv0QGf8+ENMnRp+5n/tSWio4uqrYds2vT5PPJHI/fe3YfZsjb59a5T5fy1u2TJ49lkTI0fWJCICI7C65RbFoEEppKQ05JNPzDzzjImff7YRG6tf6B577DCvvx7O/Pkad9zh+gBIKViyBJKTA4ylFYp6802Np582AXr6z9OzI1u2KFqcO1HqtNxcjW++0R+jj4+VzZvNTJjQjD/+AM8qOthuyhQTCxfWQdMUc+Yo2rc/Sd26jWjbVrFjh8Y//2jGMPZduwq/PNWvX/5e7FddZZ9LK4ANG8rOeNv17p1OaKgiOVkDNPr0sTFx4n5uvLEjMTEa69cHOGSuAZYvL3w9Fl9Uu1UrfbTnDz/U5qOP6jNqVLmrfsnRlLo4WqCtVitxcXFERUVhLm2Z9PP04YcwbpzLihPVhMmkZ6s0Tb/o2Be5LYuvr8Jms2E260GgzWbDw8NkbNM0/TXu4WHGZrOSkeHc9xIvLxshIRqaBgUFBSQne5U4Jjxcf6sXFOTj6emFxZKPt7d+XH5+Ht7e3uTn55GY6FPsfrnUqOHNzp1lP8bwcEVQEGRm5pKQUNg0Fh2tyM7OwdfXh9zcHHx9fdE0yM7Oxte3Bjk5hdtycrLw9fU7sz8LPz9fsrOziY8vbHLo2dNGdnYWGzcWfnOOirLh4ZFJQEAAK1eCUno9O3U67XAc6M2PmZkZ+PsHkJl52ugLBdCvn42CggyCgvRtGRnpBAUFkpGRQXBwEJoG27fnOPTX8PZWxnxZUVGK0NBTFBQEs3JlySzHNdekGoFSUVdeqWjSRHHqVCq1atVC0+DkyVRCQmpy6tQpQkL0bampJ6lZsxanTqVSu3bImeNOUqtWLZKSTrFsWWEaun17RZ8+ipSUFEJCQvjyS8Xp06W/ph57zEZKyglCQ0NJSUmmTh29uTc5+QR16oSSnJxMWFgdNA1OnDhOWJie/Ttx4jiffVbYvNeypeLyy4/TuHEoX3xRYIwC7NkzjTVrgo3jnnzSRnZ2EvXr10PTICkpiXr1wjh27Bj169dH0+Do0aPUq1eX48eLbjtCvXr1OHYsiQYNGjhsO3o0iWPHGvDLLxpmcwH33edBgwZw5Mhh6tevT1LSERo1agTA4cOJNGjQgKNHj9C4sb7tr79SWLBAf9xduyoeeECRmHiI8PDGjB2rkZenERqqGDfuAE2ahPP115qxDMwrr+ynSZNwNA0OHDhAeHhjDh06RNOmTYpsa8ShQ4do0qQJt91WeP0aP95GaOj+M/c5SEZGM15+2USPHuk88YQvhw4dZNas5sbEofqXsQQ+/LAFu3Y5vh8feMDGtdcqhg3Ty3/tNRs1a+6ladOmHDiQQIszUe6aNYeYNKnpmfJs3HCDYt++PTRv3pyUlN3cfHMbl15jwX3X7wtR7YOfv//WO2UCtGmj8PbOwtPTj5gYjQYN8mjUyJOsrGx8ff1QCrKysjlyxJe0NP2F16WLIisrmxo1apCdnUONGvoHY1aW44dkRISNnJxcfHz0C0N2di4+Pt7k5ubh7a1/SOTk5OLh4cP+/frcMwC5uXl4eXk73M7Lyycjw4vTp89+wQ0Ly8fDwxOl9Auih4en8VspsFgsmM0eDrezs21kZ5fv+Q0IUOesQ9GLg52HhzLStUV/2y9aQgghKsfChVYjgHKVqhj8VPtmryuvhP79Fb//rtG5s43HHtvFW29FExOj0apVNsuX+7Flyy6izuSR4+J2kpnZkT59PGnWTLFunY24uJ1ERESwZcvOIsft4MEHOxETo/H223sZO7YxW7bsKLJ/O/n5HZk//ySTJtUjMBDWrdvB889HsXeviUmTbNxyiyIubluR+2w7c56tLF4czZQppQcLvr5Wjh61snfvliL33XLmvkW3bXa4bd8fGhrFgw+a+OMPRX6+/g02IEARHa3PHxQdbWPmzE106mS/b5xRzsqVW3j55Y78/beJMWNszJihuPHGNH7+OYSbb05m4cJaxn1K1qdwW2Skvm3TJr1spWDRol3cfruesh850sannyri4uLp0KEDW7ZspWPHSJSChg0VGRkeTJ26j7lzm7Fjh0aPHunccYcfv/12iqVLQ43n6scfrXTvDps3b6Ft23Zs376dDh0iUAq2bt1KmzZt2bFjBy1bduDee0389VfZAdojj9jo02c7ERGt2LVrJ23btkcp2L59O61atWbnzl20a9cOpWDHju20bNmaXbt207Zt2zPH7aBVq1bs3r2bNm3aYrXCnDlH+e67hhw4oDefvf22CU/PXbRu3ebMqKZjzJjRAIDAQMXvv9sYOTKPvXt9adYsh6+/1jM7u3btpmXLVgDs3r2b5s1bsHfvPlq0aHlmm/7Nb+/efZhMrbj3XhN+fla+/95GQkICzZvr3xp37NjHE0+0NPqxffqpjfz8vTRrpkfre/fuo0mTpuzff4BmzZqhFCQkJBAe3oQDBw7QtKm+bf/+BBo3bsKBAwdpeqYtISFhP02bNj2zfz+NG4dz4MAhfv+9mfEtu149RVKSfttkUkY/oJo1C2jWzIPYWP3vu++20rz5IcLDw5k2TSMtLY9XXtGfi4MHD9KwYSMSEw/TuHFjfv8dvvlGf523bJnNU0/pX0YOHdIzBImJR8jKasR77xVmc8aNszFjRuHf4eGKJ55QJCYepl69+iQkHDf+L/b61Kx5lJycBnz8ccms0JQptjPZDn1U0dGjRwkLq8uxY8epW1efhiIpKYmwsDCOHTtOQEA9pk8vWc5ll+nrpJVl/HgbycnHSU8PM+ZweughG5mZeuYnOTmZ0NA6KAUnTiRTu3ZtkpNTqF1bf8/o+0NRCt5//9x9eK69VuHnl0KtWrVYuzaX7dsLuwMMHaoIClKkpKRSq1ZNTp48Ra1a+ufDyZOpBAfX5NSpNGqemTjn5MlTBAcHk5aWRnBwTZSCkyfTjGbOstx4o43MzHSj79XZtGuXRdOmvigF6ekZBAYGcugQbNtmz+6dpk4df4fFf7t2zSAgIACl4PTp0/j5+ZOZmYm/v31bJv7+fmRmZuHrq2cxT5zIOeuIr8aNc6lb14usLP0LdX4+5OXl4OfnQ06Ovi0pCeO9UJqICEV2di7e3vqXbB+fwi/Z4GOsQl+Uj4+V1q3P+TRdGtRFwmKxqJiYGGWxWFxe9rp1Fj3voNnU9denKHsewsfHotLT84zz2uuwaFG+AqW6dLEZ2/LySh539dU2BUpNmpRQYv+8eduUn5++v3lzm/r9d4vq3DnDOHe3bjaHx1z0PBs2xKiWLfX7jhhxTM2eXaAee+yQuvVWq2rf3qYee+xQqfUpbdvZ9v/zT6z65Zd81bHjaaNeoNQPP+SftZwVK/LPPH82tWuXRXl7WxUoNXfu9nPW51x1/L//s6hevU6p1NSy73PzzScUKNWiRZYCpXx9beq33+KM437+2aLCwmwqJCRfZWQ4V5/162PU+vX56umnD6r77rOqLl1sqm/fVLVrl/OPy5nHX1BQ9v49e/KM5/jDD63Ky0u/PWfOjnL/r4tvO3rUotasiS31uNOn89SsWTtVVtb5le3s63HOHKvD6w+Uuv9+qyoosKiXX04osS8sLE9lZTn3Wn/88UMKlDKbbeqTT6zKYrGo//6LUa+8UqACAgocyl+4UL/Pd99tVrVq2ZS3t1Xt31+y7Jkz9XqHh+eo3NzC88XHW9SCBVvVwYN5xudOSkr5n8cNG2LULbdYizxem7rhhmSVkKAfN3/+VuXtbTP2a5pN3XRTssrOdiynYcMcBUotWeL8/ygx0aI8PPQ6fPGF/r7euNGigoIKn6u+fUt+Ph46ZFEtWuh1GzvWesGvmTff3KNAKT8/izp5svC4//6zqOBg/TyvvVagFi3aonx89L89PUu+nkCpmTMLynzNhIXlnXl/7VIFBRYVGqqX9c8/JT8Ly/tY0tMtasAAm/E/sv/+80/nn5MNG2LUSy8VPq6tW899n2XL4lVISOHrJDDQpj79dIdbrrHuvH6fr6rd/b6CdOkCffueQinNmAzOx0eRm2tm9eqS0fHJk/q2skZ62dlHMxXvv3H4MDz+eAuysjTMZsW+fRr9+5uJjQ0gMFDvjb9+vVZqZ1jQOy/v2aPh46N48MGj3HGHjTvuOMFXXyni4/XbruDtrejXT/HJJ7t4800b/v6Kvn1Pcc01Z28p7dVL0bZtFrm5GoMHm8jLM9G2rY327cs/KqIsr75q5e239xEYWPYxPXrok+XZ55p56CFFrVqF05pecw0kJNhYunQrvk4uHWY26307hg9PZuZMPfM3fXqC0UzpLmcbDde4Mdx5pz5CbNw4jfx8E1FRNocZs51Vp47j+ltFeXlBp06ZeHufd/FOuf56xahRNq65JpVHHrEyadJ+ZszQ+1wNHJjKxIlWAgMtXHed4s03bXz22c5yda4uauTIE9xzjxWrVeOBB0w89pjGo4+24PnnPTh92oMaNRQ9e+ojgG6+Wb9Pw4b5xMYW8PXX2znTncTBvfcqvvjCxvTp+xz+f+3bQ/PmudStC40a5aKUxr//lr+u8+fX4dtvTXh4KN55Zw8HDhTw4osHadxY39+iRS4ff6zw91dcfXUqmzYV8PzzB/Eq1g3s8sv1UUO//up8c/PHH2tYLCYuv9xGu3b6+7pjR/jggz0EBirj8RdXvz58+KHec/2jjzSHJVDOR+EkqckEFXbfolMnmD5dP//LL5t5+unm5OZqXHONYtWqOP74o4AxY45y5ZUKLy9Fnz6nuOuusudSiI7W5yXbtMmfY8cgOVnDZFJGR//z4ecHS5fauOmmFKPJf8IEZQyHd4amwcSJiu+/tzJ16j7atDn3ferWLWDePBtmsyIoyMJvv1mIijr/z4yLjQQ/Z4wde9SYpnz8eBsjR+q3ly8v+RTZhzyWNcGh3ZkMLqdPF7ZxZmTAjTeaSE72ol07G999t5WhQ/Vy/P0t/PyzhSuvTAMK54gp7vff7WskgZ+f+5e6Npvh0UcVqak2pk5NOOuFGPQ3on14uL2j3t132855P1fp2vU0Xl76c+rrq3jyyZL/J29vfWj1peKuu47RqJEyPkTHjKm459vdatWCOXMUr722n+nTrQwalOowiuWFF6z8+Wc8y5bZePRRRVhYKVMsn4OmwYcfWo3JQD/4QF96pUYNxfPPHyA11cbKlTYGD3ZcF61+fQgPL332S03TJ/QsOvy/uKgofSjymjX6P2vdOmja1MQ997Tm6afNJeaXWbNG4513GgL6xb1nz4xSp0sYNUpx6pSNKVP207Zt6ee+4orC4Kc8PT9zciAx0Zu9e/VpGAD+9z/Hibfats3m778LeOGFA2WOLuzXDwYMOIlSGmPHmspcbsFq1edQKio9Xf/yZ7XCv/9CXFwAnp6KESNKfuG7+25F164Z5OZq7NtXg+BgxSef2PDy0gPZBx5I4s8/bWRl2XjjjbN/rtn/T+vXB/LRR/qB+kCAsu9THh4e8NxzB3n/fQv33ZfE889fWBfc66+Hq65KK/fxV18N27frXwSjoy+K7r8uI8HPGU2b5jJ3rpVHHz3Mq68qYyba0oMf/cVf1gSHdsHB+u8jR/SvyBYLjBhhYvNmjZCQAr77zkK9evnMn29jxQor33yzg8suUwwZok8A+OWXWomhvErpQ+eh9FmR3clk4qxLIxR11VWnaNzYPmeLYuTIigs0fH1t9O2rn/uhhxRnBq9c0nx8FFOn6o85IMDCrbdeOoFdRdFnQk9iwQIr/v6KZs1yWLvWwk03nXTb8Gz7RfWff/T3+Usv6evubdnizzvvmHnggdbGWnMpKR7cfrsHVqvGiBE2Hn747O//cwW/XbroXxIOHNA4eNAxjbdhAyQlFaaKTp/WF0O++eYOtGljJjlZIywsn5tuKlmHtm3hxhtPnvX8jz9+mOBgfTqH4cPbM3asmVWrChfxPHzYi27dPOjXL4rBg00sWgRvvtmQZs08GTmyHS1bmnjoIf3DaORIG6GhJQNePRtyEF9fvdD33lM0aFDisHJ9SbDPl7N5sz+vvaaf90Iyq8XPP3q0jYceOlop0wA0b144L111IsFPEbfeamPUqOOYTHDVVfpFe+9ejUOHHD8YCjM/Zy+vUyf9TffzzyFMnGhm+vTG/PqrPsX+22/vNSbX0zTo2xfq1dPni+jWLYPwcEVamlaik15cnMbhwz7UqKEYOLDqRuoeHvqCnaAHQhUdgLz7roUnnkjkpZeq7nPkasOHK7780sZ77+01ZnUVzhs6FJKSbMyfv5127dz7+rEHPxs26PNurVihoWmK8eMPceONegD7wAMa//0HzzzTjGPHNJo3z+Hjj88+MWh51Khho1cv/fa//xa2Gc2erXH55WZGjGhrLOg7darGwYN6M72fn95ReezYI043L9rVqmXhww8Vnp6KxEQfZs828+STLeje3cQHH2jcdVdbtmwxYbNpLFumL0j7zTdhZGZqeHjYOHRIMybYfPzxsi/cDRrk8+uvFl5/fR8jRpz//7Jp01zattX/H126KF591cbjj1/Aasei0knwU4bAwMJ23rVr9Q4mOTn6go0//6w/befK/Nx8M0yapL9h3njDzOLFoWia4quvCtvJS2MyFbaXv/lmI1q3NtGkiYnnnmvCa6/p+f6BA8G/5IzrVcq4cYrly608++zBCj9306Z6Pw4fn3Mfe6nQNH3h0oiI6tNu7y41apQ/y3khGjfOo04dfTqIV17Rvw3pyxAkM3++hSuuSCcnR6N3bxNxcXqfwOnT97ksuL32Wv1zZsGCUP79V1/P7aGH9KAiM9ODsWM9OHbM01jYd+rUfaSn2zh50sb111/Y2j233KJISrLx1lt7GTfOiq+vldhYjcceM5Ge7kGXLjZmzdrF44/baN5c0b17Oj/+WMDKlXF88YWNgQMVDz54pMxmPbuuXRX9+6ddULBoMsE//1j49dd41q2z8cwzqlpmSy4lEvycRY8eepv4338H89FHGi1amJg6tTEnTujNVvamlbJoGjz3nGLSpP3Gwo5vvKG48cZzn/ueexQ1aijS0z3Yt0/j8GGN5ctD+OEH/V82fHjVb9bQNOjfH/z9q35dhagMmgY9eui37cPAx47V3y9mM0yevJ+WLRUFBfqVe/ZsC40bn8cKu2W49VZFaKi+dEyfPp6MH98Mm03jhhsUXl42fv3VxIMPtiI3V+PKKxW9e6e77Nygdw248sp03nrLynffbeWRR2z4+SluuimFP/6w0KlTJtOnK3btsvHBB3u55hp9xvGRIxU//GDj/vuPubQ+Z+PnByEhZXRQEhcdCX7Owj5q6L//Avnf/0wcP65Rt24eb79t4fvvt9CyZfnKGTQolXXrLLzzzh4eeaR8qdf69eG//2y8884e/v7byh9/WBk58jiNGytat85m4MDzfVRCiKqkR4/Cz4TWrRVXXVW4LyDAypIlNq68UvF//3eIG290bTNcgwawebPNWGjYYjExYIDi229tPPig3vn78GE9fTp9uns70deqZeGttxRpaTaef/5gtcraiop33sFPfn4+gwYNYv369ca2xMRE7r77bqKiohg4cCBr7AsknbF27VoGDRpEZGQkd955J4nlXRWzkjRtmkuzZvqHTZ06ivfes7F06TbGjrWVOQy4LBER+sgMZz482raFnj0zuOIKfRbqJ544zJ49BXz11Q6nh2gLIaqmnj0LP0vGjlUlmtvatoU//7Rx663Jbjl/aCi88MJB1qwp4KmnDrFggQ1PT7j99uN066Znoe64w0bnzm45fQmXyihFUbWdV/CTl5fHE088wZ49e4xtSinGjRtH7dq1Wbx4MTfddBMPP/wwR4/q3x6OHj3KuHHjGDJkCIsWLaJWrVqMHTsWVYVX19A0WLTIwgsvHGDXLhtjx+od9IQQwlWioqBFC0VYWD6jRlXe58tllyluuy3Z+GJlNsPChfrAgfffl889cWlxuq/+3r17efLJJ0sELevWrSMxMZH58+fj6+tL8+bN+ffff1m8eDH/+9//WLhwIR06dODee+8FYMqUKfTo0YP//vuPbt26uebRuEH79gqb7SQBAaXMYiaEEBfIwwM2brSxceM2AgM7nvsOFSgsTB84EBBQv7KrIoRLOZ35sQcrCxYscNgeHx9Pu3bt8C3SHtO5c2fi4uKM/V26dDH21ahRg/bt2xv7hRCiuvL1lYEBQlQkpzM/I0eOLHV7cnIydYpN5hISEsKxY8fKtb+8rFbXDy+0l1n8t6u2VbVyqnsdq/vjlzpWrXKkjlLHqlq2q7ijzAulqQvodNO6dWu++OILunXrxrPPPovVamXq1KnG/kWLFjFz5kxWrFhB//79eeihhxg6dKixf/z48Xh6ejJ58uRznstqtUqWSAghxCVFy83F+/BhlJcXefYF2i5RUVFRmIuuTVOZLmRV1FatWql169YppZSaNGmSeuyxxxz2f/XVV2rQoEFKKaUGDhyovv76a4f9jz76qHrllVfKda6iq9HaV6d11Y991dvs7GzjHK7YVtXKqe51rO6PX+pYtcqROl7cdYxdu1blv/aaSr7pJpUXF6cft2GDyl2xQh0eO1YVvPmmKpgzR+1+5x2V++efavvcuapgxgxlufdeld6tm7JGRytbw4bKpmnG0vLWXr1U/oIFKmb9+kp9/O66xlalVd3Pc3LyksLCwti7d6/DtpSUFKOpKywsjJSUlBL7255res5izGaz2yJHe7lFy3fFtqpWTnWvY3V//FLHqlVOtaujUmCxYC4owL6YlyvrqOXmYt64EQ4dwiM4uOz7KIU5MRHi4gjeuxeP5GR80tMxR0SA/T4mE5w6BTZbYTkAf/5JuwcfxPPgQWoD6scfUSNG0CYuDu9t2yi6hJh9OriiV7pAHKmgIMjMxLR6NabVq6l/992YZ8684OfkfJ/HotsvVS4LfiIjI5k1axa5ubn4nJmdKjY2ls5nJoeIjIwkNjbWOD4nJ4ft27fz8MMPu6oKQgghKkNODvz3H/779qGZTHgfOAAnT6IlJlJvwwbM+fm03L4dU3o6HDpE5+zC5X0iatfGIzKScF9ftNBQMJupb7Nhio6mZno62vr1kJ5O7dOn0ZKS8MnK0qdbNpkI+fFHPJ57jqjVqzFpGnh4EJ2ejnYmqIrw8kKNGkVgRATaxo1w4ABNNm3CIz2dyG3bMKfrE9k2P1OX9oAKCUH160fTtDRMW7eiJSUR5eOD1rYtbfLyMO3fj5aTgxlQYWFkNG9O0Nq1aF99hR+gvL051asXwcHBaKdOkX3kCL65uRRkZuIZGYnq0oWDNWrQODoaatdmS04O7Xr2ZOcff9Bh9Wq0774jv7QVWIVLuSz46dq1K/Xq1WPChAmMHTuWv/76i82bNzNlyhQAhg4dyuzZs5k1axZ9+/ZlxowZNGzYsEoPcxdCiIuGUrBuHf7btkGHDpRr1VGlICkJv7g4TNu3E7p5M9ratWAy0ejvv/HYvp3o3bvRunVDXX89frVr64sKBgTgHxOD6bffaLFsGaaNG9Fyc2l9ptgORU5hHyRfPNth55WSAn/8QdF1ouud+d2syLYz60DTvsi2JmU9rDp1oFYtTDt3wuzZFJ2MP+TMbxOgPD2hQwcylcIvPx918CDmkyfRFi6kVpH7mHNzYdMm7EuqKV9fkm+4geD33mNvYiJRublos2dzzMOD2i+8wP7jx4mKikIBO+PiiIiIYMuWLURFRQGQGhdH4zO3rXFxoGkUhIWhXn0V9eqrpMTFGc+BcA+XBT9ms5kPP/yQiRMnMmTIEMLDw5kxYwb16+sv/YYNG/L+++/z2muvMWPGDKKjo5kxYwaaTOcphKgKkpPx37QJmjeHgIDKro2juDh8EhKgdetSd/vs34/p2WfRfvuN1oB6/nnUTTdRXynMYWHUS05Gq1cPNI0G+/dj9vamxbZtmPbuRTtxgjZnyina3dZhbO7q1WirVxvHAUagY18PXjVoQJ7ZjHdWFracHEzh4dCwISl+ftSMjCRR02h8xRXQuDFbDh8molMnsFjY89NPtMjL4/iWLdSrWxcKCkjZsYPaOTlkJSXh37AhKjCQjAMHCExNxXrkCB42G+Tnk9OwIV4jR7K7dWtad+kCFgtbjxyhQ79+oBR7586l5Y8/krd1Kz4tW6KaNuWopyd1u3dnj81GqyFDwNub3fYAZdMmovLz0f78k6QTJ6g7bBhER7Pjjz9obbNx6MABmtxwAzRrRuKWLQQHB0NiInTvjurenaS4OGrXqQPHj1/4/1y41QUFP7t27XL4Ozw8nHnz5pV5fO/evendu/eFnFIIcamxWmH3brwOH4bIyJLrGygFR49iTks70y1U6ReXQ4f0rEGHM3mG9HRYs4awP//EnJtL03370Lp0QUVHE5SYiLZsGezeTZPUVMx16tBAKRgyBCIjqf/hh3guWEDrrCzUQw9Bt240DgvD3KwZ9dLS0PLz0fbvp+3x45h8fcHDg/odO8KTT+rnPnkSDh9Gy893+dOjffYZptGj9SYZs5l24eFod96Juv12AjZswPzGG7RbuBDNakV5eWGtUQOP5GS0Tz81sgdFpyise+a3EbSYTOTXrYtn8+akeXtTMygILBaSfXyoOXgwuzWNtidOoP30E/lbt+KVloaWlUVe/fp4duvG0UaNqHfvvdC+Pdvi40tkOQ7FxREUEUHqli2F2Y7MTAjUc0FZERHYIiI4tmULdc/sT4yLIzgigt1FytlXSgZlx5ltOVu26EErYMnJOfPEaWRGR2O58062F7nP8bg46kREkL1lC3h7Oz7ZHh7QpQvqiis4Fhdn1CevSRNURARpW7ZQ7kUdRZXmssyPEEI42LQJ03330fHIETxCQmgLmEwmyM6mPeBRpw5tcnL0PhTZ2UQAqnZtuOwymtpsmGvXpuXevZh270Y7dYooQHl4EG02Y8rTVza336dtcDCmhAQ0m42GZ05fC+D33wFoUaRa9maPugBffgkUNrNYAgPxyMiAf/4h9My2ooFD0SX16sXEwGefERkYiDkjA4B2jRqhffIJ1D7TiGO5sFXAffbuRXvkEQBs3t6Y8vKokZAAkybBpEm0KnKsuuEGbNOnE5+WRlRqKtrvv5Ny5AghNWty8uRJateqBUqRnJVFSPPmHMnPp+GgQdCxI1t37yYiIoL9W7YQVCwAyd2yBTVsGGrsWLbGxelBhMXC1q1biYiI0DM2HToUr7oQVZoEP0Jc6rKy8D54ENq0wVgqWyk8k5Nh+XK0ffvw9/UtzKCcjVJgtaLl5cHp02CxoBUUlDjM6+hRTKNHox07hifAyZMOgYMPwKFDhX0o/PxQBQWYUlLgl1+M/hb2fiLKZEKz2dAsFjSLBaVpULcunDiBlpKC75mRpKplS041bUpQVBRH8/NpcPo0Wnw8ORkZ+HTrBu3acSQ5mXohIZyKiaH2tm1ou3eT06wZHq+/zuamTYkKCkL76y+OxcYS5u1N6tGjhERGQtOm7Dt1imbNm6OlpHB65kwC//1XD5YAVaMGPomJcN11tOrUSe/cm5BA6/bt9YDI09OpfxtZWTSbMAEtNxd17bVseuUVIkJDOfL55zRZtQpWrsTm6wsjRrD7yitpZZ+ANi4OrrkGdc01RgCTuGULIWeCmsNxcdSMiCBlyxYantnmtPL0JxKiCpNXsBCXsj/+wDR8OB3sF+jQUCJzcjDn5NCxyKyrrQH16quER0VhOtPM1Mpmw9yyJY3z8jAlJ8OOHXROTQWgU5FTRHl66s1L3btTq1YttOxsWv7vf2jHjqE6dmTnU0/Ron59DmzfTrP27cHHh73bt9OsVi0O7d1Lk+uvh5YtiY+NJdJmQ4uL40hCAvVCQzly+jQNBw+GDh2Ij4ujQ5067Nq6lXZXXw3e3sSvX0+EUhxct46mw4dDgwbsP9MUcmLLFuqf6XS6w56xAE7ExREWEcGhLVuoFRUFmZls37OHiI4dYcsWaNYM1awZSZ07U7vocUBGXBycKXNv+/ZE1K7N3n/+ofWgQWC1cnLMGEIXLSJg40bj+fHfuhXVoweNb7oJbcAAVFgYPjk50OJMPspigSNHqLliBdrMmWjr19Pu9Gk8rVa8Dh1C1auHbe5cOHIE6tcnddAgGj/3HJw6Rfzu3XTo0kVvwhFClJsEP0JUANOHH9L2o48wBQaCtzdtTp3C02IhIj0d05mMQFs/P8xdulA3OJj/b+/Og6Ms8wSOf9++ckNuchASCCQQ0gmXoAgzyowieIxjKZYzJe5gMYquTIGuiu4A1lCDOqwj5Y7o6FClUzCr48HsgiKCi6wKSMCGRAgJkEDuA9I5oc9n/+j0Ox2IApp0gv37VFHpfrr7Od6X9PvL+1za+PEQHU1iaSnaW29BVRUjW1owJicz3ONBmz0bNXEiEWVlaCdPEldaChERPcYjxG3diuGZZ9BcLpTRiObxoDU16b/0ymCAnBzIysK7axfGkydJPHlS/3wMwIEDevfPN7bN5YLdu9F272Zkd5oZUBkZeP/nf+hqakJZrbTFxvq2MAc6wsL+OYZirG8YrbJYfIHF1VfrAUrg3QllsUBGBk67XR+robrzaQ0Ph+86PTg6+sJxRpcqNZWzubm+qddA1RNPEPfoo9Ru2sTwWbMgLQ37Y4+RsHUrSe+/D++/D3RPqdY0CuLiMNjtaF5vj5lNEd0/ldGI9803ISnJF/wEiotDnT9mRQhxSST4EaKfWaqrMT7+OJEB3UP+7h5LwPsiAY4e7bFAWmbAY39X0DCAjRsByOtOGwXw9NOo2FjGx8RgBkZVVQHgvesubEuWUJidDTU1HDlxgpzJkympq6Nw6lQADu7ZQ8GJEzTu2kXKhAmo9HROHjnCCIOBxuPHSZk5E5WXR0lzM+MKCvi6rIyCSZPAbObI1q3k2e2wZw+de/cSXVmJ22jEsHmzLyBpavq+h/CKoiZOpNlk0oO2ylWrGPKb39C6bh0JTic0NOApL8fU0YG5+06aslg4m5lJ+Jw5qOuu41hjI6MyMzna2cm4668fwNYI8cMkwY8Q/Sz95ZfRXC7aJ00icvlycDqpqKkhMz+fY3V15IwdC0pR8X//R1ZnJ6179xJvNkNHB60OB0MmTIARI6hpaCA1IYHThw6RfOoUHDyIOywMY1YWXS4XUeXlaHY74Xa7XrZ38WLUmjWoQ4cgIQESEnB4vZCWhjp9Wn+fCg/He/fd1OXlMaz7ot2SkcFwq5W64mI9zW2zQUIC3uho31bkgCMjA3XrrXDvvb4pw/n5vhk54wNXZAltatYsTiYlEdd9HA9+9RXWlBSOffopuT/6EaSkcOTQIb1rrsNmQ1mtOKQ7S4h+IcGPEP2pqIj4bdtQmkbV0qW+sSFAa/fFrau4WO8KajUa8VqtVBYXExswvff8sSrVxcUkdqcd6h7fctQfbHz9NeU2G9l5eZSePk3enDlBbjC+LiRZv+vbaRokJ3N27FhIS7v4+4UQfUqCHyEAc2Mjhj/+kYwDB9BmzECNH0/UyZNo9fXE2WxoW7b4lsavr8c4bBiZLS0YPB6or2dsZyeG4cNRSUkkpaX5ZsIo5durZ9kyALz33OO70PVrI8wwYQKdgLJaccpdAyGE6JUEPyJkaB99RP6iRRimTEHNmcPQzk60999H++wzrLt2oSnlW9X27bcB9NVsAwei+teICVyKPwrgyBE0ulfIXbOGSd1TswG8ZjOeFSt8U8OFEEIMOAl+RGhwuzEtWYJWUwM1NWj/+EePhe8AvNdeS+PIkQxraYEjR3A6HJgTEug0m4myWiErixq7ndSEBBpqakgtLESlpHDi5Emyhw6Fqio6Nm8m5uBB3zo4+Aay1v761yRnZfmmUQshhBhwEvyIkBDfvZifKzYW4+LFaB99xLnmZsJmzIApU/g6M5Pc2bOpKS4mqXs8TUn3eJrAJfb9424Cl+Jvs9lQ3Y/L587FOmYMpZ9/zvhrr4XISBoOHuy5T5IQQogBJcGP+OFzu0l9/XUAGu69l9Tly1HLl3M4YDCx02bru/LCw3ElJ+trvwghhBhcDANdASH6m7ZxI+HV1ajERJruumugqyOEEGKAyZ0fccUwNTdjWLeO4fv2oWVnQ0wMqceOYTQaGVlWhsFuh1OnKHQ4MEZEkA8YoqOhvh4Az9Klvr2QhBBChDQJfsTgtGsXhn//d6zl5RgyMsBspmDfPjSv17fCcTf/CinxAWkmgNZWAhf+dyYlwYMPwokT/V1zIYQQg5wEPyK4mpowPPggWU4nhrvuIiIiAior0Y4cIa2yEsPw4YzatQvj//4v0L39Q8D2CN6pU2nMySE5Kgra2jh97hzxOTnUulykXXstjBhBaWUlOVlZHDt8mJysLHA6OeL1Mk7G4AghhECCHxFk2mOPof3jH771cj78UN+bCiC1+2ccvk031cKFlF19NWPi49Hsdr4eOpTcOXN6zMg6ZbMxNGAHb4BzmuZbPVnT9NWT3X05oFkIIcQVTYIfETQx+/Zh2LABpWk03XknicePo44exZCbixo3jmaXi4QhQzjd1kbCk09CQQGdNptvp2/6eEaWEEKIkCXBjwgOh4MRq1cDoBYtomrBAmKtVt8GmN13Z6psNmKtVqqKi0koKBjAygohhPghk+AnVB04QNz27dDZCRkZ0L0Vw8VoLhfGJ56g4K9/xZCUBOnpjNQ0tKQkMBoZ2dCAyWJhVFcXWm4uJCaSfvIkpvp6DKdOoVJSUL/7HVRU9HMDhRBCiN5J8BOKjh7FMGMGo5xOPWlCRARafj6joqN908M9HpJzc2H58n9+rqKC3Pvvx3j4MEaA06ehtLTHTCv/4ziA7kHLKQGvq//4Dxg6tF+aJYQQQlwKCX5CjVIYFi9GczpxDhuGOTISqqsxnj0L+/b5gpZuGR98gNqwgYwf/QhDbS0UFRHldKLi4qh47DEyr7oKraaG6sOHGT5sGLjdVDc3k5adTe2JEww3m6G5mabOThJycjgZGUnWvHkD1nQhhBACJPgJOXHbt6Pt2IEKC+Poq6+Sd8st4HZzZPNmcp1O6mw2hmdnQ1sbrj/+kbDaWpLfeUf/fEdhIZZ33qGltZXM7oHITTYb6d3jdppsNlKsVpqKi/W0apuNOKsVe3ExaFrwGy2EEEIEkODnh0ypns/PnGH4Cy/4Xnr8cZzDh/vSTSYcWVkoq5WmnBw9aCmZOZPC4mJO79hB0g03oKZP52hHB9YRI2SHciGEEFcsCX6uVC4XbN5M0r59GLZtI/3wYQzNzVBaSmFzM8Zz55jk8UBiIiQlYW1qwtK9WKAaNQr1+ONw9Oi3l2Ey4Z0/n+qJE0nsDoiQ6eZCCCGucBL8XIGMbW0Ybr4Z7ZNPGNGdFjiouMdJbWqCpibfSsmAc9gwjOvXQ0REUOoqhBBCDDYS/Ay087umAnm9Paaga+fOoX35JWP/5V/QTp1CRUdjnzaNIampNHs8JM2ciRo3jiNnzpAzcSJHysrIHzYMGhspq6sje/Zsimtq9HV1hBBCiFAkwc8AMv7bvzHx1VfRrFbUlClktLRgcjjIPXYMQ2sr1NX5uq5iYiA8nEmNjQCYATViBN5Nmzjh9WK1WqkuLta7phw2G6Sn4z5zBqxWALpsNoiPh5qaAWmrEEIIMVhI8DNAwiorMfznf6J5vVBUhFZURHL3a9Hnv7mtzfcPUEOH0lpQQMx//RcMGyZjcIQQQojLJMHPAEldvx7N66X1mmuIeeQROHCAhuZmkgoLOel2kzV9OqSlUVJWRn5GBnR1UWy3kzdjBsdLSpgwbNhAN0EIIYS4IknwMxCOHSN+61YAahctImfePJg3j1qbjQT/ejj+3chPn4acHAA8NpuskyOEEEJ8T4aBrkAo0p59Fs3rxXvTTXTl5Q10dYQQQoiQEtQ7Pw6Hg2eeeYZt27YRHh7OggULWLBgQTCrcPnOnsXU3AxVVeDxEFZVBWYzpjNnLv7ZPXswPP44ebW1mMPDyXM6MUREQGkpAJ6nnurnygshhBDifEENfp5//nlKSkp44403qK2t5YknniAtLY2bbropmNXoqagIw4IF5Dc3Y7ZYyHe7MYSFgVJMaGzE2NlJYcDb87t/FhiNqBdeQD38cK/ZhldUYPj1r9FaWvCvqBO4so59xgwip02TlZKFEEKIIAta8NPV1cXf//53XnvtNcaPH8/48eMpLy9nw4YNAxv8HD6MVlxMWPfTsICXjN0/laaB2exb8VjTMJhMaK2taL/5DV6jEa6+2rdhaEcHOBxw5gyjFy9Ga2lBTZ1K2YIFjBo5kooTJ8geNQoMBirCwxkf5KYKIYQQIojBT2lpKW63m4kTJ+ppkydP5pVXXsHr9WIwDNDwo/nz8UyeTFlREaOzszl+7BhjsrMBONLYSM7MmRSfOsWE7nrbbDas+fmcWbiQlL/+FcO//itjpkzBXFXFxIYGPVsjoMaMwfvf/01HdTXKaqU9IUEfyOyVKepCCCHEgAha8NPU1ERcXBwWi0VPS0xMxOFwYLfbiY+PD1ZVLjR2LF3nzqGsVjojIvQAxWGzQWysb7xPIE2jZvFikhMSMLz4IkOKii7I0pGaimnLFt/eWtXV/d4EIYQQQlyaoAU/Z8+e7RH4APpzp9N5yfl4PJ4+rVdgnuf//NY0TcP97LMY8vOpLSsjee5cjmga48eNg/Z2SpqasGZmwnfJ+xvS+iqf/sz7SqhjqLdf6ji48pE6Sh0Ha959pT/y/L40pb5tc6m+8+GHH7Jq1So+//xzPe348ePMnTuXvXv3Ehsb+62f93g82KSrSAghhLgiTZgwAaPRePE3BoMKkv3796tx48Ypl8ulp+3evVsVFBQoj8dz0c+73W5VVFSkHA6HcrvdffrP4XCooqIi1dXVpZfRF2mDLZ9Qr2Oot1/qOLjykTpKHQdr3v11jXW73f0ZZlyWoHV7jRs3DpPJhM1mY8qUKQDs378fq9V6WYOdjUZjv0WO/nwD8++LtMGWT6jXMdTbL3UcXPlIHaWOgy3vwPQfqqBNsYqIiOD2229n5cqVHDp0iO3bt7N+/Xrmz58frCoIIYQQQgR3kcNly5axcuVK7rvvPqKjo3nkkUe48cYbg1kFIYQQQoS4oAY/ERERPPfcczz33HPBLFYIIYQQQicbmwohhBAipEjwI4QQQoiQIsGPEEIIIUKKBD9CCCGECCkS/AghhBAipEjwI4QQQoiQIsGPEEIIIUKKBD9CCCGECClBXeTw+1Ddm897PJ4+z9uf5/k/+yptsOUT6nUM9fZLHQdXPlJHqeNgzbuv+PP0X8cHA00Nptp8C6fTSXFx8UBXQwghhBDfgdVqxWKxDHQ1gCso+PF6vbjdbgwGA5qmDXR1hBBCCHEJlFJ4vV5MJhMGw+AYbXPFBD9CCCGEEH1hcIRgQgghhBBBIsGPEEIIIUKKBD9CCCGECCkS/AghhBAipEjwI4QQQoiQIsGPEEIIIUKKBD9CCCGECCn9vr3FrFmzqKmpuSB90qRJ/O1vf+uRlpubC8B9993Hjh07aGhowOVyMXv2bCZNmsTq1asZM2YMmzdvZtq0adjt9gvyNZvNZGZmMnLkSD7++ONe65SRkcH27dsBePLJJ6msrOSrr77qkUdiYiJ1dXW8+uqrPPDAAwDccsstbN26Fbfb/Z2ORSBN03os9W00GjEYDLhcrgveGxYWxowZM9ixY8f3LldcmvPPz5WStxhcDAYDXq93oKshxLfSNI3o6Gja29t7pK9atYrExEQefvjhXre9MJvNuFyuXq9f4eHhREVFER0dTVNTE+fOnevxuxAeHk5ycjJRUVFUVlYSFxeH3W7H6XQyefJkZs2axY4dO3j99de5//77OXDgAPHx8VitVkpKSujo6GD06NHU1dXR2dnJnDlz+O1vf0tERMQltTkod36eeuopPvvsMz777DOeeuopUlJSWLduXe8VMhj44IMPWLVqFVu3bgWgpKSEV155BYDy8nJ2797N2bNnL/ispml4PB5++tOfsmvXLgDGjBlDSkqKXu5LL71EVVWV/pmnn36agoKCHuVv3bqV1atXA/So55YtW4iKirqstp+/GrV/dcvz0z0eT6+BD4DD4RjQwCeYK2oPltW7+zM4kcDHZyBXeg3W/zMJfMRgN3ToUH784x/rgY/J9M97Im+++WavgY//98flcvHQQw/p16/AwMPtdmM2m6mvr+fcuXNomsaQIUP018ePH09XVxdlZWWsWrWK+vp6urq6mDt3Lkopnn32WZRSLF26lKKiIsaOHcttt93GJ598ws9+9jMWLVpESUkJeXl5vPHGGxw8eJA//OEPl9zuoHz7xMTEkJSURFJSEjExMRiNRmJjY3t9r6ZpJCQkcM011zB8+HAAfvGLX9DS0qLntWLFChwOR4/PRUZGopRi1qxZfPzxx/oXa1tbG0ajUS936NChF9TNv9dIVFQUSimGDx/ONddcA4DNZgN8X9RGo5GwsLAen7/YPiUJCQk9nvv/c1xJX4rBvFgPlqXPB9JgCQD72+X+IdGXQjEAzc7OHugq9Lnzv8/9BuPv0OXUKTo6+oI0o9GoP/ZfG/tCa2srn3/+uf48sGejrKys1zs+gcf9vffe0x8H3pSIjo6mvr6eadOmoZRiypQpOJ1O/fX9+/fT0dHBhAkT+N3vfoemaVgsFoqKivTr7okTJ9i+fTvp6elERUVx8OBBpk2bxsGDB/n000+5/fbb2bt3L2PGjOGZZ57h3Xff7fXGSG8G/EpTVFTEddddp3d5eTwejh49Sltbm35Q33nnHf39breburq6C/Lp6uoCYPv27Rw/flw/AA0NDdTU1LBs2TJqamqYP38+4Oti8/977bXXAOjs7EQppacH8u8t1tjY2CM98GT2prm5ucfzzs7Obz8gIa4/dhS+0oTKhfn8W+yifx0/fnygq9DnWltbe00fjL9Dl1Onjo6OC9ICvxurq6v7pE5+5/c6XCxQCxxy0tDQ0OOP1uzsbDRNw+VyYTabqaurQymFx+PRXwPfcI60tDTGjBlDR0cH99xzD4mJiTQ3N/OXv/yF1NRUWltbMRgM3HrrrSilKC4u5vrrr8dms1FcXMzNN9+My+WitLSUCRMm6I8vxYAGP+3t7SxYsICzZ8+yZs0awHfLTSnFDTfcwKZNmwCorKzktttuA3yRZW8XyIudrMH4l4AQQggx2FxOoKZpGmlpafrzsLAwlFL6eKBTp06haRoLFy6ksbFRv2vkv9OTm5uLwWBg9OjRmM1moqOjmTp1KpGRkURGRhIfH4/RaMTtduNwOBg5ciROpxOHw0FqaiqxsbHU19djMpn0x5ciKMHPihUrmDhxIhMnTmTFihXU1tbS1dXFuXPnsFgs/P73v+fWW28F4MYbbwR8d3i+/PJLwHci8vPzAd8gKY/Hc0Ewc7GTNRj/EhBCCCEGG//11Wg06o/9wUpvGhsb9W65yspKwHetBt+YVaUU77//PqdPnyYrKwvwXZP9eXq9XiwWCwaDQb+5YTQaUUrpZfqHikRGRurlWiwWLBaL3gMT+PhighL8LF68mE2bNrFp0yYeeeQRkpOTiYiIIDIykvb2dhYvXkxeXh4AH3zwAeALfpYtWwb4DqJ/ALI/iJFgRgghhOh7/uurx+Ppcc39psAiMCBxOp2YTCZ9KEpycjIGg4Ft27Yxffr0C8bNOp1ODAYDTqcTr9erD7j2eDx6OvxzPKg/X/9nnU6nPpY28PHF9Hvw4/F48Hq9ZGZmkpmZSUJCAmFhYWiapo/dGTduHAsXLgR8A7msVisWi4WmpiYA7rrrLlJSUoAL+yaFEEIIEXz+ZTvsdrt+x8btduN2u2lra8NsNuvLPcybN4+rrrpKH6flD6aam5uJjIykubkZl8ulB1JdXV1YLBZaWlr0oCgsLIyKigrCwsIICwujoaEBu91OUlISbrdbf3wp+j346ejoYMuWLfrz9vZ24uLiANizZw9Go5G7776bJUuWAL6BXBUVFRQWFnL48GEAUlNT9Vtovc2SkhlCfU/GSAkhxODVn9/R/i4s/7X6fPHx8YAvgBk7dqxel5SUFD34GDFiBElJSTQ2NhITE4Pb7aawsFDvFnM6ndTV1bFv3z5Gjx6tz/5KSUnh7NmzNDU1ERcXh8lkor6+Hk3TsFqt7Ny5k4KCAqxWK1u2bMFkMjF27FhsNpv++FL0e9RgsVg4fvw4X3zxBaWlpWzcuJHp06cDEBsbi8Fg4Pnnn+ftt9/WP9PR0UF6ejr79u0D4KWXXqKtrU1/3X/g/a6kaeNXCulWFEKIwas/v6P9d3G+aTZdYNdTWlqaXhd/0AK+WWD19fX8/Oc/p6uri3fffZedO3fq1+spU6YQERHB/v37mTdvHl9++SXt7e2kpqaybNkyhgwZwtChQ7n99tvZuXMnHR0dWK1W9uzZQ2FhITNmzOC9997j6quvpry8nJUrVzJv3rxL7vbSVD9f5WbNmkVOTg4lJSV0dXUxe/Zsli9fTkREBB6Ph5UrV7Jp0yZcLhdKKRITE7Hb7aSmpuqLEebl5XH69Gl9St2vfvUr1q9fLxdoIYQQ4gpksVj0Xp2KigoSExNpampCKcVVV13F6NGjOXr0KH/+85+5++67KS8vJzExkby8PIqLi3E6nWRmZlJbW4vL5eLGG29kxYoVF4wp+kbqB2bmzJkqJydHVVVVfev7mpub1a5du3qk/elPf1K5ubnqgQceUGvXrlVKKfXWW2+pX/7yl2rp0qV6Wm+qqqpUTk6Oev311/u0XKXURcseqDZ/n7Lb29tVXl6euvPOO/VyLqfNl1p2fxxvOddyroNRdl+e6/443r2V7T/XU6dO/U5tvtSyr7Rz/eCDDw7Y/yPRu5AeLLNo0SI2btxIdXU1a9euZd26dcTHx7Nnzx6mTZvGli1bWLt2Lenp6ezYsYM77rgjaOWuW7eOadOmsWHDhqCX3R9tDix748aNPPTQQwCkp6fz8ccfExsbO6BtDtWy5Vz/sMv+4osv+vV4B5a9ceNG7r33XpRSdHZ2huTx/qayA1dQHsztCiX9vrHpYJWQkMCLL77I2rVrWb16NR6PB5PJREdHB48++ihut5unn36ajIwMPvroI5YsWdInS4pfark/+clPUEqxZs2aoJfd120+v+yysjKMRiP5+fns3LmTO+64gxdeeGFA2xyqZcu5/mGX3Z/H+/yyy8rK0DQNo9HIY489FpLH+5vKvv/++3n55ZcHdbtCTb+P+RFCCCGEGExCuttLCCGEEKFHgh8hhBBChBQJfoQQQggRUiT4EUIIIURIkeBHCCGEECFFgh8hhBBChBQJfoQQQggRUiT4EUIIIURIkeBHCCGEECHl/wGrIuNRl/NxVgAAAABJRU5ErkJggg==" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 7 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Remove COIVD months", + "id": "72d56d3d8678abfb" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-05T09:51:06.121064Z", + "start_time": "2024-12-05T09:51:06.075608Z" + } + }, + "cell_type": "code", + "source": [ + "monthly_reporting_by_facility.iloc[covid_months, :] = np.nan\n", + "Inpatient_monthly_reporting_by_facility.iloc[covid_months, :] = np.nan\n", + "ANC_monthly_reporting_by_facility.iloc[covid_months, :] = np.nan\n" + ], + "id": "7b557e5a8fc51c7", + "outputs": [], + "execution_count": 8 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "", + "id": "c2cd6477d9ab1ff2" + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": [ + "for facility in monthly_reporting_by_facility.columns:\n", + " if facility in Inpatient_monthly_reporting_by_facility.columns: \n", + " for month in monthly_reporting_by_facility.loc[facility]:\n", + " if monthly_reporting_by_facility.loc[month,facility] >= 0:\n", + " if Inpatient_monthly_reporting_by_facility.loc[month,facility]" + ], + "id": "6d26b8e56c6c8330" + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/scripts/climate_change/carbonplan_CMIP6_downscaling.ipynb b/src/scripts/climate_change/carbonplan_CMIP6_downscaling.ipynb new file mode 100644 index 0000000000..9b13287906 --- /dev/null +++ b/src/scripts/climate_change/carbonplan_CMIP6_downscaling.ipynb @@ -0,0 +1,1389 @@ +{ + "cells": [ + { + "cell_type": "code", + "id": "initial_id", + "metadata": { + "collapsed": true, + "ExecuteTime": { + "end_time": "2024-12-13T16:42:12.117142Z", + "start_time": "2024-12-13T16:42:11.745174Z" + } + }, + "source": [ + "import os\n", + "import re\n", + "import glob\n", + "import shutil\n", + "import zipfile\n", + "from pathlib import Path\n", + "import difflib\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "import xarray as xr\n", + "from netCDF4 import Dataset\n", + "\n", + "import geopandas as gpd\n", + "import regionmask\n", + "import cartopy.crs as ccrs\n", + "from scipy.spatial import KDTree\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from carbonplan import styles # noqa: F401\n", + "import intake\n", + "import cmip6_downscaling\n", + "\n", + "xr.set_options(keep_attrs=True)\n" + ], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 1 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-13T16:42:13.856639Z", + "start_time": "2024-12-13T16:42:12.119646Z" + } + }, + "cell_type": "code", + "source": [ + "cat = intake.open_esm_datastore(\n", + " \"https://rice1.osn.mghpcc.org/carbonplan/cp-cmip/version1/catalog/osn-rechunked-global-downscaled-cmip6.json\"\n", + ")" + ], + "id": "550653fdc7437d9d", + "outputs": [], + "execution_count": 2 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-13T16:42:13.865858Z", + "start_time": "2024-12-13T16:42:13.858050Z" + } + }, + "cell_type": "code", + "source": [ + "cat_subset = cat.search(\n", + " experiment_id=\"ssp245\",\n", + " variable_id=\"pr\",\n", + " timescale = 'day'\n", + ")" + ], + "id": "2604ef9e1cdb9980", + "outputs": [], + "execution_count": 3 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-13T16:42:16.861598Z", + "start_time": "2024-12-13T16:42:13.868363Z" + } + }, + "cell_type": "code", + "source": [ + "dsets = cat_subset.to_dataset_dict()\n", + "dsets" + ], + "id": "1280dd2d66b41504", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--> The keys in the returned dictionary of datasets are constructed as follows:\n", + "\t'activity_id.institution_id.source_id.experiment_id.timescale.method'\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + "\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + "
\n", + " \n", + " 100.00% [9/9 00:02<00:00]\n", + "
\n", + " " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "{'ScenarioMIP.CCCma.CanESM5.ssp245.day.GARD-SV': Size: 129GB\n", + " Dimensions: (lat: 721, lon: 1440, member_id: 1, time: 31046)\n", + " Coordinates:\n", + " * lat (lat) float32 3kB -90.0 -89.75 -89.5 -89.25 ... 89.5 89.75 90.0\n", + " * lon (lon) float32 6kB -180.0 -179.8 -179.5 ... 179.2 179.5 179.8\n", + " * time (time) datetime64[ns] 248kB 2015-01-01 2015-01-02 ... 2099-12-31\n", + " * member_id (member_id) object 8B 'r1i1p1f1'\n", + " Data variables:\n", + " pr (member_id, time, lat, lon) float32 129GB dask.array\n", + " Attributes: (12/30)\n", + " Conventions: CF-1.8\n", + " activity_id: ScenarioMIP\n", + " cmip6_downscaling_contact: hello@carbonplan.org\n", + " cmip6_downscaling_explainer: https://carbonplan.org/resea...\n", + " cmip6_downscaling_institution: CarbonPlan\n", + " cmip6_downscaling_license: CC-BY-4.0\n", + " ... ...\n", + " intake_esm_attrs:variable_id: pr\n", + " intake_esm_attrs:method: GARD-SV\n", + " intake_esm_attrs:downscaled_daily_data_uri: https://rice1.osn.mghpcc.org...\n", + " intake_esm_attrs:version: v1\n", + " intake_esm_attrs:_data_format_: zarr\n", + " intake_esm_dataset_key: ScenarioMIP.CCCma.CanESM5.ss...,\n", + " 'ScenarioMIP.CCCma.CanESM5.ssp245.day.DeepSD-BC': Size: 129GB\n", + " Dimensions: (lat: 720, lon: 1440, member_id: 1, time: 31046)\n", + " Coordinates:\n", + " * lat (lat) float64 6kB -89.88 -89.62 -89.38 ... 89.38 89.62 89.88\n", + " * lon (lon) float64 12kB -179.9 -179.6 -179.4 ... 179.4 179.6 179.9\n", + " * time (time) datetime64[ns] 248kB 2015-01-01 2015-01-02 ... 2099-12-31\n", + " * member_id (member_id) object 8B 'r1i1p1f1'\n", + " Data variables:\n", + " pr (member_id, time, lat, lon) float32 129GB dask.array\n", + " Attributes: (12/30)\n", + " Conventions: CF-1.8\n", + " activity_id: ScenarioMIP\n", + " cmip6_downscaling_contact: hello@carbonplan.org\n", + " cmip6_downscaling_explainer: https://carbonplan.org/resea...\n", + " cmip6_downscaling_institution: CarbonPlan\n", + " cmip6_downscaling_license: CC-BY-4.0\n", + " ... ...\n", + " intake_esm_attrs:variable_id: pr\n", + " intake_esm_attrs:method: DeepSD-BC\n", + " intake_esm_attrs:downscaled_daily_data_uri: https://rice1.osn.mghpcc.org...\n", + " intake_esm_attrs:version: v1\n", + " intake_esm_attrs:_data_format_: zarr\n", + " intake_esm_dataset_key: ScenarioMIP.CCCma.CanESM5.ss...,\n", + " 'ScenarioMIP.CCCma.CanESM5.ssp245.day.DeepSD': Size: 129GB\n", + " Dimensions: (lat: 720, lon: 1440, member_id: 1, time: 31046)\n", + " Coordinates:\n", + " * lat (lat) float64 6kB -89.88 -89.62 -89.38 ... 89.38 89.62 89.88\n", + " * lon (lon) float64 12kB -179.9 -179.6 -179.4 ... 179.4 179.6 179.9\n", + " * time (time) datetime64[ns] 248kB 2015-01-01 2015-01-02 ... 2099-12-31\n", + " * member_id (member_id) object 8B 'r1i1p1f1'\n", + " Data variables:\n", + " pr (member_id, time, lat, lon) float32 129GB dask.array\n", + " Attributes: (12/30)\n", + " Conventions: CF-1.8\n", + " activity_id: ScenarioMIP\n", + " cmip6_downscaling_contact: hello@carbonplan.org\n", + " cmip6_downscaling_explainer: https://carbonplan.org/resea...\n", + " cmip6_downscaling_institution: CarbonPlan\n", + " cmip6_downscaling_license: CC-BY-4.0\n", + " ... ...\n", + " intake_esm_attrs:variable_id: pr\n", + " intake_esm_attrs:method: DeepSD\n", + " intake_esm_attrs:downscaled_daily_data_uri: https://rice1.osn.mghpcc.org...\n", + " intake_esm_attrs:version: v1\n", + " intake_esm_attrs:_data_format_: zarr\n", + " intake_esm_dataset_key: ScenarioMIP.CCCma.CanESM5.ss...,\n", + " 'ScenarioMIP.MRI.MRI-ESM2-0.ssp245.day.DeepSD': Size: 129GB\n", + " Dimensions: (lat: 720, lon: 1440, member_id: 1, time: 31046)\n", + " Coordinates:\n", + " * lat (lat) float64 6kB -89.88 -89.62 -89.38 ... 89.38 89.62 89.88\n", + " * lon (lon) float64 12kB -179.9 -179.6 -179.4 ... 179.4 179.6 179.9\n", + " * time (time) datetime64[ns] 248kB 2015-01-01 2015-01-02 ... 2099-12-31\n", + " * member_id (member_id) object 8B 'r1i1p1f1'\n", + " Data variables:\n", + " pr (member_id, time, lat, lon) float32 129GB dask.array\n", + " Attributes: (12/30)\n", + " Conventions: CF-1.8\n", + " activity_id: ScenarioMIP\n", + " cmip6_downscaling_contact: hello@carbonplan.org\n", + " cmip6_downscaling_explainer: https://carbonplan.org/resea...\n", + " cmip6_downscaling_institution: CarbonPlan\n", + " cmip6_downscaling_license: CC-BY-4.0\n", + " ... ...\n", + " intake_esm_attrs:variable_id: pr\n", + " intake_esm_attrs:method: DeepSD\n", + " intake_esm_attrs:downscaled_daily_data_uri: https://rice1.osn.mghpcc.org...\n", + " intake_esm_attrs:version: v1\n", + " intake_esm_attrs:_data_format_: zarr\n", + " intake_esm_dataset_key: ScenarioMIP.MRI.MRI-ESM2-0.s...,\n", + " 'ScenarioMIP.MRI.MRI-ESM2-0.ssp245.day.GARD-MV': Size: 129GB\n", + " Dimensions: (lat: 721, lon: 1440, member_id: 1, time: 31046)\n", + " Coordinates:\n", + " * lat (lat) float32 3kB -90.0 -89.75 -89.5 -89.25 ... 89.5 89.75 90.0\n", + " * lon (lon) float32 6kB -180.0 -179.8 -179.5 ... 179.2 179.5 179.8\n", + " * time (time) datetime64[ns] 248kB 2015-01-01 2015-01-02 ... 2099-12-31\n", + " * member_id (member_id) object 8B 'r1i1p1f1'\n", + " Data variables:\n", + " pr (member_id, time, lat, lon) float32 129GB dask.array\n", + " Attributes: (12/30)\n", + " Conventions: CF-1.8\n", + " activity_id: ScenarioMIP\n", + " cmip6_downscaling_contact: hello@carbonplan.org\n", + " cmip6_downscaling_explainer: https://carbonplan.org/resea...\n", + " cmip6_downscaling_institution: CarbonPlan\n", + " cmip6_downscaling_license: CC-BY-4.0\n", + " ... ...\n", + " intake_esm_attrs:variable_id: pr\n", + " intake_esm_attrs:method: GARD-MV\n", + " intake_esm_attrs:downscaled_daily_data_uri: https://rice1.osn.mghpcc.org...\n", + " intake_esm_attrs:version: v1\n", + " intake_esm_attrs:_data_format_: zarr\n", + " intake_esm_dataset_key: ScenarioMIP.MRI.MRI-ESM2-0.s...,\n", + " 'ScenarioMIP.MRI.MRI-ESM2-0.ssp245.day.DeepSD-BC': Size: 129GB\n", + " Dimensions: (lat: 720, lon: 1440, member_id: 1, time: 31046)\n", + " Coordinates:\n", + " * lat (lat) float64 6kB -89.88 -89.62 -89.38 ... 89.38 89.62 89.88\n", + " * lon (lon) float64 12kB -179.9 -179.6 -179.4 ... 179.4 179.6 179.9\n", + " * time (time) datetime64[ns] 248kB 2015-01-01 2015-01-02 ... 2099-12-31\n", + " * member_id (member_id) object 8B 'r1i1p1f1'\n", + " Data variables:\n", + " pr (member_id, time, lat, lon) float32 129GB dask.array\n", + " Attributes: (12/30)\n", + " Conventions: CF-1.8\n", + " activity_id: ScenarioMIP\n", + " cmip6_downscaling_contact: hello@carbonplan.org\n", + " cmip6_downscaling_explainer: https://carbonplan.org/resea...\n", + " cmip6_downscaling_institution: CarbonPlan\n", + " cmip6_downscaling_license: CC-BY-4.0\n", + " ... ...\n", + " intake_esm_attrs:variable_id: pr\n", + " intake_esm_attrs:method: DeepSD-BC\n", + " intake_esm_attrs:downscaled_daily_data_uri: https://rice1.osn.mghpcc.org...\n", + " intake_esm_attrs:version: v1\n", + " intake_esm_attrs:_data_format_: zarr\n", + " intake_esm_dataset_key: ScenarioMIP.MRI.MRI-ESM2-0.s...,\n", + " 'ScenarioMIP.MRI.MRI-ESM2-0.ssp245.day.GARD-SV': Size: 129GB\n", + " Dimensions: (lat: 721, lon: 1440, member_id: 1, time: 31046)\n", + " Coordinates:\n", + " * lat (lat) float32 3kB -90.0 -89.75 -89.5 -89.25 ... 89.5 89.75 90.0\n", + " * lon (lon) float32 6kB -180.0 -179.8 -179.5 ... 179.2 179.5 179.8\n", + " * time (time) datetime64[ns] 248kB 2015-01-01 2015-01-02 ... 2099-12-31\n", + " * member_id (member_id) object 8B 'r1i1p1f1'\n", + " Data variables:\n", + " pr (member_id, time, lat, lon) float32 129GB dask.array\n", + " Attributes: (12/30)\n", + " Conventions: CF-1.8\n", + " activity_id: ScenarioMIP\n", + " cmip6_downscaling_contact: hello@carbonplan.org\n", + " cmip6_downscaling_explainer: https://carbonplan.org/resea...\n", + " cmip6_downscaling_institution: CarbonPlan\n", + " cmip6_downscaling_license: CC-BY-4.0\n", + " ... ...\n", + " intake_esm_attrs:variable_id: pr\n", + " intake_esm_attrs:method: GARD-SV\n", + " intake_esm_attrs:downscaled_daily_data_uri: https://rice1.osn.mghpcc.org...\n", + " intake_esm_attrs:version: v1\n", + " intake_esm_attrs:_data_format_: zarr\n", + " intake_esm_dataset_key: ScenarioMIP.MRI.MRI-ESM2-0.s...,\n", + " 'ScenarioMIP.NCC.NorESM2-LM.ssp245.day.MACA': Size: 227GB\n", + " Dimensions: (lat: 721, lon: 1440, member_id: 1, time: 54764)\n", + " Coordinates:\n", + " * lat (lat) float32 3kB -90.0 -89.75 -89.5 -89.25 ... 89.5 89.75 90.0\n", + " * lon (lon) float32 6kB -180.0 -179.8 -179.5 ... 179.2 179.5 179.8\n", + " * time (time) datetime64[ns] 438kB 1950-01-01 1950-01-02 ... 2099-12-30\n", + " * member_id (member_id) object 8B 'r1i1p1f1'\n", + " Data variables:\n", + " pr (member_id, time, lat, lon) float32 227GB dask.array\n", + " Attributes: (12/30)\n", + " Conventions: CF-1.8\n", + " activity_id: ScenarioMIP\n", + " cmip6_downscaling_contact: hello@carbonplan.org\n", + " cmip6_downscaling_explainer: https://carbonplan.org/resea...\n", + " cmip6_downscaling_institution: CarbonPlan\n", + " cmip6_downscaling_license: CC-BY-4.0\n", + " ... ...\n", + " intake_esm_attrs:variable_id: pr\n", + " intake_esm_attrs:method: MACA\n", + " intake_esm_attrs:downscaled_daily_data_uri: https://rice1.osn.mghpcc.org...\n", + " intake_esm_attrs:version: v1\n", + " intake_esm_attrs:_data_format_: zarr\n", + " intake_esm_dataset_key: ScenarioMIP.NCC.NorESM2-LM.s...,\n", + " 'ScenarioMIP.DKRZ.MPI-ESM1-2-HR.ssp245.day.GARD-SV': Size: 129GB\n", + " Dimensions: (lat: 721, lon: 1440, member_id: 1, time: 31046)\n", + " Coordinates:\n", + " * lat (lat) float32 3kB -90.0 -89.75 -89.5 -89.25 ... 89.5 89.75 90.0\n", + " * lon (lon) float32 6kB -180.0 -179.8 -179.5 ... 179.2 179.5 179.8\n", + " * time (time) datetime64[ns] 248kB 2015-01-01 2015-01-02 ... 2099-12-31\n", + " * member_id (member_id) object 8B 'r1i1p1f1'\n", + " Data variables:\n", + " pr (member_id, time, lat, lon) float32 129GB dask.array\n", + " Attributes: (12/30)\n", + " Conventions: CF-1.8\n", + " activity_id: ScenarioMIP\n", + " cmip6_downscaling_contact: hello@carbonplan.org\n", + " cmip6_downscaling_explainer: https://carbonplan.org/resea...\n", + " cmip6_downscaling_institution: CarbonPlan\n", + " cmip6_downscaling_license: CC-BY-4.0\n", + " ... ...\n", + " intake_esm_attrs:variable_id: pr\n", + " intake_esm_attrs:method: GARD-SV\n", + " intake_esm_attrs:downscaled_daily_data_uri: https://rice1.osn.mghpcc.org...\n", + " intake_esm_attrs:version: v1\n", + " intake_esm_attrs:_data_format_: zarr\n", + " intake_esm_dataset_key: ScenarioMIP.DKRZ.MPI-ESM1-2-...}" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 4 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Load datasets into notebook - NB NorESM2 has a different algorithm", + "id": "d1c0de89c29b0bbc" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-13T16:42:16.873305Z", + "start_time": "2024-12-13T16:42:16.868089Z" + } + }, + "cell_type": "code", + "source": [ + "CanESM5_ssp245 = dsets['ScenarioMIP.CCCma.CanESM5.ssp245.day.GARD-SV']\n", + "MRI_ESM2_0_ssp245 = dsets['ScenarioMIP.MRI.MRI-ESM2-0.ssp245.day.GARD-MV']\n", + "MRI_ESM1_2_HR_ssp245 = dsets['ScenarioMIP.DKRZ.MPI-ESM1-2-HR.ssp245.day.GARD-SV']\n", + "\n", + "NorESM2_LM_ssp245 = dsets['ScenarioMIP.NCC.NorESM2-LM.ssp245.day.MACA']" + ], + "id": "265cd6f694b9d1e1", + "outputs": [], + "execution_count": 5 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Subset", + "id": "d4e4a946e5bf7f36" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-13T16:42:16.884885Z", + "start_time": "2024-12-13T16:42:16.874662Z" + } + }, + "cell_type": "code", + "source": [ + "malawi_region = {'lat': slice(-17.12627881, -9.36366167), 'lon': slice(32.67161823,35.91841716)}\n", + "\n", + "CanESM5_ssp245 = CanESM5_ssp245.sel(**malawi_region)\n", + "MRI_ESM2_0_ssp245 = MRI_ESM2_0_ssp245.sel(**malawi_region)\n", + "MRI_ESM1_2_HR_ssp245 = MRI_ESM1_2_HR_ssp245.sel(**malawi_region)\n", + "NorESM2_LM_ssp245 = NorESM2_LM_ssp245.sel(**malawi_region)" + ], + "id": "de57a73224daf64", + "outputs": [], + "execution_count": 6 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-13T16:42:18.320956Z", + "start_time": "2024-12-13T16:42:18.302808Z" + } + }, + "cell_type": "code", + "source": [ + "lower_date = '2025-01-01'\n", + "upper_date = '2027-01-01'\n", + "CanESM5_ssp245 = CanESM5_ssp245.sel(time = slice(lower_date, upper_date))\n", + "MRI_ESM2_0_ssp245 = MRI_ESM2_0_ssp245.sel(time = slice(lower_date, upper_date))\n", + "MRI_ESM1_2_HR_ssp245 = MRI_ESM1_2_HR_ssp245.sel(time = slice(lower_date, upper_date))\n", + "NorESM2_LM_ssp245 = NorESM2_LM_ssp245.sel(time = slice(lower_date, upper_date))\n" + ], + "id": "bebc21a9ed742395", + "outputs": [], + "execution_count": 7 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-13T16:44:32.000307Z", + "start_time": "2024-12-13T16:44:20.098968Z" + } + }, + "cell_type": "code", + "source": [ + "CanESM5_ssp245_xr = xr.Dataset(\n", + " data_vars=dict(\n", + " pr=([\"time\", \"lat\",\"lon\"],np.asarray(np.squeeze(CanESM5_ssp245.pr.data))),\n", + " ),\n", + " coords=dict(\n", + " time=CanESM5_ssp245.time.data,\n", + " lat=CanESM5_ssp245.lat.data,\n", + " lon=CanESM5_ssp245.lon.data,\n", + " ),\n", + " attrs=dict(description=\"Weather related data.\"),)\n", + "\n", + "\n", + "MRI_ESM2_0_ssp245_xr = xr.Dataset(\n", + " data_vars=dict(\n", + " pr=([\"time\", \"lat\",\"lon\"],np.asarray(np.squeeze(MRI_ESM2_0_ssp245.pr.data))),\n", + " ),\n", + " coords=dict(\n", + " time=MRI_ESM2_0_ssp245.time.data,\n", + " lat=MRI_ESM2_0_ssp245.lat.data,\n", + " lon=MRI_ESM2_0_ssp245.lon.data,\n", + " ),\n", + " attrs=dict(description=\"Weather related data.\"),)\n", + "\n", + "MRI_ESM1_2_HR_ssp245_xr = xr.Dataset(\n", + " data_vars=dict(\n", + " pr=([\"time\", \"lat\",\"lon\"],np.asarray(np.squeeze(MRI_ESM1_2_HR_ssp245.pr.data))),\n", + " ),\n", + " coords=dict(\n", + " time=MRI_ESM1_2_HR_ssp245.time.data,\n", + " lat=MRI_ESM1_2_HR_ssp245.lat.data,\n", + " lon=MRI_ESM1_2_HR_ssp245.lon.data,\n", + " ),\n", + " attrs=dict(description=\"Weather related data.\"),)\n", + "\n", + "NorESM2_LM_ssp245_xr = xr.Dataset(\n", + " data_vars=dict(\n", + " pr=([\"time\", \"lat\",\"lon\"],np.asarray(np.squeeze(NorESM2_LM_ssp245.pr.data))),\n", + " ),\n", + " coords=dict(\n", + " time=NorESM2_LM_ssp245.time.data,\n", + " lat=NorESM2_LM_ssp245.lat.data,\n", + " lon=NorESM2_LM_ssp245.lon.data,\n", + " ),\n", + " attrs=dict(description=\"Weather related data.\"),\n", + ")\n", + "\n", + "\n" + ], + "id": "c9a234a76a53b57", + "outputs": [], + "execution_count": 15 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Save region", + "id": "4c1efa4852704874" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-13T16:45:06.434364Z", + "start_time": "2024-12-13T16:45:06.394180Z" + } + }, + "cell_type": "code", + "source": [ + "CanESM5_ssp245_xr.to_netcdf(\"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data/ssp2_4_5/CanESM5_ssp245.nc\")\n", + "\n", + "MRI_ESM2_0_ssp245_xr.to_netcdf(\"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data/ssp2_4_5/MRI_ESM2_0_ssp245.nc\")\n", + "\n", + "\n", + "MRI_ESM1_2_HR_ssp245_xr.to_netcdf(\"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data/ssp2_4_5/MRI_ESM1_2_HR_ssp245.nc\")\n", + "\n", + "NorESM2_LM_ssp245_xr.to_netcdf(\"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data/ssp2_4_5/NorESM2_LM_ssp245.nc\")\n" + ], + "id": "4674fad55e157843", + "outputs": [], + "execution_count": 18 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-13T16:36:58.244227Z", + "start_time": "2024-12-13T16:36:58.193618Z" + } + }, + "cell_type": "code", + "source": [ + "data_per_model = xr.open_dataset(file)\n", + "data_per_model" + ], + "id": "413118095a097a13", + "outputs": [ + { + "data": { + "text/plain": [ + " Size: 44MB\n", + "Dimensions: (lat: 31, lon: 13, member_id: 1, time: 27393)\n", + "Coordinates:\n", + " * lat (lat) float32 124B -17.0 -16.75 -16.5 -16.25 ... -10.0 -9.75 -9.5\n", + " * lon (lon) float32 52B 32.75 33.0 33.25 33.5 ... 35.0 35.25 35.5 35.75\n", + " * time (time) datetime64[ns] 219kB 2025-01-01 2025-01-02 ... 2099-12-31\n", + " * member_id (member_id) \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 44MB\n",
+       "Dimensions:    (lat: 31, lon: 13, member_id: 1, time: 27393)\n",
+       "Coordinates:\n",
+       "  * lat        (lat) float32 124B -17.0 -16.75 -16.5 -16.25 ... -10.0 -9.75 -9.5\n",
+       "  * lon        (lon) float32 52B 32.75 33.0 33.25 33.5 ... 35.0 35.25 35.5 35.75\n",
+       "  * time       (time) datetime64[ns] 219kB 2025-01-01 2025-01-02 ... 2099-12-31\n",
+       "  * member_id  (member_id) <U8 32B 'r1i1p1f1'\n",
+       "Data variables:\n",
+       "    pr         (member_id, time, lat, lon) float32 44MB ...\n",
+       "Attributes: (12/30)\n",
+       "    Conventions:                                 CF-1.8\n",
+       "    activity_id:                                 ScenarioMIP\n",
+       "    cmip6_downscaling_contact:                   hello@carbonplan.org\n",
+       "    cmip6_downscaling_explainer:                 https://carbonplan.org/resea...\n",
+       "    cmip6_downscaling_institution:               CarbonPlan\n",
+       "    cmip6_downscaling_license:                   CC-BY-4.0\n",
+       "    ...                                          ...\n",
+       "    intake_esm_attrs:variable_id:                pr\n",
+       "    intake_esm_attrs:method:                     GARD-SV\n",
+       "    intake_esm_attrs:downscaled_daily_data_uri:  https://rice1.osn.mghpcc.org...\n",
+       "    intake_esm_attrs:version:                    v1\n",
+       "    intake_esm_attrs:_data_format_:              zarr\n",
+       "    intake_esm_dataset_key:                      ScenarioMIP.CCCma.CanESM5.ss...
" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 18 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "# NOW MATCH TO CLINICS", + "id": "4bafba64102bd014" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-13T16:45:10.379543Z", + "start_time": "2024-12-13T16:45:10.192933Z" + } + }, + "cell_type": "code", + "source": [ + "ANC = True\n", + "Inpatient = False\n", + "monthly_cumulative = False\n", + "multiplier = 86400\n", + "years = range(2025, 2027)\n", + "month_lengths = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] * len(years)\n", + "if monthly_cumulative:\n", + " window_size = np.nan\n", + "else:\n", + " window_size = 5\n", + "\n", + "if ANC:\n", + " reporting_data = pd.read_csv(\n", + " \"/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_ANC_by_smaller_facility_lm.csv\")\n", + "elif Inpatient:\n", + " reporting_data = pd.read_csv(\n", + " \"/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_Inpatient_by_smaller_facility_lm.csv\")\n", + "general_facilities = gpd.read_file(\"/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_districts.shp\")\n", + "\n", + "facilities_with_lat_long = pd.read_csv(\n", + " \"/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_lat_long_region.csv\")\n" + ], + "id": "c6fe0e588229f053", + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_66604/1503391175.py:20: DtypeWarning: Columns (58,59,105,127,136,142,149,150,258,285,296,319,344,345,360,393,394,427,428,437,449,450,452,453,461,462,478,479,489,490,492,493,494,497,498,499,500,501,502,503,572,580,585,586,587,588,591,592,593,594,607,608,609,610,619,620,621,622,626,634,872,887,967,978,1066,1510) have mixed types. Specify dtype option on import or set low_memory=False.\n", + " facilities_with_lat_long = pd.read_csv(\n" + ] + } + ], + "execution_count": 19 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-13T16:43:52.593651Z", + "start_time": "2024-12-13T16:43:52.586565Z" + } + }, + "cell_type": "code", + "source": [ + "def unzip_all_in_directory(directory):\n", + " \"\"\"\n", + " Unzips all .zip files in the specified directory, extracting each into a separate folder.\n", + "\n", + " Parameters:\n", + " directory (str): The path to the folder containing the .zip files.\n", + " \"\"\"\n", + " for filename in os.listdir(directory):\n", + " if filename.endswith('.zip'):\n", + " file_path = os.path.join(directory, filename)\n", + " extract_dir = os.path.join(directory, filename[:-4])\n", + " os.makedirs(extract_dir, exist_ok=True)\n", + "\n", + " try:\n", + " with zipfile.ZipFile(file_path, 'r') as zip_ref:\n", + " zip_ref.extractall(extract_dir)\n", + " except zipfile.BadZipFile:\n", + " print(f\"Skipped {filename}: not a valid zip file.\")\n", + "\n", + "def get_facility_lat_long(reporting_facility, facilities_df, cutoff=0.90, n_matches=3):\n", + " \"\"\"\n", + " Function to find the closest matching facility name and return its latitude and longitude.\n", + "\n", + " Parameters:\n", + " - reporting_facility: The facility name for which latitude and longitude are needed.\n", + " - facilities_df : DataFrame containing facility names ('Fname') and their corresponding latitudes ('A109__Latitude') and longitudes ('A109__Longitude').\n", + " - cutoff: The minimum similarity score for a match. Default is 0.90.\n", + " - n_matches: The maximum number of matches to consider. Default is 3.\n", + "\n", + " Returns: match_name, lat_for_facility, long_for_facility\n", + "\n", + " \"\"\"\n", + " matching_facility_name = difflib.get_close_matches(reporting_facility, facilities_df['Fname'], n=n_matches,\n", + " cutoff=cutoff)\n", + "\n", + " if matching_facility_name:\n", + " match_name = matching_facility_name[0] # Access the string directly\n", + " lat_for_facility = facilities_df.loc[facilities_df['Fname'] == match_name, \"A109__Latitude\"].iloc[0]\n", + " long_for_facility = facilities_df.loc[facilities_df['Fname'] == match_name, \"A109__Longitude\"].iloc[0]\n", + " return match_name, lat_for_facility, long_for_facility\n", + " else:\n", + " return np.nan, np.nan, np.nan\n", + "\n", + "def extract_nc_files_from_unzipped_folders(directory):\n", + " \"\"\"\n", + " Searches for .nc files in the specified directory and all its subfolders,\n", + " and copies them to the output directory, maintaining the folder structure.\n", + "\n", + " Parameters:\n", + " directory (str): The path to the folder containing the unzipped folders.\n", + " \"\"\"\n", + " output_directory = os.path.join(directory, 'nc_files')\n", + " if not os.path.exists(output_directory):\n", + " os.makedirs(output_directory)\n", + "\n", + " for root, _, files in os.walk(directory):\n", + " # Skip the output directory to prevent recursive copying\n", + " if root == output_directory:\n", + " continue\n", + "\n", + " for filename in files:\n", + " if filename.endswith('.nc'):\n", + " source_file_path = os.path.join(root, filename)\n", + " destination_file_path = os.path.join(output_directory, filename)\n", + "\n", + " # Only copy if the file does not already exist in the output directory\n", + " if not os.path.exists(destination_file_path):\n", + " shutil.copy2(source_file_path, output_directory)" + ], + "id": "48c81707f9b51c02", + "outputs": [], + "execution_count": 13 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-13T16:39:42.604901Z", + "start_time": "2024-12-13T16:39:42.600644Z" + } + }, + "cell_type": "code", + "source": "precip_data_for_grid.pr.data", + "id": "13ded79cc9f9d", + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 2.4092836, 8.715088 , 9.038933 , ..., 6.459653 , 11.19525 ,\n", + " 19.130037 ]], dtype=float32)" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 16 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-13T16:45:49.862029Z", + "start_time": "2024-12-13T16:45:48.244909Z" + } + }, + "cell_type": "code", + "source": [ + "base_dir = \"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data/\"\n", + "nc_file_directory = os.path.join(base_dir, 'nc_files')\n", + "# NB these are daily \n", + "scenarios = [ \"ssp2_4_5\"] # don't have ssp19 scenario\n", + "years = range(2025, 2027)\n", + "year_lengths = [365, 366, 365, 366] * int(len(years)/4)\n", + "\n", + "data_by_model_and_grid = {}\n", + "for scenario in scenarios:\n", + " print(scenario)\n", + " scenario_directory = os.path.join(base_dir, scenario)\n", + " grid_centroids = {}\n", + " \n", + " cumulative_sum_by_models = {}\n", + " for file in glob.glob(os.path.join(scenario_directory, \"*.nc\")):\n", + " model = re.search(r'.*/(.*?)_ssp\\d+', file).group(1)\n", + " data_per_model = xr.open_dataset(file)\n", + " pr_data = data_per_model.variables['pr'][:] # in kg m-2 s-1 = mm s-1 x 86400 to get to day\n", + " lat_data = data_per_model.variables['lat'][:]\n", + " lon_data = data_per_model.variables['lon'][:]\n", + " lon_grid, lat_grid = np.meshgrid(lon_data, lat_data)\n", + " centroids = np.column_stack((lat_grid.ravel(), lon_grid.ravel()))\n", + "\n", + " # Store centroids\n", + " grid_centroids[model] = centroids\n", + " grid_dictionary = {}\n", + " grid = 0\n", + " for i in lat_data:\n", + " for j in lon_data:\n", + " precip_data_for_grid = data_per_model.sel(lat = i, lon = j, method= \"nearest\") # across all time points\n", + " grid_dictionary[grid] = precip_data_for_grid.pr.data\n", + " grid += 1\n", + " data_by_model_and_grid[model] = grid_dictionary\n", + "\n", + " pr_data_avg_area_model = pr_data.mean(dim=['lat', 'lon'])\n", + " cumulative_sum_window_for_model = []\n", + " begin_day = 0\n", + " for year_idx, year_length in enumerate(year_lengths):\n", + " days_for_grid = pr_data_avg_area_model[begin_day:begin_day + year_length]\n", + " cumulative_sums = sum(days_for_grid)\n", + " if isinstance(cumulative_sums, int):\n", + " cumulative_sum_window_for_model.append(cumulative_sums)\n", + " else:\n", + " cumulative_sum_window_for_model.append(cumulative_sums.values)\n", + " begin_day += year_length\n", + " cumulative_sum_by_models[model] = np.mean(cumulative_sum_window_for_model)\n", + " highest_model = max(cumulative_sum_by_models, key=lambda k: cumulative_sum_by_models[k])\n", + " lowest_model = min(cumulative_sum_by_models, key=lambda k: cumulative_sum_by_models[k])\n", + " sorted_models = sorted(cumulative_sum_by_models, key=lambda k: cumulative_sum_by_models[k])\n", + " median_index = len(sorted_models) // 2\n", + " if len(sorted_models) % 2 == 0:\n", + " median_index -= 1\n", + " median_model = sorted_models[median_index]\n", + " models_of_interest = [lowest_model, median_model, highest_model]\n", + " print(\"Models of interest\", models_of_interest)\n", + " \n", + " facilities_with_location = []\n", + " # see which facilities have reporting data and data on latitude and longitude\n", + " median_model_by_facility_window = {}\n", + " lowest_model_by_facility_window = {}\n", + " highest_model_by_facility_window = {}\n", + " median_model_by_facility_monthly = {}\n", + " lowest_model_by_facility_monthly = {}\n", + " highest_model_by_facility_monthly = {}\n", + " cumulative_sum_window = {}\n", + " cumulative_sum_monthly = {}\n", + " for reporting_facility in reporting_data.columns:\n", + " grid_precipitation_for_facility = {}\n", + " match_name, lat_for_facility, long_for_facility = get_facility_lat_long(reporting_facility, facilities_with_lat_long)\n", + " if not np.isnan(long_for_facility) and not np.isnan(lat_for_facility):\n", + " facility_location = np.array([lat_for_facility, long_for_facility])\n", + " kd_trees_by_model = {}\n", + " for model in models_of_interest:\n", + " centroids = grid_centroids[model]\n", + " kd_tree = KDTree(centroids)\n", + " distance, closest_grid_index = kd_tree.query(facility_location)\n", + " grid_precipitation_for_facility[model] = data_by_model_and_grid[model][closest_grid_index].data\n", + " cumulative_sum_monthly[reporting_facility] = []\n", + " cumulative_sum_window[reporting_facility] = []\n", + " begin_day = 0\n", + " for month_idx, month_length in enumerate(month_lengths):\n", + " days_for_grid_monthly = grid_precipitation_for_facility[model][begin_day:begin_day + month_length]\n", + " cumulative_sums_monthly = [\n", + " sum(grid_precipitation_for_facility[model][begin_day:begin_day + month_length])\n", + " ]\n", + " max_cumulative_sums_monthly = max(cumulative_sums_monthly)\n", + " cumulative_sum_monthly[reporting_facility].append(max_cumulative_sums_monthly)\n", + " begin_day += month_length\n", + " if model == models_of_interest[0]:\n", + " lowest_model_by_facility_monthly[reporting_facility] = cumulative_sum_monthly\n", + " if model == models_of_interest[1]:\n", + " median_model_by_facility_monthly[reporting_facility] = cumulative_sum_monthly\n", + " else:\n", + " highest_model_by_facility_monthly[reporting_facility] = cumulative_sum_monthly\n", + "\n", + " \n", + " begin_day = 0\n", + " for month_idx, month_length in enumerate(month_lengths):\n", + " days_for_grid_window = grid_precipitation_for_facility[model][begin_day:begin_day + month_length]\n", + "\n", + " cumulative_sums_window = [\n", + " sum(days_for_grid_window[day:day + window_size])\n", + " for day in range(month_length - window_size + 1)\n", + " ]\n", + "\n", + " max_cumulative_sums_window = max(cumulative_sums_window) \n", + " cumulative_sum_window[reporting_facility].append(max_cumulative_sums_window)\n", + " begin_day += month_length\n", + " if model == models_of_interest[0]:\n", + " lowest_model_by_facility_window[reporting_facility] = cumulative_sum_window\n", + " if model == models_of_interest[1]:\n", + " median_model_by_facility_window[reporting_facility] = cumulative_sum_window\n", + " else:\n", + " highest_model_by_facility_window[reporting_facility] = cumulative_sum_window\n", + " weather_df_lowest_window = pd.DataFrame.from_dict(lowest_model_by_facility_window, orient='index').T\n", + " weather_df_median_window = pd.DataFrame.from_dict(median_model_by_facility_window, orient='index').T\n", + " weather_df_highest_window = pd.DataFrame.from_dict(highest_model_by_facility_window, orient='index').T\n", + " \n", + " weather_df_lowest_monthly = pd.DataFrame.from_dict(lowest_model_by_facility_monthly, orient='index').T\n", + " weather_df_median_monthly = pd.DataFrame.from_dict(median_model_by_facility_monthly, orient='index').T\n", + " weather_df_highest_monthly = pd.DataFrame.from_dict(highest_model_by_facility_monthly, orient='index').T\n", + " # \n", + " # if ANC:\n", + " # weather_df_lowest_window.to_csv(Path(scenario_directory) / \"median_model_daily_prediction_weather_by_facility_KDBall_ANC.csv\", index=False)\n", + " # weather_df_median_window.to_csv(Path(scenario_directory) / \"lowest_model_daily_prediction_weather_by_facility_KDBall_ANC.csv\", index=False)\n", + " # weather_df_highest_window.to_csv(Path(scenario_directory) / \"highest_model_daily_prediction_weather_by_facility_KDBall_ANC.csv\", index=False)\n", + " # \n", + " # weather_df_lowest_monthly.to_csv(Path(scenario_directory) / \"median_model_monthly_prediction_weather_by_facility_KDBall_ANC.csv\", index=False)\n", + " # weather_df_median_monthly.to_csv(Path(scenario_directory) / \"lowest_model_monthly_prediction_weather_by_facility_KDBall_ANC.csv\", index=False)\n", + " # weather_df_highest_monthly.to_csv(Path(scenario_directory) / \"highest_model_monthly_prediction_weather_by_facility_KDBall_ANC.csv\", index=False)" + ], + "id": "3471631976601a74", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ssp2_4_5\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/numpy/core/fromnumeric.py:3504: RuntimeWarning: Mean of empty slice.\n", + " return _methods._mean(a, axis=axis, dtype=dtype,\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/numpy/core/fromnumeric.py:3504: RuntimeWarning: Mean of empty slice.\n", + " return _methods._mean(a, axis=axis, dtype=dtype,\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/numpy/core/fromnumeric.py:3504: RuntimeWarning: Mean of empty slice.\n", + " return _methods._mean(a, axis=axis, dtype=dtype,\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/numpy/core/fromnumeric.py:3504: RuntimeWarning: Mean of empty slice.\n", + " return _methods._mean(a, axis=axis, dtype=dtype,\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Models of interest ['MRI_ESM2_0', 'NorESM2_LM', 'MRI_ESM2_0']\n" + ] + } + ], + "execution_count": 21 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-13T16:35:24.071176Z", + "start_time": "2024-12-13T16:35:24.062303Z" + } + }, + "cell_type": "code", + "source": "print(len(data_by_model_and_grid[model][closest_grid_index][0]))", + "id": "c79bc3b0fc97c86a", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "27393\n" + ] + } + ], + "execution_count": 14 + }, + { + "metadata": {}, + "cell_type": "code", + "source": "highest_model_by_facility_monthly", + "id": "dbb58eb073a4a5a9", + "outputs": [], + "execution_count": 23 + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": "", + "id": "2fabc6ccdd8ae1b8" + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/scripts/climate_change/cohort_model.ipynb b/src/scripts/climate_change/cohort_model.ipynb new file mode 100644 index 0000000000..caf641d294 --- /dev/null +++ b/src/scripts/climate_change/cohort_model.ipynb @@ -0,0 +1,5314 @@ +{ + "cells": [ + { + "cell_type": "code", + "id": "initial_id", + "metadata": { + "collapsed": true, + "ExecuteTime": { + "end_time": "2025-01-03T10:30:32.359076Z", + "start_time": "2025-01-03T10:30:31.921107Z" + } + }, + "source": [ + "import datetime\n", + "from pathlib import Path\n", + "\n", + "import imageio\n", + "import numpy as np\n", + "import pandas as pd\n", + "from matplotlib import pyplot as plt\n", + "from matplotlib.ticker import FormatStrFormatter\n", + "\n", + "from tlo.analysis.life_expectancy import get_life_expectancy_estimates\n", + "from tlo.analysis.utils import (\n", + " extract_results,\n", + " format_gbd,\n", + " make_age_grp_lookup,\n", + " make_age_grp_types,\n", + " make_calendar_period_lookup,\n", + " make_calendar_period_type,\n", + " summarize,\n", + " unflatten_flattened_multi_index_in_logging,\n", + ")\n", + "\n", + "min_year = 2020\n", + "max_year = 2060\n", + "\n", + "results_folder = Path(\"/Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-09-25T110820Z\")\n", + "resourcefilepath = Path(\"/Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-09-25T110820Z\")\n", + "agegrps, agegrplookup = make_age_grp_lookup()\n", + "calperiods, calperiodlookup = make_calendar_period_lookup()\n", + "births_results = extract_results(\n", + " results_folder,\n", + " module=\"tlo.methods.demography\",\n", + " key=\"on_birth\",\n", + " custom_generate_series=(\n", + " lambda df: df.assign(year=df['date'].dt.year).groupby(['year'])['year'].count()\n", + " ),\n", + " do_scaling=True\n", + " )\n", + "print(births_results)\n", + "\n", + "births_results = births_results.groupby(by=births_results.index).sum()\n", + "births_results = births_results.replace({0: np.nan})\n", + "\n", + "births_model = summarize(births_results, collapse_columns=True)\n", + "births_model.columns = ['Model_' + col for col in births_model.columns]\n", + "\n", + " " + ], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "draw 0 \\\n", + "run 0 1 2 3 4 \n", + "year \n", + "2010 628547.29707 643232.30216 640615.17254 621277.49257 631746.01105 \n", + "2011 541745.83134 528514.78715 545526.12968 523280.52791 535929.98774 \n", + "2012 554249.89508 554686.08335 564718.41356 560356.53086 545380.73359 \n", + "2013 580421.19128 569661.88062 590017.33322 579403.41865 583329.11308 \n", + "2014 591035.10585 598450.30644 596996.34554 592925.25502 615025.46070 \n", + "2015 607901.05229 617497.19423 602812.18914 613571.49980 618514.96686 \n", + "2016 637998.04292 625203.18700 634217.74458 636689.47811 644977.05524 \n", + "2017 648321.16531 636834.87420 646431.01614 634072.34849 658062.70334 \n", + "2018 659225.87206 640324.38036 657917.30725 651083.69102 671148.35144 \n", + "2019 676237.21459 643232.30216 656317.95026 660679.83296 659225.87206 \n", + "2020 658644.28770 663878.54694 678708.94812 659807.45642 655736.36590 \n", + "2021 641196.75690 647884.97704 654282.40500 648175.76922 637561.85465 \n", + "2022 644104.67870 652101.46365 648030.37313 635090.12112 639161.21164 \n", + "2023 650502.10666 655445.57372 653846.21673 641632.94517 651519.87929 \n", + "2024 666059.48829 670421.37099 667368.05310 650211.31448 657044.93071 \n", + "2025 676964.19504 680453.70120 668822.01400 683943.20736 670130.57881 \n", + "2026 692957.76494 678854.34421 704880.24432 688014.29788 660970.62514 \n", + "2027 700227.56944 711713.86055 694702.51802 705607.22477 701826.92643 \n", + "2028 721600.79467 699064.40072 701099.94598 688014.29788 722473.17121 \n", + "2029 718402.08069 734395.65059 748353.67523 734541.04668 710986.88010 \n", + "2030 732069.31315 739193.72156 735704.21540 700954.54989 724217.92429 \n", + "2031 751843.18139 749807.63613 748208.27914 749662.24004 741956.24727 \n", + "2032 741083.87073 745154.96125 756059.66800 739484.51374 737158.17630 \n", + "2033 738321.34502 768854.52392 759839.96634 743264.81208 772925.61444 \n", + "2034 771617.04963 770744.67309 791536.31396 754605.70710 775106.55579 \n", + "2035 769872.29655 780922.39939 777869.08150 784993.48991 788773.78825 \n", + "2036 789355.37261 801423.24808 804767.35815 799823.89109 815235.87663 \n", + "2037 807384.48777 799096.91064 797933.74192 769145.31610 808547.65649 \n", + "2038 822796.47331 792554.08659 814508.89618 803313.39725 815235.87663 \n", + "2039 799533.09891 824832.01857 794880.42403 816399.04535 817998.40234 \n", + "2040 814363.50009 829339.29736 832538.01134 829193.90127 828466.92082 \n", + "2041 831229.44653 828030.73255 819016.17497 809274.63694 821487.90850 \n", + "2042 850567.12650 837190.68622 835155.14096 854638.21702 844896.67899 \n", + "2043 864379.75505 853765.84048 839517.02366 838935.43930 838499.25103 \n", + "2044 864961.33941 845623.65944 832828.80352 834282.76442 863652.77460 \n", + "2045 883717.43502 834864.34878 850130.93823 847949.99688 849258.56169 \n", + "2046 855801.38574 858709.30754 854492.82093 861035.64498 851875.69131 \n", + "2047 880518.72104 856528.36619 877901.59142 867723.86512 885171.39592 \n", + "2048 889824.07080 861617.22934 863071.19024 881827.28585 872376.54000 \n", + "2049 889242.48644 870631.78692 882699.66239 857546.13882 866124.50813 \n", + "2050 870050.20256 861181.04107 866851.48858 879355.55232 891714.21997 \n", + "2051 888370.10990 900437.98537 894476.74568 877320.00706 883281.24675 \n", + "2052 879355.55232 887933.92163 895058.33004 900874.17364 892586.59651 \n", + "2053 891714.21997 922392.79496 894476.74568 890987.23952 898984.02447 \n", + "2054 889387.88253 894040.55741 905817.64070 863652.77460 900437.98537 \n", + "2055 893458.97305 900583.38146 907416.99769 890987.23952 901891.94627 \n", + "2056 892877.38869 894185.95350 894912.93395 890405.65516 900292.58928 \n", + "2057 913959.82174 894767.53786 889533.27862 893895.16132 905963.03679 \n", + "2058 917449.32790 912796.65302 902473.53063 895785.31049 929226.41119 \n", + "2059 911778.88039 922974.37932 909743.33513 908870.95859 924864.52849 \n", + "2060 19919.26433 18465.30343 22536.39395 18901.49170 20064.66042 \n", + "\n", + "draw \n", + "run 5 6 7 8 9 \n", + "year \n", + "2010 631309.82278 637416.45856 608918.82492 608628.03274 636689.47811 \n", + "2011 546543.90231 543054.39615 514556.76251 534766.81902 527642.41061 \n", + "2012 556430.83643 569371.08844 548579.44757 547997.86321 548870.23975 \n", + "2013 576350.10076 581584.36000 577513.26948 579839.60692 586964.01533 \n", + "2014 612989.91544 581875.15218 580421.19128 588563.37232 598886.49471 \n", + "2015 623167.64174 622440.66129 623603.83001 618660.36295 622295.26520 \n", + "2016 636834.87420 626802.54399 604120.75395 635671.70548 640905.96472 \n", + "2017 650792.89884 644250.07479 637561.85465 655154.78154 626657.14790 \n", + "2018 644540.86697 653555.42455 636398.68593 667222.65701 658789.68379 \n", + "2019 674928.64978 652537.65192 666931.86483 664023.94303 662279.18995 \n", + "2020 658353.49552 664169.33912 635671.70548 669403.59836 652683.04801 \n", + "2021 657481.11898 626075.56354 649775.12621 650647.50275 640469.77645 \n", + "2022 650938.29493 643959.28261 636689.47811 632763.78368 649338.93794 \n", + "2023 656463.34635 660970.62514 657481.11898 643813.88652 663151.56649 \n", + "2024 658935.07988 654282.40500 659807.45642 662569.98213 664169.33912 \n", + "2025 683652.41518 679145.13639 692666.97276 668095.03355 668095.03355 \n", + "2026 686124.14871 676818.79895 693539.34930 666495.67656 675219.44196 \n", + "2027 694847.91411 683216.22691 706334.20522 699936.77726 694847.91411 \n", + "2028 719129.06114 724508.71647 708515.14657 695138.70629 702263.11470 \n", + "2029 720001.43768 745591.14952 706188.80913 708224.35439 726108.07346 \n", + "2030 715784.95107 735849.61149 726108.07346 708660.54266 710841.48401 \n", + "2031 723781.73602 745881.94170 730324.56007 740938.47464 733232.48187 \n", + "2032 723636.33993 741810.85118 735413.42322 740356.89028 723781.73602 \n", + "2033 737594.36457 755187.29146 763765.66077 723781.73602 742683.22772 \n", + "2034 742101.64336 785429.67818 756932.04454 749516.84395 768854.52392 \n", + "2035 791536.31396 765219.62167 756641.25236 780050.02285 768418.33565 \n", + "2036 770453.88091 795316.61230 796043.59275 793862.65140 795752.80057 \n", + "2037 804331.16988 774670.36752 776705.91278 807966.07213 788482.99607 \n", + "2038 804040.37770 824105.03812 797061.36538 809856.22130 804331.16988 \n", + "2039 824541.22639 820470.13587 807384.48777 818579.98670 799242.30673 \n", + "2040 819597.75933 801859.43635 826867.56383 823959.64203 833555.78397 \n", + "2041 836172.91359 831229.44653 816689.83753 824250.43421 828612.31691 \n", + "2042 850421.73041 844169.69854 830647.86217 839953.21193 847513.80861 \n", + "2043 839953.21193 833119.59570 824977.41466 834137.36833 860599.45671 \n", + "2044 841988.75719 855946.78183 854202.02875 865542.92377 848386.18515 \n", + "2045 859727.08017 852602.67176 841552.56892 839517.02366 871358.76737 \n", + "2046 866996.88467 866415.30031 860599.45671 853475.04830 852893.46394 \n", + "2047 852166.48349 851003.31477 868887.03384 848676.97733 867287.67685 \n", + "2048 873394.31263 877320.00706 872812.72827 827885.33646 857546.13882 \n", + "2049 866124.50813 866560.69640 864815.94332 866996.88467 864379.75505 \n", + "2050 854202.02875 880518.72104 880373.32495 874412.08526 872231.14391 \n", + "2051 888370.10990 883717.43502 890841.84343 865106.73550 856673.76228 \n", + "2052 871358.76737 885462.18810 892150.40824 902182.73845 892150.40824 \n", + "2053 880809.51322 884444.41547 867723.86512 882408.87021 896803.08312 \n", + "2054 891714.21997 872376.54000 876883.81879 899565.60883 896366.89485 \n", + "2055 895058.33004 893313.57696 880809.51322 890405.65516 874121.29308 \n", + "2056 883135.85066 909452.54295 882118.07803 886479.96073 875429.85789 \n", + "2057 870922.57910 899129.42056 904509.07589 887643.12945 894476.74568 \n", + "2058 878046.98751 874702.87744 886916.14900 904509.07589 932134.33299 \n", + "2059 901310.36191 905526.84852 914396.01001 903927.49153 903927.49153 \n", + "2060 20064.66042 17883.71907 18174.51125 19337.67997 20646.24478 \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/rem76/PycharmProjects/TLOmodel/src/tlo/analysis/utils.py:354: FutureWarning: DataFrame.groupby with axis=1 is deprecated. Do `frame.T.groupby(...)` without axis instead.\n", + " 'mean': results.groupby(axis=1, by='draw', sort=False).mean(),\n", + "/Users/rem76/PycharmProjects/TLOmodel/src/tlo/analysis/utils.py:355: FutureWarning: DataFrame.groupby with axis=1 is deprecated. Do `frame.T.groupby(...)` without axis instead.\n", + " 'lower': results.groupby(axis=1, by='draw', sort=False).quantile(0.025),\n", + "/Users/rem76/PycharmProjects/TLOmodel/src/tlo/analysis/utils.py:356: FutureWarning: DataFrame.groupby with axis=1 is deprecated. Do `frame.T.groupby(...)` without axis instead.\n", + " 'upper': results.groupby(axis=1, by='draw', sort=False).quantile(0.975),\n" + ] + } + ], + "execution_count": 19 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-03T10:30:33.173930Z", + "start_time": "2025-01-03T10:30:33.167871Z" + } + }, + "cell_type": "code", + "source": "births_model", + "id": "479ae4c0646f4003", + "outputs": [ + { + "data": { + "text/plain": [ + " Model_lower Model_mean Model_upper\n", + "year \n", + "2010 608693.460981 628838.089250 642643.447996\n", + "2011 516519.609725 534156.155442 546314.903468\n", + "2012 545969.587755 555064.113184 568324.236592\n", + "2013 571166.730152 580508.428934 589330.336695\n", + "2014 580748.332483 595716.859948 614567.463016\n", + "2015 603957.183349 617046.466351 623505.687649\n", + "2016 608864.301386 632342.135019 644061.059873\n", + "2017 628325.568033 643813.886520 657408.420935\n", + "2018 637281.967177 654020.692038 670265.070193\n", + "2019 645326.005856 661639.447154 675942.787508\n", + "2020 639499.257549 659705.679157 676615.244424\n", + "2021 628659.979040 645355.085074 656761.408335\n", + "2022 633287.209604 643217.762551 651839.750688\n", + "2023 642123.656974 653482.726505 662660.854686\n", + "2024 651127.309847 661086.942012 669734.374465\n", + "2025 668095.033550 677196.828784 690704.125545\n", + "2026 662213.761709 682387.469197 702328.542941\n", + "2027 685800.642410 699326.113682 710503.438101\n", + "2028 689617.289772 708180.735563 724050.718787\n", + "2029 706646.806814 725279.315747 747732.106945\n", + "2030 702688.398263 722938.438698 738441.296794\n", + "2031 725253.871431 741563.677827 751385.183707\n", + "2032 723669.054050 738394.043065 753606.108981\n", + "2033 726889.577444 750621.854234 772009.619073\n", + "2034 743770.063493 766644.503352 790162.320910\n", + "2035 758571.385455 776429.660209 790914.745675\n", + "2036 774706.716543 796203.528449 812880.459972\n", + "2037 770388.452670 793426.463130 808416.800009\n", + "2038 793568.224318 808780.290234 823810.611038\n", + "2039 795861.847638 812386.113266 824766.590330\n", + "2040 804672.850692 823974.181639 833326.785128\n", + "2041 810943.057073 824599.384826 835060.633502\n", + "2042 831661.999898 843515.416135 853722.221653\n", + "2043 826809.405394 842788.435685 863529.187924\n", + "2044 833155.944723 850741.601808 865412.067289\n", + "2045 835911.200628 853067.939248 880936.734799\n", + "2046 852104.690152 858229.500443 866866.028189\n", + "2047 849200.403254 865586.542597 884124.544072\n", + "2048 834559.016991 867767.483947 888024.794186\n", + "2049 859083.702472 869512.237027 887770.351029\n", + "2050 855772.306522 873088.980841 889195.232711\n", + "2051 858571.181255 882859.598089 899096.706440\n", + "2052 873158.043984 889911.308454 901888.311368\n", + "2053 870668.135943 891074.477174 917125.821600\n", + "2054 865615.621815 889024.392305 904607.218251\n", + "2055 875626.142612 892804.690645 906173.861121\n", + "2056 876934.707422 890929.081084 907391.553374\n", + "2057 874684.702929 895479.978701 912160.545126\n", + "2058 875455.302206 903404.065606 931480.050585\n", + "2059 901899.216075 910732.028542 924439.244927\n", + "2060 17949.147311 19599.392932 22111.110387" + ], + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Model_lowerModel_meanModel_upper
year
2010608693.460981628838.089250642643.447996
2011516519.609725534156.155442546314.903468
2012545969.587755555064.113184568324.236592
2013571166.730152580508.428934589330.336695
2014580748.332483595716.859948614567.463016
2015603957.183349617046.466351623505.687649
2016608864.301386632342.135019644061.059873
2017628325.568033643813.886520657408.420935
2018637281.967177654020.692038670265.070193
2019645326.005856661639.447154675942.787508
2020639499.257549659705.679157676615.244424
2021628659.979040645355.085074656761.408335
2022633287.209604643217.762551651839.750688
2023642123.656974653482.726505662660.854686
2024651127.309847661086.942012669734.374465
2025668095.033550677196.828784690704.125545
2026662213.761709682387.469197702328.542941
2027685800.642410699326.113682710503.438101
2028689617.289772708180.735563724050.718787
2029706646.806814725279.315747747732.106945
2030702688.398263722938.438698738441.296794
2031725253.871431741563.677827751385.183707
2032723669.054050738394.043065753606.108981
2033726889.577444750621.854234772009.619073
2034743770.063493766644.503352790162.320910
2035758571.385455776429.660209790914.745675
2036774706.716543796203.528449812880.459972
2037770388.452670793426.463130808416.800009
2038793568.224318808780.290234823810.611038
2039795861.847638812386.113266824766.590330
2040804672.850692823974.181639833326.785128
2041810943.057073824599.384826835060.633502
2042831661.999898843515.416135853722.221653
2043826809.405394842788.435685863529.187924
2044833155.944723850741.601808865412.067289
2045835911.200628853067.939248880936.734799
2046852104.690152858229.500443866866.028189
2047849200.403254865586.542597884124.544072
2048834559.016991867767.483947888024.794186
2049859083.702472869512.237027887770.351029
2050855772.306522873088.980841889195.232711
2051858571.181255882859.598089899096.706440
2052873158.043984889911.308454901888.311368
2053870668.135943891074.477174917125.821600
2054865615.621815889024.392305904607.218251
2055875626.142612892804.690645906173.861121
2056876934.707422890929.081084907391.553374
2057874684.702929895479.978701912160.545126
2058875455.302206903404.065606931480.050585
2059901899.216075910732.028542924439.244927
206017949.14731119599.39293222111.110387
\n", + "
" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 20 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Get expected disturbance from the model?", + "id": "aa40455f90215a5d" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-03T10:30:35.121476Z", + "start_time": "2025-01-03T10:30:35.119468Z" + } + }, + "cell_type": "code", + "source": "scenario = 'ssp245'", + "id": "bbff583692196586", + "outputs": [], + "execution_count": 21 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-03T10:30:38.768507Z", + "start_time": "2025-01-03T10:30:38.623973Z" + } + }, + "cell_type": "code", + "source": "predictions_from_cmip = pd.read_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}.csv')", + "id": "3be0a4515f3e890e", + "outputs": [], + "execution_count": 22 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-03T10:30:39.582983Z", + "start_time": "2025-01-03T10:30:39.450683Z" + } + }, + "cell_type": "code", + "source": [ + "predictions_from_cmip_sum = predictions_from_cmip.groupby('Year').sum().reset_index()\n", + "predictions_from_cmip_sum" + ], + "id": "aa5cab3b8ee058bd", + "outputs": [ + { + "data": { + "text/plain": [ + " Year Month Facility_ID Altitude \\\n", + "0 2025 24642 620396 3302918.0 \n", + "1 2026 25447 640288 3423381.0 \n", + "2 2027 24346 613299 3249211.0 \n", + "3 2028 24165 609869 3233056.0 \n", + "4 2029 23856 600707 3182788.0 \n", + "5 2030 24743 621446 3305374.0 \n", + "6 2031 22311 564387 2993610.0 \n", + "7 2032 25011 629286 3346578.0 \n", + "8 2033 23162 584299 3096405.0 \n", + "9 2034 24560 617891 3283369.0 \n", + "10 2035 25040 629510 3351904.0 \n", + "11 2036 23845 597393 3180499.0 \n", + "12 2037 23332 586786 3128727.0 \n", + "13 2038 24976 626428 3359830.0 \n", + "14 2039 24253 610545 3257219.0 \n", + "15 2040 25057 629920 3355680.0 \n", + "16 2041 23909 603172 3217069.0 \n", + "17 2042 24546 614459 3284010.0 \n", + "18 2043 25169 634991 3380638.0 \n", + "19 2044 23565 591583 3151148.0 \n", + "20 2045 24921 627096 3335948.0 \n", + "21 2046 23776 598458 3181465.0 \n", + "22 2047 22152 556685 2957237.0 \n", + "23 2048 23385 588872 3114865.0 \n", + "24 2049 25584 643536 3435564.0 \n", + "25 2050 23985 603121 3199136.0 \n", + "26 2051 24460 615031 3269170.0 \n", + "27 2052 23610 593948 3148362.0 \n", + "28 2053 24612 617265 3291913.0 \n", + "29 2054 23846 600531 3190334.0 \n", + "30 2055 24956 628421 3345467.0 \n", + "31 2056 23703 596560 3172864.0 \n", + "32 2057 23884 602103 3215112.0 \n", + "33 2058 24352 611347 3261366.0 \n", + "34 2059 24055 603579 3200088.0 \n", + "35 2060 22401 560380 3000088.0 \n", + "36 2061 25450 639870 3417374.0 \n", + "37 2062 23155 582547 3074410.0 \n", + "38 2063 23057 580043 3084421.0 \n", + "39 2064 23503 592241 3138838.0 \n", + "40 2065 23680 594336 3169648.0 \n", + "41 2066 23743 598339 3198839.0 \n", + "42 2067 24569 619436 3283765.0 \n", + "43 2068 24122 608216 3240015.0 \n", + "44 2069 24546 618608 3287355.0 \n", + "45 2070 23805 598800 3180887.0 \n", + "\n", + " Zone \\\n", + "0 Central WestSouth EastNorthernSouth EastNorthe... \n", + "1 Central WestSouth EastNorthernSouth EastNorthe... \n", + "2 Central WestSouth EastNorthernSouth EastNorthe... \n", + "3 Central WestSouth EastNorthernSouth EastNorthe... \n", + "4 Central WestSouth EastNorthernSouth EastNorthe... \n", + "5 Central WestSouth EastNorthernSouth EastNorthe... \n", + "6 Central WestSouth EastNorthernSouth EastNorthe... \n", + "7 Central WestSouth EastNorthernSouth EastNorthe... \n", + "8 Central WestSouth EastNorthernSouth EastNorthe... \n", + "9 Central WestSouth EastNorthernSouth EastNorthe... \n", + "10 Central WestSouth EastNorthernSouth EastNorthe... \n", + "11 Central WestSouth EastNorthernSouth EastNorthe... \n", + "12 Central WestSouth EastNorthernSouth EastNorthe... \n", + "13 Central WestSouth EastNorthernSouth EastNorthe... \n", + "14 Central WestSouth EastNorthernSouth EastNorthe... \n", + "15 Central WestSouth EastNorthernSouth EastNorthe... \n", + "16 Central WestSouth EastNorthernSouth EastNorthe... \n", + "17 Central WestSouth EastNorthernSouth EastNorthe... \n", + "18 Central WestSouth EastNorthernSouth EastNorthe... \n", + "19 Central WestSouth EastNorthernSouth EastNorthe... \n", + "20 Central WestSouth EastNorthernSouth EastNorthe... \n", + "21 Central WestSouth EastNorthernSouth EastNorthe... \n", + "22 Central WestSouth EastNorthernSouth EastNorthe... \n", + "23 Central WestSouth EastNorthernSouth EastNorthe... \n", + "24 Central WestSouth EastNorthernSouth EastNorthe... \n", + "25 Central WestSouth EastNorthernSouth EastNorthe... \n", + "26 Central WestSouth EastNorthernSouth EastNorthe... \n", + "27 Central WestSouth EastNorthernSouth EastNorthe... \n", + "28 Central WestSouth EastNorthernSouth EastNorthe... \n", + "29 Central WestSouth EastNorthernSouth EastNorthe... \n", + "30 Central WestSouth EastNorthernSouth EastNorthe... \n", + "31 Central WestSouth EastNorthernSouth EastNorthe... \n", + "32 Central WestSouth EastNorthernSouth EastNorthe... \n", + "33 Central WestSouth EastNorthernSouth EastNorthe... \n", + "34 Central WestSouth EastNorthernSouth EastNorthe... \n", + "35 Central WestSouth EastNorthernSouth EastNorthe... \n", + "36 Central WestSouth EastNorthernSouth EastNorthe... \n", + "37 Central WestSouth EastNorthernSouth EastNorthe... \n", + "38 Central WestSouth EastNorthernSouth EastNorthe... \n", + "39 Central WestSouth EastNorthernSouth EastNorthe... \n", + "40 Central WestSouth EastNorthernSouth EastNorthe... \n", + "41 Central WestSouth EastNorthernSouth EastNorthe... \n", + "42 Central WestSouth EastNorthernSouth EastNorthe... \n", + "43 Central WestSouth EastNorthernSouth EastNorthe... \n", + "44 Central WestSouth EastNorthernSouth EastNorthe... \n", + "45 Central WestSouth EastNorthernSouth EastNorthe... \n", + "\n", + " Resid \\\n", + "0 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "1 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "2 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "3 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "4 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "5 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "6 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "7 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "8 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "9 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "10 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "11 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "12 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "13 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "14 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "15 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "16 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "17 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "18 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "19 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "20 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "21 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "22 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "23 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "24 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "25 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "26 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "27 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "28 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "29 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "30 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "31 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "32 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "33 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "34 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "35 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "36 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "37 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "38 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "39 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "40 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "41 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "42 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "43 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "44 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "45 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "\n", + " Owner \\\n", + "0 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "1 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "2 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "3 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "4 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "5 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "6 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "7 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "8 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "9 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "10 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "11 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "12 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "13 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "14 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "15 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "16 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "17 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "18 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "19 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "20 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "21 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "22 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "23 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "24 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "25 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "26 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "27 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "28 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "29 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "30 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "31 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "32 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "33 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "34 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "35 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "36 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "37 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "38 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "39 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "40 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "41 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "42 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "43 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "44 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "45 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "\n", + " Facility_Type Precipitation \\\n", + "0 ClinicDistrict HospitalRural/Community Hospita... 440334.234308 \n", + "1 ClinicDistrict HospitalRural/Community Hospita... 368143.657611 \n", + "2 ClinicDistrict HospitalRural/Community Hospita... 389512.271746 \n", + "3 ClinicDistrict HospitalRural/Community Hospita... 467236.272652 \n", + "4 ClinicDistrict HospitalRural/Community Hospita... 510281.500940 \n", + "5 ClinicDistrict HospitalRural/Community Hospita... 415561.678186 \n", + "6 ClinicDistrict HospitalRural/Community Hospita... 306576.789734 \n", + "7 ClinicDistrict HospitalRural/Community Hospita... 322789.637078 \n", + "8 ClinicDistrict HospitalRural/Community Hospita... 417617.290163 \n", + "9 ClinicDistrict HospitalRural/Community Hospita... 397886.401018 \n", + "10 ClinicDistrict HospitalRural/Community Hospita... 459406.340711 \n", + "11 ClinicDistrict HospitalRural/Community Hospita... 397647.735041 \n", + "12 ClinicDistrict HospitalRural/Community Hospita... 391610.416555 \n", + "13 ClinicDistrict HospitalRural/Community Hospita... 441416.106096 \n", + "14 ClinicDistrict HospitalRural/Community Hospita... 375365.449796 \n", + "15 ClinicDistrict HospitalRural/Community Hospita... 410970.020588 \n", + "16 ClinicDistrict HospitalRural/Community Hospita... 409283.988225 \n", + "17 ClinicDistrict HospitalRural/Community Hospita... 473493.289947 \n", + "18 ClinicDistrict HospitalRural/Community Hospita... 469347.741866 \n", + "19 ClinicDistrict HospitalRural/Community Hospita... 367242.325518 \n", + "20 ClinicDistrict HospitalRural/Community Hospita... 315560.724644 \n", + "21 ClinicDistrict HospitalRural/Community Hospita... 371782.115694 \n", + "22 ClinicDistrict HospitalRural/Community Hospita... 434630.692016 \n", + "23 ClinicDistrict HospitalRural/Community Hospita... 341127.222055 \n", + "24 ClinicDistrict HospitalRural/Community Hospita... 431988.493807 \n", + "25 ClinicDistrict HospitalRural/Community Hospita... 421327.798951 \n", + "26 ClinicDistrict HospitalRural/Community Hospita... 321024.804561 \n", + "27 ClinicDistrict HospitalRural/Community Hospita... 469034.752168 \n", + "28 ClinicDistrict HospitalRural/Community Hospita... 479370.138921 \n", + "29 ClinicDistrict HospitalRural/Community Hospita... 378828.522395 \n", + "30 ClinicDistrict HospitalRural/Community Hospita... 478046.700552 \n", + "31 ClinicDistrict HospitalRural/Community Hospita... 370264.174609 \n", + "32 ClinicDistrict HospitalRural/Community Hospita... 378162.247570 \n", + "33 ClinicDistrict HospitalRural/Community Hospita... 414908.289481 \n", + "34 ClinicDistrict HospitalRural/Community Hospita... 455684.817802 \n", + "35 ClinicDistrict HospitalRural/Community Hospita... 359900.771691 \n", + "36 ClinicDistrict HospitalRural/Community Hospita... 522352.080349 \n", + "37 ClinicDistrict HospitalRural/Community Hospita... 376936.757775 \n", + "38 ClinicDistrict HospitalRural/Community Hospita... 467723.711737 \n", + "39 ClinicDistrict HospitalRural/Community Hospita... 323517.333199 \n", + "40 ClinicDistrict HospitalRural/Community Hospita... 345713.935117 \n", + "41 ClinicDistrict HospitalRural/Community Hospita... 395462.015387 \n", + "42 ClinicDistrict HospitalRural/Community Hospita... 406529.105098 \n", + "43 ClinicDistrict HospitalRural/Community Hospita... 574552.855124 \n", + "44 ClinicDistrict HospitalRural/Community Hospita... 446939.143675 \n", + "45 ClinicDistrict HospitalRural/Community Hospita... 478443.587177 \n", + "\n", + " Lag_1_Precipitation Lag_2_Precipitation Lag_3_Precipitation \\\n", + "0 353904.731005 325681.489860 297561.640581 \n", + "1 401420.433758 403405.854504 402539.554951 \n", + "2 371731.795831 352017.560308 341274.411245 \n", + "3 463195.874132 489324.647136 467717.368493 \n", + "4 502657.340862 482774.102033 508613.994882 \n", + "5 430082.709305 433194.385110 426679.595380 \n", + "6 309978.599600 325681.193935 315680.278887 \n", + "7 346456.981332 346504.507849 343190.362299 \n", + "8 357429.121158 338700.251142 340245.308388 \n", + "9 399155.990738 376194.009554 375103.117941 \n", + "10 495631.995766 495403.900197 486208.445508 \n", + "11 394956.683884 407506.319795 414531.165308 \n", + "12 343980.571323 350808.137426 347057.035888 \n", + "13 452575.562133 454464.217285 452146.877154 \n", + "14 362433.347050 371149.568476 363933.535093 \n", + "15 447884.643580 447682.568270 449803.904849 \n", + "16 389442.315269 385668.859805 378426.274901 \n", + "17 451147.769581 430615.696082 425669.313089 \n", + "18 494545.073752 499347.930783 493783.833404 \n", + "19 371711.781452 374913.433345 377110.720066 \n", + "20 343353.455376 345223.997177 342021.238793 \n", + "21 305812.333010 294432.924965 293503.944334 \n", + "22 457467.620834 474432.706520 472613.554807 \n", + "23 315111.678821 294945.264077 285233.426898 \n", + "24 443731.169805 451146.067144 447883.026972 \n", + "25 396769.929491 408562.425855 418502.725903 \n", + "26 345132.495319 329562.416251 323549.743210 \n", + "27 469662.194769 448426.362540 446609.577932 \n", + "28 461118.374422 452747.999276 442215.228495 \n", + "29 435684.567230 434997.915598 436064.621612 \n", + "30 428881.409055 453508.028054 449527.028001 \n", + "31 415190.572889 426911.392935 433321.292498 \n", + "32 377205.366488 342790.975990 332326.448483 \n", + "33 333540.646309 362992.743057 366721.297324 \n", + "34 472393.409198 478349.032980 477401.048276 \n", + "35 372597.770047 360489.465892 363261.114549 \n", + "36 579014.399822 568925.720500 565835.475117 \n", + "37 379134.096954 381629.099749 364270.180436 \n", + "38 401612.564532 392392.393319 396304.528597 \n", + "39 367831.340554 346112.375544 324946.993397 \n", + "40 293320.941908 318220.999319 326566.490286 \n", + "41 445201.806887 440143.467266 438945.020171 \n", + "42 356852.651551 349188.139601 335367.151073 \n", + "43 543870.172353 546057.722361 548303.362147 \n", + "44 511156.014302 533278.121296 529131.538903 \n", + "45 441135.161700 433665.355653 444075.669003 \n", + "\n", + " Lag_4_Precipitation Predicted_Weather_Model Predicted_No_Weather_Model \\\n", + "0 282054.887587 282875.789559 435056.523872 \n", + "1 403356.754888 446973.452602 448297.963620 \n", + "2 330719.679227 429699.165446 428855.082772 \n", + "3 464588.245545 426390.662966 425105.144739 \n", + "4 503630.296180 419862.210285 417366.002941 \n", + "5 423888.501330 429293.165886 430209.704481 \n", + "6 290028.482608 388423.461274 388929.485473 \n", + "7 342685.296868 434991.492594 436710.225310 \n", + "8 340546.248413 400294.397759 402492.398969 \n", + "9 373789.068455 425657.584762 427231.110037 \n", + "10 482900.825373 433154.044585 434659.478247 \n", + "11 393286.530926 409005.784582 408150.336768 \n", + "12 341463.248905 399090.628516 401572.454562 \n", + "13 450786.011451 431402.659483 429626.731487 \n", + "14 360843.806040 412578.359715 415007.121480 \n", + "15 448981.207566 428390.924640 428879.058208 \n", + "16 374044.680265 407922.043693 409972.692203 \n", + "17 429496.615643 412187.659372 413257.478800 \n", + "18 488803.549502 430347.112355 430015.937504 \n", + "19 377895.449896 401348.874670 401054.748615 \n", + "20 334436.491016 423672.932007 425227.379946 \n", + "21 296392.880809 398552.821055 401775.342808 \n", + "22 440392.213570 373087.409200 374239.513003 \n", + "23 253195.609983 390315.605105 391466.290883 \n", + "24 446049.207337 430832.507546 432053.418987 \n", + "25 419774.688159 402422.115951 403916.440618 \n", + "26 317332.704749 409463.606493 410180.385199 \n", + "27 435340.199013 391160.953917 393091.155764 \n", + "28 400887.449181 409930.626615 412238.859114 \n", + "29 432867.449960 396400.887798 396070.808867 \n", + "30 444985.809368 416341.114108 417028.311391 \n", + "31 423776.044021 395081.647605 391936.636790 \n", + "32 330739.987217 394811.555047 396221.517042 \n", + "33 367575.167706 401393.780962 403754.537706 \n", + "34 438412.338758 391860.264252 393873.141006 \n", + "35 359252.347918 367209.410297 366611.581462 \n", + "36 550598.603341 417434.381690 420020.233730 \n", + "37 356574.164485 377882.767541 377365.440971 \n", + "38 394369.022680 374082.177605 374460.254161 \n", + "39 312443.249634 382423.385030 382966.454764 \n", + "40 323628.322020 384159.066998 384056.354457 \n", + "41 435197.782687 385665.968172 385827.443170 \n", + "42 336038.756644 398291.557836 400458.849287 \n", + "43 547679.218868 391932.655476 393162.031631 \n", + "44 529176.140345 396645.182138 399251.911588 \n", + "45 439392.286115 383002.326955 384919.782302 \n", + "\n", + " Difference_in_Expectation \n", + "0 -1479.431742 \n", + "1 -1324.511018 \n", + "2 844.082675 \n", + "3 1285.518227 \n", + "4 2496.207344 \n", + "5 -916.538595 \n", + "6 -506.024199 \n", + "7 -1718.732715 \n", + "8 -2198.001210 \n", + "9 -1573.525275 \n", + "10 -1505.433662 \n", + "11 855.447814 \n", + "12 -2481.826046 \n", + "13 1775.927996 \n", + "14 -2428.761765 \n", + "15 -488.133568 \n", + "16 -2050.648510 \n", + "17 -1069.819428 \n", + "18 331.174851 \n", + "19 294.126054 \n", + "20 -1554.447940 \n", + "21 -3222.521752 \n", + "22 -1152.103803 \n", + "23 -1150.685778 \n", + "24 -1220.911442 \n", + "25 -1494.324667 \n", + "26 -716.778707 \n", + "27 -1930.201847 \n", + "28 -2308.232499 \n", + "29 330.078931 \n", + "30 -687.197283 \n", + "31 3145.010815 \n", + "32 -1409.961995 \n", + "33 -2360.756744 \n", + "34 -2012.876754 \n", + "35 597.828835 \n", + "36 -2585.852040 \n", + "37 517.326570 \n", + "38 -378.076555 \n", + "39 -543.069734 \n", + "40 102.712541 \n", + "41 -161.474998 \n", + "42 -2167.291450 \n", + "43 -1229.376155 \n", + "44 -2606.729450 \n", + "45 -1917.455347 " + ], + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
YearMonthFacility_IDAltitudeZoneResidOwnerFacility_TypePrecipitationLag_1_PrecipitationLag_2_PrecipitationLag_3_PrecipitationLag_4_PrecipitationPredicted_Weather_ModelPredicted_No_Weather_ModelDifference_in_Expectation
02025246426203963302918.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...440334.234308353904.731005325681.489860297561.640581282054.887587282875.789559435056.523872-1479.431742
12026254476402883423381.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...368143.657611401420.433758403405.854504402539.554951403356.754888446973.452602448297.963620-1324.511018
22027243466132993249211.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...389512.271746371731.795831352017.560308341274.411245330719.679227429699.165446428855.082772844.082675
32028241656098693233056.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...467236.272652463195.874132489324.647136467717.368493464588.245545426390.662966425105.1447391285.518227
42029238566007073182788.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...510281.500940502657.340862482774.102033508613.994882503630.296180419862.210285417366.0029412496.207344
52030247436214463305374.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...415561.678186430082.709305433194.385110426679.595380423888.501330429293.165886430209.704481-916.538595
62031223115643872993610.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...306576.789734309978.599600325681.193935315680.278887290028.482608388423.461274388929.485473-506.024199
72032250116292863346578.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...322789.637078346456.981332346504.507849343190.362299342685.296868434991.492594436710.225310-1718.732715
82033231625842993096405.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...417617.290163357429.121158338700.251142340245.308388340546.248413400294.397759402492.398969-2198.001210
92034245606178913283369.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...397886.401018399155.990738376194.009554375103.117941373789.068455425657.584762427231.110037-1573.525275
102035250406295103351904.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...459406.340711495631.995766495403.900197486208.445508482900.825373433154.044585434659.478247-1505.433662
112036238455973933180499.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...397647.735041394956.683884407506.319795414531.165308393286.530926409005.784582408150.336768855.447814
122037233325867863128727.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...391610.416555343980.571323350808.137426347057.035888341463.248905399090.628516401572.454562-2481.826046
132038249766264283359830.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...441416.106096452575.562133454464.217285452146.877154450786.011451431402.659483429626.7314871775.927996
142039242536105453257219.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...375365.449796362433.347050371149.568476363933.535093360843.806040412578.359715415007.121480-2428.761765
152040250576299203355680.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...410970.020588447884.643580447682.568270449803.904849448981.207566428390.924640428879.058208-488.133568
162041239096031723217069.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...409283.988225389442.315269385668.859805378426.274901374044.680265407922.043693409972.692203-2050.648510
172042245466144593284010.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...473493.289947451147.769581430615.696082425669.313089429496.615643412187.659372413257.478800-1069.819428
182043251696349913380638.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...469347.741866494545.073752499347.930783493783.833404488803.549502430347.112355430015.937504331.174851
192044235655915833151148.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...367242.325518371711.781452374913.433345377110.720066377895.449896401348.874670401054.748615294.126054
202045249216270963335948.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...315560.724644343353.455376345223.997177342021.238793334436.491016423672.932007425227.379946-1554.447940
212046237765984583181465.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...371782.115694305812.333010294432.924965293503.944334296392.880809398552.821055401775.342808-3222.521752
222047221525566852957237.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...434630.692016457467.620834474432.706520472613.554807440392.213570373087.409200374239.513003-1152.103803
232048233855888723114865.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...341127.222055315111.678821294945.264077285233.426898253195.609983390315.605105391466.290883-1150.685778
242049255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...431988.493807443731.169805451146.067144447883.026972446049.207337430832.507546432053.418987-1220.911442
252050239856031213199136.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...421327.798951396769.929491408562.425855418502.725903419774.688159402422.115951403916.440618-1494.324667
262051244606150313269170.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...321024.804561345132.495319329562.416251323549.743210317332.704749409463.606493410180.385199-716.778707
272052236105939483148362.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...469034.752168469662.194769448426.362540446609.577932435340.199013391160.953917393091.155764-1930.201847
282053246126172653291913.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...479370.138921461118.374422452747.999276442215.228495400887.449181409930.626615412238.859114-2308.232499
292054238466005313190334.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...378828.522395435684.567230434997.915598436064.621612432867.449960396400.887798396070.808867330.078931
302055249566284213345467.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...478046.700552428881.409055453508.028054449527.028001444985.809368416341.114108417028.311391-687.197283
312056237035965603172864.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...370264.174609415190.572889426911.392935433321.292498423776.044021395081.647605391936.6367903145.010815
322057238846021033215112.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...378162.247570377205.366488342790.975990332326.448483330739.987217394811.555047396221.517042-1409.961995
332058243526113473261366.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...414908.289481333540.646309362992.743057366721.297324367575.167706401393.780962403754.537706-2360.756744
342059240556035793200088.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...455684.817802472393.409198478349.032980477401.048276438412.338758391860.264252393873.141006-2012.876754
352060224015603803000088.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...359900.771691372597.770047360489.465892363261.114549359252.347918367209.410297366611.581462597.828835
362061254506398703417374.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...522352.080349579014.399822568925.720500565835.475117550598.603341417434.381690420020.233730-2585.852040
372062231555825473074410.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...376936.757775379134.096954381629.099749364270.180436356574.164485377882.767541377365.440971517.326570
382063230575800433084421.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...467723.711737401612.564532392392.393319396304.528597394369.022680374082.177605374460.254161-378.076555
392064235035922413138838.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...323517.333199367831.340554346112.375544324946.993397312443.249634382423.385030382966.454764-543.069734
402065236805943363169648.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...345713.935117293320.941908318220.999319326566.490286323628.322020384159.066998384056.354457102.712541
412066237435983393198839.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...395462.015387445201.806887440143.467266438945.020171435197.782687385665.968172385827.443170-161.474998
422067245696194363283765.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...406529.105098356852.651551349188.139601335367.151073336038.756644398291.557836400458.849287-2167.291450
432068241226082163240015.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...574552.855124543870.172353546057.722361548303.362147547679.218868391932.655476393162.031631-1229.376155
442069245466186083287355.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...446939.143675511156.014302533278.121296529131.538903529176.140345396645.182138399251.911588-2606.729450
452070238055988003180887.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...478443.587177441135.161700433665.355653444075.669003439392.286115383002.326955384919.782302-1917.455347
\n", + "
" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 23 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-03T10:30:40.235961Z", + "start_time": "2025-01-03T10:30:40.208890Z" + } + }, + "cell_type": "code", + "source": [ + "predictions_from_cmip_sum['Percentage_Difference'] = (predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model']) \n", + "predictions_from_cmip_sum" + ], + "id": "c5a9dc35ac31e4b7", + "outputs": [ + { + "data": { + "text/plain": [ + " Year Month Facility_ID Altitude \\\n", + "0 2025 24642 620396 3302918.0 \n", + "1 2026 25447 640288 3423381.0 \n", + "2 2027 24346 613299 3249211.0 \n", + "3 2028 24165 609869 3233056.0 \n", + "4 2029 23856 600707 3182788.0 \n", + "5 2030 24743 621446 3305374.0 \n", + "6 2031 22311 564387 2993610.0 \n", + "7 2032 25011 629286 3346578.0 \n", + "8 2033 23162 584299 3096405.0 \n", + "9 2034 24560 617891 3283369.0 \n", + "10 2035 25040 629510 3351904.0 \n", + "11 2036 23845 597393 3180499.0 \n", + "12 2037 23332 586786 3128727.0 \n", + "13 2038 24976 626428 3359830.0 \n", + "14 2039 24253 610545 3257219.0 \n", + "15 2040 25057 629920 3355680.0 \n", + "16 2041 23909 603172 3217069.0 \n", + "17 2042 24546 614459 3284010.0 \n", + "18 2043 25169 634991 3380638.0 \n", + "19 2044 23565 591583 3151148.0 \n", + "20 2045 24921 627096 3335948.0 \n", + "21 2046 23776 598458 3181465.0 \n", + "22 2047 22152 556685 2957237.0 \n", + "23 2048 23385 588872 3114865.0 \n", + "24 2049 25584 643536 3435564.0 \n", + "25 2050 23985 603121 3199136.0 \n", + "26 2051 24460 615031 3269170.0 \n", + "27 2052 23610 593948 3148362.0 \n", + "28 2053 24612 617265 3291913.0 \n", + "29 2054 23846 600531 3190334.0 \n", + "30 2055 24956 628421 3345467.0 \n", + "31 2056 23703 596560 3172864.0 \n", + "32 2057 23884 602103 3215112.0 \n", + "33 2058 24352 611347 3261366.0 \n", + "34 2059 24055 603579 3200088.0 \n", + "35 2060 22401 560380 3000088.0 \n", + "36 2061 25450 639870 3417374.0 \n", + "37 2062 23155 582547 3074410.0 \n", + "38 2063 23057 580043 3084421.0 \n", + "39 2064 23503 592241 3138838.0 \n", + "40 2065 23680 594336 3169648.0 \n", + "41 2066 23743 598339 3198839.0 \n", + "42 2067 24569 619436 3283765.0 \n", + "43 2068 24122 608216 3240015.0 \n", + "44 2069 24546 618608 3287355.0 \n", + "45 2070 23805 598800 3180887.0 \n", + "\n", + " Zone \\\n", + "0 Central WestSouth EastNorthernSouth EastNorthe... \n", + "1 Central WestSouth EastNorthernSouth EastNorthe... \n", + "2 Central WestSouth EastNorthernSouth EastNorthe... \n", + "3 Central WestSouth EastNorthernSouth EastNorthe... \n", + "4 Central WestSouth EastNorthernSouth EastNorthe... \n", + "5 Central WestSouth EastNorthernSouth EastNorthe... \n", + "6 Central WestSouth EastNorthernSouth EastNorthe... \n", + "7 Central WestSouth EastNorthernSouth EastNorthe... \n", + "8 Central WestSouth EastNorthernSouth EastNorthe... \n", + "9 Central WestSouth EastNorthernSouth EastNorthe... \n", + "10 Central WestSouth EastNorthernSouth EastNorthe... \n", + "11 Central WestSouth EastNorthernSouth EastNorthe... \n", + "12 Central WestSouth EastNorthernSouth EastNorthe... \n", + "13 Central WestSouth EastNorthernSouth EastNorthe... \n", + "14 Central WestSouth EastNorthernSouth EastNorthe... \n", + "15 Central WestSouth EastNorthernSouth EastNorthe... \n", + "16 Central WestSouth EastNorthernSouth EastNorthe... \n", + "17 Central WestSouth EastNorthernSouth EastNorthe... \n", + "18 Central WestSouth EastNorthernSouth EastNorthe... \n", + "19 Central WestSouth EastNorthernSouth EastNorthe... \n", + "20 Central WestSouth EastNorthernSouth EastNorthe... \n", + "21 Central WestSouth EastNorthernSouth EastNorthe... \n", + "22 Central WestSouth EastNorthernSouth EastNorthe... \n", + "23 Central WestSouth EastNorthernSouth EastNorthe... \n", + "24 Central WestSouth EastNorthernSouth EastNorthe... \n", + "25 Central WestSouth EastNorthernSouth EastNorthe... \n", + "26 Central WestSouth EastNorthernSouth EastNorthe... \n", + "27 Central WestSouth EastNorthernSouth EastNorthe... \n", + "28 Central WestSouth EastNorthernSouth EastNorthe... \n", + "29 Central WestSouth EastNorthernSouth EastNorthe... \n", + "30 Central WestSouth EastNorthernSouth EastNorthe... \n", + "31 Central WestSouth EastNorthernSouth EastNorthe... \n", + "32 Central WestSouth EastNorthernSouth EastNorthe... \n", + "33 Central WestSouth EastNorthernSouth EastNorthe... \n", + "34 Central WestSouth EastNorthernSouth EastNorthe... \n", + "35 Central WestSouth EastNorthernSouth EastNorthe... \n", + "36 Central WestSouth EastNorthernSouth EastNorthe... \n", + "37 Central WestSouth EastNorthernSouth EastNorthe... \n", + "38 Central WestSouth EastNorthernSouth EastNorthe... \n", + "39 Central WestSouth EastNorthernSouth EastNorthe... \n", + "40 Central WestSouth EastNorthernSouth EastNorthe... \n", + "41 Central WestSouth EastNorthernSouth EastNorthe... \n", + "42 Central WestSouth EastNorthernSouth EastNorthe... \n", + "43 Central WestSouth EastNorthernSouth EastNorthe... \n", + "44 Central WestSouth EastNorthernSouth EastNorthe... \n", + "45 Central WestSouth EastNorthernSouth EastNorthe... \n", + "\n", + " Resid \\\n", + "0 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "1 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "2 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "3 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "4 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "5 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "6 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "7 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "8 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "9 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "10 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "11 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "12 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "13 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "14 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "15 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "16 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "17 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "18 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "19 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "20 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "21 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "22 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "23 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "24 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "25 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "26 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "27 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "28 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "29 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "30 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "31 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "32 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "33 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "34 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "35 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "36 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "37 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "38 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "39 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "40 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "41 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "42 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "43 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "44 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "45 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "\n", + " Owner \\\n", + "0 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "1 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "2 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "3 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "4 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "5 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "6 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "7 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "8 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "9 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "10 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "11 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "12 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "13 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "14 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "15 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "16 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "17 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "18 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "19 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "20 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "21 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "22 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "23 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "24 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "25 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "26 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "27 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "28 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "29 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "30 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "31 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "32 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "33 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "34 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "35 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "36 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "37 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "38 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "39 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "40 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "41 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "42 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "43 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "44 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "45 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "\n", + " Facility_Type Precipitation \\\n", + "0 ClinicDistrict HospitalRural/Community Hospita... 440334.234308 \n", + "1 ClinicDistrict HospitalRural/Community Hospita... 368143.657611 \n", + "2 ClinicDistrict HospitalRural/Community Hospita... 389512.271746 \n", + "3 ClinicDistrict HospitalRural/Community Hospita... 467236.272652 \n", + "4 ClinicDistrict HospitalRural/Community Hospita... 510281.500940 \n", + "5 ClinicDistrict HospitalRural/Community Hospita... 415561.678186 \n", + "6 ClinicDistrict HospitalRural/Community Hospita... 306576.789734 \n", + "7 ClinicDistrict HospitalRural/Community Hospita... 322789.637078 \n", + "8 ClinicDistrict HospitalRural/Community Hospita... 417617.290163 \n", + "9 ClinicDistrict HospitalRural/Community Hospita... 397886.401018 \n", + "10 ClinicDistrict HospitalRural/Community Hospita... 459406.340711 \n", + "11 ClinicDistrict HospitalRural/Community Hospita... 397647.735041 \n", + "12 ClinicDistrict HospitalRural/Community Hospita... 391610.416555 \n", + "13 ClinicDistrict HospitalRural/Community Hospita... 441416.106096 \n", + "14 ClinicDistrict HospitalRural/Community Hospita... 375365.449796 \n", + "15 ClinicDistrict HospitalRural/Community Hospita... 410970.020588 \n", + "16 ClinicDistrict HospitalRural/Community Hospita... 409283.988225 \n", + "17 ClinicDistrict HospitalRural/Community Hospita... 473493.289947 \n", + "18 ClinicDistrict HospitalRural/Community Hospita... 469347.741866 \n", + "19 ClinicDistrict HospitalRural/Community Hospita... 367242.325518 \n", + "20 ClinicDistrict HospitalRural/Community Hospita... 315560.724644 \n", + "21 ClinicDistrict HospitalRural/Community Hospita... 371782.115694 \n", + "22 ClinicDistrict HospitalRural/Community Hospita... 434630.692016 \n", + "23 ClinicDistrict HospitalRural/Community Hospita... 341127.222055 \n", + "24 ClinicDistrict HospitalRural/Community Hospita... 431988.493807 \n", + "25 ClinicDistrict HospitalRural/Community Hospita... 421327.798951 \n", + "26 ClinicDistrict HospitalRural/Community Hospita... 321024.804561 \n", + "27 ClinicDistrict HospitalRural/Community Hospita... 469034.752168 \n", + "28 ClinicDistrict HospitalRural/Community Hospita... 479370.138921 \n", + "29 ClinicDistrict HospitalRural/Community Hospita... 378828.522395 \n", + "30 ClinicDistrict HospitalRural/Community Hospita... 478046.700552 \n", + "31 ClinicDistrict HospitalRural/Community Hospita... 370264.174609 \n", + "32 ClinicDistrict HospitalRural/Community Hospita... 378162.247570 \n", + "33 ClinicDistrict HospitalRural/Community Hospita... 414908.289481 \n", + "34 ClinicDistrict HospitalRural/Community Hospita... 455684.817802 \n", + "35 ClinicDistrict HospitalRural/Community Hospita... 359900.771691 \n", + "36 ClinicDistrict HospitalRural/Community Hospita... 522352.080349 \n", + "37 ClinicDistrict HospitalRural/Community Hospita... 376936.757775 \n", + "38 ClinicDistrict HospitalRural/Community Hospita... 467723.711737 \n", + "39 ClinicDistrict HospitalRural/Community Hospita... 323517.333199 \n", + "40 ClinicDistrict HospitalRural/Community Hospita... 345713.935117 \n", + "41 ClinicDistrict HospitalRural/Community Hospita... 395462.015387 \n", + "42 ClinicDistrict HospitalRural/Community Hospita... 406529.105098 \n", + "43 ClinicDistrict HospitalRural/Community Hospita... 574552.855124 \n", + "44 ClinicDistrict HospitalRural/Community Hospita... 446939.143675 \n", + "45 ClinicDistrict HospitalRural/Community Hospita... 478443.587177 \n", + "\n", + " Lag_1_Precipitation Lag_2_Precipitation Lag_3_Precipitation \\\n", + "0 353904.731005 325681.489860 297561.640581 \n", + "1 401420.433758 403405.854504 402539.554951 \n", + "2 371731.795831 352017.560308 341274.411245 \n", + "3 463195.874132 489324.647136 467717.368493 \n", + "4 502657.340862 482774.102033 508613.994882 \n", + "5 430082.709305 433194.385110 426679.595380 \n", + "6 309978.599600 325681.193935 315680.278887 \n", + "7 346456.981332 346504.507849 343190.362299 \n", + "8 357429.121158 338700.251142 340245.308388 \n", + "9 399155.990738 376194.009554 375103.117941 \n", + "10 495631.995766 495403.900197 486208.445508 \n", + "11 394956.683884 407506.319795 414531.165308 \n", + "12 343980.571323 350808.137426 347057.035888 \n", + "13 452575.562133 454464.217285 452146.877154 \n", + "14 362433.347050 371149.568476 363933.535093 \n", + "15 447884.643580 447682.568270 449803.904849 \n", + "16 389442.315269 385668.859805 378426.274901 \n", + "17 451147.769581 430615.696082 425669.313089 \n", + "18 494545.073752 499347.930783 493783.833404 \n", + "19 371711.781452 374913.433345 377110.720066 \n", + "20 343353.455376 345223.997177 342021.238793 \n", + "21 305812.333010 294432.924965 293503.944334 \n", + "22 457467.620834 474432.706520 472613.554807 \n", + "23 315111.678821 294945.264077 285233.426898 \n", + "24 443731.169805 451146.067144 447883.026972 \n", + "25 396769.929491 408562.425855 418502.725903 \n", + "26 345132.495319 329562.416251 323549.743210 \n", + "27 469662.194769 448426.362540 446609.577932 \n", + "28 461118.374422 452747.999276 442215.228495 \n", + "29 435684.567230 434997.915598 436064.621612 \n", + "30 428881.409055 453508.028054 449527.028001 \n", + "31 415190.572889 426911.392935 433321.292498 \n", + "32 377205.366488 342790.975990 332326.448483 \n", + "33 333540.646309 362992.743057 366721.297324 \n", + "34 472393.409198 478349.032980 477401.048276 \n", + "35 372597.770047 360489.465892 363261.114549 \n", + "36 579014.399822 568925.720500 565835.475117 \n", + "37 379134.096954 381629.099749 364270.180436 \n", + "38 401612.564532 392392.393319 396304.528597 \n", + "39 367831.340554 346112.375544 324946.993397 \n", + "40 293320.941908 318220.999319 326566.490286 \n", + "41 445201.806887 440143.467266 438945.020171 \n", + "42 356852.651551 349188.139601 335367.151073 \n", + "43 543870.172353 546057.722361 548303.362147 \n", + "44 511156.014302 533278.121296 529131.538903 \n", + "45 441135.161700 433665.355653 444075.669003 \n", + "\n", + " Lag_4_Precipitation Predicted_Weather_Model Predicted_No_Weather_Model \\\n", + "0 282054.887587 282875.789559 435056.523872 \n", + "1 403356.754888 446973.452602 448297.963620 \n", + "2 330719.679227 429699.165446 428855.082772 \n", + "3 464588.245545 426390.662966 425105.144739 \n", + "4 503630.296180 419862.210285 417366.002941 \n", + "5 423888.501330 429293.165886 430209.704481 \n", + "6 290028.482608 388423.461274 388929.485473 \n", + "7 342685.296868 434991.492594 436710.225310 \n", + "8 340546.248413 400294.397759 402492.398969 \n", + "9 373789.068455 425657.584762 427231.110037 \n", + "10 482900.825373 433154.044585 434659.478247 \n", + "11 393286.530926 409005.784582 408150.336768 \n", + "12 341463.248905 399090.628516 401572.454562 \n", + "13 450786.011451 431402.659483 429626.731487 \n", + "14 360843.806040 412578.359715 415007.121480 \n", + "15 448981.207566 428390.924640 428879.058208 \n", + "16 374044.680265 407922.043693 409972.692203 \n", + "17 429496.615643 412187.659372 413257.478800 \n", + "18 488803.549502 430347.112355 430015.937504 \n", + "19 377895.449896 401348.874670 401054.748615 \n", + "20 334436.491016 423672.932007 425227.379946 \n", + "21 296392.880809 398552.821055 401775.342808 \n", + "22 440392.213570 373087.409200 374239.513003 \n", + "23 253195.609983 390315.605105 391466.290883 \n", + "24 446049.207337 430832.507546 432053.418987 \n", + "25 419774.688159 402422.115951 403916.440618 \n", + "26 317332.704749 409463.606493 410180.385199 \n", + "27 435340.199013 391160.953917 393091.155764 \n", + "28 400887.449181 409930.626615 412238.859114 \n", + "29 432867.449960 396400.887798 396070.808867 \n", + "30 444985.809368 416341.114108 417028.311391 \n", + "31 423776.044021 395081.647605 391936.636790 \n", + "32 330739.987217 394811.555047 396221.517042 \n", + "33 367575.167706 401393.780962 403754.537706 \n", + "34 438412.338758 391860.264252 393873.141006 \n", + "35 359252.347918 367209.410297 366611.581462 \n", + "36 550598.603341 417434.381690 420020.233730 \n", + "37 356574.164485 377882.767541 377365.440971 \n", + "38 394369.022680 374082.177605 374460.254161 \n", + "39 312443.249634 382423.385030 382966.454764 \n", + "40 323628.322020 384159.066998 384056.354457 \n", + "41 435197.782687 385665.968172 385827.443170 \n", + "42 336038.756644 398291.557836 400458.849287 \n", + "43 547679.218868 391932.655476 393162.031631 \n", + "44 529176.140345 396645.182138 399251.911588 \n", + "45 439392.286115 383002.326955 384919.782302 \n", + "\n", + " Difference_in_Expectation Percentage_Difference \n", + "0 -1479.431742 -0.003401 \n", + "1 -1324.511018 -0.002955 \n", + "2 844.082675 0.001968 \n", + "3 1285.518227 0.003024 \n", + "4 2496.207344 0.005981 \n", + "5 -916.538595 -0.002130 \n", + "6 -506.024199 -0.001301 \n", + "7 -1718.732715 -0.003936 \n", + "8 -2198.001210 -0.005461 \n", + "9 -1573.525275 -0.003683 \n", + "10 -1505.433662 -0.003463 \n", + "11 855.447814 0.002096 \n", + "12 -2481.826046 -0.006180 \n", + "13 1775.927996 0.004134 \n", + "14 -2428.761765 -0.005852 \n", + "15 -488.133568 -0.001138 \n", + "16 -2050.648510 -0.005002 \n", + "17 -1069.819428 -0.002589 \n", + "18 331.174851 0.000770 \n", + "19 294.126054 0.000733 \n", + "20 -1554.447940 -0.003656 \n", + "21 -3222.521752 -0.008021 \n", + "22 -1152.103803 -0.003079 \n", + "23 -1150.685778 -0.002939 \n", + "24 -1220.911442 -0.002826 \n", + "25 -1494.324667 -0.003700 \n", + "26 -716.778707 -0.001747 \n", + "27 -1930.201847 -0.004910 \n", + "28 -2308.232499 -0.005599 \n", + "29 330.078931 0.000833 \n", + "30 -687.197283 -0.001648 \n", + "31 3145.010815 0.008024 \n", + "32 -1409.961995 -0.003559 \n", + "33 -2360.756744 -0.005847 \n", + "34 -2012.876754 -0.005110 \n", + "35 597.828835 0.001631 \n", + "36 -2585.852040 -0.006156 \n", + "37 517.326570 0.001371 \n", + "38 -378.076555 -0.001010 \n", + "39 -543.069734 -0.001418 \n", + "40 102.712541 0.000267 \n", + "41 -161.474998 -0.000419 \n", + "42 -2167.291450 -0.005412 \n", + "43 -1229.376155 -0.003127 \n", + "44 -2606.729450 -0.006529 \n", + "45 -1917.455347 -0.004981 " + ], + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
YearMonthFacility_IDAltitudeZoneResidOwnerFacility_TypePrecipitationLag_1_PrecipitationLag_2_PrecipitationLag_3_PrecipitationLag_4_PrecipitationPredicted_Weather_ModelPredicted_No_Weather_ModelDifference_in_ExpectationPercentage_Difference
02025246426203963302918.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...440334.234308353904.731005325681.489860297561.640581282054.887587282875.789559435056.523872-1479.431742-0.003401
12026254476402883423381.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...368143.657611401420.433758403405.854504402539.554951403356.754888446973.452602448297.963620-1324.511018-0.002955
22027243466132993249211.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...389512.271746371731.795831352017.560308341274.411245330719.679227429699.165446428855.082772844.0826750.001968
32028241656098693233056.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...467236.272652463195.874132489324.647136467717.368493464588.245545426390.662966425105.1447391285.5182270.003024
42029238566007073182788.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...510281.500940502657.340862482774.102033508613.994882503630.296180419862.210285417366.0029412496.2073440.005981
52030247436214463305374.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...415561.678186430082.709305433194.385110426679.595380423888.501330429293.165886430209.704481-916.538595-0.002130
62031223115643872993610.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...306576.789734309978.599600325681.193935315680.278887290028.482608388423.461274388929.485473-506.024199-0.001301
72032250116292863346578.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...322789.637078346456.981332346504.507849343190.362299342685.296868434991.492594436710.225310-1718.732715-0.003936
82033231625842993096405.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...417617.290163357429.121158338700.251142340245.308388340546.248413400294.397759402492.398969-2198.001210-0.005461
92034245606178913283369.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...397886.401018399155.990738376194.009554375103.117941373789.068455425657.584762427231.110037-1573.525275-0.003683
102035250406295103351904.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...459406.340711495631.995766495403.900197486208.445508482900.825373433154.044585434659.478247-1505.433662-0.003463
112036238455973933180499.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...397647.735041394956.683884407506.319795414531.165308393286.530926409005.784582408150.336768855.4478140.002096
122037233325867863128727.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...391610.416555343980.571323350808.137426347057.035888341463.248905399090.628516401572.454562-2481.826046-0.006180
132038249766264283359830.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...441416.106096452575.562133454464.217285452146.877154450786.011451431402.659483429626.7314871775.9279960.004134
142039242536105453257219.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...375365.449796362433.347050371149.568476363933.535093360843.806040412578.359715415007.121480-2428.761765-0.005852
152040250576299203355680.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...410970.020588447884.643580447682.568270449803.904849448981.207566428390.924640428879.058208-488.133568-0.001138
162041239096031723217069.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...409283.988225389442.315269385668.859805378426.274901374044.680265407922.043693409972.692203-2050.648510-0.005002
172042245466144593284010.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...473493.289947451147.769581430615.696082425669.313089429496.615643412187.659372413257.478800-1069.819428-0.002589
182043251696349913380638.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...469347.741866494545.073752499347.930783493783.833404488803.549502430347.112355430015.937504331.1748510.000770
192044235655915833151148.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...367242.325518371711.781452374913.433345377110.720066377895.449896401348.874670401054.748615294.1260540.000733
202045249216270963335948.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...315560.724644343353.455376345223.997177342021.238793334436.491016423672.932007425227.379946-1554.447940-0.003656
212046237765984583181465.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...371782.115694305812.333010294432.924965293503.944334296392.880809398552.821055401775.342808-3222.521752-0.008021
222047221525566852957237.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...434630.692016457467.620834474432.706520472613.554807440392.213570373087.409200374239.513003-1152.103803-0.003079
232048233855888723114865.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...341127.222055315111.678821294945.264077285233.426898253195.609983390315.605105391466.290883-1150.685778-0.002939
242049255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...431988.493807443731.169805451146.067144447883.026972446049.207337430832.507546432053.418987-1220.911442-0.002826
252050239856031213199136.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...421327.798951396769.929491408562.425855418502.725903419774.688159402422.115951403916.440618-1494.324667-0.003700
262051244606150313269170.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...321024.804561345132.495319329562.416251323549.743210317332.704749409463.606493410180.385199-716.778707-0.001747
272052236105939483148362.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...469034.752168469662.194769448426.362540446609.577932435340.199013391160.953917393091.155764-1930.201847-0.004910
282053246126172653291913.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...479370.138921461118.374422452747.999276442215.228495400887.449181409930.626615412238.859114-2308.232499-0.005599
292054238466005313190334.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...378828.522395435684.567230434997.915598436064.621612432867.449960396400.887798396070.808867330.0789310.000833
302055249566284213345467.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...478046.700552428881.409055453508.028054449527.028001444985.809368416341.114108417028.311391-687.197283-0.001648
312056237035965603172864.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...370264.174609415190.572889426911.392935433321.292498423776.044021395081.647605391936.6367903145.0108150.008024
322057238846021033215112.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...378162.247570377205.366488342790.975990332326.448483330739.987217394811.555047396221.517042-1409.961995-0.003559
332058243526113473261366.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...414908.289481333540.646309362992.743057366721.297324367575.167706401393.780962403754.537706-2360.756744-0.005847
342059240556035793200088.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...455684.817802472393.409198478349.032980477401.048276438412.338758391860.264252393873.141006-2012.876754-0.005110
352060224015603803000088.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...359900.771691372597.770047360489.465892363261.114549359252.347918367209.410297366611.581462597.8288350.001631
362061254506398703417374.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...522352.080349579014.399822568925.720500565835.475117550598.603341417434.381690420020.233730-2585.852040-0.006156
372062231555825473074410.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...376936.757775379134.096954381629.099749364270.180436356574.164485377882.767541377365.440971517.3265700.001371
382063230575800433084421.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...467723.711737401612.564532392392.393319396304.528597394369.022680374082.177605374460.254161-378.076555-0.001010
392064235035922413138838.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...323517.333199367831.340554346112.375544324946.993397312443.249634382423.385030382966.454764-543.069734-0.001418
402065236805943363169648.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...345713.935117293320.941908318220.999319326566.490286323628.322020384159.066998384056.354457102.7125410.000267
412066237435983393198839.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...395462.015387445201.806887440143.467266438945.020171435197.782687385665.968172385827.443170-161.474998-0.000419
422067245696194363283765.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...406529.105098356852.651551349188.139601335367.151073336038.756644398291.557836400458.849287-2167.291450-0.005412
432068241226082163240015.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...574552.855124543870.172353546057.722361548303.362147547679.218868391932.655476393162.031631-1229.376155-0.003127
442069245466186083287355.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...446939.143675511156.014302533278.121296529131.538903529176.140345396645.182138399251.911588-2606.729450-0.006529
452070238055988003180887.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...478443.587177441135.161700433665.355653444075.669003439392.286115383002.326955384919.782302-1917.455347-0.004981
\n", + "
" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 24 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-03T10:30:42.894912Z", + "start_time": "2025-01-03T10:30:40.961325Z" + } + }, + "cell_type": "code", + "source": [ + "X_Data = pd.read_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/X_basis_weather_filtered_predictions_{scenario}.csv')\n", + "X_Data" + ], + "id": "23e931c4a52c75e0", + "outputs": [ + { + "data": { + "text/plain": [ + " 0 1 2 3 4 5 6 7 8 9 \\\n", + "0 214.572104 67.082516 2025.0 1.0 1.0 1.0 0.0 0.0 0.0 1.0 \n", + "1 271.627509 91.681733 2025.0 2.0 1.0 0.0 0.0 1.0 0.0 1.0 \n", + "2 274.068079 81.536862 2025.0 3.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", + "3 282.787174 72.338774 2025.0 4.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", + "4 307.947498 93.346663 2025.0 5.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", + "... ... ... ... ... ... ... ... ... ... ... \n", + "170566 352.682126 110.401419 2070.0 8.0 0.0 0.0 1.0 0.0 0.0 1.0 \n", + "170567 278.709500 86.588583 2070.0 9.0 0.0 0.0 0.0 1.0 0.0 0.0 \n", + "170568 278.709500 86.588583 2070.0 10.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", + "170569 261.926852 80.761265 2070.0 11.0 0.0 0.0 1.0 0.0 0.0 1.0 \n", + "170570 253.265239 115.377080 2070.0 12.0 0.0 0.0 0.0 0.0 0.0 1.0 \n", + "\n", + " ... 344 345 346 347 348 349 350 351 352 353 \n", + "0 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 1099.0 0.084097 \n", + "1 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 632.0 0.089463 \n", + "2 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 873.0 NaN \n", + "3 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 873.0 NaN \n", + "4 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 873.0 NaN \n", + "... ... ... ... ... ... ... ... ... ... ... ... \n", + "170566 ... 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0 485.0 0.162431 \n", + "170567 ... 0.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 508.0 0.116303 \n", + "170568 ... 0.0 0.0 0.0 0.0 0.0 1.0 0.0 0.0 873.0 NaN \n", + "170569 ... 0.0 0.0 0.0 0.0 0.0 0.0 1.0 0.0 1149.0 0.233156 \n", + "170570 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 1.0 873.0 0.098121 \n", + "\n", + "[170571 rows x 354 columns]" + ], + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
0123456789...344345346347348349350351352353
0214.57210467.0825162025.01.01.01.00.00.00.01.0...0.00.00.00.00.00.00.00.01099.00.084097
1271.62750991.6817332025.02.01.00.00.01.00.01.0...0.00.00.00.00.00.00.00.0632.00.089463
2274.06807981.5368622025.03.00.00.00.00.00.00.0...0.00.00.00.00.00.00.00.0873.0NaN
3282.78717472.3387742025.04.00.00.00.00.00.00.0...0.00.00.00.00.00.00.00.0873.0NaN
4307.94749893.3466632025.05.00.00.00.00.00.00.0...0.00.00.00.00.00.00.00.0873.0NaN
..................................................................
170566352.682126110.4014192070.08.00.00.01.00.00.01.0...0.00.00.01.00.00.00.00.0485.00.162431
170567278.70950086.5885832070.09.00.00.00.01.00.00.0...0.00.00.00.01.00.00.00.0508.00.116303
170568278.70950086.5885832070.010.00.00.00.00.00.00.0...0.00.00.00.00.01.00.00.0873.0NaN
170569261.92685280.7612652070.011.00.00.01.00.00.01.0...0.00.00.00.00.00.01.00.01149.00.233156
170570253.265239115.3770802070.012.00.00.00.00.00.01.0...0.00.00.00.00.00.00.01.0873.00.098121
\n", + "

170571 rows × 354 columns

\n", + "
" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 25 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-03T10:30:42.899853Z", + "start_time": "2025-01-03T10:30:42.896457Z" + } + }, + "cell_type": "code", + "source": [ + "births_model_subset = births_model.iloc[15:].copy()\n", + "\n", + "matching_rows = min(len(births_model_subset), len(predictions_from_cmip_sum))\n", + "\n", + "multiplied_values = births_model_subset.head(matching_rows).iloc[:, 1].values * predictions_from_cmip_sum['Percentage_Difference'].head(matching_rows).values\n", + "\n", + "births_model_subset['Multiplied_Values'] = multiplied_values" + ], + "id": "fd6b107fed0933cb", + "outputs": [], + "execution_count": 26 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-03T10:30:45.693252Z", + "start_time": "2025-01-03T10:30:45.672287Z" + } + }, + "cell_type": "code", + "source": "predictions_from_cmip_sum", + "id": "4fa2a35688fd5c48", + "outputs": [ + { + "data": { + "text/plain": [ + " Year Month Facility_ID Altitude \\\n", + "0 2025 24642 620396 3302918.0 \n", + "1 2026 25447 640288 3423381.0 \n", + "2 2027 24346 613299 3249211.0 \n", + "3 2028 24165 609869 3233056.0 \n", + "4 2029 23856 600707 3182788.0 \n", + "5 2030 24743 621446 3305374.0 \n", + "6 2031 22311 564387 2993610.0 \n", + "7 2032 25011 629286 3346578.0 \n", + "8 2033 23162 584299 3096405.0 \n", + "9 2034 24560 617891 3283369.0 \n", + "10 2035 25040 629510 3351904.0 \n", + "11 2036 23845 597393 3180499.0 \n", + "12 2037 23332 586786 3128727.0 \n", + "13 2038 24976 626428 3359830.0 \n", + "14 2039 24253 610545 3257219.0 \n", + "15 2040 25057 629920 3355680.0 \n", + "16 2041 23909 603172 3217069.0 \n", + "17 2042 24546 614459 3284010.0 \n", + "18 2043 25169 634991 3380638.0 \n", + "19 2044 23565 591583 3151148.0 \n", + "20 2045 24921 627096 3335948.0 \n", + "21 2046 23776 598458 3181465.0 \n", + "22 2047 22152 556685 2957237.0 \n", + "23 2048 23385 588872 3114865.0 \n", + "24 2049 25584 643536 3435564.0 \n", + "25 2050 23985 603121 3199136.0 \n", + "26 2051 24460 615031 3269170.0 \n", + "27 2052 23610 593948 3148362.0 \n", + "28 2053 24612 617265 3291913.0 \n", + "29 2054 23846 600531 3190334.0 \n", + "30 2055 24956 628421 3345467.0 \n", + "31 2056 23703 596560 3172864.0 \n", + "32 2057 23884 602103 3215112.0 \n", + "33 2058 24352 611347 3261366.0 \n", + "34 2059 24055 603579 3200088.0 \n", + "35 2060 22401 560380 3000088.0 \n", + "36 2061 25450 639870 3417374.0 \n", + "37 2062 23155 582547 3074410.0 \n", + "38 2063 23057 580043 3084421.0 \n", + "39 2064 23503 592241 3138838.0 \n", + "40 2065 23680 594336 3169648.0 \n", + "41 2066 23743 598339 3198839.0 \n", + "42 2067 24569 619436 3283765.0 \n", + "43 2068 24122 608216 3240015.0 \n", + "44 2069 24546 618608 3287355.0 \n", + "45 2070 23805 598800 3180887.0 \n", + "\n", + " Zone \\\n", + "0 Central WestSouth EastNorthernSouth EastNorthe... \n", + "1 Central WestSouth EastNorthernSouth EastNorthe... \n", + "2 Central WestSouth EastNorthernSouth EastNorthe... \n", + "3 Central WestSouth EastNorthernSouth EastNorthe... \n", + "4 Central WestSouth EastNorthernSouth EastNorthe... \n", + "5 Central WestSouth EastNorthernSouth EastNorthe... \n", + "6 Central WestSouth EastNorthernSouth EastNorthe... \n", + "7 Central WestSouth EastNorthernSouth EastNorthe... \n", + "8 Central WestSouth EastNorthernSouth EastNorthe... \n", + "9 Central WestSouth EastNorthernSouth EastNorthe... \n", + "10 Central WestSouth EastNorthernSouth EastNorthe... \n", + "11 Central WestSouth EastNorthernSouth EastNorthe... \n", + "12 Central WestSouth EastNorthernSouth EastNorthe... \n", + "13 Central WestSouth EastNorthernSouth EastNorthe... \n", + "14 Central WestSouth EastNorthernSouth EastNorthe... \n", + "15 Central WestSouth EastNorthernSouth EastNorthe... \n", + "16 Central WestSouth EastNorthernSouth EastNorthe... \n", + "17 Central WestSouth EastNorthernSouth EastNorthe... \n", + "18 Central WestSouth EastNorthernSouth EastNorthe... \n", + "19 Central WestSouth EastNorthernSouth EastNorthe... \n", + "20 Central WestSouth EastNorthernSouth EastNorthe... \n", + "21 Central WestSouth EastNorthernSouth EastNorthe... \n", + "22 Central WestSouth EastNorthernSouth EastNorthe... \n", + "23 Central WestSouth EastNorthernSouth EastNorthe... \n", + "24 Central WestSouth EastNorthernSouth EastNorthe... \n", + "25 Central WestSouth EastNorthernSouth EastNorthe... \n", + "26 Central WestSouth EastNorthernSouth EastNorthe... \n", + "27 Central WestSouth EastNorthernSouth EastNorthe... \n", + "28 Central WestSouth EastNorthernSouth EastNorthe... \n", + "29 Central WestSouth EastNorthernSouth EastNorthe... \n", + "30 Central WestSouth EastNorthernSouth EastNorthe... \n", + "31 Central WestSouth EastNorthernSouth EastNorthe... \n", + "32 Central WestSouth EastNorthernSouth EastNorthe... \n", + "33 Central WestSouth EastNorthernSouth EastNorthe... \n", + "34 Central WestSouth EastNorthernSouth EastNorthe... \n", + "35 Central WestSouth EastNorthernSouth EastNorthe... \n", + "36 Central WestSouth EastNorthernSouth EastNorthe... \n", + "37 Central WestSouth EastNorthernSouth EastNorthe... \n", + "38 Central WestSouth EastNorthernSouth EastNorthe... \n", + "39 Central WestSouth EastNorthernSouth EastNorthe... \n", + "40 Central WestSouth EastNorthernSouth EastNorthe... \n", + "41 Central WestSouth EastNorthernSouth EastNorthe... \n", + "42 Central WestSouth EastNorthernSouth EastNorthe... \n", + "43 Central WestSouth EastNorthernSouth EastNorthe... \n", + "44 Central WestSouth EastNorthernSouth EastNorthe... \n", + "45 Central WestSouth EastNorthernSouth EastNorthe... \n", + "\n", + " Resid \\\n", + "0 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "1 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "2 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "3 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "4 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "5 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "6 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "7 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "8 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "9 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "10 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "11 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "12 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "13 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "14 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "15 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "16 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "17 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "18 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "19 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "20 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "21 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "22 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "23 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "24 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "25 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "26 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "27 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "28 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "29 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "30 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "31 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "32 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "33 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "34 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "35 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "36 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "37 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "38 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "39 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "40 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "41 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "42 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "43 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "44 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "45 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", + "\n", + " Owner \\\n", + "0 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "1 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "2 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "3 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "4 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "5 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "6 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "7 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "8 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "9 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "10 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "11 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "12 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "13 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "14 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "15 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "16 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "17 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "18 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "19 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "20 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "21 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "22 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "23 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "24 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "25 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "26 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "27 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "28 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "29 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "30 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "31 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "32 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "33 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "34 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "35 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "36 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "37 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "38 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "39 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "40 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "41 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "42 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "43 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "44 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "45 GovernmentGovernmentGovernmentGovernmentGovern... \n", + "\n", + " Facility_Type Precipitation \\\n", + "0 ClinicDistrict HospitalRural/Community Hospita... 440334.234308 \n", + "1 ClinicDistrict HospitalRural/Community Hospita... 368143.657611 \n", + "2 ClinicDistrict HospitalRural/Community Hospita... 389512.271746 \n", + "3 ClinicDistrict HospitalRural/Community Hospita... 467236.272652 \n", + "4 ClinicDistrict HospitalRural/Community Hospita... 510281.500940 \n", + "5 ClinicDistrict HospitalRural/Community Hospita... 415561.678186 \n", + "6 ClinicDistrict HospitalRural/Community Hospita... 306576.789734 \n", + "7 ClinicDistrict HospitalRural/Community Hospita... 322789.637078 \n", + "8 ClinicDistrict HospitalRural/Community Hospita... 417617.290163 \n", + "9 ClinicDistrict HospitalRural/Community Hospita... 397886.401018 \n", + "10 ClinicDistrict HospitalRural/Community Hospita... 459406.340711 \n", + "11 ClinicDistrict HospitalRural/Community Hospita... 397647.735041 \n", + "12 ClinicDistrict HospitalRural/Community Hospita... 391610.416555 \n", + "13 ClinicDistrict HospitalRural/Community Hospita... 441416.106096 \n", + "14 ClinicDistrict HospitalRural/Community Hospita... 375365.449796 \n", + "15 ClinicDistrict HospitalRural/Community Hospita... 410970.020588 \n", + "16 ClinicDistrict HospitalRural/Community Hospita... 409283.988225 \n", + "17 ClinicDistrict HospitalRural/Community Hospita... 473493.289947 \n", + "18 ClinicDistrict HospitalRural/Community Hospita... 469347.741866 \n", + "19 ClinicDistrict HospitalRural/Community Hospita... 367242.325518 \n", + "20 ClinicDistrict HospitalRural/Community Hospita... 315560.724644 \n", + "21 ClinicDistrict HospitalRural/Community Hospita... 371782.115694 \n", + "22 ClinicDistrict HospitalRural/Community Hospita... 434630.692016 \n", + "23 ClinicDistrict HospitalRural/Community Hospita... 341127.222055 \n", + "24 ClinicDistrict HospitalRural/Community Hospita... 431988.493807 \n", + "25 ClinicDistrict HospitalRural/Community Hospita... 421327.798951 \n", + "26 ClinicDistrict HospitalRural/Community Hospita... 321024.804561 \n", + "27 ClinicDistrict HospitalRural/Community Hospita... 469034.752168 \n", + "28 ClinicDistrict HospitalRural/Community Hospita... 479370.138921 \n", + "29 ClinicDistrict HospitalRural/Community Hospita... 378828.522395 \n", + "30 ClinicDistrict HospitalRural/Community Hospita... 478046.700552 \n", + "31 ClinicDistrict HospitalRural/Community Hospita... 370264.174609 \n", + "32 ClinicDistrict HospitalRural/Community Hospita... 378162.247570 \n", + "33 ClinicDistrict HospitalRural/Community Hospita... 414908.289481 \n", + "34 ClinicDistrict HospitalRural/Community Hospita... 455684.817802 \n", + "35 ClinicDistrict HospitalRural/Community Hospita... 359900.771691 \n", + "36 ClinicDistrict HospitalRural/Community Hospita... 522352.080349 \n", + "37 ClinicDistrict HospitalRural/Community Hospita... 376936.757775 \n", + "38 ClinicDistrict HospitalRural/Community Hospita... 467723.711737 \n", + "39 ClinicDistrict HospitalRural/Community Hospita... 323517.333199 \n", + "40 ClinicDistrict HospitalRural/Community Hospita... 345713.935117 \n", + "41 ClinicDistrict HospitalRural/Community Hospita... 395462.015387 \n", + "42 ClinicDistrict HospitalRural/Community Hospita... 406529.105098 \n", + "43 ClinicDistrict HospitalRural/Community Hospita... 574552.855124 \n", + "44 ClinicDistrict HospitalRural/Community Hospita... 446939.143675 \n", + "45 ClinicDistrict HospitalRural/Community Hospita... 478443.587177 \n", + "\n", + " Lag_1_Precipitation Lag_2_Precipitation Lag_3_Precipitation \\\n", + "0 353904.731005 325681.489860 297561.640581 \n", + "1 401420.433758 403405.854504 402539.554951 \n", + "2 371731.795831 352017.560308 341274.411245 \n", + "3 463195.874132 489324.647136 467717.368493 \n", + "4 502657.340862 482774.102033 508613.994882 \n", + "5 430082.709305 433194.385110 426679.595380 \n", + "6 309978.599600 325681.193935 315680.278887 \n", + "7 346456.981332 346504.507849 343190.362299 \n", + "8 357429.121158 338700.251142 340245.308388 \n", + "9 399155.990738 376194.009554 375103.117941 \n", + "10 495631.995766 495403.900197 486208.445508 \n", + "11 394956.683884 407506.319795 414531.165308 \n", + "12 343980.571323 350808.137426 347057.035888 \n", + "13 452575.562133 454464.217285 452146.877154 \n", + "14 362433.347050 371149.568476 363933.535093 \n", + "15 447884.643580 447682.568270 449803.904849 \n", + "16 389442.315269 385668.859805 378426.274901 \n", + "17 451147.769581 430615.696082 425669.313089 \n", + "18 494545.073752 499347.930783 493783.833404 \n", + "19 371711.781452 374913.433345 377110.720066 \n", + "20 343353.455376 345223.997177 342021.238793 \n", + "21 305812.333010 294432.924965 293503.944334 \n", + "22 457467.620834 474432.706520 472613.554807 \n", + "23 315111.678821 294945.264077 285233.426898 \n", + "24 443731.169805 451146.067144 447883.026972 \n", + "25 396769.929491 408562.425855 418502.725903 \n", + "26 345132.495319 329562.416251 323549.743210 \n", + "27 469662.194769 448426.362540 446609.577932 \n", + "28 461118.374422 452747.999276 442215.228495 \n", + "29 435684.567230 434997.915598 436064.621612 \n", + "30 428881.409055 453508.028054 449527.028001 \n", + "31 415190.572889 426911.392935 433321.292498 \n", + "32 377205.366488 342790.975990 332326.448483 \n", + "33 333540.646309 362992.743057 366721.297324 \n", + "34 472393.409198 478349.032980 477401.048276 \n", + "35 372597.770047 360489.465892 363261.114549 \n", + "36 579014.399822 568925.720500 565835.475117 \n", + "37 379134.096954 381629.099749 364270.180436 \n", + "38 401612.564532 392392.393319 396304.528597 \n", + "39 367831.340554 346112.375544 324946.993397 \n", + "40 293320.941908 318220.999319 326566.490286 \n", + "41 445201.806887 440143.467266 438945.020171 \n", + "42 356852.651551 349188.139601 335367.151073 \n", + "43 543870.172353 546057.722361 548303.362147 \n", + "44 511156.014302 533278.121296 529131.538903 \n", + "45 441135.161700 433665.355653 444075.669003 \n", + "\n", + " Lag_4_Precipitation Predicted_Weather_Model Predicted_No_Weather_Model \\\n", + "0 282054.887587 282875.789559 435056.523872 \n", + "1 403356.754888 446973.452602 448297.963620 \n", + "2 330719.679227 429699.165446 428855.082772 \n", + "3 464588.245545 426390.662966 425105.144739 \n", + "4 503630.296180 419862.210285 417366.002941 \n", + "5 423888.501330 429293.165886 430209.704481 \n", + "6 290028.482608 388423.461274 388929.485473 \n", + "7 342685.296868 434991.492594 436710.225310 \n", + "8 340546.248413 400294.397759 402492.398969 \n", + "9 373789.068455 425657.584762 427231.110037 \n", + "10 482900.825373 433154.044585 434659.478247 \n", + "11 393286.530926 409005.784582 408150.336768 \n", + "12 341463.248905 399090.628516 401572.454562 \n", + "13 450786.011451 431402.659483 429626.731487 \n", + "14 360843.806040 412578.359715 415007.121480 \n", + "15 448981.207566 428390.924640 428879.058208 \n", + "16 374044.680265 407922.043693 409972.692203 \n", + "17 429496.615643 412187.659372 413257.478800 \n", + "18 488803.549502 430347.112355 430015.937504 \n", + "19 377895.449896 401348.874670 401054.748615 \n", + "20 334436.491016 423672.932007 425227.379946 \n", + "21 296392.880809 398552.821055 401775.342808 \n", + "22 440392.213570 373087.409200 374239.513003 \n", + "23 253195.609983 390315.605105 391466.290883 \n", + "24 446049.207337 430832.507546 432053.418987 \n", + "25 419774.688159 402422.115951 403916.440618 \n", + "26 317332.704749 409463.606493 410180.385199 \n", + "27 435340.199013 391160.953917 393091.155764 \n", + "28 400887.449181 409930.626615 412238.859114 \n", + "29 432867.449960 396400.887798 396070.808867 \n", + "30 444985.809368 416341.114108 417028.311391 \n", + "31 423776.044021 395081.647605 391936.636790 \n", + "32 330739.987217 394811.555047 396221.517042 \n", + "33 367575.167706 401393.780962 403754.537706 \n", + "34 438412.338758 391860.264252 393873.141006 \n", + "35 359252.347918 367209.410297 366611.581462 \n", + "36 550598.603341 417434.381690 420020.233730 \n", + "37 356574.164485 377882.767541 377365.440971 \n", + "38 394369.022680 374082.177605 374460.254161 \n", + "39 312443.249634 382423.385030 382966.454764 \n", + "40 323628.322020 384159.066998 384056.354457 \n", + "41 435197.782687 385665.968172 385827.443170 \n", + "42 336038.756644 398291.557836 400458.849287 \n", + "43 547679.218868 391932.655476 393162.031631 \n", + "44 529176.140345 396645.182138 399251.911588 \n", + "45 439392.286115 383002.326955 384919.782302 \n", + "\n", + " Difference_in_Expectation Percentage_Difference \n", + "0 -1479.431742 -0.003401 \n", + "1 -1324.511018 -0.002955 \n", + "2 844.082675 0.001968 \n", + "3 1285.518227 0.003024 \n", + "4 2496.207344 0.005981 \n", + "5 -916.538595 -0.002130 \n", + "6 -506.024199 -0.001301 \n", + "7 -1718.732715 -0.003936 \n", + "8 -2198.001210 -0.005461 \n", + "9 -1573.525275 -0.003683 \n", + "10 -1505.433662 -0.003463 \n", + "11 855.447814 0.002096 \n", + "12 -2481.826046 -0.006180 \n", + "13 1775.927996 0.004134 \n", + "14 -2428.761765 -0.005852 \n", + "15 -488.133568 -0.001138 \n", + "16 -2050.648510 -0.005002 \n", + "17 -1069.819428 -0.002589 \n", + "18 331.174851 0.000770 \n", + "19 294.126054 0.000733 \n", + "20 -1554.447940 -0.003656 \n", + "21 -3222.521752 -0.008021 \n", + "22 -1152.103803 -0.003079 \n", + "23 -1150.685778 -0.002939 \n", + "24 -1220.911442 -0.002826 \n", + "25 -1494.324667 -0.003700 \n", + "26 -716.778707 -0.001747 \n", + "27 -1930.201847 -0.004910 \n", + "28 -2308.232499 -0.005599 \n", + "29 330.078931 0.000833 \n", + "30 -687.197283 -0.001648 \n", + "31 3145.010815 0.008024 \n", + "32 -1409.961995 -0.003559 \n", + "33 -2360.756744 -0.005847 \n", + "34 -2012.876754 -0.005110 \n", + "35 597.828835 0.001631 \n", + "36 -2585.852040 -0.006156 \n", + "37 517.326570 0.001371 \n", + "38 -378.076555 -0.001010 \n", + "39 -543.069734 -0.001418 \n", + "40 102.712541 0.000267 \n", + "41 -161.474998 -0.000419 \n", + "42 -2167.291450 -0.005412 \n", + "43 -1229.376155 -0.003127 \n", + "44 -2606.729450 -0.006529 \n", + "45 -1917.455347 -0.004981 " + ], + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
YearMonthFacility_IDAltitudeZoneResidOwnerFacility_TypePrecipitationLag_1_PrecipitationLag_2_PrecipitationLag_3_PrecipitationLag_4_PrecipitationPredicted_Weather_ModelPredicted_No_Weather_ModelDifference_in_ExpectationPercentage_Difference
02025246426203963302918.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...440334.234308353904.731005325681.489860297561.640581282054.887587282875.789559435056.523872-1479.431742-0.003401
12026254476402883423381.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...368143.657611401420.433758403405.854504402539.554951403356.754888446973.452602448297.963620-1324.511018-0.002955
22027243466132993249211.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...389512.271746371731.795831352017.560308341274.411245330719.679227429699.165446428855.082772844.0826750.001968
32028241656098693233056.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...467236.272652463195.874132489324.647136467717.368493464588.245545426390.662966425105.1447391285.5182270.003024
42029238566007073182788.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...510281.500940502657.340862482774.102033508613.994882503630.296180419862.210285417366.0029412496.2073440.005981
52030247436214463305374.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...415561.678186430082.709305433194.385110426679.595380423888.501330429293.165886430209.704481-916.538595-0.002130
62031223115643872993610.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...306576.789734309978.599600325681.193935315680.278887290028.482608388423.461274388929.485473-506.024199-0.001301
72032250116292863346578.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...322789.637078346456.981332346504.507849343190.362299342685.296868434991.492594436710.225310-1718.732715-0.003936
82033231625842993096405.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...417617.290163357429.121158338700.251142340245.308388340546.248413400294.397759402492.398969-2198.001210-0.005461
92034245606178913283369.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...397886.401018399155.990738376194.009554375103.117941373789.068455425657.584762427231.110037-1573.525275-0.003683
102035250406295103351904.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...459406.340711495631.995766495403.900197486208.445508482900.825373433154.044585434659.478247-1505.433662-0.003463
112036238455973933180499.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...397647.735041394956.683884407506.319795414531.165308393286.530926409005.784582408150.336768855.4478140.002096
122037233325867863128727.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...391610.416555343980.571323350808.137426347057.035888341463.248905399090.628516401572.454562-2481.826046-0.006180
132038249766264283359830.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...441416.106096452575.562133454464.217285452146.877154450786.011451431402.659483429626.7314871775.9279960.004134
142039242536105453257219.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...375365.449796362433.347050371149.568476363933.535093360843.806040412578.359715415007.121480-2428.761765-0.005852
152040250576299203355680.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...410970.020588447884.643580447682.568270449803.904849448981.207566428390.924640428879.058208-488.133568-0.001138
162041239096031723217069.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...409283.988225389442.315269385668.859805378426.274901374044.680265407922.043693409972.692203-2050.648510-0.005002
172042245466144593284010.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...473493.289947451147.769581430615.696082425669.313089429496.615643412187.659372413257.478800-1069.819428-0.002589
182043251696349913380638.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...469347.741866494545.073752499347.930783493783.833404488803.549502430347.112355430015.937504331.1748510.000770
192044235655915833151148.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...367242.325518371711.781452374913.433345377110.720066377895.449896401348.874670401054.748615294.1260540.000733
202045249216270963335948.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...315560.724644343353.455376345223.997177342021.238793334436.491016423672.932007425227.379946-1554.447940-0.003656
212046237765984583181465.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...371782.115694305812.333010294432.924965293503.944334296392.880809398552.821055401775.342808-3222.521752-0.008021
222047221525566852957237.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...434630.692016457467.620834474432.706520472613.554807440392.213570373087.409200374239.513003-1152.103803-0.003079
232048233855888723114865.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...341127.222055315111.678821294945.264077285233.426898253195.609983390315.605105391466.290883-1150.685778-0.002939
242049255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...431988.493807443731.169805451146.067144447883.026972446049.207337430832.507546432053.418987-1220.911442-0.002826
252050239856031213199136.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...421327.798951396769.929491408562.425855418502.725903419774.688159402422.115951403916.440618-1494.324667-0.003700
262051244606150313269170.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...321024.804561345132.495319329562.416251323549.743210317332.704749409463.606493410180.385199-716.778707-0.001747
272052236105939483148362.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...469034.752168469662.194769448426.362540446609.577932435340.199013391160.953917393091.155764-1930.201847-0.004910
282053246126172653291913.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...479370.138921461118.374422452747.999276442215.228495400887.449181409930.626615412238.859114-2308.232499-0.005599
292054238466005313190334.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...378828.522395435684.567230434997.915598436064.621612432867.449960396400.887798396070.808867330.0789310.000833
302055249566284213345467.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...478046.700552428881.409055453508.028054449527.028001444985.809368416341.114108417028.311391-687.197283-0.001648
312056237035965603172864.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...370264.174609415190.572889426911.392935433321.292498423776.044021395081.647605391936.6367903145.0108150.008024
322057238846021033215112.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...378162.247570377205.366488342790.975990332326.448483330739.987217394811.555047396221.517042-1409.961995-0.003559
332058243526113473261366.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...414908.289481333540.646309362992.743057366721.297324367575.167706401393.780962403754.537706-2360.756744-0.005847
342059240556035793200088.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...455684.817802472393.409198478349.032980477401.048276438412.338758391860.264252393873.141006-2012.876754-0.005110
352060224015603803000088.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...359900.771691372597.770047360489.465892363261.114549359252.347918367209.410297366611.581462597.8288350.001631
362061254506398703417374.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...522352.080349579014.399822568925.720500565835.475117550598.603341417434.381690420020.233730-2585.852040-0.006156
372062231555825473074410.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...376936.757775379134.096954381629.099749364270.180436356574.164485377882.767541377365.440971517.3265700.001371
382063230575800433084421.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...467723.711737401612.564532392392.393319396304.528597394369.022680374082.177605374460.254161-378.076555-0.001010
392064235035922413138838.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...323517.333199367831.340554346112.375544324946.993397312443.249634382423.385030382966.454764-543.069734-0.001418
402065236805943363169648.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...345713.935117293320.941908318220.999319326566.490286323628.322020384159.066998384056.354457102.7125410.000267
412066237435983393198839.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...395462.015387445201.806887440143.467266438945.020171435197.782687385665.968172385827.443170-161.474998-0.000419
422067245696194363283765.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...406529.105098356852.651551349188.139601335367.151073336038.756644398291.557836400458.849287-2167.291450-0.005412
432068241226082163240015.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...574552.855124543870.172353546057.722361548303.362147547679.218868391932.655476393162.031631-1229.376155-0.003127
442069245466186083287355.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...446939.143675511156.014302533278.121296529131.538903529176.140345396645.182138399251.911588-2606.729450-0.006529
452070238055988003180887.0Central WestSouth EastNorthernSouth EastNorthe...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...478443.587177441135.161700433665.355653444075.669003439392.286115383002.326955384919.782302-1917.455347-0.004981
\n", + "
" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 27 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-03T10:30:46.773318Z", + "start_time": "2025-01-03T10:30:46.694886Z" + } + }, + "cell_type": "code", + "source": [ + "year_range = range(2025, 2061)\n", + "\n", + "plt.plot(year_range, multiplied_values)\n", + "plt.xlabel(\"Change ANC cases due to weather\")\n", + "plt.axhline(y=0, color='black', linestyle='--') " + ], + "id": "c0ed116b28287eaa", + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 28 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-03T10:30:47.618102Z", + "start_time": "2025-01-03T10:30:47.547801Z" + } + }, + "cell_type": "code", + "source": [ + "plt.plot(year_range, predictions_from_cmip_sum.iloc[0:36, -1]*100)\n", + "plt.xlabel(\"Percentage Change in ANC cases due to weather\")\n", + "plt.axhline(y=0, color='black', linestyle='--') " + ], + "id": "55dba29ded951def", + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 29 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "# Negative values - missed cases?", + "id": "247b1e99fa019564" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-03T10:30:48.984030Z", + "start_time": "2025-01-03T10:30:48.982048Z" + } + }, + "cell_type": "code", + "source": [ + "negative_sum = np.sum(multiplied_values[multiplied_values < 0])\n", + "\n", + "print(\"Sum of values < 0:\", negative_sum)" + ], + "id": "67d8c94409dcd37", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sum of values < 0: -82646.73650538316\n" + ] + } + ], + "execution_count": 30 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Difference by Zone", + "id": "197776c5bef6b35c" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-03T10:38:42.682938Z", + "start_time": "2025-01-03T10:38:42.475970Z" + } + }, + "cell_type": "code", + "source": [ + "predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'Zone']).sum().reset_index()\n", + "\n", + "# Plot each zone\n", + "plt.figure(figsize=(10, 6))\n", + "for zone in predictions_from_cmip_sum['Zone'].unique():\n", + " zone_data = predictions_from_cmip_sum[predictions_from_cmip_sum['Zone'] == zone]\n", + " zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data['Predicted_No_Weather_Model']) * 100\n", + " plt.plot(zone_data['Year'], zone_data['Percentage_Difference'], label=f'Zone {zone}')\n", + "\n", + "plt.xlabel(\"Year\")\n", + "plt.ylabel(\"Change ANC cases due to weather\")\n", + "plt.axhline(y=0, color='black', linestyle='--')\n", + "\n", + "plt.legend(title='Zones')\n", + "plt.show()" + ], + "id": "8f79bf2846942b7f", + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_89216/2748134374.py:8: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data['Predicted_No_Weather_Model']) * 100\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_89216/2748134374.py:8: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data['Predicted_No_Weather_Model']) * 100\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_89216/2748134374.py:8: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data['Predicted_No_Weather_Model']) * 100\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_89216/2748134374.py:8: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data['Predicted_No_Weather_Model']) * 100\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_89216/2748134374.py:8: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data['Predicted_No_Weather_Model']) * 100\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 34 + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": "", + "id": "a6f75ad676cb7db5" + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/scripts/climate_change/compare_historical_era5_cmip6.ipynb b/src/scripts/climate_change/compare_historical_era5_cmip6.ipynb new file mode 100644 index 0000000000..69eff83b89 --- /dev/null +++ b/src/scripts/climate_change/compare_historical_era5_cmip6.ipynb @@ -0,0 +1,392 @@ +{ + "cells": [ + { + "metadata": {}, + "cell_type": "markdown", + "source": "# Compare CMIP6 and ERA5 between 2015 and 2024", + "id": "3f1f11ff82b246df" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-11-28T10:40:41.275334Z", + "start_time": "2024-11-28T10:40:41.270301Z" + } + }, + "cell_type": "code", + "source": [ + "import time\n", + "\n", + "import geopandas as gpd\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "from netCDF4 import Dataset\n", + "from shapely.geometry import Polygon\n", + "import difflib\n", + "import glob\n", + "import os\n", + "from pathlib import Path\n", + "import xarray as xr\n", + "import re\n", + "\n", + "from netCDF4 import Dataset" + ], + "id": "1fc465aa1172b4fa", + "outputs": [], + "execution_count": 116 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Read in ERA5 data", + "id": "aa73991ac1fd43ac" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-11-28T10:49:33.582014Z", + "start_time": "2024-11-28T10:49:33.575297Z" + } + }, + "cell_type": "code", + "source": [ + "era5_data_xr = xr.open_dataset('/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/monthly_data/724bab97773bb7ba4e1635356ad0d12.nc')\n", + "\n", + "era5_data_xr_2015_2024 = era5_data_xr.sel(date = slice('20140101', '20250101'))\n" + ], + "id": "d9dc56e45d9d0f9", + "outputs": [], + "execution_count": 132 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-11-28T10:49:34.549488Z", + "start_time": "2024-11-28T10:49:34.116203Z" + } + }, + "cell_type": "code", + "source": [ + "days_in_month = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]\n", + "month = 0\n", + "for i in range(len(era5_data_xr_2015_2024['latitude'][:])):\n", + " for j in range(len(era5_data_xr_2015_2024['longitude'][:])):\n", + " pr_data_time_series_grid = era5_data_xr_2015_2024['tp'][:, i, j]\n", + " pr_data_time_series_grid *= 1000 * days_in_month[month] # to get to mm\n", + " plt.plot(pr_data_time_series_grid)\n", + " month = (month + 1) % 12" + ], + "id": "2c3e6a8728afdb4a", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 133 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-11-28T10:49:38.725333Z", + "start_time": "2024-11-28T10:49:38.639069Z" + } + }, + "cell_type": "code", + "source": [ + "pr_data_time_series_avg_ERA5 = era5_data_xr_2015_2024['tp'].mean(dim=['latitude', 'longitude'])\n", + "\n", + "# Plot the averaged precipitation time series with distinct styles\n", + "plt.plot(pr_data_time_series_avg_ERA5 * 1000 * 30, color=\"blue\", linewidth=2, linestyle='--', marker='s', markersize=4, label='ERA5')\n", + "\n", + "plt.xlabel('Months since 01/2011')\n", + "plt.ylabel('Average Precipitation in 0.25 grid square (mm)')\n", + "plt.title('Average Precipitation Time Series')\n", + "plt.legend()\n", + "plt.show()" + ], + "id": "8383370a10bf70b5", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 134 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Now load the CMIP6 data - ssp 2.45", + "id": "8b8a3b9e737f9802" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Per month", + "id": "ed14b01708a10c81" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-11-28T11:44:26.379018Z", + "start_time": "2024-11-28T11:44:08.812505Z" + } + }, + "cell_type": "code", + "source": [ + "base_dir = \"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/ssp2_4_5\"\n", + "nc_file_directory = os.path.join(base_dir, 'nc_files')\n", + "# NB these are daily \n", + "scenario = 'ssp2_4_5'\n", + "multiplier = 86400\n", + "years = range(2015, 2025)\n", + "month_lengths = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] * len(years)\n", + "\n", + "cumulative_sum_by_models = {}\n", + "for file in glob.glob(os.path.join(nc_file_directory, \"*.nc\")):\n", + " model = re.search(r'pr_day_(.*?)_' + scenario.replace('_', ''), file).group(1)\n", + " if model == 'IITM-ESM':\n", + " continue # have seen from plots that this is a major outlier\n", + " data_per_model = xr.open_dataset(file)\n", + " data_per_model_2015_2024 = data_per_model.sel(time = slice('2015-01-01', '2025-01-01'))\n", + " pr_data = data_per_model_2015_2024['pr'][:] * multiplier # in kg m-2 s-1 = mm s-1 x 86400 to get to day\n", + " pr_data_avg_area_model = pr_data.mean(dim=['lat', 'lon'])\n", + " cumulative_sum_window_for_model = []\n", + " begin_day = 0\n", + " for month_idx, month_length in enumerate(month_lengths):\n", + " days_for_grid = pr_data_avg_area_model[begin_day:begin_day + month_length]\n", + " cumulative_sums = sum(days_for_grid)\n", + " if isinstance(cumulative_sums, int):\n", + " cumulative_sum_window_for_model.append(cumulative_sums)\n", + " else:\n", + " cumulative_sum_window_for_model.append(cumulative_sums.values)\n", + " begin_day += month_length\n", + " cumulative_sum_by_models[model] = cumulative_sum_window_for_model\n", + " plt.plot(cumulative_sum_window_for_model, linewidth=2, linestyle='--', label = model)\n", + "\n", + "cumulative_sums_df = pd.DataFrame(cumulative_sum_by_models)\n", + "mean_cumulative_sum = cumulative_sums_df.mean(axis=1)\n", + "median_cumulative_sum = cumulative_sums_df.median(axis=1)\n", + "plt.plot(mean_cumulative_sum, color='black', linewidth=3, label='Average', zorder=10)\n", + "plt.plot(median_cumulative_sum, color='orange', linewidth=3, label='Average', zorder=10)\n", + "\n", + "plt.plot(pr_data_time_series_avg_ERA5 * 30 * 1000, color=\"blue\", linewidth=2, linestyle='-',markersize=4, label='ERA5')\n", + "\n", + "plt.legend()\n" + ], + "id": "ceba09cf984d2020", + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 169, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 169 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-11-28T11:48:29.614526Z", + "start_time": "2024-11-28T11:48:29.507571Z" + } + }, + "cell_type": "code", + "source": [ + "plt.plot(mean_cumulative_sum, color='#B18FCF', linewidth=2, label='Mean over CMIP6', zorder=10)\n", + "plt.plot(median_cumulative_sum, color='#A27035', linewidth=2, linestyle = ':',label='Median over CMIP6', zorder=10)\n", + "\n", + "plt.plot(pr_data_time_series_avg_ERA5 * 30 * 1000, color=\"#4B88A2\", linewidth=2, linestyle='-',markersize=4, label='ERA5')\n", + "\n", + "plt.legend()\n", + "plt.ylim(0,400)\n", + "plt.xlim(0, (12*10) -1 )\n", + "plt.xlabel(\"Months since 01/2011\")\n", + "plt.ylabel(\"Average monthly precipitation across Malawi (mm)\")" + ], + "id": "cf4d9a658012d1b7", + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Average monthly precipitation across Malawi (mm)')" + ] + }, + "execution_count": 173, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAG2CAYAAACZEEfAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/OQEPoAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydd5hU9fX/X7dMn+2FpSxNQLrYRY29E1tsiQ0l0aiYKDZsMZZEjLEmJmoS6y9ii/pNNDbsijXYkKb0tssCW6fe+vtjdmbunZ2FXQTmDt7X8/Awc9t8ZueW8znnfc4RTNM0cXFxcXFxcXHZQRELPQAXFxcXFxcXl22Ja+y4uLi4uLi47NC4xo6Li4uLi4vLDo1r7Li4uLi4uLjs0LjGjouLi4uLi8sOjWvsuLi4uLi4uOzQuMaOi4uLi4uLyw6Na+y4uLi4uLi47NC4xo6Li4uLi4vLDo1r7Li4uLi4uLjs0DjG2LntttsQBIFLL700syyRSDB16lSqqqoIh8OcdNJJrFu3zrbfypUrmTRpEsFgkNraWq688ko0TdvOo3dxcXFxcXFxKo4wdj777DMefPBBxo8fb1s+bdo0XnzxRZ599lneffdd1q5dy09+8pPMel3XmTRpEoqi8OGHH/LYY4/x6KOPcsMNN2zvr+Di4uLi4uLiUIRCNwKNRCLstttu/PWvf+V3v/sdEyZM4J577qGtrY2amhpmzpzJySefDMDChQsZNWoUH330Efvssw+vvPIKP/7xj1m7di19+vQB4IEHHmD69OmsX78er9dbyK/m4uLi4uLi4gDkQg9g6tSpTJo0icMOO4zf/e53meVz5sxBVVUOO+ywzLKRI0cycODAjLHz0UcfMW7cuIyhA3DkkUdy4YUXMm/ePHbddde8n5lMJkkmk5n3hmHQ3NxMVVUVgiBsg2/p4uLi4uLisrUxTZOOjg769euHKHYfrCqosfPUU0/x+eef89lnn3VZ19jYiNfrpby83La8T58+NDY2ZraxGjrp9el13TFjxgxuuumm7zl6FxcXFxcXFyewatUqBgwY0O36ghk7q1at4pJLLmHWrFn4/f7t+tnXXHMNl112WeZ9W1sbAwcOZNWqVZSWlm7Xsbi4uLi4uLhsGe3t7dTX11NSUrLJ7Qpm7MyZM4empiZ22223zDJd13nvvfe47777eO2111AUhdbWVpt3Z926ddTV1QFQV1fHp59+ajtuOlsrvU0+fD4fPp+vy/LS0lLX2HFxcXFxcSkyNidBKVg21qGHHsrcuXP58ssvM//22GMPzjjjjMxrj8fDm2++mdln0aJFrFy5kokTJwIwceJE5s6dS1NTU2abWbNmUVpayujRo7f7d3JxcXFxcXFxHgXz7JSUlDB27FjbslAoRFVVVWb5z3/+cy677DIqKyspLS3lV7/6FRMnTmSfffYB4IgjjmD06NGcddZZ3H777TQ2NnL99dczderUvJ4bFxcXFxcXlx8eBc/G2hR33303oihy0kknkUwmOfLII/nrX/+aWS9JEi+99BIXXnghEydOJBQKMXnyZG6++eYCjtrFxcXFxcXFSRS8zo4TaG9vp6ysjLa2tm41O4ZhoCjKdh6Zi8u2wePxIElSoYfh4uLi8r3oyfMbHO7ZcQqKorBs2TIMwyj0UFxcthrl5eXU1dW5taVcXFx2eFxjZzOYpklDQwOSJFFfX7/JokUuLsWAaZrEYrGMsL9v374FHpGLi4vLtsU1djaDpmnEYjH69etHMBgs9HBcXLYKgUAAgKamJmpra92QlouLyw5Nr4wdwzB49913ef/991mxYgWxWIyamhp23XVXDjvsMOrr67fVOAuGrusAbp8tlx2OtPGuqqpr7Li4uOzQ9CgmE4/H+d3vfkd9fT3HHHMMr7zyCq2trUiSxOLFi/ntb3/LkCFDOOaYY/j444+39ZgLgqtrcNnRcM9pFxeXHwo98uyMGDGCiRMn8ve//53DDz8cj8fTZZsVK1Ywc+ZMfvrTn3Lddddx3nnnbfXBuri4uLi4uLj0lh4ZO6+//jqjRo3a5DaDBg3immuu4YorrmDlypVbZXAuLi4uLi4uLt+XHoWxNmfoWPF4POy0005bPCCXrcM555yDIAhccMEFXdZNnToVQRA455xztv/AioC3336bY445hqqqKoLBIKNHj+byyy9nzZo1ALzzzjsIgkBFRQWJRMK272effYYgCLYQUXr71tZW2/v0vz59+nDSSSexdOlS27E++ugjDjnkEEKhEKWlpRxwwAHE4/Ft++VdXFxcdkC2KI86kUjw6aef8tJLL/Gf//zH9s/FOdTX1/PUU0/ZHpCJRIKZM2cycODAAo6ssJimiaZpedc9+OCDHHbYYdTV1fHcc88xf/58HnjgAdra2rjzzjtt25aUlPDCCy/Ylj300EM9/tsuWrSItWvX8uyzzzJv3jyOPfbYjCD+o48+4qijjuKII47g008/5bPPPuPiiy92Sx+4uLi4bAlmL3nllVfMmpoaUxCELv9EUezt4RxBW1ubCZhtbW1d1sXjcXP+/PlmPB4vwMi2nMmTJ5vHH3+8OXbsWPOf//xnZvkTTzxhjh8/3jz++OPNyZMnZ5brum7eeuut5uDBg02/32+OHz/efPbZZzPrNU0zp0yZklk/YsQI85577sn7mX/84x/Nuro6s7Ky0rzoootMRVE2Oda//vWv5tChQ02Px2OOGDHCfPzxxzPrfvazn5mnnnqqbXtFUcyqqirzscce69HY3377bRMwX375ZXO33XYzPR6P+fbbb3cZx6pVq0yv12teeumlecfZ0tJiO971119vHnbYYZn1sVjMLCsrM3/zm9+Y1ksrvX3u/un3ppn6XQBz4cKFpmma5t57721ef/31m/y7fV+K9dx2cXFxSbOp57eVXk8Tf/WrX3HKKafQ0NCAYRi2f+lZqYtzmDJlCo888kjm/cMPP8y5557bZbsZM2bw+OOP88ADDzBv3jymTZvGmWeeybvvvgukyg4MGDCAZ599lvnz53PDDTdw7bXX8swzz9iO8/bbb7NkyRLefvttHnvsMR599FEeffTRbsf3wgsvcMkll3D55ZfzzTff8Mtf/pJzzz2Xt99+G4AzzjiDF198kUgkktnntddeIxaLceKJJ/Zo7GmuvvpqbrvtNhYsWMD48eO7jOXZZ59FURSuuuqqvGMtLy+3vT/rrLN4//33Mxq15557jsGDB7Pbbrt1+327I133RlEUmpqa+OSTT6itrWXfffelT58+HHjggXzwwQe9Pq6Li4uLyxYUFVy3bh2XXXYZffr02RbjKQrenbmIZCx/GGRb4gvKHHj6zr3a58wzz+Saa65hxYoVAMyePZunnnqKd955J7NNMpnk1ltv5Y033mDixIkADB06lA8++IAHH3yQAw88EI/Hw0033ZTZZ8iQIXz00Uc888wznHrqqZnlFRUV3HfffUiSxMiRI5k0aRJvvvlmt9l5d9xxB+eccw4XXXQRAJdddhkff/wxd9xxBwcffDBHHnkkoVCIF154gbPOOguAmTNnctxxx1FSUtKjsae5+eabOfzww7v9W3333XeUlpb2uKJwbW0tRx99NI8++ig33HADDz/8MFOmTOnRvlYaGhq444476N+/PzvvvDOff/45ADfeeCN33HEHEyZM4PHHH+fQQw/lm2++Yfjw4b3+DBcXF5cfMr02dk4++WTeeeedH7QIORnTSETUQg+jR9TU1DBp0iQeffRRTNNk0qRJVFdX27ZZvHgxsVisiyGgKAq77rpr5v1f/vIXHn74YVauXEk8HkdRFCZMmGDbZ8yYMbYCdX379mXu3Lndjm/BggWcf/75tmX77bcf9957LwCyLHPqqafyxBNPcNZZZxGNRvn3v//NU0891auxA+yxxx7djgNSWp7e1p6ZMmUKl1xyCWeeeSYfffQRzz77LO+//36P9h0wYECmdcMuu+zCc889h9frzfRgS3u5AHbddVfefPNNHn74YWbMmNGrMbq4uLj80Om1sXPfffdxyimn8P777zNu3LguNXd+/etfb7XBORVfsDBdNrb0c6dMmcLFF18MpAyWXNIhov/+97/079/f/pk+HwBPPfUUV1xxBXfeeScTJ06kpKSEP/7xj3zyySe27XPPB0EQvncD1TPOOIMDDzyQpqYmZs2aRSAQ4Kijjurx2NOEQqFNfs6IESNoa2ujoaGhx96do48+mvPPP5+f//znHHvssVRVVfX0a/H+++9TWlpKbW0tJSUlmeXpzx49erRt+1GjRrllHVxcXFy2gF4/PZ988klef/11/H5/JoU2jSAIPwhjp7ehpEJz1FFHoSgKgiBw5JFHdlk/evRofD4fK1eutIV9rMyePZt99903E24CWLJkyfce26hRo5g9ezaTJ0+2fZb1Qb/vvvtSX1/P008/zSuvvMIpp5ySMap6MvaecvLJJ3P11Vdz++23c/fdd3dZ39ra2kW3I8syZ599NrfffjuvvPJKrz5vyJAhXY4HMHjwYPr168eiRYtsy7/99luOPvroXn2Gi4uLi8sWGDvXXXcdN910E1dffbWbBlskSJLEggULMq9zKSkp4YorrmDatGkYhsH+++9PW1sbs2fPprS0lMmTJzN8+HAef/xxXnvtNYYMGcL/+3//j88++4whQ4Z8r7FdeeWVnHrqqZn+ai+++CLPP/88b7zxhm27008/nQceeIBvv/02I17u6dh7Sn19PXfffTcXX3wx7e3tnH322QwePJjVq1fz+OOPEw6Hu6SfA9xyyy1ceeWVvfLqbApBELjyyiv57W9/yy677MKECRN47LHHWLhwIf/617+2yme4uLi4/JDotbGjKAqnnXaaa+gUGaWlpZtcf8stt1BTU8OMGTNYunQp5eXl7Lbbblx77bVASj/yxRdfcNpppyEIAj/72c+46KKLeu3NyOWEE07g3nvv5Y477uCSSy5hyJAhPPLIIxx00EG27c444wx+//vfM2jQIPbbb79ejb03XHTRRYwYMYI77riDE088kXg8zuDBg/nxj3/MZZddlncfr9fbRQf1fbn00ktJJBJMmzaN5uZmdtllF2bNmvWD1sq5uLi4bCmCaZpmb3aYNm0aNTU1W/QgcSrt7e2UlZXR1tbWxShIJBIsW7aMIUOG4Pf7CzRCF5etj3tuFx+LGzdyz8sfMW5gLb88bK9CD8fFpeBs6vltpdeeHV3Xuf3223nttdcYP358F0HqXXfd1fvRuri4uLhslpc+X8Ty9S0sX9/CiXuOprYsXOghubgUBb02dubOnZtJ6f3mm29s63qbtuvi4uLi0nPaYgnL66Rr7Li49JBeGztWcaiLs9iSOjEuLi7FQzShZF8nlU1s6eLiYsVVGe8gRBIKS5taaGqLbH5jFxeXoiRiMXBiyeIobOri4gR67dlJJBL8+c9/5u2336apqalLwbh0qXuX7Ut7LIFhmLTFklSVBJHcbDkXlx0Oq4ETU1xjx8Wlp/Ta2Pn5z3/O66+/zsknn8xee+3lhk0cgmFJqutlgp2Li0uRYA1duWEsF5ee02tj56WXXuLll1/uUuvEpbBY7RvDtXVcXHY4dMMgrmQbELthLGeQnly6E39n0+tYR//+/W19fFycgYnr2XFx2ZHJNW5cY6fwfL2ykVPufoor//ma62lzOL02du68806mT5/OihUrtsV4XLYQq33jGjsuLjseuQ9T9+FaeN5bsJyEqrFw7Xruemm2TU7g4ix6bezsscceJBIJhg4dSklJCZWVlbZ/LoXB6tnZXmGsdCPY1tZWAB599NG8jS1dXFy+P9EcT07cFSgXHE3LJuh8sng1T384t4CjcdkUvTZ2fvazn7FmzRpuvfVW/vznP3P33Xfb/rkUhlzPzjnnnIMgCFxwwQVdtp06dSqCIHDOOeds1TGcdtppfPvtt1v1mMWAaZr87W9/Y++99yYcDlNeXs4ee+zBPffcQywWA+DGG29EEASOOuqoLvv/8Y9/RBAEWz+wG2+8kQkTJtjeC4KAIAjIsszgwYOZNm0akYi91MCjjz7K+PHj8fv91NbWMnXq1G3ynV22P9YaO9DV+HHZ/uimPRt55gdf8dmSNQUajcum6LVA+cMPP+Sjjz5il1122RbjcdlCrKGrtJenvr6ep556irvvvptAIACkSgfMnDmTgQMHbvUxBAKBzOfsaCiKgtfrzbvurLPO4vnnn+f666/nvvvuo6amhq+++op77rmHwYMHc8IJJwDQt29f3n77bVavXs2AAQMy+z/88MM9+j3GjBnDG2+8gaZpzJ49mylTphCLxXjwwQeBVKuWO++8kz/+8Y/svffeRKNRli9f/r2/u4sziLhhLMeh57jRTeCOFz/g7slH069i082Xi40Fa9azoT3KvjsPLMrSJr0e8ciRI4nH49tiLC7fA+sll77+dtttN+rr63n++ecz655//nkGDhyYafmR2ccwmDFjBkOGDCEQCLDLLrvwr3/9y7bNyy+/zIgRIwgEAhx88MFdHqS5YawlS5Zw/PHH06dPH8LhMHvuuSdvvPGGbZ/Bgwdz6623MmXKFEpKShg4cCB/+9vfNvldk8kkv/71r6mtrcXv97P//vvz2WefZb7HgAEDuP/++237fPHFF4iimNGatba28otf/IKamhpKS0s55JBD+OqrrzLbpz0r//jHPzbZKPOZZ57hiSee4Mknn+Taa69lzz33ZPDgwRx//PG89dZbHHzwwZlta2trOeKII3jssccyyz788EM2bNjApEmTNvmdAWRZpq6ujgEDBnDaaadxxhln8J///AeAlpYWrr/+eh5//HFOP/10dtppJ8aPH89xxx232eO6FAe5guS469kpOLqlztyo/jVAygi99YV3UTW9UMPa6mxoj3L1zNf4w3/e5935yws9nC2i18bObbfdxuWXX84777zDxo0baW9vt/1zKQxmN3V2pkyZwiOPPJJ5//DDD3Puued22X/GjBk8/vjjPPDAA8ybN49p06Zx5pln8u677wKwatUqfvKTn3Dsscfy5Zdf8otf/IKrr756k2OKRCIcc8wxvPnmm3zxxRccddRRHHvssaxcudK23Z133skee+zBF198wUUXXcSFF17IokWLuj3uVVddxXPPPcdjjz3G559/zrBhwzjyyCNpbm5GFEV+9rOfMXPmTNs+TzzxBPvttx+DBg0C4JRTTqGpqYlXXnmFOXPmsNtuu3HooYfS3Nyc2Wfx4sU899xzPP/883z55Zd5x/LEE0+w8847c/zxx3dZJwgCZWVltmVTpkzh0Ucfzbx/+OGHOeOMM7r1Gm2KQCCAoqRm97NmzcIwDNasWcOoUaMYMGAAp556KqtWrer1cV2ciRvGch5WQfIlR09kQGXKm7N8fStfrmgo1LC2OsvXt2a8WMvXtxR4NFtGr42do446io8++ohDDz2U2tpaKioqqKiooLy8nIqKim0xRkcy/50neO7GH/PcjT+mcfEc27qOjWsy6z597o9d9n37H5dn1uey5NOXMutWft3zPmRWz47V2DnzzDP54IMPWLFiBStWrGD27NmceeaZtn2TySS33norDz/8MEceeSRDhw7lnHPO4cwzz8yESO6//3522mkn7rzzTnbeeWfOOOOMzWp+dtllF375y18yduxYhg8fzi233MJOO+2U8UakOeaYY7jooosYNmwY06dPp7q6utsebNFolPvvv58//vGPHH300YwePZq///3vBAIBHnroIQDOOOMMZs+enTGqDMPgqaee4owzzgDggw8+4NNPP+XZZ59ljz32YPjw4dxxxx2Ul5fbvFmKovD444+z6667Mn78+Lzj+e6779h55503+Xew8uMf/5j29nbee+89otEozzzzDFOmTOnx/mnmzJnDzJkzOeSQQwBYunQphmFw6623cs899/Cvf/2L5uZmDj/88IxB5FLc5Iax3ArKhccaxioJ+Dh295GZ9+2xZCGGtE2wnmt6TteEYsFtBLqFqIkosbYmAAzNfhMyDSOzTol3dNk3EWnJrM9FU+KZdZqSyLtNLqZp2qwd62yjpqaGSZMm8eijj2KaJpMmTaK6utq2/+LFi4nFYhx++OG25YqiZMJdCxYsYO+997atnzhx4ibHFYlEuPHGG/nvf/9LQ0MDmqYRj8e7eHashoQgCNTV1dHUlP/vs2TJElRVtRW19Hg87LXXXixYsACACRMmMGrUKGbOnMnVV1/Nu+++S1NTE6eccgoAX331FZFIhKqqKtux4/E4S5YsybwfNGgQNTU1m/yOvU3z93g8nHnmmTzyyCMsXbqUESNGdGtI5TJ37lzC4TC6rqMoCpMmTeK+++4DUgadqqr86U9/4ogjjgDgySefpK6ujrfffpsjjzyyV+N0cR6xHGMnrqjohlGU+okdBeuDXxIFvLKUea/qO04Yy5r5pxVp1dpeGzsHHnjgthhH0eHxhwiW1QIgyvYQhCCKmXXeQNcCjP5wRWZ9LrI3kFkne/PrRHLJfeDmPn+nTJnCxRdfDMBf/vKXLvunM3r++9//0r9/f9s6n8/XozHk44orrmDWrFnccccdDBs2jEAgwMknn9zF0+DxeGzvBUHo0nOtt5xxxhkZY2fmzJkcddRRGeMmEonQt29f3nnnnS77WTVHoVBos58zYsQIFi5c2KuxTZkyhb333ptvvvmmV16dnXfemf/85z/Isky/fv1soa++ffsCMHr06MyympoaqquruxiXLsVJNNHVkxNXNML+3odAXbYOhuXBLwoiHouxo+xAmh2rXkzXd2DPzsqVK3uVvbNmzZouD8183H///dx///0ZoeuYMWO44YYbOProowE46KCDMpqRNL/85S954IEHbGO78MILefvttwmHw0yePJkZM2Ygy72243rF6IPOYPRBZ+RdV1LVn5NufKnbfQ/+xZ3drttprx+z015dw1ubItfOzi1sddRRR6EoCoIg5J3hjx49Gp/Px8qVK7s1ZkeNGtUl/PTxxx9vclyzZ8/mnHPO4cQTTwRSRsb3zQ7aaaed8Hq9zJ49O6O/UVWVzz77jEsvvTSz3emnn87111/PnDlz+Ne//mU7Z3bbbTcaGxszKdzfh9NPP52f/vSn/Pvf/+6i2zFNk/b29i66nTFjxjBmzBi+/vprTj/99B5/ltfrZdiwYXnXpT1dixYtymR6NTc3s2HDhszfyaW4ieYJR8YU1TV2CojVsyOKAl7J6tkpTqMgH9Ywllak36tH/s8999yTX/7yl5mMl3y0tbXx97//nbFjx/Lcc8/16MMHDBjAbbfdxpw5c/jf//7HIYccwvHHH8+8efMy25x33nk0NDRk/t1+++2ZdbquM2nSJBRF4cMPP+Sxxx7j0Ucf5YYbbujR5+8o5Hpycj09kiSxYMEC5s+fj2S5GNOUlJRwxRVXMG3aNB577DGWLFnC559/zp///OdM5tAFF1zAd999x5VXXsmiRYuYOXOmTWibj+HDh2fEvV999RWnn3769/bYhEIhLrzwQq688kpeffVV5s+fz3nnnUcsFuPnP/95ZrvBgwez77778vOf/xxd121ZSYcddhgTJ07khBNO4PXXX2f58uV8+OGHXHfddfzvf//r1XhOPfVUTjvtNH72s59x66238r///Y8VK1bw0ksvcdhhh3Ub9n3rrbdoaGjYakUYR4wYwfHHH88ll1zChx9+yDfffMPkyZMZOXKkLSPMpXjJFShD19CWy/bFOrGURAGPnH2k7qieHW1H1uzMnz+f3//+9xx++OH4/X523313+vXrh9/vp6Wlhfnz5zNv3jx22203br/9do455pgeffixxx5re//73/+e+++/n48//pgxY8YAEAwGqaury7v/66+/zvz583njjTfo06cPEyZM4JZbbmH69OnceOONW5ThUoxsLowFUFq66ZoPt9xyCzU1NcyYMYOlS5dSXl7ObrvtxrXXXgvAwIEDee6555g2bRp//vOf2WuvvTIp491x1113MWXKFPbdd1+qq6uZPn36VsnYu+222zAMg7POOouOjg722GMPXnvttS4C+TPOOIOLLrqIs88+21b/RxAEXn75Za677jrOPfdc1q9fT11dHQcccAB9+vTp1VgEQWDmzJn87W9/4+GHH+b3v/89siwzfPhwzj777G61Mj0JkfWWxx9/nGnTpjFp0iREUeTAAw/k1Vdf7RImdClO8mVfuRlZhcUqUJZEEY9lMqntoJqdYhUoC2YvFJbxeJz//ve/meyeeDxOdXU1u+66K0ceeSRjx47d4oHous6zzz7L5MmT+eKLLxg9ejQHHXQQ8+bNwzRN6urqOPbYY/nNb35DMBgE4IYbbuA///mPLS142bJlDB06lM8//7xLLZk0yWSSZDKrlG9vb6e+vp62trYuRkEikWDZsmWbrLVSaBRNZ8X61sz7cMBL33K3WavLpimGc9slyy8efIHGVnvF7N+efAh77rR5yYDLtuGyx1/m24aNCMCL089i3uompj/xGgAn7jmanx+ye2EHuJX4w7/f4/2FqRplE0fUc92JBxV0PFbSUoF8z28rvRK2pAWmJ5988vceYJq5c+cyceJEEokE4XCYF154ISOyPP300xk0aBD9+vXj66+/Zvr06SxatChTJK+xsbHLTDz9vrGxsdvPnDFjBjfddNNW+w6FpqtnpzjV8i4uLt3jhrGcR9qzk86Is2t2dhzPji2MVaSanW2r4u0BO++8M19++SVtbW3861//YvLkybz77ruMHj2a888/P7PduHHj6Nu3L4ceeihLlixhp5122uLPvOaaa7jssssy79OenWIl17RxbR0Xlx0L0zTdMJYDyRo7AsCOq9mxhbGK8wFT8AIN6QyT3XffnRkzZrDLLrtw77335t02Xedl8eLFANTV1bFu3TrbNun33el8IJVOXVpaavtXzOR6cnKzsVxcXIqbhKrlva7dwoKFJZ1wIaaNnR00G8teZ6c4v1fBjZ1cDMOw6WmspLU56ZoiEydOZO7cubYCdLNmzaK0tNRWb6S3KJpeVKGgzWVjubi4FDfWEFbQmxWcu2GswpI2QEUh9Si11tnZkXpj/WDq7GwrrrnmGo4++mgGDhxIR0cHM2fO5J133uG1115jyZIlzJw5k2OOOYaqqiq+/vprpk2bxgEHHJCpOHvEEUcwevRozjrrLG6//XYaGxu5/vrrmTp16hYXw1uwuokbnn2L/pUl3HnW0Vvz624zTDafjeXi4lK8WMNVNaUhVmxoBbo2B3XZvuSGsbxS1n+wQ2l2doA6OwU1dpqamjj77LNpaGigrKyM8ePH89prr3H44YezatUq3njjDe655x6i0Sj19fWcdNJJXH/99Zn9JUnipZde4sILL2TixImEQiEmT57MzTffvMVjemveMuKKyuLGZpasa2ZgRXhrfNVtSq5x44axXFx2LKIWD05tWdbYcTU7hSWdhp0WKO+IFZRN0/zh1Nn5z3/+w9FHH43H4+lSRTcXa/G2zZFu3JiP+vr6LtWT8zFo0CBefvnlHn/m5miNxTOvi+VkdbOxXFx2bKzGTk1ptkaTG8YqLF0EyjugZkfRdNsEuljr7PTI2DnhhBNobGyktraWE044odvtBEFAL3LXXZulU22xxFy7ZmO5xo6Ly45EbhgrjStQLiy62SlQFtLGjiWMVSTPj82Re47t0GEsa4n/71vu3+m0xbKdxovFXdc1Gyu1TOi8AF1cXIobq0C5MhRAEgV0w3Q1OwXGyKmzIwgCsiSi6cYOo9nJPcd+MKnniURi8xsVMa3R7PdTteIwdvJRnKeji4tLPqxhrJDfm8nIihZxGCuhakXvhc4NY0G2sGCxyCA2RzzXs1MkToBcem3slJeXc8ABB/Cb3/yGN998k3g8vvmdigRV1203j2KxzPPdMM495xwEQejy76ijjgJSjTLTy4LBIOPGjeMf//hH3uM/+eSTSJLE1KlTu6xbvnx53s/ZXEd0FxeXnmMNY4V8XoK+VN+/YvXsfL5sLWf86RmmP/FaUSdUGKa9zg5kCwvuKJqd3DBWsWp2em3svPHGGxx11FF88sknHH/88VRUVLD//vtz3XXXMWvWrG0xxu1GR8xe36dYYpP5vIomcNRRR9k6xjc0NPDkk09mtrn55ptpaGjgm2++4cwzz+S8887jlVde6XKshx56iKuuuoonn3yyW8/eG2+8Yfuc3XffMXrCuLg4AWsYK+TzEPKlPDuxpFqU3pF35i8jqenMX7OelZ2ZZcVIbrsIyHp2imWyvDniyR1Ds9NrY2f//ffn2muv5fXXX6e1tZW3336bYcOGcfvtt2e8BsVKW9z+IC8Wyzy3zk7nQnw+H3V1dbZ/1s7gJSUl1NXVMXToUKZPn05lZWUXg3XZsmV8+OGHXH311YwYMSLTlyyXqqoq2+e4nbZdXLYeXcJYncaOZhhFc5+yYs0ii+Tp+VUspL0cokUfKXemn++oAuVi9exsUZ2db7/9lnfeeSfzL5lM8uMf/5iDDjpoKw9v+9Ke49kpGss8r63T89meYRi88MILtLS04PV6beseeeQRJk2aRFlZGWeeeSYPPfQQp59+epdjHHfccSQSCUaMGMFVV13VqxIELi4um6a7MFZqnYJXDhRiWFuMNfxWzMaOsQnNTjEaofnIDZUWq2en18ZO//79icfjHHTQQRx00EFMnz6d8ePH7xCZP7mene5+1Esf+y8tke0v1K4I+7ln8qQuy7tzY7/00kuEw/aiiNdeey3XXnstANOnT+f6668nmUyiaRqVlZX84he/yGxrGAaPPvoof/7znwH46U9/yuWXX86yZcsYMmQIAOFwmDvvvJP99tsPURR57rnnOOGEE/i///s/1+BxcdlKWMNYAa+cCWNB6mFUESouYyeuaJnXxWrsGGZ2SmkNY6U1O65A2Vn02tipqalh4cKFNDY20tjYyLp164jH4wSDwW0xvu1KTz07LZEEGyOx7TGkHpHP1DFNOPjgg7n//vttyysrKzOvr7zySs455xwaGhq48sorueiiixg2bFhm/axZs4hGoxxzzDEAVFdXc/jhh/Pwww9zyy23ZJZZO8jvueeerF27lj/+8Y+usePispVIh7GCXg+SKOb0xyo+kbL1ARpJ5O+F6HSs4Zx8nh3DNNENw2YIFSNdw1hmUZY26bWx8+WXX9La2sp7773Hu+++y7XXXsv8+fOZMGECBx98ML///e+3xTi3C+3xXGMnvwVbEfZvj+H0+HO78+yEQiGb8ZJLdXU1w4YNY9iwYTz77LOMGzeOPfbYI9NE9aGHHqK5uZlAIDtrNAyDr7/+mptuugmxm4t47733LnqxuouLk0iHsdIendwwVrERU4o/jGWtN2O9F8o5zUAlb5EbO3mMad0wkaUd3NiBVPr5cccdx3777ce+++7Lv//9b5588kk++eSTHcrY6S6MlS+UVEjy2Tq90exAqj3HaaedxjXXXMO///1vNm7cyL///W+eeuopxowZk9lO13X2339/Xn/99W4F6V9++WWmM72Li8v3J23QhPwpIyc3jFVsxHcAY8daYFcSunp2IDVhLszUeOuRr0q3ZhjIUnEZcb02dp5//vmMMHn+/PlUVlay//77c+edd3LggQduizFuN1pjudlYxRFz7c6wSSaTNDY22pbJskx1dXXe7S+55BLGjh3L//73Pz744AOqqqo49dRTu7grjznmGB566CGOOuooHnvsMbxeL7vuuiuQOj8efvjhbmv2uLi49A5V0zP6j1CnRydoNXaKrGWEYZo7hGbH7tnpWmcHdgzdTq5mB4ozI6vXxs4FF1zAAQccwPnnn8+BBx7IuHHjtsW4CkJPPTtOI69nx4RXX321i4dl5513ZuHChXmPM3r0aI444ghuuOEGVq9ezYknnpg3LnvSSSdx1llnsWHDBgBuueUWVqxYgSzLjBw5kqeffpqTTz75+38xFxcXW5gquAOEsRI5D89iNXasxRDz1dkBZ0+YI4kkQZ/Xljafj3yew2J5NlrptbHT1NS0LcbhCNqL1bOTx9r564N/Y+Y//1+3+yxfvjzv8ldffXWzn3fqqady6qmnAjB58mQmT57cs4G6uLj0GmvaeXgHCGPFLF4dKF5jpzuBsq3zuUNbDr30+SIemPUpuw/px29POWSTBk8+z2Exena+V9AtkUjQ3t5u+1fMtPcw9dxp5AtiFXMJdhcXlyy2goKdHp1AEWdj5YZFijcby+LZEayp58737HywcDkAc5at5ZPvVm1y29wKygBaETYD7bWxE41Gufjii6mtrSUUClFRUWH7V8zEFfuJWSxFofJ5dlxbx8VlxyC3VUTq/+INY+UaZ5EiG3+a7j07ztfsWJ9tT304d5MtR/IKlB1qxG2KXhs7V111FW+99Rb3338/Pp+Pf/zjH9x0003069ePxx9/fFuMsWC4nh0XF5dCk1s9GewC5XwCUieTO95o0Yax8guUvbI9G8uJGJaxL1nXzGdL1nS7bV6Bsl58z5deGzsvvvgif/3rXznppJOQZZkf/ehHXH/99dx666088cQT22KMBcOpLshc8nt2iu9kdHFx6UpuXyywa3aiRR7GUnWDpKp1s7VzsQmUrWEsi2bHqZ6d3CrIT374dd5nhm4Ytsy57vYvBnpt7DQ3NzN06FAASktLaW5uBlINQt97772tO7oCY23k5mTjIX+dHReXTePkc9oliz2M1VWzU3RhrDyegmIUKVvDWN2lnjs13JMrMP6uYSOfL1vbZbtEN0boD0KgPHToUJYtWwbAyJEjeeaZZ4CUx6e8vHyrDq7QaIaB1GmlK4pzL8Z8dXbcMJbL5ojFUi1P3A71zsYexkr9VpIo4vekkmnzCUidTD5PQTEaO9ZQkK03VhF4dow8AuOZs7t6d7o7t4pF4mGl16nn5557Ll999RUHHnggV199Ncceeyz33Xcfqqpy1113bYsxFgxVM5BlmWAwyPr16/F4PN22SCgkmqKg6wYIZFw6qmiSSLgPMZeumKZJLBajqamJ8vLyjEHv4kzsdXa8ltceEqpW9GEsKE6Rsi0by+bZcb5mJz32Er+XynCQFRtaWbR2A18ub2DXIf0y23VXsLIYw1i9NnamTZuWeX3YYYexcOFC5syZw7Bhwxg/fvxWHVyh0QwDQRDo27cvy5YtY8WKFYUeUl42tEcxOhuzpS1zrywRbS6uTsgu25fy8nLq6uoKPQyXzZCvzg6kQlrNkXjRVVDOlypfjOnntjCWrV2E87Ox0saKLEn8dN9x/OE/7wPw5OyvmTC4b6aYbHdlDYoxjLVFvbGsDBo0iEGDBm2NsTiOtGbH6/UyfPhwx4ay/vTYy8QVlerSIBvaU6GJnfpUcuVxPyrwyFycisfjcT06RYK9zk7WW5vufB5X1KLqrp3Xs1OMYaxuKigXQ52dtLEiiQL77jyQ+qoyVm1sY/6a9axpbmdAVRmwCc9OEWZj9cjY+dOf/tTjA/7617/e4sE4BVEQMEwT1SZAE/H7ndnSrSmSIKnphENBWhMammFQFlMcO14XF5eek0+gDLnp55rN6+NkdhRjp9swlmTveu5E0podSRSQRJF9Rwzk6Y/mArCuLZIxdqy/VcjnyXgZd1jPzt13392jgwmCUPTGjigIlAZ9tEYTaA49UXNJx4U9koRXltCU4kzldHFx6Ur6AeOVJZvXwGr4xBS1iIydHUOg3G1RQUs2lnM1O6lxpTWoVSXBzLqNHbHMa2sYqyTgy5yLO6xAOZ19tSMz6Uc/RQVKA75MIze1CKxX3TAy7lRZEvF5ZGKKSrJIDDUXF5dNkw5jWY0byOl8nlSA0PYc1hYTyyNGLk5jx1pUMH8jUOdqdjqfGRljJ6vv3BiJZ15bw1glAR+NrZHO/Z3/bMylOIK824HzfzIdASgL+jOzJ6c2cbNinTl4JDFTvVPRXM+Oi8uOQDqMZdXrgN3YKaaMrB3Fs2OY3Xl2nK/ZMSyaHYCq8OY9O6V+X+b1DhvGymX16tX85z//YeXKlV1Eu8Wafh5pvINQYH/Kgj7aYqnMAKcWhLJiHaNHkvB5UhdaUnX+2F1cXDaNYZoZ3UQXz06RNgPNr9kpxmwsi2dH6Eaz49BniJ7R7HR6dqzGTiRr7MRzPDtpdtgwlpU333yT4447jqFDh7Jw4ULGjh3L8uXLMU2T3XbbbVuMcbugJ78l5N+HsqA/47pzarzVitX7JEsiPjn1kyqajtmZju7i4lKcxJJqpmRoMMezY9PsFFGdmvT9tTTgoz2eMnKKyTOVptuiglbNjkOjA1nNTur5UBbyI4kCumHaPTs2Y8fbZf9iotdhrGuuuYYrrriCuXPn4vf7ee6551i1ahUHHnggp5xyyrYY43YjhE55yI8spixzwzQd/6NadUVWz45hmkVpfbu4uGSxGjG5AmSbZqeIau3ELcZO+n5VnJ6d/GEsr8M9O7phZAzotGZHFAQqQyndjs2zYxUoW8JYWp4KzE6n18bOggULOPvsswGQZZl4PE44HObmm2/mD3/4w1Yf4PaidOBf0Dx1lAb8Ob1NnG0wWFMbPbKIV84661yRsotLcRNJ5k87h+LU7JimmdHsBLyezHcqRs2O3oM6O04UKBvdpMxXdmZktcWSGSMtV6CcRnf4czEfvTZ2QqFQRqfTt29flixZklm3YcOGrTey7YwgePAJcqdnx/mpg2nUHM2O13KhuennLi5ZnFrzZFNEE9mHzY4QxkqqWiZ7NOCVM96qaDEaOz3y7Djv+aHn1I9LY9XttHRmZFk1O6VWzY7DIx756LVmZ5999uGDDz5g1KhRHHPMMVx++eXMnTuX559/nn322WdbjHG74RckWzYWOF+kbPU8pVLPnT2rcHEpBG/OXcL9sz5lbH0ffnvywUWjZetxGKtIPDtpr44PiaGxUjYKXlbSRlLTUTXddu91Ot0KlG2aHefdg20eKcu4bennHTFqy8KZ80qWRPzerLng9IhHPnpt7Nx1111EIqlc+5tuuolIJMLTTz/N8OHDizYTK41PkFPGjlRMnh176rnPFsZyPTsuLvNWN/GnVz9CN0z+t3QN69oi1JWXFHpYPWKTYSxv8YWx0mGRCVINtR1+avDxPxqIoxFJKFSEi6efn9FNnR2nZ2PlTpDT2DOyUp6d9O8V9HpsEY8fhGdn6NChmdehUIgHHnhgqw6oUCiRDynBR3nQbzsBnG7B5oaxDE/2AnTTz11+6GxojzLj/961zcKLSR9iDe/sCGGsdFikUky1shEQKBW8xM0iNHZ6UGdHcWA2VneanXxVlNOenaDPY9MlOT1xJx8FLSp4//33M378eEpLSyktLWXixIm88sormfWJRIKpU6dSVVVFOBzmpJNOYt26dbZjrFy5kkmTJhEMBqmtreXKK69E2wKPRnzjo5QlFnZ6dpxtmVvJTT23CpTdMJbLDxlV07n1/96lNZqwLS8qY6ebjudQnNlY6XGGyY49IKTuWcWWkaV3k3ouCkLGiHDi88Perb07z07K2EkbpwGvp6icAPnosWfH6tHZFEuXLu3xhw8YMIDbbruN4cOHY5omjz32GMcffzxffPEFY8aMYdq0afz3v//l2WefpaysjIsvvpif/OQnzJ49GwBd15k0aRJ1dXV8+OGHNDQ0cPbZZ+PxeLj11lt7PI40HhRCPvuP6vQwlmbYPTvW2LErUHb5oWKaJvfP+pRvGzZ2WVdcxo7Vs2M3dryylKmNUjyanU5jR7AYO52PoUiReKfS2ATKORowrywRVzTna3Y24dlRNT3z/At6i9+z02NjZ/ny5QwaNIjTTz+d2trarfLhxx57rO3973//e+6//34+/vhjBgwYwEMPPcTMmTM55JBDAHjkkUcYNWoUH3/8Mfvssw+vv/468+fP54033qBPnz5MmDCBW265henTp3PjjTfi9fa8MZ6/8gwUTzWCINg8O04XKFs9Ox5JRLIYaq5nx+WHypvfLOX1rxcD4JMlDhs/jP9+vgiwGxBOx2rE5LaLEASBkM9LezxZNMZOLKniRcQjZO+xfiFda6d4fhfo3rMDqYlnHM2Rk+XuNDuVYXt/LKu3MOjL1ewUX52dHhs7Tz/9NA8//DB33XUXRx99NFOmTOGYY46xCbO+D7qu8+yzzxKNRpk4cSJz5sxBVVUOO+ywzDYjR45k4MCBfPTRR+yzzz589NFHjBs3jj59+mS2OfLII7nwwguZN28eu+66a48/31dyIH5SbtTiEihb6+zYMxmKUaBsmiat62KUVPqRvcWTmeHiLF7+YlHm9a+Onogsilljp4geqlYDIOzrOnkLeD20x5NFY8DFFY2wYP8eGc9OEf0uQCaFHrKViNOkJ8xOnHDaNDuWMFbA6yHo9RBTVDZGYra086DXgyRlv+MOXWfnlFNO4ZVXXmHx4sXsvvvuTJs2jfr6eq6++mq+++67LR7A3LlzCYfD+Hw+LrjgAl544QVGjx5NY2MjXq+X8vJy2/Z9+vShsbERgMbGRpuhk16fXtcdyWSS9vZ22z9IZWOB3dhxemxSzU09t9XZcd6FtjkWf9bE+099x3tPfotZhLMHF2eQ9nSEfB4OGj3EpncpFsMANh3Ggqy3J5ZUMU3nXy9xRbWFsMCq2Sme3wW6r7MD2fRzR2p2TGudHfu406Gs5o6YzVsY2AGysXrtlunfvz/XXXcd3333HTNnzuSTTz5h5MiRtLS0bNEAdt55Z7788ks++eQTLrzwQiZPnsz8+fO36Fg9ZcaMGZSVlWX+1dfXAyCbIqZpIheRQFmzpZ5L+DzFnXq+flUHAJGWJPFIcbjmXZxHehKQnmEHPRJ1yRUE9AiRIgn5QNZoEwWBgLerIz5tAGmG4XgvNKS+j1WcDOAvWmPHWmfH/ihNFxZ04vPDOm5rGAugqjOUldR01rdHM8t/sNlYiUSCf/7zn9x000188sknnHLKKQSDwc3vmAev18uwYcPYfffdmTFjBrvssgv33nsvdXV1KIpCa2urbft169ZRV1cHQF1dXZfsrPT79Db5uOaaa2hra8v8W7VqFaZpIBgJdM0o3jCWJNoqKDvRhbo51GR2zMlY8TyUXJxFehKQvplv/PLfHNjyHw7f+DTRaHRTuzqK9ITFK0t5CyHaW0Y431jI69npDGMVU3gRwNikZ6fT2HFg6rl1gpw7bqtIedXGtszrgNdTVBGPfPTK2Pnkk084//zzqaur46677uInP/kJa9as4amnnsLn823+AD3AMAySySS77747Ho+HN998M7Nu0aJFrFy5kokTJwIwceJE5s6dS1NTU2abWbNmUVpayujRo7v9DJ/Pl0l3T/9rX3kB7WuuQU3o9tRzhxsM6qY8O0WYjaUmLMZOtPjG7+IM0lmK6dno4jf+DkDAiKFv2PKw+/Ym66HKf6sOFVkV5biiEsrR7GQEyskdI/Ucsh5FzTBs2h4nYHSTeg52Y2f1xvbM61zPTjGGsXosUB4zZgxNTU2cfvrpvPvuu+yyyy7f+8OvueYajj76aAYOHEhHRwczZ87knXfe4bXXXqOsrIyf//znXHbZZVRWVlJaWsqvfvUrJk6cmGlLccQRRzB69GjOOussbr/9dhobG7n++uuZOnXqlhlfRpxkXLPXE3D4j2o1xuQdzrPjGjsuW4ampx4waSNh7BG/4J23X8JApFWqLOTQeoXWeQ1310YhaCss6HxjJ6aoVOZ4dvzICBR5GKsbzQ6k7tHWSWih6S71HKAy3L1n5wdTZ2fBggWEQiEef/xx/t//+3/dbtfc3NzjD29qauLss8+moaGBsrIyxo8fz2uvvcbhhx8OwN13340oipx00kkkk0mOPPJI/vrXv2b2lySJl156iQsvvJCJEycSCoWYPHkyN998c4/HkDmWdwiCGCAZjdvDWA50Q1rRctpF+IvYs2OaphvGctkqpD076Rv0rkefz+8XlJBQNQYaPS9JUWhytUe52FtGON9YSGVj2aski4KAD6nojB1bBeXcOjs5uk9HGTtG/tRzyGp2AFY3Z42drnV2nOWt6gk9/gUeeeSRrf7hDz300CbX+/1+/vKXv/CXv/yl220GDRrEyy+//L3HEu57DQC6LtkEyo737OSkntu6nheZZ0dL2sebcD07LltIrmYHUu0VEqpm6yTudNLe2e7CWMVWRTmeVAnlCJQhlZFVbMbOJsNYsnMnzGmvJ9hTz8EexrJW707V2ckadE5/Luajx8bO5MmTt+U4HENKs+PsrrVWbKnnoj2MVWyeHTWpY2gbSbbPQvaPIhk7oNBD+sGjKTqrFrRQURekvM+WJSFsb0zTzDyIrA+hsN/LxkisKDwgadKTme7CWL4iC1vrCcNW5T2NH5mWom4Xkb/ODoDisIwsY1Op5+H813iqzo7Fs1OEYayC9sZyImpCz2kX4awTNRdbGEu2C5SL4eZnRU3qxDY+htLxFrH1fyHe1r75nVy2Kd9+so65b6/mo+eXoCnFcT5ZZ50eKVVOIt6xkRKPiU+PYSbai0JzYJrmZgXKxZaQICiW8IflORsQZBKqVhS/SxrdMKgRAvzMuzOrZm+w1TmyGqdOmzBvykgrD/nzGqM/yDo7OzpKQstpF+HsHzU39dxX5J4dLLOOSFv3hSFdtg8t61INAdWkTqS1OGbeWo63U1Pi/OuGoxnzxe84Yf1D7NIxuyi8O3ajzfLwTOqZB2uxTW5kNfsgLan0Z15nqygXxzkGqUrEI6VKSgQvbStjtG/INpz1OtizY9Ps5ITfJFGkPOTP3YWgz4MgCBlD6AdTZ2dHJLbhEaJNf6Fl9Zf2eGtRGTtSUXc9V5I6km8wICBIZaixxOZ2cdnGJCJZoyDe7nwDAXLqiEgiSrzDtt5nJorC2LFqPdLh6cYlbbz64Dd88PR3mKZZVGFr0zTx6Nl7a3ltVgxbjP2xdNMkiIypRzFNg4SlCKqzNTvWOjtdTQCrbidNWhuWjnpYdT/FgnMk4gVGjX4EQKxtL8qlPTLLHe/Z0ezKelkSM52Qi02grCZ0/OXH4y//CUKncE7XDCS5OG1y0zARxK4u4WIhFf7J3sBjRWjseCQRAYFg5QRizV8CEPX0LwqRsnUik37IrF7YgmmYtDTGiDQn8cnWMJazr3dVNwia2fGW9QmyakGq8n4xtowwDINQ4lvaNzyE6Kkj1vEAUArkeOIc5tnZVE8vSOl2vmOjbVk6y1cWRRR0xzfIzsf3NnZ0XWfu3LkMGjSIioqKrTGmgqIkIjkVlJ39o+bqEwB8skxMUR0/08tFTeoIOTU4klGVYNnWKVi5PVmxaCNfvb6K0v5BDvrJiEIPZ4tQEzqGZQZXNJ4dm5teIlheS/XQy2kriQPQqCwtEs+O3WsLoMSz13QyruHzWLMvnX2951ZPLq/NehCKsRmobph4NvwDMDDUNTR+9yFDxp8I4OjCtJvKIoOunh2/R85slza6izH1vNdT5ksvvTSTMq7rOgceeCC77bYb9fX1vPPOO1t7fNuNQJ/fUNL/dkKVhxdV8STbDbHTpe31OLfj7qZIxmKo8fnoykoMPSVOLtb0808/WAE6tK+MsXFD8bQnsJLbmyzW4XxvCORodjqv5UTU0tSwSNKcbdXRO72byU5jxzRNkjHF7tlx+PUeS2arJ5uYlNZktSHp/ljFYISm0U0DMTA28940skaCNbzoNCmEXbOTz7Njr4NkLW+QNnp+EALlf/3rX5nqyS+++CLLli1j4cKFTJs2jeuuu26rD3B7EVNDiHI5mio62gWZS27qOZC5ATp9ppdLtLmRWNM9RBp+R6LlOaB4qyhb217MW1ycQmurXgeKyLOTc02YhpkxEiCV5lwcxk5Xz07b2rdoX30V7Sun0rDoA7tnx+GeXKtnR5dB9kjI3tQ9qxg9O4ZuUlJ7MWWD/kbZoL8h+7MeXGt0wGmTTnu39s17dqyFK9PG0Q9CoLxhw4ZMk82XX36ZU045hREjRjBlyhTmzp271Qe4vYjEUtUiU9lYxePZyU09h2ztDaddZJsjEW3JvFajH5Fsf4tktDi8CblIenbGtGRVz6uKO4l4jienaDQ7ORVik3ENLF73gCAXhQcht++daZp0ND6KqbcCGvGO1qLKxorElIw2x+yMTHsDqffFqNkRc2xLu0DZuRPmTbW5gK61dgJWz05GoOzs52I+em3s9OnTh/nz56PrOq+++mqmtUMsFkPqpqR5MRCJpcImmmLYqko6zQWZS/pCksRsWmD6BphUdVvtB6djmKX4So/OvFcis4vWsyMb2XNoXVPHJrZ0LomcMJaa1Iui1k5uGGvxx/8luu5e2lacT/vqq6hf/yDRjasLOMKeYdfsiCgJ+7VgGnJRZWNF27Np5ck1D/DOw1eRaH0V0zTxCRIiQlEbO9b2Ns7W7GzGs5Nr7Ng8O2nNjrOfi/notUD53HPP5dRTT6Vv374IgsBhhx0GpDqijxw5cqsPcHuhJ79FjRkgyAj6sMxyp1nluWQqrFourvQN0DBNNMPotq+O0zCFKvwVJ6JEP8bUWzD1tqI0dgzdxGOZR5gJk8bWDurKSwo4qt4Tj6io8W9Q2t/E0NbhrziVWPvOlFYHNr9zAdFyspha1y5BS8wDwNRb8eqtxNo3FGp4PcY60fLKErG2dgQxhGlEkf2jCFXtm5ON5exrJe0ZNE0NvX0uq+ZqeAJ1BGsPAcCPVFR1dkQNTNPIZI4mohqmaSIIgqPLl1g9O7l1dgCqSnI0O94dQ7PTa2PnxhtvZOzYsaxatYpTTjkl011ckiSuvvrqrT7A7UU//5vE1s9C9AzAVE/ILHe6u07N0wPIXlVVLxpjR+nUuQQqfwpIiFJZUTYDzZ2Bh/Hw5fIGjppQZMZORxLTiGUMBUNtJNauON7YUXOKpiWiXT1ryXhkew5pi1BysrEMw0dp/d2Ypg6m0iUby+lhrLSn0NA2Iogypq4RqhiRiTAGBJlIEYQX00iaRvvKC0nHSGX/aJTEP/AFZHtRQYf9LnbPTtcwVtDnJeCViSta53uLZyedjfVDqbNz8skn2963trYWfe8szZDwSgamEce0PF+d7tnR8nRF9tr65WhAcXR5TodI1MBYgp1CxmL07OQaOyHBw+fLGjhqQvGkoLc0LGH5J79CkAelFgh+TFMj3uH8h5GeE8YauMv5RCKHY+obEcQS2gUfzWHnF6zUbE1+RZR46r0gSCAEUOI6kiimqkQbhuOzsZSYjgRInj7U/fjv7DHSw9LP17NqYQJB9BeNcDyNR4ljFYNpye+Idyj4AnIRaXbyK1mqwkFWN6ekHXbPTso40gwj48UqFnqt2fnDH/7A008/nXl/6qmnUlVVxYABA/j666+36uC2J0s21OIrPxF/+Y8x1OzN0mkuyFyyYSyrZ8cax3fWhbYpdCX1t46bGkkzNe5EEQqUc8ccFjx8taKxqOLc337wLLrajBb/Al/p0ZTW34u//MfE2p3/e3QRKCcMRCmE5B2IKFfgF71FJ1CWJclWYweyNXfS17vTw1h6PHsv8nuTvPX3acx/cxqxDalSJsVSEiCNrBlI3sGWJSLRllYgV7PjrOs+n2dHV5OYpplqoqupVFrSz22aHcv3KrZaO7327DzwwAM88cQTAMyaNYtZs2bxyiuv8Mwzz3DFFVfw+uuvb/VBbg/mrg6wz14pcayW1DOzJceHsTovJOtMwl57w9k3wDS6ZhBb9yBacimCGCRe+yt8cmVRenZiUfsN2y/IJJMaixs3snO/mgKNqnekQj8CCF7K+v+YZCx1UyyG9PPccgzJqP0c8gsysXgxfI8cgXLntZBsexVD20iiRcQ0b8Mry0STquM9OyQM0vPr0toqlreswzQNDD2VrRgQJBoTzve4pRHlGsJ9r8XQWhFELwgBdC0l67Brdpz1u+TT7Dx17aEYWuqaGHXQ6VSVZLsI2MJYlrCXZhg2+YTT6bWx09jYSH19PQAvvfQSp556KkcccQSDBw9m77333uoD3F50dKaeQ0o7IkspY8dpJ2ouaVe3VWhWjJ4dNaFjaC2YeguS3kLMiFCS7MDQStFUHdlTHLojgGik64M0LHj4YnlD0Rg7ux37G1o2HIyurKJqQA1rv20FiiP9PDcbK593UE06/7rIraC8fukcEm1fkmz9v9RCMYiuGkXj2RE6Tx3V1AmXBCirG4quGiTiqWui6MJYnRmXolyeWZY2rItFs5NOPTf07DUSbWmkanA2IyufQDn3OMVAr82yiooKVq1aBcCrr76aycYyTRPd4YbBpojE2zOv1YSeCQs5P4yV9uxkf8pibAaqJnUEKYQgpXrLBBt+R6Tx9yjRj4vOuxPP83AN4eGLZQ0FGM2WEY8oiHI1nuCuhMq8+MOpG15RaHYMe/inZfU7KNHP0OLzUaNzUDreo7J1fgFH2DNys7Fa1nyWNXQAjBjxSCLjyXXytW6aJpIqoCWXEm2eSevCtzn0l/dyyC8fIVj9cyAVxooratE8RD1mV71K2rD2FEkF5bTx0n/UfpllgZIqW+aotQt6MXUXyKXXnp2f/OQnnH766QwfPpyNGzdy9NGp0M8XX3zBsGHDNrO3c4lEU8aOaRoocSUTm3TyD6obRqapW3cCZafP9tIoSY1Q7a8AWBSdQ92GBwEw9XaSUY1QEfXHSsS7GjthwcPCteuJJVWbW9ip2GrsmBtRo+8Rb16FltgVXRvt6OasuWGs9asfBzOJKNdiaE0A1Hv6o+rOzlTMDWO1x1sz7wPVv0D2DUVNGJn2MElVc6xoVE3oiKaAEl+AEHmfef/3PuXhEP1GHprZxlpFuSzo7+5QjsFjdD130saO19F1dqy9sVLnyiHn3YVpGAidxk9cUZmzbA2yKLLXTgMs2xevZ6fXxs7dd9/N4MGDWbVqFbfffjvhcBiAhoYGLrrooq0+wO3F3jtptK38NZhJ2vreYvHsOOtEtaLm6QEEFFVV1TTW9gpxuYQO/0iq5Fpk37CiSz9X4jpqfC6C4EOUKhE91YQFD7puMndVI3sPqy/0EDeLtXqyGltJ8/LHABDEMPF2hXClcx9G1gmKqOtgpmq3CFIY9HYwE3iNOLGkSlnQucaOktP3LlT7Y3RzPKYewRPYBUH0oSaNjGfHJHVPsE52nELaI6gryzLLqgeOzlRQhmx/rGIxdsSOz4glvkUXRLxyHxBENq7sCwwpOs2OrhmsWtBMSaWfqv5hAl4P1514UJd9rXIJbUcXKHs8Hq644oouy6dNm7ZVBlQoVC0JZkocp8QiGTek05T0VrSccvJpfFbPTpEIlK0aiqgYpq3yVAZ4UjOKYgtjqQmN+IZHMI0IglRJ6YDbMj2BvljW4Ghj59W/X0XjurWExXK8wV8AUN5/UGa9oa0j1uF0Yyd7Lkk6BKrOxjTiiFIYw1AQkFgh6I5/qNrbRYhAHZ5glW2bZCy31o7mUGMnZTwHq6ewMP4lP94nTEl1PYIg4PVLKAk90zKiGDLlDN1ESC5BiX4IQFpWbarjgTNt92PFccZOV83Osq82MP/9tYiSwGFTRuMP5fc+S1LWa6g7OOqRjy2qs7NkyRLuueceFixYAMDo0aO59NJLGTp06FYd3PaksSWCKI9CEANompTxlGiGs05UK7lu7jQ2Y6dYBMoWYyeJThLL+2IzdmJJTCNVtM7UW9HVdYSlEABfLne2bmfNkq/wJluISSV4OzWK1QMGM3y/S1i72IPoqXO8SNk64xQ1GW94fwBKqv10bEg9lnStyfEP1dxGoEq867WsJHRb9mVC1Qk70H5Le3YEMUh7eChjDj2K9vWrWPjeU3Q0LkGQxxIITQTg7XlL6VteQknAuaFrJaFhGNEuyzWlGdM07Zodh02Y82l22tfHgZQR174+3q2xY/fsOOt7bY5eGzuvvfYaxx13HBMmTGC//VKiptmzZzN69GhefPHFTK+sYuPtueu4/Je/Q1dNZJ8PD0sB552oVqwzv2B0Na/96Tzqxx+Mt3ZiZnmxeHbam5YR3/gvBCmMT66g1ds3s67Yau3oioYc3A0t9jlgoHS8TWXNyaDC6uZ2mtqj1JaGCj3MvJiZrIzUzVqUBAKlIYbucSxNq1PXRNzhtXasnh1r/6LSqkDG2PELMlGHZ/5Y7z2SmQo1pIijJddhGlHam7Si6Hwes4RFNTlljKqJCIs+eBYAbzhEILw/MgIvzlnErK+XcPj4YZyw5yj6lIULMuZNocQ1ApVnYJYdRwPrGRKIEG2TEeVq1KSO19r13HGeHbtmZ/3yuayY8yDxjmYwVT7/zyBGHzSJgeMP7rLvD0qzc/XVVzNt2jRuu+22LsunT59etMYOgOyV0FUNJakjB7L9pXTDyNswrdBYhW8Vi/+PFqUZQZQIH5Y1dopFsxPZuBIl8g4AgZIDiXuqM+uKzbOD7iVQcRodsc+BVHn8oJG91L5du8Gxxs77gy6gNRLldE8q2cAf8iAIAoHSbBXumMMzsqzhXTOZvbGXVvtZsyj1OoBENFk8RhuKjq6sRpBK8cjLaWu8D4D1y3+Gb4jzr/eE5ZwxvalQSLC8T2aZobeklgke2k2FhKrx4pyFvPbVd8z42eGOK9mQjGuIUglIJSTkEHXDB7NqQeo7JKMawYrs9aI57DfRc9qpdKxfRWTDp5ll65etYP3ggXmNHc8PKRtrwYIFPPPMM12WT5kyhXvuuWdrjKlgeHwiyWhn6nnY/qM60dixnmxSogVVjdK2bjlV3qz7VymSMFYymq1zlBD9DIp8TEfzvzD1dsIVNwJDCja23mDoJoIOSGXo/tGES/qAMQjBTDU6TKCzYn0r+48ctNljFYKkboLgISClUk/9JSl3dqAke/N2emFB683cTKqYpoogeDI9vUxTw2/E6Ig4uxu91XOrtKwn0nAzALIvq9tRYm1FkX0Z61BQIh8iSuXI5an4qD9cwZG//gcr5xus+TZ1n7rpxEN4Y9lS3pi7hKSmo2g6/1u61nHGjmKZgKmCgc8S9klEVUqq/IiCgGGajvbsiKJI0lJjLk2keW3efa3PQacYO+mM5M3Ra2OnpqaGL7/8kuHDh9uWf/nll9TW1vb2cI5C9qV+SNMw8Qr22KQTo8fpmL7XSCDoKfd8eb9hdrd2kYSxgpV7EaqrwjQirDVjDIp+iqGk6jklOjYWeHQ9J90XSxBE2qvPZdBOfelYHgNS6ecJU2f5hpZCDnGTqJpOSMjeuAOd9XVEyUSSWkhE1tK+vhYY3s0RCo/VSIismk37yr+D4KFp6WUkO74j0fw8AaB95SWwx9jCDXQzWL00WrQ18zpcNZxY+9hUyDc0tiiyL5PJJPHmJ8BU2am9CjgBQRCoHTKelnWNCEIjAKWylwuP2Ju9htXz22ffBJyXzQTYWndoomHTuGRr7YgkVd1xUojcdhEj9v0JS+f2IxltwdCaqK4fxf6n5y8QbKuz45AwVk+Nrl4bO+eddx7nn38+S5cuZd999wVSmp0//OEPXHbZZb09nGMI+yVaV/2TWGsHkncg/r67Z9apmo4TrZ30TV0R/SSOvIvTdumDrqlsFK3tIpx3o8iHofuRfYMBaEt+Q0IMYiIiSqUo8eIpIa/ENUxTBWQS6PhLZNL+gwrJzwYtwfL1rQUcYfeYpomi6VQKWYVruphgw8KPaV46HQA9eTSGfhii5Lx6LmC/+RnJlKGJqeIPBpB82fBhIuJcoxPsD3lRCOIJ7YtpRKgevDetG8ajJnVEnxefJ/vgderkJtmxknSHZa10oG2dNf08HbIOeLPLnOJBsJKIJlFjXyKIIUzJxB/yYBpJDL2V9g1+oBKvJJFUdUd7diRRRJS96HoZsq8MfIPRNC+SnL95tBM1Oz01hntt7PzmN7+hpKSEO++8k2uuuQaAfv36ceONN/LrX/+6t4dzDJIo0LYm1dfLNGL42CuzzokXG+Sknnu9lFQPRpQEOpqynhCnurVzSWdj6aaBjsmi0G7sVH4y/TorKmuKjux1XkptLkpcI7b+QbTEIqqkUny+OzPr+odL+a61lcaWDhKqht+zRcmQ2wxFVRka+4ZqMYyqJ/AERhMIp256JTXZdHldXUc8oji20KNtxmmGkXzDMY0Y4aoavKEOEr6dEMQQ7UKw+4M4AKuHyufvT7D6HAAGjh9E7KNG1KSOEtdsFdMdm30pVhKoOpdkcglGnT1r1xfsauxYPQhOq0AMEGtvJbb+rwBUhXemZW2Y9lU3AtC46GzG/GhkJiPL2ZodAS2pW5u3E48omIaJIHadzNiysXRn1NnpadHGXt1tNU1j5syZnH766UybNo2OjtSctaSkZDN7Op+YJfXZNOJ4BeeW+05jtWgDbSLP/f5WTO1r1PhapKpz0QWPY93auaSNnXTKuSFIxMj+3ZMxrTiMnc4eX5hJPNpGyqorWE0DpmlS6089XE1g1YY2hvet2vTBtjOJRIw92t8GIOkfiScwOuPZCVf2o7zfPsQj5Ui+ocTbHWzsWCcBgT0J1+1OoMRD3xFjKPumHEPdGYDGUKRQQ+wR1pu4rlhaRwRkvAGZaGsSTTHwWQwDp3p2IIQ3PJFkaHfkgdnxxts30L5uLkrHN0j+ESidfbKsdWo0h3lGABId2fZCmuynpCor4Yi3p6p0p8W8zvPsWOvsiCgx+/hMAxIxNTPRsWKrs+MQz842CWPJsswFF1yQqa+zIxg5aVTdZMRBt7L2WxVBDBE1rcaOs07WNNZx+ddBQtmAGk1VKC1TN9LsrSsaz06s9VsMTSRp0YvEzezYEzGVULkzH65WlLiG6KkBU8HQ1vHNvy+jo6kBf/kJlFUflNlu+foW5xk7yWTmtdB5a8hqdmTGHP4bvnlnDeDshqBpz44AaMnUa1+wU2gd8pAOXiXjzr42rJMsPWk3dnyd2aKmaeI1nV9Xy+j0AuimQdCSQLHqm/f47LlUZm+g8iyS8ZGA8z07mubFV34CphGlo7ycin4DkHzDEaUKpM5wfNpgc55mx556vuKbD1BjaxCkklRLFXUt3320jMETdqe0xh5ydGKdnW0Wxtprr7344osvGDTImdkk34eyfiNZt2wDALJpqQvhwIsNUheRYBrsEvkYVY0gCDIg4C/tj8dMPYyKwbNjGCaRxr9jaBsQxBDUTgEgjkWLUCTp50pCI1RzAQAfd7zJqMangVT6uc/I3ihWbGgtxPA2iSF4+KT0MMaK5dR46oBsNhZA0JqR1eHctO309epHzrjnfaHUrS5oma3qCWde12msN3FrOxVfQGbdtw/Q3vgFph6lRH04s86pkxuz8wGrYRK26HFCtvTz5sx17vQUZ10L4S87Bs00aKtaT0lVHeUDp6MpBt5Q6hxLh7Gc59mxa3bmvn4v8fZGBLEEf/mJxJsf56uXwRe4qouxY9PsOOR36akx3Gtj56KLLuLyyy9n9erV7L777oRC9noh48eP7+0hHYPHl/0hPaZze5uk0QyDkN7GztE5JKJzkP1jKK3/EzWDq1j33UeAc29+VrSkjqGnQgqGmNVRBCKfkEAAwUMyel6hhtcrrFVu495SBFFCEMtB8EDWccIKB4qUNUFieXAUu3qG4REDmJj4g5bMLGutHSd7djpvfkHB0nep83tYv4+hOONm3R3pMJYsiayd9wDx1uUIUgmCeC+mEcPUUynDQiIbjnPi5MY0TUxdB0R0TFsj3PK+OzH2sHNY8oWK5B2aSemWbWEs5/1O6WysBFomtOMPe4g0J0lEU+u8lmbSTmrQqpupv6coCIiCgJJIheQEMYgoZ73N+dLPnZiNtc2MnZ/+9KcANjGyIAiZH1N3qGHQE6yaENnInphOdKNC6mZYrmXFyJJvKILoo3lNFK8oohhGUWRjJRMavtJDMfUILRatVN+Ot0kaMQSpimTsnMINsBdYU1Lj/mpOv/19PnhmKa3rYigxjTK/j7ZE0pEZWemHa6jTSEig20SKwU5jxzQNoi3tXQ/gENI34aDgId78FKbeQeOiGnY57EZ8QZn4xn9iaM3USAJwWGEHuwnS9x2PJJFsXoGuLAcEPP4A/pIa2psqEMQwgmJpreJAzY6hm3SsuRZTb8UrVRLw/jWzLlRRx66TLqJp7Tcko1omtOiRnDvZNE0z42mLm3rG2+EPpYwdXTXQFN3WDFTTDVsLiUKS9siIYuq5PWjXyaxZuAZB9CF6+uItOZTqgQMZtMsBXfaVHehx22ap58uWLdv8RkWKEm9ASyxMNQ3Us/U3nPKj5qLqBuu8A0hWn0+ZthHJnxJeGrrJALmEpUpbUXh2dMXAX348AEv1jQTEJuKKRkIM4umcwRZLywirsSP4RERJJlDioXVdatmIqko+W9NASzROWyzhqEaUiqYjIhDs1E1FTLv3JrJxGZGGG9GVJvTYoYAza9RkPDvIaPG5GNp6mlemWg54gzJqfB6mvhG/6Mwq1mnSD3mPJGIYOiAgSmFEUWLUgb8ikUxdMz5/GfAt4ExPrqEZYGqkYoomAW/Xvku+gEwyqnWWbjAdHcZSEzrpOnYJtEwzTVthwYjapRmoY4ydzjCWJAoIgkDNkKPZ2NiYWR+oPI1wbSnVg7r2uvxBpZ7viFqdNEs/fJToulQX20Dt7ZnljvXs6DqGGKDKPxrJUgQRoF4sYSltjnRr56JY9AhJU6c8FCCudDCv5Ecc4hmAKJWRLBJjp3n1e8TW/w+kckJ9U8antfpwfUkZn5FqBrpiQyvjB9YVZJz5SKoKYdPENFMhhw5DtaXIewMl6ErKtZ2MNXSbnlpo0tk7AUHGNFINDuXO+jq+gIwohdH1jYhGAkVR8eZ5+DqBtLDVK0qE667HNA3KOgsJW2vToGY1GE705Oq6ieQdiGlEUMSwLYyVxtuZfm7oJppi2MJYTvPsJOMa8eanUaMfExT8+KvPBiC64T0ija9j6q2sW3pjTjNQ59RqSxsp6WeG9f6bprsq6XaBsjNSz7eZZ2fGjBn06dOHKVOm2JY//PDDrF+/nunTp/f2kI7BG8zO9AQlW8jOaRdbGk03qBWCmZO277AyVi9chBr5lDplBf18g4gGRxZ4lJtHTWZnowo6FaEADS0drPQNwOMbl1qep+OzE4m1LkKNfQZAqH+qxUXAIvLt4882NVyx3lnGTvuaRRy97s+0A96SQ4mWHkp7LIG/sxFjsKwGUQ6DUIooVZOIqjZDzimkb8JBQSbc7xYwYux6dH8gZSQEay4CwcMqUyOmas41djrvOyFZBi1VlTtQkqo7ZTd2si+dmI1laAahPpcAsE5vzevZ8folDK0VQQqTjGkEy7PnldMmm0pcwzQimEYUmShCZxFXU29DT6aar7Wvb8DbWSMMQHHQd9A73VLpkFS66juQSmE0u09AkCyTG6cIlHtamqDXDZ8efPBBRo7s+gAdM2YMDzzwQG8P5yj6jNgbX9lR+MpPRBSyho/T3KhpVF2nzuKKrxtaRjDcTrLtJYjPpZ/aWBSeHTVp9+xUhFKhHRMwpNSFWSzZWFoiq6ESQ1WsX/41axc8SWzDI+jKGirk7PRu+XpnVfBVVMtsTpCJotIayxr9gigy7pjHKOl3I4HKnzq2IWj65hfEgyiFED011AxMNTb1BmREuQJRCuMXvbZmoG2xBE3t0YKMOR/ph3xIyD7400ZOOvUcwLCkpTsxjKVbis9pmLbqyACfv/hnFr5xBh1rrsJQ15KMq4iCkHmwOu3+m4xrCGIYUa5FFwIInV7DUEVnrR3BRyISsWl2elr4bntg1ewYhm4LvYcrUvcnJaERaWlGV5O2fYtZoNxrY6exsZG+fft2WV5TU0NDQ0OvjjVjxgz23HNPSkpKqK2t5YQTTmDRokW2bQ466CAEQbD9u+CCC2zbrFy5kkmTJhEMBqmtreXKK69E2wKh3oBxB1Ha71T8ZUcjkbXKnerZUSMtDFAaMPTUDbqqf4i+I8Zk1ldrbSRVHbOHjdIKxZp5r9C++io61t6MP7GIilAgs07LGDuq47+HoRsEqs4j3O8WEjUX4QmW07Tsa5b/7wnU6Efo6hr8RvYhtWJ91wZ8hcQQvUR9Q5B8wxDlaqKmSlvM3qrDWmjMqQZo+uEYsrRNSVfpFUUhY0AHBJlIImWwNbVF+MWDL/CLB15g0dr123nE+Unfd4LW79Fp7OhaG4mW/yO+8Z+0rX47s96JkxvDUmdGxyCY49mRvQHMzppahtacycjK1Klx2P1XiWkEKk+jpP/vmNv3SgRfqt5c/bhDKK2/l7KBf6a0z49smh0nfYeMZkcQWfrZy3z37hm0r7ocJfoJZTUBku1v0r7qEl64+SgaF8+x7Sv/kDQ79fX1zJ49myFD7F2oZ8+eTb9+/Xp1rHfffZepU6ey5557omka1157LUcccQTz58+3pbSfd9553HzzzZn3wWA2PVnXdSZNmkRdXR0ffvghDQ0NnH322Xg8Hm699dbefj28Pil1sWnZB6vTikKl0dd+TXD9/6MDCPY5i0DpLgwYOZjvPr4Q0dOfDYKMoa9BMwzbhec0Eh0bMfVWTL0V3dQyxo5gGij6BsRkDEMNo6uGo6soKwkdQfQiiX2Ii36CPg/himyYytSaUWM6fcpCrGuLsmJDq6NSUikfyMbq8+gnVwMQUZbQGrUbO9bwieLQonxpYydA6qHq8UlIllm26RFAT3WhjyZTxs4HC1cQV1Lf56sVjQXvsm2YZtZoS24k0fopghRGU/YD+mHocZLtLwMQ86jg2wNwZjaW1bOjm10FyiU1AwlVDiUZDyOIgYynV5ZEUJ3n2bGe9wm0jAcqVJ4aP0AiquVodpzzHdKp55IooMTaAQPT6ECSJULlPgTBC2bqus9NP3di1/Ntlnp+3nnncemll6KqKocccggAb775JldddRWXX355r4716quv2t4/+uij1NbWMmfOHA44IJv2FgwGqavLr214/fXXmT9/Pm+88QZ9+vRhwoQJ3HLLLUyfPp0bb7wRr7d3mgKPv/ME1TPhS8e463IRNq7OvA7W9EcQBMrrggQr9kBN6vQ3NQR9DUlVd7SxYxgSglSOqUeIib5MGKtGWYO+7i9EAV/pUSSiPyLsZGPHdhPUKfUGqB06gYN+cSdzXmlHEKuIdygMqqlgXVuUuKLS1B6lT1l4E0fdfig5Hc/zeXa8fssN3KE6qvT1GjBiKImvkOUyIs1VhCs7J2NCK2p0CaYRoXnVLjCkH1+vXJfZ3wkaEeuDJJRoINn2bwCiG0uBPfCHKzLrdaU9I35VHKjZSUbaiK3/GwgegnI1XvlQ2/ohux2BN7Qnc15ZAWA3dnDG72HFWnk7YeoZzaS183kyquKttGdjOQUj7dmRRLzBEmTfQHQtisdfTqDEi+ipQZRrKa3thz9UYdvXGsZyimenp9qhXhs7V155JRs3buSiiy5CUVKzIr/fz/Tp0zONQbeUtraUW7+ystK2/IknnuCf//wndXV1HHvssfzmN7/JeHc++ugjxo0bR58+2UqcRx55JBdeeCHz5s1j11137fI5yWSSpKU0fnt7tmaI129xGSORQHdUvNWKEBiJt8REV9ZQPiilSRBFgZqBJaz9rhW/IFMjBFE0DXCekDRNxYBjicd/hGmaNCUXUhHunB1JWe+eobeRjKmZmLITsRk7pkatVyZQWk39mB+x6NP5xNoU4h0qgweW8+nilKG6fH2LY42dGJpNswMQa1tCfOOTmEacpuVHMnyv47b3MDeLpht4EEFZQ3zD34lvgMWftDDh6F8CYCpLiG14EIC2pQb6/gcwb3VTZn8nhBysY/BqWR1RsCx1b/T6w9QMv4p4hwdRLsMnrCWp6o707CjxCGrsfwD4A2PzejI9PosRnUyn3GeL8jkJWy0tS+q57JWQPCK6apCIqnhqnanZSf89JUFgp72OZcEnAzENKKkOECjxIPtHUtL/dwzbs5ZBE+zRGqtnxylGaE+9Zr02dgRB4A9/+AO/+c1vWLBgAYFAgOHDh+Pzfb+HkGEYXHrppey3336MHZut33H66aczaNAg+vXrx9dff8306dNZtGgRzz//PJDSEFkNHSDzvtFSO8DKjBkzuOmmm7osb145j2Uf34KajOIrPRRfcGcSpu5Yz47HM45AZcqYqxyc9XzVDEoZOwD1YtiRcXwr6ZubIAgogkFpwI8AxMUQyfBYSqhC8g2zlcx3Im1Na1EinyDK5aiCRMCT1bYFSrzE2hTUpM7A8rLM8hXrW9l7WH2+w213VF3HR+oBkzA1DMwunh0tsQEl8h4A0Y07b/cx9gTNMDrTzi2TmEDWoPQEs39/JdrGknXNxJWsUNkJIQfrw1Eo3ZWgMQBT76B6cOreKIgiZXW7oiipZsxhYQNJNe7IbCzVMrE0xfyPHI+/q7GT9ew46zvFIxFiGx5FEENUiyKiaCnHoi8k2b6CZHs78k4nZxY76Ttkw1gpw6zzLR6/ZGsJE8uTkeVEz45qbCPNTppwOMyee+65pbt3YerUqXzzzTd88MEHtuXnn39+5vW4cePo27cvhx56KEuWLGGnnXbaos+65ppruOyyyzLv29vbqa+vB1FETaR6Y5lGFD8ybSiOssrTmKaJP559MIUrs8ZmTX0IPbkCXVnJIFMhoe5VqGH2iPTNzTRNFAyCPg9+r0xcgfX9zqQ2mZrN2lIkHciGFV8S3/gQAMHSIwh4s2Jxa/p5naXEgZPaRiTXfI2w4R1iggcjvD+IdNHsBEqyhoKa6NjeQ+wRmm4QREbyDsBfcTLltQI1g8dl1ger6kmUn4QghUiUD2SuJYQFzngwWWfNXrkWTzCVOl9eNyC7PJi9fZfKXjYSd6Rnxxeqo6T/rZimynIh/zlj8+wkssUUwXmenUR7C2o0VY+tj3+YzdsRb36VRNs3APi1H2eWO8GATmMtKmj1Unn9Mn5r/7s8tXacWGdnm2l2AP73v//xzDPPsHLlykwoK03a49IbLr74Yl566SXee+89BgwYsMlt9957bwAWL17MTjvtRF1dHZ9++qltm3XrUjev7nQ+Pp8vryfK6y/B4y9H13wIYgivIIHpTM1Ox8YEUmdLiwYjilfO/pSBEi+RdXeAmcQrVROPngWF1VtuknSdHYVOrYVHxueRiSsaUd0y404W/iG0KWJt2VBIVArj7xRiJiKt6Opy1Ohi5MBYykQ/siiiGYaj2kbo7Y1I8a9SZVsCo0Esoz1uTz3ts9NYwn2vRxCChGtrCzLOzaHpBkHBj+Tpi+Tpy5A9+1EzODvWkqo6omVHAtAhq3y30u4BdsLkxmpwecxs2MdnEYj7LN6QkJR6SDnRs2OaImKn6F0T82vulnz6FNGm2Zh6K8rgGYBzw1jJaNZjqAh+JEtYzhuqJt6ZZClHstmWTtXsKJZ7qscvIXtEvAEJJa4Tz1NaIt0HDJxTZ6enLap6nXr+1FNPse+++7JgwQJeeOEFVFVl3rx5vPXWW5SVlW3+ABZM0+Tiiy/mhRde4K233uqS4ZWPL7/8EiCT/j5x4kTmzp1LU1P2QTNr1ixKS0sZPXp0r8YTrh7A3qc9QUn/W/CXH4e/06XvJKs8TdPyjZlU7EYzZnMvCqKIEEwZjaa+gdaGjXmP4RRaVv6TROu/SURTzUsDPg8BT8pQiFmNHYeHsUIV4/FXnIq35HBa5CoCnZWHP3/xTyx880piGx7E0NajxDQGVKVKG6xubnOEJwFA07J/a6Pz1pDr2fGFwvjCgxE91WiqM4vxaYZhawLqC9rndGHL7FVNaMy36HXAGVoEa+hZ1lO/hSgJSB7LLVvoQEsuR43PJUxqeyd6dgxLNhbdJB5uXPk1WvwrdGUFiUgzkPUiaIaB4ZCyE6Zpoht9CPe9Ea3213wb2sXm2and6XAC1T8n1OcKPP6sge0EAxpSWX7pv6UkiHzx0h+JbXycRNvLGb1qoMSLEv0fG5f9lVfumUL7+pWZ/e2encJfJ7ANPTu33nord999N1OnTqWkpIR7772XIUOG8Mtf/jJv/Z1NMXXqVGbOnMm///1vSkpKMhqbsrIyAoEAS5YsYebMmRxzzDFUVVXx9ddfM23aNA444IBMd/UjjjiC0aNHc9ZZZ3H77bfT2NjI9ddfz9SpU7dIR+SxCpQ7m1JqPYwJbk/mv/0n2hs+RvL2p7ns8C7ZVnLfA5A27obkHYimOjeDSVMSxFveAMDwDoXKSfg7PTsAHZpCp82Zt6y5k5D8g/GVpgz+FmVRJsU2VJ71MBpacyojq7qc5etb0Q2TNc3tDK6pyHvM7Ums30Qq2vZCEgyaBRm0VbTFEl3S470BGU1RHJ16HrBoQ6xZMgAlJdn7QktLPJNynsYJxqfVmyEk1mEYAXyhCtvv0DD/KaKNrwAQDl+a2U83DNsDuNDolsmi2c2wQpkSDSLJaGpyZi3Kp+sGogN6S2mKAchI3n4kjFI6VNNWVbh64C40rUy50T1k+9454ZwCu85GEgUaFryJriUQPX3x+H8BpIwdQ1mNGv2MDVHo2LCa0pqBnfs4ULOzrersLFmyhEmTJgHg9XqJRqMIgsC0adM45JBD8gp/u+P+++8HUoUDrTzyyCOcc845eL1e3njjDe655x6i0Sj19fWcdNJJXH/99ZltJUnipZde4sILL2TixImEQiEmT55sq8vTG6yptf7OP48TPTuxluVgJtCTS1kn2LsEA3gH7o/c6dJWEnkO4BBibdkqwoYUxCdLSKKYqbJa3fYxHYl/YurtdPS9Hth0mLOQ5GZj+Tu/Q82Q8Qze7XgaloqInj4kIiqDasphQWrbFetbHWHsqKaEx5My1kQhAVpq9hZNqoT9liq+fjkjtnZafyy90wsQFDyYpoEgiPhC9ttcSWlnhW5TQ1YjXY7hBM+O1RMQWz0DzATxDXXAfzLL/SXl2dd6nHTGpaLpBLzOMXYSkY2osa8RBA+ebsJY4w4/l+b1E1ESQQQp9fvItswfZzTSzL3GgUw2FmA71wSLvtcpzxDdorOR0dG11MNBEEOZZ1+wxIMoZzOiY23ZIptO7Hquaj3z+vXa2KmoqKCjIyUy69+/P9988w3jxo2jtbWVWCzWq2NtriJufX0977777maPM2jQIF5++eVefXZ35PPsOMUqt+NFkKsxxQCa4LGdhACyT4RO17aTwz+SXEqo7lpMI0qDqWcMhHTzSdGIYqipNO1ExFntFXJJ3wiNTqF12rPTb+Q+VA/ag1cfTAkX4xGVugElmf1aovHtP9g8KEr2PLEW4WuLJWzGjqGtQI03AQZKcqxNR1JodEtfrNj6v6IlFvDavaUcN/1JfKFyAAIhL5HG29GTi6lBhD4XgcVj4oSQQ9rg8ptGpsCb7LPLBKoHjWPttw0IYhjFUwPJlEYkqWp5+08VirbGecTW3wdAuPbovNsEy2rwhzeiJhNZgbK1KJ9DHqzJnLRzwNaE2epFtBo7TtHsGBZvjCjJTDj+ERZ/ugzIPvsCpV48wd2RA6PZ9cgxDBqXjdjYPTvOCC32NPLS67vUAQccwKxZsxg3bhynnHIKl1xyCW+99RazZs3i0EMP3fwBHM7Kr54n3vwNYOAvOwZwjgVrpaT/VeiqQbORQNQWd3Fbe/wSameHQM3Bwl5NE5F9gwGI6s0EvKkbdtroiYs+QEaQQmhK/uZ0TsAwdJLRdkxTJtlpZKYNNkj9HqIkYOgmiQ6VoJw1HpxSGsAqOJQt2pDWWIL+ldn2KQ3z70JLbESQylHipzjK2Ml0PKez47mpkujYiOzLVl33+iXorCckYOAxFQLB0owY2wmTGzXzPUQ84f0x9Q5CVXZN44Ax+/PdnJTwN+FToFMQ65TzKY21v1J3qeeQzcjSNQNDN2wTOKcYO0pcQ1fWYhoRDDOBKBg2z44/5ME0khh6K2qztQq/M34TawaVJMmIYjmSN+UtT3t2AiVeBCmEQAglkTOJtnzXHV6zc99995FIpGYa1113HR6Phw8//LBLeKlYWfX1qygd3wIivrJU6qBTLjQrRueYdExbbDuNLyijmAamEcWIOselnYvVEFNMHX+nMDltKHwbnMChdeegKwaS37mFESMb17Ju/lQQfJihiRAeZ+sBJAgCgRIv0dYk8YhCmWzpveYQF7fYtho1thwEGU84W9ahLUekLHtDaImNmEbMceUA0teqjIgo14AZJ1gqIFmMS0EUwNsfyVTQxRAiBrsMquP9hZ0VfB3we6S/h0cMEqw6G4D68dW2baytO7yWnmtOy8jyhQfiKzsOTJVkqPswtL2woL3FTU87W29rlLhGsuMN1MgHDAIWVP3MptnxBiXaV18Gpkq8uR+Un5TazyHjz9XsWHWQHouxkyaWk34u236Twl8nsA01O9bqxqIocvXVV/f2EI4mW3zMwNdZbckJMz0rhmFmCkHpdNP3KtFI+8rLARM5uh+w3/YcYo+xpj4m0Ql2enTSAmUEAckroiuGo8NxkebO9GUzidYZEvHndHcOhD1EmjvQFC+yJZ3YKTfCknWfENuYKuNQUn1DZnluFeXanQ5n3dJGBDHouGag6Zu5JAgEq8/BF5I58ryxXbYTq39CUJfRTIOkMo/xg+r46LtVaLrhiOs97Z0JCNlrO9eD5vVJmZ42spE9n5yWkeUJDcJf3jlxLMmfGZqMtRNr+RQlshFRrkVNjnSkPiQZ0zD1bEVrRfTbvOpev4woVWBoTRhKNuzuBAMa7KEnSRRRE/Y6O2CvCRbPKSzoRM+Otq0qKO/o7H78pXz43AI0xUdE9IPunAstjWEZj46Z19gJlJaR6uwFZh4RplNob1qJllyOKIVRDIWAN1VwL516DiB4UheYmtSd1TjTgq6LSP6RmFoLipQSG/ssYazZT/yWFV99gK5GKR34F3s83yEPJ1O33PgsmYy5VZQHjD+Rts4GgU4LkWZK4XfmOEtSfq+mLpuggyyIyIiMq++DR5I6jZ3CX+9pg8tvuUV7c4wdQRTw+lM1USSbseOs30RXLX9PKf+1G21pZPVXdwHgDf8INXlMjkC58L8JpDw7nuBuiJ5qVqrrOo2d7HcSBAF/2S6o8TYkXyWCaWAKoiMMaLBrdryJDbS2N6IlZSS5LuNZ8wVlRElAiSxgw/IoSz6dz057pYxV6/XklDo728yzs6NTVT+SYIVJtCVJwOwU+DrkR02jxBPEm2eC4EGUKpFrutYnCpVWgHcQsliC6BmU5yjOYNXX/0e08UUA5Opz8HdWHbbqXaxnqZrUbf3LnEJpzWjCfVJVuVfrzfiFdYgWo0xTEuhqSthv6q2QzIr+nKKxaAuPpi+DMU0Nf6gKSHmrrMbOknXN/PXtzzhQSFX0TTos/dwaxoJUbZq8eATolJL0CYboX1mKVxaJK87w5KY9AX5LvSBvTr0gTUnQsvy36Go7orceylKNmZOqs34T68xb7CZzz+PPVhU3jQRq0p595ZQJZzKu4Q3vDezNV8q36GbSdp0D1A6fTEtDKllHSH6DiekgzU727xjcOI91S14CIFx3AZKc8v6nQ+6tKx4lqjfz+caKjLHzg6qz80PA65eIAl4hNT90ws3PihKPoHS8A4DsH4VH6to2I+ALoPa5jDIxgCmYjvWIJGPZKqMxwUdtp84lHQISTY3o+tfQWjsQpHLUxChHGjtW7UrC1Aj4cmq7VA/AF6pF08KYpoIRz16gikNc3O2BYfikVOO/kKUthNXYeeWLb2lXk5m+sk7rfJ7r2RHz6NkARG/2WhjbpwZBEDIeUieEHNL3nNqOj4gk5iOIJSiRaUB5ZhvJ40NLNoKpYWptSAjomI4xntNY6+yIcv57kD9cyaDdzmXdcgXJU4ea0LuknjuBfKnnuckh1oysADJRVMeEqm1hLC2bPe3xl9q2C5R4EKUSdL2ZZLQNw9ARRQlBEBAFAcM0HVNnp6dGl/OeGg4gt/O5U2YVadRENrvBEOS8YSyvLJHoTI0UTAFNMWwCQKcQrtqFSLOAaUSIiv5MfZ2sZ0cguuIpACTfMJTEeYS6OVYhsd0E0bvodXY79lf0G3M2n/4nleZpJLLnlFNmfdZKt0GLsWbV7Hyzal0m2wwgGXdWhlz6BiwYEWLNz2DES1g250CG7H6UbTvRaCS2/hVMI0r/sn2A/bLGjgMeTJnUc30jupISTks5+nxBEPD4q9AUBVEqw9/5YHWaZ2fD0qfpWPsGCB585Wfn3cbjCzB4t1Np3bgKoNOz4zzNjlU3mL4OpBxvlc9i7AQFmaipOsKABrtAWa8ejb89jKFF8YftrZUCJV68JYdgGjHGHLAzWMrEyJKIouloukNSz13PzpahJqLoyiq0eAOipwa/IDvi5mdF9pcRqrsWTI31qF1q7AD4PBIJ0/pQ0hxp7JT0OYC25lSTxpil6nDaWDAECUQfGElMI2oT1DkJxeLhSJpaplWElUA4exO0ekScIii1asG8PhmfRyKp6plsrNZonNXN7ewcW0h704OYRpxQeCrgnDCpqhtICJh6O2rsU9QYNC4OdzF2+lbKrIilxNhV6jAgW5jTCdd7OvtINnXSKuRwZXWX7UYd+ldWzE2Jfv3Kd0RN5xk7uhrFNFKi3k0VdrZnY+m2AoROkRLo6Qe8kFZEphJ1rPgthQWDggfMuCPOKcj2xQKgamd8G1KdCIJlYdt2wVIv3vBEACoHDkGUst8p5cnSHePZ6elksdfGTjQa5bbbbuPNN9+kqanJJngCWLp0aW8P6ShWz/+AJR/+BgB/xSn4/EMdc6GlEfBkatMk9Y14pK6za58sEzezNz0lpkF579tnbGtsMyVTz3h0rJod38hfIG2QEaVSxzYDXfTevcTWNyNIpSRK9qbEG+iyjT9s6ckUy34Pp3h2TJ1Maw5REigP+lnXFs14duZ19pDS0DH1VDPEZMxZnc81o9PYMbIuem+gpMt2/frWsaLztR5PCfjTGhEnzMLTYzCrzqK0+jxMI0pZddfGq1bRcqDzdu40gbIohhHlWkxTRchzXaTJNXbs2VjO+E5qvJn2VdcgiCF28Q7gq9L9u3h2MFuINN6BqbcyzDeIFSX7OOYat4Z8rBmhHr99ItyTjKwdXrPzi1/8gnfffZezzjqLvn37OlIH8n3wBbNaBVOP4hMk4g4zdqwqeN008tfZ8Uh4o58QTS7DNCK0Nv6Wyn6jtucwe4TVeLFWHfZbsrHMml3wdGZ7OrU/VsuaT9CSrQhSFYnw7tR4u15a3kC2sKAStRiiDji/TNNkeNPjtKmNCIIMwhOUdRo7HfEkumEwb1XK2ImLAQSpAkEMomrO8hZquo6EiOQbQrjf76jqL7Hz/l3P+8r+gwn3+x2CGKLvmJTYOv1wTTeezBWebk/SGg8PIoIg4gmU5e0N5Q/mehGcZ+wE+5yA6D0GzTQQSrvvXePxSZidFaPVpI4n7LxsLE2JYBoxTCOGz5PytOWeJ4FwCD35beq1lHqeOGX8Vs2Ox5LBl6uDtOqOElG7sZPOyNrhs7FeeeUV/vvf/7Lffs6s2/J9KakeQJ/hR9K6TkDyD8ePRLvuLF2CYekF0l3quVeWkdR1aPGvAYg0NwHONXZU08DA7BLGglRsPJDuQO/QMJahp4pvCYKHhKnbUuchVWH5q1ceJNGyGF0P4vGdhiQK6IYzMjU03UAyVTCTmGYS2eOhLNjZQwpojycznp21/qEIpUdTInjBOV0JANB0EwkBQfAgeWoJlZcTruzXZbtAaQDJk/KUKLHUTdubk/3jLWAvpvQ5IXe2IpC6EVr7LQXgwp1VoZ0WxrIWQO2uFADA7H9eTPuqbwARZcSTyGXOEyjrmpryUhlRkkLq+sgVKJdUVwEyCDJS52/iHIGyxbOjd+/Z8XeG3E3TJNrSipIowetPhbo8lm70TqCn4bQt6o1lLSy4o1FSPYAxh17GnFdSTm6f1uAYcVyaZLQdLbkUQfBgmiqy1LWJpCyJJKVs191ER/v2HGKPaZg3HdMQMD39oXSfjEDZqnlJZT2kLkanenYG7n4nG1e3gAkJY10XgbIoSix6/1nUZBRR7oOaPJmgLNOhqI7Q7Ci6jipXdiZsm0iymDF2ANa2dLB0XTPQKX43NUoEL6bqrEw/zdBtvYq6y8byBawz19Tf3zppUDS9sMZObr2gbr5HvO1bEi0vYRoRyoITQHROKYM0ZqfOJVUAtXtjR5TTv4mBkkg4MvVc8tRT0v93mH74qm1uallOGMsf9lJafxeC6Kfd7ABluSNCo5Cj2Xl/Gu2mF8k3BK//Vtt2/rAHLbGI6Lp7aV+pIQtTmHDMBUDWs+OU32SbeXZuueUWbrjhBh577DGCweDmdyhCrM1A/UiOmVWkaV7zDdHG2wAoKTkERcrfXK+hdDdGlf4YQQwSquqbd5tCYhg6erIh9UZI6YnS4StrQb6kFsVQ2zGNGIlo9zH/QmIYYURZSjUBVRryNmIMlFWjNkUx9FS6fanoowNnZGooms6aypMZJKe8IJIsUm4xdj7+dlVGkHnQ6CEkF3Rm+iE4qvaRphvIZB8+3dXZESUBb0BOlf+PpTy3Hsk5noTM53d8QFIQkIRKYHSX7WItS0i2vwJAiXcAeKsd6NlJGztmFy+Ilcr+w2he24YgBFATSWQxK5p1TBgoraWyfI3c75QqyufHNDtDixT+fEqT9sZIpgp6EpMkppHo4tnx+CQkTxA6M3qtTZjTJQGcI1DeRp6dO++8kyVLltCnTx8GDx6MJ8dd//nnn/f2kI7Da/nhfYLzUs81JZt6rgtS/nYRgOr1I+qp+glOK/4GYGgqghjGNFUMIeWOT7eLCFg8I9LyV+hY+y4AkbobgJ23+1g3R1porXSmowbyaHb2O+MmVsxtY9XC1Dalko81RBwxE1e1lNYljSgJNs/O7EUrMq93H9qPb5auobPPLJGOBJV+ezZHodA6s7F0ZTWG3kairS+aUoPs9XfZVjCXoUTXoUYTmOZo23VU6Idr+uGotr6AaibQYv2Armnb1gwtnx4FnGfsxDe8hq40oyMgCz/pdru9TrqSjU1zUZM6uubL8ewU/hoxTTNjuFm0vV08O4Ig4At6SERVgp2PWCeEqiGr2ZFMDSE0CBIRRLnS9syDzsKCpdVEPAOQ5BJKa7MZl5KDwliGadqam26KXhs7J5xwQm93KTpsxg4SumEWXLBoxR+uw1tyKJgqMU8fyrtzDcuQLomiONDYkTw+SutTJeKbjBioS/BnBMoWz47kJ51Pk4w5MxyXnvGpdNZHyZN6Xj1wNB0t61nz3RoASsSUgeeEWV9S020eEUkWKQ9lDYSm9mw/oNH9a1ja/nfisSSCVMLSNedSWeMQY8cwkBBJdryFGvmAb5tgxD5PUNFveJdt2xueJtGeEpImo7+wCf0L/XBSNQMRATozKkUpvziqz04TqBxyOUoiiCZVgLbMEcazFSXyGXpyOQIgSadscluPT0JN6qhJHZ+1Wq8DJpzWOlRWYyffc8EXkklEVfydgUinaHbS2dOKGCA47nrkhtR38uTxzIYqakj0S/XIG7HvuMxyOSNQLnydnd6cF702dn7729/2dpei49Pnfkv76q/AVPH1vxEovGDRSqBsKIHK0wBoU1dR041nR5BFjETKSHOisWO9eWidRkIgtxEo0O6toV94TyAIQvn2HGKP0JQEsZbPMAwZTQiBQN4wFtjTzzOCUgdodlRNTz1cO8n17KQZUFlKRTgIG95BMRRETz9WNf6EPajfnsPtlrRnByOeWebpxuvk8YVJ5wZ1bGzJ8ewUPowlIxCongKmSlmfrro8gEBpNRX9dmfD6ggS4NFER5xPaUzTxDRS4zEFT7de6DTp9HM1qduaThba0wap+5US+QhdWYUZD+GjhqQYyBuaE4UNJNtnY2gt9JcraPE5oxaVNRtLtJziuZ4dyIqUARIRlXBlahvJknpeaL1e45LP6auu6tG2WxxonzNnDgsWLABgzJgx7Lrrrlt6KMeRjDZj6p2Fuiydz51i7HRtBJrfs+P1QDw2B48Rp80owWnhH2uDQM1MGzupC0wSRbyyhKLprA8OZeKgQ0lEVJCcoQ2xEmtbT6TxfgDM4O5Qum+3xo61fkUg4+Iu/E1D0XRqWl8iLvgQ5EpE+deU5wn9jK3vA4DsDaElFEwjxroNzqm1o+kGkiDiCe6B6Kmjoo+AL1SWd9uanQ5D1YamUugVyVGCWFXTkRHxhvYAoKwu/3cA8FvOqbDgIak6w4sAKQMhWHMephFngxEhsAmBMmSNHdMwkXDO7wEp760W/wY19hl0gFx9NkkxkLffl6k3kmj5FwB14f1o0gds7+HmxRp6Eiw2ca5mByBgST+PR1XClan7gbWNh2GaSAW8b339379waHQ+j/Vg214/OZqamvjpT3/KO++8Q3l5OQCtra0cfPDBPPXUU9TU1PT2kI4jUFKFIJUiCEG8nW5kJ1xsaXRb6rlhu0lb8Uoy2oa/oQFqbCfgnO0yvp5i7ZmjdcpfrUaC3yOjaDoJVcUbkkhEVNSE8zqfWzVUptC1KGIaNRkj2rwINfo5oqeGgDdlOKT6zJjI3TWt3A4ouk4oNgfFVBE9/ZEkgbJAV2NnTH0qXXvcUTfw3ccbEMQQK1tjXbYrFJqREih7QrvjYXeG7t0Pjy9/IkXfEQeysSFVPVnXZNukodChIFU3Ms1MASRP90ZCwJJ+HsLjqDo7hm4ieVLJEarRYXtQ5rJu8eesX/wEsfZ2vCUHIxkHZtYV2tMGqe9iLVapiKmkinyenVBln+xrI4qqOeO+ZRUVCzbPTtf7lc2zYyksKEn28OKmROfbGk3pvm5TLr02dn71q1/R0dHBvHnzGDUqVbdl/vz5TJ48mV//+tc8+eSTvT2k4zjgnBm89fgCIs1JFFMHfU3BY/hWrJ4dzTS7vYH4vF5MwY9gJjC0DnTN6DaFtRB0bGwg0foiguBB8NQgyj7bA8fvkWmPJ0moWiambOgmumYie5xj7Hh8pfjLT8I0VWKeKiC/QLl59SLeevCXAHhLDscfPDGzTtE05NzmR9sRRdUROtuLCIKMKIuUBrt6p9KendrB41n6xRIA1EQTbbFE3rDX9iYTxupkU+d7buE0x4WxLCn08ia+hyi0oSWXYhpRwnKFowTK1gmNbhp5W9ukiTSvpX3d+wDIgTG2MIsjwliaQaDydAy9lWQgghrvDOvkMWDK+gwkUP0LRKmCDWiYaGiGsdkw3rYmnXreP7GY2MovEIwQgbL9814n/rAHpeN91MQ85vxfkqr+txMsq+nS+byQdfkH7HkCT896G/hss9v22th59dVXeeONNzKGDsDo0aP5y1/+whFHHNHbwzmWlKWbxCtIiAiOuNjSrF3wf3Ss+S8IHoKlB+ORu3Y9h1QV5WjZ0dSIIQSpnGRMI1hauAdqLpENa0m2vQiAJ3wAgao9bTOfdK2ahKLZYspqQkP2OOd7ePwV+MqOBCCht4G2Mn/qeWk2c8bUW/Aadk9CsIB3DUXXaelzKQPFICAjSqku4CGfl2gyVTCxT1mImtJUG1ZfIPt7+AWJ7xo2ssdO/QsxdBspY8eeVdYdPksPo2RUs6eeF7gcgKobyKaJoXekJgNi9+NZ9N5tRBvnAxDq91uaHDUxsxdA3ZQXwOO3tPg1EgiWondOyPzRdRPRU4PoqSFZrkMi9TfP69kpL8Mb2gsAr9YI+npUrfDGTvrvWK00osa+ACBUOSHvtv6wB11ZiRb7nI4YxNs3pIwdyTnC8dpdjuLrD3qWtNJrY8cwjC7p5gAej6dLn6xixpOTkVXoH9WKGm/B0FLVbDH1bi8gnyzTFt6L/lLK26DEnWXsqElrCr3cxRuSDgWpSoKVX9xEoqMNydMPJXEHedodFQzNFo7rzMbK49kJltWw849OZf0KgUSiDtkQkRHQMAveMkLVdPD0Reosb5+e6ZWH/BljZ0x91jVvzd7wIfNdo4OMHaF3nh3TVIm1R/HUOMizo+mE9TY6Gu8AYLV4MOMP+UPebQOlVbQ1pl6XGgqr1MJnyaQxNCNVABUJEwVZ6l67UjdiT8Ydcz/Lv44giEGwGEpO8KwbluvcECxC3zyanS7NQEmfU4UtOZ4WKHvNbPjHG8yvBwuEPQhS9kabiLQCduOu0LV2euOE6LWxc8ghh3DJJZfw5JNP0q9fqgDZmjVrmDZtGoceemhvD+dYrDFMv+C0woIyghjENFVUQepeoCxLNFubgTosIytcPYxg7a/AVFkleLp4Q9LGjo5ErGVRqlOlIDquGahNaJ3OKsszIZC9fvb6yRXMeWUFaxalinSFBA9tplLwm7mi5VQe7vSIlAX9rGlOzZzGDsg2otS1NrTkMkwjhl+u5tuGDdt3wN2QbgTavvoaQOXLl3ai/84P5t22efX/aFt5FZgqEqfirZuUWVdoT66q64TIjkGUu5+kDBizL80NEoJYRlAMkNScU55B0wyijX8ATMo8A5DF3bvd1usPU1YzEFFa07mz5TgOmEhbU60Nsq+7NALFHiJ1Uq2dtHHyTcl+jC8/BdOIEiipy7utL+jBW3oQ3vB+lNfV0n9UKv3cHsYqrGHdm79pr42d++67j+OOO47BgwdTX59KN121ahVjx47ln//8Z28P50g6Nq5hw/J/EW9uQvaPxCeXFPzmZ6Vm2Gkk1VTIsEVZhNydZ8cjkzAtXcUdZuxInhI8gdQFFNcaCXjtf+N0zR0EIZX9k4whIDmuP5ZNaG2mLv58np00AYvwL4SHNpSCpwsreersANSUZMW9Vs/O4o+eJdr4KAD+mql82xBwhAAzHcYy9TZAQ012/+D3BgJgpoSXSrwDv7XOTqE9O7qBIHiRA+PBVAlVDOx225E/+glL5w5HVw1CRhJFa+l22+2NrijQaRgYgrxJzQ6AbOl8bmrO8+zoyRUgSBhJS9FToet38gVlTCOJobcQVhvwCLojau2kNTuCWILkTXnZfKFQ3m1FSSBQUkkyqqHELWJ5S2i40M1At6lnp76+ns8//5w33niDhQsXAjBq1CgOO+yw3h7KscRam2hc8FTnOwlfyV4Fv/lZsTYC1cxNpJ7LEgk0TFPHNGLEOyKAc/qa5XpE/N14dgBGHfd3Vn6aarPgtP5Yq75+nbaVdyAIXvylR4K/f7ep52BPFQ51dqou9M08mYwjJ5agiWEEqSTj2Tlxr9Gsa4uy65C+9K8szWzvtcQRPWaStpjI+vYotWWFLS6oGTqSCaJchWkq+ENV3W7rD1ci+/tjmgFMym2ThkL/Hqqmo8vVhGovBmDA2O7DP4IgEAh7iLQkM6nnTjA8IeXZ8ZYcBqbGRjGwyWwsyKaeA2AJxznFsxNZdweYSYSWOihPFUjMF8YSJRE1+l/iza/iBSoqTii4Dgyyf0efkP0756uxkyYQ9pCMaiRiKoZhIopCF4FyoTB0ja/vO4WTNXi9B9tvUdESQRA4/PDDOfzww7dkd8djrcthGhH8DtPs6LY6O92nnvs8MpUdH9Le8RYAG5ZfzYi9up8hbm9yPSJl3Wh2gFTRoE5Uhxk7ajIOpppqe4GBAPg2UZMpEE41cAUhU1hQKbQgNtKMb/1fiAKe0F4IQspzOKyuijvOOqrL9lUDRxOuORxV8SLKfYFWvm3YWHBjR9UNZEGipP8tAOx1StfKyWnK+gxm4G63s3FNqjq01bNVaE9ul9RzedOGS6DES6QliSyIeEwRTe/+vrA9EZAJVJ4KQIu2zuYVyMU0DNoav0SNLQHBh6Hun1nnBEPB0IyMJ9AUsvejfGEsAF+ohniqdy5BI+KICXM6jOW3PPrzVU9OkwrHxcGEZFQlUOJ1jGZH1xQMNUFPc0B7ZOz86U9/4vzzz8fv9/OnP/1pk9v++te/7uFHO5dwZT92OeYWFn8eRZQq8JEo+M3PiqHZMxy6TT2XJRKipXt4p8DMKSQibRjqehA86KaaaQKaxmrs6KLFpZ10VhhLlAKInv5gqqiiD7/X0+2sev47T/D1a4+gJtoJ1V5GyJuqS1Xoui6KmhWLI27+IVk3bHf67FzGhlURADzJdhpaC19cUO8iUN60kWDVVkiqxdgptGcnJ/V8U3V2IFus0jTNlHdH0x1h7Oi2Kukm8qbOLUHg039NB9NA8g5CV/fL7usAQ0HTdLwlB2GaCtGS0nR0DrGb+2+oYijR5r0RpQricnnBzynICpSr1EY0w0AQfXj93TeJ9oUk1Pg3mHoHS+esZcxBxzgmG8s0dDwVA2hua+vR9j0ydu6++27OOOMM/H4/d999d7fbCYKwQxg7stdP3533Zfm8VB0Rn9bkiIstTWvDOyRaGxAED6avj62njxWfR6ZNDCN5hyBIYaAk73aFYu3Cl+lY+zgAocpTCHjtF501O8tq7DgtjFU9+ABKvhsCQIu6hoA33u22giChJlI6EkNvJURK5K8UWLOjCj48pYfjNU08oSE92scm4kfKZG0VkrRAOY24mbpSPoux45S6LvmKTG4qqyze0czi2ZeT6GhG9u9MqPwIkqpG2F/4zEtrBpOOscnCmYIg4PEFURMRTCOBoVg8vw4IY5k6BCp/CkBzVQzWpp4P3VUQrug3lkhbKkNRUb51lGZnWMv/EdVbEcQSvP5nut3eH/YSa7oPMPjuw2GMOegYx3h2vIES6k6+k0eenQW8tdnte2TsLFu2LO/rHRlrHDOVjVX4iy1Nx7r3SHakWnUYfS7sNvXcK0us9g0gXJoKQ3jD+YVohUK3VB5W6Zp6bu2P1bHhW5LtX2AaMaLNR4FDejFBbiVoY5N6nVBFH8KV/YhHgwiiL6XZwQGeHTlMoPwEAoIHOdgzj4DXUmvHJ8jEkuomtt4+aLqBp4d1dsBea0e02GqFDDmkPQAliSVEo0+D4KFlzc+oG3pw3u29/hDxtlRXekNvJYyn4IL3NFbPjm5uus4OwOhDJrPowwYEqRRNyf4Gjghj2b5Ldjzdh7HsGVlO+A5po1FKZ+kKct5WEWkCJT4EqQRTbyMZbQXs2ViFfi5u02ysm2++mSuuuIJg0F6CPR6P88c//pEbbriht4d0JLl1RJwQb01jGtm7soHUfZ0dj4yBiWLqeAXJcdlYvpJ6PME9MU2FuBjsYiRY33es+TzTaybaOhrYe3sOdZPoViElRt5WEWkGjj+YgeMP5o2H5xNrVwh33nQKfdNQNB2pswbI5gyENN6A8zw7qm4Q0NqIt70Kgod1iw9h6O75jQSAxkXPEFu/CBONKvUq23EKRfpe49Xb0RLzAFBi3esjJY8Pb7ACNSkiSKWEBE/Bjec07U2L6VhzIwgeqvyj8Eh7bXL7cYedzYoFX2MaJmrSQBZFNMNwhGfHVg3alnqe34CzpZ8LHkd4dtKemI7Q3vRBRBD9mxUo+8qOAdOk386pZqbWMNYOXWfnpptu4oILLuhi7MRiMW666aYdxtjRtdZUd1s9gs/b31EC5dK+ZxBra0Yxk6m07E1kYwHE0fAiocScZeyU1e1Lc+MIANqVxV2MBKtnx/AEMq/VuHPqiEBXz06u0Dof/rCHWLuCX5CREAr+cEp12e7s9bOZ9GD4/+y9d5QkV3n+/7mVOk3e2ZnNWTknlEASklDCgJCMEWAQSAYjS2AyyAaDyMGAwGAwGIT1MxgbmwwWQQgEQhJIKIC0CqtdadPMhsmdKtx7f39Ud0/NrHanq3umasHf55w9Z2a26071dHfVe9/3CeCWJ/nDj66lWpzEzGwg2/NcStX0OztSKWw1hVcj5e/e3HXAYmds+z345VqXNGJpkObrUe8AWBGjGStzYHvti9/0bX7+/z0KQIccO2giI4JqGRWEHkyms3rOzk44yjLxKgGBK7HMsNg5GPgu0c5O0ERnZ6bXjnlQPIc6Z6fS/RxyZqjMPSBBucMm0xl+fnLdvcAsnx2Zss9OjAIydrGzP0njAw88QF/fwSNrbhd3/9f7KA7dDUB22QdT33lHYWXXYvsr8LQP3iP7lZ5nrFrcgpZ0C/BdiZK66Z37QmOu8U8uUuzogaPoXPZaZJDBzDTHKUkKuzf9lMrI/SBsRO4wcs7+E6rrmOG1I+zUOTuuJzFqXJe5SL0Q8toqE9sB0HKKjDApHwSdnUCq6RY9YDkHLhIyhWkeW1AqNb5OdYxV+93Vwmms7DgXTcDyI48/4DH5aBjoQZR8LqVCGB1o7RM04bMDoXu9VwnwqmGER9UH/yDo7BRHn2Jqx/tB2GS9Y4AwRNbYD2cnU7CojH6doPJ7Dg3G8Nx/TfBsnx6qVqRlaF56XkelGG5mZvjspPi6TOx6ktLd/8aJld3zKz3v7e1FCIEQgkMPPXRGwSOlpFgs8trXvraVcz4oEZWfO7p6UBGU66nn9Vbq/sdY4c/F6DcoqTBjx6t+esaOI03IWX5B+8RFRL73cv0MDiylOOYi5cETZgowsfv3eMXbw2+yaw44xqpjhtcO6Y8drJGNFHd8CyFMTON5wBEHfLxpOTi5HnxPIMwOspjsicR/pAVfKnBWUlhyPWiPQ08//YCPP+Wyt/GLrz6CMAroYLp7GKTIr6hvrCzhIMxCaGWQyx3wGMsx0WaYZN0hnIMm+bxj0ZF0rfwEAHd4W+b02QGwHROtVTjGqnWnD4bOeuAWUcEuAIS/unH3PNAYS8siKtiDAbiTexI60/2j3omJ+uzM8DaaBcsxsRyDwFNUa8XOweKzUxzdidz0M45s8vFNFzs33ngjWmuuuuoqbrjhBrq7I8WA47BmzRpOn+PC8seEJYecwtCWKsg8hlE4qDo79dTzOkluf2qs+hjLdB8hCEYQRh6vEhw8xY4fnYHv29mJStHD5PPQUSHwFE/uGmPNYG8yJzoHVDB9k/cwDkhQBth4+3+y7YH7Ke3eRX7x6+gQdurkRe1W0HIsLJ91c0XLBa//Nr/8+mMAZOUIZbe4cCfYJKRSWEYnlrUIwxB0DRzYV6p36Urs7BhKaqQ7/RocDJ2dGT47c0jPAcgAZShgUfXSHynCvjyXuTo7937nU2y995toWaFj6bvJZSzGSN/RGmrXXSMPykNGLD2ezlQQQoKysHpA5FBmd+jHlTLqnRg7xnsrW7CZcquUJ8bxqqWZaqwU74vSj7e5arrYufLKKwFYu3YtZ5xxxtOGgf4p4ZDTXsATj23AGw0vGqWDpC0M4FWGQZuNYme/cRG1MVYg8liMoFWFasmlq//Au8SkMPzITRRHNoUS+q5z9olYiHZIqn6AnZn+/s1f+V8+9IoLOHRpP2ljYMPLkZyH1h5lXZmzs7PjoV+xZ3M4IkWVyQozdfWMVAJh9oAOsOzm3h9RNdbBQlAO4yLCm4/RxDhOCEEmb1GZ8gkqEfVPmgTlOmenyUBTgJGtD+OOfhtVnMDpeCZuueuAj08KM1PP1ZycHa0VWoZFgVZVckY4hjwYOjvZrsPoXnkjAI917YY9YZdnf2MsyzbI9V9OrvfPGVcuMmXDTQil57aq4ux8N5PCxskfhRDHH/AYv/wbJrd+HpA8cfdbsTqOafxfmp2dJYecTHbN32FWfOAv5nx8bM7O2Wef3fi6Wq3ieTMvcF1dB8eHbD5gZiLtOjf9DxuAVpqpHTeE4YX2Ulj05/vn7NTGWNv6XsSJ9jKEUcB3D55EZLe4FeluAsDvfjb52Z2dSPFTdT1Ms4ry96BRZIXJxh17DopiR1i9mE74t/bch+fs7OS6piMMlBzHNNIPmh3vOJyjV5wDQN/quTlHMNNnJyMsKl6AVHPf0BYSvlSNrCKjCX4IhDvXypSPX5UIQq+4NMeKddWO7W7Fq42fA289prV/n6yxoSdwd/0QADOzGrfUbHN/YRG3s5PvGSTTsYLAs0GYZGsmhGl/PmC6ow7g10JaTUMcMJbDzFrIkiQvrIODoKxDTpuQE2hAq7mNQLMdHUB47sXRvZhdUTVWevcTJ9eJ4azG0s1xUGNflcrlMtdddx0DAwMUCgV6e3tn/IuDD33oQ5xyyil0dnYyMDDApZdeyqOPPjrjMdVqlWuvvZZFixbR0dHB5Zdfzq5du2Y8ZuvWrTz3uc8ln88zMDDAW9/6VoJ52ClHQ+miBldpIggU1AiYWoQ3m/1ydmqdnSmzgGF2IYR5UCWfazV9LgHGPh2RmZ0dn0d+9kqmdv49lb03kcGk6h0cz2Vmxte+3KPZOOaCqznz5V+ia+WNGPayg0KNFTV/a0aNBWA5BqLWws/WCI+VlMcngZQYwQSB+yQq2IFfLR3w8dXiGEH1YbzSb5H+0HRC9UHgs2OV7qKy90uU93ye8sTuAx6T65wWh2g5iV9O/8YKUNz7KNXx71Kd+F+y/t45OTtHnvNSjr7wM3QsvR4rs4Zc7Rp3MHR2ZnIM68XOHMGmufD/HWHiHgTO74FUCDSYPQijA9Oa23uto3cQw16BlT0CK7sYKzK2S/11iVFsxe7svPWtb+W2227jc5/7HC9/+cv57Gc/y44dO/iXf/kXPvzhD8da6xe/+AXXXnstp5xyCkEQ8Hd/93dccMEFPPzwwxRqSaxvfOMb+cEPfsA3vvENuru7ue6667jsssu44447gJAc/dznPpclS5bw61//mqGhIV7xildg2zYf/OAH4z69GbAinR3lp/9hA1CBxC6cBtqnaoZdtP1Kz2udnSqR5PODSH6++JB3MjlSwlNVCDY/jc9OtNhRGFYeFZTRqhR2EvyDkZewb6DpbHQtXonv9iKMsKtlYaSejRWdvTcz/gHY/tAv8SZ/RuCWyHRfCECx6tGRPbACaiEhlYbyPZTGv0UJ2Pnoh1l93Ln7ffzuzfez/YHwOpHtuYxcbgMlHaTssxP+bkNPf25N68BuyP2rj2Lx6ddTedLGsPpmjOTSRGn0EdyJ7wOQ735uU12/KGE2Uyt2pNIorfc7MkoC0c5OoMOb7Fznk8lbuITXqYPB+kMqTcXsJLf8QzjCpKNv7s9q38rD6FwWWsosWrWSUT3e+L+0/Y+Eav79ELvY+d73vsfNN9/MOeecw6te9Sqe9axnsWHDBlavXs1Xv/pVXvaylzW91i233DLj+6985SsMDAxw7733ctZZZzExMcGXvvQlvva1r3HuueEF66abbuKII47grrvu4rTTTuPHP/4xDz/8MD/96U8ZHBzk+OOP533vex9vf/vbec973oPjtGaZPrn7KYbu/ju84iR2/iTU8he0tM58QytBvv9VAOySExBsbUJ6HvEPOYiiFmSgEMJEGuFrdCAH5aofYPYfjznpY1iLyGBSOUg6O+XxxwmqVaSw0ez7PJ4O0RgDU4jUpefRvLVmOzs7N/6a8kg4Osl2hDlGabsoB1Ji6KBR3s9VJETT27UqUxAWe/XBQVA2C6diZ9ZhOYpsx4G75plCDz1rT8TbOQaAqhwcmzMZTNMcfGHu91oVxcxiZ/rrQKqG6CINlMceozrxO4RwMMx+wNqvx04dll2hOv4dtPZg6xLgwKaKC4269LxOfp+LCwZhZEQdlaKP1XlwEJSLo0Po8makaO4eH7vYGR0dZd26dUDIzxkdDWNdn/nMZ3LNNdfEXW4GJmqBXnW/nnvvvRff9zn//PMbjzn88MNZtWoVd955J6eddhp33nknxxxzDIODg43HXHjhhVxzzTU89NBDnHDCCfv8Htd1cSMy2cnJfU3qhGnhTjwJgJZj4B8cXJeZiefhTmd/uyXLNDCEQAXj+MF9aFlkctcxwIqEzvbAqHdEgpqEPjNrjGWbJqYhkEpT9QOGBy5nXSa8OWX8nQeN4mRk8+eR3i4wCjBwFbkmyPtRLxsLg0rKY6yO4maq1XtAWHjVi2jmPWJnpwmXpq5iCkExZZKyLxWWswbReQ5OVtPRt/+QQ4DO/pWsPO4K9mwNMJ11dJoOqHTjCepjLDt3FBlh0tGbwcnNTW7NRewM9EHCzetYdDrl4gBonxH8pgrpaHyBE2FaBFKmW+yMb8Qd/w4AmdxlwPI5O1WZTIA78QMATPPEhT7FOSGVxkA0OlLNqPyiXjvVoo/Vc3BIzx+/81uUh7/S9ONjFzvr1q1jy5YtrFq1isMPP5z/+q//4hnPeAbf+9736OnpibtcA0op3vCGN3DmmWdy9NFHAzA8PIzjOPusOzg4yPDwcOMx0UKn/v/1/3s6fOhDH+KGG2444PlkCt0gTIQogHDg4GgizEo8V/uVndeRsS0KlR2Ux8MP3MTwi4FzFvAMm0e92JFakbHNp71wZG2bkusxXqqyqRqwzqwVO+Lg6ew04jtqLffZqrLZUDJgbOcf8EsPgrAxM6vwg3QLt47KVtypXwIQVJq7KK8/9XlMjq1mbEhh2INk/SdT7+woqXDyx0D+GPqWF+hZuv6Ajy/0DnL4WVcz+d0w86+D0O03TV+tOg/Capg8NtdpK3RNjyRE+sI4AAxnMXbNI6jqPTTn2Kc4OsTjv/4y5b27sbKH4nROvxfTtv9QkS5VUOs47U92XkdHd4RULtPfnAVSNd5X0GxnZ1axY0x/n6apoO9WYz0+drHzqle9igceeICzzz6bd7zjHTzvec/jM5/5DL7v84lPfCLucg1ce+21/OEPf+BXv/pVy2s0i+uvv543velNje8nJydZuXJmsKSdKXD6a77Lw7fsAKAUpG+YBjM7OwEayzjwTidjmZSN6YugV5lYsHOLA6015ZGfAQbSyJLrevo2fda2KLkeI8UypshRN/7MYFI9SCzxs93PJvCmcGsXwNwc0nOtFbffdC0AZmYd1uJr8FK8kGutERF+iGE1ZyvRPbCa3mUGk6MjQBiYW6qmfJfVUL+WNzuOi/pOHQzBrJ4MVWF1VVlTHjuA4U1Qqj6Oo4oI89gFPMPmESW+iyac2/1qiW0PfKd+ADYnT/9fysVOtuc0fH8phimZcEyoTL9G+0PP4n7yA29ACIfJJgN2FxJSa3qCcarlb4Zd3EUnAwfeEGRyFu7kjwjczTw1UmLtkdNc2DQJyv2rjmNL5x7QHvDbOR8fu9h54xvf2Pj6/PPP55FHHuHee+9lw4YNHHtsax+w6667ju9///vcfvvtrFgx3T5fsmQJnucxPj4+o7uza9culixZ0njMb37zmxnr1dVa9cfMRiaTITNH1owQglzkIihSzgCpY2rPdopDHwRhk88cgr34qAM+PmObTJg9GD3PJ2N0Y+fXJHOic0ArTWX0PwGJaa8gs+jlT/u4KP/FjRCts8Jkwjs4CtBM98XYUlNSFfA3kcscuFgwLQcn341XnkAFE5gYqXJ2AqXYmz+eQ/OnoQno6D/wxS+Kg81rR0nduKo1S7SOFjt19U+6PjsSCwOtFUIYTXd2Hvnexwh23UsAdGZvRCk9Z+dhoVFPPZe6OUsCOxtRB6kqlp45xkoThjmAne/ByVlU/EeAypx/30w2i50LbQACI/1MP6UUXcE47mTIl61OdQKXHPAYYQhU8ARB+f5wwOFNKxzT7OwMHvJMcn11G4+5Gy2xpec333zzDL7L6tWrueyyyzj88MO5+eabY62ltea6667jW9/6Fj/72c9Yu3Zm5tFJJ52EbdvceuutjZ89+uijbN26teHWfPrpp/P73/+e3bunpZk/+clP6Orq4sgj2/OayOWnL4JmcHDkSbnlSaT3JNJ9HFOO7Fd2XodjWVTNAl7X+Tidz0KzEq3TL9x8L6Du3aCE1fAEmo0oj2dx+SGKwx9jaud7yLlPUT4Ixlha6YZxWlDz3mgmLuKIs19Gtucysr0vxBLpSs+9QBJYi7Byh2Pnjiabb94ry57ltVNKcYyltSbSoGq6s+PkrdrxAbmDQXouFRYGxaH3MfHUa9ly12uaOi7q36TlJG4p/bGJXxlB+XsIgjFsMfd1J9fVz/nX/Csdy95Ltu8lWBG1TdqdnXpX3bREg+g7F0E52pXTKXrS1CGVxoomts9B4K/DyU57b6lIEHOQ4nOSMRXSLY2xLrroIgYGBmb8fGpqile96lW84hWvaHqta6+9lq997Wt85zvfobOzs8Gx6e7uJpfL0d3dzdVXX82b3vQm+vr66Orq4nWvex2nn346p512GgAXXHABRx55JC9/+cv56Ec/yvDwMO985zu59tpr5+zezIVcYfqNYMSQuC0kpO9DzfpMCWtOwl69iChrn0Uii9ZhIKhzgKTbJKACRa7/r0B77EbsQ06uI9rZMdUU0n0cgIwqUvWbM79bSMwOMwXmNBUEOOY5V/Lkww8AYKpyqoRYL5AN12GYqRQ7EGTgE7hDBO4WhJFNvbOjtMYUgvLIzcjqJraM5Tjm2V8kM0fx9uPPvIaJrRsRwia76mNA2sWODHkV2gcUWjf33lh22Kls3DRFvzWIMHJUpnxyna2pUecL49u/RnUi7LwXVv31nI83LZvB9cdg2rViIlK9pu3pUudLGqbRMNObq1s1YwR5EAhhA6UoO6spDL4ZrX16Vxw4A6+OwcOuQDiXIMwOcp3LgTAmJs3XJIjpfTdvqefbt2+fkZfVDD73uc8BcM4558z4+U033cQrX/lKAD75yU9iGAaXX345ruty4YUX8s///M+Nx5qmyfe//32uueYaTj/9dAqFAldeeSXvfe974z2xp8HeJ+6mPHYrQpcx+y5qe735QOfAEXStCq27Hw2GsOeYgztPJz+vBOkXO1LgFEIZZkWOk7Ge/iYZLYI8EWZjIWxsLQ8KU8EgaihY65g109kRQmCYAiV16qaC9bFJHUYT3AqA4sgOfvuNVwNgF07H6bk4VYKyX4uK0MEIKhimOgnGHJw2qBFPtYfWPk5tU5OuGkthCQPDWY4wcjUH27lxyKl/xs2/slhhhQq0ypQHzG0at5BQEVKuYTZ3zTFMgWkbSF9hzujspFstBO4oKgjQunO6yzMH4dqyjND1XVex5NR+759JQSmNNgtYTqiozncPznFEiM5Fg+zdFn6WVETpl+YYS8b8jDZ9xzvhhBMaqefnnXceljV9qJSSLVu2cNFF8QqCZsYp2WyWz372s3z2s5/d72NWr17ND3/4w1i/uxls//3P8SdDFZPdeca8r98KVFD/sFihb8Ucr2Cm1vmpaonWAVqVcSsBc9h2LDhmd0T2VyBEZdxP5Q7jkmUvwq8YVHRAxX9swc9zLpQnRpnc/jaEsMhmDsHoOqVpeWy92LFS5ux4gSQjJ6jRYhHGyjmPAWbIobUqh6OXFAnKQW38g7BBZBEEmPbc3d3OxauYGplCyiyGDshg4mqZWvRF2NkxKCwOrTzWHtdcJIohBK4xXRBUiumPsezcoWhl42kXrOY77XbGRPoKQx4cbr1aa4q7/z+CyoNM7QBr6WuADMZcnR1LUNz1cbQcpdPopOq/qKnO70JBqrCQbpyfHZ/XpiPRSWm+Jr/77ruZ2vFY+HlvAk0XO5deeikA999/PxdeeCEdkd1GPfX88ssvj3e2BzkyhelOlSkrqVflMNPFU2qFYx74ha6PsRbt/RKT7hMAVKd+CKQbSjfDdVgrMvvxpokWQcsW9ZLPF5ioVMIbkp/eDakOv1pFy/FwCm4vJWtbTb9HTMvAr1YxtNfIQ0oDXiBZMvEjitWHAQjcrwGLDnwQoSHf8iOfw55tEtNZgY1BOcUxViDDcVxh4DoA1p+0uKluwrNe/j7u+/FWtj0ceoblhYWrJX4gMZ00ih01Y6zYLEEZQBqRSAMv/bmJ03k+Vl5TURWEfeDIizrGhp5Aeo/il4szQifT7OxopWtjxdq56PC62gxnR9TMRoX2Kbt+ysWOnpl43uR7K+rhJKuRYifFzk5lchcq2A00d71tuth597vfDcCaNWt48YtfTDabbekE/5iw7uRLuO8POXqNPkx7GTLQWE1WwgsFOcNnR5Obo4tQH2MFkTd4eXIcSDdA0696aFkCYRNoScd+krajnjWnrF+BPVbztxACGwPXD8hn0uMlBH6AMHtB+0gjO6fHTh07Hr6DPY+9Ey1LmD2X4+eWp1ZMe4HEiBAKrCa6IQCmneGkS9/JL74a5tlZcpRSTO+L+USgNGb0Qt4kQRkgW5h+3fLYjOHiS0UaV7l9xopNqsrCxxoQhPYGQcoRN1pPk/ebCQGt487/eC8j2zYCgq7c5zEQKHSqXQQZaMzMoWDkcLLg116fudRYwhBY+RPRqkgFM/3sOKXolFWk3lnzBVvc1HGG6eKX7kVrn+LQtJAozTGWYeURRvNj2tjEjSuvvDLuIX+06Fm6Hjc/hKXDLohfDbDsdAl/U3s3407+CiFsLKsTy1x1wMfXx1glezF9WiLMDoKUjd8AxoYeY3J7aGPQWzgNw3r6mJH+znzj62dsWIH7+0rj+3pkRJrFTqYwSNeKjwCwOdiDbRabOk4pGRZ7hDs+pTWBUnOq6xYCnpRUMxvoMReBDrBjbGSiBEwLI1WCciDlDA5FnCIhE2nT54UFKUZG+FLOGjU0VyR4lSKHb/tnJoMyZmYt0j+wcepCQ0XsOgKa78BamfpnXoP2cDCoIlNVYympyPY8F4DBtV3IR8Jsxrl8doQQZBZdiqEEVVVN3QhVKcVA6R6KxdsBKI58AFg+53F+ZTflvf8CwOS284CanD7F1+TQZ7+Px+6oGwfvm5QwG00VO319fTz22GP09/fT29t7wN1nPT7iTwWBUNSVel5VEonSSQUTw3+gOvZ1API9z8Ox1h7w8U5tDPRk1zkcYa8BwLRTJuwAQcS+IBAmnfuRnl9w3CEMjU+xtLeLo1cO8POf3Yw7uRshsmQyS1I3FpyZeK4axeVcyBR6sHOrUNLENMNxqR/IVIodP5CUO88kb4bdPicXY7cUuRHbiJSLnZnjHyNOZyd/8Hjt+FJha015zxdB2Ox69EgOOXlu+bmdyZPxRtAolJyITeCcb0SLnTidnTUnXIBUq5iq3UoywqSqZeqdnTqi5ohzjbGA0OBFgS0Myl66PlRSacxoF9dprotrZ6c770pOX7tlitJzL2aKfFPFzic/+Uk6O8O7/I033hj7pP6YERiamqIYv5q++kf6EctyjLml57X/DyLy1bTb2wDCzGJlj0Jrn6rZR7/19G/FrlyG1110euP7HX/4Ilp6GPYyMplXpN4Wnk20dvZTtM3GwNpjWXH8hxjdWevuuL/HCyT5FALD3UDOHP/E6IhEZ/6WMCi5fmrjuECFBOXqxA8Bwd4n17DhpJfMedzI1od57I5vUt4zjN1xOrYdFn1+Sgo5X0psHeCXQ1fY8eHmzDOFYeA7PWSUgWH2xZbmzjdkoCjt/gxalcgaeazBv2jquEPPeCGut50t94fRHU7NNj1Nzk6UK2nELXZMAUEtAy/lzo5UGt9ZgV04A3RAvqs5OkO+exHZnstB2HQOrofh0GsnTc6O68Z7PzRV7ERHV/+XxljhqGEU6U0AFl51TdqnROfAieQWhR4cE2aOwTk6AfXkc5+Dq9jJd6+jMPi3AOzxt7O+ySLBdjrxKiNoVQ53fGl3dqLFjlYNjlQziF40LYzUIiNCjkhrHZH7f/gppnb+IlRjLXk7gVShuqsJ+f18o97Zcce/DwTsfHgdXD53sVMc3cm2B78LgOmswrZDD7G0SON+oHAiu+9mjd8AnjruLZy8u1aspUxQVlIjvafQcgLT7InFoZqRfN4odg6Ozk7UireZ0Vz4OddYiNSz46RSuLljyXeeB0DX4gPTIOrIdnSR6b4QgFx3BwzfGa6XptN4zMKxpSuSlJJvfetbbNy4EYAjjzySF7zgBTPk6H8KcEvjDDz5IYqAlTsW3z017VPCyS/D6QgvfiVvE3aTpoLRYieu8+RCYHZHpNmb47pT/4qn/jCKYXTWODvpXjwmdz1Bdex7ICwcezGYG5o+NtoVMRF4KRVuXhudncrkXpQ/BICtQnJy2fXTK3Y01FN7m3aHzU2bDmpVwq7xMNLy2vGlRBgddC77IBqfw85a1/Sx0bFi4Kdd7CiodZS1MLFjqCajxY4jTNDp8kOUVBR3fQK0ZEitos5ZmSvYFMAd/QHe6D2gPab2vAVo/vWcb+wrPW+SRxV5XDSMOq3OjtaaPY/8B+4EGFZzJOvYV6SHHnqI5z//+QwPD3PYYYcB8JGPfITFixfzve99r5FY/qeATH5aeq5VKfWdEsxOPdc4c8ZF1MIpvWHKE7ejtctIx7OA5p2uFwJyVnp7pslCedkR5zK05SkA7GAo9bZwceTJRs5Mrus5SPvwpo+dWewY6XUSpKRr700UVQlhFDDMf236WCfXiRAZMPJYtW5EyfXo7Xh6dd1CIlAKUwjyA38L2mf9aaubOm7R6iN59qu/yG9/sAvD7MLSYdGWGkE5kOSFjWGFHZqOvmVNH5uxLZTWGEKk3sGVgaZr5cfRWvGI3D0PnZ0Ux1iBRlY3AQHVCR/ytWKnmTGWnED52wFwy1MLeJZNnIrSsVPPZz9uRrGTUgGqpM/k1lo3NnNIU8fELnb+6q/+iqOOOop77rmH3t6Q6Do2NsYrX/lKXvOa1/DrX/867pIHLQzTotxzAj1BB4a99KAodqJtQ4nCnuPNWt9hG6qMXw5t26uTzd0EFhKzxz/7y8aajZmEWINq2lLOSBipL8w5rQDq8KpFhh/5F8pjRUx7OVZubWocEdeXmP4wUo4ijM5YnZ1TX/QOpqaeT2XKp6x98CZTIykHUmEKEzsXhuMuXnNg8n4dTraD/tVHYtrhRdyuETDTupCHPjvT76Nmjd8g/LwHKBzM1IudOs9FCIMAC6vJzs6W3/2I337rU7ilIrm+l5DJhq9jqtEEgaSe9yAi3mZNjbGsDAgbIWzcavpjrBmdnSY/68IIHd9loJARknVanZ0od1WI5jq4sYud+++/f0ahA9Db28sHPvABTjnllLjLHfSYWPtSlo6GHZ647O+FgF8to1UZhI1sQqpc7+xUjemXOvAq+3t4Ytj75K8o7b4FhE0udxQZ++SmjjMjRZGFQSVlzk7nwAmNnJkRfNY1WeygNWPbw4BbnT0KM7ceL8WxCcIADBBW03EREEpr67u+ujdMWmGgIWcnGnvRfCchWkRbIt1OQig9n2aqxzEVzFaGcMfvI5BFtD4DOGoBzrA5zO5CZ5t8PbRSuMW9ta8rDRO8VB2UJbWYnoAVx3XDb+8GmiMo96x7CXbmMgB25dNXY3VOfospfwdCWCj5eaA5VcTE1rehgnFKwwMYi16M0jo1nx3LydK1/i0Ek9Wa185X5j4m7i859NBD2bVrF0cdNfNDtHv3bjZsaJ6v8MeCqFdH2jslgOFHvsTkcOiRkOu/sokg0PAlHrcW0bH8AwiRoXsgfel5ZXI7QeX3AJiZ1U2PsUwLtCyhVAmHIPV8LMPsxsqG49xmOFR1RGMMtPawEKlFRniBxF/6TgaMPForRDOt+Qjqc/9GsZNSZESgZkvPY6jKZnUMIU3OjsKWFXzv9whsqsVuGGiuS5Wp7EVN/hgFWLnmx18Lgdld6GZ9djL5LjKFRfiuhTAyjfdVmmMsKVVNYWhjZqZHtM08JydjUSLsFnrVFEdxWodhucFelLcVAKtJE9QQGtBo5WGZBl4gCWQ60nPDtDBzhyMChWwyKDd2sfOhD32I17/+9bznPe9pJI/fddddvPe97+UjH/kIk5PT8e9dXQdOG/5jQNRTwY8pdVsIqGB61+xhYM+xW6pLz5WwEJnFGBKUTN7LZTZkMH1D9IXZ9Bhr82++zuT2LwCQX/QKKt6SBTm/ZhHlHgXopn12DNPmiPNvZNvDUwgjhyn3phYGGk09Nywjtmy83hUxhMBEpNrZsZBIfxdCOGhVpdlYlLEdj6H8jUjfx84eCqSpxpJk/V2U94bcqe0Pvool665p6lgrO/18VZBuB9evVHAnbwVhkREWljG38RvA8iPP5MK//eYMZ25ImaC8HzVWMwRlJ1JQuCluzlTNE0cgqJv/2JkYeWW51QRuD6bdXSvyZKoOyvXXJGCBip0/+7M/A+Av/uIvGhfFeqDn8573vMb3Qghkyim184HovPxg6OzY+ZVY2Qm0DnANq+nODoA2NEiRuv8GQN+qS3HdM0D77Al2NJUUDqEEsg5bVVIfYwUtSs+FEHQuWodphw6glhpJtdjJ167gIkY3BKA0NszE0Pepjo1jZjdgGWZ6nB2lyHrDFPf8MwCP3H4Zz3zZO5o69uc3vY3S6BDC6MBa8WEgTZ8dhakj0vMYDuHOwHqmBl7HIrMHYfaglY7dqZsvuOVJqmP/CUB39ggwmxtVw6yx4kHS2WkgUuA0M8bKRMjWafI+64WJGriWPiOHMDTmfjIJnw4Dh72FyT0VDFNgqUeAdH12tNQIwF+ozs5tt90W95A/auSG7mBq52/Qqki2+w1AuqO6riXPR4nzAai6v59zbBIthpShMUlfpQGglY1hhkaVnhxueozVNbgKK3c0QmQRVm/q0vNqcS/S24UQNkp7TSeew8wRqYmRmo+IF0i6ajyVODwXCIudkS3/AYDDc7Dyx6QWBhpKz6eLX8tpPvYik+uixBBalbF1+Lqk+XoIe4BM9/NB+wysPbbpY7OFbkYyazGNsMMjA4XlpNPJjZL3pbDItDxWDI9Ls7PjlsZxp25DCJvy6JGNnzczxlLeLtyJ29DaQ5jLgHMW7kQPgHqxUy8e442wprljSk67Yafls+O7FWRlCEPbjVDWuRC72Dn77LNjn9gfM0xVQvnbAPArEymfzbTCoe6IPBdBOVpE+OWHoOrhCxutj0k1wV3t47PT3Bt2+eHPoDAQ3sQmVCl16fnIlm9THPoRAPm+F8cqdqJSXAsjNc6OH/gw+XNc4aDVYuCYOY+pw85OR0toVcGuuSingUBKhNmJXTgVrX16lzW/MVn3jD8juPMwPNdpTCnS6iQEUmLaK8lm1gOw7LDjmj42Y5n7uKWnVewYdhe5/r8CHfA4ilUxfHZmEsbrnZ0UE7YnhqmOhkX92FMXU9/0NiM994rbqI7/NwC2c9GCneNcqEc71H2k4hDfYeaUI2PUnPlT6uzsffL3lLaH4eSq8/ymjmmq2HnwwQc5+uijMQyDBx988ICPPfbY5nchfwwQ2c6abDCDDJqzbV9IyEiKMNDEGCvSQt35r/iqgmENIoOXYTVZYCwEotJziW7ahM4wDYQRepXZGKl3dqLvCU/MHd8RRXl8E35lCyAxrd70xliuixz/FhJQ/hHE8WDq6FvG6pPfxt6tPsJahKXTk577UoG9lHz/1QCsObF5z68jznoxe4ceZ2yoFt9BejdXX6qGJNgwRaxNSV16Xkea+ViGkcMpPAOACX9r09lYSkl+/5MvUBl9CmF2Y3WeBaRb7PhetfG1ETGrbKazM6PDGKSnxprd2WnWULAOK1IcObViJy3OTvT1UE32bJp61PHHH8/w8DADAwMcf/zxCCEaPJ0o/lR4OlGI9c8mVzwXR5jYHek7RNc7IpJ6Z2cugnLknA0HVAWtPQJPpVrsFMf+gFcaQRFKnZsl9kK4Iwm8Wg5Sypwdp3AodsELM76MbKzn8divPkl59EkQNtbSv0+t2AkiBZswmp/hQ9jZ6V91BuN7doffe8XUOjtSqRkp1GZM/tFsnkganB2pFErr6RtSzN23YxrgbScQIyBMpH/YQpxmU5ipxtJN++wIYfDQz25GK4nhrMLuPAcIO15pIZNfTm7RVaB9OlcfCaM7ATCbKES7Bw8h3/8aEA7jaW4wa50dNXUbLmAafcARTR8/Ofwzynt/D9ojt+xcIL3RopNfhF04HbRPyRpo6pim7t5btmxh8eLFja//L8GyTAICHEzUQcB1Gd9+E4E7TmDkoPMZc3N2Ih8u2XceBU8gzELqkRFTQz/AnapJzwde3UhnbwaWY4bFjkg/WC/XcyZSnYynJVXv4aal5wCmVVNCaB+T9KTOrjTJ9/81Gklnf3PBgFGYs0YOqUnPZ6eexywULGem/DyNMVa9wKqPbuLuvh3LZPHuT1MCTGctgf+c+T7FpqFmuaQ3Kz0XQmBnC3jlSVCVg2KMZdhdOB2h+jg/sAgIi51mxli5rn7sQkjOdoOdqQXlSqUQgDf+XdBVZGUZcFXTx1cmNuKXwkysnD4TSG+M1T1wCPn+VwGw0x9t6pim7jCrV69+2q//L8A2TQLCi/cM+WFK8IoPo4K9aKMDOp/RdFwEgNt7Fn3VPJC+skzJ6d2/ZWeaknACVIvjjG+7kcCtQGYN1fxJC3WKTaFeNNZHB80SrQGWH3khrrsBhB0GWKbE2QmUwC6Ef8dCX2GOR++L2R41aXV2/GixI5q08o+g/jy01tjCSKX4bNzQJ3/K5OSPmTIdhh//AEsOaU7JlHFslLAxtI/WbqqbmsBzUbKEEBaBUnN2oaM456qPcc8Pt+FVM1QPAlPB6LVfG1E11tzPyZwhRBC4gWxafTqfCKMiDKiR+KNO0M3AiHiDZVCAaNAqkkb0/uXr5jYlLfnsDA4OctVVMyvCL3/5y+zZs4e3v/3tcZc8qGGbBlWtQIRSt7Shde1GIsKXbq5OgmUYGEKgtJ7xpki7s5PtPhczcwwVVcG2m/d6EALcyQcAMIVD1WuevLkQqHMi6sVOHM7O6hNewM4tTwBgBbvTc+yNvBesmN0QABVMIv1doD0sYTCWohrLLt1DsfhrhGGze/ObGVh3fFPHPnnfT3j05x8ncKfI9b0EyxlM5fWojzINVUWqElqV0E1KawEc02S8cApLRB7D6k2VszO24x6mtn8EgOWdZ2MazY9MBtefQK4ri5Qudu26lWo2VqTQUmL6PtCM9NycNR6tuH5KxU44+s8vfjVa+/QtjWcuu/yol+D5ZyGEjc4GUNpNoFQqnSo5o9hZIOn5v/zLv/C1r31tn58fddRRXHHFFX9yxY7hl9CTt1JFYzrL0eq41HwrtNZ0LnsvWvvsUSVQe+fs7AghyNgmFS/AjbQc005EtnInYDiaKVUhY+9s/jgnEjCpPdy0Ccp+zdiqxmFzYszk9wkCTYmzE1XGxR39ADz4v2+lMrEDRA576dtTk55LpTCDUaS3GQCvUox1fFAN2+FaldMbY9V+p2nkkdZihCGxMvmmj3dsk+HuC1hrhe7JaW5qouT9QJhNE5TrmO3MnWZnx3eraFUBYaMiBPAoR2x/MExQcgq0R0ZOUfZ8ekk+KLceAmrnQ3PH7iU9sY7PdS7GtMP3p22MNX6utG6KuzSfCCJ+RQEL1NkZHh5m6dKl+/x88eLFDA0NxV3uoIclK9gT38UF7MKpBP6VMxJ5k4SSGmHkEOSQwgC1d84gUAhHKxUvwKu1L7VWqZpbaaVRctr9slklFoRKiHWnf4G9O3zAQnkbw5tcDFnrfEFrzeTQP6OCvQhhQ+8lcxafUUTb25YQKRY7AUpOABZCxB9j2ZkOKgC6igWUXb+RvJ0kfKmwUNT33abTfMcwU+jGyfUTBA5C5MIxVgo31/A5CDLdF5LpvpD+lR0sXt28hD5jWTN2ummOqw2rGyt7NJqAstnZcrFjCIGBSLXYGd36Iya3/X8A5Le8sfHzZkalWpaZ2v5mABZnDqXiPXthTnIO7BMCGpMPNpubV0cgk7/+Pvm771Ac+m5IASg0Z4cTu9hZuXIld9xxB2vXzsxqueOOO1i2LN0sloVANleg7q6jlYcMVGrFzoyk8NolfS6fHZgerXTs/g4Txd+B9pja80U4JJ2MrNnPI06xI4TAKXQjRPiqWBi4fkA+hsvsfEFJjfKHUP4QohbcGKezYxwknZ1seSdTOz4IwB7zucC7Yx3fv+YUKqVehJHFIkzQqXg+hYRfk0Ap7J7nk+25FDuvGGxyhAWw9NBncPKff4WHbg+7jJb/VCpqLF/KRicDWlBjWWbj2gDpSs/zPUdRGFwOwJD7SKwbYnliL0HlKYLqCKazJrVOWx0zUrZtGwg3js2MsZzcdBfH0AHllLrRDc5ODbGLHWsmN2963eTfY6WJYaT3JACicHpTx8Qudl796lfzhje8Ad/3OffcUH5266238ra3vY03v/nNcZc76NHd289jfS9jqdWHYfamulNSEc5QPfysGY5IvZiQWoIOP7R+pbwAZ9gcZDA955VaxZJrw0xeiV1TZKVR7IQjgjBnRtc4VHEIyo/84ktMbvsWWntkFr+GcpDOZkFHiNGGGZ9LcPhZVzGyaxMAdrAHCJPPEy92pMTERAgD08nEfi4zL+ZmSmqsmcntrRU7Ecl3qmOsmblxzUrPAR645Qtsu+/bAHQsfRdWyp0d01mElT0CrX1ErgfCXiZGE8/JzmaxcscihEMpRdd3qRSWBhWM17zjemIdH/hjBJWNaO1h5/qmf66S57KqQBJeezWqyc957CvbW9/6VkZGRvibv/kbPC+8cWazWd7+9rdz/fXXx13uoEdXoYNS/mhscxEAMsXxj1918Yp3IYSNEBaYRlNS53pBVBYdLLaXhQaJKj33ZBloJre9HrSk4Cwjs+K1sY43I46waXrtyEDRuew9ADwRjILcEUt6rqSHVmFwrqllellMZLByx4GW5LpWxD7+6dxuS1UPuuKPxNqBlNM71ziJ53XsIz1PRY0lZ44arHjPI2OZrJj4MVPuFrTyqE59Ghic57NsDmqGz46KNcZyZjhzV7GM9OJUAPJ9Z+K6xwPgDPQAIWWjGa6KZZsUBq4DYI+cpJyWD5XWdKhJpoY/CsBW82yOPvtjTR8/seMeSrs/CUAm82Ig9LdJIzJi9YlXMTlxASCpqh1NHRO72BFC8JGPfIR3vetdbNy4kVwuxyGHHEImRnrqHxO6cpmZM/AU28JupUhl5MsA5LKHQ89zmpJz1js7T3WcxtF9LwEg25HOBRBqrXXtAwq0bDoqoo7yyIN4U5vDHUZmdXo7pciuOahd9OJ0qXJdfQhzEUJYmMJMZYyltaZkLKYwcC0Ai9c3Z9AVxWzpOZCKi7IvZYMnZMbkhwCYkfdhyNlJ/vUIapwdd+rnKH8Xuzd1ETz7jU3nfNmWiSVLqGAvAF41vQ7uTJ+deJ2dxWuPZdGWvUyNEboo64lUTQXrhZswiLDCWlBjpegNJqVqKNsg4vPVJKzM9HvQVNPPwU9hjCU9VVOAWYgm7x8t69+Gh4cZHR3lrLPOIpPJpGaUtNDozGXwD5K2cFCdtsjWwsI0RFNz8PoNOPo80kw+D7wA01mD1j6+1Rdr9AMw/Ng3qIw+BIC99G3pXTxm5XtBPOn50ee9nCcfDqXzRVXCk+Pzen7NIFAKI2rE10JHZLa0FtIpdmSg8Mv3o+Q4hllABuswreZHaZt/cxOVkZ0IswOr4zRKKexYvSDk7ATl+wiqG9k9BVq9vunjTcPAN3MIowAiQ5CiWnF86FZKu+8GYVPIHxnL0XrVsc9mauJQnrg3HIva3hTVFBO264WbYRoNJ2Jozmcn+pmyUoy4kUohRAYrdwLg09G/Ltbx3QPryHRdDMIhyK+BYvgZT6OzE1UTiyYvubGLnZGREf7iL/6C2267DSEEjz/+OOvWrePqq6+mt7eXj3/843GXPKhRyNhoVUQFJlr7BP6a1M5FmHmyvVcAAXtEtukba71z4nNw+OwoCR1L3wHA5mAP3TE9J0x7eoeR0ZKqn1LwZLTYicGhqkMYoj52xiQdNZYXyJkRCy1Iz4c2/pzi0JfRukK2+7lg5VJp1Wup8aZuI6hupDoKKnhprGJn6/3fIfBKGNYS7I4z8GXyz6FOUG74aTEzi6kZbFp0PkeJvwbAzqYjQgDwitsJKn+oncd6LCNeBzf6XgzjO9JzS6/f0E1LzCDkNqPGEkIgTNAy7HymNsZSGmUtojBwDQArj1kZ6/ieZRvI9r4QgGreh+IjQDouyp4X7VA1V0THLnbe+MY3Yts2W7du5Ygjpk2iXvziF/OmN73pT67YMQ2DVXu/zJS/B0QG6X8nvXOxcmS6QlL4VLAb2xxv6jin1jmZmYacorKhxcTzOpYd+We41SNAZDCFk1pnx6/6uBO3gLBxhIWZXRRLcSKEwDQNZKBqF/O0OgntdXZ8r9jwtrFkEawcxRQiI6RUaD39e80YZpUAViZP4JXQOkxvT6P49KXCEoLcolegVYlVR3bFJloblkF9X5OmGkup6ddCCgsr5ntr9vgnUOldsyaHvo1b3ELVztBZ/avGz5v1l6mM/AdBdTumDqh4b1mo0zwgpG5Tej5DPTr9vNNQY+198pe4k8MIYWN2rJ37AFoodn784x/zox/9iBUrZhIZDznkEJ566qm4y/1RQBv1DCNvhplR0pCzZuDNyM5heoyV9XdTKd6L1i5jnWcAaxbgLOfGDK4LOvYYa2Dd6ex4PJS0mv5Oqim1hb1Kier4NwHoymzA6Xh+7DVMSyCD8KKZRlyEH0h6q5sojf4PCJPJXVcAF8Raw8l1hF+IDEaNz5DG7lUFmkz389BynK7FVuwi4fQXv4/ffn8bGLma1DkFgnJtjGXaSwDoW7E8Nj3AtESj2ElTPdo5+BKM7POoqAqTckdsLxbLTp8wXodX3kRQ+QNBBfLq6sbPm31O0nsK6YYbgorrzvHohUFI4I9EV8Ts4kaLI1NPr5OGSm70yR9SnXwMAGPVe5o6JnaxUyqVyOf3dfQcHR39kyUpe52H0GkuASOLm5I7LOyrbmh2ZFIP2bRUEa/4CwCqE0vm/wSbxExJajxTQdhX/ZNaZydy0VLCii2hHxt6gtLebxB4VYzs0fhG8p8fL5Bk5SRBdSMAvjs2xxH7YvVx57Lxri8SeJpx5YL/WCqcHSU1du5IABatiT++WbzuWMxMzbVXThKk1dlpQ3oOtc5O7a2Z6rhaWxhmB8pwUGo4VjbW2M5N/O4711OZnMIpnIbVcQpK6/QMROX0+1lFxnHN5q8ZZv2zLahUK/N5ak2jHhdRh9VGZ8fQ6XZ2pKxfew0sZ4Gk58961rO4+eabed/73geErXilFB/96Ed59rPTcYZcaLir/oz8SGf4tZtePlbgR/xp0E1fPOo3YU9Mv9yBV93fwxccpbEhynu/BMKm0x4gY8ULl52hmsGgkhJnRxg58ouvQWufTdqLJTsHKI7soDxyCwCm0YWXjUcYnA94gcSIcLksO743jmFaWI5F4PnYIj2Cso4QR1vJ+JrRSUjNQXmWqaAdf6zYGYxSGX8AtEcpdzJwyDyeYfOok3plLUolbpFSHgsnBUpNNsYvabj1aq3JD1yHVi5di0wmI7fNZs+l/5A3URzxUdqgLONvKOYDUmsK1c0US/+OwGLvky+hf+Vzmj7eLe1hcvtb0drH7DoOsmE4bRo+O50rXkxl7wggsZq87sYudj760Y9y3nnncc899+B5Hm9729t46KGHGB0d5Y477oi73B8FMtnpP2alkp66Ye+TdzO59d0gbPo6zqbSf2ZTx9XHRBPWIjpWvBNUhs5F/Qt5qgdEtTiCX7obgGzhGS11drSWoMOQwGpKnR203ciZGfe3krHifeijnBJDB/hB8qF6XiCZKJzKYV3PRWvJwPrWbozWrByjdAjK01+31BExpwnjVlrZWIHEEoLAfRIhDKpFG+ib87goOoMRvInvAVDt6Jn/k2wS9U60rCkV4/js2NkCpp1FSQchnIalQaAUSfc/tQIhsggzi5MvoKK8sCY7O5lsnpIoYQqopkZQVjhqClkNicVueW+s4y3HRstanoCctjRIQ41l5Y/A6Qj/jo7TXPEYu9g5+uijeeyxx/jMZz5DZ2cnxWKRyy67jGuvvfZpM7P+FJDL2o2v3Wp6xU5QtyzXPgodY4wVPi4wHOz8apSrUdqe46iFQ3T8I4UZu9h56v5vMrn1nwDo6HsJFX/RvJ5fs5gdexFHiQWwaOURDB7+TorjCsPsQcltYeRBjHytduFJiSlshJFFAHamOT+X2ajP8+s3pTQIylpqlJxCCBvDjH8BrkyOgHyKwC1h20uaTlOeT9THWKVdnwBd5cEfrmLDyf8daw3Dno4nCLx0RiZaa6pTf0CrMlpLhJWL5bPT0beUC173A379P08AYNWcudPgh0TpA4YpUHp6U9Ns/luU7+K66fnsmJEdgRUjOw7AzuQQZi9COAizp/HzNNRYqjae9bUksxBjLN/3ueiii/j85z/P3//938c/wz9S5HMO1IiXbooEZcPM1fxpAlyzEHuMBYAZbl3TJC7muzfQsez9oD12yFHOiFkkRG/ItvZSIyjLWdLzXEyTrky+i0LfEVQrJQBMuR0/kIkWO34gZygr4jr2AigZUBq5DXdiAmF2Ythd6XR2lGZq+9uBgI1Taznymf8Z6/iNP/8qE9u+CoA18EY8QybeaWuMsWqhvXGk83XI7hXQ/1oKZgE7n455qFYad+L7SPcJbIDBa1sIAo04pddegzRcxqMcQ9OK77NTP64OL6V7iNSaoHAqXZ3PRmufNSccH+t4J9fBovX/iO9KVBaY+D2QTgFaf018VENtPBdivfts2+bBBx+Mf2b7we23387znvc8li1bhhCCb3/72zP+/5WvfGXoURD5d9FFF814zOjoKC972cvo6uqip6eHq6++mmKxOG/nCGDv+Q3F4Y8yNfQ+yiOPzuvacdC1+Dg6lv4dncv+gd35o5vmiETfDLr2iqdJXNQ4mPYAprOCslmI3dnp6FuCmVmPlT0SYXSnKD2voIJxlCwhtY/TKpm0hjS8dtxgJkfEaMF5GGBk85epjv8PXvGXWIhUODtIRT2gMa43DYSjkzoMHXLakt61+oHCFAKn8xycjrNZevhZsdewcz0EuSOwsoeBSCvsVzcKNo2BFkaszg7sq8aClLoIUuGX7sEv3Ut1cuMMQm6zYyyv8iTe1C9xJ3+GKKfE2VEay7AQRgbD7JgRUNos6kWbiLwMabwmsjqOVmV87TUtDIk9xvrLv/xLvvSlL/HhD3849gnORqlU4rjjjuOqq67isssue9rHXHTRRdx0002N72crvl72spcxNDTET37yE3zf51WvehWvec1r+NrXvtb2+dVhB5OU3TDoMKhOzPHohUN0Nip182OTqI+NX30CKhUQFkoe0/LNrR3sm3oer5Ox4qgz6FgSEsbHVZFKSmTrieEHG2nhKzrOBOt5sdcwU04+9wNJ1tuGV30chIn0lwDxMq0MM7yAauWiVQUbk1IavASlsHLHoLVPZ3987lH/6qPoGHgOftXCtBaDHsMPkh0r1js7ub6/AODwsw+LvYZjmw23dC01WunQwDJBKKlwui5Ey3FGVcjviBvh8XTO3GnIz2WgKY/8G2iXXdWVyNXvmj7HJgu40p7fUBn9HwAyxotSSRyYrcZqhdfWeE0iL0PSnB2lJJNPhl5F2llDxn5HU8fFLnaCIODLX/4yP/3pTznppJMoFGZeGD/xiU80vdbFF1/MxRdffMDHZDIZlix5epn0xo0bueWWW/jtb3/LySeHzPB/+qd/4pJLLuEf//EfWbZsflKkc4UOwhLHQAXpcXZmZ80077Mz/TKXtnwclIdhLyPwL8NJo9iZ4bOjyMZ2UJ55EUwrCDTwprlHvjApxBzHKRngl7cRuKMI4WCl0NnxAklH+T4qpbsAqBZPBeLbEiw/+rWM7qwizC4sodPp7GiTwsDrANhwRvxA02WHn87iDf2M7gjHioY7XiMpJ8dv20eN1cINKUw+n75OyUBhOckVbOHv1DiF8JpcluMQbIvd2Xnyvu9SHQ9jYazOUOnrp2AsKAMJNVKyYTrICJerWel5NIfKUhJfNm8dMl+QUVsD0WI0TG3MLSIvQ9KdHTnL8qPZv2PsYucPf/gDJ554IgCPPfbYjP9biEr15z//OQMDA/T29nLuuefy/ve/n0WLQkLqnXfeSU9PT6PQATj//PMxDIO7776bF77whU+7puu6uJE/2OTk5AHPYfWpL2DqyROwDAcvk974J1pBByicZoudaOfEyIDy0MoNi47W+KhtoTo1jF95PCSS6lLsMZYQIpydByqUnqc0xjKs7jBnRvsUzW76YnaoAq/C5rvCHYqVPQqz92K8hBVAvpSINkiLdSxafRZTEyMA2N7jTAQSXybLPyLi/dFKECg8jZFdwrtWr/aerqOVYidjGrj+CFJMgRAE/lGJFzszPcHCTVpczs6mO/8bd2IzCAe76zwgLX6IItv7YtAe/WuWMqniE5R7l5/C+G4ThEPFzFB2PRwr/hipHUitsdwn8eQYwrRxS2vIFHpirVHc/QMq43tAWIj8YWiYwWFKAkEgsXLHgQ5w7YGmJwOxi53bbrst9sm1iosuuojLLruMtWvX8sQTT/B3f/d3XHzxxdx5552Ypsnw8DADAzNTmi3Loq+vj+Hh4f2u+6EPfYgbbrih6fPo6ehAChOLsC2cFka33UF57x0gbLLZQ7Ct5rJNopwds/8crHKAMLtSIylPDN1Fefe/A9DT89zYDsoQdndkENqfp5WN5RQObeTMbHcfZn3MG3uUfKq1h4VInIDp+hK/cBK92UNABxR6Fre0ztONHMquT3c+uZusULrBQjRaIFoDWFFSLEbiSduBlOQiN9C4xm8Qdnaywx+kCJiZdUj/3Hk8w+Yw0+29Jj2P2dmxszXzWu1Rd3VIw/tIKxoxPYvXLuZxf6jxf82OsToH1uN0hlMQ5T9JxQvoiTctbhtSKYzyvVSKtwMwNXJm/GJn7+34lSEQOcz8EQSoxAtQYWQpDFwLwB450fT9o+XUc4Bt27YBsHJlvECxZnHFFVc0vj7mmGM49thjWb9+PT//+c8577zzWl73+uuv501velPj+8nJyQM+h45smHyewZxBzEoa5bFN+LVxg+UsbV6NFa18l15CdrQmRU8p+VwGkfEPRmzOjluaYGroCwReBcNZScU6fL5PsSm0m/FlWA6LVp/P1KjEsAYxMXCT5uxIic4cQsYMOVDZzu6W1ol2IGxhgA7l5935BFuHkX1Iq50dc5axYOIcKimxg0mm9nwYhM0ffnoxx1/y17HWcGwbT9gY2g87uCnwXJRUaK0QwiComwrGfE1OfN51/Pp/HkGrDLJOUE7B+0hFNriGZaC8+ATl2aGmaSSfS6UxtGzQbUwr/ni24QStPWwMAlTiDsrRTbofw4G/Jc7ODTfcwKc//emG6qmjo4PXve51vPvd78a2F26+vW7dOvr7+9m0aRPnnXceS5YsYffu3fuc3+jo6H55PhDygOJEW+Qci6D2FhEqWVJZFDLCF/IxmvfZiTwuDAMNv5cphYE6hcPIdD8XrX0mrO7YYyzQVCfCos/Ukqq3Yf5PsglEuUcS3bQEsg4hBGuf8Toe/80uACxvc+KdnTD1PBoE2lqRYBgKJSdDgrJOPh9La03G20Np8j9B2Aw9dgFL1v95rDWKo0M8/ss34FWK2LljsTtPS7yT4AcKU/momq9MtTgaew3HMhnPHUevcDCs/lQ6uCrQTG79G0Aw4KzAWPSCpkc+dQyuP5Fcj4NXDrBqnJl0CMqR4sYUbUvPLQTlVIodRa5wGmTWYGYk+e74XdxlR72W3U+NhxxDHd7/E+fsRKT7AWrhOjuve93r+OY3v8lHP/pRTj/9dCDkzrznPe9hZGSEz33uc3GXbBrbt29nZGSkYV54+umnMz4+zr333stJJ50EwM9+9jOUUpx66qnz9nu98iS6eAeu1gh7EK1PSJxJD7Bo9Qvx5emgfcblaNPS8ygB2I/Q6NMaYzn5w8j2rEJqxaT3UOwxlpWJZLNpFzeQqWTm1C+CdfO5ZjlUUZgRkqCZQifBm+2z0wJpEWDLPZ9lavtPASgsfi2YdqIk5UApHFUmqIaE1tJY/G6fYdq4xe0AKDlRS6JPvrNjoRFGAa0DLCd+Z8yxTHb3XspyKxzxp2EzEfg+dcmORsXm69RhWQYe6UrPZcTZ3LCMlqTnhiXQOgg7IipIp7MjNZncYcBhZHrt2CMsgI5FGxgdDgtwy3sMdPI8qiBSfPpa4TQ56o1d7Hzta1/j61//+gwV1bHHHsvKlSt5yUteEqvYKRaLbNq0qfH9li1buP/+++nr66Ovr48bbriByy+/nCVLlvDEE0/wtre9jQ0bNnDhhRcCcMQRR3DRRRfx6le/ms9//vP4vs91113HFVdcMW9KLIDK1AjG6NepAnbhDJR8aUvma21DdGDaoUmY6040PcaKdna8CBk1La+depEQoDENEftCaJg2q076JGO7JEJksPxNuH5APhPfW6UdTO36GcWRu1BYdBeOaThVx0HaPjteIHG0DkcOptGyRNnOTBMQHO0DCRc7s91h7fhEaztbwLByaJ1BGIVU8rF8qTAzq+lc+UkyBYuTLz069hoZy2x0ooFUxljSDzAz69A6wLMWtbwRMWfFkKRhKjix63Emt74OhM1Tv3sucvnZjf9rtls1uetBJre+HYAlHc+i7B6/EKd6QIQCl/Dv2CqnbfY4DpIPAh3b+TilXTeCsMlkDyFjHdXUcbGLnUwmw5o1a/b5+dq1a3GceDebe+65Z0Z4aJ1Hc+WVV/K5z32OBx98kH/7t39jfHycZcuWccEFF/C+971vxgjqq1/9Ktdddx3nnXcehmFw+eWX8+lPfzru0zog7FmdhErVp6Mj+YTq2QqH5n12IgTlHd9icuwBtKoyNfJZIHnTselip/kWZBRCCHJdS5nYG6ro6oqspIsdr7KzkTNj5w9rSUo6++KRRrGT3/NZJt0nABMZ3N7SLL9rYD27Nh+LMHIII1SZlBKMjAikIshuoGvFJ9HaZ8NpR8Zew87kOO0l3+Ch23eG3/tbE8/HikrPW1FiATi2NbPYSWFTo7HoWBL6n/wh2Iltxjd69aslVLAH6Y1jWaECN43OTmgxoUF7CKFnxEU0W8TZmWnllanT6exErUuMFt9bT1fsJN3ZqUyOEFQ3hudg9S6c9Py6667jfe97HzfddFOj6HBdlw984ANcd911sdY655xz0Hr/6qYf/ehHc67R19c3rwaCT4dMoQe95KXkgzyG1c/EVDWVYieqcIiVjRV5nJYVtBwHwCuX5vX8mkX94itjkMtmw5ylmknl4iEjXibCatrJM4pHf/EhpnaEFg7WwGtTubkKXZfuSwyztddj5TGXsHNzODrSwS6QuxM1FgykCjO+zAICyBa6WlonKtFOIwzUC+ah2LHMGbleaXF26pBat9TZeeSX/8XOB8NJQX7x32CaVipqLIFZi+nxyHYubmmMle3oxsxsQAgHafVTTsEuQ0uF1j5gtjyZkP4Y0n0KrT0cUUu1T5qgHLGNCWg+WzH2le2+++7j1ltvZcWKFRx33HEAPPDAA3iex3nnnTfDCfmb3/xm3OUPSlhOFmvxM3Emwz/XZNFleQrnUZl8nKAygcRCCIXVJEfEMgwMEQbYeWaegtmLEJkZxVOSmNjxBfzywyhh07H25S2tYc1SzaRhLJjtfTGZrsvYKycZlzua5lBFUS3uQgUhQdmEVDo7wl6OgYkwW/fKsvYjPU8KgVIzuEet7lxnv6+SJsT6gQrVbLRe7GQsk4HJW5nytoFyqU59Ekg2LFfO6kJbLYxHo9w8rVxs00lFjZXr2UDH0r8DYM2Ja/jlw9ORSUaTRVz34Go6lrwNgIrcSyUFh3EVaErDH0d6m5ncZqJfeAciZhE69Mh/URz+XwA6Fl8NZp4gYZ+d7iUn07Xy02jt8UCwe+E6Oz09PVx++eUzfrZQ0vODCdEdX7HsHuCRC4fx7f+FVwzbd8bgNU2/yEIIMrZJxQsY7j+P1YWXApDpGJjjyPmH1hoVFNFqKkzZtlsbPVWnHsMvPYnWHrYzkLixoJIatIEwMgTk0cpsaSRnZwogcghhY6HT4ews+kuywiLX1bqScobPTu1mXUyaszMj46tFTsI+poLJvh4qUEhvK375AaYoMLbzefQuixd9YVsmthxHeVsB8CrzmxXYDKKdnYDmN2ZR9AyupWvJmVSLBobdj4WfSmdHRQpeY7Yaq9nU81njnzTUWFpqdMRZO26hA2BGuHB2jSOX9BhLKYEwsgiyBEw03TWMfXWO5lT9X4JtG9SNPEqldIodLadvHhIzlvrHscJipxIZvaTS3pYaYXYizEVI7WG36Ni78+H/j/LehwGwl7wtcWPB2R47QEucnVMu/xh3fXszAGawKyU1VnudBNi3SAAS3b0GUmH7w3jVjQjh4FWWkS3EL+Z3P/FzqmO/Q+sqVufZiRNitdRI9yncie/hTsDeretjFzshQdkGDBCZGbEmSaE0sZPynn8FYdPtLMbtaY5EGsXSw57B6hOXsPWhUP1je4+lUuzIiM+O2aIaKzo2SmvsriWY9kqEsHHyrW0ye5Yezd6t42DYaCP05kp8jBWRnosYm5q2TAX/L8G2QcoSWvuUK8nzdQCy3c/CsA/D1R4IgR3j5hR2HVwqcroDEvUrSAoyUOT7rwJgq5zCyVRaWseypwl/GYJERyYwK99Lt17sGGkHgfrT0vN2ip3KxHZKuz6F1lU6sodDbh1ukFy3zVcSp/IHKpO3ADA+tIGu/vjFztCjt+JOhh5OmY7TE7+5KqVrvIoQZguqMseyeKT7ORy6+BqEENi51lyx24FXHMMv/waAAqdgmce0tM7sjkgqpoKzOjtRgnKzY6zZDuNpFDtITb7/lQAsO641YcqSQ5/Fjk2rAFDBEMi9yfvsRF6P/1fsLAAm730XsjwMRp7c4Z9K5RyczmdiZBRVVQX/8Vi5Q/UbcSkIqFMb0ujszA4BbWX0AzB46HOoVtaAkcHASZyzEwQKv3w/WpUxtQd2X4tqrOiOT6RCUK7LZ9spdhCy4XFjW/3AukRfEyk1hp7+fXamNedmJ9sx/bX2E389kGDnj8OwF7NoeYbBdcfHXsKxTAIxzb9KQ3oe+DO70K367MwuEtLIxhrbeS/lvbcihM3U3pfNMhVs0mfHFJT3fAGtPQpmFyPecxfqdPeLaNRRKzEks49rSM8Tfk2m9m7CKz4cdqi6mxci/L9ip0mYdhYJoFzcajrOw3Xb8qA2Totzc60z1o3KMFX3QbR2mdh1KrB23s/zQGg3YqGOJYeczfCT6wCw/B1UE+bsSF/hTvwv0ttCN8Dgda11diI3AVMYuAm7Wge+orz3K4BEqEHgnS2tky1MFwn1osNNsNgJpITc0WStRWjt0bV4VUvrHH7WyxjbcwwYOUbMjkQ7bUprlNQYziIMaxG9yxdR6I2fQL+Pz04Km5pczwY6lr0fdMA2uZt8mz47EHLB0hhjVca34JfuBKA69Rykin5mmyt2LNvErzwA2seyl6UTXhz507Va7Mx2gobk7QDGtt9JZSQUP+ULr2j6uP9X7DSJjoHDmXQLYGSoJOgfUoeuXQhhOkU4TmenLou2gzHcWqu/Mp6Cx86MiAVFpkWC8uyLYCUFzk593KCxQIiWulSj2+6jOnEbKB8nfxy+TNYrSEqFX74HtEeZ1oUGHYuW0LXqk0CWvdoDf1OihZuvFGZmHZnckShDU+gdbGmdRasOw8qFr6ulphK9ubp+0NgtQ3s+O2lLz9EOph2OEcteia4Wip3K5F423voOSuOTWNnDsDtPT2WMFY3psTJZpJrmQDVLjhWGQAgbrX2E9hIfuwMQ+dNZLW4yDwafHelP//2NGPeP2FfnzZs3s27duriH/dHj0LOuY+NPQ7OxSb+c+O+PhtHVo9xicXZqnZ1ATCtupF+dp7NrHjLQVMb+B1DkhINpXdTSOtEPq42RfGcnUGR7noeSE2yXNXPDFm5Ou564C3f8O+HxmTVMBX3zep5zQQYaap0YYbS+9zEMEzvTSeApnNpFMEnOjpQKU9Qjz1t3N7dSVGNV/aCxW4b2fHYywQiueytau5RGTyLpDu5sA9RWxljCMJnaE4oQlNVb8z1KvnDrWX4hlcpRoAMG1hyDevQ3jf8zYrzXelbfQOALJrWm4sXPPGsbCsp7vgAYDP3hEA4/8W9jLzGy7V6mdn4crTy6Os+C7IoZY70kkOs9hUqpC5SPKvQ3fVzsq9uGDRs4++yzufrqq/nzP/9zstkEU41TREdhuoL0U0gLV4FicvvbAUnGXgo9F8Qam9QfO27107XiLcjAJt+XvPRcBgpv6uegXQrWANpubXZd7+xorbA1iRP+pK+w8ycAMBoMg9zTUmfHinBLLB0kTlBWgaJz+QfROmDp+p621rJsk8Cb9olJkrMzw2enDeqRYRohp03Xip0E+S6uH2AJAyUnQHlI30bJxbGNHh3LpCPYQ3U89EMpj+WBCxfgjPcPOcNUUGG10NmxnLoIwQJEmLKdhqmgUcC0wzzGTEcXMkpQjuFL5eT7UUUfS/tUvF3zfp5zQUgZdnGByZ1TrS2iA5Q/BICtwk1/0rw2M7ueTGcYByU6xpo+LvY78He/+x3HHnssb3rTm1iyZAl//dd/zW9+85u5D/wjRyYT6YikkTUjNVpOoOUkyND5ONYYq9bZ8Y0Mma4jsTJr0bp7Qc71QJCBgtr4RwmrZYLy9j98j4mt1zG59bV0Vh+ikjBB+Wml5y20hteeeAH5xX9DfuANaGdl8sWO1BhWH6Y9QLYzPj8kitk5RomOsaTCqN2DRBvFTuBV0Xo3gfskVjCR6NikWhtjVce/w9TOv+e+77yKid1PxV7HEAJlTm/OpN+a4rEdVIvD+JWHCKqPYsoSZgudHdPO8OzX/pDu1f9MYeA6LJE8gR/2TT1XtU6GIUQsE87pz0c6qedE/naG1dq43MnlQWQQRidC1O4pCV+zgtp1RWpFxmn+/hH7TnP88cfzqU99io9//ON897vf5Stf+QrPfOYzOfTQQ7nqqqt4+ctfzuLFyUsdFxpRjohKwXlYej6GtRitfaQZ+hu00tmB6RC4NGb5gS8pLHkHaJ/NaoIjWp4dW6BD7pSlfSZTICjXEej4hPE6+patx86Hpm+mKuEHLe64WkCDB1Y77VZdh+vwyr/HmxpGaQ8ygwkTlBX+nn/CrT4Gho3v/mhmpl2TGHr0biafCknaZvfz8OX5832q+4VbH2NFpect3pQq2UHsRa/CNnJku1fP1yk2jald91De/W8ALOq+CMvYEHsNIQROJO8uLTVWlEIQTT1vVolVR30sWX8efiBbcl1vFYa26Fz+EbT2Oe6S1qgoSw87he5V/wTApJoC/8nEN2j1+5aPihXR0/LVzbIsLrvsMr7xjW/wkY98hE2bNvGWt7yFlStX8opXvIKhoaFWlz4oMfTIrZR2f4bi8McxK9sOmOm1EFDaoHP5++ha8WHGal4JrXR2AKh5E0hfJf88Ao2VWYOVPYSivZRsi9lY+e5FGPYyTGcNhsgnP8YKNFq5aK0IUAhoqVUvDNFIGrcw8BLcufpSYUQ5Ii26DtcxNfQtKqP/jjv2DYTWiXJ2AikR2gcUKLflIsHOTqe3G9pN9EJe7+yYmfXY+VPoX3MGTq5j7gOfBjrbgy6cjJ0/HowUxtURA1RPGPMmPU9FjTWxmaCyEek+gVZBg6MSN+8rqGzGL92LKt2NoWUK3R0Dw+rFtAfo6l/W0gpPR1B2Ey52pOehta6peRews1PHPffcw5e//GW+/vWvUygUeMtb3sLVV1/N9u3bueGGG3jBC17wJzXeKo/vIKiEmShW8EzKnk8hwZTtqLFVSwTlSAUsvZ0EbhEhDGRwTMvM/FYgZ9nItxoEuvKYs3jojpDMO6qmqPrJhpoGns/kttcBsMFZxdbBy1rOlTItQeBpTESiN1fXD3B0gF++H4SNW1oPbaS+GVadY6HJaUlZhWOHOEV5q/B9hWEvBR2gjaDlQNNC7xJyfWcgfQfDWZ9oi77qB5jCINN5DnSew3GXrCHb0dPSWo4V8qcQ6UjPnfwhZLr/DHTApNnTUhAo7JtVVklhjDW+/b+pTj4AgF89t+XOzsTOb1Eeux+A7MBrqHg+3fnkOK+Ginh6tSg9N8xwc6aVxhbh5zrpzs7k1k8SVB9FY5E59hNNHxf7ivCJT3yCm266iUcffZRLLrmEm2++mUsuuaThJLl27Vq+8pWvsGbNmrhLH9Swc9MtcQufqYqbaLETtSyXWsfuJES5MXsf/gfQAYazksC7OOFiZ7bPTms3pdmqmaQ7O34keVfRmuwcajJKPY70K5jCTryTkFUVynv+GYDhR54FF5/W8np9qy5h1DgRYeQwavN810+m2AkCRX5R6Llh9LX++zr7V7D40GuYGKrU1m2eANkuqt78SM8h3Nz4tU1RGhxDp3AI2Z4VSK2Y8B7CbrGzs2vzHbiT96GVi9VxRjpjLDXT0bpOUI5bwBnWtBt2RqvEvXaMSBO/rWiY2uasLkRIclyttUarsGsoCHCc5ovF2Ffoz33uc1x11VW88pWvZOnSpU/7mIGBAb70pS/FXfqgxmFnvpAnHliNEBmq2meq4rGkJ7nfP7uz41hmrE5ClDwrjAxaBqDcxHd9XrVC4G5BCBuhpmLNXKMwTANhgFb1Yidhzo4nMbOHg/Yomb0t39B3Pno3I5veAoDR/Ty83BHzeZoHhOsHWLp90mIdPUtPoTgRFgem9yhoD9cP6Mgu/KZARsjQrYaA1mFHQn9Vgp8PN5CzpOetPw/HMghUCaWqqAC00o1xaRKo8xrrnmCtdna2/PabVMfuBcAuPIOEPTcByHafjjBWY1oS087MICjHQc+yZxH4K8GwQWQSH2MZQQW//CgIm9J4J7nO9bHXCLwq7sQt+G4Fw+oFuzdZ402pMZyw++zpgLzTfHhx7GLn8ccfn/MxjuNw5ZVXxl36oIaT60BYXQgNttJMVpIN1ytP7KEy+nUQNlmrD6sz3sw1WlRkBp+JmnIRZk/iJOXy2HZKwx8CYHn+eDL2uS2vZdkmvitDBUvCpoKIDB2DbwLgUW9TS0osmJl9ZOgg8bGJNgpkei4FHbBo1bFtrTebXwHJee0EgW5czNotdqxosSOT47TNl6kggGMKcjv+jinAzKwn8M/CziTYwa11YOrFjtXiaxLlUFkEBDK5gq2OTMcZCEuS73YwDBNVG2PF8dgB6F1+GlPjh4bfeI8lGpQLYPh7Ke/5HABP3L2T/pVvi72G1ori7v8O18seBj0XJMrZCfzpDu5TcpL++ebsPPjgg00veOyx7V0wD2pYgB869k5Vky12KlMjeFM/AyBbeAZObzy32+i4KLv2xejt4U0oSDqewJs2MpSYLY+xvMoUpT3/TuBVMe2lVDtaiwdoFbPHcYUWO1T5rn5yvacQeCamsyJRgrIbSLTZQbb7EgAG1rXuoAxPX+wk5bUjAxkpdtpTlTnRYidB5WW15rNT3vNFlBzlt98c4IJrW8vhc2wHjYUgQCsXGahEi53pzk74ObGM1n73EWdfwejuwxFGhrLIE8hkuXkwTSGoy+dbHWPNJvcm3tlR05/FVgJm9zmuphr0kjQPjYRXBzHVWE3daY4//niEEPtV7tT/TwiBTIFAlhQMU6B9jY3BVMKdHelN/z6JEXsGvqRnWtUx6bp01vTGMmGDRMPswuk8F619xqyelsdYSkoqY7eFa2aPxs0uRyrVcrs8LmannrciOwfoWbqewcP+lrGhmkGX+/vGZ2mhUfWCaSM+pi0JWoVlG2jto1WVjAoDZ5Py2pGBorz3S4CJEsuB1seBT93zQYpjQwgjjy68at7OcS6EnB2B9J5CBbsZ3b675bUc28LLHUFB2BjW4sTH1eM7bsKbug8lTPJ9L2hZ6bf00JPJdFpoBZaq4MvkrBnqqFMI6p+PlqXnKSefG9YiMj0vRGmPZYed2toahsnAIW+kOKEwjA5gEql0YtfeILLJ9BdCjbVly5b4Z/UnBq8yRVD+HbJcQZj9TFUOS/T3Z7tWU1hyPWifR3Q19s11zeLpHKyRSplOQq+epMdYZmaAXN8VAOxwH225s2Nnco2vRc1vp+oHiZHG5awPXavFDszc8RkIAqUSIfW6QTAdsQAtGb9FMfLkT5jc+hkABrufy9bcusTIi0Eg0aW7w2/M+J4uUbilnSh/GGEUIMExVl16rmvdELPF3DgIx9Yji17GgBkqFpP+nKugiFZTNTNqoyVbhjpMywiduRGJE5SV0tT3+PWOYavS8/rnXOtw5Jp0sWOai8h2X4yLZNnhJ7W8TufgKbhe6A1muQ8RoHB9ST6z8MXO7E1mHOuSph65enXyplQHG0pjwxS3hfNOu+NZTFXWJPr7DTOHlQnzbSr+NuyYu/DufJa+jhyjxQq7i2XWpFTszHiztqHGMiyHZce+n8m9OlT/BFupeMkVO+WJrZT2/AdCOAzai3CsZ7W8VrTYMTFCs7Ekip1ZWUztdnai/AqnVoAmxdlRntt4JobZ3nvAcgq45QyI7Iyk6IWGG4RjrK7lH0RryQVXH9ryWo5lUtbTXjdJKrKUVAjRibD6kdpHCrNlnx0IOyKBp2qp58nHqUxuvx4I8CZWAV9qmaC8Z/MPmdj6JdABi3tfSNmNTxBuB/UurhTtvRdmdqgEAeF7N59pnizcKgJfhflewqJgdpCxj2r62JbuNI8//ji33XYbu3fvbpC16viHf/iHVpY86DGd0wIol6lywmOsGWos3dLNcO3iXkaLFbpHbmHK3YxWLuXxG4Hkwif3kZ632BERQlDoXU9pImxr24FBNcGdklceISjfB0Bn4ZS2OjtRQq1V89rJtzZSjwXXD+isPs7E6AcRwmbbg69gybrWhQW5rsWYmUMQRpbA7AFILKBVKYueZR9Ea4+eQ9qLQTnueTfy0C9qpqgyuQwj1w8o1G5IQphkCoU5jtg/HMtiMlKpJTnG8l1FbtHLyBGSSL3gqZY7O0oGGKKMCiYxRSb5hO1aTA8EqJq7udStjbEM02zwXGwdJK4grW9s6qTxVrGvsaBMTJHlV71GvlfWWRXL8iN2sfPFL36Ra665hv7+fpYsWTKDWyCE+JMtdrIdvfStfSnlCYFpD1IuJ9uCjKpCAjS5Fm6uawd6uXfLTgw51QhzcyvJzsDVjGJHt9zZgX1n4EkGT8ogsmsWZstFm+9W2Pq7G3BLFUxnFWbnyYldOKp+gKkD0FW0rgLt/f36Vh5Dx5K3AlAOhkDuTUypobTAsMME5Fx3e8WOHcnbaXMTHAtVP6CbWldK0JZU3LGMRmYbJFzsREikXn0k12Kx88Rvf8DwQx8AwOl7Gb452P4JxoAMJIbVh9Y+VqYn/FmLY6xMoRfDXo4QDhjJur5rrTF1GHKrRHvFjpZTSH836LATiQYvIW6eV5nOeVPCWlgH5fe///184AMf4O1vf3vcQ/+oYWcLDG64lJ2PjQNQqSabWlstjhK4TyKEDaqMbcbf9a0ZCHk7vnBqYW4ZZMK7i4nh25na8W0QNgMdJ7TVEbEiOwxbJOu1Y+ePonP5R3BVhSfkdpa37BdkUh57OPxGWGFkREIFgutLhHAwrCVoApx8e0XCbKPH8Hck1NmJqKbakWwDM0w2Ey12vACL0CTNtIy2SOqOZdE9eRtFbydol2rxY0Aywb+BGy12wq9bHWNF880M7TYk7UlBS+hc/n4Alh8WXj8bY6yYxeiSQ5/Fjk2harQcDJFJsNhRUhMUf0Vl7BtoYfHU/X/H6uNby3176ncfpDL+BCCwloQeYYlFw4gMncs/hNYBDwe7ycSw/Ihd7IyNjfGiF70o7mF/ErCc6Q+sW022szO67U5Kw58HoLf7udhW/ITqtTWS8mPd53Hk4tcA4OSTDW0NqhOoICwUc+K42HPvKLzqdoLKU2jtYVkdie6UlDQxrF6k7sDTI22YI9pQo3GCCiMjEuIlVP0AP3cEnR1nArD2xPZI92nm5mg1XexYbRY70Y5h1GJ/oeEGEhONO3krVibDzkdKLDv89JbWciwTJ9iNdB8FoFouzuepHhAzOju6vWKn0LuEfO/x+K6FYQ2gExb7Rosr0wpVx6ouPRetEZQhHCkleb2SgUJrF3QVoWkrE9E06zN2jVMbiSW1QZO+xrAWAVDGDcdYurlCK3ax86IXvYgf//jHvPa1r4176B89ohdR1006ZXuaIxQIg44WODvL+7qwTANfTb8xk5akKi3AyIPyMNpQmwDs/P0XKI1sBMBZ8tZkLx61v1tQm987LcZFCCE44QVf54n7xhDCwPI2J9YSdv1Z0vN5NONrWMkn1G3TbhG/8hhC2Ej3MKB1z6Di3kdxJ36GVhUy2UNRWrdVlDeL0NHaozr2nwBs/MVjLRc7GctEimnCaFCtHODR8wvflVTHv49WFTqFhPxRLY+xFq85hpUnXM/wExMAGO7GRC0moh1DwzQahQ7E7+zMHrsnbcYnjByGvRSpvZYDZgG6lx6PW+0EYWPX9mmJFTtPIz1XTV5jmrpCf/rTn258vWHDBt71rndx1113ccwxx2DbMxnYr3/965v6xX+MMB0TrRVonyBQiX7oMh2rcTrPQeuAotXD4hY6CZZpsLq/h927pnk6SZsK5nqeg+E8myntMZnZ1tZaZoQ07hAkzNmpFTvUi53W3wdWJouoFQdJd3ZmFjvtvZcNS1De80W0qtBnFqDzGYm1t0VxB+Xdoex9bPNl8OwTWl5rdOf9VMf/B4Cs3Ucg27MWaBZVP8DSqsGcaie+w7EtNnc9h3WLrgZhk+loPeA1LgJX4hV/hZaj9BgdkD+q5WwsmNkRsTEIZIJ+WpHOjmGJBl8H4hOUrVmdz8kEN2eBL3E6zsTpOJPdmUrLRTTAquNeSnFqJwCG/xRoN7Fx9WzpecY2qXgHOCCCpoqdT37ykzO+7+jo4Be/+AW/+MUvZvxcCPEnXew89KPrqExuQxidWEteT7HqJZZam+85ilxfGBEx5j3GoS1ePNYs7mHHronG94lLz4Ppjkg75GSA/jXPoloaBCODhZ2Y8kcrjV8NvViUVjiGbLmzA7Ok58JILDLCDQKyM+IJ2jUVNPErD4J2cazBsNhJqgCNhDVadnufyUy+s/G1rTx8KZMpdtwAS+TJ9f8V+U7BYc9s3Y3esUw8YSGMcOSQrBpLNlRHqpaM3U5xEuWChfJzRQIqZwDK47upjH4dIRymdp2EVJc0/s+M2e3zKiNURv4drT267GXs9JuXTbcLLzJa1G3WiaYdVY8mO66ulibwy/eDcLCpxFL5/T9TwRgQRt0UqoqNwWTFTazYmZl63vpOc+1AL/cEv8Ot3oLWLsU9JwLr5uks50Zj/NOmEgtg2eEXsndneMEw/e1UEsrHCnyFX/ot7sT3yQB9vc+fN1PBuvQ8Cbh+QFf1cSruE4DF1EgnmXzr3h+WbSCMLFq6GDqMBUksLsLqJ9P9fNAePcuPbmutZYedyuO/+WswcoyZnWHxmYAVQBBITDODWXgGPcs7WHZY6+aIGcucocZKclMTeIrC4BvQyuVBGao+2zIVnDX+CRL02qlM7GnE9EztsZDq4unzivmctKriFW8HIJM/ETdIzpjWi5DGdZtqrKfj5iV1zSqNbqG8558BWNZ1WiwSf+y7zXvf+17e8pa3kM/nZ/y8UqnwsY997E9Weg7Q0b8et2wijAyWJtHICDXLZ6fVm+uaxb0UglGq4z8AoNyZB543H6c4J5ScdiNtx2Onjihh3Eow+TzwJVpPF1ZSWLFUAbMxuv1O3KknQEus3OGJqrEsbxveVBi7UZ28BGi92DFtg44l14NwGCaAYFticRHa6ifb82cADKxb09Za3YOrsAuhw6ylpvCSUgAFunFFbjfHyp5V7CTd2TGdkDM16gnQ5ZYJykoGbL7r/RTHJjHtJdidZybqteO709d403IaUREQn7Pj5KbH7oZOduwepSu039mZ2WmD5PKxAnc6W1Gb8dp7sYudG264gde+9rX7FDvlcpkbbrjhT7rYOfr8t3Pv/z4FgB0MJVrszOjsoFqega8d6CWIEhf96gEePb+QvsQr3YMKdmFoRXbJiW2tZ86SnidlKhh4Cjt3NMLIMyInKZldbTkeb//9f1EdfQwAM/sPifrsGDqiNmmTMG6YAsPuAw22CrO+EpOkRu5/0SDPVmDN6iQkMVaUSs1QfrVb7GQsEysYw/N+jdYepdETaIe0HQf+00jPWx1jCcNkYtd9oBVoD0s8Cz/BYqfQt5bCkneA9lly+GEN2TnEf06F3gE6lr4LhMMUCtefmPugeYLvS7zir5Huk9hFTWXqMHKdi1paa+iRWygOfwetfAo9l4DpJLapMZ1BMj0vAOUzVeid+4AIYhc7+wspfOCBB+jrS86JNw3MbqdOVZtkRs0D9mz6KlO77wnJht3nYbfYFenOZxE9KzDMV5M18mS6ls3zme4f4fjnboLKA2SBrHF8W+uZkW6KhUElqRwmT2FlD8PKHsaY3Es5GGpzjDU9I7GESswS3/UD6HwWhcIpGIZk0crD21pPCIFVt/ZP2GcnagrbrvRcGAIlNIYW2CQTUVD1AxxMtA5AuRhmF1qpxug8LhzLosPbSWXihwBM7jGBs+fxjPePIMIPcRvS89b4YEIITCuH9EuhsV+NoJwUhJHHyoRj/o7elY3Ec4gfF2FnnEbHy1QlXH8ksdDfwJME1Y34pbuxi+BXX99yseNV9iLdzQA4qgqmk9gGzbAGyHY/F4BSRzyBS9PFTm9vL0IIhBAceuihM14gKSXFYvFPXo4+0zRNMJlgZydwR1DBMAAKhdNGJ2HFkuXIoAPbyABt9jRjIPDVDE8EJ9MeEWLokR8xuf0LaOXS1XspVa+9TlGziF7M/VpnpB3+0ZqTX8yjvz4ZIWxMzGQdlM3FWHYGO2Pi5DrnPmgONEIba+3tpFr1UfM/q83xqFYKqSfRfhWLIJGba9ULcIRJUH2U8u5P8cB2UO7VHH/xX7e0Xp2gXIdMsIPrlssE1U0II4OQU2DmsNq4Xj3jxTfx0O17EMLG8rcnmo+lZqmxovFI8eMiBMIIm1QWoYw9kKrljWsc+L6aMXpvp4trOXWeqoVVu/4l1cGtc8+U1jgxqQNNX6FvvPFGtNZcddVV3HDDDXRHLNkdx2HNmjWcfnrrcrY/BkQ7CbYwEx1jaawwmFAHSGG29QFZM9BLsD089yDBgEDpK7I9l6LkOWyTYzhOfu6DDgQh0XIcAFt7jCU2xooUO7X5STtjrCUbTmfLgwMAmMHuRDk7dUVJux47dahgB15pG0KVcKxcYu1te/RWJsdvA+Ewsu0GOhed1vJaXmWS8lNh7IXIHokfnDJfp7lfuEGAg9FQMUHIEWkVGdtk1O4j2/dShMiQ6249VDQuKpNDlHZ9FIAjc0fy2+7zsNqIvsgWuhFiHAjH1UmOsWTUmds0ZknP428U65uBek5V1Q8SKXakr8j1vgjddTF7u4tkO1qfwhxyxhUMPXkSQhjslKMQ7Ejscx40BC6KjBNvg9n0o6+8MgwIXLt2LWecccY+/jr/F7Br0+2U9/4ArTyyXedQ9trfCTeL3pV/hd3xclwtqXoPt3VzXTvQy6OEPgmocPfSrsdKMwg8iZlZjclqJoPdDLbZ2cl19iDM3jDyQDgJEpQjxlaNzk4bQaBWVMqZnBor6rPTbsRCY82JX1LZ+2MAOvv+HDdIxqFbqCpalYAS7Vqw2NlpwzWh3URurvUxljA6sLJH09Fr0rGo9RGzY5mUzE7s3NEYQszwpFpoBG658bUvwoJt3qTnGAQquWKnWhxBuk+BsFFqENT0Bi1uZwdA+U8SVIqYSDDC170zt/BSv8BXofOwtQjZU8W0Wr9/Oxmn4QuWtBqrTrT2UbFCQKEFzs7ZZ5+NUorHHnvsaVPPzzrrrLhL/tFgau9m/NLdANiFkxJN2a7708iGiV3rN9fV/d08FDyEFEVAEPgKJ4liJ1okoNoqEABWHXsuj9wdBgOOykmqCRH+Ak9R2vVpAncThwmTR/v/sj3OTuRvb4oEs7GCAEPtJtAegZtDBoe0dREEMO3pm4GtvcR2fIgchrUYrX3sXHsdQ8O0MDtPwFAOhr0kEd6R6wVkhImV3YCVfT0n/9kalm7oaXm9uu+TjyKDmWgHV6kOnM7zkaLKXiMsHFtVY8FMrqSdEGG8jr2bf05x+CYARrf9A92Lnjl9Xi0UcBPbP4MKxsHshcV/mRinLarGMtpsJM3kroYFX1JqrKnh71MZuwWNRVfPS2IdG7vYueuuu3jpS1/KU089tU++hhACGWOeevvtt/Oxj32Me++9l6GhIb71rW9x6aWXNv5fa827JeTZjwAAmD1JREFU3/1uvvjFLzI+Ps6ZZ57J5z73OQ455JDGY0ZHR3nd617H9773PQzD4PLLL+dTn/oUHR2t22HvD052endk6YDJBIMn66nnssbEbMeRdEVfN51D76OIxnTWIP1zIAG7oMCbVey0YcQH+5qNJdbZ8WSYEq6r2DpMPW+n2BGGQqtqmPGlZSKcBKkUgVQEE9/FrdxHaRjc4onkewbaWrej/3jcso0QWcqmjZ9UEGj3eXR2hRYKi9e057MDkF/zNxiT4WctmvW0UAg7O5GbeptqrPr7MagVO0lJz8PsqEXk+v6CqiPZPhWG3LbjszOx6yG8qXvQ2sXOHp4oQTkIpqkKVsaZGRfRArFYmA4EgA7FLYn5UEWKXdHmyHqGz45IrrOjlEb5ZVBlBMQe/8W+27z2ta/l5JNP5gc/+AFLly5ti0leKpU47rjjuOqqq7jsssv2+f+PfvSjfPrTn+bf/u3fWLt2Le9617u48MILefjhh8lmw7vzy172MoaGhvjJT36C7/u86lWv4jWveQ1f+9rXWj6v/WHD6S9g8++XIUSGkiDxIDcIDQWhvc6ObZkgHNAuWrtUKj65zvZkx81A+grl7wFhoGSxbVPB2eq4aoKmgoa1CK1KlFQFjdHW67Hxti8wue3rAGQWX0PFm/9CfTbqO0pBZMfXZlcHoKPvcIrj4fjFdzfi+kEiihNDT69vzgP/KMLtneE+u1Co+iFBuQ5rvoodFaCFxK8mQ1BWUjdCWZURCWdtY3O29YHvURn9CQDOkrckSlDOda7D6TgbrX0Kvcvw2yAoA3QNnEt5YhJhhBvnpJyHZaAJ3CcBhVFp7/PhlvbiTv0CtIdjD4IhEnkevisRRgeGNUigXaxMIdbxse82jz/+OP/93//Nhg2tu3vWcfHFF3PxxRc/7f9prbnxxht55zvfyQte8AIAbr75ZgYHB/n2t7/NFVdcwcaNG7nlllv47W9/y8knnwzAP/3TP3HJJZfwj//4jyxbNr+y6nxXL5YziK75iFQTVDiUR29FyQoKE7LL2ie19ZyA7WkMs48deyboG4j3xmkFgS8pDn8QrUocYvaStT8990EHQChLNZCBwk7SVNCT5PuvBuCn3ibQlbbiIqwId8nSAePuwhdtVT/AxsDOHYdh9ZMtCMw2YxZgFokfg4oOCJRqi2PWDAwtQIBCI9ogwzbWMw10rRBMorPjBhKHyN9uHoodoSVs/1smASu7AWidtN0soh47QcSpt53OjpONjEaVn2hnp9B/PLlFqwDoXbqeIa/U+D+jhefUt+r5qO1hAr3p/iGxiBvpKyp7v4QKdmHvzcHLXtjyWsXR7VRHvwqA3XkeFI7ES6BD5Vclme4LyHRfwONyjO7+eJzZ2FfoU089lU2bNs1LsXMgbNmyheHhYc4///zGz7q7uzn11FO58847ueKKK7jzzjvp6elpFDoA559/PoZhcPfdd/PCFz79C+q6Lm7EGXNycrKpcxJCYNZ8RMKbazKdBK017sRPUMFeDKMA2avavnl0HfFXGDvCi8aOvZMcw8L77QS+Cn1EqLkOtznG8ipFKuPfRHpVTGsxXmYgkXDW2eM4oC036K7Fq7CyR4CwEWaBkrvw/k2uH95cnc5nAbB0Qzd2pn0S6+zRIjr8XQtd7NTLG0V7Vvh1GPZ0zyuRMZYXEpS94t345d/wm28s4riLrqZvRWuRAoYQWJaNxkQgUcpFKR3b9TcughnFTqQL0kZnZ/XxFzC8pROMLIbZm6gaa5/U8zY7O/smnyc05g2mr70Y7dIHpjdFRk09mEhnpzr9t3K1XHiC8ute9zre/OY3Mzw8/LSp58ce23p4XRTDw6GnzODg4IyfDw4ONv5veHiYgYGZHAPLsujr62s85unwoQ99iBtuuKGl86oXO0lyRMKYhfB36Zr7cTsp2wC9XXkmdoQ7jL1jpTkePT+QnsLOnwTaZUwYbY+xlAyojISmaSJ7NGQGqPoBhczCjuSiZD9/HsaK65/xXB75TWg2NqGKlN3miu92EI5N5o8jUkf9Yq51QKZmKFf1AzqyC/eaaK0xJn9BRY6jDAsZHNM20bq68/u4ww+gVYXC5Nvm6Uz3D7f2eih/iKDye7Y/BIef9edtrelYFjKzjowwMa1BpK8w5ul13h98V+JO3IJX/CXCdOjrOJNRe7Ctzs7SQ0/E6QxfT1NNJZqNNSP13BQzTAVblZ7XYWEklxYeaJzOZ6JlEXegvetuZ/9yOpddReCZuNYioJQIZ8erRswqkbEFLrGf9eWXXw7AVVdd1fiZEKIxl49DUE4L119/PW9605sa309OTrJy5dxW6l61GLpQlosYZjdVKzlyWb7/KrSqsleHHal2x1iFvE1du+S6ybxmga/I978SgEe9xzm/TTXWtLlVKBEGqHgJFDtutLMT/u3aeT2iHjcWRkKdnWDG2MRqM2KhDq+yg4mtbwTtc2juWIa6z17wC7rrB1C5D6/m6irEu9teU7l7kO4TAMjKVNvrzYWGgzLz47MDoR3C1OLXsMgMPdFkoOatqN0ffE+i5Dgq2IMRgCiExUFbaqxZBUKS0vNoZ8e0xIy4iFYIymbUZkIYiRGUVaAbzsPeUe11PzOFHjr6z6I84aF0AN7GRIo2353+HVVk7M1y7GInqQT0JUuWALBr1y6WLl3a+PmuXbs4/vjjG4/ZvXv3jOOCIGB0dLRx/NMhk8mQacHjZWrPdkY3fwwAq+MsKlZSjr0KKxta+ZflOATb2h4LZLPTO98k2vQwqyMyD2os084wePj1FMc1wuhAqF2J2AEEvqQy8lVAsFb4bO46uaULXx0h90ggg3DoUE6IszODEOvMz+jPyeQaxnh2TXGy0K36kusjlF8bYBkYZnvvKwCzPtITDoG78OahbhC+HtmeS8kvvoRz/3ID2UJPW2s6lokfGeslocgKXAXCQhgFlK7i1zrR7XR2hCFCo3dVl54nV+wMP/JFiiMPg7Dxq1+YEQTayhhr12M3M7n9F2jl09n/ssQ6O7OdoNtFvYObpBrLr0rcyZ+igr0sVhUcES+xIfZVYfXq1XEPaQlr165lyZIl3HrrrY3iZnJykrvvvptrrrkGgNNPP53x8XHuvfdeTjopTCn+2c9+hlKKU089dd7PyYpwGoT28QOZEEdkX8fedsYmAHs3foPi8J1o5aJyrVnSx4WcZcbXrs+OEIKO/mOoVsJxnOXuSWS06LsSr3g7oFlpD7C9r33ip2EZyEAm19mpOfYWd30CHYzxyG29HH76zW2v6xS6MOxlCCOHZ/WHv2uBvXbKrk+m/ypMVcWz5udv13fUSzH1pQhhUWnT6LsZVL2APgyEMLFzOQo9g3MfNAccc2byeZBAseN7klzvn5Pr/XMeLYwzObIVaI+zA4Ch0H4ltGZIsLPjV/ag/CEg7H6266CsVBUtwzG1o1VinR1d61AFWmHFTAt/OtTz55I0FfSqEr98H9J9nEEg41wb6/iWtkBPPPEEN954Ixs3bgTgyCOP5G//9m9Zv359rHWKxSKbNm1qfL9lyxbuv/9++vr6WLVqFW94wxt4//vfzyGHHNKQni9btqzhxXPEEUdw0UUX8epXv5rPf/7z+L7PddddxxVXXDHvSiyAXGcfvSsvpTwlMJ0VDQXQQvIRYGbnxatzRNrs7Pil4UaYm/LLczx6frCPz06bnB3Y1121koD8PHA96smTEqvtwnNk20amdn4G6XuIwkn4djd+IBfURr5OiFXBXnSwl+rU/CgLs4UOOpe9B4Dd/nZQYwu+ey1WXWx7GYYQqNz83AidbA4hwsJJJtBJCLOxws1Uu7LzOhzbJIik2ifR2dkn8VwIjNq/VrFj46+ZeOINABjdz8UPWlcSxYawQGRA+1iZLFJP8+la6ew4uWnXdxORmOlm3actQLV03lForRGGh5JThEFGCUnPq0HDn0ghyGXiqUdj321+9KMf8fznP5/jjz+eM888E4A77riDo446iu9973s85znPaXqte+65h2c/+9mN7+s8miuvvJKvfOUrvO1tb6NUKvGa17yG8fFxnvnMZ3LLLbc0PHYAvvrVr3Lddddx3nnnNUwFP/3p9iTN+4OT62Tw0JcwtClku9juRqqev/DFTsVH+rsRwkaqsItht0lQbrjMChv8ZNLby+ObmRr6F4TIsiqznIz1/LbXnJ18noSUMwigY9n7KKlJ7vO3taXEAnBLE7hT9wFgOqvA7qbkevRYC2fx7wYSWxgIkQMjj52dn+iTKL+iHga64MVO2WvcTI15ir2wIxwm7c+PwutAiPIR7Mw8jRQti8LULyn5w6BdqsUPAQtrMRFVY3mNxPP2nk+Um2coL1Hp+aJ1b2BqpIppCSw7M6Oz04r0fPUJr6BcDu+Rvv9Ucpwdv8rk9nehhYV1zxFw2j+2td6WO6+Gmimt1XdpIuM4z5Xk+v8Krcr8zN/MMQvN2XnHO97BG9/4Rj784Q/v8/O3v/3tsYqdc845Zx8X5iiEELz3ve/lve99734f09fXtyAGgvuDOdu1N4EXuTI1TnHnOwFYnD0Uei5sm7Nz3IWvZ2LsuQhhMGYuvPoHwKtOoLywrZ2zutoeYwEofw+Bux20i20kYwcgfTDtQXzdzThVVrVZ7Jj2NH9M1FR3Jdenp7CAxU6NENu57F0AnPbCeF3Z/WG2tBYW3iW2XJou1g17fqTVTqS7Ut8VLyTqXc+g8gjueMC23w+z7Igz2lKVZSwTx99GUPkDAG5pClh64IPaRLQLXVXh1+2O+bMdvVj5Q0A5mPYg1SSl57XfVc8OjBKUzVYIyrOl54kVOx5ajoXfVNqbegghEIaNVl7o+o5BVUsCqdoubA8Evyox7XC8O0xl4QnKGzdu5L/+67/2+flVV13FjTfeGHe5PzrsMzZJ4ObqloqNr+vBeu2OODKFXCPMzZAL671Rh/Rc6kzDQDjzMsba9uA/URoJx6nOkrcs+I1VBqrhEFvfuTptFm39q49i+fH/xNSIRGGD/8iCk5Td2fEE80RQnv35gIX34CiVfAL3CYSwMdQ8hfMGk3hTt4cxHuYy4OQ5D2kHslbsuJP/S2n3RnY9DFd86Lb2Ahstk0BMH+9VFt5ioi491zqgMyPBWNdWtA1A9+Ba+o/4eyp7w6J2PCGndJhOPa+TeqME5VY8i2Yqy0QixU7gK5AKYXajtIfhtE9C6+g/jspUBcNa3PDT8oIAy1y4Kcc+0vOFjotYvHgx999//4x8KoD7779/H8+bP0VM+4ho7ITGJlKa2IXT0brKlNWPZRhtzcABnNz0S2+rhQ8BBbByx9G16nNMqhKP+4+3rcYCsOzp7oejgwUvPqMkz0ax02aXzbQcnHwfYqyECRiIBScpz3c8QR2mbeBO/hTpPslSNYHRfe6CX9ArpTLl4Y8AYJc2AM8+8AFNQHgjVEb/HQBtnNP2enNB1kZlDeM3Znb8WoFjmezoPJdVvS9BGA6ZzhVtrdcMAjdUzGg1yaDVDf3r5kXAYUSKaJlCZ6dOsFbz6bOTkPTcqwQYZhddKz7GZjnB4We3391bd9r1PPnAXgAsL+TduoEkv4AB7nVTQU+HCZEL3tl59atfzWte8xo2b97MGWecAYScnY985CMzvGv+VPHIbW+lPL4dYeSwB1+bCCHWtHvJ978KgO3eFmyrfSmsZRvImr+qU0sSXkhCLID0JUIIAmGCac9Ly7N3xTOolLpAZLCFteBqrMCTqGAc5Q+hCXCotE1QhlnJ5wnIz0MH5WhnZ35ee8s2CaqPEFQeJAc4nWcuvM9OcbrzaTrzw0np7u2Z/iaozMuaB4KqFdGZznPpP/Is+pZlEG3GU2csC9fMY1g94e9IYGLiuxJd87yqd5Xm43NuRYoE6SVT7GitKe7+Qeg8TT9w5Cw1VvwNZ2l8M5Wxb4P26cyspuIvbBIBgFuefuErBC1xjWZjdocKFl6R5VZ9gsojVIVJXk0ufLHzrne9i87OTj7+8Y9z/fXXA7Bs2TLe85738PrXvz7ucn900DJMu9aqPsZKoA05Q+Gg2nZPBpjauwO39AtM6ZFx1lH2fLoXsNjRSjdawj6K7DyMsABWHPU8xvaEfkfC37bgO6XAUwTVR6iMfJleYFXnWTj2IXMeNxdmmI0lID8Ps7E0lbH/Rhg5hh4fYe0J57W9rp01GyGHEHrtLLTiJPA1ma4LQFXoWDI/3KP+ZSvJ9f0lwigwkemelzUPiNpnwy6cxKrjVrD2uP62l7Qts2FVAQmpsTxFYeB1COHyG12TbM/HzTXS2VEJdXakr6iMfhcI0N4q4NUzfXZa6K5XJ7fjTf4IgLxxCWP+2nk62/3Dq0xvnCo6aFuNBfterwC8Bfyca63xK2VKuz8BwCnOSjLW1bHWiH3HEULwxje+kTe+8Y1MTYXOop2d8zQn/yNAtmsZbkUiRLY2xlr4zo4/Q7I9PzlDozsexd/7NXzA7rmMsuvRnW8/CHJ/iI5/gnmSncPMi2ASr0fgSbSe3ukHhtO2GkvJgOLIb/GK4wizgGlYC9/ZCQK6lYs3+WMAttw7Oi/FjpM1yfa8kEz389iDZkruWvAC1JcZenrDaIVlx7RfJADku7qwOp+FgcBk4U0FReQ+MX9qrFnS8wQk9IErsbKH4uQshss2eP683FxHHvtXyqN7EUYBubS9GI1mUZ4qA+F7t94xbNdnx47IpU0dJJKNFe3sVHUw78VnIwNvAZ+L9BUq0mH1W+B8tnXH+b9U5NRx3MXv5b4fh4oiy9+RTGfHmynn7GrTRh6YEfpoaI9SxYPetpfdL6Sv8CsPofxdCBSF7PJ5WdeKSs8TUMcFnsJ0VpHpuphdcpQJaxHr2ix2tJLsePDjAJiZQ7D6XrDwnR0vYLGa/h2ZXMe8rGuYBk6+n8BTZFUV1O4Fv6BHxxr5wvwQJIUQ+EKR0Sa2no7DWSgISSPNdL6iOzK2iSEn8Mv3o7VLcfR4FlyNVetC2xkDWQxfF2seNmflvfcRuGMIsxcvIcd3r6opDLwJrSss3RDyUaOcnVYIyv2rj6Ew+GYQDkNCJMLZcSsB0t+NX7yDXl3CGxZwZHsdpR1/+A9Kux5Eaw+n77Lw9yzgGMurShA2ma6LmZATDJuZ2PSB2MXOyMgI//AP/8Btt93G7t27Z6TAAoyOjsZd8o8KZkS1Yotk1Fij226jOHQLGFk68sfgmIe3vWbP0g1YK67EqWYwnOUUpxb25hp4Er90N37pLjqAQv8187Lu7M7OwhOUJVZmPVZmPTuDIcbk3rY5O4blEN7pNGgfE0Epgc6ObS3CGXwLVsbjsGeeMG9rO1mLwPPIiPDystCcHRXxwenomD+GpDQ1BJAh5ILlM+07zz4dtNYYSoAJWs9ffpVjmXR6WymPfx+A8aFXAfPvLF+H1rqxMbMcs+GHY5nzMDaxcwTuGFpV8ZLK8qtqrFx4re1fHcYPzVBjtVD85rv7sLJhkr0hx3D9kXk40wPDKweoYA/u5P+yAnB3DgKXtLVmafRxgmpoaeAoCQK8Bfyc+9UAw+wg2/tCtshRdjAc++8fu9h5+ctfzqZNm7j66qsZHBxc0N3OwQhrVihdIpV5cRfSexIAkTu0bUNBgHz3YpwlZ2LvCb8vFxe42PEVWk279JqZ+fHg37XpNqZ2fhmtXLq7L2bcO2pe1t0fZrhA19RY7Y6xhBAsP/pKRnZUMcxuLAzKC9zZcf2AjJHFzB5K56Is/avbL6DrsLMmTEKmFjS60JwdHQlrzOfnryBRhkTJCoYqM1GsLFixE0iFXeM9TG57I7d8MqB32QYuedO/tbWuY1m4YvoSH3gLS7SWvkLJKioYAd2HIV2U4cyLGuvI89/PpntGESKD503MfcA8wK1MX9udfPh3bHeMNcN0MyGfHbcSNPLqAIw27AzqiCoF7dqobyEJylFnblcHZJz4Q6nYR/zyl7/kV7/6Fccdd1zsX/angGiL2cGknISJXeBR3/kHwm5b6lyHlaml6wGV8sJLtjPdF2LnT2K73IOVnZ+xiVbVRnaNrauJqLHqqJM/50PFtvTwSylOhaG2prd5wTs7nicxaz5L852EbZpV/MrDoMr06xJVf35GlvuDPXYXk2M/RRg5xra/me7FZ87LumrHjUyVw+Tz0dFvsnRR17ysOxuNxHMddvaUDFCq/RtHxjIZNXvJ9LwQIRyynUfPw9nuH74nkd5TlHZ9nOIQHFk4kQc7z2zbZweg0DOIYYafbZlQxEKU65KpWXWoNoNA7ez0Zy0jzGSk5+UAM7OewsAb+Km3hb88tP3Px1HnvYl7vcsRwgY5Amrvwo+xamjFYwdaKHYOP/xwKpWFl2IerBjZeheV0R/x/7d33mFylfUe/5xzps9sr9lk03snCSkQCZBAKNLkSlUpKoKACILgRUX0Il6vBXu7KCog5QpSBDEEAgRCS+892ZTtbfqc9t4/zszsbBrZ3XM2BObzPHme7JT3vHNmznt+7698f8JUCYZOJqk6l9SbIVj+H8i+84iaMVq17Qy0qWrK5XNhYHkQknGH8yrS4R+8I2jVGwnalAztC4VA8iJJXtwoJB2WAuims5M2duzQC8ptc6BIznt2cvNc7DZ2DHUX8aYHABgcnE1KH2fr+Acia2GE0YowQJLt+x1L7mC2Z3h7SxuMckanJqXpeCQZMFC8IygoNSmsGNzncT0uhXZXCE9gNrIkITnYfgTSZedmVzJ3pvTcDs9OrkdE10zHc6gA4h3tGFqDJTOSdmT01bMjSSbC2I+hq/gAA+G48nAqoSMrBeAbR51sECjt++/YFypCVqykbZdprR+OenZyjJ2kMAj2okVTj1fpX//619x11118+9vfZuLEibjd3V1ihYXO7H4+LHQ2bkCNLAHAH5hMs2ZP9ceR0FQDSZLRJDdCUmypxgLweGViRgRhJjCTziYu5oZ/dAzb+omNmHkWm9+zPAdRM0pCbbZl3MOhqyaxpp9jqHuZIinsK7vUHp2dA3QrYg57DE3dxNQ7EGYcYZoYutYntd5cPMGuwgWfUIk6uHsVQiChIMkFCDOBL2Rf0YS7cDiGaiLJwW4tKewm49mRJBfB6tv45C1TbbmRZ36XSXQCuFETDns9UyayUoQ7eDL+QkFnohiwp/Q8txBBSefmBbzO9iRsrVtGdP9vANi/6TbKay/rnqDci+9IT8UJ7/0OAC7fOCheQFLTCTmoPJzxUCXT4abeJFYfyKHawjgZklOTOqnIElKdLzJaUmgu+GSPx+ixsVNcXEw4HOb000/v9njG0jaM/nExHis8/i7RMq/QiTscNhGmyOpjZMImdtxcAVpe/zp6tAFJDuId8lNbxjwcuR4RTZgU+O1JJHW5FRSXhKELfLicT1BWDUy9E2F04EfGRLZJVFBK94kz0jk7Dhs7mkCNvkaq859srYfB435Gzdg5towdKq7GW3QukuSnU/E4mrOT0g1cRQspLD4fTTKpHG5fonXB6AvR5LTnU3cmXwe6jB0AIWObxyJr7AiDgOQmFdcd9YhoKQPFO4SA9yoGTytj37IlgD2igolwHVpsOUKk8LmriaacN3ZS8S6xSn96E2/0MYzl8ReQSUmQTKt9R0rTHWsmLYTIGrmJtDq33Z42V6bhr8M5O8KIIIx2AkDA3fPP0GNj58orr8TtdvPoo49+LBOUR8w8lz2bK1CTLpJyAUnV2Saa3cMm6bJOuzo7+wrQow0IM46edPbmaukkdCDJXjRhUGDjxe3xu0hENHz9EAPXVRNZKUCYxSSFCZJki7Gz9qU7CTesB0AZ8E3HS88xBMLsCke7/fZ5RIIlFfiKLwAg5bDQYzylZhOhTcXeG3kg6KEzE+ZNOHd9JLNhLBA2RhQ96fBqAh0hTAxNxdBM20rbDyQ3iTS3IasdN9f6TS8Rb3kSAF/5F4gmU1QWOtvBHaUSd3A2iARFlVbop89hLFmmsPpUkjGQXZV4cXbN0lUT0xCYRoSk3kxADyMbfV9b4p17UWPvglDxuK2ogOqgxISWNEByISlFaGYcX6Dn61WPjZ1169axcuVKxowZ0+ODfRQIFlcRKhtNZ1MCvxAkU86W2mspAzW6FCF0S4bDU2ZbGKtw4AS0mA9JDmE67BHRVJ3IvjsBwVj3AEK+H9k2dtbYwYWqGximacsCeyh0zSBY9VUAnkltBHR7PG1SuvQccEnCUc+OKQQYEop3GG7zJEIlgkChfeFYj7/rfPgkhRY9eYRX941oUu3yith8Dw8GPWTqfjQHQ0BW64705F32GWvedOjHv/97hI0OZPcAUonHHTN2cpP3pVyFXTvaRfi6qjfdQiOadHgzACjuCQTKx+AvcFM5zKry7GsjUIDaKV9m7yarA7lP3exo+CdTUaZGXyfU8QznAZG6oTCkb3k7TdveItHyvwB4Sz8LnmJHc3bUpI6v6Gx8RWfzSGoTZ9eM7vEYPTZ2ZsyYwZ49ez62xg50ZebLkoThsMCVrhokO19A6C0E5CBUXmtbGGv82V9mRccuAKKGsx4RNZEgczPXJTeFNoWxTEMn3raIZHszkhLC6x1IUtMJOuTizs09ynja7EhQDpUOJtoaBsmDSwhU3UAz7FHLPhBVt/pieYKz8ARnMeG0gQRLKmwb3+PrOh9eFEfDWLFYKps7IdloKAAUFHQl0Wsp59SHk0kNlySjxdegti/j7ScGM2r2BZQNHt+ncTPrhMAEBMKIkorrBIuc6daY69nBZmOneuRM9qyPgOxDuKuJOWzsCFNkDYXcpsl99ewcOJ4Pl7O5LpnCk24NZm0QpfXnNGBO5wI5eZ1rB1RjFfh6/hvu8Sp98803c8stt3DHHXcwadKkgxKUJ0+e3ONJHG9kNBegm3yBI+iqCWl9GlOyvmC7boChkBdTCKtSw+EKSEPVcQVOADNJp1JAyG+T0q2s0LrjUYTQkd2D8PkuJaE6aexYF52VXZPuZ2SD8Tlh/q1EozsAkPVGMMLEUxpFAfuNnVROjgjYp9ibwe3LXcwlUppzuSKRmEqy80WrZFsvBKbZNrac2k+s6RcIMw7JE4CZto2dSyIdIjO0fejh5WxdtpyasbNtM3aS7mqKlGIkpcjRJGVdNUh2PI+WWMW2fxcQ1KcTcxXZkqBcOXwK3qJ0dZfR6bhnR00amb0Z3pz13hR9y9mB7saOX3I5GsZKpSVFFE8tnf6pdIoY0wv67sUdMOoEAuWXIkw3pmco0OmsZydtSBvCRKd3OZ89NnYuvfRSAK699trsY5IkfWwSlLVUAj25Ez3ZgKQUIUnC0aQ/XTXwl30OYSZoMK2EObtydoJeDykM/LhQHP7ahPASrLBUkzepW7iyF5b5oZAkCZevCC3RijDDjicpZ3KohNK1w+urqCAc2FjP+n/MoX5lqZwcEbC/9NzjV4g2/DeGuocaFMyqL1jCeQ40mo3HNNTIKwijEyleAnzVtrEDftATa60/ks5pBaWS1s1OpBNWAbyBvjcfzXgcd5Rexifc1vxTDkpMaCkDU2/EVOuINoBUbiWL2xFSzjU4ApLLcWMnlZOj5c0xTkyzb9VYB47nQ3FWnyaRzvMMTGOXu5JNZjtXD+h7s9ySmlEUDTibeFjFFDqonQ7n7KS9R2lvem9yPnts7OzcubPHB/koEWmuY/OSrwPgDs3FUzjPsYUcrLJzd2AqAG16PRgttokKul1Kl7FjOqfzAIeoxrIxQXnYiV9m76YIslKITzJIOlghl4q3kWh7FqH4GIBCvW+YLWHFbjo76VJOp/J2kg57djw+l+U2FyoSEgiRbk9h/zWSiKvZRGu7dWSCxV3N4iQbkjoPRyqp4wJ8RedRMPpMZs+roqC871oomfOdoOt6cNKzo6VMEAKwxEozOjt2hLEUl4zskTBVQVByO57Ar8Z14s1/wNRbqUsWM/XM31ibeRvCWC27Xiay/28II0JpyYUkNedU33ONtszvwI7GrGB5qOJhq0BAwtkwlpo0SHa+iGrGGCUSFPjP7PEYPTZ2hgwZ0uODfJTwF3XlNgi9HT8uEpozCzlY2hUZVJGpxrLnWK17NiKaf0PUSOIJnYxpnIBsQx+bQ9HN2MGwrfQcoGrkHBp37wXAp+0l4aCwoBZvRY28CsCAwCTL2HH3/ftw5fb4SntdnFrQU5qBR5KJ1t8HwLp/j+XUa79n2/guj4zsrkIIDV3yomCQ1AxCDuhvJhM6wcpbESKOp8ZeY6ewfCD+QT/ELYeI4FzOjpYycAGS7MVXXEzpIHvyIb3Z0vMuAyflcBgrUPEFhPg8Q84p4fGnXwfs0dkBcAdcJFMpAkKiMeGwZyeuY6h1mHojsbZA1nPf19JzACQVU9sPQMBMOJugnOPJS6TvH7JN30fG2yZJkpV75JBnxzQs+RU18hqS0cY4OdCrnM++Z1Z+zPAFi6kZt5DWfTKypxa/ZIVN7Eq4PRDtEO0J7PLs6GoCObEBAzD0kVbGe9AZPREjx9iRXBJet30/Pe+BMXCHPDtCCAw1nv1bkyzvlB3fR/POpcRbngehESo4FSQcaxmR1HTcQsZQ6wBBpMVeK0SSJIoHX48a14kIFcPBihM1qeP3WW75woH2tCDJICsuDHcIj+nCI3THlG6tPLBM6w77rgvPoTw7DoexIK0T5PGkKwwtDam+0rZvC81rr0eYKTyhU0nELujzmEfCMgrT1ZGerkowQ/TdsxMsLgXJjSQXpFXf+yFBmRydHZtSLrwBF0IYgMAnKY7l7GipdJhXWLmrmuTpnwTljzuSLDP9gm/w+t+2AOA3Wh3NEVETybQ+jR/VtL50uzw73mBx1x9mylFjJ9K8kmjj8yB5qS3pedngkfAcEAN36vswNBPFO4Rg9TdIuKLsSlrlox4bDLdw8za02DIA/METQXE5FsZKaToeYYDsBzOBx2+vkQDg8SmocR1fthmoQ8ZOysCfPobfxiagGUwFMK2qsnA8SWmBPQ1sc7Fad1g3Tq/PPg9xxtgJpPYQj7yDMKK0F5wNOOOdzxg7ikvC6LIJcMs25LS5vdlWFEIkHTXawDISCgb+F0KYnHhOl7q8HZ6dYdPOYMv7Vg5Vpxnpl9LzRNsTzE6uRUfBTJ0Jffwdt+3bwroXr0YIHU9oHv6COY4ZO5m+WMHKW9irN7HKaOW6XhS45I2dXpCbLOfHOU8CQLhpC5F9/wlAbfBE9hbMtqWxHkBhxWCiI79LjVqBJCkkYhqFZc70z1ETTRjJTQAUl/a9708uitvE1FowzTABSXGsGaimGkiyH5d3GIZPJaJvBuxJUHbldBH2pis+nApjJTUdj+KnqPYBhDA57Yv2966yys9TuCUFOV2R5QSWVyR9Uw/YX4EnuQHN8lZ0dCYcNHZAiy0n1VZB2z6V0oF93xBIacFLd6IDLboUgHinc/khmUpFl0fpbhTY4NnxBgrxBCowjEJk9wDMpHNhRegK/0iSTKCkK1ncjgRlj9+dEVHG73DpecbYMfQGSrVGwC4FZTdCZDwuGn7J5ZxnJ23suLzDiCgFRJTCXlUk542dXtDNkyA5W/2jJbokyzXJOq5dOjuy4kL4C5A0a7xoNEWVLSMfjKF2Cct5fPbeMBq3vUZkv5VzEiq+iKQ2ytbxM+Rq7Gg5ORx2fB8jZ19I055hRNoMJLkQSdvsnGdH70pQlhQZj89+A9eT46FwsuLETEQx1BiS7MfrcaBPXWoLaqQVYcZo7/wMONAL1NStis54y4PselWnc/NIPnnHo7aM7XEppOSu71dLdB7h1X1DSxmkwv8G3UvH1i5viB05O75QCXOu+AurFu2xHlCdFXPNzW3K3dzmJij3NvdFkiQUj4yRMvFJCrF+CGMJBALLxsrdWPUWtzdIqHwkiYhAdlfgk1x0OpQrqSZzcs56qbEDvTR2Ojo6+L//+z+2b9/OHXfcQWlpKStWrKCqqoqBA50r0fywoLhkS61VN/ELiYSTjQ6lAC7/FIRIEVaKAfvCWNC9oZuTzQ7dBfMp9M2l3eiEanuToEMlXTc5txlzzLPT3djpunnbYez4C0opqBhKLGzdjAK4HExQzik9t1mIL4OW3Eai9WWEGafaN8yx3avUuY1ovaXk2rrpWkaNv97W8Y2Wl9DCGwGItJ+LE9aO0AUIFdK5NR4bys4zeFwKre5qqLmLAqkUxRNyRCpDCIGumiTbnybZbpBIDgO31azRrjwnX6jLcyc7LKCcm9jbrfTcBp0dAJdPsYwdXLSpznyY3L5YUs2XeSK6EQmTT3v7vrkJFFdy8md+y9tPW9pgfr2JJoeU0nPFKlOi98UtPTZ21qxZw4IFCygqKmLXrl188YtfpLS0lKeeeoq6ujr+8pe/9GoixxM7V7xEZM8DCK0DT9lVJNVqx47l9o0gWHmjddzUesC0VVVX8XYtRImYM5a5EAJhSEiyDw2TUNBmpduyGtyhGUhSAZJ3uGMJf7pmYGhNVi8xyUQWBpLisq01RW6+VEByO1h6buBOe3Zkh4wdQ21EjS4BoNhV7FwSZs4CGygotH14xRvK+vCi7R22jw8g6Va5tq/kUgZN8FFu44bR41LQZQ8JdxVFBBGmZbTbra2kp4x0WCN9Y3J13ZDsuj78oa7rw204K5WRCDeR6nwDxROkbZ+H8rTAox2l5wBq+DWS7Q0ApNSel1EfDVrSIJNPrUpWHz+BYl/OZ7fCEMUxnR0taSDMBKbWhDDbKXKV9WqcHhs7t912G1dffTU//OEPKSjoasZ1zjnncMUVV/RqEscjQmsFQDHDxB0UuMrtN6Nnu57bd6G7EttRIy2YZoxE9CLbxs3F0LqHf0I2h00KK4dQPOzLqGEdlzAIOxRW1FUTNfxv1OjrFAGFZZeR8tbYNr4vmCuc5pyWSErV8Kp7SSbX4dJDdDYWUlQ11NZjeHMa9fmE6lxeglKGO/QJMBOUDhxu+/AFQ04lYYxFkgOkdGcqLiUDJNmDt3A+UxeOxx+ysUlupiJL6KS1KlETuu3GjqaagESg4ssUV7mIV3thnWWI2ufZ6TJ2/Ok+eHaF9A8k0bmPZMdTANStlg5j7PR+oxBr/BdaogEkP3pqQd8mexhyQ3GqlNOk1SavXm4ngUxfQidQkzpGaiexpgeYBER884HzejxOj42d9957j9/97ncHPT5w4EAaGhp6PIHjkUBRJZIrhCQVI0k+kk6Wc6aNHVMWGfVy20rPAVz7XiHRtgaAZGS+bePmkquxo/fBDXkkPH4XaljHLSkkk864U3XVQJhdY2uSxzbDMxXrJBFejxbfh+yuIICD1VgpA5e6k1THM6Q6oGX3CNuNnbIhUwlu/U8kOUCHGXEsZ0f2jCBQNgGBYOC4qbaPXzp0Bs3NVmgxpjmTFCuZXTcfO0vPoUtFOWZqmTxuqz9Wsb3XoJYykCQFd2Aq5UPK2F+egHXvAPbp7DTvep9Y66MIvZ1g4TlEkylKQw4kjOsmeo7EhNvX1V3dzE287oPRYKm+N4BIIBzSDMoNxaXSxo4sSbaFMA+U/HBKVNDyUOXkfPayerTHV5bX6yUcDh/0+JYtW6iosK+Z4IeZqhEnMOCkXxPbbX0BEQeNnUyeiMhZL2zN2fEXZFU41HiHbePmoqsmWnwNwowhYRDy2L+T8fpdZFK59ZRzOTsu/3gkOUCzaEeVfQRsaAIKlsDjmhe+AYC36FyCoTmEHfLsqCmdQFp1GLov5nYRLCrG5R0KgEc3HQljCSFwCQkk0CTTkZYtoQIvzen/5zYjtBMlbewYiG5tQ+wg4/kwU3Vo7EOIFGpimK3HgO4eaJdXRje6jAK7PDuR5jr0qCXP4A2cSDShOmLsqAkdxTOUQMX1FJbDwPEnZ5/L1dnpizhf7ZTPsW9DM5JSgNCdCSXnlufLnW8yKt6CYaPK+I73nyfZtghdbcdfdjWmEI5oUakpA1kpwxOax069iYG9rObt8Up9/vnn893vfpcnnngCsDLL6+rquPPOO7n44ot7NYnjEW/ATQzL2NGTzhk7kYbnUWMbMBUfgcAU4kqBrTk7gdGfQIsOR1JCCGF/zgOAoRmkwi9ipLZTDBT4zrb9GL4cjRXDoQ7VumbgCZ0EoZPYxV60VLstZedg6YhkEEIlILloSCWO8I7eo6cMPIEZKO4BBMpNymr71nDyUBzc+dz+a8Tq3p6+mTtzv+jW+dxQnflduYSMECYa9htsGWOnsv1p4noj4CIZ/5Stx4DuSaRuj9LN2LErZydQVJn9v2SGCUeS4MD+OhXXkV3FyK5pVI4oo3RgbfY5w7AnQbly6FQad+4DQNLbez/ZI5Abxgq2/JtpRpSYYt8a37xrHamI5b3zpPs2qrqOS7FXAkJL6ijeIfi9Q3gvtYFxw07o1Tg9/hX++Mc/JhqNUllZSSKRYN68eYwcOZKCggLuu+++Xk3ieCQ3v0J3SPNBCIGW2IOe3IgZW4kkMjk79hk7xcNOgNBJuAMnIAxnNHZ0zewSBMNFYdB+T0LL1j8T2f8dwnu+5phbOPdmFzfSlTM2fReh0gGMnfc5vEXn4/ZNIIDbMQVlXTWR3RW4A1MpHXIawRL7BQfc/pzSc0lxxMUdS6pdxk5OY1Y7KSn2I4SBaUQQidgHv6EXuIVEKvwSqbqbefLbZ7F/8zu2je1NtzJR5YzRppMMRw//hl6ipQyEmcLU20FKouckq9q1068aOR3f+G9TWPsA3sJzCHc6E67uVonVreO5YG+bFdUIej19yn3JlS+RnHEYZjueC2EiG1ZYTpftC18GCruqYF1mJK2nZf+HyfWoqhiEeiEoCL3w7BQVFbFo0SKWLl3KmjVriEajTJs2jQULnEmy+rDiD3adcNOhHZ+umt1ilZnGenaJCgL4PW6SpHfImjM3DF018RWfh2l0sMfo6PWP9UgYanu234yUtH8xh+6tO5KGvWrWwZJqZlxwIw11axCmIGAmHEtQzk0Yz42724nH50JP7UKYcUJmkpRuv5hdJJYi2fpnDLUO4fKjpf6A22tvWCPWtJ5w3ZcBUIrmA6fbOr5pmrhRSJkxwCAZaUNR7FOCzniB6/0TqPRPRVKCqA5sznTVQE9uIN78G975G8gTLwas5H27cnY8/hDe0iEQs67DWNihXJfDaOzUtXQQTlibtom1lX3ywuVed7JDgYHcpq/bB11JS6QBr8c+Y2fUSZ8iEp5A6z4FSfbhT210pD9WRkE5JQwE9Lo1U69Xurlz5zJ37tzevv24J974Dom2tzD1DvBd4sgxrMZ6XwaRpMMTQY1aCeB25uwEvG5SQgfJA2lxM7td6YZm4g5Yrsdmvb7XolBHwhsqSfebKUTWnEpQPlhUMOCx78YkSRK+oItERCMouVE1A80wbA1bApg5Rq3X55SxoxBr/BEIlYCrilbNnuaWuUSiKUy9AVPbCxooLvuNaF+wq6pMMuJHeGXvSCQ0ZElClgvBO4iAX8MbtE9nJ5OgvCswjlke6zvQNPsrmLSU2S1538wJZdgVxgLwBt2k0uXtiahDOW1xHdOwPDgu94Dsmrhmd1cBzuTBfZMbUdxmWsYigsfG85NLxmiTJJlm/xDq9GJKgvZ57wNF5RSUJ2irtyqTfQ6pKGd6Y2W+934TFfz5z39+yMclScLn8zFy5EhOOeUUFJsX6A8b0fpVqJElAMjJMxw5hqYaSJIMUgDNLSGkJsDeMJbf4yYpVMy0p0JLGd3yLexAz3Ft6sJ0pBprwvybiEbPQ5Ik9tBq+/gAmqoT3vsNJNnLWFcJy4pOpzhobxNNX9BNImLJr0tAPKVRFLDZ2NFNTL0FUPC4HFAdBmRFRpL9CENFEklHcnZiMRUrEq+A7EJW7DfcfAVlSN7hKHIA0z3Q9s1ALG7dsL1FZ5KoOpWLr59p29gAHndO6XkaJ/pKaSkDWSnGFZhGcYVMY6BLC8VWT3SBh1Q6V1KNORP/SSU0km2PocXfZ8kf4KJv/YNQaQ1r6hqzr5k0pG+h3876NUT3fxOAQOEZgP2yH92agJpWSMvVhzyjQ9GtIsuB8nMhBGrSINH2GEZyI/MBj/EJepOs1ePV4ac//SnNzc3E43FKSkoAaG9vJxAIEAqFaGpqYvjw4bz66qvU1tZ+wGjHL4VlXT92OXVwdZod6KmDPQmArTt9EW6gcO/XiQDu4BzU5CwHjJ2uuZuysC2pNxd/yJe9CblMZ3ZKWjKBMFoRBvjTCsSFfnuNHW/QjTDjILnTeTsqRQF7j4EOsaZfYmr7eedvPkZMe93e8dMEyk5HT6bQlaAjsfx4XCNU/XWrG321M6HkQFE5yqDbCeouDGEST6kEbfRMdlMtd8DJltkYqZjZfky5YRq70FMGLv84XP5xnHTFaJ5ctwF2WsrTio3GjstoQoutxzTa0YuciSyk4jqiW7ViCFMI1u2xjJ0Cn4ehFSV9OkawtMsYdBkxDNO01QMGXblHiltGNdOl5zYfI1drxy+5bJeY0FUTBJh6E7JWTzlQEOidd6rHn/z73/8+J554Ilu3bqW1tZXW1la2bNnCrFmz+NnPfkZdXR3V1dXceuutvZrQ8cLoOecTqL6TgoE/QPHZ30gRupdzqunkZFmS+lQFcCAFRV0XrTAjaA4shFpKR5hJq1TYozhSIpyb8OcRcrdGhHahJZNISiFIHlKS5aa307Oz6Y0n2Lb0i4T3fBUjuY2A5IzWjmRgGVSAy2t/sniG0sEX4Su5kEDBAkc8O8m0V0SSJLw2G53dSP+0FEmmI2JviDSR6Pp+JQfUrHM3ForXqvpKxeyv8svNZ3N7uzcCtdOb0LnxaeItvyPZ/gREnfHgqnEdxTsCl38yFUOn4vYF2dXUTjQtHjtxcFWfhflCpVUowRPxFJyOyz/WkesjY9S6XJ0oiVYUodvqZQOIt29Ejb2LGn3bCmPZ/Dm6+mLJiHTOalFhca/G6vFe4pvf/CZ///vfGTFiRPaxkSNH8qMf/YiLL76YHTt28MMf/tCWMvTvfOc73Hvvvd0eGzNmDJs2Wd2zk8kkX/va13jsscdIpVIsXLiQX//611RVOdXOsouCioEY3iG4ceEWDir2Rl4HyYswXIAHt0u21VgoLCol4amlQClB8QzLJoPZSaKzgfCerwAStYVTAftLzw9uzqoT8tmbwyEIUjjoRyDD43FLiNFOr4usuDFUy0to6E0EXUMdSVKWTHD7p2IanVQMc+5aybi4ZUnqZrjbRSqpZ3drdnsjc5HcEunICZ2dSQZW2JdT083YcdvvkfSkc3Yq1H20b/sTwoihFp+LEFNsXUdyS89dXgXd6MoLc9noiS4sH0BL5o+kcyXbvuJPIkmw8CvWeVpTZ1++DoC/oAxX9bX4dAVFGKQ0g4CN0X3TFNkqpnjr85zR/CoA28pusO8gwIbF3ycVa0NSivFX3267ZyfzuwpW3sQGo5XVSiOf7WWSdY9XiPr6+m5lhRl0Xc8qKNfU1BCJRHo1oQOZMGECL7/8cvZvV46I26233so///lPnnzySYqKirjpppv41Kc+xZtvvmnLsT8ITTbxmeAViiOJvWpSJdH2MABB32AovsD2ZFWfx8OOys9zklKTPqYDO/BYpjpKINskwncgpp4gEV6EZETxKUUk1am2GztGrsBj+rsuttHYKawcjCdQhmGUIcvBdDNQ+w1p2QB/mdXaZcaFY20fP0OuASIcqPRTkwaZs+9zqKoMQPEqkF7OOsP2enZSifQNqfkPkPCx8fVtjDvlUtvGz4SxDBSEYV2HphG1vT+WfpDOTtffdnqih0w8mR1ro/hd5SA703Q6E/7x+F3ZNb1bvs5gezYIpiJAB4+kEE9qlITsSx7OrcQy9I7s//2F9ubo+QrKScXaEEYYP7LtHqrcsvOUMAgFel9t2eMV4rTTTuNLX/oS//u//8sJJ1gVNitXruSGG27g9NOtssy1a9cybJg9Kp0ul4vq6oMt6c7OTh588EEeffTR7HH/9Kc/MW7cON5++21mz55ty/GPhC4LMMElyeiqYbvUeyreVUJtpF14dveCkSTJ6uCeRnUgjKVqoPjGgpmEoDMq20KYqO1PAtaxnOhEn/FOGHLXjdtOz071yOmc9sXHefsfVifhgN7kSBhLSasOg6V26xRuv8PGTqwTOl5DkgMYkfHAiA98T28QzS8Qa96OMGP4I9+2dexUUkeYKbT4exCHPWvjjhg7STmA7C1HEkEkpYSUzf2xNNUg2f4PDG0HS/5UiVHSVbRhV+k5wMDRM0gUqRRJVvjV0E0UG3sF5nYKz5SdG6bJ+nS+TqHfy5DyYnuO5ZbAqmQnHkuBjXZIN62g0vFsTkTwGXEKiuw1dkbN+RTrlmxHUorwodieoJy7+U5hUNCHDWyP784PPvggn/3sZ5k+fTput3UD1nWd+fPn8+CDDwIQCoX48Y9/3OtJ5bJ161Zqamrw+XzMmTOH+++/n8GDB7N8+XI0Teum7zN27FgGDx7MsmXL+sXYMfT9aIkYCJVIeBSlFfYaO4Ym4y+7CmEm2em2vAp2e3asQSVI31OdCGMJVxWhqtsAaBvmjCqw2xfCav5jIBlREkn7jYRMorWekyxudzWWN6fzeVBy2R7G0gwDF12/IbfHuarJtt3PEd77tKW1U3W57eObsTZSnc8DkNh3JnCO7ccAEPFd6Im1AMTaO20d2xLj6ypp9wbsVTHPGDtxVyGF03+I2GfdPNS4Djb2x9JTJoZWh57YxN51mzDmdq3LdrYPkCQJVbaSVgESUY2QrZ/DwEyH4DLJtzub2rMe1kmDq2zz4EvurnFiNpfR525ag0PPYlmsFIDLbCw9Bxg79yK2rlgNgN+M227sHOjZKfD3fv49vjtXV1ezaNEiNm3axJYtWwArj2bMmC4djdNOO63XE8pl1qxZPPTQQ4wZM4b6+nruvfdePvGJT7Bu3ToaGhrweDwUFxd3e09VVdUHNiRNpVKkUqns34fq9XU0uPb/jrjWhiQHiUQupLTC3mRP03TjCVl9WRrEblDDtieYAci5xo4Tnp0cF3cwYL8WCliLoGfwF3AnA0iu4mxJr10Yuoka346eWEvK5aZQChJ2lVJkcxl9t87Oktt2z05KM/CkM10EAsWBPJEMkmwgjA4A3Lr92kemGs+abb6gM61OANz+AjK/pmTUfmNHUoooGHg/jFCZepK9xQ65nmBTERmHnu0VWRkF5ezfdP2O7fTsAOguM7teJSOqrcZOKqEjzDixxp+jRwtYW3gyWwtOzD5vR75OBqPxKSItaxFGhGjrA4B9Yblcz44qdW3O7K7slGQJySMhVIHPgWosqwmoRqrzBUpEkqLYUKB3Dat77YoYO3YsY8c6F+8HOPvsrkTWyZMnM2vWLIYMGcITTzyBvw8W3v33339Q4nNvEJ5iJK0NYcaItEeB0j6PmUtuUmfcsK5uu8NYACWRFcRatyGMKNGaWwB7JQNyKzVCQWeMHQB3+QxcrdauLB5NfcCre4aumRipnaQ6/wlAcdGZpPwV+GwUFQRLjC9TIhzEfs9OUtPxpPYQ7fg7yH52Lr+M4TPsTxgH8BeUICnFSHIASbhsz2sTygAClTcjzARDp574wW/oJQNnXk29uBBJ9hOxuWDKSGtpSa4yfFUB27vPe905bW0UM2uC2LmpMQ2BoZsEq75GcZWbmZ8cwP/8e032eTtLzwFMN4iUijAjxCK1dkZ/0mXncQx1B7FWaN9XwZpAV+NJO40dyYhgaPUAJDrbbBsXun+/uRpLtstYAIrHSuOwdHZsrsZKWTIAqc5/MgTQGyYBX+rVWL0ydvbu3cuzzz5LXV0dqtp9Mf7JT37Sq4kcDcXFxYwePZpt27ZxxhlnoKoqHR0d3bw7jY2Nh8zxyeUb3/gGt912W/bvcDjcK00gUXEiXmUskqvYirnaTK5ib8Lm9gS5+PRW9MQ6AOLhlg94dc/JtCcwhElBHxLMPgjFK0NaZTNps3CarhrdtDc0yWNrcnKGxm3LSbY/jJ5swFd0Ps0peztUpzQdlxnBUHcBEGs/she0Lww94TwadlttIlS9Ed0wbf39SgRw+ycBMGjURNvGPZCSiioalXS+ls3Gp6GZ2YoynwMVZbmbI00WWWMnZeP1kdmUSZKMNxDEX1iOYXblaNntjS7e/XPC8T0gB4h0PmLr2JZnp8sL6fIFWb/XEnMtDvoYVGafB1H2FWBIXiQ5hBq3OfE95/uN5VQLF9lZ8pVG8clo4RguYRBN2ru+a8nu6667D1IZPb66Fi9ezPnnn8/w4cPZtGkTEydOZNeuXQghmDZtWq8ncjREo1G2b9/eLWdo8eLF2TL3zZs3U1dXx5w5c444jtfrxevt+5euDD4VXzq7V03ZHw5QE0nLNSx50NI3cSdydmR/RhJfIhW3p4oul1TbMrTOFZiSl6L4JcBo248B4PYp6OnzZOdiDpbh6QnNQfEOY5/eQrviZbADxk6kdR+pzrcA8GkNxJP2VpykNB2X0DHS7iNP9ru3H3fOzdtyceu2GjtyutW5iaXf5BTFRV1eZLv74Jma6DJ2/PZ6CaG7saPuWwItuxFmlGT0P207Rm4SaSbpWcvR2bFbLE/KtAUx44RbO7Ez/KPGdRTPIAoH/4aJp5SRLBEknlwKwKRa+/J1AEKTL8eU/sP6w2vvd59KSxpoibXobz/BPN3N1sAU2z077fu30bzyeoSZwhOah56yt3WSmjSQlSIClbfwurqNU8f13sbosbHzjW98g9tvv517772XgoIC/v73v1NZWcmVV17JWWed1euJHIrbb7+d8847jyFDhrB//37uueceFEXh8ssvp6ioiM9//vPcdtttlJaWUlhYyM0338ycOXP6JTkZwJXT2dnumytAR/1Swnt+D8gMKjyVHYEJhHz2L4jGkE+gqPMIKkUoDoyvJ/agx1cC4BXn2T5+BrfHIKU1IYwIeniArWPrmoHsKkN2lRHWW0ga9Y64hAsrujyMwuhES9gbA0+mNHyh2XiDM1F9SUbMdG6D4sntfI5CUtUJ2ag+rKSNHR3TEaHKDIVFOd+zzZe50ASGWo9ptGJ2DkZLluL22Zf7582RejDb1qPFrGTSeGc7YI/XMBHp8hz4C6z1wzByRQXtNXZE8WCUFMhKKTGbO7hn1nFJUgiWlLCyaU/2uclD7AthAfgCHuLp5CPD5uasmVYRpt6KEm+kGqjzjbF9zfIGi7K5WqbRgZGy93NoSR1J9uH2T2CXLCgd3HsPbo+NnY0bN/K3v/3NerPLRSKRIBQK8d3vfpcLLriAG26wT7Ro7969XH755bS2tlJRUcHcuXN5++23qaiwypd/+tOfIssyF198cTdRwf7CG3CTyZRzQnnYUDNVGiaGZN045o4davtxfMFCVNkgJMnoDlRjYXS5aAtCziWSpva/QnS/5db2FH0JOMm2sY1uTUCtc+REGKusdjyjTvkxjTs9SLIXI9ls6/jxuPV7lSQZ2RvA5XFOeThXZ8crKbYnLyp6BBPQZDfCNJEcaqiIESMVW45kxpE9ZYCNmylDoMaWoYZfYuvjMLT8N1SPnG7b8O6csmzdHcgmdCcjHbYdIx5WLemH6OuEGwfQsG0keq5nx+YwlnvaZQRWWGKVhmqz3McBHc9z9XXszNcBS3Qzs8IbNnsMs59DaJiSC1noJJRgrzuGHw5fqARPaCCGFkLxDMJM2SsxkSlu0YWJgehTX8Ue/1KCwWA2T2fAgAFs376dCROsuHxLi735Ho899tgRn/f5fPzqV7/iV7/6la3HPVp8ARc6GkKYaHH7S6oFhSje0RgiSUIOUhYKMHfMENuPE/C4iaUFH4RpJeO6bKrSEULgK/4PfIXn0mq0UznImRAWgK+oK0HcSHTYOvahOp4X2Vx2DuDy+CgdOJqm3VbiorB58UjmhBxkt3PeEAAhkiTanwYzQcBVSkqbYNvYKU2HzheJRK2+Xu37/0rpIPs7qwNEWvaQbPkdAHLoVOAK28a2WnfEsn97A/apMwP4chKU2weeyihpIRBAyPYpZyciKgiVZNujbF0KkcYZ6IFzAcsg6WtrhQMJ+r0kiBHEbbvnM7d5psfvYtM+a7NRGvJTU2JvyNcf9JDRgBaqvdd5xkMVqjiLf1WMoK2jjaA/YHtIUVZcjD/vl+x8K70pU+29D2ZKz/va8Rx6YezMnj2bpUuXMm7cOM455xy+9rWvsXbtWp566ql+Cx99WHAbYdr2fgthdOIuOAGYYev4Lv80QtVTaTeTNGlbuXr6GFs1KzL4vW7aRNeioSV1XG57qqYM3USWfSD7UGU3xQUhW8Y9FIVVQ2kJnIikFGC4a2wdW9cMDK0RkDCMMEhQ5FA/Jl+w67KUNHtvFKkcY0dx2NgBgRp+0TqWbwxJG4UeI7EUHNCs0SlytW8UM4FmGLblzkmGhDtwAim5gKHjfARsFn0rDQUyxX3U616mFA0hGdPQEvZ5EhJhFSG6CjRc3kC2N5YT61XI56FNdBCU3IiUwDQEsmLPbzkV19BTOzDUPWxfswcj0QlKgGEVJbaHSj2KTrzzJWQzhkiUAVNtGztXGLGzNYUmewkFnemD58+tsLVZPFRL6phGhJTRicdMEOyDEGaPjZ2f/OQnRKNWnPTee+8lGo3y+OOPM2rUKEcrsT6MhApLaDCskkFTs7dPixAi603QMPG6Fc6aOsrWY2Twu2SIr0JFsoySxGj8BfYYO7keER2zWyms3VSNmEhDxRcBiHnsT1CON/8GU9vPOMnN+qrrbRcUzJCrteOyOTqqJnW0+EpMoxPFF8LQxqC47a/QAHB7AmTq6GUzaauUfCSaQvEOB0w0KY7XQZ0df2E5ctmFeEUBsnsA4WiKsqK+V50IU6AICcU/CdU7gmkXTMdrc5jB41IoKwjQEonT0BHFU+YiGdOsqiObpADiEQ1J8uEvu4bxc8sorBiA/pa1LtqdrwMQ8nq6VRil4ppt61UqoaPHV5EK/4vVT0FhyUU0KwFqSu1P5PcoElrH3wFQNPv0lQzdzK67Lp+S3WQ4kWMIEMgRQpVsXK8M3cTQBWr0DZSOf3ARENs9EkpP79V4PbrzGIbB3r17mTx5MmCFtH7729/26sAfBQKBIKarApfkRXZVI0yBZFMfmFwjQcVgwaSRtiZ35uL3uClpe5QEAsUzFDVpn9ptpuwcAEVyNJE0FPJgCmG5zm1OPcotPTck63twavEQRgdq7H1MvZGgZwi6Ydq2Q1ZTOmpkCXpyI7SBYVzmmLEjyTL+obciJ33ISohkyr6VMBpN4S2cD8wnVmw4XFUWRK5aiCdm7SrbO+O2GDu5+lMqhmMbgaqiEC2ROOFEKtseRJgCPWV0q5jrLYmIiiR7CZbNZfyplhSAvvRpwBnPTsAl8Lb9jagZR3ZVkIh81zZjR03r7GTQZOvaqCmx35gOBgsRKEgYCD1i2/0jGesyBOWcdjBOrVfBnHMv6/at79nPkSMFEOpDzmePfumKonDmmWeycePGg5SLP4743G4i1XcyWLG+ADVpZPup9JVkTrsDVZh8erpzAo5BnxdD9uMy45hm1NZmoLpmosVXAeD2SMAnbBv7QPweD0l0ArhtvegANNXEHZiBMDqpT+vpOpGgDNBRv5pEy+8BCBWfTyyl2rZQWUq3mfCPlPa+OIe7ZDxSm2XwJuP2qUHHY116N4rHORXormNIkE6tCUfs0UTJ7RSuCdMRdXSA6uIQ6/c2oQideHQzWrwFSSkklRjXZ2NHCJGtxspUYkFXNZbdOSIABcEQ/vgaDHSEO0wyas/vyjQFatLAHTqZgooxNAfbiTdZ4VG783UAfB438bLPUqmUIrmKbLt/xDqsa0MIjbbdf2NUrINOVzlFAWfyJTv2rSDe/DdMowNX2VnAkaVfjpZYuxUalT0DifonE5eiBIp631uxx2d24sSJ7Nixw7ZGn8czAY+bRE4taiqh2WbsvLd5L8n2pzD0Jko8HqoL7assOhC/183+gtMYo5RZF52NSX/JpEai7RGE0YnfVQxcZdvYB+J1KySFQUBy4zJlWxV7ddXAX/ppANarW0EkHdspldR0JaF7tFbiKc22Yxmaia/4Ikyjg+AgybkKpjSKR8ZMJ3QnbaxYjOcYTk5q7GSP4VXINGSKROwRELVyXawxk7LhmNezuti6UfuNCI2rfwOAOzgLNbEQSvrm1UvFdERaQNBf2LXD19OPOeHZKfB7UZUCfEY7woyTsKmvVCY52eUdRtmQKawy96C21AEwsNR+z47P7SLqH0eNUmIdP6HbZOyki02MTsJ1zzEN2OMdSVHAGaX0ZKTRamQLuFT7lMyjaWPHE5zFNs9AYsUGRZW9L9Dp8Zn9r//6L26//Xa+973vMX36dIIHJD0VFjoXO/+w4fO4SOQk9qpxHcr6Pq4QgtfW7mRMchOGugs5LiErzuW6BDxu9gWnMMk9FMBWz040lupSJFWcCZdkUGQZ0fYXIuo+hNAw9Odwue25EerawdVYhQ6okQIUVw/DXXoBbrkKzV1ja8sIXTXx+638gPLxJbaNezgUr5xtm2qnPEMy0WXseHzOGztevwtdJBBmnGjEnpBJtD0FQiW856tUKX7efOR1Tr7yO7aMnUt1seWdUOUucURhREnZ4GmLh7u8CF6/kZUA0A1rXXQiZyfo87Cm9FIW+MaC5LfNsxNp7/LYBYu97N9u9Ux0yTIVhfYn93rdrm6tHFIJHTv8R/HOtO6N3tXHLaEEncvZKarM/l/R7dM9inZ0bSo6RIoyf9++gx7fQc85x+osfP7553fbiWR20YbhgE7LhxT/gZ4dm4QFd7d00NAaZXQ63KC4/I7muvg9blK51Vg23pSiMRVf8UUIkSBuU1z9iOhtmNl+MzEKyu0xvg21e8gh6PU404Ee8PgLcFedgzsu4QZbm5qKnGoJrwOKvQei0Eki1QhmHDNunxs9mVCJ138PSfLjU0YC9pW1H4rY+p+Ral4FQGDYL+0ZsyOVzg8xcBlRdJvLdjNUF6WNHcmLGHA6vkQBinuALR7cRMT6bWrRd1j7wl9Y+wLMvvTurM6OYlMOYy5+j5t2VwhJtkKwCbuMnZac3JBSL/vft9Tkq4tDjoTj3IqcLakG+/qVxTqt70Tx1OA7+Q6WrFtNRCniDIeMneqR02DgtymUKzBlj20e9UwYC6BTpBjq71vvyR4bO6+++mqfDvhRwud2Ial7SHS+imm0s3/zeQwcc36fx93Z1I5HkgkN+AbCTDBimrM78IDHTTLHaFNtFBaMx1W8hVb2vDbQXuGsQ2G6gqB6kJRC4uGwbcaOfoCoYFXQ2VwX2SuRURyL2JQjAmDqXcaO3wG17AOJ7niSWIMlt++u/Z5t42qxGKZqqduaMeeEETO4vD4yS28qGrZlzFhHCoSO7K4lSRh/H/IRjkRV2rODJNFafS4j2iz/QSphg2cnkvHsdP1G93QkSajWelIa6n3D5sMhSxLk7Jts8+y0Wp/BNKLoHg01LYJZ40AIC0CSJEwpiaE1Wp3P24uA4j6PG0t7dmRXgGjZCHb7rc/lRF8ssBL4NW8ZkuFFAdsS36NpT1tKGCQx+qSxA70wdubNm9enA36UcCkyktmJGl0CQLjRniTiva1hPChWt2g50K2FgBP4PS6SwkAIHWHGiIftC5klchZUbz+EG8I1n2GEmjYOJfsWqXjHdiL7f4Mk+xniHYx3UO/KH48Wxa9Au7XYxiP2Jfai6Zh6DEn24/M7FxrN4PZ36d8YSftc3HoyBsiAaWt7hcNRUDGUZHMTkhzslljcF6IdKWR3Bf4Bd7OirJHPf8qZnIqSoB+PS0HVDRrjUUakgyWqDZ7oRDityK0UUzZkGogUb+xsA6zv/ZwTnBF69PndxOMaAclNpDVpizch3Gp51iL7/pNlv02y0FXGS+VXOJKcnKEkuoxoh+VAaNv7TZjZt1xYIQTxdIJyoMhDZ6JLEsWpMBaArohMD2aScb3Pxo6hm9nE91jTLzjdaKd440A4t/e5q72a0RtvvMHvfvc7duzYwZNPPsnAgQP561//yrBhw5g7d26vJ3M8kvJ03VATEXsUpPe0duKRutymLoerTbxuF0Pjywk3PACA0L6EoY9HcfX9uLmKvf3hScCtkC6WIhGzz0hQE52Y2n4A/K5SCh1cOAA8ARcpM4apNxNvKca25qnJFiL7LA/L1kULqb3GPm/LoSgcNIl4QxJJ8pMS9gn/mZRQOPg3IDRGLqj84Df0kTHzriHRZhm4bfQ9QVmYIls1ExYqPo9zhqckSVQXhahr7WR/NJpd9VM2hE0yYSxPcAanf/EqtrS28uu/LQKgtqyIk8YM7vMxDkWRy6At+jaKSKK5awi3jKSoovdeJCFE2mgyIS2QaEjWiXKi7DyDnlMNmYz0XastFdcxdMsLHSzy0JnTTd1JY8dQujzGiZhKQWnfjhXLydeR1N1UmDHo6Nt63uO72d///ncWLlyI3+9nxYoVpFLWpDo7O/n+97/fp8kcjySDZQSr76Jg4H9TPuxaW8bc29aJmy4viNPVJpIkgbtrodC1KC177NmFp5JatuIk4O+HnB1P1+4utzy5r+iaCpJlrGmyx9GFA0B0riS85ytE679Hom6ZbeNKWldeiD/k3I41Q82EU/GXXoGv5CIkuW8x91yEbu3kJdlDcWmxbeMejpKczufCBpXYeETNVjF1ilS3tg5OkAllRYxM2MkkaUMuWCaMJSsS3oCLx95am33ukjkTbW8VkaGYKAVtfyXZ/iRafAVt+/q2XiWjWjpUbRAsOwGzdCTtLiusONABQcHscQNVuAMz8RTMR3H3vfdWrpEgU0+ifT9KOgna7r5YuUhaHWr0HVKd/yYa7nvuWW5yskjnkyp9lMnoVTXWb3/7Wz73uc9161118skn81//9V99mszxiPB60dUB+CQXrfsTGLrZJ4+IYZrsb48w0JRRY+8iST4SERfQ+26vR4PpKyXiHkSJqwxZKaZxZydVw/q+o0m1rker+zlIXtylF8Hcr/Z9skdAyTF2EjYaOy7fZIoG/4p2I8ZWbSvTHDZ2AuVdC58RabBtXAkvin8qppmgdMBw28Y9HIFcKXk71aBzco8KCpzP2QmEuj6HkTIxTLNPSau5N6VOoeJzO/sZMhVZYyNLCTf9L8KM43Z/FyFG9Sn8k0hXY/lCbjbta2bNbuu3OqCkgFPGDe3zvA+Ht6DLmyf0dlr3xRg2tfc5T+F0crIkuRk779v8X9Nmlm/bCzjr2UkUDSUgrDZLirfvns9McjJA3aqfMKFzL6MlNy8P+YojSdYZPM0vkQhvACDSeh7Qt95rucnJKwbczi6jjdvPntmnMXts7GzevJlTTjnloMeLioro6Ojo02SOR/xeN7s7I4xRSjA0k5Y9EaqG9b6ZX2NnFN0w8YkoiZb/BWDX+wsZOtlZYydZPJJ/G1Vc5RmHIsk07gzbEgc3UnHABJHAY1MZ+JFwS3FS4WUII0LLjpFw+uf6PGa31h2ShCkpjjQBzaW0Zgj7vCOQXZXovpG2jetyDyRQ+WUS6IyZa28vt0MRDHXtJl02Cj1K6fwAUwhCQec9hopLRlNM3IZMKT627GtlXG3vb64ZY0eNLqMgsZqyvZXE2kcTLLGvQWcu1UWWd0JCZBuPJqMdtO6LUT6odzdZLWVkr4tAoYfHlnV5dT49e6KjN1d/QTFrQicx3TsGj3sArfujfVqvMsnJAAXlPvZvspLQM+02nMLlVTCEiSLJtoTdM2XnAFrCatmRlIOOh92Ft+ueF2lvBPrW/iJ6QCWWKSkUFfetUKfHv8bq6mq2bdt20ONLly5l+HDnd4ofNvweF7vMLj2D+m2dR3j1B7On1Xq/J6f3i7uP+gJHQ8DjRsekXlgLYSKidVsAeotpulE8Q5BdlRSUOJ9b4VJSJNufJBX+F5GmFbaMmdvyQs10PHfQJQxQVlVOqPpOAuXXoAT7tqPJxSWsm4GO85VxAH6vi9a0hEJAc2VzPPqKnKgjFV5MIvYm8Y5GW8Y8EuHmOrTOh4g1/Rwj+jobNvTN25ZZzPXUVsrjK5C2/gs1YU+V16HIeHYScgh85SieoYDM3k1tvR4zo7ED0Lz7b3iX/y8zOxZRGfJy+gRn7wUhv4+Noem0Bibi8g4lFdOJd/b+t5VJTgYIlnhp6LDCYjUlBY6F4sASQu1I5wjF2lLdWj30hi71ZJNBU86hzjeKeu9gx/r4ZTAqT8BXcgn+8usQUt+rhw/0fIIlJtkXeuzZ+eIXv8gtt9zCH//4RyRJYv/+/Sxbtozbb7+db33rW32azPGIz+NirxEhaWxDSm1n+7uCKfPv7HWPk72t1oKnuErxlVyCMJMMGn+ynVM+JP50guRuM8Ig2doFNu4MU1jet9JR0z+WogFTABgzx5nKjFzchcXZ/+vxDlu8U93KztPxY6c9OwUFPuLCqjbxJxV01ehz7pYQAld6f2PI9nYnPhzxlt2Y9fcRFiru4Cwatg/sU7ghS2ITyY5nAWjbO4FQ6YC+j3kEdDWJ1vo2ALJSQkdd33JEulRuY9nHvIHee4Q/iEzOztbgFAaPv4jRdQUYmsn+LR1MOnVQr0LvuYZrR8taalO7AJg++xuOKCfnEvJZ3rwGM0Zter1q3RclWNy7G2J2YydB0qVndYKcDGGBJV+y24xQJvsRQtCwvZOhk8t7PV7mdyVJMqPOuoH/3vMPAE7yOxzqrR6HN2qde0Pr+7EymwFNMbMbs34vPb/rrrswTZP58+cTj8c55ZRT8Hq93H777dx88819mszxiN/jxkCQaPoFskggyUFa932Z8treXSR7054dl1KMt3ABAIMnTbFtvocj4LUWjzojwkmydeE37gwz6sQ+utVz8jSCAefDDf6CIiJF51LqG4viGUa0LUVBWd8uPl010OKrMPUmXAhc7nLH+mJlCPo81IkIY6VSZCQad4YZOKZvOyZDM5GxDD9D6h9jR5YVPHoTAhBGmL1b2vts7AghUMwuOTYnm4BmyD2GacbwReU+5e1kchJcpZfxupjEty+Yha/AvgTuA8kICwLUh6OcOnIQeza2o6smjTvD1Iwq7vGYucZOSovhBwzJzRlTnOnBlEvQmzF2upp2tu2PMXhCzyXshSmItllrniJv5e2//pY5HRG2+ydQU+KsWKXX7UJu/SsRvQMhUuzb9GNS5YKH31jNKeOGcsbknoWwM2EsX8hNJEd53emCCsXbZUr0VadNTepZgcW40cjo2Ep0yYPRPgMKex8e67GxI0kSd999N3fccQfbtm0jGo0yfvx4QiH7ykqPJ/xuF0gSYc8gilNbEWaMnSvXUV7bOz2AvW3pWHG6Gktxy7Z1Uj8Sfo+LIq2VCdF3Cau78RVfTFv96agJHU9f9FjSFScmwpZS9g/C73GzMnQiJ7lqAGjY2dlnYyfWqaLG3kaPr6AQcFdc7fjiIUsSlCvQZrmkNy1fx8AxfWuimkrqpMKL0BPrkF1eIq21FJQNtGnGh8bjDyEUDxJ+JNlL+/44qXjfegAlkzqe4CwUzyDiUpTCyqH2TfgwBIoqOP8bT/LCEzsIaAVIkosN2xqZNLrnHiXTEMTSIaCI7KOqdjwDRtvXU+hQ+DxuigM+OuJJGjoiDPpEKXs2WqXOeze29c7YCXeFXFaWfYYWs4NzJg/F43I+Ny/j2WkyY+jaXvTYShp3zAN6XuoeC6sY6YR3t7udth0rGAw0eAY7JiiYwed20SZ7MHUrFNuw9Q2eiQ9jQ2MLa+oamDO6ltBRejS0lJE1NILF3m5l505vzjweBV2YuCQZPd43Yyc3hBVX6zghYomSNm8ZTfWQ3hs7Pb77PPzww8TjcTweD+PHj2fmzJkfW0MHrJsrwAb/OHylVxIa8B3amwqy5dY9QQiRzdnxydaC4bTGTga/x40AalPbQGho8XdBQNPuSJ/Glc20JwH7mnIeCZ/HTZ3RNefGnX3Pg2iui4DZFdM3ZG+f48dHw4jRZUTbniSy9w72v3cHyWjfvotYNIWh7kFPbkSOrsI07CyPOjT+wnIqP/Mndlbfgb/0CgAadvQtry0cSaB4BuEJzoLSTxAo6r3b/2iRFRdFlUMorK1ESuuvbN3Q3Kux4uFUpqconSLFqGobGuodBZlQVls0QUGVD1/QWrsad4V7pbkTz/HsdMoyCSXEqJHj7ZnsB5AxdoYm1hLb/11Snc8RbljWq5yXSEvXte32dH0mVfY4KigIlmdnt28MAgnFNxbkIrRm67swTMHKnfVHPVYsJzk5WOShM9Fl7DjVxy+D16PQbiYQZgK1s4XWPkgB5CYnx/SuNc/t7Vvuao/vpLfeeiuVlZVcccUVvPDCCx+rXliHIiMGtsc3hILhC1A8NSSjBp3NPdca6IwniSati82dDje4+6GjM0DA6ybsLqPDVYbiLUTxDEYIs0/GgqYbyJGlxFseItX+OMlo30WzPgi/20UYlY5089H2/bE+NzZtrovgLb4Af/kXWVE4n0Aw5GjSYoYThtUQNqMIMwKYbH2nb3o79ds7ETlGm6cflIcBRlaXstPs+h3Vb+3o03itTV2hC8nt/PeQy+jxXUn20freJfAfmHw5coBz4atcqotDyEJnSngpbzx6L7L4NwDChP1bOno8Xm4YK5YuqBhZ3T+fJWPsNHq61OW1+Era9scO95bDEmnr+h5HnnQZO2Z8k+fLP0ejZzAD+yFnp9VdzbLKLxOqug23fwJD5a5jLt+x/6jHyignA7TtfpL6J2/j1LanKdDbHfdEexQZZd+dhPfcQqz5V2xb3tTrsXKvj/1KJW8VncWOgZ+kelTfqkd7bOzU19fz2GOPIUkSl1xyCQMGDODGG2/krbfe6tNEjlf87i5VYLm8yzDpTVVWJoQFoLc/R+fuG6hfdyNNO1b1aY5HQ8ZD9UbJJxn8ud9TUP0ZJEmmaVcY0+xdfkc0qUJyC1rsLYzwqxiafbo3h8OX/hx1egtaYh2J9mdp3Nl7T0IyZlWlubzD6QxMZGtgPEUBZ/tiZRhaWUJTsBYkHy7/ZNoaem+0CSFo3BYmUHEDhbUP0Hrit/CGnO96DjCkoph2OUU0XVXRvCeKlmOAarrB0k272dd2dIb1jo1dSuW+yn4QqsxhxIgyEugIIQglXaRSPf9OMjtXIXREYh1lagOxducryqqLChDIjI2vpGHNv2nb829EWnCuN1VZmTBWAh0DQdDroaqof7z8mZydqKsYrWI2vpLLCFR8qVcehdwGoEUVQfZEDWKuIty+oONVTN50GsReWUZKa4TVygW40pvd5Tv3Yx5llCDXSNBSDYhwPVXqXkxkx8NYXo+bpGwdw1T3Ur+lrluFW0/I9ezUS172+EeRqJlN8YARfZpjj40dl8vFJz/5SR555BGampr46U9/yq5duzjttNMYMaJvkzke8efIvBvFXbvMht4YO+kQlhs5LVluYOpRZMX5NgsZYyeuFJIyBZVDrN2FljJor+/5bgksT5Ukun64bp/zRkLm+wi2/Y14089JdT5P3bqNvR6vua7LjbonHR5zuhIrgyxJBMbOwDfoRwQrbyLSMRDT6F3JeKQ1SbJTQ5JkGhDIJeXIcv94Dd2KwtCKYnYaYYTQEKagIcdj+Le31vCDZ17njof/RTx1ZINYCEGqQcXUO9CNKOMnOS9nkEu0dR9q7Fmi+7+FYiZYv/7owwzZMbKVWGFGtj3Gsj/cyHtP/9juqR5EdXEIIcm0uaxzVjV8CgWl1m+gvT7e7Wb5QZiGmQ0ZRfQoQxKbmOJpoH3/Vvsnfggynh2AfSMuwlt4OrKrhNZ9PV+rwulKLEmW8Ba4aOq0xqgpKXA89O5La48JujbLLknOVsS2xxLsbDo6j3huGMvtcSFk6xwllYDjYSyPS2GXbzQpVxm+kkuQZB/b3++ddycrKChBJO0xrCrquxe6TwkhgUCAhQsXcvbZZzNq1Ch27drV5wkdb2Q8CQBJSSdUEkeNLqO9fkO2a+vRsifH2JGUImR3LW5/FZ6A89UmgZzPEU9pVOaoJ/c2lLWrsZ1A+TWEBtyDb9jX+xxzPRoyRtteT9dNsHHbil57p3KNnX2mtWt0epeUy5QRg6hLax+ZmqC5lyXP+zZ3LZjbjQ5GVPVPuCHDWPYSbHmQ8J6vIcxk1vMphODV9TsBCCdSrN975AWyrT6G25CJNtxPbO9tbPijPS1ajpbNS5+Eln9h6k2o8ffYvaXnHpG2ZisMp6d2ZB8LldXYNsfDkcnZeb/oVLRJl3HK1fczeEJXgvreTUcfZk7kdBqP643M7lxE7dZHWPfyQ7bN90jkGjudaorCcuuaDDcnetSo1TRE1pMQKvHSHIlnPSlO5+tA2rOTpsWT7rqutzJCdG1Elu/Yd1Rj5aonf+Jz/8XO2ffy98ovYUhux8NYXpeLjaETeb7sSjwlpyPJPvZubu+xrpYQIrsZMD1WYQvAxNq+i232ytiJx+M88sgjnHPOOQwcOJAHHniAiy66iPXr1/d5QscbuZ6dxP6N7Fv1VRKtf0KNvtnjUFZGY8cjKfiKzqag5luMOfVXFFY400wvl26fQ9WoGlqAECam3sLeTe29Svxbs7MBWSlC8QykqGI8koOKqhkyPYYaPEOg5BT85dche07olXdKCEFzXcQ6D2YL7UYrkjAcXzhyOWHoAHbk5rts6+jxGEII9m223mcKwQ6zkylD+t6HpyeUJXZTltoOIokWX03z7jC6ZlDX0klzuOu7WVt35HDOxjXW85nco/7KO8owYuYn0/+TMfUWtJbehLHSNzXvCJTpn6N20jxqJxysSm831cVpb4G7iv3F05AkiYFji7PP71rT0i1/5UgkcgQFRaJr3S8d5LyWFoAiy9leT1sbWpCLu4yDnuTtxDpS2R5lhWU+Nq9YTG1iC9Wp3f1j7Li61t0VO98j3PBDIvu+QU1iVVYm4v2jzNvJlJ17fApur0JnIoUue5Bwti8WWJ4dQ3KhSwItvc8UJmxf2bMk/lRMz4q4dooUHjOBx0wycVDfixB6fPe57LLLqKys5NZbb2X48OEsWbKEbdu28b3vfY+xY8f2eULHG/5cz05wIFI6NGAkt7J9RVOPbk572yzjqNrdtYC7vf0Tasj9HImUypqXfkGs/k5ijT8jEVF599md6NrRh1CEEGza0/VDLy7smzjh0ZIx2jrdZXQOuwhPcAayUtAr71SkLUkqpoNIEtnzn1zQ9Ac+0f58v3p2yguDiCIpK2a4f2tzj71UHY1x4mHVMt4i/2aE2I67c6cT0z0sI6afCYChFAIahi5o2hXhvQN2rWv3HN7YEULQsjNiiSP6J+CunkjFMOc1qHIpHTia2ZfejTboXvwl/4FPVwgfpYEAYOgmZtK6jsKylzEnXcSp1/4PVSOnOTXlLGUhP670hiOjEOwPeagaVogQGsmYytLHt9K694O9h/FI1+anPjidN4rPpXrymQyefLozkz8E506zDCvDFCzavQNT7yAVWcLOFW8c9Ri5eSUFZT4a3nqEkzpfYm778wwsdU7kMUNuA9j6hECkrO4EevRdJhdYN/hN+5qJJo8cYjR0k0T6OwkUWYZNZ9x6T4Hf62jrDrCUoDPEywSyYhlqu9e29qhAJDcasj8Z5cTOxVzU9Ade/t6ZJMItR3jnB9PjM6AoCk888QT19fX88pe/ZM6cOdnn1q1b16fJHI/k/lgTpszoky+mpPZi/GVXoCYM3nt+F8tf2PWBpZ1JTaepM4YETHd1hWDKa/sn4S/gzQljaQbt+7ZgaJ2YeiOmtpeOxjgr/rU7uwv6IPa1hYnmNOL09JPR5stJGN+a7HLL98bYaU6X3edWMOmS8x3PD2TKsCpa2x4hsv8e2nd996huRrlkvDqIFL72vzOx8TnW/OsP9k/0CEyYchJLyj7Nsoov4wnNBayqrPe3dzd2tje0EU8d2osYaU0ipyytr86yKzn1Sz/jpMv7X7V91OwLEBXF2b83rD36vJ14p4qU3rF3CpWR/VR2DpY3pDKd+9DYGcnKYwybbJBo/gGpzhfQUgbLnt7eLex5KHI9OxFJ0F44hvlXf4/CitojvMteLjtpEmNrLIHK/e2biey7k2Tbo+xd98xR57Z164lV5kNPWl4hTfb2exgrrhQQ9tQiu6pxB2cxIWiFmk3xwSXoua07AkXWmOF06bnTXh0AT46HKiXp1IzykOr8N2p0J1vfa0LXji60mJuc3GYkcee2TfL17V7YY2MnE75SFOvmFYlE+P3vf8/MmTOZMqV/d1kfBrp5djSNmZ+6nQVfuo2B47v6Ge3b0sGrf9lE/fbDh7X2t4URwEi5mKBhjVlSHbCl8/jR0M2zo2oMPeEMZJeHAWNOQXGnd4PbO1m/9Ohcqit31TNECqHF16AnN4PZ+1LEnhDwuhlaYVUZbW9rRxRYN5ZIazLr5jVNQbgl8YEXYFd+jIJcM5P93iG0uSsocjjZ70CmDqvBSO3E1OoxtXp2rzl6r4wQIltWrBtdRlJ/qA7n4vV4CA0aTz1xUhkv1bYO2g6onjGFYOO+Q/9W6jZ35ce0elPZsMyxYEBOs9+GbZ1HrVMTbsvRa/KIfjecM9VSCVUnnEiRinXwyu+uQ0vsIdX5HFp8DaYhWP7ibra+13hYvbDcXIyo0BhRVdovcgy5KLLMHefPJeh10+gqhnRSbzKyi8V/Xs3+bR0fqHcWzqnEKij3Uz9wPisL5rIxOIOBDgsKQvfNMsCS4nMIDPwOvuJzCXZ4mKMMwIfygSXo2fYjQlC3/FsseegbFEW2AzheUQbgzRGS1Ju3semVL5Hs+D9S4UVsX97Ei79ey5KHN7F68R5ajrBZi3aTZUjR6q7CO2gqlcOnorj7tu722rf1+uuvc9VVVzFgwAB+9KMfcfrpp/P222/3aTLHI7m5Luv3NLFxbxO+oJuZ5w1j2lmDcfusH4Ga0HnvuZ1sX3HohXxPaycyEjNcViJWovVR9PijrP33g85/CA42dobNOIdPf/dfLLj+R8y+6BNk1rEdK5rZcRRx2NU76xkvFxJv/iWxxh9Tv+H3Tk39IG44s8vQXNlRj6HWoSXWs+ntBt5/YRcv/W4dSx7ezJK/bu62I8rFNMxsGau/sJzY1Kt4o+R8NoVm9GsYC2BSbTX7vTWAjOIZxp4Nu3nnme3Ub9tK3ZpXibUfvill675YNt9qHybvFC5g3Nk3MfzEc/pp9l2MqCrFRLDOsNzRwoT5rsEEcXertjhcKCvX2CkbcmyFTCePH0A8veuUwjqL/nc9q1/e84HltvX7LQ+jGnuHUKBvIpG9IddAbOiI4g0WM/70zwBQPGAEtRO6FGo3vlnP+y/sQlcP3hTkCgpGhNrvCe8ZqopC3LRwNkgSDcHpuPxTCQ34FomwxPvP7+LlRzfStPfwXt1MjpLikggWetgsD2dL8ATqy2b2i3DogcZOQvbgqUknXwuY5Crncs8YktuSpI4QDso0QTW1PcTatrJn9WImRN8FoNDpvljQTTU7ERiAy2MdU4uvwDRiCGEZlrvXtvLW/21j15pDh6RiB3Q7X1twEqd+8acsvPn3fa6M65Fme0NDAw899BAPPvgg4XCYSy65hFQqxT/+8Q/Gj+8f5cwPG4V+H0Gvh1hKpSkc445HXmL+xOFcPW8a/mAjFQPeQDPn0bzbWhjXv76fRFRjwidqun15e9vCjFNKKZCsH7qefI+9a2OEGwYzeeEXHP8cIZ8HWZIwhWDD3iZUFIJ+K8+mcmghk0+vZdXLu9ETa1m7RKAmdcbMrj7kD9AwTSJ7EvhRyCzn3mD/3ZwmDKrk3GljeGH5Rgbt/2+iZgxJKWPvxu59buJhlWVPbePkT4/KqslmaK+PZxPlKgYXsCYnJNZfpecZAl43+oj57G46i8lpEbV9G1exZcl/A+AJFPHJOx4mWHxwxUK3KiyS6INmMePMC/pn4gcwsrqMf6/ZxgqjiWll5dBh4pfcLHQPYcicSn76L0ura13dwRuCWEcKPWxYeTuJNUwaOa+/p9+N6gIv9bGXqIqsRVIKCVbeyO51rexe10rJgCDVwwupGl5IQamv2zXS1BTF1DtItDxIQQu89tBbzLv6B/037+Ku67ChI8KYmnImLbgGl8dH+aSFLNm8n117WhmrW97R+q2dRFq2cOJ5wygo7frdJ8IaphEhEf43QXcRI6pm99tnOJBPjBvKyl31LFptUir5mSNJZGrbEs0qb/3fdiacVsOoKd2vD0M3sx6RUKmPSEqlOWJVyjndADRDbq5LhukLhtC+McKOlS3oagJFqIyXSnnlrxs57YqxB61V0FV2buotePxFqIlOdvktw7U/vIeeHKMtZUqMO/UK4h3NFNWcSSpeSntDzCrxTzva1ryyF9MQDD+he5+8jGdHEyYxdKqLQ1QW2lOEcNSenfPOO48xY8awZs0aHnjgAfbv388vfvELWyZxPONSZL536fxs6ARg8bodXPeHf/DI7+5l45KH2Lj0Braoa7PP71jRzPIXd2PoXXHl/c2dTFOsXB0hBKZh7RBd3v4RsPO5XZw8xqr66oynePyttd2eHzKpjJKKtcSbf0W8+ddsfnsfKw74DBk272tmjChBklx4i85n+ImXUjupf29OV51yAuWFITpcxQAIoxVTbwWspO9Mb6ZYh8qyp7ZnG89lyC05rxhcQGes//rMHIrJo0bytujgVW0PeCQUb06FnjSc3Ws7DgrLaSkjmyCvC5PdZoQpQ53tDn4kRlaXUqC3MaNzMR0bvkYkZhk35bKfwr0yg9I3mK0NLSTV7nk7mRCwkdyIp/lXND11B3vWHX0iqt1IskJZZDGGuhM9sZpU/L3sc+31MTa+Wc+Sv25m8Z82svGt+ux3E+tIoSe6chuL+qGvVy65xk5jZ5SkqvHmlj081VbDFx78F395YzWvx/bykrYLNR1ujLaneP1vW6hb34qhmwghSERU9MRq9PBLnNn6BO6tL/br5ziQ6+bPYGBZMa2keF7byUvaLjpM68YpI7Hx1Xo2vVWfDWtpKYP1b+zP3nwLynz8+qV3suON6CclaO8Bnp1BpYVUlxYw7uQaPnHZIGIdPyPW+BOEEUOLGax48dB5kxmjzR2Yxnl3PsPAs++kzjcK6J/1KjeMpeoGkxZczaz/uIOxJ01hyoJaTv3MWGYs1AiGXsdQrZDcutf28aNfL+G2v7xAaySOaYhsqkFnWp9tkg0l5xmO2rPz4osv8pWvfIUbbriBUaNG2TaBjwKjB5Tzs6vP4cVVW/nr66uIpVTkeCtFsV0ApCQPr5sGDdpe5roHIiOxf0sHkdYk1cOLKK8N4a4Hf7rnzoBRRZz+ub+jp+Ig9U9vLICrT53G21v3oBkmz76/iYVTRmXj1moiSv2GvwKgJ1ajRd9i35ZTiEdUZp43DG+ga7exdm095bLlFfLXns9Jl0/ql75YuQS8bm5cOJtH//wmkhwi5B9HSW2IZleUuv3vYzbuYbx/Kn7vJCKtSZY9vZ2TLh6ZrX6zSs41Up0vUVDyBTrSlQ1uRe4W8usvpg4dwCNLV7PV7GDAgCLOrx7F6raTEWYKX9kX2bY8Qd3GjRg1EgWFPnydafVrQyDMJLvNKDpmv5ec5zK0ogQfKsMTGwBojbyOPzgXt6RQv7WTeYWDWKM0kRQ6K1bsZdzQKjx+BY/PxZ50CCsVfhmAaPNuTN15Re7DobjcTF54HWuf+yn1nsG85/Jz98wy2rfFupVvx8MqW99tZN+mdqaeUQsJgeIbjVJ0PkXFOxg4YW6/zjs3jPX8is08/tZaUnp3I1kC9hFlafglpoROpUwJYGgmqxbtYe2SfVTUhjANgRZfmX3P6KnOl84fCZ/HzXcvXcDzyzeR0g0kIG7oRN9+gpqChchKEVvebSTWkaJ8cAEb36pHjXdtcBpSzSjLHqAsNIdU4WAumT2xX+Z9oLFzwrCuzcjyZ76PEbGqsyItf6Cw6qu07I2y+Z0Gxs7pvmnJaOwoLhl/oR9RMxVtpbWZcFpQELobOwf+njLsWbuY/eufAiT8ZVfjCc1htFqMq1nipUc3UK74Eem9c6dIgRBMHGifyvtRGztLly7lwQcfZPr06YwbN47PfvazXHbZZbZN5HhHkWU+OW0Mnxg7hL++voqlm3fziucaxoXfpjM4FI/Hyyatnbims8A1GNmME2m1Eme3vtfIcCyjwkQwfu5AQsX9mwQLVvz7UzPH8/iydeimyYOvLufbF58GWN2rT7ri27zxl7upnXQRnR3zMA1Be32cNx7byomfHEpRpeWFSuxK4cea/4jplf1u6GSYMWIgr838VFa0jl1bOKn9BYanrMS9jXqCif7xeEyFzqYEr/51E8FiLx6/QntjHC32LqnOZ/nnj1+koORUcI2lOOA7Jp9n9IAygl43sZTGG1t2M35IFefd8d9sWlZvicEJrMV7G3TQ3SuS7HiKYHwVtQUnMan20/0+9wwel0LBgLHE2grwmglWB6ezVd/Lme4hAATDCnNc1iLe8nYnb7x9cEJ/KjQbJZQiaEb73Vt4IFNPv5y1TXHe2gm6ELzSXsdtnzuZlj37aNrVQcveJB1NEgiZeFjlrb9vx4sC7krU0gWc+5X+D/3ktnNoi3bPLyoN+Tlj0khOHzeQNx65F63jXXamtpAccC0DDWt9MjSThh1WDoy/7CrqYm+BtI3KIf1jHByJysIg1542HYBIyz5ef+gu2jo3U5/cwYCKW5EVL/u2dLAvpw+YrEgMmFTMv17+DoPVvVS1PUnFpBsotyl08kF4D+gQPzXH8zr9vJtp2bWOcCLJmtBMThMCWZLY8k4jpTXBrMq9MEU2ZydQ7LGqFeNduS/9HcZSD1P40bjdMo51ycUadwWZTlfDlSJIQDJn3Wox40yNLCX28mJeebeUAaNnMW5e3+yNo3YbzJ49mz/84Q/U19fzpS99iccee4yamhpM02TRokVEIv2fbPdhpCjg46azZvPYLZfy5zu+xF3f+xP333UPv7/uAmaNHESdGeGF1EbC++8h3vx7TL2j2/vbQ+oxMXQy/MfsiZSGLK/Mu9v2snJnVxVA7cRTOO/Ox/jEZ29j7qVdeS7xsMobj2+lbkMbzQ1RSlUvQpgkJJ2xk+1zQ/aGL5w+o1v1VKPXynlJyn5WBafzj+R2VMm6OJNRjda9Ueq3doKAVOQVAExDo15YO4z+ztfJYBnTlo6VAH676F2eXLmeE84czLjzBrJftkpmhdCzrnqXT6G0Nkoy8hp+o4NZ4UW4jd71q7GLkQPKWVF4Cm+UfJImby27zDCDZ5RxtPbjTu8QTvjcTzj3tr8gKz1KOXSET130WXwBy4BYsn4ndS0drH7xf1j+1DXsfvcG5n66ltKBB9845UD/eWxzCfk8DMjx7hQFvJw1dRT/dekC/nTDp/jsKVMxGzei1VlhudrEZpZ2Lkcfp1A7vhSPr+vmLCuF7AtMxjvnS/0iGNoT3L4A8bBVSOEyW3hF34Emuofca0YVM++zY3hs9xpCKeu1QvFyyqn9l7wvSVI2b0eRJSbVdnleCyuHsOCGXyDP+zrbXQW8Z3QVIrz57Hbq9rUT60yxY1Uzpp5ECINgVmOnf8PusiThUqzfgKofnEgdT6lsH3YZq0MnsSY0mxUkWE5Xbp5pRFExKB4QYI3RzN7UVkbHV9O5dyP7Nr5FUdWQPs+xx6tFMBjk2muv5dprr2Xz5s08+OCD/OAHP+Cuu+7ijDPO4Nlnn+3zpD6KlIYCfPNTp/Laxl0sefxHSGYELf4+jWaMZPlVVEsB4ugEKmO88+QPGDn7Qspq+1+k0e9xc/W8afzkn28C8IfF7/OLaz+ZFaUqKLPk5YsrA3zi8lG899wu2huimIbMqn/XIftlTCNKrPF/MActQGIacGw8O2AZn9+9ZAEvrNxMeUGQYcGJ6JuKUSrHsniNSkcqxbOpHSzwDyYYWY6RasBTuABZKSRUdTOVg1YTadtBS6dltBX1Q2XD4fjMJ6ZgCsGTb1s5H0++vY7dLR2s39NELKUyWI8wvfMlUt4RrCyYS6jYx8LKEM2egVSpe5HGnI2vn5p/Ho6R1aX82zc8+/fQihKmzq1l9OQqYh0pfvn82yRjGgHFxfmTx2KqJqmkzpa6FjqNFFuVDsbWVGQX1mNN0OvhP2ZN4KHXVmIKwcNvrGaG1rWrLiwvYNh8DyueXsPAcAC3ZN3YSiv6JxfvUHz74tNYtrWOsTUVTKitPEhwrnbiKZzyuftY+ui9LAueQae7nEfWr+U3X7iAKQtqadsX5fW3drB+TxNbjHbOrO4f1eSe4AuVMPcz3+W1P93JsPP+k2fe2Eentp3TPLUMqy5hwsk1lAwM8ujS1Wxs6GBT2aeZbm7kklNmHTLR30nG1lSwencDs0fVdtM7AyipGcWlZUNJ+Vby0uqtVBtBhiiFKIbEe0/sxJ1Oc1Ajr5IKv4zPezrxji90M3b6I4wFlpdKN0z2tYf5+zvrOeeE0fg9bjbvb+Z/nltqCVmGLM/bnNG1fPmMWRA3eeAfb1C+9ZckZQ+7qj/D23oM3KXEplxD4fqHmXnx7dSMnfMBR/9gJPFBQgRHgWEYPPfcc/zxj388Lo2dcDhMUVERnZ2dFBY6n4W/5vWnWPXPX2JqSV4su4KYy9LsqErVcWrHcyBMBk85vV+rNHIxheD2v77IlnoroffkMYMZW1NBVVGI6uIQQyqKswtkuHk/L/3iKwhpPN7i85AkN4nWv6JGreTRyQu/wJSzrjsmn+OD2NHUxrcef5nOeApJGFzQ9gherRPF7eX06x6hpKYGb8DFK+t2ZI2/0ycO57ZzTz6m835+xWZ+t+hdci/cgBHh3Ja/IguDhLuEZ0uvBEnC73GTSKkMSO3ihis/x7SRQ4/VtAHYvL+Fr/21K5n107MnctW8E9i9ajEr//lrmgrG8GzCqiK577IFTBkygKWbdvGDZ6zf08yRg7Kh1Q8LSVXjC7//Bx3pJPbbR3ZgdO4jGosSnnwtT7+/CVU3KMDNaZG3CJTP5eIvXog/2L8d23tKItLGQ29v458rNgMwa+QgTleX0r5vMw0Rjed8CzFkN7+89pPdCjQ+TKiJCB5/Ad9/+jXe2lIHwAL/DrzJVvbHYa13CrpsVaL+95ULGTew4gNGtJ+EqrF+TxMTaiuPmA/YHk3wzNsbcS1bik9y4wlZBoAQgnjTz9CTVi7chXc/xU+WbOG9tGDnX2/6D0qCzivY3/rnF9ja0Jr9u9Dv5cQRA1myYSdGOqk64HHz5YWzmDduaDYd4JV//I59r1kSK22uShaVXQKSxO3nzeXEAQGCJUc2Po/2/m2LH1hRFC688EIuvPBCO4b7yDP5lE8xZvrptNRt4ILBJ7B+TxPr9zZS4BmP++U3SEbaqN/8Lql4GG+gf0ogc5Elievmn8jtD/8LgDc31/Hm5rrs8wOKC7j+jBMZW6Kw6FfXkYw0AXVIig9PwVmIdBWEyxtg1JyL+n3+R8vwylLuv/xM7n7sZeT2Hbi0dFfzwZOpHmlVO725eTcPvPBW9j12Vgf0lk9OG0NpyM+PnluKmk4GnDB6LCOGfZKd7z5DRXklLtnaZSVUDSSJluAIJgwZdIxnDsMqS7ISB2DlVe1e/Qpv/PWbCNOg2FcKWMbOurom9rVFeP/J73NpYgMvll3BzBHHrsT5cPg8bi6dM4nfvWyFfn62sxTNKLaefLurb1Sluxl/7G1E7G3WvbSHEz/1tWMw26PHX1DKZz8xlTc376YjluSdbXsp6VhBUXIfXsD0K3hdCrVlzrdV6C0Z8cwvnD6d93fsQ9UN9H2rKFP3MRpYUzkVsNSYj4WhA5Y3fcaIgR/4uuKgj6nqu6xte5gECkIpptVby16jg9EnXoXy1t2UD51EQfkgOuNrAPqlL1aGuy48hYeWrGDppt0IrMa+i9d1NbsdU1POHefNPUgMdOzYyex+uxgl1cGKwlPIxLQn1VYRLLDPA3rsg94fU7zBYgaOOwmAuWOHMHesFZPc4rqOZLSdMXM/fUwMnQxjB1ZwwYyxPPP+poOeq++IcM+Tr3DSqEHMn3Ee25b8BV9RJaF557H3/Qii7AoaBoznitnDCBQdmwXkaBlcXswPrjiTbz3+Mv9UrmJMbCVt8VGM3N9MeyzJD599I3tjPnPySOZPGnGMZ2xx0ujBfP+yM3jy7XWMqSnn4lkTwDiZovIaJEnmC6Uz+O2id7OvHzew4qDKj2OBx6UwakAZm/e3UBzwMbamnL0tJr5gMYlIKyUlZZDWrHzm/Y3EVY0zNSu2f1br3xjUVgZ8+KpBz5oyiqfe3UBzOIZ2QKsCWZI4b/pYxjb8k117rMeCpceuKq4nhHwerl8wk/9+5nUEkDIEBjICCSHJDKssdbzvkh1UFoW4ZM5EHn5jNX4j3XVecnPS+JGcPGZIVnbjw04qnhFINEgWb+L5sJUfs2prO+cXj2HiNEtDqz/7YmWoKgpx5wWncMXJnTy+bC2vb9yFKQQScMmciVx+8pRDhp9rxs5h4dce5f7f/opWj5WgPbC0kDIbDR2wKYz1YeBXv/oV//M//0NDQwNTpkzhF7/4BTNnzvzgN9L/YazjibZonIaOKI2d1r8VO+vZsLcrsczndjHEG6e5vZ02d5fX47KTJvGZT0w9BjPuHa2ROPc8+Qq7mi0RPq9bwTAEumnduBZMHMFXzpnT75L4vUUIwf3/eD3ruv/cKVO5ZM6kYzwri13N7by4cgunjB/GhEFd2lK6msA0dL78l8U0dqYl5YVgftv/UaY34wsWsvCm31JUNewYzv7wvL99Hz989g1kWWJoRQnDKosZUl7CpMFVDCwtRFeTbHz9MbREhClnfwnF9eEOY+Wybk8jT769Ltu2QBYGpqRw7rQx3HDG0a2zxxpTCF5cuYV4ZxMji11UBV3UjD7xWE+rR5iGzmsP3UX1yBmMm3cZ/1q1hV//+11MIVBMDUN2M6KqlN0tHeiGyaDSQn77xWMjIrqvLcyyLXVMGlzFmJoP3vQ+unQ1j75peaTOmjKKm846Oi/u0d6/PxLGzuOPP87nPvc5fvvb3zJr1iweeOABnnzySTZv3kxlZeUHvj9v7Bw9QgheXb+TB199v1t5Yy6Ffi8//uzZDOiHRnp2Ekup/NdTS1hb171dwWkThvPVc+YcFzvYXKJJlV+99DYp3eD2T55MwHt83Fwf+OdbvLzOkgeQJYnrzziRsyaPQJKVYyZjcLRkltMP+zx7y67mdp5+dwOvbdiFQHDfZWcw8UMQ2v04IYTo9vt6Z9sefvjsG6QOUfI9sbaSH1yxsD+n12tSms4DL7xFfUeE/7xwHpVFR6e6/7EydmbNmsWJJ57IL3/5SwBM06S2tpabb76Zu+666wPfnzd2ek40meIvr6/iX6u2AlaVzeQh1UwZXM24QZUH9Xw5XtB0gx8//yZLN+8GYN64odz2yZOPO0PneGb93ia+8ei/8bpdfP38uZw44tjnGuXpTjSZQtNNSkLOJ77m+WBawjGWbNzFm5t2d0sSPnPySL5ydt8rmT7MfGyMHVVVCQQC/N///V+3BOmrrrqKjo4OnnnmmYPek0qlSKVyGo51djJ48GD27NmTN3Z6iKob6IZx3HgNjgbDNHlz8250w2Te+GF5Q+cY0B5L4HW5DirFzZMnz5Fp6ozy9tY9tEUTnD99LKU257582AiHw9TW1tLR0UFR0eGT5Y/P7XcOLS0tGIZBVVV3V2pVVRWbNh2cXAtw//33c++99x70eG1trSNzzJMnT548efqbW471BPqRSCTy0TZ2esM3vvENbrvttuzfHR0dDBkyhLq6uiOerDwfTMbKznvJ+k7+XNpL/nzaR/5c2kf+XPYNIQSRSISampojvu64N3bKy8tRFIXGxu5JpY2NjVRXH7q80+v14vUerD1QVFSU/7HZRGFhYf5c2kT+XNpL/nzaR/5c2kf+XPaeo3FSHPfJCB6Ph+nTp7N48eLsY6ZpsnjxYubM+WgnZuXJkydPnjx5Ppjj3rMDcNttt3HVVVcxY8YMZs6cyQMPPEAsFuOaa6451lPLkydPnjx58hxjPhLGzqWXXkpzczPf/va3aWhoYOrUqfzrX/86KGn5cHi9Xu65555Dhrby9Iz8ubSP/Lm0l/z5tI/8ubSP/LnsH4770vM8efLkyZMnT54jcdzn7OTJkydPnjx58hyJvLGTJ0+ePHny5PlIkzd28uTJkydPnjwfafLGTp48efLkyZPnI83H3tj51a9+xdChQ/H5fMyaNYt33333WE/pQ8/999/PiSeeSEFBAZWVlVx44YVs3ry522uSySQ33ngjZWVlhEIhLr744oOEH/MczA9+8AMkSeKrX/1q9rH8uewZ+/bt4zOf+QxlZWX4/X4mTZrE+++/n31eCMG3v/1tBgwYgN/vZ8GCBWzduvUYzvjDiWEYfOtb32LYsGH4/X5GjBjB9773PXJrWvLn8vC8/vrrnHfeedTU1CBJEv/4xz+6PX80566trY0rr7ySwsJCiouL+fznP080Gu3HT/ERQnyMeeyxx4TH4xF//OMfxfr168UXv/hFUVxcLBobG4/11D7ULFy4UPzpT38S69atE6tWrRLnnHOOGDx4sIhGo9nXXH/99aK2tlYsXrxYvP/++2L27NnipJNOOoaz/vDz7rvviqFDh4rJkyeLW265Jft4/lwePW1tbWLIkCHi6quvFu+8847YsWOHeOmll8S2bduyr/nBD34gioqKxD/+8Q+xevVqcf7554thw4aJRCJxDGf+4eO+++4TZWVl4vnnnxc7d+4UTz75pAiFQuJnP/tZ9jX5c3l4XnjhBXH33XeLp556SgDi6aef7vb80Zy7s846S0yZMkW8/fbb4o033hAjR44Ul19+eT9/ko8GH2tjZ+bMmeLGG2/M/m0YhqipqRH333//MZzV8UdTU5MAxGuvvSaEEKKjo0O43W7x5JNPZl+zceNGAYhly5Ydq2l+qIlEImLUqFFi0aJFYt68eVljJ38ue8add94p5s6de9jnTdMU1dXV4n/+53+yj3V0dAiv1yv+9re/9ccUjxvOPfdcce2113Z77FOf+pS48sorhRD5c9kTDjR2jubcbdiwQQDivffey77mxRdfFJIkiX379vXb3D8qfGzDWKqqsnz5chYsWJB9TJZlFixYwLJly47hzI4/Ojs7ASgtLQVg+fLlaJrW7dyOHTuWwYMH58/tYbjxxhs599xzu50zyJ/LnvLss88yY8YMPv3pT1NZWckJJ5zAH/7wh+zzO3fupKGhodv5LCoqYtasWfnzeQAnnXQSixcvZsuWLQCsXr2apUuXcvbZZwP5c9kXjubcLVu2jOLiYmbMmJF9zYIFC5BlmXfeeaff53y885FQUO4NLS0tGIZxkMpyVVUVmzZtOkazOv4wTZOvfvWrnHzyyUycOBGAhoYGPB4PxcXF3V5bVVVFQ0PDMZjlh5vHHnuMFStW8N577x30XP5c9owdO3bwm9/8httuu43//M//5L333uMrX/kKHo+Hq666KnvODnXd589nd+666y7C4TBjx45FURQMw+C+++7jyiuvBMifyz5wNOeuoaGBysrKbs+7XC5KS0vz57cXfGyNnTz2cOONN7Ju3TqWLl16rKdyXLJnzx5uueUWFi1ahM/nO9bTOe4xTZMZM2bw/e9/H4ATTjiBdevW8dvf/parrrrqGM/u+OKJJ57gkUce4dFHH2XChAmsWrWKr371q9TU1OTPZZ7jjo9tGKu8vBxFUQ6qamlsbKS6uvoYzer44qabbuL555/n1VdfZdCgQdnHq6urUVWVjo6Obq/Pn9uDWb58OU1NTUybNg2Xy4XL5eK1117j5z//OS6Xi6qqqvy57AEDBgxg/Pjx3R4bN24cdXV1ANlzlr/uP5g77riDu+66i8suu4xJkybx2c9+lltvvZX7778fyJ/LvnA05666upqmpqZuz+u6TltbW/789oKPrbHj8XiYPn06ixcvzj5mmiaLFy9mzpw5x3BmH36EENx00008/fTTvPLKKwwbNqzb89OnT8ftdnc7t5s3b6auri5/bg9g/vz5rF27llWrVmX/zZgxgyuvvDL7//y5PHpOPvnkg2QQtmzZwpAhQwAYNmwY1dXV3c5nOBzmnXfeyZ/PA4jH48hy91uEoiiYpgnkz2VfOJpzN2fOHDo6Oli+fHn2Na+88gqmaTJr1qx+n/Nxz7HOkD6WPPbYY8Lr9YqHHnpIbNiwQVx33XWiuLhYNDQ0HOupfai54YYbRFFRkViyZImor6/P/ovH49nXXH/99WLw4MHilVdeEe+//76YM2eOmDNnzjGc9fFDbjWWEPlz2RPeffdd4XK5xH333Se2bt0qHnnkEREIBMTDDz+cfc0PfvADUVxcLJ555hmxZs0accEFF+TLpQ/BVVddJQYOHJgtPX/qqadEeXm5+PrXv559Tf5cHp5IJCJWrlwpVq5cKQDxk5/8RKxcuVLs3r1bCHF05+6ss84SJ5xwgnjnnXfE0qVLxahRo/Kl573kY23sCCHEL37xCzF48GDh8XjEzJkzxdtvv32sp/ShBzjkvz/96U/Z1yQSCfHlL39ZlJSUiEAgIC666CJRX19/7CZ9HHGgsZM/lz3jueeeExMnThRer1eMHTtW/P73v+/2vGma4lvf+paoqqoSXq9XzJ8/X2zevPkYzfbDSzgcFrfccosYPHiw8Pl8Yvjw4eLuu+8WqVQq+5r8uTw8r7766iHXyauuukoIcXTnrrW1VVx++eUiFAqJwsJCcc0114hIJHIMPs3xjyREjhxmnjx58uTJkyfPR4yPbc5Onjx58uTJk+fjQd7YyZMnT548efJ8pMkbO3ny5MmTJ0+ejzR5YydPnjx58uTJ85Emb+zkyZMnT548eT7S5I2dPHny5MmTJ89HmryxkydPnjx58uT5SJM3dvLkyZMnT548H2nyxk6ePHn6hCRJ/OMf/+iXY1199dVceOGF/XKsPHnyfHTIGzt58hyHXH311UiSxPXXX3/QczfeeCOSJHH11VfbeszvfOc7TJ061dYxe8rPfvYzHnrooWM6B4AlS5Ywbdo0vF4vI0eOPGhOr7/+Oueddx41NTUfaAyedtpp/O///i+rV6/m8ssvp7a2Fr/fz7hx4/jZz37myLGfeuopzjzzTMrKypAkiVWrVvX8JOTJcxyRN3by5DlOqa2t5bHHHiORSGQfSyaTPProowwePPgYzsw5ioqKKC4uPqZz2LlzJ+eeey6nnXYaq1at4qtf/Spf+MIXeOmll7KvicViTJkyhV/96ldHHKutrY0333yT8847j+XLl1NZWcnDDz/M+vXrufvuu/nGN77BL3/5S9uPHYvFmDt3Lv/93//dhzORJ89xxLFuzpUnT56ec9VVV4kLLrhATJw4sVtH70ceeURMnjxZXHDBBdmGg0IIkUwmxc033ywqKiqE1+sVJ598snj33Xezz2eaFr788sti+vTpwu/3izlz5ohNmzYJIYT405/+dNjGr4D4wx/+IC688ELh9/vFyJEjxTPPPJMdu62tTVxxxRWivLxc+Hw+MXLkSPHHP/7xsJ/tySefFBMnThQ+n0+UlpaK+fPni2g02u1zZ5g3b564+eabxR133CFKSkpEVVWVuOeee7qN197eLq677jpRWVkpvF6vmDBhgnjuueeyz7/xxhti7ty5wufziUGDBombb745e7xD8fWvf11MmDCh22OXXnqpWLhw4SFfD4inn376kM/95S9/EbNmzTrssb785S+L0047zZFjCyHEzp07BSBWrlx52NfkyfNRIO/ZyZPnOObaa6/lT3/6U/bvP/7xj1xzzTUHve7rX/86f//73/nzn//MihUrGDlyJAsXLqStra3b6+6++25+/OMf8/777+Nyubj22msBuPTSS/na177GhAkTqK+vp76+nksvvTT7vnvvvZdLLrmENWvWcM4553DllVdmx/7Wt77Fhg0bePHFF9m4cSO/+c1vKC8vP+Tnqa+v5/LLL+faa69l48aNLFmyhE996lOII/Qr/vOf/0wwGOSdd97hhz/8Id/97ndZtGgRAKZpcvbZZ/Pmm2/y8MMPs2HDBn7wgx+gKAoA27dv56yzzuLiiy9mzZo1PP744yxdupSbbrrpsMdbtmwZCxYs6PbYwoULWbZs2WHfczieffZZLrjggsM+39nZSWlpqSPHzpPnY8Wxtrby5MnTczIejqamJuH1esWuXbvErl27hM/nE83Nzd08O9FoVLjdbvHII49k36+qqqipqRE//OEPhRDdPTsZ/vnPfwpAJBIJIYQQ99xzj5gyZcpBcwHEN7/5zezf0WhUAOLFF18UQghx3nnniWuuueaoPtfy5csFIHbt2nXEz51h3rx5Yu7cud1ec+KJJ4o777xTCCHESy+9JGRZFps3bz7keJ///OfFdddd1+2xN954Q8iynP3cBzJq1Cjx/e9/v9tjmXMVj8cPej2H8a4kk0kRCoXEunXrDnmcN998U7hcLvHSSy/ZfuwMec9Ono8LrmNlZOXJk6fvVFRUcO655/LQQw8hhODcc889yGuyfft2NE3j5JNPzj7mdruZOXMmGzdu7PbayZMnZ/8/YMAAAJqamj4wByj3fcFgkMLCQpqamgC44YYbuPjii1mxYgVnnnkmF154ISeddNIhx5kyZQrz589n0qRJLFy4kDPPPJP/+I//oKSk5KiOnZl35tirVq1i0KBBjB49+pDvXb16NWvWrOGRRx7JPiaEwDRNdu7cybhx4474ufvCK6+8QmVlJRMmTDjouXXr1nHBBRdwzz33cOaZZzo2hzx5Pi7kw1h58hznXHvttTz00EP8+c9/zoadeovb7c7+X5IkwAoF9eR9mfdm3nf22Weze/dubr31Vvbv38/8+fO5/fbbDzmOoigsWrSIF198kfHjx/OLX/yCMWPGsHPnzl4d2+/3H3He0WiUL33pS6xatSr7b/Xq1WzdupURI0Yc8j3V1dU0NjZ2e6yxsZHCwsIPPF4uzz77LOeff/5Bj2/YsIH58+dz3XXX8c1vftORY+fJ83Ejb+zkyXOcc9ZZZ6GqKpqmsXDhwoOeHzFiBB6PhzfffDP7mKZpvPfee4wfP/6oj+PxeDAMo1dzrKio4KqrruLhhx/mgQce4Pe///1hXytJEieffDL33nsvK1euxOPx8PTTT/fquJMnT2bv3r1s2bLlkM9PmzaNDRs2MHLkyIP+eTyeQ75nzpw5LF68uNtjixYtYs6cOUc9LyEEzz333EH5OuvXr+e0007jqquu4r777nPk2HnyfBzJh7Hy5DnOURQlG47KJN7mEgwGueGGG7jjjjsoLS1l8ODB/PCHPyQej/P5z3/+qI8zdOhQdu7cmQ0NFRQU4PV6P/B93/72t5k+fToTJkwglUrx/PPPHzY89M4777B48WLOPPNMKisreeedd2hubu51OGnevHmccsopXHzxxfzkJz9h5MiRbNq0CUmSOOuss7jzzjuZPXs2N910E1/4whcIBoNs2LCBRYsWdSv5zuX666/nl7/8JV//+te59tpreeWVV3jiiSf45z//mX1NNBpl27Zt2b8z5y1z/pcvX048Hmfu3LnZ16xbt47TTz+dhQsXctttt9HQ0ABY32lFRYVtxwar5L2uro79+/cDsHnzZsDyHFVXV/fqXOfJ86HmGOcM5cmTpxccmKh7IAeWnicSCXHzzTeL8vLyI5aet7e3Zx9buXKlAMTOnTuFEFZC7cUXXyyKi4sPKj0/MAm2qKgo+/z3vvc9MW7cOOH3+0Vpaam44IILxI4dOw457w0bNoiFCxdmS+RHjx4tfvGLXxz2c8+bN0/ccsstR/zsra2t4pprrhFlZWXC5/OJiRMniueffz77/LvvvivOOOMMEQqFRDAYFJMnTxb33XffoU9szvmaOnWq8Hg8Yvjw4dnPmvs8B5TqA9l5ffOb3xRXXnllt/fcc889h3zPkCFDbD22EIeWEgAOKtvPk+ejgiTEEWo68+TJkyeP7UyePJlvfvObXHLJJcd6KnnyfCzI5+zkyZMnTz+iqioXX3wxZ5999rGeSp48Hxvynp08efLkyZMnz0eavGcnT548efLkyfORJm/s5MmTJ0+ePHk+0uSNnTx58uTJkyfPR5q8sZMnT548efLk+UiTN3by5MmTJ0+ePB9p8sZOnjx58uTJk+cjTd7YyZMnT548efJ8pMkbO3ny5MmTJ0+ejzR5YydPnjx58uTJ85Hm/wGMfgj6Xg857AAAAABJRU5ErkJggg==" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 173 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Per day", + "id": "7464de9ae1eb71a1" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-11-28T10:27:15.140753Z", + "start_time": "2024-11-28T10:27:13.010519Z" + } + }, + "cell_type": "code", + "source": [ + "base_dir = \"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/ssp2_4_5\"\n", + "nc_file_directory = os.path.join(base_dir, 'nc_files')\n", + "# NB these are daily \n", + "scenario = 'ssp2_4_5'\n", + "multiplier = 86400\n", + "years = range(2015, 2025)\n", + "month_lengths = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] * len(years)\n", + "\n", + "for file in glob.glob(os.path.join(nc_file_directory, \"*.nc\")):\n", + " model = re.search(r'pr_day_(.*?)_' + scenario.replace('_', ''), file).group(1)\n", + " data_per_model = xr.open_dataset(file)\n", + " data_per_model_2015_2024 = data_per_model.sel(time = slice('2015-01-01', '2025-01-01'))\n", + " pr_data = data_per_model_2015_2024['pr'][:] * multiplier # in kg m-2 s-1 = mm s-1 x 86400 to get to day\n", + " pr_data_avg_area_model = pr_data.mean(dim=['lat', 'lon'])\n", + " plt.plot(pr_data_avg_area_model, linewidth=2, linestyle='--', label = model)\n", + " plt.legend()" + ], + "id": "fc517576d38dd0a4", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 108 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Monthly mean per day", + "id": "6490116d0cf0334f" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-11-28T10:34:59.226041Z", + "start_time": "2024-11-28T10:34:38.179156Z" + } + }, + "cell_type": "code", + "source": [ + "base_dir = \"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/ssp2_4_5\"\n", + "nc_file_directory = os.path.join(base_dir, 'nc_files')\n", + "# NB these are daily \n", + "scenario = 'ssp2_4_5'\n", + "multiplier = 86400\n", + "years = range(2015, 2025)\n", + "month_lengths = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] * len(years)\n", + "\n", + "for file in glob.glob(os.path.join(nc_file_directory, \"*.nc\")):\n", + " model = re.search(r'pr_day_(.*?)_' + scenario.replace('_', ''), file).group(1)\n", + " data_per_model = xr.open_dataset(file)\n", + " data_per_model_2015_2024 = data_per_model.sel(time = slice('2015-01-01', '2025-01-01'))\n", + " pr_data = data_per_model_2015_2024['pr'][:] * multiplier # in kg m-2 s-1 = mm s-1 x 86400 to get to day\n", + " pr_data_avg_area_model = pr_data.mean(dim=['lat', 'lon'])\n", + " cumulative_sum_window_for_model = []\n", + " begin_day = 0\n", + " for month_idx, month_length in enumerate(month_lengths):\n", + " days_for_grid = pr_data_avg_area_model[begin_day:begin_day + month_length]\n", + " cumulative_sums = sum(days_for_grid)/month_length\n", + " cumulative_sum_window_for_model.append(cumulative_sums)\n", + " begin_day += month_length\n", + " plt.plot(cumulative_sum_window_for_model, linewidth=2, linestyle='--', label = model)\n", + " plt.legend()" + ], + "id": "ced869549b45bd48", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 109 + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": "", + "id": "bc9105dc2b16b465" + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_monthly.py b/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_monthly.py index 293b13fe00..1ddcf261de 100644 --- a/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_monthly.py +++ b/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_monthly.py @@ -2,7 +2,7 @@ import cdsapi -base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical" +base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/monthly_data" os.chdir(base_dir) dataset = "reanalysis-era5-single-levels-monthly-means" request = { diff --git a/src/scripts/climate_change/gridding_data_exploration.ipynb b/src/scripts/climate_change/gridding_data_exploration.ipynb new file mode 100644 index 0000000000..5d012d41dd --- /dev/null +++ b/src/scripts/climate_change/gridding_data_exploration.ipynb @@ -0,0 +1,1382 @@ +{ + "cells": [ + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-11-28T10:41:40.731834Z", + "start_time": "2024-11-28T10:41:40.625055Z" + } + }, + "cell_type": "code", + "source": [ + "import geopandas as gpd\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "from netCDF4 import Dataset\n", + "from shapely.geometry import Polygon\n", + "import difflib\n", + "import glob\n", + "import os\n", + "from pathlib import Path\n", + "import xarray as xr\n", + "\n", + "from netCDF4 import Dataset" + ], + "id": "7ae9972a2d6542a4", + "outputs": [], + "execution_count": 65 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-11-28T10:41:41.365105Z", + "start_time": "2024-11-28T10:41:41.362570Z" + } + }, + "cell_type": "code", + "source": "", + "id": "46c89794acb378d1", + "outputs": [], + "execution_count": 65 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "# NB THE ERA5 AND CHIRPS DATA GO IN REVERSE ORDER ", + "id": "8003215dcdd59c24" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "print(CHIPRS_dataset['latitude'][:])\n", + "[-17.125 -17.075 -17.025002...\n", + "\n", + "print(era5_data['latitude'][:]) [ -9.376 -9.626 -9.876 -10.126 \n", + "\n" + ], + "id": "bf78a17ee53b0cc4" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "", + "id": "ac4b0329999da204" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "# Load CHIRPS", + "id": "cd1206c4719b436f" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-11-28T10:41:44.945597Z", + "start_time": "2024-11-28T10:41:44.827489Z" + } + }, + "cell_type": "code", + "source": [ + "chirps_xr = xr.open_dataset('/Users/rem76/Desktop/Climate_change_health/Data/CHIRPS/java_chirps-v2.0.monthly_malawi_clipped.nc')\n", + "chirps_xr = chirps_xr.where(\n", + " chirps_xr['time.year'] > 2010, drop=True)" + ], + "id": "9407ed417645ce11", + "outputs": [], + "execution_count": 66 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-11-28T10:41:45.757211Z", + "start_time": "2024-11-28T10:41:45.724617Z" + } + }, + "cell_type": "code", + "source": [ + "chirps_xr_coarse = chirps_xr.coarsen(latitude = 5, boundary=\"trim\").mean()\n", + "chirps_xr_coarse.coarsen(longitude = 5, boundary=\"trim\").mean()\n" + ], + "id": "2c03354e0c7f1c52", + "outputs": [ + { + "data": { + "text/plain": [ + " Size: 269kB\n", + "Dimensions: (time: 166, latitude: 31, longitude: 13)\n", + "Coordinates:\n", + " * time (time) datetime64[ns] 1kB 2011-01-01 2011-02-01 ... 2024-10-01\n", + " * longitude (longitude) float32 52B 32.77 33.02 33.27 ... 35.27 35.52 35.77\n", + " * latitude (latitude) float32 124B -17.02 -16.77 -16.52 ... -9.775 -9.525\n", + "Data variables:\n", + " precip (time, latitude, longitude) float32 268kB 343.8 419.2 ... 29.62\n", + "Attributes: (12/17)\n", + " CDI: Climate Data Interface version 2.4.4 (https://mpimet.m...\n", + " Conventions: CF-1.6\n", + " institution: Climate Hazards Group. University of California at Sa...\n", + " title: CHIRPS Version 2.0\n", + " history: Thu Nov 21 13:55:19 2024: cdo sellonlatbox,32.67161823...\n", + " version: Version 2.0\n", + " ... ...\n", + " comments: time variable denotes the first day of the given month.\n", + " acknowledgements: The Climate Hazards Group InfraRed Precipitation with ...\n", + " ftp_url: ftp://chg-ftpout.geog.ucsb.edu/pub/org/chg/products/CH...\n", + " website: http://chg.geog.ucsb.edu/data/chirps/index.html\n", + " faq: http://chg-wiki.geog.ucsb.edu/wiki/CHIRPS_FAQ\n", + " CDO: Climate Data Operators version 2.4.4 (https://mpimet.m..." + ], + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 269kB\n",
+       "Dimensions:    (time: 166, latitude: 31, longitude: 13)\n",
+       "Coordinates:\n",
+       "  * time       (time) datetime64[ns] 1kB 2011-01-01 2011-02-01 ... 2024-10-01\n",
+       "  * longitude  (longitude) float32 52B 32.77 33.02 33.27 ... 35.27 35.52 35.77\n",
+       "  * latitude   (latitude) float32 124B -17.02 -16.77 -16.52 ... -9.775 -9.525\n",
+       "Data variables:\n",
+       "    precip     (time, latitude, longitude) float32 268kB 343.8 419.2 ... 29.62\n",
+       "Attributes: (12/17)\n",
+       "    CDI:               Climate Data Interface version 2.4.4 (https://mpimet.m...\n",
+       "    Conventions:       CF-1.6\n",
+       "    institution:       Climate Hazards Group.  University of California at Sa...\n",
+       "    title:             CHIRPS Version 2.0\n",
+       "    history:           Thu Nov 21 13:55:19 2024: cdo sellonlatbox,32.67161823...\n",
+       "    version:           Version 2.0\n",
+       "    ...                ...\n",
+       "    comments:           time variable denotes the first day of the given month.\n",
+       "    acknowledgements:  The Climate Hazards Group InfraRed Precipitation with ...\n",
+       "    ftp_url:           ftp://chg-ftpout.geog.ucsb.edu/pub/org/chg/products/CH...\n",
+       "    website:           http://chg.geog.ucsb.edu/data/chirps/index.html\n",
+       "    faq:               http://chg-wiki.geog.ucsb.edu/wiki/CHIRPS_FAQ\n",
+       "    CDO:               Climate Data Operators version 2.4.4 (https://mpimet.m...
" + ] + }, + "execution_count": 67, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 67 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "# Load ERA5 ", + "id": "123d450b41f841b9" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-11-28T10:41:47.444739Z", + "start_time": "2024-11-28T10:41:47.416253Z" + } + }, + "cell_type": "code", + "source": "era5_data_xr = xr.open_dataset('/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/monthly_data/724bab97773bb7ba4e1635356ad0d12.nc')", + "id": "178103b827b5216e", + "outputs": [], + "execution_count": 68 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "# Load TAMSAT", + "id": "d859c3b67bef8616" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-11-28T10:41:48.540861Z", + "start_time": "2024-11-28T10:41:48.523541Z" + } + }, + "cell_type": "code", + "source": "tamsat_xr = xr.open_dataset('/Users/rem76/Desktop/Climate_change_health/Data/TAMSAT/rfe1983-present_monthly_0.25.v3.1.nc')\n", + "id": "a5326b8dc484c8d3", + "outputs": [], + "execution_count": 69 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "", + "id": "2e0c63be171f3f3d" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-11-28T10:41:49.775599Z", + "start_time": "2024-11-28T10:41:49.488923Z" + } + }, + "cell_type": "code", + "source": [ + "\n", + "tamsat_xr_filtered = tamsat_xr.where(\n", + " (tamsat_xr['time.year'] > 2009) &\n", + " (tamsat_xr['lat'] >= -17.12627881) & (tamsat_xr['lat'] <= -9.36366167) &\n", + " (tamsat_xr['lon'] >= 32.67161823) & (tamsat_xr['lon'] <= 35.91841716),\n", + " drop=True\n", + ")\n" + ], + "id": "8d154a9025d54e50", + "outputs": [], + "execution_count": 70 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "# NB - ERA5 \n", + "The hydrological parameters have effective units of \"m of water per day\" and so they should be multiplied by 1000 to convert to kgm-2day-1 or mmday-1.\n", + "\n", + "https://confluence.ecmwf.int/display/CKB/ERA5%3A+data+documentation#ERA5:datadocumentation-Monthlymeans " + ], + "id": "80c20eec27f5238e" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-11-28T10:41:54.704835Z", + "start_time": "2024-11-28T10:41:54.231024Z" + } + }, + "cell_type": "code", + "source": [ + "days_in_month = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]\n", + "month = 0\n", + "for i in range(len(era5_data_xr['latitude'][:])):\n", + " for j in range(len(era5_data_xr['longitude'][:])):\n", + " pr_data_time_series_grid = era5_data_xr['tp'][:, i, j]\n", + " pr_data_time_series_grid *= 1000 * days_in_month[month] # to get to mm\n", + " plt.plot(pr_data_time_series_grid)\n", + " month = (month + 1) % 12" + ], + "id": "41dec217f9da78ad", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 71 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-11-28T10:42:11.976710Z", + "start_time": "2024-11-28T10:42:02.464863Z" + } + }, + "cell_type": "code", + "source": [ + "for i in range(len(chirps_xr['latitude'][:])):\n", + " for j in range(len(chirps_xr['longitude'][:])):\n", + " pr_data_time_series_grid = chirps_xr['precip'][:, i, j]\n", + " plt.plot(pr_data_time_series_grid)" + ], + "id": "17df634e66637b07", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 72 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-11-28T10:42:13.260893Z", + "start_time": "2024-11-28T10:42:12.795965Z" + } + }, + "cell_type": "code", + "source": [ + "for i in range(len(tamsat_xr_filtered['lat'][:])):\n", + " for j in range(len(tamsat_xr_filtered['lon'][:])):\n", + " pr_data_time_series_grid = tamsat_xr_filtered['rfe_filled'][:, i, j]\n", + " plt.plot(pr_data_time_series_grid)" + ], + "id": "592bd2ed79b8e94", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 73 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-11-28T10:42:14.180219Z", + "start_time": "2024-11-28T10:42:14.064328Z" + } + }, + "cell_type": "code", + "source": [ + "pr_data_time_series_avg_CHIRPS = chirps_xr['precip'].mean(dim=['latitude', 'longitude'])\n", + "pr_data_time_series_avg_ERA5 = era5_data_xr['tp'].mean(dim=['latitude', 'longitude'])\n", + "pr_data_time_series_avg_tamsat = tamsat_xr_filtered['rfe_filled'].mean(dim=['lat', 'lon'])\n", + "\n", + "# Plot the averaged precipitation time series with distinct styles\n", + "plt.plot(pr_data_time_series_avg_CHIRPS, color=\"red\", linewidth=2, linestyle='-', marker='o', markersize=4, label='CHIRPS')\n", + "plt.plot(pr_data_time_series_avg_ERA5 * 1000 * 30, color=\"blue\", linewidth=2, linestyle='--', marker='s', markersize=4, label='ERA5')\n", + "plt.plot(pr_data_time_series_avg_tamsat, color=\"green\", linewidth=2, linestyle=':', marker='^', markersize=4, label='TAMSAT')\n", + "\n", + "plt.xlabel('Months since 01/2011')\n", + "plt.ylabel('Average Precipitation in 0.25 grid square (mm)')\n", + "plt.title('Average Precipitation Time Series')\n", + "plt.legend()\n", + "plt.show()" + ], + "id": "53369e1395a2f290", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 74 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-11-25T15:18:59.825963Z", + "start_time": "2024-11-25T15:18:59.548066Z" + } + }, + "cell_type": "code", + "source": [ + "pr_data_time_series_avg_CHIRPS = chirps_xr['precip'].mean(dim=['latitude', 'longitude'])\n", + "pr_data_time_series_sd_CHIRPS = chirps_xr['precip'].std(dim=['latitude', 'longitude'])\n", + "\n", + "pr_data_time_series_avg_ERA5 = era5_data_xr['tp'].mean(dim=['latitude', 'longitude'])\n", + "pr_data_time_series_sd_ERA5 = era5_data_xr['tp'].std(dim=['latitude', 'longitude'])\n", + "\n", + "pr_data_time_series_avg_tamsat = tamsat_xr_filtered['rfe_filled'].mean(dim=['lat', 'lon'])\n", + "pr_data_time_series_sd_tamsat = tamsat_xr_filtered['rfe_filled'].std(dim=['lat', 'lon'])\n", + "\n", + "fig, axs = plt.subplots(1, 3, figsize=(18, 6), sharex=True, sharey=True)\n", + "\n", + "axs[0].plot(pr_data_time_series_avg_CHIRPS, color=\"red\", linewidth=2, linestyle='-', marker='o', markersize=4, label='CHIRPS')\n", + "axs[0].fill_between(range(len(pr_data_time_series_avg_CHIRPS)), \n", + " pr_data_time_series_avg_CHIRPS - pr_data_time_series_sd_CHIRPS, \n", + " pr_data_time_series_avg_CHIRPS + pr_data_time_series_sd_CHIRPS, \n", + " color=\"red\", alpha=0.2)\n", + "axs[0].set_title('CHIRPS')\n", + "axs[0].set_xlabel('Months since 01/2011')\n", + "axs[0].set_ylabel('Average Precipitation (mm)')\n", + "\n", + "axs[1].plot(pr_data_time_series_avg_ERA5 * 1000 * 30, color=\"blue\", linewidth=2, linestyle='--', marker='s', markersize=4, label='ERA5')\n", + "axs[1].fill_between(range(len(pr_data_time_series_avg_ERA5)), \n", + " (pr_data_time_series_avg_ERA5 - pr_data_time_series_sd_ERA5) * 1000 * 30, \n", + " (pr_data_time_series_avg_ERA5 + pr_data_time_series_sd_ERA5) * 1000 * 30, \n", + " color=\"blue\", alpha=0.2)\n", + "axs[1].set_title('ERA5')\n", + "axs[1].set_xlabel('Months since 01/2011')\n", + "\n", + "axs[2].plot(pr_data_time_series_avg_tamsat, color=\"green\", linewidth=2, linestyle=':', marker='^', markersize=4, label='TAMSAT')\n", + "axs[2].fill_between(range(len(pr_data_time_series_avg_tamsat)), \n", + " pr_data_time_series_avg_tamsat - pr_data_time_series_sd_tamsat, \n", + " pr_data_time_series_avg_tamsat + pr_data_time_series_sd_tamsat, \n", + " color=\"green\", alpha=0.2)\n", + "axs[2].set_title('TAMSAT')\n", + "axs[2].set_xlabel('Months since 01/2011')\n", + "\n", + "for ax in axs:\n", + " ax.legend()\n", + "\n", + "plt.suptitle('Average Precipitation Time Series with 1 SD Confidence Intervals')\n", + "plt.tight_layout(rect=[0, 0, 1, 0.95])\n", + "plt.show()\n" + ], + "id": "e67094aecd706820", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 12 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-11-25T15:18:59.827881Z", + "start_time": "2024-11-25T15:18:59.826541Z" + } + }, + "cell_type": "code", + "source": "", + "id": "8a03cd86c5319497", + "outputs": [], + "execution_count": 12 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "# try on a map ", + "id": "52d16167c587aadd" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-11-25T15:18:59.831139Z", + "start_time": "2024-11-25T15:18:59.828411Z" + } + }, + "cell_type": "code", + "source": [ + "-9.375\n", + "-17.125\n", + "35.875\n", + "32.675003" + ], + "id": "dc9e04586502a4e3", + "outputs": [ + { + "data": { + "text/plain": [ + "32.675003" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 13 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-11-25T15:19:00.220739Z", + "start_time": "2024-11-25T15:18:59.831800Z" + } + }, + "cell_type": "code", + "source": [ + "from mpl_toolkits.basemap import Basemap\n", + "map = Basemap(projection='merc',llcrnrlon=30.,llcrnrlat=-20.,urcrnrlon=36.,urcrnrlat=-10.,resolution='i') # projection, lat/lon extents and resolution of polygons to draw, Malawi \n", + "meridians = np.arange(30,36,0.25) # make longitude lines ever 5 degrees from 30N-50N\n", + "parallels = np.arange(-20,-10,0.25) # make latitude lines every 5 degrees from 95W to 70W\n", + "map.drawparallels(parallels,labels=[1,0,0,0],fontsize=10)\n", + "map.drawmeridians(meridians,labels=[0,0,0,1],fontsize=10)" + ], + "id": "bf3da164ab13376e", + "outputs": [ + { + "data": { + "text/plain": [ + "{30.0: ([],\n", + " [Text(667.1692457080871, -19920.892788966048, '30°E')]),\n", + " 30.25: ([],\n", + " [Text(28021.10831973966, -19920.892788966048, '30.25°E')]),\n", + " 30.5: ([],\n", + " [Text(56042.21663947932, -19920.892788966048, '30.5°E')]),\n", + " 30.75: ([],\n", + " [Text(84063.32495921898, -19920.892788966048, '30.75°E')]),\n", + " 31.0: ([],\n", + " [Text(111417.26403325055, -19920.892788966048, '31°E')]),\n", + " 31.25: ([],\n", + " [Text(139438.3723529902, -19920.892788966048, '31.25°E')]),\n", + " 31.5: ([],\n", + " [Text(167459.48067272987, -19920.892788966048, '31.5°E')]),\n", + " 31.75: ([],\n", + " [Text(194813.41974676144, -19920.892788966048, '31.75°E')]),\n", + " 32.0: ([],\n", + " [Text(222834.5280665011, -19920.892788966048, '32°E')]),\n", + " 32.25: ([],\n", + " [Text(250855.63638624077, -19920.892788966048, '32.25°E')]),\n", + " 32.5: ([],\n", + " [Text(278209.5754602723, -19920.892788966048, '32.5°E')]),\n", + " 32.75: ([],\n", + " [Text(306230.683780012, -19920.892788966048, '32.75°E')]),\n", + " 33.0: ([],\n", + " [Text(334251.79209975165, -19920.892788966048, '33°E')]),\n", + " 33.25: ([],\n", + " [Text(361605.73117378325, -19920.892788966048, '33.25°E')]),\n", + " 33.5: ([],\n", + " [Text(389626.8394935229, -19920.892788966048, '33.5°E')]),\n", + " 33.75: ([],\n", + " [Text(417647.9478132626, -19920.892788966048, '33.75°E')]),\n", + " 34.0: ([],\n", + " [Text(445001.8868872941, -19920.892788966048, '34°E')]),\n", + " 34.25: ([],\n", + " [Text(473022.99520703376, -19920.892788966048, '34.25°E')]),\n", + " 34.5: ([],\n", + " [Text(501044.10352677346, -19920.892788966048, '34.5°E')]),\n", + " 34.75: ([],\n", + " [Text(528398.042600805, -19920.892788966048, '34.75°E')]),\n", + " 35.0: ([],\n", + " [Text(556419.1509205446, -19920.892788966048, '35°E')]),\n", + " 35.25: ([],\n", + " [Text(584440.2592402843, -19920.892788966048, '35.25°E')]),\n", + " 35.5: ([],\n", + " [Text(611794.1983143159, -19920.892788966048, '35.5°E')]),\n", + " 35.75: ([],\n", + " [Text(639815.3066340556, -19920.892788966048, '35.75°E')])}" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 14 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "# Try a grid-by-grid, month-by-month comparison of weather", + "id": "34cc093fd4b699a0" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-11-25T15:19:24.922839Z", + "start_time": "2024-11-25T15:19:24.920184Z" + } + }, + "cell_type": "code", + "source": "chirps_xr_coarse_lat_flipped = chirps_xr_coarse.sel(latitude=slice(None, None, -1)) # was in ascending order", + "id": "d4cab170b65886f7", + "outputs": [], + "execution_count": 17 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-11-25T16:00:11.724933Z", + "start_time": "2024-11-25T15:58:44.777233Z" + } + }, + "cell_type": "code", + "source": [ + "\n", + "#for m in range(len(era5_data_xr['date'])):\n", + "diff_CHIRPS_all = {}\n", + "diff_TAMSAT_all = {}\n", + "diff_CHIRPS_TAMSAT_all = {}\n", + "for m in range(len(era5_data_xr['date'])):\n", + " diff_CHIRPS = []\n", + " diff_TAMSAT = []\n", + " diff_CHIRPS_TAMSAT = []\n", + " month = 0\n", + " for i in range(len(era5_data_xr['latitude']) - 1):\n", + " for j in range(len(era5_data_xr['longitude'])):\n", + " weather_era5 = era5_data_xr['tp'][m, i, j] * 1000 * days_in_month[month]\n", + " weather_CHIRPS = chirps_xr_coarse_lat_flipped['precip'][m, i, j]\n", + " weather_TAMSAT = tamsat_xr_filtered['rfe_filled'][m, i, j]\n", + "\n", + " diff_CHIRPS.append(weather_era5 - weather_CHIRPS)\n", + " diff_TAMSAT.append(weather_era5 - weather_TAMSAT)\n", + " diff_CHIRPS_TAMSAT.append(weather_CHIRPS - weather_TAMSAT)\n", + " # plt.plot(diff_CHIRPS, label='ERA5 - CHIRPS', color='green',alpha=0.2)\n", + " # plt.plot(diff_TAMSAT, label='ERA5 - TAMSAT', color='purple', alpha=0.2)\n", + " # plt.plot(diff_CHIRPS_TAMSAT, label='CHIRPS - TAMSAT', color='red',alpha=0.2)\n", + " diff_CHIRPS_all[m] = np.mean(diff_CHIRPS)\n", + " diff_TAMSAT_all[m] = np.mean(diff_TAMSAT)\n", + " diff_CHIRPS_TAMSAT_all[m] = np.mean(diff_CHIRPS_TAMSAT)\n", + " month = (month + 1) % 12\n", + "\n", + " \n", + "plt.xlabel(\"Months since Jan 2010\")\n", + "plt.ylabel(\"Difference in Precipitation\")\n", + "plt.show()\n", + " " + ], + "id": "d636ca0d437c9152", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 36 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-11-26T08:55:32.710145Z", + "start_time": "2024-11-26T08:55:32.627043Z" + } + }, + "cell_type": "code", + "source": [ + "plt.plot(diff_CHIRPS_all.keys(), diff_CHIRPS_all.values(), color = \"red\", label = \"ERA5 - CHIRPS\", alpha = 0.5)\n", + "plt.plot(diff_TAMSAT_all.keys(), diff_TAMSAT_all.values(), color = \"blue\", label = \"ERA5 - TAMSAT\", alpha = 0.5)\n", + "plt.plot(diff_CHIRPS_TAMSAT_all.keys(), diff_CHIRPS_TAMSAT_all.values(), color = \"green\", label = \"ERA5 - TAMSAT\", alpha = 0.5)\n" + ], + "id": "65aebb73363dcb3d", + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 41 + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": "", + "id": "67150ec2a2ee1633" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Detrend", + "id": "538b11bca116099d" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-11-26T14:12:07.623782Z", + "start_time": "2024-11-26T14:12:07.454100Z" + } + }, + "cell_type": "code", + "source": [ + "from scipy.signal import detrend\n", + "\n", + "detrended_diff_CHIRPS_all = {}\n", + "detrended_diff_TAMSAT_all = {}\n", + "detrended_diff_ERA5_all = {}\n", + "\n", + "detrended_diff_CHIRPS = []\n", + "detrended_diff_TAMSAT = []\n", + "detrended_diff_ERA5 = []\n", + "\n", + "grid = 0\n", + "for i in range(len(era5_data_xr['latitude']) - 1):\n", + " for j in range(len(era5_data_xr['longitude'])):\n", + " weather_era5_series = era5_data_xr['tp'][:, i, j].values * 1000 * 365\n", + " weather_CHIRPS_series = chirps_xr_coarse_lat_flipped['precip'][:, i, j].values\n", + " weather_TAMSAT_series = tamsat_xr_filtered['rfe_filled'][:, i, j].values\n", + "\n", + " detrended_weather_era5 = detrend(weather_era5_series)\n", + " detrended_weather_CHIRPS = detrend(weather_CHIRPS_series)\n", + " detrended_weather_TAMSAT = detrend(weather_TAMSAT_series)\n", + "\n", + " detrended_diff_CHIRPS.append(detrended_weather_CHIRPS)\n", + " detrended_diff_TAMSAT.append(detrended_weather_TAMSAT)\n", + " detrended_diff_ERA5.append(detrended_weather_era5)\n", + " \n", + " detrended_diff_CHIRPS_all[grid] = detrended_diff_CHIRPS\n", + " detrended_diff_TAMSAT_all[grid] = detrended_diff_TAMSAT\n", + " detrended_diff_ERA5_all[grid] = detrended_diff_ERA5\n", + " grid +=1\n", + "\n" + ], + "id": "ffdb8b4ca884a5b0", + "outputs": [], + "execution_count": 61 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-11-26T14:12:13.650672Z", + "start_time": "2024-11-26T14:12:09.610711Z" + } + }, + "cell_type": "code", + "source": [ + "plt.figure(figsize=(12, 6))\n", + "for grid in detrended_diff_CHIRPS_all.keys():\n", + " \n", + " plt.plot(range(len(detrended_diff_CHIRPS_all[grid])), detrended_diff_CHIRPS_all[grid], label=\"Detrended CHIRPS\")" + ], + "id": "8db379416e6648f", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 62 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-11-26T14:12:19.105004Z", + "start_time": "2024-11-26T14:12:13.651676Z" + } + }, + "cell_type": "code", + "source": [ + "plt.figure(figsize=(12, 6))\n", + "for grid in detrended_diff_CHIRPS_all.keys():\n", + "\n", + " plt.plot(range(len(detrended_diff_TAMSAT_all[grid])), detrended_diff_TAMSAT_all[grid], label=\"Detrended TAMSAT\")\n" + ], + "id": "b089565508596a56", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 63 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-11-26T14:12:23.264931Z", + "start_time": "2024-11-26T14:12:19.105751Z" + } + }, + "cell_type": "code", + "source": [ + "plt.figure(figsize=(12, 6))\n", + "for grid in detrended_diff_CHIRPS_all.keys():\n", + " plt.plot(range(len(detrended_diff_ERA5_all[grid])),detrended_diff_ERA5_all[grid], label=\"Detrended CHIRPS-TAMSAT Diff\")" + ], + "id": "6335ebcc4ed369f7", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 64 + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": "", + "id": "677c7463abae62e4" + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 562d65fd7c..a24a5280cc 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -2,33 +2,53 @@ import numpy as np import pandas as pd import statsmodels.api as sm -from statsmodels.othermod.betareg import BetaModel +from statsmodels.genmod.generalized_linear_model import GLM +from statsmodels.genmod.families import Poisson, NegativeBinomial import joblib - ANC = True daily_max = False -daily_total = True -min_year_for_analyis = 2011 +daily_total = False +if daily_total: + five_day = True + cumulative = True +else: + five_day = False + cumulative = False + +use_all_weather = True +min_year_for_analysis = 2012 absolute_min_year = 2011 mask_threshold = 0 -five_day = True -cumulative = True -model_fit_ANC_data = False -model_fit_weather_data = True +use_percentile_mask_threshold = False +use_residuals = False + +poisson=False +if use_residuals: + poisson = False +if poisson: + log_y = False +else: + log_y = True + +covid_months = range((2020 - min_year_for_analysis)* 12 + 4, (2020 - min_year_for_analysis)* 12 + 4 + 20) # Bingling's paper: disruption between April 2020 and Dec 2021, a period of 20 months +cyclone_freddy_months_phalombe = range((2023 - min_year_for_analysis)* 12 + 4, (2020 - min_year_for_analysis)* 12 + 4 + 14) # From news report and DHIS2, see disruption from April 2023 - June 2024, 14 months +cyclone_freddy_months_thumbwe = range((2023 - min_year_for_analysis)* 12 + 3, (2020 - min_year_for_analysis)* 12 + 3 + 12) # From news report and DHIS2, see disruption from March 2023 - March 2024, 12 months + model_filename = ( f"best_model_{'ANC' if ANC else 'Reporting'}_prediction_" f"{'5_day' if five_day else 'monthly'}_" - f"{'cumulative' if cumulative else ('max' if daily_max else 'total')}_precip.pkl" + f"{'cumulative' if cumulative else ('max' if daily_max else 'total')}_" + f"{'poisson' if poisson else 'linear'}_precip.pkl" ) - +print(model_filename) model_filename_weather_model = ( f"best_model_weather_" f"{'5_day' if five_day else 'monthly'}_" - f"{'cumulative' if cumulative else ('max' if daily_max else 'total')}_precip.pkl" + f"{'cumulative' if cumulative else ('max' if daily_max else 'total')}_" + f"{'poisson' if poisson else 'linear'}_precip.pkl" ) - -log_y = True +print(model_filename_weather_model) # # data is from 2011 - 2024 - for facility if ANC: monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_ANC_by_smaller_facility_lm.csv", index_col=0) @@ -56,33 +76,14 @@ weather_data_historical = pd.read_csv( "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_ANC_lm.csv", index_col=0) - -else: - monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm.csv", index_col=0) - if daily_max: - weather_data_historical = pd.read_csv( - "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_maximum/historical_daily_max_by_facility.csv", - index_col=0) - elif daily_total: - weather_data_historical = pd.read_csv( - "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/historical_daily_total_by_facility.csv", - index_col=0) - else: - weather_data_historical = pd.read_csv( - "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facility_lm.csv", - index_col=0) - -def build_model(X, y, scale_y=False, beta=False, log_y=False, X_mask_mm=0): - epsilon = 1e-5 +def build_model(X, y, poisson=False, log_y=False, X_mask_mm=0): + epsilon = 1 if log_y: y = np.log(np.clip(y, epsilon, None)) # Log-transform y with clipping for positivity - if scale_y: - y_scaled = np.clip(y / 100, epsilon, 1 - epsilon) - else: - y_scaled = y - mask = (~np.isnan(X).any(axis=1) & ~np.isnan(y_scaled) & (X[:, 0] >= X_mask_mm) & (y <= 1e4)) - model = BetaModel(y_scaled[mask], X[mask]) if beta else sm.OLS(y_scaled[mask], X[mask]) + mask = (~np.isnan(X).any(axis=1) & ~np.isnan(y) & ( + X[:, 0] >= X_mask_mm) & (y <= 1e4)) + model = GLM(y[mask], X[mask], family=NegativeBinomial(), method='nm' ) if poisson else sm.OLS(y[mask], X[mask]) model_fit = model.fit() return model_fit, model_fit.predict(X[mask]), mask @@ -90,19 +91,16 @@ def create_binary_feature(threshold, weather_data_df, recent_months): binary_feature_list = [] for facility in weather_data_df.columns: facility_data = weather_data_df[facility] - for i in range(len(facility_data)): facility_threshold = threshold[i] if hasattr(threshold, "__len__") else threshold - if i >= recent_months: + if i >= recent_months: # only count for recent months, and have to discount the data kept in for this purpose. Also, first 12 months have no data to check back to last_x_values = facility_data[i - recent_months:i] binary_feature_list.append(1 if (last_x_values > facility_threshold).any() else 0) - else: - binary_feature_list.append(np.nan) return binary_feature_list -def stepwise_selection(X, y, log_y, p_value_threshold=0.05): +def stepwise_selection(X, y, log_y, poisson, p_value_threshold=0.05): included = [] current_aic = np.inf @@ -114,7 +112,7 @@ def stepwise_selection(X, y, log_y, p_value_threshold=0.05): new_aic = pd.Series(index=excluded, dtype=float) for new_column in excluded: subset_X = X[:, included + [new_column]] - results, _, _ = build_model(subset_X, y, log_y=log_y, X_mask_mm=mask_threshold) + results, _, _ = build_model(subset_X, y, poisson, log_y=log_y, X_mask_mm=mask_threshold) if results.pvalues[-1] < p_value_threshold: new_aic[new_column] = results.aic @@ -124,135 +122,172 @@ def stepwise_selection(X, y, log_y, p_value_threshold=0.05): included.append(best_feature) current_aic = new_aic.min() changed = True + print(current_aic) - # Step 2: Check significance of each included predictor and remove non-significant ones - results, _, _ = build_model(X[:, included], y, log_y=log_y, X_mask_mm=mask_threshold) - pvalues = pd.Series(results.pvalues, index=included) - for feature in pvalues[pvalues > p_value_threshold].index: - included.remove(feature) - changed = True # Exit if no changes were made in this iteration if not changed: break return included -# -# -# def stepwise_selection(X, y, log_y, p_value_threshold=0.05): -# included = [] # Start with an empty set of features -# current_r2 = 0 # Start with a baseline of 0 for R^2 -# while True: -# changed = False -# excluded = list(set(range(X.shape[1])) - set(included)) -# new_r2 = pd.Series(index=excluded, dtype=float) -# for new_column in excluded: -# subset_X = X[:, included + [new_column]] -# results, _, _ = build_model(subset_X, y, log_y=log_y) -# new_r2[new_column] = results.rsquared # Evaluate R^2 with the new feature -# -# best_r2 = new_r2.max() -# print(best_r2) -# if best_r2 - current_r2 > 1e-4: -# best_feature = new_r2.idxmax() -# included.append(best_feature) -# current_r2 = best_r2 -# changed = True -# -# # Backward elimination: remove features with high p-values -# results, _, _ = build_model(X[:, included], y, log_y=log_y) -# pvalues = pd.Series(results.pvalues, index=included) -# worst_pval = pvalues.max() -# if worst_pval > p_value_threshold: -# worst_feature = pvalues.idxmax() -# included.remove(worst_feature) -# changed = True -# -# if not changed: -# break -# return included +def repeat_info(info, num_facilities, year_range, historical): + # Repeat facilities in alternating order for each month and year + repeated_info = [info[i % len(info)] for i in range(len(year_range) * 12 * num_facilities)] + + if historical: + return repeated_info[:-4 * num_facilities] # Exclude final 4 months for all facilities + else: + return repeated_info +# +### Try combine weather variables ## +if use_all_weather: + weather_data_monthly_original = pd.read_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_ANC_lm.csv", + index_col=0) + + weather_data_five_day_cumulative_original = pd.read_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/historical_daily_total_by_facilities_with_ANC_five_day_cumulative.csv", + index_col=0) ############################################################################################## ########################## STEP 0: Tidy data ########################## ############################################################################################## -# Drop September 2024 - -weather_data_historical = weather_data_historical.drop(weather_data_historical.index[-1]) +## Remove any columns that sum to 0 in the monthly reporting data (e.g. for inpatient data, may mean they don't have the facility) +zero_sum_columns = monthly_reporting_by_facility.columns[(monthly_reporting_by_facility.sum(axis=0) == 0)] +monthly_reporting_by_facility = monthly_reporting_by_facility.drop(columns=zero_sum_columns) + +if use_all_weather: + weather_data_monthly_df = weather_data_monthly_original.drop(columns=zero_sum_columns, errors='ignore') + weather_data_five_day_cumulative_df = weather_data_five_day_cumulative_original.drop(columns=zero_sum_columns, errors='ignore') + + weather_data_monthly_df = weather_data_monthly_df.drop(weather_data_monthly_df.index[-2:]) + weather_data_five_day_cumulative_df = weather_data_five_day_cumulative_df.drop(weather_data_five_day_cumulative_df.index[-1:]) + + lag_1_month = weather_data_monthly_df.shift(1).values + lag_2_month = weather_data_monthly_df.shift(2).values + lag_3_month = weather_data_monthly_df.shift(3).values + lag_4_month = weather_data_monthly_df.shift(4).values + lag_1_month = lag_1_month[(min_year_for_analysis - absolute_min_year) * 12:].flatten() + lag_2_month = lag_2_month[(min_year_for_analysis - absolute_min_year) * 12:].flatten() + lag_3_month = lag_3_month[(min_year_for_analysis - absolute_min_year) * 12:].flatten() + lag_4_month = lag_4_month[(min_year_for_analysis - absolute_min_year) * 12:].flatten() + + lag_1_5_day = weather_data_five_day_cumulative_df.shift(1).values + lag_2_5_day = weather_data_five_day_cumulative_df.shift(2).values + lag_3_5_day = weather_data_five_day_cumulative_df.shift(3).values + lag_4_5_day = weather_data_five_day_cumulative_df.shift(4).values + lag_1_5_day = lag_1_5_day[(min_year_for_analysis - absolute_min_year) * 12:].flatten() + lag_2_5_day = lag_2_5_day[(min_year_for_analysis - absolute_min_year) * 12:].flatten() + lag_3_5_day = lag_3_5_day[(min_year_for_analysis - absolute_min_year) * 12:].flatten() + lag_4_5_day = lag_4_5_day[(min_year_for_analysis - absolute_min_year) * 12:].flatten() + + # need for binary + lag_12_month = weather_data_monthly_df.shift(12).values + lag_12_month = lag_12_month[(min_year_for_analysis - absolute_min_year) * 12:].flatten() + + # mask covid months - don't need to do on lagged data, because the removal of these entries in the model will remove all rows + weather_data_monthly = weather_data_monthly_df # need to keep these seperate for the binary values later + weather_data_five_day_cumulative = weather_data_five_day_cumulative_df + + weather_data_monthly.loc[covid_months, :] = np.nan + weather_data_five_day_cumulative.loc[covid_months, :] = np.nan + # code if years need to be dropped + + weather_data_monthly = weather_data_monthly.iloc[(min_year_for_analysis - absolute_min_year) * 12:] + weather_data_five_day_cumulative = weather_data_five_day_cumulative.iloc[(min_year_for_analysis - absolute_min_year) * 12:] + + weather_data_monthly_flattened = weather_data_monthly.values.flatten() + weather_data_five_day_cumulative_flattened = weather_data_five_day_cumulative.values.flatten() + weather_data = np.vstack((weather_data_monthly_flattened,weather_data_five_day_cumulative_flattened)).T +else: + if five_day:# Drop September 2024 + weather_data_historical = weather_data_historical.drop(weather_data_historical.index[-1:]) + else: # drop october for monthly data + weather_data_historical = weather_data_historical.drop(weather_data_historical.index[-2:]) + weather_data_historical = weather_data_historical.drop(columns=zero_sum_columns, errors='ignore') + weather_data_historical.loc[covid_months, :] = np.nan + weather_data = weather_data_historical.values.flatten() + +# Mask COVID-19 months for reporting +monthly_reporting_by_facility.iloc[covid_months, :] = np.nan +# Mask for missing data with Cyclone Freddy +monthly_reporting_by_facility.loc[cyclone_freddy_months_phalombe, 'Phalombe Health Centre'] = 0 +monthly_reporting_by_facility.loc[cyclone_freddy_months_phalombe, 'Thumbwe Health Centre'] = 0 + +# Drop September 2024 in ANC/reporting data monthly_reporting_by_facility = monthly_reporting_by_facility.drop(monthly_reporting_by_facility.index[-1]) - # code if years need to be dropped -weather_data_historical = weather_data_historical.iloc[(min_year_for_analyis-absolute_min_year)*12 :] -monthly_reporting_by_facility = monthly_reporting_by_facility.iloc[(min_year_for_analyis-absolute_min_year)*12:] +monthly_reporting_by_facility = monthly_reporting_by_facility.iloc[(min_year_for_analysis-absolute_min_year)*12:] # Linear regression month_range = range(12) -num_facilities = len(weather_data_historical.columns) -year_range = range(min_year_for_analyis, 2025, 1) # year as a fixed effect +num_facilities = len(monthly_reporting_by_facility.columns) +year_range = range(min_year_for_analysis, 2025, 1) # year as a fixed effect year_repeated = [y for y in year_range for _ in range(12)] year = year_repeated[:-4] -year_flattened = year*len(weather_data_historical.columns) # to get flattened data +year_flattened = year*len(monthly_reporting_by_facility.columns) # to get flattened data month = range(12) month_repeated = [] for _ in year_range: month_repeated.extend(range(1, 13)) month = month_repeated[:-4] -month_flattened = month*len(weather_data_historical.columns) +month_flattened = month*len(monthly_reporting_by_facility.columns) -facility_flattened = list(range(len(weather_data_historical.columns))) * len(month) +facility_flattened = list(range(len(monthly_reporting_by_facility.columns))) * len(month) # Flatten data -weather_data = weather_data_historical.values.flatten() y = monthly_reporting_by_facility.values.flatten() +#y[np.isnan(y)] = 0 # if all of these are expected to report, then can I assume all 0? if np.nanmin(y) < 1: - y += 1e-6 # Shift to ensure positivity as taking log -y[y > 1e5] = np.nan + y += 1 # Shift to ensure positivity as taking log +y[y > 4e3] = np.nan +if use_percentile_mask_threshold: + mask_threshold = np.nanpercentile(weather_data, 90) + print(mask_threshold) + # One-hot encode facilities facility_encoded = pd.get_dummies(facility_flattened, drop_first=True) - -# Above/below average for each month -grouped_data = pd.DataFrame({ - 'facility': facility_flattened, - 'month': month_flattened, - 'weather_data': weather_data -}).groupby(['facility', 'month'])['weather_data'].mean().reset_index() - -above_below_average = create_binary_feature( - grouped_data.groupby(['facility', 'month'])['weather_data'].transform('mean'), weather_data_historical, 0 -) -above_below_X = create_binary_feature(1000, weather_data_historical, 12) - +# above below +weather_data_monthly_subsetted = weather_data_monthly_df.iloc[ + (min_year_for_analysis - absolute_min_year - 1) * 12:] +weather_data_monthly_original_flattened = weather_data_monthly_subsetted.values.flatten() +percentile_90 = np.nanpercentile(weather_data_monthly_original_flattened, 90) +above_below_X = lag_12_month > percentile_90 # Prepare additional facility info if ANC: expanded_facility_info = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_with_ANC.csv", index_col=0) else: expanded_facility_info = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm.csv", index_col=0) -expanded_facility_info = expanded_facility_info.T.reindex(columns=expanded_facility_info.index) +expanded_facility_info = expanded_facility_info.drop(columns=zero_sum_columns) -def repeat_info(info, num_facilities, year_range): - repeated_info = [i for i in info for _ in range(12) for _ in year_range] - return repeated_info[:-4 * num_facilities] # Exclude first final months (Sept - Dec 2024) +expanded_facility_info = expanded_facility_info.T.reindex(columns=expanded_facility_info.index) -zone_info_each_month = repeat_info(expanded_facility_info["Zonename"], num_facilities, year_range) +zone_info_each_month = repeat_info(expanded_facility_info["Zonename"], num_facilities, year_range, historical = True) zone_encoded = pd.get_dummies(zone_info_each_month, drop_first=True) -resid_info_each_month = repeat_info(expanded_facility_info['Resid'], num_facilities, year_range) +resid_info_each_month = repeat_info(expanded_facility_info['Resid'], num_facilities, year_range, historical = True) resid_encoded = pd.get_dummies(resid_info_each_month, drop_first=True) -owner_info_each_month = repeat_info(expanded_facility_info['A105'], num_facilities, year_range) +owner_info_each_month = repeat_info(expanded_facility_info['A105'], num_facilities, year_range, historical = True) owner_encoded = pd.get_dummies(owner_info_each_month, drop_first=True) -ftype_info_each_month = repeat_info(expanded_facility_info['Ftype'], num_facilities, year_range) +ftype_info_each_month = repeat_info(expanded_facility_info['Ftype'], num_facilities, year_range, historical = True) ftype_encoded = pd.get_dummies(ftype_info_each_month, drop_first=True) -altitude = [float(x) for x in repeat_info(expanded_facility_info['A109__Altitude'], num_facilities, year_range)] +altitude = [float(x) for x in repeat_info(expanded_facility_info['A109__Altitude'], num_facilities, year_range, historical = True)] +minimum_distance = [float(x) for x in repeat_info(expanded_facility_info['minimum_distance'], num_facilities, year_range, historical = True)] # Lagged weather -lag_1_month = weather_data_historical.shift(1).values.flatten() -lag_2_month = weather_data_historical.shift(2).values.flatten() -lag_3_month = weather_data_historical.shift(3).values.flatten() -lag_4_month = weather_data_historical.shift(4).values.flatten() +if not use_all_weather: + lag_1_month = weather_data_historical.shift(1).values.flatten() + lag_2_month = weather_data_historical.shift(2).values.flatten() + lag_3_month = weather_data_historical.shift(3).values.flatten() + lag_4_month = weather_data_historical.shift(4).values.flatten() altitude = np.array(altitude) altitude = np.where(altitude < 0, np.nan, altitude) +mean_altitude = round(np.nanmean(altitude)) +altitude = np.where(np.isnan(altitude), float(mean_altitude), altitude) +altitude = np.nan_to_num(altitude, nan=mean_altitude, posinf=mean_altitude, neginf=mean_altitude) altitude = list(altitude) -#print(np.nanmax(y) ) ## one y value is > 167,000. So should remove +minimum_distance = np.nan_to_num(minimum_distance, nan=np.nan, posinf=np.nan, neginf=np.nan) # just in case -############################################################################################## ########################## STEP 1: GENERATE PREDICTIONS OF ANC DATA ########################## ############################################################################################## @@ -264,31 +299,23 @@ def repeat_info(info, num_facilities, year_range): owner_encoded, ftype_encoded, facility_encoded, - altitude + altitude, + np.array(minimum_distance) ]) -if model_fit_ANC_data: - best_predictors = stepwise_selection(X, y, log_y=log_y) - X_best = X[:, best_predictors] - results, y_pred, mask_ANC_data = build_model(X_best, y, log_y=log_y, X_mask_mm=mask_threshold) - model_data = { - 'model': results, - 'mask': mask_ANC_data, - 'best_predictors': best_predictors # Save best predictors - } - joblib.dump(model_data, model_filename) -else: - model_data = joblib.load(model_filename) - results = model_data['model'] - mask_ANC_data = model_data['mask'] - best_predictors = model_data['best_predictors'] - X = X[:, best_predictors] - y_pred = results.predict(X[mask_ANC_data]) +results, y_pred, mask_ANC_data = build_model(X , y, poisson = poisson, log_y=log_y, X_mask_mm=mask_threshold) -if log_y: - residuals_percentage = (y[mask_ANC_data] - np.exp(y_pred)) +if use_residuals: + if log_y: + y_weather = (y[mask_ANC_data] - np.exp(y_pred)) + 1 # for poisson + else: + y_weather = (y[mask_ANC_data] - y_pred) + 1 # for poisson else: - residuals_percentage = (y[mask_ANC_data] - y_pred) + if log_y: + y_weather = np.exp(y_pred) + else: + y_weather = y_pred + print("ANC prediction", results.summary()) @@ -301,162 +328,436 @@ def repeat_info(info, num_facilities, year_range): 'Year_Month': year_month_labels_filtered, 'y_filtered': y_filtered, 'y_pred': np.exp(y_pred), + 'residuals': y_filtered - np.exp(y_pred) }) else: data_ANC_predictions = pd.DataFrame({ 'Year_Month': year_month_labels_filtered, 'y_filtered': y_filtered, 'y_pred': y_pred, - }) + 'residuals': y_filtered - y_pred + }) data_ANC_predictions = data_ANC_predictions.sort_values(by='Year_Month').reset_index(drop=True) +x_labels = data_ANC_predictions['Year_Month'][::num_facilities*12] + +# Set the xticks at corresponding positions fig, axs = plt.subplots(1, 2, figsize=(14, 6)) +step = num_facilities * 12 +data_ANC_predictions_grouped = data_ANC_predictions.groupby('Year_Month').mean().reset_index() +xticks = data_ANC_predictions['Year_Month'][::len(year_range)*num_facilities] # Panel A: Actual data and predictions axs[0].scatter(data_ANC_predictions['Year_Month'], data_ANC_predictions['y_filtered'], color='#1C6E8C', alpha=0.5, label='Actual data') axs[0].scatter(data_ANC_predictions['Year_Month'], data_ANC_predictions['y_pred'], color='#9AC4F8', alpha=0.7, label='Predictions') -axs[0].set_xticklabels(data_ANC_predictions['Year_Month'], rotation=45, ha='right') +axs[0].scatter(data_ANC_predictions_grouped['Year_Month'], data_ANC_predictions_grouped['y_filtered'], color='red', alpha=0.5, label='Mean Actual data') +axs[0].scatter(data_ANC_predictions_grouped['Year_Month'], data_ANC_predictions_grouped['y_pred'], color='yellow', alpha=0.7, label='Mean Predictions') + +axs[0].set_xticks(xticks) +axs[0].set_xticklabels(xticks, rotation=45, ha='right') axs[0].set_xlabel('Year') axs[0].set_ylabel('Number of ANC visits') axs[0].set_title('A: Monthly ANC Visits vs. Precipitation') axs[0].legend(loc='upper left') -# Panel B: Residuals (in percentage) -axs[1].scatter(data_ANC_predictions['Year_Month'], residuals_percentage, color='#9AC4F8', alpha=0.7, label='Residuals') -axs[1].set_xticklabels(data_ANC_predictions['Year_Month'], rotation=45, ha='right') +# Panel B: Residuals +if use_residuals: + axs[1].scatter(data_ANC_predictions['Year_Month'], data_ANC_predictions['residuals'], color='#9AC4F8', alpha=0.7, label='Residuals') + axs[1].scatter(data_ANC_predictions_grouped['Year_Month'], np.exp(data_ANC_predictions_grouped['residuals']), + color='red', alpha=0.7, label='Mean Residuals') +else: + axs[1].scatter(data_ANC_predictions['Year_Month'], (data_ANC_predictions['y_filtered'] - data_ANC_predictions['y_pred']), color='#9AC4F8', alpha=0.7, label='Residuals') + axs[1].scatter(data_ANC_predictions_grouped['Year_Month'], data_ANC_predictions_grouped['residuals'], + color='red', alpha=0.7, label='Mean Residuals') + +axs[1].set_xticks(xticks) +axs[1].set_xticklabels(xticks, rotation=45, ha='right') axs[1].set_xlabel('Year') axs[1].set_ylabel('Residuals') axs[1].set_title('B: Residuals') axs[1].legend(loc='upper left') +axs[1].set_ylim(top = 3000) plt.tight_layout() -plt.show() - -fig, axs = plt.subplots(1, 2, figsize=(14, 6)) - -# Panel A: Actual data and predictions -axs[0].scatter(data_ANC_predictions['Year_Month'], np.log(data_ANC_predictions['y_filtered']), color='#1C6E8C', alpha=0.5, label='Actual data') -axs[0].scatter(data_ANC_predictions['Year_Month'], np.log(data_ANC_predictions['y_pred']), color='#9AC4F8', alpha=0.7, label='Predictions') -axs[0].set_xticklabels(data_ANC_predictions['Year_Month'], rotation=45, ha='right') -axs[0].set_xlabel('Year') -axs[0].set_ylabel('Log(Number of ANC visits)') -axs[0].set_title('A: Monthly ANC Visits vs. Precipitation') -axs[0].legend(loc='upper left') +#plt.show() -# Panel B: Residuals (in percentage) -axs[1].scatter(data_ANC_predictions['Year_Month'], np.log(residuals_percentage), color='#9AC4F8', alpha=0.7, label='Residuals') -axs[1].set_xticklabels(data_ANC_predictions['Year_Month'], rotation=45, ha='right') -axs[1].set_xlabel('Year') -axs[1].set_ylabel('Log(Residual ANC cases)') -axs[1].set_title('B: Residuals cases') -axs[1].legend(loc='upper left') -plt.tight_layout() -plt.show() ############################################################################################## ########################## STEP 2 - USE THESE IN PREDICTIONS ########################## ############################################################################################## -X = np.column_stack([ - weather_data[mask_ANC_data], - np.array(year_flattened)[mask_ANC_data], - np.array(month_flattened)[mask_ANC_data], - resid_encoded[mask_ANC_data], - zone_encoded[mask_ANC_data], - owner_encoded[mask_ANC_data], - ftype_encoded[mask_ANC_data], - lag_1_month[mask_ANC_data], - lag_2_month[mask_ANC_data], - lag_3_month[mask_ANC_data], - lag_4_month[mask_ANC_data], - facility_encoded[mask_ANC_data], - np.array(altitude)[mask_ANC_data] -]) -log_y = False -if model_fit_weather_data: - best_predictors = stepwise_selection(X, residuals_percentage, log_y=log_y) - print(best_predictors) - X_best = X[:, best_predictors] - results_of_weather_model, y_pred, mask_all_data = build_model(X_best, residuals_percentage, log_y=log_y, X_mask_mm=mask_threshold) - model_data = { - 'model': results_of_weather_model, - 'mask': mask_all_data, - 'best_predictors': best_predictors # Save best predictors - } - joblib.dump(model_data, model_filename_weather_model) +if use_residuals: + X_weather = np.column_stack([ + weather_data[mask_ANC_data], + np.array(year_flattened)[mask_ANC_data], + np.array(month_flattened)[mask_ANC_data], + resid_encoded[mask_ANC_data], + zone_encoded[mask_ANC_data], + owner_encoded[mask_ANC_data], + ftype_encoded[mask_ANC_data], + lag_1_month[mask_ANC_data], + lag_2_month[mask_ANC_data], + lag_3_month[mask_ANC_data], + lag_4_month[mask_ANC_data], + lag_1_5_day[mask_ANC_data], + lag_2_5_day[mask_ANC_data], + lag_3_5_day[mask_ANC_data], + lag_4_5_day[mask_ANC_data], + facility_encoded[mask_ANC_data], + np.array(altitude)[mask_ANC_data], + np.array(minimum_distance)[mask_ANC_data], + #np.array(above_below_X)[mask_ANC_data], + ]) + results_of_weather_model, y_pred_weather, mask_all_data = build_model(X_weather, y_weather, poisson=False, log_y=False, # residuals are already logged + X_mask_mm=mask_threshold) else: - model_data = joblib.load(model_filename_weather_model) - results_of_weather_model = model_data['model'] - mask_all_data = model_data['mask'] - best_predictors = model_data['best_predictors'] -results_of_weather_model, y_pred, mask_all_data = build_model(X_best, residuals_percentage, log_y=log_y, - X_mask_mm=mask_threshold) -print(results_of_weather_model.summary()) + X_weather = np.column_stack([ + weather_data, + np.array(year_flattened), + np.array(month_flattened), + resid_encoded, + zone_encoded, + owner_encoded, + ftype_encoded, + lag_1_month, + lag_2_month, + lag_3_month, + lag_4_month, + lag_1_5_day, + lag_2_5_day, + lag_3_5_day, + lag_4_5_day, + facility_encoded, + np.array(altitude), + np.array(minimum_distance), + #above_below_X + ]) + + results_of_weather_model, y_pred_weather, mask_all_data = build_model(X_weather, y, poisson = poisson, log_y=log_y, + X_mask_mm=mask_threshold) +print("All predictors", results_of_weather_model.summary()) +# -X = np.column_stack([ - weather_data[mask_ANC_data], - np.array(year_flattened)[mask_ANC_data], - np.array(month_flattened)[mask_ANC_data], - resid_encoded[mask_ANC_data], - zone_encoded[mask_ANC_data], - owner_encoded[mask_ANC_data], - ftype_encoded[mask_ANC_data], - lag_1_month[mask_ANC_data], - lag_2_month[mask_ANC_data], - lag_3_month[mask_ANC_data], - lag_4_month[mask_ANC_data], - facility_encoded[mask_ANC_data], - np.array(altitude)[mask_ANC_data], +X_filtered = X_weather[mask_all_data] -]) +# # Effect size +# if use_residuals: +# y_mean = np.mean(y_weather[mask_all_data]) +# SS_total = np.sum((y_weather[mask_all_data] - y_mean) ** 2) +# else: +# y_mean = np.mean(y[mask_all_data]) +# SS_total = np.sum((y[mask_all_data] - y_mean) ** 2) +# +# predictor_variances = np.var(X_filtered, axis=0, ddof=1) +# coefficients = results_of_weather_model.params +# SS_effect = coefficients**2 * predictor_variances +# eta_squared = SS_effect / SS_total +# effect_size_summary = pd.DataFrame({ +# 'Coefficient': coefficients, +# 'SS_effect': SS_effect, +# 'Eta-squared': eta_squared +# }).sort_values(by='Eta-squared', ascending=False) +# +# print(effect_size_summary) -X_weather = np.column_stack([ - weather_data[mask_ANC_data], - np.array(month_flattened)[mask_ANC_data], - X[:,best_predictors], - lag_1_month[mask_ANC_data], - lag_2_month[mask_ANC_data], - lag_3_month[mask_ANC_data], - lag_4_month[mask_ANC_data] -]) -results_of_weather_model, y_pred, mask_all_data = build_model(X_weather, residuals_percentage, log_y=log_y, X_mask_mm=mask_threshold) -print(results_of_weather_model.summary()) +fig, axs = plt.subplots(1, 2, figsize=(10, 6)) -##### Plot y_predic +if use_residuals: + if log_y: + axs[0].scatter(X_filtered[:, 0], y_weather[mask_all_data], color='red', alpha=0.5, label = 'Residuals') + axs[0].scatter(X_filtered[:, 0], np.exp(y_pred_weather), label='Expected change in ANC visits', color="blue", alpha = 0.5) + axs[0].hlines(y = 0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color = 'black', linestyle = '--') + axs[0].set_ylabel('Expcetd change in ANC visits') -X_filtered = X[mask_all_data] + axs[1].scatter(X_filtered[:, 0], np.exp(y_pred_weather[mask_all_data] - y_pred), color='red', alpha=0.5, label = 'Residuals') + axs[1].hlines(y = 0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color = 'black', linestyle = '--') + axs[1].set_ylabel('Difference between weather and non-weather model') -plt.scatter(X_filtered[:, 0], (residuals_percentage[mask_all_data]), color='red', alpha=0.5) -plt.scatter(X_filtered[:, 0],y_pred) -plt.title(' ') -plt.ylabel('Change in ANC visits') -plt.xlabel('Precip (mm)') -plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) -plt.show() + else: + axs[0].scatter(X_filtered[:, 0], y_weather[mask_all_data], color='red', alpha=0.5, label = 'Residuals') + axs[0].hlines(y = 0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color = 'black', linestyle = '--') + axs[0].scatter(X_filtered[:, 0], y_pred, label='Expected change in ANC visits') + axs[0].hlines(y=0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color='black', linestyle='--') + axs[0].set_ylabel('Expcetd change in ANC visits') + axs[1].scatter(X_filtered[:, 0], y_pred_weather[mask_all_data] - y_pred[X_weather[:,0]> mask_threshold], color='red', alpha=0.5, label = 'Residuals') + axs[1].hlines(y = 0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color = 'black', linestyle = '--') + axs[1].set_ylabel('Difference between weather and non-weather model') +else: + indices_ANC_data = np.where(mask_ANC_data)[0] + indices_all_data = np.where(mask_all_data)[0] + common_indices = np.intersect1d(indices_ANC_data, indices_all_data) + matched_y_pred = y_pred[np.isin(indices_ANC_data, common_indices)] + matched_y_pred_weather = y_pred_weather[np.isin(indices_all_data, common_indices)] -X_weather = np.column_stack([ - weather_data[mask_ANC_data], - X[:,best_predictors], - np.array(month_flattened)[mask_ANC_data], - lag_1_month[mask_ANC_data], - lag_2_month[mask_ANC_data], - lag_3_month[mask_ANC_data], - lag_4_month[mask_ANC_data] + if log_y: + axs[0].scatter(X_filtered[:, 0], y[mask_all_data], color='red', alpha=0.5, label = 'Non weather model') + axs[0].hlines(y = 0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color = 'black', linestyle = '--') + axs[0].scatter(X_filtered[:, 0], np.exp(y_pred_weather), label='Weather model', color="blue", alpha = 0.5) + axs[0].hlines(y=0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color='black', linestyle='--') + axs[0].set_ylabel('ANC visits') + + axs[1].scatter(X_filtered[:, 0], np.exp(matched_y_pred_weather) - np.exp(matched_y_pred), color='red', alpha=0.5, label = 'Residuals') + axs[1].hlines(y = 0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color = 'black', linestyle = '--') + axs[1].set_ylabel('Difference between weather and non-weather model') + else: + axs[0].scatter(X_filtered[:, 0], y[mask_all_data], color='red', alpha=0.5, label = 'Non weather model') + axs[0].hlines(y = 0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color = 'black', linestyle = '--') + axs[0].scatter(X_filtered[:, 0], y_pred, label='Weather model') + axs[0].hlines(y=0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color='black', linestyle='--') + axs[0].set_ylabel('ANC visits') + + axs[1].scatter(X_filtered[:, 0], matched_y_pred_weather- matched_y_pred, color='red', alpha=0.5, label = 'Residuals') + axs[1].hlines(y = 0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color = 'black', linestyle = '--') + axs[1].set_ylabel('Difference between weather and non-weather model') +axs[0].set_xlabel('Monthly precipitation (mm)') +axs[1].set_xlabel('Monthly precipitation (mm)') + +axs[0].legend(loc='upper left', borderaxespad=0.) + + +#plt.show() + + +############### ADD IN CMIP DATA ########################### + +# Configuration and constants +min_year_for_analysis = 2025 +absolute_min_year = 2025 +max_year_for_analysis = 2071 +data_path = "/Users/rem76/Desktop/Climate_change_health/Data/" + +# Define SSP scenario +ssp_scenario = "ssp245" # Change this to "ssp5_8_5" as needed + +# Load and preprocess weather data +if use_all_weather: + weather_data_prediction_five_day_cumulative_original = pd.read_csv( + f"{data_path}Precipitation_data/Downscaled_CMIP6_data_CIL/{ssp_scenario}/highest_model_daily_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{ssp_scenario}.csv", + dtype={'column_name': 'float64'}) + weather_data_prediction_monthly_original = pd.read_csv( + f"{data_path}Precipitation_data/Downscaled_CMIP6_data_CIL/{ssp_scenario}/highest_model_monthly_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{ssp_scenario}.csv", + dtype={'column_name': 'float64'}) + weather_data_prediction_monthly_df = weather_data_prediction_monthly_original.drop(columns=zero_sum_columns) + weather_data_prediction_five_day_cumulative_df = weather_data_prediction_five_day_cumulative_original.drop(columns=zero_sum_columns) + + lag_1_month_prediction = weather_data_prediction_monthly_df.shift(1).values + lag_2_month_prediction = weather_data_prediction_monthly_df.shift(2).values + lag_3_month_prediction = weather_data_prediction_monthly_df.shift(3).values + lag_4_month_prediction = weather_data_prediction_monthly_df.shift(4).values + + lag_1_month_prediction = lag_1_month_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() + lag_2_month_prediction = lag_2_month_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() + lag_3_month_prediction = lag_3_month_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() + lag_4_month_prediction = lag_4_month_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() + + lag_1_5_day_prediction = weather_data_prediction_five_day_cumulative_df.shift(1).values + lag_2_5_day_prediction = weather_data_prediction_five_day_cumulative_df.shift(2).values + lag_3_5_day_prediction = weather_data_prediction_five_day_cumulative_df.shift(3).values + lag_4_5_day_prediction = weather_data_prediction_five_day_cumulative_df.shift(4).values + + lag_1_5_day_prediction = lag_1_5_day_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() + lag_2_5_day_prediction = lag_2_5_day_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() + lag_3_5_day_prediction = lag_3_5_day_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() + lag_4_5_day_prediction = lag_4_5_day_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() + weather_data_prediction_five_day_cumulative = weather_data_prediction_five_day_cumulative_df # keep these seperate for binary features + + # need for binary comparison + lag_12_month = weather_data_prediction_monthly_df.shift(12).values + lag_12_month = lag_12_month[(min_year_for_analysis - absolute_min_year) * 12:].flatten() + + weather_data_prediction_monthly = weather_data_prediction_monthly_df # keep these seperate for binary features + + weather_data_prediction_five_day_cumulative = weather_data_prediction_five_day_cumulative.iloc[(min_year_for_analysis - absolute_min_year) * 12:] + weather_data_prediction_monthly = weather_data_prediction_monthly.iloc[(min_year_for_analysis - absolute_min_year) * 12:] + weather_data_prediction_monthly_flattened = weather_data_prediction_monthly.values.flatten() + weather_data_prediction_five_day_cumulative_flattened = weather_data_prediction_five_day_cumulative.values.flatten() + weather_data_prediction_flatten = np.vstack((weather_data_prediction_monthly_flattened, weather_data_prediction_five_day_cumulative_flattened)).T + num_facilities = len(weather_data_prediction_monthly.columns) +else: + if five_day: + weather_data_prediction = pd.read_csv( + f"{data_path}Precipitation_data/Downscaled_CMIP6_data/{ssp_scenario}/prediction_weather_by_smaller_facilities_with_ANC_lm.csv", index_col=0, + dtype={'column_name': 'float64'}) + else: + weather_data_prediction = pd.read_csv( + f"{data_path}Precipitation_data/Downscaled_CMIP6_data/{ssp_scenario}/prediction_weather_monthly_by_smaller_facilities_with_ANC_lm.csv", + index_col=0, dtype={'column_name': 'float64'}) + weather_data_prediction = weather_data_prediction.iloc[(min_year_for_analysis - absolute_min_year) * 12:] + weather_data_prediction_flatten = weather_data_prediction.values.flatten() + num_facilities = len(weather_data_prediction.columns) + +missing_facility = [col for col in expanded_facility_info.index if col not in weather_data_prediction_monthly.columns] +expanded_facility_info = expanded_facility_info.drop(missing_facility) +year_range_prediction = range(min_year_for_analysis, max_year_for_analysis) +month_repeated_prediction = [m for _ in year_range_prediction for m in range(1, 13)] +year_flattened_prediction = np.repeat(year_range_prediction, 12 * num_facilities) +month_flattened_prediction = month_repeated_prediction * num_facilities +facility_flattened_prediction = np.tile(range(num_facilities), len(year_flattened_prediction) // num_facilities) +# Encode facilities and create above/below average weather data +facility_encoded_prediction = pd.get_dummies(facility_flattened_prediction, drop_first=True) + +# Load and preprocess facility information +zone_info_prediction = repeat_info(expanded_facility_info["Zonename"], num_facilities, year_range_prediction, historical = False) +zone_encoded_prediction = pd.get_dummies(zone_info_prediction, drop_first=True) + +resid_info_prediction = repeat_info(expanded_facility_info['Resid'], num_facilities, year_range_prediction, historical = False) + +resid_encoded_prediction = pd.get_dummies(resid_info_prediction, drop_first=True) +owner_info_prediction = repeat_info(expanded_facility_info['A105'], num_facilities, year_range_prediction, historical = False) +owner_encoded_prediction = pd.get_dummies(owner_info_prediction, drop_first=True) +ftype_info_prediction = repeat_info(expanded_facility_info['Ftype'], num_facilities, year_range_prediction, historical = False) +ftype_encoded_prediction = pd.get_dummies(ftype_info_prediction, drop_first=True) +altitude_prediction = [float(x) for x in repeat_info(expanded_facility_info['A109__Altitude'],num_facilities, year_range_prediction, historical = False)] +minimum_distance_prediction = [float(x) for x in repeat_info(expanded_facility_info['minimum_distance'],num_facilities, year_range_prediction, historical = False)] +# minimum_distance_prediction = np.nan_to_num(minimum_distance_prediction, nan=np.nan, posinf=np.nan, neginf=np.nan) # just in case + +altitude_prediction = np.array(altitude_prediction) +altitude_prediction = np.where(altitude_prediction < 0, np.nan, altitude_prediction) +mean_altitude_prediction = round(np.nanmean(altitude_prediction)) +altitude_prediction = np.where(np.isnan(altitude_prediction), float(mean_altitude), altitude_prediction) +altitude_prediction = np.nan_to_num(altitude_prediction, nan=mean_altitude_prediction, posinf=mean_altitude_prediction, neginf=mean_altitude_prediction) +altitude_prediction = list(altitude_prediction) + +minimum_distance_prediction = np.nan_to_num(minimum_distance_prediction, nan=np.nan, posinf=np.nan, neginf=np.nan) # just in case + +# Weather data + +X_basis_weather = np.column_stack([ + weather_data_prediction_flatten, + np.array(year_flattened_prediction), + np.array(month_flattened_prediction), + resid_encoded_prediction, + zone_encoded_prediction, + owner_encoded_prediction, + ftype_encoded_prediction, + lag_1_month_prediction, + lag_2_month_prediction, + lag_3_month_prediction, + lag_4_month_prediction, + lag_1_5_day_prediction, + lag_2_5_day_prediction, + lag_3_5_day_prediction, + lag_4_5_day_prediction, + facility_encoded_prediction, + altitude_prediction, + minimum_distance_prediction, + #above_below_X_prediction ]) -results_of_weather_model, y_pred, mask_all_data = build_model(X_weather, residuals_percentage, log_y=log_y, X_mask_mm=mask_threshold) -print(results_of_weather_model.summary()) +X_basis_weather_filtered = X_basis_weather[X_basis_weather[:, 0] > mask_threshold] +# format output +print(X_basis_weather_filtered[:, 3]) +year_month_labels = np.array([f"{y}-{m}" for y, m in zip(X_basis_weather_filtered[:, 2], X_basis_weather[:, 3])]) +print(year_month_labels) +predictions_weather = results_of_weather_model.predict(X_basis_weather_filtered) +if log_y: + data_weather_predictions = pd.DataFrame({ + 'Year_Month': year_month_labels, + 'y_pred_weather': np.exp(predictions_weather) + }) +else: + data_weather_predictions = pd.DataFrame({ + 'Year_Month': year_month_labels, + 'y_pred_weather': predictions_weather + }) + +if use_residuals: + predictions = results_of_weather_model.predict(X_basis_weather_filtered) +else: + X_bases_ANC = np.column_stack([ + year_flattened_prediction, + month_flattened_prediction, + resid_encoded_prediction, + zone_encoded_prediction, + owner_encoded_prediction, + ftype_encoded_prediction, + facility_encoded_prediction, + altitude_prediction, + minimum_distance_prediction + ]) + + y_pred_ANC = results.predict(X_bases_ANC) + if log_y: + predictions = np.exp(predictions_weather) - np.exp(y_pred_ANC[X_basis_weather[:, 0] > mask_threshold]) + data_weather_predictions['y_pred_no_weather'] = np.exp(y_pred_ANC[X_basis_weather[:, 0] > mask_threshold]) + + else: + predictions = predictions_weather - y_pred_ANC[X_basis_weather[:, 0] > mask_threshold] + data_weather_predictions['y_pred_no_weather'] = y_pred_ANC[X_basis_weather[:, 0] > mask_threshold] -##### Plot y_predic -X_filtered = X[mask_all_data] +data_weather_predictions['difference_in_expectation'] = predictions +data_weather_predictions['weather'] = X_basis_weather[X_basis_weather[:, 0] > mask_threshold, 0] +data_weather_predictions_grouped = data_weather_predictions.groupby('Year_Month').mean().reset_index() -plt.scatter(X_filtered[:, 0], (residuals_percentage[mask_all_data]), color='red', alpha=0.5) -plt.scatter(X_filtered[:, 0],y_pred) -plt.title(' ') -plt.ylabel('Change in ANC visits') -plt.xlabel('Precip (mm)') -plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) +# Plotting results +fig, axs = plt.subplots(1, 2, figsize=(14, 6)) +#axs[0].scatter(data_weather_predictions['Year_Month'], data_weather_predictions['difference_in_expectation'], color='#9AC4F8', alpha=0.1, label ='Predictions from weather model') +axs[0].scatter(data_weather_predictions_grouped['Year_Month'], data_weather_predictions_grouped['difference_in_expectation'], color='red', alpha=0.7, label='Mean of predictions') +axs[0].set_xlabel('Year/Month') +xticks = data_weather_predictions['Year_Month'][::len(year_range) * 12 * num_facilities] +axs[0].set_xticks(xticks) +axs[0].set_xticklabels(xticks, rotation=45, ha='right') +axs[0].set_ylabel('Difference Predicted ANC visits due to rainfall') +axs[0].legend(loc='upper left') +# +# # if log_y: +# # +# # axs[1].scatter(X_basis_weather_filtered[:, 0], np.exp(data_weather_predictions['y_pred_weather']), color='#9AC4F8', +# # alpha=0.3, label='Predictions of weather model') +# # axs[1].scatter(X_basis_weather_filtered[:, 0], np.exp(data_weather_predictions['y_pred_no_weather']), color='#9AC4F8', +# # alpha=1, label='Predictions of no weather model') +# # else: +# # axs[1].scatter(X_basis_weather_filtered[:, 0], data_weather_predictions['y_pred_weather'], color='#9AC4F8', alpha=0.7, +# # label='Predictions of weather model') +# # +# # axs[1].scatter(X_basis_weather_filtered[:, 0], data_weather_predictions['y_pred_no_weather'], color='#9AC4F8', alpha=1, +# # label='Predictions of no weather model') +# # axs[1].set_xlabel('Precipitation (mm)') +# # axs[1].set_ylabel('Frequency') +# # axs[1].legend() +#plt.tight_layout() plt.show() + +fig, axs = plt.subplots(1, 2, figsize=(14, 6)) + +axs[0].scatter(data_weather_predictions['weather'],data_weather_predictions['difference_in_expectation'], color='#9AC4F8', alpha=0.1, + label='Predictions') + +axs[0].set_xlabel('Precipitation (mm)') +axs[0].set_ylabel('Difference in of ANC visits between weather and non-weather model') + +plt.tight_layout() +plt.show() + +## Save predictions + +# Format output: Add all relevant X variables +full_data_weather_predictions = pd.DataFrame({ + 'Year': year_flattened_prediction[X_basis_weather[:, 0] > mask_threshold], + 'Month': np.array(month_flattened_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'Facility_ID': facility_flattened_prediction[X_basis_weather[:, 0] > mask_threshold], + 'Altitude': np.array(altitude_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'Zone': np.array(zone_info_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'Resid': np.array(resid_info_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'Owner': np.array(owner_info_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'Facility_Type': np.array(ftype_info_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'Precipitation': X_basis_weather[X_basis_weather[:, 0] > mask_threshold, 0], + 'Lag_1_Precipitation': np.array(lag_1_month_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'Lag_2_Precipitation': np.array(lag_2_month_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'Lag_3_Precipitation': np.array(lag_3_month_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'Lag_4_Precipitation': np.array(lag_4_month_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'Predicted_Weather_Model': np.exp(predictions_weather), + 'Predicted_No_Weather_Model': np.exp(y_pred_ANC[X_basis_weather[:, 0] > mask_threshold]), + 'Difference_in_Expectation': predictions, +}) + +# Save the results +full_data_weather_predictions.to_csv(f"{data_path}weather_predictions_with_X_{ssp_scenario}.csv", index=False) + +X_basis_weather_filtered = pd.DataFrame(X_basis_weather_filtered) + +# Save to CSV +X_basis_weather_filtered.to_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/X_basis_weather_filtered_predictions_{ssp_scenario}.csv', index=False) diff --git a/src/scripts/climate_change/linear_model_historical_relationship_reporting_precipitation_missing_data.py b/src/scripts/climate_change/linear_model_historical_relationship_reporting_precipitation_missing_data.py new file mode 100644 index 0000000000..3c4fecd5e3 --- /dev/null +++ b/src/scripts/climate_change/linear_model_historical_relationship_reporting_precipitation_missing_data.py @@ -0,0 +1,360 @@ +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd +import statsmodels.api as sm +from statsmodels.genmod.generalized_linear_model import GLM +from statsmodels.genmod.families import Binomial +import joblib + +min_year_for_analyis = 2015 +absolute_min_year = 2011 +mask_threshold = 0 +use_percentile_mask_threshold = False +log_y = False # will use a binary outcome + +covid_months = range((2020 - min_year_for_analyis)* 12 + 4, (2020 - min_year_for_analyis)* 12 + 4 + 20) # Bingling's paper: disruption between April 2020 and Dec 2021, a period of 20 months +cyclone_freddy_months_phalombe = range((2023 - min_year_for_analyis)* 12 + 4, (2020 - min_year_for_analyis)* 12 + 4 + 14) # From news report and DHIS2, see disruption from April 2023 - June 2024, 14 months +cyclone_freddy_months_thumbwe = range((2023 - min_year_for_analyis)* 12 + 3, (2020 - min_year_for_analyis)* 12 + 3 + 12) # From news report and DHIS2, see disruption from March 2023 - March 2024, 12 months + +############# Read in data ########### +# # data is from 2011 - 2024 - for facility +monthly_reporting_by_facility = pd.read_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_ANC_by_smaller_facility_lm.csv", index_col=0) +### Combine weather variables ## +weather_data_monthly = pd.read_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_ANC_lm.csv", + index_col=0) + +weather_data_five_day_cumulative = pd.read_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/historical_daily_total_by_facilities_with_ANC_five_day_cumulative.csv", + index_col=0) + + +def build_model(X, y, X_mask_mm=0): + + mask = (~np.isnan(X).any(axis=1) & ~np.isnan(y) & (X[:, 0] >= X_mask_mm)) + model = sm.GLM(y[mask], X[mask], family=Binomial()) + model_fit = model.fit() + return model_fit, model_fit.predict(X[mask]), mask + +def create_binary_feature(threshold, weather_data_df, recent_months): + binary_feature_list = [] + for facility in weather_data_df.columns: + facility_data = weather_data_df[facility] + + for i in range(len(facility_data)): + facility_threshold = threshold[i] if hasattr(threshold, "__len__") else threshold + + if i >= recent_months: + last_x_values = facility_data[i - recent_months:i] + binary_feature_list.append(1 if (last_x_values > facility_threshold).any() else 0) + else: + binary_feature_list.append(np.nan) + + return binary_feature_list + + + +############################################################################################## +########################## STEP 0: Tidy data ########################## +############################################################################################## +## Remove any columns that sum to 0 in the monthly reporting data (e.g. for inpatient data, may mean they don't have the facility) +zero_sum_columns = monthly_reporting_by_facility.columns[(monthly_reporting_by_facility.sum(axis=0) == 0)] +monthly_reporting_by_facility = monthly_reporting_by_facility.drop(columns=zero_sum_columns) + +# Prep weather data +weather_data_monthly = weather_data_monthly.drop(columns=zero_sum_columns, errors='ignore') +weather_data_five_day_cumulative = weather_data_five_day_cumulative.drop(columns=zero_sum_columns, errors='ignore') + +weather_data_monthly = weather_data_monthly.drop(weather_data_monthly.index[-2:]) +weather_data_five_day_cumulative = weather_data_five_day_cumulative.drop(weather_data_five_day_cumulative.index[-1:]) + + # code if years need to be dropped +weather_data_monthly = weather_data_monthly.iloc[(min_year_for_analyis - absolute_min_year) * 12:] +weather_data_five_day_cumulative = weather_data_five_day_cumulative.iloc[(min_year_for_analyis - absolute_min_year) * 12:] +weather_data_monthly_flattened = weather_data_monthly.values.flatten() +weather_data_five_day_cumulative_flattened = weather_data_five_day_cumulative.values.flatten() +weather_data = np.vstack((weather_data_monthly_flattened,weather_data_five_day_cumulative_flattened)).T + + +# Drop September 2024 in ANC/reporting data +monthly_reporting_by_facility = monthly_reporting_by_facility.drop(monthly_reporting_by_facility.index[-1]) +# code if years need to be dropped +monthly_reporting_by_facility = monthly_reporting_by_facility.iloc[(min_year_for_analyis-absolute_min_year)*12:] +# Linear regression +month_range = range(12) +num_facilities = len(monthly_reporting_by_facility.columns) +year_range = range(min_year_for_analyis, 2025, 1) # year as a fixed effect +year_repeated = [y for y in year_range for _ in range(12)] +year = year_repeated[:-4] +year_flattened = year*len(monthly_reporting_by_facility.columns) # to get flattened data +month = range(12) +month_repeated = [] +for _ in year_range: + month_repeated.extend(range(1, 13)) +month = month_repeated[:-4] +month_flattened = month*len(monthly_reporting_by_facility.columns) + +facility_flattened = list(range(len(monthly_reporting_by_facility.columns))) * len(month) + +# Flatten data +y = monthly_reporting_by_facility.values.flatten() +#y[np.isnan(y)] = 0 # if all of these are expected to report, then can I assume all 0? +y[~np.isnan(y)] = 0 +y[np.isnan(y)] = 1 # create binary outcome +print(y) + +if use_percentile_mask_threshold: + mask_threshold = np.nanpercentile(weather_data, 90) + print(mask_threshold) + +# One-hot encode facilities +facility_encoded = pd.get_dummies(facility_flattened, drop_first=True) + + # Above/below average for each month +grouped_data = pd.DataFrame({ + 'facility': facility_flattened, + 'month': month_flattened, + 'weather_data': weather_data_monthly_flattened + }).groupby(['facility', 'month'])['weather_data'].mean().reset_index() + +above_below_X = create_binary_feature(np.nanpercentile(weather_data_monthly_flattened, 90), weather_data_monthly, 12) + +# Prepare additional facility info +expanded_facility_info = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_with_ANC.csv", index_col=0) +expanded_facility_info = expanded_facility_info.drop(columns=zero_sum_columns) + +expanded_facility_info = expanded_facility_info.T.reindex(columns=expanded_facility_info.index) + +def repeat_info(info, num_facilities, year_range): + repeated_info = [i for i in info for _ in range(12) for _ in year_range] + return repeated_info[:-4 * num_facilities] # Exclude first final months (Sept - Dec 2024) + +zone_info_each_month = repeat_info(expanded_facility_info["Zonename"], num_facilities, year_range) +zone_encoded = pd.get_dummies(zone_info_each_month, drop_first=True) +resid_info_each_month = repeat_info(expanded_facility_info['Resid'], num_facilities, year_range) +resid_encoded = pd.get_dummies(resid_info_each_month, drop_first=True) +owner_info_each_month = repeat_info(expanded_facility_info['A105'], num_facilities, year_range) +owner_encoded = pd.get_dummies(owner_info_each_month, drop_first=True) +ftype_info_each_month = repeat_info(expanded_facility_info['Ftype'], num_facilities, year_range) +ftype_encoded = pd.get_dummies(ftype_info_each_month, drop_first=True) +altitude = [float(x) for x in repeat_info(expanded_facility_info['A109__Altitude'], num_facilities, year_range)] +minimum_distance = [float(x) for x in repeat_info(expanded_facility_info['minimum_distance'], num_facilities, year_range)] + +# Lagged weather +lag_1_month = weather_data_monthly.shift(1).values.flatten() +lag_2_month = weather_data_monthly.shift(2).values.flatten() +lag_3_month = weather_data_monthly.shift(3).values.flatten() +lag_4_month = weather_data_monthly.shift(4).values.flatten() + + +altitude = np.array(altitude) +altitude = np.where(altitude < 0, np.nan, altitude) +altitude = list(altitude) + + +# ############################################################################################## +# ########################## STEP 1: GENERATE PREDICTIONS OF ANC DATA ########################## +# ############################################################################################## +# +# X = np.column_stack([ +# year_flattened, +# month_flattened, +# resid_encoded, +# zone_encoded, +# owner_encoded, +# ftype_encoded, +# facility_encoded, +# altitude, +# minimum_distance +# ]) +# +# results, y_pred, mask_ANC_data = build_model(X , y, X_mask_mm=mask_threshold) +# +# +# +# print("ANC prediction", results.summary()) +# +# # plot +# year_month_labels = np.array([f"{y}-{m}" for y, m in zip(year_flattened, month_flattened)]) +# y_filtered = y[mask_ANC_data] +# year_month_labels_filtered = year_month_labels[mask_ANC_data] +# data_ANC_predictions = pd.DataFrame({ +# 'Year_Month': year_month_labels_filtered, +# 'y_filtered': y_filtered, +# 'y_pred': y_pred, +# 'residuals': y_filtered - y_pred +# }) +# +# data_ANC_predictions = data_ANC_predictions.sort_values(by='Year_Month').reset_index(drop=True) +# x_labels = data_ANC_predictions['Year_Month'][::num_facilities*12] +# +# # Set the xticks at corresponding positions +# fig, axs = plt.subplots(1, 2, figsize=(14, 6)) +# step = num_facilities * 12 +# data_ANC_predictions_grouped = data_ANC_predictions.groupby('Year_Month').mean().reset_index() +# +# xticks = data_ANC_predictions['Year_Month'][::len(year_range)*num_facilities] +# # Panel A: Actual data and predictions +# axs[0].scatter(data_ANC_predictions['Year_Month'], data_ANC_predictions['y_filtered'], color='#1C6E8C', alpha=0.5, label='Actual data') +# axs[0].scatter(data_ANC_predictions['Year_Month'], data_ANC_predictions['y_pred'], color='#9AC4F8', alpha=0.7, label='Predictions') +# axs[0].scatter(data_ANC_predictions_grouped['Year_Month'], data_ANC_predictions_grouped['y_filtered'], color='red', alpha=0.5, label='Mean Actual data') +# axs[0].scatter(data_ANC_predictions_grouped['Year_Month'], data_ANC_predictions_grouped['y_pred'], color='yellow', alpha=0.7, label='Mean Predictions') +# +# axs[0].set_xticks(xticks) +# axs[0].set_xticklabels(xticks, rotation=45, ha='right') +# axs[0].set_xlabel('Year') +# axs[0].set_ylabel('Number of ANC visits') +# axs[0].set_title('A: Monthly ANC Visits vs. Precipitation') +# axs[0].legend(loc='upper left') +# +# plt.tight_layout() +# plt.show() +# +# ########### Add in weather data ############ +# +# +# X_weather = np.column_stack([ +# weather_data, +# np.array(year_flattened), +# np.array(month_flattened), +# resid_encoded, +# zone_encoded, +# owner_encoded, +# ftype_encoded, +# lag_1_month, +# lag_2_month, +# lag_3_month, +# lag_4_month, +# facility_encoded, +# np.array(altitude), +# np.array(minimum_distance), +# above_below_X +# ]) +# +# results_of_weather_model, y_pred_weather, mask_all_data = build_model(X_weather, y, +# X_mask_mm=mask_threshold) +# print("All predictors", results_of_weather_model.summary()) +# # +# X_filtered = X_weather[mask_all_data] +# +# # Effect size +# +# y_mean = np.mean(y[mask_all_data]) +# SS_total = np.sum((y[mask_all_data] - y_mean) ** 2) +# +# predictor_variances = np.var(X_filtered, axis=0, ddof=1) +# coefficients = results_of_weather_model.params +# SS_effect = coefficients**2 * predictor_variances +# eta_squared = SS_effect / SS_total +# effect_size_summary = pd.DataFrame({ +# 'Coefficient': coefficients, +# 'SS_effect': SS_effect, +# 'Eta-squared': eta_squared +# }).sort_values(by='Eta-squared', ascending=False) +# +# print(effect_size_summary) +# +# +# fig, axs = plt.subplots(1, 2, figsize=(10, 6)) +# +# indices_ANC_data = np.where(mask_ANC_data)[0] +# indices_all_data = np.where(mask_all_data)[0] +# common_indices = np.intersect1d(indices_ANC_data, indices_all_data) +# matched_y_pred = y_pred[np.isin(indices_ANC_data, common_indices)] +# matched_y_pred_weather = y_pred_weather[np.isin(indices_all_data, common_indices)] +# +# axs[0].scatter(X_filtered[:, 0], y[mask_all_data], color='red', alpha=0.5, label = 'Non weather model') +# axs[0].hlines(y = 0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color = 'black', linestyle = '--') +# axs[0].scatter(X_filtered[:, 0], matched_y_pred_weather, label='Weather model') +# axs[0].hlines(y=0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color='black', linestyle='--') +# axs[0].set_ylabel('ANC visits') +# +# plt.show() +# +# ## See impact on reporting +# +# predicted_missingness = np.zeros(len(matched_y_pred)) +# predicted_missingness[matched_y_pred_weather > 0.5 ] = 1 +# +# +# fig, axs = plt.subplots(1, 2, figsize=(10, 6)) +# +# axs[0].scatter(X_filtered[:, 0], predicted_missingness, color='red', alpha=0.5) +# axs[0].hlines(y=0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color='black', linestyle='--') +# axs[0].set_ylabel('Missing data presence/absence') +# axs[0].set_ylabel('Monthly total precipitation (mm)') +# +# axs[1].scatter(X_filtered[:, 1], predicted_missingness, color='red', alpha=0.5) +# axs[1].hlines(y=0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color='black', linestyle='--') +# axs[1].set_ylabel('Missing data presence/absence') +# axs[1].set_ylabel('Five day cumulative total precipitation (mm)') +# +# +# plt.show() +# + + +### Difference in weather data #### +########### Add in weather data ############ + +print(weather_data[:,0]) +X_weather_1 = np.column_stack([ + weather_data[:,0], + np.array(year_flattened), + np.array(month_flattened), + resid_encoded, + zone_encoded, + owner_encoded, + ftype_encoded, + lag_1_month, + lag_2_month, + lag_3_month, + lag_4_month, + facility_encoded, + np.array(altitude), + np.array(minimum_distance), + above_below_X + ]) + +results_of_weather_model_1, y_pred_weather_1, mask_all_data_1 = build_model(X_weather_1, y, + X_mask_mm=mask_threshold) + + + +X_weather_2 = np.column_stack([ + weather_data[:,1], + np.array(year_flattened), + np.array(month_flattened), + resid_encoded, + zone_encoded, + owner_encoded, + ftype_encoded, + lag_1_month, + lag_2_month, + lag_3_month, + lag_4_month, + facility_encoded, + np.array(altitude), + np.array(minimum_distance), + above_below_X + ]) + +results_of_weather_model_2, y_pred_weather_2, mask_all_data_2 = build_model(X_weather_2, y, + X_mask_mm=mask_threshold) +print("All predictors", results_of_weather_model_1.summary()) +print("All predictors", results_of_weather_model_2.summary()) + +# +X_filtered_1 = X_weather_1[mask_all_data_1] +X_filtered_2 = X_weather_2[mask_all_data_2] + +## See impact on reporting + +predicted_missingness_1 = np.zeros(len(y_pred_weather_1)) +predicted_missingness_1[y_pred_weather_1 > 0.5 ] = 1 + +predicted_missingness_2 = np.zeros(len(y_pred_weather_2)) +predicted_missingness_2[y_pred_weather_2 > 0.5 ] = 1 + +print(sum(predicted_missingness_1) - sum(predicted_missingness_2)) diff --git a/src/scripts/climate_change/linear_model_predicting_CMIP6.py b/src/scripts/climate_change/linear_model_predicting_CMIP6.py index 8ab40ef694..ad27671220 100644 --- a/src/scripts/climate_change/linear_model_predicting_CMIP6.py +++ b/src/scripts/climate_change/linear_model_predicting_CMIP6.py @@ -8,24 +8,26 @@ min_year_for_analysis = 2015 absolute_min_year = 2015 max_year_for_analysis = 2099 -five_day, cumulative, model_fit_ANC_data, model_fit_weather_data = True, True, True, True +five_day, cumulative, model_fit_ANC_data, model_fit_weather_data = False, False, True, True data_path = "/Users/rem76/Desktop/Climate_change_health/Data/" # Load and preprocess weather data -weather_data_prediction = pd.read_csv(f"{data_path}Precipitation_data/ssp2_4_5/prediction_weather_by_smaller_facilities_with_ANC_lm.csv") -weather_data_prediction = weather_data_prediction.iloc[(min_year_for_analysis - absolute_min_year) * 12:] - +weather_data_prediction = pd.read_csv(f"{data_path}Precipitation_data/ssp2_4_5/prediction_weather_by_smaller_facilities_with_ANC_lm.csv", index_col=0, dtype={'column_name': 'float64'}) +weather_data_prediction = pd.read_csv(f"{data_path}Precipitation_data/ssp2_4_5/prediction_weather_monthly_by_smaller_facilities_with_ANC_lm.csv", index_col=0, dtype={'column_name': 'float64'}) +print(weather_data_prediction) +#weather_data_prediction = weather_data_prediction.iloc[(min_year_for_analysis - absolute_min_year) * 12:] # Flatten data and prepare for regression num_facilities = len(weather_data_prediction.columns) -year_range = range(min_year_for_analysis, max_year_for_analysis) -month_repeated = [m for _ in year_range for m in range(1, 13)][:-4] -year_flattened = np.repeat(year_range, 12 * num_facilities)[:-4 * num_facilities] +year_range = range(min_year_for_analysis, max_year_for_analysis + 1) +month_repeated = [m for _ in year_range for m in range(1, 13)] +year_flattened = np.repeat(year_range, 12 * num_facilities) month_flattened = month_repeated * num_facilities facility_flattened = np.tile(range(num_facilities), len(year_flattened) // num_facilities) # Encode facilities and create above/below average weather data weather_data = weather_data_prediction.values.flatten() facility_encoded = pd.get_dummies(facility_flattened, drop_first=True) + grouped_data = pd.DataFrame({ 'facility': facility_flattened, 'month': month_flattened, @@ -36,47 +38,69 @@ info_file = "expanded_facility_info_by_smaller_facility_lm_with_ANC.csv" if ANC else "expanded_facility_info_by_smaller_facility_lm.csv" expanded_facility_info = pd.read_csv(f"{data_path}{info_file}", index_col=0).T -def repeat_info(info, num_facilities, year_range): - return [i for i in info for _ in range(12 * len(year_range))][:-4 * num_facilities] +def repeat_info(info, year_range): + repeated_info = [i for i in info for _ in range(12) for _ in year_range] + return repeated_info -zone_info = repeat_info(expanded_facility_info["Zonename"], num_facilities, year_range) +zone_info = repeat_info(expanded_facility_info["Zonename"], year_range) zone_encoded = pd.get_dummies(zone_info, drop_first=True) -resid_info = repeat_info(expanded_facility_info['Resid'], num_facilities, year_range) +resid_info = repeat_info(expanded_facility_info['Resid'], year_range) resid_encoded = pd.get_dummies(resid_info, drop_first=True) -owner_info = repeat_info(expanded_facility_info['A105'], num_facilities, year_range) +owner_info = repeat_info(expanded_facility_info['A105'], year_range) owner_encoded = pd.get_dummies(owner_info, drop_first=True) -ftype_info = repeat_info(expanded_facility_info['Ftype'], num_facilities, year_range) +ftype_info = repeat_info(expanded_facility_info['Ftype'], year_range) ftype_encoded = pd.get_dummies(ftype_info, drop_first=True) -altitude = np.where(np.array(repeat_info(expanded_facility_info['A109__Altitude'], num_facilities, year_range)) < 0, np.nan, altitude).tolist() +#altitude = np.where(np.array(repeat_info(expanded_facility_info['A109__Altitude'], num_facilities, year_range)) < 0, np.nan, altitude).tolist() # Lagged weather data -lags = [weather_data_prediction.shift(i).values.flatten() for i in range(1, 5)] +lag_1_month = weather_data_prediction.shift(1).values.flatten() +lag_2_month = weather_data_prediction.shift(2).values.flatten() +lag_3_month = weather_data_prediction.shift(3).values.flatten() +lag_4_month = weather_data_prediction.shift(4).values.flatten() +# Load # Load and prepare model -model_data = joblib.load('best_model_weather_5_day_cumulative_precip.pkl') -results_of_weather_model = model_data['model'] -mask_all_data = model_data['mask'] +model_data_ANC =joblib.load('/Users/rem76/PycharmProjects/TLOmodel/best_model_ANC_prediction_5_day_cumulative_linear_precip.pkl') # don't need mask +best_params_ANC_pred = model_data_ANC['best_predictors'] # Assemble predictors -X = np.column_stack([ - weather_data[mask_all_data], - year_flattened[mask_all_data], - month_flattened[mask_all_data], - resid_encoded[mask_all_data], - zone_encoded[mask_all_data], - owner_encoded[mask_all_data], - ftype_encoded[mask_all_data], - *[lag[mask_all_data] for lag in lags], - facility_encoded[mask_all_data], - np.array(altitude)[mask_all_data] + +X_bases = X = np.column_stack([ + year_flattened, + month_flattened, + resid_encoded, + zone_encoded, + owner_encoded, + ftype_encoded, + facility_encoded, ]) +X_from_best_models = X_bases[:,best_params_ANC_pred] +model_data = joblib.load('/Users/rem76/PycharmProjects/TLOmodel/best_model_weather_5_day_cumulative_linear_precip.pkl') # don't need mask +results_of_weather_model = model_data['model'] +best_params_weather_pred = model_data['best_predictors'] +print(best_params_weather_pred) +X_basis_weather = np.column_stack([ + weather_data, + np.array(year_flattened), + np.array(month_flattened), + resid_encoded, + zone_encoded, + owner_encoded, + ftype_encoded, + lag_1_month, + lag_2_month, + lag_3_month, + lag_4_month, + facility_encoded]) + +X = X_basis_weather[:,best_params_weather_pred] # Predictions and formatting output predictions = results_of_weather_model.predict(X) year_month_labels = np.array([f"{y}-{m}" for y, m in zip(year_flattened, month_flattened)]) data_ANC_predictions = pd.DataFrame({ - 'Year_Month': year_month_labels[mask_all_data], - 'y_pred': np.exp(predictions) + 'Year_Month': year_month_labels, + 'y_pred': predictions }) # Plotting results @@ -84,8 +108,11 @@ def repeat_info(info, num_facilities, year_range): axs[0].scatter(data_ANC_predictions['Year_Month'], data_ANC_predictions['y_pred'], color='#9AC4F8', alpha=0.7, label='Predictions') axs[0].set_xticklabels(data_ANC_predictions['Year_Month'], rotation=45, ha='right') axs[0].set_xlabel('Year') -axs[0].set_ylabel('Number of ANC visits') +axs[0].set_ylabel('Change in ANC visits due to 5-day monthly maximum precipitation') axs[0].set_title('Change in Monthly ANC Visits vs. Precipitation') axs[0].legend(loc='upper left') + +axs[1].scatter(X[:,0], data_ANC_predictions['y_pred'], color='#9AC4F8', alpha=0.7, label='Predictions') plt.tight_layout() plt.show() + diff --git a/src/scripts/climate_change/model_development.ipynb b/src/scripts/climate_change/model_development.ipynb new file mode 100644 index 0000000000..2b671b769a --- /dev/null +++ b/src/scripts/climate_change/model_development.ipynb @@ -0,0 +1,2977 @@ +{ + "cells": [ + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-03T17:53:55.462859Z", + "start_time": "2024-12-03T17:53:55.035803Z" + } + }, + "cell_type": "code", + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import statsmodels.api as sm\n", + "from statsmodels.genmod.generalized_linear_model import GLM\n", + "from sklearn.linear_model import LogisticRegression, PoissonRegressor\n", + "from sklearn.pipeline import Pipeline\n", + "from sklearn.feature_selection import RFECV\n", + "from sklearn.model_selection import KFold\n", + "import joblib" + ], + "id": "87f8cb7eefec131e", + "outputs": [], + "execution_count": 1 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-03T17:53:55.466857Z", + "start_time": "2024-12-03T17:53:55.463495Z" + } + }, + "cell_type": "code", + "source": [ + "ANC = True\n", + "daily_max = False\n", + "daily_total = True\n", + "min_year_for_analyis = 2011\n", + "absolute_min_year = 2011\n", + "if daily_max or daily_total:\n", + " mask_threshold = 0\n", + "else:\n", + " mask_threshold = 500\n", + "mask_threshold = 0\n", + "\n", + "five_day = True\n", + "cumulative = True\n", + "model_fit_ANC_data = True\n", + "model_fit_weather_data = True\n", + "poisson=False\n", + "if poisson:\n", + " log_y = False\n", + "else:\n", + " log_y = True\n", + "model_filename = (\n", + " f\"best_model_{'ANC' if ANC else 'Reporting'}_prediction_\"\n", + " f\"{'5_day' if five_day else 'monthly'}_\"\n", + " f\"{'cumulative' if cumulative else ('max' if daily_max else 'total')}_\"\n", + " f\"{'poisson' if poisson else 'linear'}_precip.pkl\"\n", + ")\n", + "use_residuals = False\n", + "covid_months = range((2020 - min_year_for_analyis)* 12, (2020 - min_year_for_analyis)* 12 + 20) # Bingling's paper: disruption between April 2020 and Dec 2021\n", + "\n", + "print(model_filename)\n", + "model_filename_weather_model = (\n", + " f\"best_model_weather_\"\n", + " f\"{'5_day' if five_day else 'monthly'}_\"\n", + " f\"{'cumulative' if cumulative else ('max' if daily_max else 'total')}_\"\n", + " f\"{'poisson' if poisson else 'linear'}_precip.pkl\"\n", + ")\n", + "print(model_filename_weather_model)\n" + ], + "id": "7541642c8ec45ffe", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "best_model_ANC_prediction_5_day_cumulative_linear_precip.pkl\n", + "best_model_weather_5_day_cumulative_linear_precip.pkl\n" + ] + } + ], + "execution_count": 2 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-03T17:53:55.485886Z", + "start_time": "2024-12-03T17:53:55.468172Z" + } + }, + "cell_type": "code", + "source": [ + "if ANC:\n", + " monthly_reporting_by_facility = pd.read_csv(\"/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_ANC_by_smaller_facility_lm.csv\", index_col=0)\n", + " if daily_max:\n", + " if five_day:\n", + " if cumulative:\n", + " weather_data_historical = pd.read_csv(\n", + " \"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/historical_daily_total_by_facilities_with_ANC_five_day_cumulative.csv\",\n", + " index_col=0)\n", + " else:\n", + " weather_data_historical = pd.read_csv(\n", + " \"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/historical_daily_total_by_facilities_with_ANC_five_day_average.csv\",\n", + " index_col=0)\n", + " else:\n", + " weather_data_historical = pd.read_csv(\n", + " \"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/historical_daily_total_by_facility_five_day_cumulative.csv\",\n", + " index_col=0)\n", + " elif daily_total:\n", + " if five_day:\n", + " if cumulative:\n", + " weather_data_historical = pd.read_csv(\n", + " \"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/historical_daily_total_by_facilities_with_ANC_five_day_cumulative.csv\",\n", + " index_col=0)\n", + " else:\n", + " weather_data_historical = pd.read_csv(\n", + " \"/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_ANC_lm.csv\",\n", + " index_col=0)\n", + " print(\"month\")\n", + "\n", + "else:\n", + " monthly_reporting_by_facility = pd.read_csv(\"/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm.csv\", index_col=0)\n", + " if daily_max:\n", + " weather_data_historical = pd.read_csv(\n", + " \"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_maximum/historical_daily_max_by_facility.csv\",\n", + " index_col=0)\n", + " elif daily_total:\n", + " weather_data_historical = pd.read_csv(\n", + " \"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/historical_daily_total_by_facility.csv\",\n", + " index_col=0)\n", + " else:\n", + " weather_data_historical = pd.read_csv(\n", + " \"/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facility_lm.csv\",\n", + " index_col=0)\n", + " print(\"Month\")\n" + ], + "id": "b9f227f1abc590d7", + "outputs": [], + "execution_count": 3 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-03T17:53:55.491184Z", + "start_time": "2024-12-03T17:53:55.486411Z" + } + }, + "cell_type": "code", + "source": [ + "\n", + "def build_model(X, y, poisson=False, log_y=False, X_mask_mm=0):\n", + " epsilon = 1\n", + "\n", + " if log_y:\n", + " y = np.log(np.clip(y, epsilon, None)) # Log-transform y with clipping for positivity\n", + " mask = (~np.isnan(X).any(axis=1) & ~np.isnan(y) & (X[:, 0] >= X_mask_mm) & (y <= 1e4))\n", + " model = GLM(y[mask], X[mask], family=NegativeBinomial()) if poisson else sm.OLS(y[mask], X[mask])\n", + " model_fit = model.fit()\n", + " return model_fit, model_fit.predict(X[mask]), mask\n", + "\n", + "def create_binary_feature(threshold, weather_data_df, recent_months):\n", + " binary_feature_list = []\n", + " for facility in weather_data_df.columns:\n", + " facility_data = weather_data_df[facility]\n", + "\n", + " for i in range(len(facility_data)):\n", + " facility_threshold = threshold[i] if hasattr(threshold, \"__len__\") else threshold\n", + "\n", + " if i >= recent_months:\n", + " last_x_values = facility_data[i - recent_months:i]\n", + " binary_feature_list.append(1 if (last_x_values > facility_threshold).any() else 0)\n", + " else:\n", + " binary_feature_list.append(np.nan)\n", + "\n", + " return binary_feature_list\n", + "\n", + "def stepwise_selection(X, y, log_y, poisson, p_value_threshold=0.05):\n", + " included = []\n", + " current_aic = np.inf\n", + "\n", + " while True:\n", + " changed = False\n", + "\n", + " # Step 1: Try adding each excluded predictor and select the best one by AIC if significant\n", + " excluded = list(set(range(X.shape[1])) - set(included))\n", + " new_aic = pd.Series(index=excluded, dtype=float)\n", + " for new_column in excluded:\n", + " subset_X = X[:, included + [new_column]]\n", + " results, _, _ = build_model(subset_X, y, poisson, log_y=log_y, X_mask_mm=mask_threshold)\n", + " if results.pvalues[-1] < p_value_threshold:\n", + " new_aic[new_column] = results.aic\n", + "\n", + " # Add the predictor with the best AIC if it's better than the current model's AIC\n", + " if not new_aic.empty and new_aic.min() < current_aic:\n", + " best_feature = new_aic.idxmin()\n", + " included.append(best_feature)\n", + " current_aic = new_aic.min()\n", + " changed = True\n", + " print(current_aic)\n", + "\n", + "\n", + " # Exit if no changes were made in this iteration\n", + " if not changed:\n", + " break\n", + "\n", + " return included\n", + "#\n" + ], + "id": "25bf97cac2a5083a", + "outputs": [], + "execution_count": 4 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-03T17:53:59.167776Z", + "start_time": "2024-12-03T17:53:59.108223Z" + } + }, + "cell_type": "code", + "source": [ + "##############################################################################################\n", + "########################## STEP 0: Tidy data ##########################\n", + "##############################################################################################\n", + "\n", + "if five_day:# Drop September 2024 \n", + " weather_data_historical = weather_data_historical.drop(weather_data_historical.index[-1:])\n", + "else: # drop october for monthly data\n", + " weather_data_historical = weather_data_historical.drop(weather_data_historical.index[-3:])\n", + "\n", + "# Mask COVID-19 months\n", + "weather_data_historical.loc[covid_months, :] = np.nan\n", + "\n", + "# Drop September 2024 for reporting\n", + "monthly_reporting_by_facility = monthly_reporting_by_facility.drop(monthly_reporting_by_facility.index[-1])\n", + "\n", + "# code if years need to be dropped\n", + "weather_data_historical = weather_data_historical.iloc[(min_year_for_analyis-absolute_min_year)*12 :]\n", + "monthly_reporting_by_facility = monthly_reporting_by_facility.iloc[(min_year_for_analyis-absolute_min_year)*12:]\n", + "# Linear regression\n", + "month_range = range(12)\n", + "num_facilities = len(weather_data_historical.columns)\n", + "year_range = range(min_year_for_analyis, 2025, 1) # year as a fixed effect\n", + "year_repeated = [y for y in year_range for _ in range(12)]\n", + "year = year_repeated[:-4]\n", + "year_flattened = year*len(weather_data_historical.columns) # to get flattened data\n", + "month = range(12)\n", + "month_repeated = []\n", + "for _ in year_range:\n", + " month_repeated.extend(range(1, 13))\n", + "month = month_repeated[:-4]\n", + "month_flattened = month*len(weather_data_historical.columns)\n", + "month_encoded = pd.get_dummies(month_flattened, prefix='month', drop_first=True) # try one-hot-encode\n", + "\n", + "facility_flattened = list(range(len(weather_data_historical.columns))) * len(month)\n", + "\n", + "# Flatten data\n", + "weather_data = weather_data_historical.values.flatten()\n", + "y = monthly_reporting_by_facility.values.flatten()\n", + "if np.nanmin(y) < 1:\n", + " y += 1 # Shift to ensure positivity as taking log\n", + "y[y > 1e3] = np.nan\n", + "\n", + "# One-hot encode facilities\n", + "facility_encoded = pd.get_dummies(facility_flattened, drop_first=True)\n", + "\n", + "\n", + "\n", + "# Prepare additional facility info\n", + "if ANC:\n", + " expanded_facility_info = pd.read_csv(\"/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_with_ANC.csv\", index_col=0)\n", + "else:\n", + " expanded_facility_info = pd.read_csv(\"/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm.csv\", index_col=0)\n", + "expanded_facility_info = expanded_facility_info.T.reindex(columns=expanded_facility_info.index)\n", + "\n", + "def repeat_info(info, num_facilities, year_range):\n", + " repeated_info = [i for i in info for _ in range(12) for _ in year_range]\n", + " return repeated_info[:-4 * num_facilities] # Exclude first final months (Sept - Dec 2024)\n", + "\n", + "zone_info_each_month = repeat_info(expanded_facility_info[\"Zonename\"], num_facilities, year_range)\n", + "zone_encoded = pd.get_dummies(zone_info_each_month, drop_first=True)\n", + "resid_info_each_month = repeat_info(expanded_facility_info['Resid'], num_facilities, year_range)\n", + "resid_encoded = pd.get_dummies(resid_info_each_month, drop_first=True)\n", + "owner_info_each_month = repeat_info(expanded_facility_info['A105'], num_facilities, year_range)\n", + "owner_encoded = pd.get_dummies(owner_info_each_month, drop_first=True)\n", + "ftype_info_each_month = repeat_info(expanded_facility_info['Ftype'], num_facilities, year_range)\n", + "ftype_encoded = pd.get_dummies(ftype_info_each_month, drop_first=True)\n", + "altitude = [float(x) for x in repeat_info(expanded_facility_info['A109__Altitude'], num_facilities, year_range)]\n", + "minimum_distance = [float(x) for x in repeat_info(expanded_facility_info['minimum_distance'], num_facilities, year_range)]\n", + "\n", + "# Lagged weather\n", + "lag_1_month = weather_data_historical.shift(1).values.flatten()\n", + "lag_2_month = weather_data_historical.shift(2).values.flatten()\n", + "lag_3_month = weather_data_historical.shift(3).values.flatten()\n", + "lag_4_month = weather_data_historical.shift(4).values.flatten()\n", + "\n", + "altitude = np.array(altitude)\n", + "altitude = np.where(altitude < 0, np.nan, altitude)\n", + "altitude = list(altitude)\n", + "\n" + ], + "id": "ed7695e832df1d7e", + "outputs": [], + "execution_count": 5 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-03T17:54:11.946254Z", + "start_time": "2024-12-03T17:53:59.916401Z" + } + }, + "cell_type": "code", + "source": [ + "\n", + "##############################################################################################\n", + "########################## STEP 1: GENERATE PREDICTIONS OF ANC DATA ##########################\n", + "##############################################################################################\n", + "\n", + "X = np.column_stack([\n", + " year_flattened,\n", + " #month_flattened,\n", + " month_encoded,\n", + " resid_encoded,\n", + " zone_encoded,\n", + " owner_encoded,\n", + " ftype_encoded,\n", + " facility_encoded,\n", + " altitude, \n", + " minimum_distance\n", + "])\n", + "\n", + "results_ANC, y_pred, mask_ANC_data = build_model(X , y, poisson = poisson, log_y=log_y, X_mask_mm=mask_threshold)\n", + "\n", + "if log_y:\n", + " residuals = (y[mask_ANC_data] - np.exp(y_pred))\n", + "else:\n", + " residuals = (y[mask_ANC_data] - y_pred)\n", + "\n", + "print(\"ANC prediction\", results_ANC.summary())\n", + "\n", + "# plot\n", + "year_month_labels = np.array([f\"{y}-{m}\" for y, m in zip(year_flattened, month_flattened)])\n", + "y_filtered = y[mask_ANC_data]\n", + "year_month_labels_filtered = year_month_labels[mask_ANC_data]\n", + "if log_y:\n", + " data_ANC_predictions = pd.DataFrame({\n", + " 'Year_Month': year_month_labels_filtered,\n", + " 'y_filtered': y_filtered,\n", + " 'y_pred': np.exp(y_pred),\n", + " })\n", + "else:\n", + " data_ANC_predictions = pd.DataFrame({\n", + " 'Year_Month': year_month_labels_filtered,\n", + " 'y_filtered': y_filtered,\n", + " 'y_pred': y_pred,\n", + " })\n", + "\n", + "data_ANC_predictions = data_ANC_predictions.sort_values(by='Year_Month').reset_index(drop=True)\n", + "fig, axs = plt.subplots(1, 2, figsize=(14, 6))\n", + "\n", + "# Panel A: Actual data and predictions\n", + "axs[0].scatter(data_ANC_predictions['Year_Month'], data_ANC_predictions['y_filtered'], color='#1C6E8C', alpha=0.5, label='Actual data')\n", + "axs[0].scatter(data_ANC_predictions['Year_Month'], data_ANC_predictions['y_pred'], color='#9AC4F8', alpha=0.7, label='Predictions')\n", + "axs[0].set_xticklabels(data_ANC_predictions['Year_Month'], rotation=45, ha='right')\n", + "axs[0].set_xlabel('Year')\n", + "axs[0].set_ylabel('Number of ANC visits')\n", + "axs[0].set_title('A: Monthly ANC Visits vs. Precipitation')\n", + "axs[0].legend(loc='upper left')\n", + "\n", + "# Panel B: Residuals\n", + "axs[1].scatter(data_ANC_predictions['Year_Month'], residuals, color='#9AC4F8', alpha=0.7, label='Residuals')\n", + "axs[1].set_xticklabels(data_ANC_predictions['Year_Month'], rotation=45, ha='right')\n", + "axs[1].set_xlabel('Year')\n", + "axs[1].set_ylabel('Residuals')\n", + "axs[1].set_title('B: Residuals')\n", + "axs[1].legend(loc='upper left')\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "fig, axs = plt.subplots(1, 2, figsize=(14, 6))\n", + "\n", + "# Panel A: Actual data and predictions\n", + "axs[0].scatter(data_ANC_predictions['Year_Month'], np.log(data_ANC_predictions['y_filtered']), color='#1C6E8C', alpha=0.5, label='Actual data')\n", + "axs[0].scatter(data_ANC_predictions['Year_Month'], np.log(data_ANC_predictions['y_pred']), color='#9AC4F8', alpha=0.7, label='Predictions')\n", + "axs[0].set_xticklabels(data_ANC_predictions['Year_Month'], rotation=45, ha='right')\n", + "axs[0].set_xlabel('Year')\n", + "axs[0].set_ylabel('Log(Number of ANC visits)')\n", + "axs[0].set_title('A: Monthly ANC Visits vs. Precipitation')\n", + "axs[0].legend(loc='upper left')\n", + "\n", + "# Panel B: Residuals (in percentage)\n", + "axs[1].scatter(data_ANC_predictions['Year_Month'], np.log(residuals), color='#9AC4F8', alpha=0.7, label='Residuals')\n", + "axs[1].set_xticklabels(data_ANC_predictions['Year_Month'], rotation=45, ha='right')\n", + "axs[1].set_xlabel('Year')\n", + "axs[1].set_ylabel('Log(Residual ANC cases)')\n", + "axs[1].set_title('B: Residuals cases')\n", + "axs[1].legend(loc='upper left')\n", + "plt.tight_layout()\n", + "plt.show()\n" + ], + "id": "9bbce4ff1b9259a6", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ANC prediction OLS Regression Results \n", + "=======================================================================================\n", + "Dep. Variable: y R-squared (uncentered): 0.977\n", + "Model: OLS Adj. R-squared (uncentered): 0.976\n", + "Method: Least Squares F-statistic: 2699.\n", + "Date: Tue, 03 Dec 2024 Prob (F-statistic): 0.00\n", + "Time: 17:54:09 Log-Likelihood: -26382.\n", + "No. Observations: 23493 AIC: 5.348e+04\n", + "Df Residuals: 23134 BIC: 5.638e+04\n", + "Df Model: 359 \n", + "Covariance Type: nonrobust \n", + "==============================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "x1 1.91e-05 0.000 0.156 0.876 -0.000 0.000\n", + "x2 4.4343 0.229 19.350 0.000 3.985 4.883\n", + "x3 4.5303 0.229 19.809 0.000 4.082 4.979\n", + "x4 4.3704 0.229 19.074 0.000 3.921 4.819\n", + "x5 0.0115 0.023 0.491 0.623 -0.034 0.057\n", + "x6 4.4266 0.229 19.315 0.000 3.977 4.876\n", + "x7 4.5094 0.229 19.718 0.000 4.061 4.958\n", + "x8 4.3793 0.229 19.113 0.000 3.930 4.828\n", + "x9 0.0104 0.024 0.436 0.663 -0.036 0.057\n", + "x10 4.4210 0.229 19.291 0.000 3.972 4.870\n", + "x11 4.5516 0.229 19.904 0.000 4.103 5.000\n", + "x12 4.3969 0.229 19.189 0.000 3.948 4.846\n", + "x13 0.0358 0.037 0.965 0.335 -0.037 0.108\n", + "x14 0.0041 0.019 0.219 0.827 -0.032 0.041\n", + "x15 -0.0064 0.018 -0.359 0.720 -0.041 0.029\n", + "x16 -0.0013 0.019 -0.066 0.948 -0.039 0.037\n", + "x17 0.0373 0.022 1.728 0.084 -0.005 0.080\n", + "x18 -0.0308 0.024 -1.268 0.205 -0.078 0.017\n", + "x19 0.0714 0.052 1.381 0.167 -0.030 0.173\n", + "x20 0.0206 0.089 0.231 0.818 -0.155 0.196\n", + "x21 0.0300 0.068 0.440 0.660 -0.104 0.164\n", + "x22 0.0494 0.069 0.715 0.475 -0.086 0.185\n", + "x23 0.0055 0.051 0.109 0.913 -0.094 0.105\n", + "x24 0.0272 0.061 0.447 0.655 -0.092 0.147\n", + "x25 -0.0033 0.089 -0.037 0.971 -0.178 0.171\n", + "x26 0.0286 0.063 0.455 0.649 -0.095 0.152\n", + "x27 -1.4021 0.112 -12.516 0.000 -1.622 -1.183\n", + "x28 1.9624 0.080 24.522 0.000 1.806 2.119\n", + "x29 1.8812 0.080 23.475 0.000 1.724 2.038\n", + "x30 4.5352 0.249 18.211 0.000 4.047 5.023\n", + "x31 1.0283 0.082 12.613 0.000 0.868 1.188\n", + "x32 0.9321 0.079 11.776 0.000 0.777 1.087\n", + "x33 0.0456 0.080 0.572 0.567 -0.111 0.202\n", + "x34 3.7484 0.250 14.999 0.000 3.259 4.238\n", + "x35 0.5269 0.083 6.356 0.000 0.364 0.689\n", + "x36 0.4281 0.085 5.044 0.000 0.262 0.595\n", + "x37 1.2365 0.085 14.500 0.000 1.069 1.404\n", + "x38 4.0911 0.249 16.411 0.000 3.602 4.580\n", + "x39 0.5535 0.082 6.752 0.000 0.393 0.714\n", + "x40 0.2675 0.080 3.343 0.001 0.111 0.424\n", + "x41 -3.0863 0.094 -32.709 0.000 -3.271 -2.901\n", + "x42 4.7505 0.249 19.065 0.000 4.262 5.239\n", + "x43 -2.7993 0.159 -17.597 0.000 -3.111 -2.487\n", + "x44 0.3438 0.081 4.224 0.000 0.184 0.503\n", + "x45 -0.2084 0.081 -2.573 0.010 -0.367 -0.050\n", + "x46 4.5515 0.251 18.151 0.000 4.060 5.043\n", + "x47 -0.0609 0.082 -0.747 0.455 -0.221 0.099\n", + "x48 0.4537 0.087 5.210 0.000 0.283 0.624\n", + "x49 1.9204 0.080 23.965 0.000 1.763 2.078\n", + "x50 5.8085 0.248 23.377 0.000 5.322 6.296\n", + "x51 -0.5421 0.082 -6.613 0.000 -0.703 -0.381\n", + "x52 1.5541 0.080 19.313 0.000 1.396 1.712\n", + "x53 -1.6085 0.081 -19.966 0.000 -1.766 -1.451\n", + "x54 4.4685 0.253 17.651 0.000 3.972 4.965\n", + "x55 0.7841 0.082 9.565 0.000 0.623 0.945\n", + "x56 -0.6063 0.109 -5.569 0.000 -0.820 -0.393\n", + "x57 0.1216 0.082 1.476 0.140 -0.040 0.283\n", + "x58 4.3659 0.251 17.394 0.000 3.874 4.858\n", + "x59 0.8805 0.082 10.800 0.000 0.721 1.040\n", + "x60 -0.4918 0.080 -6.179 0.000 -0.648 -0.336\n", + "x61 0.9945 0.082 12.144 0.000 0.834 1.155\n", + "x62 4.9916 0.249 20.055 0.000 4.504 5.479\n", + "x63 0.7928 0.090 8.823 0.000 0.617 0.969\n", + "x64 -0.3034 0.085 -3.574 0.000 -0.470 -0.137\n", + "x65 0.7568 0.084 8.982 0.000 0.592 0.922\n", + "x66 5.6793 0.253 22.440 0.000 5.183 6.175\n", + "x67 0.1598 0.085 1.884 0.060 -0.006 0.326\n", + "x68 1.0227 0.080 12.849 0.000 0.867 1.179\n", + "x69 0.0131 0.080 0.164 0.870 -0.143 0.169\n", + "x70 5.2242 0.250 20.891 0.000 4.734 5.714\n", + "x71 -1.9281 0.084 -22.990 0.000 -2.093 -1.764\n", + "x72 -3.7499 0.097 -38.525 0.000 -3.941 -3.559\n", + "x73 -1.9080 0.081 -23.430 0.000 -2.068 -1.748\n", + "x74 4.3078 0.249 17.301 0.000 3.820 4.796\n", + "x75 0.9251 0.081 11.470 0.000 0.767 1.083\n", + "x76 -1.3966 0.091 -15.387 0.000 -1.575 -1.219\n", + "x77 0.0960 0.081 1.179 0.238 -0.064 0.256\n", + "x78 3.8332 0.251 15.259 0.000 3.341 4.326\n", + "x79 1.6622 0.078 21.256 0.000 1.509 1.816\n", + "x80 0.7181 0.083 8.669 0.000 0.556 0.880\n", + "x81 0.9961 0.080 12.431 0.000 0.839 1.153\n", + "x82 0.6056 0.252 2.407 0.016 0.113 1.099\n", + "x83 -0.8113 0.092 -8.846 0.000 -0.991 -0.632\n", + "x84 0.6039 0.079 7.631 0.000 0.449 0.759\n", + "x85 1.7141 0.146 11.706 0.000 1.427 2.001\n", + "x86 5.0936 0.249 20.467 0.000 4.606 5.581\n", + "x87 1.4156 0.082 17.172 0.000 1.254 1.577\n", + "x88 0.6328 0.081 7.819 0.000 0.474 0.791\n", + "x89 -4.3571 0.741 -5.877 0.000 -5.810 -2.904\n", + "x90 4.7347 0.249 19.002 0.000 4.246 5.223\n", + "x91 -0.1185 0.081 -1.469 0.142 -0.277 0.040\n", + "x92 -0.9813 0.079 -12.397 0.000 -1.136 -0.826\n", + "x93 -0.7531 0.132 -5.694 0.000 -1.012 -0.494\n", + "x94 3.1884 0.251 12.702 0.000 2.696 3.680\n", + "x95 0.0178 0.081 0.220 0.826 -0.141 0.177\n", + "x96 -0.0953 0.080 -1.184 0.236 -0.253 0.062\n", + "x97 -0.0467 0.100 -0.468 0.640 -0.242 0.149\n", + "x98 4.1716 0.250 16.682 0.000 3.681 4.662\n", + "x99 0.6466 0.082 7.931 0.000 0.487 0.806\n", + "x100 0.0478 0.082 0.584 0.559 -0.113 0.208\n", + "x101 -1.2668 0.281 -4.512 0.000 -1.817 -0.716\n", + "x102 4.2024 0.249 16.860 0.000 3.714 4.691\n", + "x103 1.4924 0.080 18.603 0.000 1.335 1.650\n", + "x104 -2.0895 0.085 -24.616 0.000 -2.256 -1.923\n", + "x105 1.2702 0.081 15.683 0.000 1.111 1.429\n", + "x106 6.1126 0.249 24.564 0.000 5.625 6.600\n", + "x107 -0.6765 0.085 -7.925 0.000 -0.844 -0.509\n", + "x108 -0.3860 0.096 -4.031 0.000 -0.574 -0.198\n", + "x109 -4.4278 0.199 -22.256 0.000 -4.818 -4.038\n", + "x110 4.5258 0.249 18.177 0.000 4.038 5.014\n", + "x111 0.0804 0.103 0.777 0.437 -0.122 0.283\n", + "x112 0.8808 0.082 10.760 0.000 0.720 1.041\n", + "x113 0.5569 0.080 6.950 0.000 0.400 0.714\n", + "x114 5.0969 0.251 20.322 0.000 4.605 5.588\n", + "x115 1.5992 0.081 19.722 0.000 1.440 1.758\n", + "x116 -0.2032 0.091 -2.223 0.026 -0.382 -0.024\n", + "x117 0.5087 0.095 5.352 0.000 0.322 0.695\n", + "x118 3.6323 0.251 14.475 0.000 3.140 4.124\n", + "x119 0.5514 0.082 6.688 0.000 0.390 0.713\n", + "x120 0.8104 0.086 9.427 0.000 0.642 0.979\n", + "x121 0.7663 0.086 8.930 0.000 0.598 0.934\n", + "x122 5.1276 0.249 20.618 0.000 4.640 5.615\n", + "x123 0.3597 0.086 4.163 0.000 0.190 0.529\n", + "x124 0.2872 0.093 3.095 0.002 0.105 0.469\n", + "x125 0.0834 0.086 0.973 0.331 -0.085 0.252\n", + "x126 4.5304 0.251 18.054 0.000 4.039 5.022\n", + "x127 0.8388 0.081 10.345 0.000 0.680 0.998\n", + "x128 0.6639 0.081 8.157 0.000 0.504 0.823\n", + "x129 -1.0472 0.081 -12.859 0.000 -1.207 -0.888\n", + "x130 4.3400 0.252 17.213 0.000 3.846 4.834\n", + "x131 0.8071 0.082 9.845 0.000 0.646 0.968\n", + "x132 0.7736 0.079 9.826 0.000 0.619 0.928\n", + "x133 0.3033 0.081 3.725 0.000 0.144 0.463\n", + "x134 4.4646 0.250 17.865 0.000 3.975 4.954\n", + "x135 1.0701 0.080 13.337 0.000 0.913 1.227\n", + "x136 0.4529 0.081 5.597 0.000 0.294 0.612\n", + "x137 1.0663 0.082 12.948 0.000 0.905 1.228\n", + "x138 6.2477 0.260 24.064 0.000 5.739 6.757\n", + "x139 0.2993 0.081 3.691 0.000 0.140 0.458\n", + "x140 0.8915 0.081 10.953 0.000 0.732 1.051\n", + "x141 1.4199 0.088 16.138 0.000 1.247 1.592\n", + "x142 3.8501 0.250 15.406 0.000 3.360 4.340\n", + "x143 1.8677 0.090 20.649 0.000 1.690 2.045\n", + "x144 0.1146 0.080 1.440 0.150 -0.041 0.271\n", + "x145 -0.1134 0.081 -1.400 0.162 -0.272 0.045\n", + "x146 5.2557 0.249 21.120 0.000 4.768 5.743\n", + "x147 0.8307 0.084 9.906 0.000 0.666 0.995\n", + "x148 0.7224 0.085 8.511 0.000 0.556 0.889\n", + "x149 0.0923 0.098 0.941 0.347 -0.100 0.285\n", + "x150 2.4552 0.250 9.837 0.000 1.966 2.944\n", + "x151 1.0614 0.079 13.369 0.000 0.906 1.217\n", + "x152 -0.9443 0.084 -11.195 0.000 -1.110 -0.779\n", + "x153 -1.1449 0.082 -13.903 0.000 -1.306 -0.984\n", + "x154 5.0084 0.249 20.105 0.000 4.520 5.497\n", + "x155 -1.3949 0.248 -5.629 0.000 -1.881 -0.909\n", + "x156 0.0329 0.090 0.365 0.715 -0.144 0.210\n", + "x157 -2.4251 0.084 -28.949 0.000 -2.589 -2.261\n", + "x158 4.2168 0.259 16.293 0.000 3.710 4.724\n", + "x159 0.9453 0.081 11.721 0.000 0.787 1.103\n", + "x160 -0.8420 0.081 -10.406 0.000 -1.001 -0.683\n", + "x161 1.3098 0.081 16.083 0.000 1.150 1.469\n", + "x162 5.4000 0.249 21.662 0.000 4.911 5.889\n", + "x163 0.4769 0.083 5.753 0.000 0.314 0.639\n", + "x164 0.3619 0.079 4.572 0.000 0.207 0.517\n", + "x165 0.4428 0.090 4.933 0.000 0.267 0.619\n", + "x166 0.0990 0.259 0.382 0.702 -0.409 0.607\n", + "x167 -2.3176 0.428 -5.411 0.000 -3.157 -1.478\n", + "x168 1.0218 0.085 12.039 0.000 0.855 1.188\n", + "x169 0.2921 0.082 3.568 0.000 0.132 0.453\n", + "x170 4.4846 0.249 18.000 0.000 3.996 4.973\n", + "x171 -0.1612 0.095 -1.694 0.090 -0.348 0.025\n", + "const -2.757e-15 1.4e-16 -19.749 0.000 -3.03e-15 -2.48e-15\n", + "x172 0.9555 0.083 11.474 0.000 0.792 1.119\n", + "x173 5.6876 0.249 22.825 0.000 5.199 6.176\n", + "x174 0.3192 0.085 3.763 0.000 0.153 0.486\n", + "x175 -0.0424 0.080 -0.533 0.594 -0.198 0.114\n", + "x176 0.9104 0.081 11.301 0.000 0.753 1.068\n", + "x177 4.3942 0.249 17.614 0.000 3.905 4.883\n", + "x178 -0.7181 0.088 -8.153 0.000 -0.891 -0.545\n", + "x179 -0.9268 0.084 -11.056 0.000 -1.091 -0.762\n", + "x180 -0.7591 0.080 -9.473 0.000 -0.916 -0.602\n", + "x181 2.7100 0.254 10.682 0.000 2.213 3.207\n", + "x182 0.7904 0.088 9.032 0.000 0.619 0.962\n", + "x183 -0.5181 0.080 -6.438 0.000 -0.676 -0.360\n", + "x184 -0.9242 0.080 -11.533 0.000 -1.081 -0.767\n", + "x185 3.7619 0.251 14.997 0.000 3.270 4.254\n", + "x186 0.3454 0.082 4.190 0.000 0.184 0.507\n", + "x187 1.7636 0.093 18.999 0.000 1.582 1.946\n", + "x188 -0.0491 0.084 -0.586 0.558 -0.213 0.115\n", + "x189 4.6043 0.249 18.499 0.000 4.116 5.092\n", + "x190 0.9308 0.082 11.354 0.000 0.770 1.092\n", + "x191 -0.1604 0.079 -2.026 0.043 -0.316 -0.005\n", + "x192 1.0017 0.098 10.209 0.000 0.809 1.194\n", + "x193 2.6233 0.255 10.269 0.000 2.123 3.124\n", + "x194 -0.4355 0.105 -4.133 0.000 -0.642 -0.229\n", + "x195 0.2818 0.089 3.148 0.002 0.106 0.457\n", + "x196 0.7989 0.093 8.594 0.000 0.617 0.981\n", + "x197 -0.0193 0.271 -0.071 0.943 -0.550 0.511\n", + "x198 -1.0848 0.109 -9.995 0.000 -1.297 -0.872\n", + "x199 0.5028 0.089 5.657 0.000 0.329 0.677\n", + "x200 0.0890 0.096 0.929 0.353 -0.099 0.277\n", + "x201 5.7720 0.254 22.709 0.000 5.274 6.270\n", + "x202 -0.1188 0.090 -1.313 0.189 -0.296 0.058\n", + "x203 -1.3570 0.100 -13.589 0.000 -1.553 -1.161\n", + "x204 0.8734 0.091 9.600 0.000 0.695 1.052\n", + "x205 6.4296 0.266 24.144 0.000 5.908 6.952\n", + "x206 0.6336 0.089 7.101 0.000 0.459 0.809\n", + "x207 -0.7711 0.093 -8.310 0.000 -0.953 -0.589\n", + "x208 -0.9226 0.120 -7.687 0.000 -1.158 -0.687\n", + "x209 -0.0181 0.255 -0.071 0.943 -0.517 0.481\n", + "x210 -4.4357 0.092 -48.360 0.000 -4.615 -4.256\n", + "x211 0.5314 0.093 5.726 0.000 0.349 0.713\n", + "x212 0.2106 0.091 2.314 0.021 0.032 0.389\n", + "x213 4.8418 0.255 19.022 0.000 4.343 5.341\n", + "x214 0.6890 0.089 7.772 0.000 0.515 0.863\n", + "x215 1.4208 0.089 15.987 0.000 1.247 1.595\n", + "x216 -1.2938 0.095 -13.609 0.000 -1.480 -1.107\n", + "x217 5.1911 0.253 20.501 0.000 4.695 5.687\n", + "x218 -0.9544 0.102 -9.311 0.000 -1.155 -0.753\n", + "x219 0.1008 0.092 1.094 0.274 -0.080 0.281\n", + "x220 1.7063 0.089 19.139 0.000 1.532 1.881\n", + "x221 5.2542 0.253 20.785 0.000 4.759 5.750\n", + "x222 0.9549 0.093 10.264 0.000 0.773 1.137\n", + "x223 -0.4454 0.092 -4.835 0.000 -0.626 -0.265\n", + "x224 0.3041 0.092 3.318 0.001 0.124 0.484\n", + "x225 5.3354 0.254 21.005 0.000 4.838 5.833\n", + "x226 0.4002 0.094 4.270 0.000 0.216 0.584\n", + "x227 0.7668 0.095 8.072 0.000 0.581 0.953\n", + "x228 1.5758 0.090 17.438 0.000 1.399 1.753\n", + "x229 5.4324 0.253 21.495 0.000 4.937 5.928\n", + "x230 0.1060 0.089 1.188 0.235 -0.069 0.281\n", + "x231 -2.5610 0.123 -20.905 0.000 -2.801 -2.321\n", + "x232 1.8216 0.125 14.593 0.000 1.577 2.066\n", + "x233 5.3090 0.252 21.078 0.000 4.815 5.803\n", + "x234 0.2994 0.092 3.241 0.001 0.118 0.480\n", + "x235 -0.2034 0.094 -2.175 0.030 -0.387 -0.020\n", + "x236 0.2603 0.097 2.695 0.007 0.071 0.450\n", + "x237 5.1467 0.252 20.402 0.000 4.652 5.641\n", + "x238 0.0561 0.093 0.603 0.546 -0.126 0.239\n", + "x239 1.1055 0.087 12.691 0.000 0.935 1.276\n", + "x240 0.8487 0.092 9.260 0.000 0.669 1.028\n", + "x241 5.1347 0.255 20.099 0.000 4.634 5.635\n", + "x242 0.5811 0.090 6.424 0.000 0.404 0.758\n", + "x243 0.0341 0.088 0.389 0.697 -0.138 0.206\n", + "x244 -0.0186 0.092 -0.202 0.840 -0.200 0.162\n", + "x245 6.0525 0.254 23.801 0.000 5.554 6.551\n", + "x246 0.5093 0.098 5.185 0.000 0.317 0.702\n", + "x247 0.2575 0.091 2.836 0.005 0.080 0.435\n", + "x248 -0.4414 0.094 -4.678 0.000 -0.626 -0.256\n", + "x249 4.6521 0.253 18.393 0.000 4.156 5.148\n", + "x250 -0.8409 0.102 -8.204 0.000 -1.042 -0.640\n", + "x251 0.7020 0.106 6.648 0.000 0.495 0.909\n", + "x252 1.6183 0.095 17.024 0.000 1.432 1.805\n", + "x253 5.9116 0.253 23.326 0.000 5.415 6.408\n", + "x254 0.3938 0.096 4.106 0.000 0.206 0.582\n", + "x255 0.3820 0.091 4.178 0.000 0.203 0.561\n", + "x256 -0.7749 0.092 -8.455 0.000 -0.955 -0.595\n", + "x257 4.7352 0.254 18.623 0.000 4.237 5.234\n", + "x258 0.3414 0.094 3.642 0.000 0.158 0.525\n", + "x259 -0.3145 0.099 -3.177 0.001 -0.509 -0.120\n", + "x260 0.1015 0.094 1.083 0.279 -0.082 0.285\n", + "x261 6.4871 0.253 25.594 0.000 5.990 6.984\n", + "x262 0.3305 0.090 3.678 0.000 0.154 0.507\n", + "x263 -0.1716 0.089 -1.931 0.053 -0.346 0.003\n", + "x264 -1.5954 0.110 -14.558 0.000 -1.810 -1.381\n", + "x265 4.7001 0.253 18.542 0.000 4.203 5.197\n", + "x266 -0.4116 0.093 -4.423 0.000 -0.594 -0.229\n", + "x267 0.4961 0.088 5.619 0.000 0.323 0.669\n", + "x268 1.5444 0.090 17.090 0.000 1.367 1.722\n", + "x269 4.3971 0.255 17.232 0.000 3.897 4.897\n", + "x270 -0.2293 0.090 -2.551 0.011 -0.405 -0.053\n", + "x271 1.1693 0.094 12.502 0.000 0.986 1.353\n", + "x272 1.1497 0.090 12.806 0.000 0.974 1.326\n", + "x273 4.8734 0.253 19.225 0.000 4.377 5.370\n", + "x274 0.6495 0.090 7.180 0.000 0.472 0.827\n", + "x275 -1.2439 0.095 -13.094 0.000 -1.430 -1.058\n", + "x276 0.6792 0.090 7.515 0.000 0.502 0.856\n", + "x277 4.5025 0.253 17.797 0.000 4.007 4.998\n", + "x278 0.8008 0.089 8.974 0.000 0.626 0.976\n", + "x279 1.9276 0.096 20.133 0.000 1.740 2.115\n", + "x280 -0.2086 0.097 -2.159 0.031 -0.398 -0.019\n", + "x281 5.4763 0.251 21.781 0.000 4.983 5.969\n", + "x282 0.7023 0.090 7.763 0.000 0.525 0.880\n", + "x283 -0.1419 0.088 -1.607 0.108 -0.315 0.031\n", + "x284 2.0750 0.093 22.319 0.000 1.893 2.257\n", + "x285 0.4272 0.255 1.672 0.094 -0.074 0.928\n", + "x286 -4.3965 0.741 -5.931 0.000 -5.850 -2.944\n", + "x287 -0.4665 0.097 -4.794 0.000 -0.657 -0.276\n", + "x288 0.5211 0.092 5.645 0.000 0.340 0.702\n", + "x289 5.0330 0.253 19.874 0.000 4.537 5.529\n", + "x290 0.0325 0.095 0.341 0.733 -0.154 0.219\n", + "x291 0.9920 0.092 10.769 0.000 0.811 1.173\n", + "x292 1.0009 0.092 10.922 0.000 0.821 1.181\n", + "x293 4.3366 0.253 17.113 0.000 3.840 4.833\n", + "x294 1.2369 0.091 13.581 0.000 1.058 1.415\n", + "x295 1.4243 0.091 15.688 0.000 1.246 1.602\n", + "x296 0.4796 0.093 5.159 0.000 0.297 0.662\n", + "x297 4.2093 0.252 16.685 0.000 3.715 4.704\n", + "x298 1.0256 0.094 10.944 0.000 0.842 1.209\n", + "x299 -0.3961 0.094 -4.203 0.000 -0.581 -0.211\n", + "x300 0.6058 0.092 6.565 0.000 0.425 0.787\n", + "x301 5.0122 0.252 19.870 0.000 4.518 5.507\n", + "x302 0.7901 0.089 8.913 0.000 0.616 0.964\n", + "x303 0.9815 0.096 10.252 0.000 0.794 1.169\n", + "x304 -0.5186 0.102 -5.107 0.000 -0.718 -0.320\n", + "x305 5.2926 0.252 21.018 0.000 4.799 5.786\n", + "x306 -1.9813 0.092 -21.450 0.000 -2.162 -1.800\n", + "x307 1.9473 0.105 18.624 0.000 1.742 2.152\n", + "x308 1.0341 0.092 11.286 0.000 0.854 1.214\n", + "x309 3.3816 0.256 13.206 0.000 2.880 3.883\n", + "x310 -1.0015 0.104 -9.594 0.000 -1.206 -0.797\n", + "x311 0.2316 0.089 2.588 0.010 0.056 0.407\n", + "x312 0.5473 0.106 5.147 0.000 0.339 0.756\n", + "x313 5.2154 0.252 20.698 0.000 4.722 5.709\n", + "x314 0.2995 0.092 3.265 0.001 0.120 0.479\n", + "x315 1.2391 0.097 12.838 0.000 1.050 1.428\n", + "x316 2.0191 0.089 22.801 0.000 1.846 2.193\n", + "x317 4.8360 0.252 19.177 0.000 4.342 5.330\n", + "x318 1.3822 0.089 15.594 0.000 1.209 1.556\n", + "x319 1.1304 0.092 12.273 0.000 0.950 1.311\n", + "x320 -0.5426 0.092 -5.923 0.000 -0.722 -0.363\n", + "x321 2.9543 0.252 11.725 0.000 2.460 3.448\n", + "x322 1.3216 0.095 13.892 0.000 1.135 1.508\n", + "x323 1.6047 0.109 14.746 0.000 1.391 1.818\n", + "x324 0.8286 0.092 9.044 0.000 0.649 1.008\n", + "x325 5.6586 0.252 22.438 0.000 5.164 6.153\n", + "x326 2.1177 0.101 21.030 0.000 1.920 2.315\n", + "x327 1.5271 0.099 15.429 0.000 1.333 1.721\n", + "x328 1.1165 0.088 12.691 0.000 0.944 1.289\n", + "x329 3.5811 0.252 14.200 0.000 3.087 4.075\n", + "x330 1.1841 0.106 11.131 0.000 0.976 1.393\n", + "x331 -0.1144 0.091 -1.261 0.207 -0.292 0.063\n", + "x332 1.0168 0.090 11.253 0.000 0.840 1.194\n", + "x333 4.3174 0.253 17.038 0.000 3.821 4.814\n", + "x334 -0.7428 0.089 -8.325 0.000 -0.918 -0.568\n", + "x335 1.4240 0.103 13.879 0.000 1.223 1.625\n", + "x336 -0.2770 0.092 -3.023 0.003 -0.457 -0.097\n", + "x337 5.1278 0.252 20.311 0.000 4.633 5.623\n", + "x338 0.5160 0.742 0.696 0.487 -0.938 1.969\n", + "x339 0.6598 0.116 5.666 0.000 0.432 0.888\n", + "x340 2.0199 0.105 19.183 0.000 1.814 2.226\n", + "x341 4.7981 0.254 18.893 0.000 4.300 5.296\n", + "x342 0.3243 0.094 3.460 0.001 0.141 0.508\n", + "x343 -0.9052 0.206 -4.396 0.000 -1.309 -0.502\n", + "x344 1.1884 0.092 12.877 0.000 1.008 1.369\n", + "x345 6.1858 0.252 24.562 0.000 5.692 6.679\n", + "x346 0.9245 0.097 9.567 0.000 0.735 1.114\n", + "x347 1.0346 0.094 10.978 0.000 0.850 1.219\n", + "x348 -0.4844 0.089 -5.433 0.000 -0.659 -0.310\n", + "x349 4.0565 0.258 15.751 0.000 3.552 4.561\n", + "x350 -0.0355 0.091 -0.390 0.697 -0.214 0.143\n", + "x351 -0.0840 0.102 -0.827 0.408 -0.283 0.115\n", + "x352 -0.1339 0.093 -1.440 0.150 -0.316 0.048\n", + "x353 6.0788 0.255 23.850 0.000 5.579 6.578\n", + "x354 0.0844 0.093 0.907 0.364 -0.098 0.267\n", + "x355 -0.5754 0.090 -6.383 0.000 -0.752 -0.399\n", + "x356 0.1106 0.090 1.233 0.218 -0.065 0.287\n", + "x357 3.8002 0.252 15.051 0.000 3.305 4.295\n", + "x358 0.1342 0.092 1.453 0.146 -0.047 0.315\n", + "x359 -4.5392 0.091 -50.006 0.000 -4.717 -4.361\n", + "x360 -4.4169 0.741 -5.957 0.000 -5.870 -2.964\n", + "x361 -6.22e-05 1.87e-05 -3.319 0.001 -9.89e-05 -2.55e-05\n", + "x362 0.1946 0.089 2.196 0.028 0.021 0.368\n", + "==============================================================================\n", + "Omnibus: 12267.723 Durbin-Watson: 1.973\n", + "Prob(Omnibus): 0.000 Jarque-Bera (JB): 171279.824\n", + "Skew: -2.189 Prob(JB): 0.00\n", + "Kurtosis: 15.482 Cond. No. 8.03e+19\n", + "==============================================================================\n", + "\n", + "Notes:\n", + "[1] R² is computed without centering (uncentered) since the model does not contain a constant.\n", + "[2] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", + "[3] The smallest eigenvalue is 1.77e-29. This might indicate that there are\n", + "strong multicollinearity problems or that the design matrix is singular.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_9703/3363565216.py:50: UserWarning: FixedFormatter should only be used together with FixedLocator\n", + " axs[0].set_xticklabels(data_ANC_predictions['Year_Month'], rotation=45, ha='right')\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_9703/3363565216.py:58: UserWarning: FixedFormatter should only be used together with FixedLocator\n", + " axs[1].set_xticklabels(data_ANC_predictions['Year_Month'], rotation=45, ha='right')\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_9703/3363565216.py:71: UserWarning: FixedFormatter should only be used together with FixedLocator\n", + " axs[0].set_xticklabels(data_ANC_predictions['Year_Month'], rotation=45, ha='right')\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_9703/3363565216.py:78: RuntimeWarning: invalid value encountered in log\n", + " axs[1].scatter(data_ANC_predictions['Year_Month'], np.log(residuals), color='#9AC4F8', alpha=0.7, label='Residuals')\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_9703/3363565216.py:79: UserWarning: FixedFormatter should only be used together with FixedLocator\n", + " axs[1].set_xticklabels(data_ANC_predictions['Year_Month'], rotation=45, ha='right')\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAABW4AAAJOCAYAAAAnP56mAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/OQEPoAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydd3gc1fm272lb1SXLcjfYxoAb2AQMwRQHAgFCTQKBUAKG0FIhlIROICRAyI8WSiiBJHQwLVRTDHxUU2zAxr2qa7XavtPO98fsrrQqtmxsLODc1+XLkmZ2ztmpZ57zvs+rCCEEEolEIpFIJBKJRCKRSCQSiUQiGTCoW7sDEolEIpFIJBKJRCKRSCQSiUQiKUYKtxKJRCKRSCQSiUQikUgkEolEMsCQwq1EIpFIJBKJRCKRSCQSiUQikQwwpHArkUgkEolEIpFIJBKJRCKRSCQDDCncSiQSiUQikUgkEolEIpFIJBLJAEMKtxKJRCKRSCQSiUQikUgkEolEMsCQwq1EIpFIJBKJRCKRSCQSiUQikQwwpHArkUgkEolEIpFIJBKJRCKRSCQDDCncSiSSzY4QYmt34VuN3P9bh03d7/J4SSQSiUQikUgkEomkN6RwK5EMIM455xzGjx/P3XffvUmff/zxxxk/fjzjx49nxYoVva4zd+7cwjpbgltvvZW77rqr8PtNN920wbby/V67du2Xbv+tt95i/Pjx/PCHP+x1+bvvvsv48eM588wzN6ov2WyWe++9l6OOOopp06ax6667cswxxzB79uz1Cm8XXXQRO+64Iy0tLX2uc/rppzNz5kxc12XmzJlccMEF/fimHt3X777/BzIXXHBB4VzM/5swYQJ77rknv//972loaPhK+tGfc3RDn5k3bx6nnXbaRrc9Z84czj///MLv+fPz3Xff3ehtSSQSiUQiGfgcf/zxPcY/u+yyCyeccALvvffeRm+v6/i/67/Jkyczc+ZMrrjiChKJxGb9DmvXrmX8+PE8/vjj611vY8e1/eWCCy5g5syZm327EolEMhDRt3YHJBKJRzwe5+WXX2a77bbjoYce4uc//zmKomzStlRV5fnnn+eMM87osex///vfl+3qevm///s/zj777C3axvp47LHH2G677Vi8eDHz5s1j2rRpva43Z84cnnrqKQ499NANbrO1tZVZs2bR0NDA8ccfz+TJk3Fdl1dffZULLriADz74gCuvvLLX43XUUUfxyCOP8Oyzz3LSSSf1WN7W1sYbb7zBGWecgaqq3HzzzZSUlPT7+3Zff2vv/41l0KBB3HzzzYXfbdtmxYoVXHfddXz00Uc888wzBAKBLdqHH//4x8yYMeNLfeaRRx5h2bJlG932vffeW/T7hAkTeOihhxg7duxGb0sikUgkEsnXgx133JFLL70UAMdxaG9v54EHHuCUU07h8ccfZ9y4cRu9zZtvvplBgwYVfu/o6OCNN97g/vvvJxKJ8Pe//31zdZ/a2loeeughRo4cudm2KZFIJJLekcKtRDJAeOaZZwD44x//yIknnsg777zD7rvvvknbmjp1Ks8991wP4dY0TV5++WV22GEHFi5c+KX7PNCIxWK8/PLLXH755dx+++08+OCDfQq3ZWVlXHXVVeyxxx7U1NSsd7vnn38+jY2NPPTQQ4wePbrw93322YehQ4fyt7/9jX333Zfvfe97PT678847M2bMGJ5++ulehdunn34a13U58sgjAW8gvzFs7PoDDZ/Px0477VT0t1122QXDMDj//POZM2cOBx988BbtQ11dHXV1dVv8M/2hpKSkx/6QSCQSiUTyzaK35/0ee+zB7rvvzuOPP16UjdNfdthhB4YPH170t7333pu2tjaee+45kskk4XD4y3S7QG/jN4lEIpFsGaRVgkQyQHjsscfYfffdmT59OqNGjeLBBx8sWp5Pg+pPCvVBBx3EF1980cMuYe7cuSiKwl577dXjM2+99RbHHnss06ZNY7fdduOcc84pSlV//PHH2XHHHfnkk084+uijmTRpEvvuu29RWn4+dfzmm2/ukXr+2muvceihhzJp0iQOOOAAZs+e3WvfX3vtNcaPH8+bb75Z9PcPPviA8ePHM2/evD6/99NPP41t28yYMYNDDz2UF154gWg02uu6v/3tb0mlUlx22WV9bg9g4cKFvPnmm5xyyilFom2ek046ieOOO45QKNTnNo466ig+/fTTXu0rnnjiCfbYYw+GDh0K9Ewpe+aZZzj00EOZPHky06dP59xzz6WpqamwvOv6ve3/TCbDZZddxl577cXEiRM58MAD12ul8PTTTzN+/HgWL15c9PeXX36Z8ePH8/nnnwPwr3/9iwMPPJBJkyYxY8YMLrvsss2ahjdp0iQA1q1bB3gpcSeeeCKXXnopU6dO5aCDDsJxHFzX5Y477mD//fdn4sSJHHDAAdx///09tjd79myOOOIIpkyZwj777MP111+PaZpAT9uD448/ngsuuIDbbruNPfbYg2nTpnHmmWcW+tL9MxdccAFPPPEE69atK0obXLt2Leeddx577rknEyZMYPfdd+e8886jvb290M57773He++9V7i2e7NKWLBgAaeccgq77bYbU6dO5fTTT2fJkiWF5fnPvP3225x88slMmTKF7373u1x77bU4jrNZjodEIpFIJJItSzAYxO/3F2Vwbcz4vy9KS0tRFKVoux988AE/+9nPmDJlCrvuuivnn38+kUiksNx1XW644QZmzpzJxIkTmTlzJtdffz2WZQG9WyUsWrSIn//85+y8887su+++PPXUU0X96MteobvtgeM43HHHHRxyyCFMnjyZnXbaiWOOOYZ33nmnz+/46aefcuKJJzJt2jR23nlnTjrpJD7++OP17hfTNPn73//O9773PSZPnswhhxzCE088sVH96M84OxqNcskll7DHHnswadIkfvKTn/D2228XrfPWW2/xk5/8hJ133pnvfOc7nHHGGZuUySWRSL6ZSOFWIhkALFmyhAULFnD44YcDcPjhhzNnzhxaW1sL6+yzzz489NBDTJgwYYPb++53v0t5eTnPP/980d//97//sf/++2MYRtHfZ8+ezcknn8yQIUP429/+xoUXXshHH33E0UcfTVtbW2E913X5zW9+w0EHHcQdd9zB1KlT+etf/8obb7wBwEMPPQTAj370o8LPeS655BJOOukk/vGPf1BXV8cFF1zAokWLevR9xowZ1NbW8uSTT/bo4+jRo/uMoAVP/J4xYwY1NTUcfvjhWJZVNADrypgxY/jlL3/JSy+9VIh27o38d+vLR8vv93PJJZesNzr6sMMOQ9d1nn766aK/L1q0iEWLFvHjH/+418/NmzeP8847j+9///vceeedXHjhhbzzzjucc845va7f2/6/+uqrmTt3Lueffz533XUX3/ve9/jrX//KY4891us29ttvP0KhEM8++2zR35955hnGjRvHjjvuyDPPPMO1117Lcccdx1133cVZZ53Fk08+yZVXXtnnPthY8iJ31xS8Dz74gIaGBm655RbOOeccNE3jsssu48Ybb+TQQw/ltttu48ADD+Tqq6/mlltuKXzuP//5D+effz4TJkzg5ptv5rTTTuP+++/nT3/6U5/tz5kzh8cff5yLLrqIyy+/nIULF3L88ceTTqd7rHvmmWey9957M2jQIB566CH22Wcf0uk0J5xwAsuWLePSSy/lrrvu4oQTTuDZZ5/lhhtuAODSSy9lxx13ZMcdd+zz2n7nnXf46U9/CnjH8k9/+hMNDQ0cc8wxPQb05557LtOmTeO2227jkEMO4Z///CePPPLIRux1iUQikUgkXwVCCGzbxrZtLMuipaWlMKl81FFHFdbbmPG/67pF22xra+PRRx/liSeeYP/99y8EGbz//vucdNJJBAIB/v73v/OHP/yB9957jxNOOIFMJgPAnXfeyQMPPMBZZ53F3XffzU9/+lPuuusu/vGPf/TadlNTEz/72c+Ix+Nce+21/PrXv+a6664rCjboL9dddx233norRx99NP/85z+58soriUaj/PrXv+51HJZIJJg1axaVlZXcdNNN3HDDDaTTaU455RTi8Xif7Zx77rncc889/PjHP+b2229nzz335IILLii8F/SnHxsaZ2ezWU488UTmzJnDb3/7W26++Wbq6uqYNWtWQbxds2YNZ555JhMnTuQf//gHV111FStWrOC0007Ddd2N3n8SieSbh7RKkEgGAI899hgVFRUFcfCII47gpptu4tFHH+X0008HoKqqiqqqqn5tT9d19ttvvyK7hHQ6zauvvsott9xSFLXqui7XXXcde+65J9dff33h7/moxrvuuovzzjsP8AaZZ555ZkFonDZtGi+99BKvvfYaM2bMKKRM1dXV9Uif+tOf/lSI9B05ciT7778/7733Httvv33RepqmccQRR3D//fcXUroymQzPPffceos/ffHFF3z22WfceOONAAwdOpTp06cX/IJ745RTTuGll17iyiuvZPr06b1aJuSjjrunnm0MNTU17LPPPjzzzDP86le/Kvx99uzZVFZW9ikKz5s3j0AgwGmnnYbP5wOgoqKCBQsWIITo4anb2/5/7733+O53v1uwG9htt90IhUJUV1f32mYwGOSAAw7gf//7H7/97W8BSCaTvPrqq5x11lmFbQ4fPpzjjjsOVVXZddddCYVCdHR0bNL+sW278HMikWDBggX8+c9/Zvjw4eyzzz5F611xxRUFi4IVK1bw8MMP87vf/a5wbuy5554oisLtt9/OscceS3l5Obfccgv77bdfkVCbTqd59tlnC5Ej3Umn0zz++OOMGDECgG233ZYjjjiC2bNnF4TUPCNHjqSqqqoobXDhwoXU1dXxl7/8pbCN6dOn88knnxQKj4wdO7bgT9xXuuH111/PqFGjuOOOO9A0rfAd999/f2688Ub+7//+r7Duj3/848Ix2n333Xn55Zd57bXXOOaYY/rY8xKJRCKRSLYG77//fq9i7O9+9zvGjBlT+H1jxv/7779/j7/V1NRw7LHHFo0/r7/+erbZZhtuv/32wthiypQpHHzwwTz22GMcd9xxvPfee0ycOLEgIu+6664Eg0FKS0t7bfvee+8tRKjm+7vNNtvwk5/8pF9970pzczO//e1vOf744wt/8/v9/PKXv+SLL77oMWZaunQp7e3tnHDCCUydOhXwxm0PPfQQyWSy1z4vXryYF154gT/84Q+ceOKJgDd2WrduHe+++y6HHHJIv/qxoXH2k08+yaJFi3j44YeZMmUKAHvttRfHH3881113HY899hjz588nk8nwi1/8gsGDBwPeWH7OnDmkUqmNqn0hkUi+mUjhViLZyliWxVNPPcV+++1HJpMhk8kQDoeZNm0aDz/8MKeddhqquvHB8QcddBCPPfYYK1asYJtttuHVV18lFAqx2267FQm3K1asoKWlpUcU58iRI9l55517VLfdeeedCz/7fD6qqqpIpVIb7M8uu+xS+DkvgsZisV7XPeqoo7j99tt56aWXOPzww3nppZdIpVKFiOTeeOyxxygrK2OXXXYpbPeAAw7g0ksv5Z133mH69Ok9PqNpGn/+85854ogjuPzyy7npppt6XQf40innRx11FGeccQaffPIJU6ZMwXEcnn76aQ477LCCKNud73znO9xwww0ccsghHHDAAey9997sueee7L333v1ud7fdduPBBx+ksbGRvffem7333rsg7vXFYYcdxhNPPMH8+fOZPHkyc+bMwTTNQiG3vCB+5JFHst9++7H33nvzwx/+cJOK6a1bt67XF5cpU6ZwxRVXFBUmq6ioKPKVfeeddxBCMHPmzCLxd+bMmfzjH/9g3rx5bLPNNrS1tfV4mTnllFM45ZRT+uzX1KlTC4IreF7CI0aM4P333+8h3PbGDjvswH//+19c12XlypWsWrWKpUuXsnz58qK+ro9UKsWCBQs4++yzC+cheP7M++67L6+//nrR+l2vTfAG/f25NiUSiUQikXy1TJgwgcsvvxzwAiNisRhz587lhhtuIJVKFSbPN4Z//OMfDBo0CMuyePzxx5k9eza/+tWvOProowvrpNNpPvnkE0455ZRC1C/AiBEjGDNmDG+99RbHHXccu+22G9dffz3HHnssM2fOZJ999uFnP/tZn23PmzePnXbaqUhknjJlSsEKbGPIB5JEIhGWL1/OqlWrePXVVwEKNlddGTduHFVVVZx++ukceOCBzJgxg+9+97v8/ve/X29/Ab7//e8X/b3ru0B/+rGhcfbbb7/NoEGDmDBhQtH4b9999+Wvf/0rHR0dTJkyBb/fz49+9CMOPPBA9tprL3bbbTcmT57c/50mkUi+0UjhViLZyrz22muFVKZHH320x/I33nhjo4S6PNOnT6eyspLnn3+eM844g//9738ceOCBRQIQUPCA7S3atKampuBpmqerkAagqipCiA32p6sHbF6I7utzo0aNYtddd2X27NkcfvjhzJ49mz322KMwC92dvPgdi8XYY489eix/8MEHexVuwYt6PPvss/nb3/7Wwx4AYNiwYQDU19czduzYXrfR1NREbW3teoXLvfbai0GDBvH0008zZcoU3nzzTVpbW/u0SQBPiLvjjju49957ueeee7jjjjuoqanh9NNPL5r9Xx9//OMfqaur46mnnuLKK6/kyiuvZOedd+ayyy7rEe2cZ7fddmPw4ME8++yzTJ48mWeffZZdd921IJoedNBBuK7Lf//7X2699VZuuukmhg0bxrnnnstBBx3Ur37lGTRoUFHanc/no66ujvLy8h7rdi+okT93+ype1tTURGVlJUCfEcZ90du5Vl1dvVFRxffccw+33XYb0WiUmpoaJk6cSDAYXG/aXlfi8ThCiD6vze7b2dRrUyKRSCQSyVdLOBwu+Pnn2XPPPUmlUvzzn//khBNO2Oixy3bbbVcIjpg6dSq2bXPJJZdQUlJSGCvFYjFc1+XOO+/kzjvv7LENv98PwKxZswiHwzz22GNcd911XHvttYwbN46LLrqo1zF1R0dHr9lpgwYN2qjvAJ63/+WXX86CBQsIBoOMHTu2IAD3Nq4Jh8P85z//4R//+AfPPfccDz30EIFAgMMOO4yLLrqo1wCJ/Bhyffu4P/3Y0Dg7Go3S0tLSp9VFS0sLY8eO5d///jd33HEHjz76KPfddx9lZWUce+yx/OY3v9mkwAiJRPLNQgq3EslW5rHHHmPEiBFcddVVRX8XQnD22Wfz4IMPbpJwq+s63//+93n++ec5/vjjmTt3Lvfee2+P9SoqKgCK/HTztLS0FISvr5qjjjqKP/zhDyxbtoy3336b6667rs91X331Vdrb27nyyisZNWpU0bIHHniAl19+mba2tj4HZ7NmzeLFF1/kyiuv7BGFueeeewLw+uuv9yrc2rbNYYcdxtSpU7n11lv77KOu6xx++OE8/vjjXHjhhcyePZuddtqpTzE4z4wZM5gxYwbpdJp33nmH++67jz/96U9MmTKlXzPxPp+PM844gzPOOIP6+npeffVVbr31Vs4555xehWrwBL8f/vCHPPPMM5x++um89dZbXHHFFUXrHHLIIRxyyCHE43HefPNN7rzzTn7/+98zbdq0PgX2vvrX/cWlv5SVlQFeobTeqiQPHTq0UGija8ENgPb2dj7//PMeUapdl3entbW1yHN3fTz99NNcc801/P73v+fII48sRKD8+te/ZsGCBf3aRr6YSF/XZv7alUgkEolE8s1g4sSJPPLII6xdu3ajhdvuXHTRRbz11ltcdtll7LbbbtTU1BAOh1EUhZNOOqnXie9gMAh4Y8HjjjuO4447jra2Nl5//XVuu+02fvnLX/LWW2/1+FxlZWWv45WuRYLzAmT3LLau2UF5v9rx48fz7LPPsu2226KqKq+//jovvPBCn9912223LRRlnT9/Pk8++SQPPPAAI0eOZNasWT3Wz48hI5FIUTbXsmXLiEajjB8/vl/92NA4u7S0lNGjR/f5HpMXuydPnszNN9+MaZrMmzePhx56iNtuu43tt9+eH/zgB31+b4lE8u1AFieTSLYiLS0tvPHGGxx88MHstttuRf+mT5/OgQceyOuvv75Jxv7gRUYuWrSIe+65h5qaml5Fqm222YZBgwb1KNC1Zs0aPv7444JXVH/ZFFuH3jjggAMIBoNcdtllhMNh9ttvvz7Xfeyxx6irq+PHP/5xj/14/PHHY1lWn8W4wLNDuOaaa0gkEtx+++1Fy8aNG8dee+3FnXfeyZo1a3p89vbbb6e9vb1gI7A+jjrqKNra2njzzTd57bXX+NGPfrTe9f/yl79w1FFHIYQgGAyy7777cv755wNeBHBvdN3/mUyGAw44gLvvvhvwhMzjjjuOgw8+uM/P5znssMNobGzklltuQdO0olSy3/zmN4U0sNLSUn7wgx9w5plnYts2zc3NG9wPm4u8/UZ7ezuTJk0q/ItEIvzf//0f0WiUbbfdlsrKykJqW54nn3yS0047rU+P23nz5hWJt59++ilr167tswhd9/N+3rx5lJWVMWvWrIJom0wmmTdvXlGhifVdL6FQiIkTJ/Lcc88VveTE43Fee+219Rbqk0gkEolE8vVj/vz5aJpWZNe0qZSUlHDhhRcSi8UKaf8lJSXsuOOOLF++vGjsNG7cOG666SbeffddAI455phCbYDq6mqOPPJIjjvuOGKxGIlEokdb06dP56OPPip6Z1m6dGnR2Dnv1dp1HcuymD9/fuH35cuXE41GOeGEExg7dmxhnDR37lyAXot1Pf/880yfPp2WlhY0TStEvJaVlfU53s2PoV555ZWiv1933XVcddVV/epHf8bZu+66Kw0NDVRXVxft77feeot//vOfaJrGvffey7777otpmvh8PnbfffdCwd8NjdclEsm3AxlxK5FsRWbPno1t232meh9++OE88sgjPPzwwxx33HGsXr26qKDRhth1110ZNGgQt99+OyeddFKvqTaqqvK73/2OCy+8kHPOOYdDDz2U9vZ2br75ZsrLy/ss7NUXZWVlfPjhh7z//vtFvrYbSzAY5OCDD+ahhx7ipz/9aZ8+sM3NzbzxxhuceOKJvX6/adOmMXLkSB566CFOPfXUPtsbN24cZ511Fn//+997LLv88ss58cQT+clPfsIJJ5zAlClTSCaTPP/88zz77LMcc8wxHHjggRv8Tttssw1Tp07l6quvBtigrcD06dO55557uOCCCzj00EOxLIt//vOfVFRU9Gn90H3/T5gwgZtvvhnDMBg/fjwrVqzgiSee4IADDlhv29ttt13Bp/UHP/hB0Tk3ffp0Lr30Uv7yl7+w1157EYvFuPnmmxk9enTBfmH16tVEIpE+i25tDsaPH8+hhx7KxRdfzLp165g4cSIrVqzghhtuYPjw4YwePRpN0/jlL3/JFVdcQXV1NTNnzmTFihXceOONHHfccb1aMoDnATdr1izOOOMMkskkN9xwA9tttx2HHHJIr+uXlZXR2trK66+/zg477MDkyZN54IEHuOaaa9h3331pbm7mrrvuorW1tajNsrIyPvroI95++2123HHHHts955xzOOWUUzjttNM49thjsSyLO+64A9M0N+hVLJFIJBKJZGCSSCT4+OOPC7+bpskrr7zCY489xtFHH12Y9I1EIhs9/u/KQQcdxH//+1+eeOIJfvrTnzJ58uRCUdf8uN9xHO6++24++eQTzjzzTMCrs3D33XcXAj+ampq455572HXXXXutb3HiiSfy6KOPcsopp/DLX/4Sx3G44YYbMAyjsE55eTk777wz999/P6NGjaK8vJz77ruPTCZTsFTbZpttKCkp4bbbbkPXdXRd54UXXijYyaXT6R7fcerUqbiuy1lnncVpp51GOBzmueeeIx6P9/CwzbP99ttz4IEHcu2115LJZNhhhx2YO3cur776KjfffHO/+hEIBDY4zj7yyCP597//zc9//nNOP/10hgwZwv/7f/+PO++8k5/97GcYhsH06dO57rrrOOuss/jZz36Gpmk8+OCD+Hw+9t13340+5hKJ5JuHjLiVSLYijz/+OOPGjWO77bbrdfm0adMYPnw4jzzyCHPmzOHoo4/ms88+6/f2VVXlgAMOwLKsPsVh8AYVN954IytWrOCss87immuuYeedd+bRRx/daG+q008/nU8//ZRTTz2VhoaGjfpsd/bZZ59C//pi9uzZOI6zXhH0sMMOY+3atbzxxhvrbe/UU0/t1YNq6NChPPTQQ/zkJz/hmWee4ayzzuKiiy6ivr6e66+/nssuu6xf3wfgRz/6EStXruQHP/hBr+n9Xdl777257rrrWLJkCWeffTa/+93vCAaD3HfffX2myXff/1dccQVHHnkkd999NyeffDK33norP/rRj/rV58MOOwzHcXpEEx9zzDFcdNFFzJ07l9NPP51LLrmEMWPGcPfddxcG6LfeemtRMYwtxZ///Gd+/vOf8+CDDzJr1ixuu+02DjroIO6+++6Cn/Nxxx3HNddcw7vvvssvfvEL7r33Xk499VTOO++8Pre7yy67sO+++/LHP/6Rq6++mt1335377ruvzwmEI488kmHDhnHWWWcxe/ZsjjjiCM466yyee+45Tj31VG688UZ22WUXrrjiCqLRKMuWLSv0zTAMTj311EIUR1d233137rnnHjKZDL/73e+4+OKLGTx4MA8//HCf9w2JRCKRSCQDm88//5yjjz668G/WrFm8+eab/Pa3v+Xiiy8urPfaa69t9Pi/OxdddBGqqnLFFVcghGDPPffkrrvuorGxkV/96lecd955aJrGPffcU5hw//Wvf83pp5/OY489xqxZs7jmmmvYc889ufHGG3tto7KykgceeIDhw4dzwQUXcPXVV3Pcccf1qKdwzTXXMHHiRC666CIuvPBCJkyYwIknnlhYXlpayq233ooQgl//+tecd9551NfX8+9//5twOMwHH3zQo+3a2lr++c9/Ulpayh//+Ed+8Ytf8Nlnn3HTTTf1GegAcO2113L88cfzr3/9i1/84he888473Hjjjey333797seGxtmhUIj//Oc/TJs2jWuvvZZTTz2VF198kXPOOYcLL7wQ8ETk2267jUQiwe9+9zvOPvtsotEod999N9tuu22/j7NEIvnmoghZuUQikQxQLr30Uj755BNmz569tbsi+RaRL/x2//33b+WeSCQSiUQikUgkEonk24y0SpBIJAOO++67j+XLl/Pwww9z7bXXbu3uSCQSiUQikUgkEolEIpF85UjhViKRDDg++OCDgm9tX56iEolEIpFIJBKJRCKRSCTfZKRVgkQikUgkEolEIpFIJBKJRCKRDDBkcTKJRCKRSCQSiUQikUgkEolEIhlgSOFWIpFIJBKJRCKRSCQSiUQikUgGGFK4lUgkEolEIpFIJBKJRCKRSCSSAcbXtjiZ67rYto2qqiiKsrW7I5FIJBKJRCLZzAghcF0XXddR1W9HvIEc40okEolEIpF8s9mYMe7XVri1bZsFCxZs7W5IJBKJRCKRSLYwkyZNwufzbe1ufCXIMa5EIpFIJBLJt4N+jXHF1xTLssQHH3wgstmssG37K/mXzWaL2uz6+0BatrXbH8h929rtD+S+be32B3Lftnb7A7lvW7t92bevZ/sDuW9bu/2B3Lfefv+qxl6WZW3toedXxtYe4w7kc+7b1r7s29ez/YHct63d/kDu29ZufyD3bWu3L/v29Wx/IPdtQ+t+lWOv/oxxv7YRt/nUMU3T0DTtK227e5vdf97ay7Z2+wO5b1u7/YHct63d/kDu29ZufyD3bWu3L/v29Wx/IPdta7c/kPu2vt+3NN8my4CtPcbt+vNAO+e+be3Lvn092x/Ifdva7Q/kvm3t9gdy37Z2+7JvX8/2B3Lf+rvuV0F/xrjfDrMwiUQikUgkEolEIpFIJBKJRCL5GiGFW4lEIpFIJBKJRCKRSCQSiUQiGWBI4VYikUgkEolEIpFIJBKJRCKRSAYYX1uP2/7iOA6WZW22bQFkMhk0TSv6Pc9AWLa129/SfZNIJBKJRCL5NuO6LqZpbrbtfZPHjQOhfcMwkEgkEolEItkUvrHCrRCCxsZGotHoZt2mruusWrUKRVGKfgcGzLKt3f6W7JuqqjQ2NjJ48ODNdlwlEolEIpFIvi6YpsmKFStwXXezbfObOm4cSO3n97NEIpFIJBLJxvCNFW7zom1tbS2hUGizVCMWQpBOpwkGg4UBWf53YMAs29rtb6m+ua5LNBqlo6PjSx9LiUQikUgkkq8bQggaGhrQNI0RI0agqpvH9eybOG4cKO0HAgFSqRT19fU0NTUxbNiwzXLMJBKJRCKRfDv4Rgq3juMURNvq6urNtl0hBK7rEggECgOy/O/AgFm2tdvfkn0TQuDz+Whubt5sx1UikUgkEonk64Bt26RSKYYOHUooFNps2/2mjhsHQvvBYJBgMIhpmkSjUerq6jbbcZNIJBKJRPLN5xtZnCzvabs5B7SSgYM8rhKJRCKRSL6N5H1TfT7fVu6JZGPx+/0Am632hkQikUgkkm8HWy3i9vHHH+fCCy/s8XdFUVi0aNFmaWNz2CNIBh7yuEokEolEIvk2I8dCXz/kMZNIJBKJRLIpbDXh9qCDDmLGjBmF323b5sQTT2SfffbZWl2SSCQSiUQikUgkEolEIpFIJJIBwVazSggEAgwaNKjw76mnnkIIwbnnnru1ujSgePzxx9l+++2ZPXt2vz+zdu1a5s6du1nav+CCC7jgggv6vf7222/PBx980K91Fy5cyCeffLKpXZNIJBKJRCKRfI2YOXMmU6dOZfvtt2f8+PHssMMO7LPPPpx55pk0NDR8qW0/9dRTzJw5s8/lGzumXR8bM96VSCQSiUQi2RwMCI/baDTKnXfeyTnnnCM9u3I8++yzjBw5kmeeeabfn7niiiu+FoLo2WefzapVq7Z2NyQSiUQikUgkXxHnnnsub7zxBm+++SavvfYa11xzDUuWLPnSour3v/99Hn300c3US4lEIpFIJJKBxVazSujKAw88QG1tLQceeOBGfzZfpKH734QQhX+biusK1rXHSGZNwn4fQytKAQrb7P7/5loWiUR45513uOqqq7jwwgtZs2YNI0aM2ODn+vp5U/rWlf58rrff+/rc5txv+ePf/f/1LduYdb/qZd/29gdy37Z2+wO5b1u7fdm3r2f7A7lvW7v9gdy33tbdknxV7XzbEELQnhJkbfDrUBHc8m2WlJQwaNAgFEVBCEFpaSm/+tWv+P3vf088Ht/k4rOBQEAWrpVIJBKJRPKNZasLt0IIHnnkEWbNmrVJn1+wYEGvf9d1nXQ6jeu6m7TdZc3tvPT5ClY0t5OxHQK6xja1ley/4zaMqS1eN51O9/rzpi576aWXKC0tZb/99uNvf/sbjz76KL/4xS8K6/3pT39izpw5gJd6dt5553H11Vczb9485s2bxzvvvMPll1/OIYccwjPPPMPQoUMBuOGGG5g3bx533nknAP/973+5//77Wbt2LSUlJey///6cd955aJpW9KLUW7/vuOMOHnroIYQQ/OpXvypa1tzczLXXXst7771HJpNhzJgxnHfeeey0006ceuqp1NfXc9lllzFv3jwuv/xyXn/9dW677TZWrFiBz+fju9/9LhdffHFhEN69/UwmU6jI2/34d/19fcs2Zt2vetm3vf2B3Let3f5A7tvWbl/27evZ/kDu29ZufyD3rbffJV8fmmIunzU4RNMCxxVoqkJ5EMZUwqivWP80DAMATdOIxWKFMW4wGOSAAw7gvPPOw+/3A/C3v/2NJ554glgsxuTJk7n00ksZO3YsTz31FHfccQevvPIKAB988AFXXXUVy5cvZ6+99kLTNAKBAAA33XQT77//Pvfdd1+hDzNnzuS0007jmGOOIZFIcNVVV/Hqq6+SSCQYPnw455xzDnvssUePvr/99ttcc801LF++nNraWmbNmsWhhx66pXeZRCKRSCSSbxlbXbhdsGABTU1NHHzwwZv0+UmTJqFpWtHfMpkMq1atIhgMFgZqG8OSxjYeeG8hkUSaIZUlhHwGKdNicWM7jdEEs2buwnZ1NQghSKfTBINemEL+53wkwaYue+GFF9h7770Jh8Psvffe/O9//+M3v/kNABdeeCFLly7l1ltvBeCSSy7hjjvu4OKLL2bVqlVMmzaNX/ziFyQSCcCLQggGg6TTaQzDQFVVgsEgb775Jtdeey1X//nPjN52DMuXLeUPF1zAnnvuyYwZM4r2afd+P/300zzwwANcfvnljBw5kiuuuKJo3YsvvphQOMy///MfVEXlb3+7nquvvpqnn36aW265hcMPP5yf/exn/OQnP6GlpYXf//73XHzxxXz3u99l5cqVnHvuuTz99NOcdNJJve63QCCAYRjYtl04/o7jsGDBAiZNmgRQ+Ln7so1Z96te9m1vfyD3bWu3P5D7trXbl33b/O0risqatigfffoZO0+cwNCKUj777NMNLvs27JutvWxrt9/9+I+orkBVFbYk+fYlm4emmMs7K22yNoQM0A0F24W2pCCW0gj4XQaXfTVOamvWrOGOO+5gxowZhEIhzj//fGzb5r///S8dHR1cf/31XHHFFVx11VW88sorPPzww9xyyy2UlJRw++23c+GFF/LII48UbbO9vZ3TTz+do48+muuvv57Zs2dzxx13cPjhh/erT1dddRUrVqzg1ltvpbKykrvuuouLLrqIF154oWg9x3H4zW9+w0knncR+++3HwoULOf/885k4cSITJ07cXLtI0gUhBJGUIO6GiKQElV9BlLjk6488byQSyTeBrS7cvvHGG+yyyy6Ul5dv0uc1Tesh3GqahqIohX8bg+sKXliwjEgyzXZDqgufLwtqlPh9LFrXzIsLljFucE1hWdc2ure5McsA1qxdxyeffMKJJ/0cUJg5cyaPPPIIH374IWPHjuXll1/m7rvvZtq0aaRSKS6//HIWLVpEWVkZhmEQCoWorKwsCLd99cHwBzjvjxczadc9sGybKbsNZtx24/li8RJmzJjh7QshMB0X3XHx6VphO4888ggnnngie+21F6FQiKuuuoqDDz4Yy3VpjiWZtvueTN9zBoGqWoI+gx8ffQxnn3kGiqJQWVmJqqqUlJRQVlZGJBLhvPPO4+ijj0ZRFIYPH85uu+3GkiVLsRy31/a7fp/ux7/7zxv6fSAt+6rbVxSV+o4OVrYnqO5IMLK6kvwqG1p3WEXZJrXR389t7X0zkNpXFJV10Vifx+mrODfWd9y+iuO/qe0Nr6ygviPxlbU/kM6pTT1vVrR28OKny1na2Epjaytz6xOMGVzFSN2iZD3LdvoSfet+nLbEvWhzHZst3f7WuN7Xt0wIhXmrGvhgVTPL7S+ob0+wvDlSOP5j62o4cPJYxtVVIxn4CCH4rMEha0OZv3M8ZWhQqgpiacHnjQ61pVtGjL/66qv561//CoBt2xiGwfe+972CLdicOXN47733KCkpIZVKccUVV3DEEUdwwQUXUF9fj2EYDBkyhIqKCi666CJWrFjRo40XX3yRqqoqfv/73wNw+umn8/bbb/e7j9/5znc46aSTGD58OKFQiJNPPplHHnmEtra2oneVeDxONBqlurqaoUOHMnbsWAYNGkRNTc2X3EuS3miKCxY12bSnXFLWUNqWOlQEFXR3y6lwQgja0xQEv5qS/tnvbernvikMpO+/Nc4bycBCCveSbwpbXbidP38+U6dO3drdKLCuPcaypjaGVpb2EH0VRWFweQlLmyKsa48xvMp7YRMCLMfxREbbwad3vvj0tsy0O38HMB0XN2OSMi0eeWI2Pp+PsZN2oiWeZNJOO1NeXs4TTzzB0UcfjeM4TJgwobD9XXbZhe985zsb5eWbtWyGbDMGU9G5/+47WbFsGSuWL2PdmjVM2203kqZNxrJxXEEklSVuOvgNnfKgl6q2bNkyzjzzzML2xowZQzAYpCNtEU1l2P+HhzJ3zss8eP+/WLt6NcsWf9GnZcXo0aNxHIfbbruNJUuWsGTJEpYuXcr3f3AQTR0JLNvu0f76cF3R+dIb6WBkdWW/98u3iaVNkR4CzNi6Gr4/cdt+rVsQazayjb4+93U+bq4rWBPpKPQ9L+RsDtZEk7z1yvssa4ps8Dh9Gbru//jiVcxf3cyypraNOt7d+aqPf/f2nlnWRtZx8esaqURsk7/H1qb7vhleWcHa9vWfb5t63qyJJnlnyUe0pzLUlYdRsyHKwgE+XdvM/+uIUrm6A1eIHsvmZ5LssEOE8UMHbfD7dO/bM8vayNieL30iEee5FREmjxzCAZPG9Pjspt6LNpa+runN1X5f5/tXdb33lzmfLefeNz9hZUs7sWQamyUEDJ2po+oYWpo//k3Ut8c4ee+pUrz9GtCeEkTTgpBBr2Ncv+6t054SBLaAdnv66adz8MEHk0qluOmmm1izZg2/+93vqKys5N1338V1Xfbaay/Ae9lWFAXXdVm1ahUHHnggjzzyCPvttx+TJ09m//3358c//nGPNpYvX8748eMLmVrgZeelUql+9fHwww/npZde4r///S+rV6/ms88+A8B2BXaXoWxFRQU//elPufjii7nllluYOXMmRx11FGVlm28MsKX4ugkZCTfIe6scTEchqIOFiU8L0JYUWFYdTXHB0IrN3+brS12iaVEQ/CpDgu0Hr//C2NTPfVPY0Pf/KkXd3s4bQw3QHBdY5lAGt7iMHzwg6rRLthDfFOF+c103X8Vk1Nft+fJ1YqsLt0uWLBlQflCJrEnGdgj5jF6Xh3w6bakMiawJeKJrIp4kbVpYto2RtQn6DEI+g7Rp02HGsR0Xy7aJZu3CQNS2bUQy621UCFwyKIrCqy+/SDab5bDvzyy06ToOzz//PEcddVThb13F365CcZ7eIo0dx3s57khnee+dd7jyogs54AcHsev06fz81F9ww1+vwXEF7WkTxxWoCvg0FVVTyVg2luMQ1osfcFnLpiOdRdU0TMfFtGwuO/c3JBMJ9pq5H9/ZY08sy+SaS/6IENC9W4sWLeLYY49l5syZ7LLLLhz7s5/xz7vv8TzXNBVF9Gw/oPb+kB1oL72bk80pDvYtzjSxLtLB9EGBggixPiFnfWJNfz43rq6GNZEO3lndwv9Wv0FLPEXT1+y4bUkhaWlThGcWrUUNhBlSUbLe49Qf+iMWLW9opOPtpeiayra1FYQNHVWFd5et5a1MisqhI5gxfvQG29qY82ZzXLfd20t0GKxqj9GRzFARCjCq1EfFJoiMW5veRM6uYvTr6+IMKgtTTZbqkZ6o++aSVTzwyUqMYIhtB1Wi5gS2BWsa+aK+hR3LdapH9hTHXVfw7upWIq7G+CGeFVBSVSgN+AnXGsxeVU9L1uXASWOJZ0ziWYtSAWNrK/lgcZQXFyxlTG11QVSubIuiCKXofOt+Tic6DBY3R2iNp1AVhaCmkHDaWdHawcJ1zRwwquJL34s2lr6uaV86xsolbV+6/d7O9zGDq6kpDfJkL8dtU6/3L8v7a1p56PP5JNJZKsMB0pkMrgvprMUHKxuYOKiUYUP9lAUDLG5s44UFSxlTW7XFbRMkX46sDY4r0I3ej5OugmV76wV6HwZ/Kaqqqhg1ahSKovD3v/+do446ijPPPJOHHnoIx3EoLS3lscceK7IUUxSF2tpaXNflf//7H2+99VYh++yRRx7hiSee2GC7eR9d6Ht8nOe8887jo48+4gc/+AE/OfqnlFXVcPLxP8USBoms97Lq4m3jsssu49hjj+W5555j7ty5PPzww9xwww3sv//+X3ZXbTG+bkKGEIIWuxpXhbIAgIKigKEp6KqgJauxsNFlSPnmEwCb4oK1Vh1GUhA0OoXi1qTgvVUulX3sq0393DeFDX3/gF3xlYnavZ03DhrxLFgOWPh5d6XLug6LHaR4+41ka0z4bAk212RQwg3y2lKHtiSkzeE0LXaoKXEL539f4uzGTMYsaXFZF3VoTYpCG9VhML7kvW99wvGmLvs6stWF29bW1gE1O13i9xHQNVKmRWmgZ4RnyrTx6zolfh9ZyyaSymILAIHrCmzLJmlaKHgni6qoGLqKgie2Oq6LmosCyI8dHddFURTWrVrF0sWLmXX2r9lp6i6oqhdp0NKwjsv/eCGrVq1C0zTe+fBjxk+YhGXbvDDnFf59z108+uhjRYPR/CA1mUwW/rZmzRoEntj6wjNPc9Ahh/Krc8/Dsi1UFOrXrWXizlMLom1+e5qioBk6GdMm6dqMGzeOBQsWMPU7u5LMplizZi3JRAIFWLdmFZ/N/4R7HnuKQTU1KAo8+dijXl+yWUoC/qJ+Pvnkk0ydOpXrrrsOgOZYknVr1rDNttuiKQpuvv3cMXFsB62XQffmELnWJ45uyajKDbE5o7zWtHfw/BfrSCgGO42sAyiIM2XBAF80tPJuJsHBrndjyws529VVE0tniZt5saaqINaMq6vpdxslg328/0WUB96eT1VJmI9W1rNgdQOabjCkIkyNz8gJbFtHrNgYehOSSkN+3lu+jrfSyR4i58ZElXqWLUuJZSy+M6oKRVH6PE5az3mbXvv65pz3WLCmica2SCGqcfsh1YXrpq48jOUIsrZDNG3TEkuiKQKlsQMAy7L481Nz+WSnpl6jIQFs2+WDVet4eP5KLM3HrtsOR1F6Hv/8ebO5rtuugqPrujTEUzhCZWRNOZFEmvp4mu1G+RhcFubD5lYeefdTLvjh3j0mkr5KNnRP6U3k7CpGV/sVVkc6eHf5Ohzb4rW1HaiKwppIjGgiRXVJllg6SxgHx58hmsqwqjXKR8JlUdxhXDdxfF00xtpYim2HDymKVANIZC1cIUibFm8tWUMya5JIpliVMKkMB/FrKh+ubODPz8xlVWuUlQ3NOO8uBRQ012H0igiTRtQRSaYK5zTAivY4kaSJoWu4jsAVgtKAn0TG5JM1TShmioP3Kr4XdReVu59T/d33fU1i9CYOL1jTxLL6Jupqqpg2eugmt9/b+e4qMHveQlriSYTjUlfpYNkO5arLsE283r8stu3yzMK1xNMWo2rKMS0HyxGE/T5UVaEjlWVxa4ydxgp0XWVoRSlLG9tY1x5jRPWm2V5Jvhr8Omiq52lr9HIu2S6oirfelsbn83HJJZdw4okn8q9//Yvp06cTj8dRFIWRI0eSSqVYs2YNN910E1dffTVvv/02kUiEn/70p+y66678+te/ZsaMGSxevLhou2PHjuVf//oXjuOg5ib6P//8c4YNGwZ44+OuY+NkMkkkEgEgkUjwzDPP8PDDD7PNmHHYip+33njdW1Hk5VqwhU5DYwt33vEPLrjgAmbNmsWvfvUrZs2axeuvvz5ghduvo5DRnoaM8FOeixLv+mxSFAUdm2jaixIv3/iyJj0QQrCw0cVBo8qft5jzhGJDg1gGWuzqQiDOpnzum8iGvn8kBRG7jnDSi/jf0qJ29/MmY7lkhR/F8e5xKi6uq9IcF8QzzjdeVP+2sTUmfLYEfU2GtCRcIkkI25X9imptigtWW8Nw2r1scAeNVBbWWIJI0qG0j0mV2lL6PRmTMIexbLmLEN415ubaSJugiWE0xQVDyoujcfsTudtsV/LiIoe0RZfJRpdhFUqvy/Ki8jcx+2GrC7fz58/f2l0oYlhlGWMGV/Pp2ia2q/P1eCg3dSSYMnooQytKaYwlyDoumqKgqipCcXCEJ+CCABQMTcF2XBzXRVNVfLpG1nIQCAK6VrBSQMAbr86hpLSM7x/8Q0KhEK4QCNdl7HbbMWbMGJ586in2O/AH/P26a/nNeRcghMvdt/+D70zfg9ZECn8gwKpVq2hra6Ompoa6ujruvvtuzj77bN566y1ef/11xm+/PQIoKytj/vyP+WzhQoSAxx/4N22trWSzWVDyvS/G0FWypsUxPz2Wq/50JbXDRjB05Gj+8X9/Q1VVFAVKSkpRVZU3X5nDrt/dk2WLF/HgvXcBsLa1naqyUgLBICtXriQajVJRUcGSJUuYP38+wXCYe+//D4sXLWT48OGFdm1XkLVtbMcl47jYtkU8Y9ISS7ETm0fkWp84WvIVpef2xuaKMstHec1f3ci8Na2Ul4SwHJcxtZ3ioaIoDKkoYfnaBtZFYwCsjaWoqqrk/RX1RBIpEqkUq+ImVeEgfk0r2IYMrSjpdxt+TeWVz1cyqqaceCaLrirUlAbpSGWJ2ha1tYPYrq76KxcrNobeohMbTJt1DW20J9I0d8SLRM6NjSr1LFsi1IT8PaKDuh+n0YOq1tvXpU0RHvxkBS0ZF0cIMpksCaed5S1RL8pRcdhr1AjiGZP2VJas8NozHRfbcfDrFCabYmmTD1aso7491kNUfX9NK9e/M5ulTRHa4kl8hk59NMFOIweTH08oikJNyM/SpghrIh39vm67RvF1FzyFS5HgGM+YxLIWlWVlqIpKScBHc3uMt5asJmVadCQy/G/+UlBUfrzrjht76DcLG5qM6X5PAzrF6Opy1kZiNLRnqSgJUVsapr6tnYX1LV4mhu2gKdAQS7IumkBB4GvqwNA0KsN+rKyJoak9xPFkxsJ0emabCCGIJNOkLRszawMK1SUhFL+B3zBoiSXJZLJk3QRLmiPeZGMsiZN7DGoqpFxY3BjBtB3GVYZQFIWOVIbmRBZFVQkaOo4myGRNQFBdEqQxluDTxihr2j1Bui9Rues5lb8XrY++rsX9JmzTpzhcVy74YNkaynKZNl3pb/u9PacaTJu1UW+/WLaLX1MI+gyaY0mabIuaQWmqS0KUBAwW1Uf4YOU6dhszst/n2aby4ep6GhNpqstKURUVR9i4QqDmPPKDPp1E1qShI86I6gqCfoPGjkQhE0kycKkMKVQEFVqTgjK1p/CUtWFQqUJlSCGd3vL9mTBhAkcddRS33nor+++/PzNmzODcc8/loosuwjRNrrrqKioqKigrK8N1Xf76179SU1PDNttsw5w5cwgGg4wePZqFCxcWtnnAAQdw++23c9VVV3Hcccfxwgsv8OGHHxaE20mTJnHjjTfy/PPPM2rUKP75z38WBF6fz0cwGOTFF1/kB4eWsWrVaq7/y58AME2zMNknAH+4jJdeegkhBMcccwyxWIxFixax9957b/kd1wsbiizaHELG1kiBNW0QKOh9BEWquDiuFyW+OcjbiejYvY6/goagI+unPQ1VoU373KDSzdPXgcT6vj+A44KLSkD3zrktLWp3PW+EECSyud8VL/tTQYACQcNb95ssqn8b+aonfLYEfU2GuAJsBxI2dIg65m4ga0IIwUdrHbLCQMXLrBGOi6Zq2C7E0hCjjpJukyotCZe17eAKY4OTMUEdHFRycV+4wrvGVMWbELYweGu5Q1Wof0JqPjOkOe6SsIegxMCngSq87Jg1UcHKiMAVQ1C7LPNp0JoUvLXcJWMNw/8Ny37Y6sLtQENVFQ6cPJb69hiLG9sYWlFK0G+QzlrUt8epDAc5YNJYbNclmfFeUjTNG024LggECuROXIHpOKiKgisEihAU7hvCm/EQdN5I3nx1Dnvv/310n8/brqpguV6k7o9+cjTX/uUa/vnfh/nvv+7hvF+fja7rzNj3exx/ymmYtsP3D/4hf7vmambNmsXjjz/OJZdcwrXXXsvBBx/Mrrvuyumnn85rr7+OKwQ/PuEkbvzrnzn3zNMIh8PsMn0PfnDo4SxbshgFChHDjhCorkDTlIJ4c9Ahh9DeHuGmG/5GNpvhmONPZNmSJQDUDKrlF785h4fuu5f/3HUHQ0eM4JSzf8ON1/yJFUuXEJo0mYMPP5I7b7mJdevW8Ze//IVPP/2Un//85/j8fiZMnsLxPz+Z1+a8jOW4ZGwHx3JQFK99NxcJbNoOzy5aS2ndakYPqtwkkSsfdfXO6hYWftqAZbvUVWwZX8eNpXvk6pQRg/tMT96YKK+g38Cva4T9PppjSeLpLMNDOnW5dYM+A9NxiadNmuMJGmIp6pMWroCSgIHiM/AbOs2xJK5l4voCJLJmv9sQQtCSypI2bcpDARo7EoQNnYDhbbe+NcOypgjVJaGNEie77revwiu3e3RiWzzF4tYYim5QEvBTHfSRsW0+WLGOheuaaY9GKSsv7zOqdHK3fqeytmfZ0osNCnQep2TGWm8/XVfw37fns7QtQUkoSGnAj084+AN+2pNpWuJJBof9gELWskmYNigqjuuStRzvvoWNT9dwBKRMiyEVpUSS6SJRfc5ny/nXh8uxhELYb+DTVfy6Rls8xRuLVzNxUCl1uZPMr2ukbYflLe39vm5HVHlRfL0JnmVBP9G0WRAcvcwGgZG7L9uOS0fWQounqC4JQcAgg8rn9c3cMzf7lUd15ydjIsk0JQGDsKGjaQoL1jQxP5tihx0ihPy+on0TS2eJZS2CgSDronEiqTSm7aCkMtiOQ8pyyTouPkNDCIEtQPdu4piuQGCjKQqxtIkqXAxNY7u6siJxPBww8GleZkO57g0NYhmL1SvqaYzG6chYgEKJ38EVXuaIT1MJGTpr2jpwhCBgaCSyFrYrCgM8y3FJmxZBn0EkmWadJpgsoD2ZwXQcyvwGiqKgqeAicHKfLQ8GqG+LsqI5Sl15Sa+icp78ObUh4TB/n1L8IUqDvi773rORqG+NMWnbET0G+ZbjYqgqiYxJLJ2lNODb6Pa7T8YIIVjbkSQtVO8czh1LIQRhv0FjMsUHK+qpCAVoS6Rp7Uhw+yvzeH95A1NGDqZ1M2aGdP9cSyyF5QiCPgOBwHZdRG4841d1DE0jKQRp01NK0lkLv+4VcJUMbBRFYcIQjXdW2sSyEDIEmuqJKikLfJrCjnVar8LLluJ3v/sdL774In//+9/561//yp/+9CdOOukkNE1jxowZXHzxxQDsvffe/PKXv+TPf/4zra2tbLvtttx66609ihuXlZVx5513cvnll3P44YczdepUDjvssEKthd13352TTjqJSy65BEVVOfHEk2hubgY84fbaa6/lmmv+wn333c/QYcM4+dTTue2W/2PxF4sYM3actx8BVfdx0823cs2fr+Loo4+mpKSEo446iiOOOOIr23d5+hNZ9GWFjI21WNhcIq9P9wQA2wVfL+Kti4qhbr4occ9OxBOEe0NTPQHQtDfP574prO/7W663DHoKo1tK1O563qB49ggKLoqSH1crKHjv2t90Uf3byFc94bMl6G0yxBYa0bSnM2kK2DkbyvVlTUSSLq25mvX5TBsF73O6ClkH6GVSJSgEiYy3zHLBpxVfv10nY8CL4vXW9q50FxVb5K96lWgaEllBWQCM9Qip+cyQrJ2/bgV6TgB28GNmPA0tLxLnl7n4KRFQYgga457gXKZ737k/E0W9TX5+lWOh/iCF214YV1fNyXtP5fn5S70CPR0J/LrGxBG17D1uOOPqqolnTGzX9U7OwuyCJ8N2PRFcV+DmTlnbe2oVibWIzujWm+/9NwoKjvDWU3IPFVcIjvzJ0ex78KFkTYtfnf8HfnPBHxGui6KquEJgOS677LEnb7z1//AbOkIIpk+fznPPPQdAKpUiFAoxa9YsVrS0U15VzZ+u/7t34rtuLtpAkMmJNb++4CIc1yVtOZiO5zdraGpBQD3u+BPY9+DDCAX8uK7g4B8dgyu8VNcDDjmU/Q76IQLvgSgEzJj5PSpCQTRN5eDDj+KwI45kaFUFigJ/+ctfCIVCWI5DYzSBadv86IST6UhnvOhlxYv403MREVbOcmJ5JMmfn5rLd7YdTmsiTW1veX/0LnLlo66WNrYxb9kabEVjVE051aVBtF58HX8w2Rusf5n03P7SPXI1GPCzoiXqCfnZbFF68sZGecUzJrqqoCoq1SVB2uIp1tom43KnZNq0sByX2fMWsrIlypqOFCgqVeEAIb+Oqij4dR1ficbq5hRt8SQBQ+fpDxf1q414xiSaNgnnLDNsx8XIRVMqKIQMnUgyTSyd7bc42X2/bQ6P4+5CRncBuGt0ohCCpc0RsrbD0PIyFEUhq6nYikpdeZi3l64lk81ywPChlPj9PaJKX4xGWGW+x/KW9kK/B5WVeJGTOSEnv99C6SzloQBp08KnqYQ3YEK4JtLBO0vXoipQHfa8Ai1Fwa9rlAX9NMeTRFJZYhlPRLMcF4FbNOxWVRXLcXFdl0wu8r2rqDq8soJ73/iYlGkzpq4ay3ZpiyUxNA2/oRelVauqQtZ28Ps1FMFGidN9RZ8va26nKZGmPhpnVE0lPl3zrhXHExdbEylcIagKBzxvWAEBn8bY2ioaOxK9RvVuKhsSzvKR2qtTXnbGipZ2EskUJUmLylCQVCrNiwuW8r0JY4r2jWk7ZGyXVCKF6TgIARqgqSqxdJaUZaOoCj5NIYM3UagpCugalmnjuC5+Qydj2SjC9ex7uonjwyrKGF4WoiGaoCwYIJJIs7g1BppeGLioCmRtm8ZogoAKUTNOLJ0hm3u2tSRSmLbXPwWBlrtnJzImNaUh2hIKTYkMHekMKdPMRQ246JrmWfSgoBWOgzcJitK7qNyV/Dm1PuEwfy9sjKcJORorW6Od+z4cJJbO0taRZHvbO9dj6WzhmjNyz7+s7WJ28cLcmPYL/vm5Y9o1MhxAV1VStkVjRxLbdUlnLSJNEcJ+g+qSICU+HUNTmf3B59z/5scEVMHIxc18Z/RQRvudTc4M6W0yxK9rKEA0lSZru6SyJqbtknWy+C0bQ1O9aH2fN9aoj8aZNGIwwyoHju2VpG8Gl6lMH63zWYNDNC1wLIGmKtSEFbattBlctuFCsH1h517kbBd0tfil6JVXXum1QFi+MFl+nPq3v/0NIUTh964i48knn8zJJ5/cY9mhhx7KMcccU9jmhAkTeOSRR4q2A95Y2HYVTv/VuZx69rmF8e/xP/8FiuvVndhvv/3Ya5/vEc846LkJwEMPP6rgg/vexwtzNSNgwsRJPPjggz3aAO9doHh/dH7nzRm52l9f1S8jZGysxcLm9NGtDEJAyZK2ghhazxdtG53BQS9K3HVFH1vpP56dCNj0vqMc13u++fTN87nufF0L+xR/f4HpgCM0TEfgCgrjyt50kC0hanc9b3y66CEZCzwRx9DygVffXFH920h/J3x82qZdb5vrOl3fdrpPhgghMIVRyGZT8JZrCgT99Jk10Zr09oPSy8SJKFyPXrBg/umftQUd6fx1q9GW9KJaFeGNYbtPxpiOtw3y/wnvh+63ZMeFRBYMtD6F1HxmSNDwbBYUXFTVe2+0UXFc0DVwndybguKJt6ar0JH27jGOAFCJpIr73ddEUV+TnxOGaAwuGzge2FK47YNxddWMqa1iXXuMRNakxO9jaEUpmUzaK8iVyuC4AhdwcAoC64ZwXVFsQ6Dkf/b+mo/Y9f7irasqihc5ZTsIQFc9SdfJCZqqomA7DrbrRSutD8vpjF7NWt4gVAiBkvucF4IvsBwHTVXRcqmRtuNi5l46DU0lZVoIPKEva3sRWEKAIwT511olF2kMoHf1381ZLlhOcWE1I5cPn7ac3EyQgqJ4+8UVuejlnI+DoihU+A2asjaLGlpo6kiilvoZ1st37i5ydUZdhdFUMF2X0pCflliKRMYsRIfmfR0d1yWeMQtRVnkhzaeqfLK6kTWRDoZXlhaO75eJ+OweuaoqCsmst48DukaFTyOQS092LQvXF9yoKK/SgI8yv0Eik8WvhygJ+GiPJYhnPEFwSWOEaNpkdWsHuqagKt5NPZExMW2HMkOlBArHQAAN0Tjz1zTh01TiGe9aybfh04P4dI3WeIL6aAxD00hbDiMGhakMB9A1FafLSMnz3vOONaYoHLeN9QPt9KbsLMhUOaK4WNLwyopCIaUNVY7vLgB3FZLApj2ZJmR0ClyOK7CFw4I1zbTGU9i2w5tLVjO4LEy56lIHhZTjt1dEiAmdMbWVhX6vam1nbSRGJp1ibdohnbU8m4qESVVJCE1RGFUe2mBE3fKWdqKpLOEufSvsa0XBUFXSpsW6SJzqkqB3vgvvWszf11RFQVEV0o6D5goMTSsSVT9cVc/K1ijlfgNVUfHpCn5dJes4BBUdn67RkTFZ2hxhbG0VraksM7YdxTa1lQR0jWy2pxAGxdft+gpnTR5ey/KGFj5d28yIqvKic1z4DGJpE7+mAt4LfsqyGVlZTnkogKLQI6p3Q/R1Li5tivDCgmXMX9NIY2sb/1sRYVRVOTWqWSgGti4a44vWGDEHHEfg01WvAKSi0BxPYpsmH65sYLexI4r2jaGpnsWOouIzNNKm7T0xFO9+6mZBcz1PdZT8TLToMvnXOXEIFEZqXY+jqirsNrKGd1oyfNHQSnMsQTxroeqCjlTWm6BUvPtz1nKIug6KomLbnccvk3um5M80Kxfh5toOLbEkQZ9GLJXl3aVrMW0bR3gCqWk7KKpCQFfx6ToCr80Sv862NVU9ROWuCCEK59SQ8lLWRKK93ifWtcf4aGUD0bRJ0kl6fut+A4HCFw2tZCwb07Z5fsFSgoaBpnVOlFWEAmiKN+lgdCuO2bX9YZVlCNF7tFXePz9/TLtGhqu56GTTEaQtm6CueWNeIXAcl5ZYisqAzsL6VppiSSzbu2e2phv4bF0ztUEfYzYhM6Qvn+6lTRGyjsOatjghn47f0An5dLKOIGPZpLKCEr8OAhY3tFFd6mUiycJkXx8Gl6nUliq0pzx7BL8OFUFIp/s3UdodF5V4xnt+uMLAznqRvAF9YJ0TLipJUxQ8+JTcmNt2QQgDy8m98OctEXopqgvey6KqeNvoDcuBjC28iKT8/lBA5FJJ311p05ZRv7SouTG+ql2FDEMVmI4oCGs+re/I1Y21WPiyPrq9CRmD9Dba9QpiWQjqImczJ0hboOOwQ5262SKj8nYi69J6rz62acsTBCsCYSKpzuis6nD/PlcZ7NvO5+tWOK4r+f22JuWjNZGLjhMBzGTO79IFDRdfL95nW0LUVhSlcN7kb2tecJUn6igISvxe0IjjikL7X1fh/OvKltrf/ZnwKdfh43UO0ZTYqOut+3XausQh7ANyfrO92dT09h03dL13nwyyXM83Nm/3kR9uKsqGsiY6laUe9PKnfFRv19cGBU+cdYWfrJ3TZvLLlOL1hCjebEHHxZvAdAWYwgcIFEUtElKhMzPEFUpRsGNOqeqty4U1sk7xc7l7vwOG0mOiaH2Tn++stJk+Wh8w4q0UbteDqipFhTaEEN5LbjaFlbNAECJnjbA+wbTLGZuPDsgLtJ1ar1L4WaFT/FHAEzfzdgtdlhc1oSiev24fL415HFes18PH62rfF4UjBC3xFFnLxrQdbOHkBr7eJ7t+TuTe9BXFm7FJZk00zUuhFrno3O6YORGg64AnH48phEAoAjU3y+QJiyrb1lYSSaRZFokzqVvknBCChmiC4TmRKx911RRPE3RUGjoSRNMmpgshn4Hp2GCrjBNd+oJSiLLKpw63J9PEkymIprnr9Xkct/tkrwDUy++xYF0zja1tPLeynckj6gqFnDYk6naPjo2ls2RtF1SV8qCftGkTN22qdY2qcJA1rWla48k+04ehZ5SXoigMLw+zNmUTSaYJ+gxs16U9maaxI0EsnUVTFDrSGRo6EpiO6x0/1/XSZR2FsG2TzJgEdZ2Qz8d/357Pp2uawLVpSjuE/AaGphI3BUub2nFcl4xp8u7SdeiagqYoDK0spTwYoDIcZE0yRUVukOu4Ak33BMX8cUtnbW55+b2CkPr6ujiDysJUk6V6pCfA9uaVatkuHeksK1vaec+2eXJxEwA+4fDMsjayjutFYCZi/agcX+wH2lVIqi4JFUUOCwQdGRM0HdvNRR2qXqp1d+/Kde1xsrbDsIpSSgP+on43RGMkMhYNiSxlQR8lOYFneVOEkqCfvYYN3aBQoojOF1PXdYmkMiSSGWK2wHVcso6D5Qo+r2+mIhQAFHTVi/rP39sEAst2C/cd07FJm2pBVF0V6cByHMKGWjjHyvwGkaxNeyqDK1xM2+XDlQ0sa44wyK/x/UljGVFVzpjBVbz5aSvbdHvJcV2XZc3tlPh0z8M20nfhLFVVGVNVwqq4yfw1TWwzqIIhpSGWdKRZ3BTBsh2EprC6LYqiKIR1lTGDq3LCee9R3bbt8v6KtXywqhmzbC1TRw4F+vam9aVjfDK/ni8aWsnaFolUhpXRFG8vWYNPVXi/Jc3U0UPZtraCpngaoem4QtCesjFNC5/lEtA1LMthTSRG0G8U7RvvvPLE2GTWi4oHSGatwkPExSuemX8W5W168nsqa9sEfQaaUDxfdXpOao2oCLPDDjvw8Luf8f6KehJZC812CQcMNAS6YZAxTdK2l0diqC6apuI4xc+dfJv5R58A716GZ7/TGEsypDxMiWGQtB0SWQtDUwkGPcE9Y1qYtsN2leHCNvOi8uLGNurKwziuIJ7JemJuwMf4ITX845X3+4w47UhlWNbSTtpyqCg18OkaCcclkkqQynrtuUBbIo2mpgn7fFQHPBuXlniKmGkxqLyUpo6kN5vfrf3v54TLXgJygbx/fucx7RoZ7tNVLNvL4FHxnrO263nKekVKBW1Jk6ybAbzJE8d1vImwrM3iZIYOSxQ8m3vLDBlTW100UTWkrLRPn+5IPEXW9jyxk6YLihfRoWsKWdubsM5YDu8uX8c2gyr58W4TGFdX3fsXlwxYFEWhKlw8XtoULAdMYaC43cRQB5KuQO8jAnFrYAnvtUfr0iUld35bDmQsgaF5L5cKopCO2h2B93etj0iuvsRhU+hkbGi3BT7jyxcHiyRdWpMCVbg9Ulm7RxblhYx4NoibFkXCmq6CLXy9Rq72ZbEghMByQRFeHyJJl/LAl/PR7VPIAHYdpbGoyRMlLHyYDlSHFXS3kcGl/Zt47Q+KorBDnUpjxCGehaDRRSi2FXw6BOwEc5dVEk27RdFZg8uU9X6u0m1DUXrP0vs6FI7bkMhWGgAbHdvJ2TV5JaZz0Xj5bRQLPVtS1C5R04wb5Z1za6MCBw3HzU3OiCx+3Shq37TDvLr46ymcD2Q2Vbj8MnQV7nub8FGEIGVB0qLP6617Ia3KYM/rNCO8wlgdGRBiCLHFDoNKOm1q+vqOll3Bmg1c70PK1aLJILegEwG5CYiukyF9ZU3UhL17vOWoPa+/Lj/5NKVHVK9wOqPlddWLak1koTQgctl/XvveY6Fr+GGXvnYhl+CNhYrpdIrTXYXUfGaILYpF3650H64I4T17vf3Q+e6Rf77n++03RNFEUffJz7w4LoBSvyCeVfiswaG2VBkQtglSuO0nIhfxGsuYOCiEfAaOK8hadiESaT1TAAVcIbxZEqGQse2iEy+/LD8w0lUVF0HI53mG5r1yBd7FUoiqUjqjfd0NCLNqLnoWwG9o3awSIGvZniiqqgWPW00I9JxolDEtyJr4db0QEeRdHL23qSoKuqYWopBsx8V2XLRctHBX8oKE5qnT3nfN7VsvZVYpunE5rpfeFzAMJo6o5e0vVjF/bRO1ZWGiqSxuNE4yY1EVDrLboACqqnhRV6saaU+bJBxPuMlHvCVNCxUF24R4JluIBhYIfJpWSB3O+5g6uoara6xsifL3599mXUsrSVfxhMpMhoTTxoqWKAvrW5hS6ePN5r5FXei9IFVe3FdQ8OkamayJaXueo3lhbX10j/ICKAsY7FRTw7KWdpo6Epi2S9qy2WZQJdFUhmg8jhVLoqkqhqqiaRqm4xU9sm1IpE0Gl4ex0ilaEyl0TSHgM7CyLh3pDGvbYziOg6JquELkbBMUVNU7r4KGRks8xcjqCsbWVtEciRJJpgkHfCRNi7qSME0dSarCQUYFBP968+OCkJroMFgd6eDd5etwbIv3W9KMqa1iWXPxfotlLNZGGslYNkFDpymVQUtn0VWVmGXSYbeTzlpUhAKMKvVRsYHK8b0Vy8oLSWvbYwg8H8ysbRNPZzEdQanfE9gTmSyuohDwedGneR9fXVNpjacIGp6lQL7fS5vW0hpPkTGd3DXgRR8mFKgzDLatrUTTVFZFk7nrvVNkzJSuoa60tHNyoKqckN9gXaSDVR2pnBUCkMx63kaKgqEqKEKhLZ7GFV4EoOu4uYhq7x6nKErOf9Tli4ZWykOBQsRvcyyFoWlk7W6KlciLjRR8xHI3De/eoCocMGks85euYElThCEVJTi5aNZP17Zg2Q7lhsLfX3i7h49td2rCAVxfkNGDKogmMzSnMpiWQ8DQvHtq4Sbd2T70FC7B8+u9981PWNnSTjKd4YEFaxldU8GOFT4S3UT90pCfd5etZXF9E1knP+HmeN6fCqgomAjq2+P4tCY+WlFPR8ZC0VxUxYtsVnQVTVVJmTa2baOmMqSzVtG+8RsamuqJZZbt5Coie/fDvAgrANvJZSvg2SjYueOtAGG/j8pwgHQ6U7h/dJ3U6krWskmbFkIIDFXBr2m4moZQoCTgI5vIoAClAT8giKSy65vPB8CnqcQyWVRgdE05GcvGb6iYuXPcdlxaE1niWa94Z9hv0JjIcNVTrzNpxGBGGfDzvXbuFM7jaVx/hknDazHSMV75fEWfRRxDg5Yz57MVNHUkEMLFaY8T0DUS6SypnD1Qvt9eX7xJL0W4lJZ6D1tNVdlxWK13v2lqK2p/hG4xdvD6fbhdVzCkooSU5fDe8nWMr6umxG/QnkrnorNgUNiPqhvEMyaOK9B1ldJgAEOBVW0xFFUhqOu556OLoanomkEmbhNJpuhIZykPdqa55wunfbiygWueeYOWWKIgateUhviii6dvV59uQ9cI6CqO8CaEExkz9yBS8WkaleEgwrGZPKIWV3jXzKiaCinefgsRQpCxRC4brPPv+Zclx+0US7c2di4dujchFnJppyKXeqqCodjYiif05OdIvXG3t27AUHpMJEKxOOxFHnkf9h6BXpBG2Aeu+uWqnDfFBR+tdXNFl/zYyZyXn+iMaOz6QqwoCiVqgga7oosg7Qlr3hBRY3BZz5fT3iwWbKERSXlit4MfMwvvrHQYU6Nsso/uhoTLccC+2+m0Jhw+W1TPhLHjqAzCJ59s/ip6g0sVhhuN2OGxRNOdQnFNWKG2VOGTlZW9RmfFMoJqrR0jXNLjc9sPVmlY1ntfN6Vw3IaK0W1u1ieyNcUFCxst1kZzWaXCE13IeV4GDe+6sWzlKxe1B5cqDCk3+KLJ5v3lGXRfgBIfJBNODzH+/dUVA1o4/zryZYTLL7u/88J99wmfqhC0Zj0Npuv1pqsQ0CGV0XlvpUNpoDh1vjwArVYtau46zdqQxY/i5oVRgWlDa9LlvVUQ6OM7tiYESXswATNf4LCv610rmkTK34PdnAakKmAoJuBlBPeVNVEVVqkJQ0NM8aLNBTgoKG6nT6yKwFCLo3rVXGSvp/XkbQ+875jIgqGC63jXsk8DL1ezW1Zal58Vuk/aeP/nhVRddWmIgSNUEiaU+L2J1Iyr9hBqu0w5oxQCDnPaSUGTywcWetu3HDBtQabLRFHeR1gVbuczLTehaWjevSqa9vyGu050by0GxmhqgJPJWSOkTYuUaaNpKknTi4S1HKfPKNauYmMeLWdzYAsXRH4w2BkVpakqPlXBZ3jCsKYIyoN+VDUn3JlukcUBrpsT9rwTNV/9u+vLW2/k21MVBZETUfMvr6riRZ+6QmBaFj7Di6BM5qwDfJqW87OlIO4URRR3/R28SE0hUBQXFU8AUlWlUDwIPKEgkkhhu65nGCGKe9ubRJmxHarCYcqCfoI+nfKAQUc6y+LGNlLpDKHWBGNqq9h7+1E46ShrIh0kMjar26LYjsvgkiAIvEg3IQgaOmnTImE6ZG2H6nAAVVHQVJUSv8H79S0FH1MUaLUdRlZVMHHYIB77YBHtyRSDSsNUlQTxCRd/wE88Y/LBinXMW+ZQEgxhOg7pTJqo6flbLqxv4YCR5exEz+hYy3HxGxouCmnLQs/t97Rpk8iYhAyd6tIwiazZp41A9yiv/IC8qiRIVUmQj1c3UlIV4vwf7kXStHnl8+WkTRuf4tkAWI6L6XqWBXkBfsLwWkZWlfLkB58TDAbYddthzP1iFUvaYxi6jl/XiJkWqlAIGJ53ZW04wL47bEtpwGDuZ0uIpbMsbmijriLMmKpS2mxPRHIEVJaEmDRyMN/bcRvue/HNQkRYWzzFskgcRTeoLQvT0t5BezLFZ2stlje3M7o8QE06S4nfVyj6UxUOsq49juMKKkIBgj6dL+qT6I5X4C2STFMfT7PdKB9hv4+WZJZAIN3zAaH0LJaVj058YcEymjsSNMaTaD6f50GbyVJVEsKX8xJVFMUT6ej08Y0k0p73Z9BHacCPEIJlbXGaUnmRxItYKA34vONgeyL0LtsMo6EjxqL6Jm5/9X3+35K1rGyNEkum4d1l+AyN6oDO8GVtZGyHlniKlNUzEl8IsISgKmgwvLqcde0dBQEt5POhKBBLZ72UULzht0/XqI8mSJs2ew31In6njhrK6JoKPlvTSI3wInNjWQuhKFQEfXSkTUp9GvvtuC2KAh8tW80j737KeQfvhd/Q2HloFRH8tMRTrIjE6TBj+HSNnUfXoWZSvfrYdidrO9SUlHLK3tNwXIe/Pvoi5WUGk4fX8taSNaxtbWdIVRl+Xae+zSuKVhkKFKJ6HUewurWDZxau5eUVLWRMm6qSIGFVoPp8fNHQyierLMYNqWHG+FFF0YlN0ThN8WwuO0JFUZXc5JeGi8C2XRqiMXYdM4zFDa1kbBvNFVSEAygouHj+3ZpPoS2bxe96+3/s4CoO2X44q22DT1Y1kLE9z96SgA+BIGPahcwPJ3fCOrlJBYWcPY2qYrkuPl2jxG8QT5sEVIVExixMjuQntaAzdX5pU8QTbTUVXdNI5XxydU0lY+W92vNisVt4/nS9bro/EeOZLEIIArrGlJGDURWVxavXsi5pEUtnsWyHjGXhInBdQdp0iIosS5vbWdESZVBA5fIdduCs/XZldVs78z5ZwLQpkxhSVspl/326VxuNksE+Xv+0lRtfepdSvw+frmFb3mRSLG2SyFqesN/l+WJoSk68EcSyFrFUlopwgEqfSjKT5YdTx6MgmPfJAnaePBFFKHy4YAFr1mONM+ez5dz7xscsbY4QT6ZxibOwvgW/qqDpesEP2q8KAkG/l0Zm2wytLKWmNExTRwIX8OdsS1w3Z4OhKIVxhGU71LfHezz7s7bL4nbP+mDc4KrChMO8lQ2saIszdFCa0oC/yKc7bdmAN+kaNjRi6SyOIzA0hapwkMqSINF4kopQkEFlYRY3tvHCgqWMqa2SdgnfMhyXnHde77YCqgKOUHp4vG4NClltfQq3oiDManjRS2GfUrA8yGej6SooroWh5YpBdvGxzY9X85W088KtcIsjjxxR/HtXUTOSdHHF+lOH80JW2sqloQsXVdF6pIR2jyxKuCX49dzzP1eQBrwXfduyaYrpTBhSfPfu7hWZtQVZ4UcppKQKVCCWEcyvF9hC22gf3f4LlxpVIYVSNUVVaP33mi+bgl2ippkyVqU9TUEorg6rvLrYXq81he2WcNgYhWhGLXyupkTDdV0a+mhrYwvH9acY3abS235bn3CaMYfSvNzxrgMBKg66quZsU1xK/SohH15Uou3i173U5S0pandHURTGDVJpWrMOu6SnGD++VuHtRSW49qa3IelJX+dN/4XLL7+/PeFeK5rwEULwYrtedL11nYyy0GlJQnu6uJBWSwKSIkRl7v7mTZopBesCFe9ZEdA9b9aoXUvQJjdJ1aXolyGIZ71Jwe6Bf92v966TSO0pb+TtCPBrXoR7JtWpCeX9viuCXrGyzkkd2HmERstnWWzXn2tO8zIm8CKOhWMRz2qdE5u5yRdNBcPJomrB3DPDs0goDyqMqlL4ZKVFPOsjaICOjUPfWcCF9wTR9fd8BLTLnMWCtAkuBtE0xNLeJKeS+85KrmNKTkTWVC8owum6/3Kb77rMi8D1dKtEFkK+zomirO09jzL40BxvQtOl83lqOV6U7kApYieF2w2QsWxa4ykc18350Hnp+fnIUaCQjto99T8f6ZRfrioKZUE/yayF4oLRxTIgH33qRVAJDN3zP9RzL2e6qnkRuEWRY50DUQEYqoqhaWQs74U+rKuEun0fNxc96wrXe8nPneF5L1c1N02RMi3vhHddbNfy/P6czn3gOHkxVumSjityhWU6o3odkSuSk+u147q5aCGFlGkR8vm62E+4PQKXO+dJRNGCvICcT3luiMZpS2UJuwqG5nlsIlwWrmtmRUs7gwI6c+sTBAzP8zKYE9FQoMxvELPcgj+j7bhEk2nak2lGVoSprKxk/tpmmmNJAroXfZrImPh1jZrSEG8uWUNLzCso056r9m4oAn/QKwjV3JEkZZqkLBdVVbBtB0tkECmIJDPEo1GmTJxIyGcURcf6clFPwUCQhGmRzEVh2a7L4LIwPseHrqk88f7CokiqrunBXaMaFze2URr05aKRvTT84ZVlTB8UYGRNOfNWNhBLZ0nbLpZi4dc0QoZO1vUsQnIuodiOw4J1LdiuYOLwWlRVLURWZmwvVdsSoDgOIFDzDuqAoqiMLA+TVn2MqC6nJZYgYdkMr6xgWEUpmpnme9PG84NJ46nv6CikxwM9CoCFfQaRRJqQ36Y9lSaWTtNmCnRNoTmeYVBFKabjkDK9Ymm65qUj5yPVs7aDoWs0ROO88vlyOtJZUqbN8pZ2jMWrmDCs2BMyn1YfT3cK5dNGapy29y74dZVH/t/HBH0GwyvLaGrvwBUukaRJdUmITCZDezJNScATRDOWTX00TshnMCjkRS2ua4/TEE+BqhEwvOtYeDuNoKFj2TbrIjHeWLyKZNaivi3G5y+9j6pAZdjza3WESzxtE0+liZoOju0Qz/TtgQwQz1qkTQtd8ewPso5LMmtiu6JwXefFoYChs93gKjS1M+JX01QO3nkci+ubWdEapcRvkDRtDF0nblkEfTrblAdZ0hyhPZmmI5HhyY++YN7KBvyGTiIRZ3BVJSOry2nzG5SXBZkyYjDxjEl9RwelAiYNG1TkY9uVrh6jI6rKWd3WTtJyGDO8Fl3XmTCslo54wrvvKgoBXWNNpIOGjgQI8ONy5r+ewXVd1kY6sIV33eqaiqOqlAT86KrCovpWGqJxhKAo+j4viQs8sc91XPTchI+KwFFcklmLaDJDRdiPEKBrKmnL9tKL8K5p03ZyEyQaKdM7ZiMqwhw8eQrvrVjLZ6sbQdMZVlmKaTusbWsnlrUxu9gUeIMVFcd1yDiOd9xy98u17XHAmyF/c8lqxg6u5qjv7EC1FfPuqfnCaWnHK1KY82C13Cw+3bN2CGoqCl66Uf4+HPb7cFzvpa1rX7oj8J4XAU3FdgTVJT5iGQtdVRlbW0XatFja3Oal9/o9X2NXCEoDfuKZLEvbEjzw9nz+8MN9aIjGqY+lGBqN49iiTxsNgIzlEk+nGDeuinXtcSLxBFnLwXE9z3ghvMG2J354grsvV0TPcVwUFVJZi3gqTUPS4p65H3Lc7pPRFIVnPlq8wWKI769p5f75HxFJpNAUBdt1sFxIWd5tMeTznqtZ26YDgS9jUx7yUxv2e1EEQpA2rcLxRXjPUU31zjGnYGfjTZJ2vzZWRZPYjmBsbRWlAX9hwqE9kSaRtXjji1WsicRoT3X6dGu5yQA7F20f8hnEM1kChkHKssm0J/Cr3jNKURSGVpSytLGNde2xInspyTcby4GUlX9pyomTuWCEPHmRdD2JYF8ZXfvSm3jbm2+tV7zIE54zGYuAP4CuQirl9upjq+S2090b0Nt+5295cbgrKi5Z24tczVh9ey52FbIqAhBxvYgkKE5l9eluUQp6QRz0e9/JdATxRIbScBhDhfaYRTTt7xEN29UrUlfdHmIFeBGLFUGIpsDJidhdCwLlbRUsoeOjZ3XyjbFjqOiHALu5UrAVRaEqREEojqbpUeW967pdrSk2Jqt2YwrH9acY3aZG4/a237pHGXYVoDRFEM8YuFmoCEEm91xTVW/sYdoKSRMydj46WydtQnkQQmYbu4wdudlF7fXRmxhfU+KJepurjc1JdxF9S0dVby7y/a63BoMCFcH8ZPPGC5d97e+N2Tfeddw54dMYK77euk5GdSoW3riqayGtoCFImAppEwzdi+BUcFGU/N08n4WsYGiCODr5uumm44nD+WJ94GV3WY43Lu9K9wmuruftB5+vI+kb5k2SKPlJuE6/78FlCq8tcYqu4cqQoLYUNEUUxr0OLhoaigp+A0ppxQiPoDXZGV3r06HED5mURVkoiOVCRzyLzx9i+mjNE4jXdYrKFkZhLN3LEUMI79nojbtdFDQ6MgLbhjRBsLxnmHAdBDouEDfBwEFT9YLliurFpVDqh0wqg6uGC/tKVbzo3xI/JJIZ0MJYjje9qABVIYXJwzoninyaKAjS+fMhH4yiKzkrKLvnM2trIYXb9eClKGcKFbmdnLAIXuRs1vJSOgO5l1rPI0/kvG8BOgVZctFLadPOFRkThWgpTfF8GvMRr94J44mfadsmacdz0a9OQRzWVKVzXTrveZqqoGk6GdMm6dqUC+FF6zkuuu0UipnpqpobXHoz+6rr5iICHUxHFPxdhRAI1/POEsKLvPR8+YpP4O7RVnnyom5hWW5FM1dwJeS3yGQthKIS9htkLE/4yw+c8/f0fKRu1+2OrgxTFQ7iui7zVjSQMm1KQwoVwRAx16XDcsnYXvRsSPFTHgqwuLGNdNbC1SgIz35doy4UIpLMEE2lEXgpybtsM4QRoyvZYYcd+M//W8CShlZwHXTLprYsjGZlWZgTc2zX610qa5HMWqhA3HLwaRppy8IRXqGeUp8fDYFQVJKWiZU1eTed4aqn5jJ5ZB0V4QALW7zo2HyRpbTrMrS8hCYliS9o8N3tRlEa8DH3s8XggE/XqavouyDN2MFV7DKsmrnrYny2roVkOkM4kmKbQZX86Ds7FoSboN/Aclws16VE11AVr5K6z+cVQ0pZFoqAtGWzbU0FHR0xhlaUEktniaWyaArYdE5YCPB8GoVLUzzD3C9WUhEK4HdtAiUGh+2yPaV+g3+98AaftCZo7EiSTGf4oPEtHnznM3YZPZT2dBbb8SwYuhcAs12XSK5oWtDneWO2xBKkLQfTtjGFIGDoZCyHEsMrepQXQFzXoaEjTjp3vKIZ07MRcQWu5bCsKUI8nWVseYC63DmXzkUgz563kNZ4isbWVh76vIH6Dk8ISmeykDBZ3daBbdsEsiZ15aVsW1tJa0srUVelPZn2xCqfj6mjhmA5DvOWrOT95fWsiXSQNB001c1Nvnj3m45UxrsWXUHGNlnaFKGmJIDlehMBmqoRSWRwXc9vFAQZR9ASS1ESMDZcsNCFLxpbqQgFCOgaacct+GvruXtTfiJm7OAqdh0znFg6w/K1Dby1dDUL1rSwtLGVkKHSlLRoT6Q93yXboSTgZ+zgKtqiMRTbKwiV1VWaUiafpVswVJWgppBwFJY0RUik0kzZJswHKxtoiiZIpFMsjWaoLQtTVxKgNesWfGx78xgFWNYcKZw3QgiqSoJsV1PWuf+zFgnLZVBZiHGDq1he34JjWmSyNmnLocTvI2XZWNEEZYZKWAiylnfv7EhlWNfeUfAmHlpeRms85U3MkRNNbQcbgYEXyelFnHmTYZVhL3si5DPQNNUriOW4+FSXkE/HymVYhHOFEMGbfKkIBhlUEsBSdSKpDI7jEMva3kSc4s2Kq7nba94uQVMU9FwVAEt4/uc+TceneZNbjdE4T8xbVIj4zxdOa8k4tCfThYhay3GxHRNVgbRpE/bpGKr3YlNTGqIqFGBZk0m8q4ldN3yaF/3ekc5gCc+jNZ4xiWUtKsvKUHORwbYjCPhUAoaG5biksxZZ26YqFCCVTvPigmXMX9NMY0eiYGMxqDREKpVmYi82GvGM6Qnkhg+/oVNXUUIkniRlWkUis5csnBNsChO0ChYQT1sMrQzgmMXWOO3RKGXl5UXFELt7Ydu2y6MLVtMSS+HTPOsj0y0E1HvPGtvOHTsFv64ztLIU03Exsw6W47K4oY14xlPKTcfFcU0MXfMK7uWOaz77pTJU/IYTS2dpS2UYVVtFWdDP6rYOFjRFUTWdkN8gaHjPp/r2GCnTYlDQ24e65o0NBApBQ8O03S7p4TodqSy6T6XE752nQb9BY0divYUyJZufTfWk3RzkfVxdUTwGLUSYiuJx4caIWFuKTfWt9YInBCpuZ6pqHz62jui0Rug6Ps//L3KFfJVeItMtoWPZoGQEJb6+U4e7ClmqqlLid8lanZFF+VTWaNpLUc9HFpm2KIgViqLg00BXHHy5ndFXNGxXr8hoJl893Ltr5iuVl/hBVVTCPpe0CQkTKnMvusWRbAFcyysItMPgzh29MXYMOw9ff+j2liiOlqd7lffuaKqX5vveKk+E7280bPeo5u7kU6B9muDjtesvRtdg1fLaUoeOdP/b72u/GWqAxhhkRJgy6CGy2V2u9673AiHyWTlesSCty7npMyCeBcup8ISvDdwcNkbU7g/dxXhFUTZ7G5uD3kT0zRVVvTlwXZdV7dBsV7GizWXbGq9f+Wjw1qQgKUJopje5VOLvPHHyeVv9FS67s6F9s6GJi6JCjYoomozqOsGma8WFtFS1M+XesntmluXzt1QF3NxhchxoM0UhBd9Kdj5j8kFPPfZtL5YH+fO2Vm9nyDYjc/YPLhY+L/Vfh6xp8lmD9+7YdVKnJeGyth1coVJX7r33JRIZSkrCGBrEM5DIZQq0pxXmfJoAXwkVQe8bZXLtG6qnX9SEFarCKq7rUqKmmTxG4bNG+Hi1SzgApX6FhOn1r3OKUsnpAuTqOQiSpueFn8ldfwhwyL1Pad4yF7AwKDE8r16SDWwzagTrOgTRlMBVNIIGVIcgEk+j+UKd/VYcykLeORZJ2Awu0/j+Dp5fcG8TRd0ndUXnqTBgkMLterAcT/TrmtLvFVByc8KpN2gzHSf3kMr5bOQeXq6gIOTmrQjyRVxUlILAawuBL+f/aToOtuNiOg4BQ8d1lIKIk/fBAy/iRgjvpV5VVTRFwXU9wUXTFAxdJZ01aexIYNoOlm2jZiwU8i/iDp2eIF5VP/AKogjhFR/RcgNLL5rH+7vjipy3rJrriyBfobwQxN7lJmToXoSWjVN4qOdH86qqkMyaZC2bcMCHk/ubF73QuRGRF7RzAxQNL1o5aOjEM1mWNbfTkc4QNDSqS4KYlkN72sJVFMoCPlKmTUuuKvp2Q6pZ3NiGaVm0JdP4dS+yMaB7PsK1ZWGCquD0701jl9HDmD//E8YOruKUfaZSH42RScTZdvhQSvw+XvhoYWdae76vub3gCE/kSDjZnM+Tl8qaMi0U1yUXS4maOx5CCD5b1+zdzBSl4Pk5pDTEqqQnBpaHAowq8aGqsKSpjZTpUFfmZ7sh1T3Sg/MFacbV1bC0KcIH69oI+8PsPnY47e0RKiurSGQsXvl8RUFkSGctL2pbVchYjpdalzt/dU0hpBiowuWo7+zA5OF1rKhv9AQQ2xNWASqCfrKWQ0faExo0TfG8dFyvenxzLInjOJSHMzz5wSKGV5Xy/OJ6LKFQnUtNtxSVj1c18OHKBnRFkHBWUxLwkzItwmrnQ7kjY2HZLo5P985xR9CRNtF1zwsna+d8eR0BhoZp24W0cisXYW07Li7kUo8L8aW4wqWpI4FiW4wb5Q1Q5q9ppjmR5ouGNratraRRwOcNrWRMm6BhUB3y4Q8EvO8oBEGfj1228YpamXGDsbW11EcTzF+xlu+MHcF5B83gtUXLefGTxTQm2700e3JRm12GA/kiIW7hd5emDi8LoDQYRFNV2hIpXFfgU7yoZhWvsFAs3T8hRVMU0lnLSx0H/LqaK04EuqoQ1Lx9vLqtg123HU7QZxDNmDzw9qcAnpcsKlVhP8mMSjJrUlkSJOwzWNXaAa7DqHLPwiOS9qI5g34DRVCIqmxNpIhmLD5YXu9NXLkutm2TspOeB7KuUldVUfCx7e4xCnDLy+/xyap61nWkSCxZzeDyUsbUVlIWMBg3eDCxdJbXPl0KGuyz/WjvXuA4DK0oI6KlaYkncVy3cL5FbIuUE6MjncV0XITjMm9FPShKYRJB19TOdxmlM1pD5B4EXkaFWrCfCfs0Qn4fqqJQHvSTSacJBINkbQcdwYiqMsoCxenu4YBBRdBHVVUl9e1x5q9pwnZzHqeqjmJ70T+aqpC2POG21KcTzEVK4gjCPgNFUdFUqAqHiGdMPlndiJJJcvBegnjaZG00ScJy0FQVv6Fj5qK+3VzUk8haOd9gBVsI1kViJDLZXIpwJwp4xfoU73wuC/oZXlVKutnGsmwELpbtPUsMTUXg+TgLRMGWx8r5aje0xykJ+LEcl5ZkknjWYmhFScHGYnVbB8msyRcNrUwY7h3jaMYklM6StTzxsyyo4td1ArpGyrK9yFq8iaY8jgCfquAKF8XxCrgpQHnIj09XC9Y4k4bX8vz8paQzGQ4ft433HMvde0sDfj5e3cjz7RGmTOxgXSTG2o4kiqLiuC5J0y5c2fmnpuMKysMBb1LXcTAdl5KAj4ZEkkTa9CYzRXE/FcfFURSiac/L2RHg0xTmr2ny7tm5SY2lTRE0VaWuvIT3lq9jSWMb8XQmNzJVEMLFFQqJrIXjOrRnoNS2aU+m0VQFn6YRTZs4jvf8jmezpC0Ln66jKSqJrEmFHiSdtfDrWkHIlWxZDMNAURRaWloYNGjQBoWP/iKEIJvNdtY8yP2cv6d1XZbM2KAIr+J1bmI/bzkiENiKJ4I4LiAcbE3H3sA2+1q2MetuaJkws9iKD1PkK907qKqW8wx08fk1stmen7NdMLMWLhk0RZDMOIXv7wCO46DlCrTk74edRyUnYNoW7W0tmI6Crep0vVpcV2DiQ4PCS2dfqcPdRSa/ruBXsqDpRamsZQGFnYd3iSzqpzjY3R8ROr0iP1rrkjIFAtWLyNIoFHkCT+jQcNBVnVjWi/DK5CLZyEVZlfhV2pLw3iqHylwE7MbYMXT9XG/n8BYpjtZHlffupC0vzTqepUh87xoN2xtdo5qNbpFdXVOgYf0Rv5oqiIkQIrH+9l3XZUWbWxDdRlb03G8OGvGsJ9QLFDoyXmRfSZfhSVex1vPth7SrYhUKGmm59gAFdFxChobQ6fNYdBfODU1s8nnbX4qEPFVgOgInFx3p0zZPGxtDnxYDGziPNoWNsRTJr7vGGsznH7qYNrjUUb/E5d2VnnibjwbXcxNaquKdQ9E0GDn/7dzwcKOEyzwb2jcBu2KDNiJdrzdBceRsYbIRL6pTcTsLaRmqd39z0Yom4Av7ByWXpdEp7CZyr2Hed/basHLXlBfjJzAdCtG4ukLheu9eKDJPV/uHtz6Lk3ACxDLgUgGZnDCay4gwNIUgnjit5u6HPk1By03aeZkCLh1ZP9GMQnVYYajRRLtRQjyr9CjqpuOwQ51auP8k3CBzlwlaEt59KpHxfGS9+cC+J9nCagJFq8J28vtQ5Gp3eMff03o84dsWMKYGhlWofP5Fluqwwna1Gm1J14ucH+f5nb/1UQPtxpiiftuuJwz7FJspw0OoqorTpYqw6XjHzHa62irkNLzcJK9P89YbCEjhdj3kvWtdoZDOmji5SDQ3d5Hnox3svN8c3ku843oFxFQUNE31qkTn0j4NXcW08wVkvAson/5uaGpOpPReXjVFIeG4RemPnbMB3u1CQSmk23oeXLnTP5cKbrteESLHcXG7WjvkRGUld/N0EaRMpyiCIx91BzmtFS/KMZ7Jej6Kue10v6XkRVdFUQrfMb/ZvICNkosOVrRcWq6LaqjQLUojj+cR6u1Lf87jrzmZwYfnd+rTNIIqNESTJLJZElkTPec/pmsqmaxnY7DNoEpGVpexuKGVZNakqcPEsm2MlElFKFAoVlVXVlrU/oiqciaPGMybn3ZQGvB5ImQig6KoBAydRK4UokrOg9Bxc5HVXc4nIUjmIpIMTcPICT6m7SAUGDe4io9XN6KpCsMqSlkTidGczFBTUkJtWRi/7qWVR5MZRlWX09YeZVyuIE5XsaI04Kcm5GdpU4Q1kQ5eWLCUWMbiO6M8Wwklk6SuohRFUYoKboV8PoI+g6xp4jc0LNvtjAb0+3AdFyEcwj4fQytKGV4WoiGaIOw3CtHm8ayFbdtdREaRE0s9ITXsN4gmbVQFVjRHeOz9z8mYWbatrSbgM4hkMsQtE11TSWUtXEWQMR1MO0U0lcUyVPxBG+EKEqaFmrMGcYU3qPfpaqEAl2m7BHTvFtyeNnFao+iqmouU986/fD+7PnzdXJS6qig0JdJ80dDKsuYIzbEkruuit0XJWBZLW2LYrqAqHCBjOSRMm5rKACUBH4vrW71iP40RhlSEaU+ZLF26xvPxtW2aE2lue/V92hJJakI+gqEwjdF4oT+akjOfJ1/Er/NC0zUVM/cdvPtNzv4hf227nSJvf+Ox8kUE80JtWTBINJXGcT3PWjt3/2qKJXnl8+WMq6uiI21SnjXZaWQd7y1fR9K0MAwfiuqJ4+3JDAiIZ02CmgqKQsY0SZoWmuZ5rjquIJM1AUFV0E99e4xoOutFEyoKwhW4toOJQyor8AfS/HyvqeQ9RqdNmcSwijKenfv/uGfuR7SnMgytLGVtaZCEI2jqSBBPZxke0hmMF4EZzZiMqK5AVZRCFDdQSPP17ptuLsLWoiNjFxWvWtMWw9A1hpb4CxMbhSiTXLaAnZusAO9eVhLwUR7ys6KlnZpQkNJwEEP3IoBN18UnBLVlYVJJwdTRQxhWWUa+oCPAsIoyhpeFaDNthleV8enaZsKGRigQQFWgNW7nIqu968AFNN3zqU5b3uRjScDfZX9DTWmIxmiCT5uirI3EiGUyxLLeNRX2+zz/dsfxrg4FspaDLQSRZAaRezZkbYemWAoF8BkampuPOAPL9bxkA7qG7bq0JNIMKgnRnkiytDFCediP7Qovy0HgFeBEIWV6cfsKXsq+rqnEMxkSGRNXQG1piNKAn4RtURLwE/LpfLq2mfdX1HvHN5UhkUqxKm4SNHQytsPQgI8Sv8HS5nZUBfy6juk45POZu4qomqaQzQmVugKGphJJeJN8YwZXeSKn8K6HRNakLOcpG0mkCwUfOxIprnp6Lq7jeoK87mVc5M+h/DGiS7thv0Eyk/WyBEyLmGmRtT37oVK/gWXbZBwv8tV2BTHT7nxhBsqCfiLJNO8uXUdtUGcbf4gJwwYRjcVY2txO1vKyfVyRn4h1c/cXgenYCBfijuc3XBEKkkhnPN9Oxy6MBfJRVWruGjdtb8xQH40zacRghlUWF7mTbBk0TWP48OGsXbuWlStXbrbtCiGwLAvD8ES4/M95ATT/uysgbeXufUr+vMhPW3cGMeQC2FGFTcSnr3eb61vmBUwILMvGMHTP07mf2+ntc5pueMKSyE+seZkRuDZ+n160zd7W9SbnO78/dBb5FYKC316xcOulnnZYfhrtEWiuStAVWK5GMuu9EAs8L9C8d3We7qnDvQmwej6yqJdU1nxkUX/FwfWJBdNHa7z8hY2VyVIWDuHToCPW+RLsuKApLpOGqqyLCtZGve+lipw4ZmcJ57IjYhlosb3Ag65901SXjgye/zudtUDydgzxLp/rKl4KIVgZESTdIKUaG52C3Z9I3e5V3ru277ou8YzXbEWg92jYfL+70zWqOZalT7HEdJQ+I37zXpHg9d/Qem9/YaPD/HqvQI8r6mhY6uLTwHZDVOesAjKW25k63mU/Zh2wuwlw+WeQpir4dUHKUnuMPfNCiKHYgGcZ1tux6MuqQccmbbFJ521+vfWJk/nzL54N4qa9aytfoMirbu/bYBubi/VNPnQ/j77spF1TXLCwyaI1IUibw2la7FAdBqMXYTh/bBo6XFJO1yJy3rtUyoJPGwQ6Pqr83r0ot9gTI93OyFVD9T4l0OjMH+78/n0d0w3tm0gKInYd4aQg1IeNCBRfb4msNx4TeM+yfDJWIW1eybfdeQ+xFM8fWVPBcVVcN58hnJvYEF6keD7Dw1BzQXDkBFXVEySFgPZU/vrwzjcF0IQoEkd7Q1EUmuKCNqcK3LzXuSgcj2ga/IqR67uCoggc4QnQvi4+Pfmi745QaU1410Z+ou7zRofmOGREEDcLtSVguI0MLi0vnBN5od6n5TJPFM8ypev7NXQGtum5yd4Ot5xSF3wGpO3OlZVcf23Xe2Zoqhd5u6INlrf1jLDu6nfeVzG66rCC3qXfXfFp3gSsjo2i6riu98wSuYnJoOGdBF/VpM2GGCDdGJhouXTQVNYsCCiqCsL1onLyFAqbKF6qrK7loihdQUnuBdg2LTRFLQi8+WgsyF3MQhQ8/ZRcNK7jis4q8D3IReEJt1Mo7dKXVNbqLLCgqDjkRVhRSJ3WVSU3GHVzVeQ7hWHvu3eK095LtDdYtV0X4eT70PldPLNo4ZnS59K4XSG8qLqcwJHva35WJR+NbDoOjnBzhczyom+uhdyLtuO6uHhFptr9BtOGVTFhh/Gksg6vLVxJe8ZE0100Re2yXU98LHwPRWFweQmfrmnGSmbQNW9d1/VEnkgyg20G+fsLb/fpFbukKYLjOmQdh5BfI5vzfxX5o+L2fswKL754QrqRE8rythjvr6inqSNBWyxBfdIEFDTXYbDfYOLwwQyvKqNh3RqmTtyBVNrmnS+W0xZPs3BdK02xBMl0miXtaQaXhSlVXFzbYXmLV4ipJuSJC7F0lmjaE3jLgn5KAgaL6iPM/nAhi+rbSJsWGdvBEqZX8M1v4Pf7aU9lsBwXHcED7yzg7aVrCBoa2aTNZ2ubyJhW7mWl87rQ8pMSuXNPV9WcmKqjoLCsOUJbwhN9VrZGKQ34SGdMbMUT0cCbtWtPpT3fXNcllRWkbS+a1HEFfp9X5TyZtTB0lfJgAMtxiKUyOMJ7fQz6dFKmRTzrWR3kKRoMdL+6hBd9brouH6ysx3W9c1MRgvZU1iv4ZVqUBgNexLvqkjItYukMfl2nxKeTdVwqQn5Wt3awoLEdTTcYUlFCjaEwrLqM91esY1VLlFGlfv4/e/8dbll2nvWivzHGTCuvnSqHrq7qpO7qbqnVUivYkiwk2cAxGBts4HAAw8PB1zZg4B7gEG3gyhj7kmyOwcTD42sD9rFxxLIcBJKs4M7d6hwr144rzzTGuH+MOddaO6+qrpbacn39VO+195phzJHmGO/3fu939tRRXriywqVOzzEbzQQonAYNBVAJApoVwcX1Hkmmx+x/wDGQzfYF/X42yvIiIdGE3eIpF64eZxOAyFrLy1fXuNxxGpe3Ls3Ri1Mub/SIc0OK00au+R6xsWyMEgf+GkM/TlgfxFigFvoFO8TNDbk25LkeO2wMEBTyMVJKtHXjeL0/wmjLMBdkssHGCM6tnOe/PPEqmQp4163HEAJOtGqcH+aM0pzuKOGF0ZAryeucW+swyjS9JOWR1y4xTDM8Y7i40WeQOFZ+Zi2d4QiDIAeEtYXcQRlJYRllOZd6hoGB3igZZwvPxjrhzsmlChbsfK3CZ58/55IMWsOg06MSeNx6YA4z8mnPz9EbpTSlGUs+bE04+O4Ti3xuOeZLF5cx1hIVTLBRAeDJksIgHHLq+uyU/A6T+taFs7FVDbm0GvPi8irLvSG5sQSydB4qKp5CW+GAvan+2KqGzjllHHPd4uY0Bw4brHFM9kw7uRqN4GQ15PSBeZ4/d4lUa554/SobcUonyVlsVLntwJyTndGa0HNJDT0lC31dx/6WAqLAI8ly4lzjZzmBp2gGPmtxxvOX1zjUqlHzPaQQLjGhdSPnYqdHZxhT8T2qUUiuNWv9EQU0DUzaWEqBNJawcMS2KiEVvGIOm/LUF5+7ccb5tcvEWU49DIjjmKrv88LqCrl1DFnH3NPjgSymnJ5u4+FW0ifmmxhrePnqGgicvIznkaaCCEFvlJCN32dQC3zmQo+FdoveKGGYZjQjn7/0sfdwqFnnc8++zPIgZrFe4ULmEjUKIZzeunFRLlW/cL4Zw3ytysnFJq9eXXORMkVSutKrKgoQ3xSA7/OXV1moV/jY2TM3E5NtsTRN+fjHP84v/MIv4Ps+3/It38L3fM/33BCGbL1e57bbbiPLshtQUmdaa5599lnOnHFzUPlZKbXpu5W+5emXR2PpF2stq70YLaJivLlZJ/TgrkOCbPl5Tp48vemaUkrWh5oXX36N00ePA/DSK69z5tgJ5qpO8/LZZ59l7vBpXl61dBPLKEmomJBGBCp9nQfOnNxWtvIe+503ff8zt56gGcJzzz3HyZOnx9d8+Euv0LXHyHSRaXzUp1qtM0hhlBnmKpLId8/fG/Vp1OtkFtaGGlB4yq1ltNVIoZBKkWcJyvexuI21psJonJNJMEi2sxphc+jwUm1nAHa3UNbp72cBB/fqny47ueBCIovw5s2AS6mpe2axzlJdsjLIUTqmWd8M8m7Vg52vurJdFW2u9ErWstPKLZPflXIMJTvMnefuXYJKV3uGDJ/OEEbp3vU4bdOAUD10z5FZn1Q75urKLlneK/6kDvupW7uEJAhR23T9rc+7tJkbAswGOnTi3Rm/mSkTzrmQ7q3mSdgwNb7wmlsXKAHWaqSQRaiyT1yAo2XouGLChit3mGXouJPSKx/QsauTvISN1KZ1dbk80dYbX2trW+wGnK8NIbUeFcF19dtZ9I6FENRln0t5e0pKxWCtIs4BFPUvk7btfpq+ZT9aGzqQ7Hr1b/umwmde1gzSYp5CMUxcUi1lj26SFCnbJs4onAO7W14kvfKlS1RnrHK4gtjMXJUYpHJsyDIx5F5tup9jBhzoapBEezguSsC7HG+PX9Bc7IBBFdFLLjmsxXd7ktIRJ4oIYCE5WIcoECz3LEkuyIvzpEmQwkUbeMo9B8JdtxxLpXPPsW8LJ0e5Hhwv2PdfIxhjeOKCk7QKZHG+LhymuLkosQXBRIoxYWDab5TkbqynGjQ+T1w0XOy4sbE2tFztufY2KEYZXO3DvAnH7fHM5YlsC0AHjUVt0rndDHw7CQRrIbcSKbZLExVHY62YimARjDIH1u/HPt8pGd1cBR5/fHvywys99wxx5pIlytyxfJVJadUq+BJ6qWCx6pwIbwW7CdzuYb5SmAKoDLypcA8c063UfVTSgbG6AHcCpdzG2TodW086cFAVgGYJshg7kT7Auo3+n/9jf4TlK5fHZVBKcfDIUT72+7+R3/fNf2QSglueZt3m0SUqcf90IbUginI6VmzpmRP8ne/5bu6+737+2J/+M/zzf/QPsRa+6//4Gw5wmJoIHXPMTaZW5/z6r/wyX/cNvx+Av/tX/gJvu/d+vvVPfnsBaBf6S77v2L5ZjlJu0s3yiZREOWkJYJCkha5uKRfgKmO6GBbrAO+pgd8ZJQySjIcvrPLkxlMs1KvkxpDkhvlIjcFuiwOn4yxHCUG7GrmJf3kDi9Pqw0Juc3RBt3PMZUOrurNWbJnl/TPPvzaWjagGxTOnGQbG0ghbbdqnmFs7BpQDJbmw3nPsYClJtWGYukRFxmi0tfz8Y8+T5ZoQwy+8cJU011zd6PPiqgvLD5TEGkNqRmwMYyIBbztZQViIc02eO2B4fTCiPxjy/PpwDISs94b80C//FtXAZ75ewegcqRT9JKOvNV6q8ZWiEQVUFaz0hjx1/ipJmqA8nyTLsVM06fIZlZTYqbawOEcGWrI2GI0ZyRbHhBwkKdY6GQwhpseYQFszeRHlpnACUDyfA658IRgmmZMbsRPQ3zHMisyYyukzT3sAd24n56TJC2Z9PQoxowQPg+c52QVtIU5TtDFORzrTvLK84Vg41mIE9JOEuXqFg42Id5w+SbMSceXKZRpRyLG5Js9cWOZCNyd55SKXOg5Ucd6+nS30FUuNKoGSXO0MiDOnOVqaY8heu03r4JpirOopB8R0eVJt0HEKgaIa+HRGMZ1R4mQAPMdWCjyJsI6tuD5MiHPDMM1pV0PW+0O8YlehjVv4r/SH9ONkfJ9cG3dMOe6Ni2CYayzw/zzeI/SrpPlRXn4qZqXb57W+YqV7hQtrXe44vIiyljMH57nSHXBu1SW5a2aWg80aHm7Mbgxj1vsjrLX4nufkATxBoi3xVOx/6XCRAhpRgNaO7T3MDXaY0K6GeJWAXqbpjRJyY1E4Z5MQbrHWSxKMsVQCpyMtPcXaIGZ4bpkDFY9603ByocU8EZc6PX7lyZd46crqloSD8Ke/9u38u089ynOXVhhpDVrjKYknBUHgk+eGrCh7nE0iKFJt2BjG+IWMSD5+Dzmw+RcffYFLGz2Mcbp8+SCmGnooIfB9jzyZgJXtakTF90nTlFoUEmcZa0PX/ifmm6wPE9b6A5R0obQuyZljbj9/aZVukrHQDnjPmeOcv3qVK0PNIE54/vIahc/AOSSKqJMkyxgmZUQDXO0O3HhLMzZSTeR5pIXjcbFeIck0/VFKXXicPjDHWqdLbgwvXV4nN4ZIlk5R6+QulCLJ8rHee+grDlSrjFLNUsUjCH0GacaV4ZCV9ByVwGeYZmhtSIpkjOc7A0ZWslCvkuQ5npS0axG3H1rg6Ysr5MYSbs1ENGWelGRF6Nbra11WesNxtt84y8eAaCXwkRJW+84BcqBR48RCi8FgQOgpwkaVy90+r28MsMJypd8n8BSVAF5b6UwcV4VDtQT0A08Vji7D6YNzrPdHJNrJzzi2doAwGisUgzR1zy0F3WHK/bcc5mNnz3DboYW9J5nfhfYP/sE/4POf/zz/9t/+WwaDAd/zPd/DkSNH+LZv+7Ybcn2lFErt0bGu0crwwSiaIBRRFI2BzPL3qrFkNichJJCSODMMrUIIN+flxgGVvoSX12HOVDZds5OFPHPZsDKQDNMTvPSCY+ChT7D8us9cVXLnQUHfVDh3yS+AHIuNE4QXsjyCLDvCmSzkSM3bVu6Zzmt7BIHmkow5OJXtqnzePM+5mi9hZEgzKpxxJAgvIsCykRrWU8lS6CiHGQlaRghhSW2GFT7N4rL9/oB6LcSXcKWjkZYCWIB+bMcL3vKtszWsGDaHDr8RAPZ6GEnTJoTYFbgc5Y4VO9bULUAET+RjHd1pU9KBg+k2EHXqM2xb02w9bwz45RSApavTVDs2m7L+niHv04CQb+Byt2RNR8TDQvfYsmOW943RpA6bkQPZZLZdmHMrq22hZnZkgO4HOsxVxa6MXxfZCYpiH1pYCc4kmUsORjn3y5Ip647LjAO3wsCOAeDclu0hinsUe0Mkl3sUkZ6OBXylO+aW4yk11qf0BHieAwczPWH8TbfFfhIXcSKo+hAFLgHerP12um94CqRjHXG1Z8nSIxxcNtxx0EW79k29KAvjZEYle94iePaypZ9km7SZ3wzbT2/3enWUSzPG8Oqa5bX0KJmYsCCtNijpdKtz6/Poec3hltrUNp7cfX8yMcFy37Wrh8aISb+xuLqNMxe6fu/xCld7jLVad2vTUjd3uW/Hjplh4pLzlRIDULJlt5dwu6No8p0vGQONBWEVnxwj/GIPWEQ4aAdqe2jeflyNx+lvf+kCtnaUUQZDrUg1LNYES3XBY68ZGhUYpJM+letynnLAZLvq2nSsOSthucueki4Ar63ZIhlgAQBPIb+TvZugl0AjKGWNJv0jt4qN0eS5FZqqL1kdWIbpMV561YwdPFiNEpJRBhfsYZ65YjjSEttkWwKRkYtgwrZmej53UXiuPVxRrYWKVxC97EQbvzStGTuD56piHOWyH/t8azK6nWzaUVQPYWNoQJYyL36RfNQ5oO8+rG6Iw/1G2E3gdg8rk4c5BqktgKMp5uhUx0M4ENYYS4YugFIIlBqzR4GxlIK7DgWr1Z3vS/ei/bPf+Rf4+m/4BlJt6PSHPP34I/zLH/wBao0mH/jIx7aVU1sDRuJ7Em0toywD60BLp2NbJlCYMPPAveT/9P/ru8d/0dbiSW88MLSZbNY/9Wu/yk/9+H8aA7d/7Xv/Ib7vFaCB23RmBnzrwImqJ0mt0wzxAoGJ022eHgd85lOs3mnAFkoXlAtdsJT6wknuNrIHahWoRTx/ZXWciGh9GGMKQDW3BRNNCIIiG/rGcMS51S6eFNQCn0GauklBWEKlQEiWB05r8baD85u0YmGS5f2BU4f5y//pF5HKZ6FeYZi3kEh6o5iLGyvjZ/Skk07I8kk4e2m5dsnLKr5CG8NCrcLrax0ssNSoEPoer11Z5clzV6mHPoMkZTVNaVRc33FMtiJzK5ZIuuQ2cZ6zGmdsDEbcstgmzXJeWOngByH1KCRVkk7stBO9gs1YMgkzbQg9RRCGtKsVXl9dRwBz1QgpBXEc0x0lLDWqvHJlhEbTCENGae6AUd8jL8KDy6R+SZ6jgMOtBvXI55nzy8RbFral9mw57iq+NwbghYCFWsQwzcnynJOLbUZJyrm1jGGasVCvMlebw5OKOM9Y6a6OF/sSF6LsKcGppTZprnlttYMSglrosTHlOp523pYgjsE5cBZqFYZphs0duB75HoM0J84Nxk6exZiJZq7vK86tOpbfyYZLjjdtvieRUnCuM2SgC0dCwYrUU4xbX0mCIpHVRHrC0gx9Ugv9NJtoRInNYZr7L7CcqWLMZ+XYKfRFd7qO0ySFQZpztdcHHGO8ZP6muSbONEIpDrfqThtzlHDn4QUONutcWuuSZA5wHKUZuXX9ZTJLuv6Q5hopwBOWwPc42Frka+95CCWrJFnKWm+AVIql1gIfvvd9/NoTn+H86mUudQa0Io+lvpM/qYY+gVI8dPooJxfa/OaTzzHKNUv1Clc6/QLoFMTW6ZopKZ2G6FTH8JQkUpJ6GGKsITGaLDdUAp/Th44gtGU9jnnm4gUo+k1uNAu1KlUPBhqake+Ss42GhJUqQcGOVFKw2KhxtTfk85cu85NPXcD3FPccW+JIY2vCwbv4+9/8YV64ssKXzi/jF1IhiTaYNHdOxKLBQiXxPTVmOY/SjGHq5qSrnQHdUUKaa7SxrPSHHJlrUA18MuuiMPpxhicgUopAeQzRSCbM0En1TFg4/TSjGnhcNRZrdPEOAqzluUurbk5QkkqnR6Y17TBgaa7OY+eucKXTGwOwWFxSzNwymNJ4zS2sD2LqkU9YvHt6SVGPnsL3FHmRgLB0FB5uVPAqVapBwHOXHeAtjKEW+kSRh/QDlxgxTQu2reTYfJvIVzzx2kUaRtCohIjAseReWV5nUCQzfPLcFV6+us7qMOXAXAsE9OOUZuTTiEKSLCdUklgbkkJ72LJZ063s9YPElTvO8oLhWmyQtaEfp4RSEGwZi1HgbVustioRF1c3eOXqBodadRcpITe/+5m6TqYNgyQdSxt99J7TCCl45JXzjHJD4HnFGsiN2cjzUEJT8STf9tA9fN3dp28ybXewjY0Nfvqnf5p//+//Pffeey8A3/7t387jjz9+w4Dbr4SV5AGFpp9CS5pNiV1EsUkPdwlrn2Z5GeNYPuXCSBR6mCsDy+dfNSQ7ZLL3ZMF+jT0eP6851JTbyvdGNE5L24v15ivHJEu1JM3tNlBymklW8dyxAgoNQkkgXTbstWFxveIREm3R1rGntJ2EFVu7XfPwjQCw18JI2u38Y/5lstppVgcQ2wiRwVId7jyoxpq6++nBauMghmAKuMtwbTwlQTiOBuwnEPp2x/NS3DmlduS07npGhN4l5H0aEErxSTelBXCRKdq65GjDdOcs72UdSiH4zRdykmzz825ltT1y3vDoeYOSkO7AAN0LdNgTOM+K6A2bQaGgXIIzegshwOLKIxGT/CNYDIJRUuZocQ54tpzn1phyqo6LpEPjY53+Z+g55iLC3wTIuH3v5nD4lf7eLFOPnDiHh045QtUs/Xa6bxgDwxRyIkbD8llCPv+q4UIn42hLuPuHbq7op5bO0IHbqngPGyO52rP04t01lm+E7adFPYuO8m7JuZbzNv/1McMwdc8/JmqVYL5w81uSw0of1gZOnqlsm8GM+UeNpQAVA1qBu15a6G/nxgGbnrnMXQdb3H1Y7jkX7RSOb3Hz6ygHQYVswDgyDrYTVneSA5gG7pqRdcCdkIVur09FlvMJgGRjBJEP82qdg43WeJwe8Na5784Tm+aCxbqbXwW2yCvh+l93qNGoAmB2jbs2hFbEWHMWdpYR2WqDdCyO6Z6Znfd9vdjp7bo7GuJMkmtLYgMnrWcnSrS9BOoedPCLfUQx/xbkJ2md1usTFwxz1e2yLZ7QhIFzPI7rnvLek8TzdqqdpJQ0I8P6aMJILs8r55SAFCk2j7m9wPi9zFrL6sBwMTvootoqbp6PRxOdeG0l/QSOz8Hdhz0ONnd+h30l7CZwu4fl2tBPJcYqrNUEMi+YoxSyB3asEzsGYCkSfRU9Lzcus33gBwUzTxdAqmPWlRseT03CSqJqjaDexLcWv1rngx/9ej7967/G5z/9P/jARz7mXmoFqAmM2WuZNvjauLDKXG/Z0LF942Yt1VodAN/zqYUVPOWNJ7xcawbxkDTPtmjMQLXeKJhoxZRWgKrGOqaeB7QqEcM0Iyk23sZOQjRFAXyX8hCuHgSGcnUxBTBbgzCl1ifjxGhSCmpRyPH5Fo+/dtmFlBvXHlJMQgIcgO5A2/PrPTKjUcKFh/tKIUTmvIyOWux0HPsjAq/GUusAz18Z8OrKBlJYXl3vM7/e5fTSEb72ttu5PBQcXzpGvdJ0kgdGs9JZ4wsvPsnF1csoIchzs+Nkaq0DQaRwiW1SrenHKVVPEfo+WBeuP0oTwNKNk6JdE8dGLVZbQkqMscTG4vmu/qQUrA9HaJzWcS/JOT3XQiDopzkGl7htY+iYgIv1KmHgsdobEvmKxUaNK92+0+2RlmYlIMk1nVwz3yw0c4rXRC3yUQPHDvaVJPIUGAd8KSHcM1JoDacZgywHAZFyCbAKJdDC41aEYeWarOhzaZYzEAJPCrQQvO3IAqPMJdBZbC3xzjNnadfahadYs9Jd44svPsmF1csuEVmuCZWTUUiyHF86B4e1m9/s0+0zljMBmhWXkb7i+3SyjMhafDlJSDUtZ2JKLUhAauvCjP0q1q+BiOgOO2yMUtLVDpc2emwMY+LcsNIbgrVkxfllSIsQLuGb5yl0f4hFsDF0ieAONCIOLczz269cGOv2YsvwNwc2GmNdv97HXHDLpD46w3QMfk/XUqsSUg18eklKnGa8crXDHYcXnCZxnDDMnD6ssSBzzasrHZRyOqUrvRGHWnUWayGXBwnr/REIp2PqS0li8qLuoRJ44+RQzUqIFHDfqbuJ/AhjYlItqVfqaJOzMejSqjV54PRZzq1eJjeGQZJx3PO4tNFjtT8ikK4MFzd6KCUwmWW5N0TiQPC4SFznSUE19OkOk/EzN6KQWuiTFYBgucg5tnCID939AO16C1vICdxxbJ0nXvsSF5YvcqDdoDdKuNpLmK9VWKi7VUUmxJgdeW6tw3PLXWqNVW5dapNpB/pqY3jh8hrHqh5HtyQc/M6PPMQ3vuNOvnRhmY1hTOgpVLHRGbqVsfNqS1noiEM21QVk0a/WByMybWhFPmePHqCfpLQiJzngCcc0UcJJ02z03U4n8JUDFa1j7SZxSqInWt6XC81rXwqsEI7hWbAslHTh9r6SVAKfq90B55KEKIoJlOJwu87F9d5YomMswSMEsmD+uDFmGKU5oRSE0kmldC0IY12iSd+DwCPyPZZ7Q2yWcSyo8Bc//E56KVzeGDFfC+jHPda6PYbJCCGcQ6YWCj505y30CgZwkhsqBfM8yTWdkZNb8ZVjE8aZpjvq04lTGmlKP3Gs2GNV9x4NfY+5SsDqKCXXhsXWApEfEmcJVzurgIvY6QxjpJTUfI966DNK0mITJcaRB4m1VMCFjxX1XSk0PTdbEVEgHLO8E6ckRhD5PoOt1DYYP5sUgsiTKCWoBj5KCg616yS5YRCnpJkmQFKvhISepD8cUYv8m6DtLvbwww9Tr9d517veNf7bn/tzf+4rWKLZbbdNfwlybYwsqfXRmducu1eMC4/OC1Btp7D2uYrlUnaAYeEvNeO1XimNJRmksFS3bAxhaCscmAJycqtYG7rNdI7HpS78yjM59x2dbKr2CzOeZUMMe7PehBCEpCT49BNohJvBs92YZM0IksTQCCG3ZfSPS1YDbgNskOTFOyZHOrDJ7MyifSMA7CyMpJ2s1AodmghTtOM4seuWpcZe7NBpWYW5Sp31EQxMBZ1PNCZLMwVQmGgnnxVvOW9oKuTZtENs+/NYnD4rKA42xVgfcjqR0k7nTVucO2CihDnKLO9lHUo50b91ay9IjM+wBAqta+MsL9+v4FtNoNiko1uGp+9muzF+D9QFcW5Z7cpJtI31sYZtxJFx3eIYgqL4DSSjfKeEUUXy7V3KNL3HEVjma45Vu9pJyYVfgO0FGKMdiCWs5Wjb3Xk/lmkpq5BqwYE6M/Xbsm+YnPF61m5p41w79u3qwM0v5f0LPyqemDyXBSLlWJej7ACrAzPz2LmWBGB7aVHPoqN8KTvAb76o6Yw2s3ErvuVCfhiE68FTvhEyA3LKwVICxysDSz2YtM21kg4NkmEGizXojIBswIduazFfFTPNUzuF429g0HayY7FQRHqU63OnoZtq16b91BKnE8fJo+cN59dhdYtjcCtwN8qcs6caQBaPqFRr5BpWs7lt43TrXCCE2KybbF2fMmxfsxm7WY8Wdpd0mbZaIDb1aRetbLBbHGUCB/ZLARUxJDPNQtfXG3duNzd4DNISnBeTk6evVdwjziRrg+2Oudwq4nQ7gCxwmuVlpGwpFeHwNUs9FAxHI3JRGcubgdOXtYCfp8DmQbMTGL+flbIpy33DwFZRKawZJ4/jCU2j4pwB/WGKryLuPSJZbLx1QFu4Cdzuale6hicvWlb6gQs9kT4137BUi5mr2kK/VYzD/rMpDcAyYUfg+SgVYoXLIm6x5DpnmMQkxrmtyoQy2pgxIClK756dLIakUniex9/9K3+Rk6du5eHP/xZaa/7Zv/u/yXXGP/vH/4hHfvuLLMzP8we/6Q/xsW/+1kJs2/Jb//NT/Lv/60dYW13hQx/7BswUk/aHf+DjSCn529/3/Ugh+O+/+HP8+L//Ma5eucyZ2+/gL/y//0+uri7zL3/w+wH4wx/5AD/yn36SH/nH38/d993PH/nf/jTWwqc+8cv81E/8OMuXL3H8llP86e/4Lt754INUA58/8S1/kG/8w9/Gb3ziV3j1pRc5euIE3/lX/xq33n4HBssv/cxP8fM/9V/orK9z4tSt/Nnv+ovcec+9eEqhhAPZ0iwhty5EPsk0eW6xqoaUFXzPJUuTUjBXq5DkLnO5VBJhXaKZQaZZ7Y+4ZaHFMxeWwWoqgWOHOrBLIIQkyXMOzR1grnU7YaXJyeOOTfgff2uF9e554tGAl/MezargtpMPclr6aG1Y73fojgb4yuPQ3BIfua9gAK5cHi+WJHCgtUDghyRZQpz2UVIU4HZGP8mQQtCOfARuMx3nmtxYBolzGgjrwp77iWMwlwBK6VDQo4SK79EKPeJU8/ArFwl9j0bosTaIEcAwzfF9nzjTBJ4iSZ12sEBQjwLWuyl3HF7gQKtGfzjC81yCnwtrXbTWnF/vORDVWjwcMh75iiRzTopMG5SSGO1A9MhXxGnOME3pjBwgGCqJ53nkJpvouU7N8tnUqjEzljxOiyzngpeubhD6Ve4+eRdnT96Fpzx6owG5zvGm6//xz3Bx7cp4M5FqTegXmeXznEzvDKiDAzI9T5LlZuxwmK9FDEYxo9xJb5TnbgPki5/HFw9xz6n7aVabeFKBhFzUOT9Y4dy5l4vx73rHNPhrmSyoJDDMckSqUUIQ+I5FIYUgkIJWJeSbHriLL110ere50Wg94vJGF40DvEaZy1S/lykhxlEFElDKSXaUz6eEoOJJamEAwiWBi1PwPMn5tS7tWot6RRFnCcudVXcN4bLVA0SepDMa8YWXL+BLSasaMUxSkiKdaFaE/KucwgFinDa31uRa06i0WGjMI4F6dZ4Gcrwy0EazMeyx2JznYHOBq91VUm3pjhLiLGeQZIyA//7Ei+RFm3vKqU2VrGIHcJbOOAdQjlysoGMFa4PCIpXBYDjYPsjvufe9LDYa5DpludtFSsWR+QMsNtv8xhOfIfQyFpvzLHcTxKYl8lQ/s5ZEa1qVEHD1NddsEvqK1d6Q83nKGWNJtLfJidQdJRxvVhloy8Ywdk4ra8fj0hYOizTLJ7qthdNMGyel4yunIRwqwcOvXmJ9OBon5Ypz9z6zxpJv9JHCFiGVbkOYa8NoSuqkNJfQLSkWuz6NSDKIEyySI+06V7oD8oJKNVeLeK7TY5BbTh9oM0pcqJcxloVaxPowwRjDXM2txpZ7Q3cv4eZka0DlOf04HTsYBnHKhnEyCn6qnUMgyzigA17faPB1936Aq50Bqdas99f54gtP0OldBmupBAG3zNXQ1nK1N+Ryp4fAMkgy+nFKkmUIIZmrugSE3f6QhXqFjUHMqjYsd4fceXSJ0wfmSHsdwElrhJ7i6MIh3nH6Hhbqc9scTBfXLlMLg/H8luTayR/EKYMsJ8s1Ukpyo0nznLTQNFViwn4vzVjDam9E4ElC5XFhvetkPTLXfrvNd8bYglkkuGV+jmHmtKrT3GCM083WhVPWGJdJOlSKehjucLWbBnDu3DmOHj3Kz/7sz/KjP/qjZFnGH/pDf4jv+I7vKPSO35o2Dc5Ob/oPNBiDXBUfQpHgRyGdUclycjp+vgJpE0LPbUKnw9rXhpahrUAZmlpMi7Jk2eMAnNwIAmUZIMcAUpLbcbKkMjs3KNaHli+8NmHAzQoA7bUhhv1Zb0JYqgG0KoJhup3xuhOTLMksv9G1eNKBCFvHoigc2J4sZdkEmYbF+oRFuxUAWqxzXQDs9di0jmw/P4zoOXDOI6fqh6wMLJ99WVPL58Zlm1VWIckMGR52j6WKNo49FnpQkwPWRwvEqSHFG+/FdgMWLe68PMu50vV42yGzCRAa7sgk3A5UfvYVwx0H2RWAO9oWnF8VXO67m2rCMWLqyHRuvesXCXoSQiyOgT0rGxx2Zvwu1hWXOprf+JKrb0863dIZfPfFczoHQj1woGf5/GLTMbufP1kTl2HbAk9o6hXHlo5LaYu0PEfx9CXDxU7Okdbe420niYttZdgyNuLU9SlhXV1k2/qWm0XSvAjVLlnEomRaWpdzwrqyYmF1WIJQNT75nCmSNe2NGM2isbupVHtIoeyno6ykpWur2P5mNu7VnmGQOPAsLBj9W5F8swnwm+APo6xI0p67aIfunk+73ZIcOjFUApjjKgu1uZnrZn1oN4Xjb5KKZALGT8hz7vfVoQPlcxuNHSdFLZHkcH4DtK0xJycOvjLBY6phpe/Yt84BIeikmqovsN5sURul89MTGZ1sJ0fIxEqiTqlHKxDj/h6o3QH/k/OCyIdhKqeefecXX8lG7tNA5gUAb6dH927PsRNYP2H6TjvmwDmKKNYBmd6aKFuMnURKwrxYxXoHxn08EBmtaoVeAjpPuedYxMl5xadezEnyvaMYprV5Xbm319s0w9oTbr6RYiJNJI3P+siVW+OTZ/D51wzvPGFuMm7f6nala/jcqzlJ5hZvZefuJpJ+GuEpzeF24Ji1xdfaFOxU7WQKfM+nWa0jhGMius4v8JRHvVJzYel5NmbVSOFAmK3hwkmW8fBvfZbHH/4i3/lX/zqf/KVf4Nd/5Zf529//g3i+TxRV+Ovf9Ze45fQZfuhf/VuG3Q4//IM/wDDL+IN/9E/wyssv8/1/92/xJ//cd3Dfg+/m53/6v/DsU09y9u0PjO/jFazP3/rM/+QH/+Hf5Tu/56/xjgffzc/815/gb/6V7+b//qlf4E99x3fz8z/1k3z8h/8VzVZ7U3198pd/kX/3w/+MP/89f5U733Y3n/zlX+Af/I3/g3/14z/J4YOHMNbyk//x3/Fdf/Wvc/TkSX7kB/8R/+aH/xn/8J/9S1554QX+04/9KH/9e/8/3Hnn2/jZ//IT/OPv/dv8zC//Jkqq8fRgTI1+PESbnEh6dLyAA0t3YlSFeX/IgfYq/cvnaVYCqkGd/mCAH4b0RgnpIC7a0LE+y1A+cDwPx2AGsByeO8DX3fs+6lGFNEuI0xghPeqVJvXKXQRS4ns+/XhE6FcJlcBKQbPWIM0zRlnCWr/DXL3FA6fP8vrKZQ62Fji+cJjbj95CPaqhpEIIS2fY4fPPP85Lly/w2mqHdrVCsxKO9abyQjvVFlIPSZaN2XhKSXQRp1ROrBKXqEYIB85GQpGkLnnPsVaVc72U1f6QUaZR2lAJA+ZrIVfynDTTVAPHANaFZMJ8AZj0kwwrXD1FngtPLkE3KV3o7NH5AySZZbERsjHssNG1ZDi27dpgSG4MF9f7+EqOQZZMa3xPERTM4mQLuDi9CLc49vqR+YPcfcs7WGzMUQmqSKmIs5hhIsm0JdcZ62X9nznLyiPLJLmrx1GaMz8/x6kDPoM848r6CnYHkX1fClTBKpRFXVqcBMhCNSC2Et+rUI3miLOE1c4qC1uYdMcWDvGBe95DParQGw1IsozI92nV2rz7rnfTf+KzvL58adPzbTWBe9lnxiU6xFqMyDjdbPMtD95NONrg9O33cW7DZ2lh6CRCrGW9v8GjLz7O62tXEUiiAPLYJcrKdlg9SBxrP/AEWZ5jkRybb/Laagdr7FjfOzeWzDi94yx3yfXuOXoLI9Pk9hMNvAKQ6o36vHTpNc6tXmK5szbW8n7v6RO8urZBNoI/9dD9fOnCMv/9iRexOqdRq3KgUeXiyjorcUaeO23nzFg6o4RmVVELq9SiyUu53KgpqZivtxnEI6IgdJIq1nKlOxhL0hjrHCElM9X3FMM0JbeWQMKppTkEgrVej8Q4zc8012jrQPW8ALHjggn6NW+7h0oYsTHsFuxwg7SW9X6Hdq3Fe+54J0oZamHDZSc2mjQbcmn1Vfr9PuDKk2Q5spjzh5lirrFEvRKQ5UPqUQA2YmAOUavUOXlcYIzhpx/tcu5qzG2LDW45dpRLnR5PvXqeC73EOaK0AWuIfMUwzRECDjRrKCnpxylxmtKMQuZrFS6sd1kbprDWYalRpeZ7JCYn0y4qwgrHeK4HHpc3+mTaJeHLtEFrpwt+5vAp6pUa/dGAlc4l5uptWlGFuUZIb9Dh+WFMqxZQDX08KYl17hyW1hSbEc25tR7DJCU3FiFcAsCFxhyRF+B5cHl9xTGzPYmSkma1RaACQOOrPuv9kUtemGZUAh8tHQDay1MOtw9wzy33cX49pR5IkmxAbiRLrUU+dPa9fPIJ5+DR1vDaxoCXN15xrA3hkjksNap0RwnDJOXIfI3Feo1RlqGt5ehcg1sW28RJTGoFtx2cp12NuFwAt9Za6rU53nXnu6kEEcN4yCDLUMrjcOFgeuylR6n4Ka8ub3BLK+L2E0cBQRIPeWFt6DTEjSHXlmGSkWmnaS+Bl66u06wEVKRAj2KudAckWU7Vk/z9//YpQr9Gs7aIShOubKzuuvE2UESrFC8SGXLq4FFeW+9yubPsNhbGkNicYZoReh6H6yH9Qrv5Jut2uw2HQ1577TV+8id/ko9//OMsLy/zd/7O36FSqfDt3/7tM19H652dPjfarLW8cFXzenYUr2epBeCT4suI5Z5jKBnrMxcwJhiUIKMuQmC3Xg/c5lngNsXLvQKA2am7FBtJiyDJ7Vg+INMQKENvKllSeYLASREMCwbcctfJMgmcRmcgJjkhyp8G6TQ3ZTGHsbmOy8/NQBOJhGFWwZOTtUn57snxOFKDD5wRrA0sz7xwkTtvuRWwPNsTrPRyFuqKVmhoyCGt0LCu7bhsQthNa5zymaRwYbO5hv4o4x3HQk7MWZ56asSljZxnl2F1wFQGeM2dS5vLXn621rLa1/RMlZVeTinlWx5X/szznI2CYe3KbcdJzcpj+qbCF17VLuQ5n4DMuQFDSJC5turn0LGH+NQLmrmq4Y4lyzH/MmnlNGtDB06IFBZqljsPwJVXR05PuDcBHSZA4XZgQRt3zxW9wKde0AUjcpopuPN6qhZAI4CNPGN9GPLyimZ96AAhmIRY72crA1h92SDtMVZe0LQrDri7tJHz3LJLVpThTwHQ0yxjBwAq66Jgyt+Xe2XCHsGVruVqNxsDNDv1zemfpfPDaEdoURjm1QY2rLEx3FynW1mWu9lWELsEXfaz6SrsxNCOJus0T0LNx+1JlKIWwHAQ48uAlb6hM3QOgGEGSphCZ1URpw7MjW1ATUDdz8cyGtN1U9b/+tAyyo6w8oLGL5xGqmDNmikm37Q5oMYd24mhHtgi18N2QdeJs9olSzq3Acoc4fRGzuH29jYaj5syIZd1kWQrA0ueHeLSLufV5YjTx+C5ZafTnBGQ5A7gtxZkIZ1W1lOaWzxpGRVsyUgxZsh60t277JJCsE0Co7SJFq1LHPXyimaQuIRj60MHqpfRkXv1BCnEJodBxYN3HnPjfWvdpEXyx/J9M103QqpxOL61dqwT6xfgc3kPg5MxwMIwl8RZEX24pb0FBlkkC7MI+jFUfeOiOKxy2s5FPxE4B1paRHu4Onb9dH1oWelrWqGr1ek59PkrORe6sD6Ajp7f0+EBmwHoUQqR52REmgoeOZezNoA4PcqV5zTzVQhMBa01SinOHoIvvG4LxvT2uc8jAxFscmztFZmwrWy2WB8yLani/h95liNNy8U15+gROA1tad148hQYnZEXsi2lSQF3LEHYucrBYwc29XHPwKEm+P3znD18BildZMzFIopBiJ21eSMludKz5OkRoldzeqlzsozSY1x+TlMPYCM7jMJJI2Tl1CEcqz7TkBLi6Uk9SaAbW37rlYx3nVQcbLx569xrWefdBG63mLWWpy+5xUkzcl6PJNMYawiUJc4ll/shh9uFzm3BxvOUR6Napzfsk+UZtbDiAASti1DRQh5B446t1NyxOi/o3rbQtbT86D/5IX7sX/xTANIkIQhD/pdv/sN8zYc/wid/6Rd44KH3cMfd9wDwxKOPcPXKZf7xv/w3+J5HJfD4s9/53fzgP/w+/vAf/5P82i//Inffez+/71v+CNbCn/muv8TDn/ut8fNKKcYyB7/4sz/Fhz/6e/kD3/KtYC3/+3f/ZXzfZzQY0Gg0kFIxN+8SkDjPnqQSRHzi536Wb/62P843fdO3goDbb7uLpx57jJ/76f/Kd373XwTggx/9Bt77tR9ACPgDf/jb+Mff+7dRUrBy9QoCwalbbuXYsZP8me/4bt73tV/ngKpyLWYLDZRq3clNpDHWWjrDHloZqkGF9935boZxxvm1FVrVEN8aNtIhcZZTDTw8LIv1GufWJr7CYZIReMrpTGlNrg0fuf8slSBktbdBLaxQCV04dn/U41D7YLG3GBD6PlJ6hQyEE3Rv1ZqMNpYL5teQI3MH+KPv//3M1Vu0qnUQgiRL2Oh3ActiY4GP3Pd+jPmfdAbrhJ5kmOZ0Mk27YDflxjp2Y5aPQTe9JXuV2zO7qSb0PZQUrCYpEXDm4Dy//swrnO8M8YOQw+0Gl9e7+EWIbXeY4gnBKMtpWZdMTwkHXDUrDRZaBxmlCc3IcC7NSHLDSCcu4ZCFucYCd9/yDubrbTfBW8Nab4PPv/AYa+tX8ZTi9sPHWKpGxNbw7IVzjlWjDbUwoBJ42FzjeR5hUMPgOTC068KIpxcHxxYO8eF730ctjEjyjEoo0CYn9AKWWvMsd9aIswSBYBgPWWrN0661ubSxytGFQ5w9dS8H20sEykNJWOut8cknv8jrK5cde81TKFyCPWMcS9VXEq0NK113vdNHD3L8wEl8LwLcGHCh3eUiyjHpqmGFShCy0l0vuzBJnpEPuzQqDR649R5eW740fratm41S7sDiJEdOLR1ilGQ0KgHNiuCJc1d44MAir65XSHPnEV4b9mjV6hyeO8D8ve/n6sbLfOn8a3zp4jK+FFTDgGa1jcUxY9f7606v2xjqUcCB1gKj1BBnCbcfarE+GNEbuYRhnpRkec4wyfCkk0M4sXAIFR5hTvl0hwNyqZirN1lsznHqwDG6owGX16/y6MtPcWntMv004dRim0de7PDylTW+/WveweVOn7jf49ZjR2hEIS8oy+NXu1ztDpwUCA4wHqYJlXCSyXQa8LbWLRKrYUiap2NZl9wY5qshKwXI6EvJofYiSiq01SjRQdVqVIMQJSWXNlboj1JsIWXgKYUuGLnlYj3ThqXWAgvNeXrDAdpqAs93/dga0jwjzTKOLBwiy1MGcZ/uaISUHvP1Nq36ffgqYpT1GXZWSTLN8cVDLM7dSTWss9C+A2sN3VGXle4yxxdOUo0qZHlMmqYozyfwqxyYO8PrwwH9JOVwq8Fz0jFBk1yzPhg57NZCuxqyMRihhODYXJNenLDe6/O2o0ss94b04pSs0FDFWkZxhlCSxXqFfpyBNbz/tuMcbjf4xGPPcHmYkhaA8/2n7uZ9dz5ALaoUTkxbJDfLXFSHsKx0VxlmjxH6GYFSSCnItZtnrHLRFHnuNs5z1TaLTY/FZpvjS8fG7FQwdAYdvvjC4yileM8d91OvNLDWJcFLswG/9PDneG3lIhZLkucMsxy38La888xZIj9kY9BltevmzgPNCv0kpRpGPHT7ffzqY59CG8Mo0/ieYw/kxhYSL4qTBw5RCUd4Ei5s9BjEKcMk5dMvnOPMoVu47didrA8H/Oazr/LALYeRxtKLE168ssZdJ+6mFlbojXqkpVRSIfHRrjW57eht5OnrdGLQKuDCesa5tSv0BwmtKKCPINE50rgFdLMacXKhxYXVDUba0BklrGuNGiYIoF2tcKi1wNtO3k2z0sQljtEsFwzf86uT5KfT848QsNBc4rELPpaQ+297N3dmGau9dR556SnOr1wqFv2WYZpxoav5sd94hC++fIlvuO+2m8nJtpjnefT7fX7oh36Io0ePAnDx4kV+4id+4pqA2yeffPLNKuLY+qbC1WyBnq1jCEhSTZIaAqEYDbvkRpJSRSHo9rpFOL9Pf6ALMMC5Y7XRRUh0CN2B04EloCoSzr34Emu6BRwl1zlO8KtI+ruJZmkZDWMSNJKIwSgjGWUkTiiE1BSUOJRjmA/Lt0GNT3wppiJiPBQbg5iA1LH/UGx0+wgMOQFBssFrz50fM4mm63j685JX4Xzis5wovCIgdL3bJ8fDQ+P3X+KJJ0ZFDVT4n89sMLIRlqO8/rQrywF/lbqEJ554kpEJURxmvZ8QkGCJsCjSPMNBoQJhMkb9EakIqMmYzvkXeOqCa6MvPRe70HcAFL1Y04/h0lrGCb+yqey/9fiLLOcLxDbEcoTzXxoRiYQlb/NxfVPh5x7ZYGQiDMdcuWXMAc+V+8knn8RaWM6PMcxilM3JqCAwWFNG5Ug2YoMsfrMIktGAC7Hi8ppmQYX0OhskJsIiSZKY9Szmpf4qUOHnH9mgZypQqHhP1kJbV0Yuqa/UCb7ISeOcrg0AvzjP7nIepMmIXpohgVEc88Ira4z0PD6Gbq9LZjxcKG7Zvyb3nP5sbZF7AUEa97kYe2CP8PpzsQvbRSEKoYtJDJPGQUZunEzkqyxlcLMDYAPyzPILT2UsqVWaqsoXHn+eSCQIwbZ2+/lHNsbt+9rTCYYyo/widOJCezJCON7tOBx6O7yz+RkTvft3e523yfIR3QFYArqDESGJqxvhI7Ku0yYVMBp2nf4sIR4SHSf0Y4VzcUQMx+PbZ3lg+P99MeeQd5Ulb1IffVPh2ecGaNw49TGkcU7P+lgCclOicWqHsrp+o4u2ijPDKCthmzIGaxfOsc0xVqAJ+fRzPc4Er22aU8px009TB3whcQnvNBKDwOdzz29wi7/zXHTl1adoWQhtSO4rPK2xOWzkx9DW40o3xcWCVYj7GlFIrQDEoz5p7Fq82+uSGB9w+5Ysz7fUx8QyU2rxC6zJWenmeORECGIrSHRZJ1sZiJO6URisnVwHJNHoAlde7Wyrm2Hm5ulROukP1oIm4HPPb3BALhPnx5F4bHT7xRiKMCYrWsWVI7AJKs8Z2QjwEGhyW46/6XYTaJ2Nx0JqDJc6unBwRON6tCiM1awNzKbvJJoAwSiOeeqZi/hC0zNz/MzDXVIbkHOcF18xzllJiiXc3m926H9l2XrDhL6wCGtZ7SXkuLEg8Ogmml5i8ThG8ujrzMkOCSELqs26bpHj8qQUrUdQjDkXZW2wY8hv9jE9YamrsaMTJMpmPPrigJiIDA+TTp5BF5tXj6you+kJRSBszitXM475FdjSx1WuoQdaqPHc59sKikOs9Nz7JyUYA50S53xbG1gMCkPIE5ftuA4siiwx9BIBVBDF2sYnReKSz4HBFC7ffLy+cPl/RokmSSyffWa4aZx+Je0mcLvFSlp+tdDHmnYZCSGIfCdY3Bk5naqyEa01KCGpRzV6cR9PeeMw6IkOrEQV7FYlJe16kyzPGSQjsjxzHcbCH/vTf4b3f/BDzpPgK9pziwS+V3jCBAcPHRmX6fL5c/S7Xf7o7/+IKyMu7DFJYga9LhfPvc6Z2+8gUH6hgyO55fSZyTON/SeC86+/xh/45m/FVy7sSFU8vuMv/FWnSVs86EQLVxH5Ia1ag9dfe4Vv/3PfOQ7/k57k7H1v5/XXXmOYusn18NFjLlO8klRqNfI8x1jLA+96iFvP3Maf+WPfzJnb7+RrP/hhvvGb/gjKU5QhA7ZgTUjh2FaJdhnRc2PpJUN6oxHtWpN3njnLLz7866x0h1gsgecxX6/QiAJGo5h2LaJdj3j+8ipxYpFSkmo9Bs2XWgssNp137MTSURfeXqz/tNHjcApjI5T0XFtKOQ5TroQR7VqTjUEXJRTNah3P81DCHWP0BGTcGHTZGHRoVBrcf+puPvHYb9IZuVDVXBuudAdUwwYnl44wShOWCyCzZGjrqX5p7IS9oY0hyVyYeaMScqBdJ8nyTRq33cGQDCdX0BmlBBJCz2O1PyTThhNLh5lv344h5MP3ncBaw0p3nX7yBC8vXxzf99jCIX7Pve+jEoR0R0OMdqDHwfYSX/+OD/HixVdYaLRZas1T8Tx8X/HQbX3+229/hlevXnJMSGNZbC1x/6330Kq1kMKxNtf76zz68tO8dvXCWNvywTMTUD0KnDidNgaNwVce7VqTqx2XGC7Lc6phlcAPObpwiN/3wAdpVRuMEwUKwYH2YX7fOz/EJx/9FBc3lsfMyUQ7dirFsUutJe46fieH2os0KnWEECRZSj8e0iwY1LnWXO245EtHFw5Rj6qsdNfc+C/qq0wE14uHLqy/tcCVQueybNvyWG2drMbxhcPcd8sZKmHVaVD6CkXK0+ee5aVhk+N1zXxNoUREd9BnkCR4KkWpkFbjCKv9Z1hqzXPr4hHOHD1Fo+oArzzPudJd4dUr5/Gk5I5jp6mGFZy4gqHiaRId8bnnnysSbTlvd5y5BFjWWu6+5W485dMZdvGkz2Jzzo2pPMOTitDzOTS3xIfvex+/9tineer8MkJApx/zS0+8iEVwdK7BM50OjchlFe8nGYPE0T0OFizmLE9o11vIIsJhuqKkmMxNSii+/u1fyyef+CznVi5zfL6J7ymQFY7OH+b2Y6eYqxWyFcWFcpMXOtuaYTzi+YuvcGHtMpc3VpxOsBCEvqJVa+OrgDhLqEeRY6ZLxUK9TeiFY7ZYkqdI4RJSJnmMxRSMB4mSHpUg4p5Tb2eQDDjUX6dSeZ17T9xJLaqQZjHDJEZKj7naHEfmj6C1Jk4HWOtC1RWGQdzHUxVqzZN86pkvEAUey72YpXaDQ2GAsZbuMOZQu07oeQzjlEGak+Q5B9pHuOVASGZyVnvLxXvNFd/3agTNJlJYRkmPpdY8kRfQqrW41OlQD3yOBSHGWg7On+ahO96OFJJcZwgMvucXCcJ8tHHz6vHFCu1qm99+4QtcWLvKIE4x1nJhrUvgKzKtOTx/iAfP3Muh9hKBHxD5IcZqusM+SZZQCQInf/L2DwAQej65zlzEivDxvDofffsH+NxzD/P0uRfIx4n9LEfaiyy15t1YrfiM0qwIkRJUfKfpPd+Y48jcIhfXlxkkmtD3qfiKZqXJkflD3HfLbVTDKrpgnHf6HR55+Snm6m3ec8c7qIbVse58ksY8/soTXLhykZPC59j8AVrNOfI8IfBcEkotJg4HNxcs0o8jPnxvAyEkFsvxgx2ef+1p+tmA0IvpxglBxbLYbFIN/ULn2hIop0o3zDUKuPvoEoHf4K4T91ILKwyTEd3RaCwh843v/DpeuPwa51Yu8eyFlzfNPfeeuIP33PkONkaCyEvY6HcQ0uNQ243hTz35GV5dvjx2KCW54ekLV3ltpcOzF5f5nm94703wdsqWlpYIw3AM2gKcOnWKS5cu7XHWdjt79ixKbd9g3yi70nNSAzkgchAmw1M+xipGRrBQ9QgFJAPIrSWVTcd63LZ5d5skARg0uaoRKqhKqGWrHD9zD0ctnPtSjhCey05uStB2ykuPwKoKKKhmPcJqg1EWQuq2nptBlGmpEE21EqFtRBqP8IOIOI8cCGA1SijHErYxD93e5nB7Ea01Tz75JGfPngUYf1ZKjb/7wB21CZMvjqlEEQcq4Pdf4j33nUFKyQtXNU+9kqBFiJBgjEZKxYCIq7LNKD+P1zzGxgjSzB2XiJCKB4NUY/HHc5YRilj41AJYMhe4996zWGv5mYd7ZERjBp3WGUq5jWdqFefSw/yet1WZq8LnnniJdf+0S9DmwXDQpVprMsodEP2BO2ocbntc2sj50nMxWkRYUdZTMC43xj3j+tDy7JdGtGuRCy0fgjUGz3NJp1y0lERJFwKb5pparUbowdoILqYhtcijPV2WLOKSbZOkCUEQUhXQTabbd9IfNn9WaFVFmgFzzRr9BDbiEkqdRM9tvU4UVgi9Cp3+kCCMuO3EUQbnLWmc067XGSQwSrb36a3XDIp8JLmGeq2OEnC5l6OEx3zNJRoyJsNXPtpSOKDV1LJlumyCnZ7R4HNFH2JVZzQqvmP1Fv1NKeWY188N8MIaTQ96/QGZqE0RHdx+1K2dLQIPz3NlNtvCo3eq4zf+3d1HKhxtw7Mvvsxdt92KkDX+x4sGE/dpNZuAAxTDSpNBClbDyPhIIcfvmK33kEhyAi6ZY5DD1739ONZafv6RDbywNtZA7fa6tOt1Rhmsjcwe9V9+nvxeCySjtISaSgB352dU0itCrTWxbHDi9ntpR3Y8j6wPLV96OgHpGIeemIxbYxW5ycn9NifvWKAVmh3nIiklq33NMy+8zG233cZ8TdJ5xnCpZ4r1uitLIWYFgCSn3ayP66LZaDLMIBkW5Vau3OQ5ehMM5Pqqe1InJzhX8cbXWago+ikkucRajSedtETJjJdiKgKjSEg37tON4xw8fJwrrz41rptyTgk8l0ytLCsUDjKvTS9qYwaO7COtRCqw2qCk75K3GhA2p1mrYi1OFsFqWhWPJINhPilb2a/M1HzrUkc6Bq8xrm20UQVuIxFSOYaxzpCyeC9aRSAVw8qtbIxgmO/wDgOywtm4/7iZ/K68kAN1WN4YkIkKUpRJanOEEyckQ3FeH2dZHAcg1wmRH+B70B1lNCKfeiTI8grLfe1yKFlVyO9c75je/IxK+QxtG212ei+7z45pu7mfgkCpAFTAcr7AQ+9oo5Rita955LkLmOpRJ6uSJERhyEIN7jwAvPwSWd0lwxwlbn7zC1b5IBUI4drJjIHXnd4Fbo1ipSIXPp4eYVSANqqYHKbHuynyR7nfdRBw8vaFN02OqFxvzGI3gdstluROd9bz3UYsLzwMviw7nhhnLRWSAoSdLKoDKWnJRsFkg/JVIYVj5pVh+a5bCXzPo6nqdId9ssKD0J5rs3T4SAFUuOuHfoCSCqUUzXqDdq05BkhOnDzF9/3AP3UeDs+dY6ylVm8jkHjKo1ltFNq5mrBgmHnKG0+4nvLwfNcdphOOCeVhrBn/rVmtuyRhlgLYEgRBWCyZJpmrrZ0AidY6FqMDW6euVWkQNHz+9X/8zzz2yBf57P/4TX7p53+Gn/3p/8y//U8/xdKBg0WNT8AZQZHcDEHoh8RWkOYpSZZyZP4gdxw5xVOvv+jAJq2hYAe1iizfUgpOLDR56coqJxebCCr005xBkhBIfxyOLSgWOLZYKspJ24HLGO+AajFODgew2JxjrtYcS2MMRkPmG22MtfieW5QooVhszjNMRvRHDsRbbM5zeWMFIQTH5g7w7jveTrvWwlj3HKu9dX77pSc5t3xpU6K40paaDuQCTW/UZaEacnSuyeurHUJPOY3b/ojA9/CVZJS6RGjgQkF6cUyqDScWDnPf6QdQqoovLFobrJAstRb44Nn3kD7+mTFjqwRS1/rOi1rxQxaaLXwvoCEki3e+A61deTaGXRYbTSpRk9/79q/hlx79NK+vXOLI/ALvvevdREE01qkNfZ9D7SU+eM97+MRjn+bc6mUOFKB6r0gHW/bJsl/kxjEfA88nzTOU55EbTZwm/J773sd8vYWxjhFbMjQ9pWhXW7zrjgf4yU//QnFdwFqncSsFpw8c4f1vezee8gn9EGsturjXYnMOay1JluIVwPHljWUG8ZBmpU49qjGIh5sbCgeaqrBKxZ/oQ1omQGWz1uC2Qyc4uniYRlQktNI5w3hIP07wlc+JpbuQSnFhbY3eKGCpUaUd+azGuQsRkgmh3+CDZz9Iu96iHtXGwKdjrFrm6i3uOHLruAxJlrLed8nEoqDJg7e9k+5gyCsrlx3L0jj9U19IbjlwiMXmHKNkhLGw0JzD9zzyIjzTZaD3WB90qIUV7r/1Hj7/3OdYatYg8omRPHNpmRMLxzlx6Hau9iHL1njqSofF1iIfu/Ush+YO4HvOARano/FLeJzGRm7W9wRo11r8nnvfx288+VkOtpucPnyGRqVNq9ZwGwJcAsPSyZTrnLV+h0alxkJjjmOLh+mNBlzZWObzLzyOLyUfuuedVKL6eCyOkhGB8mm0625On1rcqGKO18XiwRhD4IUsNueRwgHFonDOzNXm+MDbDpPlOXHm5BM8KZGFUyzyQ4xnCH2/iMzokeYZudZIaZlrzJHkHqPcUqsuEOeabtzHk4Ja4LSmF5tNbjkQcnDuCGdvuZNKEI3n6btP3Mv//NJvc7WzyoNn7mWx6RiuUoixg9HiQIhetsJ63kEIwXvvuJ8TB04UGyw3r5UOpdKkkKR5gicVzWqDM0fv4pFXX6IWBCxUfDKh6AxHHJw7xO99x4do1eoI3H0FTm94oTHnxjmWPM9oViKcvm1G6EfUhRi3Yy2Cj7z9azl16OQmVulSe9G9J7KUQaG3rI0tvOpOpqEiFdpKhmmGttCqzfHA6bMcai/RLCIl0iyl3++Qac1ia4Gvf8eHqEcOsM10Ptaoj4KIB297kMivMkyW3aJfKtLMzbWe8vGUYyZmeYYnFO1ag2alXjgqndXCCo2owROvPkovvuQcBXlGkmuGWU499JmvhHhBQKJ9ciPAGnpJygPHbqcSVumOXPSPk3kJaVUbeMrj3c027zxzlsFoyKeffZirnVUeuv1eTh04ge95ZNoluVMqIM3TMTP4npN388KVi8Us5pbxnVFCnGl6ryT8+Gef4O/8wQ/elE0o7L777iNJEl555RVOnToFwMsvv7wJyJ3FlFJvGnBrrdMXTLWgElhGOZSbHE9CagSDFBpjXT23URfbCY2UZxarx7FuJMKFtf+Pl5weqkKj8YokZpP7TVtmnPPysOpw7y1tHjuvZ8hmLgk8FxJ8JXaJrOy4PFNhnlbQz+QmneHp+t1a34fbHkfnp7Rqb5skAFsZSp65bHh9vdikWsYhyGVddGPocoj6EKo+5CLBr4T0EhhkFAyyshbc2mR6Ly+l5NU1l0gF4eoQpuQphVu3jKjwqZdhoQor46Q77iIjAYEn8JXTZ3xuWXBkTvD4JUisX8gllYCISzDXS0BzACEEayNBbktAhyJ8VqLLvlAWZYrrIgvtSGMsBknkuTKMROn4KZOFBeQpY4mw/cztK8Ba5+x1mqcFcLuZazNllmEm6CeQE5Fn8MqqpRJAdxRyuVdGd+09d0kxeUYLpMa1R6mxmZmyzwkys1nXcsdi7WM5Cl/Bch+y9AgH1wRnFi0Pn4fUBkTShSMnBFtC18Wm3w2FZuv1FOI67cU12Egc1LTY8LjaFxhrHNO0XLdbRRwzFYK9t5W8vdzABXOI19ctzUiMkxHKUoPfKtZHTtIDpueB/cziK0FUc5IYUPRLu7M0wHguxKINrI8kC4XsrFKKzEw0dv2pcVuCcdoI4gwyLcZzzvTcszKUPHvFsj4skoy94sK8XXLHCZYwJjmNn6IsVzG3CEHVt2yISXj5fhU+TkYmxbjyIr/UVLX0hjnvvdWjGcGvPj0koVqQnBzrfLrCfeV0jX/7PMyZCkq5ZOAWl1Bteu0IbhxlVrmEgzh5iPWhQSPHsjzTesUCycqgnJcAJBujzW2+31h076NCHmHqAFWMeV2MKTf23fvl4jiAd+fKvJ7h5nvu+ePCSafkZL4tXwsW1x/LJJ/go3OXVKuce5xObvn2257w8dpt8p6yWFI9yfOy33lbj0k1SAu5qfDKuuTChuFyD4b5YeiWd/IxGYw6TobhAPC1pwWff83ywlVD4DkHTz917TEZo/vPJMaAFWDxmKs4fdvtSgVi8n6zLiHh9Dj9StpN4HaLhZ5LVJMbUNI6/bbxaBFj/RdfyUKvs1xuTbpmCfJJa4rkY5MNvWCyzS81XKW11KMq/VEfhEuE1qw0kFIWQGWRtMWWPcviex6hH3Dyllu5cuUSrfYc9bpjAz78hc/xK7/4c/zN7/04p87cxlOPP4YugEYlFa+98hJ33vk22rUmnvKKTTccO36SF194bvwceZ7zx/7QN/A3v+/jmALskkKMk8uUz3Hi5C08/dTjfM0HP1z8XfD0k09w39vfQVhmvRYuA3aS52OgO/RDnn7yMR754uf5k3/mz/PAOx/if/+uv8w3fvT9PPHYw3z4o793xzaS0jFd5xttqiYYAwxSSL727oc4c/gUXyg271e6Q04sHuDk0jxKVYCE2w8vkuUBD972dhrVJklmyI3LDl6LomJhOmlP54ixY7ZmbjSmAKTVlk2qKEBwimu0ag0HhsgpYLtwCIV+SOAFZHnGobklLqxe5fDcQb7m7vfQqtacyPxwhJCSI/MH+HDtvXzysc9wbvXyuLcdWzjEu86cZbE5j5IutKMf97h69SUaNYGwEPgeR5tVzvVdWE1UmcPIlFG6SuApjNZ4UtGIQt59x320q02k5zzEvuf6ttYa3wt48MxZzm8BUkXRlgfaC/gFs7vsHUopmtUWA+mTaENATOiHPHjmLCvdFb7u7Hto15v0RwOMdWHEmc7pjXrM1+f46P1fw2effZhBEjsNVe1WYlmekeYZoR+M2dBKSiLfhcvXoyqX15fxPcnR+YOAGIfulG2Ta42vBMfmD3Hb4VObGGgA8415HrzjnVSDCmke46uaazcvmPR+AZUgItN5ARwHRbioJvQCQj8gLkAbbe3YASOAYZaM2/DBM2c53F4i9EMqYaF1LSZOCyUdmJfpnCRLCgDI42qnxzB12sVKKBqVlnPIWPeCqYaVsZTHuI9uWSQ5ve2U0Hdg9DDpAym+F/HQHQ+QmS/y0pWL7sUvLO1qyLEFB/KpQHKwvTTu80o6zeIsz4o3nqAzGrDYnOf2w0eoVxoYLWjV5zh58DhSBuPxNkhGPJDMcdfxMzQLZnPJcq8VjONM603Osq2vaCkl9UqN9971TkI/IPIjKmE0Bq0FAlEKnuFka5Za8+Rak+kMJZyT7EB7kd/7wAcLB5FHksb0RjFKKRrVBtWoMp6/p4Hb8rMnFbWojqcCpFBF4knhyiGgXWuS6YzAC5xu10ijlCTwA5q19hgULaYeAs+nXWuz0ltD5zk6z2hWG3zo3vfRqNTwlYc2OVc7qzx17hmO1kJOHXsbYVAj9EIqUQWKd0iSZ0ghqYYVPnL/++nHQwfOjoZ4UhXj2LWnLhwdpw4e59DcEiCoBpVJfQqx6fmn+5iSirQYF0fmDjJfn2cY9/CVYr5exRrNB+5+F3P1pgP7rUGhJv1TOBa1tRbpy7Ecg8B51UuQF+H6j5KSYwuHWGrO8/KVcyw152nXmtSiKhU/ItMZnWGPLE8K3WXlNJOtpTsaYq0bi1939r1EQUglLFj9WuMrj4XmHMudNdb7HW45cBwpBMM0Lt6L7l1tLfiex/23nmWlt8YwHgEC5QXUwyqiYGNba0nzjKBw5lmhx4lKVeEQrEZ1bjtyF0naxWJ59NVLKD/h+HzLjbXqPKeP3km71hqvOQLPpxpGGGuo+CFJnpJmGXP11tS4d8B4s1rnY/d/Db14gCjGTpJneFLiK5+F5hwb/Q3iLCXNUg7PH+TOI7fy3MWXC3klWyS4M/TinE89+wrn1t7OycX2tv7wu9FuvfVWPvjBD/I3/sbf4O/9vb/H8vIy//pf/2u+4zu+4ytdtLGNE79ISy8uN3eq0GB1x2Qal5W+OGey5Nk+7gM1pcuOY7hWfUhiSzcuN9XBnru9Uo9RSujndQ7U4cGTiotP6G28nq0WZ+CFbpNrtAMMnFblZC7V+Hz+VcOFTsZdB68/4UiZ6GSQuE1/aSVwnW9StJLuuZSr11ogqHiWyz23rV2ouroZDBNqUYVIQTeBc+khPvGsZn1UJA6ybtPrFdqd2bbNpgP5Bra6KelOaUIIPHI2RpZXVpzmsEWgCi3Mci9QJpbp2wq/+pzTF87xWOlP5zOSU+DJpC9o60KlA6UcAF8QWCwuy3tqfPqDzeCIoUzGtr8VyxAHnuTl3V04s7Vl0i+N3bS9dUlxys/WwoVOAWhMZVbfzjLbDv6UCbZA0ovLhGNiTNhyIIvas4/PYg4vEA6AspAR8tmXDZ95aZIBfm1YHrf/Vn5WDd8bY474sDqwZNkhrvQsYVHNufVItdOwLhMZKTlJxqeEA1XyffqDQfEbL7rkTdr643FeJjFknIBpp7D+3UyMk7o5HVfj9h27JDIseB7u+hbslnvFBZBWOrC29gmBLfIvbL/2dCKlijdJMna5WwK3FjkGxaZBtcnYmE7kJoQo5B4LXWrjkrFtNoMoGLfg9H4zbamHm68T+ZaBsFQDyWJdcNy/xEVOu6Rz257RMFdRhJ6gG1uW8wVc8nb3/NPJ6HKrWBsWCSoJwTqWeKAma+udurHFoO31z+XldZ08gqu3uGDq5hbYAYx+M0xg8JXTEjZICvRk37FQOmpc+0tS7aIXvGIqcxIu11umIpGodU6S0IOrjmdy3dVhKQF+j0fPGUbZZtC17H9urQ/dEfQ5xrnHLEnmxv4EtHZnTDsuyivtVr6SU2mLd9huzr7yXVHO7fslNP1y2U3gdovNVQXtimBlYKn5Yz8u1rqZN9HQjsTYk13a9Oa1XCQq6WFMOk4+tuMGtwBmQj/A9+aQQhIGIb7nb1lwgSc8B+QK6TaKQvCuh97HwUOH+fjf+z/59j//3QwHfX7o49/LO9/9XjzP4xv/4Lfw0//5x/nx//BjfOjD38DP/cx/4cqliyCc91MJOV6hf/O3/q/8le/6s9x7/zu49/538NM/+eMYY7jzzntYvnqVfq/Ha6++wqHDR4rx5c771j/+p/j+7/tb3HLqNHfdcy+/9HP/Dy+98Cx/63s/jpLeePC0qiFx6sCk8pmCIODf/9i/ZH5hgXe+67089sgXGY2GnL7tjl3bqNxQGGPGjDeLY2FmOndhtfe9j8dffZZTB46y2Jwn8jwqkY8xMfX0Kl9z993UK1WG6Yj1/oBaVOXkwtFNgETJzts6pj2pSI1xzIi9TAh85RdhCtM6NhTtKJBK4SuPd9x6L4fnDtOuNWnVmo4RLRXzjTJTcka7GvCRAsh89sLLTqrgPidV0B8NsVZTjSIWGwvUwhrSXOHUgTnSLCcVdT549m7m6/OAA99Xuqssd1bROuPIfJWDjYCwOo9QPtPTXglG16TixOJhDrQWODy3RCUIx0yyhUYbX/nb9nICB+A0q41CZsKg8xFHFw7znd/wJ1HKvZpqYdVJMvTWscYy32ijpKJeqfNND32MYTLCWounPDKdYa1lY9DlYHuB0A/G42iu3qJZbdAZ9nh9+SIfvf8DBH5QADvBuI9YC77ykAXz/KP3v5/7T93FC5deI80zzhw6wYmlI9SjqltkFIDrTtnAS8DEacVWSDIXDh4ojzKBYeSHzNebBF6AlIpMZ7z/znfw6vJFHjxzllbVOWo8OQVc7WBKSkIvwBafq0GFXjzAGJ/FVhMpnQ6RLPqcYxYHu14PKI6RY4C3FjVQSmBRtJsH+PD9H+KBwQZfev0lVrorYBNWuz3uPuFTr0yy2pZbHiEEgR+4sHBjyPOcemOOB+94v+sjTJiSxmriLMNTilpU5aE73j7uQ9baceKjclw6gFJvA0zL4z2pUL7k2MJhhsmIzrDnGPBMnDFKSKxw11ayBNwyjLFY4cKKhv0RS00X9n1p7TJCCrQ1GG2J05i5emvcv3czT3qocMLItcV/rq/i+m1RV/VKjVGaUK80kaJoC8pzS+1pRaPSYJDE1KMa9ahKNYzG7xaLpV6pc3zxsJPukYqNQlO5bByJKhySmiTTVIKIVqXOS1deRwAHWvNj0BbhwDytNUJImpXG+DlmMd/zUFI6B4nncWzhII+/usbVgSaIQh66435OLB4GIcgKMHkshzFlm8Hh4r1VzPuToeLmmcALaFRqHGgtFLIxCWmW4iufwPeZb7TpDfsEXg2pPEJfkJmc9931AJ9/7nEeOHOWegGERwUjXsliLCFZaLTpjXpjZ2HkuySlZb8v57gSpG9WG1SCCr6nMMaQGT1OAlbxQzzPRb24OcTpk8kCiLbWsthcoBY1udzpcbB9CIHmwkaPQ+0D3HfmPiI/YhAPkEKx1JovEo1KMp3jHGoBtULKYdNYKfuoUrSqdS6tX6UaVop50jm5lJQ0a02aBataCcVH738/bzt+hi+++CQXVi8Reh6ekvRHKVc6A166snYTuJ2yH/zBH+Tv//2/zx/9o3+USqXCH//jf5w/8Sf+xFe6WGNLcpedOckotGkZz1K22EiJAiwsw15N8bedzCX1c+eBSziT5JAQ7VEK1+d8CeiYVq1SJMq0dLKQ9RGsDaaP3t06MfTiAjjDbQZFQbqYXn3lBq50LesDTS2f25atezoj9QvLhgsdzcbQjrOetyLHai2ZjDs/1bQ5AG6YAtYnLXbZJXuzl5ZASkBnBB1KALDKpe40WO7+7kBIOTUrUqwJIFTQT12Sm1q4vbYkhiSHh8+bAngVY6B+PM+K8poOSGmG0J/Sz9zNyvb3RQoEGFMmtnGb71yDLgCZ67VpcGp9OPk8XQZwSey2No3bxWmU9JxswNTfoXQLzmrWSZsZd56x0E9uDEA6DTpkumQjbwWntoMVbxUrHQCNEJYTxaPnNKHvHCsZEVnfMYU1Cr/oayWQX4a/z2puLCiW+y5ZkrGM5yh3zdkZcqJo00xP+lEjAO071t/eZ8IrK5ZmVDqJLGnueqexjmE43bvK+VWKzQBree5yvuCkTiJ3nBClU2xyz0lQuAOYlXRjLLcOgJbCJYfLtGWUCxoRVIbrdO38NnaiA+e2R7ENM8eM94t5K/DKd4XFV5a1IQxNhFBOCiKfuoCYuoNb81g6iZvT5yoQiYRRVsFXE8Bd6OIkWxKlHCMSph2DWx0sO7fxXuDdTseCpVlxbZL23Up3S0qZN9Usks5o8mS5cY6oEgoq+8BONr1jNwYaoWCQuP6nrXMnXA/p1mEr7qeU5fvuWubJvUw6mZRdvs3M5LkMAfkOycSdbZ8HZ2kzg6Qb78ZG3rq/dE6it4LdBG63mBCCuw8rPvdqTj8taPJKYozzngUenFrceYM5fQ330zG6jN0OMmw7p5jASyvDwDdv+ic2BjI8n+//oR/hn/zjf8h3/9k/QaVa5YO/56N891/8awgEx0/cwvf/0I/wL/6/389/+vc/xtd84Ot46L1fg8CxuKYlCN7+jgf5y3/tb/Mf/82PsrqyzJ1vu5sf+Kc/ShRVeNe738vR4yf4s//rt/DP/9V/3PQ0H/7IN7C2usK/+dF/ztrqCmduv5Mf+uF/w8lbbmUQD4rncdorgR/hyUm3u/3Ot/E3/s4/4D/8m/+Lf/ID/4CDh47wt7/vH3HLqdP7tFQBoBYlcawnRbvWJMlSQj/kQ2cfctm+tdN49DywNqDdvIVc58TpEE+6zXw9qm5rI4FAyCK8Z6q9PeWNGU57t+kE5Jiu5/I2UigoAF0pJLcfOYXvFXVjJ0C0FJJqVEEgqEUV/tBDH6M3GjBIhoR+wHohVeBJpzs0SkfUwhqePMrBeo0waPLgibfRKljc5fXn6i1uO3oaW8gOaJ0ReCHOy7R9ghJCUK/U+Oh976dRqY2ZbLnJiYLQYUO23CntVCECJRwYCxMgy5pyEyNZaMxPdGgp60lQLyQDfM/jameNNE+L7+QObWOph1UevO1eqgVrrmwHKSSBNw1Mu2+qQYVTB49z64HjDrAqmJFle00zVnczKV1497QdmTtALx4QegFeEWKhjaY/GnJobonTh27B9xzr3dXB3n1KCklqM+dwQRD4IXY0oFVzgJ82LimTVzA2XWja/mUXQuGL4u0lgrHUCUJQC2vUwhqH5w7TG/VZ7a3x1CtPEwVO29UYt9jdakpKTiweduMxCJ1Oq9Zjdq57HoUnTQFWaaR0QH6Z0VoV/XV6mbadPWzHoV9qDFhLkiwlCkJEock7vYibVsMrrzmRhHEOlzIrbuD7aGOJApcAJfSCfefzcfnYLPMyuZ839dkxpeuVQvrDgkSOQV5jbTHfuGSQgRew0GijpEQht/WZwCtkaXROu9Ye10lZlsDzsdYbJwQSxfhK82wMVk7eYQLpyU2yJLOuYkunTckervgelcDnnhN38IG734WngrFjQ4XROBHcfubG0aR+ymR1bmyXyRnc/Ol7ZdIaFxvlnGFzk3BkHJB/6sAJDs8dwFO+S16oNs/v5edKGOErbzJHic1jq3xnWyDwA1a6azQqteI5zdgxUzoMpuup7H+Gct5x1zp1+G7uOhECskgytkLghUXCtQ6B595hpb505IfOwZVnYIxjmG8xKcSmOdE5g2wRUWOKupVU/GjiJBFQCSucPnSSpdYCn3j0U8RpDwDfkwySjNX+VmmY393WaDT4gR/4ga90MXa1QFnSvNi4iAmYMDHH5OnGk2G/10a23GhN/7+zJ+DhbLHmNuWdbkagqsWYcD3vStfywrKZddqZSpZWpIUqN73FPwOF7A2MMujYQ/yPFzXtisAzFa70nHzE+tDQT4/y8ivu/dQIXdbzQEUs96Fvq6j8GpiitmRrRqR9x+pz50ryMThnx5vk0gS73WOyzzAFqB6ost5d1uysyGQ/bZn1yHLwxtcs51G3kVUFwFTWW+gVZZ2BtehLaEQQD4uoPGHHTMpkivH6Rmy6brYyfm3xT2GoRopGAJd77l3g5l4oXzPTpfAK/kqqNdeyLRaiZGa6+6ZvOByZ8XNMf84LJvyWu+8hDfGVNYtgYwB9BdoKrvSgEkA9hI2hk19LcwdUGQOmcGII65j614S4je/pnERlqHz5t92sbLfSBBQyDnLqO0E/hYpfXm3vvrsRO73wKG/zqRcNKwM3h2kLJi+Z8m68lgBc5LsxVjqK1obOaVvKP5QO4ZKNuhXULt7iY3kZJQBrqQWOZZ4RkGpYrAkONASPvxpSC93cMJoCwnYDBKFkR0boAXjSIiV45Dxx0bAxhE5+EIpIAGkAO1nnZ9q9P0LfurB/BGnunmvJW2Xda9OJbdEfCodLUZZyXJbyCJbdt5dbbf/Wmpgcz6FuVeZ0W6ffZG++jbu8nYDfJXA8i5XPa3H1d8u8YLEu+e0vXaCjjtJLrr9sJSDcHc1e/9d27ev//o2aKcDxbId6nu5DAkj1l6s37G3C7oTQ/A4wrTWPPfYY999//zbNiTiOx7piUbSXp393u9I1PHUxZ2VgMEYgpXvpnF5UzNe2b8SnbRpiLXVoZwF+Jjo1k1FbbhjHAOAUkLsJ1LUWXTBQdytbedxu4a1vhmU6K3QwDfVKfQy07cSYm/maacz511/lmeEREru5fUtma1mPcZps0qHMTU7ohxjjWGQlc7k8d1LfN2bCzrULgd7vWae1N8vPJet3LyfBxqDLen8DgMALmKs3CfwAWYA0zTDn/MaARtQah57veH+7GWDeywbxiOXuGguNNpEfjjUxjS1y5oppP+vW55x8U9a30xJ2PVztwGjdasYYRmmMrzwCf8Im3RoSWDLuSoa3u/+kb+zE2Jy1DmYxVx9i8ozFGDYlE1VrqmE0/r4M997P0jxzoJT06I76KCULAF2jxgkQJ0nCdtPkKTDPSZsIChB993kty3P6owEWy1ytNT5x0u67225j3vX33DEXxf7z5LQjZcK+L8Z9AXwKIegMe4S+T+RP5oi9ymCKNgHoDLvF8wlynY/BOscCNpv63a7Pa20Buu7fptN9b9MrWWyfy621m/4+AaO3X3O/+aO09X6HJE851F7a99jrMWMtP/3Z/8bB9kHed9e7Znof7mXjOVJufpdtmsML+QUKWQJtDLWosqk+bAH6ix3qeTfTRs/4Pget83F5pt81u1npsCjbVxT9b3pVbnB9qh+P8JXCU55LKFq838FFcyRZgpSqcFTtbS7BoGMslzrgpazLpmcq+pS1ls6gx2+/+CjnVl5nEGcYLP/iT/4+Pvy2W3e5y/XbXuu9r1b7cjzzal/zc0/mW8CATW9poAj1Bax1icscW3HrKmnzeQJBI3Qh/ztdc/q8ViRoRtDpdmk13VolzQ1rvYQwDBmm5WZ+7+ts/S4oQv4tk3dGmQxNiZLd5xJ85hrieESlUsEiiJRltZ9ipZN2UBJ8M2C+VWeUWlaG7hkl04mMZi/b9Hd+wdrIzNaw7ul1vvtugmm565S/K3KOtF1i4cudFCMCFmoQeYJOt0Or2cIYy6VujpIec1Unq2CL5DEOAC4k0SjBA0MrcknH1oY7P5O7vwYUVd8xBAf9LrW6SzrVT8r9y/XVzfV8V2HIR8/WWRsKPvOyxlqXEM+Fvd64+3tCFAzP7e022zXfnOff+ztTJEze3I/e7Pv70oG3cZxgVYiemkOqPtQCWB+kIAMnaXId4/16vxMUsio6A+lPzYezX0cKwXwFBikkeU7F9wg96IyyqWRYIIqkR56CPEtYaoZEgXCM/lFMtRIRerDSTTnYClwCbGO41MnQ+Lvef7psEs3vv8dFFD797AvcfedtLNQkv/F8zoW1EUvNiEEK66Nr7O9yohWubEIlCvEkrA914XwuohzQCKE2jbfIg2oAo9GIj52tM18VPPbYYxw+fR+PXzBc6rgkwSVzOMnd52xLW7j55o2PKXcdU8zg5TduLp5OuHYt19z/u52P3Tqn73ze9Byz1zXdcQ8cV9x3VPDpR57jojhNP9np2K/0XPSVv3/kuT7tmPs7HytwToSP3uVxpP3mrMWuZb13k3G7ix1sShqh5EIH4sziKxcu5HliM/toB5sGX5MsJRNyzBjcy6YZOMWHbd/t+rsQm2QDStumwfhlBG3BMSCrUc0BpQinAST2BzJns+3XmH4+gaAaVpweqs5RQrhQdSGRqgBIp9jQ023qWKjsGBo/ASj3B0S8GTdcJbu3/GyZDfRp15pEvk+aJ0R+tUiAZzDGMQf6maRZae8Pqm0Bg/YsqxBkOmNj0GWpOY8onQVj9/+MbTsGNARMMcD2MykltR3G09ZnLJMFlZsR2GGM7XH+GzUpJKM0dgmhhJOnMMaMx2ToTxjvlAzXGSzwfLTRGGu5uHaJVq1Jba6KgoJRkiFlkVRwD5bMND44WSPvPa8Fnk+z2hjrCie5S8zmzQBk7da3HJtvdn2qURpTC6vFM9gC9C6vNWnHZrW+jTm+VxlKKYw4TUiyxDEjlbctAZmVs/XTfapzawHGzppp8HaWfrrXLWadZxvVOtHucUjbljvXalII3n37OznUPvCGQVvYPF9u+vv0HE4pi+EiZVa6a9vmjc1yC7OZS0Q2S39nE7vclWlvh2W5ScMyfr7xvYrVvSrm6VbVJTQbg72WsVMUQaF1PWNftZaNYb9gcqttutjjZyrfrwLmG20+fN8H6McDvvDCY6xsnOPMgfmZ7nfT3hqW5JvfA7tZu+KSgKS50xF1icv2PsfCFh263a0TlwlLXJ8zxtCLXXKmPL3+uWdrCOQ0o7hMNFUeFyroEqATONR0jFWDwhMuRDQ3LiFUCaGWz3i92oGbymknjK/dTYzvudU8CaFNAJdjwCMnEwGjDNRUuLQDUV3IdOg5zctEuz3DWArDiqmQWqdzuVeppt8NlYBNLL9mBINk5zK/mTYipBsXc60Fi3pTmKmTsPAv357qjZvAU5DlO7XLG33T726ZgSwGCLYNmjLJVyAychFck1TC9ZgSMM1sLxNA5Yht8eTTIeYTgG27GQurw/J7xSBz85+dYkoLHKu3GcmxQ2mYuSSFpY6tLyM2hk5TupdAs+LmIn0Nkg/gpF86UyzLsZ45zpnsK8u1trexpYY0ZHi0vdIx5q7hSceOLfWmpy3O3dxQI98kS3OwIbj3qGRtoNFZRr2iiDy43DFkZvszX/sw3v6MnnT/stzJv0xfcyfm5Zttsz3TNWwmcCC5tZZL2QFG7N13fzdbsuM8uNksbg8R+W+Nef4mcLuHGQvNSNKMzBgcKCejWcBbcNmhy5DUN8u2Mgi3lmqsq/hlXlxMtH4lSkoH3s7APrv2++w9pfme83ZqozHTbKmtwNXUdQSTjIxbbbw5fjPtGmZZ3wsI/LDYwLu+aqx7gjRJiYLavtcYs0Jn6CLVMOLUgWOs9Tssd9eYr7eLJHdTO6E9Hmunz+736++fu/WBfXWIZ7jGG7EoKELPKceBGt9jel7Yyhzcz5RUKOCu47cTpwlxmtCLB1irsRbmijYx17BbmfX5vSLrtluEuvDtWYDb/e8xW1nzPMcGBSO9XHuyM1t7FrbptAkEkR86iYFxW213ks1ixhiMddlPZ7nvNBC5lSm7l894L9vvPVWaEhK5B4v4RoyLI/OHZ3Zk3QibOGtAKm8ikfAGbRYG9U5mrZnJ2VdGXZS2qf22FL90OAATR2QZWqnzbcDxbpZkKaNkxLIxzNWbY8mMfcsqBM1KnQ/d8x6uri+NE6fdtN8ZFmd2Jk3OXuLAzTKZx6x2LQDMKANBhBwVCXR0AXrYCeMl36ZtuLdtCv+1m98w2lIkXZNjDcUyqdhK34Uww/SaEHIkwwx2UB95Q7ZXmHJ57/KQoAjrLGsi8ibyBNZOQJ75CjQil68jthEic8clqaZapLivhpAMDZMw/O27h61kkJ3MFkzg+48qGhE8/exF7j5zG8t9w4XOVwIukHz+VctcRV+XruPMd3E+rOvStZWiZHxPJ4T68tjWJDtlf3ZJO/fvjzfaUg2rAwitkw1Ib4Q3ZA+TwoG15X0m0gXb1yfT/ceye1h1+f1Ov08DxbqYQxdqsJK6fBuNqJA2sT4bcQl+OqdJkjtpgmua9xB88nnLKNNjXe7QK+ZYK8bJ4a4VyjOWwqEFIAvGvivbRCZn7/M1TjprfcRYQ/yVVVPIXPh0RzCUoG/IqtOVbadyuKgRsWlufStaoK59PAhgoWp5dc0ysFXnyN+j3/5utlnbXgjnwH4r2E3gdg9TUlAObSVLFlQZwj6bSSmRM2e0vH7bFk47nk5nZzLeaJu+t0AgbwDTauf77G++55EnOdracbDJZnbulmsKsU23s2T3yT0kB26UXUu7ySLBnBCWNM8x1uIrj1GaYowm2j+qe8fn3cs85bHUnGe5u8bF9SucXDzikoAxkXx4M23r9m2Wku/vbLmW+88m9bGZ7S6x1oxDjaaBuesFraWQ46RCUjoQ1bHKxTip0qx2LSUoj/WUQps3vsrOjQtp9/d5I1mcVET5uZRH2Kldr7dOhXBM/a3szcl1ZzNXN9dVhO1luo77X8uK9MsRiXGj5sxZweitdr2A6/YCXOd511Dm62kLUSS1K88cxD08FdCq7Q+m1qMaoywlyVJWexscbC/OBvqWLGCpODh/GmPMm/aev2k33nZLrLXVyiQpRmtmyWB/vWaRLqu7cBvWUhfVOd7LT7PbZAqcJPIpr2Dt7leLc8aai7pMsGULkHf45eVXjiM3imimSZkNUihyQ/FPsTIoEsnhM8hgkNpCBsadJXHq4MPMgfZxVv51N5t9r2OBYy3D6xuCkYl4fc3w0vL1TZal/u8beX1a9kso9catBOSu1XzpgMPcgI/hQFOxPpqdoX6jTUrXCxLtGMqBS79BZgy+VOMx8GaatjCkgkjefHbgBGR0Y8rY2ZM3XTv45caQrwrtVGu497BioS74xLpHRcJq3803mgjysmzOoRJfVyZ7ydoQWpFj8YLT5XaOtArZoCShXfuaaCuQzR6/72QxIb/6nGGUMdYQd8QWsMV8P8rhWpLKXQ9zuASf38qgLUAjgLXRtY0HAfz264a1UaFNbr/8zpivNsu0S5I3vz8P7k23Nx9R/B1ske90n8owAMdkcSH0s5PWv7LU6u06LW/WPbb/bUfg8Ss0eQiclIScsS6cVMHkFaWNGbMXS53LN9OuBZwoE+U4AFfiKw9tDZ1hD/0mzNZjdrIQLDTaAGjr+Ml2vMv46jWL01S95vOmdooWrokNu58JIagEEdXAuQRzrclMfk0A1/XInVuuDaTftTSGmQAfYzT1Sn3c58eyAtdZl2Viq233Kcb+RE6F8b9rcYRdiyzAGFBg+/xyPc633eQEvmL2lZbTv0G3H6aTBFzGmpkjamZdC7hEkdfuDHHvgIkOs7FOGmgWGyYjIj9ksTnPwdbizAz6UofXJVzzeOTczeRkv5Ns1iGhROko+/JsGYxlKpmVswn0OLttff3ZXT7vWAbc2j/fsuk1dnPm9C+HTUs85MYBm1ViWpUCoBw60CvVDnQLSMjyCQDtkVP1HXM6Q7njsxsPxv3ko5b/8aLhfH6IR87bTaHa12IlkFN+vh7zpGNvvpnm1nGzH+9SyrpazwvwUImc3G4u65f7rZ3pcrxNEkApWax5xJdz21bIdox/f/PuXDp0Snszd3SmWKK69aMk0W5c5lbRGTmgcnq6u565bqsp4UDmxIYuueRUVebmxs1h19pXDS7Jmi8nCcCMKSM6xHXKZLyF1rk32NanQNtAuXltPzPApe7sic1u2v6W5DC6Udkn36DdBG73MCEEtaDYqlsx1oCyO0zxu22svxzA6U42Tmhg7SZA5s1m35YsuK2l+XLdfy8rk5HNdCxi92NLBIeS8WdmbuHZafmz9xltJtnhlZTEWcpKd40kSzDmuty1+9o4BEgq5mpNAs8nTmNGyQit9XWBgNdi1zOibhTjT2t9XSHXYvw/ZzeKlbyppgX4yiMMAvxS57aYA/Ybe9dTPyudNYZJfM3nbTWpJMMkpjvq0xl2neTD9PK9CP2WQhYav2asGSzk/kmfoNAbn9JxNdbsel7JznS63AUQVkgfvFl9exKSKxgmE6qQu/f1OQqmwUJXZ7PNB2/GPP1m9Pc0z0jydLbzbkC7uaRdExmBWRKOXev9sxnbaCcbA8lCIKXH2qA7pQO9+f7jecFaHn/lST73/GNkOiPJk03jZHYTrA7eGgvbmzabBTP6lYy9NtmDN2o36lZ6D1bttZrd8vON2NQScqZjp+8ZKJirgie102oUExCqvGaO51h+sgDBCdGmYIi+iSyzNL8xu53MTJiN17tsC7aAtm/GLuxaxkTkQS100KS2BaPYOmBtdcBU8qBrZ9ft9PmNWJqX2qWyYHB/peyrB5DLxmCp4JnLlodfN2So65LZmMX6qZOfSHGawdqWgM/sLPpZ7HquFSpXH7qQwkGUc/WNLdtXg137u9DVoLZcJ1v7pu1mK/23xvr2qxq4vRGsyFroUQ9dGDo48M+9SjROT9TsCORututkg23yO14f4womyVeMNTckrHlv21zO6QDckp2z+5mzPa/d0q56xnZ2SbD2Ku0+505ZCei4zfAM4j7XYbNeMs1Tx3i1lo1Bl8sby4zSBGMt8XVswK21DJPRtvGzlSFa/taouCRQq911VnqrrPXXr/meXy57o+BNrnOudlYZJKNrHpFCOGdAqfl8o7rM1uukeUaSpaR5Nhnzpe5lfmPf5KnO+MSjv046I3g2bbnOGaUxF9eu8iuP/jr/4dd+gvMrFxFIcp2jtUYXGe4tdpxpc5iMWOmuYawej8NZbSeW807tsMlpM2absUlTF24MGLiTTctcXM8dTAHWbY4auJYd2DUwtWe86MzawHY3dfHJHUvLdI4x+5fAWsswe2MOhrLv+KpM/LcVLtnbcpPP3F+ul43fHfbox0NeX77Iz37+V/iVh3+TLM/G4I82Bm3MOKKjbJPbjtzKvSfvQArB1c7aWI7kWi38MmoY37Q3bpEvxvqWe/ViO2ad/k4FUr7cG659nKRbjtirVgUOnAUHxC7VHZiZGJ+14ebQbSkpNG49sO47pyupWB7Aerzf3d6YWUq91xt3j+sLGrOk+W5g6I2D8j0529Uk8PV3ST58h2JBufWxYQJW5eZ6QvAtzQgWq+7zjbRJO/7uMF9+OWc2S6rh6gBmgWBuZLneGrCTA5U7I+cYmCRmvGn7WSmLs7eJqf/ftBtpa8O3Rkf9qtS4DYIAKSUXL15kaWmJIAjeENtOAQ3PEmeaJE0Jg4BQKdaHA4xVYyaR2CuDO7NpYk4fP70lvNbzp68zZgoXAIiVN7bZp8s2DTXsrLu7/SkmrOTp62x/XmstOs/YWFsm0YLU+uMrzFROy1ifeAImz2bGmkKKwN1OG0132HOAmMlYaC7NdJ2ZmbnWkuU5YbB/qKsUcqwtGHg+vueT5zme51GLqo4hOiMrsQSjO8MeoubC76FoI2vRO2j8DuIBCFEwEos2vgHs1ln7vNZ6DOrtZ9dTrukxZKwl8HxevXqeuXqLQ+0lV7czXstpUO5fP8bo69KKdGPcMTSFEBht8aTngFCT4yt//4tcg6311ugnMWv9LpUgpFnIGMxSzn48pB8P+dXHP8OltStEgcfFtUucOXwKJRWZztDGIKWT/xBC0Bn2WO6uueRJ1xHMMKuusCnuWx45PcdMyw8Ya7Da4nk3dk5d62/wypVz3H3idqS8NnC6PNa1gyXT+SRR18zs0NkSadlr0Q3a71rFeM+1Rkq7a7h+2YYWW7CvNbN0hut1WpRzopAOwc91Rm80pF6pjZMyzpYATs10nO/5112lgRewPujyqae/wHJ3DSUF59cuc3LpaFFOtiS9s8RZSqvWphZVWemuAbAx7NGqNa/5/kfbN3Z+uWlvrkW+oBbCIN6W6H2TvVU2/NdvN46jshV03f2o3W1rfVpcwiRrna7lZpBRjMOac+NCYB1dINx2oVJiQGvH7putrDfW3hpbW0FvV5mGG+cyn5Vx6zSSLfNVQWyiG1RJgn4MiXIcyi0+5Zt2DfblTdok0Nax32cBx78a2/TLGb3x1WTXCnB/Jeb/r2abNSfAm21flcCtlJJTp05x6dIlLl68eMOua60lyzJ830cbS3eUgHUZq6VU1wWsznjn4ucs1998rLWG3GhyrQk8vwgBvrHlnDCPStvt+jtNIWLT9ztDuxMzFjp5xMX0EKXeWpImVKPqvuWUQjBKEwLPgUCzZtwG6I0GDJMRvvLJdMYgGTFXb3F57SqrvTU+cPf+wG0JcszST0ZpQj8ecDBY3PdYJV2CqG4yYrmzRrvexFcemc65sHqZ9bDCUmuByA/w5O7gQdmOUkqalQZr/Q5H5sJx4iIhp8DZAsA11vAzn/sV3nPnAxxsL7Ix6BJ6b2zzLgSFxIOcKU7uetjoswKoAIN4iK/c2EnzbNxlH3vlGR484zNXa+LPCNzNItVhrSU3muA6gFtjNudJFQi0NfjCY2PYo1ltXpPu6p7lxPLka88ySvoM4gGVIOTcyiXa9SbNSn3Pc4UQY9D2/OplAiWZq7U5c/g0aZ4hPAccesploE3zjNAP8Yu+1a41oRjPnlKEM2h5SimJ0xhEhCfVno4BKeWElcjE4VMCoNZa+qMBlbAyM2hbsod3mnemZ21rLb/55Ge5uL5MbzTgnWfOznwPx3wWY+3fJEvpDLrUK3XW+x2WWvPU1f5zZT8e7tuG4Opl2nEyqza3NoUzqWBM50bTG/SZa7SQQpDlOSqQu7aPLe6FtQ4Q3WdOFUIQZ+l1JTbbGPZQUlINKqwPugziPkoqhJA0KvUiiene1o+HBL5HwP799I28ndf6G3zyid/i/OplVOFM+9TTX+T3PVCjVW3ge/4Uk9uijaEz6JIbTaNSpx7V6MdOpzbT2TU7eq72Eu44HO5/4E17S9hcVdAIBf3E3tzhzWg3sprcm9qtektGs9x0D7EtGdAE7NllbpyOCLmBZb1pb8x+8WnL4bamb6tTVJU3ZoZSm/arOnj2mux3Alh1o5LWXq+5NS1jos1N++q0t/o4+J1m87W3xlj5qgRuwbFuT5w4QZ7n15XoY6tZa1kfal58+TXOHDvBWr/LT3zhi6Sp4NSRMyw0FggLduJett7vMFdrOtBgHxBHG0130CPNM+abc/gzAI1aa1Kd4SuncfWZZ77I8xdeQVs41F7ko/e9n1pl/427qzOL2uee1hp+5nP/nbO3vI3D7SWkFIRe4DbydpLkRxuDrxxonGsnLaCNJig2hrZ4XmMNvvQc222HDba2ihzF9MtmmMYzAbfdUY/l7jrHFw4TBde2uQz9gI1hj2ES43kei8158jznpcuvsdScL+piZ1Cg/Hs/HuArf6Z79+PBJnmGvV6vTpcwY623TpwlU3Hd7vvzK5doVGponaONYb7R2gR0lAmaSoAKwFOKZqVOlmcE/gRscKyzAvAScHl9hc6ww+OvPs3Xvu0h5mqtmdmvu5kxBp13kaoxE+tvViCyfM6yXh0YuD+QUgkicq1Z7q4xiEd4yuPQ3BLtWpMXL73K3cdvo+U1ZirDnuVj0gYlYHKtQNPYiSImjgJf+kgpqUc1cq0JZ8BijDGbQql3srXeBnPVGl939l00KnNUoyr1guG97XoFyDZd/4+8/DTnVy9zbOEQ777tXg62FmnVm1hjkMKyMegjpSIq9HqlEFTDiGMLh/CkIjNTKcdnsP7IpQPvj4YoKamEEVLt3r+EEGhjyHSOJ+VYvkAb7ZI5BRFgZ2Z854X0w07A7XQtCyH46Ns/wKe/9Dl+/cnf4pNP/hb/2wf/ICeXju57j2ES0xn2UVKijSHNU3zPJ84SPvH4pzk8t8Q3Pvjhfa9T9fd/l8EkNP/w3AHAzfdK7F0XFtgowEK/iGIYJEOMFdQqVZRS+Ps4QsvN2aWNZeZqrU2Ok3F0xJZ7Nqs1sjwbg/8zMcNx7PfOoIutWeI0ZrE5T+AF4/fx1nll8/kWow1XO6sk6Yi7jt++7z2v1coxn+ea33zy85xfvQwUWZqt4PzqZX7x4d/k/Xc9wKmDxxGWMXtYIJhvtMnyHGMNkR9ydP4gvvKQ1wEGvLzc42tuv3am7k27ab/brBnCKIPcOCelLcLm3wim8zsBtPpK2fXWzY2q09zCuXUoQdab7fRm2lsbkPxKj9NJ7bx16+imvTG7Ob/ceLtl/q0hBfZVC9xCAYD4Pr7/xhiAV7qGpy9p1oeSYXaM5dd9AtUil/OcPnmGRrWBFpDY/aszCOdJ8AogAzYPL+GyQmPpDFxIcGlD0+fI/MF9r5/qDIRPpl0o8pMXLnOl4xg0F7qv44VP89H737/vDdV4VwABAABJREFUddaGGwReQD3aG2TUxrA8zHlxeY1m4zAeit4wp14JMdbiqQCBwAgzDo+wFCxRDOtpjKAEqnw8pRjkOQo5c+KXEnzbiZfsQvxdXxilLnaqBE6u5dW+MegR+SFRtUnkO+mNTOW8/653MkpHExbTDkBb+Xu9Ups5yVCr1twEBOxVTk8qYpNQj+q0qg16oyG5zqlFVW47fAvyqHSyC77v6pTt5dtcZ+5vrl4tudZOk1VMFIuNtXQHPX71sU8jkZxfvcyvPflZ3nn6LKcOHp/pGXc2Vz/D3CcZdllqLex7xixg0fSxuTb4ypsJ8C1ZixfWroz/lumsYC8u8MDpe4D95Ro2h68Xf8NijZ2SWpnY5j60PxO9NCU9Mp0BAindOCtD7YWUhGK2KT83OUqqXevVGE2ne4n33PUQ9UqtYE66pF7K33yOS5IFdstqNclSji0c4iP3vY9KEJHlmdNVthapfOYb7e1jCSffYQGdGjanMNs8psvkY2W91aMK2hriNCXTOSrL9nWGKSnpjWKGyYhWrUmap3jSoxbVxnP17EmnMrQ2mMBJWXg79JcSbK9FNT5wz3upV1q8tnyRtX5nJuDWWLtNb7geVbm8vszVzirz9dZMQPOszoIoCMdOMyEEwu5+3rSMTq5zkiwmBQLfI/I9Aq/ChbXLtKsNGpX9HSFSSJqVOsNkRC2qkOcapWQBgkzmYVenAikUmc7xfX/m6JiV7ho/+7lPIAV803u+ngOtBaScSlwpdmfRl0zizrBHu9ZA1Vsz3XMWK99r5edca/rxgGE2iQ/OtOVga4HAD4mzhM8++yhH5g8QeiESgRWghEAix31RCln0jf0dyztZbm/GQP5OsvWhpZfc3OJ9JcwAvoLcCKy9MRvt/Ga8/K4mhINMr1W79a1endOsbUUpefLWBi7fTNsa//lWtLdCn7qpK3vTbtrs5subjNvfMXala/jcqzlJZjFWk+YZvvYZpYKzt9xfhEzOqBvIRA9QFmGMwNj95r53TJi1/gbVIMQiCqCgMvM90ixFW8ul9atc6axy59FbaVRq9EYDXrl6fs8Q4dJqYXVHBtFO9kfe/78QKA8hpAMzArdpVlBS/6aSupUhGobuqMswiVlszJOZHIHA8zx835/oCs5QhpLBOn2kKbIIjTVzi2vVwgpKymtmMn7isU/TqjX4wN3vckCbhcDzCZRPPaphsfuGwQvETGG1AKHvb0ois5vZYslWCSvILOFqZxWAyA+ZqzXHoGzoBxhjsMLsCBhtLmeZgMfVYa4dPOYpx4KzuDDxzz73qAvJle6slY2rfPLxT/Hhe9/P3Sfu3PcZp+UKbMFctNaipKIfD2dOLrhfXy77uzaaVLsEQbIYZ/teWwg2hj1XJ16AkvL/z96fB8mSnfX98Peck0ttvffdZ5+5I42k0YKk0WJrGXbksHktwiELQjYhgRwGQoEJMItlEUIE+iGJzSEMwYuwDdjAixXwIovXILZByLIYCSSENDPMptHM3Dt36dt7LZl5znn/ePJkZlV3VWdVV3VV3/t8QlfT3VWVeTLz5Mk63/M83wfGGkRxhNDzEXg+krT41wEbSm0M8n7iBD9XjEkAXa+5dHJYceDmHYlOSJyX1PY4iSlSFOSxqWFKDfok8i0i9II9/siJThAlEc6s3gbfC/LiYX18lN3fXJS2teS72uy08cq77kU1CHFtZwP1sJoKRwcv2Lg+Heuk6x5Pd5jtT2tD51VKtOMIW61dWGsQ+iGCkpYexhrUKzVU/CCNRKQ+a1JBuqzApaSCocBjKCX3HYdFaj8iILDUWMTXvvi1sKac3ywAzFcb0EajE0cQQqAWVpEkCR67+BQAish1her6W6ZQROzy/NKB0x8lPbSjNnbaTSw1Fg4QwtNebi0CL6B+FMeQEqhXqoiSCH/5pQfxvHN34L67XlzqeAGBalihsVXJ1Mc8fSV9zph0cSRKIvjKIw/dtFDgoH6mjcFWawfPpWOqEirNZLEHLvpYaxHpGAIC85U6lFIjF/wqPgtjnaATR6j6YWaH0Yo7MNbgwrXLuLy5hpMLK7h55QzuPnsb+fCm31ECz0ctqBbuR2T/LS4MyULfHqqdsDgzzzYJx4l2bLEb8SR+GkgBCAnYMaa5KyDzw2W6uR77uErLbiQmHdMlUt/j2RAYpgd5Rd/oTDuyl2GuFyxooXvlYAe5icPC7QCstfjSRY3NVoJWpGGsAGwFUdMAsFnKZVmRsddTMy9+g67nrLEG55ZPpa+LzI/xwPbCYrO5AykF2lEHW80dvOtN/wr1SjWNQqJoM6PN4OhAkLDSitqZDUA/lJSo+AFNSq2G7+2NZDTZVnNhSkCgEdZR8SuQUiJJNITIT4NLPy2DEmrP+ZcijWKwFtpqWGNRD2tZkaNhObN0AneduRVzlRpFUllNgoAQJN6P+YuSSK/7QWhjcHH9Ms6tnIbW+fsX6/OQUiLWCSp+ACkEIpOk3r6pHyUGfL0TAio9T1mFewtYQQW6KkGIV971YlzdWsOza89R0TJonFxowJpy1duvbW8gTmJUgiqqQQBPefA8H4DFcn0BnbhTapFByv1FsOxQQAWPolTEdOnxz65fxi0nzhy4/cDzMbd4AoHnZ2KJSytGKrQd5JdM4qHo2ldW7C7F9XibRU1aJFrA9yhtuV+3LUaVd+IOOqlApACEQZiK7QbamtL9dGVuEZ7yIWT3mOWE9cALUiHSAELAk/39SPeci/Sc1cIKVueXESUJTqfnV6nhthOknp2xTrKFheLrKh1jjaViY6tzi5BS0phaMlJ2oTaXCowUzdmJI1SUyhfcimrhADzlQaaLW4OOUQqJahhmCz1WDjEWSonV+SW4mmHWWnSSCP/4Ba/AXWduxeWNtVRsLkZ+90R7A1hsLBx4Fay1eGbtuSzCN0piLDcWUatU9/2sO+ZOEmO33UQtrGKu2kCsEzyzdgmPXXwKzzt7B15x172l553Vgu2Me+4Ya2AsRVc5QTfRCTab2zi9eAJxunijpEToh313JaXAibklnFxYwXJjgfqXFKUsBES6MBSbBNWgsuecD0Px2ZYYjVpYzQpEWmtRk1W676MI//xV34AzSyexUGsAoPGgKKr3a0Nvf+wtYObGl75tTBfeXnHr4O8LzGzRju3U/RZvVFodIB6zqmJxPRSSY8rSe+9y0SfH0Xj+KlqHntl7jkVbhhkP2gBXd1m4nXnWmxYXNmPsdgysFZlAK6WEkvmpE0XF8QAOisp02/fgpd6KXuk0aQGB0Pfx9NWL2Gru4BV33QuVinfaxKmvY1gqRXxtewN+Sa/SOElgLUWJAiQmqoIoTZG7+7ffpawbadLIw9w/texTR1sDYXORJosoEhRlqY1Gq91CozZXOoq4l9e/8JWZgBnpvDq5sRYwunT03rjxpMItq2dhYRH4ARqVGqIkziJB3QQfoIrjxcMfdCbyKKz09y5RXEJ6AitzC/i6F78Wv/kXvwdjLWIDhL4HY8qdY20MEmNQr1Qy4dPFggV+mFVsL8NB7/OUgrUeoiSB1Ql2202cmF8qtf2VuUUSBxPyCA48D1L4uR+w9Eq1kgTU/uc9ixyFTX3vAFgLbRJYSKg+wou7XzpxBCllGmktU09ZEn0kZCZyliFJIlT8Sh/bj7zAloQsPT4VqfghXn7nizBfrdN1FoIil4fEZTH0Wzxx7VdCoRZWsihuSy+W2oeSCtVQwX2kEpD9SxZBXHKgokhvmRU6OzimODuIIachAi6wXwiBShDCUwpzlTpuWj6dHbcba/drR3H87oeFReB5mXDbjjtY391ELawMPLeB7+Pk4iotEMYJPAncvHIGZ5dPYqFGFjG6ZMq9W5wy1mYLTVLQQo5xacMCZI2RRp5a45IpB/daAYFGtY5/8vL7UQsrqIXVofp54PlQVmXPHF+O9nWr6DVdS21CUFgsVmlk9cvvehGMMdl9lJgEvufjxMLygWNPkTySnBZY3LrEYM9hgXZnByuNg73mmdkhmpEqyTci4xZtASA2gCeBxAyXKu/R14WhbQQY5kZGisncx9c7HAnMHDcsgJLT54nDwu0AWpHBbieVJUQe0eNSu4uMK+Kyy5cPFPUDa2FF/z04n0UhJB559kn80ec/iXe96V9BpenBDmMMYiTZcWhXgAiuU6bpzhAIvPKRqaEfZGn1w3Rsz/OySbTveejEcUEtHGJotxYGFl4aeesKolHEmoKSCn6dfA3NiB58gaICT/E+6a5FkYO2L0YWiPsxUPBLI/ikklidX0acxIUoZrqeIhV/jAvFO2Q7RBotem75NP7Fa/8J/s8jn0NiLF5yx0txbvl0qW3Vwyrma409lctdqnjZomNl8ZQHT3kwxqAS9I+068WJHlQAifplt1BUbkv9ooLp3sv7jcjsElzUJBBbPbBQoCt61YrauNy8Bk8pLNbnu6O27cELR46r2xtoVPsVGeo+hrIRp73csnoGnvIyqwUXiTrUlDO1mClzXMU+ZYzpEm8H7XNvRGqPmD3EDWUFjWm64Bvdb68iy04oTz9hXwkFCI1GtZa61wzOENmvwFcvUkicXjoJrRNc29lEJ46w0lgslXmipIQxBoHvAfDT323mG6xKXE8LivKlewbp2G/J0xmATRftpHSRzjKLGPdS7+eDkELi7NIJREk0dMSsRe+zwY6UvNkb8U4Lxfu3RUqJIM1AkFLS+UjPpTGm1H0q0ra6Rb8y0cIWFpHRePraFm47sVj20JgpM+avKcwMkIyQKi/F9WklwDCTxICibmd1weOoBVKVjiP2gG/xM3q6GGYgwYy4r7BwO4BnNpqwlqqZZwpK0a+xwLit4KmoEE02DQwJO30KBWU+odbi4voVPP/cHahXqoh1kolKxgnBhVY6Lzs3iBYnZ17q5ViWzJpgiCFZQFB1a+TRwhAkQtE2S8aZpanaJhWi96so7uwUXDTWsEK7E9I9z0NidHY+3ZE4Srd5WEqKY9ZaivQqRDGLnj5Qand9zhFp6rm4JoTAqaVVfNPL3gCkgsxmcwfVAzyS3UJDpeDVSJHTyH4fNbW4L6m4o1QaOZ1aJ5T6qABEGl2aeeR2HUuJtqZWE1TIi1TZLOqv0G8EgKofIkpiaGuyBZbey1Ecc9xx1MMqAs/PfGm1SSCEn/ad8r7RUpT37h6VLMo6jYIcRahMdAIDi9ALhtq3kBLWmEygHBx5OZhh+qrb02DRdnzjSOadnHq8uij2Ycbp4nZ6EaDreGJ+GYnRpa+dFBJWggTa1Kc19KjoozGpZ/JB5zS7D0V2TFESQUpFReWaO9Amwnx1MX3WGWij0+J26SJjiQYba7oWl8o+6wVILM0WfEt8Zj+sJRsCb4jFVFqk7F7QKL3/dLZnDdmLlPmggMBcdR4PPbfBwu0xYqnKU2gGiDWLKQwzLL4EOsnB75sG04pqdflMDHO9EXiz8ZQ8GiOYY8rVje1s/HGeq+P2Mu2HSCekFhZJoksVNjHW4LmNK5ir1rMJGxVhyQdxUxjKKY3apWKmRZJsXiU9NsM9kQYVu+lHt/wpMhE60VRgp+x+u4pcpUW98u26fbkrKPa85yCkcpNvSj0O/SCLChs1incS+IXJve95WXruMMfq3n/QZ9yrnTjCQm0OC7UGru1sYLfTgj2gsJhL4e6NXtdaU/TwAcLWKGitkaQ2F8X04zK4+14g96bNIrvLbkcAJjUlM9bCGJsXYLP0cx5pLxH4PlSaWu8XbCPsgK9GSilUwyoqfghPKihXZC4VcWSJFHgAOLm4Uu6QhCgVuVhmO8P2UQDQdu8CQ5nxRrh/hxBIXQG5siKoSiMggUJmxch7Hx4pZZZG79Lg+9MbVTwY552tSxYUtEDu9ytEao/g2lYuij2/h503NOB7PnxFWRaNagPVoEGLV+nCXvkjylFKdXnClxHytTGIkghxkj9DbdfTd/Dni23txJ2RxsI991TpYYru6TL7dBkuNrVP6cTTsQxiRuO5rWm3gJkFZmM6yjDHi3Yyu/eOkkcv8Mxq5DHDjINru9NuAcHC7QB0z8TH/bjf2FQ+mmWYtGqaRFGK9gHvTyeLpxZXcc9Nd0JIgdAL4Hs+vDTNHyB7BCc0OHE0m2DafDI8X21goTpX9qgKh9cnSnPAMTracQfNqJMWkoqwtrORRd863CSxSBRHSI0asmvUTxhx11NJiU4SZf6MBx5X189UOCxIq8wfib9t2Ym7zYveOYHRiUtyCJGt11ai9zw64QugQmgqLQxV8YOsiNdBOHHGRcspIYeKKsvaVlLwU1JRyrg7hhGF4a4xoeTXNmMMrm6t49Lm1e5FhYI1iihsz0Vxknirsgtw0LEWo0dd9HlRpC77vUqWjEQeJXp93+1Yu6eLl2lr4Hml/Fj3w6WBAySklxUdi59PtM7sXg5CG4M4ibNrOO4sjf3ot31tqLhike5nXfe5KNPPqRBY2VyifGHI9U9nX0HjVv8zUxyXpJDkPe7Gt8xmxADWIvB9+MqH1horc/PwPQ9REsNaM9RYOHgxoMc2KRWifS9A4PuZFYg4ILK7+HlRaFu2+DIkw4z3e9qAfMwwacRv37am2TYCAvO1+kj7Y6bDTmfaLWAYhmHGjSfJuoBhmPHQjGZjZYKF2wHcvNSAMSab5Lq5JLkm5BNP9/PBEYp2z4S4H8WJkxACoT84FdhVsX79C16JRqWWT7RSX8vA8+FLRemo6fTRiY4SAn5a0d2kFdrdZ4ZFCJSfLPacLl+5aCmJWljD2aWTXaKQTXNbKYCQJpNbrZ0sRddamqwWhZxiS1yEl5v4+8o7VDVQKaiqfZb6PklKbl8bjTiJqCib1thqbqZ+j3lq/uDdUD9OdFJakHKekUopBF6A0A/SNP3BUc29Bc8g8hTxSZxNCwtR7Bsj7sSdTyEEjDZodpp7X08j0RKts3OwsbuF3U4rKxoHIIs4psjV1IcTSIvqUWGgVtTC1e317P3DCqWyINqW+aTdJ4p10HvH0feFpPs61km6CHNwW41xhZO6H2PD2h64BaRRBGClVBbFfRDGUOYEFc46+ih9ay186WWLfMYa6DTLghbE8usZ6yR7hljYPSLvoH2U6Q8kuObnu+KHZJuS/t7vGhprutoihKDFxzhOf3fjvISXFr4EgKvb62hFzewZoI1GFMelx5n+7bFdg1Xx+PNMD8AYO1TxveL9FyfJnjFmlO2Mar+x225iZ8D+BZynu8XphcpI+2CmQyOcdgsYhmGYcWMsQOvoXIGSYcZBPCMh5SzcDuDsQg3NTisVUAx5Thqd2SZYkMDV7LSRaPI9TbTOoqrcRDgxGtutXURxXHoCDCATMIByk67A97FQm0PgBdhq7pD4kUUNCwR+kImz5P+nIdPIUSEolfzq1jVc294gEW0EIUNAQGudnaeB7+2JqvLSFFcpZXbe6Nw1KRoufbuxBlvNbfzvz38SH/30H+HqFolazjdyUHSYi0J0lgr+GApgteMIiaHo5d5jdn1CG5NGEh9sedGLBbDTLjdxp2JsHp0DATx64RGsb29kwn7R0zhvo0n7b36ORRqR3I46WTTowfuWWGosYLG+kEUzDhMpVhQZRlkoLiMYFd9TtnJ9LzIVWa0FDAy2W7uZzUGiE8RJhFjHJH5bk1W9PzG/jNALsL69Sdsp+DsX7wWdJGkEqEar08ZffulB/N1TjxxazLbGZCnYg7blrBnKIAp2IS6ycBRcwaqsmFq6LdMnCja3rhm9rzhhsmizMixbzR1st/fmz+y3pWs7m3j0whO0OJYkMEMIeeMg9MMsItYJmxIiGxMFkImLlcJ73bUpw267OXI/PciLO1u4g83GqyiOsNXayZ5VmZ2I64uW7vOqH+Lvn3oIm7vb2GrtIE50l83CqDirh344mxIM6MuDcEJwLawdopWjYy0VOasG/QVZW/jv6nSayYzI6bnZmIgwDMMw4yPR9I9hmOsLLk42gCeuXMTFjU2cWToFKSUqXpCHgqVRSiTE2Wxi24rbuLh+BWeWTiBKYnTiKBPd5qsNrMwtlt7/KIKElAL1ShVah9ht7aIaVqBkXmhIG4Nr2xvYbG4DABZqc1idX0KUxHj66kUs1eex2FgcOf14s7mDOImx1FgAkIuCKo0mPCg93UUHxpoETl95kFLgiUtfxanFVey0mvjUw5/DtZ1NVPwQS42FPXYKZXBiRBTHCH0xkkjtaLabaFTr0NagGbWzY5VCohNHCHyKyt1p76LZaeH00gkUr+5Bfo4CwGcf/yLOLJ3E88/dAWD/qu+u4JUSCgqUPvzi218GXwWF49sbzyiFhJA2E7O3W7vYbu0g8ALySlVeJlYehJdaJgAk/I8q5LnjodTp/ufHwqIVtSCFyqIfpZT7FqtyUb0uvd9T3qFS/Uk0lFidXyYPTa2hlIKH3FfYWINrW5vwfR+77Z3Mf3q33ULFD+D12KBYWEgl0xLPFsL3cM/Nd2FlbunwafWZMGay9O9+92P5IkjpdtMu5XyEgzR60gk/5ZuYRwebtDiSE69k6hHrfLmlEEAqcAPI7DrKNrwdR2gUzv8o/aAWVrIiaz2bz3ARrP/7c3+BlflFKlil1ESiyg/CLYh5iuw3nAjqbAaKgr27/wDnB3zw+amG1VL+tAc0Egau4GVxMUCkRQLp2htj0sJoS1m7kzTTwKZWDMZa+MpDvVJDFLex0dzCLatnyWPa0kJGmedS36bCFfyT+54jLy2KGSfJSOdFCIFaWEHSx6pgGPZ7ZpTaf1DJIuH3PwK6QkZrXNmJcXKBfW6PC2vNwy9eMAzDMLOFQTqNwOGDkxiGAfwZ8R5h4XYAjz23hs899hC++WtW0PDrEFIWvD8FhMgjUdwELvQC3HriHJSUWN/ZQjvuIPB8VIMKFmpz6YTRDj2JcyLGQbjoMelJeKpOKa9JDD8VqZ5bvwIpJBZr86klAqUo+9LD7Sdvpgn9iFhr8cef/yRW55dw310vziqFV8PKnqjCgwjSCuNCADWlcHb5FJqdFhqVGl5190swV2kgTP1UXdpxsfhYGRKtEfj+oURbAJivNaCNhq88JDqhCG0B+L6HMPU4bEYtbOxuY6kxTxG/aT8AUMq/9jXP+xr89aNfQJIkeN5Nd+wRi1y6fREBgdALM/FrkFVCXuDNYr5Kx7PbbuIrl5+Brzy88ObzqAQH51UKIVMxRKTCZsmUe/SIXcj9Lw/6oLEWUdJBXdXoGqQ+zoP2HcURYp2gFlZhxWiLJK4gk4uelFJmYpiFhdYGgMVCvYF23IE2BhU/gJQKsU7w5JVncMfJm3sKH9F9IlTqxWwVbjlx9vBiWNpebTRMiQr1w/qvFgVXm1qHuP490t3l/Ept7qMJ9Ij4bvtp/3Zjs7E2j9ztt/l04eawHr2hFxTEu/731mZzG//onpdjaW6R+s0YIv2HhaLwRb64kmo2QghESQxPevA9Lx2v2vDSBT8XpX6QXQ8ABMobeC7K0OX7XMwUsLQw4hYVbdp2FzUc62RPRoNL4VdSwvcC0CAo4EkJkX79OUxb44TG++qAsdFZHZW11NiPUZ7LLuLYHV+iNQJvhCwaQYtc6Qnv3kcqrFOmUYTN9tCbZ6bI1e3ZKazKMAzDMAwzi1RnJCaBhdsBhAGdnmpQOdhjFgJW2CwNXwiJU4urSHQCTyl4harwI1WIHqHIiEg9WB0WFueWT5XyOh2FVtTGPTfdiVtOnEU1rKAaVEYWRXsjfuthFbWgQoXTao3ed3f9VlZ0GldRMU95NLEVgCdVFhXo2mKsRStqk3Cm86ruAnkxtYMIPR+vu+cVaMUdaK0hLLqiNftdzzR2DRDlrjhFswFzlToW6/O4afl0KqGW97jMU5DL97Hed2bCUr/9II8CbFTqXX9TarAYRwX/fDy9dhFxonH+7G1dnrPDYGERJTFqYaXrswICwpPQWkNKoOHVMVdrZO0K/QB3nb61r2iftV+Q+FSuHv1gjNEUpej5tPUBl2jU0UEKKlBXFN9GifSz7jMDGpJ5gBf6ihACsuSpGipCd0Ab+t57qahlrcVctQFPSrSiDrQ28IfQ4UxqVbJH0BwWm57XNHLZpfkroWCl6fLdrfhh2jXpXh7K8sSJvenny7S0K7peOE3euv9RWyWNdwaGFkusReB5Wd/yFS1GJAlFh1K2RhpNay3uvukFWKhRwc1R/V570UaXvhb7RWaXwfUhCZlFyZcdy4tv9A/xvJOFvlfYAXkFJxF2Wk0IKRBFsxGRwJRjt1xtVoZhGIZhmBuWwJuN77cs3A7ga247i2/6mhXUwmr2t0FylJsouWlV4PnwlQedpiYfKgppDELrQWLYYbCWROt7bror9/07bMYsujcxVPp2mfeNIYrRbccV8OktjuZJBSMEVhqLkEp2XUcn8pffEVALKpTqXvpcOHFriN2kgr9ORR47lAg7XNTzqOy3dYHcBuCg3QshsDK3hIpfQSG+d+hWCwiEwf6LOgKDI+XKXkNXUOmwkP/xZCM9e7c/SjG1Q2HLL3KV9fEdlcRotKMOPKUQKB/GDzFXacDzhotKTdLMCAEBeZiMCNjCfWGh0/HKgqKWPecTKwRUV9toMaf0Pqwr4OfE94M/XBQj6VlJP+X/n+OE7NAnIbJ4LpVUkL7LHih8UgicXT459r54GJuFYfaRNbuk3/h+jPq5rr4qyG7JphlA2+1d7LS20ag0cHnzKrRmk9vjRMwBtwzDMAzDMH0RyOvSTBsuTjaA3ZbESmOx629DCztpWuykJ3fTxEXhVIIwKxA2Do7ijI3L3c2lXu+xKxCCBLM+0X0jRV8LUbrI3ajXothvnV9vuc/JUkXCJsVBUZpF5qp1hEEAKSTiJBk5lXnS97eU4xFujxWH6ELD+NxOkq3mNrZbO/CVD6kUqmE1i5IfzjbGh0qjR3EIGwJ3LwPpYoAUWTSrkoePPnbbtbD5NifQb5WQ8FPfcCF6vbdtXzF1EgsIvucdyl5oWKbxPaI3k8CTCr7nQ0qFRqWOU4snYazFQ888AjkjHmBMOQKeATAMwzAMw/TFV8BqfTa+33LE7QAevpJAiP7VlG9kXGQVMJ3J5Lg4Li3vnTyXdaAQY0oJLovAXpuLo6asQJNFh6YelMzsMKrFyjBj0WG9WA9irtrAfE0cWtjr9Sodld77Io9sHS/jsiHoi4vO3aftRxrdjRGyJq4jBABh6ScpgMVaBXecWJpyq5hhqPJjj2EYhmEYpi/zFWC5Phsr3bPRihlFm8NH0lhrYcz1l4+WFVE6xqLtpDiKafxRCxQMc70xaYHRV97I1hTFMcSmxbkYYtZGvht5LFaeSouvhXjV+ZfgpqX5aTeJGYLKjBTbYBiGYRiGmUViPe0W5ExVuI2iCO9973vxyle+Eq997Wvxsz/7s1NNs+5lpcHfahmGubG5USMKp4ktFAqzaSExhpk5LGUuVIMqGtUlbLan3SBmGDZb024BwzAMwzDM7LLVBtZ2ZiMIc6pWCT/5kz+Jz3zmM/jIRz6C3d1d/Lt/9+9w9uxZ/Mt/+S+n2ayMF5wO8dT64WR2jkplykBV2G/k2C1mdhFDladjctx9Xeq9sFn0ZjEaeFLWI8X9MYdj0rYbs4oQIltsT4zEbkfPTDoZczDRDEWRMAzDMAzDzBoWwFPXDFbnjq6mRT+m9g17Y2MDH/3oR/G+970PL37xi/Ga17wGb3/72/GFL3xhWk3aQy2UEIKjzY4z07h6o0zfaQI8G6s5h8XCwlwnx8KkXpaF32cpK2KWocKE5R+xRy2ismg7Pm5E0daRLU4LgccvcwjncWKW0v8YhmEYhmFmke1oNua+U4u4/dznPodGo4H77rsv+9s73/nOaTVnX4yxsMbAQEy+4AozEQTGE1mmjR7Zr7IMJIZdH5N/53/MXL/cqBGGDMPsjwDwlbVNAOxze1wIph88wjAMwzAMM9PMBbMx552aGvn000/j3Llz+P3f/3188zd/M77u674Ov/iLvzhThbwubDYR6ShNFHb/mONGUbR1fp3DXEljDGKdFLYxfoQQ7GN5nXOUI8iwUbHGmKGipCch2o7ipWut5QhghpkRdtqdaTeBGYK5yrRbwDAMwzAMM9vcujwbAZxTi7htNpt46qmn8Nu//dt4//vfjytXruA973kPqtUq3v72t5fejtaTy/XqRB0Yo2AVMsXlOGhr10/s5nixsHCWk8OcH0p5ptCUTCQ6Dh1hxjiu/dICwBgiTCd57NpoWAusba+jGlbQqNRgjIEUslS75TAp/ZMQba2FsRZKDrft6zXq90aMaJ7E+DCubd6I12MUahU5ke9kk/yedyNzag54+PK0W8EwDMMwDDOb+BJYrs/GHGBqwq3nedjZ2cHP/MzP4Ny5cwCACxcu4Ld+67eGEm6/+MUvTqqJuLzTgrX3AFagk3QgpYTvBTMvPs1q+8YlgI28f2MhRij047wqtdZQKhVwZ6iwz3EQFSxsqqLMdjv3wxoDYww8b6q1HPfFWIrjFUIC1qCTRKiFVQACxhrESYRKEE67mQNxkbaTKsI1aSYhOGqtZ7K/jQtrbTaGamPoZyHgjdmOZlzXZdbH11nAWIPdjQ18/vPr024KU5Kt9rRbwDAMwzAMM7sYC6w3LVYa027JFIXbEydOIAzDTLQFgNtvvx0XL14cajv33ntvJqaNm3NbGo//zTYSreF7Hk0wjRlJ/DsqqIr5bBaeMVpDSDm1lg0TVbgfidHZdmZpIl9sizEGQgoI5NW+j7qt+wlZAgK2p9DfpH2D92MUwd1d7+JxzUr0sBQCLghcKoUziycBUNuUVPAmNDaOEwEBCwttzLEUbyfRD8Yh2jpxdJb82Z21xZXtDQSeh3pYpT5qxbFc1JklrLUwxkzk+5Cxpm8/omh5shM6d3IeL33p7WPfv9Z6oov0NyrXmlQFgGEYhmEYhtmLtsDVnRtcuH3JS16CTqeDJ598ErffTl/0n3jiiS4htwxKqYkJt5d2dgFhsdXaRL1Sh6c8iCFTeY8aJzDNIpO6TkeBtRaB5yNKYiRJhED58FNxZVIi3ijbFamQZ6wmoXqGOkOvYHrUou1+bShDvhiSRzdPehQY5toXhXkhBeIkhhRi5u+3dtSBkhKe5wPgqMZxYFMvGAEAQmB6y2T7I4RArBNsNbcAAI2TN5EgOIFmWgA29W2eJfF6Ukzy/pFCQhsNKWT2SBECSHQCWNr31a01vOrmysyPO0xO4M3QFwSGYRiGYZgZZDeaje9LU5vN3HHHHXjjG9+IH/3RH8XDDz+MT37yk/iVX/kVvPWtb51Wk/YQ6xiwFvXQw257C61OayYjWXuZ/RYejmkUI3LinZuUuuhbYHLne5TtamuQJAm0MTDaTEUMux77X7HP9fa/SfTHYc5hsahXohOyTzgGIqgQghbDwMX5xgVZkqQFGFPf4FnDRVUv1OYmHhEuhRyLaDt7ZzGn2DZjTfb7uNuspMq+E+VLS7RQvNXcxpX1J/Hy286Oea/MJDk3P+0WMAzDMAzDzDa1YDbmqFM10fvQhz6E973vfXjrW9+KarWK7/iO78Db3va2aTapi5MND1GygUZlEZWgDmuv/6idWceCfD3FUacAp3qIzAQmEkVmTWxa39lEs9PGfLWOxfr8sfC/nXVinVCRL2mziHZjTCGycXpto3T4XKcVoP45iuXAMDYS4+hXnlSFDIHZ8Yw+7rjrEiURhJAI04jmaeOKQ0ohccepm+memuA1d0ng49jDLPfMYtssUruECVkSdaIIHRGjEoRQAojiDi6uX8JXLj+Od77hBfA8/o50nNiNpt0ChmEYhmGY2Wa1Pu0WEFMVbufm5vCBD3xgmk0YyE3L86j5lyGEByEkrD0elY1nqXDWfhxqMm0tpBSH2cJIKKUynz8h0oI61sCmQetFEWvaYmmcRGhUyevUWAvFwu2h6SQRKn4AKVRul5CeVxeNPQ1IDLOAyIvmjWJBYayBtYAqaQUzjv7tIoVF4f+PG644nFtEMtakVhrjPZ6yY2ZxMSvwgqE+O25cxC/5MOdx4VJKSKFIYJzw2DSurc/yM7X4vKFzOnysbdnjE1Lg0sZVnJhfwsbuFh589HNYbSi88w0vw9e/6M6h98tMl6vNabeAYRiGYRhmdlFiduz8ODxiAEIANy2fQaJjtKI2zCznS6YYa2c6r/MwIkKWkm7zIjdHBaVykxej54o+WRcBbGDSwjDGmtIH6IoHFX8/DNZaeFJhvjYPT6m0MNF0B5pp2Fp07X8M2wg8H/WwCiUVBCjqWqRilEk9NKdi3wGLRGsYk6fGD9uOzK8S4kjdFSwsYn08FsIGYYxBlMTZ73GSTGT8HeXSZMtbI/TNcfTndtxBlETpmNgdCU7F847P149ZFm3dlTLWIPCDkTxmh4m0X24sIEoSXLz6NG5dXcB9d5zDrauLQ++TmQFm+LsiwzAMwzDMtBEC6CTTbgUx1YjbWWe9abEbS0RxC1vtFnwvwHJ9aaaLbwwr1B11JNGwe9JaQyoJa7utEdx2jrL9brXFU17XjWNABaEC3wdsGvVUIuqxHXcQJwnqlVoaSXw4IUMIgaXGQu4+eEBfsLBotlu0/+uUSfYMUYgkFKC+2klihH4wcVEqK0IlBNpRB0KQB6WSCqbkbNxaEn61SVAJKhO/j2KdALDwlA+tdWlB0VhD95RSMyegKSUhRD4aKCnH7i/cu9hVOjpyQDuMMQPHm3GsLIdeAOclMu0FpKPiKLMt3MKfAI1DAqJrIXASJDqBTMeZF952Lzwl0Gxv4b9/+jF8x2uA86dXJrp/ZrwsVKbdAoZhGIZhmNnF2NkRbo9PyMsUaMUW2+0I2iY4OV9HLfCh0wi7fmit0eq0AWAik6hEazyzdgnbrd2xREVNOyKyHy7NVggBo00WVdhLr4BhrEE77mSRkJPGTZgDz0ecFgUr671b8UPMVesQQpAoNaYJf9mttKMOomTCI9Ex0WtGjeCWQmafk1Jis7mNKJmMcaAbT2KdIEpiJDrBxs4mOkmEreYOdtqU9+qVHNYtyHakEkx+9q61hq88+MqHAC1+VMP+++2NRKdo5yMSxGBLj90CIlukiXWCWCd9W6mNRpwksNaiE0d49OJXShcP637X4c+DlDLPEJgQUkqI1FpmVKy1uLp1Ddut3XLvH3lP42HSzx1njaKNQRTH2Gk1cXH9MnY7LXpmmv7771fErCzru1uQUqHih6j4FQR+CCUDzNVWMde4HX/8pQt9n9PMbHKcot4ZhmEYhmGOGmuBQM3G91v+1jaAzd1ddOIEtbABz5tDvbKA4IBCL0IIXN5aowncAdc41glFXery4hlF1kkkRo9lknikBb6GwFWZl1JCKZX62pb4XCqiHmUUrk3/G3g+pBRDT4jHGY3m6n2XIfRDLNbnym23R2Aqu49BQsKkGGXBRAgxcqSkkjLzvD21uDKxybDr0wICvvIAa+H7AXzpQSmZRdyWzQgoio6TwoIEy6GzFHouYaTjPm/r6Zd29OWy3HN3NI9aTyoEqvv54IS2xGi04wiJSWCsQZREuO3ETaXu/V5H73GNFuQ1u39fHdeC3mHdyIUQCP0QW62dUu+3R7Rg14/DZk3sR/ciRhpxLQDf9zBfa+Ds8ik0KjUIOfh+7r0OcVx+gcnCYqHWwHy1Ad/zUquTBIkhu5NqUMNWZwHPXNsa6tiY6VINpt0ChmEYhmGY2cWCI26PCR1oo+F7FZQ9VVJKnFk6mXpGpsWL+r1XCAReAG8I8URJhdOLq1ioNSYuuswSpQVmgayAmGOQCNE1KR5R8imKL7Tvcp8j0Xe8KzjDCCXOq7UMveew7D70EQm3LmJWm4MXTLLPFN5oxuSZLCDgqXIONKPuzQnFFsBcpYZGtY56WEc1rGSvlWrrhFO6rbXYae2ONk4V2qZN/4h7WGRRq9ZatKIO9BALYQ5jDVpR51B9wEXOd/0tfQ64BQxfemkBMzkRka8sBx3nLJjwFyPMRx1vylzNrMDfGJjMgmHx+UJe6wJizzOx+J3jIHbbLVzb3QRQ7hx170/A9zwoIWGsRaQpirxeXcDFjclkGzCTIfSmf58zDMMwDMPMMp1kuoEhDhZuB1APAlT8GoaNGfI9r9QESkk1lHjmmETV8klhrDky8Q5A6vPX87cS59da21Vk6LBtKMusRjz3MqqQM2nPRYeLeL22s4FW1C73oazWnR2pgNP+myxffm/kOziNDvY9L42ylan/6/TpEsEEUPXDkbZTPJbA81EJ9g8Nc5H5FIUoEHgeRhltEq1L+UIPizsfSkpUgxDKU/CkRxGSY93TkAhxJOPyKHeVW4Rx4+hctY7V+eVSn829z52NTb92kb8zicICEOOJMi5rfTEM+x3DYftpo1rD6txS3+33w51XQMDz8gWqxGh4ysMTayXH3huMd77znfiRH/mRaTdjD4E3G6l/DMMwDMMws0orng29ZjZaMaPEpgalvKH9L3uFu4lM0GcgIqoMQsgjFyiGlMFJbBOAEvJIPRKNNTPrMdzLqLYcfsno03GR6ARJyYhLJ34IiNSPcxwtEEdwTS2sNV3jzKyMBl1RfxaQajyPmIMWQ9zridGQI5x+TykE3njzhi3y80GLdHQu3PmZZsStAErbzxx2P6PgFnyoKCUtUpTBRXcfJMIbQ/7O2fhkxyO6HsV4PpY9WIxUZJXsiwQAm0b/dmcVXd4sZ2lxI/Hxj38cDzzwwLSbsS9Xd2YjgoRhGIZhGGZWqfmzodewcDuAtSYACJi0UNYofp1UZMtMJCX+OEACwWx2s2JkVxZxe4RC6nGJmh5VjKAoyKO99ov1+ZGLbY3jekghJl7wZb806VnEwh55O621GLbskmvn2K9b+tzo2dnMMMvjTya6pqJ32bZaWGitB7/H2sxyIN/heJ6pZfrQsNYMeZTr+LrPYSJ23fhTXKTxlYckSfDws8+MqYXXBxsbG/jABz6Ae++9d9pN2ZeLG9NuAcMwDMMwzGzjjRIVNAGONhzumLHTaQPws3TcUThOtgY3GnRtCCkkfOXDWAt1RNHMRQ/kWe4ho/bhafT7wPOPTRTz9Ygryjio8NW4sdbmUaxCDr1INrF+KgBrbJYdYYwBBD8NDqIoKg57rgTEgVHe+4mWAgLiCCKQ3b4MaCG4jFUSjWd27P30sNtz9jS+8iAAXFi/BGOb42ncdcJP//RP41u/9Vtx+fLlaTdlXzbZ2YJhGIZhGGYgm+3ZmL3NftjWFOm012GsGVm0ZY4PFqSvTDpacu9+yYdx1sVGJ8KVaec0j0RJVbo4GDN+5BEX3TLWdgm1gefDV/5I2xp/VkR39LUFSkf0H5U39CxymCMfJpJ01DF3lMwboPu43LOmTHtFuk/3rJilbyOB50NJhe3WLh740oM4OV+fdpNmhk9/+tP47Gc/i+/5nu851Ha01hP7xzAMwzAMwwwmSsxMfB9jhWMAG7ubsHZ1tmZKzEQQyP0Rj3a/qc/qMVkcKCs0MMxRIIWAtd1Rt6P2v0nHwg63KHTj3kVHceSxTqCNRmWE4nnDLEzYQqRs8biG6WtCiJldjLLGItEJ4vRL503L81Nu0WzQ6XTw4z/+43jPe96DSmU06x7HF7/4xTG1ai86uhVAY59XbJ+fp/3ajb5/btvx3P8st23a+5/ltk17/7Pctmnvn9t2PPc/y20b/N6Lz13B5zemnz01m7OBGUGjztG2NxDHRTxlGKZAwX6gKOAeZ47/Ecw2Sqojya643o0xpJRQVqIWVvDKu+7Fte31aTdpJvjwhz+MF73oRXjd61536G3de++9IxWSK8P2Ywkevdr7V4t8BCr+PO3XbvT9c9uO5/5nuW3T3v8st23a+5/ltk17/9y247n/WW7bQe8FFpZP4qV3n8Uk0FqXXqRn4XYAftCA6AiYtIL79SAIMAzDXE/kj1kLIdlTnDkYWpClwqO8ODsYV0ytn2e1pzzUpcItq2fRbrHHLQB8/OMfx9WrV/Gyl70MABBFEQDgj/7oj/C3f/u3Q21LKTUx4fb0vMGjV0ez/mAYhmEYhrkR0AYT+y42DCzcDiDRCSwAWMDAQqSeeEfp4cgwDMMcDAu2zLAIITKvW16Y3Z8yi9ZCCDSqNQSidkStmm1+4zd+A0mSZL9/6EMfAgD84A/+4LSatC+rDe7zDMMwDMMwg6gO76w2EVi4HUC7sw4jFqhSuaVyMVKIfQKoGYZhmHFxo4+xvZGgN/r5GDcWVPBLSQkrkPkkTzL6dlLXcJp9w6b/FaDChLedODOllswW586d6/q9Xqeibbfeeus0mtOXGa+JyjAMwzAMM3WWq9NuAcGhowNY27qG5zauAoIEWwGKLOEJNMMwzOS40cfYon5IBa6YcWKNyc6xM9eY9Dme1Pan2TfceXP634kGFyc7Tjy9zsotwzAMwzDMILY7szET44jbAZxYqOP//Rd/hf/Xfd+A+VqDvfCOOddL4SKGYa5vrCG/XoDGLWPtkRTTuhGw1qIVd6CkROgF2TOBBHJ+PowCLWoDYcB9dD/+n//n/5l2E/Zlu8PCLcMwDMMwzCCSGSkHwN+yB/D8M6u4tH4Jv//Xn8BDzzyG3U4LAE38EqOn3DqmDNbazMMQAvnPDDMExX5jrYXm+5+ZEBa2K4xSCsmi7ZiwALQtfPvqOc/HHZOOU0f9nCPtW+DmxSPdLXNIpODvQwzDMAzDMIPw1WwEdhz/mcoEObswh7lqiGfXnsPvf+YTeOjpx6CNgbEGxsyI9M4MRIi8sApHU80Wx0VEb0cdPPbcU4h1gkQnaMcd6Bm+/4/HWT2eWEy+34oseX94jJ3dfjltjDXY2NmEtQa1oIKKH2bneVAmBkU8H4/zKjCezBI7wigiBRduPW5U/Gm3gGEYhmEYZrY5Mzcb8wC2ShhAK0lwx8llBP4qXnH+paiH1SzySUk15db157gWsplUqqrbrk2no8fx3JTFwsIaeywm0M1OG/XKjLh9D+ChZx/H333lEZyYX0G9UkUlCGd6EWB2W9aNseZYRDlu7G6hHXewVF+AJxWkmnybtTHw1PDPGK0NpHd059QJfLN8Pzia7Ra0NfCUX6q1FFlv8MkvPwgI4LXP+xoEvj/Txzpqv+ll2GO0FrAw6CSH3jVzhJDAz0t9DMMwDMMw/VhvCdwy7UaAhduBNMIAL7ntHpxaPg8BgUjHAASUlDPulXo85ElrLTpJDF8pGGvHMuHcDzcJtcZ2V/0ZguPij6u1BoSAxOz3gmanhVpYmfnzurFDwp0UgK9mf8i0sNnFn1WRyVqLy5trOL14YtpNGYi1JE1ut3axOrcMNaExqpdRrRF8b/L9sziuzGr/2g8hJVbmFg9ssbEG1lJBUiUlnn/Tnaj4ITzlwWgz8T6w3dqFsQYLtbmhPxsn8cSeoweRGItmxCLgceL43L0MwzAMwzDTYb017RYQsx/uNEXOLDRwZuUOCCEQJREAV4Rjdr/uHpf0c4AEgNDzoaQiQWzCTbfWjlxgLtHHI5RICAFtNAnN027MACwslhrzM30vAdRnYp3g8uYaGpX6tJtTCgGyB5lpUU0Ai/XZr0BvYdGJO1idXz5SQWyW74txtCzWCaIkHsOWylMPq6XuCecp7Gx2Ti+dwEK9ASHEkQj3c9X6SKItgCNbWNgPKSSevLw2tf0zw1NlqwSGYRiGYZjBzMi0bPbDx6bI0xuAFD6iJEHohzM9mXZYUGSpksegrdZAFFKlJ31+DzOpnWVrjCJSSoTHoK0C4licUyEEvu7e1+BrX/TqY2E/cVwQEKj44bSbcSAk4inoY7Jwc1zwlHdsfOJpsfZ43PuBN10l7uouF208TsR8uRiGYRiGYQZy88Js6Gos3A5gu21gLOCnk6FZTz0HAFh7bCqQHwfhznFcRLuZjrLs4TgshAA4Ek/T48qkfKlniaX6PI6HxHh8EBjdDoKZXbQ5Ps90Bmgn7HHLMAzDMAzTj0ABt6/OxvdbnjkN4ML6eiYuHZevtsdFYGSY44Qxx2UEOFqud9EWoEh975hEXDLMNAk59f5Y4avrf/xmGIZhGIYZBQngvlvVzOhrs9GKGWWjOSNOxAzDTA0BAXkMrEeYyUDXnx+VDNMPay20MagH0bSbwgzBLUvTbgHDMAzDMMzsIQC86KzEPWdmx6CAZ6MD2O3YzIdP4BjYJDAMMxFuhMhShmGYURBCoNnexfNPN6bdFGYIlusSwWxk/zEMwzAMw8wMFsDTGwaXtmbHMI+F2wEY04GxBgkXpmEYhmEYhtmXaljlBa5jxkYL4GQShmEYhmGYvWw2gc99NYG1s2GZyMLtAJ68/DTacQQlFay1MHZ2FHeGYRiGYZhZwFMenlrj70jHiVZs0OG4BIZhGIZhmD0YAJe2La7tzsb3WxZuBzBfDbDZ3GaPBIZhGIZhmAFc2OSvlMeJa7vHp/AuwzAMwzDMUZMY4MrObHxb4m/ZAzh/5hw8qbDZ3IEFILmyOMMwDMMwzB7amr8jHS9oIsKxCQzDMAzDMPuz09bTbgIAFm4H8srbb0U1CFEPq/zFlmEYhmEYpg+a4zePFY1QQoKjbhmGYRiGYfrRjqfdAoKF2wEE0qIaVuErD0II/nLLMAzDMAyzD5KXuI8Vty4LeGrarWAYhmEYhpld4tmwuGXhdhCf/IevwpP5t1qekjAMwzAMw+yl+H2JOR4ks5H9xzAMwzAMM5P4ajZUQBZuB/DsloUQs3GhGIZhGIZhZhWfv1EeK564kmBGgkgYhmEYhmFmktX6bHzBnY1WzCx8ehiGYRiGYQ7CmOa0m8AMwRNr024BwzAMwzDMbLPamI1ATlYmB1CvctofwzAMwzDMQVzefG7aTWCGQFuu3MAwDMMwDNMPkmxn4/sSC7cDSBI+PQzDMAzDMAdhbDLtJjBDcGZu2i04HvBMgGEYhmFuTCyAtSZH3B4Dwmk3gGEYhmEYZuZZqC1OuwnMEJxb5ClAGbjUBcMwDMPcuFgzGxUB+FvbADw/mHYTGIZhGIZhZp56pT7tJjBDkFiFgB3BDkTPRoYkwzAMwzBToJPMxhcBFm4HsBh6024CwzAMwzDMzNNJ9LSbwAxB6AFzFYEaxygwDMMwDMPsSyuedgsIFm4HcHbRn3YTGIZhGIZhZh4BFm6PE0s1gcWqANcou7ERcMVXGIZhGIbpRc+GUwILt4NYqgr+MsMwDMMwDHMAcxXOuz9OCCFQD2YnkoSZDhazUi+bYRiGYWaPlfpsKIIs3A5gJ+YvMwzDMAzDMIOw1uLcYm3azWCGwBiDx68aDlBgGIZhGIbZByWAE3OzIZnORitmlIvrW9NuAsMwDMMwzEwjhIBkBfBY8dQ1ixYHKDAMwzAMw+zL6XmB5fpsSKaz0YoZ5er2Fix/pWUYhmEYhhnI41ejaTeBGYKdjoXhr7gMwzAMwzD7UvEpOGEWYOF2AFe3r4JdbhmGYRiGYQYTJcG0m8AwDMMwDMMwY+Er1yy0no3iuyzcDkCIxrSbwDAMwzAMM/MEvjftJjBDsFwDhyYwDMMwDMP0QRvgy8/NRnoSC7cDmKudnHYTGIZhGIZhZp75cDa+2DLlqAYSIWvtDMMwDMMwfdluz8b3WxZuB1AJKtNuAsMwDMMwzMwTJ1zQ9TixWAUUzwIYhmEYhmH6MleZjfykqX5l+8QnPoHnPe95Xf/e9a53TbNJXcxX/Gk3gWEYhmEYZqYx1kIJM+1mMEOw0QKX3z22WKjZmEcyDMMwzHXNPaem3QJiqklSjz32GO6//368733vy/4WhuEUW9RNVUUAWLxlGIZhGIbph7UGvsffl44T7dgiTiiCgyX344aAFAAsoLO/sBDPMN1YAAK+BGIe5BiGGQEpgM22wMoMlL6aqnD7+OOP4+6778aJEyem2Yy+XNrZBrA87WYwDMMwDMPMJNbS5LiTRNNuCjMEnQQwliYlhhW/YwMJ7Qb1UKEVAzqhv4tUueVLebzhhZRxQmHpi1VgqQY8dkXDTFf6OBJ8SWO65sGAYQ6FS2y5umtnQridqlXC448/jttuu22aTRjIbpsnIQzDMAzDMP0QqWK03Yqn3RRmCFxhsoQn98cKEvUkjAFON/KJHIvvDLM/kQYu7wAeNDyZizHXJxaxYdF2VmBLm+OLJwFfud9m40JOTbi11uLJJ5/EX/3VX+Gbvumb8PVf//X40Ic+hCiaHbFUKnXwmxiGYRiGYW5gpJCIbTLtZjBDEHpplCZzDLE4uwBICRSnKqzVHH842nb8KAHsdoAEHpSYbtRaRQLBRBvAg7rE7JwFFtCPMWnUuieB1fq0G0NMLV/gwoULaLVaCIIAP//zP49nnnkGP/mTP4l2u413v/vdpbejtT74TaNiZkdEZhiGYRiGmUWEEGh15ES+k030e94NjhTsjXo8EXj4Ml07KQCS+2Yr2IQtOJhZoa2pLxpIJBZQEtCGLH6OvC2szE+ccZ1i9ka+sTEAhAVOzAks16dqUpAxNeH23Llz+MxnPoOFhQUIIXDPPffAGIMf+qEfwo/+6I9ClYx2/eIXvzixNm5sKqzOpv0uwzAMwzDMTGCtxfr6Jj7/+c9PuylMSSItoCSlETPHEwuKCBKwe8T3aQunLNoys4I1eX+UKLtQZSGF4H58DBnHYqTA8RJtj3oBNrPoOcJ9HjUCwHwVePktXmoJNn2m6tC9uLjY9fudd96JTqeDzc1NLC+XKwp27733lhZ5h+UL7WfZ+4thGIZhGOYAbjq1iJe+9Laxb1drPdFF+huVQFlokwsZ/HX3+GL3ibZlwakcXjofLzPfUwBGWecQoHT9xHLxsWkQm3x809bdGwcJMSzaHk/GE0l93C79Ubd3pQEkGlhvHfGOjwgB4Mw88DW3+Dg1PxvRtsAUbV4++clP4lWvehVarfyKP/TQQ1hcXCwt2gKAUmpi/07UwrRaMsMwDMMwDLMfQgicWahM7PsYMzmEBALvaIuoKJBgJpFACTfNpu/bSpCnHMNMHgspySu4DPVwtL1IAFUfAAyLtlNAF076IDHWl7NmOMIMj5iAiMlaUC9KCjRCgRDt66IAm4CFEkCoAIUE5xaAb3rBbIm2wBSF25e97GUIwxDvfve78cQTT+CBBx7ABz7wAXzXd33XtJq0ByHaSAwX22AYhmEYhhnEVuc6+PZ+AxFpgUClkYDaCRpHM0HVoOhDAy8r3qKQwJNp9O8NqW7RxNHj2+gIEYg1EB8YRmugAGx1RtuLgdsHX9xpUBzVBl0BY0eLqGaud/i+7YcSBv5saZulcYvEVMzOYLEKVHygIiK85CYFWXZF7wiZWosajQY+8pGP4Nq1a/i2b/s2/If/8B/wlre8ZaaE22fWLiPhohgMwzAMwzAD2exM1X1r5rh06RLe9a534b777sPrXvc6vP/970enM6LyMwFCDwh9gbkQ8JUTN4oT1KOLMrIANHwYS8LljfnN28LYcin70+J6lC96bUIU8uNUAqh4h/ePFAJIzPV5/q4n9Azfe8xg+N7KqXiTz1rR2qKTWHRsmFnADMds3GzW0vhsIREbYKUucM5/DqfmZrNHTfVb9vnz5/Ff/st/mWYTBqK8KpRVsLAQPCQwDMMwDMP0YfaiE6aFtRbvete7MD8/j//+3/87Njc38WM/9mOQUuKHf/iHp908AMBSTWCxKnB1F2iEFpEGrDXwpIKSQCexEDhaP05jgWg25nNHRNGPUc7IVLY/s96+cZAvGlh4kiJy7SHTr20ayWl5LjkVir7CN0IfvhERqeWOsePxuD3OVH2K8N+JJrF1A0BhJ6JxzUKM6P09/WvkFuSEAJRN8OKzFZw/IfCFL8yucS9/yx5IBVJKjrplGIZhGIYZQI3NATOeeOIJfP7zn8f73/9+nD9/Hq94xSvwrne9C//rf/2vaTctQwiBF55RkMJivUmiqYs6aSc0ofGP2TWd/lRwWI5fi8eNxHh8RSdxJo0dzz3Axf+mi2K147rHTvgmEzgOozXpVe0EMBNbcZVQAmiESBe16F8wwjg59dtSAJ5yxyCxVDX4yjWLy8kynlwzMJM7iSMz9XM2yzSjGAKArzj9j2EYhmEYZj8sLKTYmHYzZoYTJ07gV3/1V7G6utr1952dnSm1qD+J7pciLNEZIm5BwE3epi1RTXv/zDBIMZ4rNomCRPMV16dnX7KZNrNcoCiegP4yC4dbLOp4I0IiFnmDC+Giqid3ZdyZnoVrvz+knkYJ0JxgiSYhgOeflKgGQBVtLNeBuUrJz/b8kgu+FkriSP1yMzE+zYj4xCPAA48ZPJOcxgOPGfz252I8dHG2al2xIjmA3dYWKhXWthmGYRiGYfpxdWsdfmNr2s2YGebn5/G6170u+90Yg9/8zd/Eq1/96qG2oyeY8WWtxWef0mhG5IenzeEkgEAB9QBYb9mpSAl5OvTsTquZvWg7q9KTxFpz2m04PjQCYDO18D6sJ/Bx4KiPT4nuBbYbd7wjK4Q8PV+M1ZuYzqaGgNdlE+QMGGxqoSIARLMXkAmAMgWK9iDjhc6EFAbWAgm8QnHTcp92ZCZBgiwufEkLyd0WQpMlMWm0NhTamUYrYCywGwGfflJDW4t7Tk1ODxzmex4LtwM4u3ICkb3RBkSGYRiGYZhyaKPx14/+Hb7hnsVpN2Vm+eAHP4gvf/nL+J//838O9bkvfvGLE2oR0NQhLsW3w0AA1sBmU4Li1Kp3Ntb/Nc/sYLelYBEO9bnyrx303gQSgo4ne13s816D7knhMPt3U+H9pKlxHON++7Ogabgt/K6OaP/drwkkI/STwe+10KDj8g7VtlH3P93Xyr1XpNfdpvXPj3r/ZV7b7SQQoLowtiuxfL/P9W530HvL7L94nwzX7v6vlXlv71jS73P9jnGI+8RqSFiYNKrSHIN+O/7XbPaz3vPaePZBf1HpT/SbTMd96tcSsRn1mh6mbeWfPQI6fQ7KA9873Gt0zInR+OTjBgYegABrzeL5KLdNAQtYjUi7dgogacEXFhIKMbzs7B++3fu/lhgDCZ3eU67ttvBeWhR48MkOWs8+AjkDsZws3A5gpXECF7en3QqGYRiGYZjZwliL3fYutLW49cRZbOyuTbtJM8kHP/hB/Lf/9t/wcz/3c7j77ruH+uy9994LpSZjNPsPlw3+4UkDXwLGKCQW2DsZ7RU4+71mcO/NDQQK+OSTOhWYynyu7GsHv9d0CYq9wlHx51Ha1vvZUY9juNeUkPAk0NEGAhKBUql9xcHbyX8zY2v3fMXHZnuYz5V5r0IuRI/7nI5rO9NrG/1FQEkFTwCJJcFhqSIRaWA3Hv/+XWThMMe4WPPhK+DqdgSpAmgDJFaj28HYwBMSBgLGOtFzHOdYwk8jUs2RXBuDmi9hjEJb77cQ1Pu5fmNR+bZVA4VAAeutw23neN9T4oDPjbYPX1HUo4VKZTsLCQEpBJQEIg04b9fEuvF073jritl7Aoj3PE8Pe/xyn/uSXnOjhHvNUx6MBRIz3vMvhYCxCQAPFiqNAi+ej/Lji4SGUh5M6pMLAG1UISwAGEghU9/9w7e732v1QCJQEtfSe0pCAELAWgMhJGBJLk/gY+nWe3H7ymS+i2mtSy/Ss3A7gNiIg9/EMAzDMAxzg9HqtPHcxlX4no/V+WVs7lybdpNmjve97334rd/6LXzwgx/EN33TNw39eaXUxIRbKW32s3VzrpER+PvnqJq1TSeuyaG2N5sc+jQNiUzFKAkDKSW0Ld+G4nuKnzlMCq0ULq118Pt607qZ0aHTKGAtICTgCcAaAwOJQO0n3I5rn+Q3WdofVgC3rUps7sTw/QCeBFrNNrywjlZCVizGUr9QErA270vj6CqeAowGbXjM52MvAtoAS1XguZ2j0QqaEbB7JHs6/hSlujLEmqTXIC1UFWsDTylIgTR9nrY4aExzL3kSkBIQyfifFfuN6QIGfvodIZqcsxK89MHhIr49mRb9SwxsFpO8t339tmUMnfde3Ge6Pz+Ze1obYCdrg01F23S/9GvWiLWmxF0np1+tdQaCfmeXrebmtJvAMAzDMAwzc7ikwiRJ4EkXNcc4PvzhD+O3f/u38bM/+7P4J//kn0y7OXtYrYvM2/bwM0wLTwFbbcBNsLzrcIZx1FqkAZ3HQMSYq4xWuRsQWbsDRFhtjH5t2rFrw141TwlXWMamnoHHn1kK3zEW6GjyZFxR17Bc7xaVJoGS5YuObbWBh58zqMsmVZw3QAwfEMBNC8BLzwksyk0EikQbCzFWf+OKX4zOmzyRBq4doQfydXJLHQnDnKtc5BUQ6cKUgEWku4VQT6ZCHuxA8Sw2QGcCom0vFulCGgxkzz2aGPo3TgS6R/2ibcB+uzroHJHxx14x2v2U2OI2JjPGtZPiIqQoLCLRM7O4QOnL2bgDr8OvVeMjMSzcMgzDMAzD9OIrStryPA+J0Tg9X7Ks8A3A448/jv/8n/8zvvu7vxsvf/nLceXKlezfrLBclzjREMAhoyNdkmYrdoVFXDr3GBo5Y3jyKCdOhiJXDRDZADttCiYsW3U7UE6EoO0oAcRQSDRQ9/P3DTMlrviUViy6PpU6rwqgFgAhOhMqilNsqz0SUVVMSbl191QRC7r2oQe0TBXWTD6quWzBIYDat9kGruplXN6mCFEDgcQAl3eAhy9bbJoFxAap0DText+y5BYkBKSY/DKiFLNbnIrpL+IPuqW1pTHWpKN8sf8nxv2+N7p0WhhLEbBxUizqhYksnBmbi7XuHCYG0H3utP2Cf5VAQWQWhf/vs8/C65MYigOv3PNUALhlaTaW8dgqYQA1r14IoWYYhmEYhmEAQAn6xtuo1PDc+hWcOTsbX2xngT/90z+F1hq/9Eu/hF/6pV/qeu2RRx6ZUqu6EULg5bd4+OTjMbbbowmtMk0ltGnqsJSA3uOrd3yZCyjqqpPOBYwl4TLSGnYCUygFFIR08jB1IpcU1JayYlrNp/e3YmTpnxYK6y1KK3cMM8e/aUlisQp85vEOtAwpCstYSg1OL7kSJHsMI/qVxVeUXmuRp7FOUrsc5hhGs9HYe68Eav8UYoCup5LAjq2jtZlGy08QY8rfyYl2Nhy5pYeGQCeh7TioEj0w7jHiyxedr6goXLfJjUVCAGLC/W/WOLxVDPmxHt052//a7+fGCqTjpOj/uVmESpE59lvyGQ8VlT8HLSiquCzUKgMI8unW6aKTJ+g7wyCLh6J1Qm/U72FRonts6oevaKF7FmDhdgCVcAE7R5gGwTAMwzAMcxzwPA93nb4VO61dPPjYF/GSm54/7SbNDO985zvxzne+c9rNOJBT8xKvu9PH319M8NyWRTMaTuhwEykBC0V1PaBT/83jjoCBEKrLV9alq08m7tZCQ0CBIgedkJ5FeaWee2WjqdoJRRPZNCXV7cNCFITB4a73iTrwlWsWQlicblBk9fZOG3P1OjxBqeMdW8FcBejEQHvMwS9diwtHIM4NgzeMH2zG/u22fV6zAJoxveZE1YkK1yjf3yzyKDsXWae1hDHFcyMmdqXifds5uX5hQaPAjRTfdfi+lkZDCyBKF/gknJe3hoQ3kfMZFkTHHNp/7zGNI1rVZSBcTz7fu0MItUXyMUqSzzW67VcS3f1eoFusdZHTvicQj9iGfrSTg0cICco02WgBy/Xx7n8URv7mYa3FtWvXsLGxMcbmzBbb7WjaTWAYhmEYhplJhBBo1Bp43tnbEfULE2NmmlPzEl97t49vfL7CCbWGUO2N26n7QIA2vMIsR4AiN6Wk5FEXcSlQ9DudTVz0TvF3R7Fe+G5ME/BGiK64Jic47M/g2boUaWEXAbikXLctAWC+klfdLqaVJoaiMefDwcfm6CTATkTtyY+X/j9QeVr5IIqvVjxgoSqx0bLwkEBKgUAJeELDWqp2H2k6op0OfbjXe/GwFD0PDdDV56Yt3ZaNfvXV4Ml3UnIYdffeuOm6F0RagGhIyU6Ibq/Io9CvlJhkvOFeStw+TB+EpJ6RpdxbygYY/zcIQ88jmY9Fvb2j2/RllMWXvXhq/GPfcWU/D1tXuNR5uLt37rk2hXO4UAEWquNtmyuWOAgh0gXbMYvGozJUxO3Fixfx27/92/jkJz+JRx55BCaNL1ZK4QUveAFe//rX481vfjPOnj07kcYeNVvNTYSV+Wk3g2EYhmEYZiYRAO47/2LMe09MuynMiAhBUZi7poYwBBoVoLXbglepo5VGTlr4XdFILl1SgqRBY2myaiFQ8YClGnB1B+hoC1+KLNpmFvAL6eguAiwxGgIeKj4Jm51OB8qvYaECrDcpVtBPVd1YGwSewmIFeG6nd+t7Z+xeKhw4q4M8lbvolygyC4BM7Oo539pQ2ymOVgw8n/lHU8lWALAGSios1eiYDiKPfLJ42c0KsUktMWBgraVCPMZHM92Wsy8QoPNLx2kghTqkdQJFxykF1BSw06G0W9cfRSraSQEIE8HIEGYM/c1FAyYl2l52X67feWmUYa/lRtnt2Akpoi6SNEQL3/CCOrY7wKcejVGphOjE+0UultjmEWipeTQ6K2aziIuelIIWJwaX+BoXlG2QGFp83E7j8YqLCg4FDSU8yqw45F4F+tusDBMlP+mI+mmg0khkAY2FiodIA0mMQmGwHGu7F2O8rDDm0RTC9SW1K0qAQM3GlSgl3F67dg0f/OAH8Wd/9md47Wtfi7e+9a246667sLi4CGMM1tfX8cgjj+Bv/uZv8K3f+q24//778cM//MNYWVmZdPsnym57CyHX2mAYhmEYhumLpzx4wclpN4MZEWstHnrOQENhKUiFKgFUffJ5vbILRFAQoMlMYnLBKQ3hyAQpAYpQVVKiHhpETYvAo7/vlExkownr5FLgi556uZAqIQWwUhe4bUXgs08INAKa9Ec6bY9wlbwttKH0bDcR7X8sBvMV8va7vHtw23LhVmaRpO5cJAbY7dDf5ioknLcTtx+i33krHiOQC4i5r65Gv2mhQoLlmo/Qo+i1jvWwtksTWo2Q7AvhoogtTJfPqMwm4KNPfanR8yGdawkNbVUmwBhL7WqEgO50UKmF2GyNJjIWKSvajgJtd3QBwiD3mB4nXnoeT+qLWG08Dyt1i8/LFgxCzIVA1DzcLiclf4xaDHFU78zEXH+i2lEhC2OmG61GGe/Ldn+dWtwEiKBF2DVeVz3g/CmB1pWv4gXPuwtfXTf422cO9+zRA/rGMLfs9da/3FqTJwFhNF50NsCTaxbtzf1XoSxoXLfpzZkkwFGWBwUwc+tApYTb7/qu78Lb3vY2/MRP/AR839/3Pa94xSvwHd/xHWi1WviDP/gDvOMd78Dv//7vj7OtR87ZpUW0rJ2gIw/DMAzDMMzxpx3PdtmEnZ0dPPjgg/jSl76Ea9euQUqJ1dVVvOAFL8CrXvUqhGHJHPTrkPWmxUbLQliD9RaJetpWEO+SGJdFCUqaSLloxuJUq3eqay2Jmw3RxGpjDs9tl2uL2Oeno0FgrgJ84z0eLm6arODaVla4jcRpl77pImBdJGugFLTOPS9diq5OT1RZv0ORzWHzSNks8si6wk50TeZCSu21RsNTHgT2FyuLu441Rdu6v+U+pntFxNyr0cPfPq3xLS+UqHjANVQgkm4vVgsSIwUMrO2eXI9LgHjt7QLXWgIPPmEQ+tQ3tzsWKr0ouxHgW4XQE5gLLTqHrFMyKdF2LFhKOR83oQfcc1qic7EFay3WW0Bd7mLTLmKjXe5aWpsX1UOXiD8uxlPkSoAi2MvaU3S3YPwctAh0nHGH1St4C/T37s5fM5BQEIWFlEDRZ8pYGyjhrEwUlmt0jneabSivivvvVjg9L/D5tSZW0gJUX3gmgYvWHeVyJJYi6gUMlFBd48gw2wtSb+jrqUt4khYdd5oWc6HANz5f4ve+kGC9RWO4J4CksIjoLGg2WoOLmPUjX9AcHufHGygg0rOhBZb6lv07v/M7fQXbXqrVKt7ylrfgzW9+86EaNgvcfuIEHro8GxeKYRiGYRhmVplVT7ennnoKv/Irv4KPf/zjWFhY6MoYe+yxx/Drv/7raDab+Kf/9J/i7W9/O26//fZpN/nI6ST0L0IAqdOU87Q4V0f3CLTWObN2Rw8579ZYk9gZ+hRpW0k2Ycxcn+rNeyObPJmKhVpDKQ/GlBPQvNSLzhR+d8XSZJpWf9C8r5VGBAceYKzARgt7KtRbS36MTph152Gp5kTRdH9wkVcSWx2Unjm24/zn3C5BdBV/AgSaMRWqygUyJ7BTASC7T+qpo+wEuBjxe3kHWNvR6Wf7i2YWEiqNGh63YLfZsnh2g7a9VCVRY6djyWdZpNHRNkAnsXTOryP2i9QzWQcRB76XGBRJSJHhAPDYFYNKsogHHjPYaFnsJKtIdPnrqY3rqwZOADt4/8O09fCiLZD3mVFT48kmxkIKMRbBtVgI8frEFpxt3V+QjXF7303CmWcjzNWr6CTAVmf4xYB8vFNYb5EQp2BRDYBqIFE848s1gbpooYm5zPZl2P7hSypotduxMAAqirYRawNPkgB90BgsACzWBGJNiyfjxI3p41j8KLMvID/D8xV6bgpYbHcsHn7UYLuTv3P/TAQ5kmhb3O8o+BKoBwCEQDgjcQmlmtEr2m5tbSEMQ4RhiIcffhh/9Vd/hRe84AV47Wtf2/czx5GKH+J6Hj4ZhmEYhmHGwXJ19r4v/dzP/Rw+8YlP4J//83+Oj370o7jzzjv3fd8TTzyBP/zDP8S/+Tf/Bt/8zd+MH/iBHzjilk6XQFnEmuLYVCp4uslq8aq6dGSXiyYERYgapCmN6ZtjDZxoCNy0JPDZJ08g2ej3bXr/lH5PuL3kYpGAQegpRMneibSAhafISsAJxEkWLiVLT/I7GvjKmsHNizSt1WlbiiJkJqxYKti1lf7Nl/RvEwbaqoIAQ8JOVHL2vxvvjWQehEknur32D71n1k3W9xVO+qCzN0gkBviLRw12IqTuuqrvNZWCCmclerwRhA9+FYCwkNYgNnS+JTSMJTFECSCCxFqzfLGwnMOlR5fFk6Ol9Xefxm6PX4eSgG/bmK9XESXARpv+ngv5+x9f6AEiiVD1q1AArjaBq/oMqlsWjZBKPLl7vczlzA+vV4DpisnH4PN98LU4rMh5mL5ZD8hS4sq2JSHK5teVhKlxXOfBTNpSZvzs3879k+TzBagIPtaabqxLBb5DWGN0EsAgxJIPLNUETOEBIYTAGf8yLqs57HRGGUeAf3yHwEJN4rNffha7wTmychHARpOEXFuwqcmHbcoc8CUQaQ0ID0JYNEKBZquFRFRH6q/d+3B7Ao6qzxSbLNPvFq0Y8JDg4UsGrdh9bxjcjw9ajBwvZFTUCIHYCKzWBJZqs3GPDZ1k8Sd/8id4/etfj8997nN46qmn8B3f8R34vd/7PXzv934vfvM3f3MSbZwaW+2SZlwMwzAMwzA3KNZa3L46e8Vcb7rpJnzsYx/Dd3/3d/cVbQHgjjvuwPd93/fhD//wD3Hu3LkjbOHskVsBiMwioYjt899GQCmQPiIECnjRGYFHLxnECIaabBnrouAkFcKSQM0HfCTwVBoBU2wvCiW+Su7IRZI6KUsWPnxlF9hoC0hYKJGnS2btK7x3sw3UQyAQMbY76Dpfbhoq08rmZRltYkpCuhO8u7djCtHw9IM/Yor9TuQEE4vQc9vZ22JnD+EiQv0xzXl3Y7JDaKGCtV1grQl40OSZaVyBGzGS2HI0QsbhJRMJQKUx70JQ/1KCrsVCBfARZ5GkIu3DAmmBPOiuvuyIEqCDEFe2gQvbztNZohlTgUEND0rkEeb7kd9HFNG4UHWp4sXjLUrH+U8KgIBO+2+OL4EwLca33/7K3iueHP/VrfjFhQNkBfIA9BxzeXo/4won9nuvOIou24dhMmzKvjXvQ/k4RVkUqrAYdUjjarjzJvp2oIZs4R/doXB63r23/KjsKeC2FYnlmsBJbx2vvV1hNbVg8NL7j4R9k8aj95zLNNvFV+RfHmuLQMRYqZEfb4AINy9SFG8Z+p8tO7EsqX7btRZd0cNRQve37hNxXWS/4mWjkD/7B71O56ad0KLWC88oiGnebAWGfnT//M//PN71rnfhta99LX73d38XZ86cwcc//nH87M/+LH7t135tEm2cGmu7W9NuAsMwDMMwzEyjjcGXLlycdjP28C/+xb+AUuULAHmeh7e85S0TbNFsEmkBPxVIXNSq3meKsCcmxuYyYTshi4QYIToa+OxXDdZSj9FhpjwynU9LWPiKJk5eegmjBGglriWpj2z6fifclcG9LRM/Cg30pUWUAEJYLFZJhKL35vt0otF8ReAf3aFwi/8sVuoCrYREBie4kNBFQuKk62D7fXdAUVzUFoNAAYu10YSlapqn6SrCK0kiYi8GKFhs2Al4xdI5bcdk71EP6DqRYDsbE+wiLiJboFdUHw5P0rWriRaWaxTx7SPGi84K3LxMxx0jQKSBEw2gIXZR8fM+7KLIe7Hpa3sj2Z2XtUCi+0U50gaVLCzihPk+e+/JXhE1UIDvUfy27BlyYlO+wNygq577qu49+ECOtpBB0YMCgSChvGgFY8xokZokBHfvQ6WLIweJTX7hvCpMeryx8CVdy3LvHmbLhK+6fwdorFYov9/9MJa2HaKNdkL+7vtxak7gJee8NEW+/BFoDfx//lbjoUsm2879d3t4/V0KtwbP4lteIPGmF0qsqmtZZouLJNaWxEIDhfMnBFZqZInTsSHaGjg9D5zyrqCd0D1T9jy452T3wg3tr+K5xQEzvCi4B5Pd3/stODhB11iytDEWuFbSh3xco3qWiLPPK76ic2ohICVdu1ff5uHU/BEXRBvA0C356le/im/5lm8BAPzpn/4pvuEbvgEAcP78eVy7dm28rZsyn33sMTZKYBiGYRiGGYAUAl+9ujbtZgxkZ2cHH/rQh/DEE0/AGIN//+//PV760pfi27/92/Hss89Ou3lTJfToXyWNlnUTSQuabBUnC8XvxU6bECARjQQS8h+8upuLJeWCVejdLiVSQyDSJNZ6EghFB0tVitCRaUSSFGSJYKAQD+lVWZzA2fR4BYBblgQCL41WlMBKQ2C5DtREGycawMk5mvQ3QuDVtymcmhNoyBbecJfEi89KeEiwWgfOLgqs1ClCSqnJp3gGClhpACE6VESuMEGPMtGNbCO2Wt3idRkESCwQ6W9OkDv4uOREjt1dPwOJ3Yg8hp3A78lBQnY3k5J5ixHdSubRkVV/9H02QqAekG1B4AksVgEIge02cP95Eodu9i/g9XcpvPG8whn/MmoBEPhUyG4UR0vX1v73Vp667u73WuAWN/I9ukhKIboj8g6K8O9uRX+Ki0q973bCpoLeI44mtlyBq969uX14QmOxii4PTAPXFwcLrt1tNOlYlqML1i+9V66Q3J8tPrnz71EI8yEobh3ojdsU6WKMa5vX9Yww8KUT7ofrb/mYbKjwWGG3Au65QJkYox6etfRPgopndpL+7w0914ZycplIhctWDDz4lMGVZJH+LgSWawJzkgqgLdcE2qbSdWzF/wICz23l585mowmwoRcQJRRdP1cBBt+ZFl4q/isJVEUHp+eA5RoQoIN6AHzzPRKn5ujp5+xm9kJZE07gFUBXdLwSNK7VRRvLNbrX3AKRAInDFdHGagM4NZcKt/Cw3RneGmQSuCjbucB9D+rgVbdJ3H+3P1OiLTCCcHv27Fl85jOfwac//Wk8+eST+Nqv/VoAwMc+9jHcdttt427fVLEimMF1W4ZhGIZhmNlBCIF6tTHtZgzkve99Lx544AEIIfCxj30Mf/zHf4yf+qmfwurqKt773vdOu3lTZakmsFgVMEJiuUYTQpFGVQXKpQHrfVMgXcRrcZrpy+6p/34Vw/dCG3d+gE5mMhbY6ZA4G3gCS7VU5NC5H+5+adblEF2+eSt1YKWhsFQFKqKDVkwHFigBJTSJERbQUJgP0eV7J4TAakPAEzot7kbbjuGT0DDhCYUFtTOUMU3MVfdrshBxVfTDDUtGbrnoPyeIJhqI0+iwaRNp4NK26zfDpQBPQlR2EdlA7tPpooG1den/B0P9KKd4H1lrERtAWIOruxbrTZuJQ8s1ASFoQeG+WylVmxY2hr9Ww54fHzGJQIW/9Ua1F+8Fd270kAK/K4a4X1t7t+PJ3HfWiViOYYpcBSqNUIRBJ01jtzZtiwIWq8AJdRVn5slKQSC1thAHCy4Wcs84adG/MKPI2p5aupj8lcQOn+LvtllRtPhT9SnCniw2RHYMrm8LII2Qpn0EXh6B78716NDYKfbtM2JA1OTBGFBUawsVGIuBRaestaUip5XI+4WSucXDc8lJmH2qcl5rWuzaaiZq+ipdVEj7l4XF2i5wecei5pPoWfPJtmTH1rJI1a0W0K9n5WMQ9dvFKqCEhpQC9UAgFBH5bVuFl92sEKADIbDXN1uQyG1Ffg+FHlANqN0eEqzUgdU6bR8AbFHUlS5S2iBQAlJIBDLP2ijLYa55voV83HA2LvkrdN+cnANuCS7g/Ak5M/YIRYYWbt/1rnfh3e9+N97+9rfjjW98I+6991789E//NH7lV34FP/RDPzSJNk6NW0/cNO0mMAzDMAzDzDYCeN7ZM9NuxUAeeOABfPCDH8Ttt9+OP/qjP8L999+PN73pTfiBH/gBPPjgg9Nu3lQRQuCe0xIKGtsdJxiRKNFJXPSMhLA0CfQQoeIBJ+u5P51AKu6lk9eikDrMhEtJJwiQWOCrPLXSWpv5bwIkFgiRRwsVoyzLTrlc2zzEuOe0zM7HCW8NgQdsdUigSYzC1V3ywE3gY6sD/MWjGpe286MrCr7aGGy208JOmLxwWxRqQ4+ifZ2wlU9WbSbiuqNPzN7JehESfMknV6YCBdLtHN5tcnxYm/Yd2LEWRBupLciFck/mUX4+IoTeYK/Yru30iijp5xKrcK0JXNsFIoTY6QD/9yvdfdHhUrXvOkFSjj9ENPKw0XC0BwmAijC5buaO3/1c1LJi7SJeh7tBnBd2qfe6NqT/HbWwVcWjRa2z3nNYqVMke25NIfHaOxRu9i/hG5+vcP95ibpoIvBd+vXB5Pem7RJ8FQzmw2I0pJOa8rOWi9hplKXofr0McxXqYxECVH1gdY6yDaqijfk0qlimi2qBovG/KtqoBLToFapcgHbRv6NBCxx5/x//DW0hEWsSNLO/WYtrTYttU8O1psWVHVtqz71ju0gzHhJ4eGp973av7lpYSLqeIn/eCuQLPBZpwUvlnm0CVZ+ib3c6aYG1VLjvPipgJbVRkbBYqFHWSNizsmkgoSRd01NzAie9tcIzJO9f9QCooE3Ho+mvSpIVywtO00JlM6b7ODEK603KkqF30kJhrIGWDdFxqxBjfhb2bs4TznYkjf7uGW9V4ZmWk/bYKT87DmLAOsP+vOlNb8KrX/1qXLp0Cffccw8A8hB7xzvegdXV1bE3cJqcaCxik+uTMQzDMAzD9EVAYLlWPfiNU8RaC9/30W638elPfxo//uM/DgDY3NxErVabcuumz6k5gZv855DU78J603ZFe/kSMEbDUzItHObhZB24c0Xh6pMa1hr4irxdk/RDUmIkZU+IbmEHoIlZDInLO/Saixy0llLA2+025up1WANc3qV4sEHzr2I0kvsdEPjSRYMLmwmef4qiFc/fqvDwJYvL2xYtVCE0CaQyaaHm13Flx+DaLlBPlnCtabFUBU54a7gsFnFpO7cnyNPIJ0dvhF2cev4qaATKQ6xpsi5MHiV9kPjlhPMoIXFhs0XRaqMl3Y8fuo50vedCpAWMDGDVUJGU42qL6/JOKNc6Fcpl3m+1oQWH3bjcdouHEXgCncSiY0MI3S3ybbUt/vopjSWzdxwWgqLsnJA3om7ZBwMJilLfjoBIK+xG1G8ELJ0H2x3ZGnpAO9Gw8EbuR8N8LlQkHtnUKsRX3VHnZZACODEn8PxTEhcf38CL77wFT60LPPrkNZw/dxPuWFWw1uIi6Hyv1AWW1AYu6gZ0l8duf9XKia/CGsxXJToJtVMbCnW8ZYna/pUrMZQXohoArWYLtUodzYJekS8cmH29yvsh0pT33VigFaWFFxXd67uddDyRgNEWFZ/6sLECoQR2IoGKb8l3OvO3Hi4+sHdc9qQrVFk2a2M4Yk0et4tVYMdU8cBjBhsti2Z8FmuP6dL7TIwbe/Jr60TBy1sWX7kW4fI20I5uxrMPUWRtbwSphcjGbNdHdjqAthaRDdCMbVeEqCicLJn+bJzg6wnMS4urOxadhIp7FrHWIoGHU1WBpZrAxU2DNb0ELwSWAqC124JXqaMVu3EqgLQ0jlmjYSFxaRu4umthrECUAGsxkKCSLe4m6QNGCBJSI0OCc+hbxAPsKfZn730jQX1RGw1PeRAAOpreZ+AycQyEUJkY7gkae92z0EVTK9C4LQSwtgsk8Wlc2rY4uzhsOyfP0BG3X/d1XwcpZSbaAlSNV2uN17zmNWNt3LTZHd70hmEYhmEY5oZjIZzt70yvfvWr8R//43/E933f90FKia//+q/Hpz/9afzoj/5oZvt1o+IigiwE7j0r8Lo7BSro5JGavRNGZ6iY/l3siV4ZPcLU2u5IoiiLyJPk1VqY7WoL7ETUjECRN60sIUtRSi/hIkl1ejBXd0kA2zFVnJoTeON5hfkKMu/aEw3Ak1RJPtHAZhu4kJzGXz6m8cBjBi0TIm/9nqMb6ZyUYaMFXNmhqKdYW2y13e4MdHataGKf9AgE/dqWF8uha9AeesJNTCLYOI8mJLmkEgjUAopOrAUT2OEAagGl2Iq0AJyvXIQnRR/6klKLk7RwXdle0CtiKWGx0yGRR4lC9KNHnpetCLgQn8TaroHtUZ1W6nSfaguIMXVDOv8kKu7GebTgRgvYaNL+3N3oSfJ7nq+SH/Hhk+nLUw2QRY4u1+l3RzlbDbLfePFZiVNzAjumir983OILzxpc1cv4wrOmK/reGIMnrmpc1ctd9iK9rd5v14GiqP1GSOLvco3sJ25bFhBS4OouvS8xVAwyQoBWUhyOU29wPbxAv91246mlSGhNz4bI+jCWRCOTitDaAo0AgBCo+RTlSWPF6Is6Xk/Bs0YFWEjXIQ6fKr8XbYErOwaXti2eiU9jbddSsTyQCr7Z2u9Te1shgMx/1y1QmDTq+LE1i6+sAbsRoOGhGdMzA6lQ20m94fU+Vhlxeo3bNsTaLo3vxV7j3m73WQ/wUvsFT+ZZI+QbbLHdATzoLMPkoedMZv9T8wU8qbFQETjVQGprIBB6ZIcQIkKckI9vK6Ln4lLVXTdaQDsx1x19Ta9Qn4oSO/SiyX53irPmkOm9KYSTbHMbEVu4HgIWS2n08VItj7gVcOvLEtvt9PuG9fDQc3vH0FmgVMTt//7f/xsPPPAAAODZZ5/FT/zETyAMw673PPvss0NV7j0OxImBuL4OiWEYhmEYZuz83ycu4baTt0y7GX35qZ/6KfzCL/wCLly4gF/8xV9Eo9HAI488gje84Q34/u///mk3b2pc2jL40kWN9aahSKPHDWo+RQcuVqnomItWs2k0jTFttJMa2SZIINZyjyfhKFXVAZpMky+oQWz6x5cIkCCWGLJRKDutd5GRFPBo4dGMD0YLNCNgpU7i2JVkBdZabLYFWjEQiAihR3OfxCpstHI/XucpeXXHYjc5hYoEVmvAWpMignzlQQpkqaLDTwcN+tWJlwB8tCFUNY10q0K3nP8sAPjQ2UR5kI3A3slxHtQleyJYLcQQAo0STtgYL27/QeoTaQwghcWLzkg8vW7w7OZkI52VoHO/UquhnVjyXIbBiToVy9veaSOs1NGJ6T4CBDZb5dskkC6cmAi1MMRm20WKUn9IDAkSoQdKUdaAtnX8+aMGq3UBrxB9u1wTqIsWmpgb+d7sxR2Hi9yWAtDWwJMq89SVNrcpiOFhM6siLzAfIhVzAH1ANGovrpBSGduDTgLUqs6nWiDuZxzbgxJufDMwVmKtCUSaRD5/16LqAzEiBKqSLvgYiPgkHvm8QSsCDKpAz2KHSNtuUrXNRfsBFjVfoBoA2zu0H/IEpc89vUHRjVWPxDItwjRyUKEdkxhP9yv1DbpfhxMxJNxYT1YF2pC3qYGCsEBk83dutoDtFvnfbrSBRdgsRV4CUApItIUnKdW/jFgnUmuIJO0L1gKNUKDZaiER1T1jlxIobYviovOdrY47/7sd4NkNEi6XQ4qW1lDodAZtqRsX4WytQGIAH3m/HFT8zH3WvXeYLJG834vMAgRpO0yqcithcO9ZiQubFFnsbD1W6gKeeQ6n5haw3rTYaFl4SPZ4ugpB5joWErWA7oUIFL7rpee+gxBzgiwVWgndy0IINEKLTkzPGzJPsZlfvSeBqMR9K7N7XMOTHhXrS1/TJreOcYu9FhKBAs7Ok6VRJ9IIPYWFCrC2FUPJML3+FmYfodxYd708XNlJfcPrk1h2HJ1Swu19992XCbcA9lWgz58/jx/8wR8cX8tmAOpoDMMwDMMwzCC2OpWD3zRF5ubm8O53v7vrb9/5nd85ncbMCJe2DP7vVxJ0EipE40SI9RZN0OYFUi9Hi+2dNhq1OgSArZgm6S4K5+KWKEzQaAKU2x1YVDyBRANJOlkW2StppI7NI2kDCTRC4Npun8imwu8WNLGL02hcFCZvniz683Z/JrEuQs0gsRLW0OfaCaVK1gLy5FtvpdFQJo/kdRFosHmxFp3aD3g+sN2h1EzfI5G7bfLjlSB1RaB/0aH9GSBgCxJt5it0cFd3NaKkX6Gn4RIt5yok/ay36XdfUZRxMVW3zGFYMYp34GAhz70qYbBQURAQ0MZCwOLUvMBy3cNGO0HcaUN41bT/7d2OAm1IW5PKaPsfk0vb7v2b1AaxtlmquoRGbPzML3K3ky5i2LzdZQkUcHYR8Lefwfk77sbfPmPQjGwWSUaLKDF2I48iIgUJoEoAl7ct4ugsTl0xeN4pKrRzxr+My2qOonZL2ndIAKaEqOruTR8GJxsKsQau7iQQIqCiR0gjfUUu5IYesFATiBKLze0OElkt7T+7WKW+uLWPwNYrjlL0aB5xGGsgGwEGnIQ8UjZdcLF5dOJSQP1JQ8ECaPgWV3aBSJ/IbSwOOMEWxcUMga0OsN0BgCqiXcBXNj2vAtpQVHUnIbFMpOOPyaLnHUMnU+ctSDMRdDpotmIaj43LsOhqOcU3GgRIIqAdIR3bDJSUaWRulpKxZ+zu2u+e1+iTsQGakaUo+pCiuiNtsydIP9E2tw7obnHWh23+swC6hMvi+O5lFhsHU4y0LSNK7mU8AiGtQ1q0Yorcvmu1geedUri6o/Glhy/ghXedx1IV+MIXKJy4k3Q/34rExi3A2ux3A0XierYgo7C2m3uou0jt0BMIRQdIbXosJARoAaniWzx65eBjUVn3oR8qPhDHEWKE2TihIaB1fn0FSLSl3+geCTxaeG3FIXxlU+uS/c+3W6jc7QCtyAD10e+nSVBKuF1eXsb73/9+AMC5c+fwjne8A9XqbHuZjYPAi9Cx1/9xMgzDMAzDHAYhjjg/eQT+4A/+AP/1v/5XfPWrX8Xv/d7v4dd//ddx4sQJvPOd75x2044cay2+dFGjkwDzIQDkRVAaAQlR2x2gEpANAUDRMrEmLzsZA393weDWFYm1rRYMqt3pienkmab3Ep4CbGJgUmHBTYarPk0AoyhCGIbkB5puZ7+IKheNa9OIQ+fXGus8ummhAlR8Epw3tttAKty5banUjNSgWDUoFXkMHbewElECVHzn9+shSjdgoMhDT5AABjihiLaTuMmrT5GWiSVBxKbTRU8BJkGaSF4+Kq4oeKt0f9oCGhUku+nf0u15YlhxeC/W4jA6EAASMpXwMHzJkOLEeq9wKEHnVyZthF4D1uZixVK1ga0OFVCyQmO5QX1jbSeBFRQx5sRDkaayJ3GCE/N07i5sFfYjAFiNxOydMnc0AFSBDjVRCiC2AdZ2Uh9VGwBp8bdRg1xd/zo1J/Dq2xT+5JEEcbuD+XoNvgSe21TZIoLry82YBL0YIT7zFYNnN2Pcc0qSb/MdCg9dMnh2w/ZEA2p4wsv6jEKMxXoAWGCtebCoFJvUDkFEAPw0tZ2i2lZr1BebzQjVsAoB4FqLUsbd+BLIGPO1KjZb7rwOPCvwFdlFYB/hNo9ApHav1kmEjBHQeFcBWlGMBOHeD3dtRWSWF74koXyjZSGswXqL7nFtK+js5Knx7pNFMXXPgtOA+9IJUIlJo5hBI4TzKXVWGZ7I3zsunODtBK/FqsBmcz/Rfu8+c31PFcR3i8SILrFJgbxSY5NvN5XFYSydb5FGYyeWLGAMquh06PwraED0ZgB044p+9Xqlu325j3oSqIeiS7h04qQnqJ0+KFq4v/Cs0SunuQXNZzZycfiwgYC9n/fSY3Tn2u3DGLIwUBKoy12st1aw2iDBdE42sVQF1lvICqUFit6b7DPQm0KEq3u+WezNphHYG6ntSypcNl+j167tJDg1r/CN93h45LkEj145+Iw0QhJdt3fIw96XwPpWDN8LYUE2EzZ93tF9EsHYEK3YZUPEqPkBZSNYD1VBCz1232KI3f3cAPjc0+Trf2p+dsTbUi158MEHkSQ0ur/qVa/C3//93+PBBx/c99/1xKn52Z+EMAzDMAzDTJ0Zt8v6H//jf+ADH/gA3vzmNyOOKVH+RS96ET7ykY/gwx/+8JRbd/S4FMmajz0pkr4iwS1KPelcQaRI53YIvgK2OxaPXTE46a3hpkWKVPWQoBYAZ+Zy37uiz52vui0VhABOzgncFjyD19+lsFqXaco/Rc+EylVIp6IugaJJtktjdl6tiQGWqkCAmCJhhUCgBEIZ40SdvBJF+rm5cP+JNEVwpoIoFLbbBp9/RqMdA21UsLZD3p1ZzFcqnCoYapfI/fU2WsBOO59M08SW7pHVOnB6AfChUVHd0q1EfykmFx0oBbV4DIkFOoUJ6WGFAoBEoq6IRptfu9waY/CeDCQSPbr+K3r+66gFJNBLaPL07dAk/4S3BiGo6M5iVSCBB2OorR6S7BoJkAi0UCHLjUAkeNnNCt/yQh8n6tRXpSCBxOxpvYUv84iwKKH7Yb5CfcyKNJINHhXmGvHYEwM8uwk8FZ3FpW2L5brEal3ACBISswg4F8Vt8uhMSjs3MIaib4u+zfef97Bap/MRKleBnRZuKsothiiKwh+y8dpKXGsC13apbcYCV5vk1dlBgI0WibYAebFe2rTY7VgkVkGI1Df1QOgYQ4+u/yCUoH7xwjMSq2oNtYCKqGn4B/RJ2odOx5fVOi0GdRLyle0k7n7cey8CezMD9r5WTnA1APVhC0SGIhqp6NL+wuRhsBZd9hsvOafwvFMjbAf5MVpQH3LnQMP1qd6YR5F5byskFP0rKbK6ghYWq6k1QtqnAuUK4O09CcVFtEEsVIHVhqDI5bQ35J6o+X+FG9+7Wkv3jQKNEV7qb60E8M3Pl1iqjk9Q34/EuueV7hKGLdIsEQtc1Sv4y8c0/uyRGI9eMbicLOGPH9b4y8c0no7P4i8f0/j8MxoVn/pYb0a9gIU17io6cTi3yMnOUXb8eaS2i3BPUm/0QCR4yU0KUkqsNETXdes3xgceLep4qcUJQO08PS/wlpdJLNZoDJ8P6ZlqUvndT9djYwTwFT3vMy/mOtKI+172Xq+tNvB/v5Lg0tbs1G8oFXH7tre9DZ/61KewsrKCt73tbX3fJ4TAQw89NLbGTRslS50ehmEYhmGYG5xxO1iOl9/4jd/AT/7kT+KNb3wjfuZnfgYA8K3f+q1YXFzEe97zHnzf933flFt4tFCKpIXn752wCCEQIkIHPrbbLtKGEsmpSI3FfIXSIbfaFolp4FvvkthoC3zp4WfxwrvPY6Uu8f/7UrzHRgHIBdIQLdx/voHlmsAXvtDCqTmBMwsKj19J8KlHO5irhaj6JAK142LNbvJ+XKiAUtTjXdx/fgFLVeD/+9lWlhJZPJ6qZ7HhxDiZb6fwLoomSlUHC+Dvn7MwhlI0E03ukUbn4hgEibW+iAAE8CV92ABZNLCEgZQqi45drgHfeI+HR68YXNsy8Lw0qqhjoUTRr9BAQnXJEu4c9kvzLFLW+3EQvdFV2iCLiEbWzv6RS1IAvu2gXqtiq9Wb0j0MeeSaFIC0MRaqQRZFGWlgtS7w/FMSFx+nFGAhBO45LfHsmsXlnVRARwBh0wrwApCWTABWGwLeNnk+Silx320Kf/rlNrSopBFtvdG+FEXuOk9igIoHBJ5Au0Xpwe3CeXMRjGVtAAgLJSmVP0KIv31a48yCwj2nJZ67prHdyYVjWGQV6QXIKsGlTENQVHuU7PVtDkUHy3M+Ig3s7LTRqNfhK2CrBWx3BK41ywvunqT+0EYIT6MrzNBYd+1l4UxSP4kMCbkitQcoK0Y6r8wKOmjD6yOOGyxUFa41BdabBm29grDjKs7bzP6C7EZiGBFkkdiu3VIAITp42c0NBIqilA0EhHX9f/gFS7KfQBa178Tx/HLSuXGn0EJgbZf6kE7H4mKE70EUI/UPIlCANRFCz0PFF/Akuc6OLZU/a4fI7FYEKPtAQkGAxNlO4grqCcRtjVog4EmLnZg+H2Xp8ftEiqbCbqeQ4bG3DRahElis0v2x3QzQSWzmKWwBiHTM9mBwoqGwGwHrrXx8o4US1RXGKwSNPauNcSydDSY2gICkcVYBOomgRQghKELbdiIAFTy9YfGVaxbGnoHcShc/rUagyIfdLWRtd4CqT4LrbkQFLqlrSqztuIW67qhUdx8XI7UXKrStjg0hYipc56eeuk4cpvu2lm0h3xJdG18JtJNUPLYkBLdiKqp2al7gT/7BYrNFVgnb2QKjRxkOwon8tAgcKAEPCdoJ8OrbFRYqGn/7jMFBfbri0fekL13UODkn9ixwT4NSyuTDDz+878/XO81k+heIYRiGYRhm1kmGUyWOnAsXLuDOO+/c8/ebb74ZGxsbR9+gKRN6gJJpMZV9tAchLGoBRTZe3cnnpoEChO0g9HwSRH2LzU6IjbbI0jGXawJSSrzsZoW1L+21UZCSipmc1BexUn9ez34FblsW+LxsIdEhhL+30ImBgC8ppboaAEu4jJX6EgCKuFz3FrHVAaoeTfqixGI3oklf6HvYjfZPX3XRsvSzRCsqRjIiE3QBiniqKvKBbTfT8kK2OxrXzfNcwRiRSjJ/8ZjGRpNSg6OkO83aV6mQYww8paBtLvh5CtB6ekskBkgjsAxEjytiRZEAstXWgJRZ8ZrE+mhFo9k2uMgpbQyUVAgU9ZvtpsGLz0qEvsh8G1cbCsYYXOzZRjbZTs+xBIkLVR9Y0Ffwirtu6fJ8BMiW4Bb/WcRzd+LiJkWMdZ8HVRAYafvrLWCxarP04K0ORWwBaeG0wvHv1/e62gwSh0UqdFqQ+Ly2o3FqTuAm/zkk9btwdddmIl6x34issrZIxZT8Pt3r20yWEkpoWEuLJM7Xs5OUF9ttJmSKPXJI7/HS/SC6XrMQQ4WJxxq41gQsfNRDKsYXG0BbctN0Nhr1gGw0Lm0D2vpYDQtRxGk0bmIAYSmq1lWW19Yi9ASWqoBoXsNWu47Hr5j0XuznIX0wFs6blmSqfGHEZn3VBT4W92EsCkUGVWnv1d7tFP8qhcgWQ5RtY6FehS+BK1sSi1WKWl/byYXKQRzUpwEgQISFeohEA+ttWn46u0DXY3M7gvWq5FdqJVox9cVGmG/VSW0FnXTf45qrUJ++si2yrAzXj10Eto3b2O7U8McPa2y1KZLz6i6NOQIG2qqsAJYvIggRwJO2sJdiboM7PxLaAJ95yuAlZymiPUltQ8ZB8Rx33TdAasdC930jJMsjV2St6IPsCervBiEalmySttpkK7Bcq2CtCTRtFWjRc3ouBHY7aVR54UCKC57OSgJIF3CyUUvkjQVwadvi4UsJ1pvkEy0EbZPsj9L+KADPdPCyW+q4vA2sN01XUbU4WcdjV+poRt1R3UWsdc+bPNtHwkAbINICtywJfP4ZAzvIOx5A6NP9sdGanUJlI2WuPP7449je3gYAfPKTn8R73/te/O7v/u5YGzYLrO00D34TwzAMwzDMDU6/mKdZ4SUveQl+//d/v+tv1lr82q/9Gl784hdPp1FTxKWSN2PsSZG01iKBhxMNgZffolANgCraWK5TFJQSuXSo0olalPTugQSwW4MLe2wUbl4U+Ed3KDRka++HQGLbCW8NgUcCmIt6ywtECQQesFqXuO/W7u00ZAv33aqwWqcJZSctMubsFwB0VafuxaWdW1BBtThVCwQsVJYer0nsUG7SSRFBm6lQNxeSMF4Uq0OPJsfrLUpdDxRFPC5VyQ5CwsD3SAgupqCqVAUW6e9iinZ7uVhAkXGulNdCBTgxLxD4dLwqbaeLnmsdUFl9f2zW32qijZU6sJKmNQtYhH73QkFvNJS1Fg89RxG1p+aAlUa6nQZwep6u266pkzC3TyRVQ7bwxrsU7jldjBHsT2LIHkNbRRHrCtnnYt0dbVu823pTsF30HEB9zwmFiQH+6gmDS9sWDdnCG+6SuP+8RF00UQm6+02+HwE/TSkv3qe0aNNtAZFYhY30PnGfVhKlRSeKaM7RfY4X6BaAPJmLZQs1YL5kaZma786dxktvkvjmFypUfbJKWeoZpxIrMrEvNs4aQmcLJi46Twj6XNUHqmhhqQa0EuBysopPPWG6vI9HwyJULqpYZEUS956bXNTuFy07DjFQIBXnKjQ2uahLDxr3nKaCdguVfG+D+v9BCxHO5mA3cgXYJKXz71I0eAw/y2JwdBKk/qQ+Im37FI3fu/zmy26h1tmaKGisNigCVIJ83K/t0ljsp8+X2FA7kS4wNsLcjsUVIHRi935nxQLYalt89mmLZbWeRfAell5hvPiztrSIqaHSYlx5kTW3UJr1KJFbGO10kEXkd2xq/2FpXLAoWkAc3Nuy+0vT8dd8oCLaqKUZM09FZ/GpJzSu7ubPvsVq6s0NOsf1ELh5EbgluIB7Tkncf7eH19+lcLN/Aa+/S+H1dwrsmAaihCxV3L3Say/kiiFa5IunBhJK0ti3VEVaUnDA+Rb5uKlNrx/49Bj68f87v/M7+Gf/7J/hoYcewpe//GX823/7b/H000/jF37hF/ALv/ALk2jj1NB2ttP+GIZhGIZhZgHpTVFRKsG73/1ufPSjH8W3fdu3IYoivPe978U3fMM34M///M/xYz/2Y9Nu3pEjhMALzyiEqTharLpenLxXfUlRtsKmPnPdM1GdeuAFfXL4GrKFN55X+Nq7FW4NnsXX3q3wtc/zcWpu8Iy2V4A1goSZs/PAOe8ivvZuhfvv9vbdzqk5gfvv9vDCMxJSUNuWazSRrAcoTKZtVnRIpR66XkGs0mmkVqIpmklnXo0UCTlfoba5iKC5Cp23+QqJjMt1oCpI8F6upRNiSxNlX1F0UeAJLKVefcaSPyC1jCamFGVs0gkksmJV08BTuZBcDYCT84CPBHMhxVkW/SGdv+GoyOzaCKjU49Aai50OeWBaa/csOBRxHs6uWnxxO1JIVH2gnYr6g1iodEfZ9cNLr0/bhiQyFQSPQdGBjYDOK5BHAwIkJOaHRz/sdHKvWiEEVuoSZ/1LqPp7+43zKm2k16Z4nxb9f915dCKPEk50JWGtzLDuUqSLrfULwnX3EXf/VQikYrzzsi5H4JH/KYTA41cMPvOURjMGYnjYapFYpC2d2KL9AnkzCwQihkyPtSg6bUeCCikKhZ0OiX4ag4thlUdASqTenMkeUa+3OwtRRjIrj4TByQZwquEiLGkRDUBXVOM5/7lsXI2NhJfG+I/alsCjMVdDUeG5wnFHiStARsXmpEtXQLogZoC2reDaLom4e3vI3h7TjPJr7ixqlKTChc4rtYOAxnYDbLbo+LWm/q6Q7HtuFqs0LklZ7Kvd8q0AZQVECdAy1ayo3GGxcKLdYG3KPR96/a97ESC/ZLeoFMPHZjvNqAEdX6Tp2thUDPf63Jz5n+k+Wazmzzcqdkrb3+0Ac6HNXqsHAqcatHAZIMbLbxZ4w10yW4gVontxbqMt0LZkn5Tv1O7pl733qluIdlHkG20BlfoR90OKtPigoYyFcEbcU4f+lv2rv/qr+Omf/mncd999+OhHP4p77rkHv/qrv4qf+7mfu+6ibufCyrSbwDAMwzAMM/PU/Rn5ZtuHu+++G3/0R3+Et771rfhX/+pf4Y477sA73vEO/PEf/zHuueeeaTdvKpyal3j1bV4mju43ee8VeYpYS75zlTRytB+9EzAAuNa0WWXrfgKcE2Bd1M0bzit8w/MVTnrr+0ZZ9vLsBk3qFisuIpDibOphdySb87XUprtwiUVxEmgzQdK9ds8p2RURdN+tEp7QqWjWLRa6SC5K1e9utxOSApUW3BIU1aoNTaSrooPlGv1cnLbnWykrqZjscwoU5dhvYu/eVxRSGgFFJAaI8dKbZNfxAujyh+z14CwryHmS9hOIGNuFBYXdyOLSDkVAdmyITz5u8MBjBjtm/45HHs55tfheBkWKA8COqeKBxwz+5ulyraf0errGa7vAxi5w8DSbTv6Jet5OW+iDecSYSBcKur1qgXyB42RD7Ok3FdFBmEbfFe9T5/+rQF65rThNs04j99wZ02ZvBfm9R0CLCnMBHa2ExkqdxMm9Scz7fF7k91Tx54MwqQArrMGltGgg9WUq3NVJgJatYDeyEIUUdzdkeEJjsUrnqVjgcKVG2QEWeRFDPYKPbT+iBGjHtODhyeIiUh4V7Ngj5KJbICxL/hkqOhZ4NN5oC7z0JtU1hhWFM4BEV18kmA/RR+g6IHIx/a/z3JZAl2AtZZ7yL3rGoq4AXFG2UJ5Fxc+Lk2lL4jsVN6MbK06jUy3ovk3SzAid/m6g0E72npsXn5PwkGSLG+7I82hYm96DAhUvtRwQVDjL9c1iUcODWAjdNTdYqQOrDXcG9+I2mVg6vq4ia32uGz3zaDEMIMFZughYgSzi3qYLDv0et72RwInpfiOdX5EuKOWvdRKL9VYqzqOCz37V4k8eoSJq+30viBLaDvlpi32imffGpcd6bxR5lNBC9HINqHrdp0cKGoutBbS2aMbIBN9ZYOhv2ZcuXcLLX/5yAMCf//mf4y1veQsA4PTp09jd3R1v66bMLUs1/P1z41zrYhiGYRiGuf7YbrcAzE+7GQMJwxBvfvObIaXE5cuX8bnPfQ6XL1/G7bffPu2mTY1T8xInGsATV4FHn7yGu86ew0IF+PK2wLWmxWoDXQWRXPGSWFu0ErIsWDJrAFa6xNhicRZraYK2bWp49IrBs5vk8dqMz2LtMY3FqoDXR4DbT/Qtg4u4lNbgWjOdrNsKorTIjxTkY5n7H6q+GkT252yGTpPQ0ENX26wlcawVV7uKowEUAVZMXe/dl0xF1Jfe5GGrbfDgE214QQWNANjdIWsGTwGLCmi1O4gFqdH7pet2Y+BJOrYk9RUNFFVU39ltw3p1dOL9YyNFFvInMs8/WAslDFYb5P/pjtdTNNl1/pCisMFM0B04pbKoBwKn56nI2KOPPoukfhc2WhYdG6LZRlaQLm61EagAa7sWcXwal7Ytzi52b83ZASR9hA4Xgeori2tNdPXbS9sWz8Sn4e/arkjS0ligUzjWfJGAHJBzwcfgJec83Lok8NEHt7GLOYpILHzKCTBBKrgJ5F61y1TbJy3q5+ORS8meftN7nwqxmn3GeeVe2bEwhYhp11oJ0Uf27n5XYihqXyk6sb4sL8DG2i0kGFhLqfRl0JZ8YmlBiUSnZgS0jCwI3xLrTYroo75JIp4j9AQCZbHRQlbgUEmJv3g0ySK1Y20xnEy6FyWccGnhyTSDAD4WAhKYO8n+xQTdnrP+kv5i021alC9CSJ7TArsRUPNtl+fnyQb6jq/uHjeiijMLJPJv70aACskr1R58boztFuddpKpIxdr0ldQHPKdry7bv8NyDwJ0rFMH76DM7iL3FTCAvZpQMuqYWEs2IrsupuXx8v9YElKCCkknhPrWFn6TIPc0NKFvFUwJKWBhLXt3CFv2K90cKEjwDBRitUfXcvSEK4wn9f5B2hij1Te7EeQaMBQpjsS18mn6iPkAZH6EnM6uU7nM9XDG8KLHwg/z8uutaXAh11iyuAGACsiO4sAVYewZb/6BxomHx/FP5dgKPznGSFsmka2oA4bITRHbuBKhvJoYKV3ppcbTidpQEVucENlsW2+3cL9wVnlxvAXMVixee8WaiMBkwgnB7xx134GMf+xiWl5dx4cIFfP3Xfz3iOMav/dqv4fnPf/4k2jg1FsNpt4BhGIZhGGb26Y2ymDU+97nP4fu///vxwQ9+EHfccQfe/OY3o9PpoNVq4YMf/CC+5Vu+ZdpNnAqXtgy+dFFjvWmwk6zg8pPpdFDfhLXHNJZqNHm6yX8Ocf1OrO1S6qqIgRMN4PmnFB59FHjgMYONVi7Gus+5yMWNlsVOdA5PPEkC5VwI+IgQqMpAAW5UnCDSRgCZdEeORkleLdvatGCLPUigEV1ilACJHg4nTtflLnblIrY6FlUPWXG0nQ59pp+lhIGEL4GKL3BqTuLS088iaZBw6SKhV+sC5xYFnnxqDZvqHHku9plNu4mygMCpOaAVAddaJAScnBOItIWxEsYUU35F12eLQkrgAZ602G67yM1G5kV8WSzi0jZFi2rIHgNhC2tFJjIo0S0CVFRaPb55Ea94/i15kTHZwkvukrjWtPjTv48BP8RilYS+ThotNxcCVzoKDz1ncGah+0T0Vosvprq6CFQPCf7ugsFmC4VFBIN2YqGhsBwCzXj/8zsQQQKhExDzSNL8/EpQRfSNFnDbssCi2kRTz/XdpOs3/SKFhRA4f6J/v3n+KYmLj3f7QjTSc/yVawYPPEoX25N5cTKItBjgAYqNFHSMoQISYyjCraTg7fqYgsFGq7y9RjOi+1hDQaXnhc5NccckxrR1Hg280VZoBPniUzOmhZS62YIQi3sitcsK0PtD95Q7fxIGQlDhvsgIdBJguQ7sdoD1lk0NWACzz73YK9b1Cu1OyLXWQAnKdy+eS51GlW62KeLXWA+11PNzEO4eX/cWsd0RqHpkP6IRlrCPoPOfR6eScOjsX6SUXTYWeXS3KBxPftyeKFfk8G+fpUhSY+chIuqbsQZMej80goPva22BVmRwrSmyRZ3FCh17M8pF9KIYaiEhJfWn3XT7zsPZV0DbyGwBIR+duyN33VnzJC1inZwT+MJXYmx3gq5z4aKvacGPvEaEoYJb7ST3f9aWFu1cQbw9BT6T9LmECEAAX9rU/1llIru7Dr3Pv2Jbipdlp4OuQm7OD9hFWztrlrxdQNGaJdYWUQJc3TX466eApXRRt7hQ2AjIsiIxAgqAVECsDUJPYbmWFoZMF2OWa6Kr+KTbznanCtOyXf73xeObEa22i6GF2x/+4R/G93//92NzcxPf/u3fjjvvvBM/8RM/gU984hP45V/+5Um0cWo8+NUtAP0fogzDMAzDMAww1apJJXj/+9+PN73pTXjJS16Cj3zkIwjDEH/2Z3+Gj3/84/hP/+k/3ZDC7aUtg//7lQSdhCb+CdJISZsXLrq6a/HXTxlUTAjPRU25abglywMXnVj1gTgVY6/uWnzqCYN2fA7hrkXFo8kiQBO1nQ7gQ8FXAp60fQW4UQmUTQUokaZvUhp5r0esdDPgErt1k0+AIqec6FEUp5t6BX6aqtq0lNbfablJL0V7RYnFXMGNzXnwnUpTMo2xmai23gK+9PAFnD5zF57dtPjSRUP7UDQ5Lxb+orOrAXjZ4VhYtGNKgRegok5ruxTdpFEpeC+Y7OiKUbyp9IR6oLDdEQg82xW52YUApKUJbx4JWEyY7/bBBTRec4eP25YlvvCFdSzXbu2KbBJplXENhaoi39Ji5LSvAGlNVvV7IT2nVL3cdFWL9yQgjI9mZJGkbYzh49ouuvrt5R0SdQNrIISATG8IgTKJ/3TG5isk8jv/XCUAKwBtNKSgCFGdnoV/uGyx0dTY0Auo+NRP9yuEs9Om1N2KT2d0kKd0sd+88K7zuRi+z/uFEJivpEcn9t4Gg4RLum0MAqWwUke6OEHV6S/t7BVD+m0DoGshh7j1BZzATKLVVgto7zlvaQQe0uhUKEQJcC0BrK0AUSpKS+CqXsFfPqZRC+g6m/RTw3rbeoihPPJLdRHunrNjSDfmthmlHqOtmFq6UqdIwo3tDrQkscqJmUURs3cRyb1uLHmwemmEcZLevUXhV6b71ahgOfU7NgccZEO2cP5WhYcvWVzetmihCpEWeRtsX+BC7fO/mDSKVNgOpOdhuxBhnY8ZJFwCqfhsNVbqHtoRsNkZ2FQAdE4pnV5DSZndU8tyC//orjoub2lcLpEk/ncXDI3j6aLOQiVdmAKdXxJA9xwiCZOaxk0pKD2/EVp04lQ4FfSaLRQBU7aNerVK43LcwStvq+N5pzwYY7D2LEXGX90pjKTpIotJrWTcKKUE2X00Y+oLGmkBuhBoN9vQop4uKFGhx6VU5NRpioCz7UlE0GWTkpieYxxw3lyhRj/1mPYE9UJqs01FdEWeudYtMFh46XgvYaENUPFokcFZwxQXCi/vuiwWSWK+e74FwG4sUA0slnAZK/WlPe0TQqAhd3AxWSwcY/fC7VxI1jTbkcCXLmqcnDvYmukoGPpb9mte8xp8+tOfxmc+8xm85z3vAQB8z/d8D/78z/8cL3rRi8bewGnSTGZ7EsIwDMMwDDML9BMSZoV/+Id/wL/+1/8a1WoVf/Znf4Zv/MZvRBAEuO+++3DhwoVpN+/IsdbiSxc1OgkwF5C4Bwh4ggQxAYF2TMVEmhFwITmNtSYJf6HooOaTqPs3XzWIrU8RtIWCJHOBxW6HKoLPhQAETdZUun1jgcgGcCn5HpJMgBsXLu2xt8hTvodc5CiTDu2JPNW34lN0rEurX8uqk0eoB2n0XzopDLy0Wj3aUIJE1PUmkBi1pxhcr3C5XCNR7eFLBmu76NqHSNNFfUQIvVScBHn/KeEK6AjEmqKMPCTYTVOAnQdkDk2yCwmuFC2mkBUnWqkBzz8lYUE2GsaYdFJNBY9W6lQAbrUBnJ3bL+05P/8W5N1727IcOCGOEkqr3W6T4OREDyno9zaCLLoaIBH9r5+i6uX1AAhASk+kgQ4qWG9RmrPzb+ztt1U/TamGD6TptGUlW1oDsAUPS/pcYpwnpqIUf+SvV3zgyg6wY2sIPfK79VX3Nt122gkVUvKQHMpT2hjT9XuUUKq0Et2FvHrTo73CcbkoQgmLJC1wVKxOj33vqeKSAOEKV9lUNQ5Ud3T8INx9naTp3r13d3Y+ZB4B3AhpH+59nqQxjaL/ga22RSemBZerO8j8Pw9CIL/fTtSpUKHrC8s1ikY2kOgkLvqTBMW1Xeq7ChoVn4rxhTLOPK17fTxdf7A9f/PSccl0jXeFc4U8ld8tIpUY8jJOzQm88bzCfIX632qdzmUZVuppv0aCpRr9nliJnb62GJTi3ltUTJW0GlYitcMB/TdIXXA29CIWK2QdUobtTj7eBoru05atoB5QpLKLic4jYA10WtCr4gN10UIrpmdt6AmEopM9+ywklCCLj1pI9ywEcGpe4JbgAs6fyMfFhmzhDXdJ3H+3RFW0MisAut40vpPFgaRxzANeeEbi1uBZvPZ2iZuXUhEcHon7kqJxVRoN3AjR5WHv/J9DL7+bis/MXoqSpwCyon8dGyDWFjsR+aLXQ2C7IxAn+QedICxTb2r3ghOiBxWRdPHphSdmZo1w362qy6u5q73WYsc00uflfqMS2TEIKVDzMfbvJYeh1NfsBx98EC972cvgeR4efPDBge995StfOZaGzQKJNqUHCYZhGIZhmBsVo/tU+ZkRVldX8dhjj6HZbOLLX/4yfuRHfgQA8H/+z//BmTNnpty6o8d5wNZ8igyLtQUV9nECXl51WhsSBCpej8gFsgCQoJlkpC20VYh0Hr1nkVa4LkZapqJiDPLUo7RO8lzcL9pwFDpJLlAUnf26EZgLqW3rTXtghKAFRc8licZCRWGhYvG3T5ssrd5FiPpKYF5aXNoGNDycrNBrntRo1EgMaqcRr5W0GFzRg69rn9biSrICIykCCCiI4yEJ7hYSJ+p0nrd32phr1OHL1I+yGePlt1Rxy6LF/3iwN3Jq7/Fmxcqsxj++w8NCVeDLjzzTHfGbRqDVfKBpqljyASklAmHhpcXYAMBXLvIsnxxnIodwvqa5/3GvN7LbhoaEsLmg6T7vCUAbEi4CZfecq04CJPBJ2JKUxu9J2shGK4+qLaIkRdlqS33TlySqWaEG+jw6sdz5vRY9LPt+BgY1X0IC2IkEWhFFjLmwoW4pYYRoK7jo4wTrTbpuzz2iYSyJNlHhOgpQ0b527DxX9/YNp+mSj7GETcVoun/oPo7hY71FRX+acXcUmztPALKU8cUq7W+jZTFXEQh94NoOYC3ZCvQLBrWg/bVTD9pihHcvTqDRhn6uVoCLkUI7Bk7OpcJ6ar8xHwJXk1Tk0uW1TQvnmy0RGycOU58NPIHQs2jGsucTIrMzUEgABNmroUeV7DuJxbWdGIFPaf70/uJ4RtH/Jts/FUJ0wrkTat3pMTYV5OIO2nGtK1L9IDZaNKYEIkLohTTO9yG/54HnnZJYqAr8+ZdjdBKq/BYhyF4nEVIDwsuut7ZAVZEA3m7SzVTJBPdun9fivgAao7vaIgFlgcR6eGodqPvljrfm9y7qWOxEAu0k7VOpj0jRN9aAFoPuOiHx5FNb2JVzmW0OLC2MuCjPig+cbAA3LUk89zRFxy9V0ZXWnx2DEFipC9zsX8RldSd2I1qAMoXCeQIG8xWFa02BnY7BEizOn5B43imZ+l9beD5S/+sWar6Pay1aGBRAl4e9K07mpx67nqJrkxi7ZzzLo7kNFqoKncQVa1Roxs5j9gLO33E3Hr5kcWUn95P1XNhy12qDyARglS7qREn+LLQSODVH3012dtqo1+sQAK7txJgPQ7zxvIK1dt8MA4AyIZqm2uPf3Z1V4aLhPQno2I7te8lhKSXcvu1tb8OnPvUprKys4G1ve1vf9wkh8NBDD42tcdOmE+0gDNgqgWEYhmEYZhDejK90f+d3fie+93u/F1JK3Hvvvbjvvvvwy7/8y/jwhz+M97///dNu3pFDXo4Wnk9ei/vF0Vjkwu2+77ACQlgkVuLqTlqFPk1jFyKP2HPibLaVLLUTiBPAlzbzeD3Ic3GY4wPyFM1ej9FiJFHVA64duEULJUWanu1hqwP88cMaW22bFTIqklgB685hQchxgkwzsthuJnjJOR+3LecefNbarmhIay3aNsSCT/OsYqXtQFFxpU6iEGnadlE4TYxFXbZw23IN661i7GZ/nB+hsRJVX2ClLrOI30gLVL3cVmC9BUTwu1JqHbFx55xS6bWl/qakQKBItNhpBvjEIwatGHu8kYs4sb9XBuyNLFxvITtXAAnkFuTlKARgDYkSgSIBykXVFrfqIkm1EeT/q9LUYRnAFqI6FVxKvYUUtI8kLUCnDQoemP3JBA+ZL5S0YpfyTkJWsd/6ioTdVsvrKk7WDxd97K5b22q04zSSUQC+1WmUKRVx6yS0zdgAG9v/f/b+PEqW477vRD8RudTa6+27A7hY7sXCCwKkCO77OpI970nezsyRRcrHx+KMLHN0PLItyfIRqTPSiNJobGub0WixLHJmzntPHpG0LJqULVKiBYmbSAIECZIXK4G79961ZmZEvD8iIyuruqq6qrp6AdhfHRF9u6syIyMjIjO+v+/v+2uBX0pT/u3xQs/5Q3vbvDqjTPVnSRbnndzdBSKb+6T9ZtO7LXHkSQilsGS9tn2qTMerNfTStShNnQdob42ize2MFSE6Ve51qnh161acWmo4NXqQzvdREaekajO2anurapQYbVIvUY1ICWJH94W+8+r16R2LzqojEIpX3CZ54qbm+hZZkavAA5m0qJQr1NrORsT2K8J6mkoEYWDnW7vZpFKuIARsxlZp3YpHJ257/X+HkdpdpKzoLoZ3fcvgvIil6KT8OxV8pKzdixDdRcWasVVuKlHIAhnKKDzhZ2PUUqfb30VcwKAZWVWrRGekpx2n2+1QCkFP0EHaK7OkZKrsRVmvXgPaWCW6J0XH0ia1zdlUZBYTBR9k0mSmUGG1KahFlmQdVnzTBbgMgpeekTy/pnluHdDWN7zgg0haVMIqYOe0sxgAuLxun0Xzxe4AY5DO/4CYxUqRjSaZN/ZcSSBaBqVbLMxUacZQb8SEBRv0cIXMpEiV80mLaqFKtWADDuu1mAfOlLhw3D7fbBFFj5tbCX/yWA3CKpXQWuDkAzT5Ip5xYtfGwDM8swp1XWLGs9cQeuAJRSFNBQhFTCMusNYwaNN5huazE4wx3KxpInyEsSS/8/R22TTa2DVca2tp40kxtfeS3WKkZnzjG9/o+/OLHRNVEj3CEY5whCMc4QhH+A6DPAT+X8Pwnve8h4ceeogrV67whje8AYDXvOY1vOUtb3nRFdcdBQXfbkhcheZ+JIvAbppVSra4yugO0plHIjN1ik43zlFGeEi2WpYQE2iUTomLNF10s219WhMTdHm8TuP6XHXvME1PTVLlkMDaFdirHLUgku2r0LOb7nJQYa1hFa+FfurE3DF7CUYhBMXAUBeGUtDxzru+ZXj8esxyzdCMbuH6txTl0FoFDCr2VAosobLVBik6RZeaiSD0yfxo27Em6UNo9CLRjryVNCLNU8uG5+LTCAOLlU4l+MATVENro7HVhmLYfZEqLYQDVskZeLBVazJTqRB6gmZsiAlYb1qFmiODb9Y0q3WoJAtdafwI35JGGbHsClsZAs8WitPa0i++tOpvmz5vcnSYyTboTh1px2lHKR76aXpubGgm4Elj09gL9jpJ1eNGpCnYSRstStl4FyklpXKE6yCYlPB0ql6NlymiBcb6dNIpurNUtWOp0dxenGzbsXvUx8ZYkh3ICNGYkMCzf2+2NYmGrcgGMkIRUy6WqLVBx4rA9zG6u+6cU1H3Qgoyf2m3RGSKz/TvwphU3W0Ja5+ERIUY31AIrPI3MZ2ji/SeexIC3Sb0AlpxRyU/jCc36Vjx0iCC88JVaYOsxYHNNnCkHBhmi/bn1UZ/MrA/BLW2nZfHvDVMeIL11OZDYBXfyoAxivmSTzmE5Tq0E6tU7FdEryjanF+qcrzq85+/mRC32sxWyoQebGyqnmBQzOvuLCIEPHwpZqZcoBzaSdNqkhG8CUVkDI9cVjx4djTCwz4zLMlvjMnm1LBxboAnb6aF3hC89IygvGx47Kolxr2UKNfpWJHC2m8YoBSmyseUSLSZCc9z7OwFHr2sU3sf6xNbSAlwR71qR86bznOA9JiLZUFFNKgzk1Mjd5O2YUoc5n/p7CgcaSyFHc+etN7ebWXVzptNuyaJNDDiFKgeisWKpODb+5YnTvM+rr3o8lCPz7ByVVvLIh+CqMVstTMWwD5fSoFho20tBjxps2v6BRg7n/V54Iy1Z3De2LES/PmTCcaInL94gIrS+yRsEGG26BH6UKuRraFWLatZqnZ7w1rlsORMcJ21wJLBngSlbaE6nd6JasF2dL6I5HLNBts2GtCMTGbVYYxJs3ps1sJnn1G0YpMrOCnwdSnLPri2aQMH9lmZG6smDbjhiuoZ2kqwVLHvJYcBY/PHf//v/33++l//67zrXe9iZubFrUa963iZayOYVx/hCEc4whGOcIQjfCej6I0hTTogvOQlL+ElL3lJ9u+XvexlRFHEI488woMPPniALdt/LJQF8yXBct0wE5ruqtdpeqIUtsiJ84rdbFrFksiKjnTSJjNCLVWy5SGwajTlZJMZLBFo1bE+J2e3FwDpVaAO8/bMoxgISiFstaxfnZeSRIKOWkobQysRqfZr+8aslwyqhDa12226qwVLrESE9BIYMseF9ItpKG3b47yha7rEw08p6pFV6yk8Gm1otK0arxF3e0q2E2tT4bw9YwWrDTCmSKBseuq9JyVXn7RK3mbcUbkNQ56g/9yztpCapgQxtDdgttjpkSCtXB4pSTs2qZrRoxZZQteNm62W800mUwM779BK2ElHtuQ61BLYMKdssaieNP4oTQ921glGRxR8n4Lf6dNGDPW2I+Q9YuXGtMRL2x14tiL5WsMFJ6xS3Je2WnlVNFiqzmQKtAC4dV5wdl7w9LOXMZWzVimshC0qpmwwwBFBnuzYJeSLGEGHSNJYpZ7zeI5FmBGyGdFpLDU1WwQpJJHSXeNmEPLqYyEEkTJZQSAhwdN5qxKrKpZegZmCoBEZYkJibdWJtfVVVvWJvsrqfsjbcVgixs43V5jJVo63fdRKoBDAnLrBlrjFFjVL+9DkjuOsMcohtFqpLUvaHoElsRLdPwiTpBYJgYiAEEGH8PVEh4CTAkx23wRSQkHCZmqVMcQZIIdOcbpaXOHB45JnVrWdD1hLA6uObFMpBGnhKk07gXo0PPiyWJEsVQSX2zY7oXfNSjRUZJM7jlkp9ldkk0QVwNj1om0KCNVRnwapp+9fPKWyQMmw9dU9M55rBKw06HiV7oCrm3BtS+OZW1h5UqdBvDSYkM2Z7nkqBbzsrMdMsVNkz9kI3HdS8pJTHk8tKy49fYULd9zC7YuC/9+XFfVIZtkWBg+tyAow+iScW/ARQnA6uMENb4Z6ZINsOlUq2+eDoVoQqQK3c9OT3P3XWLLWBSHduDPGrgPN2FrhJK2U7FaW+rfEfDeRmSdZ8yp6YwyXbmq+HZ/FrxmqYXe2QyuGAiZbU/Ow6mUb4JGyWyk96LOxEpya7Xhjb7Qsmd2kgKfSZyYaKdIAUxqcakR2Pe9dQ4uizUKp2nUu9zw32OfT5Q3DzS1DOxEkxtmaxCjts9k2XUUkQ6+TQROlXsJSB6w27HoSU4QE4i27XgZpX63UDa3oDDeeUhgEoYR6Fh7L7kR2/9zPrcQ+dy6e9g5FYTKYgLi9//77+a3f+i0+8IEP8PrXv57v+Z7v4R3veAeVSmUv2negeOXtC/z7rykGOWMd4QhHOMIRjnCEIxwBItU66CYMxZe+9CV+5md+hieeeALdwyx6nsdjjz12QC07GAghuHja47PPJGxFVgHaio3dnGqrOUkMOZ9Hm+YbKdCmQDvJWxDkyZrtyjSN8+fsJg7d23Uh9Y29vulz8XRnK9Xrz5lXz+yEhbJVyjRbOvU3tYSANlZxKCXIuM5SdYbrm91tsoXFFJ7nZ6QoOO/Ezp4gb1XQq5bz0/RvASnJ0kFeSTdfrLBSt6rWdlpd3pdglE2Hdmmcmy0ohxqBIDEe681UVWZs8bBjZUk9glgpLp6WWUVy5/OXjB1XsQSIzLHXytjNckFY5aYQggIRLROwktpjKFOk0cj3Z/9x4xRohVRKnL8mL01nF6KTxt+I0p53qu/02hUe86lSW6XKzY0ui0hLEpiURFYaNpuOSBWZUjzVztFWIDWc9jZ4y/l51pod4mip6qG1pn55jQfvva3zt3suECn4zBMK3W4xU6lkRLo7ch55Qbm9hwYjJCerlsS8vG6vS2mbgixMm4IfdI2bXkKkF1FCpj7OnzNTsKY/uPkr04JvD571CDyTXfN80fCxL4aWGFUdpXov8kEOk/27Q45Y0tMqTp1Pa+jDUkVy70nBpUtttsgdALtaWMuJmNC3RPJmG3RKELll3AWN/HTempxXKunv50sdr1Ry5Ez/4l+5f4tuq4xh3LVToIaeJZlutj2eXdG5c5iu/sm3LyBmvlRILTyswrQ3+CKE4L5TkmurqsuPtB/JC3DcX2HNn2ejZbLx4NEJBji1fj5QMmx9FUJwclbwzIqPStJgmNE7BoQcuQmS0LNBFUM3Edr7ucCD249ZZW++yJ6DlJI7jhk2nlvljmO34XkedxzTPHY1T8Z1+5YveOtIeQawBb8u3Onx+DXNct3QasUUCwUWS7CyXkfpmS5bGrDjzeBS9DtF5px3slJ2xHcChVbF7dbwJOfpnrXQGLSx6v/lWoc4v75lePxazPPrhtiEJJGzH/F2DBpCd2DQkx2ldD/0BhEd5kvOJskWUnNWAiINvrTTAEecXm/vGrooa9lYdNfU9Ty/qpkvCV52i+Qbz9ykJo+nViyFrMBbMbBXN5MGLTdQmLTIaaIhooCfvaOITJm/2QJpCoTaBge3WgG6DSdnrcJftPKjxP1vZ+xIYZXZL7/V5+Ts4UnBH7sl/+P/+D/yiU98gn/37/4d999/P7/927/N6173Ov6H/+F/4BOf+MRetPHA0EykLbhwhCMc4QhHOMIRjnCEvoiSiGPVw/2+9LM/+7OcPXuW3/iN36BUKvGrv/qr/It/8S+Yn5/nF3/xFw+6eQeCk7OS19zus1Sx985PK8tbosGSXUXfbuAkpqNKQ7DZsiobS04OozM0fkbw2vMUfassKosmixVYqtqCN/nqzc6fc7luuip7r9QNz8enrE9iHz9YB0dyBCIm9G06eJEWs0UIA6vcOx3c4C3nPV51TiBS4spVud8O07XhdudwKlhLmnaIlK1IUCnYlPOtdvffNtv2PFVZ4zNPGj79LU3TlDJPYLcNF2l7wKoL15tWARuZIE23thvygogIfcF8yX7p8nofaeAopqs98KWzjbP0h0t7b5tCpkTT2N289ZCliyjx0o3+oHETEmHHmb0mlwrvyY5K0xZksx6hbeXIA52Rv2qgUruzme/6PdaaI19sJkmLbIEdmwUfatoSo4vljgKtN+U3/7dSYEkpIawCrv8Y2g5trAWDj+Llt3q8/Z6QV98uKYiIYmivX6K6xs1xf2VHBVjoWxoiyZGb7vpd/9jrSNuBxJNWqZ6/rvWWoGUKzBRgvuwUcTYFPG/f0WvlkW9erteohHBmFs76V3nb3R5vvdvnRNWlituiQ8eqUBYtlmbg1Gxqp+CWGNPh7qVj8kVaQDH9gyc6RJKkM6fd/KvH9piO/MkUvsaRWGmfpOf0hWK+RBex1dv7rpgTWJJapKTm9VpaCM9L0+uxhF8zDWI4Mr4im7zzHsmbznvcGlzhTedt35yc6T6T84o9VhFdNgJLFcGrznlUZSdqUZVNXnXOY7YoMvLQkNoAEFOP0gBKSnwL0b2+9sIYw/VNax0Seh2LgT6Cz4zEFuT6M7U1cHN6GEKfsVSOxliVvyQvA+5835e2INVKXWfPiZMzgrfdE/C2uz3OhZfT8ehxOrhB6NsgQX7dbqbjpuCn49s9J+lkF0BHxS1ILQVkpz35gEI7MazUjVWMEvDoFc2fPaG5mczz+WcVN2omtYNRSGnXrKYpUo9shkzo2QBPb+Gs7gBPRymd4G8jo3s/m8d6012Htb1xzyedKozdPe4EJu0P+TXUnW/g87wBX72i2dIzBGmApUjTPstcG9Iiki6IItN5q907hen8LHLtiwhZqcO1zXTsGZtl4axpZI6MJs0wKvjgEXNmFt513+EibWGyApUA3HPPPfyjf/SP+L//7/+bH/mRH+HP//zP+cf/+B9Ps20Hjq2WGvMV5whHOMIRjnCEIxxhOnAbrcOOzfomLzk9e9DNGIpLly7xYz/2Y7zxjW/k4sWLBEHA3/27f5f3v//9/M7v/M5BN+/AcHJW8ta7fd503m5ev/s+wctusUTSbBGWZgTVgqAg2nazng7IWFkli9uUBrKbvMmTNXMlWx3c+X/OFgWVUOBlhbRssRil7ebU+XNGia3ynq/sPVOwm9UvP6f4k29GfOpbimejs3zqW4o/vaSo5dRieZLDAFpYf92lisxIDiEEdxyTVIWVR0auInaqEnVqW4neRtxCXi3HNiLl9Xd63BZc7kuynD8uWVELrNR7N9Idf1DnzekSdku+JR1VWlilkJLqnuh4G/okXQS4w7FKqqpkO+mUR/5vmcIq/XeHOxNsta3CLCLEE5ZgmyvbtgbSbt7dpz3ZPW6qBZuCKoT9ZaxtGrnbSPeSipDe/x6CoODZDfj1TZMV70nwmSvZvtl57bRtlSnJN1OwPpozBWszsLa9uPtA9JIjo26wlbbnPBtc4+SMJScuHJfcFlzmRHVncm5ge0qWjGnGdj4F0hLA2liCXRnn+Wr/nuBnyuU88spdqzC39IgjpfJ6NQdB7h5CZnMQkPCyWyTvvNfjhL+WkeHO1qEUWDuI0MuvDR1V42K5Q+oeq1qSV9r0AGubYcjUn6Fvz3dqFk7MdPfjQskWuZordfyvnRq/4NvxKbAex464k6JjseGTsFSxxxEY0tpImap/s0nmx2mMDRLNputfbxBjs20yMl5KOTBQkEdVNnnz+Z1JXrBr4INnPUohlGixWLH9mOD1DZS49fXxa3obybfWyHuldu62u78OflrgL/tEjhyLFJniejCsf+1qfURvjrRtN2sGkEhc0Ehl8zDRUDMVPn3JkqPuOdEbgBFCZIT3sYq1CmqZIo0YjldtHzZSwlumQSRt6AQWyJOKFjJ3/c7ew2UYtNNCfhJrIXFzy3AlOUkjsj7JYMeKO6ZGstawBb3cGtsbNOwN8LggpocaGETsFwxyGRdFWtmz33nDBl6H1J0twmIFisKOr941dOjzPDTU2xCZgNkilENBIBXlUFAO0+dhVkSyE0QJvNyaI9y7h9kWQnaBQxAZ+ewI4GzcpxkX5dCtU4o7luShsUfIYyLidnV1ld///d/nh37oh3jd617Hf/yP/5H//r//7/nP//k/T7t9B4pvr8cH3YQjHOEIRzjCEY7wnQpjOjvgQwqDIfA8zs4f7roHpVIJz7O7yTvvvJNvfvObADzwwAM8/fTTB9m0A4fbvAoMj12Fb1y3BFitBSs1Qzsx+EKxWE43aLQoBXD3CZkp+aTsEDmOrOk+R/q3LgVSB07xV/DpInL6FVMRRnNtC769Bo3ItrURwfPr8Gx0pkstthPJ4Qi/orRWH4Nmm8Rsm4qjqOX6nf8tFzyubxoUHjOFjlIv328KSawdietlbbt90ZKzixU4VhVZRe1OOzsEeB62IE8zR6Jsv1pBf+WkRG/rl60W3KjZjfxM6r/qNsKQetEaS8gmqZ9pSEQpgO+6RTJTgMiEtBPTncZvuknFOCXDBLbK+WIFSilB0KvUdiRjOYDZnDp08PbbdkaQkpGtxP4q7w85KnrJkdaI3737OLz5vNxGxlZlkzfdJXjwrGTJW+XBs5K3XPD6knOD2nPcX8mUg4m2ZKXA9qnAqt5i1VH83ndqO1mRV+46hblT4OXnQ8dvVneRemAJpoWyLVaUL8bnkCeHjTFEypCkxeLs+Lf336apd0hdKYVVbacKx9kiFFJVfSAhFAkvv9XjbXcHXfPvHfdIyrJpyeAKXWNqsWKPVRUNjle7gzHHq4KXnBL4QtFMOutdkgVYUiJZdNTglhiy87Rf8Gu2MDoZ33t/RyF5waqo82rwYYGSYcGfdqpUbxFaj2JhgwGCbtsDpV3Aq3+botzfXMBPoPClDcbIdLwt10d/92nFJi1WZuezW1Nd9oKDJ4eriruQrUtpcCJ3MKfO1njb1kadC765K3VtaCedrIkkDaBo7PNvswWR7tikSOmC9zI31+wPbWUJW5+kb9Cwd0yNo9R2cMXohDCdZ386T2aKnYuSaVDHT+elECJbQ9ux4ZlVQ12XrNVQz5BIjMgECnEP6+pJq4JVuCKSrl0ifeYAaOZKMFd0Pb0d7reW1rdwBHDH3khYm5K0/792VfPpbyVc3xw9eLAfGJu4ffe7380b3/hGfvd3f5cHH3yQj33sY3zkIx/hve99L2fPnt2LNh4Yas3D7dd2hCN8p6I3CnyEwwPVW5XmCIceSisSpXb+4BH2HU4tcdhRLc/wrRuHu5rra17zGv7X//V/5fr167z85S/n4x//OOvr63zqU59idvZwq4X3A9e37GZ2JU1l7C0Coowt0GHTwK1KTEqRKqvSlOzco9kRGQAbTesrapAoAxsNSwY79Cr+ev058zDGEGPT6l26tLM5MFjPuy8/p9BaZzYKa02rjuslOVy17j+7pFhRC1ZZR+eYvrAq16LfUZkOUisNU8v1kizrTbqqfLs+dOna6be6VFtgycDn1gwSk7Zx+9qQJ8DzcAV5Zop2o92hFByxoFkopxty29Nd6f7bzmQ6t9ulSrt7EOtOWq37bqwgIkADX71qUu9an+W6HR/5FFwpLCHr+sDxJY4gGKTUzpOMRttGydTiojetv/d6BJYkjNVgz8edkCdHekmI/jBESXdLnP3HjWSB//RNzSOXNctqkUcua/70ktqZbMrBKQeXUrJGC49iYJV8pdD+O1Ldit9e9Cp38wSkg1OtOV9PPw3iyHRMHauKlNTv36fuvjViS6qt1q3KcbVu1x7TpfDtRiASir4l9Q1gnKq+2q1idvNvoQTrLUFF1pHSktaWcLUE5GbLnmfO2+SBM5I33iW5NbjCxdN20Dy3ZtDGrlEbzW5rELDzL1FkhcycOhHoG/x64OzoZPyk6FWDDwuUwODgT+iZjJD1pQsyib4F4Uzf/263m5EpcethcsfMrxyjoZ101pxYu6KNXk/Wki2cOUhVnJ97f/G0YqVuKAdQEG3KASzXrVVB0U+J2yFT0ZBPz7fzw2VmNBO79rlnpFPDC+G8yO18NdkzNV2nc90h6Zz/HXeLkdTX4yi1oXvcQDc566xH8uMmD2tdInj0iuaL39bEBGw0OoFgh/yWUWu6gja+MOnc2V7w1K0FPppysJ30zSN/m+LcTSv4gsWy63+dWTgVhVUYL9cNn33mcJG3Yxcne9nLXsZP/dRPce+99+5Few4V4rgBDDd/P8ILE8YYmlGb0PPx/bGnwb7AGPOC2LDvNxKVkGhFMSjs/OEj7Cv0EaGeYb2+SaPd5MziyYNuykjQWoPX5+3rCEcYAGNserKUAk963NiKuXjQjRqCn/qpn+Kf/tN/yh//8R/z3/63/y3/7t/9O17zmtfgeR4f+MAHDrp5BwpjDI9f0yg8FvsUAVHGqiNJVacJPidLgmNlkW5IE6T0M8IrI9oAhcgUftarz6etIGlAoL3MOzCv+MsTcGEPeetsDMBuhvMV4QWgMNyowScfT2hEZmBRM0dUB3WTknqWjLCplOCbiLlqySrUlGF1S1Et+EOLB42KdtJd5TtMU/5V6gHZD84WwRbWsuqgwOv+tCPAT6YEuO5hfrOCPNc11zYNjchWUg89kEmL0KvYyvbYPnWPdL1N52M4PmNZ2hs1S34VQ4M/4JU1Mc4fV9KKYatlCbyw3cbIUqaqVMYq7maKnUJS9swCP01T7+0gjSRIierZgiMZSxQDk6o0nWqY9Eh23Oi0mF5HRWfHrdJWuTtKAbDevnfV0l96RnCsYvjCt3v1fr0QPLViqEUaX5ey4j03tjS15DRiM/VGNSojEj7/rGZhhOJ8DidnBKdmJU8tw6WnV7lw2y3ccUyy2ugUIFsowSOP9B/DTrm75s+z2YaSbz1OywWr+POiNvecLbPZMlxeh1h5aG3vh0haVMIqGIYWVVsodYrKCdEJnICXKReFGHz/Cz685nYPbYZfkwvUrDcNDXWMIFWFN4yd0/UoTXGXsKyO8V+etMWTYh3yjeuaSAlKfkrklQo2+LBNWd19zw02GOBsPoSbb2nwqxi4UbodvR7eS9XB79i9n837lfYWNcsXrMtsIEQEhFmfujk1+Hyd/u/XA3m4ZchDE0hJNOAynDWMRuILOFbeaf504HxnjZGD0yawa1WkrG+qUxXPFTtjY61h2EhOgrJrkTuus38wCOpxGqwy9mpFpsm16Cg8bXq+K4YZJg3eeU+RSzcNf/G0DYz5nv28SQNWJn3eapMvKGn7wfW5JYVdcTjDRns0iw1wQcTtQcxBnx1YDC+216XTQGb+MMYYa6WDx1bbZdiYTIm+3oTAeOk5TOYxvdFyhHiRuJ7akqTfbSZ2j5loj0ZkPa/z5x9ErboR5N5K6ulzM/O7jtzzyVAO0+wLYW0cAs9mK3ztquLEzOEQUYzNWP3Yj/3YXrTjkGIdbZaQ4nAZEx829C6roy+zBwet9eEnRg9x0w4S9sX68ES/jtCNo2FrX1q+/PTXWd5c4++87nsOujk7wmCVc0c4wlhIh4w2Jn1PCg60OTvh5MmTfOhDH8r+/eEPf5hLly4xNzfHyZMvjADLXqHbu9De2FDEJCK0qh4DMZKttt1Y+ShOzgoeuaxopUSmp+wm1DMRpVKJZtRJF3cFgkTSplL2qaWp5IoixVTx5+trnJyZA/Iqv9I2ctIpvpwCM79jdmqtRFvl3lwRYiJCr8hK3RCn6bGn57qJ6rbzsRVp9W1t05xterHAkwYpDA+ckRQCkZFDS1UPrTVXx+xvl4LqqnwLISiIiEgEfdVrEs1c0UMKSTnUtNoGKcmItPxmelDKu8PJGcHpuYDlmuKLX7+MqZylGUNDWfXliRlJadHw9at2c9zTxQhIFZfl1MtVESlJlDhNXX84n0FjoBWDjkARIpTdnCdaIYW/rZBUM7ZqNE9uJ2S2E9UdkrEZ2z5WWqJ1R53m1La2VpslWq1STyBSgrEUwIJe6aqI7s7XjxzbVi39Sc1MSEYcu34zfXZIldCO1VZ0hhtPqSzN2nmnJtpWWa8aS0xvtlwhr9H2MLZt2rZNLdK4rPn2Gtx7skP07ISqbHLhnMc3rluiKyYk1tY71t+6wituvQcpJd+8nvCFp1r4YZFqCPWaLarWTGwwpl+f9sKRQAaRpqJbxBqWt0xOEd59/xcrEq31wGtygRq/blV80ihCnyzlf0ZukXhFtLb337TturFcM9STkxQjq8YjJZFDX1AJ7bVBZ8zmVewGO76UMgS5d6ydAiyd+5YbU08oFsqGe0/2v7bez/YGqpwaPKmcTy0QTN9AybC2RcqSWYkyHUVx+rftY70bngDfxCzX/S4lb5TYOakRKOW+Z9fFR65o7js5GgeTJ5k7ZN126HT9gQIytX7oF8TzhB1z602QOmC1Ae3YXR3bsiGk6PxOyrQIndaUQ8+OFw8WWEHKJUJfAyKzqsg3tOMbLVJ7EksyI2Q2vgQ2oFkIoNGE5ZrZVlhsGjDGzpVFbx1TqHQFLY9XJSdm4JFnYrbaYRep24gt6SwwxEnHNsIVNDMCTGqTs9Vya7O1Q7AB3k62j0msxY4xJdaboCnRbtqMgQsnBE9ds+cfeh2AHWGSuWLHVqIe2Xaq1I5nrZEStxmpLCgHJiP4FysHv086YiSHwJcFmu3p2iV8J6R4H/ywHgxj7GPU8zxKhSLSO7xToF8K3BFsvwTe4VRJfydDG4M2es8XAG0OP2kv7K6D86duO+imjIR2FB2tN3uAF/3zPr08kWosT8we7iyI9fV1fvRHf5Rf+7VfA+w8/aEf+iE++MEPsrW1dcCtO1j0KkDBpvVW0uIgSbqx2mxZIqki6zxxU7PScIV8NEbYDVrbBFlasxQ2PXQuTQ/2hKLgC45VRKaye/Cs3Obx2evPmbcncD6G/SqZ54sTFf3+Rc0ev6ZZresuotpxKo538US3r55TEheC0X0lh6FflW+XRp1PO/UlNrVdtDIvW6syNtx7QmYp8G4zPSzlPQ+XOn7CX+Nd93rbUmdfdc7jrH+VUpCr3J2ee75kSX13nAIRAqi1IcoRG4Ng6NghOCrT+thaX8dI2YJAmaq5KjjjX6ccdo+FdmxYqYMxgvlSZ7119gDHqzJTyCXGpWMnaFKyTkKRjueoRiKlJbj6eT5e3zJ8+lsJn3lC8Vx8hj+7pPhP31A8F5/kL55WLNf0tmrpJsfI2J96+8aS45XAFuCpty1paMebztLIQVBr26+XgtELpw2q5G6Vu92F/HbCyRmRFTF0YyU/b3dTVK23qFySeofqrMfsutRSsNaAJFXqD/Lm7SXYtdY8fk0Tm4A4sar1FkU2mxCn5N26mkOlafQGu1YY7Dqi07HZe/vyb6NOkemhCDxSuxn7iXrcvYYN8xQe9b71pvVvG399fFxdqvybL3ic8a/b4mxBh3SOEsN606o4z85vb1fBt/8fpufoIqqFVUCKNHXeT60xBHYNKwTWxiZS6XFo4YmOtUHeK1agmS3CSp2xxqlTag/WMFtY2lrSTiCQOgvizRQ6/usyVdkqDa203fn73zm+yGxeHALpqFf7hXwxTLBjSmAyu5888lYRcU5x6wtnP6KohvZztbZdNx690l1wbRrIr3fL6hiNCMoBLHkrmU/7yRnBordOtdDtsTtbtJk4LtvGS60I3H1RaSB4tbHdC9yqiWVW3sEVJ5PCPnuKNJkv2b64vmU45q1xrOJ6uveu5/9tH6zlAC6elix5K/heahuUjhuZksVNU8jsHGzwz2yzDTkoHF7W6hBgrlwBhk/+cXGoFZ4TopMScLg3qQYbnXbTW+Z+PkI3jDGZKvmwwWDwjlTwhw5SCNpxRJQcFXUE2GrVmavsfbGmaay7npQTzfXDvuYfJDYaW7Si9kE3YyKMel8z9ZgArRSY8dLF9xvvf//7WVlZ4Xu+p6OC/43f+A2Wl5f52Z/92QNs2cHDKUDzaa+J8ahH9mfLGWrrjwqsqAUakVUAVkJBUbQJpVM5STaanY1sgsdm01bBVjklSzGwBGS/YkWw3Z/TbQoXy7liWbmh2vEcFNk15ZEvurNcN11EtfMYdKnDrjl242hyad676OSetvSr8u0q10sBIW2OVWApJbwdHIl8cnY4kTZOW/qR0cf9df7OyySvuE1k3oxn5gTVguj5vk0xXSgLop5q8W4z3Xt3nReuTq0hOvuI1MpAdAiCN5+XHPfXu8ZC0xS5WbdekREBj1w2/H/+Kubx6/Z+OpLx7fdYAvr0LFQKpFSg3axXCxCImGpoCZqQmPtPC95yYbvnYy+RJo2iGcPlDbiplthoWuWgs9kIPJFWhLf2G/2CDK6HNlqwmnqlGuPUab2f6vjvjlo4bVgl99mCba9T7o6KUQpijeujCXQVlVusuPRxnaXre2g8YVWGyljSdVCgwqW8O4L9M08oPvn1mCubhgSPSHf7Ysfant/5eK426PLY3Uj1W4nKE2kWHXVkx3JA0PGGFqlyc740eoBllPt2NT7Bnz6h+LNLiivJyb7jb5CPaz5o87o7PJYqNkDVToMBzoomK86UI35dwMkIyULJzimnDA892xM+muNVOFax5OxMEb77XpkF6pYqMFcCX2hmS1bx6+ClgYmyaFEJxxunTg0sMClRuDOUho2mGRjEc9YN+cDVTpDCri1FHyqizlsvyG3jvxAIay+UKuqdVYDzw3Vp+65QnsFDG0eax7RVqkY1NlBQDsYouDYC+gUOCr61mVhV81zfMvzpJTWQ1H3grNzmhSwx2bMt7Sm0SW2C0uJ0zu7IqY1Dz64FBmnHRSgIpKIcCuaKdg2s6Spvukvw5guSAlHPlXTPL0/atfbxa5oNNYvW9l5JOlkYtr8Fmy37jqu0Ky64626dCo7YjyG4dXGGUqG4K2rPGEO91TiUBFgvJlWyaZe2bvZvIz9Jfx4ESftCITacV6GDEAIpB6faHSSkGOwBtx/QWo9s1fBCuf8w2ZwyxqC0zq6zHBYJ/eEpK7tFog5J2HMHFIMC7bj3JWK6sPN298cphoWRvb7z4yROEtrxC5OcnAQGUCMWcQu8gI3mC0/FmVeJ7AT3Oa01m801BId7LDz88MP8zM/8DHfddVf2u/vuu4+f/umf5tOf/vQBtuzg0asANcZWvdapUhEBAZrZApTDAQo00fm3cgRULp22V8kySgGofiq/d94rqYgG0DmHRhArumwGNlt0FUGBTtEdEF1EtRCCUMS2grV2qZP2v/kCZNN8JxpU5dt6knYUbPlO7iWRR60s36tA7FeQp9/fpJTcf1pSlQ17L8324yb4HK8K/qv7fF6Wq1EtcUqmDhGeR/5e5VVmTuVb15XsGl1/vfVun1sXBArfjsmUcJfCWhx84VnNzWQ+PeZ2VfG58DKvu0Ny64I9ZtsUWE9TdQ2CZ1bNtgJgvUSaNtCmkBUcsp/ppFW74IRMFYcYS2LNFDrXmJsqNqU69fjtKhrV3dOZqm/UwmlrTavMLQXbRUNCiLGUu+Ni1HHpkPe0TrQtRCTROaLMEmrzZYYq9XsLLAYpkXN106bHG2Sm6japUtITZFYZjcj+zSnwhCPWsHYavenxnvPuxKpvXXEsbTrWHOXQ+u+OEmAxxvDMqqGuS/ge2waCtW2Bmilzs+ZIsO60/nxwzAWqrDXCdrg5dfG0zDx3e4sz5RWvLuAksN7W9VaqoDcd5WQoIltwUYIRNitACJkWgdNstiwx3jRFaikpLtPA4Hy5O1A1zjjdpgYe/nHb39iCY/2CeEpbCx13HDdudoJO+6IUwpngBscq2/fSCyUoyyahn/q0ms78D6QNVJyaEXz3SwJefbukICKKoV1DEjy7Xhk7/goiGkrUj4thgYOZAsTG50vP6S6Fd57UjRVEiUgLr/U8f4VTpVuUA5gt2WHuikgGXmfulwvuHWL79bhr3NJlvnbNdogUhtlCf3LTKbGLvl0L6qZEKbAF1wLPvgu0k85a3ErgxqZhq22yoqmHAWMRt3/5l39Js9k9cz7+8Y/zmc98ZtcNee9738tP/MRP7Po400Q5LGX+tqbn/0dFvd1ko1E70PTeUcmjcaqKm/S4tjpl+iKyTwrWSQsgTZM8f+HQcXuPafXrqMdpxxE3Npancs5JIKSwXmsjIIoPVn06zp2ZZEPq1hY9eLcxVSitqLUm32VMY6SOup4uzS5ybX3vx6k5gGeL1ppEKdZqG1NRWI+zhux3MMSRWDplLcSIc19pRcE/3NYBgzBqD2uj0Tphq7nFI08/SqVwuD1ui8Ui165d2/b71dXVQ1ukdL/QqwBtxpacFVgCQgq7Ie8k/5pMgdZODG1TSH05O1BORYRMCRn7c61tx86oKtZeEkhKyenghlX/SquE05mW0sIXnSIojsgAuznzpCUH+lkVzJesykcZpx7eOc17NxikTrxryZIj663uFOthJPIgArafAtEp6Yb9Ld//g2wr8infUkpCX2abdbff7rfvdspme3z3d7uD8ORgssYYwxM37RdDSaas82SHALmWnMgyxlx/rDUtWTIjG1w4Lnnb3UGHrEo9PgNihIDluu4iq/IEKNj0ZJOSZXl1niBNqzaFtCK6VcO5wvClPstjpg5Mj6OxxEWQqsw6j0aRkr2jq7+ditXv88iyzzRQRrJcM1PdH7njDwoG9EPH09qmJds+ExlRarDkSuh3lPpF396bXjsEl/IeeAKFZ+9Xb8ABu2ZEytl0WGjTKXgoSD2v06CCjVN1H8hPlYSeU5yazn2zBFXC8ar1392JyHZz8Yvf1sQEbDRgpWa6gk8ucAO2SFpvWr82nSKS0AlU7ZTmfXndvlnNF0dTZrufhezukyy1Pbc2nJwVfO5ZRa1lrRJaiSO1TaY4dapWLyWi8xhVYd6rBi7tqCGx7U4U24J4Xpp9sRNEz38d5kvDnxluTS2H1qpitghFWswW7foeijhbU/P2I83Eeq8L0ylWmSe5BxH148zHYQEfsP0UK2t/MciKKPRMFlToe6r0sMXArvf5s3QKE9LlcZ1vSq1tuLpp1fAJAX/1nOGT3zDExme2CMdn08JtaALPkrUuS8cgUmJfpgp1q6Y1afZH7ulFpCzJe3r2cBQmgxGLk7XbbX70R3+Uz3zmM3z4wx/mFa94Rfa3hx9+mI985CO84x3v4Jd+6ZcIw/HVVn/0R3/En/3Zn/E3/sbfGPu7e4nlRne6j8n9PCoqhRLlQnGkAme7KZYVqwRfetu+r02aojTCYaUQO7bBAFEcoY1GCknoByOTWNOCFL2PztEwbt+6F7FRf79b7NVxR8E4faO0zo0pgTEaT+y+Gv2obYiSmJkxKv1OG+MEJ/Z7bvRCK4Xn7f7e7ARX2CqKYzzpIdNz2rIMdr4a7VIUJ+sTW71eMreLez+V+TXiRH3pubu5snp9GmccCG00sVZ4cu/vsYMxhlglSCk5NrMw1hgf9HwZa20+gIVSGZ1u4vqUtB4AKSRSvvBCfON0rTaa5Y3rfOXpr9Fsb+xZm6aFv/k3/yb//J//c/7xP/7HXLx4EYBvfOMb/PIv/zLf+73fe8CtO3jki9fcrNnV2xi7kawWOsVrHKlhsCRLPSWyfJHXE/aHQdCMLaE6qADUKKjKJhfu9PjaVcVza1i1DbYAUpwkIAIkqXo2R6TlCxndd8psq5btqnzP+VCJr/HQ+dsmLkA2KvJVvmMFn/5WwnLdkBhJEqekiykSpF6h956UXH2ymxBwpM9603QVMjoxQ1Z0pxR0CrUt1w0PP6VpxWcp9Pnb55/VLOT8EvsVp3Ip3/micta70e4PnPpwO93lCK7Ozw4yrb7uif5kzbOr1uPYqiG7nz1CgmcgMT6PXjFstIYXa7q8blBGIrT1PFUUiZtpoTQFSUpW5QnQWLvCYRohvJwaTGQKYoPHSt0SeTL1fm7GlmjOrh+nMtOA7CpIBHa+tWNbAEpiFeWBtEq+UYt85VWsgTBEypAYj1pkaMcuJd76Y17Z6O6b3WDQWOxXVMvBEVk3xDxrDVJVvJdZEwicl7awxK4RPHrFBn/cOcqBYq1pCznZivM2awBjx9SgRLk8QWfM9tVLSvshAdQjEGF3McCQmGLRRxurIGw0WpSLFWIFUiRDCwU65ItjhWm6vyvOtN6EIA0+ufHnZk87HZtKp4UhhfUOjZQdfxqZ2U0MQr/ClPn7UgoMG20bRFmq2qKOCMGJqlXabtVaFEoVWula1coVnIyTNZ64WaERdXMoGcFN6iHq7nOfbhpVYe6Cj9dWFbXI2fv0wtBxQ7X/XaxAKxFcbnaCeAovKzaWX7sGcUGugKNGUfB8HjgjOTkjhj4zutdUjRbW47d3TXWfffC85NJNw+eeiliohBQC+8DNV2LqR9T3Fq5bvmS960kWWG0Ylqrdq/OwgE+cBl9Frv+yvskRx5GyAZZ6m2wNM5Cp1t0dMOm6FnjQ0jJnUySywIm1g9CE6b6yrQOi5vb7YhXfPmtNq3J3Rd06/ETnmH76K2tTYf1rrSLXy8hdsGuoL+HqpuHeU4ejoP1IxO1v/uZv8tRTT/GRj3yEe+65p+tvP/dzP8e73/1ufviHf5jf+Z3f4Yd/+IfHasD6+jq/+Iu/yEtf+tKxvrcfqLdaQIA2emI16Tjfm3RAKK1RWmU+hXmSWI5xzFjZRXsYCScArRUG8H1LFO/31tSpn/aaFBvUc3bBMiPdV630yMTZwS8Ho0EKkQYEhCXR99lvdq5c3X/VHZPdH/+Ai6jteT9lQluR2iaovvPSvexM0hpXUDCf/TDq96B7XR113g7DqOt04PnctnRmV+faCVESE/p7r3LM91ukYgLp43leZy0eoU/cfbTkyPbPq1GDDPu4UBpjaMVtPOll/Tzq9fqeRyHYW9uQg8Zzy5f53Df/kmLgsTRTphEdbn/rH/3RH8UYwwc/+EHW19cBWFhY4N3vfjfvfe97D7ZxhwRug/jMquHhS21mylZ5EyvreesIUIHGFZPKE1mjJG4ZrMLo5bd42wjIcZHk1HLuVcRDW6uGbNPtsZymFXvGcN8p+8Fh1bLvPSm4+uQai+Vz+7ZZq+kSDz+lqEek9g8eIn1wCgwXT0vuOelvI5HzpE+egL1Z0zy/BtoELBbS/UiqjvKl4foWKBOw1PO3wLM2E05ll7cqOD3nsVxTfO0bV7h4/gILJXjkkc49LAQCH4URfmaTYN8L/FThaZ8lngc69UAEp7rVFDyPwLMFo/qRNfXIvdX0fxNw3rnfumHwPCj5nf5YqRvi1AOyGFif4wSJ0Wm6PBopPGINQkOiS6w1uwnQfkSOQ/49UeCI0ZBjRZgtC27mVcykCkltMm9mR0bX2jYlukAbLf00PdsGJZYqbmzuPG+cinWrXUIbk87hEo0GqXrX+WPKrr45M7/joQdi0FjsFwwYhvw7Y1cfG6vkVHhstS1RGhMBRa5uOcK3SFJPCUE8AjHGeyOW9PLT4lLu3sh0LM4WBa24N3BxhQt33p0RcCYl4JaqAn+rm4Dre05jMqXwYpqks4HC4OGlilQXfOoQX4bVRsfTOzGQJGRkm/PmdoGqhbLoZMb1oF9hyjzyitc8ySulIMRmKlRDQTWERmTYaiQ8eDbg3AJ87ItVdAKVEBqR62G71hhjgx15/+dYQehtVxhbhXm3aKNXRbpUNduCj3m4MSVwKk6DLwUnZiRzpU4Qz5d27fVEPqhkP+vI9M5vLTJVaJpd8uiV7YGlfhhlTc3aLwRLVdvfNngqtu3xeol651UbKavQbqXe3BstMOY0m99SHK92B1Xy613Ycwlu/ZPkvWo7cMRxwYfjVUGrneB7HonqKNFd8U0RJyQqhGBwoCrRaSZFmuVhjCEi7FoXTLpDcahHpOfrhlPtBx7W5xpNpCSBsmujRON7du7GSlPwPZaqoLTIVMyLlYNnakZiXP7wD/+Qn/qpn9pG2jrce++9/LN/9s/42Mc+NnYDfuEXfoHv/d7v5fz582N/d69xdfUKSisEdsHTI/pa9mKvKSaDQTqJf5+JPCoareZIymCRep/up8qr6/xi9FT1SZH3fDXGkGiVkhR6LPJH9FvZXqDQ2qUZWOWjVT6bvR/gPbDm8ftLFr8Q76LZY9o2fV/M5qIQgnKh1EVWd80TYT/jyL5R19Pe4Nc4V5W3VTFm96TtuNjrDX87jnh+5Rr1doNEqT2745lCwRh86SFzxcxGXYsNlmiOkohW3CZJkuyYiVZjrJX7cw8NhmbU4vmVa2w2rFet0rpbHjYEhSDE3we1+0H6aH/r8pOcmKlwz+kllqplqoXDTVR7nseP/diP8dnPfpa/+Iu/4Atf+AJ/+Zd/yT/8h/9wT6wS2u02//yf/3Meeugh3vCGN/Bv/s2/mfo59gJCCG5fFFRkk1Zs/QjzxXpWmwC20Eg7IUsFdyTHwOMC7oXh1nk5tFjRTnAb0rUGmR+lMVZ1ExFmNg19Lo7VhuFT34r51LcU15PjbLas+tcVVtmpkNKoGCc91RjD1fgEWy0y5a9wHp/CpoM+eXP7MzNP+rj08HxxrDj15+x9FCVGZMRY3HPYYb6SO3mXLpSgkno3htny11EveSSEvlXmhmkBKmc5IDFUC7ZRg+wAKqF7GvW/P86/WJv+/owulbcZa5qR/awrniOw/3Up5zE+7dh0pfELsb3Q2iA4NW4YwFsv+Dx0myQkZq7YsU1w6bqhB0UiKq7ImwItPEoBnJmFs/5V3nb3eGNTCEFV1mjFtj+TXOE4qw4EXyRT88ccNhZ3KjLlfDWNgVMz1svW+VwGqV/pZgs2WtaiRaZ+2waITcBmi64JL0XHq3Kcy3EkYqxT+5X03hSIhnrV9vPiHrVQYK/i1fltQ0r+G3tvbm7BWiNVLaY+p2nvZcdKtCW9lKbLxmTYu2h3YUqrzFZpkM4VZ3JBlG6St/uzCLoKTq63RM5iRHQRfW5uaJNffwTrTbhZg0R7Q61hrm8ZPv2tpK/Fi7OfedvdkhLNLEiRSjnIW7OfqMJiRW7zG3fZJsXA2hFkafamu79dOr5Mx6l7Lm61u72Bh2HYmtr7DJkvmmwt6p1Hjqh3fqzDvLn91Js5SrZbw+TXu95zOKbJ99z1dsNZERUDq34OREIgbaC2kFpB+J4tanfKv5HZ70hhA1W+7KxTNlAluPeUwBOa9RbUIjuns2tO29NRytvftJVV2GskOrVpErnnSyuBsmhSCqz1jaZzV3UaqJkt2sw5T9rMop3sRvYLI72pXr9+fUdi9f777+/rHTYMf/mXf8kXv/hF/vAP/5APfOADY33XYdRCIZNgeXOZtbjImcUTyFRRNglGfcg7+4FxcXNjlcD3KRdKlEL7JDOML+lemJkf6TuBF3T5Kk76emv98cyebm6V1kRxm1Jh/BSgRruZWkF4tOOIYhBmZPWoCsxR76d9FhwOGX4/ONWFADYaNaIkZr4ya0lUxEhKuYwMF6P3y3cKJrVJaUVtPM/rsklxqsZYxVxbu8m542d3OMpksJscmd3TnUhRF1SKlWKzWWO2VCVMST8XFJGi/wtm/ncjjx3Rrewcp3+df3de5XuYZqY2Vmb22Lcv8enHPsvfePU7uWXpNCW/QGECu6JRIYTIOmN8Erw7G8QI99u04GC/HMU+2C/7D6U1tVaDSqFMISik7RRZuw8LphGMUFqPHQxVSvHVZy+xNFOmnSS8/SV3cGq2sifvZHtxzMXFxakfsxe/+Iu/yGOPPcbv/d7vceXKFX78x3+cM2fO8N3f/d17fu7dwpE+V5N56/sowG5vvHQD43HhuN1oX90wGQHlCZs+u+14244/edvchlTL1MIhSTdzA89rmC9bxdH1DcEXv53qrbQlRJqR9bHzzDGrHh7nWdGzsXZEY296ar9U/TxWG4aGKYF0FbZtbztbCoVhuQ6rdc187hDD0pyNEQhh7QDaiSUdnWq6Nz28F6P6SvbCpbyvhfO0E0tQdqeOxzxwa5EbW3BjSxMrS6SEEqRuI4WfkTX97ADOLdoU3EaUT6tNr0N3vDNniiILFOfb5lJ5V+sd5eL2i7D9nhhBK8ldkz9PM06VnNoSAk7x6ItOcSqHgg8mbtOKy6w34fZFwVdkE02BxYolFmu1FtVKhUDCzU3J8aolAFfq2irwLjgF3vjqb2MM62puaGgvNgGk+8W8P+ZcceTTZBg2FsGSRVu6xDOrhtt7ll/nqzkXWDutamhoN1vgVTK7hFjBXMn9nLDaCIkSSChkkkdL0InMq1alBQv7kUyDEHopeWQ0ixWZ3Zv51GJFa52RbHn0EnCjYpDiNW8nAun4yhf0g1S5mn4+9xdt+qfc94Pzhn2uEbJccwrfIlEdfGmQsqN43Wzbfo2Mz0rd3hP32cAzFIMOyZtPuU+MS3vXIByZ3gnB2OeGxpdeSpyW8GOr2uy1hulVkfZTdQshOFYR3Bpe5YZ3F/UoJfKMQQpLInu6zctvrWZjtV+2STm077ztVhs8v8umQop0nVS22Fae8Cv4gs2WGRioGAWDniFVWaPlz7PZhpLfbduRJ+rzcwo63ty+sONGpqS8K9aVz7Bw612/c0jSzMqey9qu8E7Vz9XzrDdNpkTvZLSsc/rcucx+xwWqlipA/Sp3nL2VyxuG59asNUqUuMBcB3a+51Xc9vdOrWuQJGnwZfvz5QYXzs3zyGXd9Q4TeiBMm0KaZae09eEdZjeynxipGadPn+bJJ5/k7NnBBMDTTz/N0tLoPlXtdpv3v//9/PRP/zTF4gRPiBRf/epXJ/7uTmiur/CfLj3D977qncyWq2PZDkwCo02n1N4YeOSZx3n25hXe9eAbOD63gCc8SoXx+3T06+vW+IybfuwWsWbUprjHFeiN0QTeZKnE5ULJ2mRISTksdr8ATquBKbRWE5OZGeFh9k7hJ1J1bZREbDZrVIsVglRZqUYsjuQiyU5xKSYif/Yfe5Vyn4c2hiiO8KU1ox9VzR4GIXESs9aso1LFZegHxEnCw9/4K+bKM1MnbmOVkCTW4zRRiuWt1ZHOobQm0QmtKEIgaLZbSCFyCt3RzN9HVnhqa93ge34XqT3KfcsrTGHvlbPjQGmN1hopBI12kxNzx/j2zascn13EGLOnxC30V0CP0qcbjS1AEHg+sUqotxqcXTxpjzHGi602ZpLH5MhQSmVzcGlmwRZRilqpYjt9MZzycEi0wj+gDBaYbHxrozk+u8C19RXW6k0eOlHh0Ucf2YPWvTDRaDT4/d//fX7rt36LixcvcvHiRS5dusT/9X/9Xy8I4tYYQ01XKfhkihWntyl4kCSKRuTzrns9Pvl4wo0NxULZI9Gw2hh2ZIEEqoXB63i/FNg88htS35nn5UgA92n3syBVOKbKNa3S6tYSjNJ40rY7MQFffl5xem60uThoYx0n8zzXh1gYlI5ujOHbawaFJCAlI3OX7BTFifZYrtNF3A5Lc5Zp4S4FbDRdpfsicZpG7pbd3fhK9kOvd2Nv6vh9J+e4eFqyXFN88euXMZWz1qtUWdJmkI+vvSbJA2cln3taEWcWB87LOCW6jSIY8J7gUnltIBGUEZYMEx3CzyWSCTRFf/s13djStBObnu6nabxu/+QJ8EyLuUqJ0IP1jSTznBTFDiGy1RaUfINEIWBbkbfFshmbAOzFasNQNyWEsORMks1jMv9OlfNDHbWQ1SAMGovtxFBrp3YrBPzVtzXPrnYHMfr5avpCMVu2iszNrRZeUOGOYx5fvaJoEeKpzlxxvdStmrO/MYicV661dMkT7K4AWaJTuxfTIe6TtDjRKMrVSeEUr4lrsTG0TUhvuLKjRswhHavZMpj+8vxxyf2nZd+U+14IITg5K3hmxVrddAXpFEgNi7KGEEsslG3gZI0CMnG2AtZipJ3YMVAmYaFk1+nMYzlVaCqdeqELiLWdZc6WIjCaE1Xra7xai5ktFHjLBWvJ5axh8kG72SI4ws7Zv6w3oRmfYKWuWSyLzAv98Wua5bqh1YopFgocK0NQu8LJmXu29cXti/AV2SRRhaxTs7GoYLWWMF/xKPhwdZMscyFP+PV6Ax+f2fE2dGEQOb1SN8RqgQePS65vGZZrNhNGxJbwzBP1w7y53Tixbe9u62J5sKf5UlUwp67TCm/ZkTiGDhm+1iSzgsh7xvdaRbwkFYn+1ePw2FWN1vbZXRBtyqWCLTaajlEvtdSx9627/2ZTCmyjEbNYCUl0/+fLyRnBf3Wfzye+HmfvMAUfNjZVNt4asf3Owi7W4mlipEfyf/1f/9f8y3/5L3n5y1/OzMz20Ver1fhX/+pf8fa3v33kE//ar/0a999/P2984xtHb20fvPSlL90z9U2jushvf+GjfOzz/4lXnn8pd546ZxWte4UJx8RDd91PK2pTKhRZ3lynUihRLBRtZCtd1KdpLdCOI7aaNU7MH8+9+Y3+fSEEWmv+y9e/wGJ1nldeeCkY9s63dhcPWikkiYqRwutq27SJu3ZsyaxJCPd2HOGlREOsEpRWhF4w9XkhEIR+yNnFU8Q6gZSEHZtwFlY1J0ZU6h4EnK+11prr6yt4UnJy3gamnGWEJ8VUlJjGGNbrW0gpmClWLKk9svre4Hs+s6Uq9VaDdtJmeXOVb119lusbK5w7Pn2P1evry/ZFb+4Yy1t2vRkFUgriKOH5FUsyguHm5hpLM/P4fjCSb+g4qLUbXF9f5vTCCQo5tfyopxFCpNYopLXV09ecPQyQjAIphfUL1Jo3veSVvOniK2lFkSWppTexentUOEuDvGetN4LNQegFXdYVSqeVcBlP0TxqgHHSNdrZQGitiJKYtfom5ULJHmnKwSZ3rw66iOEkV+RJj5fdcZEvPflXtGLF4xsR//T+B/D7VbTYJZRSexqk3wt84xvfIEkSXv7yl2e/e8UrXsFv/MZv2MDLAd/znZCRowUIfEGUmEwdGHqwuhGx3gzZaAledovHpzdj2klIIU1/7xdeceqYUig4t9g/i60fGdpb2KhbyeVWELuKdIsKOorbWNlfuMrhvenxzvZhubZd1doPA1VfNUM9OUkxshvgXmLhZtuSCKfnTHacP3tCc23LtjZOCcjt0yhPTXX6opf0ySOQ7nlnfRetktdu3GPVKRoT9Hx1mK/kqNjJu9GpE0/4azx4720DN/b9cN9JyfPPXWVV3kIrBpOmtJdDuHNJcOlKQqKDbf6M0PGArBYkxUBbQjHzSbbElSAtYIOyBYD6XJMjnLdSQlKbfBG/mNArd52v0IcAHlbkbRpYqVvFmS/IVMTknotOnTpOIath6DcWE+Ox3uwuSBT4bAtiDPLVFMJWgJfCBhEqoSvOJTJLiyxokynuDL5nCXlnHujUkYkjJo2zirCp24kGH81C2ctIZlLCd6k6/XuTh1O8uuJYsbIBJsgTstZjFTrkbed6Recahf27xK7hg4JfeRhjuL5p8EjwfetH6mjvom/PU0uqnfU6PadLwHK/yiseIZ9yXyLwOj6m+Xxdt3pLAYGIECK0NisiphFboi6v/s4H7fKKehccsNYSFT59SbNUscEBO2+DdC26zMW7B/vI2n7trzhNdFocUCS86vYyIFh/IkG3W8ykz0VH+MHkWQs7kdM32x7PrmgKgevFdIT03OJh3tz5/nfjpretg9fwbqXsTmtYvvhmP3sd9ywQGL56xR5zIzkJygaJC+kYDH3BsbLhypZBGYHsE8QAgSegXLAWp3WhecWtkkIgBj5fpJRd7zCuIFqsDM3EKm0vnvYOdN+Xx0jL83vf+17+y3/5L3zP93wPf+tv/S3uv/9+qtUqm5ubfO1rX+MP/uAPOH78OD/yIz8y8on/6I/+iOXl5eylNooiAD75yU/y5S9/eeTjeJ63Z+TPsUqFpZkyV9au8wefu8arLzzIO1/2+j1TCU7qGVsulHn9va8g8ANqzTqxivvnPk0JW62mtR7YBUEghGCrWefZm1d42e33EvjBrlLneuEedDc3V/Gkz4m5MdMiRecuB15AM2pTCEK7ka+tUy2WmdlFdfteWOXkZGHuVtxGIJCphGKltsG5PSyKZEliq+pzStxx4AjbdhQdWuIWUmWw1sQqIVYmS7ER6dvJtAgyIQSL1dmuwl6JUsgRCBCtncWAIFYxm40685U5Xn/PdxGfT/ZkpVqoztGO2kghKQUhlWJ5pO8JIakWy7zk1gs02k2urt2gGBQs+adt5eVpWWgorTI1ajEIWa1tUAqLlMICcoyCca49SqnU23s8knEv0KmIS2akXy4UqbdbFIJwz18utNZIT25LQ90J5ZTgT9LAkiP8rd3K6GS4GFVxbXZRxFJYH+3A80mUot5qMFeu5t58p9PH7pqn9U4x6dichOSWUvLAHS/h/Jk7+Pq3v8bjz32TR56/zqvuumWCFrz4cPPmTRYWFghzCvilpSXa7Tbr6+v7YtWwG+TJUYElTzyhCFMTyLw6L18QZr1p8FAkKfHgYStte8LPivw8cNaqCp0FhjGGtSbcSBZ4+mmVqWwGFTbq3ZAKYatHd1JwLRxZo5TbiEGe5OmFO+Zy3TBfGjwfhm2sS4Fhq22LthlcQShrTxBIutLRW3GnkFPRg4bTeaZtlV2ZDbZYy1JPcZRe0qfXH9GpS/OrjPuvUyRutaEUmK7N6iCrgnEwaur4Thv7fjjur/P2B27j2TW49PQVLtxxC3cu2Q35c1cdWdT9fMqn8t62AF95Hrba/Vc+AxRExEKp+/2ml3BebRj+5LEahFXmS7aXXZX3QcWhxilINBWIzn8y+n/HNOfx95C9YxEgMgEYSwwpY8nRcuBhfLqCGN0k3+D7NlvM/z77id4n31zRzvGNrTYyLLNYFmw0DbESth2eLUAkhFXbO+Kw4IeEnp0T9VbCPScLXDwlePTRPbo32DF13ymZFcfK2wi4S7QqZtl1mZ4AIV1hVx/p1jrg6VXDpWU1MPiVh7O4CEXMQrlArGGr5shIQawMG7FVY3rS0EqsX6n0yl0+wqFnPWGbTT9VbvYSoJ2Ce07VLYX9ng14dEjPQervfsrsfHBACmsr48ve4MB4NhajBFg2Wva52BYmey7mMWnWwiByGuy/hdFcr9lnZDUE025T8gvcrEEcneHkTc09J2XXnCoGpisbBdJnSqqEHlQMctAaPs4a5p7vw4II+aKG9t5aAjZSNoPH10H2DA2JiCh2ebPnl6tKaC/U9X8hGO7L7q4n/w6TKYwrgounPU7OHp5A+0jDKQxD/s//8//kt3/7t/noRz/K//F//B/Z3y5cuMB73vMefvAHf5BCYXQ16oc//OGsOAnAL/3SLwHwT/7JPxn5GHuNmVKBc0vz3Nyqo4CnbzxPK2pTDAp7vjkeZwMW+D6VYpnA9zHM40t7W6WQafrPaA/gUc+5NDOfqhTG74P8OVZrG9zYWOH51WucWzpricddwhiDSn1yktSjMPSDsUm23k8Gno8AfCmZLc1MvZK7Lz38cDISc7ZsVfBGazSGswvFfY0Mjbvhd0q9RO+dP7XDpL7RUgiSxOZhFYOQzWaNOIk7VeKnTOCJLssA8EacC8ZYYrnohxybWWCuMps95EvsjZdwuVCiHNoxtjAzjxm1yBhkARGXuTBfmQUEzbhN4HmEU7BOcV7KWhvW65tUixVmSlVubKwwV66m5xwdWmu0MenDsrvAwkHCkxKT29qHfpCqwU1qpbA3aX35cSqFHNnz1QZ57H8TkxCIjoXFOO3ca8si5+VtjA0MF4MQpVWmtE9UQimc3N5pL2FMp5LxOOvTbgKwlUKZ77rru2hGCcu1oTnyB4a1tTV+7/d+jx/4gR/osvT6l//yX6K15od+6IeYm5uumqrZbHaRtkD2bydUGAV7Wcdh0LmUUvjCIFLiMRTdxVrBqvN8Ab7UKKWpyib332FTVR+/9DylY3fy5IotioSxtEM5hEV9lbuXbkUphVK2IMqfXrJFxjZzKpvQs8SLL2EmtEVqbibHSJKE2dBuSBtxiZJvUkLKdIpKaRuICHI2fG5Ou5/7j/j02rRBpWZ6StnCtCs1xZYus7yVYIzdWM+mS2G+b3Sq+IsTW2RH6449ge+BMLZwUKOt+MZ1W8hpIR0mXlOh6MxfhURmPqpwrAJzxe62Adxz3FZEz6vDosRQT4dZSITnF7PK3s7HL/Cg0dYUUrVxTEg7gWNluOc4XH+m2TX++vWFUybnx86w/07zb8YYbpuHDX+V2+bPZsH24/4Ka948my1D0bf3vR0b6jEIY6gGhk99K2G9YUeDWyttMbjuNHqlVLY+9l7/Sk0xX4IzwXXW/CpbLesJmmiPRmSItVXt3nPctivffmMMOv23Vgp3mdPst4WiSQkwmSnLpU1st/2X/q9EsNke3NZxzp8fi9b318OjY2MRiAhj7P7JJ2GtYViuKeYK/e9blBiaSadt7cSO20TZCvR5HXrHJt/OgUCCEZKTVXjzecFq3fClb17FVM5Sb8NmeoyCU4M2Fa3YUIvIfLyfuGlYrhkCXdrTMb1U1twSXCMu38W1zezP2Rqo00VA5samTq9RY20/TM4KoxVbYi8gIpBFlmuazzdhIXcd7vzNSHZZXATSWgM4Jb5TYzYjlfo7QyASZkv2fFv1FjPlii0iZ6CRflYVrFXBXbfAN2+mhdWER9G3xbLW6jGzpZByaL/XYvDzxbW197mktekKDri5HEhLFC+3Pb5+VXGiSlYQedR7s1TWvOkuyUoNHr90hfvuuJP5kuGxx+y6OFuQzBXhStNHa5MFA90epJFmLcyGJZQSI4+NZmRD6Z7oHKtzXEjwMcZeny+tOnuzbdXkMQU++4zm+fWIe4+Tzalm5EhtmQYV7cpXCcHo7W0dddzOFazf81xBZ/7L+c+757u1sDjD8iXFQllzz3GTfcYYw9evquxZGOVeeQx2vCUUUekz1Ech3bqeC8aSXlMzFvYdQIx+TUqpnncYe7+PVVOf+D1+Dxvn+MJM4JrcarXY3Nxkfn5+24vppPiJn/gJAD74wQ+O9HmlFF/5yld42ctetmeqvSTRvOODv0tbF3nl+Zdyav441WKF4h57CIIjtybfpKo9LOAyDd9HbTT/4Yuf5uraTR647R5eeeEBPLl7oiFP1GmtqbebNKMWi9X5XRVBa8cRgR9YQk8pIhVT2gcCfxLsdar0tGAVpnuruNVGIxhNwTEISep5mffkNaRE+QGnOvem7juVoU1DtzYKh7UQ3M3NVebKM7jCZEIIisH0rGhiZQODrnCbCxiM2x+H0ed2FOxKcbrH0Kkv9mEdm3m4F2eR5lVHcUIhmG7gblrIr/1RElvyyt+7igr518dGu8mrb6vzurtvnfp5dvO+d+3aNX7gB34ApRT/+//+v3Pvvfdmf/vQhz7Ev/23/5YgCPjwhz/MiRMnptbm//gf/yM/+7M/y8MPP5z97sknn+Sv/bW/xuc+9znm5+eHft9d80HBGHgmvoWGKRISdSlUjYGIkLJocXvw/MBsKa1hQ88QExAQMye3yC9HNV3i+fgUCg9pNG3Sks+pNqgk2ngi3VgZicbj9uB5SrKdfTcxHgoPkyUVi9x/7U8emoJo0zYBCQHC0pdd5K3BkgUSw4XgacpeO2vjzeQYLVNIdek2pbhtChRFa9u1KyNpmFJKh+kuv09XDdsn4ax/jWvqhC30IuxnEuPRNEXyVbPdN0Nibg+fH1ilfpR2aiOxPq6CGB+NZ9VrxJREm1lvixnZoCjafe9pv3MURZvj/srAdh0U8m1VRqZjxG7sdVf/mrS/O0pyD41PDEJk4633mL3X39QFriUnSHJ6KJ+EU/4NjvvrA9u2l/1oDDwRnaNmKgh759MrFmkfCCSagoimen53fXVdIsaaS/toQhFl89m1Lybk1uAKM7LR9d1BfdPUBZ6Jb8lUuDq9r27+u7TxEi2U8PBRnA2udV2XC7xs6TIrahGNLcxmjKBFMT2vpkgbIex5PBS39BynX3+3TIEEe95B82gYjIG1ZIZnlc1c6bdO2eCOTK9a49a7zAYGRUk0R16zXZ/m16I88msvMPJn3bzp1zcF2jybjP98yT+XAhOh8GlRSMe3ncsemlJ6nwa1Z1rIP8N8kiwwkuD3HXujYNj9cM8XgIpoohG0s7mi014QBCT4IuGW4BpAz3wED5X2uxm5reOO72F9k59PvdfbeYbmDy6QKNw67ZNwh/9tlvUiq3rB8mW5uWCfv4az/tVt6+9hxijvuBO90ReLxV0VFHuh4NnVdQxl/vor3sRceSZVxfX3EJw2WeZUP5Nit6TtsNTJ3V6njYwa3vSSV5GohLmyrerYS+RNQjrkiQApJTOlik3JFbsjs8PUbBxserIQVnkVTFl5Ow28UAimvSZtYTrEUJ7wV9o+GDzpgRRErTaX165z+4lbkIiU4N1ntXPudEIIvEPgmTkK5iuzBJ6fkc96xCJ3vRikLAx6LBF6i2qNihfKfOqFECItQDKZ6nwvsd/t2Q1R7IoqWu/pznpwGANk+faEfpD5CO/l+dz8LRdK+7Kmj4t//a//NefOnePXf/3Xt723vuc97+Fv/a2/xXvf+15++Zd/mZ/7uZ+b2nlPnjzJ2toaSZLgp+T5zZs3KRaLzM6OrvrfyzoOvXBewi996UsBqD/yBGvBXUSqSNGHRn2TcmXWKuDadV5z9zyn55e2fc/97HnewL9JKfnTSwq11mJppkikoF1XNrtJWCVXpA0nZ+27l9aGla0Wt915gVMzgq9+9au8+Z4K37wpuLllqEU27TnwwEvqFEoVau3USsEowmKV40W4sVanLSoI4VkFkorxvMCqLLXmxIzHa19yL1pr/jK9fi1hNnf9tQiSSOEXZ6kWbFBwc2uT2ZlZtIb6lq125UvPFj5LYnw/sISE0gRhgXvuvJ3VZwy6bb8HsLpZx5NepogCVwFdILTmrjvv4vS839Wn+T5+zXfNp2qhp7jvwp0IKfnME5qoFbEwU83OobyyVahhrWtmywViXWC17fHS82e3nQPo2xel8iz1uMSzUYFX3l7iwklrVTDK/d/rv732wfNIKbl0Q/HFZ1qEgU85gNV6hBQexpAmnycUfJnaUyhC3+NYxSNOAtbrbRbOXOD8Enz20Sf7joVmUuLZVoFSsUTJswq4ZrNOqVQh1iEr0QL3n78l69NBY6qZlHi+HfDmeyp9+3/UObVSU9n9ny9B/dEnuSHvoh6BwbOFkKWHNFaROaev8V33nGW+VOKxx56fWv+/5rvm+fYa/MWTbWbKBcqhhzFBNk8A1jZrlIpFLl64wFxBd9237uvotE1KSeuS4spaixPVEGVgq16nUKzQioVV4BlFoVRhvgRB7Ule++D5rrY98ECu3efP8s2bVo272UpAeBQ964HcbjaYnZnFGFjeahFX7+LBC91j3B3n5O33882bgrWGodlqUSoWB55/WL898MBLMcbwkb/aosFM33XKM+CbJn5YohnLLNOmlGYpiKTBXPqMcf0thPUp36wbbj1/Pwtl0TVuXJ/OV4sIQdd92mxDGK3zygcu4HneyJ8VQgwdN40Jny/1R55Ix3TRereaDmPhSQhNK2vPxuYmfqHKHXfey/HK9vs2jfH+l488QVy9y6pK03t/siy457jh+jPNsc9hjOHal9ZR4TyzqZbF9XErhnpDU/Ql85UqKw0wsSLwPITwiJMYKX3mSh5tVeBmdIz/13fN43keKzXFl75pvbkbkaTZUpSKRU6U4OwsXL8iuOWu+5kvwWOPPda1pnS+17nGhewaH9vx+e7GycJMFWNgvQVX4hO89b4ZEiO58rTOnoVaQ2NL4cx8bCjWIKWPBGJtn6GvefBuPvOkYXM1wvNDlJYZj+RLW5yzllR56/23DB2LO92b/cA4dRxGIm7vvffekTYoQgi+/vWvj3TiXoyqtN1P/PGjT/Da+17BYnUOnaq1etV72mhipfB6Up33E6OmRBpj09PzhMag7+q0tOpeEEB2cfWYr8x0zmcMUnqZetAqecb3WOqHrAhIz/wbx9evd/x76Qu5877c6/TdIxweGEPmd1tMU/6NsZHEVtSi4AdTXwumacswCvajeI5bhxz57InxH5D73S8vNLjnlc3etXmEe+XRfpghhbRKdKPx0p8ZU33t1nj330zlPsZzZL+xH0RqPni02hr+2YPAww8/3Je0dahUKvzoj/4o/+yf/bOpnve+++7D932+8pWv8NBDDwHwV3/1V9mmZlTsZR2HYeeE1Ofvdufzp4kJiTVp0ZdrnJ6/p6ttvT8P+9tGS7DRUlaJIwXSpYNiyQdPQIwk1lDwBcpYLVEp9PBSP8HT8z5nFgRPLSsee+omonQ8qx4tBNy6IDg7L7j23PNcvGA9+B7+8jVueJbIsgVbZFY4qUCb77qtiu/7JEmS87G152sKWyBlXhqakS2GUyl0AjhC2HZCR/drTOe/NrVb40lJYjw8mZDQ8QuPTACCLOU40Zr5kmdTfrcE37wpOLsou/ox36++77M0Y71il2Z8pJQslGMutzrvI309R0NLZN5se33P0e3pa691C49aZL14Ywp8/jm4UtPcd1KOdP/3429SSq5sWoub+ZItQqaxm3pjrCJcp/dfCuu/HCtb1CvRoAh47JqtHL8cn0D2GQu+NNRaATqCk7N2PUzaikpK6N+MOn3arx/dcQLPDOz/Ua5/uSHTeYr1NX0a5ksCH3j9XdZLdrluaLUSiqHHUsX6ql59co2lmXNT73/f97ljyfDI000SXcD5QENnj5fgc7Is0mJBous4SzMiG8e953jJabi+pqindgAeioJvx3MxgEp8jYcu3JZ5bg5r9+l5n7OLkidvJjx8STFT9imHNue+3XSBW6vw22jBZlsyVxRdx6npEs89b1O8Sz4kRBT8IqsNiONTLDckZ+bH69PTwQ1ueDPb1ylhbR1OqCu87mUXujyeS6Hg4ScVOtFde1YXfPY9+7aSmM4a2tuntcj2qV1/SIszGRb0Cr6/NNZn89ckpWS1YdjSZTba1n91N8+XzO9mgN7DXb8ruFcKZdc179T/4/ytKps8eMHrFFi80CmAdX3Cczhv4K1IbCuOJjCUQ1uYM1FWPy+y/VNKYHuCsjRstAtsRh7HZ3yWZrYXgzx15jyXNwxfv2G61w1dytaUG1tQS04jNq3FjjR2vq004IvPW/uNnZ7vDpGiq4jcnz0Fs0WTZbwIIVA93I/7V6Ldq6Z9hj6/IVlp2HPMlmwmfFZA1RfEifVm3oy8zJ+3X3+Pem8OC0ZiFz70oQ8N/NuNGzf4V//qX3H58mX+2l/7a1Nr2GHAja2EMwsnAUv+9fMMlEKidYQ5QOJ21C1jvkp6dzJZ/2NOhzYdDRnxKch8GkfdVE9C3thUd5MWRJp8022AOIkpBntvn/GdhP1Qs00ybjxpSR9jjE1KEYKziyczgqTs7Y2/8H7TQrshbXdLpuZ9qnf+rMaYydq7H1Yd08JuyUFjDFdWr1EKiizMzO9ZoOkwqnsd7DULlNb23gu5LZg3CrrTFs3IA/4wKnSnjcIhfMmt1WosLCwM/czp06fZ2NiY6nlLpRLf933fxwc+8AH+5//5f+bGjRv8m3/zb/j5n//5qZ5nr3FyRnBqVvLUMlx6epULZ2/h3AJZsR5jTLYhX23YIkMOw/7WTtjmqyhRaOMhUoLCHsMep5l68C3kisJe3zJ847pmraFp6BlKyhYmKUcrPHT+tmzzXL/cKaxSlU0u3LmdyDpWhqB2hZMz9wCDC8QYY0iMJXKU8VlrQNE3xKmvaTO2y8Fc0W5OXfEe5yuLbiPwKfh0V5J3pKKwJGKSkqqV0IM0ldsVNZsbMeGxt+iRL/t7jkKYkVP9ztHbF61Y0zYFhHKEp0ZryY0tw1ZLZUXk8hilQM204You+SRZ1oRtS8cLFARReh2OYCdNVPBQlAPJzRrUTZkF2T0WwN4ng0iPKTJfUEhrF+T6VOnhRYcmucdgicPPP6uIlKDkd4r6ueJMF4C33ROkhYQuc/Hu7ZXV9wJC9BanyhXAi21K/32nxs9SG1RI6HhVcu9JwdUn11gsn9v5QLl2lgKBFIaST2rQ0D0+BxXLGlao0JemqwDbOBi0TnUI9yZSSu44BhvPrXLHsdvYaAk8qUi2Wa1YDCuWNaw4070n7fkm+Sy4dTqx63RaLM2Rg+MWuVptGK7EJ0HAyRlbrGylloAM8NNgVGRCu6YqG6haCGzgZnxj0NExSYHFYRhUHO14FcRaA6VnUHp7BaN8wTGt7b+jnjHr2iqwz89+60YrOsONp1RWKFNg8NNMGE2BqrE+xZsta8PQ+37b+3yHwUXkNluGdgw6vW871UUU6TV95bKi1gZDgaRur1kAoWezKz1p+l7/Cx0jMY2vetWrtv3OGMOHP/xhfuVXfoXjx4/zu7/7u7z2ta+degMPEsfnlxBekKacDp6E4xSBOeiNrUCAsYRlFMdWUu5SPzEYbbJ070mWnWko4KTsqKP8EVR4k5xPAKRENhMo/Rx8zzukWquDgTY2x2+3as19IThMbnc4BoToTrkuBIUdlemGjsH82B6r6XcPKyE2bdiqqaPfl0nfxaYxxnbrRb5fkELgS0kramLMLBq7aRxEXE9KFB9W5WkeUgi+vXKdYzPzzJYtCTTxHDOjj6MXO2kLcHb+8FkHXbhwgc9//vPceutg792d/j4pfvInf5IPfOAD/OAP/iDVapX3ve99vOtd75r6efYSXeSoWqRxWfPsqt10D9uQD/sbQMG3aa2OZBBCEIqYRIQpwZD6Oeo0/daHBb2CEFbJ1Y+sKvhFttoQq3m72Rww5yxZ0E1k5ckCY2xBosR4qdrNPmUS41kVnbJqTG1s8bVmDIYSUdOSsz4JxSBkpmTTkzMVkAerGwZPQjHoJlWzouTGkoEC8ERCpAJCzwwkjnZCnmS5WTMZyRj6k1VyN8akm2WBL9LUbGyDS4H9rNvIO9R0iT97QrPeNCNVuZ8W8uSBMZY41VhCo/fMlixweyFLcgc6IvBCSoGhFgmakVVY937PjdV+hEO+Tx2R4g94zExyj0cnDr0dK6vvBQYRUMdSVeXJmbmJj/vgedlROZ7fHRkd+nYcJxrCPvfHKTcLPazJoAAP7I6Mh/7r1LBrXCiLrmBQ/h4PCn7lMU6f9vvssYpkpa67AnU7BRWubxnOzIuusdkPbg1ZrhvqpowXwaq2a1hBRCQiyIrVxUhu1CzJaAjYbMOfXlJ7vt5MG4NI7Ye/fIM1f8YW/qQ3o8NQLdh3caXNQKJ+2LrhCcNWK0C3YbECzSh1UJYeEoi0oNaGQmDX/I12gbUmLJY7x+99vmcZJcb+Pn1kEHhQCQWr2tBSMgyZSuQAAQAASURBVHsW5v1treRCZ3xLW9k1UqRBTsureUQKtCnQTgzFQAwNVOShtebpFc2NZJGnVzTnhsf5DxwTSUQfeeQRPvCBD/D000/z3/13/x3/4B/8A4JDWqxjN7h1cY4rWzv7Ilpid29JlfwiPGmRHXD+rKlkXEpiZWe+NgopbDqDSQmtiQnRKWHP+3RK5xD74Cc6rXTccYj1SUj4fpHqvcbESrYJX1x778ModiK2X2ASmnFla41SWLJezfuE3QSYprEGjFozUwo58XibCskohPWM20XwZ6TTTKGtnudTKVas6kjrbJPRz6/dpSuP39CDfTEeZc0SQnB17QZ//Mif8wNv+n9TDIuWtJWTtd3ZpuwElXoLHlQP7eYZMuoau9KIgOkVGJwGvv/7v59f+IVf4M477+TlL3/5tr9/+ctf5n/5X/4X/uE//IdTP3epVOIXfuEX+IVf+IWpH3s/MGzT7RQ5hvH+5jbrp+fkNpLBF4pqyaZS2pRQO6d7lVzTULlZ1dF2ssARzjdrmgSf1TqEvqHg06Uydc8dk9oOeLSplkvECUSJYKsNi55V/3hCEXq59PCSYKEs0LpDqi7XXRqzExZY5dhq3Vkn+JT6EEejwJEsz6waHr7kPEetxNRVco81xMYnBEKvu9/ypBbCKbD6pOdKQSkw2Ub++Iztz+fjUwR1QynojIXluuHzz+q+6txpwZEHbeOz2oB2DM43cdhbQ7GH1JbSXn+cKqjzqlqn1JXpz73IE36OSBiXHByGvSQOp4VxVJXjYJoqx4WSJTWbcYmgZ/xvn7edv+eDGv0wacDFoXedGnaNvQr7UpBTOCdiW/Br8PkG92k+i2KtafttRjaIlSVH84G6uWLeYgQmVSPn1xA/DRRJYTMa1psQYBW1tbbrZ2nnmAcyaVIOKvuy3uwF+j2nXDDk8Wua59cNCuuLHvogTJuCH+xI1A9bN/JZBDZjpKdNubXQk/1Vvb1BhHxGiUjP4aEJU05qpmCII0W14LPVsmcBu6b6ErTSmTd5GipkppC+K+i0KJ/skMqhr3cMVAA8fl3z6GVNKwZtTnH1CU0xgEU9P85t2leM9QqwubnJL/3SL/H7v//7vPnNb+ZXf/VXueWWW/aqbQeOauiPtNEJxyhQpZVGDlrhR4QB1ITHyZMxOlVcCQEyjTQLOpM4GTFdeVvbtBr7e71wL+zZcfckzdSglM4Kh0yKw662y2PUlrpiPmJM8s55Ke0ntDF4kyhnp3T+UQlul6o9zncA2nFM6HWsOPZKgZtv07j3fdqwli6uDcNX4YNWMu71/Le2Lrv3HD42s4DWlmRURqXHzqf6iyyXrB1HlMLxCbiDXglHPX8xCFjeWOFPv/Z53vng660FijaM+9hSWhOrmNAPuwI4rl/zPrhaG6Qc/1mmjR6qjt4PaK139PoyGJqHMCft+77v+3j88cf5/u//fh588EHuv/9+ZmZm2Nzc5Gtf+xqPPvoof/tv/23e8573HHRTDxXy5OhM0W7UXAX3akimyDk562o/bFfr9P6tVwHYj2SQAnwP5vzUqzJneeBUX3tFVvUS1Q0SjAhppapaEITp1LVVqy05oAxoY4tfGR+abU2iYbNtU6+HpYc7UnW1Yfjjxxq0sbIlqzqym9V2YtNTFwK2EUejQgjB7YvwFdkkUYXsBTuvIo4pomObguq8aqGb1Ar90dNzjTE8fk2j8FgsuPdDOxYCb3Ca7bSwUBYUfVijiKdASAZ6YjoIYLZkLQ+cZXcgrW2CxkNpQ5BjaB2RJAT4svMW1S9VW+vJyMFh2GvicFoYFCg5LBhk6xAlhnoEwhjOzm9v96hK3dAbbBszTYxrYzAOBmVRxMk8z/UJ8A2zGBl1ne5dQ2I3fwVZ6n5kQhZ9uxbfqIFShvmSoBLCxqbat/VmP+HU2N+8nvCFp1r4YZFqCPWaGomoH7Zu5LMIYDsf48KWaSmkvqrW3iBCb0ZJ3qYHLAEsheGBM1Z1+9mn2iCs57s7f8fiRtjdoRBUC4Z2bKz1T3qCKLGEfikYHqi4mcxz9VltC/4JMEYhhaQZw2Vzmseva+4/c/jsv0ZmrP7gD/6AX/qlX6JYLPKrv/qrvOMd79jLdh0KNKLJqpwPg5hQ1ZNfZKQQyF2SjWCLA6k0td33vHQqikzRO0lhskQldnHeLXErOiQCQKySsQjykc6BQHq7J6iMMSQqIZhy+/LY9xTklM8hVZZEcUzhkPr47kUBvXEwuoI5Z0XC6KrWpZkFNpu17GWjt0DiXuCgX2mkELk3BesnbH8/vXs9jT7MXihGVDMqpSYyu59GoTiBoNaqUQqLNmMDiVb2RcWOyc7bWnBAfu29mIb1Tj9EKkYAX3rqawC84d5XUC2Wh3+pD3zPw5O2kq0xIn3JTLN0cg3X2nRsdXJk7khjRmvaUZtqqTJ2+7oxWU9GSZytsaZPgbuM/AeSJN5lG/cGP/mTP8k73/lOPvaxj/HII4+wubnJwsICFy9e5Cd+4id42ctedtBNPHRw5GhJwmrdFRMp0a53VDb9fD3H8fwc1auyd63eC7Kqn4o3s24QLg3etsNtHn1pyUBP2/TcSFmFbShipFdgpiBoRDunhzuVm48iwi4R7vGXZT8Y0bt7Hhu95JQnDK1URYyx/VYtSFbq8PlnO161+e+Nk57b6zHb25a8Ondx/OV3xIu2rTVm8AqY4xQsIaGBPuM2FiHN2PZbnowPiSkWfLbatpBQoj2W0znTm6o9bc/XSVP8DxIH4Xc8CnptHdqmQDvlOQ0eX7uqubKRdKXcj6LUnfNtMGS9YfraxuzFdUzTRgIGZ18s1wz15CTFyM3hTnBmmMUIjLZO964hgTQdL3TRKWIZpY4vibbzqBJK8jN+0vVmmE/7QUMIwYXjkuvPXSapjkfUD1s38lkELiDX0tKui8I+e0X6AGgmg1Wt+ee7yyjRA2x6XDZCIRAUAghEQqkU0Iq7feKt+tYKUGQ6zgqiDZ5PrMDmgtjijy+/ZfD1a625lpxACxuYEwKMTglkA5ESPHpZ85JTe1+oe1yMtJT/3b/7d/nSl77E2bNn+ft//+9Tq9X46Ec/2vez3/d93zfF5h0spJw+EXdYiuFYA2iDJyRCipxCCBA720MMghCCJEnQ0ttdgSOXrpv+e0/6TYAwYtc2BK24bQtWMZ76ehzsZ4TQ6SnyEVKt1bCvvCCRH1+xSixhNYWAyLAT5iPOZthOIocwCDjmze8rWTut8aa0nohY18bg0SFXD6t3qo06W8X3KMXOJgkUTe3KBZQLJRKV4Ht+FgyzhTdF1+f8XRaZMsbQitsEXrC7Y6VFAKepODXGsLq1zktuPU+xUGKrWedXPv4h3v7S1/Lae14+9ri31Zp9oiSiHcdUi+Vtx+g3B0Yd0770uLK1TrlY2mXgYjIa3Pc8kpTgt6Js01m70kMKBIlWVAuH4/2mHx566CEeeuihg27GCwZRYtWYG82Od6fB+sZZ4tJupHqFgeN4fsJkJMNekFX9VLzOumGjCSrdFKqezSNksRi0hgiDNnZj+8AZSegzUnr4WhNL8pSsp6BVOEuEthtnX7doJeVdp7x3p9naDbFMN9MiaVMJ7TtsrzptkvTcm/XtBWryGJRmOy2sNQytGIq0EX45tUrowI1TX1qyoq3sgqZ091ppjMEIyckqFEPB+jav1itcuPNuHr+uubYJDUpINSBVG3jVFD1fJ03xPygclN/xqHC2DlbJaPB9UiVji9ALt6Xc71SATRhDI4Z6zBDbmOmTg9O0kRhmTVMKDFttuxb0SjOHWYzAaOt0b5GrXi90RzLGzvcUCOkoOfMYd73Zyaf9sGCSZ+iwdSOfRRB4KckaW7sD+0lrWbDWtMVAj/uDVa35jJI/eawGYZX5kn1ndBkN/WwdiqKN0iUWK/beOp94jFVV+ymhjAFfKGZK0Eyg1ogJAo9Xn5MslMXA6392zT5vfZFmYuS6wPq2a1qx5NlVwx2DnUUOBCO91ly9epXTp0+jtea3f/u3B35OCPGiIm5D//BuQnarRHLFx1wBMBspV0hP7ook8aWHV7DH2A3501scbU9UlcZev04Uvu9nasZxodO0dd/zMouBQRvsfAptlMR4Qo6kwHMVcXN75b0j8joSD2KlSJSamHyZljfvXiDfqsDzR/ZV3QmD5qYxpktxr7UtUrITBGJipf6kyI8tO6aHF2gchEl9Q8N0EzguxlkXtXGWE5O/1Arsmmewc74ZtQi9YOCcdnNhr5SkwyFSJa3VFQWej9dL2k4Bbt0P/YBEa3wmf45ma/KUO+u7v+st2TNKG0291eTrzz+B0nritc6THqu1myMpd8dZF4UQnDtxNnu2TIrO2DMopRBCjESGSyFptet4pUrHssONmVTNFquEertBrA5fgO8LX/jCyJ995StfuYcteWEh8Cw557geu7fpXrmsMLH7d+N4fjqMSzLsBVk1SMVb8AXzZcNy3QYiZ4oeoQc3tzq9YVLR+WbbkrcJRWQMj17RPHhWjpQe7s7vCSegAIz18kspC6LEbqB361V6ckZQ8D2W6wmeajFbLRN6Nq0YBqvTxk3P7S1Q04tRi8dMCkf6+CJhvgJbLVhP2YJUo9JVo9ZVaGgldvz3qmFffqs31KvVaJORQu74/awhXl+F03P+VDxfdyIOJ1Hx7hUO0u94XFxet2NhvsiOFh+DCrAtlmG5nWDMYI/XLz+nePy63jc17iQYZk1j1yZD0oecHWYxMuo63W8NyXuhR2lALdHWGmWzZVDt/scaZ70ZrajazsfZLUZV/I77DN1p3chnEXhi+45l3K2dEIJ5b4O6V7XWSPnz9bF1cG1zWQwShQAaMUiU5YRcppfxWGs6u58QFDxyRXfZ/fSiGe10HXb+16ODD3b1YqTH5ac+9amRDhZF0a4ac9hgDmBrPSqm0TIrNe9s3CYlLnvhjnEYXhSGIdGKKE3tVLElMibZtJcLJYzRdApzDb7uPAkxLmEisBuHKIkJfR9/iunMNtW3Q7RrY2hFbdpJxFx5xqbATnC6w0ra9sNej9deBfpuiZj9wm5UfrsN3kxwwjTusPN3tdEIw1SKCwoAISgGhZHOvZuRNmkwxLUx9EOUUvQWuOz1ZZ0UneKXu8u62Cvkn3MGq5yrlso8dNdLdxUg9KTH6YUTo/VfGjQc53wCQaISPM/f3apqIEoSwjGyC2bKVRKV0IrtO14hCLMNXDuO0EZzdfUG0dm9yneeHO9+97uH/j1/vx5//PG9bs4LBsYYtHuXc//TccXIsNaAuVLnt4M8P90xp6EA3AuyapiKN/Rsiq5OrR8CSSddV7vq5SJTgIFVA221TZflwE7n10aw3kyJbwEajTYyVScXiWN45LLiwbO7X1cjZVdBXyQE0hIgifGIlCH0BqvTxknPHbXK/Xyxwmpj96nzvSSHuw5L+ggKgUG0NKTBRMc/GWMJKEHqi1gebHHRz6vVkTzORkKi8KW0qumsyrnsKdw2Pc/XQcThpCrevcA4fscHjUksPvoVYDPG8Mdr/kAvbmE012vW37sajkYOHkTq/jBrGikGZ1jkLUYakRWrxNqzc0uNtk4PWkMKviD0DOtNIK7z1gtzLFU9Pv2thMvtTkEsla5pgTe8WFce0yh+OQ30Kn6XLykqIZAsTMViZPi6kWYRZJkZNqjoe4BqMVct2WfcDr7BXQp7dYxA2XHSMAy1dRjUtqWqYE5dpxXeMpbdTy9KqSBbGwZIS+zzsRLubm3eC0yF+fnKV77CRz7yET7xiU/wuc99bhqHPBSIk4QpddELAnuxyT4YZdlo8NNqhkmSoIy2RdUmIG5tZF2mP3c/nHuvv6PQMDSjNqVg9AJAViEl2WhsUg6LzFVmx25rHkprq4hMN/KJSiiGhYxQlkIyX55BG8NWq0GpMP4bwgvFBH5ayuBxjhMeUs/gaWLaBdR2QpTEVvU/wjx2NjFTxT6M9WmMU6ua7HPkKTbfZQi48xxG9b0UAs/zaMVtijkyEiYjsEe1WhFifAW7EMKuw0GB4gSF4/LH2WhsUvBDFmfmd/y8NhpXdHKjsUUxLLDVrNtgpZAUgoBW1OavnnyM19/50onbtVf4xje+MfBvf/qnf8r/9D/9T9RqNX7sx35sH1t1+LHayJG2dHu85hEpS94G2hvo+bkXCsBpk1XDVLyQet+haScSKew1unOCJX0ltp8khtmiJRc2W2akgjjzRbtCKmOJYau0tX74jhjBwFZrdDJ4GJySrW38rDiZMkXiulWbFoPh6rRR0nOHVblvxNaf0hcx/+mbtgL4blLnB6U1FwOop6SPUwCatDp5PnQeeJDohFOzPm+922elrvuranuIs/lih+QpBdCKO2pbX3SqnBcCs6fWEP2Iw0lVvHuBccjQ4zMH1MgUven5vRgW1MiT8dc2BxOeLohljB03gbczOXhQqfvDglqBtGnlBg/Rs+N1FiMLRZvGvt4ETYmoCcUAFr01Ts7MDSWjh60hzURQCg0L3OBYZQEpJfedklxZhetbzoO7SLtm0+F3Sut3mKT45bR9m3sVvy1jA0MbLTDmNJvfUhyv7t5iZNi6MTgzIyb0yum81QN9g/sp7CthMVv7l7yVvsVHd27bOqfPnRvb7iePcwvgk6BMiNTdWzebQSMpBXBu8XDtWWAXrOTVq1f52Mc+xkc/+lGeffZZZmdn+Zt/829Os20HjkLwnUPa7hUO35DvQCDwpYcMJHFqWzCV4+ZWgN7rF7nPVItlmlELfwzlkxCCUwvHp0KAZAVnMGkF+ULmLexLl1Zt1bgzuy6Mc7hJ/N1aezhobTBmtHTrw9oXL2SEfjDyPdyLgIIeo/jYQc6Hfte+F23JAlUc3iCOs4twvsow+b0ZdV3OPNzH7I9AetRb9V0RtwBLs4sjK5vya+NabQMhBEuzi/gyQGnF9fVlvnDpUa5t3GCh+qpdtWu/cO3aNX72Z3+WT33qU3zf930f/+Sf/BMWFxcPulmHDgJLUqi+/IWdJb5n/64oUuzj+blcg5YpImJYqjBVBeA0yaqhKt5EUA5hUV8jqNzKetOghUcxgERBW3XsEkKPzPN1nII46y1hbSdEquDdNj0NUloishV3NqSTKvAWyoKiD2sU8ZRTzmmE8IhSv8gyydDjjZKe268AXT2yBHcCrKtjiM3UD9YoQo+xU+cHpjU3yIhvS/qkhLsISYwlVj3TolosESuQIuG+U7ZY52LZbFPD9iPOygE0dImFABCdvLusj3Ien/b27p01RD818GHBpGTofmC4Uns7Rk25H0Z4xhoUHh7g9QgI+pGDB5W679YYD0UtgnlPb3vPkWikZy1GBNs9fhNjfaTny9CsNymWKkQJ3EiO8VfPKbbagwu3GWMIPFj01jGFCs14uFIza7Nw2SG9dPLOGLf45bR9m3sVv+0E2hQQ2vZjrKwly3Jd8/ln2XUQb9i6kc/MCL3t1zNo3mqt+crzitgEVH0bGHOBiTkPNluGuq5kz5dhxH2/tk1q9+MgpeSUf4Or+hZibYlkTfouk67TD5yVhzJrcKzHR7PZ5JOf/CQf/ehH+fznPw/YAfbjP/7jfP/3fz9h+OJSkJ2eK/LE8gE8RY6wr5CpH2OeRJ2GOkxpPdQ/UwhBuVAau4DTNFVrmW9uujHv9RYGmwJcCKaR7m4yP+DDiGmQSlKKVKl/eP2xdws3Zg4jCXfgbRrj/Iev96YLmVcqGEOiFOGgN+E9gNtwjPLiFfph59YJbMXcPUTvOjvqxqJcLOFNUOCuF87Te5TnXN5n+OKtF9hq1rm8eo2tVoNGs84XnngEZQzFwKdaONzvgEopfvd3f5df//Vf55ZbbuFDH/rQUcGyAThWsRtUg7QkhgZy48X9tFi25OVWI+HBswG3L4oOcZrOI5H+sBdZ0NMkqwamZ2YEwToPnj/XUZnec4FIwWeeUOh2i5lKpWvzCKMTUlECQhjmS5ZkbCXgVgUhQBjnKNzZkD6xbLiysQsFngBSoiVvWz3sPk1CFOfVuV/8+gp17yxKWbW2wOCnZLWmQNXAbGG4Wqq3PYPSml0KfkDMYqVoC+2lhLs29t5EbTs6l6oCf2twUGEQcbbWhIgApa2K0FVg7/SpJXJV6n87Sqr2ixEH7Xc8CKMotQdZfOx0H4ep+HVqrxLkiizlkScHDyp1P983kQlQsW3PTKHHD1UkPHBriRtbsNbQAzx+bR82hQ08WT/SAo9eNvgezBQg6CGjH7+uubGl7b1RxyhFVjVbjvorNZ0dh8aza0qapiCwO7JYjbamjFP8ci98m/OKX7BevgZhbYiEfQooDUW/O4i3F/ufSebt9S3DI5cV1zZB49mMHA+EsfviPKm6m2fYpKSyw3F/nVtO38ajlzWtGEzq6V8KYFFf5b6Tt+/YhoPASEvkZz/7WT72sY/xiU98giRJeO1rX8vP/MzP8Pa3v503vvGNvOENb3jRkbYAJ2bEELXBdJDfsKkx1FpHmC6EEARegE6Lr0xL0dqMWpTC4ZUkPCltYTjp7SuZY4xBK9Uhq4cs/NPyPj5wYm2PIbAeoi9mXF+/yUypOlIRpu807EkRxQPGbpTBbr4LYbMb9lV1K0a36pCio5Pai2JoO2HU0xlj8GWQ9eNubB3cd4wxtkhprlBZSrNtW/eNMcxVZpirWAsdrRXfdf6lfOHSV7i6+iwzpd0pgfcSX/ziF/nABz7A5cuX+Uf/6B/x9/7e3zt63xqCxbKgLJo0zMw2X1uH0IfQt+RBXRhKgX3G50mucgCm3aYcFGxK/j4WdpkE/VS8eYKgV2W60RKEnqItTN/N47jqPE/CTBHiBhit8D0fKSBOK6ZLYdVByki+ekVbIncCBd5aw9CKoUgb4ZeJlU0P1cZu1osBNJt+l1ppN6naQggWSlZlpbX1GGzWrcpXSg9J3lbAbp5HUSrvlNZsCQKfB85Yew5HuB+ryIF2CL0YRpxVQ0MjsmR7MbQV2NuxQRlX0E8gDDTj1D9X75yqPQwH4XE6DYzqd7yfpPboSu3hhZQGYScvboGhFKZZLT2rbJ4cnCR1f9p9UxBtgmKBrbZN15emSJCzprnv5BwXT8uhHr+tWNNO/Ujd3bdBDUtOBngZGX295fOl5zRFn4wQLfhFttoQq3litf29Z61hWK4bEmzgxJNglMaTHokBlUCiSzuuKaMWv5wvwaefm75vc17xG2tLOLtsCNdrBrqCeDtd06QYd966cdOISEUQGplmcXT8vlNubZfPsGkEg+47KXnJKY+nlhWXnr7ChTtu4dwCPPro+vidtU8Yibj9e3/v73Hu3Dne//738653vYty+Ttjw75YkSyWBct1sydKAejesE26iXBpl9OuDv6dBud5O02EfjDS57yU1NgPj0wHIUSXTcNQVcMUFMhREiOl7CIIjvDCw3xlluQQVo8/wt7YEUzraPudciTGSJGbVmHO/YDLjHA/T+N4vuhek0Xufx2MMV3vKFIIhPSYLVV56/2v49nrC8wWDx9xu7q6yi/+4i/ysY99jHe+8538zu/8DidPnjzoZh16CCE4HdzghjdDrU3K5nfGhEQzV/QQCJQ22QbpsBR22Q16VbyTFM+BydV5xcCSfhqTFTvLq/Oi2KZZJ5qUuBu/j13qui8S5itW/VqrtahWKoS+LRzXaHbUStNI1c4TUNpsJ6vytgLjKJWHpTW748RKcGq2c08H2SHs1O5e4izwbDGySEmixFDwBQXRBs+3xcmQ+NIGBPqldY+Dg/I4nQZ28iodlQydFsZVau+Unj8Ig1T8x6sg1hooPbON2Ost4nhlfbzU/d1iUN9UQkE5cAXB2rzxriKL5U6GxTCPX2NMl3I0f8W+tAr4yIS4v2gkSsF8aTT/X4BWbGhGtr2ur2x2oLVFiRUofFqRZhU50I921OKX6032xLc5r/jVZpsYGyelckG8UdbJSQM+48zb/LipFuzarOn0f97vO1G7f4ZN69krpeSOY4aN51a549hto3XMAWIk4vZHfuRH+KM/+iN+6qd+ig996EO87W1v4x3veAf33nvvXrfvwJHoBK13X0hhr2GMXbj3S0FymP1KDxMOqy3AuJjGdYxKYh/hcKMYFFDeEXF7GLEfz6nD6lXbDy+MVo4O7wCDXn19kYUALKF7x+l7OD13+IL63/3d383W1hanT5+mUqnwr//1vx742Z//+Z/fv4a9AFCVTS7c6fH1q4rn1iHRJrWWApm0KPjVbRukUdVhq3VtC5++wJSDvZgGIeUK21Rknbqcpxk7b2GJ1unmF0O1ABioR/YdvBpOrsDrVisJ6+spFKEn9oyMz5OsiUltGbp7whZls3KysZTKg9Kap5GCP4wcFkJQIKJNQK1t08g9FOWCvU9e1OaVt1e4+4THSl1PXLzooDxOh2Hcgkz9/I4jBcfKcHZecu05MZXCTqNgIqV2nwJ8o2CQF/fDX77Bmj8zlBwU6Xo7aur+NDCsb6SUVAuajdjvCiL3Q77diG7lqMkFAoVIrQyQWbFHkxZm1AYiZUiMR6RsgcFB61s7sZ8XfahOm4EFsRF86XlDotVQP9p+hLu1iQCSdQJvllZs9sS3uTuIZ7atk/kgXpzsvL7tNuAzaN72BjHy48YGQEyXbYwLzEWJmcozzBhrLfS8Eaw2YKZ4sMGg/cJI0/x973sf73vf+/ja177Gf/gP/4H/5//5f/j1X/91zpw5gzGGZ555hvPnz+91W/cdKzXNck29YMi3/Uz7e7FtiGFvSI9Rj2nYX7XtEY4wKYQQB0ogHWEwtkWdmc5anVdGJVrhpXYyLxQC9wh7CTsGpAz49prhzuMH3JwevO1tbzsap7uAJR1Cvnk94QtPtfDDItUQ6jXVd4MUJWZHdVg7gc8+o2jF/QvSvNAw6sa2H7oK26hjBMqSDzLd9CcmLdyl20jhs9kGzwMPvSsF3jhqpWmlaueJHEc8dPvBijRFfTo+osNUV+Mo0HYizoQwlEOYKwkakb3/sbZ2e/7WFWaLd/Onl1QPcaI5Oy9GOv9hVLFPWpAp73f8tW9c4dTp81zeMHztqp5KYadRMalSe9JnST8v7kFqXGc/4PyWR03dXyhbpfxuMWrf7ERI5tsdegYNaAT5JjpFrIMr8mgAYWCr5QpGFYnrzg9Y9F3fCr4lZ5URXb7d7rg6JYvrkSVgd/KjzRPuX/z6CiY8SyOGhjrGZ55QlENLEesp+zbnFb87BfF2WienFfDpnbf9ghj5cSOEoFowPbYxBm2sLYa/y2fY49d15k2rCIhi2xceJYIxlfEvNPuZsYbTxYsXuXjxIj/+4z/OF7/4Rf7oj/6IT37yk7zvfe/j/Pnz/J2/83d4z3ves1dt3Xd8e7WOFD4IgdLaStMPqYdhPs3zSA37woNL6z3CEV4IOCJCDj+mtZ4kSUKsFcUwtBt8939HY+AIKRzpcrOmDx1x+8EPfnCkzz366KN73JIXLoQQXDguuf7cZZLqcHJyJ5IrNr5VCbUM1fBwKAengVE2tr3oV9imEhZpxDYFtuKtEFaPs9WGZhLQiG2K9Zk5yRefUrtS4I2jFB6FjB8lVbubgNruB6sRBNIWZpuKj+gA1dW4CrRRiLOzVcFb7/a3+eY+/GW2ESdQ5Ll1w7NrBqlv2fH8e+1xOq5ydrcFmZxPtMDwjet6G6m0m8JOo2I/lNqjYJAaN++3PGrq/rTeyabVN67dN8Q8a01XL8hL/bQBTFrElk4hS2EJW4NAY4sWStFR6kYKNEU8s319KwZpUbk2ObLQErZKO+LWUAlFl/1Crx9tvh+FEMQKVtU8QZuu8b7ZMrRj0Cacmm+zm4sG+1y9vGG4uWVoJ/2DeMPWyWkHfHr93XvHW++46bWNcSrqxbLg9mNi4mfYzWSeq89qW2BSgDFWYKkMKCS3LAhedc4fSRn/QrSfmZiFfOihh3j/+9/Pn//5n/Nbv/Vb3H///fzar/3aNNt24HhmpQlCYoyVwR9WYk0I0UUoH22nDw5CHAlnj3CEIxwMul44mc6zwPM9As8HBFJI63d9tMgdIQeTbogS/cIaF9evX+c3f/M3+Z7v+R7+m//mvzno5hx6VGWTN5+XvOm8x63BFd503uOtd/ucnOnc9w7JxTbvRq0NESGS7d6FMwXreff4NT1WMZdetcy4hWCmiXG8cV0FdIVnK6rn+mKuaFVpLV20CjM66b/GWLXYoD52ROJ8qsAbBqcUPlYRRKrbx/NV5zyqcjsZ3w8aiTdCqrYjckIfNtuWkCnQttYJ2l5l6MNSRXadfydUZZNXnfNY2uE6oKNAW64bQs9VsoeVuiUjr2/1cZTsaXesOsTZVrtDnFnf3G5V5c3kGFECs+k9VnjW6zMlq0xqUzHs/DspIHfjceqUs595QvFcfIbPPKH49LeSvu2A4eN2NvW1HKUgkyOV8n0zyXEmxbB1qpt025PTd2GUdWPQGD9WEZwNrnWtwf0wzjo5at/MF8dbe/MFyZyyXghLqiap5YAAW9gqhScccdvt6aqNfYZ0tbssOF4VeCQEnlPvWkW/W0d91LZ1ylpj2ODIWs+Ss9M67Xt2/dvqWRccqXrcXxn5fbl3Ln7tqgYDL7tFcta/yulZKIegUwK73/qWhwv4lILtYpvegM800G/c+EKxWLaF03wSTs/Cu+7zOb8kJnqGaa25lpxAGwikVSNLrII39AAET94c7T1gkmfBYcCuY0lSSt7whjfwhje8gSiKdv7CCwjaGLcjOUIPjlS9/XE0XL4zcDT+v3NxmO/9XvnPWmsEC3G0xh2hD4yBxcMrUsjQarX44z/+Yz760Y/yuc99DmMMb3zjG/nxH//xg27aCwI7qW6GqcNccZqZovXN361y8IWolnFYa5ihhW08adg0ZUzd+gCadptyUGClAV/4tqYqa7SmoMAbRSk8zVTt3vRwLTxKASxVgPpVHrr7tqn5iPYeZzcKtFHT2vPoVcpqrYlMAMYSDhiIlcRgyfhB598rj9NJlLM7jdtRq9yP5jG783EmxSRK7YPGKOrcfhh3nRylb4pJjc88ucB6c7DFhZtvRsKpWev5vNHQCOnhpZ63UuStEQyRgrkStKIEZIgy1v/WYN8xlLHqW0/a4mD550QniyDBlwXKATQaLcrFCs3Enis0ERBuu+ZB9g87jfeZgiGOFNWCTzOevIjdoLm40oCttmZBtnj9vd5YGR17GfDph0HjJtFpFoVIePCWMlLaZ/8kKvJn1yDBxxcgnKQ6O78dG61Y8uyq4baFwW3NPwtmiiYtJOn1XYsPm1BlqkkAYbh9MryQoVQbrTVCSoQwR6RcDodrGL84kO9TpTVCvHiKmx3hCC8WJCpJFajfGRAItNHZy8the4k5wuGA1gqtI+BwFqH8whe+wEc+8hE++clP0mg0uHDhAsYYPvShD/HQQw8ddPNeVBhEcs0UoR0pykF/j/RxNpKHsVjTOGgnDCxs41RtYK+tX1pvoqu89jbJN28wMpE4CJOS8a7IjDCGs/OjPxe2EVAXHAG1xmL53NR8RHuPs1vLgXGJs17iJNaWHPB7MvOsH+fg8++Fx2leSbhYIC00tXPq+E7jVhtQRrJcG+4VOS0f1UnQLx19vTE56baf6OeVOwyTrpOD1vCliuDEjOCRZxZ2JPzz800KSTU0tJst8CrEaREypeH0LNyxJLn23PNcPH+BdmxY3tTMlCzZ69LsdWoVgG4j8Ps+JzK/8dTSxwhLxi2WBZstg2r3nx+D7B9GGe8Aty8KlqqCr39z/CJ2o85F0usY1W95v4vawXgBrkmCYc1UHyoHXrqtyFGPhktsMjWyhNW6HWPKFIlSH2VpdLYWL1YO155npNtVr9epVCp73ZZDh7LX4rl2g0qxjDEgB4+UFz2cH40VIdsHuRzh5cpVnZ4m6W0XS/2iLZCktKYVtwk9HznoreYIB4rv3JXgCKOsey9WaKNJjMLjxbn2HmEyGGO4sXETQxmYPejmdOFXfuVX+Pf//t9z9epVHnjgAX74h3+Yd73rXdx2221cvHiR+fn5g27iixL9SC5jDH/82O68WeFwFmsaFwXfklNJH8e6WJMSG4beshp5NWLoC9569/gKvEnQu8lumwLt9DQGj69d1VzZSEYuKjUuATUNTEOBNk67e4kTR/JkKeM5X89h55/E43Qn39pRlbOrDZvO7o4Tev3HbTuxivpI2WJBj17RXNkYrOo8KI/ZbUXVrmrmS4KLpyXXnhufdDvM2O062W8NP1aRfPpbyUiEf7/55gvFbNmucZtbLbygwoO3+JycgfplO6dWG/beexKOVQVRYqjVWlQrFUIPVjfMUGuWflkErt2X28OLMc4XK6w2xh/vX71qWKqAjxm7iN20VOy92O+idg7jBLjGDYaVUn2oTpXY22ErPlXC4f0fJZAYj62W5bc8ARqNTG0oFCEymZ4aeZoYiRV661vfytWrdgn7yZ/8SWq12p426rDg5HyFR555LFM/JlqNfQxjDEoPMIY6ZHDRZ0eMatNpd5Ik2d9jFRMlEcaY7P/7YS/4DW007SQ+vIbDu4Drc2MMBT/E847IkRcq3NyZ1J8rSfb+adE7d80EkypWibWUOYQwPVdk17Xdt9Ves05Ttw7XtU9yD3c8pjGZh7oxhpsbqz3j5sWPvb5GrTVKjf9+0YuDuBfGGBKtuHT1aRrtw2eX9b/9b/8bnufxcz/3c/zmb/4m/+Af/ANuu+22g27WdwR6Sa7F8mS+dr3Yb+++vcBCWTBfEiT42/pCaZNuTHXq29eNvBpxHF/d3eLkjC3AdfG0RApLqi2WoShahB6p4k5RO6RWFdPy6h0VvZ6PTvuTWoKnaeCdezzs/ON4nI7iWztMSQhpJXsj+fyz3cf5yvOKYkDXuE2Mx3rTkljGgIeiHAz3ijwIj1mXjr7S62nZgG9c14gJSLfDjGmsk73ry3qTHUjGjldsfr4ZDJEyKOMR67TIVrqGFIPu4+THBgZCT+AJRejZQmajPCd62y2l5L5TEg810I+2Kmt85kmzJ+N9GEaZi5Ooz0f15t6L8T7Oc2mcz55bsF65yoDp6S7naVwM4Nzi8GsKPINKVdy+dDYL9r820GCL0oXe4XuHGIm41Vrz8MMPc/nyZT760Y/y7LPPcuXKlb7//2LCd507w8215/jPjzxMrdlA0h2hGRWjKrTyRKnBoMcgfN2GXWu9bfNu2E5YDGq9IzecvW923JRQFHTI6GEkgcj9726Rnc/YiuahHyBeZOpnbTRxkrDZrCOlTD0lX1zX2Iv9IL1c0MRgaMcRsdqf8JmzuBjngWgApRRfefpxbm6ujv69CfvRYLIgjZtb43x3rb7JtbUb3NhYzv0+XYNGaNNekIy9UFpl13hl9Rqbjc2JjuPammjF2tZ65n+eaEW0DyT7KFBa0Y7a0z+w6PSjFBKlNWu1jemf55DB3fPdehrvNM7ts9Sep9FuZX2dR/6lchDaccRmfYtG1Jq4rdpooiRCjRikVlpTazVotJscnz1OKTh8Ngm/93u/x6tf/Wp+/ud/nte+9rW8+93v5kMf+hCXL18+6KZ9x2FaG8lpKCcPuqiZ82PsRyQ0YzvXA2L6rT77VfF+EC6v21Vtvrj/RaV2g53IwlEDB6Oid7xjQKJQpuPvGYoIECOd3xHn+eKAbz4vu4oTDSIne0l1p/jWA2gA69fps9VmG8nZiOyo3Gpbu4zIBJZISb17CyLaseDgsLVgksJOO2FaRdVeSNgLj9NxSEY337basLxlWK1D0xRZrcNyDSIT9h3ve0U4DivGeP64ZEUt9CX1pzHeh2Gnubib9X6UgM9BPwvHgZSSU/4NpLCqbaVBY/8bp/30wFmZiU2GQaT/03u1h/jygRGtEn7wB3+Qf/Ev/kU2Sf723/7bQOfB57yChBA8/vjje9TUg4EBvvLM13n02a9zz5m7eO09L2e2XAUE5cLOoUDXZ0qpHRWUjijVRmcbp0AGIxEqWqcehMJK3qVI7wtWON67vvU7ovu8hC6iN6sibsAICPwAozVaa/wer0fhZkK6Fd3tBNDG2gYE0gfpZUVyXF/tB7nplHVC7N3ZWlGbOEkoFwqdRVNwKMlbpe349D1/rLRxbXQ6FgVKa66t3+Dk/HE8sTcRPyA7l9Jqm6fZju1NCUgpx2vfJESPDdQYNpt1Hn32cW49dorTiyfGPMoY50uDM1KIVMUeIaWk4Ns8FLeeDLruRCkarTqlMGS+Mp/9XgBIMXTcZmlKQzpKiN0/PJMkQUqPRCtaUZul2WN4IzzMt7U3XWeMMTRaNTxpm92K2yRKEfrB1AqWueOMW2TMGMNWs95lH+O6b7ftimKbXeF7AVJK5spVNhpbCATz1dldz93edu7Xuj4M2mi00tkz24y4Fg9qu11HxLYxrbW2z1KjqbWbXF29zh0nb6EYFHtS+bIT9D12lMQ8t3KV/+9/+Q9cPHcP73rw9ZQKxbH7UQpJ4AUjB1WaUYtr6zcJ/ICFmXlu1nevGp42Xv3qV/PqV7+an/7pn+bP//zP+fjHP84v//Iv8/M///MA/OEf/iHvec97OHbs2AG39DsDk/ja9WK33n2HpahZ5sdYsX6Mri9OVAWtxLCyKYem9S6UqvvaXhgvrff4zL43bygmsRzYLXrHu8SgACmhWoC4qcY6/zCrhnF8axfKkvmS4HJze+q41pqtln0mzxf7HycgZrFSZKUOCh/PpKrFArQaKmvrMN/gYT6q0/aYfSGP20mxFx6nwyxeoJtkFEJQlTWuJvM2g0DYs4JHWwF4nJztv8+YxnOiH4bZKAybN9MY74Pgsi/6zcVhNg699ieDMMyO4LA8C8fBcX+dW07fxqOXNa3YWvVoA6UAFvVV7jt5+47HiJXAQ4HwbSAi3ZJqY/9fYAg8iNTh42BGmq7ve9/7+MEf/EG2trZ4+9vfzu///u+zuLi41207cHzp2SvUWm3Ozs+w0WjzrStPsdWs8fYHX0+lUKYQhFZZl/KUhsHqWs+znjmDogBOzZpohRQS3wuswmbEjZcUkljFBL4lek3aoN4F0SlyRVrRN0oiPCEJA0vYWN5VkCrFMcYSFKWgkB1LCg/Tp2hWl8rW9Ff1GjqEkfu31oP9ao02GZlESmoPI5T2AgKrOBMIpLc3StjAD/A9H09Kaq0GvucRegHCH06C5WGMye77KNGm/PeG9WeeSMbAZrPG8uYqJ+eOUQyL+NIb6XxSSAxWPS2l4MTsEhhDpGJ8z0NKr+tKRyWvDGAGzC2lFVIIas06M+Uq/oi+yDole9frmyAE85XZkQtSjTM6jDGpYq1BrdVgrjLLG+97JeEYyrV+fWRT8UzX340xKKPxpZd5VAtAIikEIVqbrM+V0UgEku2bCG0MnpQcn1tCCrltzdtpvNoAkRnaUTuRtv3GRu/vfD9AqYRvXX6K43NLVqk/wdy1pK1GxXWMSSiGJaIkJkpibmysUCmUObVwfCprkltrjAF/BKsUG2CzStiZUpWbmyvMlCrZsZySczctc8+4RCXEkZ0T5UIRjebm5grlsEilVEErqxwdpd15CCxRqtKbLhEkOibw97/YqSXAa0gpKYVFa4uhNdKT+LITqDI9cyv//W2bQhuBS7NYXGaM6shnBURJTDks8pJbL9hn5Bh+Y0IIPCk5Vp3nxPwxHjh3D6EfkKQ2JpOMe2OGz0+HYhByav44G/VNPOFxdb0+1nn2E77v85a3vIW3vOUttNttPvWpT/Hxj3+cf/tv/y2/8zu/w1ve8hZ+7dd+7aCb+R2BSaujO+zGu++wFTXrRyQsVT2ubig+/XWrxi0Fh6fi/V6l9e4X+hFC7cRWEidZJ/Bmp6446x7vlzl16/m0INb0CCkYl5y0iu9rq9vHWC2y9FqBNkJUBhzH54EzkpU6fO6piIVKSCGw7Ec+52MnVWe/tWAvPGZf6ON2EuyFx+moJONCqWr3N7pKwScdW+ASvQs+JHHC9U2fi6f7n3u3z4lB6C3GuLP9w/TG+6D2DJqLbr0vJjU+8+QC680OwbpQNrvyFD8sz8Jexe8o9ij3nZS85JTHU8uKS09f4cIdt3BuAR59dH2k8zVjO+aKASSqUwDPGJthoHVEwfenWrhtWhi5SbOzs8zOzvInf/InnDlzhlarxbPPPovWmttuu41qdf8jv3uN5VqDSGluWZzl1FyVrVbEVn2DayvPcd9tL0k3tCKTW+84fYTg689d4ralM5SL5ZS0SnBba0+IbUTIqJtuIQS+9NFKW+J1ALkppMwUta3YptVqozBxZDd4XVFXQ6wSSmEhU5z1njOPfFu3S88N37z8FB/57Ce45+yd3LJ0mluPnaZUKDJbnkm/4xS6nW87xVMzalEIwmzzKzAIKVJV5PhkwbhwKcJG6VSB+f9n77+DLEvS+m78k5nHXVu3XFfbsT1ux65fmGUtIBACiffVH0johwApCEGg0C8IfqBdkACJdzcgCEkgFIBCSCEkYRRIECF48WaBZdld1syOn+nxPe3KX39MZv7+yHPOvbfsrZ7q7prZeSZ6quqaPHnSnvw+3+f7HA4btgAy0zxTvZKKRqWK1joPYVdYaxBSTjG+YHVznUoQUYuqaOOYlEpKVMlWHo2LAvC0gNoFdLLWlvICUgiGScyTr5zj2Ysv8Q1v/wCDZJP5xuxUmisFSJ9mWd5fFim93OmQkaUJSZbQiGqoHFycrhEtYhfguHAItOoz5T1PU6rFoqSiWW2w0WtzeXOV03NL09VnSjPGsNpdZ7PXIfBc/6RZxumFE2RZ+hoBN1sy5QtwWAqJ7znmOowAs8KR4qlRG7r233mMS+GYgzIfk8Ya5HSqO6UJBHEaE/rhvp811tAbDojThGpYIfA81A4genGvg3hILx64+gvBrUs3keqUl1cuMFubYaE5e6C6doddMp2CFWgrGAzXefyVF7nv5ruYr7dKp9thmZKKJEvRhl0dWuDaZZDEyBy4U0Jtcy4cRr2UVMRZTD+OwVr+4JG/AAun509wx8lbHMBqQSp5IHkfoHQ0ZVrTHfS4sH6Fu07dhrzOiSfHpYaSLEVJSW844HPPP87F1YvcvHSad9/xEFiohJHrF5E7Q/LoGCVVCfLuZsWaJgopnBxdr4XV0XpnwYqDAQee8mhUa5yaW+T0vFundB4Vk1gI/d1B8EIypZB3KRy705iSilpUIfIDOsMeSXr0NG53sjAM+fqv/3q+/uu/nm63yx/8wR/w27/92ze6Wl9W9lqSU10tc/KoJjXbCiQIIXZl497ojPcHYdwdVRsHhP76iVVscIp+Cn09z58dEBCZ1sbH+x2LkruW5KEDUgcFJ3cbY83IPUvJdGf0qSgn1YKFuks4JfPnxa3RGtOwOq+HTvMbYdwe1K4Fw3wakLFwKq31LUMbMpNLUyTa0ukOadRq+BLW2ykbg3BPdur1SGI47bw5rPG+k+213h9rCB55cRa/Z6n4I4DVyZ8YZq+CHXtU9sLXwviVUnLrvGXzlTVunZ8ub0FxvbWeIUPRjR0bvRHCcOjGpidgJZOHKptzmHbgJerYsWN8/OMf55d/+ZfLBDqe5/GN3/iN/NiP/RhBcP1ZMtfKFupVAiUZJCmNKOTk3CLVpVu5/fSdOeiyQbNSL8Nv9zpkgwM8bl48RSWsYIx2SbbGTAOVwAEZ2hiUGoF107APpZQMkphMZyXratzGgSCZg7uOpemYvlmi8ZTCk4ovPv84n3v+Cf4/H/g7CFw49cT6tCtwucskF7DUWuAb3/U1nLv4Ek+df4FzF57jpsVTPHzPu0uGjwOtJ1lNULStWybHGbdKKoZpvA24PazQ5cISnRF6jgWZZKnTtkwT6pUqSqry0LuXZToD6+YLjBiyxhjHts7BWykksSkOwLYEWMfDvCdBcheeKxBUwoi1zgaVMCIzbn46qQCDysH90fXNnixxyB0CY5II9YrHV9z9Vt519gFMQau2Y0nqRCHNsYPTAOHaypdkOuPSxjKt2gyB5zNIhgySIdY6sKGRz6v95tTo/mGnHt96b/ttQYVEiNN5dsD3E688y92nbtu3HkDZDtMwkPtJn3a/SPQokMLSiKpIIegM+4RBCLu05a7XHxsLQggynbHW3WSz3wGgFlY4PnssB1xdtuBiXBUgWqEJu1UGxX3GtbIQAk+oPKHSwWeatZZ2v8tCMxjVewy4khIKDPAzz36Ry+srfOiBr8T3PNe2dvS4VEoZYHll5RJJ5uaOwDHZZ2pNbK4f3ov7zNmZqeZrYY+/9ASpNkRBhUzHfPH5xxCqirVw5+lbWWjMjjlDdg/zT7I0B8in2XYtmdaIHRjNkIfHp+nY36A8RTWIMNZu+04xrou+c1c4iBPDo1ULSXXKV971NtY6G9x3y93Uwsoo2iSf39OUl6TpyEkpBGmWgoDjrUWG8YDKFDJE09h4fxT67VvlMsY/o5RivjlLlmU8/sqzYOED938FrdoMkR/me+yQLCskAQz9ZMiJ2aXcCaen6t+J8belEyz2QOOz6EdPerznrrcTeEG+BjmnX6oz4h0cs6PLT3qdnSTQNJEONl9D3JgOPJ/Z6sGlSG601et1vvmbv5lv/uZvvtFVedMOYFcTSlsk65nxR46+wq42zPVa2m5s3BuZ8f4gjLujbEK45DNruoUfc2iAyEGuPw0gZa1lfTBdePTVgJM7jTEpBH/6bEac7l/Ojcpcf1B7o4zbg9q1kByY1qk0rrErhCBQDvQMnGbCVbFTr4UdZN5cy/F+tTIOhfzJQc6KR2EvvN6M363Xi4hJhUdiQMfg54Fm3eTaJm57rXZg4PYnfuIn+MQnPsHP/dzP8da3vhVjDF/4whf48R//cf7tv/23/OAP/uC1qOcNsbfdfJKbF2dpDyT33fIA9ahBFFRzRlTMsN8jTmJm601Cb3/mWGFSCOwOg0GKEeCinItn5M2ZcuwEnrcjiDn+e1GUkopMZ+XfhR6okopX15aZrbvDapG4aDwh2EFCiay1ZDpDG8MdJ27hrlO30RsOGKYxcou+6QQ2PPZ6AUSU2c2Lz8COIexbQU3IgdOcnXZQtmw/HpQH/rXuBqnOXOi/NTSrjT1ZVtY6cDbT2eShXoCw7tDrKTWhKyyFJDPa6RXvoI1Ylo3NNwcHSDxz4SVeXb3IidkllFRlci5w4I3ZAl0WrMSdy3btWLS9KUFJUYK/4ED/QsLC5mN2Nwavu6ZASkWcJqx2N5irNfGUYrE5n5dhSLKYlc0NTs6f2rWc8ZqKKRmfu9WqAHWEEHmiuBRfeUR+yH0330UlOPydy+ZSJlK4tq2FFaIgxBjDMIlziZKodJpMAwYbY8iMJvQCtDG8tPzqtsSERYRAkiYO5Cn+KyRMBLR7PebGHuh2W0OkkmOg/fSzygK1qOrqU7AQi2+Lom0g1RnHW8e46+Tt1Cu18jNFcrDiZgrN3K3ODSVVrs/qEXgBSZYwTGIqYTR5zT3swVsfxFPKsRCt5e23v5U4S9FGk+qM7rBPo1oHW8hI7Fyml9dlGit0Rh0h007UVBs3Pi0QegFSihHQJwRJmhAGjgU7krdx0QkGixIHlTJw1051SnfY5+yJWwjO+Hmov1vbtM4QyttbcoXRuMm0xvccaCulxPd8OsMug3hIGgROG61Sd+NuF8B1PyscEROgJLlTdKysomVTneXSKo65/OAt9/DALXeXTgFrHKBaj2ol01YKQbPWcE6SLJsSlN/b9pI62n6Pk1YLq2OAqttHAs8nyVKGaVI6hi3kEkVyy+gqrr//I8doLLvJGng+x2ff1Il9066fHTSU9lok67nWthMb90bXZzfGXT91OpY12WN9MD+1BuONsIPowV5Nmx8EcN3NuqbCn57TrPZgkJzm8jOahbrhnqWdB/DVgpNbx5iUu+vfbtXcXB8IarJHT7Zox5ZKGRZ/7XSDr8YOwhR9o9m1kByYxql0LTR2r4W1Ks5x0+kHxJmdqM/WeXOtdbK3zsX1vmWlZ5HWkBoIxsDirfInc9Xpr3Oj98Lrzfjd6Xqe1NSr0I1hmIEmIjok2ZpraQeeLr/1W7/FT//0T/Pud7+7fO39738/YRjy/d///W8o4NbzJH//K9/Nly4IPOWDcJnqjDUo5bHYnKXT36Q72MSETeo7sFy3WqHvWGhMFqCKJ9UEI6ZgwRRg2ThTCnZnS5ktYbtbPzc+BWR+aBaMDnK+55Nljg35ljN37Aiqbq3LNhu7SJGxXhtLo1LLARZ3CB8mMYszczt9bVvdt4YjT159xHYrQObxt4oHD6U8B7bkB+yDJNaqh5WynWaqTZR0Y8GTqrxuUYeCsVQCBziAS+G5UOICN7EF67YASEcrqKcUOmdLhdLfQUd01C5QhK9bFpotbl06nbO1BSpw4fdZnpxrXHBhL1ZXydArQVsXUl8c9CccALl27Vbm1l7mwJoAJSTVsEI/GbLe3YC83SqBz2x9fx1tIWAKEYnp6pTPzSzLsIC2htALiPyQdr9DPdp/VzzIFiMwhJ7Clx71agPfC/CUh7GGuUaL3rCPJxSetzcgNllmDtBZgxSCelRlmKZUgpBaWMUfKysKopHTZmy9cUkHpwT3cvwURizPvUCfAiAWOGdIlGtn75rQSQhm6zPEaTLxmYKpWXwO3FjdCu5po134+th7q50NluT81O0a+A74slYT+YGTJPB8tNFobaAg5Yi9gWC3d0w3QvZiPaY6B21zHWSbN7i1tgzh17mky/i66ZK0DWlU6+xe+nbTRjNME/rxgNl6E0+Ot5vIZVhUCeBP7hmjXWN8rAW+T6qdZIq1LuJgrt5iza4zTBOwPWo5QGpyZ9FBbet6pPM5UUSQmLy9BBCnST5nJJ6SJeu1kAgSCMZ9Q26sKawdMc495R1o/u9pW5y2O86PHb4WZ7FjpedrWdEfvvJIxiN8xsbFTi07+cww2lMnny8EQjjHoTEZnudxuKIhb9qbtr8dJJT29QIkHHXbiXHXS1xSFySsHKLkwGEAoDvZQfRgDwKIgANcP3HOsDGwV6VHCS6k9+X0FHrd7fEaRT+GV1LLWk9zbAc28GGBkwfW3NTz+Nr1f99yqLq9h2lHVX7keti1kBzYz6n0emBju9B5Q3sIGR4rPadxKo3add5cq8RpO9XtC+cN3RgsIVkPfAXCjs5nV6vNfKP3wuvN+N3teqEnCD3oJ5ZOP+PBUz63zInXLFtzLe3AXWKt3TH77tzcHL3e0U1McTVmraVaOc7STEKimWCHWmsxwlAJa2z2N0h1DOwP3A6TIaEflhq0EscKC7ydkxG5A1gOpE251o6DA1u/Mv53ceAev1+LZXPYY7HZQpuxUNxdyttqW3GJgkEc+A5e09ag80zsQgg2e20XbruP7aV5WjJCtWGYJvnBVTqQ0biQY89TDsiULjw3045ROa2Wn8w1YgHwHDtLoSgCkEXeTznltDxsW5GDuta9p9Q4I3A83HsCF0AIQeQFaGvykGnHzBXj3zU56FsCZpalmYVJ9lTOuJLG6U8O0pi62l8/dpSQbBIs23FrFZQapyOG4N4mgHpUoRJWXB2VR1QLIAdKMp1N3TdTT4x9ijC51rDOgaSCmdiL+6Q6m4qFJoXYxmre9ZJC0Kw0iIJKCbJZa9FaUwkCfOXRHnSoBBVCL5hgOe9VZpTrxgohODazgDa6nOcFu3Y3Np8UAqFUWUZZLrsAsvkaNl7WbqDP1vdrUbVk8ZctZgv5EFsy49e7GzSrO4evjY9/V//JMZNkKZnOCP0QbQyB59ica902rXpj233uZA748hmXaCmuldgUT3gU43Yv2Fob49aHq9DjHmfd+spnHLYrQM0isaVzrowcfsZarIDzq5f40otP8fVve/+uYfPbrmstK511usM+p+aWcibwLiYE40DxuOOquFTJoDUGX3oIRA6KO6dho1JnmKwClszonKVs0MbuGdWw731gR7rRRT2FKJMVesrLow9yR+bYRlay0aUE8uSKOTDaHXaJ04TFmWNltMChrEdjlulsQo5nJIey3epRrdxzx/cfx7wdSfQUIPZUZkcOyUxnebSJoFztrXXJJYVgtnp0MxG/aVdvV5M85Cja6wFIeL3YOOPur59YpadOYYxjrtn4cCQHDgMA3c2uVbKqyx3L+fT4a9KjtNbyhfOa2PpIwJNgtYuGzAx0hqA5tiMb+LDAyYNqbtaCqGRcL6hV3nH2pkPR7T1sO4ryI9fbrpUzZKtda3bqa7Xx0PlaADoeYFSNRIOlgpfCYn3neXOtEqdtrdsgJY/KNEihSDQYGxJnlsgXV63NfKP3wuvN+B2/nsWSaIu2ikRbAk8Q+dATlop/46Na9rMDA7fvec97+Kmf+il+6qd+qkxI1m63+Tf/5t9MsHDfCLbet1xsGwwengKwjPAsgRKKKIjoDj0ybaYKqQmDiExnBH5AkGfN3u8AVQC805gnlQutnsJ28jIDzDVm+aZ3fY3THRx/f8o6bCmUNEtzZpUDO6QnynBVKeW2g+hO0MduYeKW/BCKK2u9t4kUgrnGLGCJ85D3OI1R0stDnkUOfpjyULxfmHeqUzzl3D6FVqUDTEZ6hI6JPFnP4hCtcxYkRlDgD669bclknbheluVMVsNaZ5Ne3OfE7LHJkP28ziP2rRtLmdHo1BD6PkWOG200a51NqmE0yWTeoa13sxKc3vr6WAkF+D+Njmaz0nDJsgDphy6zvNYY7K6OjK1mLVPNu/2sBG2Nk3wI8pBnYy2hF7DYmJvCaZGDZVOwA93cUtQrlZKFr/UoMVKSOb3jWlRjtbOOEHBq7sS+5Y6Hh7uxlzMB7SScXvTlbjXdWQtz8hqimDNbxsVedz/Oggw9fzRAxhjrWo/LexiOzy7iyZ23ql0B5TFLjcYzmuOthdH1LVP1U1HnneQPXNSEJNFpyXB3AOP2MrQxxGk89bget1ECOef4GiYJ1SiiuBGtc0dDISOTO/lSnaKEiwjoDwf8wSOf5MrmKg/cchc3L55CWLHHukoO+poy3D7yw9z/ZCccOqN2GgHMAFk2YjIJ3HophMQKV1etNVq4tUlKBwr6nk/gB6Q6JU5iZBiVDre96ln+vUNYZ8lezn8WzpXx7xVgrhTbnQHFnY3uZDTPtbFltMNWYP9qrVgPCiuSnmXWtc+erO5d9h8AzGgfEkA65kDdu0Kgtc7B4xHzFnJJHFEkVbUsNo7eA+/dd989db88+eST17g2rz97LclDjpoddSDh9WZCCGYrlp6pYYxLauVef+2SA4cBgO5lh5GsaisANl8zU8sv7GVrPcNKnv7Az58n3PnC/Z1q6NlKfs3tbXpY4ORBNTdnFLSHbjzMVnZ+jjwKdtTkR8btWoOq19IZspNdL3bqQW230Plmzc2vtW5KMwz5wB0ummyneXNYLOatjtFWNKpbK4I1A0Pj1ilPQmKES6rlmavWZr7We+F+zt7rzfgtrtdPYZhaUg3aRiQ98JUl8q8OAL8RduAqfvSjH+Xbvu3b+Kqv+ipuvfVWAF544QXOnDnDz/3czx16BW+kDRLDIM8RVRzaLJOMGiUVc/VZ2OMwVZixliBPPjUeqjiNbQNZd/nceHboq7acEVUAy3tdbz/LdIo2Jg8jdXHVRdjybG3GAXdbTt8jINKWP4XczjFy8g6WOE3wlQtfXmotgHVSAxaoBJJMa1baG/hK0qw2yvDsNEvoD9tUotl9s2570ivrE3h+nlDsYBu+A3vHUB2bH6zHQKHxhFFpzjibqdYJPJ/17ibPd1/mrtO3O7Zw3gY6y0AKrDEkOisLj1MHWispCf2AxeasY/aOAw271HW398YB392/N/rmXq0zATQxYoAXybGm1QOdnpm7u2XasRUdq8/m49YS+AGtWnNHoKowi8Vol00+ToYgBJEf7To2rDV4nhrpNRdyF1JQ8K4jP8AiiJRiqbUIdrs2517m9Jct2mSoHLhNdIq1tgT/d+17xI6h6eOyHogRQLhX2L01OwPZBfO3AAfHWYLSc6CesaZk2tu9PL5FvYTIHRPGgZlCOpmDNMEaSzWMRjctxpwMU6xuu4HDRR9nOQjm9Ki3H1CN0fjKm1oqYdykkI4Rnmsi9JMBlTCkYDvGaeyiOBhJ7xT3lOiUyA8QwPLmKnefuo0rm2scm1nYW7c5B2ellMzWZ5y+ay4TtJeNt+Ug6ZNmCYk2RL6iGUVIVSVOE3pDlyyvUW1NrDUOJM6B2yylVqltD+OYuN7+VvTxVnb1eKnjTOHtzoBtYSTlS0pKrJVoq1FCTeVI2M+MMeV+Z7EkyZDPnnuEql/l7Xc8OFUZ21n1lkQ7TWuBc4RKOd1DebE+6VxuJ1BeCXyXgDyCLOvRqhyBjE5b7Jd+6ZdudBVet3a9k4dcDzuqQMLr1fYLeb0ayYFrrT8Lrz1Z1U4AWDUwtIfTyS8sNnav20rPARo7UiWEY7WmVrLag/ldAj0PC5zcWs7GgGsmMfHlbtcaVL3WzpDd7FqzU6/Gdlu3hHDSCIFI6achGwOuaaLKnRyjVR/6psKs757V6qEhTvM1QbjnuziF9T5Ug6vXZr5We+E0zt7rzfidrYBHxmY+5DwJBsdijjPH7K2SvS6iiQ4M3C4tLfFbv/Vb/Nmf/RnPP/88YRhy66238vDDD0+VPOf1ZGv90ZFNFAf9HR4UfOXnmnlmz8QvLgx5xOSD6bLPT2sFsGLt7smh3H3sXY6UksxkZCYjkEFZ9tVs/C45VhFCPHaNHFRJdeaYt8jywFsAd0mWEvqhA3fypGkT90IOhgrH5Jq4zNjhujBrNaFKqQUe3djSTwYYEe6Y3GzyOiLXiHVFpllGsE8inq3mJBomQ5wLEESJEViZaZ3rDjupBIQo9W6fvfgCpxdO0B100caUfV0JIuqVGonWO17byTA4TcYi5H+kyevGxLZwdlGAGQWDYjrHwUEsThOiINzx4U8W/Ylje0m1e0K5ghV4NVaM61Sn9OJhqZcrpWCYxM4RIEaJfHayQTwkUD5GGwI/3DZOTT4H3H0aQOXMP5PX35Z9oArN5PH2gFx+wbqEYns4GUBQNIWxGt9TGDMC4qeXBpHb2rUow1pLfzjE9/Lw7by/iilnrClD0IvEamXfjY21HIdECncta2yJCo87SwRizzD5cfmaSlChGlbzvw29YZ9umqCk5OWVCwSenyft0yRZyu3Hb9p3Hk/zyFBEDmQ6y/eDSceIUqrU2r1aKwC32VrT1TlnDTu5EVfRIoSfHKwMlOekYpTH//dvfTuVnME6Ls2x9cA6Ps2cbq4s218KiRW7t8h4WY1Kg0xndAc9fCWItcAXhs1+h+6wD0AYVEvpoAKgnqk1iILQAa37gOsF+F5GPWyNCtjLOTX2u9ziGJz4zk5n5/xBvzscYKylUbFo65wNhZzE1eyXxhpeXbvEbH0GrOHcxXN0eq/iS8WZhVuw1kw1hwsd33EmcJJlGGPxPZ80TQiUj1VO01vkeu0Ttz3mOPWU02e3uO9PmiXVCecvP8OFjfs4M3+0gK93vetdU33uypUr17gmry+73slDrqcdRSDh9Wr7hbxejeTAtdSfHS/navVgdwPA1vuWYQqh3Xntn74t9qFI3ECC6LWSmPhyt2sNql4PZ8hedljs1MOyG52cC3Z3jK4PIMGnCD4MPYFHSoZHZgAUGtAWzi5K4otXv28d9l5Y3FOcgS9BWI0AVrqWbMzZeyOjXwosB8Z+WshQrPXtkXc4XRUp2Pd9PvzhD/PhD3/4sOtz5M1hDVspohajNVZIsjTBU2obeFN+NB+EuwGrr8UcUDCqW5FoSI2BXtMSvpye6muto0v+kml3YBwHqW1etyL5DORZuhEkOmWj16FZrSGFQFuDzfUbd3qIK7RqjTVcXL+CrzwWZubKxESB5zPfmCVOunTjhF5iqIYNpPRJk2Qq8Lzd7zBbn8nBqas7qNg82ZiXs64LoGLcvFy2QRtNlrkdw4XKWh645R4ynbHR2yDJdMmus9YlflNKkRkH3kohy+RFxSW00agCYMsZfDJfwQyTDGJjjGMye37O7p1+LEzDYtRG0x50qYQ7uzLHQ+qHaUxIsGvG9qsFbY01JRhhLczXZ1wotzX0hgMubbzK8dZiQT7c1UoGaxlGPAl4SikxOfDvMtMVIOZo93BdaUvQfpgzd6WQrHXWyYzmxOwxPM8BKEKI0jkxoS8rnNazY2g6R9L44/W0y461DtDxdwmlFkCcZvjKMYczO3q6GbGmR6BRuf4UsLQd9ZsDEIsLuzpqa/DG2nS/MVUAjgW4bqyDuithhVpUY7m9CpAnaEoROFazNgahxLZ23Hqvu814T3llkkJjDVc2V5lvzBJ4fi6f45KE+coHKaZu/x3rkX+5nAdjwwjcHLbWlqAsAoZpQpalzDZaI8a02NkZU0icFOtbEb1hcX1Z7Fn7zW2nUexAat8LmG0EGGvox31WO2sO2Mw7vD8cUAtHT0nGuDlZzXWftdEkaYJSKpe3max3kWxy93WEsc+aEZhe3kvxud3vaZyNMT4Oh0nMIImpjDmf1rsbzDXc3gOUmsNSSDLtEnjteS0ca/z8ykW+8PyjtPsb/M2H7uTs8ZN0s/lc6sDNy2LN2Cq1M86KL27SYkmzhNhaWt5MngTRohAopdDalID81vFROBYtdiJipNwHLUjhkVmfbpzsem9HwZ5//nl+6qd+inPnzqFzR6e1liRJWFtb44knnrjBNTw6dr2Th1xvO2pAwuvV9gt5vRoNxusFDl6NHuxeAFg9dKBDQsBOsRfTtsVCzTHCUi23PX9a6wAbidmVbXst7TAkJt60STsIqHq1dj2cIa8nu9HJufZyjNYDSz+BTgxRYIkzS4bv3heQGccU9SScW37toP74Xjhb4aqlOop7SnDr1CABTUQ2BE9BZr0JZ+/1jH5ZH7jkczMVGKZODsMiS3BcCBjaiD951rBQO9pSUG8siuwhWz0UFFG+xXq50+Ndb9hjvbcJ1iVUSbPJp4ntfNNrZ6KEFi3Gajb76/QG3fyAm6L1dE86AlGCq3Aw9lDBPu4NexiT5YzWIrSy2JQEgedTCUKstay011xmbyyhH7DQaJWJhJSQeWImu+PGpY3z6CRZBgK6cZ9hEqOkIvQDlFRUwpBmbZYoaFAJ6mhjWN5c2xVg32qV0DF/lfIIPH9P1tlulhmdJygatcE4o1VJhVKKAsTGWsc4s5Z+3CfwfAcQGceAqgQRgeczTOMcpJMlo69gEdsxQEobTazTkqE2Gil5f+f/ae3GSuiHOSA13b2anDU8TViDsXYbw2s3q0XVPcH1qwXSi7FojCXVKVc217i4foXLm2ukJuP2pZsQUpCkCcZs5cGOlSO2J60avZe/JhXWignHSQGuFH02wbLNgf04TegM+3k2d1E6L5xTxuZt7r5prOHS+jLn1y6RaY021rHscma3HfvsfpZmGWosid3Wb1WiiCgIWO+1idNkVDcEWZaWTgGXFCoj0y4BlVsDHOicGiejMu7hL1rRG49cKNfg7XW3+ZoLxRimrG+q3QOqpxQz1cm4RAsEXp7sbw/QdksVtr8uKMexQHC8tUig/Bys9fCUV64xhUTJtbJCHiNJU1ba61xeX+HyxjLN2ujexyUBxm2CXY8ox9UIgB/77B51EPl49qTaFoofeAGhH6GNpVWfwfN8KmEljx4YgcVCyBxgH10vy6Uz3GdMDsy7dTFOh9vur/g33t5JlpDmCcrG97ZpTEoxAdoWTOLjrWMstRZLp9dcfba8bqGDXrBf1R5RA9Y6traxhivr53nmlS+w0Vkh8j18pTh3JUFJD21MOWcmHB5lW41LPuTjLf/MTK1JqzaDEm5slvriQpa/72bF/lTuGdbmiT8zUu3m/6n524muQsP5etq/+Bf/grW1Nf7RP/pHrKys8J3f+Z183dd9Hd1ul//n//l/bnT1jpQdBUbSm3b0bRTyun2PnpQcmL7MAhw01wEcrMsB7z8red9ZxRn/Au87q/jgnR5Lu+h17wWABUoQKNCobfPiIG0xV5Ms1AAE2oKxRTSTu3csVMXghjgcComJDO/Q+vvL3fYHVZ0Tbf01BAS8yZSetP3WrQyPVh6qfy2scIxW/O3nD1+BRJNoiFNLN3Z9o4TrJ4FbI1sVt0+/VlC/sEKq48/OaV5JT/Jn5zR/8kzG5c50Za8PoGcqJBkkmjyS1CCEA0o1HstdB9IWttQQfPBOb2L9ff9ZSV0ebvRL8TxT9R0wPFcDn8TVMW9XsHgSVnuO/T7tfV9ve9MntofdPOcWzH5KfvgRZShm8X9tNOvdNpUgwIX3qm2A1F7TfrtPdrfPTanFaJ0EQAEaSAFJFhP4EViLOGBG82kT+EDOlrKmDOeMggpJmtAbtBFS0Kg0Skahu6eRJVlKe9ClGdVZmJkl0RmDuM98cy4HOCWI8ng/cWD1pGO9BZ7HidYicZaQpKnLWk/OLM0Pz54KkEKw1t3EMj1bM/JCl4hGmonrT9t/QAlWF226W58W3laR31tmsjI5ku8FLLUWcyDTHcyTLCXLXMI7X/mkJsu1NsdBW4POK51mWa7HOcmALth1QgpCGTowJacbFuzUJEuRUqFyYKqwIoHStDatVut43XZ8j/0ZgLuXa8qkUWudjbI8gH4MJ2aPlYBknCX4dsT6G9ddnnZuInCaryUzN6+9KBIejT7qKSdr0Y8HHG8tEvpB2V8lazBnVY4DNWmWkWRpLjMSkGqDki4Zk8yZsNOY28jURJsUY91iEdaBc5Ug5NLGcu6EiaiFFXzPL/tX2IIxXyRFEng543Kz12a21iLRBs/zSskTa43TZnVPktvadwJAMxnCCoRXgFQWKygZ7ZnO8JQiCkLqUbUM0QeX7EvmGroFSCm3gPD7d+nosw4k9kZ1FGJCOsc5V67WzbDdRiDdJAN1eXONQRoDUA8rZT/uBdo7lqwt+y0zWTnWtdGOrS9lyfTcqY1GALzAZUV0o6Xodykk9ajKlc1V1jc3Od5apBJGGG0YJAn9eIA2WakFHgbOcVcwiLXWSE+WMhEA9Up9m5xHAWoitjC2c/CRfPzs5AxyoO6W6IN8/yjkbAxuzZ1rtAAnqbLe2yRQPq1aE6U8QuF0b43RCDlyuOzY9taSZI6p6pKPQRg4R2Wt0kIFZ5ivzTtngPDKseruddcunWgTIL8ncufgzp9z4EDBTN65voXjRQiBsEViRU0YRFzpaW7dv0o3zB599FF+7dd+jXvuuYff/M3f5LbbbuNbv/VbufXWW/n1X/91vvmbv/lGV/HI2I1mJO1m1zp5z1Gzo36/e4a87iM5sJu9Vv3Zq7mHafVg9wLAhHCs2ziDXgJSXF1bCCF46xnF6uMDDJUcuJWYnH1bD+GYvoIQs6/53g9qr0Vi4k3b2a4HqPomU3rSbmSoPuztGBVCEJIQ49MZQmqgkNkrtK/roTvnVHxzKEzpw5DqiFNLhkIyApgN7qxV/D7Mk4PNTORZv/bRLxPPM57AlxaNexbOU9sgcKB51WdCCupajYGrtQMzbl9++eVrUY8jaVJK3npaoQpEPvceGKMdA89aNvsdMq2JMw0WB7Dsocd4NY9cB/Gk9OI+K+01Mp25w5RfIdXuAOl7/sHCysUImChYtDuZsYZe3Kc96NKPB1zZXGF5cxVtNIEfUK80qARu0hvt2EJplhKnLtQUcAmggHqligX6cRdjdZ4EbFQhUXD2xNjhUTqAQAiJUh7VsEKrPoPN2UnjYeVJFmOxjjW7hUm2l20OuvSTPlc21ximSclOLYCsacyTXhk2O2q7EZOzTFIlJL5SBF6AkjBfDzizcAwlVQlCjTQHoRZVSt1BJSVh3s9usbElm6uwguE2UWuRg7taY3OgNtNZgWRQ6K9KIbmysczy5uqEVEMxRIvEc7tZcU2R12/attuV7cr0c2pc17cX9+n01+kNB6x121gcaFIJIhpRzTEnc5kA3/eoBlGpXYlgwgGxF3NvfOraLSj/qH/MtrE4TBM2ex1mqg2XOG/LQJU5oFWMpUxnIARzjRl8z2ez16HQptTGsNpeI81SvF1Bm8lL7OR8Kt+2eVsKpy89W58h8AJa1QaVsDIB6CupRpnrrQNmM5NhrKUe1soxkGaOfZtmKcuba6x2Nsq2S7KUOEtyh0wy0d7O2VDIXbgNVubM89DzXSLCHDRcnJnn5OwxamGEEJDpkebsXmusW/tGrOYiDL74njZ6x/E5nmBPCKgFal897d1sp/ILcFGIkV62sQ6grwYRtbDKTL6uHiSpGOTOsBzE9osoA+ucPnESj+ZSDmaW9bSutsUYGW9WF21gmW+0+ORTn+cvn/48vWGfSxvLXNpYpjPo0o+HxGlCkqXOyYG7fugH5RpXAMfF/Y8zUIES7BWIsXB4N37lLiBqsUUUr1pG9xWnMRfWr3Bh/QqXNldo9zsoqRimCa+uXebC+hUGSczmoMtLKxcYJAMyoxkmMRu9zp6gbVFfEKUkQWYMq50+izNLvPct76ZVm0WbpATAVVnedumN8f163OHlys12lZsZfT+PABjruL3W18KJopTbG7rD6VnMN8I8z6PRcAz02267jSeffBKAr/zKr+Tpp5++kVU7cnajGUlbr7fWt1zJZvn9p/RVM4Jeb/ZaGVDXy+pywLtuVizUBIlmQnLgXTerA7OnCnBQ4cDBVI9AlXbsDuGL3uoNOVDvxwb2JPikjg33GtpiqSG4ObjA6ZZLQOSRUQ3gTEvw8G0Hb9PDtEJiYv4A/V3M4cIBcS2jj15vdj0Y5teDKf166+Pd1q35muCUf2lX1v1h2DiQuJMJYakGUI+YcNwEyvVT6Lm6HQaoPy7V0QidXEMh29AMp2f1DjNXz6LVXL0FoyBci7E3Jkpn/HnGWEM/dZERxXO/tqAwBCon4YxJQR01O/Ay8Pf+3t/jF37hF7jvvvuuRX2OnN1zwjXRF85rBql1g1K4EM3ucEA1iFicWSi1QGFvBuDWd3b7ZHEQnTbzc2FKSE7NHUdISZql+CpgrjGHQJZspGnLKw99JbDokiTZMQ1PIQTLm6sMk5h6pcZ6v5Mz2FJWO+s0Ky7RjC88d+jPEpSWpcZeET4c+gHNSo0oCBkmMUmaEAU+1misVJOhuuOHSpFr5eaAjatTvvnlmq/GGnSWsd7dJM5STsweoxJE3HrszD4gozuUZlnG733hE/ytd3wYazUb3U2crmy9BJynIVyanHno5S62ggFlrQvVl1KWDD0pFJlOSdMhnmqWOsDFhaQQBL5PCV0Kl8RrmMaEQYgULpP9IIlRUk4c2APPy1m0LhEa1mmKpmlCFETYnFFWhqvn9yaEIApCTsweY5i6sOPAGyXimSbxkhj7GQXhCOgRk7NmW1b0vajNOYi4n7lkQj0ef/lZnnr1HPeePs6tx+/Dk4r5RqtkIXs5MzXTGq21Y6gV1cjB8sKpkWntMspPIfuQuxfKcVUATwWwLoVEKAdEXVi7zPHWYh5qv/MaULADyYFJYwwbvS6VPEFad9jHkwptNVIqenGf1e4GJ2aPlX01Po/HTVuDpJAAmDSXuMw5LV5cfhUpJHeeuIXAD0ogT+I+U9Q98AKX8FCnbHTb1Co14qSPp1q5HmwBdLUZpnEOFLoUqkrIEvQWjNZGbQ3dQRspJE0v2BYdsA2cwznW5htzqN4mjcgJxBUMw5LFuOWenZyGyR9IRkmfitB2gECGW6416lvI107r2KvGHkyXuWCzqz2iH4qweAEcm5krmctp4bDJgctp1inYLt8hhSTwHPN8o7fJMX8BYyxrnXWklMzVWyVjny2JWQoJB4sDJX3P5+TsIhfWlxkk8QQT2AKpNqQmIdWZc4TmY6nYh0Z1s05ex5jcySUn2NjauPWwmoO41hZA/y7NkC+l4/W1WDqDHv14dBDNdMZMrYlOdMmUBYj8kFatia8c4zz0A5dcc5z1u0sH+J5XJuk7vXgzs415rJVUgwitY+Isw+BT8SMKcRub6zirsbHkllNbsmLHr7lX4tRtDTEmBbTfkCmfKQQ0woNF9Fxve+tb38ov/uIv8oM/+IPcd999/PZv/zbf8R3fwWOPPUYYhvsX8GVkN5qRVFiRofpKx9DNTiDa7vAqrSZQXPOM6DfKblQG+Ku1nZLcLNRdUs6LV1neQfVnr4dNwwauyQFfc1eFjaF4TW1RlwMevEOxPoDHn3qVe+98bW16mFaXAx48K/O67X2P02SZ/3K268Ewv9ZM6ddrH9+oRJUjILGCr3Z2jJ6qCx48pfijZzLSYUyzViVQsNkekUcOA9Q/LP3jKAejtXFAqLVgUZhcNsEg8MX1j9KB0fPMFdHicgdMrnGbGsiMA8ADkQAu+fdRloI6cPMtLCywurp6LepyZM0Tm6yun+NSW3Bpo08nHtDrrzI/c4r33PUOpFCjhEGHZGbK7NFbLcqTtGhjJrQXhRD0h71cezHYNVyysPF7GSWKcuBhqrOSzeMpxUtXXubmYzfTHfSpBB5CCLJMI4WhH7fRpkq9Umdz0GGj1ybyQ5Zm5qkEIcWxUAALjTkA1nvt8gBqcqpUcZAWOHkKF8rtYbEoaTHGMW9LnC9fB0dtgEtQliVgwfNGCVfslsRp4/dtgacuPM/73/JO6lGNWp7BPdMZa91NtNG0as19mUwAaZYix9p9HEAowsmLhGVaJwg7RKmQTNtcf2Uc9rQTQIm1FoNhpbMBWE7OHsMCVzZXCLyAxeZcqTVcsNEkuSZm5pI1FZrCWAi9MG/LnUNmIz9AClmOBd8bJRwqNHT3s9APnLdrnPUoRAlGlne7z7yaxhmhtebTzz7CHz36KQTgKcFMFHDbCcHijJPjyIxG5WCllJJAjthqRfkyB4eMMU7zUYDH9GCFY2jmc1OM5maRtMjNe7h58RRKyD3nacE2LkL8rTX81dOfZ627SeiHDNOYjc4arcYcke+0lI7NLDJfb5Us2CTXPPaUA6y1duuOJ/cez4V+7aX1FV68cp47TtxCpjWpTl2Yj+f6tgRFsQziPu1+F23BS2P+4sm/ohI0efvZB/CVx0a/Q5onRGtWaqQ6c/rWytv2IGuswWjNMBkSTKmrmek0Z617tGozpFkfYyIynZWMwaJdJzstBwvzN3TO+E10hoBS+3PXTsqtn6SOnWsgCII9HXxbbdwpMr5uGJMztfPBkOqMzV6bLN+PqmGFKIhGIPIuqKWTdRATf5fVH3s99ALmmy0EgiSLGcQDlJJYOwPbcy1OmDGmLMvkQPIgHjJbb7LSXitB4sJpUzj1CpkDxt4XCKwZsay10dvY5NZaKkHkNLeFLRm707R6wegtHGZSiBJgDpQq2eyBF5BkCZEfsticc4n6ckZ2f9gjCiqATxGdsTVxYWEFWNzubVIJJLVwASF8usMO3ThhmKTYQcbSzHy+VoCQEq0dA1xKSW84AOHW5sIBkemMwHPyQAdxFogtzJ/d1lgppNN7zyMzbp472lmqPvKRj/Dd3/3dnDlzhm/5lm/hl37pl3jXu95Fv9/ne77ne2509Y6cXc/kITvZeIbqVLtDoSfcQcsQUrfQDK99RvTrbeMMqGuVrOha2NaQ19faFwcBB6+XTQuASbkwtfzCftc7jHKuhU1Tt2IOJ1pQ8UYOiNWeJR3LMn9U7XpIlVwv+Ylr5Qx5vffx9QjV3+ma0zhG5+uShZrg1dhJE40/wR4WqH9YUh2hL1BoUtSILJIfOhzrVuJ7EPnF6XV/28riPjTt7H2qcKOkoKaxA1fpLW95C9/zPd/D/fffz6lTpwiCYOL9j3/844dWuaNgz15a5T9/4vOs9QbUQo+nXn6Jeq1KL0m556ZjxEmM8rxSDxC2swX3IgvuZEXiFIspQYlpH0gLppW1LuzdMd7yEH2lWGmvMteYIxTBthDOgsFTAEgmZ0fBCGACCDy/TECV6oyVbpvbjiu0yRDCHRJVzrKrhjWUcGyiVq1J5IeOvVRMGjFiBBUM3EAp4iwjM6JkDhdh+gWzM7O5OokFhIdSe7eNA9kkVaVKQLzU8dvjqwK49djpXDc0wc9Dz33PZ6Exx5X2GhfWrnDT4sl9+yb0t7Lyij5zQFcB5AEoFQAe0grHmMynqjHZRGZvgdMQTbOcsSslg2TISmeDheYs841ZNvod2v0uc43WNnDDJbEyKOHKURQJqUah0DuOu5zNtdxeY5gOuXnxNMJyIE3kgu1bFlleR4zYeVMA4olOCeXOQFgB8g2SIY++/Ix7Dci05bkrl/jqnCkfZwkir9PW+x2XWLDW0Ol3SE3CfGMBJdWU208OOIk8SztOJ9aKEfvWhWe70lSuIzzx3R3urwD6i98/eP97WOtu8uzFlzi/chGlFMubq5yaP84DtzzI8dlFoiAsmaLOYWGRSJI0IU5TGtXGVAdCgeDBW+7mLWfO4imPTGe5HIuALQxsIQS1qI6nHLv24vplzl26SKZf5Up7lbeffYD5+iy1sJrLbSiwFt8fratFnYvEbcMkph7Vy4RT+428zX6bTBuU9GhWIjY6rxD4d7skbHt8u3AUCVyd1robzDdaJRg63lKToKpbT12CKtdipVzGATaFrYDb+NfGAdbCYWKwDJIhFujFA2pRdZSsELvjWNpanZK5uYP33VdBeU0HKCjsPrNACEHou0SURmvuPXOWd9/5IJEfUosqVIKIte4mvWEfz/OYqTYQQtAe9PCVk5gQokjKZ4iC0K2XORtaKVVKCYw7WYokZ4N4QOA7neODWCEFUg2rbPTaxGmMzuswLgvTqjWR0jmyCsA50SkiFQ443+8pETe+k1zOxGSaehQSeBH9eEDgBySZoTvs06jW8aQbs+Ms4yh00Spr3U2MdeCxNobF5nypE6wO4GQatz2lHvI9NNUplzoZS62jm6Ds7Nmz/P7v/z7D4ZBKpcL/+l//i8985jO0Wi0eeuihG129I2k3ipFk7SjrdsV3GaoFBimdhl5iBN0YQt+9/0bKiH4QBtRiY5dCrpFds4P0LnYUgcujygY+ajY+h5sRwMgB4Uk7oSN5FK2QKtkY2JJFOlu13L10+GOwGFNp9XZW+xDbEJHCQg3uOa4ObUwdtjPk9d7HN9KmcYxeD1D/sPSPW5Hr4y07Vvn/4lm1VRmR6/ayw2RxF+PUSliqOxmb1W4G0scTjiGc2MDV0kKGx9J1koI6qF0VlvxN3/RNh12PI2nGWH73S+dY6w248/g8mwNYbC3RrDk24lyjRS8e0lS1SQAKgSHXreTgDxrGGuIscdqWue0H3I4O4+6np/wSDLJWY5EEXkAjqhJ4AcYYNLoEaqUQYPoYIgI/yEPpzShUvLwOediuA4wub27Q7q7nyWuKEHyLUj71SiNPEKQRxumehH5ANapgrXXsV8iBs5TLG1c4PX+CVn2Gdm8dyygBV96wORDnQC/Yn4052UiWfXDaHdu0GlZY664xTH3m6i2UVGRa5yHCzRIEKRPijHvExkCS/XUOnWmdISUIUSROyvWPtOsPISzWSkQOfKY5a7JgcwL0hn0qYcRmr+0kHaqN8vBegj1CjGnluiD+sRrln9mpsk7rcpDERF7AI88/zrHmgmPQGuHYcrulop5sYHe/xiV8G3ck9IYD4jRmoTm3bzEFaOgpbxsgVWieKqX4v9/zN7i0scxnzz0KwNc88G6qoWMjRn6Ys+F27qPCqeAaxDCMY2x9//E02d6FU2WMJVk6LQxxlpafD6QHOShUAIB7hcoXnyvkO249dprOoMfljWWev3yeB265m1oYOXDWSwk8rwTnBnGPaqjIdEKtMlvKAPj7MFkd211SCxu5dvPIyWStceNzS1tEQYTWmldWLlINPDyvBlbyuWcfITOGpdYS7zh7L1KKksVdAnE5K9HkjEYhoN3fpFmd3XdOu7p6YGO0jgn9JsfnbgYhtyVh22oTbHohmKu3MDlrWhuNtwOTcUJDumSSO/1ZT6oDrVsFw3vckbaTZcYlKJzzZvGkxyAZkmQpK+11jjXnymR6E+uTdREUxho86eHlbNJ+MiTyg13D640x+Mpntt5ycgEWjNaoPRwtUgiQbk9aaM7Si4d0hz1SndGs1FhozlIJIrTR+HnCyXpUweRRAb1hn0ESE3oeS/5ieS+eck4Oa+2I/ZmDupEfghC5BM9wj320eG37KLAWKn5I2JpnvdtmEPfJdEbohxhjqIVVoiAstY+9XP82y9KcqZtH49jdIxHSLEEISS2qEaddKn6Atk6XfqE5nzsbRcnUL2stRv3pKw+/4hEFIVc2Vhz7Hce6DWXIem+DYzOHnzDGOaqdkMi4dMRRtAsXLpS/r6+vA3DnnXeW7508ub8D9svRbgQjqci6PeODsdv18AWWVDsm7hstI/pRzQD/eg2HvhZ2FNnAR83G5zBAoi2ZVSTa4ksmdCRnjliwxg2TKsmX1yL17IFYX9Ne4hCdIeN9PC4PVlznKPfxUbBpHKPX2lF0WFIdG0OBxOLJERmkwIYs5JGqko0B+46Fw2Zxj49TKSWhsIQiIRM+OmcHZ0j6iYvouV5SUFdjBwZu32iM2r3s1fU2z11e5ebFk1QqJ4mqIQ/Xb3eh8llKJariKR9vB8ZWATIkmQsdniacdxT2LOkMerT7XY7PLrpDcR76uqPW5Riw6Zi+ORjr+ZQcq3wyNqoz7vBYgBW5VuQgHtIe9FiaqbpwXqvxlLcj26sIkzbGMkxjXlq+xEp7jeOzi6z32oSez0KziUCSZC6re5zGeFLl2eMd6Kt8xxbKtGats4E2lvVum/lGi1Z9xoUwC4lUEiFGIEPBjDyobf1OyTrc5TA9DrjWK3XavQ4r7XWWZmbxlcJYx6JNs2HZlg67tWVfjANuRdjvfiGrSqkc4NOAexCciQSdWKC1YyMLDL4YAfu+9EhNiqckkV9zAI+x/OVTn+Z99z6MqDV3CXV1AFmcxo7huk8bFtqvSioalRpSSh649V5C3zkKnK7ydMtKUR8lRhnbMa6fXPjvdOywTGfESUI9qu4qLeApj2a1TqNS49TcEql2jDZrLanJHKN7C8O1TO5T9mWhgSpBjJjbe5kL4R4lAxhnyJYAbn4PEtCM5uR4K06zdTiWriplMwLf59jMAjcdO50zBKFRqbu1QeVAVx5ODimBV0cIUTol9rJC1qIS+GgTA7WS/ViAZtvrJzEmY5jG3HnqNs4snKRVm0HlAOhKe41KWCH0QwLP36YbbHHtkqRJriEa8qUXn2GhucDbzt5fYm47XVsgWKhXma/P8MJyGyE9lKhPtOy027PvjfrTV94EoFDCf3lEQlGXTGdcWLvMTK1Bs7o/RUqbkRNhmMYuYeHYdcflRYo1pVhXPOUz35x10hVZwmav68qQjvU67mgqHD1u7iYoFeVrltxzDEglkVYSBRFREOURDWMyJzv1Qf6aJxXNSp1mtY7OAemCGduL+zSiGpUwGu0TkMsS+MTry/TigYsSULJk4hb/trKJrfMk5lEN4a4PYcVc3IkX63tuJiqhWJyZox9XMLi5vdRaKDXEPanK/Wyz30ZJgc7XpigIS0dJWUcxim5ROaAd+AHDRLLc6bHQrFAJQrRxkS2B8qd6iPSVx0Jzjovrl9HWkBmN0CmhH40cUAcwN070NjkgN/ZM7vCTIATV4OiybQE+9KEP7dmGRbKyN+3G23jW7czuNDfdymucmslUjKDXix3FDPCv93Doa2FHkQ18lKyYw9pAe+gcLdpGpD2XvR0rjqSO5EGkSg6rz0dAsctqb+MhVT9gtQefeUkfOU3rwsbX6Z3sKGuFTmPXI8JgGsfotXQUHRarN8lACEurAr3EOVWLU1GgABMj8PYdC9eCxb3TOPWEpl6Bbjyqa6phoX59pKCu1q5q2//c5z7Hf/2v/5WXXnqJn//5n+f//J//w6lTp/iGb/iGw67fDbVunKC8OrPNWxDCw+iEQdxDSo9GpU7kR/uyKAugs7C9EpSQAykiT2xirGWYJPmA9fY8dIItGZpbajHBxN0q3yCEwBPKZaXPD5NSAEKijQU5Bgy7m0LnSa+6wz61sMpsY44vPP84f+Ot7+fM/InyIFskV8u0pjPoMdeYmbh3kdMOhRixCnrDPo2oSuh7REEVxh5cjdUOgJJ5eOyOG8XuzCn36nj7i5KFu581ojrDJGaYDEmyHkJINnsJM7Uag+EyoV8t+7vsAzHZduPsqL2tOKK4n57ynNandKudp7w8W3quuej5Zd+enFuaAGa+8Z1fRyWI9gRhlJTbQvN3rZlwWd4Tnbn8NRaa1Rqe8kdMyKtwETtQ1IXtG2sJvIBwi7OjAKnKpsEBoaEXOGbdls+KnO1WAEmpzvCkolVroo1GF4BtXgNj7ASrtQDCxsFWgHqlTjWoTA2AjJJebRmTY1+XQqDHxsr4Zw/qpHB6pYrQC+gOerS85jYmOHZ0Xy60G6xJwQY5e3bvpH2FZudsNWSYjhJ77V5Xi9ED4iwmTg2n5o7TjwesdjZLtvSp+ePUoxrjyQ/HQ/gFLlGZypOjgeCh2+6nFlVLIMzJTUyGzBdWC31Cz6MeNcAKhCjkQJz26rTj1hibz0yLttpdZ8tXR9d2QF5n2ONPH/sUd568lXff9bYycmC3OWeMRigvZxV3McawMDOXO9VsOd4z49iygQpK0N7mArLWOiBwsTWXv2fce2o0l5yuaodeMkBJxckgLNt5t/YQwjHQhRD0hj2UUtTDGhbrHDeejzW2ZPiW97RDvzgw3xDmie2WZuZ31AsXuD3wWGuB8ysXSHWKpyLH4LV2Yoy4Vnc2PnfHk6DtZLu9PT4XhBDUwiraGJIsIfTDch0Y38+kEHh53dr9LoHvJEQc87a4IHlyTY2SThdeSEmWr0OuuDwOQogJffT9LPADoiAq14DzKxd5y013Ulx+f4b66DNOKmTrN3Knk3WRBNpopLC0arWp63gj7I/+6I8m/tZa8/LLL/Pv//2/f1Pj9ojZeNZtX7l/QyOLAAaK2S44HJ2/o2TXI1nRQezNcOg37Wos8BxbfmPg9hQpQGAQQpFoMEQoe/R0JA8rWdO09nrVtIbJdTrY4XH2KGuF7mdHLcLgWjqKDoPVW4wFJWG+LkgyS7c7pF6rEShY23Tv7TcWrgWLe7dxGnqC0IN+Yun0U95+U4Vb5sQ1l4J6LXZg2uLv//7v813f9V2cOnWKF154gSzL8DyPf/7P/zm//Mu/fC3qeMOsFgQcn7sZi8KaGISl4jktvfagO9WkUUpNYIh7gQOOOVWAvZLL68t88YUn8szyasdFOzMZvif31XgdBxLGD2UFQNSo1Ak96RJW4TQm/ZzvbnMGqcUd4lbb61zZXHF6hFKxUHeH9sgPCHy/PHiXYepSMlNt4MlJdprJgWpPKuYbLaRwsgSBHyKl2naQLnRurQW5QwjvvodRa0ttXigA6qJ9isPAziaFZLbeIvRDenFCP44xuAN3NWyWbMydNvmrMWtdsqwCIFntQy/JE1lJVQIdMgdYCp3H8fGV6YxKGO2biA5c25YZ6PcxbRzLypOKRCe0+13AgfRREE51vZ3v2d2rA+YMq93NcozAGPCdg1LW7P4QMy4Hwdi80kaDcOC3r/wc2LXlOC2/XwJAWzg+1oUF7ycjUNh6t422I1bjRB3H/pZS4CuZi4NQOnFeiynlIXMm5EiGYnu51lo2Oq8wGDi/7b5JjHLQ1xhD6FmWmo1C1aGcR4LJOeUYujaf4w5ozbKYzGQ5SzGlF/edE0EpUrPzWJRS0KhEBJ7T7V6cmaMajnZuJ/sid+43BJsDcia3zZ0fo+9Na8ZqhBSls2MrMzhvIrTW9IYD+smQC2tX6A3beeeKffvWJRB05hifIymUrQD8Tj4q1w6uDp50UQ5KSCwGY025XnlKUatUIZ8HOk8g5nnTPWVro+kOemVdPOnkSna6Owe4jOaVsc6JppSaSES3l4Wez5mFk0jhNJnZhUE64UBjtLcehhWM5ELWIc4SdL5WF/vZXL1FZgzaCGpRRG+wSbu3irWu/Z3zc0CcxI7lbgwGN05VLhMSeD7DZMgwifHEHgnwdjABzFTrrLRXeOTFpzizeBJtMpI0xRhNplPHjt/j+4VJoUnSgdO9tzpnVRefclEWWsc0Io+Kf7QZZ6dOnZr4d9NNN/He976XH/qhH+JjH/vYja7emzZmo6zb7u966A5e2pHoMQiUhGHmDmWL3uobhvFYMKAUjgGV6hEDqh1f//stDtIVf/sz7daD9Jv2phXWipyLX1tQogBu3U8lHJ3IWGgdMTLp9ZYq2R8odvNv/QhiSePr9E5niwyP1hHVCt3LigiDlZ4lUOCTEChY7Tlm9OXOG2+tq8sB7z8red9ZxRn/Au87q/jgnR5Ljen6bmLPthAogRKaQDly0LRj4VqwuPcap+DkEWpywC1zRz9y4sDA7c/+7M/yoz/6o/zgD/5gCdB853d+Jx/72Mf4L//lvxx6BW+kVcM6zUqTQTwoD6KeEsxUQqrhdDtNkiasdNan+mymNcYauoMe//OT/y//+9N/wPHZBSS5Vi052Dn2HSkUnUGfzX5nO6Nvp/pkKUmalIdMYxxDTSlJFNQcK8lCL45J0nxWWBf663AfS3vYw1iL53lkRrPe6/GhBx6mXnVav0X4bVEbJVUZKupwr/ydMXAq8kNCP2Cu0cr1CoFcJ3hUksD3fRdKb0egS8n+EaO/d7Jtm8rEe7szrsAlwJJC0qg02OwPGaSGuXoLKX1S65Fmr20H37pOaGvAWpRwgJNjY8pSPqDov0EypJ8MkGP04zLMP9d9nMZSnZbhyvuZzBnV2poStDU5oLQbaLOvbQlz7wy6tAcdhmkuQ8EkeCuEyCUlLMM02XXsF0DeiOk3YgFqY0ZyCLvYjpq5U0o4ALxw5WXUFJIKmbakLv7RJbMaY+iWMhIHNAFUgnACLCs8+eTMVAeWS5569TKfOvfcdOWKgknY5sJGn1c3h1hbsLzH59HEpHSgllIEntPvdAzMEci2lQk/zqSkLEmQaVuCpVKIiXWksEKqprhvBxS6Ay8CPClKdvU0khcT948cC8+XO/aPFAIpnUROnCZ89tyjDNOMjW67QDD3vkZRPoJGVKNZbZbtVI4LyEHYLY2UO9msdQ6Kov/jLHV6trnDo/gZ+gFSqnL+F7Nk7zZwYyBOE6eTnY+nLAfcldzO2N0JOLU58CqFwO6PR7uyhcRTTtqkWOv2W+cKhvPVWKEvXMyXVKdl/xRJPLMsm6h14AfM1edZmj1GvVJlvtFkmCWsdzeI04SV9joX15dZ626gtYsKUMIlU+snKaHvdOBX2utc2limN+xNVddx+Yunzr/Ar33yd7lp8SS1qIqSHkIWzlRv1zVzmwmPKKg4kD13BBnjwOc47aNkTKtW5XjTf90dzgoTQnD58uUbXY03bcyEcFm3Aw/asQN7QmInnWAAXAjnQk3yrpsVdXkEUY3XYAUDar4mSDQTDKjrfb9v9HDoN+3aWKF5qYRL/pMfL7GWXFfSRU5uHLGpW0iVmOskVXJUNa2nsa3r9LiTqRMfba3Q3ayIMEgyaIaO+VwwoBshaFyEwVFkQL9W2yrbcJB+O6yxMM6O3ckMcirm7rR1uxHO0NdiB152XnrppR2z7z7wwANvuAff1AjqUcggGdAdOsmCNNH4gcT3wv0LAF5cfpWNbttp1W6xImHJCBR2Sa8+8cRnubK5yrGZeU7OLrnkLEmSH3zz+EQc2CmA1c4GkR/SrEwz4ASZyRAZ+J4/wTL0lUeSxag8SY02BmHMKPw5D4ts1Zps9NrUoyqX1pfJLBxvLYAdhaPancAJOwIc8qqU35HSJf3xlJcDajpnX45AHYtFWJivKqSwbA7dNTwhyeyo5F3XUgEFj60AW3Ziy+1khQ5nFAScnj+O7/klOORJByYXYcJXY1vrLAW5eqAqodBMZ3kbCITMJROMZrPXpRpUMMWmb4sy5NSAn0DQG/aZmUJ/01cexhoGwx61UFIN8nBh4RwVQNk+U9tY35gcfLDW0hv0qJRZ2fOPjqH0xhoiP9gfaBKjcP7CPG97MrOdrJBbIAc+rTVk1hDKYL+vcteJYztuBCNXRF4XpUgy48A2KXOmrHSsUDEFC7Yor2TVuum3WK8z1Dafu+5uTQ5ijlPvpVRYoqk0uxxo28HajEo4u6M8giva/T9f5hikmlApfF8yTGM6w+FEmcaO6386Jl/gB6NlJJ/jOYTvgDSTuavYXKZBjEBHk+vhAgzjPnOLTeJMkQfr5cnT7J4Om51MKbltPO40jqSU+Dj2pCclgyTj1bXLpNqtE3vK7IzdQ2Y0ge/WaiEkSTZyVDgtXHffhb5wOe+FKOe/zfcZa906Ekg/7xcnaVA4Igv98mJs7HRf1lWQNM1o1ZoEXuikFaSLEhj10Ohu3PdGMjWl7y6/VyEEcsu1dmsdYzW+8imYy0V9r8UD1ziALPMxN17PahAghSXLdC7dozBYrHUJ0UJPkMUduolloblUOrYWZ+aYyeps9tq0hx2alUYuOeDWs+XNVXSjVYKw8ZROtYJZbK3luUsvuWeIuWNEuaSDNobEpA743kcOpdR4z1/JdEogA4TII3wsBFEdJQSRD/eeOFjSvRthP/uzP7vttV6vx+/+7u/y8MMP34AavWl72das20YoKr7LtE7vIu+486Y3dEKoo5IA640cDv2mXTvbSfPSIp0T/QCal9fbrrdUyVHUtD6IbV2nCyfTfO1oa4XuZm8mXNvZrLWsDyj1fhfq2w9PhzEWRuzYCr7amcW9lDN3zR6Rt9PW7bCSvF0vO/AycPbsWf78z/+cv//3//7E67/xG7/B2bNnD61iR8FCDyqBRz0KeXl1gyRzbCWZpMzVAqq7YLdjeAjHZhY4Obe0+0VGOCxxkvDHj/0Vn3/+cQRw58lb8D2fVLtDm5lgn7rDXOgHzDdaLsv9lgPs6LA+CVBKIfE8x7gp9BAF7lAXeAGrnQ1qUYXA83OW3ugAr4RgoTnLfL3F5qDLZ889yl0nb0FKNRF6aax1SafG2kJIgUv6bUnTFCmVYxfm/6VZShREuIz0Ak84HUqRb2YCx8ryPEnVg3assRSgbQEG7D6JC/DXhUgLhskAi3F6pXJnDWFjDcMkdgfqIMRXHlIokizGk451GvhByW4t+mik0bmHpvEuZqxBa+ukD4TIpSGY6EObg7SBF1AJI8eyM9vBjmk9gp9//nGstXuP1S1WCWts9jfpxppmBYR1AGChw3mQ2y76BkDrrAzHrUW1yQlVft7ZtMB7aWPNsZ9syQi4EOiSHerAqWlZmqneuX47XbnIGC8ZyTbYHJBLTeoSS+0CjEy+XOi3OscHugBzc3B0DDUu1oe13iAvZ/9Os1iqYQVrR0mpdvzc2HwUQlINGyU7Ms1ip+upR44rKUSpjVo4SpwzxBu1mIU4jfG9gDTL8tBzixSWQPouOiAH2OM0BmuQ0oXYp0YRedBPRwPqahzm085nrd08aERV3nfvO/nNv/pd1robrLTX951nRZIrcIxYcG3oKVAyykPzjQOA821Ba41UglRrOoMuSZagpMfCzFy+N+Tzyxri1CURLJixkR/SHXbd+M4ypHSyOdvmnQCsINMupC/wgjx8XgBOb3r3MTp6XU48DDsG9bQM0CTL8L2gbKetZe98bTkW4r+3je+jtpj3OaCd6mzC2SmFkzgR1iCV0+0r5l8hV9HPLJ4X5YC60wGWwiW2XJxZoB8PuLR2kS+88AztfheL5vLmCl//tg+5hJ/dzakB0QIE7w56PPnq89y0cJJaWM3rLAiUc1xAIbtBGTnlGMXkEiejZ4ji59Y1BmEdiH20sdoJ+/SnPz3xtxAuiudv/+2/zXd8x3fcoFq9aXvZtqzbdxRZt9eZq9585J0Fr9Wupa7htHatDtJv2muzaYCUG2mHpXl5va2QKnmtyZp2s639Nl87WprWV2Pb1umzxTr9+gDDxu3NCIPt1jUVPnHOsDGwpd7vbNVy99L2/ei1joWCHbvutWjHUPHG5l/62ljcO9Xt9eb8PfBy+ZGPfIR/8k/+CX/1V39Fmqb8/M//PC+99BKPPfYYP/dzP3ct6njDbLYqGCZdNvouKVbke1hjEFLSTwa02NlzMD6UWrVGeQDfbpOb7Kef/gyPvvQkZ+aP886z93M6T/QlRIC1hjTLSgAJHOBijEv8FXh+CXA54E+PfdbmmokCYwq2Un7IkyM2lM0ZtfWoyqWNZQLlUa/UadWakzeVH2rrUZWlmXkiL2CSC+xMG7NNN7QAJFKjEXnSE1855mMlilzYrOfnh0SBQI9fNi8Xugn4ZGRCYezOAKXDjQoA0QFuwyR2+qmddTxpaVSaJFlKJZxkyubERQomanvQ5dTcElJIVtqrZEaz2JxHG4MnDYJRCGl+s6NKHHBtEbgwa210CUw6bGacCZeD2ULgy0kd5fHrjTNuizbd2laZzviTxz7Fw3e/far6uRB2gac8GpUG7X4bhMjDptWu4M1WR4GxOZvbQmY0WZYS+CFJ5nQYK0Ho2LaHdFAJPB85dVEiT4QnXd10RuiHlDIUYvcH5LKfgI1eh/nmsTK0eieGp5O86CNwwHfghU6f1BgynSIQZWb7bbXM+7S48riNi2cUCYZGsgk5QxOLsS5R24TTh72HrcoZe0UysGkYwUUCNmMtkV8hDWJSbfCVz2y96VjasnDS5KC8dXXHOj3VzX6XRGecnFvK2e2uvCzLyLJsgslaDSsYkzBIhgRKMVt1OqEbA5OHwF3lIWePhinYxUCeoNFgjOXk7BJvv+0WLq6vkKTpqD8K58CWB/V+PGAQD5mpNYBc37RwxLmOIkkzvBx0s9oilSROYzZ6HQbJkNDz3HjP66N3Qqlz1m3oB0T+fM5aLsapq3vxWlFXNzYzpHB678U9SzlaW3Z2WNmSIVyA687hNAL3p2jiCZmiAgDeF7hlZ6mGrWaMYZgOEUKUyUctbh11MhNmopziV4vIs9KOzFMwTC2+7xJ2WavR2iWbLBJtCiEJ/RAEbAw6vLxykWrgoRD89blH+Ztv/wA3LZw8UILCVGd84onPAnBidrFk19py7bH5WuPK1FpjcUzygnGtM02cpSTpkFa9nh9inAPFzU23Ps1UHQOyEwsev6g51jja+mD/7b/9txtdhTftKmxr+Oabdn3tWh6kj7odVXD0IEDKjbJJwH+r5uXRBvwPI1nTTrZbvy01xTUDiq+XvVHW6TcjDCbtcsfp+vo9S8WHlIRARaz0LJ95yTC7Q7K21zoWriWL+7XIQRwFO/Cwe8c73sHv/M7vlInINjY2eOihh/jJn/xJTp48eegVvJGmteXPnvgCpxbuZL7RYpAMiZPEsRyDiCRLHWC6izk9PJfJfhq749QdZFZwz+k7iIKQbtynUanlB1xJ4Ps5qOXAOC9PKPWJxz6JNob33/dellrzgEXn2nueVEilMNqBUL4XjLJbj5kDPVwW80oQUY+qdId96hV36HSHTFEeYK21BJ7Pw3e/jT945JPl4XkcFNwpY3oB1JpCwzVPqOUAvPE6lZBzLmKfg7PWaQEfayhMnOD7IWnGRDj4eAkO1NFIKdjsdUDAMIn588c/S+SnnJ5b5K7TDxL6EXI8WxkjWKcW1YizBN/zGaZD+vGgBBSVlJO0va3o9ZTrQQEIutB4QRz38XKmXdG240WPAyNxlhD44UQCuwIkN5gSgNytMn/97JewFp6+8CLvv+/dUzEKizr5nk81rOGS6rj+zkxWJqIrJS7yMN1MO4AwDAKEFaRZRqffQRfhz8IB7JkxVMOdw8nHCKMHMlkw6Kb4ooA8lL64jgv5N8biKz8fK9utYFwL4ViJF1YvcOvx21Bi68AYu5YQVMMaSRaTJAmZNsxXFalRKKHQVjsnSA7eTsvijnxYasCzV/ogQgrgLM00Ukm8XI7BZoavvPsdZZj7zoH/k/U12oByoA/WIndzTU+0jUFJgbUC5Slm6/NI0aUSVnLWX6Ef6gAkYwybvQ61wCMMfLrDIUIKGkGVQv/W4jRPpZ+HzueguWPWDzFWUA0b+HYwAvmmAGx3AwPHnSfTmAsrB4Xi7jMPEQXnqIQRG702M9VGyVh2euMu0iDTmvXuJrP1GQSOOVwwXZVUrHbWiIKI9e4mf/rYpwA4ObfEO87eT+B5+frsHBWVMCLOUnylCJTnHGYIQt93vWxHrNVxiQO35wiMyQCTA+dOV9qTBk95pUNSCscULwBAL1/TRzIGTkfZJeVyAHMhVVOMN5nPF62dPuzebTq5T0z70OVkDiRxlmCMIchBfqcLm6F1gkXy1CtP8NjLT/M33/E3mW/MYnAs2ZEe70g/OTOFe3Gr0IOLODHCYkr2qmtcpRTCCLTWGJuhpGKuMc/XPvAwv/vFv+Di2qUxR8iIab513u+0DnSHff4sl1r65nd/DWcWTkxGJeTg/7gTB6V48cp5VjtraGNpDzpc2Vjhax96P/24ixAZgRdSDWsoAX6up25MkXBGUvVtGTo4VztaD8G/+Zu/OfVn/87f+TuHdt12u81P/MRP8Cd/8icYY/jABz7ARz/6UZrN5qFd441iRxUce9NG9kYLh57Gjio4ejVAyo2w1zvgf9hSJXv1W3tomVfr+LX6oQLFb9rB7c0Ig5FZa3nykkGjmAuLZ0en9+sraA9hOZufikBxUHsjsbgP067KX7C4uMg/+2f/jE6ng+/7RNEbU+Tj8y9d4NGXnme12+P2E3fQrMxQiaoYY7m4vsyLV17l7bc/wEytUYYoAuUxONVZHlo/HVtmtt7i4XveSZKlXNlcBWCYxlQC174FyzG1aXk4vrh6hfNrV5ipNvniC0/yFXc/RC2oIJFI5Q6T1li6cY+Xly9y9sTNE4ylAlzWxpTMVyEFC815ZqoNvDyEtWDnSCSB52OMY8LVoiq+p+jHA6phZSoGlBCC0AvI8kQ5jlhnSbMELwi3xn2jbc7+stDpbfDsxjOcmZ+hFt1MPUi50G5TiZp4UpVJu0oionBsRZMzby+tL/PZc49yfvUSzUpA6Fd5Z63p9GGNBSQiZycXwftRENCqzWCxDIYDjs3MO11Hqcr2Ke8Ngdny925WABvWWjZ7HQLfJ/QClJRI5RMnMaEfTYJEOVpVMO+EEAR5mPNMdcYxqAvgymgCLwAsne4aM405d9TPy8t0xpdefJI/fPRTnFk4znvf8o6pQCnHssvHg5D0Y5c4JwocW1YKgZXuAc2NHQf0DZKhY70qidGO2ZZkLuRaoljrrnNl7RK3nzrLfKPlAKFDNJ0nUDuIFcl+As8Dmye9KrGU7cBJASYabbiweplX1pax1jiOm9392sZoAi8k9CPavTZSKuK0T+BX8aVXshLdNbaw5BlNGQFEHtTtMg/fc4LeoMdfPnuBucZpPM/pxXpKOaDUQpavNUJYWrWZsVG/+9gViDK8+mCSGIIkc04fT7mtZ6Y+A/kalGQpm/0OWEur3qQSRDSrdXpxj9W1dbRV+bhwbFmRJ52zWCQyBwkdizNJEoZJj2a1mssBOOA6Nc4Z5EtId4ict7me8TiLOMsyJ9EiPUwOfBb3fxBrVOrcfuJufBWUa5LOknK1UELh5YnPAi8g8AIyo/N6AYUrxmo2+h0qYYVUG9a762x012gPNnnwlntpVmeohVUshkvryzx78RXeecf9NCtuPS+B1fzKDsx387aQZykWAiEU5LIsUgoynVAPINGeS95hLWnOdM6M20eECJBC5vuKdmNOeghccjpjnCPC4CRlhBD042HZ90s5S/Sgc3U3K8aotRakY3ILBEmWMogHZDplth6y0KiyvNlnaabK8Yc+UMoJOcdAgMl1t421DAZdLFCLKvl+Iyemt0sy4qQmyiVVCOfEtU6nt1j7ERCnQ6Ig5F1n7+d/f/oS881Z3n/vuwk8j5dXLhB4AYvNOecoFpQJPDOdOgBdwJXNVX7pT3+T0/PH+Ya3f5CZan0iMeJkhM1Y+2CZb8ziex5/+MVPcqW9zGJzHmM1IInTDKU8tLVkaUqmJb7nxn+J/UrQqT2SoYM/8zM/M/H3xYsXCYKAM2fO4Ps+L730EnEcc/fddx8qcPsjP/IjvPzyy/zH//gfEULwoz/6o/zwD//wtvp8udtRBcfetO325XSQPmxw1FrLWt++ZufEjQRSrsZe74D/YUmVTNNvmanzt28XbAzl6zaM+41gr3eHw2Haet855T2ybfcrhKDiWzbjkPUBzFUP//pvFBb3YdqBgds0TfmFX/gFfvVXf5XVVQcuHj9+nG//9m/nH/7Df3joFbyRttLt009Szl08z9MXXuH4zAKelGTG8Or6FfpxyvnVK7z3noc4OXuCKIxyADLFV34exrofkDli4oUeCBkADthMsoTVzgZLrXnHYMwZnlY5HZyNfpsnzz/H1731g8w3ZkvG5SCJQThGru/5efZ2yfHZBdr9NlEQOo1EU4RQS0LfMYcLRtl4Ap3ikG/tCCiSUiDxsBbOLh3j0898jvfd+xUlg2zr/RrrmFdlyKdwoPQg6bHQWCTVmQMGjM61PseZRuR1jVlfeYJKRXBhM+OEsmwMO7SHAyqRY7GMQnXJD+cJvvIYxEP+96d+j43eOpl2EhKekNQrLZRUTrNRSazVCG3w/MDBFTlbbJAMsNYwU2vmoE3OwxwLIXZgEpOHZTFJyB03nUtaACX4UYyXArjZmgSpkBootAVdcrJNoqBCkiVODzNn5zmmt8VajfQ8AqmphR463uTO07Pccyzkf/sBL1w6w3vv/QoalVrJSttVt5ScKZcDSkoq2r0VlPTxlJeD52Mh1nmfGGvY6G1iscxUm6x3N/iLxz+B79cIpEerHpIkPS6sruN7GQ/c8hYM25l3+z3q7iVHkGQxSZoyU5vBMl3otMWSZCnDJKZRzdnvuXMgyzReLutR9JPWGiss3UGX5y+/yHvf8m4HAO4BiOe8RIzReMqnUW1QCQxpuwumSyVqkGc+mrifQndyBLNqHjrt8eApyZe+dIXLneN87mWfxdnbRixKKxDCsbCHScxGr80gGZbOl0pQcU6BKRP3SSkxZjcpmHEWp5P+AFGG3m92N2nVWyRZymp7lThnNYLgyuYKkR8RBRFPvvw4F9dX+dAD7yf0g5LN7CnfRQ8UcxGBFc7J0x92ODPfoFGtsNoFbSSJzn0zuHD/QAnibMQ2Ldnq+ZKcZhmZznjuwhO0qj7zM7fj+w4A3n1N351ZHXgexoYEXlDuE+TrgwU0Jme0KnLC66jfsEihiLPErd3a4IWKZqXCZm+DODM8d+lVXl6+SKMyQ+SHBMpyaWOFTpxyeXOVd569n1Nzx2lW62iTkWSZY+gaF5FQ3HOQr0MFc9xa4RizRnNh5Rxvf+tNfOallP4wIQwiAs/tdVIWrFqDVDIHF005Tiu+ohcP+PTTX2Szv8HJueOcPXk3g2RIp9/B4jSZO/0N6pUGwVQJQPfn3xf9ZKwlS2KXiM86R6Ws1MiyPrcvztKOQdCm1ThNNYhY77VZ2RzSqs/g5/Ivg2TIameFp155mkjBu+5+G56q43sRSkDkCYyFVDttciUkWQ58O+BUlhrgro9Fuad2Bn2Ozx7j7733b9GqNWnVmxhtON5aZKPXZrWzzmJzDild0kIpJRu9NkJKhknMHz/6VwC8/953MVdvOqeTNTs+5OWrZOnkaw86RH7Ie+58gKde+aKrT3+T2fo8qR4QKFWOxcwYbCbwMLlmrpMvUlIcydDBP/7jPy5//7mf+zkeffRRPvaxj9FqtQDodrv8y3/5L1lYOLww1H6/z+/93u/xK7/yK9x3330AfPSjH+Vbv/VbieOYMJwuue0b3V4vzMEvN9sKMs6OdcOXw0H6sMHRyx3LU5cz1vvmNTsnbjSQcjX25QT472bT9tvG8PUdxv1Gsde7w+GwLM7c851k5xwRSoJFkBxBp/0b1Q78mP2v//W/5s///M/5/u//ft7ylrdgjOFLX/oSP/MzP8Pq6irf933fN3VZL730Ev/qX/0rPv/5zzMzM8M/+Af/gH/8j//xQat0zWyu5hhNxlqalZB2f5MkSQiCgNBTdAYJr6xe4jNPf5r7b7mb24/fRZwNMMYy25inBG33vEqpWojFQwpBFAScmFskThM2ex2WN9eYqTVyNqZiEA+5sHaJF6+c58Fb7ybyI3rDXp6cRlGPqg7MyAGzzV6bYZoSeF4Zfuv0bt1M83P2m82lBiyWlfY6gedzbGa+BE7Ha+zYh+5h5tXVNV5dPc+npOCtt7+VShihxtiSBQsWiizorkUurV1A6yELjUXAlKBfph1wacqWEVg75NXlp1jpD7lj4T4CPz8sy4Clmao7iI7JNRRt7pIcOXbXXH2Gjd46nnKvaWvxxjR+Hdgo8CX40jF9e2mKkoq/evqLfPD+ryiB8OJ+zDgYjdMQNkYjpZpg5RXAkECUaG6WubJTnTFTazgd4pIqnANK+anegVMCMSbNqXVGqtMcZJM5YJqQZEN6vTYzjQWkFKRZTBz3qczV0BZS63OsIfF9xc3zLd559gEiP6TT7zLb8Ett3YINV95DiYbmGonCeYKVzADLyuYarXoD3wtyNuqI0e00I0PCICBOU5585RxSSrr9NoMkoTN0J4NASSp+wqMvfo7js7dwcvEOikzsRU22zqdxKYm9rDvsYY1Gm3o5LnaS8yjKNAUwai3L7VWUUoS5M6OQC0GDr/wcfLUkOmazu8azF1/kntN3UYsqJVDjF+HpY2Oi6EsHkor8d0knlgRehNEp2gwBgVK1ETBdAKLCjYti/J6egY2h4JV0ibWXDMZIrHXyKm48SqSUdPpdVjvrud5syGx9Jncc5JISu2S33Wrl9Xc4wBTrhsoT9/lqUvpitt7K73ckXjByuzgwKvIDIGOhUacWVcsxKeTO/W1MhtYDsBnV0MeXIIUhszBINJVAjV2n+I4L2ZdilIwr1SmdXhcpBTfPBbQHbZcgUEgSneQs8cn5UbKed3HWWKST2RASbZ3GrSmlTYq6uLWjEkQ52C/yQ6NEG0N30MvBMgcA9uMhUkBiLAhLqBRrnTXHBg0DfOVKPr96ifOrl3jwlrt5/73vYrPXQUrp1ne38AOOha9kkRyvcE5JjEl49eKTdOJVFuu30um3mW0slP0P5DICCislSZJihcl1Ud0dNiPLq8vPsdJe5aHbHmBxZoFKUCH0fSpBxGa/Q5bFxFmCF8dTAbd7BQiMv2et5aXlV2lGNWYbLSf1YDKUUAivSjt2Wa5bkU/P+HSGHQJPMkyGLLdX8aVHNaqx0dvgk098El8pwlCytvEMrfoxMn2CKBAstBrEmWW1a9EFG55il3djVmvtojKs00FOspR2v4+nAmaqdTzl9nhjDNpqQj9gcWaO5c01VtprtOrNchwp5XFh7XIZRXJsZp5TeeK7gq1tcomHcTOl1IiLKDDGkKQpx2eP0Y9v4sr6BT5/7jEevvc9LDRmkEJjTIZSAZ50ckX9uMNcMkMUePRTwULNhQ4eZfvFX/xFfu3Xfq0EbQHq9Trf+73fy9/9u3+Xj370o4dyHSklP//zP88999wz8brWml6v9yZwy8HAsTft+tlOIGOrIvC+jED0wwRHu6bCZ17SJFpQ8V67c+L1CqR8OQD+e9nrtd++nO1Nh4MjFCoJ2S5nQm3cCTQ4gk77N6oduKl/+7d/m1/4hV/gHe94R/na3XffzalTp/i+7/u+qYFbYwzf9V3fxf33389v/MZv8NJLL/F93/d9LC0t8Y3f+I0HrdY1saWZOqGn6Mapy3aeb+Cp1vSGaXn4X+n2eO7SeU7P30KZdGXMHINth9e3PZCK8sBvjUsYs9CcZb27yfLmKqEfEQUhf/nkpzl38UW+9q0fdAfeXhsl8xB9o2n3O5yaP4EArmyuYHHakqnO2Oy3qYZVXIZyL08QJUogtgixd4y8IaXm5U5ghHDAzJXNdYZZxmeefYw/f+pLfNM7v5r7br6zBL/GbVxf96alm+kNuu71nKkr8zBlIQwKGGaOWfRnj/81y+1NHr7nXWQ2ZH1zk/mGAwOFUCipSLI0T5rkgI4ii7gAamGVDz/wldy/eSePvPA4yxuXqEYhlzZX8kzhHkrYPAGdzr/ndEAd2Ow0EUvwtYDOxFg/5ixiY1LqUR2JO7wX2oZFQi6daXzPJ/ACUu12aRe6bil1hLMUgChwbE1tbcncNFaT5OxEX/kstZZKIM9Y8FSNZrNKqjN6/U086VENIkLPwxOwEis+8+KAV648wcurA+Zbd9IZ9EiylGrkNJzjNEFJ6RJGFWixIAdqvRwIEGAsp+bP0E9cEq8rm6sO9M1lJGpRldB38g+tWrMEK99+9gGS9HaeeOUpnjn/IoEnCZQisO4e7z+zxAfvPs6fPZcgx5jHO3Ic8wMfdnJOjRKJuTFXCULa/S7r3U0WmnMTYMYIpHVs0yIsWghBnA5Zai0Q+QFr3U2qYVTqYwLE2ZB2v0/kB7x4+RleuvwCd515iCgI2ehtMleXjmVpMhAyDz+nHEuTrG13l9pCJWy40Py83RFbHQCjOyVnw//lixnawIaez0tyLP1Ea5SDUhF41KIqm/1NpPBytr5EW0OcJoTB3hqj44DYMI3xpTcGDI8+4xj2I2b6ZBkjh4eiYGtOBnD7no82Bms1zUrNhc8XEQDW4gQoRm3ovpYwSGIiT6GN5aWVTeJMEPhVljsJntR4MkBLhTG2lCtx7FfHUk+zlJXOKjO1Gdq9No9fvMQwzXhPU6OUxpOei1TIxbdHToORa2EkRDC6HyksynPJFI21KOVhcwdAIVOQGU2WJrT7Hfym7/TAjXHM+u5mrs9qaVYbXFxf5tX1lfIK0kIt8lGpJMs09TDA96rUq4phGrPSXuXi+jKDJHbOtJL56XS6ZB7RYYwhy3oo6btw/GyZJL7M0+ef56vuu5PLm10QqgS6y0gMMcl8Xu+uEXoBgRfRGbR58LjPZwYJH77/YZQXMkwSB85aJ0fje7OsttdzR8+o5YoEiztKDlmNsSDl9kcZseWP0/PHkbl+spSSQDrms0RiTcw9pyr8dT9kMfBYExm9OMFTApPvf8NkSLPSoF6ZoTPY5MX1PivJK8zWVnjw5hCl5hkkGZXAIxQxKM8lLMvXfmFNfi9uLZdKYo0hyQYgYLbeBAQbvQ4Fq9tCKbnUqjW5tLHMcH2ZSlihEkT80Zf+kqdefR5w9/c1Dz5M6Of3lTtCrXXJ+Ebsbdc2hQMyzVJm6zMEuWP4zlP3sjhzgj997K/53LnP8XVvfQ9SROhcWz/TmvagQ7ffQwONqEar6nPvicNLJHmtrNFo8MQTT3D77bdPvP65z32Oubm5Q7tOFEW8733vm3jtl37pl7jrrrsOfB29a3Lbw7fiWuPX3PraYb231ndMJg/3DFRGS+VrUuRBOw5Z7WoWGuKqrmGtZbWr6ZgqK52MVuXq63092+ZG1a1rKnzmRU2ineSST4IvHciYpce5uJFxovX6arerKWeQyBJkm3imzH93W79gkGh0KHYt01rLcjaPltAMRxE9noRGYGnHzjmRZSOAeL+6eVIihQNSdqpbph2Q4gmN1nuXeaP75ijX7bCv8Ubqtxt9/etdt5nQ0JB9ZkJDkX/8qNTtWl+/GUpmIrgw8DDGjoKhc0JeP3V6wM2gsu+4fb22zfWwg1xL2AO6s9///vfz0z/90zz00EMTr3/pS1/iu7/7u/nkJz85VTlXrlzhYx/7GD/+4z9OvV4H4Hu/93tZWFjgR3/0R/f9vtaaL37xizz00ENXpTc4jT15YZmP/s8/5LkraySZpuJ7pGlKrC1Jpp2KnYBa4MCtr3vbBzgxe4w4S5itz07IDEyAC6UVD6ru9yRL8vBfSZIlWOuSd6VZympnjXrU4MLaZY7X1rhp4Tivdpr4ShB6kn6astHtU69UqVUahDlbKTOaTCdsdtt04iFYy4nZY6Ueqac8J+lgRwe5QRJzZXOFShCy1FosQ6bd++7Bo0jQMkyG/O4X/oTlzcu0+zFWwH1n7uLr3vaBErAubCu7sdA6LBKUjRYESsBHa0N32Oc//eEv8zff9iEWZ+ZZ624CEPkhi805pzWrFDoHPAv9TPLrOzadoN3rIKQkSRMeOffXxLrHRn/Ihx/4ECfmjuN70klh6AyLV4JP2mp6gza1ygxZluXg8OheTA70KamI0w7gEQYVyBO5dQd9LJZqWMVTXglQ95MhxmpqUQ1jDGmWEfoFWOWY3p5U+L6P1k7awlMSa2OMFQjh5dIU7jCdaYPveY65S5F0RzvZDCEIPA9fQTzs0teWc69+icVmg2rlZpY7G2hjqQQRC41ZpHRArESMJQsq2M/5g4bJyLIhQkik9BkmMcvttbxNRv1+vLVI4PkkWUJ32CVJEqTyWGzOoKTk5Usv8Z47FrltocqTz73AvXfeyltOzACW//lnz9D2bnbMwy2wrcXiC4PBY5Qx3VmmMxemDU7yA4ExQ7rDLuvdPs1Kg1Z9hvFM9tpoMp05RqTReMpDmxRrhi4UXNUZJkPa/U2alQpaa5RSDJKYODNEfshfPf1XKAFvO/suEp2SZhmRHzBXn8XzlAMahRuf4+N9kmld8gRL0E7licQK9q7NObGOpV0kghJUfBeSvjl05RQuhixLS1apyOfzSnuNWljBV45lXTSfl4OF4S5Josbn9Eb3AsZKIr+OUj6BH4zWvFzaQ+7AanbJCV39LfDK8gW35uXvSyGYq8+w2l7ls89+mpsWT/IV97yvBBm3WrG29IYbCAxVaekbQao1tbBBkgyQCgwenlBUwipCWNr9Hp4XlCCkMYY4iYmCCITINVAztEmohXWG6ZBKPo8lEs8rmNJbuZ929LrNpRk8QZIZtBXO2aaclI3M2yvOUvrDPp5S9PvPg4ho1k4zW69R9+HJC5fJrKQeVRimMX/4yCd5ZeVS2WaBkizN1FlqzdOqznLzsZuIggrGOgma1c46n3/uMd52270cn11krbvJ8dYioR84uQvhtGiTLGEQd5ipNun11ugOX+TiRhcz7PP/++av5omLXV7tLOTawaIcyIXjjzz8fq2zRuAFJGnMK8vP8A0PnuHJK1WqQQ0hnAyFlJWc6W2wSOIkphFZql5IO3Vt67SpGUmvFC1rLa0oIzWSQapKCRldyohsd5QmWeqS5AmJUs5ZkKQpN892ePdtp/jjJ3ssNCOEFAySlPV2HxXUSTUkmUYKyZXNK5y78BSXll8hrFTpDmPmqi2+4t6v4HhrhplI0eu2qdaa9BLIkgF3narSHlhe3jBo7eahpyzDQZtOmjKINfMzC8RJzIX1KwBl36Q6K5OiXd5YIckSZuszXFxf5jc+/Qccm5nnzPwJ3nPXQzSiGr43CWKP1mJb7lvFOmJyTWfByHnV6XeQ0mOQDOh2X+bkrAeEnL+8Ss9GLMws5ZrvEPmK/rDLML7Ct37FWe44Pr9tbh6GHdbz3q/+6q/ysY99jG/6pm/innvuwVrLo48+yu/8zu/w8Y9/nG/4hm+YuqzhcMjly5d3fG9xcZFqdUTF++///b/z4z/+4/yn//SfeO973ztV+cU9v1GtY6q8kp7EJ2EnvN9aSAk441+gIfsHLr9rKixn8wxtSJEmNRIxi94qdfnlw5ia1qyFF9PT9G1EsKVPrIWEgKoYcot/fsf+eiPZwIS8mJ5GolFiO0NSW4lBcYt/noqMr3k54/ZmP70+7fXab9bC0IZkKDw0kYiPVP3etGtvXVPhfHocjcIjQ+LIABkeHppT/qU399RDsmmecadi3F64cKH8/du+7dv4wR/8QX7oh36I+++/H6UUzzzzDP/qX/0r/uk//adTV+7YsWP8u3/37wB3oPr85z/PZz/7WX7kR35k6jKutdXDgJvnZ5itRTz56jLLnR5J5rLSR4GXAxOGWhSQasNnzz3Khx98mJlK3YFmWuN5LjlZwWQFxkLQc41ZJGDKhCNWWKe7ajRaa3zl06q16A37fPH5x/m+r3+QmxaOs/xsghSOkRd6AY2qolltToCKSkqUiJhteGRmlcy4BECh75KDDeIBzWqjBDd1zthV0tXZhRFTHpzHQ9KttfhewFfe9Vb+8NG/YrVzkcVmle5g0+n8ej7koNJOeqLa5GxfbAmgFSHnozBdwVOvnuPM3CKz9RadwegBfpg6oHC23kSpiquzVAyTeIItqvIs5jPVJolOCD2fs6fv4vPPfZZTs01WVp5hvjlD4NVJtcVaBaIA1TW+zKhFtRz0cuCZQefalGPZ7ZEMBlfwxID17oLTwxUJw3SANoZ+3EdJj3qlzvLmKv/7U7/LW266g696y7uI05hGpeZAYVkwMk3JfnbAigtfFkIi7BAp/Jwl6gD3IA/FL6UDhMBTCmtBGwdkDjNIbICxKTctzNEd9El05pLFmcwx8zprLnQ+B5kdc1nnUGHOGtYZSTJESkslUFg8Ij9godGi3e8RZyme59GIqjmgHbPZ38z7GCpBROhHCKG4/fRdrAwFq+cFKryTZ5Z9lnuau5cEdzb7tGsJzywrEP7Y6DH4dsjJ2TqD2LLct3ndNFhDph1TezzJkZQB1bBBP9b04h6VAAwBkV8h1Sn9YY9apYGxFt/z0MbQ6XeoR76rtdVEfoTfMPSGA+LEsVPrUUDF+Gx0VrFmgPSbSKnI4gFKCrTJWO+uM99oodTWJVcgxCTIhxgf/9Il/tEpUjoA32Lc3LIFgKUpgrKDkeJCzrADrEtqaK0mMwZpBFIq6mFE4AdorcsHMSVcX3X7HZZml0agsB0xSJUczdWZ2jw66/Hpc19iZXOd2VqAwSfRitD3uf34zZxZOFne7YRWthixq4pQ8CRL8T2PmWqdNEt48eIzLDZqiFxP262fI4CwWCOKcqphjVZFcHF1DVREszpTvq+kxZiEc+ef5vaTC5xZOMNKJ0NbS+S7BJDGaKpRFWsNK511eoM+M9UK9ahO4IdkOqU72EQbgRSCWxZmaVYC1rsxWkT4EoYFzX6MES2li6Yw+bwOfZ/l9ioWmTvBDJnOmK03afc3USRgY158ZZm73vlVbAygEtZIjWZ5c5XPP/8YF9cuoaRgoTFH4Ie0ag3ecftdHJtZQOVa6XEWs9LeQBvDidlFvvqBr+QLLzzJTK3JXH2G3nCAr7zcoeQcQINkyEytSZIlPPvqU1QiuP/0Mc54KY3qLN00LKMP3DplXVh+zvKU0t1TJajQGaxz+fIzzDSadNIlmtU8akGECKnJ0hjwAQXWRTVUQ4WxTuLFyeHI0qk4vv/ESY+gUcEzHoPMQTOBB4NUww5hXUIIfM8nzRIQlkzr0uk3W/EJPMd4yYyTykk1aFmFPBRMG6dfPVNtcO/N99Mf9Il1n9lahVdWLhKe+xx/770fJNEOcEoN1MOUXuc5jtVu5e1nWjy7rPns8308P8KTmitrA6zymKk1wdrSKQmw0Wuz2JzDVx6Z0bncTEA9qtJPhry0fIH/691fw0Jzrlyvi1k67kZw+7pj+o77Ftye4Bw1mXYOyWGS0B32iXyPelSlHt6M1ecxps9TF15mYCWr7QsEfpU40Tx0y3GqgeGF9VV+71G4/dhc6XQ9ivYt3/ItnDp1il//9V/nV37lVwC44447+M//+T9PRJFNY4888gjf9m3ftuN7/+E//Ae++qu/GoD/8T/+Bz/+4z/ORz7ykalB23ErnrOvh2mtefTRR7n//vsByt+VUof+3mYsWXlWkwwzZhuOvNHutGk2mgghSDJLuzfgnjtuY6HhHegan3rkHOv+7RgJTQ/6PedIGWQVzsc+77+rxonW9GVei/s/rPcOq5z1vuWpJwa0ahGB55IuFv0BsN7uQtji5jvmmQnN66LdrrYcKSXDZzUX1oe06hFCMNEW7RiCZIN3PnAHQohdy7zUsbzw9JBWo54/A9iJMW6MZbUz5Kbb7uB4Y/dyttb7+EbGJ57uIcImlbHxPcygqWA2fZUHHjjafXOU63atrvF667elW+7j6WXBet8yGA6pRBGtCpxqwuULz3PPHbfRqsBjjz32hu63N0LdXms5n3rkHGn9djYGlGNhqSq4a9Fy+cXBG7ptrocV15/GpgJuP/ShD5XsleKw9l3f9V3bXvuxH/sxvuVbvuXAFf7Qhz7EhQsX+OAHP8jf+Bt/40DfvZZU5uPNGrcdm+W3v/gM7X5MqzZL6IcM05j1zhq+p/Ck5HSrQWoMG+0NHnnuC7znroeQcrYMc01MQn/osldbNI3KTH5YSonThEalkR+gHDDl5AskQR62KoRgrbvBnz3+WYbDVT581610UoknElIrCWWVQEkCf3tSqSKk2lcec40W3cEGWEF32KPd71ANq2WYc5olbPY7aJOy1KxSnPKsMax2lvG9CjPVZsl8ElIgLcw1Fvjah97H737uTxkkHTb7G1xYv8yZhZMlgLgtWZkxKEkOWrkkWiY/mDsgwwEc/XhIvVJjmFImERu3YRpzeWOFelhjYWaWTGfE6YCZWitP8jNCsZRSVL0K1hpOzS1R8+4kVCmfe/ZFTrSfwxdnQDUds1EbkjSm3Xc6l63aDKF07VgAWYl22qEAvueR6IxPPfsM1gzR5kW+4i1fQTWIEMRkWhP6LkS9P+zz1+ce4Y6lFknaRWBZaLQopTJy0KcAQIw19IYdUmPxVUCn9xIL9TqVarMEbaUcsZYndVSLgSDpxM6j70kPIRR/9NizrHXXec/dDY63FukOu4RePg5660jpUQ2qbPQ2iOQKJxfvI0sTPD/CeIool0BQ0rLR6yKFoBpYQr9BP3Hs1d6gi5SSdq8LwiIR1KIa843ZCeDOQSOQ4ZFmsNI1fGYAs6bCw7dVuX3B8qfnDEk6pB6FNCNFp6tZ7vR4eXWTetQiCkKMdSxtKZyeaNEUhdauFIpWvcVaZ4PN/pBKqLjSu4TF0Ky2cu1b7fSl+x368RCLoFltIHDan1LWqEU+xrSxCLTx6SdDPvXMI6RZzPHIhfAHngNc4kwT24xhegXf82lENRrVBkWCooKhOOo0m4PlIj/ADrAmRtoqnhdgdA+jU7I0ww9CB+BLD4FlkEpIR31fjgQhCD2fwBpSJ0pEq1YnMxYjbc4uhmHiAGyLYZAOqebJyopw78IBY7EMk5gk7aFkwO0nzvLSlb+kF2/SCH1eXN4gMRZfCU7NHy9WogkAeNzBFAUhp+eP00+G9OI+q+1VXrryPBfWLvOBe28nDJp58jYni1JKRpS0ZYMUcKwZ0I010q8R+hXAorMBSdIlDCpIGXFm6TZeXnmOB09HfOaZLxLHmrlGBALuOPEWGtUZ2v0NusPUfd9kDJIBvhdSjepsrndJtQYLr25AZxgSqoB6JWG1O0Cqesk2dqz3jCQTJaA1TGLiNGauPkN32GcYJ1TDkGq9QW844PLay9xxLOLZy6v42ZDnXn2Ex15t88zlDeI0pjNoE3oeZ5dO89Dt99OqzeCpgFpUQYkRIK6Nc/otzsyx0l5no7dJqzbDTYsn+YNHPsk7z97PQnOOYZoQ4ZIaxmmCsZY07XLnguWMrfPW++7lZKvBpx99jj95OqaXKqQYC7sXAk+4RJBZliClxFce3d4lQrFCog1nlt5CO/ZK5rwQAiUkMvTyNdSNVre3KI41YGX9RV69bLn55J1IMf7wZEnSISbrI0WDoR6N9jQzuGRqO4OHUgh85RNnifs717H50suXOFaXREKwOfDpDnto62R4hmnsHHN5crjlzVVatSY3Hb+DP/7SnxP5ilQbVjur3HssphZ5fOLzz3O+Yzl36QJXVlf55CsXueP4PF/9lluJhhdYjo8Taw8jI4wxnF+9zFyjVcoRwMgx2ao1Cf3AOaI8j0vry7xw5VUevOVuqkFEnMZ5IsqRSMfW6IQiUZwxOo9MSUizmGrYwBgXqZFpQ3fQzYFyS3fQJwxCnj2/SS0wtOOU2aZz8l5YX6EqLaGax1rJ8Zkaz15c4eXVdc7MzezY9q/FDvM576u+6qv4qq/6qtdczrvf/W6efvrpPT/zi7/4i/zkT/4kP/ADP3DVyXuVUtft8DB+zd2uf1jvLdQls1XDq8MiAmVSVmeYuRDM+Xr9QNcowtONhGbkyhrkEQ++sizHiqeXBafm5NRlXov7P6z3DqucLI/a8dWktFHxu8RgLGRGonLt9KPebq+lnLecgMvrmm4CFd89lmcGBpkg9CyzZhXPW9izzErgngW1BbWlTYVw0SECR34Yb9P96naiBaf9S2S1s2wMbOkoXKhL7l4SXHxucOT75ijX7Vpd4/XUb11T4ZXzkGioeJCRIETE+U14eQOkOc3qC5T612/kfnsj1O21llOXAx68Q7E+wOn93nEHC3WX5+byl0nbHBWbCrj9oz/6o2taiZ/5mZ9hZWWFH/3RH+XjH/84P/zDPzz1d6dFqK/WXnrlPL3U56sfej8LeVi+Nprl9hqfPfcovd4ql9Y3qfoeka94efk86+3LLLTO8PY7HsJTHoNhrwx3Dv0KG702j774FLcfP8Ox1kIZ2j5ijhUPlA7i6A17/N4X/oLVzhr/171nePrpJ7AW6v5phtRzbVuz5wArkkNt9iDyAy6tX+G3PvuHnJxd5NTccd5y8z1ObkBrQk8yTDSVsEKaDki0JvCrREEF6RTUXe2sRWcaJMzWZnj4Le/k//3M7+JJyWef+Ty1qMpMpeGkFsbq5oBP7bRsESjlilzrrCOwVIMAaw0bvS6pFczVZ4nCiCwPX091OnFvxloGWcxGr0N30Ga2vgW0ZQRgO3avIvArdDo9Hlu+gBSCx55/mmp0kfvv+Ep6cUKcJSRZSiUIma3NltqzRUi1Y3f5pFlWZra/vH6F1Y0rDFPNZpzSTf6Cd9/xAHONWSphhUxnXFq/wheff4xXVi8RKMVsNCD0PISQxKmTyijYzo6p7No7TmIqUZ1X167w6Lkv8p477uWm6i1o7RKvOXmIkVzACNCiDFsHxxC3woFn670+G90+jzz/GLP3fyW1qE5/2EcbMAaqYUicDvj8uS8wV41o1hPCIEQbi8CgBGANSSbwvRBrMi5dfAJtUtYHhscvreApn6996/sd4J63/4n66GA/YtCNgMtuYqjTpS0CMjHPl770KEMbIs1pqsogsh6dLmwOEl7Z3CAzBmO6BL6PNSZnWavRGDU6T8bjQsY9qZitNRmmMd1hn0fPfZGN7gqLs6d4x53vpJ8O6Q0HSOHkOFq1FkqNmLvWgu8FzDbm6Qy6nF+9xNOvPEm7t4o2hmf7L3N64XbmGvP0uhtlEj9tDFkyJAoiNjqrVHMW5w6ztVwLAIzO6A2HeMrQrM2SaUWW9RyYJXwsuQQDLgx/ZJZxVQGts3wsKCQZoR6QUkcIp/eK0TlbPiHVhs1el0AFuea0038tZBoyrVntbGB0CvSoV5q8/ex9fObJv2A1jqn4iizJWNnccIxxa5BCIaWTCdkKrGVZhpSS0A947KUn+YsnPoOvJJGneOHCJcKgx0zjNgKvgkA7mH+ESrswf1Jaw5fpdfr0h0soIUiSTnmNOBkAAzyvRi06xhcef5K4t0Z7mLCyaTjRWiC4KaLTbxOnTmc18iPqlQaBFzinklQcby2x3t1gmAwRVjBMnSPs008+wnpnhbfd/T4qlRbg2swhqTBIYrCWXn+Vzz/3GLefupv5RouZeojWmotrV3ju1aepij5/vaFLkPxTT54jyQwX1tbBgrZwrLnAe+99D6Ef0hv2mK27ZGYG8j0qw1iLMRmeUsxUG1zaGNIZ9FhszpFkaRlmX8mdkS70PUSR0fATHm1U+Ft3n2b91ZdYOw8vDE4z3EGyBEaA6NDEpYPtlUvPsdFd5213fwAlQ5ckC7aty0KM9CuV0CzoK7S6HW5SPb60cp5z57/E3WfuoRrV3VwXPs1qi2a1Sac3IBIxx1TCip53CcF20sIdr2vuEJP5mm5MxuMvX+LR557iHTffSj+4GSUDgkCRaY3Faf9qY9jotcmMoTPosdCco1Vp8urGMp4U2DThC489ihKC33/qPO1hykI15GSjStzv8hePrfKXjz+Diwx4lNnaLC+3Y9Z6PS5srPLN7/4ajs8usj7Guh2mMZc2lllozrHe3eSPHvkklzbdZytByHp3g1qlxniiO4mgWAYmVgNrGSY9HnvxcRZmjnEsl0HKTMYwiekOumTayZWYjFLz+OJGj9XNK2hrCbo9VjJN6ClOLzS5csXJOmhjudQZ8LlHHmV1tr5n+19v+8hHPsIP/dAPUa/X+chHPrLnZz/+8Y8f2nV/4zd+g5/8yZ/kIx/5CN/+7d9+aOW+UUwIwT3HJZfWNJ0YKr57fkm1ZZA59vysWUWIhf0LG7P1gQvtnfGZ2EeLa3pkbAycvu5MdNh39fq18YiDYIcl1CDxpUtW8+VgSw2xDWRLNCzUBHcvSS4+t39o8GzFOR8GaQVfTUo8WWsZ5PqQs5WDr5l1OeDBs3IEpJwdASkXD1zam3a97PXQb5POLwCBRhHHubSjdRrPgYLVniVNj3O5YznZurH1ftOurbkEg5QJBo96ToM3qk21BZ86dWrbaysrKyRJciiVKKjJcRzz/d///fzAD/wAwT4Jcsa/e60Q8STRPP8X5/nwA++kEkR0Bz2SzCUKOTG7yNc++DCfePxTLNRgsx+z2e3h+z5vv/0Mn3n+An/+aJd33vVW6lGjLHOzv8GfPPZ5Xlm5wDBe5vLGHO+8470EfjgKIyY/cAlRJnoaJl3uOD5P4Cnuvfc+hIBzn+uQWZVnn96u+7jVhBDM1lusd9t88YXHmK1X2ei3ubyxwuX2Gg/f8xAz1Rk8KQl8Rbvf5tzLjxNGFY7P307kz4xAW2yZQAtjkdLj5OwSx+eW2OxvcGXjCn/66Cd52233sTS7RF3VSiaQlAIpnIasHQspDn0PJTRGDwiDkEYl4nK7Ry38/7P330GyZPd9L/g5J335qvZ9+3rvxwEzGHgQBEFA75GgDJdcEeJKG3yMDShCG7GiRC0liuQTyBBCb1cRFLmk3qO0pEL7HmVAkTIARBAYEANgBmPuXO9te1e+0p+zf2RVdV83Bm4uwP5GELzT3ZV1MvPkyczv7/v7fnMEYUDH7zJWrtHotomSjbknhaDo5lioL/PCpa/z3kNPUNp+7AH7D1pvtKDbuTLPHs5x6dYdEsvl0PQOEqXpBD1MQ2CbGeEhpESpBJVkgXEbLdoyUyolCc1em6+ef4lKsYBSitX5Ve6sLVJwEkZLNXw/phNHzK+v0AkiTNPgwPQoU5Wxvt9g1iY88JUdEM2Dl45yoUov6nHxznke37uDSMf9BHgDyYZy876FdPDzPvkgDYM4TYniiNFSiWavxe3VRV64/BLHdhymmCvhOR6mFHSDFudunCWIu+yb2oY0LFIFjm0ghEGSxJimhVCKVIGWgkqlhFI+UbjEsW1lbq2HpEplik6dUnDzd5GgYjP5NpxZEjtfIieg1dVs33eMkYJxV+saaC6vzKGBnG1hWxZzawvEacx4eZS8zJPoLAl9vdNEKTUM4JFC4NoObb/Jl89+naX6EttqFVLVpt5Zo1KoEScRqVJZEcAwh8cxVSlSaLTOVGlhEnJ94TTtMMCzDEbKVdY7Pi9cOc2Hjj/LWKlKJ+gSxpl/ccHNEcQht5cucXCyglE8MvSQftD1mtmRSMr5HB0/QqkIy4hBuJiG21ciqr5vrnHXcbzXc1X0rzmhU96xw+LQpMN/v6RYbkZU8zap1qy2Eko5l04YYZsmt1fn8MOAbbVJirkCSqWESUSj28aPAlzLxDZM/KjHSLHK9oltRFGX+bU6M7Uy6+1luqFPwc0NA+/u9c4dtNoLlWKbNid2HeLC7XOs93w6UYKTK3By+zgVM8Rwsu6EJGVYDDMlJEnItprDu/Yf4vxci4VLEUrHOI4LWhNGIY6dkeRB5FMp1jg2VeByO6VRbxBKE8PMgxAkWuHaFg5GRtr37VGSOMn8koVgpFTFjwIcQ6BVwHNnXqAVtPiRY3u5uniVnRMHybsevaiHH8UIKSm4Ln4ccmn2IgenC1xfOsvZ22BLE9syaPtNHJ1SmRpn/0SNlXaPS7fneOrAbuYbHS6sNLEtkzTVPL73OLbp0Oy1cS07C79DZWp6MhJVy4xkT9MU17LJ2Q5+FJF3crj9gsFycw0AQ4AhJUmqcG2T9z51hOV2lxfurPLRdz/Neg9eOhsPgwofpup0+sdnsbFKKlPeffQ4tpeFMUlxd6v+AFJIUpGdyyRJePb4ThzH5ESaAt/gZmRwbXmZS7MXGR+pcWByhGf2VOmuL/Rb9TzOnj3Lnm3jvHRHEd9lJaiH95nNPvOGYRDFIWkaknMcDs6Mc2Eu5D+fPc++mZD92w6TeXf3Cz5pzGq7kRXXpCROU4SQeF6O0TRPEIYIy+axY8f4k1cv0gpinjqwGyEES0tL7N6+jV1a87kzVwmCkB976ggtP+SLl69lhKgh+ObVM/zwyXdT7SuxkyTBNDPLgm7Q47lzL7LerbNjZJzRUi2zDep3qNx7PbG58NdfS+K0h4rnkOEi1xeWWajXOLrzBH4UIsWGotWzs86fJM1sgCYrBZZbq3TCkELOY0etwp6xKnG3xcREZqfSDkKUE/DkyePfNcXtd7tI/51Eo9HgV3/1V/nEJz7Bxz/+cVZWVoa/q9Vqj6SK4+3Ad4IcuxdRkpEK5kPqN5LseSXcSm+/C29EMiaYTHiCau7BPvM/iPh2STYhBGPmGnWzQisEz/zOFCc2b3+LSPn+w6N+3u4tfimliHRmz2b0s6rjVKJ0FmLYC0xem02ZLL1+0XwLW9jCt4+3XDv93Oc+xy//8i/TarXu+vmgbfXChQtvajurq6ucOnVq6AMGsG/fPuI4ptPpvOnk3e+mlPlPL1xl98RecrZHJ2j31WpZKFOz16KcK3Fi11HWG5c4tHeMV6/d4l2H9vDTz57k9J0/Ybm5zGvXX8S1CySxwrQkzW6DubW1ITEnhu2hDC0uYROh1Vf9/ex7n6YdtLg+u8Biu0veLZFgUs0JgtigF6e8Ce6WKI74yvlvMLe2yM7RKnbRZGG9QcGOKRjLrNQXWKq3+T+/9zF210q8ahZ48uRx2kGer91U/UCZLGxn8FIsESRpRmqMlUdo9hrEqaLjN7gye4orC2V++OT7MU1zQ7Uo+mneImtt1WhyVpZ7H6ZZwjuCvkew4NlDT1AplMk7HnknRxiH1DtNEq0oe3l6YcCr18/yocO7KRdcHsgQMCA2s5fxHzlxAFM3ee7sZfZsK7PSaVMsJDimiUJhGRaWmal/TcNCiLvTQActvnPri3zt4svMrS9yaHpsk9o1uya6fptOp0Mul2O8lCdJEqoFj3/6Uz9CJzB45bam4AliZdIO9DDoDM1Q7dgLO3z1wktYqsOvfeITLLY7fPmCjzIyD89EKdQ9ez0IgBL9YymFIE5imr0OIPDDEMuQBJHmxvI8i/VlTCOHZ9tMVfNEcZf51To7xkcoeu7Qo2uQ8p5qjdAqIzKkJkn1pmMMeyZq7BpTdOMuI8UK1ZyJZTj4yUD9vJlk3HQBCE2qBK6dnalEZ8FcOaubtST3UiQJUaLwHIec49ENA75+8SU6fpP92/bx+J6TtHptCk4WtmQIkISgU8IoxnHy5M0GnhVjGpJjM2MUXZezt87zzJF3USuU8aMI17aHc0ah+/Nf9M3ZBZVcmVKuQpyuU29FHJoaJVYWZ++scHX+Cid278dzPPL9ls1e0OLczbPU/SZFN2H/Rk3noUjSBNOQeI5HN2jyV56osNyBs3Mpec+gaFvMtzcfx3uh+2pMjWcLamqBI9O7MAyDx2YSvtSKCVMb1zJxTYMUyWixwkqrzZ+f+yar7VWeOfAEj+0+Ssvv4Ef+8MXNlBIpBUmc4jkmOdsljnvkrMwz9em923j1+mneffideLYD981S+hYW9JWXCa7l8tieA7x6/TKohP/r+5/gHXu28bVTl6nbo4QJ5Czo9QI8N48fpag0YjSvkLJMtVDENpv0Yp+8Y5MoTZxqDJWFK3bDiFG3wN7xKvsnR/jq6hpP7tlB3dcYAso5D9sQJNpBSoEhs+s4JlPCd3pNTNOh63fopIvESZfF+hKu67DY7nJlYYHVZosTe49TcEvYVqZabnTr3Fi8xs3lBfZM7OfpfTPM1ZvcmF/i//7RDzJdLvHKmTM8efI4Qkj+l//6PKM5Bykl05UCRdukkyh2jkwwXh6hG3RxTAPbNPqKaHPopZtdh/1OAyNTSucdp3//SomSTBUdJtl9Y7CNVCmSVNGLE6arxeH9ZrZhIOUG4f6g8C/IyNte2KXXusYv/Y/vZ75pcGbJAN23MNh82W9CpuZWhGnCC7dWef/BaQwDtlfyfOz4CS4tdzh3+e7gwlONO4wWNx5hjkybNPwO55asoaer1gpDbvjMD8adJAGWjDGFhVI+EGIYgjuNHtvGm6y3rpPL7SVJEhCKIIoI+oVqKSW2mXXeOCZMlvPMrWVFzJVOjxsrDUZzTp/QjGj4EbkgAgFKZx0i3SihG2WqaCkEhoDZtcW7LCxMJ0eiUpbqK3zz6hnm1xY5MDnK9pExLMOg018X0jTe6KrQG/dkUGidonWmLI7822jtU3It9o2Pc2VpnaX6ClO1cWwjpd71h+28SmVhmvVOnZmqRSW3g69dusl4Kc+Tu6ZYaHaYb3RJnTbTlSKLzS7Ht0+wY6T6yHncblbRficVta+H559/nl6vx2c/+1k++9nP3vW7L37xi8zMzHxPxvH9gO+0Am1LOfqt4XVJxhhMUg5P3m/H9oOOb5dkK0if/TsNLi5lKu/vRHFiC1v4buLe4lesQGFgig1uQgNNP3umSTBZaMHnLySc3LZF3m5hC99NvOVHl1//9V/nYx/7GH/9r/91XPdb7zOanZ3lU5/6FM899xwTExNAZnBdq9XeNGn73cZiK6JWrOJHWSBW9oKV+RIppWkHPUZLNc7eillo3mHMsfirTx8jTFNGi3lanR7XlhsovU4SJ5iWidJgGpnfXL0bsGOsiBSSKImGrcT0feoGifKmYXB6rk3O7BClio4f4yeaRGctqW2/S5xaOLb3hvt0Ye4a1xZnUUozV29jGpK8abCtVuKlm/OstnusNtsoIp7YNcUOUxDGKV+5fAvDniHVijTRfXuAbPFO9cZ/9+KYth8hBTiWwZ31FkUv7Ceqiv5LJf2gnk3SKA31Xpe8vRFApbSmmi9hmRYVNG2/ix8GVAslHNthsjpGy+8wv77MmVsXkGmbF2+EHJ4pU6vcv+8ZoaGHN54zs+t888qrXF/v0E6zdPYTu0eYrIzSCTr9llox9I8FSPshQqY0MsVlHPG1S68wX1/ClIIgTuhFMZaR+aHWuz61vIcfJ6zVW3SCCKU0vSjhD756ih9/8jEcwyBnm1iGQKUpt9eamUrVlJjSxDBMvnTm6yRpj792ZAbbNtgxUmZP7hLLRoVOuGE5MAhMy7w5FVESZ0reNKHeaZCkMQW3wEJ9hRvLiyAgURodJ/hRDPjYUmDKKqlSOKbB3okaUpqgU5QShMkgoCzFUFlrthBZK/5co0fRiUmV5s56k7OzK1Rydd554Ek6kYEl436hZdPD730er7De8dG5zLf12nKbP34tJFZGpsbVWfhQuVABFO1ekyvzl1lprIAhWW6sEsYhqVb0ohhDCAq2iWlkIYBaK9ApQiiOb59gpdFmqdkl1ZqF+hJnb55ix/hexsqjQ4VhqhRxmmSEUGYRixCZXUaqHRKlGCmPUS0fwLZy1CoJSmkavRbnb5+n3WuhhMIP2thoDNvGsqpsDpN7ELL2/Iy807HP4vptgiTPTLXK5cUuZdfAf6hySA/nvNKa5cZtiladnBkDu4D7FU+lXIlekrDervPi5VNIAT/6xIeYqIzi2g6WaRHGeZq9NkEUoIE4VXi2DVqx1umQppnNQBAn3FhrsNrqsbPssXPbsWwebUKcZsrxDe9chSFMUm1mISkqoZzLigZ3vwApIiXptnu0ek2u3D7LazcF+yZHefeBfXiWJExMllvdTC2UpjSCKCMpDZMgjvnjV85xaGqUr527whfOXSNViqcPjDJWHqMeBowUC6g0Je3PVVMaxGlM0/exZIRrO7x8cxE/ygoKMlGcub3IUqvDUrPFjbUlxks1UiVQOsGzFa5pkmpNlGRhU+OlAnNLq1Q8jx2jZdarBbbXylxeWidIUnJmVpSUUnJgtMS51TZJ32s5SVPSvu9epdAPjBsWlsSm8MSsUBLEMXknx521JRqdRmaxk11uxKlC9UPjtFKcmV3iyV1TRKmiG8S0A8FQdk52Lxz4r2+eu41uk5X6Fd4747JjtMyN9SZgIYQedjsMilGbFbtRmtDqNjENi8++dIWzd2b5yLE9dJTHn1/XNPwcsbuXyyvuMLjwXnzx3HV+/2uXeOfB92IISZQmfXeWFGnKTVYnfasXwyUKfeqdWc7PzdENJZXiKPP1mLn6NY7vqjBSqNH0eySpGq5QcZpS8Aos1le4vDCHZUhyhmS0mGe96xMkKUmi+OaNeepdn063x61OhGOZREmmbI2SFD/KChZSZkYnlqGZXVtkdm2R8fIIbt/CYrm5hiGg6GQFxZtr6+zZlmL1bYNSrQjiEM9y0YJBriap0sPi8HJzha+eP8OxmTE6vYirV+9we61J0fX5yBPvRQoHIbJyVKLAtXL0woAXLp/GsyOObBtjvOCRpJp/+42zhHFCkqacXmriWCYnto/zI8f3PXKk7b3odrv89m//Nj/xEz/Brl27+Pt//+/zhS98gSNHjvCZz3zmgd1l3wo+/vGP8/GPf/w7sq23A1pr6j60VY71nma08N1VWH4nFWhbytFvHQ8jGUfyAlMtMlH8zqvp/yJgoiiYKhusdtJHtj1+C1sY4N7i12CZHKzKqQKNJNFZt5bITLqo9zQv3kqpqjfmIrawhS18a3jLxG2v1+OTn/wku3fv/ra++Pjx4xw9epR/8A/+Ab/4i7/I3Nwcn/nMZ/j5n//5b2u730nUCkXWfAM/9B/4QpIkCaaTI+949IKQwUttwbGxDTlUJg5aNAUCSUZyuqbJWDHX99DL/C9jPfA17Cv8+oQoGHTDiFeu3+HkzHauN/L4sSLWJoGvSLUD4o37vrTWLDVW+mPaqJzFacqF+VUALENSsE1GCh5nZ5f5WrNB9XYTx8pzaOc0tpH5/qm+16UhJUKAIU1SldLuNpEShBJEieLA1Cg/9a6nWO9BMlAcDanFbBxJmmQevHaeTuhjC42DxLXzpFoSJzH1TpO8k8M0TJq9DnG7TiVfYq3d4GsXv8ZffedRXrkcsBIoeqG/QWAMVGd3HYeM0JhdW6NW8CjYJoaUNP2Ql66e4cMnnqXkFYnSeOg/PLAtSNKkf0NLMKSJZZponWbHJUlJlGKsmCMKQ2zbYayYZ73TY7kbIoWg4NrYaCzH5uZKgz/8xsscmTraf8mA8ZJH4HdYCzS9KKLg2qw21xgrGvyN97yHkXhD6V6QPvv3GFxYVNxaS0j6PHgYh3T9HqV8CdeySdKUeqcBaIpekV4Y8NK1s/0wpt3kHY8wDrgwd50kVaRKkyjFRClPWSpqeQ+tE6IkouOHlHKFrGXcyM59nMRZW7qE3WNFri7Mc329TTNqYZsGMzWT5tpFnMmDaJ3HNQYUfjbPH/Tq1IsCktTG1CGvzRloLAQJSdQjwUVpkyiJuTx3ga6/itaakZxNoCWJVnQDn0qhjNAZgSv1RpHANF1S5aNUgGeZ7KjkObJtjFurDcJEcWdtgTjpUHRP4NkeUZJkdhab59Cmf4dpiibHOw68A9cukqqIVreFlCaVXIXH9xzlq+e+TqPbJEpS2mlCzTDJu3kQECURttlXdN9DYAshMAyTNG0zO3+ORMTZ+rLpwSpVm0e1UQ7PWsQzoloIiSUVZ2eXOR10OXx4nYPTY8N5tKF4WqA0Ns5/PTWLbRr88GOZjUvH7+JYNo7l4No2tlljtbWOUimubVLOFWi117CNmHqQ0ApiTNvm0NQYy/kuzcZtOiWF7WzDcSYZEOipyghMKQahSpmq3TYUB6dGWF+vk3c3ijmDF6BXb63zB6+9jDINKh7khU8pX+Ps7BJz6012jx3CNPOAj9K6T2IJJFDwciRJj4vztzh3B3pxAlpQyVdZri9TK9bIO5lvqGVIEFlLWJwm1DvZ9SdlFkiYd3MsNlZphzHdRKG0m31GZWrkufUV/CjCs232jNeI0xRDZDYsAH4UYxvyrn2E7B7imgZhuNHCPl3OUa1Wubme+dF6rkecxFiGMVzPB1Y78gHER87J0Q17vHz1DLaZ+RrH/UVD6Wwtz4IRBZ0g4uUbC5RMyLsWRVeim/o+sewgqHFAtFyYvYgn20AFrTU5W6KVQsjM0iP7TPY/WmSkskaz3FxDktkmFBzJ2dklVjuaXWP7yEuNZ0FMhG24rHY1L95Sd70cfPPOKv/H+dM0uj67JlaZrk1k4YBpSqJSSMEyrKGfrpSSNO1yc/Ysy2HKvumTlHKlwe7T6Da5tngHd3uOglvAD31UFGGYJkU3hx9l94pM2SpItcI2JKOFHFGccGW1iWU7FFwH4Vg4lkWj59PoBeSMTLGbc7L7jm1ZKKUIhiFtGxYWkIXaFFwbnaYsNjqYhk+aRowUyzR6bYIoZK3VYKIygmlkqmulswkh0ERRlzCcB+CFq3MEfduQiVKetdY6526eYufEPgpuEdt0UDoLWjt17QzLrVXKOYdXbi6QRjE9PyaMk0yZ2y9kh3HC9eUGt1Yb7J8cuW/ePUr4x//4H3Px4kX+8l/+y/zJn/wJX/jCF/j0pz/N5z73OX7lV36F3/3d3327h/i2o6M8nruqaPiaXjzN2tWUak4/sFjyKGJLOfrt4UEkY9WD117bUoZ+O8iKE+KRbY/fwhYGuLf4JTdeK0DRf9fUmGIjEFsKKDgQxLCSjLyuIGUL3z/QWrPe08MibnWLk3/b8ZaJ25/+6Z/mX/2rf8Uv/dIvvWkf2gfBMAx+67d+i1/7tV/jJ3/yJ/E8j5/5mZ/hk5/85Le8ze803rNvhiurK/0W+SxRNVWq7ysnkIaJ0ilP7BwnTQu8eu02/+6Fs/w/fvS9hElKkCh2j9do+CGdXo9CzqPs2lxcXCNMFUemx0g0QwVn0g9R2kwLZSqvhI7fZKQ4wqFdj9OLTJI0JIhSTNPO/AzJ0rmHtgv3QKPphj5StchZFnGaMlUuUnAtLi+sEnV89o1XWe/6lD2byXKRiZLij27NsxIqfvREFZX2MGQe27RQOiVOUyzD6H+/xkk6/PbPfpiVZpeXz53nqeNHeGrXDFdXFavXA0pulhTcDdWQlFY6pdVt4Ng5wqiHaVhImaV5CxUSRhkBvmt8JrMP2OQ12uy1qeZL/IdP/V/4o1dfQWn4keN7CRKz316eTe+B598woKtPwI7kBdorUnYt/CRlqpxnsR1z+uZFDm/fS9Er3kXaRkmMUgrPNjPFsM4Ikl2jZVTqY6N494GdFByL/9Ro4Tkm79o7w5cu3sQxfMbKBRzTZKneZLTicnwma1e9vnCZxw6NDl8ySq7NRG2UtV5Ez++yd6fNr/6Pn8Aw4NSpU5lautHiZr3DSNziPbtL/O/P/zm9yOTw9r1Ypos0DLpBD8PIWnpt00EIzVp7ja9eOMV4eYS//MxHcG1vaAXw4ZPv5qsXX+bszfO8e992KnmPpaVFAJKkR727TiVfQRCg0pg4TrAsE4FCa5NO0OT/9sGjzLd28E///RcoC4vHdkwCsLi4SBzcJFZ5RGEPju0OiaZ7e6e1Vni2Ry/0aYQBxVwJU2aFiUSAITRKhUgpqRYnaHWXkUIwVZvkwI4jeE4BKU0KrodrlegFHdbbDRxHYxkuSeqTpitorVlodDg4VuIXPvYe5pot/um//wIdYXFy+yS9YI3Im0JKA6XVsBgwGK1lmMRJQrNd5+jOo9iWjdYhUmQBUkmaEMU+nu1xbNcRvnrueSxD0ghTwiShYGVzOVP1KpRSJEr1H3hAIhFSEgYLrDXvcH7+Du86tIfJUoG6rzDIEo/tTU4xffuprDiis38Nnp1sQ7F/osY3LzX4wpmr7J/c8FXbrHg6ub3C8W3v4befWyDRNoZIsPMOSezj2Q5SSJSAWqFEGPco5QpondBt3+Ydu6dp+SGvXM1sY37h4+/j//OlF/nq2cvsUprVxnXGamVsyx2OSwCWKTNCTxgoFbGzKnjtjk/BNlEprHXU8MGhltN89dJl5tYWeOrAbjphTDuMKWrYP1Hj0sIqc2uv8viBp5ks16h323RVQM5xcW2XbuBzfeEih6eqfP7MVYpumU889QxKOKRKYRkmpmH2SUXZDw9UrK81idOIvGNhSCMjJEkZLXjMrrcwNEyVCyw2uzR7PTwhyDsW3TALe7OMTIFfci2KbhZIdm52BVtpbq82mV1t8eqtZaLSLCe3TWNbBmdXW1iFJkXHoRFE7JrZweGd2xAy318PMzuAzedxsD4OCfH+LaXtt3nu7Ass1JewLZO8beDHMUqDYxoYUuJHMXnHYrpS5PZaEy9vMVUq4lmaswsRQmYhiOrewpjIfEiPTxe5tNDi1EpK4UpKw/cQIkEIOQzQ2jjv2T/COEKrBM8rst5aY9QTjBRGiJmgF8O4Be0woBFEYAUUXZfVbsxCJ491bZaT2yb5zxdmafsxu8cqnLl5hrzrUfSKmQXD8JpVtP0e526e5ci2Ilr5LHcDjux5Es926AS9oRfyWHkEx/I4deMCB6Z3UClUsC2XVKUsN1d58coZFhtL7BmrYRmCW6sNWkHIsakJwiSlHSbsrZSJlSJKFQ6asUKOlXaPIEnJ2xalXIkDkz3qfkAQtgjiBFMIiq6FBjpBRCXv8tfecYwzc0tcmF1msjbJMwcfo5wr4dgeOSdHlEastxv0gi4jxSpxmmbHNIsTYXXlIqNlhx85tofPvnwJELxr7zamKkWeO3uZhfoyfthksZ1iSQvPljS6Ddq9gHLeY6KY58ZKPfNHdl2OTI8RpSntTpdiIY9tGNxea/KvvvIqHzi0G/Nh5qKPAJ577jl+//d/n927d/OZz3yGD37wg3zsYx/jyJEjfOITn3i7h/e2Y6mtmY0nsbpvXCx5lLGlHP32cC/JuIUtbOEvDu4tfrkGSFJSbdB34EOSCUKAfscQ2Gb21NwMHeo+1HJv735s4dvDUltzcSmh3lPDIm7FE5jfJ88BP6h4y8TtRz/6Uf7G3/gb/NEf/RGjo6P3VVS++MUvvultTUxM8Ju/+ZtvdQjfM4yXDcYKBpBnrd3Y+MUgMMrN0e01uDw/S73r0+wE/NfTV2kHMYlSGEJwfn61n3qvWOtlHnmGlMRK8dlXLjJWrFHI72GsMoIJQ/JWiiyRXAjB/NoSd9aW+dgTH8Iyba4sLBAmKYYwGC2PoKTEEH2fWWlttIRuMs1NVMrXL77E9dXGUNU3V2/h2CaJUog0Zbndpeg6zOQyf8p2EPfVaop2EGEY81j2NiwrhxQSy+iTAkJRciTj6Rp7xg6yZ6yK01llamwbf35dsdJRJJg0fU2cxjS67U2+lhqzH/7y4pWXMKUkTRQHt43SChL2bXuMXN8CQmdGnSCy9vxaoUKchFxda3BtaX3oB2mZHr2wSylX3sSBbxwTrTXLjWV00qTkOcyU8/SMMjvH9/K0V0RpQapSepGPaztDKwABGFKQDuwBdJqpgbsxrmWys2AjJVxbqbOjksf0cvyX166w0u6Spim31poolflo5noBL91cYLKc59rSHD/+rM+6n6fe0/RSi2ZrowX8iitYqK/ykWN7uNPo8vyffZNrS+ssrq7ylfkOrmVx6tYtVBxz6uZFCm4B08zabFeaa0xWRrBNB0hZb9U5MLOfD598dzYP06TvqSuxLY8PHHsXtiG4td7ENCWp0rSDkOsrDXrhGs8efArDyKNUTKoiTMyslV/HXJu7xGK7ghSCbpyyd2YcKSVKKVpBzO1+6/ATexymRqfxLOe+9WNAqq+1V+j6a1QKMygVI2Sm0U1Sje+HxEmKUlArVHixnTJVKXJk9+OYpk2z1+2Tpnkq+TLScMl5ZTphRBgtU1+7TqVssdjsUst7PD3mYpqSnSMVPnpwG5+/3eRzZ67SCQI+eGKMHaPTfaIu7Yfp9a9NYL6+RL3nM1Kq0gt8TGkTJdncNgyDWCmIQ0aKVaSZY7WxlikR3TKrPYudBbBMa1OgUNr35wTXsohiny+fe4mFRoc0SVjuwP/6/ArlXIlYW6Qx+NGgniEGmsa+qlz1lZgGceyTJA2EEIzmHK4urTNXbzFdeXCacTsSjJZqzK+vkQpwTBNURJr4KGlhGBae42Ia0OjUSZMVut11DKfGUqvLVCnHX336GLZt8CPH9/G1c1f4/NmrpEqxc1Tz9KFnkMLAkKBVOrymtFYs1W/y1QvXiJOUXbUx/sOpNqWcwBJTrF1NcYyQ+UaKY0heurlwVzt6rZCj6FpcmJ9l58QosrITwzAp54ukSjFfX+aVq6dZaq6y2ChTzFV5cu8TRNomCiMSlWBKE8e2ce1MnVnN99vYVYJtGH1riDzrrVXW2uvUu35mjWIYrHR6HJzeTZwKOmGPawu3cE0DhODGaoORvMdUweb8/DKv3lqk4JZwDJtf+D/+nNX2OpYUuC/fIFbZuesFMdfXL2Eakj1jUxxwdyBkvh+cJfpGCNnDc5Kmw6C7gRd1rFPCMCTV8MXTX6PZa5C3TVIEDT9C9H3MUqWJ+/N2pODR6AVU8i6WAQutNjPVEi5dAp0VswZk7XBNTTVx0kaIiJ1jU7jONpbaKSXXwKZHpHMZeTv4XL/rIUlTOn6HolckjCMu3L7A47uq1IpVXKdEo9Ph1J0OQZyQpoo7jR4KjWNY2JbNP/njr4EOuFXvsm2kjCENwrDNF0/9Ocd3H2GiPIZhZJZCzW6DVmeeXnuOywtlCq7F9on9OJZNs9dGCkHeNom1otFtkXPy7Bib5k9e+iIjhSpCGIRxyOJADavhxmqdQb7m7bUWv/KfvoRrF9g5Nk0jCFltNUmShPUg6yopew61QpVYbqOQq/ChkzvpxTHLjbWhj20vSrN9NA2e3b8Dx7GYrBRY78B7jz6Dbdr0oh69sEcxV8I2bCYqY/TCHpfmrnNu9hrNbocoCemFHfZVcxwxtnNufoVGzydJUk7dWWKh2aHi2pAKVjs+jU6PIIrxnCzA0ZCZ0ne9l4UQNnsBU56NlJKRXJmyU8K0TbpBm5FijpsrdV65Nc879z66/q1aayzLIggCvv71r/PLv/zLADSbTXK5v9hvmVprLiwqUgxqTt9+SYBlZC/lreD7S0n1F1E5+r22uNjCFrbwg4l7i18STQoICXLQNaUzkYpAU3AGIdhZ71y0Ff74fY2O8njxVkqUCjxzo4i71tXE8SRLbc105e0e5V9MvGXi9u/+3b/L/v37+Ut/6S99Wx633w8QQjBRCJlraGqFMu17kp6DOOLU9bN0oy4F1wHXIkBycXGF26tNOmFEihiSfgMPQXTKzOgU79x/sp907/TTGo1NL7XZ37e6Lb5y7ptMVkYZLVVp9bpZa75pECYR6506Ra+AY9oYhoEf+FimNdyW1pqO3+X5i69w6uZ5Co7NtlqJKAjoKUGzFxAmCk1KJedxfPs4UbsJMPTjEwiiNCVNO6wtnmZq6jCGkSNNNalWTJRsnt7l3WWyP7jow5hsHEqR9hVsBa9Aq9sg1SlporDdAqnysY2E1XaPtWabUg72jk/iDZSZZArEzWQBgGXaNHt1giRlenQ3heJhhDD7La8blhNaayQCjaLld3j12qsc2VYCYLw6zsTkCVIlaAVdun6AaZqUc0VMw6Tjd7BNG9e2hy2iSRrjhz2kNJiq5IgT6HTaNLoBx2fGsUZcXqtHQ+I7VhohBoS8wDENVlpdmr0ASydYIuSDB8qv2wJ+fnaJeqNBqVxmqlJAhjlKeZdXby2y1ukN25zDpEHcP3caWGhkREPJsTEMwbsPP4khJWEcIWXml6nJWvYd0+apfY+zXj9Foxuw2PZRTsCesSpXl9ZZW72Au+0IhnSxrHymvkx7BMEiq60VukEW0hOlKbm+X/F6x+fyagthWhRch1sLlykVyiiVEMWZH6oQAtuwiNOYawtXuDx/ldHSGE+UdqJ1CphobWFYBqiUVPVAq0w56LrMjO3BMCzW2g0MKbANQTf0afldxkpVwqjHxdkzXF6YJ01iju/cxpO7p/nho3voLNy++8IfFGZyVS7P3qCaL5NzvCFZmz2zaOrdFs+d+yY5x8WQBr0kJk4McrZFHCcUcy69KCGMY1w7h2vZGFIwU5vmA0ffRc718KMunl0YrjeWaSHTFCkNUp3yjcuvsNDoMlUpsKsywr6ZY8RKstJuUbagnHNoBcMhD5GquG9jkrWor69fxesv145p4CcpnTB66NoXJmAaBqM5i0BL/DglxSRWCZ6pqbomQZRyYFJw5vYyV1dXh3Pl+Mw4282YfRObvcqzRa2Sr9Lstrg4e5HdE7vxHA9pZCrOOIk4f/M0Z+5cwTYNnj14kKnqXizLpRP4pElEwTNpxJLR6l6uzC+z3mrc1Y6+0upiWzMcmDmMaTgsr1/gtdsNklQTpQltv0USxwghWO30eO+RJ7IxCINSfhBqqInTpE9kSoIYkkRjWzZF2yZVkiAOOHPrPEGcUMl5+EHIiT3HOLn7OK7lDdfeXuhz6tqrnJ+9ysxImVre4/byKso0+dCJ9zFWqgGCJE1Zba3z0tUzzNeXSbXC7K8VaEGUpDy+73GKXjErbqgEpQSGYQztXAwjs/XpBj6pSrAMSZTE5Jw8je46WgdUci7trs/O0Qor7R5CerimRRBH1LsNcmamMB4p5NgxWubW/BLdIDte+WSOFjswpHMXAatQdIMuQXCbogPlwjYSZWMJhcbAMQ0cE1p+DCJTbAwU7GEcIoSg3qlzZ/U6q60VoqSEECapgnYQIqUg7zpoBWGSEMURWsXkXI9KPs+pW0t0wnh4vyrlyqx1Al64fCoj6gyLXhRiiMy3/QN7Joi8EhcX2oxWy/hhgG0a5G0LlcbkDItWENLte9iPl2uster0wmhoQyGApG/BYUiBJQSTlXHc3G72V/IcEpJEpay3G7x6/QwrrVUEgu2jUzy593FKuQJRHNAJeiRaMlUd54dPvps/fe15FhrLmFJSdEzKueyiNaTk2K6jFFyPTtDJAj01tHotTMPAMR2WGuv8u69/bmjJJKQkThWvLYQs9GLM/lqPVFhSZv7PSczRndPcWmuy2u4NCVtLSoz+zXailEcAi80OE5VxDs8copirDG0u2r0GN5avsX77Jqud3kPXlEcBzzzzDP/wH/5DcrkcUko+/OEP8/Wvf51f+7Vf40Mf+tDbPby3FfWepuFrTJL7iFkhBJ71/aek+oukHP1+t7jYwha28Gjh7uLXHJPb93FjTbHQzEIelc46/oQOcczsfS9VGZFrb4U/ft9Ca81KMoKSUHIBNoq4ptSshJlF41R5qzD4duAtX1qzs7P89m//Ntu3b/9ujOeRQpIo/u3XXqDlS57ad5ySV+i3yCsanXW+fuk0C+sLnNg+iZSSngbXNtg9UuHsnWXSVDNezpEqTasXoPvp0SOlMT50/FnKuTzdsMdqa50wCqgWy0ghCZOIKIlYaqzy0tXTLNaXeXr/fkCSpAl5x8I2rWHQT71TR2BQ9Aq8cPkV7qzcZNvoDI7p4pia2dXbXFmqY0jBztEynmXRSRNG83nEyDir3QCtFI/tnKTsOSz2iduBD6NGYxsGUnoIIsIgs9NfWFlH2BY/fuJxJopiaLI/uOh9BXGaVeS0yF4DjX5rbd4t4EddCm7Wunx7+Qrv2D3NfKPFjXnN//ShJxGizOnFzN7g3kfP4U8E5Ow8k9UdTIzs67e1Z16zUmcqOCEEcRxjSEWUdHjx8qssN5Z5bGcVgGplV0Z2qxBTCvKOS9Gz0TpC4FHOFVBpl14YYgvYOVYjUZp6x2W8bPGp93+YuUaTl187wxMnjuNZBX7n81/Dtkw+eHgX/+mVS0BM0XUwDUm7F9AJIqarRZZaXWSa4DkZ2TxoAX/HwT0IIehKQdF1KLoO/+21K/hBwI/v342UG7/bPVbm1K3M0iBnZ8FfCSlSZlq8RGXelO/aP8NkbRt5xyNNFe49ileNJk1TXNvjRx9/kumy5uXX7k65b7RXqfWuI6VHvd6kWi0DIe2ef5dXp20Y9KKYkmFwdXmdMEmZLpcQQrDSXOHMjVM8ue84qcp8Hg0paPbqXLp1jkhlgW7toEeSJhTdAobpYgBW3wq0RAk/6BGlEe89sBtp1egEPQqOTc7xUApilRJEPs1eh5ztcHL7JLtGPF65eou9YxV+/oPvQAjNqT5xq5TmhdureO4IP/HMU8TKxI9SRN+HVmkFWpCqhOXmGt+8epql+hJP7NrVJ5EtdoyUcS2TXhAihaSSc2n2IrRWTJVzFOxRju88Sd71sIyETpCQplDM5cmy4AXSFCgV8fKVU1yZu8yPnDjYD+iawjQslArxY0UrFBSK9BWTA4Vt1hpuyMyHQauIIFik2biNN5nZVoRJiuMYFJyHW904JhgSTMOhYOWwbU2aKgxD4hgC0wQj9jm6rcj7DryT22v14VzZVilx+vRrAKSp4gvnZpke28d7Z/aCsEgThWFK0CHzq3N4xPzlZ44hRcqZ83PsGC3z2I5JvNwetLaACM826SrFejdgrJhDCIN92w5ydf50dn0Lwd7JveyeOtBXl2eeW6mKuLX+Mi9fPUM572FKSUwWELlzdILx8iiO5WTFC61QOkUKmdnBKE2qEjQCPzUp5Wv99S0hChcZc0Kmd2xHaxgpTvHOA+8YKl4Ha1PRK/DuI88yM1Ll5z6wl1Sl/D//9z/n6N4nKboe9U6bMI6xLZOp6jg/1Cfv1lorBHHWfTFWzFHJV5muTWQFqEH6lNiwRhhYFtimTUf3CKKQSrVESRYIQ5+82eYTTx7qr69LfOpjP0Q3KnF1tQcaTEOQpgG3Zs9RKlqUcy4tPxhe00ppXrl1k9Bps2N8D4nqHzM07W6DV66+hmunPLN/P0K6pEmEnxr0upBqFyM18GxJs9cFDV3/Ns1umwtzqzi2gdbB0DvVNg3SNCZMQ/KORzlfwDSyC19p3ffa9omSBFNqpst5LvkhyBzHdj1JzikhpESplNXWGi9fPU03aPHRE/vohjG3Gl3+8Y9+iD+/usLpeRMBOJYJSGKdKeDLnmCt3cM2TZ7dv4ueX+ULZy6DNCg4Fk0/RMUJZc/BsUzyTol3HniSSr7ASrNBnCaUcx7TtXFqhXdzcfYsvaDJ/ukDWIbNZNEm1g7LDYNEawyRYhge7z70GKduvETBsVlYq3NtaZ2RQg7T8Cj1wxhHijXAGCoftU5YabYoenl2j08wu7aKVgrLMDCkoBslLLe6HJkeox2EKCFwbZNasUqzE+LHJk/snELjILTg6PYxbJmwsLzE9MQE5ZzL5cUVto9M8cTep8i7heE9WKNxyhPk3CL1js9o4dFm9D796U/zz//5P2d+fp5/8S/+BYVCgUuXLvH+97+fv/N3/s7bPby3FWGS3Ufk5tDYTTAkW0qqRxQ/KBYXW9jCFh4tbC5+7R+THBg3+Nz5mOVmSjWXFeWbrb5QSGc+4q4IqXoP7ubbwqOPug+Bdihb9J8xNwhaIQQmCQ0/U2KXf7D1m48k3jJx+8EPfpCvfe1r/ORP/uR3YzyPFF65Nc+tlTpFz+HcrVfIOQXW2j7dOKLVbdLoBSil6UQxRdemFyfsqJZBwliphmXauKag3mmgycJqNJp37DuOazu0gzamkH1bgi5+5FMpVFjvNPnia8/T8Vv4cUzetYnjmDhNKHo5Kvli1lZMprRL0piO38OPQxbqywBcXbiJJTS7Jkb7Ho3ZPg2IulppjIM7j1LwSpk1QJrimDGkG6EoBcdCCsF4ZZzx2iEM6WI7GXkTRl0W27McnC4xWSpwZ72Zea6uN8nZRToqR3xXaNIGpJQ4tovSmRffemuFKBG0/JBOEHNorMxTu7ZxbiG977P3QzBaLDM96qL7Dp9SGFhGn3Tux2EqrZhdPM1IXlBvr2VBYY6NlB6WXewHOHmUc7ksEEoKQBHHAaadB1yMtEfT92mHIWAidMr2isAwJNtrZW6Vx7i+XmC5k1AePcKoaRAnPbbVGtxYmsU0MmLOMiR+nBAlKdtHtlOwHVZaBoZoDS0f7lW8tIKQIEkIk5T5Zpvx0hROfjuxshG0GC+P4FgOkLDeqvf9gxmqvQWQt21sI7OTkHLgrbr5SAro805xarC9lmetn3KvtWC0mOMb84vUej6CkIX6EsLWFF2ba8t1CrZJnCiWmh1SpTg/t8KhqTGUttk5tg3HMVlrr9MMIgphk1brCs9fXUZryWQlRxz36HQ6FAoFEGQp89LEMu+/MwgEOTePDhTNOKToGOQdl2qh0vd57qutVdb2LIB6L6aac9lZybPS7jHXaKG14ma9Q2m5wYXFFKd6lJnKBIYEiFj12whpUnTzhEnMK9fPsdxYZr1Tz/xAXZs09VnvNBgt1giSlLLnZsFSSQKY2KbDenuNOOkxUqpSLlQQKGyrQNWU/RsjKJ2QJjFSCtaaF7i+dA1DCKQUGMbGPDWMHAUjq3bXe7rfuK76YVApShs0ez2WGrOUnfbwpqu1puWH3Gp0edfkBOOFHGfmU+7EkxjzKUcmNo5v0c7UkD3lIGKFFBqtUpAQJgZBopFJSMdXjOSrbK+Vh3NlgKW25uXbAcLaxcFdzpBkSuIOAhNp5BgpTXDqyousdUaZLBWHFhummcOQLlEcYVkZqV3stzK3gswWoFKoUMiV6Pptdk3t5+D2YwghSdM0s/8wDAxp8+zhdxInCbeWb6KFJk4VZdch57jk3ex6T1VC5n/d9wdWKVKYOJaL0oqqZzK31iRB4tkOpcIkk9UlSp6DUop3HHjsbtJ2E6Q02DlxiG1ll5duzrFz6gB5x6Xlt9GAaztoNPVuk3K+xFP7jvNfX/4zICt6hYliojqGZWRhW4Zp9tf0TUWXPoknhKBWrGQWL0KC7rG+dpFKOTv+nSDm5PZdtKMRohRylmS93aKcL2BYBXZsO0HPn0XriIVGh5lyjqlSgVfudFDOFGMllzS6zfm5Futtn3LeoRu06XRb9GKbXpRiOZK8W0DpvnezTvshXhLHcvGjgHbg41kmnmXQjRIcQ9MJoqH/7531JTyvxPaR6aFve9Z1kSnBPcvl1uoc8/UVbMNg99gUHz75Piq5YhbKlRlok3NyVPIVvn7xG0yViyy22lycX+eV2/Mcm57i4mKDRFsYhgdIpNT99T8l52R+27WcTS/QQ6/cVOmhZ7FjZQWSx/Ycw7Ec4qQ3tDuKk4Q47eBZOXZP7uXm0hXK+ez6qAfZ/dt1S/0zqNBBj1qxylRllG7QJmeZrHf9rCsmNvFsF8t0+yp6Nt3TbWqlMr0woOjlmSxrpGGQpikrrfVMHaw03TBCCMF0bZKn9j9JwS1mTRpS4tkWHyrHKJVScG3CuEu7Ew/nVppqPnDsnRTc4gN99PNOgXcdfJLHd0w98Bp4VFAsFvmlX/qlu372sz/7s2/PYB4xDIp1CQ/2KN5SUj2a+EGzuNjCFrbw6EJKyWMzBl9qxYSJjcwetbLwx0Rgm1BVawgx+sYb28IjiSjJirQPiyuQKFKVFXu38L3HW34E27ZtG//kn/wT/uiP/ojt27djGHe/rP76r//6d2xwbzdWOz2iVOH1W767QZtut0krVgT9tkyls2TwOElxTIMj23fhOuP8paqF7Hs21jsNXrz8GkuNFarFKqOlGm2/h22Kfkq1xI9joiSm0WtnikGgE2UvThXP5eLCHPtnjrF9NHsxSlRGTmTJ5xa1YoVbq/PM11cQQpCzLYqOSZQk1P0w82CUWTjO3okZju18jJxbuE/JmhoetrNKOwhZaHQ4PrODQ3ueItUmWimiOCKJBWBzYOfj3Fq+xM/+r5/FMQ16nRZfme+wf2oHjrevH5zz4GMrEJiGjWfnqBSqaK2JkxDHmeNort73bxx2474uXriximXXUHcJRfpmCn27BNuyOT/f5M7aLLtHq4y5mRJ055iL45oIaWekjUr7ry0GYGCaLmma0Oy1kNLEtHLMrndp+y1uz1/itZsG+yZHeXrf/qHiQWpFL+hQzhewzDzvOfI0SZKw1FrDNjPl8aFt+3n6wBO4tosQgjNLkourikJ+il54d7vpesfn9OwS6x2fIzMH2D7+FJ7rUatkiqdyaT/bJwPCOCZVKeudBq9cPc2ttUXSvtpWAqfuLDLahI+MHHjoA7wUMkuKV/HwZ1eX1vnC2essNhOUUeK5S0s0uw0sAedXO/SiBNcysbXiJ//FvyNMElSimBqZxFeTPLHvMJYhSZRipbVOLzpDvdfj1duLtP0Ora5PGBcYKXgorQmThE4YU/Qcyrni6577nJOjFwbUyhb5fLkfeAYDM2QpJdVChW7QpRsEVD0bxzRY7vj8b8+9TLMbYNuTLF12MA2T6dHSxuxRkLdN2lHKWqdBJV9i++gUr908h1YgBbiWybn5FVZ7r/GhE++CtmCts45n2pmNhJYEScC12YuESYKMNI5l99vz5V3XhxQGSmrCJOLqUnPY+h0lKUIYSJn5CfeNV4bBAEpnc10rWG61cS2BJU0q+QqXZm8yWc5T70VcvXJ76JUbiwn+v9+M+9sYYeW25pU7MCLHWTt3nX/91dfYP/MEE+UJVJqS9v19ZaowZObfXW/7/L8/9xL7Jkf5yLE9d52XjvJ4/npKy5dYxqYgMmHiOEXipEej18Q2PUaqu/mdP3uZ7bUSDT8iZ1sIYYIwsW2rfy0qtE7RSFKdKVnDKMSPsvlycMexrEFc6yyUMBOeo7VCCoN3HXoHS81V1lp1DAEF1yZOBYY0+rYDmoyPygK0tNI4VraNeqdDGAkcqTLPZ79N3ilQLu+iHdzET3Lsq75+UKeUJv/yK1exzZhKoYZSikq+mnmSi+w6jpIYPwqZrIxRzVeGXqrdMMKP4r6i1nrgtTv4Wb3TxLEsmt0mF9eusK1qD72HB57Oe6YOEKVQcgWGcFlvt1hpd9BaU3Dz9NISXzr/DQ5MjnBi5wH+w2lNL3LZs/1kdn2phIPbFnj5ygWafkiaZnYnQZxwc3WNJyuHkUIQJ/HQ3z1MskBKU5pYho0So5hunscP7CFVirV2Hb14jars0glDri3VeXK/c9fzhdj0L21oHMthpdUFIfjYkz9MrVDOSItN3RgSTbVQ5vG9J/lPr34JKaDV9fmdP3uZJ3ZN4Vi7MO0yqVKZuloPiFuDcqHEWmOZ/372LL0oJkoVpBq/f192TYNUKYpeidFSjSAK8Gw59EHvRXFfrd/Fs/MEiUXO9nAs5wH3NEnOzSOlgR9nc3pwTK8ur7NvYpqc44J4cHHAMiwKjuTkruPDwMlUpay1G7xw+TXurC3S9EMOTu/g5K6TOLZLohIEgoKdR0pJzjFodRqstSNc22V07Ainbpyi3rnDie07mK5NgBysWZv3QCANSa00QiuEEet1L4W3HX/8x3/Mv/7X/5rbt2/z2c9+lt///d9nbGyMn/u5n3u7h/a2opoTVDzBnG/eR/JtKam+t3grSd4/iBYXW9jCFh5dTBQFM9YiSX4fDX8j/HE0Lzg0Ie+yTdzC9x9sMyvSJgrsB5C3Cokls2LvFr73eMuHfW1tjY9//OPfjbE8chgt5LCNLGm76DoUvBKukWNSwLXFBXp9j0ilNeOlPNsKFcare0mVZKnZIE4SXNtirDTCB48/y5fPfr2fWG5gSYNqoYxlZMFEZZ29uPcCH9dymKyMsdx/cV/r+OybqGX+dIhMdSckhiH7IUQbqsqBqlMpTTdOseKEsWKOKAyxbYexYp69U4coeCW0VqRawaaXVcv0yJf3slw/z/GZccruDnCK+HGK1hLD8/q+rQmuaTJe3cEXXvkSlZzLzqJNJe+y2ErY4YnXZVyFyNp6kyQh0SmGyNRY+ZH9uMYcAE6ffBHc7+G5GS0/pGYJhNjIDxd9H8JMbZgpsIpenjBOWG53+dG9Y5RGx5mtd6mUTNACIbKQro1HXwVIlE554fI30UrTCVNsE9q9FlIlVEvbOTu7RMwUFa9EzYEgydLcU5UCKa7l8NT+43z57PP4ccKBmQO858gzmIbRN3jPSMY4lWwfP8hcEgFZKasVxMyuL9IOQo7vPMz7jj6DITPLjFSDbdkIKci7eYJonSiJGC+P8IHjz/JnZ77GQn25Tx6ktPyQyUrMG0EIqOay1fpOo8urt67heRMc3LGHnVMpcZqy1qrz8rUzLDVXMmJYCBphhCJTls+MTPCBE89iGBatXhelUmzTZLo2wVR5lGuLVzh35xLdMAt2Gyvm6EUxnShBmwkTpTyHtx/qW13cf/4HwXtCGNSKY7hWFqijyXyEN4fRSSHwbBfXykiP1W7AnXaEIQUHZ44xWtlxnxmHQGCZLgWvjGX5NP3Mj3K0VGO8NEK928AAGr0AraHeXuXCnUu86+BTGRmPwJaCJI147cZZrq3MUynkGSsZeLaLFEZ/dHpgTZwVM/pKyvVOh0YvIGdIbNNA6xQpreFcBiNrVdYb40VIDCNrjZYoqoUax7fv5OXr1zizWMcwLaYqBR7bcYzp0Yxo1Toj9hGCVMNSMsb5c+dZbaecsFzWWuvk3Myfd0AwhnFIFEXknAKTtWnOzt5hbr3JM2Muj/W3uRCP04uzqq0QehMRIJDSQEiHKOmgdcBoqYYtRrmxusxSx2e+0Wb3eAEhJFqL/nXYnwNCI0VWYHAsm4JjkLMnhwUQsanUI4VEk3l9590c/8M7P8JSfZkLt84Tpl08O7NHMKUB0ux7xWZnJSNyZd97XNAOQnSaMl2r0Akj/ChAWnn8tsGuyV39Y/j661Qn9phfWGTH5BQ527uv6GkaJp7joZTiwyffw5fPvcDs2iJSCubXlzesEV4HURKRqJiSlyc3XmOxscl7ePsEz+7fx/l5A8968LZ6oU85V6aSKzNS2kbH2gl9K+TB+RPSplrayftPTBAkIfVOg1NXT9PrNdg7XsM0JEmqUFplqn6ZKT6V0giZ+TiPl0dZazdI0wTXtpkoj1ErlLly81Ua3YCTO3cxUqw+dD8FgrFilWIus/7ZVptECnk/cdFv558ojyOES6PXxDMkIwWPs7PL7JmcomI+5KRtqhxKITD698hYKVKlCFOFoRTlXB7LMIiTEEPe/0iVpgmGzAEiW68feg4FjuUwXipxaX6VVhBj2jZHt43zkWOHOLU4CJ578KcNw6CcLxPEAUmcIoRgvDzKh0++m//+2vPkrZh3HXwMy8ijhURKLwvZ7F+jQprkvAJr7Tptv03BLXBg2wFevPQNcm45s2YSg5Lo5qf5wbUtWekoRgoPJpcfBfzbf/tv+a3f+i1+/ud/ns985jMAHDt2jE9/+tNEUcSnPvWpt3mEbx+EEByelCyup7RD8Cy9paR6G/BWk7y3LC628GZwbzFgK7huC98OCtLn5D5J3WcY/jhaMFBKDW0Tt/D9iaqXFWn92MMy7l4ntNYkmEx4gmou45q28L3FWyZuf5AUtW+EJ3ZOs3OsSsuXHNt1gpJXHvp9HJxp8Nz5l1lcX+QDB3dRyXtIOYUQJpIgU6ihMSVEsU/O8Xhq3wnO3DyTvXSWMyJW6SzgSwpB3vUouDmU1rzn8BPsm9zOi1fPsNRY4p//1E/w7840syRpr3CfGqLld8g7OQ5MbsMxYpbbXWw0z+zdTsEx+U+NFp5j8p6DB/ByI2ShXQopGLbUG1KjtKBWGuVw0NjrAAEAAElEQVR/OPEsk5UCnzvrkygDQxr9QJnsQdDqJ3XXCjWObN/O7ZUl5ts+B3c5OE754Qd1E4TQGIZAK4kpJa5pkGhYTMYzNbGUZASm7JN3D1ogdBYMl21xGEg2JLQ2HafRYp4j02PcWmvywp1V/vAnfpSrq12+cctACCMLxBEZmTb4lOqTqkXX5rVbt0iSlIPTY3jlPPOrdRYbHZ7etw9peLT9LlM1D9cyh63yecfGjyPK+Sr7p6ZZbzd4+uCTWEa/1VkM9iL7hxSSibGDhME1lPKZbXbxtWS04PGO/Y9hyCxwKCPpreEYhRBUC2XW2ytEiU/BzfP+o09y9sZLXFhYJWcZfOzEfsYqM2wwEg+HZeZRSnNqOaU8uouckwVERXGMY5rMjIxTzj3LVy+8QN6KODe/SpIoxkpZ6/mJ3cewTZsw7pGkMa7lMFqqYBoWUkqO736Mqdokz517heX6Eu/au51eHDO/lPkqljyHXuoMzipCZPuptB6GAw2alyv5kWH77oMIWMhIsV1Tj5EkHdpqCctMOD4zTqE0c99nNsO2cxgywbNNlppdHNPkg4f3InSP/3rqEomGSt6hUhjh+I7DgKbttwiiiLzjMFOr8tTeoyRhk13jeSr56lAp2z/xm/6pEbqvEs67KK0JkpR8X/GftUDK/vy+v+1RCLBND9vM1pVYZS36nSBmuV7nib07KXkuxdLeu47QvbNh//QBWt0VEJIkjYZqWd3/e9dyMl9YIXHs3ZTyE1xbuMILd1b5uNLUfU1Xe8N2zTBh0zWVXZumYeHZNnGSFTbcyhgVD64vrHB2dpmdo5P3jCoLGbSNzAYla0eHI9vGUOT6Ra3+Xw6Pqbhr3chZNrvGp5kqV+kFs7iWIIyjoV3C5jkzcD1IddpvOXXoBhGdMGHnSBk/Tqh3Ij70rse41fBY6ej7vu9eFFwPpRM8272PtN347owkrBZKw7Cq9fYq5gPa0x+EycoYjW4LQxr81WceA9Edeg/vGKmy0Ew5N9/FlNk5WWln6v6xYubFHoQhBdflPQd3Y7u70QwKWfdfI6Zp4xHhVscoHHsXIlnkp971GP/tfA+tZX99EgitM+sRsXGl5RwXKas0Oi2UTig4mlh5HN55hL/2VI1eUuD5m+nr7qtlWuwYnUSI7Pp+GCEqhMA0THaOTfLytXUcWzJRKjBVdUmETbPXopIrYJiblIZa0Q56OHaejz/+FPXOEs9fuEaEwVjB48pynSRJ2FYpUvZMUqVw7UzNn/YfZPOO1Z+Lmbf9VKW8yZ5mMFZ9z1glx3adZN/Ubl6+/AoHp0v8vY+/l1NzCYMugmw3N1Vs2fAgcy0H13KGhHOUxJiGwdMHTjBTDPHsIghz+BwzWFulyO7vpmExXiqSpFkI3LbaGB977DiNwO5/3d332GwsG3OzFz3ardh/8Ad/wP/8P//PfOADH+Cf/bN/BsCP/diPUalU+Ef/6B/9hSZuYUtJ9XbjW0ny3rK42MIb4UHFgK3gui18u8j8bxmGP25ZsfxgQAjBmLlG3azQCsEzNxVxYzBJOTx5v1BiC98bvOVb+W/+5m++7u9/kB58TVPy088+zfkli5yT7yv5MoxaLh99/AOcv/4iK50erlug7BaJk5Agjim5Np0gIogTLNMgjH1GihVaQYRpGJiGiUZjSAMDhmpBQfbSGCUxk9UxfrivlvnDl89TLO7DNLOXsgGJKvoqrKJXwDIMSrkcS41l8o5Np9ujG0UstTrsqOSpVqsstlL2FUziNFNeqv4Ln9lX8woUSIN2rKilEGOi+q2RGy2S2XEwDJOc4+GYDgXXpt7q0A5CMGLejF91psbLiBgpBYnOtpxgcmtdkyRd0PaGmd+9n9cK0Ki0DYwMt/rg78pa1KXM1FYLrTanZhfYMboNUwQkffWiEFlI1YBcM6SBFJK900dZaPQIemvDeTDwIPRjTdUzaQUdgjjBsyyqnk09UpmvIJmPYMtPyXkj9xFFG+PObny27aHFXrpBA2ktIuI2rjNC3smRpH3ZRN/7VGvdV/plc8k0XNLEJ4x9Srky7UhiCMnhsQLVgjc8lIlKhmqrzWNQfTW3kILZegsrvw3P9tBa4DkFck7290kak3cFJ3Yd5eWrL/QtGTRKw1ixykipSifoIaXGczxGChUMw+j7JSYIISnmqvzQyXfz1XNf4+z8MnvHqxRtCyHgytI6u8arQ/2kFFl0l9Z3qzcB1ro9pmoPV+cNkLU42zyx/x3UW9fRcuShvqQDCCFIMQmiHpVcpnjpRgH1bpNulCnqgzjlsd1H8RyHXthBqczfsp7ETFdylPN5juw4wo3l8+RzAyPZTcUFBgrxAUUmOLT9MTpBys2lO5yZW+bwtp3khvNk8Kn7RksWWpT53aYqZbWjsN0Zdo4u9+fW+DDU8G5sXDeWYVIpjAEwVq4hhCBRKZki0BqqGJVSJGmCbebYM3WEC9deYq7Rwk+KaCRm/xQJAUJvEJrZ+ZTk3RJSyH4w2DSWVebxHR3OLCxwfaXF0VzSvw4NUpUpCC3TIOnbVCRJzI3VFjtHcwyYKt2/iDfr5geKbcOwUDrBsV2kMcXLV1/kyQP7HvjwMVyLAbAxDJNCLocGljuKgmPiGDEztQKtKGWlc/9xvG+byme8nH8oabsxXkGz1yHverxj33H+5KU/pdq3k9Ho/jX8EJJSSqrFCkHo0456HJna8B6WUtzVApUmCd0wws4MnUlUZkWRqBRp5LDMQUFsQNnd0yAvJImGIOzi2S47pw7SDnrESYJp2MPjONinzZBSkrM97LLFSmudKEkxDYFjF+gmgijt3xPvU9r3v7u/Tdf2SFL1hg+QQggcOyuqGQI6YYRju1iOpBt08axs3sdxgmU7QKZ+NoSB0jaT7giPbU+5uLpMM4gYLXgsNTusdXqsdXymaruYGpmgHXQxpEAKSZwqpBTk7RyNXgOtN5/3h88TpUEaOR7f/w7es89FSsF6J+jfC1+/6GYaJnESk6aD68XC0iY7RiZZbd6iWLL6a2hWBDOEsUHEkhG4cf+gK5UikEhpkhs6gWzqannA9+esR1t9MT8/z969e+/7+fbt22k0Gt/7AT2C2FJSvT34VpO8tywutvB6eFgxYCu4bgtb2MLDUJA++3caXFzKQsgGRdyRvMBUi0wU35xAbwvfebxl4vaFF16467/TNGV2dpZWq8WP/MiPfMcG9ihAa400J6gWUpI0+z+lFFJKTMOgVizzwaNP0wqus9BUFPKgksybc6yQY63RZC1I6EUxKtW4hRwHp2ewLXOontNa3UXYQEYWjpVHCKIA0zB5x77jzNWXOV7N2iyVUsPXPq0HpJ3EtVwmSx5K5Vlt9+hGCesdnyd3TbF9V5XDhw/z2VcXhy/T9NvI5aYW3KwdGsI4JUg0ioGSMfv74bHp/08WBGZjGQap1kRJukEuvgEEAt1vo1ZKo8UgVAY+f/Y2l+cuMTVylEppHAGkSg3HOgifSVUXzYYy6/U8dfdOH2L72C6uzl/kK/WXWWv77J3QqM2kDw8I7RKCsdIYHz75Xk5dfoFYB/3zJEiUJkzCrNVUGKSpBgtcy2DUdrmz3iRKNaYULDaa7Bibvm/7G+MekDL9fZU5njz4Dr567gVs20MKQdJvbRcMI6n6CtTsg5VCmSByaHXbCAQ7R0coOZodhUy1maY9dN+aIk4iRP/8SikwJJjSRJAykoebKyn5XBUpTTSgkoRszsi+ctZgojJK3imCbmY+qzrznjRkpsi2hJGp2Qwjm2sDolSAo21c0+aDx99DEi2y1Fi4q637Q4fG+dpthcbok+qiX+AYhDFlNhZ+2EIwszEveTCp4EcxnaBDKVck503RiaDy4OlyF6QwKXoOBbdAt73KaqvOubkVwlSRhhEzoxOMlqoEoU+YJqRKDwsrc40WO2oVJiojFNwdrHQiKvS9lPut3YNrT/fnoBSSolfgA8ffxUuWYOdoDj/OCBOlUqQ0+qT9g8crhIEpBUorWkGIxqRY3snXr36Tpw9OsuNN+NyFcUbqGIZBEGe98o65YV4phUQaEiHcTDkvBRNje+j4Mcbgz8SGglSLAem+8TvLsIakEViYZplDu9+BMk8zUXaJ04g4TvDcHKZhITDQWhCnEUEUECcJy80WjW7A+47tQvSDHu8n8TKqORuPgZACkzxHZvbi9K1qBsd/8ycQ2VqcAFGaDi1lglgQp4KCSKh6cHAMLi/3t/A6vFWSrFHMjb2uwnuAguvR7ltz1Aq14T7Fabyh1n8ABtu2TYeu37tP/bu5BUqQkXdxqmg2OySpopwrcmtlkTAOOLHrvo1nK+WmTUapIFUKT6ak2qYbdgAJQhIlUV9dbWLc4806OL6maVItlInjDrapQUrafopjDwoz9yhS7/lJqhTem5SS2YZkqlqg0e5m/tEiwrAUlmH2faJVZq0iMw9anaSkIkWpGMvMs2fHE4yMzHP69iVW2z3QmY+t0pqXr57lA7kSnpND6wCtYhKd2f90Qp+vXTzFzrFtQL9DAvHQeZCqFNtIKVge8y2Tf/GnL7Lue0yNHNi48Q4wuG8MD5DANC1UokmVQqUJtmni2R4KE01m4TPo0jDgrueJLMAupe13sAwTwoCLd+bZOTbOgLS9a07ddd8S2OajrcA4efIkf/RHf8Tf/tt/e/gzrTW/93u/x4kTJ97GkT1a2FJSfe/xrSZ5b1lcbOFheL1iwFZw3V8svBXf7C1sAbIOnKmywWonHRZxqx689tpW583bibdM3P7BH/zBA3/+6U9/+gdu4V/vKlY6GSnqGJJESZIkxTQNTJm19SuzwE8+/STLnS7fvKEp5vMUXQs0JJ7N9vFRmn5Ao+OT9/J8/Effw9dvpSRpv+2RBz8Um9Kg4OaJ04Tp2jiGsoYPcwOlpd4kvhnceMfLVWZqDnP1JjfmNf/Th57kqV3bOH36NfZN1Pj4SZuvXleYhoHoe9MptbklVaJUyljhbk+se/mIzS/QpmESpymGENimgSHf/DwY7P+AtBo8q95aXaGSd2nVr1LMl5DSZmBiIPv7Gyc94mgew3gz+t5MoWtbLoe2n6De6TJSzO5cmV1FilIphrQeKPA1pKSUK3F41wlO33gRyNLFDVMgdEgYd3FsD9nf9yBOqUcxpiHJuR7za0ugfcbLr1+lGuy/KQ1ieuQdl2cOnuT64q0+SSv7qquNcd07zrzrkbMdLAP+zkfeyf/25ecJu+1sX5WP7zfI5UawTYtUpaRpim3aZK/xkMOnlnOYNSzsvi8sfXWz1qCFHhKPOccj73oZqdMnV8M4JFUppmFimQa25WTewQOLg76y2jIzGVelUEOKGjMThzG23+DdxybZMVJFa8WVuXmW0/E+WUufPJIIkbUK7x5RlM1x2q/fVT08NoYUdP0epVyJeqfxxh8CbMvBki6ChAu3z5N3bE7uGOfrV+7gWhY520VrQS+KMrWnGIxVEMUp840WJSfHjz9xjEavwzduZX6SEojVQDl/91pgmyZKCQ7MHOKnnh6hGRi8fAeEMHHMrGAQRMkm9abY+P99RX6cJJjS7BeCxhgr1ej44ZvaZ0MapDorVtmGmdm59JWEA2QvlhowkFJSztfQ0mQk308d1ZnqVjDYR3nXtTVYz5RK+teNxLJz7J8+xCcey3Nm0WSlGVMtZL7ga4027TAlTCLyToEoaHF4qsBSOyWMAzwnx0bb9j0rlgCJgRRZgciwLQ5O7OPamiRJkr6X8gaBvhmmzNb7ga8yZIRhoLNJN1owkGmLVD6cEY/iHkoFKF0aHrvXu1+WcgW0SjBNkz1jI3TDDkmaYBomUr6+ly5kfqeX1gp0khRrk6JmcwtULzJQCtphtt1KvkgYB5y/fZFdE7vu36i+/z7gWRYqlTT8gFw+I29THSHSJGu/R20Uax4AQWa9gQpQWoBSFD0LyxwUErO/2tyav0Eea3aN5il7b279P77zKIZQvNY5g20aoAPqnTpj5TGkyM6lZfXV2zpF9r3ELcPJOkNsi1F7H+8rjnFl/hL19jn2TI6yo1am0VjH92+DnsQwPAzLwtCatt/k9PUzrLRWiZKYpw88gZCZL5hADy1eNmOy5FJwDZbWmszWU64tdxkrydedM/3lBtG/P9qmRZzEWH0ffCkltpGp8WXfbsWQkqxsKYcKZoBirohj2SilqHfXubm8iB8pxioHM1/2BxDOum+H4VqP9jPgL/3SL/FzP/dzfPnLXyaKIn7lV36FmzdvEgQB//Jf/su3e3hb+AuMbyfJe8viYgsPwhsVA7aC6/5i4K36Zm9hCwNkRVwxLOJu4e3HmzPOexP4mZ/5Gf7jf/yP36nNPRJY7UKiwBAg+r6uWaXSQMjs5wrJui84PFmkZMZobd71diuEoOy55ByP6YqNY/d9bZVCkMJDAgUGsAyTUq7IO3YPUts3tZ72r6FB67JGk3Ozu28niDk0VuapXduGZCLAkakiQgfZC969KiiRvRzGYZODEwMf3U0Kz77acTO0znRKnSCi5FoUXQdTZsrkh3k9PgiD7Q8eLsaL2baisEEU3EalLfzQx48ClI5JkgaLi6dJ0w5vtv6QBcdkSs0n9z3OYzOThDHEcYTWCkO+vk+iAKrFEfJuEY2mFyfU8h5F1+b28nUMEmJlEqWauh+RKih6RaI44uLtC2yrljDF65/vAWzLpuRVQCtKuTKWEeOH/iai7mHHNiPAhDRItclyL8f+qe2s9sLh+Vhbu4xWg/8WWIaVkVoSii5MWVlbfcnLZQSeUncpQ7PjkZGDUhrU8nkMKTJSXcB6p85aq07BzWFJsx/4NlCYDbZzT+u0yMLZAnsXnbg4nLMz1jLHpjKPyI39A0MIxs0VPnwwx/Ht4/0guNdrIoZyrsBYeXRIPnT89ftIugfB6O93J4jpRgkHJmsc2zZO2bGIlUKpmDhNMiVs/zgpnSn8Kjm3nzAf4ZhweKpIUfp95bDok5n3jlqTqRYNqoURim6J7bUCjkgxpehbBQhAkaZ3M9aZED0LOsxUv5m6z7FdPNul468+ZJ83zonWmma3gdaa5eYaYRxlCts+aavJ/GYRA3V6Rsw6tkfZzVPLCXLCB5356yWZyd6DITbsWiBFa03Bq1BwCzy1w8U1NInKru+m3yNOU4peESFSms2blDyXfWM5Gu0VlIrfxA0tW8y1FrhWVjhIdUqiYpI0HlrIPOgY3bVGAd3EZL2bEYp35l4jSoIHfJ+mF/Q4feNllFIsNZb7BFz2u4fBEJJKoYIpDHKOgWMmLDVW++Tcmwt/ilPJnTrciqZZam98V0H6vHOnwXjBQIvs/pJzXNY763z9wgvUO+u0eo27j9lDRmsIRcGx0Ei6QUjZddFKs9aqZ3YswnhDfbEQAtcpIoSNTnscHC8wVriXwBh4u27M0yRNKNoKdPqmrmPTMDm68yQndh3OwkYdi0t3LhKnEbblAWbfRmSDbM6I8uy+oVSCAAwjz0R1PztGp3jn7m1MV4vUPIeKp7GZ5wunvsznXn6Oczdf5sKtV5hbW0QICMIWi42VrFNFygdeE3ESk3ey7274GZm9a2wE1xT4kf+6+7n5ditFFmq42Rd7JG/SC32U0pmCXYj71nadtfDg2h6O7TK7Ok8157LaatMNuiiVFfDu+ebMNiUJsR/dXDIADhw4wOc//3l+6qd+ik9+8pPs2bOHv/W3/haf//znOXz48Ns9vC18C7hXSfZWnju/23grY9tsY/MgKCTG6yR5F6TP+/dJ3rfPYLs1z/v2GXzwgMlEcetl+43wdsyh78V3vlExYCu47gcfA6uM1a7GNsAiwjZgrauZ7ftmf6fwenP6UV6nt/DoYGuevDG+Y3b1zz33HI7jvPEffl/h7gmTakWqNaLvAzr4tdaa2XqbxJ9F2kVagYEQCb04RYYxUSJIkpiRnKbVE6TKGKpmhXidFzGydztTGji26JNbmRJowy6g73erMiVuGKdcW1yjlvd4esy9i7QFMAzJE9sNvn69i23n+kRTNg1SpUjTkGlzGcOYYiSv+km1si/k2zB1gIEaCsr5CcYrdQqqRScMWVi6zrFd0zi2d58f6d3ekfciOyZBHFDvRVT6Qqo07RD4XW6t+VxfajBeyrG95tDtrmM4NbrtNfZv2/a63o+D8wQSKSDn5JhrS/yoQxhHWCik6fJ6tQwhJRYWSI+l5gK2IZmsFLiytE415zIpF6jlR1juJGC4uKZBELV5+eprdLrrVMslumGXVKVv6K2qlEYKg6JXJEwiwgQu3D7HY3ufwJTW0PPzAXvJZqJlpaMZre5lujbPlaV1pioFut111ppXMMwx8l4JxzCwTcFE0UDoNU5fvIVdyTNdmUSKrH154/v0MEXSNEy0UszVG9TyHs1uQMMPMYXk9I2zjJTeg2t7D7SGuBdpPyhHIzg9pzg0njJbb3Kz3uHJHR2e2l7i3KLi5twqu6ZHKdpdTp29zp31PFpJlJJDQuRh5HuqFKY0GSlV6QY+N5cX2Dneopx/uApaoCh7BkKnzAUp+7YdAhbphBHTZY/rdZ+bq0scadWZqIzS7rVJB0FBtgUCPNtjvbVCNzQZKZSZspZZNoq0gvtbz0Gj9MCSxcC2XaIUJvOQkz6R6aBUVlAyDZNUD0IGjeE5BzYpszOZpCElvUgjCAmjANe+t9K+MQg/8lnrtFBakSrFQmOFcq7EWLk6VD0O/b77xR6ExhCSKIXZeguCW7jFw/iRJAu4enhrv2GYw31Gg2nbrPbgwNiGimjzNaXSHmG4TODXoTyJEIJ24xalQoWxogla0nuDFxGtQRKi+scxUZkNiCmt4e9fj3GUQqBNh9l6l16kuLY8h5XPUy3OgMiRakGapqy2Vzh7/Qwr3XX8sEbZc4niEMd+fZWoJrMVEVKw1l6nE0Scu3GK0dL7yLvFoW/vwzDoiEg1JDi8eidlqryx5kwUBXdWl/mz08+jVeZv2/ZbpEmMYVrM15eJ0yRrl38IWZit1RGWAZ7j0eo1WW4FaAwQivXWGuV8mbzxZrwVJaZhY9Bmvtlme63CeAHmW4N14e59EwK6vXWuLMwxVh5jm5etqa+nYo6SbH8O7zzOyvorXF9pkMYt5lauIPQuSvnKkORUfc/w4RzQ/VBABJ2gh2XaPLX3OEIs0fJDGn5Ezg9BQBB1WWt3iZICOcciSFJsy6IXJXzh1Ff5sad/mLJXQNxzb05Vynp7nZF8BccyiZQgL0GR0uw1iXuLTNWmsUzrde4fm+0+svu21ilap7R6DToJjJfHcIWFaZiYcnD9ctdxDuIAlSpGS+NcXbiKUpqlxgqebWMJE4ExvNNoUrRWtP0GvRB4xL3PHMfhr/yVv3Lfz//9v//3D/z5Fh5dPMpKsrc6tu9EkveWxcVbR0d5PHdV0fD19yy463s1bzcXA+wHPIZvBdc9+lBKcWNNsZzUuLGm2DP65uflt+qb/a3g9eb0o7xOb+HRwduxFn8/4i0v1x/60Ifuexjodrs0m03+3t/7e9+xgT0KGM1nlco41ag4IVEqI1RSjSmz0A604ovnLnJ1YZ7F1VUmRluM1XZQcItoLVnx27R6TW7PX+LPLyTE2ubE7ndmqdpCIrTgDbJqMn8rqcnZgq7OfHGTdMMPU0jRT8RWeN4Ej++t8cR2G6N+44Hbe3JnmVs3X2NVTRFpG60FQmgsGfHOnQ5GPVvEazlBXvj0KGbhPn22YLPqJ1UJo6UK1cJTXLrxMo1uwPGZcUblMj1jN6nKQpIGxNJg7qSqT0BvYkeUUjR7LeI04cztBTwroSwVdsfn2kqd1XaPpXqLTpBnvm7i6JTdTo7Rcp5Up5hisxr1we2cmszPVQhJL9RIHdHxm4w64ygVYRgPvyQEgBQ4pkHBsbB1RhYe3z7BDx/dQ2fhNif3SV651eXLr77E/m1jrHcaLDWWsfov6XNrcxyc6VFw8/epWDePM0pjpBCY0sC1HPKOwY3lG3SCiKcPPoH7EOJn6JXbH3AQgWOZPLHnOI3gNteW1lls+zTULFF6m0q+QhJFxBouL80TxilRFPH/OzPL0ZntvGPf00jTQWmDNE2GxJ1pmGQeuwlTlRyjhXFml1dZCxKiJGGxvsyLl1/iXYeeRIj8A9usH3RuBNCLNL/z5Stcnr/G4uoqX5nvsG9ylI8c2wPda3zlQn8/Vlf5z9fWWO8FnNz9NJPVCeI0QaOxh/6pG3Mr7nsvO5aNFIJrS/NI8TwfOPF+8s79gXGD1uN2kP1HmqY4TpHTN69wZ22JTi+k4Fg0fcU3r57hh048SzFXpBP0SJKEIErpmgJThtxevEIvzAiNgvTZv8fgpdspS+2BXj6z8khVNkbTkJhSojQEyaYWd7tClEJOQKcXEUu3b7uyURQRQmCbcmg/gtYkSmEbmvn6OnNr82wb2YZjOZuUdgP7kYggbFLvLLPebjBaqlHvNImSKCPGNx2jwfaFEP1CluJzpy9xZeE2i6ur7N7mMzW6F9epbD7T3HttSiGzkcuBZYnmz85dRx6uDoNyNl9TUsR95d8GkqjJnaVL7Bx5HD+2eRDuJf9SndALeuS9ylBZLqW4bz8fvKWMWG35IY6REKUppggIgpuAw5XZZW43O9xcWSRKspC10WLEBw/v5uydMxza/SSb1aN3bb3vWT5QxDtWnpxtUSDkztIFntr3BJ3YGs6be3H/0AXLncz6p7LpOXmt26PeqZOTECFJlCJKFbZUhFGX9fYqo6WxvkL93iOQqbrbQZwpl3XI4vptupOThLFF2SvQjXqk6s11GGSWLRH1yOX/9d++zr7JUZ7et5+1lkRJD6UzZXbmkw15W1AO13Bmxrm40KZc7FJw8w8lbwe2HqlOsUyHO3VYbXWxNHT9OqdvrjFVnWbnxCFsyxkq5+mvSwjR9/pWOJaBH0YUcmVO37yWrQXdHrc6EY6V3T8Ktkkl59L0A6JUYZoayzRZqC/xJy/+d5499DgTlXG8vnd5lIT4UQ8/CokShSE0lumgVYBSAVGScmHuPNVCBUEOwzY2KbcfUhTtq+GVykjVP37lNLZd5IeOP0vsuKA1pVwRoK8wzkLLBsfLj3wqhQo5t0Sz2+CFK6epFirkHBdTZv65luX0P5uwVL9FN3r0+m2TJOF3f/d3+dM//VMMw+CjH/0of/Nv/s3hPDl9+jS/+qu/yrlz57aI2+8jPCh0yZIuy21NHE0zsaI4OPEdayr8tsdmGy5rXU3cV7lNV+7+zFaS9/ceS+1MdWh1NZ71vQnu+lbmxreKNyoGbAXXPdq4sKQ4PacIYlB6koWrihdvKU5se3Pr2rfim621pu4zVDyOFt6Y1H29OR1E0yxfT9F89+f7Fr5/8Xasxd+veMvE7ac+9al7WqYFlmVx7Ngxdu7c+R0d3NuNWl6SsxPWuwKtxbAVGpERKkqlNForXF+8zVSlQKdpcX7+Fs0rl5iqjiKFJNGKZqdBEkdYjkPbD5mo7mZbbQLTyIK9HobNghwlJCe2wQs3UpAWpqGy9nBhMtC9CAQ5J48hBLcaMP46E31PWfNjx0e5tNzh3OUbHN2/myNTE4DmVD37GyHEUB3YCbPqLGKgu9WgU0YLBkWnyHovZfTgY7zvsMdMtcTp06/hTBmcnlN0I9B6QBBlSfRS3K30AYiSjDhdaqwQxh3afsqdMMRtZi3IliEpuxZP7pqiGxuQpHz88ePsnyjy2VMt8l7lgf60sEHabFY4KqDkWSyuXKdaqmEaD1aMa/SQyBEafuqZx9hZPc6rZ8/w5MnjQz/WUwu3M5/hkkGvt07bd7AMA9OQpP1eJEMIXrzyKu8/+q4+WZR5wW6G0mr4O6WzeXB8ZoKKp7kxP8tTM/vpxDZ3mhI1bHWV94y5X2nXAh2DaRb5Pz3zFL2ozX/56otcaCXYiWK0ILh4c4Vzq22CKMGzLGquhevavHrzJtXidmZGpzGkzNR3Bnd5VprC4APHP8D2SsjyrVc5efwoy40uL587z1PHjzBWmuTLVxVa6OG8eZhSUGuVBdRpWGgFVPIuMsxRyrucnV3i/OwS9UaDUrk8vN5u1VustXs0/W/yw4+9j5JX6KtNN29Xk/RDvQwhspBBrakWKlyan6UX/nfee/QpxsvjGIbFQPmdeR5rhLBJUoFt5YiTCESWTi9sC8fLfI0X60t88bXneceBE4yXRjA8malV15c5c/s8ZtIi726Ee00UBU/uMPjChZREaRwjIy+TRGCaZhYel4Igxe1Pj80pn+tdRUw2VtsQRKm6bw5s9o+Ok4C94yV2jlhcnb9KzingOi6WlIOrgjhV+FHAevMmn3jyEOu9BqaosH10DJU+wERYb1iIaA1pqriytDw8b44ZcnvlNvu3lTf52DJU+N8z2MyOAZF5Gy/McmflJs+MuZwEPMfEkhI/Tsg/YMkMkxQrafPkjKITC752XQ3KFw+ElFByDS7NnWf31FFKbgFT3u1z+0YhYoIsXCvvCmzDoBfFlE2T1dY6F+Zvg2kxUyvR6XQRpkXJc3jl5gLzK6tMjFSpFHYipPXADQ8INNe2eXzXDLYMuXFnliRpc2Kb4uXZzOtwYy3uD2hDIrpp9JpECVY6moq38dPRQg7LMNAqZbpWIkoS2p0uxUIexzK5cPssJ3Y/yUipgkCQqDQjtY2s4GaZJiOlGr2gx4tXz4FqMFbcQ+PSTZzqHmr58iYbjNdHpuJWVPJVBDXOzi4xt97kyfFRqlNHWetBEMS4jsNoPgvjWbim+fET7+CbN+b4wvkGecfp7//9RLMQAsu0Mj93IRgrV9heFbTr65RqZRYaHcJwHdeQSGkMLUm00Ehkfz6AEAbjlQJXFleJlaYTpriWhXAsHMui0fNp9AJyhuTxnZN0wojnL96gWiyggXYQMr+2yJ+d/gpj/eC5o7uO4JoWSd8n3jAMIiVRKqbpz+FZYJsGa60Vzt46zaGZw9jDoktGSA8U+puhddq3YjG5ujhP0w9IOj2+dPp5nj74GGOl0WFAoiYr7mid7adj2ZiGSRRHFD2POO4yX1/mtRuvsH/6IJV8GcewkEKg0h6NzjxJ0qHgPPx55u3Cb/zGb/CHf/iH/NiP/Ri2bfM7v/M7BEHAz//8z/Mbv/Eb/Jt/82/Yu3cvv/d7v/d2D3ULbxIPUpKlGLRDiFOIcXjhpuJOPaKWE0O12s7q2zO2N6ty20ry/t5Ba82FRUWKQc3pP8uI725w1/dSAQlvUAzYCq57pLGSVFi4pVA6s2XUOssV8WP45i3FlKy84Tbeqm/2t6J4fL05bQhNO7BQIUyUBsKS795838L3J96Otfj7GW+ZuP2Jn/iJ78Y4HkloDUvr19HGDI7lkrGM/ZcjoekEXb5x6WWe3T+OELDQ7pFqyfaREteWl0iSlIPTY4yVclya72KmsHeswtnb5ynlCpS8HKlKyBvF+757Y3JmIWajOdg1Ipm9s8C6nMGPZF9alf2dKQSaBENaKA3tAFLGX3eiG4bkyFSJaElzZKqEYcj7PDMH6sDX5lLmm9kFZsqMLBJJSMnNvHBLLjSTPAWvMCRoDk9IjkwaXFuO+dzZBsJ0kITEiYHn5ocHWZOpqWzLxpAGc2uL5B2bvKO51GzTTTT7xqusd312T0yzd/oxpOESRAk36hbSyuEYy3R9g7xXAO5Xsmq9yWdTZORQxRFsq5QoGT7XF86zb/owUtr3fe4uT1ahWeq6KCEYLY+xvVZGSsHmw7atUmKmlGOh0eHA5AjVvMedbo+K1lim5NytC5iGwdMHHsc27yeLDWlgYGSt8GkWxgRy6Fv8zN4Z1ruKW/UIIY2HEkwDdWyqQWESpdnYZhs9ImVwcGqUNE25ttYmSRW1vEsQp3SihNGqQ842eeHKaQq5IuPFElonGJsKDbofWObHJldXHaaKM+werbJ7tIrTWeWxPTMstu69IQ/IhvuRecNm83WsmCOOOnSloOg6FF2H//baFfwg4Mf3777rets5UuLUnXn+y0tf4pkDJ5kemaRg5PoWAhmJa5kW6Ez93eq2MAyDkUKB+fVVbq7M82E9TxgEuN6uPgGqMguSlH4bmcA0sqCv47uO0gt3M7t8Cz/uYAiYq7e5s7ZIdK7NaKmGRKJQrLXXWe8GVD2TicLdqgbPkuTslHagUFpiCJkpCpF9H1uQOsGxNo75IOXz2krC81dSijkT15DMNtMHXuuqTwAKNJ6lUIbJ6dlbLHYD3n/0SUx3Y+3xwyZfOvsyrV6dn37XCWo5TWP9Irmpw5iW1z/nG9+x+atSlZJqxc7RcVTaHJ63WrEEmkzxu4kkvldpujGHsyLE/m2HuLZwhVMrKYUrKc0gx+HdTxFrjSVjonB50zzUrPZC3rtnJzO1Equd5C41ar9ccF/L/WTR48LsLS7Or/DswccYr4yRdzL1fqpSHMt9qMFDFlSmqeU8tlXk8Hovug5Xl9cJk5TpcgkEtDpddtRKnNw+waWFVaI05er8NY7tEHi5Pf1jKjdtXQzXKCkM8o5HHAfDfTw0WeDmesx8a3AcRd8W4541755R96K7/+aJndPsGq1w7s4io1oxUqxRdkqYtknbb3J5YRZTp/z1D36Ueg8WmiG2aRMnCd2gSxSHSMPAMiwObz/ImRuvcWLbJN+4eoczN17hsf2PI9+UTUK25knhAREFx+PA5AiXFlZ55fZNfuU9x2mGgnMX5zh6YD8jeclaV9FWORoBPLVrmi+8/FXCfLkfgvgAhXBfrSukidaayZKDSh16zWyelqZcbq8HxColLzOP6ruPY3aMNYJOZGAaNmGS4lqgUoNYZJ0YY8UcK+0eQZJScGwq+QoHpxLacYLQPoYUJGrDC/zW8gKdoM0Te49jWzmqBRfHdKjk4Mq1y8z3WhycGqXo2pQcizur83SDOk/ufy+1Yq1fUBSbSNvBbN+YU0IKju86Sq1Q4RtXXmNudYGvnP0qO8a284Hj782OvRR9W4zBPmukyO59edtgTWuKjslyc5U07ZJqh6Jt8diuaSDg1soax7dPsK1aelPn+3uJz3/+8/zqr/4qP/7jPw7ARz7yEX7hF36B69ev82d/9mf8wi/8Ap/85Cc3+cdv4VvFt6LW+lZwr5IsiBWhdhBp/76JIkklN9fh5roGppi/qvAsqKnKd2VMDxvbm1G5bcZWkvf3BvWepuFrTJIHdFt9d4K7vt258a3gYcWAreC6RxdKKRaTcZQAq/+qr1XmSSw1xIrs90o9MOB0gDeyylBIrL5v9reqeHy9OZ3ojDjWGhIlsDaN4bs137fw/Ye3Yy3+fsabIm5/8Rd/8U1tTAjBpz/96W9rQI8S5uot5tZbzIwPWgg3kw6aJE1QWtMJIwBaYUy1VCLu2xhorYnTTKWk+62esdKotMtzZ7/O0wceY6RY2SCYgA2l1CYig+zh07M1Y2aDHzqxg7MLipfvKIT4/7P350GaZelZJ/g759zl230Pd481IzIyI/fMysqskqooiSxtCDHQUmuQoKWhVMwfI6wZTIYYBmTQ2BgM3WCoRau7sYah0WIjREOP1EKgvSSVas2qrNwzMjIiMhb3CN+3b73bOWf+OPfbfAuPPaoyX7NY3L/73Xvu2c/zPu/zKvxcii/L3KZVCKeB2TZF1tuWifLteSimq4Jnj3hsdjJM3KFaLhMo2Kr30cq9RO6llJya8piR11iyJxCqTDFUPbYeOdvHWkOSuIRKJw8d5qvvzeF7yiVy05rlRosTU4d5/tRzKK+EMSk6a9MmZLlRYGLkCK+ff51kZJZScYTAK/ZYsi5cvOvFcQtLO+5waS3i2MQMHz8+yVdWIt6bf4szxz6KlB5CSNfSO+QMjGM/7RPmIaXo3bOrK7u0tslSowUWaqHP/Oplzl87z/Onnubph57G9/0dAKxAoKQiyeDcwvKQbrHLMi8IZFeDcq827nJvJZ3Ucm2zwXy9zamjswghWNhq0kgySmHgMo97EMUJSZaBhaWNJf7ozS/zZ5//NmrlQwwCr8a4pEC+VBgrdt1IJFoMfAP2Am0H39lYQ7NTJxw4RzeiJNdz3Tne2qlLGjS3tsjy11Z47MgpXnr6E4ReiBEGbfvh2kpIaqUqURJR77SdbAaWpUaTY0EZsD39UJkDyYnultn963shE0GZ8eokUdJhcXOFldarzK8u0EkztLEu7N9YokxT9D3SzPLa/AIfO3W0V5axkmCyLOhEBk+6MWtxbH5fOlZokHUYKw6vVG4hE0hhKXqQWeGYxLYLrHZDw4VLEohFCoi04vXL88RaY0yTty6/QrlQJUsyvMCj2akTdzbopBkvv3+NJ45M0mqts7x+lmZa5tjUo3lCr25CMpsz+lziMqEEsngMayYoFGNXY7aDxTgnhDG9+Wlvc5OlUmUePvw0aZqx1NDUCoqyl7GVgrYhfniEIFylEcUsbDapFQK+9+nTfVZv/s79PeTgrOoA0XcXV4mzjFZnhd969Q+ZGZnk44++QK1cY6vd4OjEzA4W8+DdhLBMVsXQeH99bonleouCp0i0phklhJ7i4elxpJQcHquytrFJ6Cuurq3zaPHk3s8QEms1rbjDlZX14XcU7h37nMv9zL11ORiueM+TfOZTz/E//f4bnD7yuHM45H1+rb6OUhf5xJGATz+q+Px7S7w9H1Er1Vhvbrq6NRYhBS3boVaqcvrwI7w+v8j3PX2aNy5c4vVLX2dmbJaZiSd2RBVsN5OzSZTycqaoYHa0wvvzC7nm7QhV2SbV8Efn9Q6ttCenR3hr8zKdZIrJkcNDc6lbX7vOBoE2ms3mMrVi32nmIiVqpFpT9DWpVnSyft05c2Mq1ZZysUpjfZG51WUqhQBjLXGW0YxTpqolKoUaqTxCpTTKC2dOEOvMJWyz73L++lxPC1wK2Gqv85tf+32OTh7i+04f5jsfeYGxIjSvKaKVIu8trjEzUma2WuJKK+Hq6hYTtUuMV8Z662eXyeLeBbDd6AZLmmUoIZkameK7nv4kn3/rSyw31thobeVrzM7+1117pJScnHkMYwWmvcqmFmy0InyVsLLeZmrEoxWnTFSKfN/A+HuQbGNjg4997GO9nz/+8Y+ztrbGu+++y2/8xm9w7Nix+1i6bx27l/p0g0wyay3NOP85X192mxONhVYCbQ5zdsnw1OG7A9TfLMttN/swk/fdtzhzUYRyjwTRdyNx153oG7diuzkDJisKYwwLd/ZRH9odsCsbkOG5+czJ6/dMSFAWMutxZQNOTux9n4PqZo8W4Q/nDsZ43G579WljLO3Efaat+5lt+4O71d8/tG8uux9z8Tez3RFJ8pdffplr164xMvKtFcbTiBJGqkdQUmJ0E4skTVN83yfJUoRQnDn2OOutS5SDAG0svpLEqabLytID1B2BRVtDtRBydWWNNy99nUJQ5vDYMR4//jhK7a5fVQ1hrQ0vX9GMmaI7fFoxtFEdmtiFC61Ikay1YKLc/yzLDF+7NM/XrywTVeeYqVa5vNFkYn2L4xN7x5G5bNGaRGdok2G3HcT3Erk3xjK3voXGUi2ERJnob6zzRUAbTaPTQJuEoh9waGSCmdEJ3r12jSh14eq1YshHH34aXwUYHZEZi7aWLEvxpCbVkhNTR1hpvM/ZFcHs+CnGKiN5VnCZA+Mu/D3VKdfWFjg95gEzHBst8/jjj/O7b71Ps7NJ4Fdc4hbl91Am0W1RoxFYKqHH6j5hHt17/tbr5/mT964QZRkSx+4qBJKJsVESbVhvzCPEsz3AUubAco8tKAS+FzBZlXzPkw+zeu0qc+tbrDQyMi3wPb0n8NM3B1wvbnYIVEapNE61WANS2rFzPvjK3WOyNoY2gnKhQL29hRBwbX2R1a1FauVDLrN6r4s6Z4YQFoXYdSMRejv7540siiPiNCZO+kl/Ut2f0JNM5/3GlbsVGwc04LSn37t+ie986ttRShKnyRDz0mAI/QAhJK2oScH3SNOUdpzSSQ1+luL7Iu8vBjmUrM713cALehqrSnlM1Sb4nmc/yVtX3uXUzDFGy6NI6RKI1DtbXF2+yDtXLrFSbzO3vtUbb0fHRpkotbmynCF8RTlQdKKUYqgwuXe9bFpsdCYYKw5X4KAnXefUamEzbK4X2y2rsZo4aSOloh0bZkbKvKsUoyXnPW926jSbTSo5G7gSesQWpkfLbLYiFhsddNChFHokaYQnNL7fTeInEMJpbWY6wwJZFuN7RcYnHifN1ikG47leqAJkv2/vwg52Gr8uyZS1GZ4qIISPL52cBMBUtUC9k5BZn9rYadbqlzk+XmOckNBXGGNJtUChQXqYHMzWuVSGEK5dfAUbHecAmCwFpMJjub7Gl9/9Gt/x1CeoFkr7+kOEECig6htefv86c1stPnryKN5VyfmFVTAaL804VCszIg3j5SLGGDZaEVtRyndOjwM7KQYi/6u7P7YINlutoXdcazrNswIxwi8RpduHV1c6YfgFdnPgPXX8JD/w/AhtLdlqN0mShCAImB0/xBNHj/KQN48Qgq12RCEoEKWONapNzuq0AiUFSdphrDLK/FYHYzVHayVaXsjl5TmMmODIxEwvLH+7GWt6/WLwXFAMfBJtaEUpcANtwMJD/MBz8Nuvn6OTjFP0C7mPaVgww1pLnMYYQq5t1Lm+1UKHdY6MjRB4LoEh1jBRUSw1XNi1a5Jc4kXYHhu3Vixy8tCs07hNMqyXMV0rc+bwMUrFY1SKZZI0ohN38P2Q2fFDHBodp+x9hXNL14nTDGOgHWc8MjPBZz71NBNpvQfUDK5LFxZXaaYZx8ZqTFVLHB6fIUoilFJuPusyr/PS9hjnwjFpjTVEaUSlUOTjjzzD5976IuOV8RuyTAWC8coYk4++yNLiGxhluLC8TpR62HKRzTZ85MQh/swzj/DIzD4nyPtoWZbtSJzr+z5//+///Q9B2ztk91qfbnD9Q5DLCjkig8txuYtcCl1AV/DqvOGJmYPpb99O2W7EcvvQ7p+FnttjZXskJL4bibvuZ9/Y7gz4MOT4wbV8a7od5+xZ9/fd6/ayg+pmb3Y4MONxsmJZb9teVIWv7I4+HRufVsNFe5JHuq22YKQwvFP9cC780OD+zMV72W5RQw/aXHmgavjH//gf7/r7paUl/tE/+kdcu3aNP//n//y3XHIyCCmFgkzHKAEu0UdKmkEzSogzw0h5hPPXE6zZwlhIdZ7gJmfBKCmoFmscmQhJTYYSjoVb8BQfOeEyor8/d5alaokjU6fYHkoekDBSdAf8egQL6SH+6IJmqQEgSI2bHHd4cLsHf9ufZH/rjTl+5ctf5/LKBvVWB756kZmxSabKRb66+gbHxot88tHTvQ47lu+1Lyyt87tvvU9kZvBUkfXlDcphQFEYRvJn7CZy3/3ehcVVJkdOMyoSfGlRXglrDZ6nsNZp+FQKRbbaCfVOhzAocn2zzWrLhfBk2lDvCBAhcdIhNoY006SZBpFxfnGVQlDAV1Uq1cd5rKZINTkAZOjEMVmWuGRoQhKlEWevvsN/+fzHe2U9PT3OIzOTvDG/xVcvJmghiZM2vl/IGU0Si6HV3mKrA+UwoCBgs1PYU9j9jQvL/IevvYMmICyMk+iEeifmyaOj/I3/4k9zdGyU3z+7zOUNByrLAddqjzeYJ6BbbXr8wp+8RrtZ5/PXm8yOzxCGx+jETQK/5EDmXWwQCHn1WoInFY899AKBrxA2ZqJmkeJ9JqqTPHPySUbLIwgh8SQ02nWi9BUWNlcoF0r5/XQvFDkndfZ0TmHnRqIH3JouMGNztuDOsG5jDHESs7i5xLtzV2jFSS/pTykMeoBt4LnnKylItcFTTg5BCqgUAsYrYxjjwt0DzyfRmatH6eQItNYYqxmvjNFaW8ICV9a2WGsZXnjkCCKJKYVFfOXt0I3smpRO9zIUzpFQKZT41JMfR+uUKO3QiRLCIGB6ZJLRUo31Ros/ee8Kf/D2+72karE2hJ5irDjJw8eexvcCBAFpx9VroKCVTfK59zQTJfBNX67AWotCs9HRtKM2iAKZ1lhcIiwlFNZqPBEzOlImSTK++xNP0GjV+cr5K3SSFL+4892SzFAMfH7sE88yM1LmP33hZdYJuby6jhYbTI9NUY/WqYQFfK+ItYI0SxFSkiQJq406AhivjFIuHSPVKZlp43sFl9Cu62QQfU6U03J2TpXuJq8Tp1QKblCtNDpEaUKcJJQSKIZlCtIjGAkZqYzQ7NR57eqbnMuTWn3y0dMooZAyoxEbrHX31CZDCItvE0KvwngxwFcKjObwaIUk0zRaWyxtzHHm2BM95nhvzd6mI5sZ+L//yh/y9vwcrU5EuTjP9EiF6ZEKVWk4dfQw1ULI0tIil5Y3eG1uifVmmyTN+P/88aucnD7GD3z08Z4Dy2mNMsCetEgEU7Ux5tfmeXN1lXONL/PI4ROM1k7hiYzRspPF2Yzc9UOECIeQ5+zgoRfo9aOzi4ZCEHK0WqAe+Ww2moxWK9QKBbYiuJ4eYrWpCfwKBV8RpR0Kvocxlkxrp9Pu+bkTxeM3vn6e84uuPkqFkPFykU78OtMjowR+ge36szaPqPBU17GW5s4A6CQpgZKUC/6BtAGv1yWBH6B1Rj1tUCmWe1Ip3fml3q4DgjfnV7mwMEeSZby1VGe0XOTMzDgPz4yQ2ZoDbC1gMyyqNyt3k/1hoVwc5WNnvp1n0zZLK1coFqAUGFRwFAiZHQkQImCrLhipVSl4HuttzZ9+4iM8drTGtY2EZjumWg558vAIJyZHaS7Uh+qnuy5dXdvgldffJCqN8IdnFwmDMuvNTYy1jJYr1Eojw3OqINfmNRjhHFG+EiRZxERtij/34vdSLlRvkISPfHxmeL7H6OhDtOJVnn7oFL5fwukcSzxPsxXdnyRQt2OHDx++30X4lrC7oU83uG/dTXJhkEkWeMNJGs3wpUMmhfs8SuHymuHE+J0/kB2U5TZWck7ED+3+2FhJMFoUXOt4O/rm3Urc9WHf+NAOYsVcHc3Y3RT7+3Nc8QCS8gfRzV5uHozxuFS3vHk9G4p4GimAR0YnBV9ZmrElprCDrGMsbHYgFO6s+mF/fzDtXskdDdr9mIt3s72ihp6cVUzXHpw97i3h18YYfvEXf5H/8X/8H5mdneWXfumXhkLRvlVspFwm9A31dodynnQj05ZOEqONwWiDV1CMFItcWdmgk2rWm22mR8oIITg8PsMLj3yUWmkEbV2IZhQ3uLx0ldFii9HyGMa0KZbGmB2fpuwLOhk9bUOA1CpasaUcCpSEui1hm1BQ0M4P4g4wBtk9uNmup8tweV1ydkmz1p5moxNzbOoJkuw85TDimZNPOVaqVBRDx0L88mUoqllWz2vKAWzWy5y9/B5LW2scnxQExWOEQZlW3KGeJRRLCVb4KAFl2WcHzm22+Mr5V9loRxydmGKkPAY2pZVoyrKAEgZPeoAiTjPAhdt7ngvFdprCztxbOTA2Sh0wLqXjFIVeSCms9pKpWFsk0wlb7U3iNGasMkLoh7m+aUajs8HL599E6gbPHx8+uEkpKHopZy9/g5npM9TKoy7BnNHEWUwnbuPhMmk3opi61niFCnHmFqLBQb/cPEQ9yfgL3/YXcqDNsQm3Ok0uL13lD88u8JlPjTE7Os6VTcdiVtIbemMntZHiK59OCtfXtjhRDRgtF7i+scHhyVmiNKEQaMYr4zfsz74X0uo0aXbalAoFaqUKx6bO8LHTbU4feZRiUKAVtdE6pVIsMlIZ4zue+na+eu7rVIJuqHF3G+FkCwKlhjR+d9tIuHfvJlETPcC3e9yy1hLFHTKjaUZtXr7wJlZHVAphL+nPViui3o4p+YJKGCCEk5xoRjGjpXBIO7IYhm7xaW4yUqqihELkLuokS2l2GoSBY412khQpBFGS4qs2zfYW47VJ1urrFIIC49Ux6HkBhxewrhZp6HuQOQCrEzeRQlL0QxCCdtzCU0WeOvEkm/ULHB6v9pKqbbUiHp45ytMnHkZgaXUaCASVUhVrJVEGAh+TOEBcmsNMLBmWGprVpqWlA7QGK1yGeCU9B9jkgKNLGBZQ7xgqosPjM9NoXWGmUmSx2aFSCIbAHmMNW3HKU8cneOGhI1xcXuPV6+vIQpkjY1UuLF5gtDpC6BVpJxkjnkv0JqXCWEMnifGUR5qlKOWhlMdme4soiSn4AaOVEXzl98DbTDuQzkUviF54dmZSkjRDhw50jDODrxQqKFAIK1grSLIs1zZMKRdqPHnyozQ7c7w1v8hKI+PI+CmyBNpxg4IfYnSGVB5RGhN4BcZFwicePtTXeMUS+h7V8RlOTJ8c6rtiQNe863KwaLSFVuJRLQSUpUUGAXOrm6TGcKgY8GwhQKkiLVPm3PIGa802MtdCbScpvir0xoDTdzZgnfZ4fw6ArcgwVi6g8kR9FxaXOa1mqKi8PML2SLa7mcEigbW2YGxAdWNQV0pKwWipiMgSCkGBjQ4kGjJb5j+/Y4FRSgVN6IeOxZ3GYAyFsISUqgcJHzt0mlRnrKxdRwYhi1tNomSDSulrvPjIR/C82tDGzPS0x51T1JgMa51e88Jmk6MjJY6M1m6oDWiymGubHn44SyksYYybc1KTEacx2mR0kg7GCgIvYLXeIPAUvgChFKv1FmvNNkVZ5MnjJ/JknJYk0y6iIHcCdp+tjcn1dH2K4RgnjoxibYIxMZn1sWmHYlBDIEh8RdH3XfSETElEmXL5EZ4bL/XkJhqdOr/ylYt8ZCThuW3tJ6Xg2PgIv92M+Hcvv0+lMMrjxz2SxKKUpBVFVIo11C46x12t7X5dSYqFEp6nyHZLOLiLaWPZbLUohzVKXhmBpB13wGaUggqpCfjy+xmwwQsP7R21cz9tcXGROI6Hfre0tLSDcfwhmHvzdqf16ZYalneXhsGB7ZILg0yyjiPk9xj7+obnTDdOVlr2rgC3B2W5PWgsng+aCeGSXC6uaxoxFP1+O7VTdpxpbte6gEhZtmjJUeqxk7r6sG98aNvtxJgDQ7UNkGZYXsx2yVpknBg7GIRzI93sgzAejRW8u2wwdjjiab0NifUoCsfabQ2Qd3LBpt45w+L2cYm2RB/29wfO7qXc0aDtNxffqySK+0UNfeVyxrc95D0w4O1NA7evvvoq/+Af/AOuXr3KT/7kT/LZz34Wz/vW5LkXfUG1EBAlPq3YaRV2Mk3mSIMUQwcIbnU6VIohjVabdpIyt1bn4emjfPzMx6gUKr2zlEAwUqpyaHSWLIuR0tJo13n0+AnKhSKlEGLttHC7m1CLYqMDndT2wg6KnptotzoanU+0Fhd2YHMQt8sQ2upAKYClrQ00kpmxKcarYxhr8aSinXRIM021WMFXHtpmtNMILy2yFUHmHWdy/BDT4xFJvMzKyjvMzj5OKSwQCY+NtqZS8NGizw4cL8Jry5r1doczs5NIWXRyBVJTlAqtU5BeL3mWY5UqaqUavnLZtT/1xIs8fvQ0X7vwBlJKPvHY81QKJcphMdfw1RT8lFJYyHVKZX6YN/jKZ6I6xlpjg+vri0xUx2i0G7x55XUuLy9SLYb8xSeOopQYYnWMlwy/8+YFrq8vcWSqTNxpgpohypKcaa3JBFSKEi/waXQsrSjGl2Fv0HstiydhK4qpFKsoqTBGU+80KBfKjFVGOTF5hLWowx+8mzJWoqfFmemULuMQHBOxG/RaClyCp+uNDmceCikHhrXGBuO1CZIsviGbxSVTSikFkk4siLOURqdBOazw4iPP00lT1hqbKCHwlfu8GUXUilX+9FMfJ7YZJUDmmrrWWpR07FejHftQoqmFaghUiTJIdepAeeHAj1Q7eQdPqZxdKCiERTpxh7eunmNxfZFDtQp9KMoNuGLoEQjL+aV1jk8d4tHZ48w1WlxdWWK8XGSrFbHZiQkbTbRxlLnlrdVcszgHXHSGJxVKa1pJhBDCyVPkz7l47RzVco1KsUKWM0C71tW+3Vm3BQq+0wYthRVU/l4WS5KmtOM2h0YmmK1GGNPpJVU7PjnCw7OnQXhgE0LPYihgrAOgu5zULgc/JuRrVwzdRAXaSgwOVDK2y9h2YFiWs2B9L0Qbw9LWFuutQ4yXBX/u8aP8u3euc3V1i4cOzTBWK5JhabZjTk4f4S99+/MIAb/z5gXqUcqLJ8YRQlARK5y9+gYnDj3MWGUcIZQLT8UlRxqr1LBYsizD8/xembSxRGmCsBFapxgjCIJSzn7qcUzxlNNca0dttNWQz4MFXwEGVIhAgjAY7bR8Q08ACUr5jNVOMFo9Sqo9OlpRCHxqpXGsSUi0xpOKaqFKo9NkfmUBpZ7mM596jv/mP/w+V9fqTFSKvHj6WZT0aHU6LjnZAJu82xa+hFbi+vDhsTGSZJVmllIphFQKAReXNlDhCJk4SqlQ46FjRzhyOGOzucXc6hzLW5u0k5g4jZwGsbEoL08ymNeJJ52jz1qYLHtYO4qJBSOlEWrFiGangShUHfPVdPtKf4PcN4PWGqE8rBkG9nbTlcqsYrMzyFrLE3VZp/lspUQJj8ALe2PKAc6WJEuZqI5QKz3Pa1qTmA7ToxMsbnaIM0W93Was6pJHdsdilHYAQ9tklMMqaRrTShLm19aGNL2TzL3dbtqAFks91gSFCmXpkeoUKZwzQSlFQYRstiIARso1mp02UyOjzK+20FqjpCQMPKIk472FOf6fxwRvLViasUFKlbNSu8n/nPSOkLIH4dte7SuMDQi9EM8TpBqCAVaVxbLeign8IoEfYExMkrYJwxKj5TECr8hrK2f5s9qwFYshxkOWGX7z7DyNTsrxyQCszaV8rJMPMt1xOMBU6PZZ4SSLkswwUnbJw5pRC2sFleLOxKjbTRtNkiaMlEewWcpmaxMlJUVP4RR2MjLj8fUrER85ZnLHw4NlP/zDPzz0s7WWH/uxH+utmd318+zZs/ejeN/Udif16faSQ9lNcqHLJDu7aJjftGgU2jjALdtlnd6+PfLvgh5zF5yzuMRP17Ysm212Zbl9aPffpquCo/4iWfk0mx3HRmwl+fonYVVP8PlcR927DbmPIWeEnsDX7hlte+/6xo1Y7B/ag2NSSma8ZRbMUdJ8TjO4eVZbd2acUctI+dCB77mfbvaNGI89rVpDHl06HPEUxYKS78rWyP2j3Ugvad2eIDPd85OgFcOh6u339w/7dN9ulyl7r+WOtttuc/G9SqJ4w6ihGN5e0ByqPhgSMwdGXDc3N/kn/+Sf8Gu/9mu89NJL/It/8S++5dkJYyXBTM3H2BrNTpN6JyLOXHho6HuMlCrUG2sEKqUVZSgpkUpyfGKEb3vso1SKDsjo6mF2AW4pBEYqkrTNWGUSKT1knqjEWjCoLlZF9zge6+5h2iKlyyrpk4H0c00vN7GmmkF+DVEKUaZBeAg0zajJWGUSsCxtuszs4xXHktE2QwqF9CtO8gEHAvnKRyApFI8Thilx5OTsN+oZ/qFHiDM30Rs82gm0YsPo5BP4nSsIkSGElwMgHpA5ZpWQZMaBUAjp9H2ly1i+vLWGMYZjU7OcmDrsgCijidOEwA+QQlLwfQq5jIHtAUQagXNPKikZq4xQb29S7zTxvYB2nPLo7CR/6dtfQCWG331X00npeZZCFXN9UzNZcqDERnOZFMXUyBRRkqGUJM0yMuPC84thkXp7i1YkubBWJLU+NoN6phmtjNLTrZWSscooxhgynbmQfaW4sh6z3gocU0r5SOvCurumcqZfnMWsbi1RKQRs1Js0Ircynp07y8cf+zilsOhAil2yqfd7gkDKAsiASsGQ6Iyi70DyICiRGU2Yh0Cn2qAwlMOA0YJC+aNkOiFJOgRBMV+QJZ4SaCOH+tsfXrBMlHUvrH+z1SLJUjAWFRQAgRISqfraqAhBK2riScWzJx4nSztAG08VUbKEpwTlMGB6pEyjZXn6oecQqshIVXDSWhqdTZY3rnL2ygXWooyN1gYbzU2mR6eQwvVNqzWRMSjlUS1WWG9soLMOk9USNtOMlgq0k5TVrQWsepUnjz/OeLWr2dgFvAa0IwfMU3mCLusm/ExnvSRthSAg9AOsycjSMmv1rV5StVpxlLHKKM24haeclICvgh4U1H1mOnAezkyeNVsYMpPlTEDb62tduYGuxIMD2CXVkeP83rmU6Zri8SPH+KkTj/H6tYyCX8X3PHzlI6VAYWiZkP/8dmdoLADUCj6TFZ8L119HyhovnH6BUqHYT6yYd10VKISQrm2xlIIwZ5RKlACtE4wJSLIOUhYJPB9rDUmW0mg3cvZ51yGVg+3Ky50GTg9VKUWqU0TuQDAmIwhqGJOS6DZr9U1mxiYJ/CJCFQkLBYRwofj1rXnm4zWubZzgu548xfvvn+Lz1+rOyVWs0YzaFH2/n9Aq/8vpsAoSY1G5xvexqZNUSyOcu/I2iekgheSF009wevYM1WKRKIloJxFFP+Tk9HEenn2IKImJs4SVrTXiNKEQhKS5lIuLxLfIwMdagdYJQTiBkgWC0M07xkRknXVSXWaxadCmW84B9vSAFnV3bnSOob7geaBcP8usR5wjHbENHOs372vgDg1KQZRZB67bYYC46zhIsyZpFlMMSzz+0NMYa6gUqjwnFIWggBSQpDFKeUih8DyPqleh4EEndeuW55cYCU4zNXqS548FqI1Lrqz7aAN2kgzpuXkp0RGNTkKtWENJ995KSMbKo3ieW4cqhRLfN/pp2nGHl9/7BueuX6ASBoyXCmx0OsyvL/DE9CjvXG8Q+iUQGgtIWcrHwjA87maFrv61j5ASQ5G1JngKMD6JtmSZxuD6ldUx/ZXaYE1MwQ9Ja6f47bMxqfGHGA9Wr7DY7DBRq9KOmjSjBpVCjShtO+C8ZztZt0I4p8h4ZRQlPaI0opPEVAvF/PPdHVJdqxTLPZ34TtIh9D0nY6KNc6RgkCIj0T7nFps8caS2983ug/3BH/zB/S7Ct7TdKX26/eRQ9pJcmK4KZmoer85lvDWf4nkhgepKxwzdHecwyu8LHL/D5PAdbKUF4xInzkoW53ay3D60B8MqssOzpyUbHfj6O2u01BGMgaIPNh7QUd8jGfGNbDdnRDko9Fi9k2qNF04fv6t94yAs9g/twbIpb5Ojs8d545rJ8xgojHVErKcPS+KFzTv2rBsxHpUEiaW0R8STR0aUwdFRyXLDANpJzQnIMpco2FdgDKTGcmpC8tHj8rb6+4d9um+3y5S9G3JHt2KDc/G9TKJ4o6ihku8+32hbxnfJFXKv7UDA7b//9/+ef/bP/hmVSoX/+X/+n3nppZfudrkeCBNC8OSsohFbAjVCOQyJk5SRcpnAL2BtRqtxlRdPHibKPFY36sQI/sqnPsK7KxUy7ZInWatccp08HNhiCbyA0A+7MoS0EksrGe4QdtcfHIs206BxYRS9C6zFCPByBqG1GiklSQajlVGaUYNu1nmswM91UX3PZcX2RF+D0thu6JnNQRSBEJLJqccwJgETMzku8DwHnkq62a2d1y0MKyh1EilSlCoBfg5MZFhimu06pdEJMkMv43iaJWy2GlQKJarFSh6K6uok05pO3EFJNaTX2GVsujKbHPw2LrmT8jh1aBKspt7R/OT3fCeBP8JSA6LMILbAkwadJRSsx3pbMD3+KFhFO7W0E8VyfYGJ2jjFsEScRqSpxiKQMsSmHRbXr7LSqrLasmRIHPksPyTkbMheyylXVq2d9qo2gq3YYA0I6cBQm7ejGEjk40uPpx/6KJeXL7K61SDJNIHv9BsvLFzgiWOnGQRkXO0MgysO4AYpFMVCFZlGOavUHWZqpRpTtRGyLKLVaVMuFZgql1hpJhghmK6FWBRr9RirHAALfehBAAZBK4J2DNIepTinmVsXeCpEek7Iw1iDwSJMH3iMkgRJ5pJxFUp87MxHKXhQCCoYY50shu2w1Vrj+PQUpWINgeyB4iOlCqemZ/nEkRrPP3Gcd+ZWeOv9JSarx1CyylqjgRcKJoMS3QRZBV/xFz/5Z/jSudeYX57nscNTVApV1jcbTE/OUC0PAJJDk0I/WL6Pkah8vrCUA4/UOB1dF0KeHxaVQqlZKqbISGUNY2M8z0NJRZq5BHFdB8fe5j7LJbR70hN9MEkglauXNE3wPL//HenRTg1zGyDNUQJCjk44Fre1XU1Vd+NWDK1YMjv1GDIdPgGPV4pMVEtcWFpzDgip6MpmdOtD5DWkhGSkVHPMXNHPXq+UzVmAmrmVK8yMz1AMApTIKPle7hxQNKMm1jo96f546MqkgI+PEL7T8s3DUa3NAIPvhXgqyOc7m4fgp0ipmBw/QXsloRm7mK4Xj03yE9//af7kwgoXVwvUihVGigWWm8Y5wgQIu20xz1mjgR8wNTJN+dEK86uXGa9OMlGbRkmFUo7xXAqryJyFKBAUwwKB51MplHJw283BWmuMcUxea4WTzJEKIaoYE5GmbaQsIZWTTIgzN8+Rj+1+3+nKLyi64IcxmnPLgvHcC7/UsLyzoGnFoCnQaXbfzAPjxnV3LgJLpgHrGMFdLW5r6TE8rTGEQYE0c7IEk7VDJFlCJ2lRDMp5uytCv4RJ23iBj7WS1Bhi7TS1PaXxraRQKCDxuLim0c0S/vU6hyolFJpmAqPKDM1tSWrzttYYnWGMphO3KIYlp2GM6M3DXSeHA3DL/OmnPsFktczi+lVGKoeIUji7kFANY66tvs+JqUfwwiLkc80gKOp0s3uzAQjVK5fFklnIMoACadO1vZIeWZaQmRStDVGqsTKl4PuAoVaZZLPjJC0GGQ/tqMxE7RDFwPWX1a0lymGFSqFGJ2kNzAPbrT8uAz8ELIGGhw9NMlIssto2gESIbfrIA+Yrn1rJRxtDMfAohSNu/vXyaJEceDZaUI8evLS/lUrlphPnbm1tfcsl271bdqf06W4kh7Kb5II7vBs22u7azHQTChq2q0MOSihOlGAiPxDeCduLrbTWhkZsGMPuYLl9aHfebpWBJ4RgrGhpmTLGQK2QO0PFsI76XsmI9yvPXs6IEQX1yD1zrMgN9n63bjfDYv/QHix7fFry+LTkzeuay9fWeejIFE8fdvPaawu3z7LsmrUuYe+42sSGZTopQ4zHqYrgtSt214gncNEW2rh+3SWgbQ9o6HZvAUxUbo+5+GGf7tudYMreabmj2zHHDOeeJlE8SNSQTi3xA7K9PRBw+/f+3t8DHOv2r/21v7bvtd9qoWbTNcm3PeTx1kLG4pbPaGUMpQRGt0nTLcKwRrl8nKr0GalqEHB1o4Q2EiF0DjgA1tBNOtNlVXYzngsh6CK4O/voMEAGIte+BItEM3jgElhjScjwpIexljhNSY0DEEtBmXqn6Q6X0mn9gc0B0uEZ2bGqyIFS6ZI9afd+jU5EMShSKBRxoE03nFaR6BzEAYKg4hiAvfcTCOE5QEPpHksYHNjqez6T1X6m60Fuo6cU1VLFhYTuBqjhAIUkS3sbfh/B3FqDmZEyBc9jKy7T7gIUVmCwJFqgKXFtvY1UPsWwwonZZ9DWMDZimZmMHUCIJPAKqJLT0jUmodlcoxgWUMLPk3K5UN7MiC6kvK0lHYDgEua4g4k1DmAxxtLV+dzeCTzPZ3rsCLXSKNYEzEyexvdKfKLyMNZaPOlY3VmWIvMwfSVVn7fZva+UedtIimGF1DggDOGu7KQWCPFCnzizXKu7kGPHuBMY4yGU+8727UEfqu5qzAW8fs3Ba0L020wKSQ774IsgD8ONqZVqTivVQKXYlUmweXsLtPEZrdZyzWEnyyCFwZeKzECUKqR3lN9+/QLzGzFbjQ6sXWOidsQB1b0+Y0iSFkoJCkGV5x9+nnJQZnbyUQp+mfERXEI6a9E62cfD6OptO7st0QASIUXet3MRBuvGjZQlXjzzMb747te4tr7JI0cySoUioV/ZMxHadnNMSIFS/o4+1q1jp+Gbv7E1jo2YaTJpUdInSRzbw0kPDL+Hsa6vhn6JiclHsfoqUhYpFseRsgjEjJZHCDyfoVG6rShOHiXYBip2D+WaYjjCydma0wpXPqiQwHcM+k4S8crFt9Da8KeeeMElbhtglGudkeoML5+7lFIYq6l3IgSaWqlC153gni/BGowxKBVyePIUJb8vyOx5kmePH2Jxq4mSiqvrW0Sp6bWL6AL2+WtYa11SNuHes1ys8ujRp3rM2T5DF6SSQ+0k8vHjKQ/f8zGOkoanPJRSPUkD1x9UXpcO6IQMa2KkqlDwuzIrAs0gmClydvJgWyjWO4o/Pq8ZM6O8d8GBtn1m96DZHsihjSF2qC2+CnqwpMinqa4jUgiJn+saB34RISRxFgECT/looykICUiUCpgqS9opbHacAq8BYq1AFWmnbj2wCIw6zhcvWZTIkPjI1G2yqmGfEZIYN6NokxD4FcZ8gUQOJJfb6cDqll0pjyeOP83Dhx+jEBQQCBIBf3IppVIYY3X9KrOHHkKqIt1Vt+cyFIIBf0Xv792OTtraXj/c6rSpdxq9dbsRZ/hKcWh0Ak8IQs8dgAYZD51E8ezJJ5lfvcRjRx+jXHAyPJ7yqZXGhhyE3UIMxQZYMFYjhUR5RaJMEzfTfC3aG7R19Sfz/QsUg0ruWDBYq7FCIYRCygLSJNQKD55s1k/8xE/w6U9/mh/5kR9hampq32sXFhb41V/9Vf74j/+YX//1X783BfwmtzulT5dkbj+4FziwXXJh++E9FDGlYug0FpMMqRSJHp7jBOCT8PGTpT3W9Zu3B4Wt9EG322Xg7eU4sNaSGhDWsNqyrLcMowfEhW7FGXEn7VZY7B/ag2OuTzumX9tUuLhqWW8bHpsWd0yPdLuMRzGBcgClxDHBJytOG3eviCdwMo2+dFEM7y5BO5G9fVbXbkWbdzf7sE/37WbWnv3sTsodfTPaQaKGlHR78wfBDlSMX/qlX7rb5XjgzRqLEApPKjf5qAqhqnCo2NWzdKGopUJAM/HyzaIc0pt1DFYYPFJtn1hsVyLhBvONzS+22y50GKkrozGOpeYrd8BUgSLwgh77a6wy6tiyuwChgi6onCcSMtoxSIUDMTpJRDEs5Vf2D7RA7zDojrc5+zD3wjkgW1EujZAZgRKQdhNXIYdIEsOMUfeU7mF8N5MDLNUuZNZJUzbahmIQkKT9uw1OY0oqioVKj40lpURamQMSgs3mlgvrN5p2Z4tq8Zhj7k1WEELw5oLshRU74E7tAm0OtlHX9Ti8kdt3oRFQKlR48cyLSDK0SWi0G0xUJygVujs+f89nulvk3ivR/01eHUOl7WZizz9CW8tW2+nGmT0mNnftbsBjriG77d0GRQeqpS5oqR31eLBsuOQ4zoHQZxS6gyF4yuBJSawtsa2Qioc4MRPAtGODG+s0Pq104TpCCHy/iLUx1iaUwhIvnnkxB7+TnMHp+qnnFXaU5Ua2s9VdTzTWYKzF6JhascKLDz/Hf/za79CJE6ZHp/INjtn2vf1sN8h2d5PCsYy9nH3YLZO2u9/BgtNYtVAqjmNtESk8wkLueTQdwngDJSWZ1iilhuaQru6p+10X4N5WeuGYukqQJykceC8hKAQFPvHYC6TahfxvtDYZLY/2ACopJcIItDWoLvPYStpxROgXqPhhLh8yAGbm4JuUEAQF3lny8P3+4cxaS5bFbCXQjmNCzyNN24Rhrss68LexmatTz0PQn3csplcX/T7fB/QEeR/0PMeaRqCUcszbHGzzvd3Hse+XMSbL50DnEOy2oczZ+vv3CkEzgRaz2L02YNvmgq6jaXD8Oiau6K1TUjgnGEKhlIevPIzVjjHcc9iArxTWQoJktY1LrEfXSbf9+aLnOOw+MzOWssjQeGxFIG0BX8NkRXF5tY2UoSur0b1khDucCcLpQrvZxz3M9wKU8nKnnyH0ApQKOHLoNGmaoDw1cKPda7jvuNrl0211Wi6U2WzV8/rs9xGBwhpNMRjO8OjYYD4zY4cYq45R8H3iNCJJu2D/4PXDazH0+2F3XLq6yUHnIZ2EvfuOhb58SS7NIET/Z4HE9zwenS7vdYv7Zr/6q7/Kv/yX/5If+IEf4NSpU3ziE5/g4YcfZmxsDK01m5ubnDt3jldeeYWLFy/yl//yX+ZXf/VX73exv6nsTujT7SeHAsOSC3sd3gNP4CvLSmqZKLt7rjQhTlLCIGCqDEFrnunqmTv27sNsJUi0ReckhsATFH3uOjg3yDId++CQzXp2Jxh4g44DiyXRlsT4rLRciLcmJInhK5c1Hzl6MB3vm3VG3Gm738Dxh3brtl+f/uL7hig9QnibeqS7PSP0CjRiSPUoqe7uP1zURCct4qvh/by1lgyP6aJgoqJ45ojlq5f0HdPm3W4f9um+3QxTdmqfdAZ3Su7om8W2r5kT5eGoodTQW8N9ZWmngsmyYOwBiZo5UDOcOXPmAxtqtlQ3/MnFlGbszjee56OQvSOatRYrBAKfSqmG03rt227w3Q2cHwMMnhtdt/tV3aPlEINP5KDkAPtr/4P+Toq6EO5oaozBU8OHy53v1D84d6UQBm/X/a+bzPeDOYev3/caIfByvUUlFVjL7NihHd/erf57bLr8sy7s7CuPaqnCwsYyM2NTTNbG+0f4HAiMe8m55Q3bdrcyD/67l3UP357yiNM2URIzUR0dAG1v3W5UZGuhc8CN5W73Gg7hHgDjrR0AZjTGkIOLvW86/We2QxEONJBSkGjbcwoopaiWRrE2w+SUQSXddVmWYYRF5aw/hJM6KXb1V41GSIkUgwBxlxt5+6akYrQ8igNxLceminz2u/8SgR/m4ebClYvhcXKnrMvq7/IFt3vDt1tqyJmsEqgCFpHrskjhc2jMMe9UPmZsFwgjd9fsAC93WneM7WZSSEph0QF2OnMsfEtvk9Ydm9B35kgpmRmbgbwvOIDflUtKlxhPW42w7h02OpaXr2gK2WifuaB9lOeSmhmjc7btYJ919eblOq2I4TfwpN/bTO6YP4f+L4Z+0Z0jb2SDTNrh+23/zbANMR/2db7s9t3htWAwQ3D3qd2PjXFyLJnJAEknSSgXIPR9yMepRZLp3efhvUabQCCkopNqjo7CVgSkMZ96uMBowfLLG5IMmesje+y2fnVN9oDSvmnjtJN9qfpMXQSBH+byFXsUbLDse4wp2/vcyRIU/IBKoUxmsp4Dy5PKyaboFGMgwZJ1N47SMaArhRIqTVjZWqVUKFIruwgErbWTohH9cgzVneiD+5nJ8PDy/mf2HYPDdTYI2qoe47r/PEMp8KjHgvEHbHMfBAH/9X/9X/PZz36W3/iN3+ALX/gCv/7rv876+jpCCCYmJnjiiSf4oR/6Ib7/+7+fSmX/kP4PbXe7XX26G4EDg5ILNzq8dzUXv+2kizx7+915nnzs7mjMdtlK1grWWs6hrG2BpAW+spSDuwfO7cYyvd1EWt9sdqcYeF3HQTuFKA+L1RQg66+sCidv8PIVfSBw7GacEXfD7gRwvD0cf6JsPvCOgrtt+/VpT1qWGqCtz+RtMPxv9IxBaRAhBFPeGhveKPUYit5AVEUKHprHZxyB4fFpyfzcAuvy6F3R5r3fzpAHye4UU/ZOyR19M9hekRnTNcH1dVhquKhTbQtETedsqBQsT87eSMrw3tmBlosPaqiZtZZXrmbUOzlIB/2Duh0E3Cz0QNAbNexBgaAbwbd7H3F3/60Y+hf6QOxBrBtun+mMUqGyjRW29z26bK1B9u6Ovt/FTG9QlEH4by9TSuFtB2p7bXPjd93O6hRCEPoBh8cOEQaFHWDJdmiv+5Rut7gzsN/2w7VHtQBKVXpgyK3ZzXzxYO6E3Wu5F1A99NtB9rRAIVV3jO0CPuwGU+UAjN3WAk6OgzycNwcgu9rIXRAD0WfxWpASjB2WDBGi/6xbt+EDJTiWOUApLPXetUfCHvj7oPc9qPUkM4busd+zxLbadfq5rt68oTYy1mVI3AHydQGeXDZgaB7IN4r7jZNuiT3hNLIzk+FJB5gq4eRArOmCs7InEeIiCYYBOiEknpB5HxVkGhoRrGczlFsWKTLq7S1qlTE8VehJtuy0HO7apeoO6oi5XbuZOfRu9inniMgZz5BrGgt8z8kKWWOQwjlojHHa7OA2Q3rH427svrNC0U41lVCxlbrty9XNrn6yRAgH2u65Du4xXwrAV3Kn5ED+HW3MNqfSXrZ9TA3FMuT3E0yPTvacoF02qxQSD4+VVne9KhLn0j7WgpCKUlhgenSqB7hmuVxI/y32rkMhHLvdSXM4NvRBefv9IJGdzkkhHFjvKfHAaIDtZqVSiR/90R/lR3/0R+93Ub5l7Xb06fYFB7ZJLiSZ3cGO7LFcVV9zMdGCQxV2zaR+pyx0wRN0CFG6yzIzSOGkGtIOSCvuODi3FyPvdhJp3Uu7U0zhO8XAGyu6MO6tzuAaYQf2+BKlYLTo9g0HAcduxhlxN+xWgeNu2yxnY0NJnBfPaYzVKAnJB9RRcC9svz6d2V68EKmBYJCfdRP9/SDOr25CppGCc8w9ckL1pBu6URUTZYFnFpmu9ol6U94m3/XMca5swPlL13nk5FFOTbpEyq/dZpap++0MeZDsTjFl75Tc0YNu+7HY11qWzEp07zzq/m9s/9zyoNiBuvYHNdRsvWVYaVoQuecin9f6bCnbQ+m2QxzfDObAaHEg4M/Ls9f7qut1OPi7dsPz+0BYFxQdPOR2gRA7dPbtg1p9hGc3Audg25iBEN3u727Geu0ooCslEfpBv6SD7zHwLSzYwXfqgfx2sKgHqrnt79gNhcbCWLmArxT1qAsg7a9ReG9s8P3Jy91965wluaPdBvuCGLi23xdu/r36Ne1ABqfPKaXc5fl5HxGWQHpkRmOG+pu7+OZ6+8GtL5mxrY/fN7Pb2o0cEOzXhSe70jDD5RyU1xi0wUONFCIPzWag/d3zxEBf2G6eUug8aZeSyoHsTogXrAEMg/q3PQBT0J+rtvU5gdMKdsRsScGDNLP4fhFPFTiI7ZzP8lq6w024+7jp/iL/9wbve29M5Oxxl3BRSgHKo1s/2nbFQByonu57r72eIIgzSykAbSUvXzE0Y8jwcvDYMa13TLgD9SYG5qVuWykpcMDvzg2wp1SeIPGgpRxc34YKn0su9cF91fVWWXdYltJtNGx+zXZwO5ASFRadZq7JKAYBUihSc+PC9eZZAXHSQKmQ0O9KG+ztxBmemwbn5r4uuwWiFAJ1r/rardnXvva1XX/vJHR8pqamOHz48D0u1YfWtb3Age2SC9vZkcMsV7DWoyi5J5p0o0V3QAYXgdIleQjhGJpprkk/WjiY8/sgdjNsuQfR7iRT+G4w8MQ2x+LgKnoz4NjNOCPuht0KcNxtm+WGoZnNIuoOHLTWEqWuXpQA32oCxTeNo+Cbyfbr04P5FHfbkxy0v+8mDbKb82vQGTtdFcyOOM3bblTFXlEMUkpOTsDW3DonJ44jpYsOul27386QB8nuJFP2TsgdPch2ozVzoQ4av7eGu4hLR1BqJ/DK1Yzvf9J/IFi3B9rWfFBDzVZb7nDvuVxS+SQ52GhiAHS4s+aetQ3wuuvW25ps+z+kOsXaPNxSZygpe96ugxxo+wDxANS56zuKIeCoe/gdEtfu46rbygraaKyxyL12cTco4/ZnDYf572bDYJM1BoFxzK9tgOrNb6H7/csO/Bwo1dPUvVe2KxDhPtn2/t32FDkYoftgyFC7Dddzty8M4VI3UbbtZcqPTmTG9sZvN+HeDma8dbp0XfCtV5a7Pu4G+jn3EbK1wy4IBt/fgsX0NgU2//mgi1e/bUQv0dzBIhP6po0l0xqQvdBw0WNG5uBRnjDJWNvTuh5qx20dy7EEu4cz0dPyKheqsG3uu7GJITDw7tjwvAjs3243M5C232f3Sw5wNwcmapNLUxg3ZwicfNBglmFjyRM5HqyIwybyrMcejRhC5UAclY9du72udkkiuOOOef/Z/TPH0N/JEN5pQ3PhDtxW9LV3cSxelUekRElMMSgATi9Y5MlMdxRbuEOz1k46wleSPmZ7oyRj9KJflByOSzl4Ig+7+5gWAm2GWTsPov3Mz/wM8/PzGGMYGRnBWku9Xu+9g7WWZ555hp//+Z/n0KFD97u4H0jbDRzYLrkwyI4EN5d0Wa5xBoaQMd8dbM0BnBq3Y5sdN7cJrJP+ws2Xxro/SoCwls1I3DHNxZtlyz1IdrtM4UGm7lrL0Eld1Ecng1KwE8iJUtzn6f7z40bHOQBHitCKnQZ7/xwCwhqMUaT65sDggzoj7obdLHDcbZs4c5IfAosncvkPQpQFX7p9U0qAr9zYe9AdBd9sth+rdDDNy25L9kFZltudX0nu/Ipz5xd7OL9cVIW4YRTDdomNycqd6Rv32xnyINmdZsrertzRg2z7rZlpj8Tj1nIl6WEHFndOWWm6xJQTlYMlEb+bdlP+6A9eqNnuQNX209R+x8KdR3nHSNrJmtrv0LTbE/YCCQ7u1R/Uut1+D8dUFGjjQpu1NvieT6Y1ggHNO+4UcL1Hue1+kCmI3vfcVY5tu19rwN537F7VZxTu/m5dat1ud7I9j/TNYDg7D8476GI9a8Xbf3WrgNHB6qNfxm140C7vv1MXeSeA3sXrrTU7Ph9u09sBwtw9hqRByCdrMdxvbP73rSYK3N8O9g4WgczB5YM9cPs8cnAbTpq1N2TXXdcsDFzfbT9XTm10HqZ+43L0k1sN1v/QFexWV8a499Rao3yJta5dHWjU7WOWJEsdGKZcEkZjMkD0wt8Hm9fYYWCtHjn9WCm7TMJ932TP394dfvZuz9u/3Q7eb28vTkQJ0atLi0tk6LzVmfNWD9THSMHpgZskolYuYQ0stwbvdrC685WkEbmrR3NQYguNRSGBg3M6hh2Uu81VAL4UpNmda1cH6vQdDFgnlWBxAA9isFSOnSyBzLqEglL0+1oPk7LducPu+R7GOr1oKSSecuOob/t1lr3Xu96Yztt9rS2Y3CcJxv22H/zBH+SP/uiP+G//2/+WkydPAjA3N8ff/bt/l09/+tP8hb/wF/gH/+Af8A//4T/kf/gf/of7XNoPju085DMEDuznVBAD48XmP2PFnZ+G97A4c4e9AhGocp6Q2EmKBMppOzbb9o5qLt6IZbobW+5BsNtlCg8ydZvJEa684+SwMjw22tCOLdV8TYgzSzOGKAPweP2a4cr63qzebp2WfAdcrbUcEcRXHlJAmhm6ep3Yg4FjXTuIM+JW7CDg2EGB48G2KfrQSZwbUUqXX0Brt94ICcpAiiTREKg77yj4oCfc249V6okuAcWB6IN2MyzLrvNrs+P2w25PIdHGAVWCwi07v5qm2M8bMaAj+tj0nWHD3E9nyINmd5opeztyRw+y7bdmptnAnnvb64qcLJEZR+aceAB4qTcdSPRBCjWbLLtG1obeYWmvLrzftDZ8PARytH9Q7xH2Zr0MhuHudd+dpbkBw2jgqu7/++Vxn6Q6pdFu4nkBSRozXh3vHTDjNEEbTeAFQ4ymPjB2c4N9r3fsv18XpNoFXBP0GJUOzNnfI9JnVW4vQw7WDp4E6LKU6IXA7Sxb34yJANBGuPD8g9aDcKCzNXabtuZ2DV2DFSoPzbvxOx3w0Qc+4wz2rL2+Y6wh0xm+2jusYHvfH/5s976wWxn2MgeMiAEmVZ8ZNvgMa7sA717Pun3HxJ79jeEefbPtJ7AkWYynwgMtrl1NTa01YeDjSZEfMgfVh3fMVrvCq12TQqB1hlI+B7Ph+t/t0+3VIKXEaOPKb01fkqDL/rMaa8UAo9p9anIGpaI/ngbB8cHnSOEYNl3Ac6+5eLcySwHCapTySPTtjcUdz9vj9ze6/35jxCfBiNBpOd2BcirpGDlgc4eezdmrTvc4zZ1+p6ckqy24ti7dgUOCRGMGtiE3mouEgES71SAkRggX6h+IlEwE3AxO4fqCA3z7Nba97xuszZNx7eNEvBmzeayjzQdBd14S/QvyIjhw1VN5/8xc/x4MlTSmCwR3WfGWrhZ1pl1tKKEQ0jlZhBUI6fq6RaCs7Y+bG8whu7+7qzNtNEjVi7h4UO0Xf/EX+YVf+IUeaAtw7NgxfuZnfobPfOYz/MRP/AR/42/8jQ8QOeH+260c8gfZkVHKDrDUmIgoK90TxmlPZ1BYxkqOvdNoRlTLZQIlSLVF4LJTr7fvTJKnG+k8Gtwcey+kIm7GbocpPMjUVQIylDt6WLcXkAJiDVkbpPHptAfD+iMCVd6X1TtUp0oQKEtktrv+3TW3Eo69nal4u4DIzYybgwDHg21j7O7Sf+6c2N8HdZvvTjoKPky4xw1ZpeXQEkUpjVjdFstS235aK5v/bXs7aEFyC3pWSw3LfDqD37IU/WEd0ZevmAMl9Rs0YwyX1gzL2TiX1gwnxtzv75Yz5JvRvpWZsnfK9l0zDzwVPxj725te1j9IoWbjZclURbDYcBpanswPckNC0IOh7DttANIcAIBc8KgxbWKjiJKUueV5xmo1Do8fHtJn3e1OPesyb3Z5+KDU4a6fDdy1ex8AbTI6cQuBwVdQ8AMy3ebs3Fs8/dALpFlGZjK0yQg9n/HqRD/xU34vrAtb627K+qHLtpfc6Ea15Y7/hiRNkBIXcisU1krnAd7leyLfvJltIa8790eDnFqLMV2GXbcibP9d8nJIsZ2Ft8cxVvhkOkYIgzEGz/MOBPxpY9A6pRx6hLaNCMq0k/5TpICRAsRRzuqAXNdwsE/dLHvO9t55r3609/f6oKa1mswYB0gIeklvMqMdW0y6eIMhOQxcvYo9M9wPF6bLzu0mo+oCHrt+0+bh2dYM38c68G8Q2N8J4fU/MVZjjKHg+xgrb2PK7rbNtiR99Otk++HAE5DawTvs0uOEYKwUsNbcwlLE93zHNt/mOOk6U4wxGKMJPIEnJApDZDKMMUiS/J5hruujEWKvLJrud5lOCD0PzY3HsytHhtYdIEQqDyXU0OfdWw/2RW20k2ZRCpWDgjrbwuCjjcSTmnqnQxhUCL2gzwC2/clvMDmhsTudP11z2rl7w/i7wdhSONZDpu22NjRYDNq48N1BV9n25G0HmaeH7UY9cRCEHIbkyyEctvNMHHmEV65kxAPhoPvZ4BXdqAZroRS4MZbqvaVpZD73J1nM4zPFgbAuKBATCa/PHN0xF/XfQQCeFIyVYKsDMu2fEj2hqRSh3oHoAJTbIAdDE+tkLrLeXNp3S4WeJdOWzOZhVDc5T9ptDNiurMDeAGj/e/22tz35BwFUCxCneTZh6wBsJQztToNSsZLPbQ6Rd1OBRBtNs92iVCjmTHTtnBemxVbcZqQ8ls+VB5uLh81gc015bTTapEDtYBV0n2xjY2PX3w3q732rsEwedLvVQ/4gO7IcCBJte2CpL2Grnt0zxumgziDkDEShCfIspC7resYb1w1bnTuT5OlGOo8ZHtNFcU+kIm7GbpUpPMgGrYYOAAeBJ0BIsJn7v1TkmexDpHUyOtUCRG19Q1bvcJ1CJYQ47ctfGAS+dAze+x2OfSvj5kbA8WDbZHa3PWe+Wx7cl+a32M1RcCuh8t/sCffupN2IVXr+/LXbYlmuty0xYU/CanCfIXBn+HqsWG8ZRg+ItVprObto0CjGQ3JcyDHqfeUi2w6S1K9rZ5cMb1wzdFIwdobrFwxFH8bNKHDnnSF30razxu+UVMRe9q3KlL1Ttt+aOchcl9urzTrypifd+HoQ7KaFQH/wB3+Qp59+mt/6rd/iq1/9Ki+//DK/93u/xwsvvMDf+lt/iy9+8YtMT0/zD//hP7wb5b2nJoTgo8c9agV3qNfGTWzdwODBJgwUhETUwi7Au+1eGKToL4SeMEzVqpT8hN/7xue4sPgWC2uXiJMO9dYmSRb3GDM3KCWezMMnbYoUDpTpAXL5xNkFiQZDnun9z03XgVKMFiVjoeXoRI2Rco1MJ0i7zrGxkM3WJgXfR0lLwffQOmWztUmm4x6DGGvITMJmcxNjXGIoYw1RkpCZDIELeba2mxfTfW/wXRWaSgHGSxmvn/8T2u2LGN3GGp0DHQZrM5KkRSduEAjj2kRAtVCgmMcv7fa+gy/uSYESAiVdeFU5kHg586ngWyaKGs+0KAeCmZqP2nciNKRpB6M7kMN0UkqyLCHJkvyw3AezgbzODHESEaiEQ9Ui42Wfo8Ei/+fnJC8cF/ikjBbhyKigEroDwXgJxssuNM9XuSxD/k7d9r5ZKwUCXw6Xb6c5ZpUSjkHiyq/pxFtEScRma4Ot1gabrU1W6+usbK2wsrVMq9PIGWAJcdIkSiIHFPSeZbf92fZMHbu6w0FiQjhQVpthhKYLeLhEZDlQp+vorEWWxWjdxpgIm98rr7Lee3T7ovtX589ygG04gE36olvnO8ta9MkPJe4zT+Q/CwfgOBa2HQjxz0Gp7hhFUy1A4HdZ/gZPuntINL50z/YE+GR87CGfl05LGp1VsizCmDSv137dWixJEuMpSzkMEdJDSqgWM+ZXzpOlbYT0sUCSNCEHt7ugqe16dwbe01pDq1OnHFg8pbbNMdDXC+3XURyv0G69R6u1SpYlqF01k92zhCBvX4MgRVpNmrSIOleJostE0RxJGlErlZmsVWm0myAg8AOMtSRZgpTKaa1am4Myw8+TorsA5g4PO/h8uXPezKvAl1AJICBxeqPGHVy06Y9FISwFz6MYeEhhkFLkidUciK8G56ahedruP2/taxYH5dkdY8OTcHJC8J2nFRXZ4fFpyQvHmlxbuUCWuTFhrL5h8gibM9lBkOkETxiEsQPzxs42lVKRZDElP+qFdU2UhWPOCkU5gJIPRc/1cYFwDp+B+vCkIBAJ335S8m0PeYSeq/NBCz3BVNWBOeS15wnYLp4gMAi64YCWibLk6KiiGmqETThSSzk1qaiECg+NEoObOcHONXV7G7j+V29vEKVubeyCml3Qe/v3+nBxd13MD1LWMcS1BYWhErhkOEUfirSZrYGvXEiQMSnWpBiT5nXmIYQlThpIaRgtBowUoGbmeelRjz/9iMeFq69iTLSPvND+NuiIakVbCOJbus+9sh/+4R/mb//tv82v/dqvcf78ed577z1+7dd+jb/zd/4OP/iDP8jGxgb/9J/+Uz72sY/d76J+y9vgIb8ausN995BfCx2Q1D3kb7dB9owQYggsFUJgkKh7xDjt6gwqnEMq1X0GXD124zzFZ72VO4ysJkodoNtJ3M/dJE/zOTh1kGdOeWsEHtS3PbMRg4fm8ZnuPuje2XawYnvbDbbbbrZXu3XZoEUfMptr0tOPvhFYjHXyC7WcqVsrwGRVEHqDjtJhVu+gba9TKVxUR1+L3bEZJ8uSj51w6+j9sNsZN/vZYNv4Mk/yl7PYh3Z/lt561E1aluExmjsKoM8G/vwFzVx6mM9f0Pzhe9m+fbsLzicZ1La9VzUEjQPcH3Qd9Ttp01XBS496fMdpxTH/Ot9xWvHSox7TVUFFdvjO03LXzw5iay033ry8rX3lzt7d/0tMLzz8oLbRtmx2LB7ZjrnHJfVz43jjAENnJRvl5cuGVtLVH3VSHa0E5rPDnF26x4lebsKWGpbPnUv53HuaK8kRPvee5nPn0gPN7fvZjebXD21v22/N7GSuzwscSbPL+3GfAwKmKoLx8s3nTrobdtPbmg9aqNl0TfKph33eWshYbVo6kaZYUEyW4cio5NKVa9jyEToptDsurPF4RXBkVPDu5SWacookA2Ndg5cDeHhK0FmZ48nTj3B+IWKjucpErUqWZWQ6I05j4ixCCkUxKFMq7JbRwPUsXxmOjUqOjCkW5y4xc+w0l9YM17f6YsvONAwx4ywjBeH0bJKYM0dKNGLYbCsyr4gUHqHq8M6lVxmveZTDgHeuvUfl4ecohxWSLCK1Gmsc46bZccBJMfAxOqYTt5FSUClUQVjiLMamBk95aKPxpEcxLIAQdPVFPaF54rBPZ+UqT5w+zYWldVY2V6iWFYfHOghRoNU2jI8fQ1uPTDuQYqximaoI3lmwpAakUBgGGUT5KNyWpEYKkNKSJW2KfomCB1uRptVJeewQfORomS+/fpWN4GE6KUhp0JmBQcamNYADojuddbALdFLF+8sRjx1/jHIY0opiysVyzjS2aGOI05hSWCTfclIOC0xVJY9NCxYudpBSMlWxKOEO60O6u0IQKPBFRujDJ05KVluWy9dWOXF4EmE6/MG5DpXyKF1Eart8RNfjqQSMyxU++dgsrU7E//5ag0JQxVMKcIlzZF5uk7PmCkoQeiHNeoMoWULrhLBwnCzL8H2PVKd0khQhBKXQpxW3AImnMpT0idIUT3lYsZ2r3mVla3yl8onTYmxGJ9pkbm2DM0dO9xJUWQvS7x9OjDVIJBJLK27Rjq4TyCZClFBqGhUWMUbnDgYNynNQV1ciw2qyLCYISo5FrBOiOGFschQhJJ6CVmLRuHpzYHJ/Ig+JqYVFWsnwmFppOK21/CkgLAqXsMmFYLt6AbDaAbWVwLGwk7iFVBW0ERjr6iv0BJ7UNDsZjU6L8XJAo7lAyS/ieyW07qC1Jggqed0Y4qTF9MioAxeTmBcfKlNQmv/09atsbCzy6ENPE/pllBIO/AHacYJAUCoUHYfUaJT0AEuWddA6RSkIDHQy0Rtf29u0C4i3Olt4wrK8dpEjRyuEXoHMuFB6kc9NFk3R98i0xRjhQsWlRJsmi0vvMjoSIqWk0d5gdWOJM7OfItUehSAkiiM8T/VC0T3lY62hHUWEfoiH7LFIeplDMeikhRcUEcLDham7snhCoMkAr/dGBR+OjHQZD/Ok1YdZa+HWhdCtC/UI1loumZUUEiV0Hqru6kMKQznsJ5WKkgwh/Z7shME/ELvbWosxEUJIdKZRnhuncZoQJQmzYyN4KkAnES+eLHNm2hsKnaoUfK6tXWRlbY5HH3qawKsQpRqZo5TWCgpB2IsAMdY49jw4h03UxNZGyRDESZswKCGEyp1UIKzNfzZcX71I6amHmVvfYnVrhedPzFAOq7zz3nWePPMIE2XJWsvw9rvvM3PsNNc2LasD9SrosLzwNhuHjnJi5DBad2gkAtHqMFrqx9S6OVKjsjZeWCYzEpG3e/dza51ebKAE0saEnpN0qYQeOk352MkKk5VuCN41njhzGmMM//ntDCN8AgnaigGW7qAzLj/IZilSKOqtTbJCldAL8rXPIFRfe9vkEi5KOUeJxeLlESwuCZ/AWOUcokmLtVYRX4UUAxhjkU8+9ihnF9v8L29+g+nJEcqBBUJabcPE+HGk9PG9AF/AeNny/LGQhYttnpitMbe+RaezyfrWBcaqR5GyglTB3v2tx8fZ2Q+1jlnbvEy18NQBeu79s7/5N/8m5XKZ//6//+9ZXl4G4NChQ/zYj/0Yf/Wv/lW+9KUv4Xkef//v//37XNJvfbvxId+yFbtD/tQ23eQHjXG6l87gRMkxNDsRVEMn8xLjxtjtJnnai5E3URZ4ZpHp6sjdfu0h2y3EfXvo/q20m7WW1aYlsyrXU989iD+Pb8BXLvrFl8P75q7tF9a/vU6NUBR9mCwDrQVeePT4fQ9BvplxczPJ8PZlHOdEBcGA/AQJqfZzRnnfUXCrLPpv5oR7d9P2Y5XeEZaldax1d1KwQ07q3gUHJBHEWS4tye6g6kGT+hljWMim98xXYBG8Mmd4fPrgGQ3ulTVNkS++r2klueMdj3YCc6llva05dIuSH3dbN/iDYHutmVMVyaEqvHo5QovCEBlHSjcXfvT4XhGo995uyR/9QQs1m65JDlX9/CA3z5OP9vVDWtc2ePax47tqi7SuLfHMM9Nc2YDzl67zyMmjnJp0DLDX1txE+9ETh5mpFFlsdqgUNmlGDcphla1OA21SNlotpkbGGSlVB8JqHbi1vDZPM1qg0ShydOQUVdnmkSnJo4cUv/1OyvWNFI3oeQ8E7lDuQtktSuabvMZ1PnrsDFJKVpuaP/za+1xvwfnr13hvYZ7oGgSeohknrDZavPDIM0xWxygVHNAjbIevvvcNkiThu5/7NjxVpFaqkhnDytYC7y9eZX59lThNSdIm5UKNchAwUStRDEo0I81EJeCf/sVvRynBf7y4wq9+ZZMLi2ssNyOuvzfHickRTk+Pc3l+gctvvYanijkYqTkyGvKZTz3HEU+yLo8S9XR5HGCUZimZTlFS4CuF7wUYnRHpmFYUEScJK60OxlpKYZmt5hpvXLrAV6fHOe6lHD45wytXE7QNcj1Rp98YxW2MtRTDEGszNjcvMzoSEqqUc/Pv0kqbfOfjz+N5HnEaU/ALICBOYiyaLNtkfvUaBd3mRz/6SaZqw8DKQXXMSqHi6RGLXl7kmSMzGFPl17/8Gsp7imJQghx0G5SYcHqnKaenDLXWMuOlw0yUa4TiCs0OBH5InCZkWuN7AeVCCSEkaaZZijPSbI3FpfOkIuGxw0exwoJQRKnLKt/VTUwyl9xBmxSbXifB8MVzc4xVx/jow2dgCCywZDrFVy60XAnY3LjMfH2Bo6MBXzv/LtfWlvjEYx+lmIPexrp0kEmWgjWMj1YYL8MXX3uT6+06Z2YnMabJ2voas7OPI2XB6d9KRStq0+i0SbWTC9AmY6o2iswaufyDTzEI8ZXHWMmB6m+cmx/oY9IxvaVj5JpMkBo4VN05pr7+jnPwNGLoRBnFQtBz/izOzfHEmdMAvHNuntrYIb50fh6jDtPstElNA1/5KARKSVKd4nkeEsW//fK7HB0rEHox71z6Bs898hGUKmKExJoEKySJzigGIUp6vfEuzBS/8fpF5ta2WNyo897KEscnZxj1FdVqmbPX51nYTFHKMUaFEJS8gOmxcY4fOkalWKNarCKFx0wNFhouM2030KobEt5l3rajNp97+3XGSkXa7SYnDs8wUxtjpWlJtaMvBgpkFlMreLQTSSdt896VtzkyUcDaiKizASMzWGtZ2GziZR0uXX+D+Y2Y1+dWacQdrO5wcnoWZWBsZILJkWkCv4SSkooKHWhnLNpaojhmq92gHXVQSlItFBkthBSKVRdGn7k2FkDBg4pd4ZOPz/YPbrLDs6dVPvf314WFLc3vv93BUHQHzfweKk/6MaIXeeHM8SGwst/+c8wcO83VdcPcZt/55mrV6Xdrm7PJc5a41k0WFt/FL1aQ3iSeV8STHpvtCF82mTQLPDL17NCafGFpnd95c1v7T0zTjlI2ooirq0uUCzWOTczy6JGHGKuM4CsPT0lCT5FoTTEIkcJjugbnL75JgxInph/B90KU9DFYOlGbr733DZY25riyfInQ92g363z+epOH8/l1vPQoUkrGS7a3hp2ZduPmf//823xxcZO35+dodSL+9VdeJzWGY+MzfPtjL1KPC8ytNxgNBMJP2GhrOmnEOxe/RrEgeOTwScaV4sTRQ3zj0nskHMFXJbSNKfqKoujrzQ7qFg4elibKTpD3sDfPgjlKmjOrBRqLRxe87cQdNlurrG4ts7G1hhd4bLU2eGj2GY5OzLq1Q7qkenIgNXSapXlUhsGTCi8MsVaQZjFSChILSebm1c2oRapXePaIR0V2EELw2HSVqmwztxpzZnYSaztsbS5SLMQIUeDc/DLPnJzl+594FrC99eXIaI2jtRJXVhYoeClCFEjSAmOjxxFS5VqGA1EBORu4C97GaUySxbSiOgtrV3jySIUjYw+2TIIQgp/8yZ/kJ3/yJ9nY2MDzPKrVPir4qU99ik996lP3sYQfHLudQ/6+GpDp/WGc7qYzKIXgj85nSGtYb7s1ReM5+e88ckffRpKn3XQex4rw+uv3lg26V4j7drDuZtutC1asthyou94CT+0W1+FmJSkcsAjs0aturP+7o04f6dbpBuOlE/f9bHunwLHttrNtHBnByFy7H0ExoLeXSWK1w1FwO6Hy36wJ9+613anEbRNlt6fUViJ38RNZnDTIzYSH9/S+9wjm1nmU042S+l3ZcON9P0sy+E9vZ7xwfP+cNvfSrLUspIdop44Y4qKsnVyasdCIQHPowFIRXes6Q7yWdWxo66KPV1uGl69w07rB99puRTblbtl+2shr167tIONMVQRPznpM1x4Mti3cAnDbDTX7qZ/6KZ566imstbz99tv883/+z7+lQ81u1eslpeTkBGzNrXNy4jhSyiGA2/Mkf+7xo/y7d65zdXULId7mmZPPUS5UaHbaKGmBlChpI4Rgs7FKnLZQrFNfX6c2Ps5b80tcW9/i26YKPJc/c7LU4t3rEZ4XIoVFZynK8zGZQArLBKt8xzOnhzZ5QgjWGxv87tmzyEKZ2dEKR0dKvL3aYKsTEyjJ8uYy//mVzzFaHqUUBDw2O06qO0yUYCNp8calr3Ns8hBr6w3mGi2uriwxUipQEpqldocoyegkGTr0SHWRtWYHX1j+Lz/83QSBx7nrK/zmu/O95z82NcKVVsKl5Q2urG6y1YowAjwZIa1hcqTC+cUm//g3v8CPPHGYv/oDx7myAS+/fZmrbQOyQLVYc+H9Ajaa6zQ7G4yUpwmDAoHno7PMbZz9Au0kYn39EqO1Am/NL/OlrU3Grm5hrOXoxBQ2VYyOHcPkLDwpJZvNDXS2Qqu1jgrHWdhscny0zFgJ3rj8CiOlGpcWN+kYl7qwqBQnZ8bYatcZKxV4dqrARGXnIeNWWSVSCp47pHh16yJRcZpyoUaWWTJriJIO61urlAuala1FLl0rDPQbwaPTRf6n3/8qZ449zmRtnEAq4izj2vXLXF6aQ9oI31dcWl4Eo3ns6DTnFq5xYnqMQlhio7WFzEOdhRAkmaZSqBBFW2TZJgubTULbJFQ+b1z6OkcnpvCoMjp6HCE9POUhpaQcwtOHJRc6q6y1NReWNzgzO8FXz7/LG1ff5czsSarFMkpq3p1/n6OTh/i+04f59JkXGCtC67oiWiny3uIaMyNlWq11ltfPstmBOPE4NnMaKRRplpBkGUp51EpVttptzq6dR9JhemSCp8ZKfMfpp3sT+5S3yXc9c3zIGXNyQrLetrsenLrzxiFv0MGz3fnTBYdgs77Cb1+cY6MdcfrIKIFXIIqaaJ04LUkp0cYw5hVJ4i2Kvubta8tIoNHa5PV8/EXNNoVKifm1laH3GCvCb/7xKr91cZ6NdsRjhyeJOhFRpnlv4Ro6TfDDkE7sHB0r9QgDeEIiMTTiTV6/fK5X39/x4gtMVhRvL2R89ZLL7iUBYzSZtrlUgeHclTeRQvD+yga+sDw6XeTTZ/whULuTQlu7w8BUVXJy3PL1N6/STNxcoI2lEcUsbrVQQrDeTnj7+gqzoxXGvDbXNxtESUYrvspY6LHS2uAr773ZK+uf/dhHsdby69/YpKV91hsb+J4i9CRISb3TRgiPcrHFj350hEtrptfGJ8bgjTecg+NGc/90VXAiuE5aeZi1NkRRRiFQTJZdSO3CRXcAHAQru+3fBy49zi1lfPViByNDp7NkXd066QzD2Utv0srajBZhYW2JK605tloRJyanOVYrMz5eZW51GRO1eOaxY5w5PAXA3GaLr5x/dWf7L16n2W5TT5xmdZyus9FY5/UrbzNeGacUhJyeHsVX6Y4+deHdhD9+5zKff+dVHjtyCmMV9ajFuWuXEBjGK2XOL64xWipwohowWnbz6xtRi8cfX++VbbBeX710iV/86qukVjBRKWLShJVOQqo17y3MEUjLM6eeoVSosplImpttkqSFzlYoiw618jhvXDlPfWuTscvjGGs5PinwiscI/QKtuEM9SyiWEpDBDXULp7xNjs4e541rZshxE3rQ3JrjD8++ybXVZcYrRXQSo4KQtWaHJHuXI+OTJJkg0ymNTgxSUgpCsizj6xde5/Ur5zgyPsXjh8Y4cmiM1UabrUaHlXbE8uYqDx2awUOQYbm8vMjniiE/8sRhnnvOzdsfPz7JV1ai3nzXHSsLm2uYtM33PPkiSg3vPXb7Xn19nU66SCcr4VvJtz3xOPUoJEpdzI4xhnbcYW7lMktr13rlqRZD/ssXvqPH1n6Q7Z133uFf/+t/zfvvv4/WmpMnT/Jf/Vf/1bfcnvVBt9s95D9ojFPYuR4sNwVxBhEBKk9cSR567pj/AH3d0G9GcGpQf9bJFOwP1h203YaYmx60ybAiyAE+oBvGL7pMW/Ckpa2dpnCmgx2hxAdlY28/7+337vcakLhT4NhudkPG8WODDued+93bYQN/sybcu5e21LCcXUxZbVmi5AhL72kmSuDfAnA3XhKURYc21V4On254eFfKZLLicv0Ys5cbZNgG9b63g5PbneP72UrzYONoswMvX9EPDHC53ra0bRGkG6OOxZzL3glXr21TzJNTHmyv1HWGpNbHZNBOQFMg6XTza0B2E7rB99oeRKbwXnheZQ8yzoNWrzc9BX4Yanbn7cVjk5w6dYp/8yev8ebVOZbqLT72yDNMjUxQ8JTTkzUd/vjtbzC/PM9/8eJTSBnSkoJqIaRWLHBuYZWvRk1+wLjM0l85f46zl9ccA08WQfl5yHHExYXzXEvW+OE/dXqoQxpj+Z03L1CPUl48MQ5AI04ZKYRUw4DNdoS1lqKn6MQN6s0UT0T8wEfO8L1PPczZs2e5mvlcXFpncWONWrnCo7OTBJ6i3WzwxGyZha0mUaqpxwmZVJyZneBTh2t815OndjxfCJd8afrQFOeX1vjG5QUyYxgthpTCgIKwTFTKTFQsV1a3+E/vzvMT3w8nxgT/+vLbrBnFmdlJ4s46GxtbjI2N4NkOXz53nmqhxnc/920oVUR54BtDJ67z1pWztJorvDR1htOHfH79ynVWYsP3P/MIoFlcvUapmPSYTMenx6gVBBdX11hsdDBhxNNHD3HsoTEef/xxfvet97mwuEoUr5OiEECcauIk4Olj03zPk6doLlzdtV/cDqvk2GiZxx8/zu+8eZHPv/U6zU5KKVR4MmVEGo48dIyx4sSOfvPuwio62eTywptcuO6z3oppRTHNqI4UgoISPDQ9yfGJGhcX12hFCS88dJiXL73DY8eeZrw8Qifuhur7FIIiURLxysW3OD5Z2LVuFlfPMzN5hUcPn2RMKT725KkeMz1eKA9de2SkxFqUcWn5CsJYquUij85O8lf+1NNMpPXeJtu9/8Az8rY5OTnCL/7Ja5xduM63PfosY5VRygVJpjVLW6u8/N4brDfW+MlPv8ifefY0zYWrN3TGKKUYL+kbbvJvFNZkjOWrV1dZN4pHZyY4d+09Thw6w1i5RpxG1NtOQmOiWqOTxLxz9R2ePTHBozNu/I+XAs4cnuL9lXUWV9eY0RNDfWw8P6h0n+HYeZZOvc6mkaw32lzZivETzZNHpojSjCxN8f2ATpbRijK22jGPzkygpObKynVGC7nG37Rkfm6hx0a2SJSCJI14+8rbvHH1XSqlIqemRum0W5xbWOW7nzq9C6g96AEd4c89drQ/p+Rt+NTRQ6w2WqxtbPDItJsnjo2WmRwf57W5JVbqTRbTlEmphvrGRFmSZYYvvPMyj554nonqKHEakSQJgedTK1ZpdNp84eyb/MhHP83JCdlr45u1iuzw7CPdDcC1IaD+ICGWQggemZIsze2UY5iqCB6bDqg2U65mJS4srvHuyhaZUJw6NMbD0xWSxhZFr8Qj0+N87dwmv/vmBR6Zmdy3/dfqLeajFAtUgwCpBGmaYYSg3t5ira5pRZv8lU99hO97+uGhPnVlo8XsaIW0UuStuQu0ooRi6DNeLrDZ7tBOMk4fGmO91eF6o8OZh0IemQ6GyjZoWWb4hT95jXaS8fDMBFi4EqVYayn5HklmOLdwDU9llAsV5tZbSGn5M08dw1Og8rWxvGMOT1hZeYfZ2ccphQUi4bHRTnnkUMBjM+qGST0en5Y8MaN4f1VvA/XrnHrpaX7hC69zeWWDdiemZERvfXv+dMgrV2OiVBAGIcZoljdXOHvlHerRFtO1Mo1OnTfn6wSh5eGpUf7jpffZTDQnJkewJmKj2aRSqXB8cmRgvTN4ntxzvnv66CGOeSmnp8d3fZ+9vnd6usQxL+bPPllGCMH7Kxn//kvvsNBqs7S5wHqzTbPdplIqcWp6HE9K3l1Y5dNPnHqgwdvf+73f46d+6qf43u/9Xn7oh34IrTWvvfYan/3sZ/m5n/s5vvu7v/t+F/EDY9sP+akBbRWJtvjqYIf8B4VxupcFymnmkTMJTU9M3YGbvYiKfMgcJMnTRNn0GHfnVwzXtjSb7f6h+GaSnN0Ju1GI+25g3Y3abTfmZiBSMhFg8iSiBuGAbwNgKfjQiAWhbxnRy0Te0bvKxr5fgMSdAsf2shsxjgcdztv3u7fDBn7Q5E8eNNsrBL+TgDSHeeQmE7cJIZj1l1lWVVrJcK4GKcAn5SNHg5saJ129734C2kEdUXHgpH57aWBvN0/cuqbz3bCubrAv+k66rok8wiJFstZyjOeD2Ebb5hEHiiwfNzZvp25bZbZ409Io98JuVTblTtitMtO/GZK83TRw+2Go2d2x73ryFI/OTPIz/+H3aTUbmPQqnolYW64zNjbCVnuL5a0VjLU044RaMex9VwjB7GiF9+cXuLZZR0nFxaV1fNOk07mElMUecAkx1TDj/ZU21zbrHBvvsxKubdS5uLTOZClECEG9E1OPU8ZrNUJPUS2GbDZafOLMCaqFkEvzCxQqFf78849xdKxKc6HMDzzzLNc267zy+pt89NmnOTo2yvzGZu/nwyMjvHJlnq+/+Q4vPP0Ezx8/zFtvvbHr87s2XilyNKvxxtwSUsD0aJVqIaTVbAJOR3KiUmSh3uAbV68zO1plvt7m1NFZhBAY06HTWWdkJKARJWhrWdxYYnn9XXyvxGuXFwgDnzRrE6Up9SilEbkkK8Y6TdpGlFAt9PX/rI3wdJ2VLcuPf/KTWGt673hktMYbb7zO6elxHpmZ5OraBq+8/iYfeeYphBV840133fGJMaw1vLYHcAu3xyo5PT1OIfB5Y26RUEecOnKYaiFkaWlx335zfKTMyWOHOb+0xptXFykGASOlApk2RLFjqIaex0jos1RvcWp6nLeuLbO49DaPnniaSq2G1gblSbARm/U5hK7zl779BV546MiudTNYbycn5BAzffu1zz79JMubLV552/WhF08eQwjLa6+9tuP9tz/jtcuLNOIUzTp//PYXGCuPIpFoq1mtb9DsRGgBJ6fHOD09vm/b3Gm7tlnv9dtGlHB5+RpbjSZPnnyaclihVvIw1rDZ2uDS4kUuLy9warrCaLmYt2OD/9NHzyCF6L3v9j42+IzuIatW8Hlkeprrmw02mi2KYcjRiRHemltipBAwWquSZJqNegMVBJyZnUQIev3moSkHCnXZyN+Ya/H/+8pZRmsFAtlmuprw5PQIh6en3bwxN8+FpXWubdQ5PFrp9cXdFstjozvnFCEkP/ufv7hjnjh5aIyTh8Y4v7TK5cUV/tr3fZIfePaxob7xjavXOXt9Di0Ujx19jHKhil9047re3uKNC2+w0FjjG1eu89GHZm+rPe/EBmAvD7Axplc3X798jbmlFU4dmeHwWA1rLYuNrV4ZJkthr7610Xu2//mlNa6sbRF4ipOHxhBAo9WiUnK7wdWtBkZKPvbwkaGx0e1TjxydxQIr9TZlTzBWq2It1NuR08fWhkohYKPepBHF1IrhUNm6fQHgG1euc3l1k5HQRwpJPYpJtMFTCimd3nSiNY04Icm2WFhfRUjJ4tYYswP3acbpjjk86mzQab+PlEUWVtYRgc/3P/ERpquVA4HqznFjd4D63/XkKT79xMN87dLcjvXtuRMjHKo2+Ge//XVMnDI9OUJBdJgppTx/8iS1Ysj1zTqXri/xl779KayBX/7Cq0zUqkghhw4l29e7j506Cuw+33Xn1P3sRt+TUuLJJu9cPcupo7OcGD/CVjvi+uISh2emGSkVaEYJFxbXuLZR59jEvWc6HtT++T//5/z0T/80n/nMZ4Z+/wu/8Av8/M///IfA7T207iH/+josNbpJjwrETSc/VA5gyrvxIf+g7Mj7bd0kT2Lg5+HPd4JT28HBxXMaYzVKQpQc4f1LLulxNXSao4EqsNaypHmSs5sBcm7VbhTivhdYt1+77cbc9ISmUoRmDAkOvBU4DULrBOSZLDv9+YWLm8yeOHHX2Nj3E5C4U+DYjZ5xK2PqdtjAD5L8yZ2SI7iT5dkvBD8h5NU5zezIzckGVGSHR04pzi6Zfg6fPFeD17jGdPXMTZd1L73v/ti8sVNt/ID1HfhOpm4vLfT7ZnthyLeALUeppZ30Jdf6N3I/aQsWjzg9uBbxvbCbkU2507ab3vq9dmjeTbuloIMPQ83ujnWyjEoh5JCP04qzUQ9wTAdCHJNspyB3MfBJtKEVpUiliTJNyXOT+CBwKaUcunbQmnEy9L0k02hj8ZVbLCthQKPVpuD7jJQKTFUKdJSinfTvI6Xg2PgIa2MVjo2PoJTc9rPiY6eOEtRXeS4/cO71/EGLkgyBwBMuWdH26akY+GTastboUCsUSLSmFPg77rO9HpOswfW1RWYnxlBS4iuFtnaojgWCZJds66Gn6GSadpLy6PR47x0HbbA+TkyMArCeXyel4AZJ3IHbY5W0kxQlJVPlwhDY37W9+o0QApFvvgq+aw8lBQaLzr3dgSfppJqlrSZKSkLdIkuuYLLtjgJNoBS1QmGIjbW9r+xng9eenBzj5OQYYdP1oe0hwHt979j4CL/zxgWMtYR5H9tobjrGZRDk+p2SVmZY2mresG7vtLWitNdvtzoxmTZsNlZ589LX8bwSa42IzKQUA0PB84b6abcdO3HGY4cne++7vY8NPmPQhBCEnoevJL6n6CQpmTb40gGOoe9RCjwyKUmNYaQY7jqHSCmp+DGXF9/j+epJhPCoFUPahaDX/7rjphknB6qX7W343tL6nvOElJKTU+NsbtY5fWgCzxvuG2uNDqm2tOM6b15+hXKhSpZkeIFHs1Nnq1Un1YbVZvtAZbsXtr8Uj6BWKBB4kkO18g7GEwzXt9Fmz/YXSMcKkBKDpeT7pJ6ikF9bCT22UsN6a3je2d5vhYCS7xF6Xm9tEFi03dlv9+oLq802qdaUfTcHZcY4ber81ZUUpJkl08atB8I52QbXIuivlbvN4cZ0yOJNOllIKzlYX7yReZ7cc33rpClJ2qZkY0p+FfyQTj4upJQcqlW4trRKrVDg0soGqbYUd1nDYHi9G7SbmVNv5nuDbSyEcGO66MouhKAY+ixuNQ88pu+Xzc3N8dJLL+34/UsvvcTP/uzP3ocSfWh2ANEUD9bZ87Yt0e6Qmul+kie3i5KDKQ1JNUQ3SPIUWe0kS3LJnG5iVGOcdqLKk1pWw5tLcna7dqMQ91sJ3d+LuRl6gtCDOLNsNlNePFFgsiJ459z8kFbhAnePjX07Oq53yu4EOHY37HbZwA+C/MmDCPrsG4IPaFwy1/WWYfQmi+nGyXAOn9sdJ7vpfd9MxNlUVeLcM/tPGqEnUMLekqbz3bB9dYNzuTOBOTDbFhxw22Ugi+5fth+l4djXkii7/4zjQbud5KO3Y3vprd9rh+bdtJtW2/293/s9/uJf/ItYa/mhH/ohfuiHfgghBJ/97Gf5/d///btRxg+MVcKAgqeIdwFmXcImZ8EugEUnSQmUpFzw973P9mv3e37gKXdAzr3ZqdYoIXrPjzNN6Ckq4d6ZqG/G9it3MfBzLSt3aN/tnTwlmKgWKRd8gm2Acte21+N+79h9T4slUDvr/E6//362n8byfnYzfWH7taXQQ4p+3WjjfH7d+k8yg68Us6PVoe91HQXGdHY8437bzGgFKcSe9ZEZi5KC2dF777od7Le+UnhK9kDyVqfOtbUFVhubKCF3jMWD1vF+Y2Owv5cCf+j54NpfSUGg1L7P2+8ZcPvj5lbnN4CJahFfCTp52ZqdOqtbyzQ7daDfpycrD1jM0T52M/W937Wl0Mu1Fy1K7Nwa7FU3+/Vblc9TFrFrv92rL0xWSvhKEec7Vk9KpBC90GJt3KHQUxIlnEakFGIHIP0gzeE302+399Pdru2ud/fCbtTHOnF6z+rxduzhhx/m85///I7f//Ef/zFHjhy5DyX64FoXAEMIDlXcobcgIibKMF1xB9IHJQT2Vi303J+AhEB1WbYCmYfNuiSHgsw4cOqIv8h0VQyBg9XQSSrEBBicrqEFNCoHcCE1ENkC6y1Yb4O0ppfk7G5bP8SdXTVl+2Ddwe/ZZW6aXY6oQnTrzzBVlUyU5Z774lvdN+9nNwYknHTExl3GTiuyw3eelnzHacUx/zrfcVrx0qMe09X7qx35+IxE4djAqe6zZuuxA/kdi37vMk5XBS896g2913eellTk3Qeju6DPassSqC6LHdZazomy1Lg/c1E3BF+JPmDXNZE7gzIDq61bu//dGCe3c8/xkqAqOvv68AIFvro9Tec7bV3dYIBU00sM78aAu6YsOjfFYk9620W7g7A7ON0+CMD1oN2tJIr7WVdvPcmgFjpnmhBOv7ngQWo9Xp/XB9ZsflDtpoHbbqjZz/7sz/LjP/7jfOYzn+Hnfu7n+Omf/ml+/ud//m6U8YG0LDO8/P48X7qyzFcuznF5eZPLG03m1rfIMsPc+lbv50E9nsHvfenCVb783hxfurLMy+/PM12t8PD0OKvtGGMM9U7MZieh3omphD5KuKRP5cB3n0XuM601F5c3KAce1sBUuUzgK86t1pnf9nytNW/Pr6CN5fp6g2xATObIWG3o+dZaAiXZaHXIdMZKvY21ls1Wh7nVLd5dqVPwFFPl8oHe9+X354eet92Gn2+H3nG6WsJTksxYjBmewNIsZX69jhKC62sN4lhT9hUXlzd2DNBqIejVYyUMqBYCaqFPM4rRRrPR6hAoidaGrVaHKNUkqaa8DRCw1rLajjk9Pc7sSLX3/lfWNrm6erC6iKJs6Ock0XvWozF2z2cM9rdLqxt89cL8rn1q+6baGDPUb6arFSarJa5stdhottHa4EvZY+pFaYaSDiQxxrAVp5ycGuW7H3+4972tdjS0mAw+Q2u7Z93cyPbrR/uNxSTRQ9/79KOnGCv6tJMUrTWZNmTGkGmDNppOpjlUK/PpM6cO9Lwb9enBdrvRXHB1ZQttDO9cW6Ec+IyVi7TTDK019U5MojWZ1kgsK/UW1roxkmXZgerYGIuxtjc2tDZDY6wc+EghUFIyO1LpPd9al02+nWaMl4tUQn+o3+z3jO3jb69xs19/3/7ZfvPE9rlw+z2namVGCwHLjZar1yhmK06oRzF6oE8/f+LwbffLG9lBx/T55TV+4fOv8m++foFf/MKrtNvp0Pe0Pnh979c2M7UyQR5x4EtBnGZEmaYTJ2y22iy3IsbLBZ45MjP0DoP3rIT9fmusY8kaa8G6yI1mlFAr+FQL4VDZjozVhsry/InDPDQ5ylacYqyhEvoESjrmbT5eAyWpBD7auGRqvqc4VC311s2tduTGuDEYwxCoaK1lqx1xZbPFVLXERLHEb752jv/j7av85mvnaLfTA7XrzbT/7Ei1N09utjtstfv9Nsuy3ro8v1ZnvFTq91NjiDPXFnGWkWUZC5sNip5CZ3bomQftUzcz3m40bxhjuL7Z4PTMxI52fNDsr//1v85/99/9d/z0T/80v/zLv8wv//Iv8zf/5t/kn/yTf8Jf/+t//X4X7wNlgwCYlIJACTyhCZRwkWEDANj20OVvFjC3y0C0QjJWhPEcnJ6swEwVij6URYuXHpFD4FS3bqQ1rLdhvQUaD20cSOtMkJq+BEP+KxLtkqHF2b1JctYNcQ88qN8iWLfduvWW4d0xMPhO2f0AJPayuwG43a512cATZUGiGWIDf+yEOhAAez/eay/Qx1eCaugcJWcXzf2de/Z8tLjRBd9U1tXfHSnuDVIZC6sNSyO+f3PB9nUJYNZfplpwEi5DusESqgX3+c3pBndbNydBDIDBA799IMb+oO3nfIO7A7h39daLud46QGaVW0PbkOGxUIffOZvdNyfMnbCbrrIPQ83gD95+v5eEpN7qwFcvEviKiYLH0YtrxNoQeop2s87nrzd5eHqc417K2sD3Nhpt0i+cAwG+FIy9Oc9DU2N871OnkAJ+582LaGuJoogLW5EDU0ar1BuW3337ItoYoijindUm7SSj4HtMFTz+9r/7Xa5vNWlFKY1OxNzWBcZKBU6OFljTy7x6ZZEoyfAE/PSv/i4PTY7yHUdqvezU3/f0ab709nu95zeilEYSMbe+hUAgsMy/eg5rHfN14+1LfPHiL3B4tIpIoz3ft9WJ+Lf5O37mTz3LxC712n/+eX7nrQs73lHmM9h7S2vUCgFlJVlb3WC50cZYaEbwt/7d7+J7HuMFDz8IWdhs8tTRKeRARvpHZybY2NzkwvI6s6MVZqsl3ttsc/b6qvPmW8P/9rW3ybTbFbe14Ve+8ibPn5hhRHSzdTepFZze57/43Ne4sLjK+wuL/MtXLgMQWM3nrzc5PTPJ9z51iq/NrfLPvvLrXF7dpNWJ+F9fuURqHDBqtOaXXrtC6Hu71mNlab2XPGb7M35zoL/NL6+w9kfvEGcZwthefX/vU6eoFXzOL7n31fkh/a35FdJMM+IL/l+//kfE2pBpzZWNFu8uvw044FVbWEhbSAGhklxe2UBbS8VXfM9TD/OvPv8K7y9vsNSI+N233md2pMyEL0gHnhFi+Gu/+Ju71s3NjLdeP8r77Zq/91gce2eB61tN4lSTJEnve8/NjvMnV1dZaXScdEPuDjXGEniSTz5ynP/rL/wfu/bb97e14359+sJAuy2urh5oLlAChJScX1rn0ZlxOpnm1bmlHoMx1infuLqEBDwl+K3Xz2MFVMOA8dDbs47nNlt88XNf4+LSOtcabVY6mrfmlykFPiZLuLDZQUnJZDnkyKFJLixvMDtaYWltk6VGCywESlIKfX77zYu9fvNzv/PlPZ+xlbBj/O02brbXTWWfenvuAPNEdy7cq2xCuNDvV64sInCHTNmIEEIwEnr8lT/13A6Jhd1s+5i+0fy2V9/Yb0yfnbvO8n/6BmkOsv7Hd+b5f//HL/DQxChFqXvfM0lCjDxQfe/XNqcmKiy2Us4urCKlIElT0o1mHuIF1zYafPZ//XU+86eepb1Hex+fqAGC80vrJFnu3TaGs9dXmKyWmK2VaMb9sn3v06d3SHp4nuQzn3qO/+Y//D5X1+pMVIqMFHxWOyntNMOXkkqguLy2Rb0TYwGJ4N9+9S1KgU8cx7x8fYMsM0gsnq/57Tcv8NTRKZrthAvnr7Kw2URnGX907gq/+vLbxGmG1ob/7+uXEeJ3Kfoe0tqh+ea5526t/bvt/f7yBte22lz6+rt4UuALeH1pi61OAhYU8H/7N79J4CsCYWnHGa9dXXTSLkaz0IiIMicblGaK/8f/9nu9slVmD9antu9L9htvg5/tPW+4RHffl7fjg2wvvfQS/+pf/St+5Vd+hX/7b/8tYRhy8uRJfuVXfoVnnnnmfhfvvtq91nU8KAC2VLe8eb0furx6XlMOgGyM9bZlsvLgHsAG9UibiQNqFRoBNFNBMbCMscxEeWzoe13QNSJA6X6iGxcRwVCNDYbMCly9aSNItUuOdi9srxD3Ww3dvxc6rrdqt6Pj+kGx2w2Vvx92oyR7HlmPxT5SuLdl2zcEHzdP+tKNt28VG9TfvbZph5xQAgNWEWuQBsZl857PBXtKagCf3EU32CUVvvm5cLLsJFgSbRBC9aI2YHBduDn5hXthdzuJ4m62XW89ziyxDRG6L1MEio225eUr+q5qkd9Nu+mlpRtq9uM//uNDv/+ghJp9bW6Vf/fOGzQ7MeXQhe9rLM0ooRVFNHPdvdFSgRPVgNFygbfml/n91VXW4vdI0gxfSRJj0NaCsWjthuH5hVWurG5SlhaUN8CDt31tE/cjIEi1JUpijLVUCyFCWN5ZWCVKMoq+z1Q5JLaCtVaHlUYTT22ipGBmtIxvNDIIeG9xjUtLq5w69T7f+8wj+QNEb4eYGUOqTV4U29swWhwTJ0pdIq/NVsRTh6q7vu94pUhZWmQQcH5hlX/8m1/gR544PHQIHja76ztOVsucGCmw1M7YaHVYS3WvPCXfQxuDAaIkZTFNefJYjU6S8erlRUZ9wcmwxNPHpvmeJ09x9uzZXrb65XZEqg0F3w2HzXbaA6YDJRmrFNloRXz5wjWO1Qo8HpZ4+ugh/E6dz71ziY12RMFX1DsZWlmEhchkIOCt+SW+emGOd68tgVRMVIqYNGGlk5BqjS8lYwWPONVstKId9filrU3Grm5hrN3xjHqasJVt0IlTlBRstiMM5BrADoQ8v7DKwmaD7zoxTm3yEBeX1nl/vcFWUifwFB95aIbm5hZXNupstSKUFCSZwZIzm7uHBZyHMzMWZS2h5zFW9PjqxWsYazk+OYJMItYyy8Jmk8vJ/5+9Pw+yPLvu+8DPvb/t7flyz6zK2rP2rl7RQAMEQBIUAW4jyvZMSNYMRZkecWyHRM/IEaMJhUOyQqFwaEjZ/kOWwgpbIwYlQXJQm0WaBEwSBAgQjW50o7tr69qra8s98+Xbf8u9d/64v/fyvZdLZXVXdVUT+Y2oqsz6vfe727nn3nvuOd8TklmpUwh8jk0Oc/PBEiqKN/XN/dV1XhvPsJ0o9M63Xjm6Or/CpXvz+D+4jdFm01ystVrcXW+RaE3W8xjJeGQy9ntoxXS5yP21KlGcoA1IYQg8l5GMxx9dvbOl3P7Xv/kHRHGE63qMPkSm71YavH7tB6w120wN5ZFhjtJudAEwXspQa0e8dWueRFkZ74REdjSCBow2JGiUNtSJEUaTQWzq40v3FlirVCgNDTFdLjCRy1KJmqw3E+JEkXVSgkEDOc/hP3jlFFfmV7k+v0wp6xHhWE6tyHBjYa0rN7LdTNu0uYzZkRI6k+PCvaX++Tcwbwb7plfeB5+9125w+vQqJ/eN76gnipmAyUImnUOb6zaSDbiz3ko9iftDz3ZzzDXG8Dvv3eV3bzVoRppixn8k/dYrGzvN6ShRrDXb3TQEnbqFseLK/ArljMdQIYcwILXi2L5R7qxUH9rfO43Ny6MZvj1X48K9RRrtiDAxqVEUMq5kKBdwbW6Zv/Vvv8loIJkaG9003pfvL1OPYrQRZDwXz3Pwg4BWFBMnmqVGm0KjzbmZCQ64MbOTI1v200+cPcrNm0f51v0qt5crhImmlPFJtGa0OAw4REmM50gmcy6VGJaqDdpRgtYK6TjWwOs5nNo3xp2VKt+7fp92FBL4AdPlAs1GgxtLa8RpdIEnBW1l0EYTxYqJvI3KGFwnf//iTX797ZvERjySLijlArKuS5IookTTUAna2ENi4LkIDDrVYQJN1vdJlKIdJ2AsTzBA1neZyPtdnXb1wSLfnquRD/wdZWpwX7LTfBt8tp3eEHZS7GLmPBv47Gc/y2c/+9m+/wvDkLt373LgwIEnUubf+lt/i+vXr/Mbv/EbT+T9HxULVc3FOfWx8jruxgCmjeD9RY02lq+ubRStGNbbYMw01auK8YLh1OSza7D4MHykvmPS0Fp7CNXp/husF2DvdOvzuOXpTcWtOGV7jXXGGNZadC8GHmZw/6TzuJYzeVabu2/vnzR8ErKz9+JhSfYkGqU/Hi/2QXRC8JsUiVMjlEakOtJ+ZqwAI3n5iQ8D78VkUTBVcvndSzFz6wpw7dkHSWKso4sroa4LH6sn9MN4VI8DXzrRzxv8YS8uRvKSsQLMrQPGtldphSNtBIYQkKPFSG5zDpuniadx+dbLt+4JQz1M57ToeC5bmp1CYDnlt6Ji2mqdetZ01yNTJfwwh5oliea3Lt+j1go5MFoiTKzBpRj4lHMBYaJZqbc4MDpEojUPai0KQcCx8TI3Vxqs1pvMDBdZb0Uobci4DlnfJhSotNrMjJRYqTd5UG3xk2eO8cWTh3luqswXTx7mK+eOMbdWY7kR8uXnjvGFEwcZytiw1DP7xpEYri7XSJRmJJ9BCHtDc3iszPGJcmp005yeHmOskMeRkmIm4OBoiWaU8OvffocoUnztvE3e9JXnZvn88YMIBJ4jmShkuwaOjOfYUGSgHSeM5DMkSnN9pUbe9/vae3B0iGIm2ChvbIhaK+S3398cVqq1ScuHr5zb3EZXWi6w//CV03zluWN2IgosjYKUGAyB45ALPLSB20sVvnz2KAfHhtg3lOP/+ZXP8l/8xKeZnRzhQDnPf/6lV/kvf+o19hezzE6O8Oc+8xye4+AIGC1kGCvm0ptXOD09RsZz0MbwKz/5Gr/8Y5/ig7UGq40WxydHmKvUiZRisphnYihPpDTzlTrHxstcuLdAtR1zcKRE3veotGOMMeQ8F60Nqy3LGzjYj7MTw9ypNLk6v8zsxHBfGeOlHNUwZr0ZMjNcZKXRIowV5WxAMeNbTrRYcXDU9vf37i7zl774Sre9B8eG+KnnZ5kZLjFXs7QIMyP2PbHSjOVzjBZyOFLguQ6TxSyB65D1HL7y3Cx/7jNnqEeKq/PLHJ8coZgJGM75/Mjxg/zk2aO4UuI7Dl9+7hiNMN6yb45PjrDaaPG9u8tb0ib0zreDY/1yNDNcoNKKWKk1mRnpn4tDWZ8wMbRS2RQC6pFN/HdgpMh6O6LSaPFLn3+JL5+b5YXpMl8+N8svfu4FamGypdzOjBRZrjdZb8UcGCntKNNaG753Z5nVRosTU6PpZwXFzO50QSOKOT4x3DXajuUzjBay9sYw9coFSAxkfI/xYpY4UVRaIROFXF8fz04Mc3V+hTuVBrMTIxQCn7laE1dKTu8bYzifoZTx+cKJQ3zl3DG0gStzy/znX3qV/9dPf5a/+Mox/uF/8nP8j7/4cxwdLXTl5sDIULdNxydH+srotPfAyBA//fxs3/zrnTeDfdMr7x2Z6i2j2o75+vnrJIl+qJ7o6N7BuuV9jxsrNYQQTBSz5H2Pgu9yfHKU52fGMQZ+/dvvbBvyvlAz/P6VmKvLOT57+nN8+aUf43Onf4Tx8uRD9VtHx3VkY1Bv9M7pfUP5rtHWFRu83gbrlQmw3o4Zz2+MdzOM+alzx3bV3zuNTc73+I8/8xylXIArBSP5DFPlAo6UhLHiQLpO3Vypc2x8uO+dP3XuGJ4ryaYXAH/6pVO8uG+EP3X2KH/+s+eYnRrplveffelVDpR3dhN49cAY/7//+5/h7/35L/OffnqWX/u//hn+3v/tL/EfffYr/Nynfpw/9/mf4hd+9Oco5cdwhOD09BiuY/lwj40Pc2LK+r42w5ivPHcUz5V4juQnzx7ltaMz3Kk0UcrqYoyhndhjgZvOsdVWTD7w+9bJdjvhn/zROzSjhIOju9cFnfEGw4mJEY6OD6VGF8N4MWuNxUpR6NlPNKOEczMTjBeyNgGk5zA1lMd3nU067eK9RY6Nb79OHBzYl+w03waf7aQ3fur5WZRJ1+5HoL95lvDGG2/w5S9/+Ym8++233+arX/3qE3n348BCVfP67eRj53V8WDi8zaRtjROlLs9rQKJJjSuGKIHlhuaNDxT1Z9h75qPwkfbkbuv+Pgi70tgHKtUp1kvr4z1wbhfiXtdZvnld863rirvxPr51XfGNqw8PV30WeVwB9pfthVWlvTU1REHW+dYN88jt3cPTQ6/RZytoJI60F04fNzrUAVnf6sFYg8ax/xrwSHhpxnnmDEyPA5WWTfjXubRyJUhU18CuNDR09olzSnewW0oN4LHQfQgheGnGIRCxjUIxdl00Bhznw9EvPC48jMLocdCmPAp6+dYjZS8/BXojKgXrvey7W3ORb7tOVZ+ty5BHNtx2Qs3CMOSrX/0q//pf/2uMMfzzf/7P+Zmf+ZknUcdnBm/fecB8vcVoIWtvDeIYT9gMsFrb5CiJUjTCmELGp9q23qjz1QZRmpRlrRXSjmNcAVJIBAJXStpRQqUZWo9HpVio1SllA8pp1ul6GKNSvsBGFCOEIFKa4XwWKSVCStqxwnccpJT4rk3sEiuFMh1uFENjgHhJCslQ4HFrqcLXL17nxsIqY7kAKQWNKKaVKPKBh2JjwyiFpONpo7RJs1+71MOEufVaX3sjpTeVN1rIMldr8fadB33P7q9Ve8qXm9rY6dNGFBMqhTbgCkFiDLHWSESaHV3gSkEjjLi1XOHYxDCNKEFI+kI5pbRct41YcWximIVag0YYkfVcPMftGq1bcUKsDROlPJV2xGK9zly1xr1qk+lygVo7Yq3RIue53fJznstqo8WNpTXCRCEFxFpTD2OiNBO6lBIn5e219ZF9/VgPY7QxKK2ZW6/3lREn1gtaG8NaK7TJejBoQ1+9I6W7/f3Ovbm+9kopqbUjqmFMIRPQiJKN96Qj3D0wCEkx49vnEpqx6tat1t7IJC6E5aez7YP5an3bvqm1I6bLBe6tN7lfqe443+RAsqRmytiujaHSDPvmYqJMV95jZbpzIUoSEmVwhKAdJyzVm5yYGuXk+BAnpkZZajS3ldtGlHK9pvNvJ5m+X6l2ZWNwMd2tLlistTbCIdPLA2PAwXLQdjxwRbqIC2HnYj2K+/p4br3e1Rv1MOobb0c6DOezaQiOlb+xXMD1hVXm1mscGBni8HCBQ6NlHKdfbnpRa0d9ZfT1jZR986933gz2Ta+898pUR646dXv7gwe70hO1dripbnPrdWpRQtZzcV2XfMZHIAg8B9dxu7rw7Q/6dRNs3LI/qMTU2k2a7RqJiijlhnj+2CuU8yM76jegTzYG9UbvnJ6vNbsetkLIvmCLTr8ZYKne7Bvvehjvur93GpuFmvVczfsuWc/r0yn1KO6uU/PV+qYxdKRNGOY41kO3nLVrmOM42+rineC6kk8fneH5A4eoxaMsNzVJEoNq4UoQMsfpIy9xYGwfsTZIYddiKe160Omb+WqjWzcpBTeX12gnCs+R3TXU6j3bN1IIEm1Ya7T61sl/+cZ5bi9XGAq8TXppJ13QO95SShJN12MrSaMbOuPfu59oxYpcJuhGD/Su74M67ebS2rYyFSndNzd2mm+Dzx6mN/aVi1yfX+H+2mY9/sOMKIr4G3/jb/Di9uFFTxXGGC7OKcKnwOv4sERGjgSJIefZtCzrbetlJrAeZxKD0jbpSJQ8+4nMHoW3M1L2gCkwKNPxte01z1r0plvs0Cj4jk2G1kmM9rSxULMXACsDFwPLDbMrg/uzxOO6UDN842rCxTnrBR4lljuxbTJdg8TsuGRFDX/o9u7hyaDXyLTS0Kw0dJ/B6WFJ9hJcylnB8CMklnrccGWqF22Yi03SJzd0w59EtGNDOz1yubJjuDX2Z8fqwwSHMP54dP9WPKodDFJqPC5MFgUHvfvMDEMuABdFLoCDw4IfOfr4DaC7QUcX9ho5v3ldb9JvH+flWy/fej1MI1Ox62KSUtgUAmvb6OUiN8ZwbUlzJ97PYn2z3n799rNlvP1Qy/rTCDV7FrBSa6VGSo849aZxupb81FgExCo1dhpDlCiaYdI9cMeJSjNgb7xXCus9FyWWx9UYQ2vAwBr3EABGaVZqpW3Clw464f1g/9UYlLZ0B/a56XtPB74racWKuUqNdqLIpZm4m2GCNraM3kzYphuibKGNJnBdGmm9O+TZQog0tLM/m3fW90iUYaXWr2zqYdRXfpSovjZ6aeKcKFHUUi9VhECnBrVeNSCFQGlDrR1xeLxMpDSN9uaM2I229QbN+R6L1UZaXu977KFXGd1X71Im0/3eeiskURqvZ1AdaQ/jtXbU9ZjojIU2pjv+UogeybFt7PRj4NrpKRA0o7ivDJVuLASGOFHdqPHOhmM39R7s40aoN72nM94Gs23dogGZ6sjnVvXu7ZtIKYaywbZj0zvfBtEr01GS9M1FbTZ6VBuNL93uXADrtaqN2ZQhvXeeDsptojYOTYnarMB36uPtythJF7Tjjfmv0wnVuw2QqdxrY2ktOp7hnbp1+ri3jVvpjd45JWWW4dI4DSM2GXJ658kgttJNg33TO8bbvadXbgZlCiBwHVqJYrne3LWe6DUOdnRxR6d1+qlXNjq6cLne7Cu7c8uuJWAi4iTGkwKlFc2wQcbLcWDiKOu339pWvw3246De6J3TYTygb3vr0vN7mCTddmw3p7brb9h+bHbShYnSj7RO7VTebtHb/55UJDrBEQLQxEkL3w04OnWMN68uY3twY0y3mwu1Vty3Zg5CCtGVI9iQjbur63aN97a+997tOpFo3aXB0On6pTEDunejT7db32FDp9Xa0bYypYwm47p9bbLPdtbhkVIYbbadYwDZwGN+vb7p4uaHHf/oH/0jTp48yeHDh3njjTeednU2oZMEK/eUeB13CocfLwje+cAaZyutToiyvfBI72ZT+iBB1jOsh9Z7ZiT3+Ov5caNjdFVRhHTcLm1CR1UZkx5KBQQScj602y2K+TyugOVEdo1MT9ML3hjD5XmNwmEksDLVuRjwHOtJ1zG4P+vegoPh0YEIyWUDGpHV0WenJScmHL5xNdlVe/fw8aGXj7Qe7eeDS+l+Xs2wcl0xnLN0K+PuCmtumWoIWbcntDu2xrLTU/KpeTYuJaPEgCchVnYfKOmEzksuz2umh/7kyVWYbFDFDHZ9J3GXQdL+mCgsnhalhuWNdlLe6I9Gv/Bh0aERWEyGuXVLobXlbR+kilioGfaVN773cdKmdPjW372vmVu3s0SnF5rChASuPQt1uMhroeEPrsTcqxhi45NEoDUInA29HcLFOcVE8dmgfHls97FvvPEGv/zLv8zly5cf1yufOYwWs3iOoBXF+K6LlAKdTk7RIYvGHmri1KvOdx1ygZvehhs819nEUaVTw57vumhjk+RkB5jtPWfjBO2nBgtHCmKlcVIPuI7XHdh/JQJHWi8++1z0vaeDKNF4jsN0uUjGdQhDexjLBS5S2DJkj7CKDgduCikksVLInnp32uuIzdqtFcW4jmC0OHAzE/h95fuu09fG3j4tZlNDhDFIITYdOrSxSr6Y8e14OZJ8ZrPxIp/x8B2HZhST9T0cKbqHXfseEFLgCNlX797veY6D60hUjxFDaYPjCooZvzvenbGwRjfr7t45sHc6tLcfO+NsMOR8r68Mp+t1Z6kMENb7sqNUdlPvIdft62PXXt1uvMdsjLdAbFs3f0Cmdqp3b9/4jrPj2PTONy/bX0avTNu5GHfnYkdWrWeO7JsLpF5tUopNxqzeeToot25qsBA9P/dipz7eroyddEGHb3mwPRuf6xjoraeuSeW9U7dOH/e2cSu9ESvFVHmSqbHTZLw8rm8Jt2+u5CjnNyq2U5u20k2DfdM7xtu9ZyeZAggTRRA4jBVyu9YTvYtsRxd3dFogB2SDDV04Vug//fcmrjDGvlf3DFw7alHIFClkSjxYW9xSvw3246De6J3TQY/FVKRb061+71yg7DSntuvvncZmJ13oOjLVr7tbp3Yqb7fo7X+lUx3aiVQQglbUpJAtMpQf4u5qJb1RF319MzgXilmvu2bKLTbhHd3sdy8IrGwcGBnCc5y+y8zBNu5mnbBc5HYkOxd4Io0a2dC9pGUl267vvTqtmPG3lSlH9M+NDh6mw33HwUiz7RwDaIUxgetQCPyHD+YPCW7cuMFXv/pV/t2/+3cfiSrhYUkSPwpakSFRhmyaUqGzh+peAKeH0FakKXh6U306Pw/++yjPCrLFc0cMlRZcvvaA00eOMloQrNQVxggqrQ0ex47vqb3LlGlEkL20NQhakUIF4rHV7Um8ZzfPSoFkKAONlqScsYbqWqNNMZ/HEbAego6aZDJ5GyrtQIy9wK+lRqaT48Yml/0Y6z3472rTGv1drD7qlS8hBBkXqmHASl11PRk/SvnGGFbqiprOsVxLGC2YLufnR2lHx3CmJJSCjcsyz4GhDCzHgntrmpEcu27vWFE81bH5uMp42nWr6yxv3FaECjA2szw6vTBFYgws1zVvtGAY+NQMXFmCtaYN7Q4Texnk6XnGcgWUUh9736zUFQ2d3TjjSDBKI6VDokHjslQzLNcVQ8GT0dNPuo3bPfOkSB1atjCYmc6ZyeBL/bGMjStsVGqswBdm05qpkbgCXKlRSn+oMrZ7prVmKLAG0KFAo/Wj6ZCPUn5dZ/nDa4q1JlSTSVAQOKlBVNgLhIIPy6HDpTnFRIFH0r2Pc9zGcpo/dULwf1wxLK4rhrMOvgvVmupGzjZjcEm4PK9pxx05UkgpiRRoE9CODRlPkHXtOrZcV4w8IY/73vo/DM9AIM0nA1obxkt5yhmfxVqDI6Nlsp7HehyTMfbgp43Bd13ygcdao0Up41HMBOR9Fz/1UBnOBix5Ho0wwjU6DZPU5DOW125uvYbvOEyV+jPtFTO+DfEUgkJgjYGlwKPeDvFdidGajOcQKUVGO0SJInAlvut2PRGlEOSD/gOzNpr1MOa5g6N8+ewsNxdX+faFZY4Yw/RQgaLvUo8TCr6LkAKjrY8D6d+OFHiOoNqKKQQu00NFjNHd9voDRi5tLA/wdDHLywf39T3bP1zi2ORIt/xixu+20ZU28YxjDNVWyOGREl5KM+BKgSclbW0n5VhpBHCQUnN0fJjri6vMDOXYXy5tGtf95RIzpRxzKefqUC7DcrVONh2bWGmGMgG+I5mrbNRbStH93ompUYbzWe42mgwZTZRoKu2IA4U8R8eG+Z57j2aYJr8JJH6akEoKUErjpgYGrTWtKOn2ow2FsaHx00MF7q1WudtoUjYGz5U2TFUIhrMB96Ug0XaBM5huvR0M91arFDzJ/Gqd5/dNdetdzASYdIzWGq2URzF9D6BS3z5rWEh5YreoWzHTf1gvBN629UZAM044ODzUTfqz3di8fHAfU4Us8/UWhTSkvYOc73RlupwLaMdJdy66qcDbiwpBO96YC1orlDEUPJepoY051uEcllIQD3iyg03aJbAeLm7XS3prme6VjWImoNoKqbQjcq2QyWK+OzfK2YAF1xrapFY4UnZ1wWQpx9x6DWOsgUdp3U2+ZrTphnQbASKlAhBC4KYh0x35myoVdtQbGb/EK7Mvk/EKaB1Rb9UZKZZoxi7fvhGh12F0dZ3pUnFzm1q2Tb26Ke97fc9K2YC5Sp2ZoRyThQJv332A0ppL95d49ch+6mHU7Zu8vyE3hcDv67dC4LPcDPnC0UO8eGCarxWv8fqDeUabbYqZoK9N9XbU1b1gw71VGvad8zyyrkMjtEmtevVkry58+dC+rp5LEs27d5ZoxBmcdpuhbIaM51JvR7iOHYlEKbKBwJHOtvptK32T8z3u1epkoijdhNrkf5PFLHOVeur9rrsZ1DpG/87P44UcBrPjnOqUV8r2u8wZY7pjM10qcn+9St5zuLG4xvMzExu6UGs0hjBRFH2PvO+itHnoOjUoC8WMz43FNQq+i9E8kidYr5eD57rkA5/VWkTOWP2PsSn8sn6ANh26gc4GzfbN9FD/XDg2PkzGdWgnGkcKjNZdChKttaXikYLhfLZPNv7sp8/xtfPXuXh3njGj++gSlFYsVhuMZnzG8nmUMn19mvM97lXrZLJRmjDBXrq40npmkep0hOnbT7SjaNv1vVenHR0fZrXR2nKd8B3Jas++xBi9Kx1ezPgYY7adY8YYHlRqnDswyf7hzXr8aePNN9986GeuXLnyyO9tt9ssLCxs+Wx8fJy/8Tf+Bn/lr/wVxsY+WvKN8+fPf6Tv74SWDojiGdZChSM2IkmqNUt5oZEkYYtb1+8xL8NN9Rms24d9duHCBQCKEu7duMA9rNeL5kQaXaPYiIDRdDSg1ppWvY6y1xjcuXmNpS3q+bjq/bjes5tnns7iMMVKvY1LgoOm3qiT4OKiOODPg7IenNUwwOBTbbTIiJApb4WF2y0WHlLGk35W0zla8T48dFemYEO+rAHe5/K1mxRl8yOV/913r7OUjNI2AYZ93Ltk+2LcXaEgP1o7WjqgbWaQYZ1qtHmeuEjm11ro6jItNf5I7X2UNn7SZfrjrpsxsJTMUI8im8wLB7BEoXYXL6m3YjKiRRWfRIySv3WBISAwAYnn4CpFphEi5NPrm6rKkXAQtEKgu/t/rWI6V2yNKOHC5ZuUnM3z6Fkcm90+a+kAqQ9ik9EqOqevOEkw6dW3h+LOrZssfRA+8boZAxkxQ6Uh8Im6XsDVWtVGPeLjhxU+uHKv++yTPqfqOsu9eIpktZ3Gs/lgFO0EwsSQFc4mXfj6D+6RfcQ9w+Nuf15n8cQU602Nm6ZBXavaNdQxCkdArdlGGoVN7d0/pyqNmKxsWc97fC6+/6BPbz8t7Blud4Fr8yv87nvXuT6/jBA26dPluWWG8xmkENRCG54YuJKRQpa7K+sM5TJMF3zqYchcpc7R0QIroebeWo3D4xM0Ik0jbLO0voIAytkM91arjBVyjASSG0trTJcLabh/yPx6gxNTo6xVKlxfXGW6XGC6mOODRsSdZVve8dEit9ZbrDbaZD2XvO9Sb4es1FuUsz6+73N3ZZ2RQjblrrPPcr7LL37+RXzf4SvnZnnv+i2uLdgyjo0Wubhco9KKCByHGEU7UdbTFesZuNpok/FcZkeLNKKor713BspbrbcoZQN+9tQ+3IFYAynFpvKnizkuLNe4s7LepRj42vnrBK7DeD6gEirWmiGBK5kZmealY88xWhzGkQ6BJ4mTJtPDHi8NRVtyKkop+MzBMV5fanN9cY2T06NU6k0qrRBXSKSAwHO4s7K+qd6d73XqendxlWsLqzZ8VGsWa02+fvEmRyZGuLu0yp3VKqOFLEMZj+VWTDNO8KRkOOMSGbbsx4PlPMPDw1xftPKwsFJhodYAYw1wXhBwb63GSD7LeqPdV+92HPODuwtoA40Q/j+/+Xv8va99l8/sG8JxPH7nvesorai1I9oKVupNipmAeitkudFktDDC/pEyYRKxuL5Czve2rNu1hVWmhvJdWX1YvX1HMlUucG1hlZF8ls+MZ7YcG9eV/NzpGf7lpQfcWd4stx2ZvrdaJZ8aGjbmosCR7pZzYSjjc2pmguuLtt5rzYjr1+4wV6njSkms4fKDJSaH8rhas1xrsFBt4EgHYTTXFlcpZXzyjsQMyLTjCNZa8NKhI3x3rtLt43a7zfVKC0dK9pWyVGLNlfkVtLa8xO1YYdJtZTmb4UGlzmg+x3qrzVKtaT2KUroEBUwMjVLwA1pxxHxl2XoCS8H788tgbAKzxVqTr124wfRwkaTlbKk3vvLyy2S9gChpESYJrpQUApfV+jqxdlirFfju73yXY5MjHBrOU1kN0zZp26b1tjXQl4tUa4avX7iBMqbv2YnJEfKew3/6j/8dt5crVBstImN49+4CQ9kAx6hu34zlA0qlIr97fnO/jQcOJ6fH+J/+8PvcXFxjodbm6xduMj2Upxh4RLHp6sLpgs+9tXUu3FsiTjTtWPFv3nofV9rDfqI1i9UmOd+jnPW6stHRha4rUUrx5t1l/t7r/5b1FvzImc8xtx6hU4NXJzTdXhB4tOKYK3OLZDyXnz01s0m/9eqbr91Z53fP36AVRVTbMWtzK2BACANac22xQjHj29B3Y43zkFKupO8ayngsNZoPnVMdPXV1fqVvns6vNxjJZzmUMfxPf/h9biyscr/WZD3CGnRHiqzWmiw1mtYuikG0I96fW2EoEzCZ97Zdp+4vLffJwqWVBs0oJuO6jGdd/oevWZk66Ma8uIs1uDdxiC8F48Uc1UaTRhQTuC4530dpxdW5RZI0UeGNpTVcKSl6tm+uL65tWkOPjxW5tFTt6uKMK2grbfscGMnaS9Ze2chkXP7iF17kb/7m73Fnxep01aMnBILIk/zl3/htAHQUUUsMF+4t4jmSargx3p2Ax6Vai8B1cRxBfZv9xE7re0endcZjq3Xizhb7kt3o8M6zwf1G5z3z6w1GC1m+cm5217zFHyd+4Rd+YVefe9QQuHfffZe/8Bf+wpbP/qv/6r9CKcWf/bN/9pHeuRXOnTuHs0UEwuOAMYbwumalYSimSamrtSqlYsl6otXa7BvO8NrxU2itOX/+POfOnQPo/uw4Dkqpx/5suZZw6WKIIyXG2HBHg+562hoMUkgy+RLtBPyowqvPH0cI8djr9qTa+LBn3333OnHhGJUWtNptspkMkznByXHDwu0W586dQ0rJSl1x+dpNTh8/Sjmb5cKFe0+13p3f10PJ8jVF1E4YLhb65EsIQZQYqo0Wp48fZTj34cftu+9eZ807hpZQcqHZqJLLl2gnWdacMsQ3+OwLsx+6HfM1w60rbcrFAlLay7ZOOwDWq1XcoMCBfYeozuldtXe04AyMm73A+LjG5mnLxsdRt7Wm4dLFEKTf4VXBMmVLOuREWnrk8h45A9WG4cDsc4wV3Weqb24uJdy4YXOjONKuBUkS47odyrsEhMuBw7McLJtPxNjs9pmUkvY1xb3VCMf1UdpekDvSsXy3EvykzqvPH8d1P55xa6T6JlIZMj36ppWAGzZ47USZ6fLYMzXfPkr//+E1Rbwa4roBkeo4j2xQ90TGMFny+nThkaOnGM/vbs/wpNfQqHCM1Sa02hHZjM9kHvYV4a0PWpTzGRCw2rAOG505FScJSI9s3kMAkYKzs8efqMftoDF6O+wZbh+Ca/Mr/ONvvs1qo8XUUJ7nJoeZmXD4wQfzrNbbSGOQjvVKGc247B8fJVLaZn2u16g02pybmeBnDg8jRw7x7v0Ez7FhuIlW1NoNPli4Q61ZoZwT/OLnX6C5NMedxOPGwirztRY6aHPuwCQ/efYoly9f7j6rxwkHhktMlgr4rkOzXuPMdJ659TrtWFENIxLpcHJ6lC/sK3H06FH+ybff5fbSGs1WSE6L7rOfOHsUgNnJEX7u1Ey3DITgzPRY9531Zps4jfP3pSCf8cl4LtPlIiYO+9qbG5/eVN6J6TF+8fMvMBpvncRksPw76w0qTXtrk/Fc0BpHCMJE4QqHn3/5JN++dgfPLfDFM6+R8TM0wyYSRdYrMJwf4fD4BMPmg23H+EA5z+nTp/n6hZtcn19m/1COlXZClCQILYgSvWW9e7/39q37tJIEpWw9PWxSLAFMlfK8Mp7jUiXi9nKFMNGUMj6JtgtxohSB7zCUCzb144HDw311K2U9Iux7fV8yOlzuytu9xeVuvcNIUw3bgPWe8gUY6TC/XuffV+scmxhJW2HpM4LAoxXFCGBmbIrnD59ltDSMKx2UVqzWKrx/7wrNaH3bunVldeDZ3dUWhyf300wSas11fCPB0JXp+tydbcfm1QNjO8pt7zOM9SzrzMVyqbjtXPjxT7/cHbfz82s4rseJ6X2MBQGRFHzn6jXmKw2kMWgpyHouL81O0ajVuF1ts9Zosa41w2ZDpoMw5pvXNZWWoe4d4fBUTC63jyv3rnCvfQ+wYc0ZT7K/UOBWskYYJ5ajKt1UCgmRsvL2k88d5Z9/6/vcrjSJlPUymhmd4tXZc4yXRnAdh0QplqurvHPrIvdX5ugyPff8Uwx8XpguEmVLfXrj6MQ0o8Vh2lEL15UUMwFSxSzXm8RKkfF8yvlhBCNcuLdIdb2Cm82nI2O6/4qe8roZUnqeNWKH7622CZW2odw6YaWd0AhjVpIWpcAlkxFdQ9YGxMYfA8045t+89T7aGA6ODSGjNiuJ9RpVSczRqfGuLlxcW+NapYXvOpzeP8b7dxeoJYoosYl2hrKB5V/WmrVWv2x0dOHvX7zJr799k9gIRgtZ6s11hgojrNbXbRI+YVNCeI7LUL7ISm2VervK2f0TTG1Bk9CHtI+G88MEXolmFLK0voLEeq0mShN4LlkpWG3HXU5nsBdJh0fLZKXe0AU7zKlB/da7ppyYHOF//aM3kZk20+UCsyMldCbHhXtL3FmupkmABMiNIc54LsenR/l8j0wNvvMf/953aWh7wRcrTTtqo42hmAmYLGQo5zNcuLfIe+0Gp0+vcnLf+I7dtZE4JIvnGPKBz2QhQ8tIGmGEdAKW1leot6uMFLOEYUiMIEk0rVhRbUW8cmTfpjU053ucnh7jg5V12nHSpYwRws75Dk/5oGz8xNmj3Lx5lG/dr6aXEW0SIOu5HJ8aYWFl3SYRNZDEMTguYZzQjjpDb8ffEYJCKosmvZmRiC33Ew9b3zs67WHrRO++ZLc6/Pr88qb9Rvc9Byb5yrlZjk+N7izzTwnvv//+E3nvZz7zmW09dX/hF36BCxcu8PLLLwMQxzFKKV566SV++7d/m337NnvjbwfHcZ6Y4RbguX2a128n1KINXsdE0+V1PDPtdA/EnfpsV7fH+SwxBikMQ1loRJYzUPWEywoU4NKILMfrsF7BdcceqYzdPntSbXzYs4Js8cLxDq/hA84e3+A1XOj57FjRJu8aK7qPXMaTfDZWkAznNPfbKYVaJ3Ik/bedWL0+WthInvmoZfTyn5cy9h0tYTOH+y5U2/Z5J5Hphykj6xs6ieKcngueLjUZEk/CRFHyYN08tL2JyfOtG4a1JjTjfazcgnJW4OrsQ+smpewm2VoPJcPZDzc2T1s2Po66xVoTp9QIvWRTvT9rDcYIPMdgECTm6bd/8FnWt/7C2gxmjLEwCFwBOV/S+fqzPjaP8uzMNCysxXiujyuh1WyTzeRJUu7SYazu/7jqVpAtjh+2iTuXG4bQBBDbBJ8iqRD4pb4kzp/kObXeFiw3FAobKSe6ZzzRPeolWIcn3xFdXZj1JY4jdlXek27/xvHUdH9KEJZq0ulE5xra2lKnWHVtI461sclCx/KCsYLzyBf8TwK7Mtw+qVCzZx1aG373veusNlqcmLKE8g0pODs1wZl943zvxn18HfNf/PQXmB4q8s7FC7zywjlmhsvcW6vw1rvneeWFc+wvl/jjd66yJqc4MQ1KhVQbLfxgCGVGOTZxgMA17B/2ODMlmYur/OzzL3C/Uu2+4+DoMMZo6nP5Tc8Gy9s3NMRbH9zj++cv8alzZ3j54D4uXHiPF88e5UtnjvHmrbubnvXiQHlzGb3vfPHsKYQW/ODyZT517gyvHJrhwfp6X3vfe+/dLct79cgBhDC888472/Z7p/wPViv8Z//oX5MLXI6MjRMrRa3eoFjI40nJjYUV7q6u87W/+hf4V+9VqbcF2UAwlClSrdcYKhXJeC61NizFOycEmJ0c4fjUGHdW1njr3fO8cO4si5UGb13cud6zkyMcmxjlv/33TRbX1njp6EGEkMwtLLBvapJSNuDq/AqNWPG//NLP8869uW5fvHRgPz+4e7/7+3b9OFi3F889RzOUXLx+i7MnjnBqssT9ynq33vdWqvzlf/JbKGCskEUKSRRF+L5H4EoWq01uLq3xS194iUYU82De1rUQeLx+c42Xjr3ESKFAFIe0whb5TJbRwn72jYwyN3eev/yVTzEzsnXdeutdzA1z5uBLjI0k1uCaCcj7mubKFV47d6Qr0+/sYLgFayTZTm4HZezl504zVdyYi9vNhd5xSxKHV068TODnLXWFIzlz4Axv37zAlbu3mBop85ljMwgB8/OaV04c4UGlznu37vHq7EH+9v/5J1luGr5xqYrXMGQ8qDarKOFyYHSS6fII12+/Ralow8z/3fcvkdWSP//ac8yt13mwsMTU+CgYOP/BA16dPcjf+g//FP/om29Szgb80rkT3FhaY24t5jOnP0s+k6HWbFALmwS+z6HxaUaLZf7w/HfIuDFSCObX1hkv5vj8iYNcW1jlg0qDv/lTP8615QYXr1q5KWeL/NGNmLCtKZeKZFyXK/cXiBHkU65KjaQQZJmdGObffvCAbKj5qXPHqbVDHiwssG9ykmLG53ffu06rHfLznzprZWphgcMzs5SL+6m2QQhpE+C1a3zvyttU4iXGi1nWWxEGw+ePH6SY8fh3379EQ9f4qXOz1NpRVzZL2SLfuXqPhWrM52YnABjO+ZyanKTaCnn7+gc8PzPB//tnv8i9SoX/729+nSHh8cKBSd689QAwnJgYIVKK+dV19o8O8bnZGd68NYevY/7yz3yRVw5v6MIk0fyTP3qHZpRwbGoUgeCdWxd47dRrjBbLrDcbuFIyVirjOT42eZ/kP/2Jn+fm/HW+d3eZn9Vmkwei1obv3VkmmxnlP/zMK7QSB6VTKpJWlTevvYPvxHzu+EHeu7dAgYT/8k9/iT++eocfXL3By6eO8edefYHFRo233j3PS88/hzCCt8/3rxODc2p2coTZyVEuza13x//kRJH/6ZvnkV6Zk9MTGNOmIQX7R4aYGS7xv/3gCvnA5c+cO04zSphbWmLfxDj7ysWuTP03P/0l5qq1vrXoH/z+99DG8JXnZqm1Q75z+QZZHCZLeVYbLR7UWpw8HHB80ufNKxW+fv46x6d2DifvZIvtTRwSuA7DhRK1tmKxUqHWeMCf/+y5rtxMT05gjOEHN+5wbLzMf/bjryKE2XINnSqW+NrFq7x18QqvnD3JT54+zrv3H+y4Tr56YIz/5Ke/xPc/uM//+NvfInZ8Xj2yn+/ffkCkFPvKJQyGKw8auC6cmh7l2sIaGM2xyTGEEMytVjgwOsRnZw/w5q0Hu9pP7KTTenXxoGxstS95mA7f6tngew6ODj+TnrZPE7/2a79Gu93u/v4bv/EbvPvuu/zar/0aExMTT7FmmzFZkrx22OXinGKtuZEgbDQvcPU8k8Whp1Kvjpe9I21dImWo1NrgZtEaEm1lbiQneH6/ZO7Gx59Z++PAx5nY5XFDCMHpKcn8qqIWQtbrSfiUWMPqsF5BiA9PJ9LLf75Vgr3Hkbhu8OKwF8YYElwms4KRvOT0lNmxvZmkzpt3yt0kZw9L7NOL3iRbzXgfK9dV1+D7UdBJOlTTOVabhrHC7mmMnmW0E+tfuxM6xplOsiL/GXRnCzyBR4IWltPWSf0cjLFOHwJD1oeM158P4U8KBpNYauFggLG85NSkeHq6PxUthaQVW3lDjfOtnoR3n3S0Y0Mnl7DTbW8/DDZvT68ufNqJMcHqy3vxFF4Tch6YMCTnBaw0Ya2pMUbYKD5XUAgMYWwv52TaJmHsBXbOh7PTz4bRFnZpuH1SoWYLCwv8nb/zd3j99dcJgoCf+Zmf4a/+1b9KEASP9J4nhftrVW4srLBvuLhpQ+A4Dmdnxrl5b46Z0RIHRoaoPChwYGQIx5EcGBliZdj+3nsjPJQRhElAO3YQwsGXNqmAlC6rTcMbHyiGdRYpRd87pBR0uIsHnw2W5zgOnz46g19d5sWjM31tcl257bNebC6j552zBwHINld48egMjuP0fbYXjiOYndpPWGkyO7Ufx9ndZJZSsFRtUGlHTJSKOGlSr9h1ugl5hgKPW0sVvn93hXxmBNfUGUl5S+PQIet56cZNdzdu48Wdy+y048jYMEfGhgnqy2kb5bbk0XPrNZZrTQ4N5Snns0iZhVhQzg8BIdPlAjfvzbFQr/f1/eA47dSPnbp9MDTO7bWizcCcOcbVpQxLDc2pyRKH03pfvLdIO1EUAt/e+vV0tzE2vCGME24tVzgxvR8zYuu63lzn1IGTZLwApUICT4J2CFwJJiLnZxgePmx5GHsO6oOyAv0ZeAu+g4gS8kGOVuygMkfwvVKfTD8MO8lt37NjBwB65uL2c2FuvUYj8nj5+Ktkghxax8RxEylzOG6e54+8yPzaOofGijiO7BKtSymZGSkR1Uu0E8V8tc615Ww3k3A7SWgnilzGw+gQ1wmYmTwOZo5qK0SnfKuNKGH/cAknbDI1WgYgbtZpJ4r37s9zY2GVsVyA67pMl0uMlafJBxnaYROETpNjaRphncDL8uLR57h2/10C12Uo49OMYuphzHS5wPJaxNeuRLSTHGEwy6WFgFKgcBxJ4HpkPRvqb+udSUNRJcZojFHUw7hb73oYUcoGNDM+pWxArR2hUp7dRhRTygbo4UlGy0dRWtKKKiRJQjGXoZgd4rVTn+GNq2+xXFsmH3i0wohGZKlMNsqIKefLeNMlRkcOYoTLZ88ctHygrsIky4Bdc4ZyGQ6V8yzVmizU6kghaMSKYzMT1MOYtUYr5S+WZKTs9k0zVl0dvm+k2Edt8PYHD7i9XGEo8JBCEsYJd5aWkPL7nDl4ipHiCEPZYvdW3RiD7wY4MsPsvue5ff993l+ocXqqX+Hcr1Spqiynp88ghEs7qpEkEZkgoFwY5gtnPsu7t9+lEcUcmxjm5r05Mp7Ln/7Uixwr5Dl76jjZrMOBwM63Q6ncrG6xTvTCHvg0a80cceYYF+czvHM/RriHeO7YDL7roHSbTNZGN9TDGEdKHCFwHYeZkRxu1GRq2HoSdHTaXLXWN/cfVGpduZXSGhkipRkuFZBSUsj4rFXr1NqW/3gsF3B9YZX7a1X2lQubK96DTrbY9xdM18AUKyhlNH98513Gh30cx6GcL2NGBMOFIbRudWVjbr3WLWOr9e3nXjzJDC1efPHkjnpjUPfsHy7hSMnx/eM0og15E0IQxcpmgDeGRpRYD2YhkFIQuC7ljE8jsrQ5u91P7FS33nYNysbge7b73sOeSSnIZ0qMDk2Qz5Q2ZXreA0xOTvb9PjQ0RCaT4dChQ0+pRjtjsiSZKAqW68p6ds4eZzgL77779Iyh/cYy680TyJhSPkusYLWeMFly+PJp1/J1P7Wa7mEnDBpdOhcDY3nBqcmPbnB/WJZ3R9rnPflxHxlbXRx2DbKpZ/rpKevRu1N7T04Ivvt+AZ1AKQMg0iRnAlcalkLrxTc9tPmM1LunflSD706o62w3UqxjDP6TYnQKnN0ZjgR2HDMiZDi78z7kaWA4CznZInKD9NLK7s+1AU9CojVj+WfDWPakUJAtXpiVG9EHsxvRBx+37u/OxVSnmDTJnTDW2QVguWF44wPN8Ee8VHnaCJNOclDT3etJdLedHRK3WFld3KsLnyaMMVye1ygchn1IDCiswb/oG6pte6nTisFzDIErCEQIjkus0iRz0q5fZ6ddJkvbLDBPAbsy3D6JUDNjDL/yK79CqVTin/2zf8b6+jp//a//daSU/LW/9tcee3kfBvUwsoYMf+sM2FnfI1KaRuc6IoUxphvKstq0CVI6N8L2vRuhDUKAxKA0ZFxoxzbZQCcL6dPC47iB3ep2eLcbAmMM8+sJ40OTjJWytKPGps/4rqQVK1abUXpLord40+PZuO2EjpyMFsfI5o7iyAx+YD03tW6jmSdS9zfJyaOie3vUMGS9jY3b4AIxX6mjjfVIG4TBytW+4UlmJs6Sy48SZAyOI3C8JonxqLfqeM7myxNjYrKZEks1xcEdomL7Q9fgUTanHydq7YhyaT+e66N12PNEY3SIIz1OHzyDUPe2/H7gOrQSxWI9odLayCQcxQbH8XAdBzBoHRMEReKoQpRYYnOBINrCwtZ553K9aXVPZwxFhqFcmShpp9/v5Ne2PzTDFqPFYR5kSiRJM00yZ4iUYrQ4ylBxP8sNBylsBtpmBM2oE/Zikw8pZY2vTmqUl9Kj2VwB07K8zdvUO+75vfO54fLhrmEyVglgSJSirur4XpazB0/xzYvfxnMcGsbQipLuhcx4aZxy6ThZv0i+4CEQKK0I4zoCKGSKSG+GTHZlU7/VwwitNJGyenu9FZIojddz0dDbN0PZYEsd3qGLyHt2se4YppfWl/j99xb4uVd/hqFcEWUURmu00QghcYSH62Y5cuAc7z0QLNZ1nzdMvRUzNX4UR3pEcZNExTbpnFY0wwYZL8ux6eNEyR2GsgHZ7DDv3PfQqA99qBo88LWNoh1bjzXH8VBJ24bgOTkmxs+g1AKxWqKcL0PWyt6gF8d2a193zUzlNkoUqifZn+fYxHwdOekdt+3QuxYddODHjjusNAQX33/AmWOz3FpskRhDuTBF4A8je/Sv0m3KxTarUXPHMj4KGu14W3lTXW5iQ6J0+pNBpYer3cjis4Tt1vSz084ztbHdw6PDenaKrmfn08Z2xrJEW88mXyS8MJNDyu0v1ffwbOBJGl36+c83P39cnpRbXRxu55m+XXuX62pH72AXu5dcaxqGenKJPqk99W7PFJ9UhKqXWmV7X9RGDHn/o3t/Pyl0daFfJlKQEz10ARqkijk9lX3qxrInjWch+qAzFyNAKQiVNdxaqj4ASTuGkbyx0b7JztG+zzoC17Yr6aMpMnhOeoGQNk1pGC883SidXqw1DZWWQRjNWgtiBcpkiBvgOZDxbDukpLu/cFDkAkvN5EQhrx7Oc3LSfebm1VMLCrh58ybvvPMO3/nOd7pZd3/lV36Fv/t3/+4zY7gtBD4Z16EZxWmG8n60ohjfkeQCr2uovbakuV9RLDcMrWiGhauKnA+JsUTasbYCZNkRnTThAmkmbMh6fOSwno+Kx3EDu93t8G42BHWd5Q+vKarxJD/50o+j0TRbVe4s3qRer3c/FyUaz3EYyfkst0hzBm7Gbjdugwb34V3uWQqBz3B+hPHhozhOv+emdHJkMgcYKy2Qz2x9AbAb9N4ejQR2Aets3DwHqj0LxFS5gEx5gHNOf58IBPtGJvnpV36ckULJZjB3rGIOgiECIyxH8BaKqkMI77nbt8MYw+1VQ0NnKTrWUBwrK/+RMniSbTenD2v/hxmbHd9JQD4jSZKYQDqYAcN/okJGi8PU6qtbfj9MFEHg4DkeKuXJWm1CmLgUcuW0DzVah+l4OfipQctg8B0HKbNksyNImUXrVvedY4UcGdchDFMDl+fjSEk7DnGE7BptDdb4mqiErJ8h8HySpInSBscV+I6DH0zju6mnobAJXqSwuseedyW1kA3eViNwHJt1vtVaJZ/LMpTPc+agT6wjfKf/QsDr+d13bZs8v4jWMVJKfNcmjvMch0QlNNtNyoUyw4Uy82vLSCHI+i6+6zBRnuClYy8TeHmEtPx1CIOUDsP5YdZb6ygV4nhZyuXDYOb6xiLv+6y3NeNDk0Taw3MSa8DrubXp7ZtYe4wPTaCF37e5Givk8ByHMDUwOt2+MYwWRhgtltPEcokdWySe43aD8qSQOIJN3jBG+hSyQySqIxMC0+Mh0QpbDOVLhO0iykhOHjpGM3YoZT7coWrwwGcMRHhpmyAREtfNASFah0jHw/WmmXDHGCrZ0KB84CFIGCoHqYdx2F37BnVa3vcZypUwUYyUWXw3xJGCWGkcKYmVwhGiOw8641ZIqTkGsdNaJDCcf2BYrOc5e+wzBF4We1HSJo4b1nPeyTE+cQa9dnPbMjr91KtfdntRaYxBC39beevwIRoErtMNwOpejvTK4nZ9+mHr9rix05r++u2E1w4/W14JzxL+yl/5K0+7Cp9IPIqxbA/PNp6U0eVhNAaP05NysiiYHnJ25Zm+VXsf5h0s0Shtvdx68TA6iA+7p97tmeJZM1zsFhnXOkYB3Q3zVqtnOSt4aebZplvp14W6Sxewpws/Xqy1oKmz6K4nKpCmzOwkkI6UdYzopWnZKdr3WUbGE2R9qLVNH01HJwOJK0CYmE8dzHB4RDzVKJ1ehIn9E+EjlT37CjRCOETK2uIEcGpCslhnI4pPw0RR4NYecHz85DOp+56a4XZ8fJz/+X/+n7tG2w56DXNPG/uHSxybHOXCvQVOTPUf+oyxSXGOTe7nxkqe9baiHu3nxk2NSW9eNA7NEJohKFyaMbiyk9xSEOtOpngHDNTaUAge7h36JPmItruBXaprVhuQT4Yfajjb6Xb4YRuChZrhg2gfugIGj4xvjVw5P0u5MMq+0UPU2+vcXrjOehjz3MFRPndsgm/dUNxvuZveuduN20fhjtpXLnJo8hjt2EGrdofZmo7RThuXY/tPsm+oX3M/yoG8c3vkkmzqs0Eery+fmWU4+westWMynoMUsuezhi+c+TTD+RJSSJul2SiMSD8nJOV8GUm/8jXYsLDAgf3lPFuhY2RZqhtiPCoNqHRyS/XcdGHElpvT7fAoY7PbubFQM9xaDQg8D+WorpFVSt1tb5QkBG7AUgyDN6bGGJabIV84eoj95TyXFxLaZNIFQqSJLAyOsIZMpdoYoygE1og5UZ5gYuRUn3e2Ui1iWeH05AgvH9rH69fv8u0LyxwxhoxrjYY2G65Ba4MrbViU60pcx0XpdCwxNOOEg8NDDOWGcB0r956UCAGadBHr8GRpq3dasUsxW0QhAYkQkrGxkziORwHBcNkm9hIowvYcMA/YZFodw2Yh8BHCQQhbVj4oEniyOyUSnbBeX0cKied4tKKEQuAyPVQEDGcOnsF3fSABfIxRCCEBlYbaF3Bl1OfFrFST5WbIF2fPcG05S6VlOH3kU8TG4MmYwxOKC7euUTYGBDTjhHMzR5gYOUWsPUaKgiuLOe5VFKT67aWD0xweK3Px7jxjxiZ1ClxJqBRjpRE8xyVK4q5hzhLhi65sCCFxHUHep+sNM1XSODJP4EMrbpP1JJ7r0AoVHVNdlCTks3m8IEOoh8h4AcM5x8pUj4dNpQWteIKVht7RO27wwBcpg8bBFSAdG96kpQNGYvVVgu+XkDKm3l7HGEMpm0fKHBMTZzEmRqkGtbVrzAzl2F8u9c2pa8tZju17gWYYk/FdMpmIFw573F9fRpuQejuilPEoZoL+OTRcwpj+i5OdvIG+c1PTjvcTNAw5z8FNjfxSCqTMIGVk26PaIFwOTR5jX7lI59jWqye2umwdK2hOT+5shNwwKue2lTfPtbIvhaDge4yVRnClx3AhR6Nd7c7TYsbn6vzKln26Wfdp9pfFY73Eehh61/RixqShZGnYWWCohYKLc4qJ4ieLg3MPG3gSl6OPA49iLNvDDx92pDF4TDy6g+V9WM/0h3kHdxL7BAMn8w9r8N0Jj3KmeFpORB8VXW5YaR0VHGkdUKRwU6cpRc53ee2wQznLM0+3sqcLnz7C2BDjIjrylAZ7dJxoTHq+1dqed59ktO/HgeGcTczVamtc2U/T4TsgJfhJk8Mjz5bHt+/YfapB4KTn3d6zb6IBHCaKcHaf+4maU0/NcFsqlfjCF77Q/V1rzT/9p/+U11577WlVaROkFPzU87M8WKtydX6FqaE8Shtq7ZD59QbTw5McGp9ltWlv9lQqzGBvYjpu2JGy1zCVlmYsL1NPLet9A52DPsRKsN4CYQSeNNxdrXJ7rc7o6joHRsqsNg2LyTBfu6yoR9CO9ttDZl5zeurRPV3iWPHdW0tcfBBRzc3zI8cmt7yB1QbiBGoJVJiielUxmgMvNZxpbbi7ut6ta84vdo0FBlhthPa2xgkZyQfbehUbY/jBXUVEgIOdYK4wJEbgOi6u4zEzbjniju07w/47l/k/vVDGcSSjuRofLCasNj2KGWfbjdtgXfeXS318Na4D0ijEgLfcVGnz9zpYb8NQbojG6goNDYHr2pA+pQmTBN81lAtlKm1rOO01FizWE5rtKeauREwU3O44am24X9kYf88bskmMsMazWG94sfpOPx2En3P4+TMH+Or5u6w22uR8F6E1jTAknykxPTKRhmcnXc9aYwxKJzjSw3d96u0mnjR97cgFRVwTcWu5wVCmfyfXa2TxHbBbIjq3FMiUHydSoMngmM2b063QOzZCJCRJC21clhsuyQCv1249xTvvbMW23+JEY4TAkQ5BUCBRLVpRiCtdMq5ASs3VuQpTZTv/q602N5cqCCF4/uAU5WzqMY+gY3typGdNrMZgjaCC9WaFSgs+e+J5Dk6fQBmJ0RqlYhAuiQk4cegljk9bA9RXzs3y3vVbXFtYZbpcIOMPkQmGqDTWcR2HnO8Saev5P5QfYnl9iZuLc2DAdyRT5QLLDcOhgoMUaksuSoHVW+MFODQi+b23llkTkxhkysXZm5lToI3l485kZyiWKtTadebXG5yYGmWtUuH64ioHxlyGfWtAA0kvY4cjHUZKI9TbTRarNVxHMjtapBFFVFpwaGIEULRjQd6xLhLGmC7HUuB6NMM2rtRI4dGKNR8srbJvZIqx4WOsNAxCJLiEhFqiRMDZQ8+zul5jobYKBvaNTHHm0PMo4+IITcaVNCI7j42ZpnpVMV6Q/LnPfZr/9t/879xZqTJayJLzHNYjTTPdhQkh0BiEEenliEnDhtIM0rEi5zu4JCzVDV+7nFBtGzw3g3R8lErI+RBGsfXsNeC5Do6E++ttDkzMkHd0n/d7mNjwq3ZiMCbP1y7HTBUd/G0umAYPfJ31qZMY1nPsmtWODVJoXDeLMdCKWuQDj4xfQIhOhmyJED4Gh6PTzzFpPuhyXfd6Yw7nPOqtJtpkcN0M5469wmzUZn5tgduLNynoKtVWi8sPVmjHiulykSTRPFhf71vvevmpGrGimQicRJH3HBZqGqVcciIh0S6e66O0JlEKKR0cN0M7bpAogwSGhkatns7064ntLlvvxobVhmJim34dNCrn3YT1GJQJeO7wixjtMV9dplKvUAo89o3vZ3b6OONDYza0W2tqrRrD+buMFODawioj+SyfGc9s2acdD1fIcLdi+GDNIPXMpkusrda3DnoNcysNq6h2c2nYG0WRBVYbG2FnUXoZl/XsZcJa0zCSf3Y273vYHRaqOk1O9niTHj0uPGs0Dnt4dDxJh5PtPLMfF4/u48Juk5wNcpV+WIPvTggTumeKrfCkKeY+DmzFDdtxJAocm4R2smiTynVyWDzr2NOFTxftdE8tsfsgC9FNFgcbUdTPcsK73WIjwWSM5/rkZA9NR2q8HebZpBjpYPDs26EYNN3nn6w59cyI06/+6q9y6dIlfvM3f/ORvvekua2Ojpf5i194ka+dv861+RUWay0Sv8Vz+8eZmThDrWUo+OlBBmuh6JhktZG04xilrXu2RPLBSgPfC9Jpb8MmwS7SCmWTcGnDP//jN7ixuMbiygpvrEgOT85SyJRoq2modkwDHjqCu9HGIbPTH4P/Dv7fm3MR//uDu3huFuEd4Xu3Na/fus9keZRMytVpjCExDqtNq4BM2rpGaPkxHb2P4NYqb9xI+2ZlhT+8X+P49AEK2UOs1NvUQoMUDsgslSasNpoUA4GDoBUpVCC6dVppaJYaAKZ7QyIdiYfTVYidenmOy7kj54hp8/f/j9e5Nr9CGMLsweco5Ur4wsNNYDQHJ8dh4XaLKw+W+L1Lt/rqemximJHcYVzsDVkzAkWGuJXephmP791qcnfx4qbvHfYV55SiFUlcx2Es59HSgmZqiAmkopgJGM1naYaG793WhAk0ov3cuKFItKIdNWi06mTbWarNLEs1D6cm+KPf+153/P/wfo0T+/YzOnQCZVxWGtbNX5lsenA2ZNKNnSsUSgl++tQM+/fv53/51jssVRtEib1VP75/Et9x0cYagJUh9VQzuFLiSNBGUAgKNEObKCvneZRy5TREK+CdB4Z37rcpqRznlMIYw6U51TWy9I5VRwVaQ2DHUGgzUBZ9hVJmWzlNkoSlZJS2Tqi3GzTCiDCKCNoJOd8jcHwuzSkmCjC/rrgXT+E2LB2DNAoBLNc1b7RgOJ0bHc8xJWEoAKUlWjtoY9BGIZAIEZCoFn7gsVxbYXl9hUhpwuWElUqNcKWJEOAbxW++cZH37lUoFU7SE5QFYmNuW59xSal4kunxPI70EUKmZRocJ4M2BmkSPC/Dew9qXJ17nT915gg/d2qG25HDjcU1wvAqJw+/zFhpmDgJieOQfBDguQFKxcwt3SDneXZTauwF0f5hm9hPDASI6ZQrUKeGxmuLUGlqTDBBxmRSbs7NXhhSOoRxhO/5DI/Mcu3ed3lu/zg/ceYIV69e5XbkcL8SMjLkIdJQrt63GAye4+E5HvVWlcNjQxgMq/UWJ6YPks9mKGYdVhphmhjNlulK25sIQT5TpB21CJOESqPB2X3jDOcOkSiot9e7cuI4LmEckQvyPHf4DLUr30MIeO7wGVwnwHMcXOmiEUQ9y0g7hqW6JnCm+MVPv8g3b9/lg+UKzTAh8FyUamCM7lI/9N4y259Tw1tkaEQRrrF118aQ96ApEqRwkcJDSoesHxEmMUjIB3naUYMDI3nKuRyuanS9vRPjsFzXpPeACASNyHBzJcFjimOVhOlyv553hUGkdCW+MF0yGWWsvtNG4khBLlMgSRKkdDBGp9QVOZS2Ht7Wbm4vXxwp8Zw8ShwkSexa0ZlTRd/QjD1K+bJN2ICljcgFOQ5NHGR6eJzXL32H337nOqFKENrwd3/rj/gfvvY60+UCMgn79F2SJNytRBgjMGQI6xqlY1xpoysWatYLQAgHx5GQGm8RLo22wnWgnHFxHYdWpGm2N/RExtn+slVpGwGjmCBJNsZYbaHvhICs55DJZllvG8Dh5eOvUG83qDXXWassMHvwNL6bTTeQ1iu1lCuyb2SaJGnjiJCXZly89Tub9FQpSHUkDmGY6ldjdw+etEkwkniKN7dYizvr1GQl4cqSYK1paET7uX0pPaSqGZavKYZzmpPjm3XxXPq9xZohwiNqp+FxciDsTIHvGlqRRmUeP5XDHofpk8NCVfP67YQw4bEmPdrDHjp4VPq1D+P9vZU34tNKXrQdHiXJWS8+rMF3JwSuPeN8VIq5Zxl73LB7eNzIuACG5CHT7FlPePcoGEy42KHpGMtLTk2KZ+ZirBeRshHeseqneDDGnn+kAIwmVp+8uf9MqORf/dVf5dd//df57//7/54TJ0480nfPnz//hGrVj8+OesxmyrT2F8l6DoVsgTstjYuiVq8SaRebyUV3hUNjvRXTdCRoDY12C88Nul41HVieRAetDc1Y8d6tJTKizbGJ/YwP2zB8I5TlkxQakxoHtE4AwXpboMQE7713vu92obd/Oj+/ORexzH58zyeKW2htvZRymSJhIkiUwqlVMQZCk02NON27CYxJMEaQGJ8/urbOm5euMpYL2FfMETbrvHP9FudO7MNzMkhpvalJDUFSOjRC8GTCnZvXWJJht27LyRCJ2o9Ao5RGAYaOtxfdGxIpsOkbjeBOxeXbF2z5edfh9q3XaZsMQ7kcP3JwmCEtWWjA3UqD33r9D6i24766vncr4cWTJ8mGSTfEXaSh6EoLtJHcXW3xzo0FMqLd/d4fX1rhQsYDXmesNEIUz+C7HlmhKTgeKuOmXI6CdpgQE7BaC3GJibVHkoa0+24WgoQ4CVkJW7TCArVmnvPXz/fV84/ee49Xz4xQLk6k18bWQJRoQ6LtAlEUCXevX+BeOv7PFwW/+lPP8ztX7vPHt5fQwKnxot2kaJN6eluuVUeK1ONMgXAouDGBDMj5eYTToQkxXcODwWPdOci/+s4NDhQU8/FMdy4oI3vmQpeJlSixsiowJFHM9965Q7Zn/AfltKUDqsk+VhurRInlf8y4DlolrNUjfDcCDN+tPWBBjRObHFE7TrNdZmg3FRJNE0MiR3nvvfO0TUDbzCDDOrVII4yDFBkQEpkaQ6SUlPOjxHGTdu0uORPTaLVpaY0wkBWKfaWUg7ZZ5/ytOV46NWu9Gru0FKJHbg2BlyHrSgKpaKdSJoTAwZDoBGEMvuthLy0K/OD9Bd67foufOzXD58YCjuSmaSmB66yhvRGaOosyORxhyMkIL17g8IkhAncYgaCdKLKeQz4TcT1RlpolidPREERK99TToOMm99ZcEuwJSQqNNpuXB0unIYiThMDP8mOHD3Mw36a1eJ/h0hhxMkqp6JPg9/RCj55L/yfj+XzqwD7iuM6PHJrg8EiBQlZwJ4E4iih7hrq2nLBg+l7kSEkuyOOqGqf2WXqH62GW1bUBOTFWj4RRk33DY/znr51FIFhxptDCSz1m6dFttoaRMiiV0MIwNnqU/3LC5epylfV2xFDGZ3a0yLWoRSQKuNKno/PpOQAZo9HK0jwkMoPUGqIm7UTjC4fQ2MOZKyWjxREcQsuSZRKGTYXRrMOdJEIjqaa6uKkyGNG5GLF9YrQd20gG/N6FCs/l73X1//nz5zEGMmKGSkPgE6UtzJLozvWiAGFw0QjXTduQkBOCphHdCwjRa4EXAJqmyfLGu9cQAtpmBtNuMt92UbggHDpquqM3HFfiyjwnDp7j4v07jGR8BIblZsRKvcVyrc6L08OodE49d+wgrutbmTE6veiwXttCSiQCrZVdrxxpDcsIPMfFYChkMrTCBtVI4jYb3Lxm9YQigxNWqRuJIkcnLMDqKolWNjmYRtLAtjHnbOiplg769B1Yo3oY2fHURiMdyXjOYyw3ycGx/ZBSh3Q88LsdKQSu5+MLhxuLihkv2y2jo6eqkfUIjkzGyhRW/2skjUYdgSZULt+4XOEHV/vX4j++tMLtkUnW/BqO4yGMJsHHdA2hknaryf22ZH51o3ywxpb3rzRQOAijgUzaTxBrg4NAqxiDNYCryHDz2jXmnd5Ej3t4lmGM4eKcIkygFEAvrdWzlEh0D58MbEX/9agJsD4Kbdmg59SzaJD7MLzNH9bguxOGc4JyVnwkirlPAva4YffwONHxfu9sibdbGVuJzVn0rCa8e1Q8yQSTTwKBa//oKEI4bkqbsEHxkPGg1VKfyIupp17lv/23/zZf/epX+dVf/VW+8pWvPPL3z507l/ILPnkopTh//jznzp1jqSGZv6nQYZVSsUQjgnbLpB57oNOYaZtZXhMnGtcRVOpLDOWHdiR8d6XHmUMHMaaBlPvIBjm0iXCkZz30RKcMQLh4Ke9I02SZOfYc4yW3r65A92et4X9/cBff80mSNlIKjBZIKYiTNgRZQnwKhQyJEtQa9pDYMbgYDG6ahKcZJeRzI3zm9Fm0brGwsMCRA/tRyhqpHV+iVJIeWDv8LxrH8WhGIS+ensX3ZbduN1YE925pMBrXdTGKfs8/QWrykmmov8aRLj9y7jWiaLFbvjGG71+9xf3JAj//wqdRSvGbX/1tRJDj1UOjAN3POk4B1w0wbCTMSZLYlg+0QusF+dzRw6ik1v3e4bSMDyKXn3nhJO0bmgdrbcqFDEJAtWblwhhYqIPQivFSQKwDausxymx4inleDs+VZIG1RgvPL/LpU6cxJuyWdwRwvUy6WMiOuS3lPE29wZCcO/ccQohunwoh+d5KzMhilU+dOILjBGitcBwXB0WiLRdr1vMt37IGxyR86VQebeB/uxDSSacFdOVWCBs6XRUzHDzi8+ADunMhTKDVULhSph69dpkT0sV3QMQNvEyeI0dPMZ7XW8qp4zjcW01493wNDZTzlpohjEJyQYYssN5oEhvJ6P4T3J8zJGGCI11cAUrFOI6HNrb2TW04MPscoYJbV9qUiwWkFLRjQ7uRIHAw6Q0cqfHW81ykFN3x/t3z12m3Q37+U2eQUnbHxnXLqXepHRnbU5qugUY4gKGcC5ACWs2O4d32quN4dIxHWht8L8tzRw9z+d5t3llS5KfPETsQt9u4mQwjWThXgoUHNzl9/CijhRJaj2zZj1JKapcU8zUFwku5fXrqBjgoRofy1EOotDvJkyRabb0lcaX1NDXAkcOzvDDjMVdJeP9KAzfIk1WGWrTlV+12JzW+vXDsFJfuXeXuepNf+ukfRwhYfLuC8ssUfYgaECpb167fcnrBhYCsdPhTr7zKfBXObyMnOaAexiQaXj53DiHg/7iicISlJIi6fB4bvuFW0XiWD1cbjpx+npdfFH2yebCS8I0rbZTIoLST6qmedhqF43SM95ZLenjIHoCqtSrSc6lHabHCoMjjCBiVi/z0y1a+omuqq1MiBes1G/Zglw2JMRopbZ21gVAWODB7juEcfbLQePc6a94xIpUhcKDZiDsFp38rHMfDKGuC9hyPwPdotnr7o7efRGqs04zsP04xAzfeDzFOgOk6RvZ+D8DSNbRUwvjQGC8dOUq9XeWDxVVcz2UsG1BtRVxfqfF/+cwRHDeLdDxAIIVtdJJ0LkU1onuhZ3AcYY2lYuPgKhDks0WyQY4ojgiTNifOnWDhpsFt1xkq2TW72Uo1qthILCEdDymsx1GiNaP7jzM7LvrW/gc9a78xsFCNEKnuEcIhShTDhQIYWGraMnzHRkpoo3v2CQbwGCp4tBNYikZ5hkj6oQABAABJREFU7eUyC/V+PRUlhkZd4TqOjWABokSRzRXwXVh4sEw2O7RpLT5sDG09SWhcDhQzrLWAWOE7jqWuSRR4OcZzNrNup3yAf/92BTfIMxJYyo12dy9ge1gDgSstnY6xHg0nT51kNP/4E5R19jN7eLzo8FzmHmPSoz38cGI7Pu52YnadAGu7BIh/0ry/PwxX6eNO1LcRAq2ohZbu5klyAz9N7HHD7uFxQ0LXcrvVSamcFbyw/9mhaXkceFIJJp8EOhdTjZZkPGf33vV6m0I+j+fYiLpP6sXUU00B/Pf//t/nX/yLf8F/99/9d/zsz/7sh3qH4zgf659OmVk/DStP+Su9lNfTUiSYHlOAXQyldFA6odZu4qS8kVprtOn/A+A6LtV2guPk8IMi2sQI4aaTpNf71XQcWbt1WWvLTXXt/fl7t1fw3BxR3NrkDqe1IlYxruOx1oyJO3xAbHCECEzqmalRWuFIB88rbByYhaDSFiRaWRJ46fQc9SyPqDaKWCnevLvSV7eJokyTtz1cGRjTDeDFcbN95UspGcsF3FxaY77aYL7W4F61yb7hIo7jDHzWSzkHVXqI7ukPo0m0NQg4jrdtGQu1JmemHRws93CSOhgnGtZDO1oBIVIKwsQavJyu56pGShchHJQ2xCpBSkmoRF95npcnG+TRWrMR9m6fS2EnctsErIeyr0/nqw1uLVUYy9mM8Ma0CduVdDwdHGGTXiXahmAD5ESL8ZLD3UoLKfsznA9CCJdbK3HfXJAde6WwN1udsNpyFsbyqbFFYufQNnLqOA7VsEmUJGR93/ZFVwht32Q8jzCJqbRC2rHtD1fSpWSQwpatDcS4xFqS9R1s4jD7qkZkv+dJcKW2Bkmj0LqJEJJy+TBCCBpRYnlsjaERJQOyYA2KHb+93vJ7YftoY9w2L/dWroQQOI7H4Yl9FIdPsFhXBC54RAQurLYEV5at9IwVXVzX3bYfXdfl5YMOgYjtvNUb5XdCnjMi7B6oOrVSO/F9CWt4NcawWK0gpeTKkkDhUAogUluTommjMdrOWyEEzRj2DRe5t95kvtbAdV3G3RUC184bZVK/QrHRU1LYW9ShLCS4VKOHy0nW94mSxH5O24uO3nduBSn65Wawf6fLLge9+8wMg++qHoOHsQni0gsAkXLfWrlRCCEItZfK3QY6YTzLapSrywLXdft0Sj1M2Gia6JbTNaRqW97NlXBTXQuyxacPO4wVJO00qZQUtkwn3X0ak4ZOoqzBcofI9A25FggpyHgShU3+IXfYUWhj55fruJQLw8SJJkw0geMgpSTru9TDhPlqndYGeZg1qKZ/xMDa0Pl/rfWmTaSlgHHxvYD5yiLztbatI/2f7ToS9369V4yk3HHtT8xGnwq5QRUjJX3hdJqNZxtl2VUs0ZDzrA6vRk6fntrwDE/rKvrLCJOEVhzhu571UO7RTa6bZyhfphW2aMWKRNk51bueJwoSI/rKr0YObROQ87DrRvfStKd/sUk4VGq09R1Q5snuvfbweGF5Ls1jTXq0hx8+dAyuy2mOA48I34HFumGhBtJs1s82AZbVOWstuvQwUer97TkbRt5iYKliLs/rTYliP6n4MN7Bk0XBj59w+eKswwHvAV+cdfjRWUlBfjjjUCcEejRv6aJ6uYE/fcj50O99FvFJ8Mbew7OPWAkcNI7cOENJlE34i3WEyLrw/D5pDYRp9MGfFL31SUHnYsrBXkzZeDpLoVgL7cXUuLvyidQDT81we+PGDf7BP/gH/KW/9Jd45ZVXWFpa6v75JKBjzU+wYSa+Yw+9HQjYmKipJ9B6Y412PHBiN/TbYlMkRtLJzg47GFHY4LzbDVabEVJKtN76ZN5qNyxFQmIPZd0qdg6K9PwnbCn0sbL8navVNRIVI4TEka4NG1YJ9WbVPq/Hfd8byUvGCp13bN8m0WM4ANB6c2hm4DqEiaIeRjTaMZFS5PzNRkhjkjTEVm7ihjKaNDGQoceVbMsyttsAlTKCjAuuSHmDuxQFfS2C1NvFdVy01oQDciJlDikclFa40uCl8uY5NnTDGrwlK43+OtbDiHaiCHoyRC2vXEWpNjaE2UFKB61tvxYzMO0tIoRgpdEZ360HwqS3Bo1Q9c0FL13IdMfgArhocl5q0MalnPJx7QShI+qtddwuVUM/PDdLs10n0UmXn3LzS0iNdIJ20ssVZpMGxqkhY8PYLKzRzSi0jgmCIlJmiXs4FqNBq1bqAdcpvtPmwXV6w8/2YRBgFEOF/TiOjy913yGmlHrAdTxVHobJougaGQPfVtQRNoxnJAeOsO3pXD7Zv7ffaBhjcByHRrtJFFY2ZSfe0eiLNb4ZY2hGLbK+R6Q0DWt5t0bGQw6ljOjy7zrC8kplRJvRPIwW7IGvkzjjYXLiOj611jpCRykXtN5yfPrqOCA3W6EgW/zYrMP+UpswbqJUE2OS9KLLTdupU6oYSLT1qI7wuxd7nQXYkeCll1bv3bff6dUpKu2LdARS/t+Nfu7okzDZurKdA9/z+yQuCWN52FcWjOYhK9qM5GGsYC+YBNsbagbl1+8V/YeIYv+FpkClHM+d5GueY7mmW1GCMZI4iW3fiQ3u6N6EefYCwPagvZTqr4CdywlJEpENhoiSjQsmW17nLZvX0C4PFprRfH87Btf+3oRvpN9z0N2+6X3n9hB9yWB69ZQxpmss7/RzbxlKmXSvYOx61tcHDo50SHRCrMwWQ9S5bO5PRjOY1K5zGeXIfgO3xspAMbAZvB8lOc4enj4sz6VIk/ZshsZeUuyN6x62w04G12y654vpRBX1o1fnrLWsETfrbT5XDHp//zDjcRsgC7LFj87KPmPwj59wmSx+8gwae9jDk4bvgisUxUzvumh1XsaDDBGuA+890HzruuJuvI9vXVd842rCQu2HW3d93PiTejH11Ay3v//7v49Sin/4D/8hn//85/v+fBIwaM1PNAREqSelhT0S2S6uNqu8f+8yjrQejl2qhK67T2rQSL2zfFf2eG7J1HBoYJtFuuOdNnjIHMRIzkdr3ZctvheJVjTadXJ+v3HKbsT6jWNSSnTqndgLz7HeuIlWrDcrVJsVqvU1qs0KteY6iVZorRgpeANlCF6a6fEO3LKGpvu3PZgrknizsT9MjZWFwCef8fAdh2YUb/qcMcpSRFgzgDU2QvdfMCgdbToQD5YBW2+AXjvsWJ6VjrHAFSkvce/UsxZO6x2YZa2+Bqa9RV03LARSbHg/d/5vKxQC33Kx9hgb26012q07qGQdpULiJCTwDAfKgh85uqHMMt7u1EPWdzbNBR/LpxprWzWPiFhBLdw9H1ch6zG/dBOlE4QMevpMImVAoiIqtfuUMk7aD2KTcaRjRBVoa7RLucJ8F+ph6gWXfk4ba1BMVEeZa4SwFyhej8eX7w5aZFTXkDbox9fbwod5efZ+WsgsQmaI4hauu7Onym7QMTJ+5pDEJ6acswbQoOfdvrNxMSMQJHqzzBtjrNe81rx78x3Gh7KbshP7DpuMaJ13dsY8VglGNWlFlpM2n9nQBZNFwWuHHQoBZAgZycN4AXwR4zuWtqU3ccZOciJkgNIJC0s3KWQ9Ak/gpreuD0si3Cs320EIwXhRoJKYRMVoZQ24UVhFqSZKNdA6tl7UQtBK7AWL/W6njNRLW9jy2jF8sGq64/ajs5KT4zFKJzbSwGy+1bLJ7jTjhe09E4UQjBUErlCp/hD4jsARCt+xnrtCGHI+lLakE7RlbhgqNRlXdD0QNjy6ty/flQ6JVlSbFRxhKQo6kQ6xUkghyPouQmiiJKLaqmK0QgqbANJeDCQordIkXpZHWKY3LwadeswrVNKyYxE3yGUK5Dxvx8vWXr5jlSqGnGhtyjI7uPZ32txJ+CcF+MLyYPRehmzdndaH2Hf7k8H06qlqaD8rUShjLzV7y5BSEPhZwriB1v3rhjEqvexzrUFl86h0owN6y+/NYg50L+PAXhJ2oiiGMvbyJzFiV5dxe3i20LmEaMabdXYn6dHeuO5hJ+xkcO3kTlDIvgSgHfTqnMHLokHsxvt7kGN3z8ttd9jzRt3DHnaHzqW60jCSt386zg8jOUiwCVtr7f7oA8vprajr7J6e+hjxJ/Fi6qkZbn/5l3+ZK1eubPnnk4JBa74WDjkfcp7A6JgwaqN1iIornL/+BneXHxCGVWIVp4lWdNeY0fFC09oQq5iCp9C6RRTWkNLDoK33KnZzYzqHvvTABZDf4pA5iM8dmyBWTXxv88ncYPDcgHpzjT/zXIYfPyHJilbX26bje2mNXBIpBPXmOkr1W4+Gs1CpV8hlcsj0oB0lkTU8pGW0wxqfPTK+ZZ92vAOLGRt2MIiOJx4YFtY+2PLAsdwMmZ0cYf9wif3lEjOlHHOV+qbPKtVkrbaCQOO7HZ5Dy9vnuxKjY9YblU1tHCyjg8EN0Ehe9hkLsr6LTtopLYa0Bhdt6RN8L0uURFy5+37XGNxbzw41hRyYtjt5h+0fLnFscoTlZtjXdqXqtFq3uHLvbdYWz/Plkx5fOun1KbOzU0GfV98mpN64Z/dltpwLGc96dWZ9+3uHj2u/N78rpbm/XKLktLg5dwmlmkjh4Hl563mcNLh06232lx1mhvN07H7K0Gd8V6nh2EUReLbMjlfncM5azjqE5YErSOI6rShMTS0yNcgqihm/a2gaHButE8IkBDRSio3QmR7ahk6YsdNxy7MdONDiHk9KY1AafAkZb7PlsNdTZbcQQnB4RJCXLRsKv8VeoePF7Ug7vwezuRsMYdTmu++/SaVyh5cP7utmJ+5cTozkA+Ik7Pgybvq+Npql6hLDOcFcpc7MUI795VLf50bykrG8QAuJ1yWTSt/RlzjjIXKimtycu0TJbbG/XGI4C3nZ6hqntuwnSD24++VmO5ycKIBqYnDTFmt72YMdxzhNKGVwiHvGa1MUQ7eHoBFt9JsQgpcP5InalfTCr3/+izRAS5gmp6Z25msa9OTsRcdQM14QfOGYS84fDI8XXY9ZR4JHQuCJbTwQ+iHSlkohmF9bpNqs4LsOgSsJlUJrTStKKAQu00NFsm5CtVnFczy0tgbwaqPCam2V9cYaWtuQWa2aaB2itSZWMaQhuVrHGGw0RTuOCVyPciG/7WVr74zUZnP0wSB69Z1O3WCVsQbOcrbHiz01cNr+3fj+xsVgJ2KiX6ZhQ0+N5QWxho7fsZRQCKyOiZUh1i4OCXcWb265vq03KuSCLDnfwXM21jdba2tcHix/UE6EEPidC9VUx3Y8fmuR9bQ9O+3sHfg/YRBCcHbaXi5XQ8tv2eG5fJRL1j388GIng6snO5ENYtOl3uA6PnhZNIiHeX8v1AzfuJrsebntYQ97eGLovVSvhaIvBL/atnrKlTbadqtIybl4gj+8rvr01B9cibm2pPcMuU8If9Iupp4qx+2fBAxa83/ipMN//CmPVw/G3L77Fu/ffZvFtfcJTAPHkVy+f5+V6gpgeSSjJCZKIuIkRhmFEFCrr3J1/gG1dsjK6i0SFZNoF6VCBLprQIU03FbufMjshec5vLDfJU4iPDfLhtlA4rlZEhUz7a3h+y6jeckBb45SxpahtFVKKvUq8oioNe5ydX6FWjtEaUOtHXJjqcLSyk2USnYsw/O29g7reAd+6YTDrH+H2TF6PJntD46AXDJHs3lvU/nXFlYpZXy+fG4WKa1H0mcOjjGSz2752dXV2wzl7KG2lIGANqWM3XRmXU27vfDQMrbDJs9sBaVAkKTGW8vRqDFIKvU1Vis3ydDg+uJqX3nvP7hHFNdxpNjSOLmdd5iUgq+cm6WU8bi20P/Oq/MrZF3FC+OS0cLmw9lY0cEzTTYbGDsjISgGmvGi0x23wbnw517x+NKJD8fH1Rk3X4a8d+v7LFWuMDf3LkuVK7x76/uYpMaXz80yWpCMFwQOiTVM9BrfUyqJvGx1DSJgDS9fOe0yVbKH0+Gc5d8d8gWe49AII8Cl3a6x3qxwbWGVE1OjHCzntxybJK7jCY3f1ai2z3zHHjQkmjDpGAR7jXLW8Ku0Sr0pNUrH3F9dRQpDOZthKz+5Xk+VR8GgJ9/gQd0XCZ86KDk4bCk+WlGLSmOdpfVFrty5yPfe/2P+6R/+r9xfuc3PnprBdeWm0HEpBT4hiUrS8Hi7EVFaEScJa/V11tY/4PriKiP5LJ85MLZpDg3Om956VkP6+Il2kpP3bn0fX4bdMjrtz/n2QGnD2XVfD0u5vdxsBceRzAQVBMrq6ZTjWmlIjIdSIcfHE8YK/SbaraIYOh6QeV9sKmOfu0ii2ikVhUAIF0s5oAmjBi8fcHGcnZf0h41/x1AzWpBMFQUusaV6kbaerkzDwXr6ptcDYbQAwzm661QHBmvszXia87fe5c5KlXoYkbOWRFYbbVxHMjtapBFFXFtYJWwvgElQxkNpk3p8CkuREjWIkxYIn3YUY4zGEQJjbKKyOG6SKE0jivFdj2LGJ+uJHS5bIe+DR0zOZ1P0wVbo6LsfPe6wz11gKAu+l3rWp31ajyAgpuBbuepEBnT6RKDJ+9tzbvVyGh7y7/O5I5IDw6nXek/Y15Scw5fhDuubRz0S6QWXIUk9d8GQ8TaXv5WcOCgKQXpfl0Z8dMp/7bDLZGlvO/lJxGRJ8tphl7GBcMJHuWTdww8vdjK4dqKDwNBKdl7Hd3OpuJ3393Ycu71ebjthzwNuD3vYw27Re6neT41oaQGLwdZ0L46EusmxVKerpwDuVgx/fEtzO5rhW9cV37yuH6qz9vDDiz3mqseAwUx7UkpeOFDmzoEMdxKPGwur1OOEA8MlJksF1qofUMhkyQaFlN/PxskKIONqTuTXKM5McGNhlfnlFbSX4fDULKVsiThOMI5rPQV1Qi7wGC8ITk3uPnvhzz4/w4P7b7AUT+A5OdzAxxhDFNd5fr/Lfr3hUViQLY4fdbi8oFmuG1ptRTZwGMuDW5vjR147xtcvCK7PLzNfa6GDNudmJjjgxsgRxbv3w4eW8bA+fXHW5YuzcP6B4vb9ZQ7vH+fMJJw/v8arJ17i6xdubln+7ORI930HynlOnz697Wc/PRuk2Vo1RjgYsGHFZpHP7dDG3jK2Q8dYkORnqbQMjptlNOOx3lzn/soDFlYXGSpmOTia5T/4sdNcvkxXbrrlHZjk00cD3p+L0GRTw63seocVAphQiwgxvKn82ckRfu7UzJbv/MmzR6nP3dl2DI5lF/lA5Wgnaeh/mmwJwDEhP3o835/oZ4u5MJIz3d8fFZvGbXmFKTXa1/8b2XETXGkT6jSbbXKZPLG2htNhNmfHlVLy4ozDN6oxYeKnia8c9uUKrDUVrbjNtfvvk83Q7avLly9vPTbHClybV3gu5CS0mm2ymTxJajzOtOfx8gdYaxrrxZjevkgpwFhfukTFJElCGNc4MCKYGQ6oNvUGrUqKfk+VR8+I+bDsxKcnhzg7LVmuS/7Vty7w1nyFi/fu0my1yWUznJge4xc//wKjcbU75oPZiUuBpI2haTMcEsYRYRKxUl3h3vw1JsreQ+VvcN70GqoG9d22crJFGb3tX6xpYrVhZBeqTSGT3VFutsLRIcOhYZe37kTE2kG4WevNKCOm3Xm+ePwFpJQsVmN++0KMFp71xuyhhOlcOGQ9ODQiNh0ebRmCt+7UiYyHMZbawBUR++Qcrxx64bGM/2RxqH9OOQE5H5rN1rZzatxdYc0tUwsFWdeQpY1y8sTK+hDnfMFUSXBqMkt7ocC37mtuL1dohgmB7zGUC5guFzFxSKWxoZvee/8uy3KaWLt4fg4PaLRrLK7dod1qcvzgc5RypTSpn4PSMa2wSTNsE/g+xUyALz0mSy7DOYHWhoJs8cKsZK2FzTB98jijeclKQ3Px/fucPXGcsYKlA5l7SF929N2Eu8b0kYPdNaS/Tx9w/PgJLs9rlhuGZjsG6VsdoBTgbCnT/WVYb4Hj45KTk3JzduyG4flT26+FG+ubwUWBcEGAScN1tip/KznxsEbt/WXB/N17nJ21ffVJ92D4YcdkSTJRFHtZ1/fwyNgwuGbxnM0GV6WhIJqMFYqst9h2He9cFq25ZaohZN0NI28r3t77u8Oxq6U1nHQiET3HRhNU2xv5ALbSU3Wd5ZvXNZWWoRnvY+W6YjhnODW5p9P2sIc9bI3JomB6yOlbM8PY8I3q1sk+O+c2EGRdq58UDmG4kWPBIPAdWGkY4niKhZphX/njbdcenn3sGW6fIA6U8/zs8y9wv1LlrXfP88oL55gZLnNvrcLr528RDJ1gtQlRnOC7LgfKPhPFFjeu1viZF8+yWGnw1sVLfOrcAT51eJxK23Dx/Q84fvQo371xlyt373HqyAyfPXiIhXqV22t1RlfX0zLWub1WZ2h5zb7ng0Wi0j1ePXIAIeDVaZ/Tp2f4nYt3ef+Wfc/PPHeIhXqNt969zejqejd8ebIomCy6XJpb5+LVW5w5dISTEwXOn28xOznC8akx7qys8da753np+ecQRvD2+fO8OFPkK2dK/PHNBS5ev8PZ2YN8fvYwUsI77yw/Ul86jsO5faAW5zm3b6r7/zuVf3egL1456PD/+LFP8dYH9/j++Ut86twZXj64jwsX3mOyKBjPC759fZG5e3fYd+wAh0pZ3r23xKHDU9t+b7fYZCw4dZyR3CR3VwPeerfOKy+c4+DoMMZo6nOb5abzrLVyhbhwjJUmtNsJGd9hLAej+RY3ri5xd3VqU9h5RxZ/+rnnefvOg24brCwY3tnGcNap95867nNpTjFXVYRRTOC7lAJNa/U6UXwErTcbizvQ2nB31fb/8EoFYcSWctorb4MYHONXXjjH/nKJ9957t/uZrpGvYI18HeP7eEFyalJsaRDR2hDFVZz2LTL5k9RDSVO55JDMTviM5gwHTOHRxiZ3jKWGoq0FUikmCy6npiRzNyq8MHuItRZ8/9J9Gv5+tLaejK1mm2wuTyuGsB3zxeNlnp85xHxV8Y1L1a4xtHuISax33LDebFTU2nC/sqELDo5uPTZbbTp6D+odY9GrUx6/+KUv8fVL13nr4hVeOXuSnz53EseBd955Z1P/d9rfVC65rMv+skOiKty4fZPnjx3gUHmKdy8t9/Xbw+Svb97MHmckJ7m7WtkkN1vJyXZl9Lb/+5fuY3L7WWnENBONCGP2lX1OT+3+MgzglUNDvLDf8Fvv3e7q1J8+e4DLlx90+3SsYL0z5/QMsbaRAxrrnatSb+zn91vO1g5NRe+YvnIQfumzY3069bNHxrl48UH3s9vNt15ZsDpdcmmuzsWrtzhxcEOnD47ppjmVF4zkmn36ZtDI1/FklSKmWbnLuUNTnJoscb+yznghw3/zH73MpbtLvH3ZytRXzp5gvrZ5nZS6xpfPHqIZSi5ev8XZE0c4NXmY+5Vh3nr3PC8/XyQfFHjr/bs0/P0o7VMIDDWZUCwUcZ0AFTY2HfgfdsH0YQyRO/XppjX0+BEmi3kuX9swfu7GUAx2k99oV1lZX6TRnqSc2V7+O3pysG6nZ48gDFy6cYsTh45wZnoIMJvK30pPdOZfp/zR/PB21Pt7+ARhMJxwD3vYDXY0uHb3Kov8yGy5bx3fSuft5lJxEB2O3SGvk/ein2Yo6xnWQ5sPYCTX/92FmuFePIXXMGQ9iInwnUzqqasZ3vN628Me9rANBtfM1eZG9IE/YLyN9UaUk5TWkBsZD4yNRsPYxO4Gm+x1KXS4PK+ZHtrz/t9DP/YMt08YUgoOjAyxMlzgwMgQjiM5MDLEO6bBncUL3FsLWa81cT2P32+uE7gOy2urRG/dBsA3iut1zfdvzfPl547y7atX+a9/5zss1RrEicJ54x3+5r92OTxWJi8Uv3VjhVBpAtfh3uISK394iTBJENrw1fP3ODw+zF/8/As0Kw2+80dvp169y1xfW+VfvfkOgevQrFf51oM6xyZHOOjGFBZWezzZlvnuvbnusxd72viOEPzWD6523/mtB3Vmp8b48nNHKe3zefHEFI7jbOLNfFx9PFh+b18069VNv1+va968+YCDbszKxZv8k2+/y+2lNaqNFnz7LXzPYTTjMrPD9158hHoOGgs6stCRDSkFna4ZlJvOs4Js8cJxJ90A36c0OsF3rl7vjk3vuPXW7W6lwXf+8Psb490jUw+DPbz7LNcV33jzCgtt+P7cg1QW5rtjPIjrPXJzc26ef9Qj04NjsV29B8e40x9bYSsj33YGkcG6RVyglBsi57hMjhQ4MJLly88d5fAjjM1adZk7q+vdOT1UzHFgJMv+0tG+8R/0ztOpQWyq5OKKRc7tP4mU4pE8Trtj/Advbjn/tsJuDup3Kw2+86230ndWWb94izsrtS3fuV37v/zcUSYinxdPTgOwPre5T3dC77xZra3xL757c1t5325sdmr/B3PX+Nb9t1hv2URTUsJQTvAXP/8Cow+vXhe/36NDGq02+cvX+FdvlPni/hIvvrjxuXG3wsz0Qd67bxORGRy0sXzQI3qO05OHu58dHNPBeXNtbZXzdzbr6cH5NigL1x+i0zsYnFOl4R30TY+R7xtv3mSuAddTPfH7V4vdeg+ub+tsyNTh4QJhrPiHf/DmlmWcmS7hOE53jA+OWl0w4a6hhspdj2elPaJ6iCcbjOk5Jou780b+KNipT3daQ0dyJ3ZtKB4s42Hyv9X3bs7NE715HrD9f/Te3K71xFbzb3ZqjJ96fpbjU48yW/awhz38ScF2Btfevcrg/nc7nfewS+VBPCyp2Xb5AIwxXJ7XKBxG0tDmR/HUfVoYpHV4GJXTHvawh48HO0UfKG26uQE8x6EZgcLBhb6Lb2PSRL4kVFpWnw5lPt527OHZxp7h9ing+sIqv/X+PWQmz3S5wEq7wo2ViPVGm6zvEscxjmcQBto6AQEX7i3wBxdvcvHeAhrI+R4e0NKGaivk0v0lZofzrESG9UYbRwoqzTYacKVM+TAl1+aW+Vv/9puMBpKpsVGmywXq6x4frFVZb7Qp5zIcKvqU8xku3Fvkj9crDN9ZRxvD1FAeGeYopc/eazc4fXqVk/vGN7Vp43ML3F9d57XxzCMZOT9qnw62aTQQ3N2mjb+3vMxKeJUoTsgHnk34hqHejmi029QTQ6L0pu/1tv/jRGcDXKku8bs37rLWbD/xsRFCsFpb4+uXL+/qPXcrDV6/9gPWmm0ynkO1laAcK9PVOGI9WaMVxo+9T3dzONiubs1wGakTysUDXLhXfSS5HezjmAZZL9i2j3d7ONmtMfpJzL9Heeejtv/DoHfcdpL3R8HvX7zJr799k9gIRgtZdBQi/YBrcy3+29/6Nn/2zL4+o+t2ePPuMv/y0nvUWyEjhSx5aZC+z9X5FW4tLHP06E2+/Pzx7udPT0rOTDncXFZcu/WA40dmODQM771X6X7mYTptOz09ON9615D7q+sczhhuX1vZdT8+qr4Z1BO99d5pffswdeuXje+z1mwzMzpOu94kU8hxd3kR3W7w/KkDT1RP7ySbu11DP0oZD++brXXxYP/vNE+3L3+BB2tVfulHX94z3u5hDz+k2GpP8yiRBL14FO/vXo7dQS832D4fwFrTUGkZXJIt+Sh38tR9WlioGd5fSFhr6i6tQzkrcPc8g/ewh6eOh9G9CAHSKFYbHmFiqdHiNNquk8eno4okGqUhfIQE1Hv44cBeNomPGVobvnb+OtV2zPHJEQqBz1ytiVKaA6Ml1lsh1XbMRDHPxFCeSGnmK3WOjg1x8f4CoVKM5DJkPZfYGKSAnOeilOb6ap0k0cyMFFlptAhjRTkbUMz4aANhrDgwUmKl3uTmSp1j48N95R8cGyLRmge1FoUgYHZimDuVJlfnlzk+OUIxE+BIQTETcHxyhGo75uvnr5Mkuq9NvZ87MTXKaqPF9+4uo/WTcfnfqU8Pjg0RK8X1lRrJFm08Nl7m5kqD1XqTAyMlwkSjjKEY+JRzAWGiWam3ODDa/73e9j+pdj2szd+7s8xqo8WJqdEnPjaDfbzTe3rrdnxyhLlKnUgpJot5xks5qmHMejPk4Ifs04+SSGKnuvXOt+OTI0+kb3qx20yXD/vchy3/cbXpSZS/VX12I++PUkaSaP7JH71DM0o4OFpK3ykpZgIOjg1Ra4X89vv3SLZLc93znt+6fI9aK+Tg2FD/e0ZLNKOEX//2O5veI6XkyKhkwl3lyKilR+ht7046bTs9PTsxvKNMr9Sb/Nb791ipP1o/flh9s9v17VHqppTum/9K6b66ZV1F2F4j66qPRU/v1De7XUN3o2M+jPw/Ln23U/mdOf61p7QW7mEPe3g28DSydz8sqdlGPoD+74WJNer2pwzdwHaeuk8L2yVgW2lYuoeF2p7u/Tiwl8huDzthu8RlEwVBOQsx1mhrE9UaBDZpddy5YEpztmskjrT5JPawh17sGW4/Ztxfq3JjYZWxXIAQglo7ohrGFDJBmnHV/omVQiDIeS6rjRYXHiwRKY2kw4loUNrgCHvgdx1JrA1KaxpRgtI2CZLNYi/wHEkrTqhHMY4UREoxX633lS+FpJDxqbZjau2QehijjX1nrR31tUMIwVgu4PrCKm9/8KCvTYOfmy4XuLfe5H6l+rH3qRQS33OphQmB62xq43y1QaQUjhDUo5hWHOMJy4eoNUghSJSiEcZ93+tt//21J9OuHdtcqXKv2mS6XNiyzx/32Az28eB7DoxNUFM53l+ocW9to261dsRao0XOcxFCECcaY0AbQ6T0I/dpJ5HEt64r7sb7+NZ1xTeuJrvetPb222DdeudbrR09tr75uOX/cZT/KO/8ONq/W3l/lLn49gcPuL1cYSjwkKJ/KZRCMlrIMldr8fadBzu/584D5ustRgvZLd8zFHjcWqrw9gc7v6cXD9Np2+npufX6jjJdzPrM11qUsv4j9eOH1Te7Xd9q7Yix0jDCHWK8NLxtGfcrit+52Oqb/7/7fkhVZR+rbDwKduqb3a6hD6vbh5X/x6XvHlb+vnKR6/MrT2Ut3MMe9vDDi46Xm+9CNSRdZ+y/1dB65I67K5v0VuBa46ze5hi8nafu00AnAVuUQCmwdA4dWodiYEOuL8/rPSPiE8ZCzfCNq0nf/uOb1zX1PY/nPfRgsij48RMuX5x1OOA94IuzDj9+wiVwoJM8sYOtZqwxhgSXclYwvMc3v4cBPANL0g8X6mFEO1HkXHutEiUKpQ2eIwljhd0qWKMsgCMFSUqH0JnhncXZGHtbA+AIa9JVWpMonWYo3PisFNZYliiNTAn8W1FC4Lrd8gE8x0EZQ5RsEEMK/v/s/WlwXEmW3wv+3O8ScWNDBAASAPdkgsxkMplbdVX1Uouql+pudVtLs6j1JLOnbj3JZPNhZDOSzEYta7XJbGQyjUZq2ZhMZm9M0kitN88k9chmpvSm1OouqWvJWrpyX5hJZpIgkwtILMQSiP1u7vPhRgARgYhAIAAQYOb9p1WR4MX1c/z48ePXj59zPHL0diNhGtSDkJVKraNP3XBsCy9UVBv+3oTXB4NkCpHzVbXVqWrvY80N0EQff0GoUEpvpizopsA14Ich6YTVIZtW/ytu54b8caDa8PHCkJRt9Xy+32PTLeMWDCNDInEcJ5Ukkw54/6FNylI4Tp6UbbFRdwlChRUdLxI29VGgCbUiaZpDy3Q/LpJol1s3b7A137wwZMxJ7Ek2LTxu/d8P+rtpUxrhgfd/WH3fzVxcqdSieW313rg5tkUQalbLneUruiMuVkp1/FDj9OHNNiV1P5qLw2Inm9bPTtc8f6BOG1LihxrZJxKqnxxHtTfDrG/5zAT53AVM0yGfC0glTAw8XHe5g0Y+O8mxiVmKDcFYcmv+b9Ql5069gNRLQGPoPu0XBsmmNT47raE78Taq/u+XvduJvpOwWNyoHMpaGCNGjM82hqmx241CSpB3BA/q5rY6tp2RupnH2ZWe2OkCtrge5sGjFfHshQLH3Pr+WK1q/GbE84n8YXMZ46igO/ugWIdGAAkaCCPVvKis+btEpRJCLah5ECgwCbddqhsjBsQRt48dmYRN0jRwmxs62zQwpMAPFVIKotB5gdFydCmNIQU5J0HLS9uKlhFCbJ7WhDpK9zGa0beI6Ndbk161Cl4bctOJ6dhmB32IHJSGENimgd3cfGs0trHdKeMGIQnTYDKT6uhTN+qej21I0snem769YpBMIXJYy7aPnfY+phImguhDzTQkUgpa2Z6iKXBB5Chpf6+9/5mEfSD9GoR00sI2DGpeb2fYfo9Nt4wBkk6BpHMKaaQIQh/XrWKbUPMNnjn7MoFOYhkGpiG3HDVNfdQIDCGHlmn7RRLZroiDXCK6oKJ1kcSwcuvmDbbmm20Ye5JNOx63/u8H/d20+Tj6P6y+72YuTmZSWIaB26cUQt3zMQ3BRHbrQKBXxEVdT3NqYop6H968ILqMYDIzfKG8nWxaPzudsq2BOh0qhWVEB1m90E+Oo9qbnda3fHaSl59+mYSVIQh9yrUSYRggjRRJ5xRJp7BJYyx/DtOwSVud8z9layzTxrB614k9aDs9SDbDrqE78TaK/mutUcLm2NgUnrL2ZO92ol93/UNbC2PEiBGjX5TbVLZ/CapL0xKDkPIuInUPAztdwBbXwzxYxBHPMfaKrdIsrai6KIzBIAqsa4U0+SFMpAUnrcW+tivGZxux4/Yx42Qhx9NT46zUXLTWZJM2uYRFpeE2F4Pof5ZhoNHU/IDxtMPzJ45hG1E1JkkUKWNIQagVqhlla0mBISVp28SQAo1oGgSNHyocyyRjW4Qq2kRO5zId9JVWVBoeuaRFNpkgk7CQQjTrNW53pK3UXGanxnnl7ImOPnX/3kKxwqmxFCfzuccuU6UVnh+QTZi4Qbitj9O5dOTQ0JqMbeFYFr6OFmApI6evaRikE1bHe+39P1k4mH4N7HM+x6lcioVipafM93tsumUMUMifQwgTpVwavkfSNMgkTAopg6SVQJrHyCZtCmmHmh+gtcYyZVSgXQhsQw4t050vkogiEtZ7XzzcU27dvLXPt2zS3pNsRpHxqDgI+rtp83H0f1h9381cfOXsCc5N5tlwfZTudN4qHdW2nsk6vHLmBNC/xpwWDl95/qcxzWzPdjZcn6eO5Xnl7Inh+7uDTetnp2fGMgN1ulz3mM46lOreruQ4qr3ZaX07f+IijpUEPPwgKmfjBT5KuQhhks+fA0CIJKadwZIKp6vol2ObCOWBSCJEsi9vB2WnB8lm2DV0J952q/+tkjI3HqW49NRPkM3Mcnz8Wc4dPzmSvduJ/sNimdnpiUNZC2PEiBEDdl9jdyorOGUtMtFVj3IyLfjCWYOM3OGD8jGh/QK2XojrYR4sWhHPjkXP/Ud7xHOMGL2QMKMAugZJfAVSRgcurfN8ARgEfO6M5Kuz8sjYnhhHD7HjdkSMWqBcSsEvXpkll7S4ubRGxfWYyaYwDMn91RI5J0EuYbFcrrK0UcU2JNP5DLdXNrh8coqEYbBWazRrsUaRUzU/wDQks+MZTFMyv1ZmPO2QMA2KdZdy3UMKSFgG99dKTGZSnJ/IcOvRegf9eysb0eY/41BxXeaW1zmTT3NxepKbS2uUGy6h0pQbLjeX1sglbb5+ZRbTlB19av+9G4urjKcdvnh6shlxtf8YJNN7KxuYhsHT41nMHn289ajI+YkM45kU99dKJEyJFIKy61GsuSTMqNbl/dXO99r7f1D92qnPXzwzyXja4cbi6oGPTbeM64GBZWfxA5eq62EZBgXHRiCQQpA2FVkny/x6VDvRNgyWylWWSzVyCYuxVIJ7u5Dpfl0k0S63m0trHby1z7ebS2sjy+aw9X8/6O+mzcfR/2H1fTc0TFPym19+iZRtcm+1RLnhEihFueFyb2WDnJPgV549hWnKgREXuQQUUileeuoy91Y2OtqpuAZPTZ3kL/zU5zGM0eU/rJ2eW14fqNMTmRS/+uwpJjLb5Thf9Dg5McPPPHOR7v3uqPZm0PrmBhaFTAGtfaquh20aTGWS2KZB1fXwAxfbzlIPDB4Ua1jSYDKT3MyEaEEgGEsaWIbB/Hq1L29CcCCXigySzbBraLve9vq22I3+t0rKrDYPGNJmgCAk1Akun32BE+PTu7Z3g+jfWFxlIuPwi4e0FsaIESPGqMjIOl+dlUNH6h4GdrqALa6HebCII55j7BV5J3LcRtmmUZStIPrTlNHdRQI4W9h+OBAjRjvi87kRsFTWfLQUsF5T1PwTrM6F5B2BOWSB8tmpcX712VPcCyxuLa1R8QNOF3JM5TLYpsHK+joeBgKwtQQNV05P8Qu/dJ7/+J0f8Ye3HvGoXMUPQgxDMuYkODuZJy0UqXRms5355RVWGwFeECCUwAsUF2cm+Y0vvUjt0UJf+pVKmWK1wZVTxzl9rsClS5f41ge3mVtcYbFcRyWaz0yf2anxnn3a/L3TU/zC5fNUFu4d4IjsLNNapczpQrZnH//0uQKpYzP83g/e486jddBRRGg2aTORNDl5bAIvVNtl09b/w8DpfPqxjk17OwsbikwaVOCTdRIcy6QI3K0TwqQpMJMpZqePc/PhXXKOtaXTtmSikN+VTFsXSQR7uEhCa816HfK5Y/z608f54Y055hZXOnlrn28jyuYo6P9+0N9Nm4+j/8Pq+27wc5fPc/v2eV59UOLOSpFa3SWlxKadnPCjy5Z2qjGXsTQXZk6wXHyKD+/fI5fM89LsFabzx0hZJlXl8O0bPpemhj8r3cmmDbLTO+n012bObP5uXac4kZ7lxLEclhB8su5QdAOener8eBzV3vRb3/KpFJZhorRH1klQSKUIPI8x22a9WqPqekhpU3MV549lSSUMEla/OsIWtpnkqckcNxfmt/GWTRX4zo3R1+x2dDtWC84OshlyDYWtSNliXW/yWUhpnp0SQ8m/vaTMeKKVjWCQzTg8Ktfwlcnz556jcuO1Xdu7vvRPT/GLV2a5MD2xa1nGiBEjxmEjitRl6Ejdx43WBWzrZp6SC465Vdah7sf1MA8a7RHPdo9POIXEiiOeDx29vs2OCor1aA8LilBLDFr3EEGooxq3UmuKjcgWxYjRD7GZ2SX2q0D56XyaX3nhRR4US7z13lU+9+IVThXyzK8Xeeu9q7z8wvMILXj7avTszEQBrRW//Owp/tb/+pf51rU53vrwYz53+Rl+8fJFFsu923nxymWWi1Xe+vAaP3HlOT7/1GmE0Lz7bmkb/ZP5MT5aKvHhjU+4fPEpnjme4erV95mdGufC9CT3VtfbfjfH+++/t2OfWny/e8COq2Fk2uvnVj9eunyen33uad745D5vXr3GK89fYjqb5d0PPxj43mHjcY9Nq52Plsq88Ykmm06TTVqgYaPNcauQOJbBL33xEpXGiZ46vRuZ7vUiiW6HSGo9yXNnXubLz9a4deO9vvNtFNkcJf3fK/3dtPk4+j+svu8Gnz89yV/+5Z/l7XsPefNqt518Fxgu4iJl2/y9P/tzfLy4zNxyAtNOIZGEOqTmwn1fs1YNOb4LZ+EwNq3V/27ZDNLp1u++P7/B23cCEskU2aRBrVLCNpy+F/5103jlhSukE1mu3ZhjraaZzOih+H75heepNiRv3NU4yTRKm9R9og9a3yDrjDGWCqg3XH7+p5/jmeMZ/pe31qj7YBm9I45O5kz+/OeucH/tdIdsfvTujX27VGTQoe1LA3RzGL0d5vLFQTSgf0mZdMImnbQpN3zS5nH+Nz/xa2RtvWt716sfZyYKcaRtjBgxYhwg+l3ANpEWmGqRqezYYbP4qcVWxLPT9/tjqhnxrFRcLuEwsNeAuoOGG0QRtQ4uGCZ+CBqJ0kSZUTaUa3rHrNEYMWLH7S7QSpdVEnJJgK10WVNqHrlRgfKprOL+2gZ31itMrG101IxTSm89K5Y4mc+xWshwenysY6MlEKSTWSbGjpNO5ghDxZt35nnz7jKN7EOePzFFsP6IF89MY9sGp8fHNtsxDLn581OTBZ6aLJCorPDS+VMYhiRs3m4tpdj8PdvK8f3bivVaCj/5NDceJVmu6E2j1/67M7ksb955wJt3l/Fy83zu7CkebkR9KqxvILTo6O/8+pYsos17b9m0IwhU5EjpQWPQe+18dsuiW8bdME3JF86fwi6t8NLTpwEoPtzezsl8jgfF0iYvZyYKfdtsh1J64HsdujGgj93tnCrkN595Ych/fvcGb1+/xzwOv3zlmc0aOt2ykVLQ46LzHXlVSlOulXBdMCybtKVxw4C6H2J5Pg0voOwJTLtO2kxzs1jmYanGdLHMdDbbk57WkdOhdVKaT4ab+u7l5nn59ElQK9Rdk+WKQcGxOiIOvMCjuDLHa7frTGezHbL54GGZW/XjJHSAbWiCoI7SJqtVk7LrMDl2jNOFMR4USwPHbpix6ZYxMNR72+Ux/MlxO2+D5l9htYjQYpOXE2NjvHW3ZVPub5Pb5ntdbQ6iP7ZWZLlY5WGpxolimRNjY1u2oYt+O42xlfXogGmI+T7IFkUO1z6y6aLfrtNSCmbyWU7kUszks9vGLWVnNyMuLKmp+z51P8T2fZKWuRlx4diChprAsEJEs+6cDhWGNAgUlBsQcjz62A8Ub3yye/nvZIs3+641y8XK5licKuQ7ZBOGihvL4CuJg48ljY71bLnis1BJI27eQ2rBO20yPj0+xt2xY9xaTfOo6lNrTLPwscfxjMmlabmNz24benYij9aaD+eL1HyzWfcaBAohDLwQtDZJGXWeOT7Gw40yQX0eaWcpNQwcK7IZXqgpN0KCwGcipdE619H/+6sl7tTGMHXIeMqgEQQ0gpCECjAFlEPBW/caTGU7Qxx66c3NDbh1y0NjIEWwaUcWSwK3cZyxB2VeODXWd504MTbGQtMWniiWmcllO8bizXsNGqHAkQGmYW6OhWVAqbF1+aJhbLcxLdRcRcX1qTcaSMtkzNmq+SsQpG2TRiOgkEoRqnJPOzHwm6U5b7rXkRgxYsSIcbCYygpmxgxWKiEffvSQy7MXKDjw3ntxPcyDRBzxfLSxXwF1B4nNrFGhGU+DF0Kl0iCTTmObAj/QO2aNxogBseN2V9gpXdYkYKkU8D9++3qUrrmywqsPKzw9Nc4Z0yeztLaVZjjgWb2huR2UyaUElpjhzgd17q8u89bcVeYe3oPXbmFbBhNJk+ceVpidnuTrz58fuV+7MXpv3F/hd3/8De6sFKnWG/xP794lYZmcyGep1yr8i7fuAGDrkG/eWsUNFQkziuTq/rm9/y+18TOIhvAbfd/bCXMD5D9sO/eLVX747TeidPBmG8PIf6f3huWtu512md56uMjSH72HFwSg4fev3uMf/8GP+KtffYUr6eHlNIjX9rHJJsf40uWfYrmUQCmPhuuii3Uc26Hhu3zjjTf4P/+/F7GkxPeDDr091ca3hdVX3z9ZvM+/fusTfKWwpOR4bpKXZ69wPDdBxjZpVL3OufGDd7bReP7sKyTtDOWNRSBKR0k1AtIJm4yToVQf4719GJtujPrebk6O22ncXljsO/9W1tc6nv3+tQUeblRw/ZB6w4XXbjFdmORY2uHb82+xXtvo+d4g2Vy794DV717DDQKE0kPbhvnlR33fGzTfu+3Ev786z7ljBX7zSy8ysYNs2vsxaE6126l88gwbDZtKvULV9XA9j9WmHtnSYsoRaA0rlYg/q+3SgcgJB34IVe3wX96f59//+E3uPFqnVK33nRuD5D/ITq5vbHTItFs2f/zhbf7jm7d5euYF6m6d+aIiZVtMJE18UeP+2gZeqDGlyf/pP3yPlfIalhQUmu38dz/1eVYbx/HqdWpunbpbx2k4lGopHlVMZvTuohy0ZtOpLJo/AzSCkP/7d97cHJunTtY5OzXLWCpHI7TYKNYo1Ta4ee8Dvn/d2ya3XGqML178Irqxzr2VACkFnu9zd6MWjZEwqPop/sdv3+IXLp8YOKd+8uIXGdc1am51sx3VbCebyPBfrxX5/kcf99Sp9vnmeV40HpN5vnIyR2Zmjf/64UOUcYJ6o06xLkknbByhGKNV7kCz4UaXLx7rffbVNaYuD0r1zTEda/phQwV+GPKNtz9gbuFhX32fnTnBlCER94ubJWV2s97FiBEjRoz9R/cFbDEeD+KI56OJYQPqZsb2HgndKrfXCqhpZZgNg86sUbANgSFCbEOAZses0RgxWogdt7vATumyXuBT9QSfrJTIp5NIN0UuneSD+WV+tFGkcG8DpTXTY+m+z85MTpNxTmNZSSqNaFOsMUnaGb5w8SeoNlwerC9TaXjUXZfTDZcP5pd4sLbBTx5L7sqRCbszen/84W3+7du38bVgIuNgqoCiF7JebbBarpG2DJLJBEJDyffYCNapuz75VJKJhOD+eomNaoN8KsnZrE2+2f/3G1UuXVrjmRPHBtIoVhs8fzzb872dcL9Y5cc332G91tgm/2HbmVta45sfzSOTaWbymbY2Bst/p/fOJTV3bq7uyFt3O5UNi7tNmSqtWavWUc1aOUJoLClZLFb4x3/wI/7CldO89NLO2jGI19fm7vPRgyWQBhMZh3ptle9f+zHPnXmWyWwB204RqpCljRXembvK3dVFAqUwhcA2JNIQVBoe1UaDSqAJQsXT06e4MvsKyYSzTd9/8pnPowKfDxce4IchlpQk5SPemXsdTRJDShSKtdI66YSFEBCiO2hknTEMw6FcrxJqDRpU84KzcsOl5gaAwd1Hta45u7ux2S99280hSjuNpGVQqgeEht42/xzbxPd9DCt6ttpoUFuv4gUhtmEwUzjOS+evUMiMYcqo8lKmUmTu4U1Wqt7mew0V5fr0ko0XBDzYqBMAppQopai5/o62wZCCYq2B6vHeoPnebSfSUiNtm5sLK/zDb/6Anzs7TqXJW7ds2vtxbX6J9WKR3NjYtjnVbadEuMqz5z+PIU1s00KoEMu08EKDmlvneVuzWssRNOstb4OI5qarBP/fd+5wc2Glr94Godo2bu18d8/Fdjv5aKMaHSpKgSll8xRfbsrmleMZ3l6ukEnmefa0gesppJRUXY9yw0WW6qA1UkhsM4FlWQRhSBhGTtWbCyv8ye06x3IOoSqTME2SpoEhoVQvEYRpPDnGz3SVNOnGeh0CTMYcaPh0pI4lTBAELFfhk7a5mTBd3r39Oik7Q73uknBs8g6Ebon7VY+NaqNDbhlHohBUGw1CpSKboRRCyqYt8MkKyScrJf7Nq0sdOt2uN4VUHieZo1Sv4vretnaqbpWxdIZbD6v83/7wTzp0avERXFtYoeEFOJbFeNIimbS5sbjKjYfL/GChzFR+iqdnzmBJjWkYlBsupTAkk/HIJBM7Xr74xv0Vfv/a+1TqLtOFc+TTeSpularrUXM9Uqkak9kUG42QpeIqnyzf66nvl6enOXfiMqFI8kBpFm4p6uFxjucF0q0Ntd7FiBEjRowYnzbEEc9HD8ME1BXrkbN9LDmgoR0w6P6BYSCE4NK0ZHEtpOyCY7VFbQcC24SCWkWIydGZjPGZwPA3pcToKFDeDY1moxHihyGnCmmyyQSGFGSTCWaPF7hXrHFjcYULU+MDn+WzpzAMC/BIWpKaF1LzXHy/jmVYXDn3HNmETSGdJFCajxdXmT0+zlq1zmv3V3ZdX6dl9Bxr+02G7UbvUVnxe99/l5oXcGYiRyZhU/WjnXwhlcD1Q4p1l+OZFMdyKUquz0bN5czEGH4YMrdaJggVZybHCJTiYblOJpHgwtQ4pYbPt67O4XlhXxrj6SRBqJhbLZO27Y73duqzUprX7q2wVq1zcXqiQ/7DtqOU5o+uzlFq+NvG8OL0RF/57/TeaqXGNz+aZ7UymLcgUB3tZBI2C+UaYag4WciwWq0TKo1jGSQskyjpOJKb6wf8p+v38bw+dRGG4HX2eIEP5pcoNXzOjG+NzWJxmR988H2+8dp/4z+/+V2+/8EP+f4H3+f28kNCpXBMg1BpGkFIJmGRTyVwA8Vqpc7piTGenpkFYYLu0vegTsKymT31LFprUlZ0Srle98kkbFKWz/UH95hbeMip8RxuoAi1JpuwO2icmigAAtf3SZgGCctAaXCDkLRtUWo0CDWcnZgYeWx6jfko+tY6RPECyCWiw5PWIUo2ASHRIYrWuoPGhalxFooVvDBkKpvumH+nx3Ns1F1KDZ/j2TSTWYdiw6PhBxRSCY7lJ/ny5Z9kKj9JEPqsV0pUGnWmCsd48fzLpJ1xjmfTHB9L44WKxWKFC1PjHbKZPV7g44VVAqXIOwkyCQsvVPhhONA2nCpkWa3Wcf1w23uD5nu3nYjkK8kmE5yZHKNUa/Cfrt1ntVzbJpv2fsweL3BjcZV7xSqzxzvnVLedmj1e4Or8ff7k49cxhItlWNh2GsuwMGhw/ZO3ee3mx2wNaR9bIkApaHgBpycG6G3XuLXz/fSxfM+5iIC8Y9Pwo3IA+WSCbNKO9N0POTMxxka1zh98/IBy3WU8Y4PWmIaFKSVJyyQIFX4QkmzakCAM0SrAsS00UKw3uHTyFOlklmK1Qsq2MA2JEGAaUaRow29QCizWqoPtcusgNGXBREYwngZHNBhPR1EspXoVjeDs5PY59P69u7x//w4nx+yOcTs90Sm3dELiBwEgcSwLP1QESm/aAikNvCDgZD7VodPb9SYHQtDwvJ7t+EFIqODM5HiHTqVti1vNtW88nUQIqHgBmWSC0+NZNhoeH84vc2IshRQaKY1IjrZFoBSPyjU0euDli0Gg+Ob1ecp1lzOTYyys3sUPfHJOlkwyiVLwsFhho6GpNOrcfvjxtjXkzOQY+cw409PPk7SyWFKzVt6gXK+TTxcYHztPOj2+43oXI0aMGDFifFrRHfG83+URusuktTsiY2zHMPdPhCqqMTsqWvcPrFY1tgEWHrZB8/6BkMqQdXSnsoJT1iITaYEXshm1PZkWfOGsQUbGBwAxdkbsuN0FtgqUs82Y1r0ALW3QDbRudDyruD5Ka0KlKDe8vs/qgYkhkwRB9L4bBCitEUCgFZVGjcncOOPZAgJB0jAoVhssblSYyWeY36gNrNPZC8MavQ8erHBnpchYwkIKiReEuIEiYRjoZpRuqDQVz8cPFFpHNQa9UGFbJmU3IGEaSCHJJG1KDZ9yw0UIwWQqEaWnfjjXl4aUEsc2qbgBCxvljvcerA/u84NiiflSjZl8pqdzeph2HqyXuLW0xmQq0bONfvLf6b2sY7NYrpNz7IG8vX33YUc75YZHyfXJJBMU617bBlogEEgpCEKF0pCyTdZrPt+6NjdYTgN4Xdio4AYhUoCvVMfYhBqWN1a5u/KQ5dIqQagjt5WOdAsBSoMfKpQCKSKHkGGkKGSiyLBAqQ59V1pTa9QpZApM5yeRUmIaEi9UlF2PWtMJrbSmWHOp+z6WiGpMtdNYq1QIVYhpGKjmnDWEwA9CGkGIIQ1Cpai6nQvmbsamW29G1bdhD1HWa7qDRrnhsV6tk7JMhBAd86/i+Wgdffz5YUjVDQhV06YozcvnnydpJSnVSgRhgEbjBT6lapmEZfPCU8/hhyECQcoyWavWKTe8DtksbFTYqDU257dqHmxpHdHoZxvW626TF43SdLynNH3ne7edaIcUkpyTYL3uIw2xTTbt/VjYqBBqHcnJ9TrmVLedatnp5eIyy2sfUat9wtLi+9Rqn1Cvf4KlKswtraGCGqaMIke7v7d1cw74oY8fVJr10XrrbbHmdoxbO9+3Hq0PnIs6mnr4SiEQWIak7gd4oSKVsKh5IY5tUmtUqDTKJO3oozNs2hCtNV6gcBIOq6U11spFBFH0bsMLaARgGpHD0w06v4YF0UFDoOFBscogtB+ECkRH6ljDD6h7IVJo0J0HTuWG13fc/FB3yG29XGStXCSVcAi0oiWdli1IJ1OsV4ps1DY6dLpbb+pegzAMMQ2zZzu2aeKHAY9KpQ7eFjYqlL0AxzKRUmKbBm6g8IKAINQYIurrw/VHhKqBaSZbEx7biKKg627Qlka3XY5v33vIYqXORMZBCkmxusb7t96iVNvAMmzymRxKG3h+hTsL17FUZdsaIoXkuTPPYkgLL6gTqkjmfujj+XWEMMnnz23aolG/N2LEiBEjRowY29GK6nx1LuS+f4JX50K+cyNgqRw7b/uh/TtSa40XagJt4DW/BVXzronEiPnlWmuuLypCDLJdATW5RORDad0/MAwyss5XZyVfmTU4bT3kK7MGX7toMpWNy57EGA6x43YXaBUot00ouTQ3idGfNU/gBy6h/2jbe14QbYIEAq/rNqj2Z0pLEBLd3Ki2NtKtmn9BGDmaElYCAEMKQq2peT6OHUWrVRv+rvo0KIoY2DR65XoNPwxJND28rc2pFAKNbqYoQBBGEWQR35pQK6QQkUOu6YyyDINQ682+J0wDNwhZKJb70mi9p7Sm3swXbb1XcTud4d2oNny8MCRlWz2fD9NOxfWiS21Mo+fzfvLf6T1DSvxwq4/9eFup1Dra8YKQUGksQ+I35Ri5Etp0pvlfwjRRWrNYrPTt30681j0/qkNJpJftY6PaFiyldcfPWmtEM3Fcab3JnwakNDCkgd902Hbru68CDGng2Fv6rnWURh40vXyRkylAKU3rjpx2Go82ViPHTTK96UgTUUmhKCLYdlivrFNtbF3U08KwY9OtN6Pq225Ojttp+GFIECqMpgDa518QqubfIvkGSqGbMi5k8kxmC5Tr1U1nXwtKK2punYlsgXQy15SHIFQaLww7ZFP3fEKlMbbJX2/O+162wQ/CpnM/Gsf29zS673zvthPdsM3oPd2s59kum/Z+1LytueoFYcecgk471W3DlapTr6+hVL2DNyFcJtPRb4ZNB3Sk+1F9UQ0sFR/hBzWU0n311guCjnFr57vc8IaeixBd+qV1ZIsNKdFEhxcA95dv4wceqUQaQ5qRo9e0yDgZGp7LO7c/2NK/5rypNuqo5mFI2CPisnUY4geD16JBB6F+qDAMG8+tbMp469nWGto9btEB1pbcQq1595MPcH2PdCKDZViAQAqTVCKNH3jceHBjm053602xurHpAI5YFU29jfhwEg4b1RLr1WIHbzU3sm0tnTKkQLXxJkTzkMrz8dxlVOgjZQKQTbsjqfrROn3MXO0Z3bNaruOHGqfN3qyVHnH1kze5euct3r7xY7599VUa9U9Yr671XEMyyRxZZ4yaW+uw4a1DNKV8EoksUkae41G/N2LEiBEjRowYndivqM7PGlrfkWUXVquatSo0dJK1KqzWwNMWeUdQGLEe9HpNU6xrTIKeATWOFQXcrO8iWPago7Z3QhzV/WQjdtzuEhlZ5wtnDSa7Qt3HHMWd+auUauvb3rGbGyWNxjaMvs+kUKCjW7WBzU2jhmYqqkGoQlzfBWg6SwQp26Lu+diGJJ3s7Szqh0GbZ601ASZ5RzCds7CMKFoIoo3/pkOWyKHWSpdtOQU0AkPILQdvs30/DDGE2Oy723QWzuSzfWm03pNC4DTzRVvvZRL2wD6mkxa2YXQ4atoxTDuZhE2y6ZzphX7y3+m9UCkso9Ph0ou3yUyqox3bNDCkwA8VVlOOgsixBE2daf7nBgFSCKbzg4ueD+LVsa1Nh6chRcfYtDs2ZfPfWxAtx37zWYs/ASgVEqoQyzSRQmzTd0uahCqk7m3puxAC05CYUm62b5smUorNNPV2GrZp8v7dD3E9l0wygyENtBZY0sSx03iBx/V71zd1cZSx6dabUfVt2EOUhNlJwzKi9OpNB1/b/DMN2fxbJN+o5mkk46SVjJxsYdDUnS1IIQnCoHlQZG/K35AC2zA6ZOPYVvMQqVv+YnPe97INlmnQDMjejIZtvScQfed7t53ohhdE7wnJNtm096PdsW6bRsecgk47NciGt/OWTdq8fNrAxm06vbbqtgoBthHyztzb1D0fKcVAvW0ft3a+s0l76LlIkwchIlscKhU5fJs63R6daVs2Y+kcSSvBemWN71z9Ex6sLm7pX9NZXHMrrJaLZJKpDod4C0JY1BsljmV7H1Zt/V7/g1BfGSgdsLxya9t7Vpv8u8dNStEhN0MIFtaW+P711yhW10lYNmOpLAnLolTb4J2bb7JeWd2m073mVMsBnHUyWIaBRGAakQPY9T1uLdzcplOphNl0BKvNMZRtvEWliCNdDMMKy4+uEYY1pDAwrRSWaZF39MA0uomsg2VEByjdqNRLPFhZoFIvMZPPDlhDLKQQhCrosOGalh4phJCb3yajfm/EiBEjRowYMbaw31GdnyUIIcjICm4Ajc0EsOh7yw0gxGQqN7pz1A2ioAtJ7/3GTvcPHDXEUd1PPmLH7QiYygq+dtHsCHX/xWcT5Iw6C8XKNuOaSVhNx5Qkm7T7PnPMoCNdMtF0aGnAFJJMMsVKaY218joaTSMMyaeTTI9lWChWODWW4mQ+t6u+DNo8l10wCbk0LfncuROcm8yz4foorbBNg4QpccMwim/SkRMhY1tYZlTzUDbTPT0/IJswcYMQpRWVhkcuaZFNJtBas1JzmZ0a5+uXZ/vSUEpR9wIyCZOZsWzHeycLg/t8Mp/jVC7Vc2yGbedkIcfTU+OsNFOYu9voJ/+d3ivXPaazDqW6N5C3V86e6Ggnm7TJJSwqDZe8YzcdFtCKV1RKYxoSKaDmBRRSFl9/bnawnAbwOjOWIWFG9WGtZspva2yMlvON6JlpNF1QohmXpqNoPcuQSBlFcJmGQRjWWK8USSfSmFJ26LsUglQyioZdLK6glCIIFbYhySZsUnbkQJBCkE8lorqTOqr/2k4jn0qwVHzE9z/8MeV6lDqcctIkEwmErvPu7XdY2Xi0zYm6m7Hp1ptR9W3YQ5RCSnTQyCZtCmmHmh+gte6YfxnbipyiQmAZBumEGUUuA0HoRWUkTJN2t+2mc9wwCZVC6xCNpuYHjKcdskm7QzYzYxnGUsnN+d30qUfOWin62oaCk2jyIpCCjvekoO9877YT7VBaUaq7FBwLFeptsmnvx8xYZtPpmUnYHXOq204NsuHdYzqVFZy1H3IqDykbTAJSNpzOC372go0IyqxW6liGGKi37ePWzvfTxwpDz0WNxg8VjmViG5Ka65OyDepesCm7zejM26/zX97+Lv/5zT/m+t23WS2vEuhIppooWjtpm+RTCd65/QFe4OHYabY+IyRCJmj4LkHtAad2sMvQ/yB0OmtgqiXurixsmwvZpN133KINz5bcWvq2XHzEtTtv8d/e+x7ffv8HvP/JW7z/yRvcX1noqdO95tTi+hI//Oh1KrUNElaCXDqHbdqUakVe++g1tKpu06mZsQxZ26TuB6hmWYuEKbFNE9OIMmaSlsn0WHSo1qivU6/dplq9zQe33kCG8/zyc87ANLpXzpxgOuOwWqn3nA8brs9Tx/J8/fJs3zXEDdxmFLuNKeWmQ75lC0CiddMWDFjvYsSIEWOviCPCYnyWcBBRnZ8VaK2pqAwJExKbZ/rRN2nCAIOQpdLoNiRhRs5Z1cddNuj+gaOGOKr704HYcTsiukPdDUPyxTOTjKcdbiyuUm64zbRWl7nldc7k01ycnuTm0trAZ8XyPGHoAzYNX5GyDVJ2Asty8EOfq3euUXY91qsNTCl4ZnqCueU1xtMOXzw92ebAGx79Ns8TacFJa5GprMA0Jb/55ZdI2Sb3VktUXI+UZYCG9ZpLwjLIOwmWKzWWSzVyCYuxVIJ7qxuYhsHT41lMQ3JvZQNDSmYyDhXX5ebSGrmkzdevzGLbRl8aa9UGpiGZnchS9byO93bqs5Si79gM246Ugl+8MksuaW0bwxuLq33lv9N7E5kUv/rsKSYyg3kzTdnRTsX1mMmmMAzJg/UK42kHQwrqfojrB0RxfpHckpbJn7l0GtseHAE3iNe55XWePzVFLmlxb61zbIp1j6QV3SxfbLhU3YCkKTGkpB6EGFKQNA0qrk+x5pIwJRMZh/urG8wtzCF0AKJL302Hhu9yc/4jhBDU/AAhoOBYVFyP+fUKecdmIptifq1EwoxSi8uu10Fjfq1EzklQra3xX9/7Lt+5+n3euP4nLK1e5/07bzGR0pzJp5lbHn1seo35KPo27CGKEKKDxs2lNWbyGWzDYKlc7Zh/95v9zyUslstVHpXr5JM2Scvk9vIi65UiGScdpbaHUVkT2zRo+D4ZJ02pVuT28gJLG1VsQzKdz3Bzaa1DNnPL6zwzM4EpJcW6S6URReNZhjHQNsyvlxlPOyRMY9t7g+Z7t50oN1wCpSg3XO6tbDCWSvJnnjvNRDa1TTbt/ZhbXufi9MTm+LfPqW47NciG9xrTjKzzpy4Y/OxFg7P2A372osHPPmNxIm/wq5dOkXUS3F/dWW9b49bO961HxaHnYrnuIQUkLIN7qxvk0w5/+pmTZJ0E91Y2OmR3/eFDytUVlG7wYL3MmGNjSEEjCKl7PgLIO0nm10p4fplb999jo1pEI7GsNBpJsbLORvkOLx0zhl6Leh2Efu0Zi1+4PNPTFt1cWus7bvdXO+XWPRf8oEa5srKjTvebU3V3g2+++cf8yUd/wo+v/YjvfvB9/uu736NYXumpU1XP5+mJaO1bqzbQWpO2TCoNl/trZcaSNpdPHd9mfz5eeIDyN/iFy6cwjMGfaaYpN3Wqe0zvrZZI2Sa/8aWXsG2j7xpy7f59yvUSmWSKQKmo/JIVZQVUXQ8waTTKbNSKA9e7GDFixNgLlsqa79wIOiLCvjenDs2pEDuRYxw0Pm1RnY8TrbtBsgmYzHZecjuZAVt4m3eDjIJCSpB3BAFmz4CaQfcPHCXEUd2fHjwBZwRPDk7n01y6dIlvfXCbucUVFst1VKLBlVPHOX2uMOSzR9xdfMSFM8+TS+UoOCmkaXB/dZm35q6ysLaEFFHU10TSjG7ZnpnkFy6fp7Jwb2Tep7KCmTGDlUrIhx895PLsBQoOvPfe1hHfz10+z+3b53n1QYk7K0VqbkDCjjbFM/ks9VoVDyNK9bUlE4V8dDmZaVCrlDldyDKVy2CbBpVKmWK12X/TZ3ZqfCga2nd7vrensRmyndmpcX712VPcCyxuLa1ttXF6aqD8h3nvazNnduStu52KH3C6kNuU6a2HSyxVvWbNWIGvFDP5DH/lq69wJT2cMd6J1++8/nbfsVnfKLHaCPCCAAODlGUSKIUpJb4f1exs6e3JYxNN3fD56O47ffX9/soiuaS92U7dDxENj2dmJvjyiRznz5/n937wHncerTcje3vRMFhZX8fDIAiquH6I69mbfbp+/fqex2a/9C0j61w4a/DRUvSh0X6IYqpFprJjfWnkHKvv/Gv1XwDjtiSZSrGwUeHjBzcYS2XJp3PUvTpCK1LJJJaZIFQBC49ukbatqE0tQdNXNifHUpvjL5AkExbjGWdH2zC/vNL3vX7zfZudqLuklODizCS/8aUXmfBLZNp465BNVz/ax797TnXYqUE2vMeYRod7bKtj9fnTk7vW2158DzsXhRJ4geqQzS9auU36Ldn1mlO2lPhKgwS7Gandaqf2aIF7wSJ3F++yUa4zlnU4M+Hwv3rp6V2vRb1qfu1kiwaNW4fcBsyFnXR6pznlY5BJWAN1CiF4bmaShY0KDT+k5HoE0tiU99e+8Mqe1qVeOtU9pj93+TwweA0pVR4y5mRIJpJkkxZJxyKVyrBeC6n7DW4++AgnyY7rXYwYMWKMgopyeP1uiBcKHBN8PGwjyWpV4/vTLJU1J/KPl5/vzSmKdU3NP8HqXEghpXl2Kj6wirF/aEV1Bp+CqM7Hjfa7QaJLbtm85BY67wYZBUIILk1LFtdCyi441lZATT0Q2CYU1CpCTO5jr/YfO0d1azbcKKp7PHVITMYYCrEZ2GfMTo1zYXqSe6vrvPXeVT734hVO5nO8//57u3r2ygtZ0okM127McfnZC+ST53jzGZM3ryZ45flLTGezvPvhB3zuxSucmSigteLdPW6kujfPvfD505P85V/+Wd6+95A3r17jJ648x+fOnuLhxgZvvXeVl194HqEFb1+N+neqkGd+vbjZ3+6fW/3fDY1+7+2EQfIfFqfzaX7lhRd5UCxttjGM/Hd6b1jeerXTLtMrzz/HtfuPePv6x3zu8jP88pVnMAx4991396WPlR3G5sUrl1kuVnnrw+jZy6dP8s79B7x59do2vW3ne5C+d7fzE1ee45UzJ/jgg/d56fJ5fva5p3njk/s70ujWzc0+LezP2HRj1PeGOUTpR2PQ/Ot+dmJsjLfuzvPWR/Mcm7yM0jlqDZeUk+B4xmQiVeOcGOPlF36mp9x6yaZ7/Ie1DYPe242d+PxTpxFC8+677+4om0Hj389O7YcNgcjxvGe93eVcbJdNN/1Bc+qly88ilOCd69e72imNZAt3g4G2aIdx281cGKTTo7TTi7fWfOuW90HpVDuNnWTa6tOPr35CauIZ/NCiVm9gGBYXjtuMpzSndeZAxjhGjBgxtNY8CiZQEnJJgK2IMFNqHrkG1xcVM2OPJyKslVZsVTWOteVEjtKKFYU4rTjGPqEV1fmgbjbvhNjaf3dGdQ6+p+SziPa7Qewefm+FxGreDTIqprKCU9YiQXqWYn0roGYyLXh2SrJw6+jXsIijuj89iB23BwApBafHx1gtZDg9PjbSszMT0bOtUgwGXzh/Cru0wktPnwag+DBqQ0pB2PvuqwOBacotXs6fwjCMTb7PTuQBWGv2zzBkR3+7fx6FxqD3dsIg+Y/axrDy3+m9YXnr/r12mT59bJynj41zWtZ56aVnMAyDcATlGMTroLF5arLAU5MFEpWtZ/30tp3vgfre3c75Ux28dvAzgEa3brb3ab/GZic5DothDlF60Rg0/7Y/25Lpiy9mWK/Dhx/d5fIzF5jMGCiVJXw0WG7d9HuN/zC8DXpvd3ZCduj7INkMGv9Bdmo/bMg23kfU293NxU7ZdL/bl7fZMwA4tdVt7YxqC3eDQTQGjdtu5sIgnR61ne289bdhB6JTXTQG0dvs0xi8+FyyaQuiQ6N2W3AY3xsxPh3QWrNeZzPlfDITp2TG2EIr5XnMal5q25ayK4TAJNhMeR5LHiwv7WnF44nm5alNJ7JlQKmxlVb8uG+Ej/Hpw6clqvMwsHU3iINl9L4bZKp5N4hSo685GVnnxVnZ49tIsbDXTjwGxFHdnx7ENW5jxPiMIq7ddbg4SvLvlaoe49ONo6R/MY4OYlsQY78R32QdYye0pzz3wl5TnneD+LKoGI8brajOia67ZibTgi+cNcjIWNl6YTd3g+wHrSf12+jTUqs3RhxxGyPGZxJLZc1HSwHrNRXX7joE9JJ/3hGYcfpdjMeAx6F/cYRdjBgx+qWcP6oo1qqQDgqs1XS8YfyM43GkPA+LOK04xmHgSY/qPCzs5m6Qzyrao7pLDbAMja8Map7GV5FdjaO6nwzEEbf7gCBQvH57nh/dXeb12/MEQe/F/qhBKc39tQ3urFe4v7axpzSCGBEGRbEdFXm3LoBYqWpsAyw8bINm7a6w5+29cXTe3tEa/5sb8INbHo8qCtd3qTYquL7LSjXa4D6uKKTHoY/7oTfdfAaBGonvQf0NQ8W1hRI3NwTXFkqE4XA2fFCb+8V3N0aVabf+rVTU5vy3DFgsBdyqH+fqg3IHr3dXi9xbGY7vdhp/cK3xxETYHSX7ttO83I95O0jfHwf9GJ8N9LvJWmkIQthowMNgmlfnQr43p3p+e8T4bGAr5ZmeEWEBJvlmyvNBo5VWrOK04hiPGU9yVOdhYior+NpFk6/MGpy2HvKVWYOvzso4UrkNU1nBhLFOqKFYhwYOxXpkz2aPxbJ6UhAvO3vEG/dX+N0ff4M7K0Wq9Qb//uo8544V+M0vvcjEYTM3APeLVX747Tei27pXVnj1YYXZ6Um+/vz5faXTvSH+NEddDbqB9nHJeycMugCiX+2uODp072gf/8mxWTKqxno1cnoopTBKdVK2xUQ6+1gu4JhbWuNbH9zm/lqdjXKN11be51QhwRnT56V9orEfetM9b755axU3VCRMg1qlxKsPKzw9Nb4j34Pm3+0Nwes/WsFXJqE6xfKNgB/MLfO5MzbGiG0Ow/co839UmbbGe25xhcmxWfKigSUDjmVTuEFIcX2Dqushhc0fXF3j//rN/0bCNFhZX+NfvHUHAFuHA/lu0Xiw7jMx9hTJVQ9LNkiK4Ehf6rKf2Qfd691uowh3Wifax7H1fBj9b8cgfX84Av3Z6Ul+6YVZLkwf5S+eGIeBXinngTYo1iPnrSEg0CAErFY1fvPg8kT+cPmO8fjRSnleN/OUXHDMtjqf/v6mPO+E+LKoGDGePOzmbpDPIpbKmtWwgGlCPgX1ah0nlSZQMPfo6H2bx+iN2HG7B/zxh7f5t2/fxteCiYxDWmqkbXNzYYV/+M0f8OefO8FLLx02l9sxt7TGNz+aRybTzOQzSDdFLp3kg/klHqxt8JPHkts2gaNsSD9L6fiDbqB9dc7jx/dq1JQ7tLwPCjtdAOFYmg03qt01ntqKzvVCgWNu9SveZA2P9vl2evI4KWeM9WoJ1w8whMQyBNKQVF0PL9jAti3Wa+aBXcBxv1jlnbu3cJwpzk7n0Mc1QgrKtRLfffgxl5bWeObEsT3R2A+96bZTlQ2Lu+slNqoN8qkkZ7M2+XSSD+aXeb9R5dKl3nwPsnd3V1ymxp8mYdsIAnTQQNhJfGXx2p2AaUTPuTmozWvzS6wXi+TGxnbge3fzf1SZ3i9W+fHNd1ivNTg1cYyxdAG0T7nhUWm4eL6PZVkkTBPPdzFNh5VySMMr4vs+hqURGhoqAEFPvttpXDrzMqZMoJRL2QsohSHZjE8uYR+5S136yXQUJ/NeDyp2WpfPJTV3bq6yXmswPZZuez5Y/9vx1t0N7gfTmOZ2ff/hbY+PbpfRRrBL+ks8XC/xP3z1ldh5G6MD3SnnWms8bYGOIhoF0XNDgJOAR67xWA4uYxxNHJWU5/iyqBgxYnya0OvCRV+GpKzoO7zU0Efq2zxGf8SlEkZEECh+7/vvUvMCzkzkyCYTGFKSTSY4MzlGue7ynz86mLIJe0nrVErzR1fnKDV8LkyNN/kWZJMJLk5PsFat89r9lY70x6Wy5js3go60153S2kZJx39S0S8d0DIE2YRmo+YzPv7U0PI+SOx0AUR77a5WdK4XQG5bvyAk2mTFZRP6o3u+pe0koQI/CLCaO9dAaUwpcWwLzw8o1lxq7sGUW1FK8+5yyFj2HPl0AYHC96sIFPl0gZMzV/ivHy7sSR/3Q2+65ZZJ2CyUa4Sh4szkGIFSPCzXySQSXJgap9Tw+dbVuZ5p3f3s3YWpcRLJKRAmhvAjR4KI5oApAzQG9938trIJO7W5VA5wRYaLMycH8r2b+T+qTJXSvHZvhbVqnYvTE2QSDlJKDAnphI0baBQm6UQSUwpqnocUBqcnCmzUXUoNn+PZNMfH0nihYrFY4cLUeAff7TSePXGKpJUmCBqYhiRtWwRK8ahcA8GRutRlkExzichWtj5kd0K/9W51yPInO63Lq5Ua3/xontVKNI7dOtdP/9sRhoq37rkIYWL20PdQSQqFc8we3x39lh7/0Q70Y3z20J1y7itQGEgR6V5ragkRbSRNAor1yGkX47OJo5LyHF8WFSNGjE8L4gsXPz2IHbcj4u27D7mzUmQsYSFFpxilkExkHBbKdd6+97BvG6M4YCvK4btzId++EXLHO8W3b4R8+4Y/dO3AB+ulKF07leg5eWfyGeY3ajwoljbpvX43ZKWiEAKkDjfT2vptSPdzQ9ze5lGpQdiNToMIXqgJtYEXalw/pObWGUvnMYxUx3u95H3QaL8AQmuNF2qCJq9a647aXa3oXKcZndvNe7zJ2hnd8225VMILA2zTQgiBbNb7U019TtomDc/n1vKjA+Fnfr2ElT5J0kqglQubl28olHZJWDb1MMf82uj6uB960y23QGc4cXyW2ZmnkEKSSdqUGj7lhosQgslUgrmlNR6slwa20456YJJL5ai5NUKlEUgMaSOQCEAQIIwUHy9XhmrTMDKYiXN88Zmf4qee+2mc1FNYyXMkkgUyyURPvoed/6PK9EGxxHypxkw+04ywD9FaIYSJkA75TIFCtoBhpBBGCstMAoq656J1ZBP8MCTrjHH22ElCbVNueB18t9OQ0gQh0TpsMYfdjCZveMGBX+qilOKTVcVyMM4nqwql+h+AtMsU6LCFMLyTeRSnevd6Nr82eF3OOjaL5To5x47G28yTz5/DNPMD9b8dHy9W8JUZzfsuGkGoqHt18pkCbtiZiNWLfvfzE/ksc4urA+nH+Oyh+ybrll9fAGgINRhEtbYhiswNVRSpG+No4nF8ix+VOp8ZWeers7LDify1iyZT2TgiLUaMGE8O4gsXPz2ISyWMiJVKDT8MSVu9fd+ObRGEmtVy713foHqo/bBU1tzzTxKuR5EKIQY1F+77mrVqyPEholgrrkcjCEmZvas3OraFFyqqDX9rQwooBTUPQpL4dTAlBNrqmda223T8nbCbFNS93GQ+an3ClkHUWrBaBT+EUCfxqoAQaASGNFBiu8zb5f040LoAouw6TadMxKtfjW6ZFGKrdtdSeXB07jCbrL3WfNwtlFLcXWfTcXN+8vF+YHfTd73O+bZe2cDV68wUjlOul5sbEhVFHglwEimWN1apNEzg+L7z96gckkzm0Nrv9t1E/IcutpVmuRJwshD9227n1E5R3cPoTctOnZh8ikz2EkKYFMYANF7gMrfwMSsb7+IFkYMwYRrUg5CK6/Vsp5e901piSAMpJZaZxpAGQoIUoFEYuARSUa6HO7aZdAoknVMoLSk3yni+R8LMYhlpPnfx89xevE65VsQyDEKtN/nOODlSKY/lUsipQn+5jirTasPHC0NSduSdVKpOELjY9gSgCcIArTWGACkMxtJjFKtrbFQ3AMH0+HFefvpzjKXG0ECoFLYREAaP8MIHm3arRUPrALRCtNk6KQSh1gRKYSjjwC51ub6keP+BouGD0tMszCmSFoyrfM/fb8k0VFGaWLctTNnDfcjutN61O9XHkr3XfikkhplFmrWeNAwp8UNNPnuCdPophDRxUpH/VamAqUmLhfLSNv1vR6kRABL09g93rSNdSFgJQi2BTp1v0ZdNoyGlg+OMI6UDuDgJi8WNykD6MT576E45b9kvpaNvWCnAEh5gR/+OxJJRpG6Mo4fP4n0HkROZQ3cix4gRI8aoaGW/BPGFi0884iEaEZOZFJZh4AZhz+d1z8c0BBPZ7R80g+qh9qurp7XmnfkQV1tIog9gHSoMaRAoKDcg5PiOp9+ZhE3SNHDd/nzbhiSdtFivQ005qAA0UR0yhUIKA19BiGSlurUhbWE36fg7YTd1HUdxhrewlw/ShBnJp04CI+yUU6AETiJDEDS2otDa0C7vYbEX57QQgoyssBDkNy8HiaIuDRpBtJEalxWEmMQ29WZ0rt1jLHfaZC2VNdeXfFYqmrp3iqUbIRNpsA7oI/9RkOc/vtvpuHn9ruKFk48nsaAXfcvIMF04w6PFjwBIJUzevf0BhRd+hpyTperWCEONaZg4dpK62+DGgxv8b1/5ib50uqMKd+OctkwLQ2pCFSKN7XKJnDcOlhHp4yhzqj2qexS9gchOTRfOMDUxi5QGSoV4QYAhDWwrybOnrlCuNrDNyAnlBiGJhEHKsjtkk7L62zshVLQpS48jpYFGRRGpwkAIA2kkkUGDrGNs4627zUL+HEKYhEGdIIwMm0ATKpeEleD0sae4dvcd/DDEEIKMkyeZPIUWCS49dZZb62nKvuprb0aVaTppYRsGNc9nzDSbfHWmKXfKJHI8SimYLhzjZ579IlknRah8/CBECoNEMoMyk0zmljbtVouGZTYIVQPTTNJy/qlme4aQI13qMoy9exTkWbirNm2a1pEztO7DAz3D9SXF8yc6x9E2QWmxeVGSaIYBaiIHuB+C0GLHD9ndONX7rf1l1+TM1DM8mG/0bCNUihfOPcuxwiyiGdGsVIiUBlJaTE1dRpkJMgm7L5+5pAm4ILYzKoTANMzookSx3bEbKoVlCBJ2lmTyHFImsRMK05Ao1aBYeUjCNAbSj/HZRCvlPEjPNjMCNKGGhAHZJDRqkZ3QWhNgMuUICikRl904YojvO4gRI0aMJxPxhYufHsSlEkbEK2dPcG4yz4bro7oiWJRWrFbqzGQdXjlzouNZdz1UTVTzSwPZhO5bRmCtqlhpZuxaRrMmGDRTMqN/r2qHtR3S1k8Wcjw9Nc5Kzd1GQ2vNQrHCqbEUJ/M5XF/jY6J05ChupxltUgV1Dxp+ZzvtToZeGPZkZzcpqK0N8UpVd5R0WKmqHWvq7rU+Yd6J+gQSQ3TLKYq21VoQhp3RVN3yHgYtR1p7veHv3AiGLpWhtaaiMiTMaOMUITIDCSNy/FRUBq31ZnRu3Y90ur0ERGuTlW9usnrx+cPbIffXNTUXgmZ0+Pw63PNPDs3vsLi+pHgQzFD3I+ezIEQKqPvwxl3FoyC/r/QG0Y+koRCAF0pOHrtIIn0SrTUzYxnKlVW+e/VPWCmt4tgOE7kCjpVko1rkex/8CWnb55WzJ/rS+Q9v+bw6p3gQTPPqXPTz9aXhauKezKcxRXTJxrYR0JpQS2xDcjKf3pxTq7usU92hN0p1pKArNVhvWpgZy3Bi8jwg0TpAiGhehzokCH2kkLx4/grZZAKtNSs1l4snL/DDO8kO2fzwTpKLJy/0tHeOGUSRjoZBd4Sh1gqBxDIMLh5Ld8qwy4ZK6WAnsijlYxpbt14bUmBKgec3SCWypJIZKg2Pc8dnmMifRxqpyBlNSMI0Btqbdpn2stv9ZHoyn+NULsVCsbLJq2EmCMMGEB38WaYVRcjqkFJ1A9OwKWTGeOHcZTLJFKZpkU7mGMvkyWVyGIYJmDx98hlOjGW30fDcZVToI2UCtMALFelEEl8Z2CYcM1eHjloaxt4ppVgMjqM0WDI6GJREf1rNQ8L3H2wvm5BPajSiWTYmsuEKo5k9QfTvCPLJwbZqp/VOEdUUto3+tdALKYljJcjmz/Yc33Ld43OzryAQmweAoumA1TqKpD0xeZ6Zsf4f3c9MZ7BkgJCJbV5705A4tkOxsk7C6DxRbdG/dOI042NPI40USof4fhWlQ6SRwnFOceHEaU4WhlvHPgvQWvPP/tk/46d/+qf5whe+wO/8zu/guu5hs3UoaKWcf/WCwQlziTEHbKuZ3dC89KnsgknIpWkZRzUeMcT3HcSIESPGk4tW9otBlP3ih1sXLpZcdv1tHuPwEDtuR4RpSn7zyy+Rsk3urZYoN1wCpSg3XO6tbJBzEvzKs6cwu8JwWvVQpVas1WCtCnWdZK0a/d2QvevqrVSjjaHY7m4B0YwyQrJaHcy3lIJfvDJLLmlxc2mNcsMlVJpyw+XG4irjaYcvnp5ESkGjGUkko4KPPchGNcu603N3cjJsnewM5nXYuo5rVcX1RYWvLfwASnVokKRUB8+PSjz0q6m7Hx+kxXrLWRhFkijddMg3a7hFKqCZL3rb5D2dn+TlM09RbGyXVTdGdaT1kmk2AZNZwXgaHNFgPB39nE1s6Z8QomnIYakMqxWo6SSrlehnAT03WVprFvzjlBtRiY3IkaKiS0o0uNrinflw3z7ylYpSpDWip+NGaSLHzoB6l/tBXyEiB5AGjRH9qSMHy/lTl7m5tEbV83l6IothCNwwcsBIAQpNzfNJWga/8aWXttkNiKIK37ir9uScHk8LcqZP0kpSdT2CMCrTEISKqueTTDhM5UzG06Kvk2mnOtUdelOB1So0dJLVKixXQGi94+b8fhEMaaN0SKh0M602+v1QacIwJGk7BKS5ubTG0ycuknTO9JRN0jnD0ycubLN38+sephQoHaK13OxLVNtVoNEkTEHJ66ph3mVD675CCEkQBlRdj0zCwrGiCNRAaSypMaTBWsXDkJLLZ54DLMJmNH4yORbZqgD8ZvmZbrm2ZGqbUOr66Brk8JBS8MUzk4ynHW4srm7yGoYhQRjJCKKDmeiATjezOJLM5I+TsBOY0iRUIWEYgtZoLTFNm7HMOBuu2EajWF1lcelDGl4ZTwkyySw5J8VkRu7qUpdh7d3ddQgwo0OzrmkTHaJFUfB31zplWmxEnY8OT1uIfkdt/m3r9/phWKc60PdyCCkkhZRJLpXvuU6cOXaGVMJBawXIKCJcms2SFAZahxjS5n6xP5+GIfncmQRaBwTaQmmJlNGfgTIxpGJ9/Q5zy9u/CyYyKb707MskLJtyvdwssRFF6JfrZWzT5tTkUz3Lr3xW8S//5b/k3/27f8fv/u7v8q/+1b/ixz/+Mf/8n//zw2br0NCqW3rcXOennzKYTMuOS58m0oKT1mJcP/QIIr7vIEaMGDGebMQXLn46EJdK2AN+7vJ5bt8+z6sPStxZKVKru6SU4OLMJL/xpReZ8Ldf1OEG0f8a2NvS6r0wSs9EGz3KCLQ+lvp8GO3iW3d2apxfffYU9wKLW0trLJbrqESDK6en+IXL56ks3AMgaUabXo2MHFBtbUT708ip252e23IyrJt5Si445paToR5EqacFtYoQkwP5HDYFdaXadGwj0Wp7SQehIFAO63U4lu1sY7f1CXvBbZYYSNIAI40fsikz24CULSE0uTB1nJsL91gs10nkErz89GVyTg438Hl1hxT09kjt8UTEW8uRZhlQamw50gY5xNplKhDYBhgixDYEAoEhdf8yFgJEsxZri6deWKtpqtrpiAZvjw53A1ipRFHk+X2omnB3TdPwI10VXZ4bIcHQEGiTu+vw1MTe6fWiX/eha4a0/SxI2g4vnL3AzYefMJad5CfOvowQJpVGjVLVw7ZtTowfZ/bYJM+fGd9GYzOqUETOaCGiUpWGBKmj27pbzmkp+5/HCSE4m9pgQeQxawY1t0YjCHEMyDlZbBHwhXMOxXp/J1N3neruObUNzYOMTZEM4d2pepEeW0ZUizZQqlmLVUZKKKLcdi+QXDl1nFTqOWg67rfLRjB76jIztWsd9u7iybOMZZJ4jSq+SKK1gGZtViEUY0mJ7/eeC+02dH69SjIZIAVknQTHMikqlQp1HV3KpZsRlzP5FJaRxXHyIAwsQ2IZAq3CHcvPQBS1duGswUdL0fN2h4epFpnKjvWU5el8mkuXLvGtD25zf61KOqVJ2k5U21cKAhWgtUBh4CRz+KHHdD4TOQqBUDVLPzRLCcimcxdt4frRoLbTmFtcYXFllapyuTBzguMGfO3SFSYzBkopFnYc/d3Zu3qzrKrsq1ZRdHnVa5+T4PqasJklsZWVLTb/XwoItdzsYz8MXO/8Lae6F4qBl0Nkkha5ZKJjnWity5dOnef2msDAROvm4QIagUAIiWlEp6vdfezG586OcevuEiXzJGBimq3fDrh4zOApke35XfDTF2a59tDAtk3WRHRA4QYhCRmSdRJMpBOE2mK9phlPx463MAz5N//m3/C3//bf5qd+6qcA+Ot//a/zjW9843AZOyKYygpmxgxWKiEffvSQy7MXKDjw3nvxxnEv2EsZrUHYj7r1MWLEiBHjcJGRdV6clazX2Vx7d/NtHuPwETtu94jPn57kL//yz/L2vYe8efUaP3HlOT7/1GmE0Lz77rvbft82oktQaPsI2kyrF2w6/SyjcwM2mY4iN/2w6URt2xu1ovwkionOrN6+OJ1P8ysvvMiDYom33rvK5168wpmJAlor3m06bhOWwCREY0YbTrEVSdra6CYtSFqCbodyPyfDZFrw7JRk4dbOH+jD1nVkc/PeX6YhZnMD3on9+CDdLPotNIVU5EQrVxpk02lsQ+CHUcTYr37hWWreSX589RPk2CXAwLGgWqnuWOO4Fak9jCNt0IVvO8m0vYxFKxpZS5jKdPbLFLBSFj0vp1utRjpstiK1u8Teor9S1ZuRaHtB1Wul/ffepLQcOvUDujen4nbdlt3sc2uYoovHBF+6+DS/8sI0r16vYzp5Co5BqZGgWK6Qz2bIJZOslBs9ZdqKKjRbUYVtj3frnM7IOl95OsH1RYvlikWtniTlJDiWMbDKt5jKFliujH4DaYfeZKP5V6k0yGTSWBIelejZx3akbdF0nklsyyTUiiAIME0TQ0j8UBEqzS+9cJaJdIrvzoWDZSNt/vRLn8OUlU17l0mO8b25ABlIpnM2VS+gXKmTzThkEhZBCBu+37ekS8uGzq+XmmNaYDxtIBAErsHxXI66F7Be8Tg+ZvG//+rPc/VhmbfuR6UJEmbTZabCTVsVqq3yM70OikZ1eMxOjXNhepI7j9b59g0DpBkd1ghAC0zLIggVgRJkkyn+9Nde4dXbCqUCUomopk8QNuUvJWEIgYZGsJ3GvdX1TRmfzOd4//33dn2py27sndMsq6o09L5yM9KltN3ZTpRREjluLTPKDgjDEMMwkZJmH2VHH/thGKf6RmPnyyHa14n2dfn2is/tNQWIaO5tRvNHB26tCOHUDqXSl8oalZgin0igdUi1ViOdSiFFgg0XCrlJfuWli9u+CxY2Qj58WCWbtMil8tQ9n41SmbFcFse20Dqyg7HjJsLNmzdZX1/n53/+5zf/7dd+7df4tV/7tUPk6mihFYHbuvQpxt6wlzsedsJ+1K2PESNGjBiHj/jCxScbcamEfYBpSr5w/hQ/ffY4Xzi/vTxCP3QHLDaDWHvGy4ynJZPp6Be2peM3d20pUd/VB7CUgtPjY5wrZDg9PobsClkqOJCWdWwz2lBqvRVJahlgEHAs079W5VRW8LWLJl+ZNThtPeQrswZfu2gOnQo3bAqqZTQvl+lTRiJyOIueG/Bh6xMO+iBtFf0OmucgtiEwm1GswGZpiPG04FQhh+mcAgxySTF0CrobjO5I6+B1F2Us2tPjpJQd/ZJyiPS4ARFwO/zCrtBy8vVrr+VUdQ783hw9uEtCkHFyGFaaXNLAMCT5lEPBscmnnIEy3SmqcLfO6ams4Gefsfj5Z2yeTi7y88/Y/KnZrVSZ1mGEGuEG0g69EZHebEZ1D5lWeXZckLS27I0hJIaILrhq2SFLhLxyOk3dF8PJxu+0dxMZuTlvBZBNWKQtTTZhIRBDlXSRUnBmYoxzqQ3SCYOyKzbLGAQhBMrEMTSfO5PEsgxyTjqKkJS9DX2/8jMdv9Pl8Bj2o0tKQTaVw27W3m2V8tC0DhckUmhsU0Z2T0TRnIaQGHJL/ugte5s0t9MYtKYMi93Yu7MFMAmi/nT9ektXklakU+1ImlvyRm+Vu5HNg5d+feyHXuvdV2fl5pxqXycG2d7x9HYZZhPQspubDlvRzBJptiGAXJ+skBaNVhRzLgF5xyRjafKOSS4pNtceIdhGv32dFAgcKyoH4ljRXAlVVNM5dtxEmJ+fZ2xsjLfffps/+2f/LF/96lf5B//gH+B5B3R6GOMzjf0oozUIo9ZYjxEjRowYMWLsH+LP7McML4wcjUGom1GynVGska8vxA+3Rxm9fNpg9cM6CqfpuJWbt2FnEnA8XEaIwr7xupkCaudxA3AsqNUapJJROQApgh1rVY7qZOigv0MKaqtkQ6hFz2jkKHZZ9dyAb32QOs0o5/Z3h7vluFX0e3EtKvrtWP1LQ6zV9MDSDP0iZzejekdwpA0t0y5evUCPFI08kW4+0zLKaO+QadPpJmkeROwdLSdfzesRja6adYYJOFs4GHM3nmoF2fbWv+bfmEiNHuG9U1ThKM7pQRFPe7mBdD+i2KWUvHBS8tonIf5m+ZNIz8Omk23aWEbKczi22pTBbmSzm3m7E4YtYzBq+Zn9gheAEJq8A1VvK8NDNcu6oFwEJgiBY0O5ETnrDLHl4G3JX+qAhHUwpyG7sXdSSqbNZRbUqZ66ItC8cFIiZVTbd5OGJbAIUMLYtz4OmlN70bdASQw8QuRm2ZGOP5sy81VXyHkb9pK1sdM6WfOjbJrPkuOm0WiwtLTU81m5XKbRaPC7v/u7/J2/83dQSvH3/t7fQynF7/zO7+yKTrvOHjRatNppdv/bYT37rNPv90xrzbWFkBCDgk3zQCfK0Mva0cUzj4IJgmBr3o9C/5i5yrqRp9SIDrO0Bi/Q1IPoW/yZYxql1JGT22HTP8q8HTb9o8zbYdM/yrwdNv2YtyeT/lHmbdDvPg7shlbsuH3MSJjR/0LPQxrmtnqoSQvqddXTATeVFZy1H+Jnnma1Bo1GQNI2mExHG8Jhyg/sFp0OCYUWBhqYzAjMcv+6igdDv18KauS4q7r0dIYLog/LhLV9Uzmsc3gnh3Or6HeQnqVY718aYienVr/I2b040oaVaTevo6bHjacEKVGnprN9SmwIJtNRFPl+XBi2GyffQcCxJY4dUvPo61SxCEjaUR7zKDLdiiq0kergndN7cTLtV1rlpSnJ/P0F1uQpGn504ZvSkLLhygmJu1AE9iabYeftMBimjMFeys/sB1pjY0iYyAi8QEdlLNJpbAPWNqJnk+lIBvWGwpQQqC0HryVBSrCDOgVnQF2WPWC39u6YWeTUzBnef6A6dMWxYFwtcGnq3HYaDqRkHc9MoNTj6eOo+mabYIsA07aoeZFOt3JMDAGGdknZyYFzai9ZGzsd+CVMuDxjfKZS7t577z3+0l/6Sz2f/dN/+k9pNBr83b/7d/nCF74AwG/91m/xN//m3+S3f/u3B9Yh78bVq1f3hd/doJ1mN/3DfPZZp9/rWV0lWPRPYRJSrmzdq1EqR38PtcQnwRvv38SR7sj0MxLwb/EomKDkJtDYlKp1ksJl2lpl6U6dpT5tHmT/h3l22PSPMm+HTf8o83bY9I8yb4dNP+btyaR/lHnb6XePCmLH7WNGa0NarUsKTlQnsFU31JJQdgc74DKyzosXjGZh6QdcvnjwhaUP+yKJnegXUoJjGUHDDTANg6DLGS7E4A34qJf+9Gpnp6Lfu6kx2479jA7sJ9NuXkeNRhZCMGMts2xkqXp0RocDCVxePp3Z103+sE6+g0AhJZjOCu6u+iCsbU4VywBH1Sg4UbriKDLdKarwIJzTozqZ9iOKvYVjZpGfe+EMd9fh5icPufDUKc5PGmitebepqHuVzX4W69+pbmOr/IxnJprzt7P8TKACjmXMoWQzCjrHho4yFu1jM56WXJrWLK75WKZNSkK91sBJpgmadrXA8PZmtxjF3l2akjw3bXB7JdzUlbMFeP/9Yl8arYwSL4SUeDx9HEXfWuOmhMN0Liq/U6s1SKUcHBNWymymKvfTm71mbQw68Ls8YzCV+2xV3vriF7/Ixx9/3PPZ66+/DsD58+c3/+2pp57CdV3W1taYnBxep65cuYJhGHtjdkiEYcjVq1e5cuUKwObfDcM41GefdfqDnj2qSh7eDlFuiVw2B0RO21w2hxCRPVgtNzhz/gLTWbEn+j/14ixSSlYrIddv3ubShfPkHYcPPpg/knI7bPpHmbfDpn+UeTts+keZt8OmH/P2ZNI/yrzt9LuPAy36wyB23D5mtG9IK14UEWQQIoCyJ7BNvaMD7jAKSx/2RRLDpaAGmDJBqr2kg4o2rDttwPfLOb3T2Ozk1BoUObuf0YFbvPYvY7GXaOSMrHPhvMH1RcVKVW9Gh0+kwKo8ZCr7zK54HQbDOPkOAlv652HaFkJEabTJpIOmqX/elv6NKtN+UYUH6Zwexcm0X1HsLUgpeWoCNu6v8dTEmW0p77B32Twum7of5Wf2hf4QY9Ntb1Qr2yIteXZKHEiGRztGsXeRruhNXdkJ3Rklj6uPu9W39nGreALH1PjCxzYcKt5wc2o/sjb6Hfh9liJth8Fzzz2HZVl89NFHfOlLXwLg1q1bpNNp8vn8rtoyDOOxbR7aafajfxjPPuv0Bz1zbIEhQwI6539UB1sQao1A49gGRvPehb3Sn8xG342TWXPge4ctm8Omf5R5O2z6R5m3w6Z/lHk7bPoxb08m/aPM27C/e1QQO24PAfvtgIvRJtNMJNNWSYdjmeE34I/DOb2bGrO9sJ/RgcNgL9HI0Sbfam7yo+jwg47UHsbJdxDo1j8hotvfC6nt+rcXmfaKKjxo5/QoTs39imLfDQ5DNqPgSSg/0/67j9Pe9OL1oOkPk31wFLDXObVfWRt7qVv/WUEmk+HXf/3X+ft//+/zj/7RP0JrzT/5J/+EP/fn/hymGX92x9g/7GcZrRgxYsSIESPG0cVnK7dtD1BKc39tgzvrFe6vbew5jTUj63z5vODisRpW4xYXj9X48nmJ55d2TWO/eduJxt3VIvdWRqPX3s6tR2v8/97+mP/04T2++e7HeN7eHGwZWeers7LjVu8vn5fcffSAH91d5vXb8wRB/5qq+9HHYcYiI+t84WxUm9gL2XLcp+Bcoc7KxqNt77a3e29tg0qtxOrGMtVGiTDsz3cQqJF0o52e55f46qyxKdefOSdw5ALv37+7o0zbN/k5W/PGJ1tjUav5fPPd/Rv//UT3OHpeyOu35wfqUS/9+9pFk6nsdsdG9w303TL1vLDvuEXOaclxc42nJqLL+YaZU/tlJ4ZtZ6c+NhpBX5mOzqvAFGVq5XuYokwQ6JFotD/7ZGWd1+YGj/1eZfOVWYOvzkoycneHGp4XDj2HBs3pQfS7HXVh2F+mgzDqmO7GUTjIhg+yhYNoPO71dZAudo/bl89Lzo9XNteMQXZKKY3nlzAan5C0/KHXnhij4bd+67f4yle+wl/7a3+Nv/bX/hpf/vKX+Vt/628dNlsxPmVoHcgYRAcyfrh1IFNyo/Jcx8zV+IAlRowYMWLEeMIRH/0PgZuLq/zh+3PMLa6wuLLCqw8rzE5P8vXnz+/8ch/cL1b54Xfe5NbSGosrK/zRzTu4oSJhGtQqJV59WOHpqXHOmD4vDWhnbmmNb31we195G0Tj9sIi/+KtOwDYOtwVvfZ23rl9j6U/eg8vCEDD71+9xz/+gx/xV7/6ClfSo/PaHh34zief8Hs/eI87j9ap1hv8+6vznDtW4De/9CITB9DH+8UqP/z2G5tjOui97iivXOE4P7zRqWOt8c8M4O2bt1Y39WZlfa3vs93o1KB+fPTgHv/i9Q+4s1LcUabteOP+Cr/7429svvcv3rhF3Q/QSqO1jsY/+yN+6eljvPTSIO4OHt1z6vevLfBwo4Lrh3ieF/V5Ms9XTuboZnU30aktZ1G3TP+nd++SsExO5LMIvzFw3IadU3l/eN3cjWx2aqdfH//1W5/gK4UlJSoMO2SamdlOYxRbOGjcBtFon2/X7j1g9bvXcIMAofTQNmQYvvca4f9fPprn//Cf3+FRuYofhANt6KBx2w39P/7w9nab2mcu7ER/mDHdDQbZ8IOwhfuFQbLJDBi3YukR/+HHxU3edqPv05OLzM6cYMqAp06c6bv2DJJNjMGwbZvf/u3f5rd/+7cPm5UYn3LEWXwxYsSIESPGpx+x43YH3Fxc5V9/723WqnWmx9JIN0UuneSD+SUerG3wk8eSu97czC2t8c2P5pHJNDP5DJUNi7vrJTaqDfKpJGezNvl0kg/ml3m/UeXSpTWeOXFsWzv3i1V+fPMd1muNfeNtEI2kZVCqB4SGRmhoqAAEQ9Frb2e9WmN+o06owRAghMaSksVihX/8Bz/iL1w5vWfn3Rv3V/j9a+9TqbuMZxzSUiNtm5sLK/zDb/6AP//ciU1Hw370sXtMhxmLluOmWHrEH96632Mcl/nRRpHCvQ2U1tt4K/keG8E6ddfHsU1838ewtj/bjU4N6sdrc/f56MESSIOJHWTajj/+8Db/9u3b+FowkXFwGw1W6h5KawSQtiSWabK4UeF/frfKqdPv8ZtfeWUvwz8yuufU4iO4trBCwwtwLIvxpEUyaXNjcZVPllY4f/42X3/hwsj0umVjqoCiF7JebVCsNnj+eLbvuA07p/4v3/wBZ3IO52aOD62bw8hm2Ha6+6h8j0d1Dz8MsaTkeNom25TpjYfL/GChTDphb5sLu7GFg8ZtEI32+eYFAQ826gSAKWXz4ia5ow3ZDd+j4v/5w/f4n9+9Q6A0KdsiKQVaGj1t6H6tE/1s6k5z4XHIZpANPwhbeBDr6yBd7B63a/NLrBeL5MbGmMlnRtL3q/fu8cONIoW78z1oHIzexogR42Bw2GVtYsSIESNGjBgHi7hUwgAopfnD9+dYq9a5OD1BNpnAkIJsMsHF6QnWqnVeu7+y61IBf3R1jlLD58LUOJmEzUK5RhgqzkyOESjFw3KdTCLBhalxSg2fb12d20ZDKc1r91b2lbdevLZoXJgaZ6FYwQtDprJpjo+l8ULFYrHChanxgfTa23n6WJ5r8yuEWuNYBgnLBAQKGE8ncf2A/3T9/p7S5oNA8c3r85TrLmcmx5qykWSTCc5MjlGuu/znj6I00v3oY/eY7mYsBo3j7PEC94o1biyuMHu80MHbsVyKkuuzUXM5PZ5jo+5Savgc73p2ZmJ3OtWvH7PHC3wwv0Sp4XNmPDdQpt1j8Xvff5eaF3BmIkfKMllv+GitMQUIwA01jm0ynk7iBSH/j++9fShlE7rHIm1b3FotE4SK8XQSIaDiBWSSCc5M5Kh5Af/2B+8OnSrejW7ZZBI2VT8EEc2FIFTMrZZJ2/a2cRt2ThVSCRpewO21MucnCyPbiVHtTXcf07ZFsTn+KctEa1iv+2QSNqfHs2w0PD6cX2b2eKf+7cYWDhq3QTTa59vTx/J8vLBKoBR5J0E2aaM0uH7ImYn+NqRbNoP4HhWeF/Kvvvs2XhAynk6Ssi0MKUnZ1jYbul/rxECbOmAuPA7ZDLLhB2ELD2J9HWT7u+lfmBrnxuIq94pVZo+P74u+96Kx33obI0aMg0VcfzpGjBgxYsT49CJ23A7Ag/USt5ZWOVHIbvsAEkIwk88wv1HjQbG0yzbXmEwlEEJQbniUXJ9MMoEUkkzSptTwKTdchBBMphLMLa3xYL2TxoNiiflSjZl8Zt9428ZrG41yw2O9WidlmdFttQhSlslatU654Q2k197OrUfrVD0PUwikkAgEUgqCUDVvgTdZr/l869rcyHy/fe8hi5U6ExkHKTpVXArJRMZhoVzn7XsP96WP3WPajp3GYtA4VlwfpTWhUixsVDp48wOF1qC0puJFjjCtNX4YdjzzQjW8Tg3ox8JGBTcIkQJ81emc6ZZpx1jcfcidlSJjCQspJOs1l0BppIhqtUopCJXGC0KkkDimwXKpyrc+HH38R0X3WCxsVCh7AY5lIqXENg3cQOEFAVJIxhIWnzwq8vbdhzs33gPdsvGCEDdQJAwDKSWObVJxAxY2ytvGbdg5FSiNlAI/1NxeWe+gvxs7Maq96e5jxfXxQoUpJVJKTEPihYqy6xGEGkMIGn7A4kZlG41hbeGgcRtEo32+3Xq0zkatQcI0NmVqGZK6H+CFqq8N6SWbfnyPim99OMejchWnyVs7pJQdNnS/1omdbGq/ufA4ZDPIhh+ELTyI9XWQ7S83vI5n5YZHqHVk+11vX/S9m8ZB6G2MGDFixIgRI0aMGDFGQ+y4HYCK69EIQlK21fO5Y1t4oaLa8HfdZsI0APCCkFBpLCMaCsswCHXkyAJImAZuEFJxOzdW1YaPF+4vb91op+GHIUGoMOTWBtNoOd3CcCC99nYqDQ+toa0ZBKCb/yVME6U1i8XKtnaGxWq5jh9qnAGyCULNarm+L33sHtNe9IaRTTdaOiAQ1Dy/g7dQ6+YzTRCq5t80odIdz0KthtapQf2oez5aR2MV9ojAapdpO1YqNfwwJGFG+u2HIZqoHYgcBJrIsQJgNuW9UCxvF+QBo3ssam6A0ltz05AC1ZQxgG1K/DBkpVIbiV63bFrOGNl04liGgdKauhcAneM27JxqtaeBSpdzBoa3E6Pam+4+Bko1eYqeG1KgdaTDodYIEelCzdvOz7C2cNC4DaLRPt/KDY9QaYw2mUoR3dIdatXXhvRCP75HxUKxTKg0puwdTdVuQ/drndjJpvabC49DNoNs+EHYQtj/9bUb7brohZ3ZB37bz14Q7ou+d9OA/dfbGDFixIgR46hDa81aTVNWKdZqUVBMjBgxYhwFHAnHred5/Oqv/iqvvfbaYbPSgUzCJmkaPZ0IEDmzbEOSTvbelA5q021ummzTwJACP4yiGP0wxBACu7lhdJubx0zC7mgnnbSwjf3lrRvtNCzDwDRkh9MuVBpDCmzDGEivvZ1M0m5uJLeeR4686D83CJBCMJ3PjMz3RNbBMgT1AbIxDcFE1tmXPnaPaS96w8imGy0d0ER1LNt5M5rOPY3ANGTzbwJDio5nhpBD69Sgfji2hRDRWBk9HEbtMm3HZCaFZUQRYBA5IyOnYgTdrHPbclYGTXnP5LPbBXnA6B6LVMJEiq25GSqNbMoYwAsiR9BkJjUSvW7ZGEIghdh0YvthiBQCx45KkbeP27BzqtWeADJJm24MaydGtTfdfTSlbPIUPQ+VRohIhw0hmg5o0dOZNawtHDRug2i0z7ds0o4ObdpkqnR00GAI2deG9EI/vkfFTD6LIQVBnxT2dhu6X+vETja131x4HLIZZMMPwhbC/q+v3WjXRdvodB5bbT/bprEv+t5NA/Zfb2PEiBEjRoyjjKWy5js3Al6dC7nvn+DVuZDvzSkqytn55RgxYsQ4YBy649Z1Xf7m3/yb3Lx587BZ2YaThRxPT03wcL287cRNa81CscKpsRQn87ldtjnOSs1F68hBkEtYVBouSisqDY9c0iKbTKC1ZqXmMjs1zslCJ42T+RyncikWipV9420br200skmbQtqh5gdRWj6amh8wnnbIJu2B9NrbefpYgbRtE2iN0iqKClQa05BIATUvoJCy+PpzsyPz/cqZE0xnHFYrdZTuqrmoFauVOjNZh1fOnNiXPnaPaTt2GotB45hJWEghMKRkZizTwZtlSoSINuQZ24pKOwiBZRgdz2xDDq9TA/oxM5YhYRooDZbsNBvdMu0Yi7MnODeZZ8P1UVpRSCUwZeS4UyqqD2rIyJGitKIehBzPpfn65dHHf1R0j8XMWIasbVL3A5RSeEEUOWqbJkorNlyfp47leeXsiZ0b74Fu2dimQcKUuGGIUoq6F5BJmMyMZbeN27BzypQCpTSWITg/Weigvxs7Maq96e5jJmFhGzKKvFWKIFTYhiSbsDENQag1SctkeiyzjcawtnDQuA2i0T7fnj5WYCyVxA3CTZn6ocKxTGxD9rUhvWTTj+9R8fXLsxzLpqk3eWuHUqrDhu7XOrGTTe03Fx6HbAbZ8IOwhQexvg6y/dmuA5ds0t485Mkk7H3R924aB6G3MWLEiBEjxlFFRTm8fjdkpaqxDbDwsA1YrWrm/WmWynHkbYwYMQ4Xh+q4nZub49d//de5d+/eYbLRF1IKfumFWcbTDjcWVyk3XEKlKTdcbiyuMp52+OLpSWSflNV+bf7ilVlySYubS2tUXI+ZbArDkNxb2YicdBmHiutyc2mNXNLm61dmt9GQUvDFM5P7ylsvXls0bi6tMZPPYBsGS+UqSxtVbEMync9wc2ltIL32dm49KvLcqUkMIaj7Ia4fABoJrFUbJC2TP3PpNLbdO0V1GJim5FcvnSLrJLi3skG54RIoRbnhcm9lg5yT4FeePYVpyn3pY/eY7mYsBo3j3PI6Z/JpLk5PMre83sHbcqlGLmExlkpwf61EzkmQS1gsdz27t7o7nerXj7nldZ4/NUUuaXFvrTRQpt1j8ZtffomUbXJvtUTND8gnI0dzoKPI0EQzkm+t2sA2Df7KV1/Z0/iPiu6xqHo+T09kMQ3JWrWB1pq0ZVJpuNxbLZGyTX7jSy9t6/Ow6JZNxfVIWQboaC6YhmR2IkvV87aN27Bzar3m4tgm58ez3F5ZH9lOjGpvuvtY9XzGmuNf8wOEgIJjUXE97q+VGUvaXD51nLnlTv3bjS0cNG6DaLTPt1uPijwzM4EpJcW6S7nuIQUkLIN7q/1tSLdsBvE9Kmzb4K/+qVewTYO1aoOa5xEqRc3zttnQ/VonBtrUAXPhcchmkA0/CFt4EOvrINvfTf/m0hoXpyc4k08zt7y2L/rei8Z+622MGDFixIhxFKG15lEwgRdALgGWIRAi+jObgBCD64sqLpsQI0aMQ4V5mMRff/11vvjFL/I3/sbf4KWXXjpMVvriwvQE/8NXX+EP359jbnGFxXIdlWhw5fQUv3D5PJWF3TudZ6fG+dVnT3EvsLi1tEbFDzhdyDGVy2CbBpVKmWK1wZVTxzlt+sxOjfds53Q+zaVLl/jWB7f3jbedaOQcC48o3d3WEjRD0etu59RYiqWqhx8EKC3wlWImn+GvfPUVrqT3vjB+/vQk58+f5/d+8B53Hq1Tq7uklODizCS/8aUXmfC3LlzZjz52j+luxqLvOJ46zulzhf682ZKJQh4vjKI1V9bX+z4bVqd26sd3Xn+bVx+UuLNSHCjTdvzc5fPcvn1+8z2lIefY1P0ArTRuqFEiZCaf4RfPH+O//5kXhx3mfUf3WCAEz81MsrBRoeGHlFyPQBo8MzPBl0/k+LnL5/dEr1s2NTcgYUeOppl8Fu27fcdtN3Mq71dG0s1Bshm2ne4+uoEil7QJVHRJWd0PEQ1vU6Zf+8IrvefCLmzhTuPWl0bXfDs5lmK1EeAFAUIJvEANZUOG5XtU/Pc/8yLz9+/zh7ce8ahcxQ9CLNPoaUP3a53oZ1N3mguPQzYDbfgB2cKDWF8H6WI3/evXr2/ytl/6ftB6GyNGjBgxYhw1rNehoROMWc27N5oOWq01vgKhFStVzVpVkY+rJsSIEeOQcKiO27/4F//intsIe1yqsd84fyzP/+5rn+P+apF3PviQl5+/zOmJPForri508tD6e/ef3f92Op/mly4/z8NiebPNk4UxHqxvbP58Ip/lww8/GNjmU5Nj+87bTjRevPwcaHjv2rVd0etsJ8PlS89yff4R73x8k5efvcgvXbmAYcDVq1f3he8/9exZvvrMOd785AFvX7vOK89d4ieeOokQehuN/ehjrzEdTTad478Tb+16M+jZMDq1Uz8qpyf5S1//Ku/cW9xRpu1tfr7Hey+cnOa/Xb/FOx/d4OVnL/ILz53n44+vDeRtN+O/X/r+8vOXmRnL8fbdh5u8v3xmmuvXP9wX+r1k88rZEyxslHYct93MqVF1cz/sTa8+vnR6hnfvL2yT6aC5sF/jtpv5duW5SyxvVHnn+ke7siHDzrdR9eaXnz3F//HPfJ3/eu325hzqZ0P3a53oZVOHmQuPQza7sZP7YQsPan0dpIsdtrgHb/uh76OOzUHicdGJESNGjBifPXhB886QtqShQBus1cAPISSB58KP74S8fOrQq0zGiBHjM4pDddzuB65evfpY6Z0rZFh/cJf1B3d78tDNz6BnH374QVeb3TR21+Z+8jaIxsbDe3umd66Qobo4zxkTzlw+AzS4dq33u3vlOwn89NnjUF3lgw9WD7SP28d0NNn0G//evA33bFid2qkf169/uGuZ9nrvxo1Vzhhb4//xx9eG4m2/dXrQs3a5tfN+/frqvtLvls21a6vb6O/U5k5zaj90cy/2pruPH3202lemWkfRDxNjx3l4f5G1+bsIcTDjttN8Ky/cx2H3NmQ3821Uvfn442sdc2gYG7of47+XufA4ZPO4bOFB2pv+z7bo9/qG2Ku+jzo2MWLEiPFph9aatZqmrFKs1TSFOPryUwHbBIEmUGBLcAONqxOIEKJqQVH5sVJD8/rdkEJ8WVmMGDEOAU+84/bKlSsYPW5EPgiEYcjVq1c3abb/DByZZ4dN/yjzdtj0jzJvh03/KPN22PSPMm/7TWPq3PN8/EiwXtPUGw2cZJK8A1blFj/14uwTJZujzNth0z/KvB02/aPMW6+fDxotejFixIhxWFgqaz5aClivKWr+CVbnQvKOwIydeE88Cg4khUvddzClouI2I3AFCAEgsE3IO1BuwKNgAq01QsQ14GPEiPH48MQ7bg3DeGyO2340u/9+2M8Om/5R5u2w6R9l3g6b/lHmbdDvSik3IzA2XLkZgXEUeHvS6FeUw/158EJwTAjwSJjJKF3Nn2alJjmRf3Jkc5R5O2z6R5m3w6Z/lHkb9HOMGP2gtWa9zmak4mQmvuQnxpODinJ4/W6IFwocE3w8bCPJalXj+9MslTUn8ofNZYxRIYTgmLnKupmn2Ii+QUEBBoGKonEzCZBC4liKDTfBeh3GU4fMeIwYMT5TeOIdtzFixKlLMQ4LcQTG/qF1q6+SkEsCbN3qa0rNIze61XdmLN7wx4gRI8aTgopy+N6coljXm+tkIaV5diqOVotx9BF/m3w2kJF1Lpw1eGdeUfM0GonSYBsgtEvCtAAwZBSN6wWHzHCMGDE+c4gdt58xfNqcnEfBcfZpk2mM4RBHYOwv+t3qC9HPJgHFuma9phlLHiKjMWLEiBFjKCyVNfP+NFZV41hb6+RKVfP6XRXXioxx5BF/m3x2MJUV/OQ5g//2cYDfcMmlU9gGbJTaLhttRuDasQclRowYjxmx2XlCsB/OwaPg5NxPHAXH2adNpi3EaY2DEUdg7D963erbDokiVODGUQ4xYsSIceShteb6oiLEYDwRObla66RlQCmuFRnjCUD8bfLZwnhaMpkWPHAllgTYsk1aa+p+VA+34GQOjccYMWJ8NnFkHLcff/zxYbNwZLEfzsGj4OTcTxwFx9luZfqkOEPjtMad0R6BAeCFmkAbeKHGksQRGCOg+1bfbiiij+jEkVm1YsSIESNGP6zXNMW6xiTY5pgVQuBYOq4VGePII/42+WxBCMGlacniWkjZBcfSaA1+qKkH0SVlBbWKEJOHzWqMGDE+Y+hzfhjjoNAdOduectMLLefgSlVjG2DhYRuwWo3Sz5bKOzv/Wk5OL4BcInJutpyc2QSERE7Odl52y+fjRstx5jRTl9rRnbp0ENitTFvO0FfnQu77J3h1LuQ7N4Khxm8/ed5pTFtpjatd+halNYZUnvBI4v1CKwIjVNFcXKtCQydZq8JaDbQW+xaBsV9z8ajP6a1bfdnGm9aaAJO8Iyikjs4Bwm5ketjyP2z6u4FSik9WFcvBOJ+sKpRSh81SjBgxdgk3iNKKJb3nb1wrMsaTgCfx2yTG3jCVFZyyFplIC7wQfGy8ECbTgi+cNcjI+mGzGCNGjM8g4vPBx4jdRs7uV1TpbuszPQkRl4edurQbmTb8yBlqVjSWAUKHCOBRRVFq8FhqvFWUw3dvhqzWoOGdZOlGyGRacWl6S4BxWuPwsE1QWlCsgwakAIFCCAMvBEUSQ+89AmO/5uKTMKfbb/UtueCYbVEOPpiEXJqWR0b3diPTXrb/ccp/qay5vuizUtV95/9RwfUlxfsPFA0flJ5mYU6RtGBc5bf97qhZDE9K9kOMGE8yEmbknA36xIjEtSJjPAl40r5NYuwPMrLOi7OS9Tp8+NFDLs9eYDJjoJRi4bCZixEjxmcS8efSPkApxd11NqODzk9uX7xHKVXQkY4twAs0YTMd2zaGT8dud3Jqrbeldbc7Ofd6kcR+bYh3auewU5eGlWnDj5yhvjZRIdQ8CEni18Eyoo1L0HSGHhSWypq73gnC9cjJqDAJXah5mrVayPHmmO5HWuMwc2G/cRiXw+WTOoq41WDJSK66WQfLEBAiUBryDrSGdrdzY78udRmlne6Ix7OF4eSy1/nfutX3o6XIrrWiHCbSAlMtMpUd21V7B4XdyLSf7X9cl/NUlMMPb4dUvUgXFSY1D+77nfP/KOBRkGfhrkLpaB5pHSKFpO7DAz3D9SXF8ycMYPTDiIpy+O5cyGoV6t6pyImdUVyaOnpO7KOAbvsaO7ljDItCSpB3BA/q5rYD37hWZIwnCU/Kt0mM/YUQgvEUZGWN8ZSInfMxYsQ4VMSO2z3iUZDnP77bGR30+l3FCyc7IxlHiZxtT8cuVTR+CKFO4lUjpx9DpmO3nJw1P3Ikttrxm+0obZKSYBuad+dHj7h8nNGBW6lLDpbRO3Vpqpm6pNT+bzSHlakbwKNKxE8QRA4+kAQawiCK1PS1w3odjmX70xvVOam15p37IS4JhN6iH2oQGkp1CMVxtNa4gdhTWuMwc2G/sZf6z3tx+BYbAolGAV7zslmNgb958azGkFCsM1IU+26in3fq426jqHcT8diO/Zr/U1nBzJjBSiXcjHIoOPDee9tT0w4jcnK3Y9Oy/dmExldRGRUNZG1N2T3YKHatNQv+cWo+CBHZG41CCgOlodyAkOM9nSqP+zBEKcVicBwlosMQIUCryO5IDV4oeP+B4rlpNfKhxlJZc88/GR1i6Wgsam7TiV3dvRP70x65e9iR4jGebMS1ImN8mrCbb5MYMWLEiBFjvxE7bveA60uKB8EMiO3RQW/cVczIPLD7UgUt2GZUK7OVjm0IUM1NtxdCSAKTnaNKC04UnbtR39q8t6d1hyQZb7YxasTl444ObE9d2mhEsY6usig1oo3BMKlLe9l0DytT29DUPNBIBNHdpFGsZsRXqEFh4Pr9afdKc55IgTWETNeqiuUKtG5F7aavgKp2WKvpjrRGrSMnU9AW4T0orXHYubCf2MuFe3u98M8LQDHYebGXKPbdRD8PcvjvNop6NxGP7div+d/O23hKbEY59MJhlX/YjUyhWYtbRrWPuw94khbU9eAo9r3YqbWapqYdkNHcFkRzXorIbgUKaiqa/xPpqC/7cRnmKLi7DgEmpgAhaZ0yARGvAkXDl9xZjaLBd3vAqLXmnfkQV1tIiLIlQoUhDQLV6cQeBqMcxox6+HYYEa+b9jUA0wCpQ4SAlari9buPp8RPjCcfrVqRQXqWYl131Ip8dkqycCt2esV4cjDMt0mMGDFixIhxEIgdtyNCqSgqTSOwe0QH+YooekgpvECMVI81n9SotnTsaPMa/WkAIZJQdaZj7wSto/eh6cTTABrE6BdJHFZ0YEbWsbOC64uaUAMkcRuRw2lCVgemLu2n02eQTBt+izdNK9Ka5u9vptBjUO/juO2X5lz3QKoTXBjgnIRmtK8aTF9hsFLRXJqJ0hrv1yxWaxB0OJk0QvROa9zNXJByf6Jv91L/eS8O3xYsQxM2nfEJE5SGMAwxDBPZnEt+CJZUvPdg906m/brUZTft7CbisR2HURt5vx3Fu8FuxybUkoob6Uj3AY+vQGjZdxz3aqdWq82yMU1Hbbcz1BDgI1mtwkR6f+bGqKh70Z+yb9c0GnhUHa2ky1pVsVKJ/m41zx5a66llRPO1dYh1PDeY193q36jO8MOKeN28fBNQqrPEjymjteGgS/zE+PQgrhUZI0aMGDFixIixN8RF3UbE3TVNw29twjufCRltiANM7q531mPtBYXEaJYqaI+sWa9H7xmiGZnZTHVXOvpZoJEiigAbdFv4ej3iZczZcjJpJKp5eVISl4YfOSQMGfHTC62IS6uLz7Wq2mEjHUWdre8QWLFzJFtnO4+CPB8tRZt5U4AgxBSRjFbCCa4v9RZ4a9O9Wo0iSS08bIPmpjukMoTTZ1iZbmz2WWzXk7afg5BtaKU5lxuRk7Xl9JHNPnokeOd+OHDzXPPao7v7049SqQVTOUGI2XaIEMmwEUT6kZGVbWOzm7mwX2hFsTvNKPbOfnVGsbdj0yERQC4RORdbTsZsIkqdvr6ohnJIiOb/bV1OFs3H9ldLjZ2i2HvPjVb0805zcadLXXbTTivi0WhFPHbw2op4jMa7Hbudt3tFu6M42zWGuUQUDd1yFHdHK+6Ho2k3Mo0c/AahbjrAm4dvUjTbaKbrd5d7gS07tVKJMgraLzUc1k5tol+32/59P+fGKHDs6M/+lW2iPAFLjlbSZaUarcGilzBamQJNJ/Yg7Eb/YMsZvtK13qxWo/FdKvc/tOv13m7WqVGxXo8isb0gOlxoX3t8FfWxppx9m9MxPv3ojlSMa0XGiBEjRowYMWIMjzjidkRUPd3c/kX/H2pFqDVCKwwhN6OG6h6cG9+5HuuYCe8+CCnWtiKrEma0Ac07UPWg4StCJdAoEpZEqAZKp/nxnZCG3z8iq1UrN2VB2haU3YBypUbaSZGxDTZKAaGKnAyW4VMMJTXPx2nzCrUukjAJeP+hYqPOJr2kJXCDYaP6NPfXNrizXmFibYOT+a3QpmEj2Rqe5m6txLw3CVJjNzfOBBrTiBxnw0QHFhLgBgGNICShArIJk/KANNt2B5Dr6y2ZJgReoKlUGmTSaUIVUGy4SD+JpyJdUFqjdbNQQVsELi0d6rGJ6U5zVlqhtEYS6ViIZqUaRZLl++zh03ar3cGbpJQd9XGppDEIMQwDX2mUlgg0CUMgJVSCzDbZdM+Fbmit0BrmizUMHW6O/alCnvn13rqwE9ovh+uFflHsw5YtWa0oKo0t3s5MFDra8UOBQQjCJFQAikBrUFFfdXOcqp6xqdMaTcMPqPshtu/j2FZfJ9Ool7oEgeLtew958+4yXm6enzh3auh2Fjeastsh4rHqtevu8PO27ipeX1zY5O3zT53upfY7YthSBXMrmocbe0/5V0rzoFja1IXT4/mhZbpWa850vX0GCoDmYZzeZhfHePNeg3poYAWKqiei+uZ1jW2KjksNBzlAJtKRwy3UEtk9PTX4SqO1IggqrFUzHZdh1j1/U1eTljn0ZZij4mwhWl9CbSNV98GWQmlB0lScyht8sjrKTfVt9rYX+oixu1SFFDsdVG5F/Bac3WcGKKWZXy9xpzaGqUPG0wai673lis9CJY11a57PnT3RT6QjIVqjK7jaQihNwhSb4hEiOiT1Q6IDvgElfmLEiBEjRowYMWLEiLE/iB23IyJtR9E/oY42uIFSUSp4qDGlxDSiXEzH7qzHWnLBMdsuaPBB6OiSq6pPR3pquQEBBsWay0JxPbr4qOkzsQyYSKUwJYiGJmP3T9dsRfyWGz5r1RpV18P1PNYbDdIJm6QA2wz5xpsfMb9WZmLsKWqBwpKapAhJNS+SEAJ8LNaqdKSHlhqaRgC27q1OrY300sYG/5835phbXGFxZYVXH1Z4emqcM6bPS9BRY7VfO34Y8o23P2Cp5HPq2GV06KOUwDa36m6210O8u6Y50+Zzazl9VOByb9XdlMVqIyCdsBlPpzajA1tptr3SVVNWVH84UGBLgW2AH3g8XA+ouh5BoHCCCuulVZzUWdAa1XRsRY4cDWikEAgUE+nt/W2lORta0fDCbTomhCZQBitV+jpuJzORczNQzVRtthxJLTebRDGZNjZlQ1inGtSp+yFBEGKaBo5l9JRN+1zQXZ6PUCm8IIwONJD82++9wcO1B9g65Ju3VnFDRcI0qFVK23RhJ7RHsds91EUhseT2+s/DOHzrfsh/eO0mNx/e3dTT2elJvv78+Q76hlBIGVB2FVoLFAIvDAjCANetk0xYvHp9lULuDF6gKa5s9NS3Xk6mUS51eeP+Cr/7429wZ6VItd7g31+d59yxAv/dT30eg+yO7Th25IRROirFsh3ROKcsOg4xbGPneVv3fP7+f/oTPpy/38Hbb37pRSZ6D0VfDOMoDrXk6sOofMdeUv7vF6v88NtvcGtprUMXvjh7AQN2lKkfgoECEc1BoxmhrZtZE1JAGAb8xzduc3PhHosrK3zz1iqmleb5cz+BZdh4bohSIRod1WMNDUxDbF5q2K82LsB4SpAWdWpk8cNmXVcgUAo/1CgN66VH/KvvfMiFmTOkkqdxfZ8H67VtupoUCnOIyzCHQa+6vVJKps1lFtQp/KasAq3xvQCNQCnF3KM5ihsup48/R8DuDjUm01H//VB2lLehfTy6bHGvUhW7OajcbX37lr7Nr7tMjT+L9DYo1w2OZaNBXinXuL+2gRdqLMPiH/wvP2LMga+czPHSS3u/VK5Ff7liROsr29dXRKS3gRY09kEXYsSIESNGjBgxYsSIMRix43ZEnB0XmDLECyVKBZEDTkbpX4FSaCQmPmcLkYgzss6FswYfLUWbtNYFDeMpWHEDtN4ekTOW1JQbimooqLoelmlERSeFpOqG5FLjSBWSdzojcrrrShYcUH6VR65DzXNJmCbCNDANg3LDpSETuNVlbi/cZXoszfrKdY5PP0OoknjawG6ETOVMGgHUG5DtqmOZT2pcH1wSfTfSyq/y//rxh6zXGkyPpZFuilw6yQfzy7zfqHLp0hoXZyYHRrJtNEKWiqt8snyP2ZkL0XMdOSFCX2PJdoXuHx1Y90OWKzWEYWyXhR+QS6Rwfc1aDZaDAp98EqJUt7M6clSVXRg3NFXXY6nS2GzTNpKEqs6H925w8WSWtJOnVfcWrdAi8qBoIUjoCuOp3u4rrcENgyjStkvHAGwROYD7hYuNpyXHs7CwEUUIR26DrWRhKSBNjfFUnkfV7bLRhBiiUzbd0aFnxwVJC2relkMk1BrfD9BaY0jz/8/enwdZkuT3feDH3SPinXlnVmbWXdXVVV19VXX3TM8A0zODawAYAQigRIjLYwkCZrQ1SqCoNQNB4+6aEdg1iktwQdFWWpNWWCMFSuBqDRRBUaBAYEgMZjCDwfSg76Oq6+quO+/j3S8i3H3/8Ih35cusrKzsrip0fM26szLfe+EefsXzr39/3x/1doPLCx8hLFSikM14nWY74tj0LEcm5pkcG+kbC2cOzuw4/yYK91axzxYEE0WB6Ym9vhfh24ottXaDKwtLjJfyPeN0kdtrm3x+Js/5pHwT1dlsF2iEdTzp0QhjjDVEccxooUw7rHPlziVOzufIeSUis3XuaeMxIptbSCa4v6Qu//69a/z669eIrGCqXKAkLTIIuHx3hf/yd36fP//8Uzx56qUdr7OT4tEmViCBgg9X+4ms8YLr//o283alHnJ1eZE3PvpoS93+/m9/kz//9EHOn9+xu/twrwOeWLuw/tiQEFe79z/uxZXFNX774i1kvsSR6QOUVZ58udgZCy8dmGZy8tkd2zTwwBOaQh5akVMqppYqgQJBzFKtxYeLbrzVNn2ur1coBILzMsAC2sQ9IlFLbGIMCiXSpIbbK26FEMz7SyypEeqhI7y1lejYWR4YE1Jdv8J4Kc/lxSWOHZhho2nRNt4yVmsWDuY1Oc/ffWcNwU6+vTPeBofnj/L2bUMjtBirnD2QCVle+gBkjXdv1VmpWY7PnKLazm9LnMNUH4k5VZJMl+BuRSQkbdd6yCTLaFE0mSzmgO19bHd7UBl49xcZ0Dvejs0cJOd5GBt11l7PalaaVWKt8T1F4HmMl0p8cOcGHy6ucPDYLcrFg3tWmA+W7w4WJbHRfc9Xa9MnjiGffYPMkCFDhgwZMmR4ZPGgh/oZHh1kHrd7hqBav4U1Bk/6HbJCCIGnfIy1LC5fpndTPTsi+P7THl86pTji3+FLpxTPH5LEeNt4dcJGreIUu6OT5DwfgSDn+cyMTiKEoFKvJDq43s/1+0paC9fuXKIdh4wURvCU50IelUc5X6bebvHatXd4cnaSkXyOsL1B3L6Obl/n3WvfZW3zA54/pGglVgmD9ZRSMpJ3m7mNlttApxvpStuRF9fuXGKt3uT03BQj+RxKCkbyOZ6cnaTSivi9d65gLZydkyicyrDvOi1LrdXk2p0PeHJ2kkCZzr0qKbHWEuleIma4OtCTlnqrjUVSCnw8JZO2kJRygVMHRpq37xi+fllzJ55ls+k24MbSIYBG827THRuotCzL1RaxMZSCHIFfwJoIG6/y5Owk37n8OpuNCkKkE04ik/5tRQ0+uvP+0ORykwXrSBskSsq+MaakQAiJMbovs+3g4gzwwmFFToT4Mg2Dd16svnKHBfP+EkII/F20TSMM8QdirqWUPH/IWSpEJlVGu75zc8Hw9tW3mB0pMTNapNKOKOTG+PHP/hCfPfN5Dh86z/T4Gc6d+AzCG+X33rnSR7YOQ6piDzyoDIyVahs8NGfn5Jax2iV82eLVaaylHkuqzSpHJnN94/T03BRr9SbfubmCMXbLnAq1ph228ZVkojxKK2pz+c5lTh2Y4LWr71Jvtyjn++feSGGEdhxy7e6lbZMLlmWTL5+SfWvG95/2mB3p3lccG/77P3yTRhhzdGo0qbdkJJ/j6PQY1Wabf/Pu+3zhODteJ1U8pj6W2jhVtjbud3BWJKsN+r06Gy55kYCh83a1WuPNa+9xdGqU+YkZZifmmJ+Y6dbt4i3i7QzAhyC1kUgVl72w1rpEfkA58UwNtSW2ijBZH7bzP+4bC8byu+9cQXijnDvxGWbGzzA/f46Z8TM8f+IzhCbH6zc+4osnxY5tmo43bWCy5P4riJb7dxGqrYhKY4PD4wHlXMDdagOtDYcmJxBSOoW9EMjEv8JYi0r+bqygtYtQ9bJs8oWTiiMTgmIOorhNGLUwukLYukHY3mAkn+PQmM/S5hoGRSkX9M//wEepHJuNzQeySdiNv/jZWcl//IJHq3mND66/SbN+lUbtXaqVm525eHd9keu332GyiEvy1kOcv3zMqUO/fsXwjSuam9FBvnFF8weXNcemJAFtBP2+5ELASM9auJOP7XjerePpQWUv+hW/u/e394Th9967hfTHOTN/iIIvsdbgKY9SLiCMYxaqTWKtKQQ+Oc/HGoOv4OjUKKOlKS4tByzXzH356HbqkYz3SiviydlJCr4kjtsAKOl15rOxKTHt1ticn/mUZsiQIUOGDBkyPIpYrFq+dinu+z789SvmY82TkOHjQ0bc7hKDhNittQqXbl/mzsK7GBshhERKHyEk1oRUah9y4eZFbm9U+q4zmKAh0mJbRc5ms0W1WSeM2zTDBr4KKBXK+Cqg0W7QjlqsN2psNlt9nzPGuKQiVnF9zXBzrcLVpds0mzcwuoEUCt8vIYWiHdX4zgevsrSxRLUVDtxzC09XuHz3Dnc26l2vTmuph5bQ+NRDi7GGgg8+MSO5rRvp4xNNri7dZn68vIVIU6rIsZmD3Fxvc2ut0lEZTpVE33WKQcxHdy/gG5ccK443iOMWQrhNuhQCYy068VO1SPxEHfj7lzQfhYf5/Uuab19rUW81KeQKW3xlBVDMlUD6rDd0QnIKl3ndwEYTtFWdfgxE5DbJShNqS7kwgpQeWtdZWn4frWtUWyFLm8t8671v0WyvYWyE1qH7GW9Sq13j6uLtLeMEoBHWqNTWEnVz/wARwqmsa80Nmm2XKj1VsvUuzl+75OSxR/3bHJ6AUs71UykHRycEXzipKEunDmy0a1QalW3bphAU2KhvUG9Xt9T17KzkkHeXgu/UtlJ6SVh3mzevvsHNxasIIcgHZZ479jRffuZ7GSmMoU3EZmOTWEcor8TTJ17k9obm9vrW9hhEWTZ5+ZhiemCsTJUEh/yFPgKt227bE77rDU0ramPiZYQQSFmgUJhEyoJTLo6XubXZ4PZGhdsb3TnVCmsIoRgtjuCrgEpjk7evvsaHS7e5u1ljaXOZ73zwKu2o2jf3jG7QbN7Ytv9767xTUpfXr9/ho5UNxnI+cmCcSCGZKhe4W23yxs2790wOM+Nt8NljkoKfElsKYyHvOcJRCRgJnJpd49SQI4FrQ5+IyVL//Be0+Ob736Hse5w7+TLPHX+JF05/jueOv8S5E5/l9Pxh7labvH7jzj37u7c9tj3gaYNSzp5AG0dcrdahaQus1nGes1YM9T/uxa21Cit1n+dOfQ7llTFWE0V1jNUoVeTk/NNU4gJ3Nqs7tmnveKu23WGSxCUZW28amlGb6sZ1hBBUWyGVdkQ5n6MZth1pK2UfqZ8mXFNSYYym0mr0lbddMrbZEcEPnPZ5erbB+1e/w2b1Eu3WR2hd63y21o54/8b7hHEIBHS/HkikyoONub54lTsbW+f/bmCM4c1bmsj65Dx3cLRdUq+7mzUu3/mQVvUGWm9uadP58TJXF2/zxFR9C3EObEsOX1k2HPBWOTzufL09YooBHBnvXwt38lHezUHljLeKEGLHg6I0MiDvwbc/bCP9E5w//QVK5SfJ5eeJ47b7TpHcc2SsI9MR5Pw8lcYGtWaF0eI433v2M0jhY3R7T0nlbq9XuLq4xnQxhxACY5q0WxtYqwGNkhKERBvXpoEHJdnMVBsZMmTIkCFDhgyPIPaaHDfDo4ss0G0XWKwY3rur+0IQpZAob4Ra5Sa1coznjbvkVOU8xlSwOibUhnor2vHaO4Vuh7FBSkWsYz64+S4WSxzGeIkh5tNHz6OkIox15zO1tqXScn594PPWbYsn88xMHsMTLVqtj4Ac6+ubTEyMsbS5ytLGEoV8nlBrBpHzFM1YE+kIJXM0bcDdSnr9PK0GbDbdJlgJw8vHnMrxvYt3eObUk0yXFe/fahNqTTHohtjmCxMUiidRMs+xw8fQ1vLaLYnnWcqyyblTkvUmnessVyr8r/U1ij1ee2trV5idfSYhb7UL/dWgE1WpEHBzw2KN27w22lBvS3w/D0YjZQ5j0v6RCOkjhCIKQwIpkTIlhR3BEBsIbUAaKCqTLNtz5RZff/cdSsIyNTmOMU1azXUYmyNK2nRpY4mFlQscGJvqtD20UaI7TgZJl3or4sqtd3jhzBeQMkjsMDzntmAtUdTg9spV6uHZbcN6O37HwPedUkmb3uKZ065vjDHcTVqgHobcXbvOsZknkX5hS9tYE3Nj4TL11lhfPafLbuGf8Tb4weeP8kdXK/zr1z7g0NQIK5UFLt25ydz4AZ46/izFXJlCUHTJz+IQpZXzlzQaZdp4KmB85NCWQ4TtMDsimB9TrNR0Z6xMFOCtt7ZPd76dbUnR13xw/Q3OHDlIPn8YKfMEOYOnJMa0MCwQ6tudOR1qjSdaLK1d4P07VYpKEeR8as0KlWoVLT0aYbSr/q81o6Ftuhus1BpEWlPyh5/DFQKfWFtWq7tLAX92VvL0nOLaiubyh3d48sRhRnOW33vPqQPXGklyIpsnqjsCLu9DiMfzB/vn/6tXF4mN4XNPfZZ8UKAdNQnDkCAIGCmO8+KpzyJFgYXNeEdiaRA72UgcHBN856plrQnGpC4Dzo/aJZLLo+xW/+MUi1XLn9yUzE8/hRROdeoO5mLAYE0bJQNmZ05Sa+68vsNO4y3mxuIH2HATKDo/aGPxlSSM2jTaTYpBHqUU1hiEcF7R7hDH0o5axD3k8zAv7t5QeSEE0oYsby5y5ECRwcd/GGuWNpZ44+rrfO9TL1AISskhg0TrOstLF9gIG9Tau5ubg2361m3NQgUMivVGQtz2HIT1JvWqtUNase5b73tRCHxCbWi0I45OdYlzoKOUnRyw9EkthGJT5idPSTZagvcu3h66FjYjQysCbT0akVtT+8r3oUbMSE7RjtnWKmM3/vbrTWhGylkhJZAyQIg2WIuQOYTQYMFXPoVckUiHLG8s8dyJzzBaGKOQK6KNoRFJivHOPrrDMKy91zc+olgaAzyMaVNvtRibGEcpR7xP0O+xnSFDhgwZMmTIkOHhw9r7T46b4dFHRtzeA4sVwx9/FNNKPN6EdWqpRuhxdPYMt285tWscb7CxsUA+P4eUkmYYEShJKb+zH+BOXp2+kpTyRTbqG9RaFay11Go1ymXnh7lR22BiZApPujDglskR9nEzFiUEkZY8eewFKrWPgArGNGk21xgbCzpJRyyWQG3dJLdjTS6nOFD2uLkBIbk+v0VwfoHVNhQxHdVZrwKtlPcJlKIRRox5HkqVOTDzBEo5crDVrqO8HM3I49XrmglTSFSGdK7TCgPynqLd7pLLmxs3GB0ZI5+fB+HhewFWCPIe6CgkjAtY6/wwhXVErjYC38vTam4iZYSS+Q45YUwbBLTCGp43lShuk7sULllOhCTULlQ8TYA1VvCwpsl6vcrEeG6gD7ttGniqr+17x0lkc/z+pYiVmqUZHmbxkqbglfClYm3zMhMjh5GqiNYWlEDrOjduvUcsIkpB0CErJgKIbb8astp2SjZgR3VgOReg4yq37rzD8aPP9reNbrBevYUvJVfXS7y3rGmFh1i8pJkuGc7OJSYQUnJsSrC0co1yfh5fKWbHD/D88XPkcwXCKAQhEp9GH6VGiWKNTOoSxU2K+TLQ3447YVCRuhsMI3xrzYh/95oilz+CVD7WaIyOsDJAqiL5/BGmRxc7czod075S1FsVqmHIxNgoANpYlCf6Diu26//p0RmubZT4YFVv8fzcDabLRXylaCcHOOXCKHlVxAs86q0qzTDCU4Kpkd3L46SUnJiybN5c48TUURYqFm0ltXaS5C5JACiEcgpbA8JKIi2YG+32xXS5yLPHziZRAjVyfg4v76OUwlMehaDI9zz9OSoR/MFljX8foTvDDnimy4o4jvn2VZmQtE436lzHRZJOShIZl9BvkCuumQLfuqaptDxUDw8uhEcuN4K1LbCaWIeMFMawMthVXYeNt2bb8LW3q0RJvwWeQklBpA2RrrK0sczcxAECPDzpo4TEYjFWg7XUGutMl6dZa9g+L24h3H0Z61SmcU8ytsG1uBfps2C5ssxG5TK2ONY5ZDCmyUZ1hVxphKIf8OGqYSme5MNVw7GJwbvd2qavXtc0QkCAsAaZjBtjc7RjS94XfUm9yrmt630vtnu+7qSU7SWHN1rbq9gvLBreuGmSxFs52nU33gO6ZWmz/UFlLwEMO/vb32k57+OtEHheDq1bWN3AUx7j5VGkgGpjg7XqCsfnniAX5LHWuIR3WCySjSb4tocE7vHR3Q7D2rvVXKfVvEUudwArcvhegFCSmbLkqVnR57GdIUOGDBkyZMiQ4dHA/SbHzfB4ICNud4C1lvfuauptp5JphqDJE7ec71/BLzAyfgxrl7Yk5Lm7UePwWJFD46M7lrGTIkeqPNZWeePae+Q90+dla6zhtavv8qMvfT9tnaNRBUOXRHAhuQYlJVIItJEUC4cIm/1hp+Wcj0x8Ykfy/SSEtZaVRpsvnjzGwfEyX786uPPr3xiHBFuSEwEcGh/l8GiRuxs1Rgt58vl5LAHWRGA1oTZMFhUTRUm1J6la73UOTYzyxOwk33x3hRM9r0XRMnG8wmJVMhEE/PT3PsdIzvLb7/mdnF2xcSHf1iSqMwFBrkSzfgkhRIeckNJD+ocJJOQ9Lwn1Ns4eISGBLBDF4IluAqwzc+WhdQMYyQcoIZBCUM5tbd+7GzWemD3E5ZUC9bBfHdwMfc6e/AzXFt4n732IEPlOXbVucH3lLl989jTFXJmNZoywhvXmcDVkM/E73ikDfbeNL3FgqoBSxU551rZYrcWcPfkZ1hqOwDB4NEK4GVnWGpoDCenW29+n56Z4+uhRPC8l7gpIKYi1cSpb6TFeGkOKEKymFUVMFUYYK5W2r+g+YZDwHcuNcOrQGcBDCIVUPkLmkQIsBrA8cegMB8dGEEL03eNEqcDNeoNx6xLQNaKYoxNjzI+Vd+z/atvjqeNP04x8isOU0rsgMl84Os8zh4/QCD2ePnqKvN/9TK1V5dXLbzM/EvPi0YN7bitfWTQKLHjSzXxDvxodVHL41B3/Jw7Mc2A0INKGyZEZpJR965jF4qPQVnJrA6Q5yJMJybgbDB7wCCFYb7pDFZKapF9VbM/vsXYk33hP81pruRsdoBEB1qlajTXJoYJASoW1ebSu04pCin6B8SFJ5Xauaw9ZWOpf00byAaM5n1qrzUQpzzs33mekWEbJIu2oRTuMyAUBI/k8jbCFjCtcWzvGxm3NZjyL7c1hRo5205HWkqBzqj64Fvdi8FnQe8iQPgu+fPpFvvVRnlZkMHaOu1cMeR8mzfAO6z3xLyd2CL12rwbBRhMOeKYvqddUafh63+mnbZ6v7ZiOpc8w9JLDw7Acj3PnI4MeIPSNhRZ5am1LOUfHx3ayWN5yUDkMw4h7ozUfrqUHVL0jlc7flMpTb37ItaU1PlraoK01I3nD8yecgl0qhSc9pJBIz6mxtQHbExmSHjBupzCH7Z+vWtdoNuvcWGsx6Sn+4me/wMyot4WczpAhQ4YMGTJkyPBo4H6S42Z4fJB53O6A9YZluWYItfNtBEc0gCPHfM9nvDzFrY0wyRBvqbbaXFpYZbJU4HNHpjtJZXbCdl6d0yXBmL5Jo73JjZVNqq02sTFUW21urFbI+4rxYj5R22wPIUAKQ+DlWKqqvrpeWVrn6HiJ03PTXF5c63vt8uIao/mAH37ulFPbDhc/dRCjuL6+9e9SCj53dJr5iVmMOoryRlDKqRitKJD3c8yMFJFC9iVVG7zGjzx3itG8v6WelxZWkbbK2dE6J6YVa02JQbp26VMHu9+FkCjpsdKwbDY2qNVX2Wxs8NHyKlJYRgsl1hqw3nAEkDZ0xoBFstmCpZpT8Z6dkyglt63b5cU1Ts9NcXS8xJWlrfWeLBU4fvBpqi0X1q1kSrg7siAXlDh64DSXFlb76trbN5ERtGNHnIfa9bdTQ7o6V9suk/x2ZMV2bdxb3qWFVY4eOE0ucIRqqriUibqv2oK70QGstZ3+niwVuLUeMl4aQ+uYUn6MYq6EkoqcF+ArpzoN/BxKlbCiQDEoMpIPKDyEpDebbcFoeRJP+VgrMdZibZz8lHjKZ6w8yWZb9N3j5cU15sfLBEqxWK2zuFknUJK58TJXltZ37P/D0yco5QqMDiRAGvT83A6LVcsfXjN8z9lXeOWZ72FyZIbAz9GO2jSjNoXcCF84+zI/9uzTeNs9vXcJm/xvsGcSZ5Kha5C2grFiKSHnXRJB2/NOR+KKhBx3iv43bur7sk0YxGo9+bIieq2a08R+btymatRerDUsdeuYXE+l7+2/UyE8EAXyfp6CL8kHex+ng/Ot1g6ZHymilOTmaoVGa5PXL/0JS5uraAN5P0fOU2zU1mm2lpmfOc5ag6Tt5ED72w65HuOxUHGn6r3j9tLC6n09C544eJp84agL8RdAssY0I7gdz3NhcStZmp74F3wIErsCjaStU7LfRTDc2XAe4mlSr3ut99s9X3OeW0PNNl9tesnhQRhjuBPPooeM8RQbTZeMstfHdrcYJO5vbEBvScMvJdho+pQCw+fmfSLdoNqSlAtj+H6AJz1iozsHDCZRWsdJu6Y+uuMFwcQO0Qj3au+Cpzk3I5kqb034mCFDhgwZMmTIkOHRwW6T4+50qJ/h0UPWXTugFTkfOmPcZgiccjOdBFJICrkCT84e4PLdGyxUm5hci+eOzPKVZ05Su3tj12Vt59U5Xg84efQV/vtvvsVHy+s0mm2KRnBmfoovnfksOT9wmzXTT5xY+jevMvFpPDozzaVbq926Hj7AkeMTnD17lt979xpXFlb6X/MiTs1O8v6C7bSBTK5vsc53lVRFJWiEwwmXidFpzo4dY7OhE8VbhFIK3/PJeeN4yg3FnRRRp2Yn+fGnDnMj9rm6uLZtezvSR3QUdiIRM6UhxI4okhweH+XSnaXOdZ6cn2Z2NM9mS9KOU2Wh3UJIdbmg7gb2XnW7cOHC0Ne+59Qp3ryTR+DUsen1HYHnxt1ocZznjhzj8t1bQ/tmo2mJtGs3lZBVu1FDDsN29/H80WMUiuMuq/02ZTRMgbWGZaokODJe4uzZs3z1/UWE9Bkp5hBSuoRLVg4k0bJYa/A9n8DzGSsqJooCY/ZO3u0F7ciCDPCQGBMTG4MxFimdz60UHiDd++jeYzpvRgs+IQoBBFaCZcf+f/7oMSZGpyFu7hjWvZ1SOg1Bb8fO+zLWMVGiYh4pjrHZqKB1i/mJSUbwh6rhd4tICxSmo2BXCdFqrfO7lgKwhkj3X9+XBouHEElyJEtfHdJ/CuHWFY1lpQ5rddOnht0LpARPJESW1njKQwrnHQ6KwbngCF/ZIXxFsk4MjkJPeQReQFHUHjg50+B8q0UxRyZGmR0tE3iKlfV1Xr/yHcaKYxSVx4HJMkenChw++DSVhmEk50Lt7RA6XQgQ1s3TZuR8W8fyW8ftbp8FxeLTWJsoMZPEdboTiSB4+7bh6bn+b4i9J/5CCJSwDDsvNkArhlEVdsbHbtf7XkwUBeMFwe2mt2W8W2s7StmJIUrpj9YsuucrkRRgbP+aaXERDJ85qh7YKqDeHvyLGPq8mZ2Y5AdPz1G7e4OXn3ua33rjJnnfZUeLTYySApU8i9M6gjsEbkXgoTk7d2/CdS/tnSFDhgwZMmTIkOHRwk5WnOmh/mxyqP9J77cz7B0ZcbsD0rBLYwe3bt3NK0Lyo8+f4cfPH+K1t97hpXPPcXRqAmsNb97nRmc7r84ffOYkP/D0E3z3w5v8yTvv85nnnubE9Dy/+34r2Rh3ycleWETHj9KRlYIfffY4P/bcZKeuh8ZHefvttzg1O8mTc9PcWF3f8trgVRGio7Lr7AWTsofN/TRcVgYe8+MeKzWLEgrf81BCEsaaWhtyvt1REQVwZLzEjz1/jtsblW3bu/ezg3vVDnkr4IefPc6PnZvpXOfI5Dj/9v2IzZZTkhm7VbklMUyVFb6E5Qp9xt471a12d/hrHyzGWGI8Jzzc0oduI6/4oWef4cfPH7lH3wy536Rv7mdJHnYfTT3KH13TCKIkGVx/man/72odphKXg1Ozk0yOTPLb74bE2uIrgbEJ2SPS2lmwgsDzEEKgB08gPkG0OiSTQPk+2hjiOMbzPJSUaA2xEYn3Zfcee+fNC88/i7CC19+5d//7/hjfuhpjtjkO3ekQozcEveA7GxdPWgpBjkhrYi04NDnF3KhHrC2bNX1Pq4ydEHjgCU0h78igKFGfG+v8nvM+NJt6y7yttNL1SaCExGAT1Tt0V1VHVqUq7tgoVursmbidKiUhQFYm0QYgsR11uE1Cx6e3c+MQ/f8WnXGa/q7YRSDFrjFsvh2eGOfW+sbQMVXOj/H1KzEeNYQQhNt84eq0s3VHbGt1mBtxr+203g97LTZl/uCK7h6G0T24S0tvRnB9zXJ0oluH3hN/D+NsKIYgbc51PY4xBpV4g+9mve+7jhCcnZMsrGmqbSj4PcnAYkHgwYQZnlRrrd6tS+dAobc9k7s/MCKYHREPbBVQGmbjPWS8ffb4DKdmFW/evcEPPnOSk3Mn+IPLEcbEFIIAXyniOEKqxBYoOZyMYjgwIvDMArMjY7uq0/22d4YMGTJkyJAhQ4ZHC/dKjrvbQ/0MjxYyq4QdECSDHLqbud6fKXIeHJkc4/hEmSOTY7uyR7hfeJ7k5ZOH+d5jB3j55GFiK4iTBFRKOuJsO6RkRd6HE9Ny27pKKbZ9bbLYCTbektCn145gaggxNBgum/MEUihkx4fSKUbDuFcRtf397FRPgLwnOh6H1qb33/03OGKnEPS3xWbLkXc5WgSquwEGR/74fcmK+o29d1O3Heu9bf8l+qkdPhtqkah1bWfjnt5vbFzdFVvVkDthS10HQs63qebW6winTHeqXIm2MmFF0uu4ySSEIFCu7VsxfW36SSHvOeIwbTslJCohHG2HRzHkB8jJ3rY6NjXO0end9X8hSci0l7Du3jllrehrfl+pRC3uogPu5eu5G6Qnt9rAZMn9VxCtzr+1GT5vG1Ha06mSUAyQtg7dNWTgJGgPmCwKiqIJtnvwZnE/dTKnp0swWepv9y7h2/1Mtx7poi/IeTBWcBYEg5Yue8Xg2PA8ue2YiozY0ce1F/1rdX+b3s9a1ehR9abTN+3GtD+NhVq7v4zuib8bCzrx25B0e1oK9wz1pGvTQbude633g5gdERz2F5gaYj308jFFWQ7vtDSP5JYIi849OgRqf742HZsYclLXLbXTwCem+g/KioHAkxIpVV/yy/QZ5drWcP6Q4Mun5Lb3ux3ut70zZMiQIUOGDBkyPFoYZsXZjmEkBxNqA1+lUcoZHhdkxO0OCGPR2bAl+83+n7i9Vfs+CLGdYK1lrWGpmiJrDbvjZHLqQNkhkqUEyVYTWm2SjO9Ynj8kkXJvXV4IJIUkt1KHBO35CeATkw+2Xn8wXLacc/XpEiQ22fSzJ+/AQeR8gU88QGZ3f1HC1TU34KOaKqx9EbuER3lXT186VWG6X+8lfx/U2LuXLBpGiFsk3k7qQBzpkfMgT0ig0jbtqiFH8k4tuZ2KeTeYLrn+2xqSjSPIrCMLpgbqGWqxjQdn/wVGc+5wwBfxQzNLz/kCD41gCOHnXALw0FvGzV6RhnXHeFvmen9Y99bP9s4pKYfR6Xag7tur2HeD9OQ28KDadppAmbRVtS22nbelQCRKWruNh2d6/bTWIhnve29jIQTz/pKbv6J/PgggR5sXjqgtdU0JX3ci3bla33sCBTMjwhHmD0iG7xWDPq7bWRd3R5RAAuXc3h/3946iGv6G3nHTCId/zktY3JQfbA593/2hLJt8+ZTkS6cUR/w7fOmU4vtPe8yObD+ujo67+tDzo6eapFrYoxP7M/8nS9IdMOyAqRJMlfv7Le+L5Fm89aBOWzc2AmKmRzIlRYYMGTJkyJAhw6cVsyOC7z/t8aVTimm1SjFwQooVPcU3rmi+dilmsZqRt48LMuJ2B6QbZNUhFYCe0FAlhivw9oLFquVrl2K+cUVzMzrIN65ovn7FUNsmq3w+CUE1tlMxZLoJ7oHFhVIf8u5ydnbv3T1RFMyNCFRCiPa2hRKuPmXZGEoyDRpk5zxBTrQ7qlabDMPJ4s6KqF3XtQBF2STvu3op6fpJSfd73nevD9Z1kBARqc9Ago76OhkP+2HsPagO1AY0TlG3kzqw734TAtAIyWRx92rI+6pnSTKd2EJGup8sSEmukmj2WXwABCr1RjY7uuv6niN5HqZZ+kQBSrJJ4NE3Nm1CgAeee/1BfU1TpGHdChfWHeluGEvlHocYvXPKl84POa1rcvUkpH13KvbdYKckitvN22OTgrzv6uPLVLU+5AtCzziaLu883ndb1y+cVBwZFxQD8IgpBnB4HI4Gd4YSeEIIxtXmjuO0FLiW3Q8yfK8YJPwLiVJ8EF1du6UQuL7YK1wkRaJBHhpx4cbbMCuOdNyMdcaf6Nj7qCTBIXTJ4fSA8EExaD10LxKzl0g19K9xpvOerUTqg9TvsL9AeZhlAhAQ8vnjWw8YJorCHaRh8GX/wYQv3dow7PmWIUOGDBkyZMiQ4dMFIQSRhjU97kRyCvxE7LVSt7x6XW/LN2V4tJARtzsg7ztllZSO0PMSVauX/C7F/ijw0iRDK3XbN5lW65Zb0dzQk5BUVSqFC4fXxlFjTgnnUu8oYl46Ivjp85IZb+OB6piSTDkRUgyczN4nZCTnyIyR/PYkU2+4rDGG0DGSlHPuNY+Y+VH44bM7K6Lup64znjtVCnwYy0OBFmN593sxGF7XlBAJrc9qAypNp6qLEgVobBzRECShBbvJ1r2bus77SxT8rjraooiSPvWJhqoDB6/RSwDGCbEaa6juk4pZCMELhxU5ESFFOt6kC9mWrv/n/aUdy7jXed5+tele0TtuPOXGiU/Y9/uDtuMg9hrW3TungC0qdoOzYWjF+9P/vfVNT253o2SUUvL8IensUBL2axjJGCUKZ5+YFw7vPN7vp64/cMbnB04rjgW3+YHTiu97cvs2tdZSM2V34KP6tbap/247BmPNvpHhe8HgfNfWkXz90EiSBIIPGG0BkA8kHk5enCq5e3+COyAsDIm4ANcXP/aMR8F3V/CS52nnGslBlUfMsYk9V/OB0Eukdk0MukkutyNSHwROGaw4OSUoJwcM5QBOTMHx4Na2Bwxn5yS+iAg8GM1DnhajeXcAFigoyTrrzSwELkOGDBkyZMiQ4dMMay0XFgwa5fgbJZIk6ILRnIviXI6nsu+MjwEy4nYHTBQFM2Xp1HYdKzm3kdovBV6aZCiMYXRgMo3kQKO4sGC2TKZUVaoUmITwMwnhZwHlOdXlwbF7K412i9kRwZRax1gX9hrj0wgdOXBqZnsvvZQQEwIWay57e8vmWWs4r06F4dxh9UDEwiBSlddUyRGvET6R2ZkQE0IwOyrQeLTj1Ms48crFEQuSmCghRPfT2NtLrBjcMDOOeBcgxe4W0bRvYgMbTWhSYKPpCNad+uZ+MDsiOOrf5vAEFHPu/os5Fzr8hZPD2zTs2Ijs3LcfR5vuBWXZ5NSMI6RrbQjJUWs7cmm/2nFYmfcb1t0bgl5pJz6htJ1PqAFw9gXTJbkvKvbBsu9HyXh2VnLIu0vB76oDO9fCUWNKdJXxDwupb/BIztkhjBedjUl6aCewhLGbX/tJhu8Fg4S/EIJcnxWqQuNm3bRafaBoC3DPmxHZcBEMA37XSoAiYm505wMXpRTnD3dJ/FC7lS7U0NbuanPe0r4+B+4XKZF6fBIKnmvFggfHJrcnUh8U6WHIZ49J5rxlPntM8uUndl5revvfAka4dkwjNdIQuJ2idnpxPzZNGTJkyJAhQ4YMGR4PrDcsG02LR7xl3yKEEym2bG7f8nZk+PjwEAI9Hx8IIXhmXlFtW1qRpeBDo9GimC8RGRfOPcHwDNW7RUoWjPmAcAm6tFWE2qlvexNgjeX761aWNap6HITrSG01Eg+NOz0x5PnDq4bxgsDbBwn8YtWyqifwlMv43mg0KRZcW1xZNkzstow0BNW4ezZIKi3L/MexWUztDbYJ8+17q7UsViwKjadcYieB6AvlTRWRU6X7y9a9U5nL8RRWwtyoIzBrtRblcglfwnIFLiwY5sd2bpt965t7oCybPP+E5Po6XP5whSePHObktMJaOzTLui9Nj1/odhC0Y5gdYV/atBeDhMS9DllqpsDNZUfWfZztOAhHhrJrMhRcXzx5THFx0a0PRihyCoo+6HaF0wcmeO6gI8GG9c1eMdim0+V7z9sZb4MfeO4I7y1Y3rkZIrw8U0WILVRrTUbKJTwBK1Wxq/G+GyxWLRcWIlbqllZ4iMVLmqki+Nv04RYv7gDazRaoUjKGHa08mhe8cFhy9+rD/Ybj5qLg+rrg3WtV6iqPlyqurUUKt3Zt6hEWq5aD43svq5OdNhinFbmDgmarRSFfwBgwUcTZucK97QiKLlIkShJrdq5PotilvfdK7iOEEChp3aHCUA/p/cNi1XJx0bDeMDT0JI3bhutr935ml2WTc6ck6034k/dXqatDGOPa0bZDApVntW6Jkqid7frflR+78qODrF7R+/adIUOGDBkyZMiQIcPDQ5rDZ7ukxvuRxDrDJ4OMuL0HZkclnz/u8e7dmJWaJU6UmzNlwVOzD755T8kCbaBSs0QatM0T1p1vJVYMTdaUhvXmvB6fUSvQ9Hob0rFcuNfm7V7oldlP5hO/lJamGLiSKi3bkdkPbt57ycnZEVfXzWqI9dymP7Q+3/nIcHszemBlWIrUfiLUgqIPtt2m6OdYbcCr1/VQAi49kQpEyGTZEbQpiepJp8CstzRPTHs8Myd4++0HJ256iXspJIGyKKEJElnbdsR9L4wxvHlLE1mfsu8OFHbbN/eLminw9SuG1Qa04ikqNw3X1yxn54b3W6XVDaWWIvWNTIOPuwhj0Hp/F6T7JSTScWokjOVd/T6udtwvzI4I5kYl11bgjatNmnGe2ICxo7x+0/L+Qszzh/ZPwbhYtVxYjFipWZrhYRYvaabL5p7ztmYKfOOqZakGbQKUdmO/nEsS593HeN8NaqbAt65p6mHqUerRCF3iK2kO8uSQtbDXNziN+PeEZrToIho2q22CXJHPH1eMF/aXDN8L0jZdb1g29AQ2Ua16EoTVKOl8T0NyvHFTMz+m7nnNndB/UGCQwtlxTJUEXvXeBy7pOmUT325tk4PQYoGC79bX5XD/QrWstaw3ua8Dhs64SVT2Gkk9hOYaCI5QvqV54cj+zf3e51TBg4jdE67gnsMTBUvdlDDGWdZEiZLZ4iyNlttq28OQBy0/Q4YMGTJkyJAhw6OLNIdPvE3068PM25Hh/pB10W5xH8rN+0HggbWCjSadRF8Gg0xDH8nhsTVZU4fwS+wV2rFltWZAKrxkXxlpuavN225wb5m9ZbPtZPaDCWoGyUlrDRE+wjgyT2IwRrJUtVRbw0nV+0EvATeaB+jaT/jKkYnDCLj+EylBoEAJjbWw3nDhvBqP9xcsK3W7rXLvftCr8rNYQt2vuJaYocR9isWq5a3bmoWK26yv1Z3tAsZPruFCILbrm/vBYtVyPTyI2Ui8KRMy7GZkWWtoDgxpj0aU+kVarBU93pH9iAzc2ACPw0NJtfvFXgiJ3nEqhNhCIHkSqqbAR2uW45MPVr/9QqrWu7tpaJhxIKXEDVJImhF897phXo4/cFkpqVVrJ56kKEwLGqFlrT68/9M6puPGJImstIVm5MLlc7ZLKN5rvO8G1lruRgfc2BPJgUGypu5EZHZ9gwv4qtv3Qgh8abFCMl0STJYkxjw8SwdwbXormsOv2yRZpPsyZnFWGTKJFBCAxrJSh7W6YfwBl6zZEcH8mGKlpnnv4h2eOfUkEwV4662dD7EG16n1RrJO4Q4o5cAzZGbkweqZHjBtNG3n0GaiaHlqdgcP7mTc1CM3Tt073TPUBQ34vH7L8sFStC+HIb3PqZG8vS/CtRfpulWQsFqjc/jbriVta83Qw5CdnpOetA/8nSFDhgwZMmTIkCHDw0Waw+d209vCfVjbm8S6/BBrmWE3yDxu74HFiuGPP4pZbbgQ5JxoU/TpKDcfNAvfeN5iEiJDidRXNcm4LYAkAdTghnswrFckm3clQEj3eXAEsxCiT8m2FzyIzL6PnLTWET+IxMM1IcOFC/HcD4PszkY2IeB6sZOXS3oiZXqmRWwVaw1HMunEO7QVwa11uBEdGpo47n6QqvwaEazWLGt1aNo8a3XnBRxbDyW3EvfQJSfXGynLYDHWJaRqkWel7tTWsXnwEAhrLW/c1ITksHSTNaUq2moL7kYHtvRbKRCdPhYizc4+nDyxOCuK73yoH6j/9+ob3TtOe9GOLat1S6XlvJJfu2F27R35cSLt/6WqodXTtxaX4A7oZJ1fiA88ENmYklqVpiMG3ZXcahAbl8hvWP8Pjhsh0ho6xMbNxfRvBrnteN8t1hqWhi2A6CaRFLifKik/JTJ7MegbHGmbRDPYR8J/OcVgkoE0iVZ6j9Bdw1Kf7tjASn1/yr9fj+NPcp2CLqm9OpDs816Zc9calrotdkjb7VagRnIYshyPP1A90+eUkrBWp2/tX2v0E647IYzdc2qz6dpUJz7SOmnjJgHteOthyL2ekw/6nSFDhgwZMmTIkCHDw8VgUuPe/U1ln5KYZ/hkkBG3O8Bay3t3Ne0hBNB+ZeHbaIlOcp40I3yaaVtbR3hJ4RLi9KI3rBdSJVuXEkurlM7BB1WyDSM1e7GTzL63rpFxiiCBobs+ONJByf0xyN6OgEuxHcmcnkjFuBMpay1tGySEQlpTlxHdWGhbnzduPRjJOFFw4eGbTdc3vYRoO4YWOfI+W5L+9JKT5YT3sok6LH2nSRIAbTbBWPFAIRBrdZMQP7aHcE/IMOkKbdgCawOb/GOTgrwPIPDl9gtOej1whyKrtXsa426LvRISg3MKHCGy0XTt6GDxPUc03UqUuw8Dvf3vq3T+99clSuabBGI8rq/vvby1hqVmC4kWvVMLSH43QG1I/w+OG5UeTPW8RyMJtbunGI/xws5Jru6F1XpCAAsY/A5yLyIzTWo4nST96vW0PuQvfCzJqe4X20U/dNcot76ZTleIgXd8cvik16kHyZy7Ured59tOLaXYn8OQlHCtttz99679oYbWNoTrIHxliROitoveXxTtGALVf1f3ek7uh/o9Q4YMGTJkyJAhw8PFYFLjdH+zU9L2DI8eMuJ2B6Qb5OJ9KjfvB2EMUljGC86P1qYbW+t+z9PqkHi96Ib1us1qqrRK+RttQWEIknDUB1WyDZKaveiX2Q/5bE9dtbFbNsUWZ2Hgq/0xyB5GwPViO5J58ESqETp1Zud13GbWEQHubyu1rcq9vcKpph266kQxlEXoJSf9ziwWnev0kmpOgSUYz++duFmpkyRrM0PJMJUkmVsdIMOklDx/qJtJfqcapPW2wI0HIBn3SkgMzilrLaH1MYka3gIehqLPjsrdTwK9/b+VoOvCWJcAzOL8XfeKlZrtqHihPzIghUWxUutvi8FxI8Qw1b6gGbH/qtZtu2VnInN2RPD9pz2+dEpxxL/Dl04pvnxKPjJfagajH9wa33MvA02XzoXp0idPOn/S69SDZM5t7HZ+JOvdgx6G+MqicT7EnuyfU27tEkR6K+E6CGttxyoDhs9NbdiyTt3rObkf6vdPMzY3N/mFX/gFXn75Zb74xS/yq7/6qw/dYiVDhgwZMmTI8OlEWTb58inZt7/5/tPeIyFKybA7ZMTtDnAbZHvfys37Qbp5SpO8TJYgL1pMlpwfqRB26OZpMKwXCxKNtk7RKgUEIgTEvijZHkRm31vXZuT+ZnEkdZyQqOWc093uh0H2IAHXi3uRzL0nUq0kkzy49vRV1+PYvWIT5d6D2TrEeIxtQ9znaNGK2aIO7SUnY5vKVfv9l1PlthLOqXGj9SALc6+eb4eXh+DsrOSQd9dlOx94zakvt344Mntv070SEoNzqhk5z8mUVOqdUw87lLi3/+UO3Sp6/lUI9l7PRtRzzSHE/bD3OWwdNwLr5tIAsbRfqtapkiOKtWXouNwNkXm/dgCfJAajH3wFKnFhNbZn/ifPAoDpMkyWPvnH/Se9Tj2IpU/R310ZvZYUD3IYkl5r2Nnc/ZwFrTUGozG6z9fkLwCsDrzvXs/J/VC/f5rxy7/8yywtLfEbv/Eb/MN/+A/5rd/6Lf7ZP/tnD7taGTJkyJAhQ4ZPKR7l/U2GeyMjbneA2yCL+1Zu3g96N08AgRJ9WdZ32jz1hvW6kGi3+ZLShaVK9L76Mz6IzD6t64GySJIFKbRJVMWiTc4T9yRVd4udvCp34+WSnkidOeCCjn3pPrOVILsHmbkLpMRG0R9O3PsiHqoO7SUnjUkJ0H77CXCkznjBHQA8yAHDdClNoDbkXju2Hoap0vDPz3gb/PR5ydOz3b/JIaHsab1nHkAd+CCExGCovEV0SPTxgktW16n/Qwwl7u3/7Q6WoJcQsozk9l5eMdjb+7YbN1LQsc4QaF4+JvZN1TpZFJSEu06k+4msh01k7gcGox+EEORE6FSb9Kj2k8OGnIh44bB6KF/OPul16kEsfabLAsG9LVqk7KrcC7ucF8MQaYFCO5skM9wmyVcQ6nv3mwC8vvW0q2pO/cUH6eHHxdP5ccXXv/51fvZnf5Ynn3ySz3/+8/z4j/843/72tx92tTJkyJAhQ4YMGTI8hng8d66fENINcmMPys3d4kE3T71hvceC23zvCcmRCffej8Of8UFk9rMjgh844/O545KcCMkHLpt1SjDvp0H2dl6Vu/VyEUJwdEKgMBi2KqBSZaxT7u29nr3EhhCij7gXQmyrDu0lJ4WwiY1DkoxHOXIk78HMiEDJBz9gmCxJppNkk9uRYSXRZHIHdZaUkpePSTwcM2MSRWRq75GSIXkfjk/tfWnarzn1maMSn4ixIkyVBTmv//0PM5S4j5xm54Vc4HyUY7P3Np0uiY6K0dr+/k/nhsRsUbHuNG7cmIeyaHJ8cv8IIiEE8/4SI3lHsmnj+kqbh09k7geGRT8oNKP5bjI2j5hiDo5MwFH/9kMLg/qk16kHsfSZLArKornjXJIJM66ta+NjE3uva+CBEoZybni0RUBIzrv3+pIqzC102lWi8RUdq6TtFOaPg6fz44rx8XH+9b/+1zSbTRYXF/nDP/xDzp49+7CrlSFDhgwZMmTI8InAWstaw1I1RdYa9qHYC/5pQuZetgOEEDwzr/jjj2IqbSh4XQKoGbskKhNmFSGmH6icsmzy5DHFxUUXdt27efLMArMjY/esZyp7f3JGcmZWslLTvHfxDs+cepKJArz11v75M7ry2JPMXgjBkzOSxZu3icun2GjaPlL1qVnJ3av7U9fZEcH8mOpri+mywhjD3V18frIoKIomDTvSIX1SRZQjGQXTJUdO7dW7rktsFPDVVqIhxmM2UYeaHvuAlJxc98ZpRo6w0UZijEsUJbGM5gFLD1lR3lMd0/JeOKxYq7TQQvWTYRJKARzQSwixM5MhpWTeW+SOPuyS8bmrdwKbBZYXDiuklGi99wRl+zGnjk8K3pRNYp3bEsu8U998EhjsfynBGM3gkq6EU8HGoX4w4r4oKIkGdUYwtqPnAxLiWECJBpPF8S313I9xc78oyyZPnlRcWDSs1CzNlqaQU0yXwKveZnbkzL6W90kjjX6IS9011AeOTggOjQsWbt7kmdP7v/bfLx7GOnV2TrKw5kjtgr/7Z3ZK+C+pEWrtxBd24D2SJOGfgDm1hJTH91zXdO3XpsBk0V23WmsxUirhCViJZScyYKf1JVWYNxgh0olfbqJxH1SYD3tODXtOPuxx86cBf/fv/l1+8Rd/kRdffBFjDN/7vd/Lz//8z9/3dR7kObjXsnrLHPzbw3rt015+VrfHs/xHuW4Pu/xHuW4Pu/xHuW4Pu/ysbo9P+TVT4A8uazaa0IwOsnJZM1E0nJmxD71uu33vJ4H7KSsjbu+B2VHJ5497vHdX9xFAnwTJuNfN06B/yaOIsmxy7pRkvcmeSNXd4kG8XHo38vUwDWWVHeIqR5sXjpQfSLnXS2xsORyIdlaH9pKTS1VDOxbEiVpLmjZSeB0V834cMMyOCI76t4lGnmC1TocMmynf31yY8TY4fOQob982zkfWWmSSOGjS3OHs7PEHqmdvfR9kTj1I33wSSPv/woLh1oZFIJ26VgE6pFzMUfCgFu4PIdaZC+00nNsghXKkbW57Ana/xs39wvW/n/T/rUeCyNxP7LSG1m8/Omv/w1inBknt3T6zBwn/Wktj8VJXXmdrE8BzByXtuxsPVM/e9aUaCgqeU04L3Jzd7foy+JwaVJj7RLxwONjxOo/Dd4ZHDa1Wi8XFxaGvzczM8OGHH/Lss8/y8z//8ywvL/PLv/zL/Nqv/Rp//a//9fsq55133tmP6u65zMHyH+Zrn/bys7o9nuU/ynV72OU/ynV72OU/ynV72OVndXv0y6+ZAreiOfR6C48YH0PYirnd8lhY0xz2C49V2zwqyIjbXWB2VHJgROxZublbfNo2Tw+i3P2k0NnILxhW6pZWKyYfKKaK4Nfu7Ity70HUob3k5J+8fxtbOkQzgoZWH8sBgyOLVEIWOTJsL3Ph7Kzk6TnFtRXN5Q/v8OSJwxybgLff3tiXeqZ40Dn1oMrdjxspOfnBYsx3r7XwgjzlAOq1NoHKUYsEgWf3LzJgiIp1NwTsfo2b+8Wf9jX1cVhD4WGtU3s7GOwn/K9x9vQTVNtw+cMFnjxxmJPTCmstb+7DwN2v9eVPu8L8UcRbb73FX/krf2Xoa3/rb/0t/tE/+kf8wR/8AQcOHACg2WzyS7/0S/y1v/bX8Lzdf/V+7rnnUErtS53vBa0177zzDs899xxA599KqYf62qe9/Kxuj2f5j3LdHnb5j3LdHnb5j3LdHnb5Wd0ej/KllPzBZY1ebzE9kkcIqFQrTIw4AVGlDcvhFJ9/cRzP8x7ptvkkkJa/G2TE7S6RZeH79KJ/I3/7Y1HuPYg6NB2bB7x1zj119BNSMT84WSSl5MSUZfPmGiemju5jDfcXj3oo8SdvP9KvYt3tGHtcSMYMHw8ep3Wq93k/XVZMl+msUw9q4zKI/Vpf/rQrzB81fO5zn+ODDz4Y+tr/9r/9b0xMTHRIW4Cnn36aer3O5uYmU1NTuy5HKfWJbR56y9yu/Ifx2qe9/Kxuj2f5j3LdHnb5j3LdHnb5j3LdHnb5Wd0ej/I3W4LNlsYjRvZkdhfCfRcv+obNdo5KqJjJPR5t86ggI24zZNgFPgnl3n6UkZFjHw8eB+Xm42A/kiEDZOvUIPZrfXkc1qlPAw4cOMD6+jqrq6sdkvbatWsUi0UmJycfcu0yZMiQIUOGDBk+HrRjZ9slGZ7/R0mwCML4E67YnwLsPc14hgx7QJZdMEOGjw+fBKm61zmczf0MGTJ8GnD+/HmeeOIJfvEXf5HLly/z6quv8iu/8iv85b/8lz/1hxQZMmTIkCFDhj+9yHmOnDXb0IzauCS6D5I0+9OKrMn+FGKQIJkoPOwaOSxWLRcXY9YbhkZ0kNUrmvGCwDOPSAUz7ArWWtabdMbXdPnRJeAe1bkwiMelTYfN4Ymi5anZncmIminw9SuGjaa9r889KB6X/t8vfNruN0OGRxGe5/Frv/Zr/L2/9/f4S3/pL1EsFvnJn/xJfv7nf/5hVy1DhgwZMmTIkOFjw0RRMF4Q3G56WGv7DqytdQm+HzRp9qcVGXH7pwC9m/XLy4bbm5qNhn2kyNGaKfDqdU2oBQUPIkIClWe1bomiORarloPjD7WKGXaBh0XA7QWPy0HB49Km283hlbrl1euGiW3adbFquRXN4dctBX/3n3tQPC79v1/4tN3vx4mMAM/woJibm+O/+q/+q4ddjQwZMmTIkCFDhk8MQgjOzkkW1jTVNhR8i7UQaUszFgQe+5I0+9OIjLh9zLFYtVxYjFipWerhEa5dM0gJIznwHxFy1FrLcjyFkTCaBxAIAb4SeNKy3FZcWDDMjz2aKsMMDg+LgNsLHpeDgselTXeaw76CSguW46mhJ6sXFgwaxWQuNaa/9+ceFI9L/z8oUqX2UjzBhx9qjKFvHP1pu99PAhkBniFDhgwZMmTIkCHD3jA7IjjsLxCXPt6k2Z82ZB63jzFqpsC3rmlurlvqLdAotIVIO0LEoPCVYCTnXruwYB6Kr+R6E1o2R8FnCzkjhMAjZqNpWW9kxO2jil4CbiTniLeUgBvNQRh3CbidrvFJeJymJGMYw+hAXXc7Fz6Juu5Hm35SuNccLvju9fWB5/B6w7LRtHjE9/W5B8F+9P8njb2Mt1Sp/fXLmjvxLJtNN2aM5ZG838fB4zgl/FfqlkClh5+wWncHLIvVR6/OGTJkyJAhQ4YMGTI8SijLJl8+JfnSKcUR/w5fOqX4/tMesyOPVkTp44RMcfuYwlrL3egAjcj9LmVq9gwWiA1YcoDdQo6O5T/Zuoaxyx7obXNMIDFo47IQfprxKIfn3puAs2y2HQE3Wdz6+WF2AOMFw6Fxse/3m5KMY777PdSW2CpCbfEl95wLe/Vxve96PmCbDsPH5ZV7rzm8XYbQnTKLWmsxFrSVrNQ+pv4XEMYWnfR/oO7d/8Pq+XH6D+/FKqNXqe36RKAERAY2muBbBWw9GPuk1/7e+vbOqZXLmlIAxBOPjKdzr6p8JG+JtDv8tLgIliwyJEOGDBkyZMiQIUOG3cElzeZjTZr9aUJG3D6mWGtY6raQKKucysrRtiCF+10jCTUEan/J0fslMgLPZQ+MDfjSEmpHpLRjixAQWY8ACNSnd0P8qIfn7kTAwfbEHQy3A4A8Nzcs19ct0hze1/tNSUZtoNJyBIy2eaK6mytYse1c6ITYx061aK2bS8tVw1odSgnRtB8k44O06TB8nF65vXM4GELebpchNM0sGg8Ed7RjS60NoQaNz9t3DHc2P4b+r3X7P9xF/w/i4/Yf3otVxqD9RFu7v0vhxmxsILQB7ghP7PvB2P0eMA3aVrSsphnBZgusnadySTNT3v+Dkft9TnVU5RLW6mwZN9Kah06Af1x4lA8NM2TIkCFDhgwZMmT4tCMjbh8h3M/mabUOFokn6Mpsk406nT8JmpEjRA0SXzoi5UGwFyJjouCyB1bbBUzTkT+xzdOoJfdNHhPBm7c1Z2c/fe4dKbHRjsGXIKxGACs1S/yI+FNuR8Cl2I64G+ZxqlG0244UxbpxmoYj74cfZ+CBsYKNppsRUoDAIIQi1GDIo+zWuZAq7poWwoiETs3RTsL4BbDJHN/YJ5J5r206DCkB6NVtQjJphICVuuHV6zywV246h5tRAX/ggGWnDKHDMovGVrHRdIS4taDQFH25r/1ve/rfrUyuzo4ozuFx77Xw4/YfHpwbkelVeFqq2/j/Diq1pbCdOxQCp7ztObRL1/5A9T9f9qJyvd8DpkFv5HYMbXIIA550iQrCeP/GaYq9PKfCGGKrqLZcWyoBBoNM1g1NgIz/9EWGPOqHhhkyZMiQIUOGDBkyfNqREbePCPa8eRLdHyl/22sdWG9DFENsA2YLgomiwJh7b9iHqZX2SmQIISjLGnfjcee/iCPrem8i7zky+tXr+mNNyLRbcvzjDo/uLWc5niLE9VszBE2euAWegth6j0R47iABFxk64ee+2p64GySZrLWE1gfrCFULxNaRTOUAVvYhHHk8b53i0iZEuHAkrCNwQSMwFsYL/XNlvQk1UyRKBLBunPZTfzb57H6QjMNIzRQ7kaGDSAnAyPrYuDuGoqYjx2IN8QMmABNCMOOtsu6NU2lDwdtdhtDBzKJ5z/V/StorCb4J8VWwb4kKx/MWgyDuETJbFNak/5Zos7X/e2GM4c1bmsj6lD2nuNzvpGrp3JDWsNbYqvDM+9C0W60yBpXavgSJxliFSPxtwd2btZYYjzHPHYxtNPauHN5LwrdB25Ja280hlbwusMS6S+ruh6fzXp9TvrJoJMImymw6j1ekgBiRHK6Znlceb3xakvhlyJAhQ4YMGTJkyPA4IyNud4lBwm8/iby9bJ6mSon9gZWdzbrAYAfUe0KkobSK2dHdeYts50faiu2essNba6mZMjkPjIFWDL22DtYaYqOYLGyvMtuPUM7dkuP3q9Z6kLqtN6FuCth4qzrUeSx6LNd2Ds/9JMJcUwLuzhosVh0ppG2edg2EhFIAM95W4m6QZEpVhZLEh9k6Im2zBS0FYhfhyPci1TdaAok7IdAWFN0DDW1d+yop2WjSV0YrNETJkihJNZqDfS6otp1dQGx9LiwY5kbNntp/kNQs+LsjQwex3rCs1C0xEmv6lYKRAWEgNoX78sodhrJs8uQxxcVF1z+7zRCaZhaNik+wVIMYr6N4Lueg1dCd9kj9WNfqBmP3NqY3WiIh2Xthew6LBNaypf9TLFYtb93WLFTcWF1vJMRtj2/sdv7D9zMX24l6s0WA0lsVnpEGrNpilTGo1BZCEIiIWATE2o1Yk1y/FYGwlkYE9dD22X+s1Ayvtnanch1UzkJ3/d+JcO/1Ro5Mck9YYgvWOELdWGebUAq6RPXMyD2rtG09BxX+90O4i+R/6XGNRRCZlOCXxAa+e8Nw7tDjHxmy1z7NkCFDhgwZMmTIkCHDJ4uMuN0FFiuG9+7qjyVZ0V43T5NFQVE0adiRTlIyMyTkWuA2+nEUs1jxeGZ+503YdmqlpZpTAAbW3HcipY7qKuc2xGENjDV4UqEkRLHzoYxN9zprDUcyVE2Ry8uG25v9arH7DeXcLTl+v2qtBw0zbUeWOCEyleySLqk61ODIl1a0+0Ra25W/Hypia21H3i26YtRtMUgyGevGgO6oHx2EJbExCFA7hCPvhlR3/rSW8QLUQ0cWWSTGutBxTBuBt6WM1QbdG+rYjwxrBEdCaSQLVcvvXohphHsbmympGZdOsdHcPRnai2ZkaITuHlOfU0ESNo+7/xiP5YrGWvlA/T87IpgfU6zUNO9dvMMzp55kuqwwxnD3Hp81NiXuRGccDEJiaMfwxx9pWtHwNr0XOdqOnDWMEl3C3iJ6ohIMkVZD51S6TjRCkjHeJVKNzdGOLXlfDPUfvt+1IFC20x5p0re03zzRHbfOmqI7voep39N1vhFCnJCMtbb7mxSGVrzV/kMCgQ+xnsIYw0ZLbDs2epWzqXI+xXYJ0Jxq3GKsoBmDFBZtHRmenKuQUqSxgWobhJW79nQehgdJ+BdpgUKD8Drrk0b2DFSLRLDesLuKDDHGcH0dluJJPlw1nJx+tFS6e+nTDBkyZMiQIUOGDBkyfPLIiNt7YLFi+OOPYtoxfYTffvkc7nXzJIRg3l9iSY1QD52StXdzrwT4tsVoseC8OSPNSt0p2cZ3sAfYTq1U8C2NECJ8ep0jO+Vtk0jJWuu8Wq2iHTtiQfeol3RyuxZH7PjSZZl/9bojcGrhIa59aJDCZfb29xDKuVtyfG7UdO5/InAEiE49JwNLtd2v1tqPMNNWnNIBSYhzD1/ieAeLsf1EZkrALsUTfPihRutUEbjVG3d+zJFcS/EEv3tBUwuhFR5i8ZJmumQ4Oyf7rrsdIZaODYTgQNm1TbXWYqRUwpdsaZsUvSSTMS4s2g5he3VHIimI9PBEdbsl1dNEWkrCVFkQxpZarUW5VCJQsLbpXhv0OE1bQpCSfcMhRGJBYASN0JWV97u+sr39n7b/TgrMsmxy7pRkvclQMnQnwn2xannthk5sAVzbOeLWkaOxSck6yR9fByUNVh9+oMMnlyFU7DpD6GLV8mF4mDjstqkFmhG0IwjwneWGdIkKoxhEy1IOts6pC4uGparZkRxN55QSIGWitNYapTwETtE8OKegf50o59wBgKFLpIZGODLUt1v8h4etBb7Ms1S1ROFBZpcNZ3bw77Y9Fgdp+3QOR4a0/6D6PbZ5aCevAx4hxVyOMIamLUDUfc0mNHZ6KBRR4qsfGJoRfREWh8a7RG47sh3lrLUuwWScWqXIrckv0wOW9YY7mFqr99xX7z0ikEn7OsJZ4Su75yiCXoW/MZZmDG3jUw8tBc/1u7aSldrWawYeKGEo5JzdSG9kSFpjARR9NzZ2Uu4ux+P85puGVgTGznH3iuHV64bnHyGlbq8aehj2O6ldhgwZMmTIkCFDhgwZ9oaMuN0B1lreu+uSRo3moJfw6w271FpzY0PsSVmz281TK7Jo07+RLcsmT55UvHdHc6cCOgmTzfuO5KzVDbV24p1IjrDtlGwvHB5e2E5qJSVFopjqJr3pxbBESqkCbbnmQtDX+8SDjjxIQ+Ul7vPVliOHN5vuHkyycTbG+SP6qPsO5dwtOX59zd2/GPScrDlitJCE8q7WDZUW3IzmERYmS+5e9hJmmk9IRmNhCFfp/CBFmljIkbW/d9EpAjfjWWzcVekZCoSpr6n1efUjzUjesFyzVON5qKQ0hI8J4UZoWa5pxvTEFlXzymVNKQDiCdYaFilMZ2xIKQgAT2gCJRIlmxmqZEtJpturlqVaqrQdnB+9PrIySVrl7jcd71Mls+sQ6N5EWl5Po1rr5ltofSb8rR6nxVyX1toJ1jrf2LTO7YSA1OQJG679tfV546bm/QXNar1Llk8VwR9y2OPIULaQoTspjFOysN7utqNN5hRItN7aytp0lfm9hPcgOTxV2t7+4X5sY6y1fOdDTUQw9HUDtMgTVt3hT5QkDhsvsGVOLbY8Xr9pyHv0EfeDByW9c0omtgAmKUwKt6Z4pIcD3b7uXSc85Ujf2Dg/3HQ5DDWEsaXV4z887GBIo6gma29Eju98ZLi9GfUlXwy1G7uxdkpUYV3dtOkmxwJNGDO0vVP1+6Clh8WtoZXWcLuPdL0QSbtoPDaS9TYiBPLc3LBcX7dI40j+og/WChqJ+j9dG6PEj9dYj2JyGDJ4wOIT0d7hq4ZJFOwpq7tWt7x7d29RDKnCv2kDFqrpwWCedsO97ny1fd6+Y7iz2X/NdN3QpsBoHqIGxEbT/Zok0cBaA4oBhEP8hwEuLBpux/MgXB9aq5FC0ozgu9cN83L8nvexH9hpTq/WTZ8auhg4Mj71Le9NavegCU0zZMiQIUOGDBkyZMjwYHioX8nb7Ta//Mu/zO/93u+Rz+f5uZ/7OX7u537uYVapDymRWfQhig3v3Vmk3gopbTQ4fWCGlWobS4F/+p0QISTWznLzUsR3PtIou8z7H9zgI5PjQKnMm9eXCEdv8fSBOf7Jt9/l6u1lji++xqGxMSrtCTSGyWKB62sVmu2QfGONnCept0JGTJvXrsNyvU2rPcPVt+u02jXev7bEmbWrTIwcpRlZpJBYLO0INhoNBB4qjh3hagyegs2G4vc/aLKx1KJRvoEwgjeSus2U5liutqg1W2yEhrG8T7UZYr0mJT9HKwwRwuOj5Q3CWBPGMblaxMmpCVbqEdV6ld/6k+uM5gpcX7LMtBsUgxyNdgNjAqRMyDmb+CyiE4JKEGnNRl3RNs7nsxkZZyNgJAqNrxRtbWjEksZGlTCyRDE0YsuJkTxv3LnFxQ+rvNv6gDeufsTFW7c5e3GRv/3DX+J/ev0KqINUwjZHJ8ZYbTTYrDapG0du1VptysZncc2wXI2wBKgkk5FLRmWIraAeamIt+K23WgjhIUQBQmchEesmtUbIamuDSMc02zHVMObMVJn5STfNarWQX/13f8S7127w7Ecb/Cdf+hz/9I/eoVw6RSFXwOLRjiK0MajYEnheQs4YXrtuubHeQKlZZKix1iXIkTLxrUxCe421ifrSZ6lmWa1bjNWJ97FJlM2WSEd4yqPagg0zy60rEZ6SxHGTWrNJSSvWGgpr57j+RoO5csBaI2KzWqMaxVTbmnYUk69FnJqeYKlWoxXC//zdC1RqG7z74XXOLTb5C585x//j373G3OQZRgoeCIGSznU29dt0RKNxvwNhbPjmFctaM6TVnuHaOw1myjmWqiGNRo3YxrTCiEqjyWjbcGxynEi3qbUVX/vgLgWpWVi5zejMOeqhRxgbrM1Rq5qkjTw+XG3xO28b7m7e5vKNdd6svc9Pv3AahXbh0dgeUrdbV4C484IjemMcSWKtQAvjlORGcqdiUEKijUYbSbup2WxaWq1prnzzA37q2RP8s+++31kLjo4VePfqDW5R4AfPnOLfXrjJQmWSfNii2qhTbdYZKZZoR+O8eXOTaiPPRLnG/GiBmrGARIj+uqUqbotFWzdujBWs1ELmyz6LlTZX62U++KMVlCrQDme4+naTnOdTabVoh1O8+ycbWN3m4kdLPLnyDqfmTnNpuUasJ3j9O2ucmRlBygpX74Tc9W7yxtU7fLS8xvFbIX/pMy+w0iBRJrJtm2psQjRLYm1YqUm0blCpNWlYCVbQihUehpFAslprUmvEVG2dRjNGSJ//35+s8L97boTfvXiNhj5IPiigrUzKUJhOHSQxltdvaK4uXOD1ixd4+lYF3xtH5Q5RjWJKQZlGpJHSEVlpm2ptWa6CsSE371xnuX6btTqUSkfwWlXyqsTtzbpbQ3SMlKC1IUSxsCm5tFDh3ctLnFz8Nj957gXW6y3akaGULyKEAhRaJ/1mIiJt+TfvVKi1Y7SZ4LU/XuXMzAgrjRaN0BIENQQexvhIaTtrgEjWre4BnLumsenrGillp/3X63WsllTbBh+DQBBqTRhFrNWrFIICVihadYMnBe04ItYaJRVKSqwNqG5uYJqj/JsLFVqhIq83ifwcTS1QyvQcKrj6dGEdsW4h1po/vBozkstRbdXZrNUYjUtsNAKarUmWX/+IHz17hH//wRVee+8GV2KfSq3NW1eu8WLN8h+df47NRpPY5h15b5x6V0qJEO7gIoojqo0aG/USzdY4V775Af/RuZP8y7fe5eL1dZ48+RJtr0ArMp21qr+mgmrLWU/8z9+9QK3Z5qOFFZ5YfpO/+rln+ZPrMdoIpNRExhDFGt+DQPmExnCtPcm/+O77+ELy5gduvn/PsWP8X/71V7l0c4FTb1znz7/0HBeT5/K5Qwf56oXLvPaee+8XT5zgH3/NPUeeurLCkfFx3vvoI16sWf7s88/yL9++zI3FmNfqayAC2uE0l99qUPADmlFEGM1z6e0w8TqWtGsmOdA0aJOjuhljrSGKBbK9Qrs+xi/8q29w4bp7pv6dH/kyv/3eBV6/eJUXa5a/+Lnz5PMZu5shQ4YMGTJkyJAhw8eFh/pt+1d+5Vd49913+fVf/3Xu3LnD3/7bf5uDBw/yoz/6ow+zWh24sEvL6zdvU22Fnb8HWnG3ZvBUvrMxttYS6RhjDdp4aDPO2+sFfv1//F2EEOQ8ycEPNnn+2NNMjc5ycP4gDaP59vU1irlNpkbGWa3XyfkFysUixlpqYQiqSD00vHtnjVqzQaRjPOVRLhQ5evhFVFCiFhr3d+mhpCQGfCbiiTwAAGrbSURBVK+INppmFCKFwFMetVaby3cXmRwZZ6k+yj/+f/8vIMCXgrkPNvnsqfMcnz1CMT+GsZaFakilEfHh2gLGWsr5EjOjk0hVJC8hn3OquIWaxVqFVSVadpRWG8rj87RiyXqjRqPVZKLs4SXKL6ekE50kOSREQT3SSCEI4whjDb7yUFLRCEO0aTt1rPIIYx+lJMpzV/u3V2Ia7XFEucT1dY3xDrMZr/MvXr3Av3j1AgfGpvjJl6dphW0+XF53fpB+jkhA4PkEuRyxFnz7RotiLo9M+xSLNclWXViEkPheDmOS9lapbYREyjylok+sNbGNaEQhphHyF/67f8mz8yU2Ntb59v/wdXTCXHz31hr/9BtvAvBnP1fi+IHD5H1Q0kMp58eprcVaiYngejPEWAnGEBqNpzx8pZKxl45MscXEoh278WKtxSRvFEIgpYc2JukLSaQ17VgDiiA36sqC5DDA41YlQgpJSEAt9Mj5BfKBUy9fWWlQa7UQQvC/vPoaS5urAHzt2iL/+He/w5/93FfQFq4t3WKqPMHEyFhSadGpTzqHjDFIJbm6Ume1uoHWMZ7nsVobpZQrsFQPaW1UCTwfJRXV9RofLq/jScVYsczf+1/+iFurdzk6PcePvvgkI4UyUgqk6CodpRBY4XGjYrHMM31gjDvVNv/X37nC8ekD+IEakmBv+3XCJnHt1hpHRAuQUmEttOKIUMedkGpfevh+ibu1kF/+3cvMjR/k2OGjhDrmu3c2ubJR5Hf/11f5m//jv+WnXv4Ks+NFrq/d6ZRVbW9yZ32T6dFJJkamWFhf4ebqMkenD5Lz1TZ1c2RdO4ow1iKFa4/vfHSHwPOZHp1ko9lgo76CJxUzYwGhdmTzWr2ONoZyocj8/PPUYsE7dzZpRSHWWnJ+wLW1CClLhIUzXFtVjE1McKYU0ora/MYbK8yOT0Mfabdzm2prqTRDtBWsNDQ3N5cJPJ+58RlsrLm+3kZJifJHMUZSyKfzNc8/f7vBN96/zfkToxycLG2xGkjLbIcR796pEetpKmKG33ztOnCdn/7eeTyvQCM2IAYjEwQWS2QsxijGJk4RScXYmMCTHpGOubzcQEmFpwTtsPvM8A3cXFmilC8yMnGKf/7H3+If/+53+Etf+g84Mj1PrI07yAKEkHhKIYSP54G1AYWcZq22SaPR4j0jKOeLVFpVgjgg50sCTybRC70KczfnlZR99y6EwBiL0abz2kajxUfLFebGZ8iJmEjHyTjxWK23CDcrHJs5hLHQCKNkLRHECTEqhODuZoMf+X/+Dj/58g/RCmtEOiLwfOYnZmjGbQRQCIabpcbaYK1BSo9Ks8mlu13H5MWaC9WYLI9x+UqdX/jn/zWzY1P4KuDfXHmdyfIYI4UJPvjOTX7pX36d/+NP/CzFnE2eLRbRc2AIbm7e2agAFSbKY1y7HfNL//L/lfQwHPpoiVfOvsST88e7bZk8Cyzu+EsKgVQ+t9ZKBN4EB+cPUY01v/oHtzg0NUek3QFcirY2QISSEk/6/H++cYWLt68hBfzT164B8NShk0xOnuT6Wp1f+eq7jBZK/Pubb/Puzd9yZVvLr792je5V3XPkqUMnGSlMsPJ+lTdvX2J+4gCzs2ViK2iHbWqtNhMqn/SZh+d7nbHSPTgD9xxzHjFCSKQS/N6br/J//1fvdcp7b7HCv3j1QqetfvvCLf7Rv/1j/uorL/ALP/aFoX2bIUOGDBkyZMiQIUOGB8NDI24bjQa/+Zu/ya/92q/xzDPP8Mwzz3D58mV+4zd+45EhbnMefLS8TityO5vA8xktlBkvjQL0kTtCCALPJ4wjWlFI3g/40tOf5dbqAoubq0yOzvDFpz9PIchRbTaIEwJ2bmIGJSSlfBHVQxQowHfMJM2wzVpts/NapCPWa5ucnD2KFIJG2EIKgTbaqVqtI6eUkOSDXOKgCniW2fEZaq0GE+UJJkbGWd5cZWZsjh98/ouMFUeQQnaSGnlKkfMDFjdWaEVtCrk8sXHkgpQSiUA6c1uMteSDgMSWFaUUURyT8wJyZR8hBFEcE3h+p92EEB0qF5zHqLU2CU+FSMdO0aU8YhOihMTvISGFBSkFSnmUCyVWKmu0wjZzEzN85dwX+Opb3+LW6gJLm6usVNaYm5hhvbZJzs85AlpKYqORSIQQrv69fYpASIFJCc5O4iqBlKpDsqQUpBQSbSNyfsDM2CS1VoNGu81vv9Ul3g6MTZH3c7SidofgvL58h9MHTyCEIDYaT6qux6UQGONCbdPxZaxFG90ZH71krRj4vSsOFYgOcdv1cTU4YscYS2RiCkGXuE4hhcRLyOSpkXFHThvtWHcBOT+gEOQ699N7jwDTo5OEcczc+Az5IOfqNiyjuxCohIxOlXyRtoRxxEa9QilfZHp0gljrzjiy1r1eazWItKbebhJrzcunX2SkUNrW9MAp6Vxb5fyARrvBgfEZpOcOTdQ9fFuHQUiRECzdDtDGOMVfMnaldET5gbFppkcnO+SOkpKpkXFOzh5hs1FltbrB1Mg4lYYzB02Jam00YRzRjtqMFEqMFkqMFMudsbAdpJDk/MApsmNnhaKkpJwvIoVI2i9iamQcIQStKMRXHuOlURY2llmvbXJ0+iBCCNpRSDlfQkrpxmoyHwtBHmNczHs+CGiGTUaLI7tuv9551DYhSirGSqM0N5aTdUC5NQC3TnhKbblAKVfgK+e+4EiqQePYHiglCbyAsVKeH3zue1ivV1iprJEP8gSe79SqdLWW3fklOqRmMZdP1oZ0LRPk/RyeUoRx1NP27tMTpTEC3z1D/vwX/gy3VhfI+QFSuDHhrBFE3/yzOIJNKcX06CQrlTXqrUbyHBpDm34/DNE74ntvYOA9opsdzK252q3Nged31l+ZEMjlfIFaK1HzGqfU9YV0a0pSP2Ms8+Mz/NhL30cpVyDW3THmSPt+L1hrbUIypzV29+jaMGBufIaNeqWzhgBUWw3mxg/wH3/vj1EulCjlihRzOXe4ZC3GGtpRRCHIEXfWx8EDGDcXp0cmqDRrxNqtSwfGpljaXMXi1q+DE7Nb2swmi6brL4ESikOTc7TCFmu1TbQxTI9OoKR79g2DawfJ/MQBLt6+hrHw4slneOWplyjlC24cyDSRo8UYzRee+jzfuvgab157r4+0HfycTNYfd4Bs0SbG93ymRycSdbUrO6FsAYGn+g8nBO7hkLbTueNneP3ae0OfWxbwpKTSbPPf/PtXATLyNkOGDBkyZMiQIUOGjwEPjbi9ePEicRzzwgsvdP720ksv8d/+t/+tU93Jh5/Ew7ba3Fxd4vD0PCohPgLPd68N7IhT0sFXHlJIpJCUCyX+42SDXswVKAS5oQTssZlDjrQVYijRlA9yWzaypVzBKQeBvJ8Sjm4bnaoLhRCo5IqRjomMJucH+MqjFYWM5ousV1b58jOfZao83lEmdYhVBL4STI9OUG83CZRPnKgHc36AUKpDDCilUICxJgnvd6RuOwoJlI8SEuXJziZfDetf4UiLQDn1WroZV0K6v6dtnxKQsns9KQWT5TE2G1XWa5tMlMf47KnnuLW6AMB3r7zDV859gYnyGAU/h5QuhN2TypHe1jiLAtklgzpE0pC6OoJ7wDsyIcsjHZP3AzwpO5vcw1NzfPbUc0yPTuJJRWw0K5U1vnvlHY7NHCSMo07fdMrv8bCMjcbzPDzlJaRSL8G8PdK6i6S9+uorZcdjwaYqsgHSKP1s79995XUIdEvKjQkOjE3xM9/3ZxFSEEUxrahNpVmjlCuS8zw8byuRsh3yQY7Z8enOoUEYR0RxRD7IE2unCLTGkUEpcXxj5Q6V+iZzo1McnprrzoMdyhRJWTNjU4RxlJBHe0NKiA1yZZ5U+D1j15Fmoo/YgkS7LSSFIM+BsSlKuQJRHDOVG99CVDdaTQQwMTJ+X/WVQhL4vjvkSdY0rd3YHyTutNHJ3wLAdohakR4SpWNCCFRyYBRZp5z0lcdocYRaq0Exd/8JHNM5kpavjUYlVjBhHFFMlJu9Y9QRzm33GZlYI2xzfSWVI/h0jECgjeHozEEKfi5ZX5KogCGf1UajPN9FBxhHkhWUIznbcYTnOZI5bUdPeYnSUiWHMe6g7vTBEyghE1WsW78HD03SAxZrnXJ0cmSc26sLnQR0SLUdN92xzkmRJiUjaSttDFK5+6m1GhSCfPLMcGMkXd8mR8YZL44mvtKu7yMT4Sm/Q1grKbAIDk4eQCQHhsYYYq07z8XetS39XKc/hMJYZyZskufLzNgky5trnT4tBHnGiiN4ShHp2BGWPQ1ltDswcIeKw78/pPc0UR5jvDyKMc4+5ofPvcIfvPcdDoxN8ZVzXxj6fJJCbDkIMFbje36nrpVGlVK+iO956Cjs+axMIkjcc+PZo08yXhqh0qjxmVPPucMza/Bkf2SAtpZyocgPnfsCFnj9mlO/vnjymU49XbSNAOsOGnMyIEoO+EjmUNr3nSf7gNd7Lyzps0xwaHKO//zH/6rrG9z3iIX1Zb575R1urS7gewrPShpRzK9/8w1+/gc/l9kmZMiQIUOGDBkyZMiwz3ho37CXl5eZmJggCLpJa6anp2m322xsbDA5Obmr6+jBDDz7iL/5m79NtT3CmUMnuyrIBINkUEeRlZAxaUiysYZDU3OU80VWKmtbygg8H095nY2U6SFeU0ghHLnkdTeyvvJBgEQkCZ2cNmsoIQodoi1KlFV5Auphk8nRKQ5PzjlFDi4cU/eoioRwKrKlzTUC5XcUYto6ZZ3YEk7siAkBHcI1NjGeygH0he5CvzrUGBe66yXELUAYOxLUT9soTbeTkNzGdBP1KKko54uEcbRFSXVrdYGvvvUtXjn7EuMHDncURVEcIzyPKCGGhtVr6++pqrKrF+6SvAJfeMRao63hwNgUgefzlXNfGKq2/jMvfplCkHOkRqJcxqZqOIFM2lF4vmtTKcn7uc5Gehh6673TAUiqGE7uaMu4G7zWltd6DhpM0v4p8R0on1wQMJqqQUXqA7u9CnKwXF95TI2Mc3tt0dXRuv91jyh6lMWkBLdhZmLGzY+0XrsoT0lF3pc73u+uIPrXBt/z+kmqQUV3MqbTcexsVQLWaxXK+SIzo5PEximce4nqwPOdb+d9Vc2RYlIKUg9UJRWNdpMwDjvEnTVdr1QlRWe+pj9lcgjTJca795733XpusRR7xsNu0Z1HCmt0cr8+OT/nwtSTNWI7UtXV26CSIyttzPbrjbUdwnqiNNpZY9wbbd+99ZKeKiGvU4ILazvRBH5ymCWF83KWyfOgo9jEJl6irl5KKYQ1NMO2i3Dwgi31FLI7fjypmB2f7owdmdzHdgNhMIIgVbrG2qCkGwOthGBMyXgvOWRI79tai1SyU4dIxwTK7xwcpu3UGz+hpCTWMb7nIaXc5ThI9buWWOvO/E/7yE/WQE95lHJFt/732r8o2YnS2A0c4ayItWaiPMpXzn2B8dJohwzd7jq9Y8EY21H3pup0nXxWJiS0OyDxO7cY65iNepW5iRmeOvQEUgiaUXvoYYSnPBphi7wf8MpTL3aI21eeegklJa3ECklKkTw7XCJRT3mEOu6s76mStu/+B+1gSPux59/C2XKAm1fGGEbyJQ6MTfNvXvsaC+uLFHyfQEqqzTb//Dtv8jOvvMB+4+P8npchQ4YMGTJkyJAhw6OOh0bcNpvNPtIW6Pwe9ngD3gvvvPPOvtarF1dvL/Pl8+d7CMPd0SQdTs9a2lGINobRQplyvkSt1eh7b0qEus/ZRLPXRS+pKYXsbA4jHXU2j6lyZjvSNoXvJYRostE32lkn+J5Pwol1kBKIKTl3c+Uuc+PTTmWm40RxKreEEqf1sT3Eb0c5arduFsXAv401XVsAHUOyie8SKiTXMli65VvrCI6J8nhnwyml7Cipbq0ucGt1gT+6+AbTo5PUW40OeXJgbCohzU2nl1O/0pT4tNZ0SepB38yejTwI2lGbzXqFfJAn7+d46YlntlVbHxibopQvoRNyTqnkgCD9Xycst4eAScJ0u+UPksw9yjrujZTE3vE9PddKCVhH9tNRyAu6vppp39PT58baba4+rDx3D/kg11F8ekoR65hQx3hSOZVfMsdqrQalXJHJ8oSzSEgOTXaLTn0fEAJ3qCGT/umz2NjhM+kKkxKrKgltTpXh6RxPD1/yfnDP6w4tK5mP1lpGi2WMNdRazo4hLSd9j0x+amPwleoQ0PciC9N7slj8+yRu00uGcejU8MlBznptE086X2dvwBaid1yKhCwbxHYjz5PKKWE9ho6XdB20kKhi++8v7ZfYaKRxB0E5XyZkpSSMIrxkTnfrZxKLA9sToSE6lRys62A/57xBS5fdo9OHwlBr1nnv5hWOzhxkojxGrdVADvRX6utqO6pgB6nk0DZN28PZLLjnjd9DBG8HbUyPzY9E4yI3CkG+c3CRPh9yysdTqr+/eg4bd4t0TVNSslxZY3Z8mlKuQDsOOxYnHYJ+4B7TOTJMnb5W3WRmfJKcFxDqCE96HeLUWlirbRLpiDAKUUphjN72MEIIgSdThXGRpw6dBKCUL3QON/vp1v7P7eb+O5/Z5n1pmyqhnJUDlsmRMb70zGf5/37jf3WkqnWewq9fvMq58oOvoxkyZMiQIUOGDBkyZOjioRG3uVxuC0Gb/p7PD09gMgzPPfdcxxdzv/H828scnDyANYamjvsUUTvDbey0diGogedCk3NeQOAFhHFP0hrp9X7M+WQOuaJTrnY3h91N2/akxCAETq0X65hWGFLM5xktlRzLbLYhuRx7yVhxxKmoko2qEINbxcGPOaLTk8kG25IoTRUD2tUuuZdsbK1wG3lPSpT0iHTE4voKh6fm0VqjratDzu/2RVofT0qnNEokmKmSKvW7bUVt2lFIrHUneU4v4dNR9CESGrfbdtu1d0pMG2O4s7ZEGIf4Sch5MZdnenSSarPBMLSikNFimVinV949udlTgcR/MbXwELsRtQJdH0Vrt6q1t7tE6pCYvkf0vLfzSkKkxD2ujCkRuFuk4eF5P+go4BrtJgsbywRegJISbQxhHCIQjJdGKeXzVJv1Trj7ntrzARAnbWkTD+Sdjnv6XkvenP7uJcnNwCmPU9/KVMmZvuZI8q3k3nblkdiPCClZqawDMFosAxDGUceyI23vdhQSxiFK5rsqw3v0Ya9aLzJxZ33uP+DYivQVbTS3VheYHp1kvbbJv3vrW1jgJ1/+Iay1jCfh8r1jrpfY7lo4uMpsp/I21nTmfxhHHQVpqvtM55GxWz+XtkPaFlI4L+zlyhrFXJ6J0hitsEUrCinm8u7e3WkeceJ/2tuMg7YGO6LnDMsdEuzyQDEpMIxD/vV3f5+Lt11SrNTG5dDkXIek603GBf3NFyi/74Cxr3SRHD4Ip5L0pdfXT9v1f7o2mIQwdX7QiderMR0SMkr8mT26hxBpWwhEX9TEvdBbk3K+2PHl7baTmwuD8zg95Ip7nsG96vRG1KLSqCW2J87z2FqL1i7B3GajCtCJChBCDD04651HToHsM1Io9dQhtSvpf26kz7OdDq92Gmm7md1KCI5MzTM3PkWtWU2idCwvPvUE58+f3/EKe4HW+mM9pM+QIUOGDBnAPUPXGpaqKbLWsEzcv9tXhgwZMnwseGjE7ezsLOvr68RxnHhfOvuEfD7P6Ojorq+jlPrYiNv/w5e+zB/fNkRJohmzHbk5AJEkS1mrbSIgSSbkNvCD5Fhkkk38PbbtTt3aDR1OEwGJJExyt4SYMYb1WsVtBuOIerPeUdYOu0YaClxpVp0qqqOGSl5nu42e2zSGcUyQholaaIch+VziI2n7N6eOKHEKt2qzhq88wjjmWxdf450bl/jP/sxfoVwoEkVxci82uXc6CWraSV95yqMdhSxX1vr8bgcTlQ2SVcaaDunbS1ZYLDrJwp6GwHY3yK7s1epGh5Qv54ssrC/TaLecX6cenqwmiqNOeGsc2757GoY+orvnb0bbbkh20qqDCYG2XMtaojhCCEGtVWekUN5SVkrQiP4X+jGkiJRIYaANdysPTIlzp4hTBH7Qpw7tPfwA8DyP2GiiOGJ5fZkwdqT8rhls2Hqfe0DqS2m0pmM/sU0dhv01nYeR0Z2w6mEKY2M0Y6VRwGJMvxp0GFIyFNyBhyc9vvrWtzo2HqnicrNeZWZskrwfEGvNZr2C7/mMFssd4jddE3YD2zNPYq076u4ticV63r9RrzJRHqPeavD1915lMfGJTuftrbUFThw4nBDYqc+yW2+Mtc7fNl0be9TDg+V40iXDCnWyvg8c3NhE/S+7YthO6HvHyztBL8ldyhe4sXKbRrvFken5rg2ONcRxnNjMAHTbJk1odq85m9Y9jYSI4qgTodDxMd3m8yYhDwctANJohB947vN8z5kXCOMk1L9j0ZBYecjkQBJL7/FbHyHbM8U3G1V8z2OyPJ4oxSN8NbyeFksYRUgp2WxUk8RjeRCub8MoAi+xEko+06tU79DN93kw5A6HnDq4HYZOWS0UxsbukDIK+xJqgjtUjHTUR7b2qtPL+SI3V+7yW9/5Kq+cfYmXTz1PpVnbEm0T6cjNp21WnV4luVPgu4OGJ+aOOi9bEbi1v2eOWdvtD/ec2v3as9PrgxEXQgh85XFkeo73bmwSGsNYIcdf/Nz5j+37WIYMGTJkyPBxYrFqubgYs94wNKKDrF7RjBcEnsnY2wwZMjx8PLQMYGfPnsXzPN58883O31577TWee+65RyIxGUCpHCQesil2R5CaJPHUZqPa+Wyt1cBYSzlfTLz6BL7nvBu7Pn3910l/ddmy+0OHlzZX2WhUXDZrrXdUsvXqcarNGr7nsVJZ49b6MrfXljvq3V7P0i6Z6jwN76wtUWs1OmqoVFnVW0/373RDbtFGE8Yhq5V17q4v0wib3FpbSBLW9LSrcAlvUjuIdAN8a3WBf/Pa13j3xiUAvnnxNbQx5P2g40MIjrgGR3LJZENprGGjXum0/fToJAfGpgCXqKwVtpkoj+F7Ppv1KtZa8n6AMYaVzTWaYcttghMyp95qcnd9iaXNVRcW3ROWa41hvbZJpVHD93wmymO0wrYrJ2q7xGJq+BlJh3Ayrl11R9G8DQGTbMxjrQnjCG00d9aW2ahXqLea7m+JH6DFdhSgqT+hTv6zOAIwtZSwwKU7H7K0uer6wto+cn6g0v2/9rOzPZ+xfYcdURz3KcV3QmoZkDIGt1cXuLlyd9uw69RD+vb6MguVVW6vLSRK790TOfsR4NsMW9xaXaDaarCwvtJJJpjC7kAupf3dCtu0o7YjrOKIO2uLLGyssLS5ysLGCgsby9TazaTO7jN6h0Ol7qGCO6TwlMfCxnKf9/PC+jJ5P0c+yFFrNag1G9TbjY7dx0plnSiOiI1Okkht3wa9BI+nPKI4cvVLDmuMNR0S10KHeNLGUG83OwmQUpV8it55u5GsrSk5Cxaj3dqgjeHuxjL1dtOF2HesbvoPyMLkftIoAkh8PHtI2XTtFNBZo6y1rNcraJ1EQCTrTa3V6Mz9r7/3XX7rO1/l9978JmEcYYxbw3WPAtLYrg2B8yqVO/Zj2qbGdMeQr3xMcldJ8/bfizEdQjuMQyLjfE9T5WYv7qwtJcm6LO04pB31/BeH2GQ+bdYrnTYyxnR9xumS6Ok9tcJ2fz8n9Uz9hdPeiOK4MzeaYZv1+qb7d7vN3fVl7qwv0kqegamNQd9gSw7TevtSG7PtYWvaJo6XtsQ6pq0jZ1vQQzzGRtMIW7SidmcdvbZ4g+XNNYwxHV9klRzOlfKFztoPcOnOR1RbDdpRtKUO9Xazs953bEqG9HfqodsK25w+eIJyvtj1fLW9iTKdQjyN9mlHYeeApDP+E5X40KiRtCkHX+v9m+15vxAUgwKNKMaXkp955YUsMVmGDBkyZHgsUTMFXr2uWalbAgU+IYGC1brlVjTHYvWTjeDLkCFDhkE8tG/ZhUKBn/qpn+KXfumX+C/+i/+CpaUl/sk/+Sf8/b//9x9WlbZgugSFQGHxaEUR6dbUGttHLjvSISXcJLdWF4nisC/EMuf53F69S73VZGp0Ei9XJDaa26sLNNtNZsemOzYJvRsnay2tsM2d9UVmRidZq23y1be+xdLmKn/2c19hbmKGD5duMV4aZWbUJXTrU8ckP9PwXyUVzbDJux+9jyck6/UN7q4vcnhqPrEr6DcFMNZyZ22Bi7evcfbwExyenkclCi/oknsIp1BL98Ikdge3VxeShCqW73/ue5koj7HZqDJZHu/z9tXaoJTziHzrw/d4+/oHrFTXCKRgrJijGcW8e/0C4BKzlPIFp3Q1zpk2JR+lkLSjkI16pUOaxXGMlyuS912CtLtri/y7t77FZ049x/ToJJ5U1FoNRwpYjZSKaqvBnfUlVirrnJw9glIKbQ3VZp1m1GayPIbRhqsLN8gFAdOjk4yXRomN7su6raQgpyJGR0a4s7G2ZcOc8wNqzQYIOsq5VNksknYFRyBorTtJ6NKweSklr197l7sJ8dZK6vaTL/8QUgjacUTOC5yKNylTCpeAanFzldFimfWeMXV4ao4fe+n7GCuOOEWZUp2xA0kyOEGfglFbgydSgqA7HkyShClVaEkpd61aN9ZgNSxtrvI7r3+Nxc01jkzN8/3PfU9HHZqq9UfyRdpR2BnTSPjupdcZLZQZKZTx7O5U+ZaUOLk/CrfrcxrzO69/g7XaJj/58g+hjWa5ssahyVlkYp1gEnJmq9ezIxcjrak0a90ke8m6MqgwzvkBjXaLQi6HRHSIsEFFvzGG9Xqlc6hQzhf7iCXoKi4PjE1R9HM0ozaLm6scGJvqjCmAP/c9P0o5X+yoLoNEPdmrPOz0fxpuHkXUmnU8z/nUjpdHO9YPC+vLLG2sEuqIarPOWm2zU97y5ipKJn66ySXvrC3wtXf+iBefeI7p0QnqrSbFXM6Vb11iwFqzzjcvvs7y5io/dO4L5IMcxtjOWux7XrJAOlVimhgyVXZro1mrblDMFcgHOaRwh13LlTUu371OGEecmjvK9OgkrSgkTwACWqE7BOmd+wAXb1/jpdW7HJ0+iK+8zkFK6kFqjSEymmbYIowirDWU8iVGCqX+pGoJgRcnlhk5P0AJ2TmsglTt7fyVbc/anCaiSxND2mQdG8TF29eot5uOGDRhZ63pG0/WKZnbUUjez3XabjASoBW2CeOQMO4qNHVC8g5GFKQ2Ep5QtKIQi6WUL6KtYbNR6Yz9jXqFmbHJpB1j/MSywdkDO+I+8Pzu2riDNUunbXosjSbKYyxsrDAzOtmxZ0nnVNp36ftqrQYrlXUmyqPkghxYR3YvrC/z7vULrGwsIWBLhMdghEpqpRF4fs89dRGbuHMYUW3WOl7psdbMjE11LH6E6CrEsdCM2tSSZ1gpV+wQ9amnvrEuoZ6QAi/xqk+Tv6V9Mmjf0BcVlKjuNxo1xgo5fuaVF/iFH/vC0LbOkCFDhgwZHmVYa1mOpzASRvOQHoT6SuBJy3JbcWHBMD+WkbcZMmR4eHio8oi/83f+Dr/0S7/Ez/zMz1Aul/kbf+Nv8MM//MMPs0p9mCxJZsqChYpPzvNohmEn1DeNFtY6xtoW1sZoG5DzA547fJBW1KRSqzJSKiNlQKvV4LPHSnzm0FH+ybff5ertZY7PT/LKsQKXbl0jNz0BBERag1Ck2ztrNaUAXjpxwm3uN27xC3/mBW4tV/ho8TYThw5yfOoYt9ZXCaOQwA9caK+FvoRagMRy/tAYSsZMRmOcf+ZzCCN488ptSsEc2npEWnc211KAjlr84FMlfvEH/lP+62+8DbpNLl+gHTdotC1jxdHEw8/QbNfI5zyk9Gm328yW6vzsT5zh9y95vPbeBzx/UFPKjXN5pU4YNcn5eVc/C4GvKAWK8fwmZm2N//1f+CLCCN64cIHPPPc05w4d5KsXLvPaex9wcOQOSxXJwlqNg9Mj/MQzp/iDjyJ02CCf94miJr7UTIyXOTUzxa2NGu1Q8+c+e5qf/fyf5etXr/Haex/w9EmoNta5cnuR00dn+clnTvE//Mn7XL27zLHZCXJBm8XaDUYOFzgzf4brGzlaYUzgKerNKm9efZPZiYBf/KEv8T+9/gFXby9z9MA4I7LKfCHkK186zy/+yBepxJKvvV9hbvw4y9VNKvU6o6USU+VR1uo1Lt28wOkjZ5koFbmzsUGrHZLPBUyVRtEJC18OFPVQEyeWCM6P0/XRf/nT38f/8J0/5t1rNzjz5DyjuQL1xhoTozPk/UKioBVI2RPybTTPHJqnHjZZXfyI//QHn+U/PPcs//Ktd7l4/X1mys9iyBPHEYGfI1CSOG5jkUkoMWjjNv6+UmDTBE5pMjeLEjCaLxAZjdYulZxLamQ7hEuaCX2QyCz4HtgQr3mN/9NPvMwPnjnFv//gCu9c+ZC56WdoFydoRzH5wOPEZAlPrjIVd8f0Gxcu8PRxCHXAh6tNwkjiJ36VKTGb2kOmnpypz2gnPLzn+5mzgTbJwUZ/XaV0ivGVjWWOThh+9vMvsNQIGZ08wEwxYKHmkh0JKTsenIJ+X2UhnN2B1TGHJ8c4PJZjrbbESs3nzMF5ao0GlWaD0WKRA6PjLFQ2effDN3j+iXMUgiKiJyTa2Sm0qdSXeOHoEZTMUw4UucAjDBvcvn2BP/eZY/zs5/9D/tU77/H6xas8/+RxJosl3r50mZeeOccXT5zgH3/tj/rGlIkq+KUihcCjEeoO4ZZ2nVsb3SGMo0oNT0wVWG/7NGqrPPWE5je//V3W620myjn+7k98gV/96jUu3Vzg5Pw0P/XcU1y4cZ0Xn3qWP/fCc3zt8lVee+8DnnvqFMpK3vzgEi89c4YfOP0Ev3fxJhc/vMLkoQNcW6ixVm0xNZrnP3nlGaby07x+cZNj4w1mxw/wwVLVjT8J8yOK9ZWLnH3iBJGe4vpGhKcCR5tbQ61RY6rsc3C0yK1Ki9XKBhvVa0zmPUbtMueeOs5f/dyT/Kt3r3DpxiLH5ydZ2mxxY2WN43NT/J+/8jz/43iFty5bnj15hBNTk3xw8zZ5bw4hAkKtOgkYfSVphg0u33yXE3PHmCiM0I5j8oFiriRZbqaJ/hzJpq0jEcdyeSLjDskKOYlC02zXCXIlJKpjQyNF17ZHCZgoFGhrQ73d4MS04J/+zF/jv/vmd3n32g2ePn6YHzh9kgt3buOrM/iqQKQjYq2TSA9Xbx2tcP7QLNdWm53nSzo3pFRIAViD1U1Oz03je3naYRul8ozkC0RxEiUhuokro7hFMVdIDnkEJ2amODKW5+ZGjclikfmxPIFSVOp1RnIWTwW0YoPRGqkkWIGxkPM9ioEEs8ZmM4cfFLA980J0nou2zwbCl5qXjh+n2m5w+dq75MdOkgsOUg89UCKJcGjz1tW3GC0KfujZz3G7UqDVjsgFgiiqcv3uh8xPBfzffuxZ3l8a40/eeZ9nz57m6p01Lt1eZGbkMCdnTtAKG1RqVcqlMhaPZqvBiN/GiglqoegmehSunjnPo+BLMKsIU6CU93n24AQfrqxTb25SLox0rC+EUOQUtMNFFu9e5uShaebyEVfu3OTQ5EuM5IpUWw3qzRbFfB7lSxqtOlLWOHXgKDc2Q6xIyFvr5rBTtCdEt3VzKCWHYx3zky8e5S9/7kcypW2GDBkyZHhssd6Els0x5vf75wOJr37MRtOy3rCM7T4NT4YMGTLsKx7qt+1CocA/+Af/gH/wD/7Bw6zGthBC8NJRjz+8GlFrC4q5nAtpTBwmPAklETI6MkIzgrhd5/njOZaqsN4oopAUC3nnj1O9wStnzqCU4j/7ynnefPPNThKPN998k/knilxYNKzUBPVWhJC+2zDpmJFikYmi5KnZEndzo5w//2zP58a5uGjJ+TPUGm2i1JM02bSnJJVHyPc8kefMrIcxs4w3D3D+1FEACo1V5p/IJ+Urmq2QQj5gugRedbFT77/zYy/xzdc/IB45wEbT0mi28AMPY51aLS9zPfd7k1dedJ/78fNnOEyT8+ePI6XkMzWf9y5e5uzpJ6i24fKHt3nyxGFOTiusneLNqL9u508eHrhO9/7Pnz+LlJIPq5Lba4aZ0TyHx8tsVjYZGx0DYHpkFBlu8FOfPYfneT3XeSa5Tsj5809v0zclzp939h0rSb2feepJJgpjvHVglfPnz2/bp+lrBa057C8Qj5zC98YZz+cpFvJMFCXfd3qCu6Ml5p+Y4OKiJe9P0mi2KBbyjOVhcb1OmxKxgVKQI9YRnvKJDRirmR9TnDoU8Hd/6vv6yv/m6x+wpOaohyBEasGgEjW2YbwcMFOWPDU7yt3CZKeuP/PKC7xZfpNz52ZYb8J7Fy8zd+QUtzctG408tUYb0vBbrcnnfIwFi6AZpoQdCGHxhIeQMFrwGIlu4Y0dZqUGtbYGnKLYU6JvToFLSnd0As7OFbmbH+X8+f5xdO7cZKduzzz1JNNlNXRMnz8zm/Sb1xlvlZbl21dahOQ780SKVPHqyp8fU/zIUx7v3NG8c7OF8PJMlyDUipWaxnTq6lrTkzBe8Dibb/HKj/9Up/3Xg4CmFkyWAjYacUKigUUzmnd9oYSgFN3lpbNHAHj/g+s993QwmW+n2CjmaTSLPeNmmrsTo8w/Mcr7dzVLNecfnQsCZkqCoH6HV758Zsi4HeGt8QN9/X2uLDrj5oTf7rT3sDG1HuRoxzCSk1QbTYwsYNKIcwxCKpRQWBszXgxoWcFYwee4qvPKuTP8B+fO9M2N/+ZnfmJg3vid17rz9GkAjnmtTt1+6sUTvCk3OX/+zJb59jNT6T25+/9cLei5f3jrrXxnbHywKPnutQZekKccQN0LKJVHacaCwxNFnivd5ZU/831byvirrzydrBvntrz2n//I9/DmbKF7T7lkfV8wrNQFrVZMPu8zXRKcnRvl7kiJc+cO9Y3pqZLkd96LuFsxKKnIeR5aRyjl5psSihx1ZqdKbDbBFwI/cAcqsRG0Y9uZYwiNJz20hcBTHAs2+Zs/8xND+3gsfpPcvMfbtw2tKMBXjmTO+zBp7vKVLxzvjKk/ef8GtnSIahuarRg/8DrK5bws9T37pg496a4p/MQuwtVNiZjp8SLjBcGhccXCze74v7vp8bX3K/i5EQo+5IWhVC7QiKDgS0rRXV586vCQZ8gBvvn6B4TlJ1iuQSt07aYN2I7FT1I+MaMlN6e+1FkLjyOE4NqK5vKHt3jyxGGOTQS8PTrK+fPnh8+pt253+v/l8mGCygrnTx/nS6ePJ8/pUS4u2iHfC27xyotn+sp74thBpIDLH93t3NPdzQP8/oU606N5pJScnptis7LJSNmjGUOt0UR5Bb7/tGJu9DBvvrnC+fPP9XxPcOX7Xom8Uj3l3+GVF89s6dNGqNhoxtjkK2Lv9wmR/D7ht/hzL5/t5CjIkCFDhgwZHkeEsdvHeNs4NUoM2kB7d25vGTJkyPCxIPvGfQ/Mjkq++ITPu3diVuqWVivGC1SyQYWwrQg1TJUEnlng7OwYz8xLVmqa9y7e4ZlTKVnQ3LmcEcH8mJ987hpPnzkFwPsf3OKZUymRY7g79HMq+dxt5o6c4ua6YbkG7TBKiBwI6jd5cubMtolr+su/xTOnh9e7LJucOyUTkuEOz5xxJMNq3ezqfoUQTBYFI7LBdFkxXYbNm2ucmDqKlLLr3XcfEEJwdk6ysKaptqHguzDhSFuasSDwYMKsIsT0fV97WL3//+3deVzUdf4H8NfcDMONiCCIoKICSooX5bGBeaJkh2Wtpq275U/NdNetrc01tdJ2TTOtttXdR4dbSubqupqtWh5r3iWpeCsgigpyKMMw1/f3BzECHqkJn88XXs9/gj5f5/WCGb+8/cww3yDv23831Gu+b7Xu05r349Xv4/++y8cFXSuU2QGXG3BDC5e7crPRAAc6RRive5/6aMvRJkb342ZR5ePWZNLBzwRorOfQJbbFDR9TV79ewFdrRZsQLdqGaj2PsRqPzWr3/55DeTU2cswmI0J8NGgXqsW5E8VIbB2FonJgz6E8lBmbw+2ufPKj3GqDl9kCuwtw2ivQNdry4xMMP90tyPvGF2Oqfb9VPd7O5uThgq4VrlQAihuo3IrVQaMB9D9+T/V6PTo216D0fB6KjK1w2a6BWa/ACza4dBY4XJW/Ouxt1KCZX9XXePUx76MtR5so3Y+bNQr0cAHaytOt8uMFoiqfjNHg3IkiBFuiAFz7Nd3a48Z49e9tu5p//37u47a6ml+TG1qNBiYDfnziBrDZnJW/LaABFFflGxw0sVz7valPN/v6NRoN2oRocT43D06f1iguV+CAEXbX3e9d8/yah/jYmvdj7ce0VqtFp0gdCg+Www3zj0+OaCs3yTWAjwlo6srHfa1jr3su/t/BfFzRhsDuBNxK5Z/zNgIdwrWoOFd8067tQ7WIa6b7cSPx7I8bl0BmZnGN72lTfRES27X4Mf+MZ8P5ej8Lat9m65bN4e8FHDqaW+MxXZZ39fEf6qupfMLLUvO+qXzCqfLvTROfqOv+DPHRliOxje7HbicR364Ngrw1OFXovml+1flGq9UiOljx3O6tPqZufv9fe36v+ntaPa9VSGVeyZmrX5NR74YGCpxuwFjtH5ZarQYWI1BR7oLJCJiNWtR+e4tbyb/efbrnUB5KdM1RXnkNtR9fKa6r9vi7AI0m8Ja+fiIiIlkZ9bjuz9gqbmhh0AIm7poQkUA8Bd2CUD8tmvpW+0f3Tf6BCtz5Zkn1PxdsqfzJcbubU5WbbPobbuTcav7Nel9vkyHIW7krm0N36kb/yBe9cVTdT204Xu/779mAPe9GwRUF5TYXzCbdj6+GzkOob9sb5l2zWdS26rFQhCDvqJ+8ev2NutV+bFbd/9ds5Nxgc6qpvghh0S08G4DuHzf7mvpWvgLsZk8w3A3X/Z56Xf97WnsD1q3RwdsIWIwAys6hS7sbb4DXflLlVp+Mqe1OHjd15ZoNoBpP3Nz51yjST22O3y2176efeoyH+moQZTwLh08rFForN8a9jLofX6lbeU670bk40nAeHTuGIrsIns3XylejKvj+Fr6om21cXvs13drPguq3GdOk8jZ/6nvxc+6b2t10Oh2ig3Fb+XfTz/l7GmgGvDQVKHeYYdDV3JhVFAVO6BFq1iDQW+O5WNyd5lc/Tye2alHjyT8vU83HHxERkdrdjZ+xRER1jRu3t6j2P3pk2Ky8kfrcyJFJfW3A1LdbfTX09dT3Y+FWXw37U68Aq2u38z29pmubW98Av9MnY2R2s3OhWr/G23kVd32q+crRa1+pezOVG6U//zcaRJP1vqlPGo0GIfpCFOkDUFoBmPXVfqvEAejhQvtm2rv+vfmpV4oTERGpnaifsUREt+MG7+ZCpE63+6o2tWiIX5for+l28kV3pcaLjz0CKjfxu0VVvuLV7oLnt0qCLRo0N+Qj1LduHhd8/BERUUMn6mcsEdGt4ituiYiIiCQn+jcViIiIGir+jCUimXHjloiIiEgFGutbIREREdU1/owlIlnxrRKIiIiIiIiIiIiIJMONWyIiIiIiIiIiIiLJcOOWiIiIiIiIiIiISDLcuCUiIiIiIiIiIiKSDDduiYiIiIiIiIiIiCTDjVsiIiIiIiIiIiIiyXDjloiIiIiIiIiIiEgy3LglIiIiIiIiIiIikgw3bomIiIiIiIiIiIgkw41bIiIiIiIiIiIiIslw45aIiIiIiIiIiIhIMty4JSIiIiIiIiIiIpIMN26JiIiIiIiIiIiIJKMXXeBOKYoCAHC5XPWWWZV1o//KtCY6X+ZuovNl7iY6X+ZuovNl7iY6n93UmS9zN9H5Mne73rF1qSqnau5rDGSYca/3/2R6zDWmfHZTZ77M3UTny9xNdL7M3UTns5s682XudrNj60NV1q3MuBpFpZOw3W7HDz/8ILoGEREREdWxDh06wGg0iq5RLzjjEhERETUOtzLjqnbj1u12w+l0QqvVQqPRiK5DRERERHeZoihwu93Q6/XQahvHO3xxxiUiIiJq2G5nxlXtxi0RERERERERERFRQ9U4XrpAREREREREREREpCLcuCUiIiIiIiIiIiKSDDduiYiIiIiIiIiIiCTDjVsiIiIiIiIiIiIiyXDjloiIiIiIiIiIiEgy3LglIiIiIiIiIiIikgw3bomIiIiIiIiIiIgkw41bIiIiIiIiIiIiIslw45aIiIiIiIiIiIhIMnrRBWSgKAo0Gs11P7/Z2u0cW99rovNl7iY6X+ZuovNl7iY6X+ZuovPZTZ35ddlt79690Gorn5t2u92ejzt16uRZUxQFiqLccC0pKQl79uy5pWPrYk1E/o2+p6RePB+oP5/d1JkvczfR+TJ3E50vczfR+exWc77t3LlzjTlR9Nx6szXR3ZKSkm5436iG0kitXr1amTp1qufzVatWeT6/2drtHFvfa6LzZe4mOl/mbqLzZe4mOl/mbqLz2U2d+fXRbfbs2cp9992nDB48WImPj1c6duyo9O3bV+nUqZOSlpamdO/e/SfXbufYulgTkf/SSy8phw4d8nxP3W63QupU/e9HYz8fqDWf3dSZL3M30fkydxOdL3M30fnsdnWt+nwrw9wo80xbO/+ll15SsrKyPN9jNc64jfYVtzqdDqtXr0ZYWBgmT54MvV7v+bxt27ZYvXo1mjVrhilTptRYu51j63uN3eTNl7mb6HyZu4nOl7mb6Hx2U2d+XXfTarXYtWsX3n33XRQXF+Pll1+G2WxGZGQk+vbti48++gj33HMPevTogeXLl1937dFHH4Ver8cLL7zwk8fWxZqI/KeeegoZGRlYsGABHnnkEaSmpkKj0aj3VQmNXPUZtzGfD9Scz27qzJe5m+h8mbuJzpe5m+h8dqtcqz7fhoeHY8eOHZ45UfTcKttMWzs/Pj4ev/vd7/D222/j0UcfRUpKiipn3Ea3cVt1B1ksFlgsFvzrX/9CUVERUlNT4e3tjVWrVqF169awWCxYtWoViouLkZqaelvH1vcau8mbL3M30fkydxOdL3M30fnsps78+uhmsVjwzTffwG63o1WrVti7dy8MBgPee+89vPnmm9i9ezd8fX3h5eWFzZs3w+VyXXdt3bp1SExMRJMmTX7y2LpYE5G/detWjBkzBuvWrcPy5cthMBjQu3dvVQ20VHPGbeznA7Xms5s682XuJjpf5m6i82XuJjqf3WquVZ9vLRYL/Pz8PHOi6LlVtpm2dn5QUBDef/99TJ8+HcuWLYNer1fljNvoLk5WdQdlZmYiMjISv/3tb7F3714sWLAALVq0wJQpU3DgwAEYDIYaa7dzbH2vsZu8+TJ3E50vczfR+TJ3E53PburMr+tub7/9NiIjI/Hss8/Cbrdj8uTJiI6Ohp+fH06fPo0ZM2bAZDLB4XAgOTkZXl5eqKiowN69ez1rTqcTPXr0gMvlwp49e+Dt7Y20tLTrHnuz27nTNRH5+/btw4wZM+B0OrFhwwY8++yzcLlcWL58OXJzcwFUbgaSOlSfcRvz+UDN+eymznyZu4nOl7mb6HyZu4nOZ7fKtR9++AEGgwHPPvssHA4Hnn/+eQBAdHQ0AgMDMXjwYGFzq2wzbe385ORkuFwuLFu2DE6nEzNmzFD1jNvoNm6Byjuoaqe9b9++GDt2LPLy8qDRaJCamopu3brB7XZj165dNdZu59j6XmM3efNl7iY6X+ZuovNl7iY6n93UmV+X3c6ePQsAGDhwINq0aYPdu3dj7ty5CAsLw7p16+BwODBt2jQ4nU5kZGRg3LhxcDqd+Pvf/w6n04lp06bB4XBgxYoVGDduHE6dOgW73Y5t27Zd99ib3c6dronIX7JkCdxuN2bMmIFDhw5h7dq1ePXVV5GVlYWPPvoIwNXNQFKH6jNuYz0fqD2f3dSZL3M30fkydxOdL3M30fnsloru3bvD5XIhKysLrVu3xt69e/G73/0OAQEBCAsLw/bt24XNrbLNtLXzP//8c4wfPx6HDx/Ghx9+iNDQUFXPuBpFTdvMd1FhYSEuXbqENm3aoKysDKtWrcLixYvRu3dv/OpXv8K6devwxRdfICkpCfHx8Z61qVOn3vKx9b3GbvLmy9xNdL7M3UTny9xNdD67qTP/bnf76KOPYDabMWbMGCxYsAD+/v548803MXbsWNjtdgQEBMDlciEmJgZBQUHo2bMnXnnlFXTs2BFOpxOHDh3CgAED0L17d6xcuRKZmZno2LEjjEYjTp48CUVR0Lp1a1itVhw8eBAdOnRAeHj4dW/nTtdE5A8cOBCJiYmYPXs2BgwYgGnTpuHIkSN44YUXsHTpUuTm5uIPf/gDPvnkEzRv3lxVgy3VnHFzc3MbzfmgIeWzmzrzZe4mOl/mbqLzZe4mOr+xdquaaRcvXuyZd/V6PcrKyqAoCtq1awcfHx8cOHAAMTExUBSl3uZW2Wba2vnTpk3Dxo0bPfPuwIED8dprr+Hjjz9GREQEdu7ciRdffFF1M26je49bAHC73QgODkZwcDDcbjfMZjPS09Ph4+ODhQsXQqfTYcqUKWjatCnee+896HQ6PP/881i0aBHmzp2L3/72tz95bH2vsZu8+TJ3E50vczfR+TJ3E53PburMr4tu586dwz//+U8sX74cgwYNwtKlSzFjxgwsWrQIo0ePRn5+PiIjI7Fv3z44HA64XC5ERETgwIEDcDqdsFgs2LhxIy5duoT9+/fD19fXs+bv74+5c+di3LhxcDgcsFgsOHjwIPbv33/d27nTNRH5GzZsQHl5OUJDQ7Fx40ZYLBb06tULfn5+MJvNMJvN8PX1hdlsVs1AS5Wqz7hOpxORkZF48sknG8X5oKHks5s682XuJjpf5m6i82XuJjq/MXermmmff/55fPTRR555t2XLlsjLy0NmZiYqKiowbNgwrFmzBg6Ho97mVtlm2tr5VTNt9XnXZDLB29sbGo0GXl5eqpxxG/zGbe2rxSmK4nkvC0VRoNVq4XK5YLFYkJKSAgCYPXs2jEYjxo8fD61Wi9mzZ8NgMGDixIl47bXXYDKZMH78eM+xVWvVj50wYUKdrbGbvPkydxOdL3M30fkydxOdz27qzK/rbm+88QaMRiN69OiBFStW4MiRIygpKYGXlxcOHjyIWbNmYfLkyfjLX/6C3Nxc+Pr6wul0YuPGjTAYDBgxYgQ+/vhjlJWVoW3btjh06BAA4MqVK2jVqhWOHTuGkpISLFq0CGPGjMEHH3wAq9WK8PBwnD179prbudO1+s7ftGkT9Ho9XnnlFcyePRsA8MQTT2DNmjXYt28fSktLkZ2dja+//houl0tVA21jVH3Grfq4+oxbtWaxWNC3b98Gez5Qcz67qTNf5m6i82XuJjpf5m6i89mtck2j0WDOnDlITEz0zLQjRozA+PHj8cUXXyA7OxsREREoKipCRUUF1q5di9atWyMrK6te5laZZtrrrcXGxuKbb77Bvn37UF5eXmPeXbNmDXr27ImNGzeqcsZtsG+VkJ2djaioKACVw2tOTg6ioqLgcrmQm5sLo9GIbdu2YfDgwSgoKIDBYMCWLVvQt29ffPbZZ9Dr9Rg1ahROnz6N77//HqWlpRg2bBjWr1+PuLg4HD9+HO3atcOhQ4dQWlqKkSNHIicnB9999x2Ki4tx77333vW14cOHs5uk+TJ3E50vczfR+TJ3E53PburMr49uw4cPx1dffYXS0lJYrVZ88803iIuLw7p162AymTBkyBBs3boVvr6+uHLlCvR6vedXtIxGo2dYq/pVs6NHj8LtdsPtdiMgIADFxcVQFAXx8fE4evSo5wnfqk43up07XROR7+XlBT8/P8THx+PUqVOwWq0oLS1FYGAgtNrKyx/Mnz8fcXFxIkc5uoHqM+7p06fRsmVLAIDT6UReXp5npn3wwQfxww8/4NSpU0hLS2uQ5wO15rObOvNl7iY6X+ZuovNl7iY6n91qZiiKgtWrV+PLL7/EpUuXkJCQgM2bNyMsLAxOpxNdu3bF1q1bodfrce7cOZjNZhQVFdXr3CrbTFs7X6/XQ6vVemZah8PhmXcdDgcAdc64DfIVt3v27MGSJUswatQoJCcnY+/evViyZAl++ctfwmQyYdGiRdi/fz+GDh2KmJgYz+fp6enw9/fHe++9h169eqFLly41js3NzcWmTZswf/58JCcnY/369Z61rKwsz7HJycnYvXv3XV1LT0/H7t272U3CfJm7ic6XuZvofJm7ic5nN3Xm10e39PR0VFRUYP78+Rg4cCCaNWuGpKQkrFmzBiEhISgtLUVFRQXGjRuHOXPmICwsDEuWLMHLL7+M3bt3o0+fPkhKSsK8efM8a2vXrsW8efPQrFkz/O1vf8PLL7+MzMxMtG3bFg8//LDn2MWLF+Oll1667u3c6ZqI/C5dumDx4sXo3r07pk+fDpvNhsLCQlgsFnh5eaGwsBCBgYEICAgQPc7RdVSfcQ0GA5YsWYKRI0eiR48e+P7772v8Xfn666/xu9/9Dr169aox7zaU84Fa89lNnfkydxOdL3M30fkydxOdz241MywWC86cOYN58+ahZcuW6Nq1K/7zn/94NiTDwsIwZcoUJCQkYM6cOWjRogX++te/1uvcKttMWzt/3bp1WLx4Mbp06YKXX37ZM9N6e3t75l21zrha0QXqgpeXF7Zu3YqlS5diy5Ytns8//fRT7N27F9u3b0dAQABSUlLgcDg8n3fp0gWvv/463G439Hr9dY/99ttvERAQgA4dOtzwdupijd3kzZe5m+h8mbuJzpe5m+h8dlNnfn1069KlC0aNGoX+/ftj+vTp6NevHzZu3IgBAwbg73//O8aOHYs9e/Zgz549eO6551BSUoL58+fjpZdewm9+8xscPHgQBw8exOTJk3HlyhW89dZbSE9Px+TJk1FWVob3338f06dPx69//Wvs27evxrHz5s274e3c6ZqI/AMHDmDSpEnYt28fZs2aBT8/P0RHRyMoKMjzcYAKB9rGovqMm5WVha1bt+Kf//wntm3b1ujOB2rNZzd15svcTXS+zN1E58vcTXQ+u9VcKyoqwlNPPYUBAwbgjTfewMaNG9G/f3+8++67npn2z3/+M/r164fnnnsOly9frve5VbaZtnb+0KFDMWnSJOzfvx9vvfWWZ6bVarWqn3Eb5CtuAwICYDQakZ2djYyMDKSkpHg+r3pbBIvFgoyMDLRv3x4mk8nzeZ8+fbB27dqfPPabb76p1zV2kzdf5m6i82XuJjpf5m6i89lNnfn10S0jIwP9+vXD73//eyiKAofDgSlTpmDw4MEwGAzXvQjTwoULYTAY7soFJG50O3e6JiL//fffh06nw//93//h3XffxcyZM/HKK69Ar2+QI2GDU33Gtdls0Ol0nnm3sZ0P1JrPburMl7mb6HyZu4nOl7mb6Hx2q7l25swZTJw4EUOGDMGxY8cwZcoUDBkyBBqNBunp6fDx8RE+t8o209bOf+uttzBlyhQAaHAzboN6xa3T6QQAHD58GJGRkXjjjTdgtVrx2WefITAwEG+++SZsNhtMJhOGDx8Oq9WKzZs3IyQkBG+88QZ0Oh2OHj1602ObNGlSr2vsJm++zN1E58vcTXS+zN1E57ObOvPrs5tOp0NOTg62bdvmeT+rIUOGeN6X1dvbGw888ADGjx+PDRs2YP/+/ZgwYQLWrVuHhQsXom/fvjXWJk6c6FlLSUnxHPvOO+/c8HbudE1EfmZmZo38Bx54ABMmTLhmbc6cOSLHN7oF1WfciIgIvPnmm55/LDbW84Ha8tlNnfkydxOdL3M30fkydxOdz25X14xGIx5//HFYrVZ8++23CAwMBAC0a9cOQ4cOhVarhaIosFgsSElJqde5VbaZtnZ+7Xm3en5qamqDm3EbxMbtli1bAMCzk37hwgVERkYiISEBqampAAC73Y6LFy+id+/eMBqN2LlzJ1JTU1FaWgq73Y5Lly4hNTUVGo3musdWXQTC4XDUyxq7yZsvczfR+TJ3E50vczfR+eymzvz66NapUyfP2oEDBzB16lSUl5fj008/xcqVK3H27FlkZGTg+PHjno8BoE2bNpgwYQKCg4Nx77334oknnoC/vz+0Wi1at26NCRMmICQkBF27dsW4ceOQmpqKNWvWoEWLFpgwYYLn16iq386dronIrxqYg4KCcN9992HChAnw9/eHXq/HL37xC7zyyisYNWqU5+MRI0aA5FR9xt2yZQsiIiLQokULtG/fHr1794bBYMCuXbsaxflArfnsps58mbuJzpe5m+h8mbuJzme3q2sHDx7EM888A5PJhO3bt6NTp04oKytDRkYGtm3bht27d+Pzzz+H1WpFbm4uzp49i7Vr19bL3CrbTFs7v2qm1Wg0nnm3SZMmSE5O9sy0Foulwc24GkVRFNElfo6ioiI8/fTT6N27NyZPnoyioiKMHj0aycnJeOaZZ/D0008jLi4OOTk58Pb2xokTJ5CUlISLFy9Cr9fjyJEj0Gq1iI2NxcmTJ9GtWzfk5OTAbDbj5MmTSEpKwtmzZ5GVlYXExETY7fYat1MXa+wmb77M3UTny9xNdL7M3UTns5s68+uj2/Hjx3H+/Hn0798fe/fuRUFBAUaOHIlf/OIXeOmll3D27FlYrVb07NkTVqvVc3GHtLS0GheQ6Natm+cCTWPHjq1xAYm0tDQsXLgQmZmZSE5OvuHt3OmaiPzp06fjzJkzeOihhzB48GCMHTsWDz30EAYNGoQ//elPAABFUaDRaK75mORSfcYdPXo0nn76adx3330YO3YsFEXB6NGj0a5dO1y8eBEGgwGHDx9usOcDteazmzrzZe4mOl/mbqLzZe4mOp/drq4VFhaioKAATzzxBHr06IHXXnsN+fn5GDRoEE6cOIHLly/j4MGD6N27d73PrbLNtLXzx44di2HDhmHQoEGYPn068vLyasy4tWfahjTjqv4VtwaDAVeuXMGKFSswe/ZsGAwGWK1WrFmzBu+88w6uXLmCzZs3Izw8HOXl5SgoKMDXX3+Npk2bory8HKWlpSgtLcXhw4dx8eJF/Pe//0V4eDhsNluNYx0OB3bv3g2tVnvN7dTFGrvJmy9zN9H5MncTnS9zN9H57KbO/Lru1qRJExQUFOC///0vWrRogYKCAnzyySf46quvMGLECFy6dAkAYLFYpL24hYj8qotb9O/fHxMnTsSoUaPQr18/TJs2zTM7VR9iG8pA2xBVn3GrZtp//etfeO+99zzz7v/+9z80bdoUVqu1QZ8P1JzPburMl7mb6HyZu4nOl7mb6Hx2q1zT6XQoKCjAp59+iq1bt2Ls2LEoLCzE+vXr0axZM2RlZcHlcuHSpUuN4qJst5NfdYHiP/3pTygqKrpmxq090zakGVf1G7c+Pj7QarWIj4/HgQMHsGDBAs/nR44cQXFxMeLi4pCXl4fQ0FC4XC54eXkhOzsb4eHhcDqdsFgsCAwMREVFBby8vJCTk1Pj2LNnz0Kn08FoNOLYsWMIDg6u0zV2kzdf5m6i82XuJjpf5m6i89lNnfn10e3ixYvQ6XQoKSnBvn37YDAYUFpaihUrVuDMmTMwGo0AKn+VvPrFHb777jvPhR+qLiBhNpuRnZ2Nr7/++obH1r5IxN1YE5G/bt06TJw4ETNmzMCFCxc8Hzek4bWxqD7jHj16FMXFxYiPj8fBgwfx9ttvQ6vVIi4uDrm5uQ3+fKDWfHZTZ77M3UTny9xNdL7M3UTns9vVtTNnzkCn06G0tBQrV65EcXExvLy8UFJSgs2bN6NPnz7QarU4deoUNm7cWK9zq2wzbe38fv36eWba8+fPN6oZV7Ubt1Xv8HD8+HHo9XpMnDgRgwcPxs6dO3Hp0iU899xz6NatG+x2O3x8fDB48GAcPXoUJpMJr776KoYOHYrDhw/DaDTi1Vdfxf333w+9Xo/4+HgMHToUR48ehdFoxIwZM9CjRw+4XC507twZI0eOxMmTJ+tkjd3kzZe5m+h8mbuJzpe5m+h8dlNnfn12S0hIgF6vR48ePeDv7w+TyYRRo0YhIiIC27dvR0hICP7yl78gODhYuotbiMivfnGLoKAgaDQaz8UtGsNA25BUn3F1Oh2ee+45dO3aFXa7HRaLBYMHD8auXbtQVFSE5557DmlpaQ3+fKC2fHZTZ77M3UTny9xNdL7M3UTns9vVNafTiaSkJPTs2RMGgwHdunVDREQEVq5cieDgYMyZMwfR0dG4ePEiQkJCMHfuXNjt9gZ5Ubbbza+6QHFubi62bdsGAI1uxlXdxq3L5YLL5fLcQc2bN0fr1q0RHh6OQYMGea6+t2zZMjz55JNo2bIlsrOzcfToUc+Vpzdt2oRBgwZhyJAh0Ov1+Prrr/HEE08gJiYGFy5cwOHDhz1rGzdu9NxOYWEh8vPz7/rahQsX2E3SfJm7ic6XuZvofJm7ic5nN3Xm10e377//Hunp6dDr9fjkk0/w4IMPokWLFigpKYGXlxcMBgNOnz6NNm3aQKPRwOFwwGQyITU1FUajHBe3EJH/zDPPwGg04ttvv0Vqaqrn4hZVF7XSarVQ+eUMGo3qM67L5ULz5s0RGxuLsLCwa2baoUOHAgCWLVvWIM8Has1nN3Xmy9xNdL7M3UTny9xNdD67Xc345JNPMGrUKMTExKCgoAD5+fmIjIzE5cuX0axZM1y+fBl2ux1msxmDBg0CcPUJ3IZ2UbbbzQfgyZs6dSqsViuWLVvWKGdcVV2c7K9//SuOHDmC3NxcPPbYY8jKykJRURFycnIQFhYGq9WKoqIiREVFYdeuXfDx8YHFYkHLli2xc+dOeHt7w+FwwGq1el7qXvtYp9OJs2fPwmg0onv37nW+xm7y5svcTXS+zN1E58vcTXQ+u6kzvz66hYeHY8uWLWjdujX69u2LDz74ADExMXjnnXfw73//G++//z7CwsLQpEkTZGVloWPHjnA4HFJd3EJEfkBAAIYNG4aAgAAsXLgQ3t7e6NWrF9avXw+LxYLhw4ejV69eABrWBRoaouozbrNmzTzvWfvoo4/iyJEjKCoqwunTpxvF+UCt+eymznyZu4nOl7mb6HyZu4nOZ7era506dcLWrVsRGxuLJUuW4NNPP8X777+PFi1a4JFHHsHq1auRnZ0NHx+fBn9RttvN9/b2Ro8ePbB+/XoEBARg+PDhaNasGd544w14e3vj8ccfR8+ePQE0jhlXNRu3ixcvxpIlSzBu3DgcP34cu3btQm5uLh5++GEcPnwYhw4dQlhYGKKiopCTk4Pc3FwEBQXBz88PLpcLubm5CA4OhtPpRElJCQwGAwIDA2EymTzHut1ulJaWwtfXFy6XC263G1artc7W2E3efJm7ic6XuZvofJm7ic5nN3Xm10c3Pz8/NGnSBPv27YOiKIiKikJRURGuXLmC6Oho/O1vf8ODDz6IK1euoFmzZrh48SIURUGnTp2gKAoyMzNhNBqRkpKCvLw8HDhwAFqtFj4+PigpKYHRaMT999+Pc+fOeY7t1asXNmzYcN3budM1Efk6nQ4+Pj4YOnQoWrZsiddeew1+fn7o1q0bNm7cCF9fX6SnpyMlJUX0GEc3UX3GXbNmDQ4dOoTw8HC0aNECZ86cQW5uLoYNGwatVosdO3Y06POBWvPZTZ35MncTnS9zN9H5MncTnc9uNddMJhOKioqgKApatWqFv/3tb0hPT0dZWRmioqKQnp6OhQsXAgACAwPrdW6VbaatnX/+/Hn4+fmha9eu2LRpE3x8fDy/jff66683uhlXNW+VkJWVhdGjR2PUqFGYMWMGwsPDkZCQgG+//RYGgwEPP/ww+vTpg9OnT8NsNiM+Ph5OpxNGoxFNmzZFfHw87HY7XC4XBg0ahLi4OBQXF8NoNHqOdTqdSEtLQ79+/aDRaKAoCtq2bVtna+wmb77M3UTny9xNdL7M3UTns5s68+ujm9FoxK9+9St4eXlBo9EgPz8fdrsdkZGRyM/Px8KFC+Hr64uIiAiUlJRAq9XCaJTv4hYi8v39/XHu3DmsX78eoaGh+OMf/4i8vDzs378fU6ZMwdmzZ/Hll1/CarWKHuPoJqrPuJGRkXj44YfRu3dvZGdnw2QyISEhATt37kTPnj0RERHRoM8Has1nN3Xmy9xNdL7M3UTny9xNdD671VyzWCwwmUzQaDTIzc3FokWL4Ofnh4iICFy4cAEnT56E2WyGt7c3/P39G/RF2W43v2nTpsjLy0NmZiYmTZqEc+fOYd26dQgPD8fLL7/c6GZcVWzcOp1OXLhwASUlJZ7PHQ4HYmNjkZKSggMHDqC4uBijRo1CamoqTp8+jcDAQAwZMgTl5eUoLS1F+/btkZaWBrvdDqfTienTp2PYsGHIzc1FYGAgBg8eDLvdDpvNhrFjxyItLQ0ulwshISF1ssZu8ubL3E10vszdROfL3E10PrupM78+uqWlpcFms+HChQsICgpCv379YDAY4HA40KZNG4wbNw4//PADiouLMWvWLDz66KNwu91SXdxCRH5SUhJGjhyJc+fOITo6GpMnT4aPjw9atmyJN998E5MmTUJCQgLmzJmD559/Ht7e3oInObqR6jNu1ccWiwWjRo1CSkoKTp8+DT8/P/Tt2xdvvfUWCgoKGuz5QK357KbOfJm7ic6XuZvofJm7ic5nt6trv/rVrzB06FDY7ZUXFX3ggQdgNpuxY8cOlJSUYObMmRg3bhyysrLgdrsxf/58pKam1svcKttMWzt/xowZGDp0KLKzs9GqVStMmjQJiYmJeP311zF58mSYzWa0atWq0c24Um/cHjt2DCdOnEBZWRmeeuopfPHFF/j3v/+NsrIyPPDAA/jvf/+L1q1bo2vXrtiwYQM2bdqEwYMHo2vXrti+fTvMZjO6du0Kp9OJ9evXo3379p5jd+zYgYceeghxcXH49ttv0bRpU8/axo0b8eCDD9bJGrvJmy9zN9H5MncTnS9zN9H57KbO/Pro1qVLF3z77bdo0aIFevToga+++grR0dGeJ2D1ej1OnTqF7Oxsz0VHV61ahaefflqai1uIyB81ahSio6NRUFCACxcuYODAgcjJycE//vEPaDQaaLVatGzZEs2bN4eiKIiJiUF4eLjocY6uo/qM+8ADD+CLL77A9u3bPfPu/v37a8y0er0eSUlJDfJ8oNZ8dlNnvszdROfL3E10vszdROez29W1Ll26YOPGjTh48CCefPJJ3HfffXC73RgwYIBnvnW73fj3v/+Nhx9+2DNHrl27tsFdlO1289PT06HT6bBx40YMGTIEAwcORHZ2Nj788EMoioI2bdqgWbNmnlc5N7YZV9r3uJ03bx42bdqEsrIymM1mmM1mnDlzBuXl5TAYDNDpdHA6nVAUBQEBATh//jy0Wi1CQ0NhMBiQk5MDrVYLvV6PiooKGI1GaLXaGseaTCYoigKr1Qqj0Yjg4OA6XWM3efNl7iY6X+ZuovNl7iY6n93UmV8f3ap+phcUFMDHxwchISHIy8vDo48+CpfLhePHj2P//v0IDg72vJ+WbBe3EJF/4sQJdO/eHRMmTMCqVauwdu1atGvXDjExMVi7di06dOiAl19+GQDgdruh1Ur93HyjVn3GtVqtUBTFM9OGh4ejoKAA5eXlCAkJafDnA7Xms5s682XuJjpf5m6i82XuJjqf3a6uVf254uJiNG/eHAkJCSgsLERmZiaGDx+OvLw87Nq1CzqdDi6Xq0FflO12848fP47OnTujZcuW+PLLL9GhQwdMmjQJX3zxBdauXYuOHTvipZdeAtB4Z1wpN26XLVuGRYsWYeHChbDb7Vi+fDlWr16N3r17IycnB2fOnIHBYEBSUhJOnDiBs2fPwtfXF2azGUajEXl5efDz84Pb7YbNZoPL5ULTpk2h1Wo9xwKAzWaDwWDw/Fqm1WqtszV2kzdf5m6i82XuJjpf5m6i89lNnfn10c3tdqOiosIztFa9d5ZGo4FGo0F5eTmGDRuGtWvXwmq1IiAgAC6XXBe3EJFvNpvh5eUFg8GAzp0744UXXsDnn3+ODRs2ICIiAnFxcZ5XLc+cORMkr+oz7pdffomMjAy43W506tTJM9N26dIFOp0OeXl5Dfp8oNZ8dlNnvszdROfL3E10vszdROez29W1qvlWo9F4XlXrcrnQv39/7Nu3D+Xl5SgvL0dQUBAcDkeDvyjb7eQ3a9YMeXl5MBqNSEhIQFxcHNavX4+YmBi88MIL+OKLLzjjAtCLLnA9J06cQEpKCjp27AgAWL16NZo1a4a4uDhotVpYrVY4nU40bdoUbrcbhYWFcLlciI2NxYkTJ2A0GuHj4wOj0Qir1YqioiIEBQUhMDDQc2xAQAC8vb3hdDrh5eUFnU6H8+fP19kau8mbL3M30fkydxOdL3M30fnsps78+uhmsVgQHBzseaVh8+bN4XQ6kZ+fD19fX89FmIxGI2JiYhAXF4cvv/zSc+GHc+fOwWg0wtfXF35+fsjJyYGiKBg0aBDy8vKQlZWFyMhIxMfHIzc3F263G2lpaTCZTNfczp2uicg3m81ITEzE5s2bkZmZCZvNhkceeQQ2mw27d+9Gnz59YLPZsHPnThQUFKBJkyaCJzm6keoz7po1a5CamoqCggIkJCR4ZtqCggI88sgjWLp0aYM+H6g1n93UmS9zN9H5MncTnS9zN9H57HZ1zWq1olWrVrh06RJsNhuMRiPcbjc2b96MFi1awMvLC61atcLRo0cRGBiI1NRUnDhxol7mVtlm2tr5Tz31FDZt2oQvv/wShw8fxrhx42Cz2bBjxw7YbDY89NBDnHEh2catoijQaDS4ePEiHA6H5/PLly9Dq9Viy5YtiIqKQnh4OIqLi7Fy5UqEhIR4nuH47rvvYDAYYLfbkZeXh+DgYDgcDtjtdhw+fBghISFwuVyoqKhARUUFfHx8UFFRgcLCQs9V7O72GrvJmy9zN9H5MncTnS9zN9H57KbO/ProVnU7NpsNTZo0QVlZGWw2GxwOBywWC1wuF4qLi5GbmwsvLy8UFRUhPj4eY8eOhV6vx4oVKxASEoIuXbpgy5YtUBQFiYmJ6NixI1asWAGns/ICEp999hlWrlyJbt26edZsNhvGjx9f43Y6d+58R2si8o1GI7Zu3Yrk5GT4+flh69atOHz4MHr27ImRI0fi8ccfR0BAAJ588kk89thj8Pf3Fz3O0XVUn3HtdjsAeObd8PBwz4zr6+uLoqIi/PWvf4VOp2uQ5wO15rObOvNl7iY6X+ZuovNl7iY6n92uXbPZbLBarQAAq9UKm82GgIAAOJ1OHDlyBN7e3rDb7bDb7SgoKMCVK1fqZW6Vbaatnb9161bo9XqMHTvWM++eOXPGM9P6+flBo9FwxoVkFyfTaDQAgLS0NOTm5uLChQtwuVyeK/uVlZVh4MCBKC8vR58+fRASEoL27dvDYDAgLCwMs2bNQqdOneDl5YXAwEAkJCTAYDDgwQcf9BxrNBoRFhaG0aNHQ6vVonXr1ggODkaHDh3qZI3d5M2XuZvofJm7ic6XuZvofHZTZ35dd4uJiYFOp0NoaCjS09NRUlKC5s2bw9fXF4WFhYiMjMTrr7+OmJgYXLp0CeHh4UhKSsKOHTukubiFiPxNmzbhwIEDePLJJ3Hvvfdi3bp1SElJwb333ouPP/4Y2dnZsFgsCAgIgKIosFgsjXqglV31GffMmTM4f/48Bg0ahNzcXAQEBMBms2Hw4MHQaDTw8/PDjBkzGuT5QM357KbOfJm7ic6XuZvofJm7ic5nt8q19PR0KIqC6Ohoz0wbEBCA8PBwjBkzBmVlZYiLi0NiYiL0ej0uXbqE8ePHo1u3bg3uomy3m79jxw5ERkZ6ZlpFUTzz7ocffojCwkL4+/t7LkTGGReAIqn8/HzF4XAoLpdLURRFmTdvnpKWlqZYrVYlPz9f+eCDD5T+/fsrNpvNs3b48GHPsf379//JY+t7jd3kzZe5m+h8mbuJzpe5m+h8dlNn/t3u1rVrV2XQoEFKUlKS0q5dOyUpKUnp3LmzkpCQoMTHxyvdu3dXOnbsqCQlJSn33HOP0q5dO6Vjx47K/fffr8TFxSkJCQlKamqqMmDAAM/n99xzj9K+fXslMTFR6dSpU41jq27/erdzp2si8kePHq306tVLGTFihHLkyBFl165dymOPPaZs3bq1xsekTtVn3Kq/K2lpaQ3+fNCQ8tlNnfkydxOdL3M30fkydxOd31i79ejRQ3nggQeU3r17K8nJyUpCQoLSvXt3JS4uTomPj1cGDx7smXETExPrdW6VbaatnT9x4kTPjLtixYoaMy1n3BuT6hW31YWGhkKv13uuGKfT6WC1WqHRaBAaGoqvv/4ap06dQmFhIbRaLc6dO4ehQ4fi0qVL2LlzJ06dOoWioiKEhITc8FiDwYBNmzbV2xq7yZsvczfR+TJ3E50vczfR+eymzvy72W358uUoKSnBlClT0KpVK7jdbly+fBnx8fFQFAUOhwMREREICwvzvOetxWKBVqtFXl4ezGaz59Wkp06dgsVigclk8ryVkr+/P/z9/T3Hmkwm2Gw2uN1u+Pr61ridO10TkW82m7F7927Y7XZcuHABS5YsQUBAAEwmE7766it07drV8zGpU/UZNzQ01PMrloqiQKfTNcjzQUPLZzd15svcTXS+zN1E58vcTXR+Y+yWlZWFoqIiZGdnY/r06VAUBXa7HbGxsWjatCmcTieOHTuGdu3awWQyoby8HIqiwM/Pr87nVtlm2tr5wcHB2L59O1wuFy5cuICdO3fC5XJ5ZlrOuDcm7cZtFUVRAABarRY6nQ4mkwnvvPMOMjMzERoaivDwcOzZswdXrlzB8uXLsXTpUvzwww9o1qwZwsLCsGjRop88tr7X2E3efJm7ic6XuZvofJm7ic5nN3Xm341uZ86cgdlsRmpqKvLz8wEA99xzD1wuFxwOBwDg8uXLngHP398ffn5+aNKkCUwmk+cCEi6Xy3MBiSZNmiAoKAh6vR5BQUGIjo72HOvr64ugoCCYzWbPsT93TUR+ly5d4Ovri4qKCkRFRaG4uBjz5s2DRqNBWFgYACAwMNDzMalX9RlXq9XCy8sLu3fvbpDng4aaz27qzJe5m+h8mbuJzpe5m+j8xtTt8OHDUBQFy5cvx4EDB1BUVAStVovOnTvDYrFAURQYjUYUFxfj8uXLnrkxODi4zudW2Wba2vne3t4wGo0wmUxITExEcXEx8vPzPW8nBXDGvRGNUjU1Skr58WIOS5cuxeeff4577rkHn3/+OZ566ils27YNnTt3xmeffYYWLVogOTnZs/a///3vlo+t7zV2kzdf5m6i82XuJjpf5m6i89lNnfk/p1uPHj2wYsUKRERE4MKFC0hPT8c///lPmM1mhIWF4eTJk4iOjsbp06eh1+tht9vh4+MDp9MJm82G4OBglJaWei5cZjAYUFJSAkVRPBeQKC0thVarRUhICAoLC+F0OqHT6WpcJCI4OBglJSV3tCYi3263o7y8HMnJyThy5AguXboEi8WCNm3aID8/H/n5+UhOTobBYMC+ffuwbNkytG7dWvSYRj9D9Rk3IyOjQZ4PGno+u6kzX+ZuovNl7iY6X+ZuovMbQ7etW7ciKSnJM9Omp6d75t3c3Fz4+PigtLQUer0eTqcTLpcLQUFBcDqddT63yjbT3ii/TZs2OHLkiGfevXz5Mg4fPgyTyYTk5GTY7XbOuDdSr2/M8DN8//33Stu2bZWEhATl4MGDNT5fuXLlDddu59j6XhOdL3M30fkydxOdL3M30fkydxOdz27qzP853RYvXqzExsYq8fHxysyZM5XY2FilXbt2SkpKivLBBx8osbGxSmxsrDJ16lSle/fuykMPPaQkJycrv/nNb5R77rlH6dOnj/Kf//xHeeaZZ5TExESle/fuyq9//WslOTlZ+f3vf6/06tWrxrFz5sy54e3c6ZqI/JkzZyq//OUvlZSUFGXdunXKrFmzlNdff1358MMPlVmzZilz585Vjh8/Lnoso7uoMZwPGno+u6kzX+ZuovNl7iY6X+ZuovMbQ7fXXnvNM99mZmZ65t3Y2FglIyPD87GIuVW2mbZ2/qxZs5THH39cuffee5WZM2cqc+fOVb7//ntl/fr1nHF/gmo2bq1WqzJz5kzlxIkT13x+s7XbOba+10Tny9xNdL7M3UTny9xNdL7M3UTns5s6839utz/84Q/K0aNHlStXrih/+MMflDfeeENJS0tTioqKlIceekjp16+f9Be3EJG/ePFiZciQIcrRo0eVKqdPn1aoYWos54OGnM9u6syXuZvofJm7ic6XuZvo/MbSrWq+dblcitVq9cy0hYWFysyZM5Vp06Y1yIuy3Y38xYsXKwMGDFBsNptShTPuT1PNxq2iKIrD4bjh5zdbu51j63tNdL7M3UTny9xNdL7M3UTny9xNdD67qTP/bnZbsGCBkpKSopSXlyvz589XkpKSlNjYWKWwsFB5/PHHldjYWCUvL095++23b7jmcrmUESNG3NKxdbEmIv8vf/mL0rZtW6WwsFBxuVwKNTyN8XzQ0PLZTZ35MncTnS9zN9H5MncTnd8Yu82fP98z3zocjhpzoui5VbaZtnb+3LlzOePeAukvTladXq+/4ec3W7udY+t7TXS+zN1E58vcTXS+zN1E58vcTXQ+u6kz/250UxQFer2+xkWY9u7dq6qLW4jIz8jIwNKlS/HJJ59g+fLlCAoKglarqtGNblFjOh801Hx2U2e+zN1E58vcTXS+zN1E5zembsqPl4vS6/XQ6XQwmUx47733kJmZKXxulW2mrZ0fHh6ORYsW4eOPP+aMewukvzgZERERqZtyixdhkvniFiLy7733XmRkZODTTz9FQkKC6LuRiIiIiH5Ufb79/PPPa8yJoudW2Wba2vmdOnXijHs7RL7cl4iIiBqPhnBxCxH5RERERCSnm82JoudW2Wba2vl0a/Q/vbVLRERE9PPFxsbil7/8JZ544gmEhYXhwIEDeOKJJxATE4Py8vJbWrudY+tiTUQ+EREREcmp+nwrw9wo80xbO59uDd8qgYiIiOqN0+n0vDdY9Y9vZ+1u3Y6a8omIiIhITrLNjTLPtJxxbx83bomIiIiIiIiIiIgkw8u2EREREREREREREUmGG7dEREREREREREREkuHGLREREREREREREZFkuHFLREREREREREREJBlu3BIRERERERERERFJhhu3RERERERERERERJLhxi0RkQBTpkxBnz59UF5efs3amDFj8Pjjj0NRFAHNiIiIiIjuDGdcIqK7ixu3REQCvPDCC7h8+TLef//9Gv//q6++wu7duzFjxgxoNBpB7YiIiIiIbh9nXCKiu4sbt0REAoSGhmLixIn4xz/+gdzcXACAzWbD7NmzMWbMGMTGxgpuSERERER0ezjjEhHdXdy4JSISZOTIkYiKisKf//xnAMDixYuh1Woxfvx4nDt3Ds8++ywSExORkpKChQsXwuVyef5sRkYGBgwYgISEBHTv3h2vvvqqZ/3FF1/Eiy++iKFDhyI5ORmnT58W8eURERERUSPEGZeI6O7Riy5ARNRY6fV6TJs2DSNHjsSGDRuwZMkSLFiwACaTCRMmTEC7du2wcuVKXLx4EdOmTYNGo8H48eOxa9cuzJo1C3/+858RFxeHAwcOYOrUqUhOTka/fv0AAKtWrcKiRYvQpEkTtGzZUuwXSkRERESNBmdcIqK7h6+4JSISqGvXrhgyZAgmTZqE+++/H7169cKOHTtw9uxZzJw5EzExMejevTteeOEFfPTRRwAAb29vvPbaa+jXrx8iIiIwYMAAxMXF4dixY57b7dChA1JSUtCxY0dRXxoRERERNVKccYmI7g6+4paISLBnn30Wq1evxvjx4wEAJ06cQHFxMZKSkjzHuN1u2Gw2FBUVISEhAV5eXliwYAGOHz+OI0eOIDs7Gz179vQc37x583r/OoiIiIiIqnDGJSL6+bhxS0QkmMlkqvFfp9OJmJgYvPvuu9cc6+vri61bt2L8+PF48MEH0atXL4wfPx6vvvrqdW+TiIiIiEgEzrhERD8f3yqBiEgy0dHROHv2LIKCghAVFYWoqCicOXMGCxYsgEajQUZGBh5++GHMmDEDjz76KFq1aoWcnBwoiiK6OhERERHRdXHGJSK6fdy4JSKSTM+ePdG8eXNMnToVR44cwZ49e/DKK6/AbDZDp9MhICAA3333HY4cOYJjx47hxRdfxMWLF2G320VXJyIiIiK6Ls64RES3jxu3RESS0el0eO+99+B2uzF8+HBMnDgRffr0wR//+EcAwIQJExAcHIzHHnsMY8aMgclkwogRI5CVlSW4ORERERHR9XHGJSK6fRqFv3dAREREREREREREJBW+4paIiIiIiIiIiIhIMty4JSIiIiIiIiIiIpIMN26JiIiIiIiIiIiIJMONWyIiIiIiIiIiIiLJcOOWiIiIiIiIiIiISDLcuCUiIiIiIiIiIiKSDDduiYiIiIiIiIiIiCTDjVsiIiIiIiIiIiIiyXDjloiIiIiIiIiIiEgy3LglIiIiIiIiIiIikgw3bomIiIiIiIiIiIgkw41bIiIiIiIiIiIiIsn8Py1Zvfc6245iAAAAAElFTkSuQmCC" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 6 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "##############################################################################################\n", + "########################## STEP 2 - USE THESE IN PREDICTIONS ##########################\n", + "##############################################################################################\n" + ], + "id": "647bfa3bcd7e63e2" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-03T17:54:14.908641Z", + "start_time": "2024-12-03T17:54:11.947154Z" + } + }, + "cell_type": "code", + "source": [ + "if use_residuals:\n", + " y_weather = y[mask_ANC_data] - y_pred\n", + " X = np.column_stack([\n", + " weather_data[mask_ANC_data],\n", + " np.array(year_flattened)[mask_ANC_data],\n", + " #np.array(month_flattened)[mask_ANC_data],\n", + " np.array(month_encoded)[mask_ANC_data],\n", + " resid_encoded[mask_ANC_data],\n", + " zone_encoded[mask_ANC_data],\n", + " owner_encoded[mask_ANC_data],\n", + " ftype_encoded[mask_ANC_data],\n", + " facility_encoded[mask_ANC_data],\n", + " lag_1_month[mask_ANC_data],\n", + " lag_2_month[mask_ANC_data],\n", + " lag_3_month[mask_ANC_data],\n", + " lag_4_month[mask_ANC_data],\n", + " np.array(altitude)[mask_ANC_data],\n", + " np.array(minimum_distance)[mask_ANC_data]\n", + " ])\n", + "else:\n", + " y_weather = y \n", + " X = np.column_stack([\n", + " weather_data,\n", + " year_flattened,\n", + " #month_flattened,\n", + " month_encoded,\n", + " resid_encoded,\n", + " zone_encoded,\n", + " owner_encoded,\n", + " ftype_encoded,\n", + " lag_1_month,\n", + " lag_2_month,\n", + " lag_3_month,\n", + " lag_4_month,\n", + " facility_encoded,\n", + " np.array(altitude), \n", + " np.array(minimum_distance)\n", + " ])\n", + "\n", + "results_of_weather_model, y_pred_weather, mask_all_data = build_model(X, y_weather, poisson = poisson, log_y=log_y, X_mask_mm=mask_threshold)\n", + "\n", + "print(\"All predictors\", results_of_weather_model.summary())\n", + "\n", + "##### Plot y_predic\n", + "\n", + "X_filtered = X[mask_all_data]\n", + "print(y_pred_weather)\n", + "plt.scatter(X_filtered[:, 0], (y_weather[mask_all_data]), color='red', alpha=0.5)\n", + "if log_y:\n", + " plt.scatter(X_filtered[:, 0], np.exp(y_pred_weather))\n", + "else:\n", + " plt.scatter(X_filtered[:, 0], y_pred_weather)\n", + "plt.title(' ')\n", + "plt.ylabel('Change in ANC visits')\n", + "plt.xlabel('Precip (mm)')\n", + "plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.)\n", + "plt.show()\n", + "\n", + "\n", + "plt.scatter(X_filtered[:, 0], y_weather[mask_all_data], color='red', alpha=0.5)\n", + "if log_y:\n", + " plt.scatter(X_filtered[:, 0], np.exp(y_pred_weather))\n", + "else:\n", + " plt.scatter(X_filtered[:, 0], y_pred_weather)\n", + "plt.ylim((-1000,2000))\n", + "plt.title(' ')\n", + "plt.ylabel('Change in ANC visits')\n", + "plt.xlabel('Precip (mm)')\n", + "plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.)\n", + "plt.show()\n", + "\n" + ], + "id": "2f88473d3723adda", + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "All predictors OLS Regression Results \n", + "=======================================================================================\n", + "Dep. Variable: y R-squared (uncentered): 0.976\n", + "Model: OLS Adj. R-squared (uncentered): 0.976\n", + "Method: Least Squares F-statistic: 2204.\n", + "Date: Tue, 03 Dec 2024 Prob (F-statistic): 0.00\n", + "Time: 17:54:14 Log-Likelihood: -22396.\n", + "No. Observations: 19766 AIC: 4.552e+04\n", + "Df Residuals: 19404 BIC: 4.837e+04\n", + "Df Model: 362 \n", + "Covariance Type: nonrobust \n", + "==============================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "x1 3.705e-05 0.000 0.321 0.748 -0.000 0.000\n", + "x2 -4.85e-05 0.000 -0.381 0.703 -0.000 0.000\n", + "x3 4.4725 0.232 19.282 0.000 4.018 4.927\n", + "x4 4.4930 0.232 19.388 0.000 4.039 4.947\n", + "x5 4.4103 0.232 19.016 0.000 3.956 4.865\n", + "x6 0.0058 0.026 0.226 0.821 -0.045 0.057\n", + "x7 4.4602 0.232 19.226 0.000 4.005 4.915\n", + "x8 4.4765 0.232 19.317 0.000 4.022 4.931\n", + "x9 4.4082 0.232 19.005 0.000 3.954 4.863\n", + "x10 -0.0032 0.026 -0.120 0.904 -0.055 0.048\n", + "x11 4.4649 0.232 19.248 0.000 4.010 4.920\n", + "x12 4.5295 0.232 19.547 0.000 4.075 4.984\n", + "x13 4.4273 0.232 19.088 0.000 3.973 4.882\n", + "x14 0.0528 0.039 1.339 0.181 -0.025 0.130\n", + "x15 0.0018 0.022 0.082 0.935 -0.041 0.045\n", + "x16 -0.0159 0.022 -0.729 0.466 -0.059 0.027\n", + "x17 0.0186 0.023 0.799 0.424 -0.027 0.064\n", + "x18 0.0516 0.025 2.056 0.040 0.002 0.101\n", + "x19 -0.0290 0.028 -1.026 0.305 -0.084 0.026\n", + "x20 0.0448 0.054 0.825 0.409 -0.062 0.151\n", + "x21 0.1132 0.105 1.076 0.282 -0.093 0.319\n", + "x22 0.1342 0.087 1.550 0.121 -0.035 0.304\n", + "x23 0.1338 0.088 1.520 0.129 -0.039 0.306\n", + "x24 0.1233 0.071 1.731 0.083 -0.016 0.263\n", + "x25 0.1515 0.080 1.895 0.058 -0.005 0.308\n", + "x26 0.1119 0.102 1.099 0.272 -0.088 0.311\n", + "x27 0.1552 0.082 1.903 0.057 -0.005 0.315\n", + "x28 4.252e-05 0.000 0.303 0.762 -0.000 0.000\n", + "x29 6.167e-05 0.000 0.442 0.658 -0.000 0.000\n", + "x30 8.721e-05 0.000 0.784 0.433 -0.000 0.000\n", + "x31 0.0002 0.000 1.578 0.115 -4.39e-05 0.000\n", + "x32 -1.3766 0.128 -10.761 0.000 -1.627 -1.126\n", + "x33 1.9964 0.087 22.927 0.000 1.826 2.167\n", + "x34 1.8243 0.088 20.693 0.000 1.651 1.997\n", + "x35 4.5983 0.255 18.049 0.000 4.099 5.098\n", + "x36 1.0265 0.089 11.484 0.000 0.851 1.202\n", + "x37 0.9694 0.087 11.132 0.000 0.799 1.140\n", + "x38 -0.0008 0.088 -0.009 0.993 -0.173 0.171\n", + "x39 3.7093 0.256 14.487 0.000 3.207 4.211\n", + "x40 0.5601 0.092 6.096 0.000 0.380 0.740\n", + "x41 0.3963 0.094 4.215 0.000 0.212 0.581\n", + "x42 1.2338 0.092 13.443 0.000 1.054 1.414\n", + "x43 4.0639 0.254 15.993 0.000 3.566 4.562\n", + "x44 0.6548 0.089 7.324 0.000 0.480 0.830\n", + "x45 0.3446 0.088 3.905 0.000 0.172 0.518\n", + "x46 -2.7669 0.107 -25.766 0.000 -2.977 -2.556\n", + "x47 4.7796 0.255 18.749 0.000 4.280 5.279\n", + "x48 -2.8521 0.161 -17.742 0.000 -3.167 -2.537\n", + "x49 0.3483 0.088 3.947 0.000 0.175 0.521\n", + "x50 -0.2252 0.089 -2.538 0.011 -0.399 -0.051\n", + "x51 4.5429 0.256 17.712 0.000 4.040 5.046\n", + "x52 0.0263 0.089 0.296 0.767 -0.148 0.200\n", + "x53 0.5357 0.097 5.522 0.000 0.346 0.726\n", + "x54 1.8634 0.088 21.271 0.000 1.692 2.035\n", + "x55 5.8783 0.254 23.151 0.000 5.381 6.376\n", + "x56 -0.6414 0.089 -7.211 0.000 -0.816 -0.467\n", + "x57 1.5420 0.089 17.363 0.000 1.368 1.716\n", + "x58 -1.5629 0.088 -17.727 0.000 -1.736 -1.390\n", + "x59 4.4701 0.259 17.289 0.000 3.963 4.977\n", + "x60 0.6569 0.090 7.299 0.000 0.480 0.833\n", + "x61 -0.6068 0.131 -4.623 0.000 -0.864 -0.350\n", + "x62 0.0984 0.089 1.102 0.271 -0.077 0.273\n", + "x63 4.2406 0.257 16.513 0.000 3.737 4.744\n", + "x64 0.7721 0.089 8.694 0.000 0.598 0.946\n", + "x65 -0.5270 0.088 -6.013 0.000 -0.699 -0.355\n", + "x66 0.9885 0.091 10.899 0.000 0.811 1.166\n", + "x67 5.0278 0.254 19.756 0.000 4.529 5.527\n", + "x68 0.8106 0.098 8.313 0.000 0.619 1.002\n", + "x69 -0.3650 0.095 -3.852 0.000 -0.551 -0.179\n", + "x70 0.7162 0.092 7.750 0.000 0.535 0.897\n", + "x71 5.7262 0.258 22.206 0.000 5.221 6.232\n", + "x72 0.0155 0.093 0.167 0.868 -0.167 0.198\n", + "x73 1.0096 0.087 11.593 0.000 0.839 1.180\n", + "x74 -0.0727 0.088 -0.830 0.407 -0.244 0.099\n", + "x75 5.1827 0.256 20.226 0.000 4.680 5.685\n", + "x76 -2.0700 0.090 -23.004 0.000 -2.246 -1.894\n", + "x77 -3.7635 0.099 -37.851 0.000 -3.958 -3.569\n", + "x78 -2.2680 0.089 -25.563 0.000 -2.442 -2.094\n", + "x79 4.2767 0.255 16.794 0.000 3.778 4.776\n", + "x80 1.0238 0.088 11.679 0.000 0.852 1.196\n", + "x81 -1.4396 0.099 -14.483 0.000 -1.634 -1.245\n", + "x82 0.0266 0.089 0.298 0.766 -0.148 0.202\n", + "x83 3.7391 0.258 14.496 0.000 3.234 4.245\n", + "x84 1.6166 0.085 19.012 0.000 1.450 1.783\n", + "x85 0.8149 0.091 8.988 0.000 0.637 0.993\n", + "x86 0.8977 0.088 10.177 0.000 0.725 1.071\n", + "x87 0.7275 0.258 2.821 0.005 0.222 1.233\n", + "x88 -0.8747 0.097 -9.043 0.000 -1.064 -0.685\n", + "x89 0.5544 0.087 6.367 0.000 0.384 0.725\n", + "x90 1.4995 0.178 8.448 0.000 1.152 1.847\n", + "x91 5.0399 0.254 19.805 0.000 4.541 5.539\n", + "x92 1.3584 0.089 15.197 0.000 1.183 1.534\n", + "x93 0.6807 0.089 7.613 0.000 0.505 0.856\n", + "x94 -4.3977 0.750 -5.863 0.000 -5.868 -2.928\n", + "x95 4.6917 0.255 18.422 0.000 4.192 5.191\n", + "x96 -0.1922 0.088 -2.192 0.028 -0.364 -0.020\n", + "x97 -1.0008 0.087 -11.472 0.000 -1.172 -0.830\n", + "x98 -0.7607 0.161 -4.732 0.000 -1.076 -0.446\n", + "x99 3.2058 0.256 12.520 0.000 2.704 3.708\n", + "x100 -0.0575 0.088 -0.656 0.512 -0.229 0.114\n", + "x101 0.0334 0.089 0.374 0.709 -0.142 0.209\n", + "x102 -0.1020 0.105 -0.969 0.333 -0.309 0.104\n", + "x103 4.1386 0.256 16.183 0.000 3.637 4.640\n", + "x104 0.5666 0.089 6.339 0.000 0.391 0.742\n", + "x105 0.0261 0.091 0.288 0.774 -0.152 0.204\n", + "x106 -1.3051 0.284 -4.596 0.000 -1.862 -0.748\n", + "x107 4.1941 0.255 16.459 0.000 3.695 4.694\n", + "x108 1.4557 0.088 16.499 0.000 1.283 1.629\n", + "x109 -2.3244 0.093 -24.901 0.000 -2.507 -2.141\n", + "x110 1.2385 0.089 13.958 0.000 1.065 1.412\n", + "x111 6.1283 0.254 24.121 0.000 5.630 6.626\n", + "x112 -0.7592 0.091 -8.320 0.000 -0.938 -0.580\n", + "x113 -0.3383 0.101 -3.344 0.001 -0.537 -0.140\n", + "x114 -4.4850 0.201 -22.298 0.000 -4.879 -4.091\n", + "x115 4.5196 0.254 17.773 0.000 4.021 5.018\n", + "x116 0.1071 0.120 0.894 0.371 -0.128 0.342\n", + "x117 0.9122 0.089 10.201 0.000 0.737 1.087\n", + "x118 0.4930 0.088 5.592 0.000 0.320 0.666\n", + "x119 5.1641 0.257 20.088 0.000 4.660 5.668\n", + "x120 1.5677 0.087 17.995 0.000 1.397 1.738\n", + "x121 -0.2209 0.103 -2.146 0.032 -0.423 -0.019\n", + "x122 0.6985 0.101 6.928 0.000 0.501 0.896\n", + "x123 3.4953 0.257 13.614 0.000 2.992 3.999\n", + "x124 0.5448 0.090 6.052 0.000 0.368 0.721\n", + "x125 0.8503 0.095 8.977 0.000 0.665 1.036\n", + "x126 0.7178 0.094 7.651 0.000 0.534 0.902\n", + "x127 5.0968 0.254 20.062 0.000 4.599 5.595\n", + "x128 0.3623 0.095 3.803 0.000 0.176 0.549\n", + "x129 0.2984 0.099 3.002 0.003 0.104 0.493\n", + "x130 0.0053 0.094 0.057 0.955 -0.179 0.189\n", + "x131 4.4541 0.257 17.344 0.000 3.951 4.957\n", + "x132 0.8292 0.089 9.277 0.000 0.654 1.004\n", + "x133 0.6453 0.090 7.169 0.000 0.469 0.822\n", + "x134 -0.8931 0.090 -9.929 0.000 -1.069 -0.717\n", + "x135 4.3267 0.259 16.717 0.000 3.819 4.834\n", + "x136 0.7836 0.088 8.882 0.000 0.611 0.957\n", + "x137 0.7963 0.087 9.203 0.000 0.627 0.966\n", + "x138 0.2221 0.089 2.487 0.013 0.047 0.397\n", + "x139 4.4126 0.256 17.237 0.000 3.911 4.914\n", + "x140 0.9907 0.087 11.372 0.000 0.820 1.161\n", + "x141 0.4549 0.089 5.087 0.000 0.280 0.630\n", + "x142 1.0341 0.091 11.416 0.000 0.857 1.212\n", + "x143 6.3703 0.264 24.146 0.000 5.853 6.887\n", + "x144 0.2672 0.089 2.988 0.003 0.092 0.442\n", + "x145 0.8735 0.091 9.633 0.000 0.696 1.051\n", + "x146 1.3309 0.099 13.424 0.000 1.137 1.525\n", + "x147 3.9324 0.256 15.374 0.000 3.431 4.434\n", + "x148 1.7781 0.098 18.082 0.000 1.585 1.971\n", + "x149 0.1430 0.088 1.621 0.105 -0.030 0.316\n", + "x150 -0.2508 0.089 -2.826 0.005 -0.425 -0.077\n", + "x151 5.2642 0.254 20.717 0.000 4.766 5.762\n", + "x152 0.8160 0.091 9.008 0.000 0.638 0.994\n", + "x153 0.8386 0.095 8.855 0.000 0.653 1.024\n", + "x154 0.1292 0.108 1.191 0.233 -0.083 0.342\n", + "x155 2.6064 0.255 10.234 0.000 2.107 3.106\n", + "x156 1.0393 0.087 11.998 0.000 0.869 1.209\n", + "x157 -0.8539 0.093 -9.221 0.000 -1.035 -0.672\n", + "x158 -1.3418 0.089 -15.120 0.000 -1.516 -1.168\n", + "x159 5.0147 0.255 19.677 0.000 4.515 5.514\n", + "x160 -1.4755 0.251 -5.885 0.000 -1.967 -0.984\n", + "x161 0.1005 0.099 1.011 0.312 -0.094 0.295\n", + "x162 -2.4487 0.091 -27.047 0.000 -2.626 -2.271\n", + "x163 4.1986 0.266 15.773 0.000 3.677 4.720\n", + "x164 0.9252 0.088 10.487 0.000 0.752 1.098\n", + "x165 -0.8374 0.089 -9.430 0.000 -1.012 -0.663\n", + "x166 1.2691 0.089 14.302 0.000 1.095 1.443\n", + "x167 5.4841 0.254 21.569 0.000 4.986 5.982\n", + "x168 0.4087 0.091 4.511 0.000 0.231 0.586\n", + "x169 0.3859 0.087 4.432 0.000 0.215 0.557\n", + "x170 0.4521 0.101 4.488 0.000 0.255 0.649\n", + "x171 0.1277 0.270 0.472 0.637 -0.402 0.658\n", + "x172 -2.3806 0.433 -5.494 0.000 -3.230 -1.531\n", + "x173 1.0554 0.092 11.475 0.000 0.875 1.236\n", + "x174 0.2079 0.091 2.297 0.022 0.031 0.385\n", + "x175 4.4785 0.254 17.598 0.000 3.980 4.977\n", + "x176 -0.3396 0.106 -3.192 0.001 -0.548 -0.131\n", + "const 1.847e-16 1.16e-16 1.594 0.111 -4.24e-17 4.12e-16\n", + "x177 0.8799 0.092 9.588 0.000 0.700 1.060\n", + "x178 5.6759 0.255 22.301 0.000 5.177 6.175\n", + "x179 0.2881 0.093 3.114 0.002 0.107 0.469\n", + "x180 -0.0536 0.088 -0.611 0.541 -0.225 0.118\n", + "x181 0.8386 0.089 9.451 0.000 0.665 1.013\n", + "x182 4.3527 0.255 17.059 0.000 3.853 4.853\n", + "x183 -0.8235 0.096 -8.611 0.000 -1.011 -0.636\n", + "x184 -0.7501 0.093 -8.040 0.000 -0.933 -0.567\n", + "x185 -0.8175 0.088 -9.332 0.000 -0.989 -0.646\n", + "x186 2.6288 0.259 10.141 0.000 2.121 3.137\n", + "x187 0.8246 0.098 8.388 0.000 0.632 1.017\n", + "x188 -0.5031 0.089 -5.624 0.000 -0.678 -0.328\n", + "x189 -1.0291 0.088 -11.748 0.000 -1.201 -0.857\n", + "x190 3.7065 0.257 14.431 0.000 3.203 4.210\n", + "x191 0.2965 0.089 3.316 0.001 0.121 0.472\n", + "x192 1.8581 0.099 18.848 0.000 1.665 2.051\n", + "x193 -0.0644 0.091 -0.712 0.477 -0.242 0.113\n", + "x194 4.5869 0.255 18.022 0.000 4.088 5.086\n", + "x195 0.9707 0.091 10.711 0.000 0.793 1.148\n", + "x196 -0.1926 0.088 -2.198 0.028 -0.364 -0.021\n", + "x197 1.0355 0.113 9.164 0.000 0.814 1.257\n", + "x198 2.7799 0.262 10.591 0.000 2.265 3.294\n", + "x199 -0.6528 0.120 -5.451 0.000 -0.888 -0.418\n", + "x200 0.3345 0.099 3.365 0.001 0.140 0.529\n", + "x201 0.7180 0.103 6.942 0.000 0.515 0.921\n", + "x202 -0.0559 0.289 -0.193 0.847 -0.622 0.510\n", + "x203 -1.3092 0.123 -10.657 0.000 -1.550 -1.068\n", + "x204 0.4801 0.099 4.869 0.000 0.287 0.673\n", + "x205 -0.1714 0.105 -1.628 0.104 -0.378 0.035\n", + "x206 5.7305 0.260 22.012 0.000 5.220 6.241\n", + "x207 -0.0759 0.097 -0.778 0.436 -0.267 0.115\n", + "x208 -1.6290 0.108 -15.085 0.000 -1.841 -1.417\n", + "x209 0.9060 0.100 9.075 0.000 0.710 1.102\n", + "x210 6.4321 0.272 23.635 0.000 5.899 6.966\n", + "x211 0.5240 0.098 5.374 0.000 0.333 0.715\n", + "x212 -0.7460 0.101 -7.378 0.000 -0.944 -0.548\n", + "x213 -0.9292 0.143 -6.512 0.000 -1.209 -0.650\n", + "x214 -0.0406 0.262 -0.155 0.877 -0.554 0.473\n", + "x215 -4.4969 0.102 -44.245 0.000 -4.696 -4.298\n", + "x216 0.5099 0.103 4.953 0.000 0.308 0.712\n", + "x217 0.1854 0.100 1.857 0.063 -0.010 0.381\n", + "x218 5.0045 0.262 19.130 0.000 4.492 5.517\n", + "x219 0.6829 0.098 7.003 0.000 0.492 0.874\n", + "x220 1.4211 0.098 14.536 0.000 1.229 1.613\n", + "x221 -1.3962 0.104 -13.383 0.000 -1.601 -1.192\n", + "x222 5.1203 0.259 19.796 0.000 4.613 5.627\n", + "x223 -1.0768 0.114 -9.420 0.000 -1.301 -0.853\n", + "x224 0.1023 0.102 1.002 0.316 -0.098 0.302\n", + "x225 1.6563 0.098 16.863 0.000 1.464 1.849\n", + "x226 5.3104 0.259 20.475 0.000 4.802 5.819\n", + "x227 0.9486 0.101 9.412 0.000 0.751 1.146\n", + "x228 -0.3787 0.103 -3.677 0.000 -0.581 -0.177\n", + "x229 0.2854 0.099 2.882 0.004 0.091 0.480\n", + "x230 5.2710 0.261 20.182 0.000 4.759 5.783\n", + "x231 0.1716 0.103 1.674 0.094 -0.029 0.373\n", + "x232 0.7966 0.104 7.667 0.000 0.593 1.000\n", + "x233 1.5023 0.097 15.420 0.000 1.311 1.693\n", + "x234 5.4116 0.259 20.898 0.000 4.904 5.919\n", + "x235 0.0389 0.098 0.396 0.692 -0.154 0.232\n", + "x236 -2.5379 0.131 -19.337 0.000 -2.795 -2.281\n", + "x237 1.7632 0.128 13.788 0.000 1.513 2.014\n", + "x238 5.3306 0.258 20.658 0.000 4.825 5.836\n", + "x239 0.1808 0.102 1.779 0.075 -0.018 0.380\n", + "x240 -0.2837 0.104 -2.730 0.006 -0.487 -0.080\n", + "x241 0.1803 0.105 1.712 0.087 -0.026 0.387\n", + "x242 5.0276 0.259 19.439 0.000 4.521 5.535\n", + "x243 0.1390 0.102 1.368 0.171 -0.060 0.338\n", + "x244 1.1046 0.096 11.477 0.000 0.916 1.293\n", + "x245 0.8131 0.102 8.005 0.000 0.614 1.012\n", + "x246 5.1668 0.263 19.648 0.000 4.651 5.682\n", + "x247 0.4615 0.098 4.693 0.000 0.269 0.654\n", + "x248 0.0511 0.097 0.527 0.598 -0.139 0.241\n", + "x249 -0.1395 0.102 -1.361 0.174 -0.340 0.061\n", + "x250 6.0510 0.260 23.271 0.000 5.541 6.561\n", + "x251 0.4695 0.106 4.413 0.000 0.261 0.678\n", + "x252 0.1100 0.101 1.088 0.277 -0.088 0.308\n", + "x253 -0.3864 0.105 -3.669 0.000 -0.593 -0.180\n", + "x254 4.6433 0.260 17.885 0.000 4.134 5.152\n", + "x255 -0.9023 0.106 -8.484 0.000 -1.111 -0.694\n", + "x256 0.6881 0.115 5.973 0.000 0.462 0.914\n", + "x257 1.4363 0.106 13.514 0.000 1.228 1.645\n", + "x258 5.9228 0.260 22.748 0.000 5.412 6.433\n", + "x259 0.3620 0.103 3.499 0.000 0.159 0.565\n", + "x260 0.3853 0.099 3.875 0.000 0.190 0.580\n", + "x261 -0.9046 0.101 -8.980 0.000 -1.102 -0.707\n", + "x262 4.7053 0.261 18.042 0.000 4.194 5.217\n", + "x263 0.3175 0.103 3.096 0.002 0.116 0.519\n", + "x264 -0.3407 0.109 -3.122 0.002 -0.555 -0.127\n", + "x265 -0.0188 0.103 -0.181 0.856 -0.221 0.184\n", + "x266 6.4608 0.260 24.849 0.000 5.951 6.970\n", + "x267 0.2615 0.099 2.637 0.008 0.067 0.456\n", + "x268 -0.1781 0.099 -1.807 0.071 -0.371 0.015\n", + "x269 -1.7494 0.124 -14.062 0.000 -1.993 -1.506\n", + "x270 4.7214 0.260 18.132 0.000 4.211 5.232\n", + "x271 -0.4753 0.103 -4.635 0.000 -0.676 -0.274\n", + "x272 0.3999 0.098 4.090 0.000 0.208 0.592\n", + "x273 1.4166 0.100 14.184 0.000 1.221 1.612\n", + "x274 4.4892 0.261 17.214 0.000 3.978 5.000\n", + "x275 -0.2541 0.098 -2.584 0.010 -0.447 -0.061\n", + "x276 1.1836 0.105 11.280 0.000 0.978 1.389\n", + "x277 1.0988 0.099 11.093 0.000 0.905 1.293\n", + "x278 4.6746 0.260 17.952 0.000 4.164 5.185\n", + "x279 0.6008 0.099 6.064 0.000 0.407 0.795\n", + "x280 -1.3150 0.106 -12.418 0.000 -1.523 -1.107\n", + "x281 0.6365 0.100 6.374 0.000 0.441 0.832\n", + "x282 4.4557 0.259 17.206 0.000 3.948 4.963\n", + "x283 0.7496 0.097 7.689 0.000 0.559 0.941\n", + "x284 1.9207 0.105 18.315 0.000 1.715 2.126\n", + "x285 -0.2955 0.105 -2.806 0.005 -0.502 -0.089\n", + "x286 5.4453 0.257 21.157 0.000 4.941 5.950\n", + "x287 0.6349 0.099 6.408 0.000 0.441 0.829\n", + "x288 -0.1733 0.098 -1.770 0.077 -0.365 0.019\n", + "x289 2.0493 0.101 20.352 0.000 1.852 2.247\n", + "x290 0.5037 0.263 1.916 0.055 -0.012 1.019\n", + "x291 -1.752e-15 1.02e-16 -17.169 0.000 -1.95e-15 -1.55e-15\n", + "x292 -0.5624 0.105 -5.363 0.000 -0.768 -0.357\n", + "x293 0.4416 0.102 4.347 0.000 0.242 0.641\n", + "x294 5.0002 0.259 19.283 0.000 4.492 5.508\n", + "x295 -0.0487 0.105 -0.462 0.644 -0.255 0.158\n", + "x296 0.9849 0.102 9.653 0.000 0.785 1.185\n", + "x297 1.0039 0.102 9.884 0.000 0.805 1.203\n", + "x298 4.3614 0.260 16.802 0.000 3.853 4.870\n", + "x299 1.1919 0.098 12.128 0.000 0.999 1.385\n", + "x300 1.3776 0.101 13.617 0.000 1.179 1.576\n", + "x301 0.4465 0.103 4.319 0.000 0.244 0.649\n", + "x302 4.0999 0.259 15.853 0.000 3.593 4.607\n", + "x303 0.9455 0.104 9.059 0.000 0.741 1.150\n", + "x304 -0.4532 0.104 -4.362 0.000 -0.657 -0.250\n", + "x305 0.4625 0.102 4.554 0.000 0.263 0.662\n", + "x306 5.0228 0.258 19.447 0.000 4.517 5.529\n", + "x307 0.7105 0.097 7.288 0.000 0.519 0.902\n", + "x308 0.9845 0.106 9.300 0.000 0.777 1.192\n", + "x309 -0.6792 0.110 -6.203 0.000 -0.894 -0.465\n", + "x310 5.2407 0.258 20.314 0.000 4.735 5.746\n", + "x311 -2.1480 0.102 -21.131 0.000 -2.347 -1.949\n", + "x312 1.9675 0.113 17.471 0.000 1.747 2.188\n", + "x313 0.9882 0.102 9.730 0.000 0.789 1.187\n", + "x314 3.3165 0.264 12.543 0.000 2.798 3.835\n", + "x315 -1.1503 0.117 -9.835 0.000 -1.380 -0.921\n", + "x316 0.2832 0.099 2.848 0.004 0.088 0.478\n", + "x317 0.5995 0.117 5.127 0.000 0.370 0.829\n", + "x318 5.2110 0.258 20.178 0.000 4.705 5.717\n", + "x319 0.3045 0.102 2.996 0.003 0.105 0.504\n", + "x320 1.2151 0.107 11.350 0.000 1.005 1.425\n", + "x321 1.9551 0.097 20.067 0.000 1.764 2.146\n", + "x322 4.7542 0.258 18.434 0.000 4.249 5.260\n", + "x323 1.2955 0.097 13.289 0.000 1.104 1.487\n", + "x324 1.0941 0.102 10.725 0.000 0.894 1.294\n", + "x325 -0.5137 0.102 -5.059 0.000 -0.713 -0.315\n", + "x326 2.9626 0.258 11.472 0.000 2.456 3.469\n", + "x327 1.2751 0.106 11.990 0.000 1.067 1.484\n", + "x328 1.5232 0.124 12.283 0.000 1.280 1.766\n", + "x329 0.7988 0.102 7.867 0.000 0.600 0.998\n", + "x330 5.6842 0.258 22.010 0.000 5.178 6.190\n", + "x331 2.0457 0.110 18.675 0.000 1.831 2.260\n", + "x332 1.5400 0.113 13.679 0.000 1.319 1.761\n", + "x333 1.0521 0.097 10.858 0.000 0.862 1.242\n", + "x334 3.6005 0.258 13.941 0.000 3.094 4.107\n", + "x335 1.2511 0.118 10.574 0.000 1.019 1.483\n", + "x336 -0.1762 0.100 -1.758 0.079 -0.373 0.020\n", + "x337 1.0346 0.100 10.363 0.000 0.839 1.230\n", + "x338 4.2940 0.259 16.564 0.000 3.786 4.802\n", + "x339 -0.8935 0.097 -9.165 0.000 -1.085 -0.702\n", + "x340 1.4177 0.115 12.309 0.000 1.192 1.643\n", + "x341 -0.3180 0.102 -3.131 0.002 -0.517 -0.119\n", + "x342 5.0974 0.259 19.709 0.000 4.590 5.604\n", + "x343 0.4659 0.750 0.621 0.535 -1.005 1.936\n", + "x344 0.6426 0.121 5.318 0.000 0.406 0.879\n", + "x345 2.0122 0.114 17.616 0.000 1.788 2.236\n", + "x346 4.7277 0.260 18.156 0.000 4.217 5.238\n", + "x347 0.2275 0.103 2.200 0.028 0.025 0.430\n", + "x348 -0.8918 0.208 -4.279 0.000 -1.300 -0.483\n", + "x349 1.1205 0.102 11.033 0.000 0.921 1.320\n", + "x350 6.1559 0.258 23.857 0.000 5.650 6.662\n", + "x351 0.8570 0.107 7.979 0.000 0.647 1.068\n", + "x352 1.0360 0.105 9.878 0.000 0.830 1.242\n", + "x353 -0.6854 0.098 -6.977 0.000 -0.878 -0.493\n", + "x354 4.0013 0.266 15.033 0.000 3.480 4.523\n", + "x355 -0.0286 0.101 -0.283 0.777 -0.226 0.169\n", + "x356 -0.0504 0.115 -0.437 0.662 -0.276 0.175\n", + "x357 -0.0720 0.099 -0.727 0.467 -0.266 0.122\n", + "x358 6.0824 0.262 23.248 0.000 5.570 6.595\n", + "x359 0.0480 0.103 0.467 0.640 -0.153 0.249\n", + "x360 -0.4963 0.099 -5.035 0.000 -0.689 -0.303\n", + "x361 0.0335 0.097 0.344 0.731 -0.157 0.224\n", + "x362 3.7954 0.258 14.693 0.000 3.289 4.302\n", + "x363 0.2475 0.102 2.435 0.015 0.048 0.447\n", + "x364 -4.5298 0.099 -45.575 0.000 -4.725 -4.335\n", + "x365 4.055e-13 5.58e-14 7.267 0.000 2.96e-13 5.15e-13\n", + "x366 -5.366e-05 2.13e-05 -2.521 0.012 -9.54e-05 -1.19e-05\n", + "x367 0.1919 0.095 2.014 0.044 0.005 0.379\n", + "==============================================================================\n", + "Omnibus: 9437.817 Durbin-Watson: 1.971\n", + "Prob(Omnibus): 0.000 Jarque-Bera (JB): 114074.545\n", + "Skew: -1.990 Prob(JB): 0.00\n", + "Kurtosis: 14.075 Cond. No. 2.58e+20\n", + "==============================================================================\n", + "\n", + "Notes:\n", + "[1] R² is computed without centering (uncentered) since the model does not contain a constant.\n", + "[2] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", + "[3] The smallest eigenvalue is 1.44e-30. This might indicate that there are\n", + "strong multicollinearity problems or that the design matrix is singular.\n", + "[ 6.51992712 6.17844488 5.4851872 ... 3.788228 4.68137159\n", + " -0.0789069 ]\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 7 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-03T17:54:22.890759Z", + "start_time": "2024-12-03T17:54:14.909189Z" + } + }, + "cell_type": "code", + "source": [ + "import seaborn as sns\n", + "data = {\n", + " 'weather_data': weather_data,\n", + " 'year_flattened': year_flattened,\n", + " 'lag_1_month': lag_1_month,\n", + " 'lag_2_month': lag_2_month,\n", + " 'lag_3_month': lag_3_month,\n", + " 'lag_4_month': lag_4_month,\n", + " 'altitude': np.array(altitude),\n", + " 'minimum_distance': np.array(minimum_distance)\n", + "}\n", + "\n", + "df = pd.DataFrame(data)\n", + "\n", + "# Concatenate one-hot encoded variables\n", + "df = pd.concat([df, facility_encoded], axis=1)\n", + "\n", + "# Compute correlation matrix\n", + "correlation_matrix = df.corr()\n", + "\n", + "# Visualize the correlation matrix (optional)\n", + "plt.figure(figsize=(15, 12))\n", + "sns.heatmap(correlation_matrix, cmap='coolwarm', annot=False)\n", + "plt.title('Correlation Matrix')\n", + "plt.show()" + ], + "id": "35ef0542ae552104", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 8 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-03T17:18:02.508963Z", + "start_time": "2024-12-03T17:17:59.538638Z" + } + }, + "cell_type": "code", + "source": [ + "\n", + "############### ADD IN CMIP DATA ###########################\n", + "def repeat_info(info, year_range):\n", + " repeated_info = [i for i in info for _ in range(12) for _ in year_range]\n", + " return repeated_info\n", + "# Configuration and constants\n", + "min_year_for_analysis = 2025\n", + "absolute_min_year = 2015\n", + "max_year_for_analysis = 2099\n", + "data_path = \"/Users/rem76/Desktop/Climate_change_health/Data/\"\n", + "\n", + "# Load and preprocess weather data\n", + "weather_data_prediction = pd.read_csv(f\"{data_path}Precipitation_data/ssp2_4_5/prediction_weather_by_smaller_facilities_with_ANC_lm.csv\", index_col=0, dtype={'column_name': 'float64'})\n", + "weather_data_prediction = pd.read_csv(f\"{data_path}Precipitation_data/ssp2_4_5/prediction_weather_monthly_by_smaller_facilities_with_ANC_lm.csv\", index_col=0, dtype={'column_name': 'float64'})\n", + "weather_data_prediction = weather_data_prediction.iloc[(min_year_for_analysis - absolute_min_year) * 12:]\n", + "# Flatten data and prepare for regression\n", + "num_facilities = len(weather_data_prediction.columns)\n", + "year_range_prediction = range(min_year_for_analysis, max_year_for_analysis + 1)\n", + "month_repeated_prediction = [m for _ in year_range_prediction for m in range(1, 13)]\n", + "year_flattened_prediction = np.repeat(year_range_prediction, 12 * num_facilities)\n", + "month_flattened_prediction = month_repeated_prediction * num_facilities\n", + "month_encoded_prediction = pd.get_dummies(month_flattened_prediction, prefix='month', drop_first=True) # try one-hot-encode\n", + "facility_flattened_prediction = np.tile(range(num_facilities), len(year_flattened_prediction) // num_facilities)\n", + "\n", + "# Encode facilities and create above/below average weather data\n", + "weather_data_prediction_flatten = weather_data_prediction.values.flatten()\n", + "facility_encoded_prediction = pd.get_dummies(facility_flattened_prediction, drop_first=True)\n", + "\n", + "grouped_data = pd.DataFrame({\n", + " 'facility': facility_flattened_prediction,\n", + " 'month': month_flattened_prediction,\n", + " 'weather_data': weather_data_prediction_flatten\n", + "}).groupby(['facility', 'month'])['weather_data'].mean().reset_index()\n", + "\n", + "# Load and preprocess facility information\n", + "info_file = \"expanded_facility_info_by_smaller_facility_lm_with_ANC.csv\" if ANC else \"expanded_facility_info_by_smaller_facility_lm.csv\"\n", + "expanded_facility_info = pd.read_csv(f\"{data_path}{info_file}\", index_col=0).T\n", + "\n", + "zone_info_prediction = repeat_info(expanded_facility_info[\"Zonename\"], year_range_prediction)\n", + "zone_encoded_prediction = pd.get_dummies(zone_info_prediction, drop_first=True)\n", + "resid_info_prediction = repeat_info(expanded_facility_info['Resid'], year_range_prediction)\n", + "resid_encoded_prediction = pd.get_dummies(resid_info_prediction, drop_first=True)\n", + "owner_info_prediction = repeat_info(expanded_facility_info['A105'], year_range_prediction)\n", + "owner_encoded_prediction = pd.get_dummies(owner_info_prediction, drop_first=True)\n", + "ftype_info_prediction = repeat_info(expanded_facility_info['Ftype'], year_range_prediction)\n", + "ftype_encoded_prediction = pd.get_dummies(ftype_info_prediction, drop_first=True)\n", + "altitude_prediction = [float(x) for x in repeat_info(expanded_facility_info['A109__Altitude'], year_range_prediction)]\n", + "minimum_distance_prediction = [float(x) for x in repeat_info(expanded_facility_info['minimum_distance'], year_range_prediction)]\n", + "\n", + "# Lagged weather data\n", + "lag_1_month_prediction = weather_data_prediction.shift(1).values.flatten()\n", + "lag_2_month_prediction = weather_data_prediction.shift(2).values.flatten()\n", + "lag_3_month_prediction = weather_data_prediction.shift(3).values.flatten()\n", + "lag_4_month_prediction = weather_data_prediction.shift(4).values.flatten()\n", + "\n", + "# Weather data\n", + "\n", + "X_basis_weather = np.column_stack([\n", + " weather_data_prediction_flatten,\n", + " np.array(year_flattened_prediction),\n", + " #np.array(month_flattened_prediction),\n", + " np.array(month_encoded_prediction),\n", + " resid_encoded_prediction,\n", + " zone_encoded_prediction,\n", + " owner_encoded_prediction,\n", + " ftype_encoded_prediction,\n", + " lag_1_month_prediction,\n", + " lag_2_month_prediction,\n", + " lag_3_month_prediction,\n", + " lag_4_month_prediction,\n", + " facility_encoded_prediction,\n", + " altitude_prediction, \n", + " minimum_distance_prediction\n", + "])\n", + "\n", + "X_basis_weather_filtered = X_basis_weather[X_basis_weather[:,0] > mask_threshold]\n", + "# format output \n", + "year_month_labels = np.array([f\"{y}-{m}\" for y, m in zip(X_basis_weather_filtered[:,1], X_basis_weather[:,2])])\n", + "y_pred_weather = results_of_weather_model.predict(X_basis_weather_filtered)\n", + "\n", + "if use_residuals:\n", + " data_weather_predictions = pd.DataFrame({\n", + " 'Year_Month': year_month_labels,\n", + " 'difference': y_pred_weather\n", + "})\n", + "else:\n", + " X_bases_ANC = np.column_stack([\n", + " year_flattened_prediction,\n", + " #month_flattened_prediction,\n", + " month_encoded_prediction,\n", + " resid_encoded_prediction,\n", + " zone_encoded_prediction,\n", + " owner_encoded_prediction,\n", + " ftype_encoded_prediction,\n", + " facility_encoded_prediction, \n", + " altitude_prediction, \n", + " minimum_distance_prediction\n", + " ])\n", + " \n", + " y_pred_ANC = results_ANC.predict(X_bases_ANC)\n", + " if log_y:\n", + " predictions = np.exp(y_pred_weather) - np.exp(y_pred_ANC[X_basis_weather[:,0] > mask_threshold])\n", + " else:\n", + " predictions = y_pred_weather - y_pred_ANC[X_basis_weather[:,0] > mask_threshold]\n", + "\n", + "data_weather_predictions = pd.DataFrame({\n", + " 'Year_Month': year_month_labels,\n", + " 'difference': predictions, \n", + " 'y_pred_ANC':y_pred_ANC[X_basis_weather[:,0] > mask_threshold], \n", + " 'y_pred_weather':y_pred_weather\n", + "})\n", + " \n", + "data_weather_predictions_grouped = data_weather_predictions.groupby('Year_Month').mean().reset_index()\n", + "\n", + "# Plotting results\n", + "fig, axs = plt.subplots(1, 2, figsize=(14, 6))\n", + "\n", + "axs[0].scatter(data_weather_predictions['Year_Month'], data_weather_predictions['difference'], color='#9AC4F8', alpha=0.1)\n", + "axs[0].scatter(data_weather_predictions_grouped['Year_Month'], data_weather_predictions_grouped['difference'], color='red', alpha=0.7, label='Mean')\n", + "axs[0].set_xticklabels(data_weather_predictions['Year_Month'], rotation=45, ha='right')\n", + "axs[0].set_xlabel('Year/Month')\n", + "xticks = data_weather_predictions['Year_Month'][::len(year_range)*12*num_facilities] \n", + "axs[0].set_xticks(xticks) \n", + "axs[0].set_xticklabels(xticks, rotation=45, ha='right') \n", + "axs[0].set_ylabel('Difference Predicted ANC visits due to rainfall')\n", + "axs[0].legend(loc='upper left')\n", + "precipitation_range = np.linspace(X_basis_weather_filtered[:,0].min(), X_basis_weather_filtered[:,0].max(), 100)\n", + "X_for_line = np.column_stack([precipitation_range] + [np.mean(X_basis_weather_filtered[:, i]) for i in range(1, X_basis_weather_filtered.shape[1])])\n", + "\n", + "y_line = results_of_weather_model.predict(X_for_line)\n", + "\n", + "# Plotting\n", + "axs[1].scatter(X_basis_weather_filtered[:, 0], data_weather_predictions['difference'], color='#9AC4F8', alpha=0.7, label='Predictions')\n", + "axs[1].plot(precipitation_range, y_line, color='red', label='Line of Best Fit') # Add line of best fit\n", + "axs[1].set_xlabel('Precipitation (mm)')\n", + "axs[1].set_ylabel('Expected number of ANC visits')\n", + "axs[1].legend()\n", + "# if log_y:\n", + "# \n", + "# axs[1].scatter(X_basis_weather_filtered[:,0], data_weather_predictions['difference'], color='#9AC4F8', alpha=0.7, label='Predictions')\n", + "# axs[1].scatter(X_basis_weather_filtered[:,0],y_weather*results_of_weather_model.params[0],color='red')\n", + "# \n", + "# else:\n", + "# axs[1].scatter(X_basis_weather_filtered[:,0], data_weather_predictions['difference'], color='#9AC4F8', alpha=0.7, label='Predictions')\n", + "# \n", + "# axs[1].scatter(X_basis_weather_filtered[:,0],y_weather*results_of_weather_model.params[0],color='red')\n", + "# axs[1].set_xlabel('Precipitation (mm)')\n", + "# axs[1].set_ylabel('Expected number of ANC visits')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n" + ], + "id": "a21f46f9af85a26c", + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_92649/1417594935.py:101: RuntimeWarning: overflow encountered in exp\n", + " predictions = np.exp(y_pred_weather) - np.exp(y_pred_ANC[X_basis_weather[:,0] > mask_threshold])\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_92649/1417594935.py:101: RuntimeWarning: invalid value encountered in subtract\n", + " predictions = np.exp(y_pred_weather) - np.exp(y_pred_ANC[X_basis_weather[:,0] > mask_threshold])\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_92649/1417594935.py:119: UserWarning: FixedFormatter should only be used together with FixedLocator\n", + " axs[0].set_xticklabels(data_weather_predictions['Year_Month'], rotation=45, ha='right')\n" + ] + }, + { + "ename": "ValueError", + "evalue": "all the input array dimensions except for the concatenation axis must match exactly, but along dimension 0, the array at index 0 has size 100 and the array at index 1 has size 1", + "output_type": "error", + "traceback": [ + "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m", + "\u001B[0;31mValueError\u001B[0m Traceback (most recent call last)", + "Cell \u001B[0;32mIn[142], line 127\u001B[0m\n\u001B[1;32m 125\u001B[0m axs[\u001B[38;5;241m0\u001B[39m]\u001B[38;5;241m.\u001B[39mlegend(loc\u001B[38;5;241m=\u001B[39m\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mupper left\u001B[39m\u001B[38;5;124m'\u001B[39m)\n\u001B[1;32m 126\u001B[0m precipitation_range \u001B[38;5;241m=\u001B[39m np\u001B[38;5;241m.\u001B[39mlinspace(X_basis_weather_filtered[:,\u001B[38;5;241m0\u001B[39m]\u001B[38;5;241m.\u001B[39mmin(), X_basis_weather_filtered[:,\u001B[38;5;241m0\u001B[39m]\u001B[38;5;241m.\u001B[39mmax(), \u001B[38;5;241m100\u001B[39m)\n\u001B[0;32m--> 127\u001B[0m X_for_line \u001B[38;5;241m=\u001B[39m \u001B[43mnp\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mcolumn_stack\u001B[49m\u001B[43m(\u001B[49m\u001B[43m[\u001B[49m\u001B[43mprecipitation_range\u001B[49m\u001B[43m]\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m+\u001B[39;49m\u001B[43m \u001B[49m\u001B[43m[\u001B[49m\u001B[43mnp\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mmean\u001B[49m\u001B[43m(\u001B[49m\u001B[43mX_basis_weather_filtered\u001B[49m\u001B[43m[\u001B[49m\u001B[43m:\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mi\u001B[49m\u001B[43m]\u001B[49m\u001B[43m)\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;28;43;01mfor\u001B[39;49;00m\u001B[43m \u001B[49m\u001B[43mi\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;129;43;01min\u001B[39;49;00m\u001B[43m \u001B[49m\u001B[38;5;28;43mrange\u001B[39;49m\u001B[43m(\u001B[49m\u001B[38;5;241;43m1\u001B[39;49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mX_basis_weather_filtered\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mshape\u001B[49m\u001B[43m[\u001B[49m\u001B[38;5;241;43m1\u001B[39;49m\u001B[43m]\u001B[49m\u001B[43m)\u001B[49m\u001B[43m]\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 129\u001B[0m y_line \u001B[38;5;241m=\u001B[39m results_of_weather_model\u001B[38;5;241m.\u001B[39mpredict(X_for_line)\n\u001B[1;32m 131\u001B[0m \u001B[38;5;66;03m# Plotting\u001B[39;00m\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/numpy/lib/shape_base.py:652\u001B[0m, in \u001B[0;36mcolumn_stack\u001B[0;34m(tup)\u001B[0m\n\u001B[1;32m 650\u001B[0m arr \u001B[38;5;241m=\u001B[39m array(arr, copy\u001B[38;5;241m=\u001B[39m\u001B[38;5;28;01mFalse\u001B[39;00m, subok\u001B[38;5;241m=\u001B[39m\u001B[38;5;28;01mTrue\u001B[39;00m, ndmin\u001B[38;5;241m=\u001B[39m\u001B[38;5;241m2\u001B[39m)\u001B[38;5;241m.\u001B[39mT\n\u001B[1;32m 651\u001B[0m arrays\u001B[38;5;241m.\u001B[39mappend(arr)\n\u001B[0;32m--> 652\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[43m_nx\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mconcatenate\u001B[49m\u001B[43m(\u001B[49m\u001B[43marrays\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m1\u001B[39;49m\u001B[43m)\u001B[49m\n", + "\u001B[0;31mValueError\u001B[0m: all the input array dimensions except for the concatenation axis must match exactly, but along dimension 0, the array at index 0 has size 100 and the array at index 1 has size 1" + ] + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAABJ8AAAJDCAYAAAClobUfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/OQEPoAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeZxcVZ3//9c599661ZV0OmFJAhoEUUGQTRgx7kuUbUAcfwojyiLqiKBCdBRUQL/OkHFDcMTh6wLoKAPuOqIogoBfQGDADIgsghFQSVhC0umlbt17z/n9caoq6aQ7qU66k+rk/Xw8iuqqulV1urvo7nrn8/kc4733iIiIiIiIiIiITAK7pRcgIiIiIiIiIiJbL4VPIiIiIiIiIiIyaRQ+iYiIiIiIiIjIpFH4JCIiIiIiIiIik0bhk4iIiIiIiIiITBqFTyIiIiIiIiIiMmkUPomIiIiIiIiIyKRR+CQiIiIiIiIiIpNG4ZOIiIiIiIiIiEwahU8iIiIiIiIiIjJpFD6JiIiIbENuvPFGjjzySHbeeWeMMfzoRz/a4H2uv/56XvjCF5KmKc95znO47LLLJn2dIiIisvVQ+CQiIiKyDRkcHGS//fbjoosu6uj4JUuWcMQRR/DqV7+axYsXc/rpp/POd76TX/ziF5O8UhEREdlaGO+939KLEBEREZHNzxjDD3/4Q44++ugxj/nIRz7CVVddxe9///v2dcceeywrVqzg6quv3gyrFBERkaku3tILmGqcc/ztb3+jt7cXY8yWXo6IiIiMwXvPqlWr2HnnnbFWxd4b65ZbbmHBggUjrjvkkEM4/fTTx7xPlmVkWda+7Jxj+fLlbL/99vr7SUREpItN1t9PCp/G6W9/+xvz5s3b0ssQERGRDj366KM885nP3NLLmLKWLl3KnDlzRlw3Z84c+vv7GR4epqenZ537LFq0iE9+8pOba4kiIiIywSb67yeFT+PU29sLhG/EjBkztvBqREREZCz9/f3Mmzev/btbNp+zzjqLhQsXti+vXLmSXXbZRX8/iYiIdLnJ+vtJ4dM4tUrFZ8yYoT+eREREpgC1eW2auXPnsmzZshHXLVu2jBkzZoxa9QSQpilpmq5zvf5+EhERmRom+u8nDUAQERERkTHNnz+fa6+9dsR111xzDfPnz99CKxIREZGpRuGTiIiIyDZkYGCAxYsXs3jxYgCWLFnC4sWLeeSRR4DQMnf88ce3j3/Pe97Dn/70Jz784Q9z33338eUvf5nvfOc7nHHGGVti+SIiIjIFKXwSERER2Yb8z//8DwcccAAHHHAAAAsXLuSAAw7gnHPOAeCxxx5rB1EAu+22G1dddRXXXHMN++23H5///Of52te+xiGHHLJF1i8iIiJTj/He+y29iKmkv7+fvr4+Vq5cOebMAu89RVFQluVmXt3WK4oi4jjW3A4REelYJ7+zZfPQ90JERGRqmKzf2Ro4PsEajQaPPfYYQ0NDW3opW51arcZOO+1EpVLZ0ksRERERERERkQ4pfJpAzjmWLFlCFEXsvPPOVCoVVepMAO89jUaDJ554giVLlvDc5z4Xa9UxKiIiIiIiIjIVKHyaQI1GA+cc8+bNo1arbenlbFV6enpIkoSHH36YRqNBtVrd0ksSERERERERkQ6ofGQSqCpncujrKiIiIiIiIjL16N28iIiIiIiIiIhMGoVPIiIiIiIiIiIyaRQ+iYiIiIiIiIjIpFH4JACceOKJGGN4z3ves85tp556KsYYTjzxxM2/MBERERERERGZ0hQ+dSvn4O674cYbw7lzk/6U8+bN44orrmB4eLh9Xb1e5/LLL2eXXXaZ9OcXERERERERka2PwqdudPPN8La3wfHHw3veE87f9rZw/SR64QtfyLx58/jBD37Qvu4HP/gBu+yyCwcccED7OuccixYtYrfddqOnp4f99tuP733ve3jv8d5TFAUnn3xy+/Y99tiDCy+8cMRznXjiiRx99NF87nOfY6eddmL77bfn1FNPJc/zSf0cRURERERERGTzUvjUbW6+GT70IbjzTpg5E3bdNZz/7nfh+kkOoN7xjndw6aWXti9fcsklnHTSSSOOWbRoEd/85je5+OKLueeeezj99NN529vexq9/fQOlg7xw7PyMZ/Cd73yHP/zhD5xzzjl89KMf5Tvf+c6Ix/n1r3/NQw89xK9//Wu+8Y1vcNlll3HZZZdN6ucnIiIiIiIiIptXvKUXIGtwDr70JVi+HJ7zHDAmXD99Ouy+Ozz0EFx0Ebz4xWAnJzd829vexllnncXDDz8MwE033cQVV1zB9ddfD0CWZZx33nn86le/Yv78+Xjvedauu/Gb//f/+OpXv8IrX/VKKpWEc8/9JMaANbDbbrtxyy238J3vfIe3vOUt7eeaNWsWX/rSl4iiiD333JMjjjiCa6+9lne9612T8rmJiIiIiIiIyOan8Kmb3HMP3Hsv7LTT6uCpxRiYOxf+8Idw3D77TMoSdtxxR4444gguu+wyvPccccQR7LDDDu3bH3zwQYaGhnjd61434n6NRoP912jN+4//uIhLL72URx95hOHh4XD7/vuPuM/ee+9NFEXtyzvttBN33333pHxeIiIiIiIiIrJlKHzqJk8/DVkGPT2j397TA8uWheMm0Tve8Q5OO+00AC666KIRtw0MDABw1VVXsfPOO1O61TlZmqYAXHnFFXz4n/+Zz37ucxx88Hxm9vXyuc99jltvvXXEYyVJMuKyMQa3GQari4iIiIiIiMjmo/Cpm8yaBWkKw8Oh1W5tw8Ph9lmzJnUZhx56KI1GA2MMhxxyyIjb9tprL9I05ZFHHuEVr3jFiPCp5eabb2L+S17CKae8F+8hsvDQQw9N6ppFREREREREpDspfOome+8Nz39+GC6+++4jUx3vYelSeOELw3GTKIoi7r333vbHa+rt7eVDH/oQZ5xxBmVZMv8lL6O/fyU333wTM3pncPwJJ/Cc5z6X//zP/+QXv/gFu+66G5d/+z+5/fbb2W233SZ13SIiIiIiIiLSfbTbXTexFk47LVQ2PfQQDAxAWYbzhx4K15966qQNG1/TjBkzmDFjxqi3fepTn+Lss8/m3/7t39jnBXtxxOGH8bOrfsauzXDp3e/+J974xn/grf94LC99yYtZvnw5733veyd9zSIiIiIiIiLSfYz33m/pRUwl/f399PX1sXLlynXCmXq9zpIlS9htt92oVqsb/yQ33xx2vbv33jADKk1hr71C8PSSl2ziZzCxvPc4Hwqz1i7Uau12Z9buy9tIE/b1FRGRbcL6fmfL5qXvhYiIyNQwWb+z1XbXjV7yEnjxi8Oudk8/HSqe9t57s1Q8jZcxBovHEQKn1ddPbPAkIiIiIiIiIlOTwqduZS3ss8+WXkVHjDFEJlRBrXmdiIiIiIiIiIjCJ5kwCpxEREREREREZG3d18clIiIiIiIiIiJbDYVPk0Az3CeHvq4iIiIiIiIiU4/CpwmUJAkAQ0NDW3glW6fW17X1dRYRERERERGR7qeZTxMoiiJmzpzJ448/DkCtVtMcpAngvWdoaIjHH3+cmTNnEkXRll6SiIiIiIiIiHRI4dMEmzt3LkA7gJKJM3PmzPbXV0RERERERESmBoVPE8wYw0477cTs2bPJ83xLL2erkSQJURRROo93HmMgsqoqExEREREREel2Cp8mSRRFag+bQIXzDGaOvAQPGCCJPGliiBVCiYiIiIiIiHQthU/S9QrnGco8hYPYgjXgPGQFlM5TS1EAJSIiIiIiItKltNuddL0sD8FTGhsiazAmnKexoXDhdhERERERERHpTgqfpKuVzpOXoeJpNLGFvAzHiYiIiIiIiEj3UfgkXc37MONprK46a8LtXtmTiIiIiIiISFfSzCfpasaE4eLOQ2RChVNr4HhkDc6Hj41GPomIiIiIiIh0JYVP0tUia0giz1DDA2H2k/chbIptKHeqVcIMKBERERERERHpPmq7k64XRdAoPQOZB+eJTDgfyDyN0hNFW3qFIiIiIiIiIjIWVT5J1ytLqMSGSgSFgxIwFqbHgAm365UsIiIiIiIi0p30ll26Wmu3uzQyzRlPvt12Z41p3146r9Y7ERERERERkS6k8Em62tq73dnWBHJal6H02u1OREREREREpFtp5pN0tTV3uxuNdrsTERERERER6W4Kn6Srhd3uwqyn0RQOkgi13ImIiIiIiIh0KbXdSddLkzDbKSs8sQ2tds6H4Cm24XYRERERERER6U4Kn6TrxdZQSyHLm8PFm612aRyCp1hVTyIiIiIiIiJdS+GTTAmxNcRpqIBq7XanVjsRERERERGR7qfwSbrSWCGTAicRERERERGRqUXhk3SVwvl2e50ntNclkVd7nYiIiIiIiMgUpfBJukbhPEOZbw8Sbw0Wz4pQCVVLUQAlIiIiIiIiMsXYLb0AkZYsD8FTGhsiazAmnKexoXDhdhERERERERGZWhQ+yYQpnacoPaUbf0hUutBqF4/xiowtYae7jXhsEREREREREdly1HYnm2wi5jR5H+471uHWQOnDcSIiIiIiIiIydajySTZJa05TVoSAKGnOasoKmvObOkuLjAmh1ViHOx9uNxr5JCIiIiIiIjKlKHySTTJRc5oia0giKNzotxcOkigcJyIiIiIiIiJTh9ruZKONZ05TJ6FRmhhK58kKP2K3u9bud2mi4ElERERERERkqlH4JBttouc0xdZQS2nPjyqbrXZpzLjmR4mIiIiIiIhI91D4JBttzTlN0Si50MbMaYqtIU5DBZT34b5qtRMRERERERGZujTzSTbaZM5piqwhjoyCJxEREREREZEpTpVPskk0p0lERERERERE1kfhk2wSzWkSERERERERkfVR+CSbTHOaRERERERERGQsCp9kwihwEhEREREREZG1dcXA8UWLFvF3f/d39Pb2Mnv2bI4++mjuv//+EcfU63VOPfVUtt9+e6ZPn86b3vQmli1bNuKYRx55hCOOOIJarcbs2bP553/+Z4qiGHHM9ddfzwtf+ELSNOU5z3kOl1122WR/eiIiIiIiIiIi26yuCJ9uuOEGTj31VH77299yzTXXkOc5r3/96xkcHGwfc8YZZ/Df//3ffPe73+WGG27gb3/7G//wD//Qvr0sS4444ggajQY333wz3/jGN7jssss455xz2scsWbKEI444gle/+tUsXryY008/nXe+85384he/2Kyf79aqdJ6i9JTOb+mliIiIiIiIiEiXMN77rksKnnjiCWbPns0NN9zAK17xClauXMmOO+7I5Zdfzv/3//1/ANx33308//nP55ZbbuHFL34xP//5z/n7v/97/va3vzFnzhwALr74Yj7ykY/wxBNPUKlU+MhHPsJVV13F73//+/ZzHXvssaxYsYKrr766o7X19/fT19fHypUrmTFjxsR/8lNQ4Xx74LgnDBxPIg0cFxGRLUu/s7uHvhciIiJTw2T9zu6Kyqe1rVy5EoDtttsOgDvuuIM8z1mwYEH7mD333JNddtmFW265BYBbbrmFffbZpx08ARxyyCH09/dzzz33tI9Z8zFax7QeYzRZltHf3z/iJKsVzjOUebICrIHEhvOsgKHMU6gKSkRERERERGSb1nXhk3OO008/nZe+9KW84AUvAGDp0qVUKhVmzpw54tg5c+awdOnS9jFrBk+t21u3re+Y/v5+hoeHR13PokWL6Ovra5/mzZu3yZ/j1iTLPYWDNDZE1mBMOE9jQ+HC7SIiIiIiIiKy7eq68OnUU0/l97//PVdcccWWXgoAZ511FitXrmyfHn300S29pK5RutBqF4/xKoot5CUTOgNKc6VEREREREREppZ4Sy9gTaeddho//elPufHGG3nmM5/Zvn7u3Lk0Gg1WrFgxovpp2bJlzJ07t33MbbfdNuLxWrvhrXnM2jvkLVu2jBkzZtDT0zPqmtI0JU3TTf7ctkbehxlPY411sgZKH47bVKPPlfKaKyUiIiIiIiLS5bqi8sl7z2mnncYPf/hDrrvuOnbbbbcRtx944IEkScK1117bvu7+++/nkUceYf78+QDMnz+fu+++m8cff7x9zDXXXMOMGTPYa6+92ses+RitY1qPIZ1pVR857zHAWEVIzoeQyGxiNqS5UiIiIiIiIiJTV0eVT3fddVfHD7jvvvuOexGnnnoql19+OT/+8Y/p7e1tz2jq6+ujp6eHvr4+Tj75ZBYuXMh2223HjBkzeN/73sf8+fN58YtfDMDrX/969tprL97+9rfzmc98hqVLl/Lxj3+cU089tV259J73vIcvfelLfPjDH+Yd73gH1113Hd/5zne46qqrxr3mbdFo1Ud56cAYaqNUH4VZUBBtYmXSmnOlWiIDkYWsCGuKU1U/iYiIiIiIiHQj4/2Gm6KstRhjGOvQ1m3GGMqyHP8ixiiNufTSSznxxBMBqNfrfPCDH+S//uu/yLKMQw45hC9/+cvtljqAhx9+mFNOOYXrr7+eadOmccIJJ/Bv//ZvxPHqjO3666/njDPO4A9/+APPfOYzOfvss9vP0YltdavgVvVR4cIsJ2tCZVNWeBqlpxIbEhsCKQ84b4gt1NJNa4srnWdV3WPN6CFW6TzOQ2/VbHLIJSIiW5dt9Xd2N9L3QkREZGqYrN/ZHYVPDz/8cMcP+KxnPWuTFtTtttU/ngYzR1aMrD5qWVUvaRQOjMX70GbXk0Bvj6U61jTyDhWlZ1XmQ7A1SkjpvSd30Jsa4kjhk4iIrLat/s7uRvpeiIiITA2T9Tu7o7a7rT1QkvVb3652pfNhqDiW6ZVQnRQGkRsaOcTWb1LlkzG050qNli1N1FwpEREREREREZkcHYVPP/nJTzp+wKOOOmqjFyPdaX272mWFxztIYkMSjWx9m4h5TJE1JFEYNh6NEn5N1FwpEREREREREZkcHYVPRx99dEcPtrEzn6S7jVV9VLowA6p13drVR7GFvAzHbUo4lCaG0nmywo+YN9WaP5UmCp5EREREREREulVH4ZNzbrLXIV1srOojT6iKckBqwa6VPllDaMnb4FSx9YutoZbS3mmvbLbapXEInjalrU9EREREREREJldH4ZPIqNVHzpOXnsoY1UcTOY8ptoY4DWtoDTVXq52IiIiIiIhI99uo8GlwcJAbbriBRx55hEajMeK297///ROyMOkuo1YfGUOtEpKgaJSEaTLmMSlwEhEREREREZlaxh0+/e53v+Pwww9naGiIwcFBtttuO5588klqtRqzZ89W+LQVG636yBMxlG2+eUyqfBIRERERERGZWkbZP2z9zjjjDI488kiefvppenp6+O1vf8vDDz/MgQceyOc+97nJWKN0mcga4ubOdqEiypDGIXTKXThPY6ilEzePqXCewcyxqu5ZlXlW1cPlwm3iQCkRERERERERmVTjDp8WL17MBz/4Qay1RFFElmXMmzePz3zmM3z0ox+djDVKl4utYVpq6a0aelNDbzVcnsjgKVRXAXhsGHVOVsBQ5hVAiYiIiIiIiHSxcYdPSZJgbbjb7NmzeeSRRwDo6+vj0UcfndjVyZSyZkXURMpyT1Z6SucZzmEwh+E8tOBlpSfLFT6JiIiIiIiIdKtxz3w64IADuP3223nuc5/LK1/5Ss455xyefPJJ/vM//5MXvOAFk7FG2YaFwMlT5B5nDLFpzpry0CjBes8wUE28ZkCJiIiIiIiIdKFxVz6dd9557LTTTgD867/+K7NmzeKUU07hiSee4Ctf+cqEL1C2bd5Do/CUQCUyeMJMKd+8XBJu9yp+EhER6dhFF13ErrvuSrVa5eCDD+a2225b7/EXXHABe+yxBz09PcybN48zzjiDer2+mVYrIiIiU11HlU8/+clPOOyww0iShIMOOqh9/ezZs7n66qsnbXEiznsK16xwajgKR3u3u9iG+U+FMTjvAVU+iYiIbMiVV17JwoULufjiizn44IO54IILOOSQQ7j//vuZPXv2OsdffvnlnHnmmVxyySW85CUv4YEHHuDEE0/EGMP555+/BT4DERERmWo6qnx64xvfyIoVKwCIoojHH398Mtck0maNweAZzD0NB9ZCHIXzhoPB3GPwWKPgSUREpBPnn38+73rXuzjppJPYa6+9uPjii6nValxyySWjHn/zzTfz0pe+lLe+9a3suuuuvP71r+cf//EfN1gtJSIiItLSUfi044478tvf/hYA7z1Gb/RlMzEm1DN5wHhwpcc5jys9ptl+Z5rHiYiIyPo1Gg3uuOMOFixY0L7OWsuCBQu45ZZbRr3PS17yEu6444522PSnP/2Jn/3sZxx++OFjPk+WZfT39484iYiIyLaro7a797znPbzhDW/AGIMxhrlz5455bFmWE7Y4EYAoMlQiT1E6snJ1210aeSpRuF1EREQ27Mknn6QsS+bMmTPi+jlz5nDfffeNep+3vvWtPPnkk7zsZS/De09RFLznPe/hox/96JjPs2jRIj75yU9O6NpFRERk6uoofPrEJz7Bsccey4MPPshRRx3FpZdeysyZMyd5aSKrgybnwWHoiT3WgnNQ+DDrqbX7nYiIiEy866+/nvPOO48vf/nLHHzwwTz44IN84AMf4FOf+hRnn332qPc566yzWLhwYftyf38/8+bN21xLFhERkS7TUfgEsOeee7Lnnnty7rnn8uY3v5larTaZ65IpqHS+HRZFdmKqkVrBUhwbKhhKF3a8iyKoWHCsDqhERERk/XbYYQeiKGLZsmUjrl+2bNmYle1nn302b3/723nnO98JwD777MPg4CDvfve7+djHPoa1605xSNOUNE0n/hMQERGRKamjmU9rOvfccxU8yQiF8wxmjlV1z6rMs6oeLhdugsqRPETe0JNYplUM0xLDtEq4HHkTBj+JiIjIBlUqFQ488ECuvfba9nXOOa699lrmz58/6n2GhobWCZiiKALCLFARERGRDRl3+LRs2TLe/va3s/POOxPHMVEUjTjJtqVwnqHMkxVgDSQ2nGcFDGV+kwMo7yGJDXEMjWJ1ZZX34XIch9v1t6+IiEhnFi5cyFe/+lW+8Y1vcO+993LKKacwODjISSedBMDxxx/PWWed1T7+yCOP5D/+4z+44oorWLJkCddccw1nn302Rx55pP72ExERkY503HbXcuKJJ/LII49w9tlns9NOO2nnu21clnsKB2m8+nUQGYgsZIUnyz1xuvGvEWMgtobIQOHCybtwfSUOt4VB+BPx2YiIiGz9jjnmGJ544gnOOeccli5dyv7778/VV1/dHkL+yCOPjKh0+vjHP44xho9//OP89a9/Zccdd+TII4/kX//1X7fUpyAiIiJTjPHjrJfu7e3lN7/5Dfvvv/8kLam79ff309fXx8qVK5kxY8aWXs4WVbrQYmfHmPFUOo/z0Fs1454Bteb8qHoeKqvS2ITrAUN4zqzwpDFMS8ddxCciIls5/c7uHvpeiIiITA2T9Tt73JVP8+bNU3+/AKH1zRPa7EZjDZR+fDvRFS5US+Ul7ZDJmvAAWQGxDZVVzofKqthCmqjsSURERERERKRbjbtc5IILLuDMM8/kz3/+8yQsR6YSY0I4NNZYJ+fD7Z22xI01P6pwplnpFCqpchceO42hlhriCdpZT0REREREREQm3rgrn4455hiGhobYfffdqdVqJEky4vbly5dP2OKku0XWkEQhLIpGiTHDLKjRW/JGs/75UaHqqZqYdjveeFv5RERERERERGTzG3f4dMEFF0zCMmSqSpMwhykrPAbf3onOY8bVEle60GoXj1GLF1vIS6gmEEcKnURERERERESminGHTyeccMJkrEOmqNgaKoknG3YM57SrknoSTy21HbfETcb8KBERERERERHZ8joKn/r7+9tTzvv7+9d7rHYw2bYUztPIIbKWGVWPIYRIzhsaOcTWdxRArTk/KgwUX73bnTVm3POjRERERERERKQ7dBQ+zZo1i8cee4zZs2czc+ZMzCgJgPceYwxlWU74IqV7jZzTNPJ1kRVh57o43XBi1JofNZR7KMJjtna7i21InmqJ0ZwnERERERERkSmmo/DpuuuuY7vttgPg17/+9aQuSKaOTuc0lc53FBpFETSGPY0CqlEYNO4cDORQiaG3quBJREREREREZKrpKHx65StfOerHsm1be07T2q1y453TVJZQiQyVKOyUV3owFqbHq28f/5QyEREREREREdmSNvqt/NDQEI888giNRmPE9fvuu+8mL0qmhtacptx5inLdVrk4AoPpaE5Tq4oqjUNrXel8+7Fal8dTRSUiIiIiIiIi3WHc4dMTTzzBSSedxM9//vNRb9fMp21HZA3GOFYNeWxkiE0IpLyHRgn1hmdGLQwj35C1q6jWDphaVVRFubq6SiGUiIiIiIiISPfbcCqwltNPP50VK1Zw66230tPTw9VXX803vvENnvvc5/KTn/xkMtYoXcwArrnFnfce5zy+mSQ5s/YI8vU8zhq73Y0mLz31hmMg86zKPKvqnsHMUYx1BxERERERERHpCuOufLruuuv48Y9/zEEHHYS1lmc961m87nWvY8aMGSxatIgjjjhiMtYpXah0HucN0yqeocwxWKxuu6vGnmmpwXnTUatca7e7rAiDxtd+nv7MExtIojBLynnIinBbLYVYVVAiIiIiIiIiXWnclU+Dg4PMnj0bgFmzZvHEE08AsM8++3DnnXdO7Oqkq3nfnPdUQBRZplcMM1LD9IohiixFEW7vdOB4mhhiC1nhw8wnH85X1R3WQ2+Pbbb6hblQaWwoHGS5qp9EREREREREutW4w6c99tiD+++/H4D99tuP//t//y9//etfufjii9lpp50mfIHSvYwJM5hyF3apS2JLHFmS2FKJDLkLt3cycBxC9VItNaRxqGzKXWi3sxam9xiiUR4otrQHkYuIiIiIiIhI9xl3290HPvABHnvsMQDOPfdcDj30UL797W9TqVS47LLLJnp90u188zTe28YQW0OcNne781A6GMoNSTMmXXsXvNYg8k6rq0RERERERERk8xp3+PS2t72t/fGBBx7Iww8/zH333ccuu+zCDjvsMKGLk+7mPSSxAeNpFJ7Yrt7trnAQx2FG08YEQ60ZUcaAyT156Smcp3C0d7uLbes5TcfVVSIiIiIiIiKyeY2r7S7Pc3bffXfuvffe9nW1Wo0XvvCFCp62QSEAMlRjQyUGRwidHFCJoRobYrtpwVCobgoDxxtFeMHGNpw3CujPPNZseKC5iIiIiIiIiGwZ46p8SpKEer0+WWuRKWb1DnWGWsXQKByOEAxVYktWeCoRmxwMecD68MCl8+3qKozBunF39omIiIiIiIjIZjTugeOnnnoqn/70pymKYjLWI1NA6TxFGXaiSxODwbNiqGSw4ak3PIONcNkQbt/U5/Le0JNCWToGGqEKaqDhKUtHTwreGw0cFxEREREREelS4575dPvtt3Pttdfyy1/+kn322Ydp06aNuP0HP/jBhC1OukvhPFnuyUvaQ7+t8eTN4KcoXfv6JLITUpEU5keF54ysZUa6+lFLb8jLMNXce7XdiYiIiIiIiHSjcYdPM2fO5E1vetNkrEW6WOE8Q1kY+G1Y3fq2KvPUc0dkoV6A82BNCKUaJWS5J043PhgyBvLCU5RQrRhCtBVEQL0RtrrTwHERERERERGR7jTu8OnSSy+djHVIl8tyT1Y0K5yaO8457xmolww2whDwGVXbDqWGcmjkDgNUE7Npc59GZk6d3yYiIiIiIiIiW9y4Zz7Jtqd0nnruaZTr7ji3qg5ZAXFksNZgrSWKLLWKJfcwmLkwHHwjeR8eO7HQKD3OebwP543Sk9hw+6Y8h4iIiIiIiIhMnnFXPsm2x3vICo93jBggXriwu11kCLOXWgOfmio2BFN56YijaKOe2xhIrCGuQFGGdbRa+9LYEEcGg1HbnYiIiIiIiEiXUuWTbJDzYdZTtFbAE1lDRHgRlQ7cWiPGWyGR2YhkqLWjHkAShVa/ljUfrnDh9k1q6xMRERERERGRSaPKJ9kgawyxhdKv+4KJY6jnYDzgwJtQAVU4wEJqDePJhUbbUc97x1DD45whsZ7IgnMwkEElht6qgicRERERERGRbqXwSTbIGKjEhrw59yk24brYGioRlAWkFXAGvGu2ysXQKA3TUkMl7qzAbs0d9WIbqqach1UZFLknij1DeZjvZAxUY09kDGWJXskiIiIiIiIiXWqj2u5uuOEGjjzySJ7znOfwnOc8h6OOOorf/OY3E7026RKRNfQkhjgJYZMDCh/O+3os1SrExpBGUE08ifWUDnoSQ29P5y+xLA/BUxqH3fFa7XoeyD0UzlCLYVoFajFE1lJ6qOee0mniuIiIiIiIiEg3Gnf49K1vfYsFCxZQq9V4//vfz/vf/356enp47Wtfy+WXXz4Za5QukCaGNDLNIAqmJdCTQE8lYs70iL6awWHIy3A+PYXtp1uqHVY9lS602q19uAcahYfmDKjMhYqq3BtK7ylLH4ahK3sSERERERER6UrG+/G9bX/+85/Pu9/9bs4444wR159//vl89atf5d57753QBXab/v5++vr6WLlyJTNmzNjSy9msRpvHlEQhmIqtoVG49pDxTlvt2o9delZlnsSOHFDeKBzLVpXkhccbQ29isJFpz5VyOBJr2HlmNO7nFBGRrdu2/Du72+h7ISIiMjVM1u/scb9b/9Of/sSRRx65zvVHHXUUS5YsmZBFSXeKrWFaaumtGnpTQ281XI6bE8UrsaWa2I0KgYwJYdba3XPWGpzz5AVUohA8GWMw1pDEhqIMVVN2I3bUExEREREREZHJN+6UYN68eVx77bXrXP+rX/2KefPmTciipLtF1hA3W/Am8jGTqLlL3hqc81hrIAofl85TOkdROvLSU7HNgEp9dyIiIiIiIiJdadx7hH3wgx/k/e9/P4sXL+YlL3kJADfddBOXXXYZF1544YQvULYdaWIoXZjh1NrtzgN4SC1Y6xls0N7tLokcsQ0VWap8EhEREREREelO4w6fTjnlFObOncvnP/95vvOd7wBhDtSVV17JG97whglfoEwdpfPtYGhjqqJia6iltOdKlT4ETT0VGM4BLGnscA7yAoYKMBYMnqGGo7ZGC6CIiIiIiIiIdIdxh08Ab3zjG3njG9840WuRKWr0QeS+PYh8PGJriFOzRpAVWurqhcPgGc4hy8EBtearN7JQOMNQ5qmlKIASERERERER6SLjnvn07Gc/m6eeemqd61esWMGzn/3sCVmUTB2F8wxlnqwIbXJJs10uK2Ao8xRrTxDvUGuuFDTb7ADnDB6IDFQTcMaEQeXGENswLyrLNftJREREREREpJuMu/Lpz3/+M2VZrnN9lmX89a9/nZBFydSR5Z7CQRqvrjaKTKhGyopQERWnG1+J5H0IlYz3NApP/3DzOQqoxp4khtKFiqvYEtr1nJ/QYegiIiIiIiIisvE6Dp9+8pOftD/+xS9+QV9fX/tyWZZce+217LrrrhO6OOlupQutdvEY9XMTEQY5H+Y5DTdCq12aQATQrHQaaIDHMatmSSLTnhMlIiIiIiIiIt2h4/Dp6KOPBkKL0wknnDDitiRJ2HXXXfn85z8/oYuT7uZ9qDgaK1eyhk0Og6wx5IUnK0Pw5MtmoFWGVrzhPHy8fW94EtNsxRMRERERERGR7tBx+OScA2C33Xbj9ttvZ4cddpi0RcnUYExzFpMPrXZrc81ZTZsSBuWlo1ECPsyRwhMum/D4sQFvoV53NBLLrB6I7LhHmYmIiIiIiIjIJBn3u/QlS5ZMSvB04403cuSRR7LzzjtjjOFHP/rRiNtPPPHEZlXL6tOhhx464pjly5dz3HHHMWPGDGbOnMnJJ5/MwMDAiGPuuusuXv7yl1OtVpk3bx6f+cxnJvxz2VZE1pBEof0NQntd4Txlc8h44SCJ2KT5S61KJhtBNQlplyOEWmkcqqt8cwq5bVZiiYiIiIiIiEj36JoSkcHBQfbbbz8uuuiiMY859NBDeeyxx9qn//qv/xpx+3HHHcc999zDNddcw09/+lNuvPFG3v3ud7dv7+/v5/Wvfz3PetazuOOOO/jsZz/LJz7xCb7yla9M2ue1tUsTg8GzYqikv+4YqDv6644VQyUGT5psWg+c9x5rII3CZQvUKiHUMoCJQgAVGc/0HoP3ph1+iYiIiIiIiMiWN+7d7ibLYYcdxmGHHbbeY9I0Ze7cuaPedu+993L11Vdz++23c9BBBwHw7//+7xx++OF87nOfY+edd+bb3/42jUaDSy65hEqlwt57783ixYs5//zzR4RUMj6tqMc0/2P8yOs3RRJZahXDqnrY7W5VvRk6WahEkFiYnkJfLSYykDsNHBcRERERERHpJl1T+dSJ66+/ntmzZ7PHHntwyimn8NRTT7Vvu+WWW5g5c2Y7eAJYsGAB1lpuvfXW9jGveMUrqFQq7WMOOeQQ7r//fp5++ulRnzPLMvr7+0ecZLUs94BhZi1iRo+lN7XM6LHMrEWAad6+8YwJVU7DRRgunkTQk0AlDrOfiiIMIm/NntrUGVMiIiIiIiIiMrGmTPh06KGH8s1vfpNrr72WT3/609xwww0cdthhlGUJwNKlS5k9e/aI+8RxzHbbbcfSpUvbx8yZM2fEMa3LrWPWtmjRIvr6+tqnefPmTfSnNuWUzlOUnkbhyEuIm68iawyRNdhm+hPb5s50G9EG13oOCJVMlQhm1SCJIfeh1W5GJVz2LsyVmogZUyIiIiIiIiIysTaq7e6hhx7i0ksv5aGHHuLCCy9k9uzZ/PznP2eXXXZh7733nug1AnDssce2P95nn33Yd9992X333bn++ut57WtfOynPCXDWWWexcOHC9uX+/v5tNoAqnCfLPXkZWuqc82SFZ1pqaDbdjWANlH58bXBrP0deOIZyTy2FxERUopIsD49biQzOe0oHA1lJT2I3ecaUiIiIiIiIiEyscVc+3XDDDeyzzz7ceuut/OAHP2jvJve///u/nHvuuRO+wLE8+9nPZocdduDBBx8EYO7cuTz++OMjjimKguXLl7fnRM2dO5dly5aNOKZ1eaxZUmmaMmPGjBGnbVHhPEOZJytCqJTYcJ6XMFT3lKMkTONtgxvtOYyBRgE4MMZRiSN6KpZqYoiiUBHljCGOoJYaYlU9iYiIiIiIiHSVcYdPZ555Jv/yL//CNddcM2J20mte8xp++9vfTuji1ucvf/kLTz31FDvttBMA8+fPZ8WKFdxxxx3tY6677jqccxx88MHtY2688UbyPG8fc80117DHHnswa9aszbb2qSjLPYWDNA6tdcYYKnEYBl4vGXW203jb4NZ8DoCG8ww3HKWHwTyEUM450gr09Vhm9UTUUsu0xNCbWgVPIiIiIiIiIl1o3OHT3XffzRvf+MZ1rp89ezZPPvnkRi9kYGCAxYsXs3jxYgCWLFnC4sWLeeSRRxgYGOCf//mf+e1vf8uf//xnrr32Wt7whjfwnOc8h0MOOQSA5z//+Rx66KG8613v4rbbbuOmm27itNNO49hjj2XnnXcG4K1vfSuVSoWTTz6Ze+65hyuvvJILL7xwRFudrKt0fsRspzWlsaESw1DDM5QV1POSel6SFZ7Y0nEbXOs5DJ6hhqM/czy1yjGUGyLAFTDc8KzKPP1DnqHck5WerIRpaQjCRERERERERKT7jPsd+8yZM3nsscfWuf53v/sdz3jGMzZ6If/zP//DAQccwAEHHADAwoULOeCAAzjnnHOIooi77rqLo446iuc973mcfPLJHHjggfzmN78hTdP2Y3z7299mzz335LWvfS2HH344L3vZy/jKV77Svr2vr49f/vKXLFmyhAMPPJAPfvCDnHPOObz73e/e6HVvC7wP85dGKyyKrKFiPUNZybJ+x9J+x+OrHAP1gijyHVcjeR/a7uqFp1FAUXqMIbTXWcgKWJVBZMB7TyN3rBx2OOeppap4EhEREREREelW4x44fuyxx/KRj3yE7373uxhjcM5x00038aEPfYjjjz9+oxfyqle9Cr+eydS/+MUvNvgY2223HZdffvl6j9l33335zW9+M+71bcuMCbObnA/hz5oahePpYU/pDdOqodrJeSi9ZcWQJ7KOagdVScZAXniKEtIEGqVpznwyJLGlmjhccw3OQ+Fhux5IKxa8wicRERERERGRbjXuyqfzzjuPPffck3nz5jEwMMBee+3FK17xCl7ykpfw8Y9/fDLWKFtYZA1JFGY4rW1V3THU8FQigIi8tDhviSwM555Vw6PcaSzNTfNalVaYsKNe6aCSQG/VsN00y469lu1qllnTYmqJJS9D256IiIiIiIiIdJ9xVz5VKhW++tWvcvbZZ/P73/+egYEBDjjgAJ773OdOxvqkS6SJoXS+PcvJGqg3W98iQoWShRBnesgL8HgGM+jrcRucyeQ9xJHBeE/DebzzeBOqnBpFCLdia0giiwEiu7oiq/Th/iIiIiIiIiLSfcYdPrXssssu7LLLLhO5FulisTXU0rAjXV6GwMc1K5TSGNJkjXDJQGIha0DmPJ0UJRkDiTXEFYjKMPOpXoTHqcRQsQYbGQyh5a4SgTUhEDPN+4uIiIiIiIhI9xl3+PSOd7xjvbdfcsklG70Y6W6xNcRpCHy8h7qFJDKj7oIHoTqqcKx3lldLaO3zZIWhVjHEUdhBr3Rhl72hhqcn8hTeEJvVu+gVLoRfUYeDzUVERERERERk8xp3+PT000+PuJznOb///e9ZsWIFr3nNayZsYdK9WkFPlYg0dmQFJKMc12gGQ0nU2Wixka19hukp1BuewRKMBQfExlOtGPCQlaEFsBVEiYiIiIiIiEj3GXf49MMf/nCd65xznHLKKey+++4TsiiZGoyBaanFlY6hhiONwnXeQ1ZC0ry905a4tVv7PIY0MfRUPJGF0oHzBufDrKfQ7meIVfUkIiIiIiIi0rU2eubTmqy1LFy4kFe96lV8+MMfnoiHlCkgsobpqcUDjdwzlIf5TtZALTFUEsv01I6rJW7t1j5jILKrK6dGXq/QSURERERERKTbTUj4BPDQQw9RFMVEPZxMEWliyApDWUI19nho7kZnqERmwlviFDiJiIiIiIiITC3jDp8WLlw44rL3nscee4yrrrqKE044YcIWJlNHKw6KI4sh7IC35vXjUTi/RttdeIwk8qO216kKSkRERERERKT7jTt8+t3vfjfisrWWHXfckc9//vMb3AlPtj5Z7vEYZtYsjcLhAAtUYktWhCApTjsLhgrnGco8RXOHO2vAeciKEDTV0hBG5aWnUXicNxsMqERERERERERkyxp3+PTrX/96MtYhU1DpQoWSwTPU8Aw13OqZT5UQIOVlmN/USWVSlofgKY1XHxsZiCwMNRxZ4TDGMNwIs6XS2NOTGIwxIwIqBVAiIiIiIiIi3WPCZj7Jtsf7UK00mJUMZM1WOQfGwkDmmJ4apqUR3m84DGoFWbEd/bZG6SlKqNgQQFUjQ6PwFN4zLYF0IyqtRERERERERGTydRQ+HXDAARjT2Rv6O++8c5MWJN2vNWvJec9gveTJgeYud60DHOQF1BsefMms2iiJ0lq8DzOeRitaygqPd2AtNEqw1jPcrJLKMk89hr6e8VdaiYiIiIiIiMjk6yh8Ovroo9sf1+t1vvzlL7PXXnsxf/58AH77299yzz338N73vndSFindYe1h4M55nhrwDDSgmoBb6/jhAtK6H+2h1mFMmN3kfGi1ayldCJnwnqwIs54aJeTNuVARMOTA+ZJaxVBNbEeVViIiIiIiIiKyeXQUPp177rntj9/5znfy/ve/n0996lPrHPPoo49O7Oqka6w5DNwajwXqRcmqDIoS8ghSG0Ik70M4ZDwM5ZDljloarffxI2tIIk9WhBlPLR4oSs9Q7okMlA4azWO8g5Jmq543DGQevMN0UGklIiIiIiIiIpvHuN+lf/e73+X4449f5/q3ve1tfP/735+QRUn3yXJPVnpK5xnIPP2ZZ9VwmMNEswLJAYUL52kMcRQuF66z6qewW11oswutfR7nwiBz46FWtZTN9rxKbEliiyMEUJXY4Dw0ys6eS0REREREREQ2j3GHTz09Pdx0003rXH/TTTdRrVYnZFHSXUoXZixlmaO/7qg3fDOMgqyEsgwhkyecIHxgfGil63BcGLE11FJDGof2u9yF8ySCSmraD57aEGh5H2ZPeQd56alaAEOhAEpERERERESka4x7t7vTTz+dU045hTvvvJMXvehFANx6661ccsklnH322RO+QNnyvIfhhgutb5EljkOo5BNDFHmGspALzYzDvCZHCKWyAmZWoRJ1nnHG1hCnpj3UvHTgiCiLMPPJA1EUhp3nZXNWlA1VVmlkyDXvSURERERERKSrjDt8OvPMM3n2s5/NhRdeyLe+9S0Anv/853PppZfylre8ZcIXKFue86HyyXiorDENPIksvZWSrAF5GU6xXb1zXWKgVoE4Gn8g1NqtzhhILJjYUy88jQKcC219iYVKAom19CSWvPBUoo17PhERERERERGZHOMOnwDe8pa3KGjahngfTqO1z1UTmF6BvLlLnSFUIqUxVCxMq27a8O/IGoxxDGeQxBF9acGqRliLjQx54UlTHyqkDExLTTu4EhEREREREZEtb6PCJ9n2VCJD6T154YlMmKlUOo8BplXDbKbeFGxzx7tKZKkmUEksfhNHMDnnGc5LGvXQypeXMJRBFIVKp0rkqcSeGamhlmqnOxEREREREZFuovBJNiiODNWKYTj3FIVjqGwOF/dhonhPCpUIehKLtQYDpLEhjsBgOh44vrbCeYYyx/JBx8o61DPAhIDLmjAPimbY1VsNwVOsqicRERERERGRrqLwSTYosoZKAiuHAQw9kcdacM4wmHvyArabbulLo3Z7njWGrPBUYjaqDS4ET56sgIEszHpKYig87cALA64ZhNUqCp5EREREREREupF6lKQjiTGrq5kig8dgmhVR1QR8EeZCWRPOs8ITW0iTjQuEstxTODB4hnLwLsySipoDzfMSIgzOwUAD8tJN8GcsIiIiIiIiIhNhkyufyrLk7rvv5lnPehazZs2aiDVJlymdx3nDzB5L4UKw5JpB04zYYvDkJdRzhzEGa6CaGNLEbFQ1Uul8e+e8zEFRQOnB5TBcrB5+7hOPM0AeZk6JiIiIiIiISPcZd+XT6aefzte//nUgBE+vfOUreeELX8i8efO4/vrrJ3p90gW8D61tSWSoVSwzqpa+nnBeq1iSyDRnQI2+I97GPl+Y6+TxJgwYXzkEWSOchjNYPgRDDXCEoeQiIiIiIiIi0n3GHT5973vfY7/99gPgv//7v1myZAn33XcfZ5xxBh/72McmfIGy5RkDhtXVRZENFU2RNZTOM9AIlUppYqjGhiQyZAUMZZ5iI0KhNZ+vEluKEobzUP1UutUnTwihyjIcJyIiIiIiIiLdZ9zv2J988knmzp0LwM9+9jPe/OY387znPY93vOMd3H333RO+QNnyImtIIihGGauUFWEYeK1iwqyn0lM6Txqb0KKXjz98WvP5nPMUZaiGKkpwLoRQNIOoonlyXpVPIiIiIiIiIt1o3OHTnDlz+MMf/kBZllx99dW87nWvA2BoaIgoiiZ8gdIdwvymEDaVzuO9p1E4hhoe6x2DjZJlq0qW9YfzpwYKnHPkZWid29jnG2q49o52GPCmuZte86VmLeQO8lLhk4iIiIiIiEg3GvfA8ZNOOom3vOUt7LTTThhjWLBgAQC33nore+6554QvULpDbA21NFQy5WVzALgH7x3DpSfLwoBw46EwsHzYM5zDzBpM9+MPJVvPt6ruKTxUIkji5lwpG1LTyEKjuRPexgRcIiIiIiIiIjL5xl359IlPfIKvfe1rvPvd7+amm24iTVMAoijizDPPnPAFSveIrWFaaumtGnpTQ2/VUJSeoQwq1pJYSxyF84q1DGSwarjcqCHkpQtTx6uJIYkhTWB6Cj0VqEZQaV4XxyGMmohB5yIiItuKiy66iF133ZVqtcrBBx/Mbbfdtt7jV6xYwamnnspOO+1EmqY873nP42c/+9lmWq2IiIhMdeOufPrmN7/JMccc0w6dWv7xH/+RK664YsIWJt0rsiHpaRShugkDcTQy/YkjoGgOCne+fZ8NKZwnyz313OM8ZDmkMdQbkBfhGG/AuNBuZzxMq0ASaeC4iIhIJ6688koWLlzIxRdfzMEHH8wFF1zAIYccwv3338/s2bPXOb7RaPC6172O2bNn873vfY9nPOMZPPzww8ycOXPzL15ERESmJOP9+CY1R1HEY489ts4fJ0899RSzZ8+mLMsJXWC36e/vp6+vj5UrVzJjxowtvZwtajAreeiJIiSYkcV7h3NhDpMxFkpHAey+Y8y0dMOtd4Xz9A87hhvNl6SBPHc8+rRnoBF2wItsOPeAAxIDO06HPXZKtOOdiIiMoN/Zozv44IP5u7/7O770pS8B4Jxj3rx5vO997xu1iv3iiy/ms5/9LPfddx9JkmzUc+p7ISIiMjVM1u/scb9b995jRulx+stf/kJfX9+ELEqmBkOoeDIGhjPH00Pw9DA8PRQum2ZFVKcdcYOZY7DuwRhia0isoacSUUshMlCrQDUJLXfVBGakofWuVkHBk4iISAcajQZ33HFHe2YngLWWBQsWcMstt4x6n5/85CfMnz+fU089lTlz5vCCF7yA8847b73/4JhlGf39/SNOIiIisu3quO3ugAMOwBiDMYbXvva1xPHqu5ZlyZIlSzj00EMnZZHSndLEElHwxCAQhblLMaEtbriE4Qbs2OtJkw0HQ6XzDDU8GKhEprmjXrh+WmqoFx7noJaEiqfShftVY/DG0D9cUkstcYftfSIiItuiJ598krIsmTNnzojr58yZw3333Tfqff70pz9x3XXXcdxxx/Gzn/2MBx98kPe+973kec6555476n0WLVrEJz/5yQlfv4iIiExNHYdPRx99NACLFy/mkEMOYfr06e3bKpUKu+66K29605smfIHSvSJrsAayEhJCFVKrJS7LIS/BGjqa91SUnkYBsfEMNxyFCzvbOR9Cp74KrMrCYzoHzkJvBfpqEFtLVgB4aikKoERERCaQc47Zs2fzla98hSiKOPDAA/nrX//KZz/72THDp7POOouFCxe2L/f39zNv3rzNtWQRERHpMh2HT60/LnbddVeOOeYYqtXqpC1KulurKikvHaWHvh4o/epqJFjdDld6aBSuo7a40nvywoM1xM3ZTqWDgYYnzyFJoGZD8JREEEcRvvR4G3bFy0vIck+cKnwSEREZzQ477EAURSxbtmzE9cuWLWPu3Lmj3mennXYiSRKiaPX8xuc///ksXbqURqNBpVJZ5z5pmq6zOY2IiIhsu8Y9KOeEE05Q8LSNKpxnMHOsqntWZZ4VQ46hBvRWYVbN0hOHNrieOFye1QMlhrzc8Ez7ODIYH6qfKpHBNls848gSGxjKoSyh7sMud1kBZekZKjzee6wJgVVehnBMRERE1lWpVDjwwAO59tpr29c557j22muZP3/+qPd56UtfyoMPPohzq/+V6YEHHmCnnXYaNXgSERERWVtH4dN2223Hk08+CcCsWbPYbrvtxjzJ1qlwnqHMkxWhlS6x4bz0MNSA4dxRNIOhwkNWOHIPJoxx6kgSG0wEeeEpC0dROvJGGQIlDyvrsGIIVg7C8mF4csDRKHy7Pc+a0PI3vv0bRUREti0LFy7kq1/9Kt/4xje49957OeWUUxgcHOSkk04C4Pjjj+ess85qH3/KKaewfPlyPvCBD/DAAw9w1VVXcd5553HqqaduqU9BREREppiO2u6+8IUv0Nvb2/54tN3uZOuW5Z7CQRqv/t73VCLSyPHEYKh2mlYBY8E7qOfQX4ftp3c2cNz7MMDcuZKBekne/MdV52CwDq4IoVbhIAKMgxzAQ73i8D7CE4IuvTxFRETGdswxx/DEE09wzjnnsHTpUvbff3+uvvrq9hDyRx55BGtX/+6eN28ev/jFLzjjjDPYd999ecYznsEHPvABPvKRj2ypT0FERESmGOO96kTGo7+/n76+PlauXMmMGTO29HI2i9J5VtX9qMPD//xEg6X9UKnA9DSU0jmgKCFrwE4zYffZG575ULrQxjeYOxoFuGbrXOE8f3k6tNlNS1aHWzYKVVV5Gdr+9pgb47whjWFaOu5uUhER2Qpti7+zu5W+FyIiIlPDZP3OHve79DvvvJO77767ffnHP/4xRx99NB/96EdpNBoTtjDpHt6Hdra1N5FrFI4oMmw3LVQjNYpwKkqIDGw/Day1NAo32sOOEFmD856yNPRVI2b2RPRVI6YlBuOhLEJLX17CcAGDWTPgcuHjoYYjtpAmKnsSERERERER6SbjDp/+6Z/+iQceeACAP/3pTxxzzDHUajW++93v8uEPf3jCFyhbnjGhnW3tOd4OMMbQm8KsaYa+KkyvGmZUDdtPt/T2mOY8pg0/R+k8xhiqETTKMMfJmDD/KStCtdNwIwwdx4ErYaABvoCsBLyjlhritRMyEREREREREdmixh0+PfDAA+y///4AfPe73+WVr3wll19+OZdddhnf//73J3p90gUia0iiMG9pTZYQEJUYpqWWmbWYvh5LGhucNwzlkBWe4Yaj2EAC5X14nlrVUImarXvNIU6lA2/CMUONEDYVzWHmzod1TK9GCp5EREREREREulBHA8fX5L1vb7X7q1/9ir//+78HwjDK1o54svVJE0PpPFnhsca3B3tHJlQmpbGh9J7h3FM6SKNQpdRTAY9lKPPUUsYMiFrVVQZDrRJa8LwH4w2J9QxnYKJm619zB71mwRNpvG5LoIiIiIiIiIh0h3GHTwcddBD/8i//woIFC7jhhhv4j//4DwCWLFnS3iVFtj6xNVQSTzbs6M9CwBRZqCbg8Tw9WFJ4T15AEsNQDrXE0NcTUYkNWeHJck+cjp4SheqqEGRFFmwzjYoji6OkcBBH4bYW50IABWgHRhEREREREZEuNe62uwsuuIA777yT0047jY997GM85znPAeB73/seL3nJSyZ8gdIdCucZyjyNIlQZJc1qo9IZPGCMZ7gRhoDnOVQMVGPT3h0vtmFYeLme9rs0McQ2tOqVzuO9Z7hRUnpIK9CThOdsnSoxVOPQkpd3MNRcRERERERERDa/cVc+7bvvviN2u2v57Gc/SxRFE7Io6T6DmWOw7rGRIY0NpjmDaaDhGMpCuAQhFDIG4tjgfAiSahUTgiof7jOW2BpqKWS5ZzBzOA+NHBILaRUqUdjprjkKip44BFrGhABKRERERERERLrPuMOnsVSr1Yl6KOkypfMMNcKgpUq0OuVx3pMXnqE8XK4mkBgwFobzUI1kbJgHBbTnRK1P4TxDDcdQw4fwqQytds5DXrSeGLDNyyZUREVquxMRERERERHpSh2FT9tttx0PPPAAO+ywA7NmzVrvfJ3ly5dP2OKkOxRlaLdLRylsG849uFCNVBSQe4hiqNiwK50ZdszsicIQ8ph2G95o6oXjqQFHo4BqZLAWIgzWeAYzsFHoE/WAKcEZsBZqKVSTcXeQioiIiIiIiMhm0FH49IUvfIHe3t72xxruvA0a5VveKBz1AkoHDR8qnpyDRh3yyGMNDHkYzEqmpxFpsv7XzarhEDxNT1cHSbWqZXqas2IYYhNmPK25prwIbXmVWOGTiIiIiIiISDfqKHw64YQT2h+feOKJk7UW6VJxZKg0B4ZH0cih4WUBA1kY/u1CZx4loV2uKKFaCYPEa6khXk/VU6NwDOdQjda93ljorYbHg+ZcKR/a8Wo9YRe8RuEUQImIiIiIiIh0oXG/W1+wYAGXXXYZ/f39k7Ee6UKRNUxLDbn39A+XDNQdA1k4DTYgdyF4cg4KH+Y6Fc22uMhALVl/8ATh/t6HNro1tYKuWT2h6im2zd3uYujtge1r4DHk5XommYuIiIiIiIjIFjPu8GnvvffmrLPOYu7cubz5zW/mxz/+MXmeT8bapItUEkNsIS89jpAUeULLnXcQxyF0soTzSgLGNa/roE2ztUuec+ve1h48HkFPCtNSmF4J98kdeO9H6woUERERERERkS4w7vDpwgsv5K9//Ss/+tGPmDZtGscffzxz5szh3e9+NzfccMNkrFG6QFlCT8Wy/fSINDbEsSExUKtApRLa4JIotN8lUQiGKlGzDc9vuCqpElt6EqiX615vPPRnkMRQi8OuepUIwLAyC8+dauC4iIiIiIiISFfaqHfs1lpe//rXc9lll7Fs2TL+7//9v9x222285jWvmej1SRconScvw8BvCDOgImOIo9AGN70S5i6VDkofKpXSaPU8JjrsiOvtsVRiGMgcReFwLpyXhOFkzsOqBqyqh/Phhofm7noiIiIiIiIi0p026W370qVLueKKK/jWt77FXXfdxYte9KKJWpd0Ee+hcD603Lkwv8nEgLdYE8KhJIKeJAwBDxmVpVE60ijMjOpENbZsPz3sejeYeVwBZenoSUIl1VDWbLMjPEdiYUY1PH5R+o6fR0REREREREQ2n3GHT/39/Xz/+9/n8ssv5/rrr+fZz342xx13HFdeeSW77777ZKxRtjBjIC98c/e61QFPElv6ehwrhpqznwgzm4wFg6cSQ2/VEkedh0KxNdQqFu8dzkNRGlY1PM6HFr+GC+V6DqjYMOC8kWvYuIiIiIiIiEi3Gnf4NGfOHGbNmsUxxxzDokWLOOiggyZjXdJtDKw91TuyhmlVy0AjBEV5GeYvYaAn9lRiQ2/VdlyRVDjPUOYpHFQTizVQz2GwXlLPYXoKvoTcNweUR2EQeb0IAZmIiIiIiIiIdJ9xh08/+clPeO1rX4u1GvC8rfA+zHky3tMoPXFzZzofRi4R2xAAed8cItbcha7HQpp0ngpleQie0nj1fTyAhaEShgeb4VbTUB7a/KoJFGWotBIRERERERGR7jLut+uve93rJmMd0sWMgcQa4goUJWRFaIOzBvCeSgKVJMx9MhiMAdusdmrknmoHr7L2UPNRMs1GDkUjBFq2OVPKGzA5pHG4XY13IiIiIiIiIt1JtSKyQZE1JJFnKA+X88LhAe88jRIw0FeNSCPTHgZuraHeCIPDp6UbHgbeqqJa+zDnPFkeZjvFEaw5PsrEkJUw1ADvFT+JiIiIiIiIdKOu6Z278cYbOfLII9l5550xxvCjH/1oxO3ee8455xx22mknenp6WLBgAX/84x9HHLN8+XKOO+44ZsyYwcyZMzn55JMZGBgYccxdd93Fy1/+cqrVKvPmzeMzn/nMZH9qW4UogoF6yd9WFKyoe/qHPcuHYekqyItwu7WGyBqsNTjnsdZTLzxFueFgyJgQWrm1DvVAVoRB5rENbXa2eR5FIbTKi3XvJyIiIiIiIiLdoWvCp8HBQfbbbz8uuuiiUW//zGc+wxe/+EUuvvhibr31VqZNm8YhhxxCvV5vH3Pcccdxzz33cM011/DTn/6UG2+8kXe/+93t2/v7+3n961/Ps571LO644w4++9nP8olPfIKvfOUrk/75TXXDmWOwERIeSwiLLCEwqueQNRwQKpWGc8dQ7hnMPMO5Z7DhKDaQDoXqKijCw+C8p3Se4cyBCRVReRlOZfO8kUNswBkYbpST98mLiIiIiIiIyEbrmra7ww47jMMOO2zU27z3XHDBBXz84x/nDW94AwDf/OY3mTNnDj/60Y849thjuffee7n66qu5/fbb2zvw/fu//zuHH344n/vc59h555359re/TaPR4JJLLqFSqbD33nuzePFizj///BEhlYxUOs+KIYf30FOxNHJH6cOMp54KNApYVfdU4jIMHi+hEodSpoqB0hmGMk8thXg97XdpYsgKx4ohR+k8mNBSV7oQdFUroQKqJbIhgIqAZLRhUSIiIiIiIiKyxXX8jv26665jr732or+/f53bVq5cyd57781vfvObCV1cy5IlS1i6dCkLFixoX9fX18fBBx/MLbfcAsAtt9zCzJkz28ETwIIFC7DWcuutt7aPecUrXkGlUmkfc8ghh3D//ffz9NNPj/rcWZbR398/4rStyfJQ9eQ8DNYdeRna3EoHrgyDwJcPwuMrHKuGHPXCMdgIYdX0HkutYilc2M1uQ5zz1JuVU0MNT05zwDirw67WKY5CRVQSQyXqfFc9EREREREREdl8Og6fLrjgAt71rncxY8aMdW7r6+vjn/7pnzj//PMndHEtS5cuBWDOnDkjrp8zZ077tqVLlzJ79uwRt8dxzHbbbTfimNEeY83nWNuiRYvo6+trn+bNm7fpn9AU44GsAfUMMAYbNWc7RYa4udvcwDAMFGEA+HADBjOPx5PGIRSKbbNlbj3td0OZYzCHahLRl1r6qpZZqaG3B2wU2u2cW33Ch+BpegpJpMonERERERERkW7U8Tv2//3f/+XQQw8d8/bXv/713HHHHROyqG5y1llnsXLlyvbp0Ucf3dJL2uysgQIogTgyWGMwJpxDCKfiOFQmpXFoj6ulBrxpVztZE44ba1O60oUZUdaHlr04tsSRJY4ts6aFgAnfHDq+RpFTLYFahY7mSomIiIiIiIjI5tfxzKdly5aRJMnYDxTHPPHEExOyqLXNnTu3vYaddtppxJr233//9jGPP/74iPsVRcHy5cvb9587dy7Lli0bcUzrcuuYtaVpSpqmE/J5TFXWGNIY6g0onG+HP857hhshwQytb2EOUxwZYmvwPgwcn5Z6fBjhhBmjO64oPQ0HadR8bOfxhPtMTwxM8ww1wv0LF164tQpUk3DqdK6UiIiIiIiIiGxeHVc+PeMZz+D3v//9mLffddddI4KhibTbbrsxd+5crr322vZ1/f393HrrrcyfPx+A+fPns2LFihHVV9dddx3OOQ4++OD2MTfeeCN5nrePueaaa9hjjz2YNWvWpKx9azG9YkgrISTKnadwnqyA4Xz13KVqHHati4yhKKH0nqzwFKWncKEyKlpfMOTDfYbXmPmUlWCMJ7bQW4WZ02BWD8yaHqqrnF/9mFnhO5orJSIiIiIiIiKbT8fh0+GHH87ZZ59NvV5f57bh4WHOPfdc/v7v/36jFzIwMMDixYtZvHgxEIaML168mEceeQRjDKeffjr/8i//wk9+8hPuvvtujj/+eHbeeWeOPvpoAJ7//Odz6KGH8q53vYvbbruNm266idNOO41jjz2WnXfeGYC3vvWtVCoVTj75ZO655x6uvPJKLrzwQhYuXLjR694WxJFhWtUyo2ro6zEkNrTPORda4KwJ7XCeUA1VOI+1UORhyHijDOFRmowdPMWRIbKe/syTF+GFGdlwbo0l95AVofqq3pwrleeengRqiaVRQKP01HO/3rlSIiIiIiIiIrJ5Ge/HmsIz0rJly3jhC19IFEWcdtpp7LHHHgDcd999XHTRRZRlyZ133rnOQO9OXX/99bz61a9e5/oTTjiByy67DO895557Ll/5yldYsWIFL3vZy/jyl7/M8573vPaxy5cv57TTTuO///u/sdbypje9iS9+8YtMnz69fcxdd93Fqaeeyu23384OO+zA+973Pj7ykY90vM7+/n76+vpYuXLlqMPXt1Yrh0v6hzw2MhRlSdbwZA6eHoDSw7Q0hFB4sDacCh/CqV23i+jtiTbYDvfYypynBzxpxRIb2tvcZaVn5aAjScIue7hQaWWNIU0M01NLZA1Z7rAWZvdGxNr9TkRkm7et/s7uRvpeiIiITA2T9Tu74/AJ4OGHH+aUU07hF7/4Ba27GWM45JBDuOiii9htt90mbGHdalv946lwnv5hx3DDUy8cjSJUJj21ytMow9ylStScx2QBC95BXw2etV1lg2FQ6TwrhhyDeXjsNY+u5w4M1GLDYOaJY6jYMIy8UXoqFnoqlqJw5B7mzrBUYu1+JyKyrdtWf2d3I30vREREpobJ+p3d8cBxgGc961n87Gc/4+mnn+bBBx/Ee89zn/tczUvaBsTWMKPHEltHPmjoScLw7xlVz1AeKpJa5wDTKlCJIY3tmEPG1+Q9WGvoSy2NOLTQOQcej8GSRJ56DrmHRgYu8cTekVgonKF0PuzGZ2nvwiciIiIiIiIiW964wqeWWbNm8Xd/93cTvRbpcrE11CqWRtmc8eQhLz0N5/EGYgc4yIGKXd2G1wljWrvhGWoVQ9rc7a50nsHMM9RwDDfCnKnSQb/zVPBUKpBEhkZpSQwkseko7BIRERERERGRzaPj8Okd73jHBo8xxvD1r399kxYk3c2YEEJZA96EACqyEFmLiT3eeVID1dhSNgOkTho7I2tIorCDXni8kCAZoJ6X9A9DHEHuoCjDfXwEw3WYXvH09UAUGXoSs/4d9URERERERERks+o4fHr66afHvK0sS371q1+RZZnCp61cZA3WOLICTLMprpaAA0pnyH2oeqpEBhuBw+C8Z+QUp9GlSWifywrfbJ9bXfk02AiX8xIaZXi0JApBFZWwW14lMuvdUU9ERERERERENr+Ow6cf/vCHo17/4x//mI9+9KOkaco555wzYQuT7lM4T5Z7hnPPcMNTlJ5G4UksVBNL3TtqMVQrhmpiyQpHbDqfwRRbQy2FLPfkZdhFLy/DQPOsBOvDYPM0CpfrRbhfJQZrPLXUbnBHPRERERERERHZvDZq5hPATTfdxJlnnsmdd97JaaedxplnnqnB41uxwnlWDTuGGqGVzlpwhSfLYdjAcFHiHUQR5C4ERqmFStrZwPGW2BriNFRAeQ/DltCKB0zrCfOeIDx2TwUG65AXUI2NgicRERERERGRLjTu/ej/8Ic/cOSRR/KqV72K5z3vedx///18+tOfVvC0lRvKHP1ZaJ9LrKEaW/p6YqanUM+gfxD6M1g+CE8MwJP9joHcUYnYqBlMkTXEUQihcgdpHFr5kgjiNR7OG6jnsGKooHAdTjcXERERERERkc2m4/Dp0Ucf5aSTTmK//fYjjmPuuusuvv71r/PMZz5zMtcnXaA1d8l6qMQGaw3GhHPnYagBw2VoieurQi2B3IcgaigvN+m5jTEkFvAwnHvqOQxkMNwIoZf1Yee9whmGMq8ASkRERERERKTLdNx2t8cee2CMYeHChbz0pS/lj3/8I3/84x/XOe6oo46a0AXKlleUnoYLs5YAXHMXO+c8/fWwC10SQ2QAY0hiSBPPQAOeWuXZcbofd/VTq+0uMlCNQ+Dk8jBs3LV2uwMwUKuEy1nhiSzEqdrvRERERERERLpFx+FTvV4H4LOf/Syf/exnRz3GGENZblqli3QpD6X3NHJH6cB7qDdKBrPQEhfZUPkUGWi4sAtehOfpYXhyVc72vUlHM5laQ83zMoRLBktsSxoFpAlYB675MLENu9/VIohsRKP02ByqyfjDLhERERERERGZHB2HT865yVyHdLE4MkTW0595KtYQW9oNm7kDn8P0nhAWDTU8zoegKImgcGFg+FDmqaWsN4AqnG+2zoVgyZqw211kIbHQyKFeAj6EXaULz5Om4XJRhuonr847ERERERERka4x7oHjY3HO8dOf/nSiHk66SGQNkQVfAmtkR4kNu95lRZjB9NQArBiGwQYM1j1ZEVrypqU2hFD5+lOhLA/BUxobouZcKQ9UEkMtDWGU96vb7WILvRUwJrQARiaEXU7pk4iIiIiIiEjX6LjyaSwPPvggl1xyCZdddhlPPPEEeZ5PxLqki5TOU4ks02uORuEpPODBxpZq5Bisg89C0BQBJbAqh9LAvBlQTaKwa10ZHmu0lrjW7fEocehww+OA6TWIM8CEqiprQrXTcCMEUo5WxZRa7kRERERERES6xUZVPg0PD/PNb36TV7ziFeyxxx7cfPPNnHPOOfzlL3+Z6PVJF/AerDX0pZa+qqWaGCqRoZoYZlTDzCfvwYUhTTgPBWA8xM1405oQEI1VlNSqaFozlyq9Z7jhGMxguIB6IwRMjRL66+G0sg79Q/DkQElROiqxQdmTiIiIiIiISPcYV+XT7bffzte+9jWuuOIKdt99d4477jhuvvlmvvzlL7PXXntN1hplCzMmdNsZY6hVDEnpQsBUOqyF7aeF1rvBHAofqo9m9UClORC8UbjQRtd8rPU9h2vucFd6z3DmaZRhnpNrhEArb4ZQkQUTAQ6SSrh+qOGZ0aNh4yIiIiIiIiLdpOPwad9996W/v5+3vvWt3Hzzzey9994AnHnmmZO2OOkOkTUkkWco91CEuUweqDc8gw2IDdQqoXqpUUIlCqfEhoHkRXP3u7Ar3ujBUOs5siIES0OZC8GTCcFUXkDmwuNlBdgI4iI8jwGSBEoPjULznkRERERERES6Scdtd/fffz+veMUrePWrX60qp21QFIVgZyAL/XURHuM8Q43mkPE8hEaxDUO/V2ahLa4owv1iC2my/oqkNDEYPMsHC1YMO+oNx1DDsXIoBE+JDa18FQuRDwFUTgik8GEOVD0PlVYiIiIiIiIi0h06Dp/+9Kc/sccee3DKKafwzGc+kw996EP87ne/w2jAzjahLKESGaanBqyh9IakEpGYMI+pLEPlkWnOdsKFeUx5Cb1VSy01xB20w7XmQq05/ykvwmPbKBxgbBhunsbNYwxMr1oiDFnhw+wpEREREREREekKHYdPz3jGM/jYxz7Ggw8+yH/+53+ydOlSXvrSl1IUBZdddhkPPPDAZK5TtqDWTnRpbKhVLNMqhmmpoRpDFINxMNgIVUd5Aa4Mu9BZA5UYqklnwVOWh4nls6ZF9KaWntSSmDC0PAEGhkNbX1GGaqd6Hlr+8NDIHbY57NyPNdVcRERERERERDa7jdrt7jWveQ3f+ta3eOyxx/jSl77Eddddx5577sm+++470euTLjDaTnQQZjnhIYnBOWgUoQoqc+E+leZEsbzccBjUCrhiC9YYYgulA29CVVXhwdow36n0YS3WhCCqLEM1VMOFaqgk2qiXtYiIiIiIiIhMgk16l97X18d73/te/ud//oc777yTV73qVRO0LOkmrZ3o8tIz1HAMNjyDmWeg7hhshJAoMuCboZMvmy1yJlQquQ4qkVoBl/fhObLmc61qrK52siYEXZUIsM3wyYVTPYPEwLTUjrmjnoiIiIiIiIhsfh3vdrch+++/P1/84hcn6uGki0TWYI3j6bonblYlGQuJNWS5ZzCDNAlzmHDhtixvVij1QNRBGmQMOOdZlTsaRQi7Wncrm7vc+WKNmVDNOVClhwowLYXpNcv01I65o56IiIiIiIiIbH7qT5KOeMCGkUwjr/eQ+9AWZ5oDx8sS6mWYyVTPYLDhQoveekTW0CgdA0MegyE2hmpsqRqoJGGOVNnc0S4yq9vvTLMaCgNpZDa4o56IiIiIiIiIbF4TVvkkW6/Sebw3TO8J7W9Z4fFAo/Qh9IlDINRwoUoJQkuciUJoVW94hmJPLWXMweOl85Qu3AcPPvwHG4V5UlEEiQ0tdqUPx1TiEIjZ5vNpzLiIiIiIiIhI91H4JBs02sBx70MQZIDUNoOm5uDvyAAGyiIcF0Xh2Cz3xOno4VNRekpnmFbx1BuOoTI8Z1Y0wycbHjPy4WNrmq16zcu91XDA+p5DRERERERERDY/hU+yQcaEyqR67nHGkFiDMVBEq2cwGQfYEEANN4Mj76AAnuj3zJ1ZYk1E6fyYM5lK76GEKLJMsx5jIPIeC+TNeU9mjTVFEUSEwIvmLKq8ZL3PISIiIiIiIiKbV0fh03gGib///e/f6MVId4qswXtPvYTpa1QVxbGlJ3GsyCE2oUKp0RwEXmlWKqUWhgtY1u/YfjpMT0d/ycWRweAZLmB61eCa7XvGgDPNSitWDykzPjyfS0Iw5ZzDGkvpw7EiIiIiIiIi0h06Cp++8IUvjLj8xBNPMDQ0xMyZMwFYsWIFtVqN2bNnK3zaCpXOY42hEnsahccQqpIMIXSKLFgLjUYIftIIaAZGPSn09VgGMkf/kGPujLGfJ7GGYe9YNVyGB/eh7a6eQYMQaLVCKU94zjyHIQuNEnIXhpV3sLmeiIiIiIiIiGwmHe12t2TJkvbpX//1X9l///259957Wb58OcuXL+fee+/lhS98IZ/61Kcme72yBXgP1hp6Yiidoz9zPD3sWJk54ghqlbDDXcOFGUxFsyopjUIw5fFUbNgBr1G4MZ8jiU1zPpSnLD2F89SLMMTcA5mDnNWnevOy9zCYeQaGPcao5U5ERERERESkm3QUPq3p7LPP5t///d/ZY4892tftsccefOELX+DjH//4hC5OuoMx4JxnoOGbAZPHNXeny5uDx+MoVEFZG4qWouYryxGGicdRGERejtESZ5pte7E19FRMCLHK5u52rWPGWF+Wh+OcGfsYEREREREREdkyxj1w/LHHHqMoinWuL8uSZcuWTciipLtE1pCXjqcHHSXN1rdmhdPAMNQLmF6BWhrSzNYudKULrXhJczC4xYSd8MZQek9WeLw37Va+KA/VTRAeg/DUQAiaCsI6kghmpAbnjQaOi4iIiIiIiHSRcVc+vfa1r+Wf/umfuPPOO9vX3XHHHZxyyiksWLBgQhcn3aF0nsHcMZSHKqMIws5yBQznYYe5ogytd8N5CIeSOARCcQQVa8icYVoFeirRqM/hfWi3axQhTGoNDq+v0aVXNE9l87RmEVUEJJFp774nIiIiIiIiIt1h3OHTJZdcwty5cznooINI05Q0TXnRi17EnDlz+NrXvjYZa5QtrCg9g3VIbHO3OxuqnUoPlQjw0J+Fne6yBvQPwuDw6p3vVgx70hi27x09eILQytfIQ9XUUOZ5agAe74eh4bHX1cqYYiCKQ7WVAQ0cFxEREREREeki426723HHHfnZz37GAw88wH333QfAnnvuyfOe97wJX5x0h0bhaBTQk0ASW1xehlY6C/02VDyVhNDHmFC5VDSgQqh+6qvCTrMipo1R9QTNKqfSs3wohEjWgI0gzse8C62iKGPBNmdPpTHbfMtd6Tzeh+/Ftv61EBERERERkS1v3OFTy6677or3nt1335043uiHkSnAWoO1YdaT956yaFYYEWY6lYQgyHnwJgRHlShUPSUx7LJDQiXecJHdYBba9irR6mCJsfOq1esDosgQW0iTbTdsKZwnyz15GarCDJBEnjQxxAqhREREREREZAsZd9vd0NAQJ598MrVajb333ptHHnkEgPe9733827/924QvULa8JDLUEqjn8PSg4+lhWFGHpwdgsDkQvBVGRc3z1symwkGWu/U+PkBeOuqNcH/XvF9ehrlSHfGeWrrthiyF8wxlnqwI4V9iw3lWhDbGwmkQlkg3aBSOeu5oFBv+uditSucpSk+pnysiIiIi0qFxh09nnXUW//u//8v1119PtVptX79gwQKuvPLKCV2cdIdKbJlWgeEyVCflJRRFmPvU6oozhKqnVhVUmPwNeQ5ZB2+ySh8qq5yHqBmeVKIw2HxNhvCitaxRtuehVtl2gyeALPfNtkNDZA3GhPM0Ns0AUG8SRbakeuF4YlXB0n7Hsn7H0v5wuT6FQqjCeQYzx6q6Z1XmWVUPlxVui4iIiMiGjLtf7kc/+hFXXnklL37xizFrTHbee++9eeihhyZ0cdI9nAlzlZIYIhfCIrtGVVIchcCoPa/JQL0BWQl5ueE3Jt57jCG09/lwAmisNfOpVWEFIZjyzcDq6UFP3zS/TQZQpQutdmN1NsY2BIal85oBJbIF1AvHUwNhdl41CvPsnIOBDBqlY/vpUO2gNXlLalVXFi78TLEm/OzNivCzpZayTf78FREREZHOjPuv3SeeeILZs2evc/3g4OCIMEq2Ho3CkeWGmdNgVg3SNAwbN/HqNjtjmm13zZeAJwRURQGrhtngv+5XIksUhVa9OGqebNjFbk2OUF1VAnUXLtsIcrfttpd5H77eY73vs6ZZiLbtfWlEusKq4RA8TU8tcWyxNpxPTy2NItze7VRdKSIiIiKbYtzh00EHHcRVV13VvtwKnL72ta8xf/78iVuZdI28DJU11QjS2NITQ28PVGOIm6FTVsBQAwYbMNw8RUAlCdVPTw249QZQkTVMq4QXpGsGUJUI0mT9a/OAK0PVVVb4bfINUCv4Gyt3c351QCgim1ejcAzn4efnaKpR2Gihm2dAjae6UkRERERkNONuuzvvvPM47LDD+MMf/kBRFFx44YX84Q9/4Oabb+aGG26YjDXKFhaCDc9QDqV3FC5U0aQJVCw0ylCJ5AmVSBHNC0BPBDNrq/91v9o7+rsXY2B6BYqe5qDxEgq/usVuQ6LI0Cg9Nodqsm21l0XWkERh2Hg0ypc3VCuwTX1NRLqFa26+YMcIn6wFX4wdHneDTqorW5tMiIiIiIiMZtyVTy972ctYvHgxRVGwzz778Mtf/pLZs2dzyy23cOCBB07GGmULSxOL9bB8KMwoGWye6o0QbLT+vd7TDKqal1vDx4vSk1i/3n/dt8YwrWqZWYPtpxlmpjCz2gxNOlhjWXq8C9VP2+IboDQxxM3qr9J5vA/nWeGJbbhdRDY/a0K47sYobHIu3N7N2bCqK0VERERkU4278glg991356tf/epEr0W6mCe0huAhaU79LgtoNN+MtGY/tQKoqPlxAdRL3yqEGvPNizFQq1hK5xnMPCYG46Bs7qC3PjmhUmqaCbOfnG+tYtsRW0MtDXNX8jJUIRhCeBeCqW3r6yHSLSqxpSdxDGQwfZTfuPUSpqfhuG6l6koRERER2VTj/ms3iiIef/zxda5/6qmniKJOalRkqilKT+ZWz/vIPGQOhsvVVU6W8LEhJJpRHHbG82XYkS4vwuOM9d4kvLkBh6GaWHqiMC+q3FDyRAinsmbrX9iFadt8AxRbw7TU0ls19KaG3mq4rOBJZMvq7bFUYhjIHEXhcC6cD2SOShxu73aqrhQRERGRTTHuyic/Rk9TlmVUKpVNXpB0n0bhqGdhAHhPpdlq58OcklbolDePbYVRURn+hbwEihKIoCdZ/7+Me8D61dVOjTxUMnUiL0O1VRKbbb71Q9UHIlteCGhCVWc1tmw/Pcy9G87Dz05jQsVTb4+l2sVVTy2qrhQRERGRTdFx+PTFL34RCLvbfe1rX2P69Ont28qy5MYbb2TPPfec+BXKFucJIZAx0JMYSuepF6G6ac3CpNbbJ0MYPJs1p5AXJdQq0FOxY85jKp2nKMFbTz3zDDeawVOn85sMxImhJzEKX0Rkiymcbwc0rQbgJPKkiWHH3phG4XA+zHjq5la70cTWEKdmRLCmn7ciIiIi0omOw6cvfOELQKh8uvjii0e02FUqFXbddVcuvvjiiV+hbHHGEFriyvDGqiihKMKbpzWzodbMJ5rnJaFCqlaFmdMssbVjViV5D0MNRyOHNLY476iZ5oyolRte47QKpJFR64eIbDGF8wxlnsK1WoDDz7CsCAF7rctnO3VKgZOIiIiIjFfH4dOSJUsAePWrX80PfvADZs2aNWmLku5SiSzT05JVjdBW1xo87vzqtjtYXQXlCS+shDC3aXoFrLEk0dhvWpz3DOce4yGxhjyyWMCazvruUgu1VK0fIrLlZLlvDt9e/XMoMqEFOStCRVSc6meUiIiIiGx7xj3z6de//vVkrEO6WBwZZvYY8jJUPeEhNpCbkeFTi2+eLOGNV5bDjJ71D6T1PpyMJeyk5xyF63zr7t4aCp5EZIspXWi1G6uwKbZhNl3pvCqHRERERGSbM+76/ze96U18+tOfXuf6z3zmM7z5zW+ekEVJd4msYda0iJk1Q60SwqayOXC81WZnCQO/I0L7naXZeucgTTqrSkoigys8ywdL+gfhqUFY3kHLHcBTq0LLi7TmZ4WdqERk8/C+GbqP8WOu1aY81tw7kc3toosuYtddd6VarXLwwQdz2223dXS/K664AmMMRx999OQuUERERLYq4w6fbrzxRg4//PB1rj/ssMO48cYbJ2RRMjk2JZSopZaeBPIizHsaaECjXN1q15oA5psfJ80rrIG+nmiDwVMcGSLrWZXDUANyH55nOOtsfUMNmrNWtt13doXzDGaOVXXPqsyzqh4ub8tfE5HNxZgQvI/1v5tr7g63re/GKd3hyiuvZOHChZx77rnceeed7LfffhxyyCE8/vjj673fn//8Zz70oQ/x8pe/fDOtVERERLYW4w6fBgYGqFQq61yfJAn9/f0TsiiZWBMRSmSFY1UW3j3VUqjY0EbSeh+V0xwwTgigsmYqZSJoFBue2xRZQ+7CLnfhMqSVzt+oJREULsxc2Ra1Bh1nzUHwSXPYcVZsXaGcqrqkW0XWtH8OjaZwrHfu3VSi/w+nvvPPP593vetdnHTSSey1115cfPHF1Go1LrnkkjHvU5Ylxx13HJ/85Cd59rOfvRlXKyIiIluDcYdP++yzD1deeeU6119xxRXstddeE7IomTgTFUo8taoky2F6aqgm0JOCjUZ/AbXee3nCDnmDjQ0/T6MIO92ZKMxFKVxo7UuSzj7POB45U2Vbs+ag48gajAnnaWy2ilBOVV0yFaSJIW4OFy+dx/twnhWe2K5/7t1UoP8Ptw6NRoM77riDBQsWtK+z1rJgwQJuueWWMe/3f/7P/2H27NmcfPLJHT1PlmX09/ePOImIiMi2a9wDx88++2z+4R/+gYceeojXvOY1AFx77bX813/9F9/97ncnfIGyaSZi96XhRsmqusd7GGisHqob2ZHDxqM1Pk4iKMsw36QsQ9BVS8ceCp6XnqEGxD7skFd68A4qFWBow59nTxxCtdJvezNVtvZBx51sX69h89INYmuopeHnbl6Gn0cGSONWMDV1X6f6/3Dr8eSTT1KWJXPmzBlx/Zw5c7jvvvtGvc//+3//j69//essXry44+dZtGgRn/zkJzdlqSIiIrIVGXfl05FHHsmPfvQjHnzwQd773vfywQ9+kL/85S/86le/0vDJLjOeUGK9j+NhOA9vMvI83Ccrwvna97TNU2u+ibVQSTZcfeOcp1GGNrs4agZkUWdtdwbwZtudqdLpoOOinJqtMmsHqGVz+VtLVZdsXWJrmJZaequG3tTQWw2Xp3ows7VXV8rYVq1axdvf/na++tWvssMOO3R8v7POOouVK1e2T48++ugkrlJERES63bgrnwCOOOIIjjjiiIlei0ww78O/Vic2BDN2rVSm40ohH9r26iVYD1kjfOyKtQ4jzH2KAdMMRCITnmdD1TeRNRhCqGVsCJAsYwcqazLNJw9vjLaOmSrjseag42iUTz0vPfXc45zBNud0JZGfEpUYrQDV4BlqhDe/3jdDSuubryszZau6ZOu1Nb0et/bqym3NDjvsQBRFLFu2bMT1y5YtY+7cuesc/9BDD/HnP/+ZI488sn2dc6HuOY5j7r//fnbfffd17pemKWmaTvDqRUREZKoad+WTTA2F8ww1HEONMJtjIPOsqpdkpWtXvnRaKZREFudgoA6NIrTaGUa23EF4MUWEwKiShNY723yFbWib8fAv6KurrAazcKoPb/hzdYTd7raGmSobY32Djkvn6c88zkMSmSk3iLwVoNYLT6MIr7HYhvNGAfUifA5bqtVSg5c3jb5+U0On1ZXbWsvzVFWpVDjwwAO59tpr29c557j22muZP3/+Osfvueee3H333SxevLh9Ouqoo3j1q1/N4sWLmTdv3uZcvoiIiExRHVU+bbfddjzwwAPssMMOzJo1C7OetGL58uUTtjjZOKtncxgqUZjrVJae4QKiuqcnNaTNEplaxWzwX6pLF8ILX0LDhKqm2EK51t0MzTcnphlCWajEYIzZYNBlTNjdLqrDUAa5B1wIojoRR83n6uzwdT6/VjXNVP1X+zQxIwYbt+axrKo7rIfemiVqfvHHO/NrSzIG8sJTlFCtmBHXVyzUG6F0b3O3WhbOt+f6eKZWNVk32NDXr1G4ZrUmVMYqt5HNZkPVldtqy/NUtnDhQk444QQOOuggXvSiF3HBBRcwODjISSedBMDxxx/PM57xDBYtWkS1WuUFL3jBiPvPnDkTYJ3rRURERMbSUfj0hS98gd7eXgAuuOCCyVyPTIA1Z3MYDANZePOexuFNX5578sJSiaF3tHcSayl9eGdRSwkVUI3mv3KXkAJZ6ziaA3Y92AIq0erd9TbUEmeNwbrQuhFZwIGPYDyFTMM51HPfcQiwNQUIow06ds5jLdRS0w6eRt5nYltlJi3Eawaa475tkmjw8qZZ39dvuFGSO09emvZrqSdx9PZYqgqhtphQXRnar6NRvg3basvzVHbMMcfwxBNPcM4557B06VL2339/rr766vYQ8kceeQRr9f+ciIiITBzjvQrlx6O/v5++vj5WrlzJjBkztvRy1lG6sP21bQYAQw1HveHxBkoXhk57oK9qsJGhloRhuOvTP1yw+NGSeiO8yWgUzbDGw9N1KEa5TwLEBnbohf13iahVLLV07FCnUTju+VvOUwPNz8MDHobq8GQ26l1GeMWz4RmzElxz9lPcDF3Ger6x3gB3ct9u1wqBSucZykMAOFq1ovee3EFvaog7CCHHMnqINzG7exWl5+lhR1l4SgyxCYGE91B4iPBEsWFWjx31c5iMQGwwc2TFyB0kW7LCk8Zs8P+pbdlYX79G4Vi6qsR46KtarA1hd70MVY3bT1cAtabJrthc+/Gn6s/Mbv+dvS3R90JERGRqmKzf2R1VPvX393f8gPqDYstaczZH6cIbhUpssNbgnMcl4c1CTyW8ieuk8iWODNZAPSf00xnwzcHPowVPADmhdW4wg7woqUxb/25PRemp52HYuAXKErBQjvUEa2kUIWBZu6XMJIz6Bm3N6rDS+TW2RDcbbEfr9ja91pqMAZP7SW2VmcgqoNG+rsZAYg1xBYqS1QPHCZV1cRSq+9b+HCarqk2DlzfN+r5+q+oOX0I1tURR2E3NWpgew0DmWDXsqPYqfJrsis31PX4tNSOqK8PPzIkJmkVERERk69ZR+DRz5sz1znlaU1mWm7Qg2TRrzuZoDYA1raHf1kAzJGgd18lud7ENLTAYSG0InBo+hAEbkuWh4qqRt3YnG7sSqSjAleBMCKBcJzvxte8/8rLB0z/sqecheFvzDZSBETuoZcXq0CONzZg7qE21Nr3N0SqzZojXft5xzpTa0Nc1fA6GWsXg/OrvlTUhKKys9TlMZltcJ4OXO9pBchs11tevUTjqBVSTNX5urXFMNQpttY3CbdMzoCa75XPDjx8qZYcbJWUz1O6pRO37d3swLyIiIiJbTkfh069//ev2x3/+858588wzOfHEE9u7otxyyy184xvfYNGiRZOzSunYmoFDK2Ra841c4UPFiDUhXOmk8qUow+yg2IQWmLIIb0jWNwy8ObaJrDnHqXCsN4gwJlRLlX6N4Inmbnmj7OK2tmqy+uOyuTtaVobrEzvyDVSlOfuqnjuynHawhg9rTBOoJhbvN0+gMZnGGkTe+jw2ZXfAiagC6uTrOtbnkJV+1M9hIgKxsWjw8sZphRLO+1G/fo6RP6fW/vpZC775c2dbNpmv7U4ef9VwSdHcCGL1TK6CWmrAm3EH8wqrRERERLYdHf0T8itf+cr26Zvf/Cbnn38+ixYt4qijjuKoo45i0aJFfO5zn+PSSy+dtIV+4hOfwBgz4rTnnnu2b6/X65x66qlsv/32TJ8+nTe96U0sW7ZsxGM88sgjHHHEEdRqNWbPns0///M/UxQd9nVNIeEP/hAwGDx56XHO0yg9sVn9Zr1wYTbPhv7oL1yYE+VteMNhm29G1vfiaeVFBTBQb62DMbdUj4whIlRJRc1d8qoxVNPOPufqGjFqVoQqqjQOs4yMCTv6pbFpzqzy1BuOgbrHG0McG5IonHtjGKiH29d8A7zmm7LIrvuYWd6d74oN4WsZ29B+l7vwBj6NN31Gy0Rsv97J1zUMUzekMRv8HMYTiG2MEO6uW2nX0un/U+NROk9R+o1e85ZUOM9g5lhV96zKPEMNyEtHVo78XCwhgGg0//9fu9LWuVa122ZcfJeZ7Nf2hh7fOceyVY7+zJOY8DM3MbBy2PPXp0tWZQ5rVm8ykRU0g+V119N6XawYcjw9FM4HMzfqsSIiIiKydeio8mlNt9xyCxdffPE61x900EG8853vnJBFjWXvvffmV7/6VftyHK9e/hlnnMFVV13Fd7/7Xfr6+jjttNP4h3/4B2666SYgtAMeccQRzJ07l5tvvpnHHnuM448/niRJOO+88yZ13ZvbmjufeW9oNCuBqnFzu/r1VI2M9XiNIsx56knCfCXnQyUUHbxXyB3UC08SMaKaaG2JDW/cWw/ZCjc60nzY1pwrTKuSZuTztd6g1QuH84bKGuUXrTlCjRxy50dUa0y1OT/rtrIZrPFUmkHbRKxzU6uAxvNmOraGODUbrJTYHG1xk1lNtqap1ua5trGq2sDQKDzgSJvz5CJriIwfc5B7vYTpKV3Zcrcp1TvjuW+nr+2i3Lj1bOjxBxuOvIRZPeF70KpMrUSwsu5pFJ7eZtXV+mbveaB/2DHcaP5P2Pw9Us89PRXDjJ71zwcUERERkalp3OHTvHnz+OpXv8pnPvOZEdd/7WtfY968eRO2sNHEcczcuXPXuX7lypV8/etf5/LLL+c1r3kNAJdeeinPf/7z+e1vf8uLX/xifvnLX/KHP/yBX/3qV8yZM4f999+fT33qU3zkIx/hE5/4BJVKZVLXvrm13qxXE8+0MrwxcN60A4HxDIl13uNcqD4ofaik8YCvwKoOdqKblkBRAN6P3Y5kIE2gJIRVRdF8I9VhYVpWhN3bWm/Yq/HoIYA1zUoub6jGkDerwVpvgAoPiQ3Dz1cMOZLY4ppBw7S0deC6j9lNc37W18pWOM+0dGIqc9aeKbX2PKYNzZTamKBoQ+veHG1xa4a79eZAd2ugmpgJHfo8Fds81zRWC1et0ixx8uFnUmtw9XbTLP1ZmMNWjfw6u9319nRX8LQp4WDrvvXct++7odfP2q/ttf9/y8vm69GFQe3jDSvX9/hF6RnOmz8bm8G99+FnbqP0pFGYr5eXjmSNAXOjzd6r5yXDeQgS1969crDuiayjrycac50iIiIiMjWNO3z6whe+wJve9CZ+/vOfc/DBBwNw22238cc//pHvf//7E77ANf3xj39k5513plqtMn/+fBYtWsQuu+zCHXfcQZ7nLFiwoH3snnvuyS677MItt9zCi1/8Ym655Rb22Wcf5syZ0z7mkEMO4ZRTTuGee+7hgAMOGPU5sywjy1YnLOPZ+a8bRDZUuVSTTfgXemPCwGoTqp/yZlDTyWh5SziuxBOv5x1/ZMIaszIEGWUU3pC4Eugg4CqKEFp5H0KsNDFEozxfK3yIraGShDa/co0d1KzxlAbKMuycl9iwa19ewlDdM63Hr/O4nQQam3O2ydpv+ltVOoWDwSx8PKM6MTtUpYkhK0LbDNAO8QB6KoY0GTswmIygaHMMWV9T6UL4FAr6Ju77OtmzfcYyUa/TDVW1pbHBeUOtEoKT8HwxPWnY1W44DzOejAkVT709lmoXVT1tSjhYOM+qYcdQY3Xw5AmVP7WKoXeMyp/Wa3soD0lN4VaHXgbHcOGp2FDZuDFh5foe37lQqZTGUJShrRsbdiVtFKFi1Rg/YibXaLP38tKzYthjPO3vPYTvcwWouxA+Tk+7p4pURERERCbGuP+aP/zww3nggQc48sgjWb58OcuXL+fII4/kgQce4PDDD5+MNQJw8MEHc9lll3H11VfzH//xHyxZsoSXv/zlrFq1iqVLl1KpVJg5c+aI+8yZM4elS5cCsHTp0hHBU+v21m1jWbRoEX19fe3TZFd3TabIhhlI424NKV2zsiO8yTIeGCMwWFvFNAeOl779L9yjiaMQBkU2nPIitL8ND3W2xtxBb2qYWbPMqNox2/sKFyoMqhWDc4aexIZ2xCjMMImMoSgN01JDJbEYY6jEllrFUC9Hn+002pyf1pyerHAjZt6sqvtJnW2y9pv+svlmrlGE/9mrcagmGc79mPNYxqv1Wfvmf/xa149lsuYntWaeZUWrddKPaJPb1La4wnn6h0Pg1tpyPi9DpVz/8KZ/byd7ts9o1p7NtKmv007ngVkz8mdSNbbs2Buz43TD9tMNO0437Ngbd1XwBJs2A24oC3OTwJA0w6LEhgipP/MMZWPvsBBFYWbdQObBeSLC+dNDjiz39KSbNpNurMcfykKg6wwkscE0n8NaQyUObdlF6Ud8v9ecvWeaVYyl882ZjeH2tSWW9mOJiIiIyNZl3JVPEFrvNvecpMMOO6z98b777svBBx/Ms571LL7zne/Q09Mzac971llnsXDhwvbl/v7+KR1AbYw0iajEjnoe2l+yovkv4h2+h///2fvzINuy+64X/Ky19nCGHG7WrSpVSbKqSrJKM5Kx+6Hi2eaBG9thAuLZDtoYA34dDoPdAhQYmVY38NxtO8B2mw6IFlgmaGyGF9iATLwOBwQGY8CDzGRUliVZY6lKUqnqVt2b0xn2sIb+47fW2ftknsybeQe5hv2NkOrezJN7r732Wjvv77u/3+9vWiBh3uH8n8m1ElXAAhatnGP/Ap3uACorBJaMt1P7aBVWygIfhJSYlJqAZ3/mOXKOEDOifHxTn2kY53otL6rMFI0TIic3nkyrUzk/Qhp0Fsc2WmsUYjXKjbqj1qlNKpUQhEjIYpdAIWCgyLrv+wCF6QV6n6GguYgKpm4DASH9nO+UHEarCyl07kZ+Ut8Wl8ghxeWspudhXnvmVUAbdVdsQ7ebW3VZ9dLdsPjdqqqts7IpAtKwwAf/gsq5up0uj84H5nVAByh6a1spKDT4Rr4/PUP545zs3SKSti6AJ1BmYrVzDjix9C6TSbfp+EqL8mzeONoW6DWB0FphtMzHqOjWW8recyEQbAA0IcjzsW484yIpTsOpcPk7KCAcMGDAgAEDBgwY8ALCLZFPv/zLv8xP/uRP8pnPfIZ/9s/+Ga961av4R//oH/HII4/w1V/91Xd6jBtx5coVHn30UT71qU/xB//gH6RpGg4ODtbUT88+++wqI+qBBx7gP//n/7x2jNQNb1OOVEJZlpTlBVuuvUQRghADPkDVyttptBSnN/9hCTk3QZ2bHh4CVE3gYAGLOgYTX+Lld38sYqkL1EvPbK0leGBSiqWlzBXKQFsH6a5FDBa3UIzWC0OQomqrUMybgO1lvJSZqAVSfsu8DQQPoyzEzBRRCCQbmNggb886dVbWjDHQtEKQSWEvRNh4FWrV2QuVOrsovWiWzcki/GRhe5Gi924RRRcNKL8o+uHzi0YGuRZWfwdtQ7dP3Fwug+huWPxuxf54WRLsS2ll7eN2yEHrAo2H8gxuMjdQe/ncJuKqdZ3aKpG9zouCTCNz50NYI84vmkl31vGFvFfsjESxNasd46hmCkHGmu6ldSGqGUXBFUKgzLV0M9RAEFJx0cJEpedjN4bWSYB5dhFZ7YABAwYMGDBgwIAXFS7tZfjABz7AN3zDNzAej/mN3/iNVR7S4eHhl1QNNZvN+PSnP82DDz7IV37lV5LnOb/4i7+4+v7HP/5xnnrqKR577DEAHnvsMT784Q9z7dq11Wf+zb/5N+zs7PDmN7/5SzbuFyNyo8k05BmMM6g8zGuYXSCLyQHXjwNKB/KoftoEHwLXjqUoyWLXuyy7+Evw7V5evPWBpgWjNdulYnes2C4VRmuaVr7vHEwKzdUtw7jQFJlmXGj2pppRoUVBcAJKKSaFZiceb3skJFbTSoHcOlE0jDJF7WDeCDFVZIrWBuaNX1mlNlmnklXvPDtVKtBry1pb80UTuD7z1E4KW6VkczdOOg36eEwbui6AyfrUvydnHX9T2/STRbiP9jYfD7jp+JuQacW01GyPunmdlnem49WtWk0TTtrRDhaeo8qj9eaLuhO2oVuxI17mvvVxNy1+fftj6zzWeVrnz7Q/XtTKdhmL4EX21EXQP06fHNyEm2aV3WwoZ3z/5H4zWkjFTHcEzqb9dtHstLOOb2JQ+Cg++ya52JxrJ//dKhWv2NVsFRofuuw9rQNZphjlekVUZUaxM9LYFqpGyKkQ5PnU2IBXMC3vTDfOAQMGDBgwYMCAAS8sXFr59MM//MO8//3v50/9qT/Fz/zMz6y+/j/+j/8jP/zDP3xHB9fHe97zHv7wH/7DPPTQQzz99NP8wA/8AMYYvv3bv53d3V2+67u+i+/7vu/jnnvuYWdnhz/35/4cjz32GO985zsB+Pqv/3re/OY38yf/5J/kx37sx3jmmWf4K3/lr/Cud73rZa9suhla50FJweuc2ENCDsrfnIBqidaQmxRAi9pxUAEO8rIr7AoulDfOKO/+vK7kOFHgWnkj74OiNCmMvVNQVG2gajYrCJJao9/uXYpeKdJrhDTQWlEghFDdeKyB2nlcIwTVONcURtQEySZ3UcXKWSoVkFynwsC41FAH6tjJr3WBZSud+zLVFf2b7sllVDCpCG9X+VahpwhTZAYU6qZF791EY/2qG11xydygvhJHkTLLJMemVoFstL4+VrgD19u3I3bnljVzM+Im4SLqpdu1+J2HiygQEy5KgtXWU7fcVB11qyqwk2qqfle6tI5GuUKpgPXqwqqu9eMGKgdjFdAnxtJ6sTZvUv6cpYgTkihQNZGwP6WIu1jI/nmKO6OFrDZKc89Ur4L2dZynqg2MS5iWemXtbZymjs8e1wsvR0FZSvOKxgdM6L63Uyom5Qsr32vAgAEDBgwYMGDAncGlyaePf/zjfO3Xfu2pr+/u7nJwcHAnxrQRn//85/n2b/92rl+/zn333cdXf/VX8+u//uvcd999gHTh01rzrd/6rdR1zTd8wzfwd/7O31n9vDGGn//5n+d7v/d7eeyxx5hOp3znd34nP/iDP3jXxvxSQcrkSNaJRdsVfRfBdgnOK3w424q0aDyNYxVMa2IhNM4uZu/bjbFfFy1iA4FRLNR1qrqQIs3Gon+UCeF2VgZR/1xJcaDieYX2ChzVgUw5UHIM3ULjPEUG01zjAtTNzYvp864t5auMolom94E8Z2XJaVtRQI3zwLjUq259J4vSy2bZiDrFczDzOFhlZxGE8DDA3pbG6POLydtpWX8WKtvrmrYiPfyqa9pF86xSKLL1KS9LoZVn3kKWBcYnSKA7ZRvqEzfLO0TcbLI/3o2Ogwl9BeK06GRcSokCMdNhdR0XJcGqNuC8OpdkI+fSGVZ9kqlbg6IabNPzJ67tqg0UWTrn+jlOPif6a9v6QBvJ72ULy7h+RrlCobDRajwpNit/zrMylpli0YqCKARFIGzMpDtvzd/MKikqtLTWhICrGsnJU1FNWbWyb3UknW3smlfGRhLei60w11CW8QWAicqqXL2gsr0GDBgwYMCAAQMG3Flcmnx64IEH+NSnPsXDDz+89vVf+ZVf4bWvfe2dGtcp9FVWmzAajfjbf/tv87f/9t8+8zMPPfQQ//Jf/ss7PbQXNO5ELkoIsZ28h2UruU8Ai+ZiP3+9hofGAaX0ufk/wUtWbq67Yv9CuVJ0CqyLdtmKTZw2vuEfZSIzSRYSUfKcziDqn8uHLnhaKVE/hRCY17A9UhglKiQTX/3PFp58y2OdWSlWfDynUvL3k4qVs66ts9qEVXEu7eulWNRK7HZFptB0ZNVJMu1WVDDeB5YuoIKizLo5qC00KrAbGcqz1uHdCLuurOf6zNNYMMpj4jFntWbZOqYjj0HfNM+qagONCxCD6pWGEIQYqBqxehU63WtZs3fKNtQnbnZG66H5t0rcbFIv3Uo200VRt6K+I/SaFABlFoRgbjmlojuPBPM+4BFSaBM6ks1jI0HlfOjliG0Owbc+cLz0LJp+xhFcnznpojk2lLqXcRQkn246kqDvPmHVJ1BOKueq1rOshbzxXo5R20DZimLIKMU0Wk7PwnkB/TulhI77sJ6dljLpLkLunnf8MlMUucI56Za5bOR5VWYwzrtsO+cDZd7Z7IpM4Xrh5ZMMfNCUmWJnHLvmqcsrEwcMGDBgwIABAwa8uHBp8um7v/u7efe7383f//t/H6UUTz/9NB/84Ad5z3vew1/9q3/1boxxwC1g05v8W32zrJUUHIeVKGl8zEO6YCM6cDfP/5mUmsJ4KgvKdoHj7QVPsYxZTieL2JMd2HwQMkMrKQo3FdwBKYqS6umswmjtXNH60tjYtcoH6qjksjZQBcSG5iDgUfGzVRvQOlr0NtjWWqdWhN1ZBbp8LVDVAa8Ukwy0lrlunMKFQKZuTqZdVgUjBA2MM2m53tiA9zJfk1LhPczrgNEOH4OGTxa+dyPs+njpmTUeFWBuZZ1qINOOpZM5uX9Ln0t0hajeCn6doFMKdsYG5y2tjdbGu2Ab6s+Lj8SRVpCr0wTKyfsmQfeRBFXqpuqlu9Fx0PnAshXbaZ94CvHaygwUmlHeqejOIsHS2IwWAvs8kq2JZJfRYbWn0h4uMxUJKrVGgi9qHxWKilzHPetkbTcetoqAjvv/ZLB8FrO/NnXy7N/D48qzqEEbzTSHrJW8I5TkwYUQuDI1N30+nx/QL4q4PtEbuJwK7EINADJw3hFytcrnSkj7ljbeByTzyfeew1or5pWjajwLY9Cx4UPrXlhdDQcMGDBgwIABAwbcWVyafHrve9+L956v+7qvY7FY8LVf+7WUZcl73vMe/tyf+3N3Y4wDLomz3uRXbWBSKLbHlw9zXrZit/MerBOFx0WJIedFkaB1OFWgpUKpyDS7Y091KOdK4oYLCp9kfHVgUgpptGiEvUoKKunuJoXipFCUuY4BzacLbhV/rmrpEXenC6OTBXNSWjQ24IMXhUpUHaUuc84FjFHkSDB1bTzBQ+VO29ZGBopCE4LaeL7+OESBBLtjhTE6kl+i+pjXsFWKYqTIID8jgPuyKpjUuaswco2wHndkVOC4EbJpXKhThW+Z37pd7Cw01nO49DSRiCuMPOQCcFwLcVprCcDOjT5TZeaDrIFNvIvRiu1Ss7CBwkCe3VnbULLRKSUEh+3l5WQ6nCIl031btCLLOfl5FEzys9VYd6PjYAiwbDzzJpBrLR0y49q2HmaNJ+C5Mu5u/kkSLIRIYNlEAIMPclOKDexoItlsSHawuB7jZFTRSjvKuz3lfGBeS6OAfofLgDw0ciVjGBdhZT8G0ASOqkCuA+PiNJHZX9uJiNOq65A4yjQeyaqr2oBRsn4uss5v1smx/+eUSXdRFdhFji95T+pMRVzat1rL86/pPWPTurAhoGKOVK5vX+04YMCAAQMGDBgw4IWPS5FPzjl+9Vd/lXe96118//d/P5/61KeYzWa8+c1vZmtr626NcUAP5xUE6eub3uQnW9BRHTDaszM+w7uyAVXrOK6FdFK6U9VcFEZLgdUnGU7m/HgvhViegQ4Xz5NKqJ3kRoFYQxonyqKR6bJGZq0UsNtGnVlwZ1qK36bhQsTdyYJ5nIslZVEF2iCF1SiyH0qreI5Y2K2sXYrMaIwJqABBgwuK48azpTxqsrlA10rsWDZlPuUy4Nq6aL8T5cs0F7VBsjBm59z6y6pgvAssQkChyLVaTVgbVV0+iN0vrdW+qim0gYC65bDrTXvBByEhXYBp0c2bD0LaLFzgaAFbZSDPwpmEjlaiknHhjIekVmyVinumeqVKu1MdukKQEHdnAw5Fpro93LhIYGasCBQQa1WzPGfNj84f280Ih4si/XzrPMtG1nPeU7URyQZbE21baZetk2BVG5i3ojwbZTAqJBfpuPLMloHdaVhllyWkLoDLJjCLpFemEdlbIr1qD6HbU4lALTftiSDHa7zssbxHeLWR2C0yufcn7bL9tZ2eRUV/IcX7qVGSa+dlLJvm/CIk01n3onVCpq9IzB4Rv0kF1seZ9uhwMWuzieSv9dFG7ZM6TCyjZa7JTOxq2Hsu3IraccCAAQMGDBgwYMALH5cin4wxfP3Xfz0f+9jHuHLlCm9+85vv1rgGnMBZocwmdqDrSJzAUeVQSlHkXfGtVLSDNfKmf1peXE1iAyxqOX5pwCkw0cJ1EeudMZGwIpFgp3N+Kicqra2RfG5eXY7gWrRwsPRUrWKUS+G0VUqLdoeQZluZTJxzQLa54J7XgUXLhYm7kyRWQAKEMy2ZKNaB1hqjOyKrdRICXuTxz06IJNuzb2kVaF0v7Lh3vpMdxHxsV75dSqG7v/S0Vor+MgsUhUKjKXot688q7i6jgsmMBBs3Ttqtr6DAEFhaIeMyo07ZH5M6AkShdNGwaymok7rstJXPOk+7gUwIQYgyPCw9BO/JlD6T0FFKiIU25j71CSAbYjZZpsjOUJHdDpLtSwhFtfb1AiH1gltXETonqppU7Kd8na2s+/5Fnva3ei0nn0+tFQKpPOOcWol68uQe7/akYxxkL/U7Cm6PNPtLCZPfHumN5GgzE9JzE+lV19Ga18eG54yoyeIaPTElyW5aaFmH8+a0Xdb21nY6v+qfp7e2Q9g8htsN4k/P2tYFvO/nlonq0upAbtZJzItAKfk90wYhsk92fFy3NismRbf/vQ+AxrpEbp9UXV1e7ThgwIABAwYMGDDgxYFL2+7e+ta38pnPfIZHHnnkboxnwAacFcq8aKQwLjLpGqQVLF1gUUtXLB9Ot4LPzflv2TdhtvBSzIaY+XRGsXQWciW2H4+Eare2C7BNCMi1KcR+oY2c66IwSgiBxnp80IwzKMeKEb0QcKVWaoB+cdPv9rbJgnMz4m4TiRVCxv6i4bjiVPHqEaIpCyLKIIhaqjSRaAmwtPI9G9bvVT+IersMkaiAowqOaykmC6OY5KCUIiAESp6LOukixd1lVDC5UVgrBW6mWDFsjZMW6gZRpPmg1lQXhRE1Vj9762RWUd/m188w6xQxYaWISZYd3SMNirwbp1Iyl9L1D/LcoJQ6k9AxWjHO1SqcfqUaQWyGKPn+7aiDzlUX9faY9X6VW5StWNz147WOVf7OSaJv05q/nbGd/Mym55OLZF1rwRgvCpc4bBsVMHkcm43z3t+HydZ18vlltGKnlJDv1sn9Tuq1IlrLQDHSp9ekDTDSAGq1pyQQW9aLMevnGeWKRRMo8iDiqbg+GxtoQqAEZk040y6biMBMC5GdSNEQLbGy3zWtD9FSKKHkWsneuN0gfpl/IcBHxennWdWE2FhBPnMRtVvah8vGU3sojeQ+lbnCqE41WWaS49e3NhslLwLqVuyPm7LEbqZ2HDBgwIABAwYMGPDixaXJpx/+4R/mPe95Dz/0Qz/EV37lVzKdTte+v7Ozc8cGN0BwVigzRDuHYY1IybJYrNv1VvDOByns3OXOPx6pVQ5ScEmxcvHA8UkBKLEPiSVnc85PbcU+Fzyr4OpUsN4MKr5tr5y09U5FzqTQa+TPpuImFdON9WdbcLg5cdf/WmMlU2hSerwPkbSLna5i4e6cKBDKAkqlZFyxMB9n4GL3u7U5WlsLajWuRWOZV6LuMJFU0UqCwBeNhDVDl2V0WbXDJoQA40KjtKdqw6pVfPwuZSEWwiZav/qqi8ZJAToZKeZ14GARV1Pvho9jNlef3GidkIN5pmLXMRiXnd1J+cC0UMwaKZDLqHbzkbTTWuyJp27fBkJVLIjJzrXece5WgrgvqmQJ8foa77h27LCe1Q9k2rE1UuSZWa3hkzaok2vzIgX9RcbWJwATGTbK5VnjYne5hCLTTMsQiUdR3iTCqtCSR61UYFYHVONXxypzBTexdeVGmK1JLp9LKrhlK2RL6wLjQj7reqRhbiDLFG3frqhFmXO0OK1wM0ZF5Z4QVyqqMyGQRyLFoMgy1oi1ZJfdGRnqVr42yuCw8tRLH61w4ItkSfMUGTznDCFEAjR4ilyz3XsY3ZI1rXtMRGKuu24XAtYGjiu1Cv0+T1nVzxJ0AZwNHLeBpRaSODOK1slLEKUUpg0UOZj4OyOtwTJnRVadxM3C8QcMGDBgwIABAwa8eHFp8umbvumbAPgjf+SPrAWwyj+aFc5dktkYcC6SaiGRNUkdkkiEUXy7XrVitQshyFt2mwovKRSbGEQsXaPif0049+15ImW8k7DcBqRz3SWvYd7A3qSzwWwqLDOtWDawaOQDsWnVhQVWNkDjxb5mtMbQzQtKoZGCuF/cbLYKebJScQb/dOEBaaViHoxGKcWy8VSR/JjkasUEzGuwLWxN1Ro5oLViWUtmTr+73CbiLil+CuU5WMpBMiUZU3gpZpeAnwsJltQ7k/J0d6y+yuhmJImomBTTXFMaIZS8l2ssjOZ4aVm0inKiVs+KRD7M6kBh5F5FfREuBGE0VSTQ4nkS4ZZpqBFlk9aKAjlnHfO4Mi0t3KdlWHWIW8ZuZwQhQSWnR7J2kpLFeshiEHv/HqxnENEjXC4fxH2WenGTkkWpGFIdbZuGSNzFsP9lExhlnUrrdrvd9cemVUgRSdRWrcYGcLSUHCc5qXxoXnsCsDNOieKCROo0ThGCosgkoynZFus2kGXJ1iabvWolmH5aqpvaulQcQ9OCjZYyrVi1aaxq2J1GtVWcC6UUVeMlhL7n85yWGufl2mxa8HEu79sxYldd2wuK2npaqyj6iiJkXzWNPEsUMefJBiFmPCyqqPrKpEnC3Es6/M5EMTKi+Gxt4KCC0vmoal3f8Be1poUg1+md56hya+RT+oCWZPeN9/zk+u5nCY4yRWE62+FhFZgWgXsmZk2NmHnpfDnK030Q1Vp9wk6ccLKpwYABAwYMGDBgwICXDi5NPv3SL/3S3RjHgDOQVA2B9c5XPhIEmfFS0KBWNiLnxSYXrLQCb50oiYKSQnarULENuWNaKibFOtVyknzQ2uAkxATD5UghgMqCV4FxCpiNyol+zk9tPZWFZQ0oYiv2i8M5IdSKTOGcp3KB1ncFj1IwyaWY2x7ptRbkqeA2UZkzWwauTE9bFlsvxWS2KaDoBFJmkArglRAmSglhEVDoEFAGlPLMa+n+tZV3wVCtDSgN417mzVlBvyF+T2sJayeqy4IX8iLZHIs8xK5sEHBMG884dtNLhbVW0h0LFN77lQrEB32qKO264wnRUPbsXgDHSjMp5D5kKqxlJo3ifCxqjw0yV7WVNarivahdgKVDKQmODrDKisELAZUpuTaxmAq5tD3SNM6zqIWIVcjXmwBbBexOpNNYUpkVMf8rrZPz7umt4iz14iYli9GKuvW0TrE3Nafa1B8uHXXrAbOyrOWGW+52V7diAyOIsq//sy6AaeWZMK8C2qwHoLsAi8pTGE8xXidJJoWo1ua1KKNUfMxUjcMrGBUmznu3Lo4WXoiJoKhdVNTosKaUSQSFdaftu0Wm2B0Hrs89x7Vnu9Cr47cu4BVMy/W5yLRiZ6wps9OqrkQyip2369iWGY3WgTZayvqd/LJMOu0dLDx5plEoWucoDUy2hAxMczyvA3WAQiuyyCpnWWCcBxrnmVWecro+rxe1piklLwraINfVV9C5aHWdqsDSKrQ/fc/7yqpNlmSN5FsFhNjKtWJS6tXzqr+2p2W/aQKXamowYMCAAQMGDBgw4KWBS5FPIQRe+cpX0jQNb3jDG8iyS3NXAy6JpIKoWgmvTYWfBZatZzEDZWB3JP+Q9x5sULQ2gPEsW7EJ5TEbReeiEGoaUUMVGexNAttjzSjTG1UQxwu3KmQ00F7yGlorRdaViShdhLCQ4iTB+8Aydpg7K6T4PBgt/ytjtspzxzLO7VKIDx9gVgW2RrA9VtQtGwpuxSiT7KRZ5dkq9VphLOqZi+X89DODnJPgXa0TAQUoRaEh0waCk3viPRphX4KCUaaYxOIZTitcEhRCDoSg2C41WnkOl6JyMgoOmkhcKcnfCrmEpx/MA/dsB65Os1UBeFwFqsZjMmhsZ5UaZS52rdNrRenJ7nhmpeiR7mCTUsmaPJGZVGSK1knWlXeRoNOSCdbYwHEVUEEIuEkRmJaKxrJqWS/3W7KjAmpFzCmEHBznsgeaSKAaJdanIldsj8zK2qXivaptWLOvwroiKI+ZaifVSn1lzXkZSWdZTeG0kqWxHhcUYxOtYHrVsE0y3lRg3sD1mYvkBoQgdijvRZGSxjpr1bnd7pwPLNuAPfF8SUHsOgRmMbQapSh6Cy/lZS2UEF9bo3XC1mjFtNAYJZtHKSHRMyOKoXFvQpQC4wPHLtBUcHUqi93agFWyh8pCVFSZFkXUstk8p5NC0zhRjtXOi+Iq3uudUgiS0/dAcs5G+WkV4Lz2aypAHzwhyP50ISpMI5GpdcBZcF5C9HMtpNesBhUU25POLtlYIdqUknswLsIphWDVSufAvPewvKg1zWglJGwlRJ+K98C5wHETmC3lGS/rOFqPnRDjSyA3Hh0J2bO6AqZ8rmkhdkYbMwi7eT2t0rpMU4MBAwYMGDBgwIABLx1cuMx/4okn+CN/5I/w0Y9+FIBXv/rVfOADH+Crvuqr7trgBkgBEUKgOtFRLM8UwTvmDeyMRZkihYwUZlUsWovYZi3Tkts0b8E7CfPN86g2qOUt+9WtqCA6QcosrGT3KCc5J5fFNBfrzKIOTIvThIVWQgy1DnKEKKgdl5JXLVuY1VLsVK3M1yTvVBEGos0ncDB3lLnZWHBrrSm0o7aePNk/4jimI7X2Bv9mSJlBdUC6zhlAxcyr+H3jwOV6dd1KCcmRxj3qKVY6pdE6cQeRIEMClYWAAK8D145lLkeZBG0b1SknFg5GTeDeLTkvIWB94KgOqBZ2y06Vsmigsl02z0UKSRUJJZOpU1Yw5wMKIZqUksD8xnrmtZf1h5CWHrDWM29gWhhKI+Sijt9vXVidq3WdIgal2BmbmDnEak6XNqw6pfWJsk2Ki/PUSovGyxox+qadyE4q1k4Ggp9Ussh4FWXZa1OfCBECQbPK1sl1JA1rIWqMDsybjmwZZVL0n9XtLgVoeyQ8OiERS7UN1I3HeyXZbSdgtBC2s4ZTxANENYsBrcTyaqMicSs/fazGBgyswunLTJ5ZAbFqBRXYGfVzocLGXCijFbsjTaaD3K8Ydt5XMp2Fs8jHvh3ReYXznjaI5bSvTKstLL1YB4tcx9D/+F2dcvj06lzWe+nC52Tv5bF7YqaF7BHV4foYL2pNczFrTkW5qtEdse1sICiwkdAV5awQurXzLC0QDMZ0hJtzYbWIk4UvWXZT44STSGvbunVSL5F9fUVZcRY7O2DAgAEDBgwYMOAlgQuTT9///d+PtZZ//I//MaPRiB//8R/nz/yZP8N/+2//7W6O72UP50PMD5JCPdPyD/i6lQJBrA0wzuUtdQhCxCSSocxhkmu0VuzPHd51b/5DkI5k01yxaIWUyYxekTJqFX4rpJTj8nlPAFbJOZatvO0vMn2asIh1VAt4d3NLySnEQq1qA/sLWdjjItrWoppIKcWydhwtAxPvMFqfKrjHkexzPjDK1IoMukjhehKJmIHAslWSiZRImExRtaI4UBpMUGyViWwUNc8mQmQTcWdjAWhUYNE4lo1Y8ForeVulkbyjUa6iBU2ypEothF3desaFiVZEYRxHmayZpMSYGJhXjlntuWdqTl3n6ULSCJEU16hOsq2IVNAHFMpLOPj+wnFcy33Mjaw1r2DpwTVCpGjVBeeXuWYZw9Rbp1eKmOOqU/KMsnX1Wk6Iwe9dp7RNiovz1ErOiyLJOtgdh6jYOp3ftMpMC2J3bCPB0CeTMp32dGf50yqp3BTjQq9l9TQWyRrKpFNbIg0D0HgoUGwVHWkYlCI4UdaM8tMZQSk7bpPTyXlhPlob0LFLHLDKyko5SrlRmJj/Y3ToKcS6bpxJObZEuiPWKpD1lFIuzgvI2p43mjxenyKwVcq5EvEp5OVpFWCCUmIFnRSs1DuXzRHq2xEXtiOYykyRZ9C2gUZLSLmO6qBFK4RX3y5LnLqMLocvBNl3tYVlkP26bH0kI+X+NtHuSAir7L6zrGmbuhRaJ3bHnZI1hVYiP4X0EntulgmhVzWBpZV7eKW3tlsnhNvcBnLXEaIh7qWgpLlFUuomkrl1UbXr10PNjZHfKX1FWev8oHwaMGDAgAEDBgx4CePC5NOv/Mqv8M//+T/nq7/6qwF45zvfyatf/Wrm8/mpjncD7hxEjaPYKsQGY2MB4ZHifGdE9P4oIYwQ0sU7ye6QwkvsEJU9YWnr2TdGRkgrLbKRaOXqsoRcbEZ20Q53fcwrQAWCV6u3+ImwSEVTO06KLQi3qLCqrBRZWgt54YPkkqheMVMYOGrB2MB2VHKczNQptKJViu2RIjf6lgrXBMmTMThvOVhKe3mjWPnnHGLtmeQBo4UAUkrGuakQ26Q0Sh2klI0KJRf/3Eogs8rlXiabZYgWwiwWn4ncaK2ncpKBFKCrCntzV1spErNeX/pNAeWt8xgjgcNnZbsUmWZWO45ryZk6rmW8xghxlvKYjJa1+fl9z6SU9d966fw2ySAEUblMSgmGaqw/W8kTVCQHYkbWGYqLs/K1QK4neFEfpv3Vz29a1EIi9Oejah1LC4UWkqzf+W8RAntjMMLwUGSace6Z1bDVU7gkgsYiyqFkxQrIejDxWbEipfrjtWEjoaujDdT57peB82HVoKCJpEtGYG49uY8kBkm5JaTIdqEYF7K/k/oNhHia5L28n0wzKcUSl53oxmldYFHL/S+NkBUSCC/qodx0pPR5KkBZk/Ksu1U1TbIj1rUXBWgMwicp5ZD1452nVqxIRhCFZN/al2lFrkWRlyH7ZdkE6hZUfFkwziSDTuGZllruuVZs5wGtNa3fbE07rzkAyBeMUtJsIT7nvJd911hRg65IZgWoQNvCdCS5VmltTwrFrBLivswDpWF1f+aNdF0tjWfZ6qhVA4VnaQOFVmu21UXTkZJ91el5YecDBgwYMGDAgAEDXvy4MPl07do1Xv/616/+/uCDDzIej7l27RqPPPLIXRncgC7nJ73JT2+tqwZMJl3Nsky6jRHJJ60VLWLbMLoXUh4r6tSZ0EaFiVIKrQO+CTRBrC8YKUoVgL010ml1DUhhpc3Z7dPLXNp5pUzcywqfUuHlvcxJrqRI9gRMj0EJSCh3pqH1gbb1XTv2aDshSC5NbvTGcPFNKoObQUfbY91TUMh/pfvguNBslepCxz1J3CmlaI49VSOKiUnwWAejAMtMrDWhkMKvaYX4MCpm+ujuXEpLV0DnhAA4mfjuSaqcHmFwThe3zHOq1Xq/gBb+TUhRHzu5aZ1ycuQ4BZH8TKSalnurlBzPaznepNCrYOizlDxyEYGZDWRak2fqTMXFWflaiQBKX/OxQ19Seiik89c4h6JXcDc2EkRlIOtPrALtT6/37bGEps9qL13QtNjq5o0ce2vUywDyQjRL+LOQOJHHwmjp3Nj6RI6sT4xSouSprBBOBM+yjUSVkkDpItNY5zlcBIrcM8nUKnhbulMG7t/RkWTt1F6LRp/a7ykLTToIBgrt0Vq62y1bjwX2RhoTGaVV9lEj+7IvJtqkArxTwdUhwLLxomQymizr9qz1ydYsiqE6dkIkCEE76oWjp2ueFIqDpajImkZspEaDziTcOz33jipP8B5tDONCcXXLkOvNz4Wz9p40kwiMcpm7Nu5n3SMxtZZzZiGRP2FFuHU2VnnFkdZ2mSmMDpj4HEsTkiuoELJbSHTZz/uVNCzY3dGddVgBCPnmXCDP9JoKMAWh93PlBgwYMGDAgAEDBrw0cGHySSnFbDZjPB6vvqa15vj4mKOjo9XXdnZ27uwIX+Y46w1/nmlK7Vm0sJOzKtYSmvjmf6s0LJrA8cLJG2cDmfhbKHNFGZUB3oM2Cqxkskx7LcTb5vbIpzyT3KjdLKyUCCff2B8tugr8ssQTgG2iIkNBWcDSiWpEnyi2KysWtHGuOa4DPs7TqpiuJTT4Si45Rdathw+fpTI47019snCZqDBRyA+rlYojtpznYp30EvqKGOelTbuOGVXOiQJuVqXMFcRWE5VNxsgauWcSiT9ESVdGC2bmA4SYVxMtaxrIIvGQcLMubsalVvanCbs07iyTsfllR3oVeSJM5J60QdbR1EBRxPlXmrr2zI1HxcfOJiVP/z7MW5n03KhVXtJJu1ya2037LiDrpPUSiA6d0iPTAes9zksw94ooCFJkj6I31MeAdIWQFVkM0u6HMo8yzdUtOF565nXAWznOtEA6s/UGpbVcc9MGgvIEH8nEWNCHEFYqrU1raJQrWh9oWs/h0tPGgPXSyM+Nc40zinktfljbX/9alIX9eQPiZzZnMqUueLM6UDshQGy00U0KGBUb1EqKU2To3Qyu9kGIGBVYD1lH7tmiCRy3EuS+O+5nowWWNRRZWCOgJoXmcOmYVRI+noLwSapFYF4DUU304G7gytQwOke5dXLvJSLO+thFL4aZW1izbKdRZQa2SghBxY6RQvyCkFGLBozpVEwO6ZQpIezy/BBVnOxNAhzVjjLTaC3j0lqeRV53pGRtA/hAFSQcP1mNGwuogG7ZaBEdMGDAgAEDBgwY8OLGhcmnEAKPPvroqa99xVd8xerPSimcuxXD1IDzUOai6DhY+FXRt8r5iQoebV2nsnBgQmCU61WxkWea0jiqFkwhOR/eS/5PCDBvA4XxlJkWRVCvhfjS3RohlFC3kOvAKDcr5dbJN/at7QiOWyG6PNGOGJUwLgY12+AxXoqb2sm59qZGyBoFoyIWXlG9MikkgLdqPYumIxa08jGTRp1S+GyyivTJlhTqrJS0dD+ZmVNbLzYnd3lFFXTZLtuFrAsfLWONhe0RUMHSgl+Icsh6CHnKgkoZU1Ls5VF5NCmUzGlIJBs0SrFVqhWBeJkubmeNGxTTSIQVWYiEiYx/pGVNyBzHXB0g2JjhEwvrqu26aZ1U8qSCOwSY17J/tkq9sqb1ibK6Ded28tNKVEZV63FBMqdCVOOkrLWqCZQFawqdRFiNjCIoJZa/mEMkOW1C+J60xWVauh2GkLK0IslxUr1EtCZaUDpllYWVMknrwLhQbOCeACH8nJd7lWuxJBLAIoH5xGyunZFi0QTaqKDSKq6hUuFPkGcnlWMnQ9ZTFzyjhTzLPeipPK+slw6Va1ldWoLDN83Rugrw1i2yfUieEWfOWRufGblRa9Y+owP7S78Kte/USLL2sgxU3SOANBQKpmOZf+2F4NmbmNWLgU04ufeq1jFrwiqvbRSfgZlRGBVwwUvofCSAxNYL49KQQexoF5+ZFkwuqjcT70Ht4HjhWUYSXRswQeZh2UKJfM1qCG2y9yq0ks6htVUrhdvRwpGZztaX8s4KHXO2zrCIDhgwYMCAAQMGDHhx48Lk0y/90i/dzXEMuAnSv8WTaibTilGhMC4QCBzXMRQ8iLJlnAuxcbQUVuXKxFBm8NzcUdVBgpnrwNHSSeZTIW/nl40U2kmlE6LF6HZqAQ+MCyk+JNtjg1omBtCmLKvLElAWUT1pBbuj9IZeCro2jj7XohqZlprjKjDNkZws5buAZqJNKUjAbnorn1RSu9POUrOJuEjqqKoNq/BtraINxqTC/AQRsLKCCUl4UUXVGpQUkGneCiPFcUjZLA14Iza2lPm0M4GdiaZ13VjvmWqyOsSOeaFHaCrGmWJ73BXE5+UiEb/eOFG49NUyKbwdhFDIM9BOOgKm3K5My/8aGwv9eI2SlyQnrlo5jwsS5l1knZIn8V2rjLRIEo1ysQ+dVAFduCW8kk5kqZBf9u+zlmDqMpJLvVuzCu6X+VJrBIkPvc+Qxt1Zqka57pGd0R6Hl1yk+DM2drfcHmtCkOtXCialkNHnkTLOibrHlHAYos3KKJIAyblIcAZQWrNVyNykQHNrAyELK/VWIm3yqBCC0yHrIHsxZbOFAIUVstc61uypZQpX57QaMeFuqGQKo3BhnYgndN0BRxs69hmt2CmlO18/1L6xnizT7JSKo6XDBFaEdW0DrYXtkWFWuUhyn4+096z3HCzCmmKtNo7pSKG0ZpwrQvCxGYBakZjTUvZeYdTKlp1lCtNaag27hSbTPesjcFALQXXvlqZ10vlynMEiwPESfAEPjjUOUEHC2hdNQGewl0u+U+2lE2kRZB+rE/vQqLMtogMGDBgwYMCAAQNe3Lgw+fT7ft/vu5vjGHAO6lb+IX5lotda1k8KxTPHDhXgyihIILkTEkYBIYh6p9ABFy1v0yLgvad1UDfgFOwUYrMrYgc266UbkWR/wHZ5e+O/dwoaTWtTp7HTahlFFzJ+qxa/aQ55DuPCsBstH3WPHJiWetWm3WhQRWBee6q2r3JwKC12vWWbFE5S8KfjTYr1oigRF7UVi9SyCbj+q/sgna2M0rdlBTsLmVEYRHERovJNI2OvrVzb3hZsjYSICQp2R3LMtg2xq5gcq8g09+ZCfCxbKUyVEnvO9liv2YDOykVKaF1gVntMVHjF2p0qzuGkFILDOsW0FBXRwULmwtORS6LmgO2xjN3H7KdRoTq1WO+8olhK2T+hU3U4xchszgLSqgtvX5vbE8oaWQuaRePYr10XHh9VIPIZ+VwioKS1fKBqovLlxOlTOHafQOlbqnzsdCZ7Xke/UxC1URA1VpnL/tVaSwfFHpk6jfPfJ9YSkoJGiGCF9R4dx5yUKq0P1FaUM2Uk7/qkQdUGbOtZGPBBdZlmQTKTvJd5T1lAs1YUQtooWqfj5yVjyAUJyPZByN7UZa9upZNeX414aYL2EsiMkPu1jWsjkphKyT00XojMTTbZXBY8k5wYPO9BaUYE5rUTi22QNem9ELytA+997JrXhZefBaWE0DpeeJqQSF3Z9/M2UDWBrXFgkhtZ12i2R103TeuFGEbFFxXIcz8zmq04v95366hqvOw7JRlp6dnogqhWA6JQCwpypfAotBel7XYm+0gpJfbTTEipIj9NPjmSGnYgngYMGDBgwIABA15quDD5NOB3Bs6LikbFAshotaq0rQ+MjZKCPNAr1qQomNeiugHIWgmUJSjunWbMa0eZSYF8ZWykcAiSYXJYSXGrtBSGt/sCel6DI5ApdaZaxm8IXb4MMkQ9tVWKympSxgDq3K/Ip75dzHnp6mS0ZnsUVsXX0VLhXMBkQYKVY5eqxkEWUpDveov41K5+VgeOl5Jj5NKFKsl2ai3UymNStzN1a1awTRC7meSwqLgWrAM0zGogyLzsjY10mTKipjlYSPeq+3ekOFwFhWvF3lSzZRMZIITepvP2c5FOWquOK0/TBqalWbtm6+GoFsvVtFTsL4Xck05ojnkl2VQuCCmTmdQdT9bJisVC9oR8ppujvmIpEYs+iM2oPBEGnbBJfXTyWoFOlRMiKZjGEu1TrRPy8aRwo8xUJGJEIRQIZ4ZjJ0JIKSnSkzJFIWRaZkChmRRSpDsPWhu0kq5j0h0uqo80FJnY4jbxGf39qGKodGO7cGqx+cVxJdL2JGHgAtbHgGvTWVKPayFsxrmQYA4hDcc6sLRQ1WILTZ93Hg6WTpRYWbQYOpgtLcpEK5q6ueX1dtBXbk0KhbUpU6tnA/SKDMXojBytk2vJR/JZESS7LNpJfYhqurh+6khw5xvm+CSMVtSt2OC2Ss2SIMf3QuQdNQFPINNC5eeZXt1jmSrZc23ryctsRfiPchhNFM6rlWpQKbFuZkaUiMsaUB351EQyLSAWcJPJM5Qg89ZaWfdaR0ILyYhyQZRbJv5esAEM0kVy4J4GDBgwYMCAAQNeehjIpxcwJNjVM2sCmRJiKdNhZVez8e17G1hZQ5RSZJlUZ60X60frA3Xr8YhKoHWiksqNwmix2WTxeOMcxrnCOihjGOyN24zxWlRi2xnFAnuTWqZ1nfLpVqCQ/JmrU+m6leauHw7e72oWgtg/tsokXQGpoBy1EzWYUp19qzCislllM8XiLaBi5lKgsmJ90VHlszokYgtsHOwYUazcqhVsE5yXotaYrttfq6FtpaBPbd4r6yWjJlc0NmCU2A5Tx7xEei0aT209udGrsftwuiMcrOeR2V62kwKWrafMNUXPXpmyXXwTmNeBe7Y0O17sWVVU1wQldp5RHsPgEQJzVsvPamStVDaAhyuT85USko2mUJEk3MCjbVQfbYIPsq5AOs71CR2tFYulpXJQtX7NLmc97JRCZq5IBzaHY6dAc2cDjvV29I0jkqOgVSIsQbUBhXRV66sjdVQ8nUWsnVSvlZl8PuVlhRAIkZApDKcUMdZDUAFlToesa60wobNCpjFVrTxvtI5jpdsvjZP1mzKXVvcnEhz9rmmXIWhvhk3NBLSS5gWtFXItEY1GK7bHijylc59AbQMgKi3rPfPKcX0u+y3PWBGDqbNb65COiSNZD0V2ukvgSSQb3SgPWBtw1tPKaQF5jjtgVntZPy4Qgqa1nmXrJYyclK9m2Z0aCq0wTczyyrrOqt6LLTBlrxVZvIfR0jvOhVxvYyh+iIR8QNSWKOmsqj0orZiWilGQTCjrxBqsiPtSSTfEIWx8wIABAwYMGDDgpYeBfHqBImW+tLEYM7FIbOLbfgl0ZdUEygf5h32RafnHf6w2CxM4WMQioZBiw3s5TuMCV0YBpTQgBaZWiq0C5o2QJAp1oQyS8+CV5ImEIAqV3J/uInabp6Aooh1Gq7W8HK0CcnVQWymoyqhcKjIpslNIvrVCSBkTLWONR6FiCLKntaJ8UipgnahLikwKe6MC86V0ZZuOoOiHjwdQPlB7Vhay27GCnYR1gbqVsHSjNLX1ZDEY2MdCflYj160VyzrQuEBmgnygB+fle9bB7jiQ9xRRZ6lMWh9YWr8iCFASYN60Z1s2c8NqPsYxK+u4CtggaqhRBtORJlMKHxyNC9QNLDtBmXRzHLEK1l/Nx9r9l3kQ9ZM6lZd0lvpo4zx7sREummj/Q8i8vg1NZ4rSiUrkNMkkarybhWPL2ggrcrn/9QKxuQUXVtd8UoGmE6O0GvfZxNrJnzVaMSm6XLbaxq5oI8lnSp3RkiLG6ID2ikKvq1UCMud5DLh3PqyIsLQvl60E5Sdr6/HSoYmqH0VcSCESo/L5aRnWiMabEbQXCSLvr5d+MwHrFZqA1jHzK+6pcQaTUuOcWg+jDzGTywWKLBLcrY/h9/LMzY3sReclZy+L63mcw06psYG1UP+z4CNhvFVA6xXzVo4/LmQ+cy2qPx/gsJHucSMTOFp6llaOoQPYDA4WARs8r9gxsi97a8HFZ7X3cg/S46Ky4K08y3T8JVQYGVMVf2dlWSQkjaYwIZKhMC0Mx7U8L6ZF3J/I/rzIPhwwYMCAAQMGDBjw4sRAPr1AkTJfxrl0u2qcEBqFlsDb1D2tdVLI+SC5P1Xro+0qWqCChOM6DyM6lUE/ABl6RFYs+iaFWtl69qa3dy0msT/xZP0uYlpFVcZNCJabIcRCfVGL1aSOREh9wrLkks1IK4xyPHccmMUiDcBZUdwYrbDOR8WM5Awd1VKcjnMZc6YkIys38jNtiCRaWLfNZApaIxYirYXsS+qHMg+3bAVLhXXjRDGUZx1RpbV0i2utqBSS4iiPxEbjoGlhMgprlrXaBoIX64t0VzvfBjivPXUD49ygi7CW67RYepaNJ8/MWse7Th1DJCOkep2Umh0lJKoPCu+APOYnBcnzyo0UzeiYE+ZFCdRH6piVrifZLstMroWwrnBJAejnWbesDxwvPYcLj/dyb+ZO1m+ZSf6UjpleWa6ZFqJK2kR8XEjV0dsvF/nepj110YJ+U1e/MlNgA+VY8rjEbth9Ns1dQFG1Xu7LhpB1H23DKbcuBYYnr1lphBy2zjNromXTBLZLFbvkwcLLL6oKUR32lXRnEbSblExnZUT187USZEsE9mvZ51cmam1OnYMiB+PowujjzSkyxSTXHFeOZRMtkpnnuIZFK3vTWgnqzowoNseZ2M7GxXqo/1nQSlRpNiodx5laBblnRmHbQO2E6NLRsnp95ll66bpotJDtCihyzXwZ2DeO+7aztbVQtZ7WSgD9OIPFsiOnfAuVj6ScgZ2RjCXPYFxK8P1h5SliG4n+c9joaNHUmuSkVfiYM8bZXQwGDBgwYMCAAQMGvGhxy+TTpz71KT796U/ztV/7tYzH49hyfPgH453AyTbaZS7Bv40LUQUlRYf3oswZjzTzxrFo49v/4Gli0HQbpDjIDdStZI+McsUo5rAE5A29DSmvRVG7sLJ/3AlI++6wst5kRlHkgXrpmaVMnjtwDufgoPU0TixjJ8OXG6fQMci4tY4bM7GrbRVdl6XrDRzMYdQGyiKWTFHVQLTh2BCDhpViksnXnYtZJqTAab8yEymlUDGPa1pqyqyzulWtKAuAU3apsxQrJwvr1sasoRa0ltDxNpJLR5WQT7mG6zlsjSRQurUy57u9cN+kSklc1MntfFJl4rxkEonqIWnwBOM8YDLPUQNZ5uR8IWVvCQlR5nKN1svXZlXAa3kolZmmcYHQiuVHRcWJCvJnlCiJ6sbL5xJ5GMmOZSuErfedVKqyot7ItaLION118Bwsah9zqjSTwq0sSEsL8xYmbWB37Mkysa1m5tatQyEI+YeKJPOJAPEsE8tsn3DJ9Ok9pZTch5R/dhY2dvVDMo8SWWN0WCMlTNwTjRWVV56tH99ohcLz/MLTtIBG9p7qyNB7Jp7GGbF22rS2oAzQZF2cVno++Q0M9SaC9iwl0yb13slnbZ9Yq62Qnjreyz65VtuAcbKfxQIn4wQdA8rj3kDWdosQM0RRl8nkeaWN7MPawYMlXJmuh/pvgvVp7wcOlp3FbpwpHIrWBo4aIYSmRWfZPIzkuYmdUIk5VoVWeCPKw6vTwKSUgPd57Zk3iShSZDlkdUf0ZVosubmRNXNci1oyi40rqsbGlwAKHTw6dlBdRKL86pYm12LPnVceGzShEmXpOPenGhwMGDBgwIABAwYMeHHj0uTT9evX+bZv+zb+3b/7dyil+OQnP8lrX/tavuu7vou9vT3+xt/4G3djnC8rnAzlNkoxLrs39EnJtD2SasbF7kiNg6aWTkTy9lgCXE1sZb8IouxZtoGdkZAhVetRSjEyUjCn4rKvlGja02O8DKYFayoQ68WSZbRmu5QCqGkky+dWSSgfs40aB8tGwr3HpdiEOvVJwIZArhTHdWDpJMQ4dZbKdWCUBa5V4kYbF102S22lmMuUKBXyTN7+Z1qLusOLja+2MK+FMDEmVmlRqTLK5F72SYkyly55B4t45aniRlQQ5YlcmU2FNbFd+uFC1EE+SIEv3bREFUYmTdKOlzAZyTynLnSt86tuaIkILDd0nDqpMpEMLJkPiPlAPaXPJINnj4UkLU13bfNG7tW01PigaZ3j2pFnfyFjz0xgknt2xorGy7gVcGMWO2olIi/37E7EHtU6T2YMIUhm1bz2hKBo+4orZI+M8sCDuxm5ubmlEGJHwlqIiFEhbebnTSAoIS6bSB5axIq0O7mguukMKBXHEQIL66lsRyaNMsl8y07Y3DbtqURWNW0MKr8JAdXv6ndSrXUeQVVk4PzpY7fWc7CQ+zUpZE85B7MKsVsWQiiKTTPmkrVJlRlW6kCCEHxb6jQherNOgQlnqffSszaEXrh76DpcjrJI0idGajUfou5z3q06/Hkve3laSgh862UfeS+22BDEamcAchn71kieWbmGe6ZmrSnCpvvQ3//bI41zfqVOCrnsxcoGSgNXpuC85DytOnpCVM2K4kxHy1uhYRFJ7LJ3Ph+fM5IDJuMfZd09VMC0hONG7q2LY2+9kOHWyyQvm0B0dwvRb5MVE2ZNIHjFtJAXIwTFrBZF59UtBgJqwIABAwYMGDDgJYJLk09/4S/8BbIs46mnnuJNb3rT6uvf9m3fxvd93/cN5NMdwMkQYBDSIoUJWwc+g92xWBkWtbTBnteiIPBBMmmyELuGVaLY2R1LuKtzoogxGia5FKUmk3ynYkMA8u0K2oKS8SdSZb04lIN7bk/9pIGFC+RajlNZCbXeyhUp9EnUPoG6kWKsyGBeu1WnvRBg1sSOgUGIjkKJ0sYYKaLnVSRhSAWtj/YRySlatGLR8waCZdUtzACTcnNr9vQV6zu7VKYVm6a9P3fOi40Qumwd30DdiOIti1215D7HwrQB08ADO5pFLTYy4vmsl1ydrQ2kF5xhA1SxUG/FYpdq9HGh6fE+ovhISyCuT4BF67h2KDk0Id4H72A/kaRjUezdmIEyMS+LlOEF147hvq1OdZkCwWeNFP0u5koRScSgUsc2LtxZ0LpA4zuSLeWFpXVjlMy3JlDmmvw2N4yobDzzVsjN7SKsLtqjmLeBvUxUWAmb9tTqe3colPssgioRIn3bXusC1+cBFSQDLQ1JIwrLqpVGBHul3DulFVrJek4kVGI3PIBPXRwD4DsV2BmdAhNf0VgfTV+i5Dyp3kvWwIWVRZlp2e+pw6UP0t3Sy2lXqsQQAvM2MA5KQvHjGmgdLKpAlrNa59YFnJM5sDblhXWZYLmJCkYn+VLn2QUXtYSFj3KFVgazrcQOuvQcV7BQQuhMSiBoCZtXQnIfN1F51ETCzsheq6wnU3IffI/cyo0SAj7AYqUkhOvL2MHUC6HYWiERy5F8ViziopZyXmzfxsiLD5OBRl5yuFq68zkLO1Pw6EhwKbYyxaz2HC89o+2BfBowYMCAAQMGDHgp4NLk0y/8wi/wr//1v+bVr3712tdf//rX8+STT96xgb2ccTIEuA+t5C17yiUCmBTyIa2l0HNRGRIULI5FNZAKKgCUkBV17G734G628S17KjJv98Vz3YAygTzTWLdeHKbzHFe3d44W2J/B7hRszHAyucITUEHF9t6KedXlO6lIzlVR2WWd2F+M6ogwpWPGUBDSrlWSsUWQYN+qDTRNIM8VZQ5qSVSCdGqVMnaFKrPTVqxEGhSZItiOcCwyUTP1SYNUWCtEpdE4IUCc9yxaYoc5uYaUU+XFXcNxxap4XLaSr1JG1Yl1HqUktDvXotiAm9sAMyOBzNcXHus7BRDArHEsalFK3DvVtP607a5u4cbcM6slZJxc1BU+iH1xVsl4ZzU0Aaaqa+ueWr23NubaxGkNUSUzq2Ssue7Ua5WTeyzB2evr56adBePnxZal2BppnIdZ5VeKkp1SR9JN3bRD4c0Q6LKtkgIoDVn79cink4TLSVyka2Kycs7rjkCclnpjRtLJY2xSRVWxo9p0BNOyUxdaLx0hjRLy8Lj25JFIzYysF2vlPhvVXXsZ88wOl57M6DMthUnJZJ3nYBFOqMY8W6VC6a5LoYkd9xqbOl/GOY6ZRPPG473D6Cwm5omKrHWe4KWLn3WB6CxkUihmdWCs5XNNK/vIIfvRIc8R6+XZksdrdkGUYs6rjXbBxnoCYbXWJfTdkWeKnbFmlMPzM0/dwqiEsZHfE9KRU7qALmrPPNrxRllUP2oJEz9sA7sjsTemzqRaSbe+qg14H5jXoq508VmYiNdDB42Bq3lStkq2XOrmlxuxP7eKlarKRqVu28o49FLC5J0CZcW6OjLyrGqsv2MW8AEDBgwYMGDAgAG/c7g0+TSfz5lMJqe+fuPGDcryjNZWAy6NTSHAZ3Xmap2n9jDJ5M3yrIpWsZiDFLzkcaSQV5+kI0qIF+me1/3j/mSm0Ly5vWs5msFs6cmnosoIdGRByka53XzZBilURq0UriqAW3rGRVRdKSKRJvapeSPqKBeDlMVqIyobrWCrFLWQECygQuDQSrexUSFv6Ge1+MGWTaB0ovLIdXesFOjuvCgPUrevVLynfKLGCZmVRyVGCJHIUQHdik3MaBVb2weqaKNJU1a3gcOl3MsUhq2QwrBphXgoMrHHZJn8/WApY3vFVD7bWrkH01IzazzXji3jTJ9rAzRa4fEczmMBqbqPz2uZy60RTEqzZslTSuGc57hyzKICL4uZUTqTtvY2qkzEfiN2x9W66RFNISotUoGa7EGKSNymSVJCKCjXWX76OK+zYGZEEdj2iCvrPLNK1CQ2ZvccV548Y2X/u1UI6asYl4FF41k0QjJqLeTGpFSEHsF10qZ7kjS8WddE6wMHc8fh0q+IR5Dr2R1rrkzNuZY96FRRKf9IxiakUR8KtcpRa1tRCpZxvG0r+3ZcxMyyqNrbKmWPFgaujGOQO7F7YbQUKjq7XGs9B0uP96JKSntq0YjK58oY1Mis5lpsx12mXlKeWu9xFqyk1JMpmetlG1hUgVHu2Z8HFm1YI5p9CBwuVbTyybmrOpK+sQmAC3I9s6V8/epUVG3+rODzZUClXMXgOVyE1XN5nMvvhCITgt056YBntGJnpFk2nqNKbmzTCnk5U/ICo9DQRIVgiCS1VsnWG1a5Y22QLpmLRkLSV3ZF1eVJ+WMZS57JHnQWxqXk4dkgc5saGjRWrhvEmri0EPAUGWilGWVBXqBY8LexlwYMGDBgwIABAwa8cHBp8ulrvuZr+If/8B/yQz/0QwBRqu/5sR/7MX7/7//9d3yAL1eclbFSbrDF+SAEk4q8gFg4pCi2PhIxHpY1VDq+Vc+l+Eg5H0VcCZsyhW6XfHLA5/eB4BjnkodiouWptlL4FJdeieuIXA/WicVt3sgxMw1tiNaTTM49LRT7i8CNuRRfSVUSfLTbWCE7nJdC0gchqoySa6kaL5kuNiqLYgHWRmWZyeSiV2qyTAZX27BGAITQFWN9MjF1pktd29LPKAXLxrOsAybTsRiNOS4tLCvJfErEU1L8OFjl6qRuf4WBoyU8G0BlUnCqAPPKCVFjIFN+ZWfbZAN0PrCsYwZZEMVUFIWtkXmpGcFJN1obbXClEbWFF1+ZhFMryQmatUIYZbpbj4ng8gF8DAqzSZkUQ6tGmdxDsU7J93IFOiNauNYr2vM6CxotltejhRAUVeO4sYgKM5laCgM3FmJPesUO7IxufUGHAK0XRZ10s5T7AbLG6iYQCiGooCNLWi/d4GrbhWaXmSIzQvqc5QY8Xjqem3tUWCdragvPzT1Gw960u55NeUSnQ/CFHKsayHPZLwFZC40XkiMgREYelVlLK//Ty25Pai3rdFIICWWMIuvJQReNp7Z+pQhVwMHCsXBwz9gQYoC4WNEUh0tH1XrAiB0uEnj5SPZ9ynxSyLhGhfyOE5lQukFQO1FVoT0rjjYImYaHIgtMC0VASKJEtkQxm8wZcOTBtJIdZp08k08iBZ8rLdlmR5WQO6lr3hwh0csc7pko8lyaIqQmANaJRVBrUUU5KyR1E4n2XEtzhaCFMMujNXheexrrJYOMuJeJv2/ic4R4vz1Cfi/bqFjT8kyYV9Lh0wdRjVZWjtNGZVuWiZ1Wx01dW0B5toPGr2yO526XAQMGDBgwYMCAAS8SXLpC+rEf+zG+7uu+jv/6X/8rTdPwl/7SX+IjH/kIN27c4Fd/9VfvxhhftrhZCHBCUnnUVgr1EMkoo6UgCB6yXBQFDin4dCbB3C7EjmARZ7cdv3VoJQXPUQX3OiEaAlDSKbnGuSxGe5NjnYe6hbmC7ZEQG00lBEEqSrfKwDgTgqJ1Me+kR06EEDNZgsyLjSHmKVjXB5nfG4uorkKUMNNCiL8mqmCm0UqzgtIS7L703LslFjchq/zKorIJqQOf76Udty5Qe1FaJTVLHQs664GowmliiJYNkTBrpeD3IZIyUUnXxkykMpPifVaLHW57BCE+HZTabAOsbbTxJPIjEk+KGFKshQSsnWeUmbVra70QNkUsPKsmsLSJ8BPyrcw75cO0lPPYaF3SyPoe5fFnnCg7tFIUuVg9F1H5l+x+KTtoPIr3OObhnNdZMGFaapz3LJvA0VIUT9NoM8qNjFUpxfFSFDGvvHLrm0Yp6Uo5awKZ0eSmI/VcUBw3ni3lUROhMSS7yHMw8zhkvyeGrrYBA+xt6bWMqFW4fAgcLDzBwXS8bm2aGJgtHQcLz85Y9mzdilovrchRrjBGiIy1EPxck2vP0QIm40Aeb79CnjuNjWvMw9J3pMZ8KaTKOJIwzsoabqKFr3/fRIUk92RcKIwS5dVxJQvkcGnRSq3ISgXkSsig6zNHnulVF9FRrpgUeqUakz1nyLWXLKcQsDbtBTn3rIUrY1EsJrTOs2iS0lAxLhS5FoVkWrfp9tioZrNe1KrWn1aApg6UuQGvFNVCrHeTXBRk2sj6B5gtoDCeL7snZ1lHC531+CDKMOdjZ89R3J8ISTuOakalJfOpajyVE5XTrO6yzhKxHyKhnX5rrK4nqki93H6xLVZCMI0yeT7WTo6pEFWktXBk5c/jUtG0gaYBPw1UTgjHwXI3YMCAAQMGDBjw0sClyae3vvWtfOITn+B973sf29vbzGYzvuVbvoV3vetdPPjgg3djjC97nFUQrzKZjJJ/6LdCZLSRdPA2FawwjhakLL5JLg0cNkKm9G1gm9qOn8yduiwmIyn4KyckgdEa5wJ1ECKqMNG6dLMDec/eEx+lPN6n3t5j/5E3x3Tw+G0Hx7G7Vl1LgZTChlFw4KDKumwkpaLaoWdJCqHLVNHRmmIdLJ3Mqy5ijlBvWLWVYjMdK7edJQwA5aUDXwvXjh1FFlZ2vtZ6QqbIEBIwFclaKyEKddd1zrqwUh0s2yAqFc2qs5YLUhyqqEBqXEfmWYSIyY2Qj8e1fLbIZQq1lsJb60DtoJlDGcPoCXDkxFKmlV7ZAK0LLKOtKHVW7MYPxgkpUdWeQusVYWCjTO2eLcOycTx7LN0Dne/UYxZYLiQkn1bIpHu3Y6h6iHZSJd37RhkEpbFeVBu5loLWRdZBh9iJLs2BhUUbsCnhnM2dBftQiOWttW5lmYKoNlRp3AGTydpaNo5xYTYeK1nTJP9q8zlbGySAWgWOar9SNm6VmtZJN8U+vA8sXdioXmpUYDcyrCcVSlXjOFgGtqNjOiRJixIybZSLGmlRO6xXLJpujQYk80wRyHPNpDd/Raa4MpF1tmxEnSPjFMVgpmXtjQs5kA1CSjgv6r08l/UU88WpG3j+GO7b8uSZRsWx1zagtIS8G6PwXtQ7TbTwjfJ4LZFkb+PgRfETCZ02MFsGdqehs+h6mYvUWEArtVLHOR9W2WOJeEqqLlB4FbgxA63kWXdUieq0r7VLc6gi0T1vYFl7tkojCsv4LFi9eECeFVV8Tqa8Nx+kiUBSvx3XMKsco0IT2sCxDSzaaCfWUWmWKZwTQjDX8qwhBFobqFrPjSUrm6f3oliaN1DF50ueCSmo6J6vaX+1kUAORp6HXsFWLuc/iqRcEYPOm1b26LKOlmEnuV9ai+pqXGi2xwPxNGDAgAEDBgwY8FLBLXlDdnd3+ct/+S/f6bEMOAObukslBYKQEbGs8aJoKTSMTLTLJeWLleI1OjFo2mh50tGqRC/H40Tb8UQI3CqMFlJs6URBsJ2paCeSAqtPnJyF+z/8Qd7ygZ/gypMfxzQ1rig5eOgNfORbv5drb3tMxq+k8JnXosIp4hv3JLqxXubhsJaCrXVSAJeJgwhQG3lD73y0VTWiJDIhBvVqKaS8lnk28e8KmduqhRtW3throo0kqo2ClgBgQpBCK5MCf9l46nbdkpdpIRGKXK/ZpVxUDGmtaF3XcU3rTn0QYnFne8dLKq1RCURFV9t2Y4eYnxSVcsk6ZxSxO5eMUyE5QMAqXLhphSxI1XVSsTgna05pIT36+VHTkQQlX8sdSytFsw0y7vQ5rWF7IgTU9Tk8dyTqpMbHro5K5n88kuBvjWJ7rIXMRFRTTc/+mEe1R6YkBDllcsUtsRGn7GRxXscmkXasXVeOFOCNC4xPHKuy0r1r2XZjGuee7bFeaydvnahWqgaeOfCdFUzBde25MhFSpW4l58qHQNXCOFNorajajtyalGJfqlpRqtUnFEpNVJMtG7BBJn9FICohv0JQzBtP7TSZUqsQ92QbnTWBvbSoVus0YIymyDwHMyEuUoq/9zELLJeVqY3CRitrniWiSNYdQX5JtQhJYZ1nnEvjgqNKLLvTUs6llFx/GpuJOUgq5l61TjFb5XKpVbfD7ZFmfyn3ZlLIz1sXn68uUBYS5KbieJatqAMzI7a/RDQHxMbcNGn+5Plz6CSTLnKu/eUiBBNC1LROjqeU5FklBVZjxTKnkf0u2UlREdbKszMz8jzyDuaVJyDPDyGVpPtdFsn2upEOdG0DlYGJd4QAhdGStRXJQR+t26j493gLtY1W3nSve9cS4nU3cZwoeSmSyMA0V3W0/pl4rxsP+0u5hp2JKN+ubq3viwEDBgwYMGDAgAEvblyafPqpn/optra2+KN/9I+uff2f/bN/xmKx4Du/8zvv2OBe7jhZ+EpB46lsT/mgJNC1ip3xtIYqEhJFzHVSsXD1keRx0SdhIlF1Yy4WlDzaLlLbcaPErnG7//yfLaWolO5jUghqrdguNUZLV6zSdMVmvzgDIZ7e+b73Uhzvs7j6ALYck9VLrn7ycd75vvfy63/2R7j2tsfEXqjlONp33bJsvN5M+AbmVQxaD2B8ZxvxyIk9UcVkxTrWWlFtaSVzS4AsFpuJXFo6yXtZRhXCPHSEQZHL1/NkJQqKZRMoIgG3rOXEuicdykwgKMW26ZRpEtYt9zFhZSkKUqArL+RRKhQTDEKeEaJ6CCleU7FZZB4XxPqWSKcUxK4UGCWF+LLtbIBGqZXCKmUSpc8ThFScZrA71qsMKK27LmredwqV1hI7g3VkWpHJ10oTFUZegtLbaCkdR/XMVgGZNhzVAeftKjy5iethZdGyUqSP8mjzNDpaVqX1e99SCOv5Z9Y5nA/MKiF6Wg0742hxQ/ZRnktHMR9O75nKeq7PvLSSNzJfq05+znN1i7VCe14Hbiy6e506MFovRFxAupPlTgK2jypPkQeqRjFvwop8IkjofuMV81p0Kn1LbZFp8sxz1MAkBArdbUBvNE0LRR6orSj1ilythccXmULVQshshbBS6ck+8xI8H9U6AVZW0DqGbo9zWUd1030mIMSFSfu1kYXuiTlhiN2ustEKpgOVDSvbZFJqLlqZJyGfu+y8iV5XkxqtmOYSsC6dL+UY1kkAu2+82HdXazt1nRTyrsuzgkUtz5+taLu1cc2nvZj+21c+eSRc3To4WHqx7hbR0oisTaU6O7F18jwNbbQsR4J9UclevjKBg7ko9G7Mu2dEa4V8D0SrcFJ+Onk26NJzFDtM1jEvsPFCNo2zqEQDajYjQ+yx00J+rrUyH7OlHD/PujVvA+QBQpZC2rvnc6nhgd38trpFDhgwYMCAAQMGDHjh4dLk01//63+dn/zJnzz19fvvv58//af/9EA+3SFsCv72AQ4WnkUrLcbL+Jbfxwyl3Egwr4mESRELk/QPexOtEMZIYW9jJdRYxfWZ5+qWqCiWNkgXpBQme5vs08KBqeAV2zAuzFq486SUktOHaLGhUzoA4D1v+cBPUBzvc/Sq15FkQHa8xdErp+w8/Rne8nPv59pbfg+110xMR2CYmBsEXQGmI6mUisVE7BH/7mKmkApdS/TWiwolN0IgNfHrBZ01KGVFpTkN0bojRawojEZBcpcmpZeueEgHqcpKYTbJOsLMBY21Ya0rm1Zir9yvQbtApgNGidqmsV0mclIi9MknSwz6jRlKrY0WGhPD1OsgKqVIEhmViBs5fxsUrYeR7ym0lPy8Qgg92zthCgjPDZHojF0De2NqnYS+e2Td+nhulZQWsZjfGomF1BOtaiYSf4BtJS9nlDuMEdVbCpsfZdLhLIX1T6O1rLKihumH9mda1kK/G2HdBo5rx7ySoryynW2sIio24vrJDUxLj3dCEpy08B0vhXjaKruvaw1bmXRNPF56RtudouxoIfe0NJHwjP6mUsk1HQLZfVHNpWDRBPYXoltKSjkHHC7FdjXOHePMnAq0LjIt6pwFHMdnQ5oVpUWNdF8OKI1RgWXraWxHbmVaAqVrLzbMIhJb3geemwnRkOcxNyiSgG4p9+hwDrsjj4ld5NBi5xrF+9tIVBJlBsF1arxl7aVRgYvdJRH7X4jKqcLAkZO9piaQx3y0eS3rLM/i+dI8eSGvGic/a0y0Mbai2slMYCvrCMN5VNS1Hu4fsXqAWC+E16IWRc9hBgrPcY+t6ZPqge45p2SKmeQKn0Vlk5fsuL2JZmkDbRtWuUpKRTI1EtIpsD2pR1snBJLz8ZkWomLTSwbTvJYBTArJ0rKeVTB6ygzL4oZVgFXraqdNUIiNUmt5ls29nN+Y1CgjPlsVuBayIqq1QiTM44uRWQNHS8f2+OZdFgcMGDBgwIABAwa8eHBp8umpp57ikUceOfX1hx56iKeeeuqODGrAevC382EVDJ4yb8SWJP8wzzNpTT2rAkdVpxiooj3CqC6nQ5OsKLHYjwqhZSvt1pVSBB9YWHkDbSIhcTtI6qlUR/TDnZ2XTntBSeHU0iOegL0nPsqVJz/O4uoDK+IJgBDIF8fYvOTqx/87e5/+LZo3/S6sEjtWpqQIqqPFKSlpPFLkJbIBOjuIUtH6FU/REi0mvssjyjIhFxLRUlshI4KPf44FM/Hn0jW3AYpIAnqvaJGsnESSeS+kAnGexnnAmKgQiYSIUtLtK9eBNgRmTafoSRzVeQViUmkli56KlarRrDrMpTmYxLlL5bLWQVRV/SdGkGP40FnmVhkwSlRYFrH3jfKwWgt17IS2bC2zWogFZeTcGhlfiEqQmYdpFY8Tx5/mXkX13rwFMw8x9FuKV61ZBbInJZKLpNrSwqyyMMok+8doCcWPnweZ88Ol49qRqGFsLOSVkmL+uIK5iXlTCAm2qOX+3jPtjgOS8bRshVTZhJGRnKjGio1uUTsWSXkXhNjSRuZ21sr5myA2ujI3FJkmBMfhMn4W2U8qiCJmWYOayvNiU6B1/3kx0fLzrYcqhk03DmzlYlfHeIDI5jak/K31h0RtvWQ4WSEkVsRigLKA6hiuHcvaMyaIBTRZL0OXY5TWp3dCpIcAx02SGsmeVAp8HlbNBRKxNCmi0rOVZ8Io6zpT9h8li8YzqwMKhdES+h1UzC+youSxkcQRm57isJJOfvOaFWnbRoKnbaHW3TXULTeFIhFtGq0V4zxQO3kJsDUylNZztHRkWgLa07OCSKotYrODnZGs71EmqsBZJaRSaLq5MfGFRgZCaMY1Y0Mk/ELMuvOgnayhi/wKaIHnj2B7LL9vZlW3/+Yx+yvQdaBM98nFe5i6OrZOVGhGa7ELDgTUgAEDBgwYMGDASwKXJp/uv/9+fvM3f5OHH3547euPP/44V69evVPjelkjBX8rJHupjkoD66RIGsdw5tTCHuSzdcwN2ZuK7WMWCxIXOsULCAmhIwGDEXXEuAzMa0VmAoVRqEwJ6RLEcnY7MIjqpPVwOLfsTLKoUvEr5ZEh5uf49Z8tj/cxTY0tuwSd8mifrWc+S7GYg3doZ3nn+/6vfOx7/leOv+IxvJcCbX7Mql23UVJQFaYLEW/juSp76rSr8Fxi8bSI1p8tByHv3tLXTr6XFFDpOkL8u0t2EidWv3kLEzy+7TqwhWhvIRI2JpNW7lmAUHnsRHfWu9ApQFLIcODmqgSQIjKRjkUsjm203SkPKtpiSiNkULLoKKLCJYOR6pMCCms79U8TiVGtoIzrpmjEIjVr9GrMo9xRZGrVIc05ICrEVjlRsSgNiNVO8pFiIa/kWowSgmappPPcvJKvey9/9iFaB5FJMkauMyvgsIKl9dKxLfNMSkWmu3ytEODGTDqnKSXkEHEuWieFdp78mnSdzByy72Z1wHov9sJYaOszyCetWXX1S8eyNgWSC/ES88xFSeYjMRV/3vloBYz7v4wWKQsru9jYCnntg1rrXhmIHRpzIWtSZzml4GracpFAWVqxGhaJDIiEXWWDkNtBCDSl4HjhVyHXVVTcpLWUnkkhxD2Y1pOCZZD7nsUvu/g/heSVHSy7hgjojiBSVaDI5Dm5iOcrskh0RFtoFtWc1omi0CuZk0UjyiejQlzz8vyd1fJzB/N1O+i4lQ6CpkcspRcCdbRDN1a6eyolpNrN4OnITVkTihjPRutkTvNMMS0CGlY5aXPbPWPGhaz/qhEy1AU4WgopqiK5bHSnbKqD7E8/knu/SOSuE8KyjWRh7dabTuRxbW0ipJat3Bddyx5s4zWVRo7jrSj5NDKmZCsdF5JLZVs5b+oCeNIKO2DAgAEDBgwYMODFi0uTT9/+7d/On//zf57t7W2+9mu/FoD/8B/+A+9+97v5Y3/sj93xAb4cIfYt6TxUxa5CkqETmMeOUBM8mY65OyoGTccCWzpcyefGRSSbiORAVDqlTmexlqVqoNaBaaGY5oostiFPxNDtYDKKyopGAseNCTStih3lpJjKsl6+DV1hXW/v4YqSrF5ix1uUR/vsffZjKNviihKC+IR2nn6Cr/hb7+Vj3/cjXH/7YzwfQ39TERu0FIOZhofGUqQfLkS5cZJ4gtgS3YmCxzsphtoanu0pnLzviv1RJoRGiORRspIky5eN4b3XZ7DIoxXFSIGVOsalwjVUcv68gGkeuKfxmOjHs16sN1orJoVUxI3vutqdhxDJMaU6oix1A6u9BK9Py2jrQb6uI9llA+Jzy7vue63zLGwsdkNXoCeChniuoyWMCyF6hMjT1NaLlSoqRpZLIQxBbkhSgkAsfolkXyNrI/ed5S+pAa2TYzUWDhbyZ083ptDKvO5GklMHH8kKzaLx3L8DRssjsWodBwshTpIqSiHHnrWx8E7qIi3XvzWKY2zBe09tDc4HMhNWWV1axw6HcUx5plcEaeJ0vJMJSN3Gqh6Blpn4OQW2Dbgy0Dq/smIl9VhSEsbpjN8X5aTRXTe1qnGSZxbtaos6ZsFlMCqE2kz5Rj6AtYG8UCvSMxEypRFyfOHE0lZFwiy42G0wMhU+iDLII+qY3Eg4v9Fw3MBiKXs2kQ/QXYezcj8IYhUrTFQjReKycWCiMqyO9rQ8qTy9dFsjzs8ok5y72nquH0sXPKM7dVYbRLlTx2ufFN28L2J3tsLAaCznTerJtB/LqLTMFPgLKJ9Afq5ufcytUrTes2wDzgtx21oJokfLvj1ayHjLrFOW6ki07y/juvUdQV3F9W+ikskHIYtEaagYZaK4PGjjZxM5pMA23ThvdjkqPgeWUf05Krpzurj3LLKXVS5rIJF3KW8u12qjFXbAgAEDBgwYMGDAixeXJp9+6Id+iM9+9rN83dd9HVkmP+6950/9qT/FX/trf+2OD/DlCKWgajyzJpBrHTsNhVWm0HMzKE1gUkqYrkIKpTaGYqtIKmEksLl18lY5V6JoSTlIVQpzjsoOUcQEWhNiASj/4Ne3mfnkXZdp4hwczj3aCHG2sCEGCHef779R33/kzRw89AaufvJxjh6csPXMZ1G2xY4mooCpFrTTXfYffiNXnn6C1/zM+/nco7+HgF4FGHuioijad45iaHV1zpgdsQtfIoRiQYqLBJ6ONsFoxwpaiqZGd0RTExUyLhZbClFlWCtkm56IfWtZy/1RXu6vCqJCqpdSvLYOFrWQGI2TYi0gtp9EHF4E1optzigpjkMpf97K5ZpcJCySjSjlvaxuipZrSYHjLghZUPXIolToJjJsVgsRtB8nu9BCRGkd16OOeVUnZBSJ2DDx3i2tjLUN3QdcnKuCzloZiOTAhuOBzNeigoMaTLRFjYxIMZpee0AXYucyF3PUENJkWXdrqvJiy9S6y1nLtJAIS+u5WmbUVgrncR64sfCoxq+uV5RNQkTdM9EUUdIzLjMybTmqWCnCVmvQC6EzHYFXilkTmC89i5hzlcdQ+Xi7GJdREeWlW5oicLCQcHmChJ0v60hyRYseJBWVZIpl0V64gxynsSJjUho0EtZtAygU40z2c3Ddes/zaMkMUfFE7DoYmcGqjUHWVjKttOmskmn9OeCoFmI3MzDyUBSKIhfy2gd51kGnmCtMUohG9WNUYS0AFwI6hNjZU0imLJKMQcn4j6uuI+YYOUbwci2LBqwWJdiyjiSnS8oqGaN1sg/sBZhhjyiFnvV+pVJKZGWm5Hk5yhX7y8DRUiYmHba13f3WcT+5SNy18ZkSvBzThu75lF5qHCylY2Ch1wlFF++PVjIHZyaN96HiczP+rwXG8aGglOz/Jh6q8mAj2amVvAwYF/CKHSFlT1phBwwYMGDAgAEDBry4cWnyqSgKfvZnf5Yf+qEf4vHHH2c8HvO2t72Nhx566G6M72WLxomFJM8U1nqWsQNdmQX259JtK8+7rloHSymKdieI/SMWdTbaJmwlxVHqeEYsblLWjiJ2y1PQtAGlvNjvVGyZfTN4z94TH6U83qfe3mP/kTevWCsn32ZnDLnWXF94Ce/WeqUAOa66vKC1WkNrPvKt38s73/derjz52xSzI3xeoLzDtDUhyzl+8CFQmsXeK9h64rfZ+vRHqV731rVAXwDtpWA+qoTMACEu2pPnjGNeRNULPhZxSCE1KrosnET+tCnPpIFl/Pl0zDWlgIdWyedS2/HGga86O5JRUc2goMkhN6ISs17sQq2ViWpjcbi4SFFIR8KlznjBdyHJ45j70tikyIn2pVh8bhXRAuW7YnBROenuRaegS8RMgkUUYaNc1lcThFTLlWT/JPVTZjp7WRaPkdaDi+NtQzenLjIYKk6wNnLMmRUFDXFMfdIpoQaO5l33wdqI4mteh1XukrVe7F9RTdQ0Mh8urB+rib6wLOZoadXlLC1yT2agdYrcBJaNWGPHuRzXBthfxDDm3ahGCkAIZDpmtsULSPvEOZmTrbgvs6h0QUlGky6j4isSFyoqgZQRMrn1gaWVjmpERVJluy6NSemiEULYZHDPSO5dYcQemIgN5SORHQmNWeNYxoB3F+1uDaL86fPXSdUYvBAQvhWS10eCxMefT/syoyNFjuaiCDQKxoXY3xovweNFDGdftEIgFWlRxgn0KioMQyI7RU1YO8lFKmNHToUoHm0cfxbvuY83IcvkIg4dNNfjPqZT2gGouL+V7hSNN4OJTSBS8wIX4J6J3IfMB7IUmO+ECLVxw7kQrYdarrvMJEesiYScRf6+yllCrqG1st8T+bg7jS8hojo2Nv4DhHy8CPmURaIp5b+B5D21UZ1FWD9MIqw9ct3eAduS89RvTDFgwIABAwYMGDDgxY9Lk08Jjz76KI8++uidHMuACOukysmVZ1Y56jaQMnaPF90b+GUFc6SAXzbxrfwi2p58LFSV5Gws4rFVL6NoOpKiPSmgigK2R1qKtxDwqFUr+fNw/4c/yFs+8BNcefLjmKbGFSUHD72Bj3zr93LtbY9RtbA7FltSkSuaGSwCXJ0KseJCWFm2Np3u2tse49f/7I/wlX/vB5k+/0UggMlop7scP/gQ9faezFs5ZrR/DX28vzEDqUZOUPVOcp5oqHVCaCTyQ+6NFOt1VJSl7myLVu7BeccLxAB3pPCbt+IaTLaqRJRoYl5SJGiq1rFVZqvg6+PYvt5HImg+P+ek/eshhggjQcIKUcvsL2CRCammghTLsyoSLZF8aq0EPhdjUY1AtJj1CKGEfkGZrkcpIWqyIOc8jtYepaVYtq4jJeyJY6Qg6ZNzmf6brEVJmZVqfcXZWVjzGrYi2WqB46VYQF8VD5xnmtw46lYUKUdVVH2xPpZMdUV9oFOxpXwh54KQCq4j4GZ1Rw5tRfXZwdzjvZCxbbSXJeKpz12ka0oKtMZ6yTfScKPpCKPVdS6FZLtvJIR20yrGucEqWQA+rqNlVE65EJV3MROurqHNhVBbVGAyhUFshMLfKA4WQqrNlt2Yq1bGouiIp/4ah0gCLuQ8zsY1fWLtnLx+DbgG9r3MfR6VUDZ0nf9Sl8pjx4rNDsjz0fnYpVLBKFN4p6gbsbLmkVCGqHiMREprhcTxUWUaXKea7Kv++mN2xPB3xU1tagkHcyEmU4C/CrLurm7J+plX8uLBRqIpnTBlubVWPlfEAPsqEk+eaMumux+JQPRKnssgJLZzMdNMiV1SRYXn7DyZaA+pU2X/ueCIXVY3fD6Rp9qAKeS5ehh/WfUbUwwYMGDAgAEDBgx48ePS5JNzjp/+6Z/mF3/xF7l27Rrer9MF/+7f/bs7NriXNZS8xfY+sIxFhfVdoe2UqHfqmDeS2r73OwnpaFPqF+BJDdQS1VBIAZznMM01k1ITVIjKCEem1SqYexPu//AHeef73ktxvM/i6gPYckxWL7n6ycd55/vey6//2R/h8G0SAi7Fn3TusyFZOyTsNxVGZ0EIqB/l637gT2DLMe10h3aytfZTul7iipIqklF3AqlgTnaylviGPqqoFFJABQWHFzletOgFJfelajuFj2F9DqogpIhR0qUsIEXlvIrWIE4XvRe5HkdHokTHmVj3YrV4XHV5O8myVGmoMyHDTJQiND1W4GSB3ScZ0jWGIGqMNpdx1z4RGKevoV+43gyerv180ZPYnCc4qS3oRggCpyPpsZDcInJNZhSjXCyDTdxbm+a6r3qhlnPmTmyGOziMhsx1mWzJgpXq6aYlZnAFtkpRXc1ax6zePP40L7MlfPEISuMJSu6FJVoZ+5OvOhtW6yRHyLawXDUxEOLJegl79slqpaOFL86VdxJu7Zuwlu1VGC+B3EgXyDKqMdseUZdI5ZPEHcTA7kierBRR59y3lPPUWiFNMy22yLKU/eKjejBZDfvh6i4yW0XcOz5Eq6UW++QyBowrJXlEyeK5Im9Ctz/TGPMT9yatD0unMrro/jxcsury2EaCyXoYZYFJId8/rmQtjnK5thAJuHT/U+e4xkVSJ54/CvRWSLlMyfKmkZyoeR33Rjy2ClEFdZGNSCQxYzOA/nX3n599mKybN4OQTUsL1w5b7t/NKfOBeBowYMCAAQMGDHip4NLk07vf/W5++qd/mj/0h/4Qb33rW1fd1gbcOWRGoQgsWylGqiZmvQT5h3kbO34FpDgxyNejG2tVJOtwfvFuETVDayWrqJzKW2aDY38ZIukUeH52xgG85y0f+AmK432OXvW6lT/CjqYsd+9j+9kn+Yp/8CP8+v/rA0DGYQX3bsViw0u47qLtCLObRRftv+6tXH/0HVz95OMs7n0la1RNCEz2n+X6o+8Qy98dgINVod3Hookhy5pVx6b2gvIGGy1Cmmg56n2vT3SlYm3ZwqL2jAuDQoq7NohSjTi+US7Kq8tgRe74ruNcFeR8SyuEmu4tpoBYz8aLzgZT5JuPvelcSWkRABOJ1Dzm4izbi5FMZ6FFiuRxAaML5pMJ8SB7ysecnJQdBNLyPhEUaRo2kU+WbuwNQkb4uGelGyXslvE+tjFMOR0MIeZaDzsjQCmUki6A9U3uZxPPMymEGLCRaEnd/tLOGJVRyWJhVkkDgybZBIOQ17M6zkX8mYAoJOtW7FrHS5iNhChrIimSxWufV5LFNC1l/pNdLAW0p/tzFlouTmxAF07tg6jIaifraUsJIT/KJBNv6SAPdDcvRBKplc+0TmyWte2FlWeRHCYSO/GcKaRf60iS9R5UiVSD02ujsqImu6ArltrKsyXTQlCnDKsbi9jMIKowUx6Uiy8dbLzfRklwPF7OW+YS4m9P7C9Hp1DTVpogGB0Jt/jZFF6flupFr2FmpXHBycnYRDyCrLFktU4NETxyUulAOfz7YsCAAQMGDBgw4KWCS5NPP/MzP8M//af/lG/6pm+6G+MZEBF8YL6UYq+KShsfJOC5CbFAIQYFs7kAukhNVyHFp1JSnLYOrh1JCK/zkhG1XG7+2b0nPsqVJz/O4uoDK0aiPNpn65nPUizmKNfyyt/4D/ze7/9WnnrXe9l/+2McVNJhzHt4bt4pPy4Umt3Lf9p5+jMs9l6BK8eYeslk/1ma7St85Fu+5/YT0ns4WTAlwi8LMndZDJoOF8x1SVY969fvz1nqCItYb7YmAescbVQ0NEmdELoi9VbQIMV3nokqp4okpg1CQKTiM9n0ZrWQhkWmV93mboYVgRcn00V1h0Zyii44dediawRXJ5LVdBEkQizQFfGNlQ5+IKHaKUA8EC1N4fR96t/D1FlR04VmWwuzWNinzmnzuLe06jr2LSJZBTHU+ybj94hKJVNdNpSPnfhS3phG1tvOOOZLzeWLo0xh4hbJXKCxcj5FJM/ojtE4yeiaFHJNk5EohNo4icmSufRwkHXWRGfvzH09iVV+UuhUn9bFsPK8G7dDMqlMJFAIsTkAkchHiLo8jrlxcv8ynRSn3d5vgFBvJmLOu8bQs+Sdp+ZKcMjaKDIZB8Sw8CDXl2li1zux6yYboY0qTAIUQezTeSZEUrjJL4EGePaoI5TTtQUvGXkgpN5FEegpGns4a1dG4Vu82BhQHoPcB+JpwIABAwYMGDDgpYVbChz/8i//8rsxlgERKYTaIYVQE4PDsxjYbAH8eqj17UBpeQN9YwGT3PP8sRQ7yxiiPT+jgCmP9zFNjS3H8vejffY++zGUbXFFCXmBqeZceeKjTH7svXzs+36E+n+SDKg2Zqy0Tt66Ly+YKZLyn1YZU/vXcEXJ9UffwUe+5Xu49rbH7sCMnI9EHKmY/ZJsKxdBFcSG1bfonIeAZEM1NqBNZ4cbZd3PZ4bbkg6lArlt11UqSYlF7/DzFma1Y3ucrT5zMyR7V6DrEujDzTsOXgbewc5Y88z+xcmnRDCUWc8mFi9o2Xo8ou5KIes3I1MUHbnhI0HQOKjmcv2LRv6b1FXJspcbuEd35z7P5trHsoZpnlQ8pzv8OaL97BiuTEUtlylRVoYQVmuwb3fr/z2hBq4vxE5V5l2eXEB+wHshn8qo2iGqku7Es+kkEmmU9lwiD0E45yoqQxNtkUiZ0NujwUcS2HdsYrr2QLSknRj8rfC7Loiy7aLzEIh5Z1aymFzoSCGtOzKrdpIJ11cTad/ZdjUdIbe8wFpq0sn7Y6e3Di55Iy97392J/+YtbI9uOY5ywIABAwYMGDBgwAsUl/4X3l/8i3+Rv/W3/hbve9/7BsvdXULrPPMmZjk5IZ4I6yqRO6kqaFpQGRzO4XkHN+Zdp6nzCol6ew9XlGT1EjuasvXMZ1G2xY4mYiFyFrKc2QMPMTl4jtf87PvZ/wO/B4UW21UWw9PDxTtCgRBQ197ye87srne30Q+0NlyMmDj585fZOZNCinnvuvNmWVcg3+4unDfSSv4s9HNuEnEIQmxchCdJCiMdVShtUmpcJqzqJqgctC5wfInOfyl42fbYl/RI815yz7yTzKeLcHsp3Fn7mNWVx65kMVepcXLfUuh8oGt7X+W9vXbBeXFe7gesh+ifRIXs6Z1xUln5Vae0o3r92s5ax8tWiMdJzBtKxJntqbRUHBMa3G2o8c6D5EzBeCJh6IsWTBCSMIvPEp8+l0kGWApHL7LOwryIjEttO7uXprMN+juwNg3rmVMXRUs3vx6Z48IIIeX95nuUnG5VAwexzaOzlyeCXgioAzx9YHnVPYpR9qV5pg8YMGDAgAEDBgy4+7g0+fQrv/Ir/NIv/RL/6l/9K97ylreQ5+vBLz/3cz93xwb3coUPkrszj9lCWp2dmXEnsIxEV93CUbTtpABsOLsg3X/kzRw89AaufvJxlrv3USzmonhSUlqbtqad7tJOt6mMZueJ34bPfJSDV7519XbeWinuL12ras3+6956axd8h5CUCrf6sxdFrsQ+44JinIeVgqaK9q36dgKTkGJPtZBtKLhV77/pel08nw0Xuw4bxLYXEGtbkcVi+g6ST8sWnj1yKxXMzeDpSJPWdV26qjZgfaDMNLZ1krUTP3czvix9r0EUOGMdCdYA+07m7hRBosWmNG/BeQ+YC3NyzsveuZm1Ko3JOVhGy2cinxZnWGpPIq3zqu2UYP4EO51C37WTfLC7AR+kK+M4j908bcxiosvFM1El5L10bSOFsKvOEllkMMkDresuwfVIxotmHJ2HCpmLW8EqX8yLMq8wsLA3z3arEZvkixkWeOoGaG158Eo2EFADBgwYMGDAgAEvEVyafLpy5Qrf/M3ffDfGMiDCh0BTd2HErZVi8Tx1w+2gauWtetMLpl0FTofO6nUKvQym7WefRLkW8gLlLKatCVnO8YMPEVD40Zjs8BrZ0T7ugXSd8frOeJs/QLBoYSsEgoetQtrT35j3FEh34BxnWeDCif+CkF7WhwsTDCe7mFkr/7uTZKq1ko11S2qqOJBcgUKzqAPEDl+tl4ek43IKM4/sKYKEQJvYucw7yeRJyfIhiH3TOVg2ga1S7vNFYIOQefP5xT6/bGRM/WB1f0lyxNKRXafyr+L1hTtopzyJJsBsAVUlpKkGxlkXug2x+1sTFWs9W12yl06VfH3RKrwPEt6NkDzJNqiaO3MNt/rITtfigtgrZ7DKRHo5IGi4MQsUxvKqveJ3ejgDBgwYMGDAgAED7gAuTT791E/91N0Yx4A+Qpe5hO4Cqu8WGkCfqGpWmSc3qbhTBtNX/IO/zit/4z9iqjlkOe10l+MHH6Le3hN7WrPE5SXH4z2Wtah18lg06mh7eTkQUMmql2wyF8H1OUwzT1kqXLRKpcyXO4WLchBJYbKog9hBb+H4SVViNn3wFrGswU9hdiuMQew+qDMoc4X1MKscTskYG25uQT0JH6KSJojKJp5m1Qmu300ti3+u3eWIWJtIqwt+vo42SRWVQIqOhLoMzlwrobPh3S2VZgCO4gQppLthG2QeTCSOXHt2BzqAXQ27I8gzhVZhpURrbZeb9Tv9LEq2UJAQeYU0OXi5IAdQsL8I3LctDQ4GDBgwYMCAAQMGvLhxS/+is9byb//tv+Unf/InOT4+BuDpp59mNpvd0cG9XBGIHay8WO6cu/1cn/OQLB7998stsZ33BViJa297jH/9Iz/H07/791FfuZfnv/x38fyjb6fe3pPjh0D5/LMcPfJGnvmyN3PcCLE2qyTHatn8zhd7XypclsQAIRmemYky5tqR/L0wUqDlN/3pOwsF7E6FZFjcpjfpNt2CawitECoX6pp4Am3MXWocHFcOHzzzSr5+q0TKshU1ljaipkmkY9rP1sn+yjUoI/fznglsl4qtS9zUZJG9KFTMiWqcKCnrO0hoNL1Msi8FAhKofbwQMnYW1aLLm1xTZeX+HC09B1UkCpG5sNyFZ5H37H36t3jgQ7/M3qd/60J+01XHQg3TArZHcu9eLkj23KqB6qIJ/AMGDBgwYMCAAQNe0Li08unJJ5/kG7/xG3nqqaeo65o/+Af/INvb2/zoj/4odV3z/ve//26M82WFqnXyNt5LF6u7TcykDk8nLR3NZQrTLOO/f+d7eef73sv44DmC0rhyjKmXTPefpdm5whP/p++hcpq6iUX9nWQfXkS47GVrJaqVZ47hsIqdqNydJW8uihD/TxFoX0BKjDldl7nLInX2WtSwP4fGeslcuw2PU+1h5EVR6JUU0scN4MH4LkOriUFS0wyUEpaqvOBT2Xuxl12U7GmdBL2XOStG7XatZek6oCNxvtTLYhmgriDPLxayfdzCx58RYsc7WNxFbuP+D3+w68zZ1Lii5OChN/CRb/3ec5smBGQux3GCQ7hY57qXCpYxpP9ldMkDBgwYMGDAgAEveVyafHr3u9/NV33VV/H4449z9erV1de/+Zu/me/+7u++o4N7uUIphfXhruWmbELL7dugkgVvVWztX8MVJc8/+g4+923fw9E7HmPMnQnzfTlh2cBkJNk+9WVIJ+/veEfAAPzWF+B1r7AcfykX6AUwqy+m1DsLx62QfEUeCOr2SZTWCjlkoyVskxUsiTq0hnkVyLS/cIB8g+QaXRTHFkYKJiVgYt7UxX98I/pz9DuZR3S9hqy++BgWDYwyuUd3C/d/+IO8833vpTjeZ3H1AWw5JquXXP3k43zNj72LxdUHGB1eP01Kve2x1TFmDnwjxN4LbLvdVaggytitEYzywXI3YMCAAQMGDBjwUsClyadf/uVf5td+7dcoivUQ0IcffpgvfOELd2xgL0c4L/kjwYfYCvxLh8tkEJ2Ha297bOMb/XGmyVsuL+O6CwTKiw1HdWwXfwni6VzFRa+4vRXcmIN7BhYXDLr+UqBF5mb/Nhfx9XlUQd2B/WejbW9Z35zYPVjCs8eBhbV8Yf/2z70JAVEJaQdFJJ5eKuLDwOXIrxbuboC397zlAz9BcbzP0ateFzuAgh1vUW833PuJDzF99nM8/4Z3YMvJipR65/vey6//2R9Z26MLe4v++Bcx5jWMcgmTN/pLZeQcMGDAgAEDBgwYcDdxafLJe4/bIC/4/Oc/z/b29h0Z1MsN1gfqtmv7fTB/AXc16pNB010AyvnhOjGkNfuve+vajy091A0cXeJUd5NAeTHBIpYwfUEpznmKi03F7aXHE6Sz3Auto/tF5+c8HC4ko+n5w9s/Vp+/uhnJs/BwfQGLCp4+uP1zn4e69mw98VHy433Cy5TQhbv7jN174qNcefLjLK4+sCKeAAiBrWeeJCgl3fcCoA12vMXRK6fsPP0Z3vJz7+faW37P2j15udnPDht4pYFRobAuDATUgAEDBgwYMGDASwCXJp++/uu/nr/5N/8mf/fv/l1ALGKz2Ywf+IEf4Ju+6Zvu+ABf6rA+SOcwL0WvVjB/gaZv98mg4mifYn6EApqtHertvZsSQxcuoLzny3/hn/D2/+3HyaoFxw+85qbqgJc62nBB0dg5iovzitvLwAPhBVgNN3eATaidhFYvbv9Ql4Z3Yq26m6LHtIf3nvw4+mVM6N5tlMf7mKbGluO1r+eLY4rFHFeM0LZB296iVYrF3iu48tnfZu+Jj54i8F9uuD6HnfELKFhuwIABAwYMGDBgwG3h0tXnj//4j/Orv/qrvPnNb6aqKv74H//jK8vdj/7oj96NMb6kUbdCPJWZQinJ9pi9AEORkprm6ic+REDUTqatUW1NcXxIUGpFDN3/4Q/e1nl+///zO3nsb/5Fdj73aUaHN7jyuU9Rzo8igfJaitkBb/m591+oa9RLBRe90r1P/xZXP/EhbDkmX85YS+U5UdzezlheiDEs1R3wkFlg9iW2vCYsmru7pPt7uN7a5ejBh6i3du/Ivh2wjnq6C8Ezuf4M+eKYtA+1bVGuRdkWAniz/v7HlWNMU1Me3yXv5YsISwvXjiAzg+ppwIABAwYMGDDgpYBLK5++7Mu+jMcff5yf/dmf5fHHH2c2m/Fd3/VdfMd3fAfj8fjmBxiwgvNitVMqsGgCtQ0EpHX4Cwp9Nc0rX8vVTz2OspZ2vAUKsmrB5MY1nn/972Ln6SduWVmTiuPR9WfQrqUdT0Ep8vkRe098jP1H3kS9vfeyVAdk3FwRc/+HP8hX/r0fZPuLT+KNAZPRjqccP/gw9fYeEIvb/WsvyeL2TikG3e+Q8nB2ic51l8YJRZy6C4q4AYL7P/xB3vLP/w7jG9fIqgW+KGknW1Q7VxnfeAbT1GTB403G7hc+vbY/Tb3EFeXq7xfCSzQXTyN74nDRcs9WcdPPDxgwYMCAAQMGDHhh41LkU9u2vPGNb+Tnf/7n+Y7v+A6+4zu+426N62WBEKD1gab1VPIiHIUEFL+Q0M8vyZezaBspV5Yul5fkyxn5cn7rxFCvOF5efYDx4fMEk4FSWGPIqgXbX3ySevvKi49AuQPF4c1EPX3izmcZLis2Ene3VNxuwPFLJal6A36n8tYcML9LqquTGURrZqYXo93rBUq49PPWjh98iJ0vfhbdNhSH1xnfuIbXhqAUoEWd2N+fW1eY7D/L9UffIddzwfN9SXLx7tR8X+I4y0a+tWgD99zm8AcMGDBgwIABAwb8zuNS5FOe51TVy6nh892FUlC3nuM6UGgtViYF9QssbbyfX1IeH0JwBF12H9AG2hptW5rp7i0RQ/3iWHkPyqC8EwIK1RFcixkBdUcIFOCuF7F3qjg8l+vpEXcHD78J86nHKeZH2HKCHU064m5r99LF7UsGl7jP/rzP3+X1cre2/lkZRAm/I4TuReZyw2fu/8h/emE2ItiQt+bKCVtffILxwfMo7yQjb/uKWJaDx+UFpqnZ+dynqHf2aHb2+Mj//KcvtPby2RHv/Dv/t8s3FrjkGj73Gbahs+lZx7rss7ABQnXzTpEDBgwYMGDAgAEDXhy4tO3uXe96Fz/6oz/K3/t7f48su/SPDziB1gaCg7xQeB8gnFOA3qmC+JKfr7f3cEVJVi/xWXaCGEKSkrXBZ/ktK2vWimOlaSZTIVC0EZYuEVxtQzk7uCMEyt1WDdxy17lL3p81VYvWzB54mL3PfoysXuDyEpcV5PND9j772yyvvoKPfMv3vCBUIreFS8zRZe/zWZ9/+h1fwys/9Mvd1/OCxb0P8NTv/SaeeftXs//QG9l78rdvi5hSwN2IWO7vYTveOvX9O6WIuyhOzXF/Lt/2ewF44MO/xmt+7V8xef6LmLbBFSXV7lUm159BOXtXOjneDjZ1uKt39vDaUMyPcbkQ9vsPvwntHFvPfJZiMUeFQLE45rk3fiVPfvUf4i3/4icvtPbK4wMgcOO1b93cWOADP0E7mq51Iz2XuOsTSbGT6QMf/jXe9L//f9FtfWq+v+bH3sXi6gOMDq/f9FhXP/mbvP2f/I1LN5BogUn5In9WDRgwYMCAAQMGDABugXz6L//lv/CLv/iL/MIv/AJve9vbmE6na9//uZ/7uTs2uJc6rAsEpciM53jp8EEynzY5by5cEN/krfStqAb2H3kzBw+9gauffJyjBx85QQyBaWva6S7teMrO00/cEjF0sjg+SaAQpCSf3Hj2fALlgqTELRNDZ+HkeR964y11nbswUdI73/YXnsA0FbZ8QOZyZ4/9h9+0Km7xDm1bFnv386mv/3ba0ZS9T/7mWlF622TUhuu/FBFzCRXMA4//yilS4qw5umnXxP/LX6Pd2r2pmuT+D/86r/nVf0m9s8fRKx/BNBU7X3iCK09+nFf+xn9kuXsVtMHlBcFkt0xkniKe7pDSav+hN7K4+gr2nvgYx694iHa6vVqThPAlVcSd3Htrc/lf/z0+l3wfbRtA0Ux3OHrVa3F5wX0f/S9o23L90XesSLQz99RdJuVP/szJfZignQUFrhhjmiXaWeqde6i3r5AvjjFNzejgOT73zq/nDf/qH9907dlyzGj/OSbXv4gzOdPnn2Z+3ytZJYYphS1GvPrXf4Grn/gQKH1T4q5PJK06mYaAdi3KOeqdPerdq9jxFna8Rb3dcO8nPsT02c/x/BvesbavTh1rdkheLYAgCru2WeVcXSRv7Ol9z+7kYmtrwIABAwYMGDBgwAsXlyafrly5wrd+67fejbG8PBGkw1XtAtatOJY1nEWUbCpKznwrnRfYcsTkxjUgXKgQ7xdfn3vnN3DPpz/M3pO/zXLvfvJqQb6cEYCQFyz27mfn6Sdotq/ckrJmjeB65fQEgTITVdRowrW3/A9nEjGnSImTypR0PdbyFf/grzN57gscP/AwdiTB5jdTDVxYWZMXtJMp2198ivnVB06nSKeMnSc+xkP/8f9HfeXqpdQBJ89H8ExuXMOWYxb3vhIQAioVt+Pnv8hk/xrl7IDf9b/9v/mq+f9D7D9bO9TbezcnSW5SlJ8cj3J2Nf8XIWIuQrilz9z727/B1rXPQwgdKVGUm+fon/8dXv2f/s0q9Plk0bv3mY/wB37w/0y9fUXGm+WMD55Dec/Bax7FjqeAkvtQLTBNRVYtMW3D3pOfQNmWdjyJgfvPEpTCFyNuPPLmjWO6LO6UMi8dZ+fzn2G8/xzjG9dk7l75CK4YMdl/9pb37YXQXz/jbb7ip/86k+ee5vjBh9bm0uUF+XKOchZQKALteEpWL9h78uMcP/AalPeo4Nn9/Ke59qY9IdBCIF8cY/OSqx//7+x9+rfIq/mlrGIXVgT11v9F9iHQqUVtu1KIAqAU7XSHoGa00x1e8+v/+jRZPZqibYtuG7S12PGU8uiA7Wc+i3KO3LbsfeYjjPevrdZ2ebTPzhc/i6mWMparD5At59z/W/8JbVsOHn5jt7ZPEElHr3ot5fwQ3UrrRWNb7GhMvjjusqmmu+x8/lMQAso5lA+gDXY0xWYle0/+Nltf/CyHX/Z6OVZTobwlKE24hQYSz83gTXd+VQ4YMGDAgAEDBgz4EkOFsInuGHAWjo6O2N3d5fDwaJoJcAAAwHhJREFUkJ2dnds6lvOBJ55v2J9DpsHHO/EbX+h9yHt+/w/+L1z9xIfWihJC4OonPsTo8Dr17lWef8M7SCxHeXSDez/xIVyW8/wb3iGZIp//DKOjGxACrhzRbF/puiyFwN5nPoKCrhDfoKxavREHbFEK0UCPxHj4jXzkW77nlm0vK5JtdsBi7xXylrxasHXtc7jRmA99x3v49Nd/+0bi4yQpsdy7j/H+cxTzI1CK2f2v5vk3/m6efsfX8PCv/Dyv/I3/QFCKYHKayZTZAw9T74jlaPLcF9j+4pMs77l/pRq4qLLGNDU7X3iC4vgA4yz25FxHlAfPs/fZj1Hdcz+qbU+pA9rJ1tr92Xn6M1x/9B185H/+M6eVOdWCez/xoZUipN7p4nn7a+HoVa9dBSAHIGQFR696hKxe0mxdWSdJLqgy2qRi2XviY5imxhflioiZ3Hj29Dk4g1itFmw9+zlcOeZDf+I9HD/4iFzz0Q3K4wOyao7LS4xtCCZfhTWfnKPR9WcYHz6/Cl83bS2ff/iNmGrBlc99CuVarr/ubYQsY/epTzI6PiAAbjSm2dpddSgbHd4AxBbr84KgFO1kG4Bidoh2lmZrB21b2ukuz7/+d5HPZ2w/+yT7D7+J//xnfpBycbyyM5Xzw/U/nyD1ziKcV/N4FlF8k1wgWZ+fWd8Xb/pK2bcXye+5jbyg4mif8mifvJ7jTYbPSyFkgHa8RbE4Rrte54UAPstptnbI58co70VFFD9Q715lcc8rKI+udwo/Z7nx2reQNdUphc/kxrMEbU5Zxc5SBJ31+fRcPKVSOmsfnvOsTnv7+MGH2H76s9hyTDvdoZ1sAYp8dsS9n/jvq/k8fPXr2HnmKXRTy/qPJJ3LC3xesv/QG9j5wqcp5sd4bXj+jb8b7Rw7n/8ko8MbqNhlr9q7T54vW1e4+skPUR4fELRZXYcdTdC2oZgf4U1Os71LVi1wxZigiPtBUO/ssbj6IOXh86tsK0LA5yVBST5fsZjJ1+L9zKqF7JNH345ynu1nnuRXvv//wzPv+JpTa+h1V+EPvLE89fWL4k7+zh5wexjuxYABAwYMGPDiwN36nX1L5JO1ln//7/89n/70p/njf/yPs729zdNPP83Ozg5bW6fzRF5KuNPk0yevNVw/hiK+DA8eHv9i95m9T/4mX/cDf+KmRcnzb/gK2ukOeM99v/1fV8XH4Zd9ea9YqSEEgslxWU7IpHAnwN5nfgvTNlx/3VuprtxLVi3Y/dwnKY8PabZ3OXjN61cKkBUx8B3fx40vf/v56qDzitX+93oZI6fIjjNIrVWBfoKUyOolxra4LMeOxjFLaoo3mnJ2JF+rl9jRFBV8j5SQ9+t7n/0oplqy/8ibRDXQL/rPUda4vMC0NfiAN4ZicUzQmSiAso4kmTz3hRXxcfTKR5jeeBZdV1JMKo0dT2OmVr5SB2SLGeXsgMW9D7L99BOniMjJtS+w9+Rv47Oc5974u3HlBFMtuPeTsRh+/dvZevYpitkRdjQBRVcAvv53iV3y9W/nQ9/xntU92Pncp9h67gunVEZ9AuQt/+InO2IUuPrJD8VzSAF/LhEz3uZ/+Lv/K3tPfJTjBx6mnW5THh+sq92KEXY8QXnP7L5XceXzn5K1azIgrBWx2WK+Nkf19h73fOa3sOUkzlUgnx9DCGjvYpEM7XQbFTzKWoxtVnvEa42xLV4bdFRuKO9QAbzWUbWiKGeHMkdbOwSlyZqKdjQla2p0W60UK+1osiJsT5G3W1fWMo/e8Y9/nKufPE045/Njdj/3CdCa5d79ZxLF5+UCpXnYfuZJbjzyFn7hR/4593/sv5ydwRRVgxvVQa95lKce+0bmD7zmFJnWJ75sORY1Tr1Ety1Ba1w5IqsWsuZHU7JqDnGOUch8A205JqsXKOelU5/WQqLoDO1d3OcTCEH2Hwrl3SkCqNsjGc+98SsljH85576P//eVImh+/6uQk5/x+XrJ5PozjA6vY0eT9Xk9ax/WS7a/+FlGRzeod+/h6IGHhVivl0z2nyUYg81L7vnMR/HGgMlox1MhPq8/zejoYHV8n+cEpXtknV3tT9NUolZydkUyNVu7Em4e13ZAr5FVxw+8hp3Pfxq0QrUtGIMtRgSToZyVtQ00W7so25JXC7wxaGdXx5K/O5w2GO8ISq3tk+7eKlnv0x0CYJzl+de/nYCinB3wG//L/11UoCd+T7zjQfg/vHYgn14KGO7FgAEDBgwY8OLAC4Z8evLJJ/nGb/xGnnrqKeq65hOf+ASvfe1refe7301d17z//e+/Y4N7IeJO3oi69TzxfMvBAhaNJ//oRzGH+zyddVaQr/x7P8gDv/lr5xcldG+fO5UGa8VKevscVgXANrptaMfbKG/JFzMArr/+7aD0qkOTdhavDdU9929U4vzSX/2pWwp6BtYUEUlRdaoQ79vl+ugpwpZX7ufeT/0mLssI2lDMj9C2Wb2xN3VFVi0A0N6J/UNr7GiCK0YQAlm9oBlvo52lWBwRTMZzb/jdQujFuTxXWQMUiyOUl0LQZ/kpRYwrxrgs6+ZV6VW+zUXUAbtPfRyMYXbfq1Z5N+XR/irbqU901Dt72EJslkevfJh2vMW9n4xzFIPilbMY23LwZa8nnx0y2b9GvX2Fyf5z4gVViqAUthxvVBkdP/gwk+e/SL19BTveIp8frZ1DOXsuEZNVC/Jqjjc5Pi+xeU7WCEHqihJtW7JqjvaegMIXBdpamsn2at6Us6si1paTtTlS3q+NR9uWfHHUkRhKSIxk3WpHYvFCKVQIeK1X61+FsPr6SgGV5dhyRLE4BpQU6N6Tz4+kuM9ysnqJ8k4IrBDwJiMQMM6J+kdrUBqf52TVUiyZV+5lNDtkcc8rWNz7IO1ki/JISLny+BDTLCFI17SD1zyKy4uNRPFo/znu/fSHcSbn6DWvX88FAiE054d8+Nv+PG/+F3/3VAbTSh1136uorlw9ZdmdXH+GnS98Bu0dzWR7nUyb7nYWxi97PTtPf4ZiJvOS8oRkTrys+fjnsJpjVmSfNwbtPXiPz4RwIrAiQfrKHFsI6amdKNCuvemrhNDsdZwjQH3lXhb3vGL1vOwrgqqdqydUPPL5wy/78kiqHfKKj/5n2tGUG697q5CmRwdn7sOkCn367V99Kp+vunKvEO3L+ZpKL6sWQqAnQgcla5Ug5FN8LuXxmWPLMaapVh31vDaRLFugfH9ty5qX+1Wtq8kCoHW3v0JYPUubybbsYdvEYy3lHpoMlJLnbVzj4eQ+SZ9JRNnWDsHkmHrBjde+lcnzX9youk3qyv/j6+GR+wfy6aWA4V4MGDBgwIABLw7crd/Zl858eve7381XfdVX8fjjj3P16tXV17/5m7+Z7/7u775jA3s5wPnAooXsP3+QN/yjn2D6mY+j65pH884KYpZzfJatipLiaJ/xjWu42AUu2S7yxTF7xwf4GAIub6U92rYEpfFZEcOMlcirghQxo4PnYlEj39t78uMob1HWxQIxQxEojg/Yqy6e03FmoPcnPsT/9MPfhfJSSNVbV1YZIwEojg+pdu5h+4tP8vp//U+EDNtAbvU7S5mmgeAIupTiy1lCLGZNXa0IAJSO1+NRIZAvZgQd50ZpJgfPxbmB4D07X/h0Z8fr5TR9xT/6UYrjfZZXH2B8+LwQLbFIBcTGlue40QQ9P8LUFV4byuMbQmREMqKv/FjdH63R3omSIC/JlzMZJ4pgDNo76QiIEE97n/2Y5OUUJS7fwSxntKMJ7WjKZ7/mD/PIf/zfxZp0fLiaowTtPaZecM8TH0G3LcT5CsbgihHF8lgIgHIshWy1YPuLT1I/eoXF3ivY+fyn0N4xv/dBOZ61a+eQ41eRNMhX91zXS8bVQhQs3qOwhLygnB2syDsVQrxvnqA0IPkyBE++OKaNBN+qC6JtMSzX56jfNVFpsmqB6lHtQjiYOAaiAi6TItl7NCGuo5NEFKCVqKdCEPLEGLzWQiACrhjFAt3LnlNKukJ6j9J6tQd9UVLMjghtTTPdlvyo689iXMvOYsb0+aeFWGhrcF7ykJQGPFm95J7PfGRF6Ghn0fsNV5RaEdRn5QIBor65/gxv+rn3M3n+ixw/8PDGPKutZz/HztNPrCy7pm2odq6yde3zck+dZXR0IxJrUB7EoOmFZMLdF8dmRxOCScRkKyRSVDLpSKwo3yM0XLtaR0EpVFyXejknKBWJZLnf+WJGMAZjG7J6CQTKw+s88OEPrj3Pgjao4Mlnh+z9/9n792DLkru+E/1k5nrux3nWq9UPtYTQEyEhQI0wdtgOAg1zJwiFzQQBDAhCYV88Fp6xhvGVGF8kmDtG5hXYiEEzvmNzHcagwYOxrwMbCM312HMl4BqBsGRJFkgtqVtd3dVV57kf65GZ949frrX3Po+qU11V3VXV+YmoqKpz1l4rV2auPOf3Xd/fL/ev9eulUwnKy2e69XXl+FDz6PDCQ6FfW7LDPc595g9Cn4jj8aTn8I++46/16cKf+bZ3rLg93/iPforh019i99HXYP744zJXszLMK4fyGmeSFXFHeXH81aM1nElBi+OrW8e9NrTlUPpxLnN9MbcbOmeYFBN3vXPLG1mblp8vm2Zo22JqecZkLutewxSn6bR/ThZjKM8VWqG9o8lKGQcPynk8IkStPfEnpPMJ9Widarx+Yp274nUvzO6FkUgkEolEIpHby01Xl/23//bf8jf/5t8ky7KVrz/66KM8+eSTp3zq7uPnf/7nefTRRymKgscee4zf+73fe97bYLRC/38/yst+/N2sfeoPaUbrTB58KdVgzIVP/C5rX/pjmuGapFSElKxFUCJBmvIWpzQLUcn1b8klsJLPmHouQZ+3AChrF6JMiCS8NiTTA5KZpFbIgfI9m+Yo2zB+6gv0uxbVFfnBzvEbc25lp7e2HIE2mKYhPdxn/OXHGV3+IsXOs2x84TPouqIpR7SDEcq1wa3zMrLDXV73ax8UF84R8oOdkE5XLgr6OtsLCRJROnm7790iYFIKKSItAk46OcBUMwlYXRegiisqm+yz+finyPflHm1ekk72WX/ij5luXxLx48h1/ZJ45EJqUVOOSJpKgjGlQBmawVgCx2PjEyrQeyfCirPopmaw8zT7D72CerAmbfWe0eXHUW3TB/V4B2nG3sNfifKOc5/9eJ+GuNxHgLiKZgco60IAKn2mXYtum77PukC3mwOdGGbzEmWtzJlqJsO+fA3vMd3nMhEsVoSYTuTTBoXcfy/ezadBKOrGTQURoJvzjmQ2QWwVVoo4m+R4HynF4aVH8SYlnU9CqpDqU/C8UjKvu3HzTlIkF9lpS/+QoNsb07cFZzF1FQQVg7It2jY4Y/BaiVAUHDrKuV4Q1Z046izJbCqn9h7dtiIgWUnxQ4FuGrKDXZKZBPgqpDWhDTZJSeZTssO9Pg1NAfneVTYf/xTp5BCUkq/7ICB//lP9M1teu8zg6lOc++wfUexd5dxnP872f/xDdD2nLQYoLzu16VCXCQXaWtKDvfDczmnzUgQFa7FZgQs7VibzKV6r8JkW5SzJbLIQoZQIcL1LphNvFbTFgLYoZX6EsVLBsaicoy0HUjDbi4DYuQVB+qubL5JeuL+6nnU3Igpzv1527jdct74urTlK0xYlup6z8cXPkM5m4TmWeZMdyvi4Lh30yHP4yO/+1uJcWrPzFV8ltY20ZuOLIqCj9fG5qkwvyhHcmiCOMG3Frerygr2Xvgqb5rT5gDYfMF/bDGuSPTa3O4OTrItLk1wpmmKIS7KV50t5RzXepCmHvUtQ4alHm1IXyjao7hzhmUZBmw9W1jOvDc6ImKW8I5seYOqa/HBPHImzCRtf+mPyyX7Y+OHl113/I5FIJBKJRCL3HjctPjnnsNYe+/oTTzzBeDy+LY2603zoQx/iXe96F+9973v52Mc+xhve8Abe+ta38swzzzyv7Wialgv/6BdI93eYPPwV2MGI7HCfzS98OtQtqtl8/FOYpgalrhOUqMXXO/FFSdDvuV7wEcSAkMrRCTIQ3pRDuIYCrVfEB1PNsFm+UkS7Y9mV1IlXnUunqyEC9EWgdduE1A+1uMZssuKuOko13sSGQLcZjKkHQ2mzUivtXk7R8V3QqRQuzUL9LBE7OlGmcw3YrKDNByjbMLr8BRFTqlnvDmjz8pTrdkGs1JKqRxvsvvRVkqKVFSLGFSVeSzB5dHw64UM5D7YFkBpL4w3+4Hv+BruPvprBtadJJwdk0wk2y3sxxTQi4jXDMdPNiwyefYrpuQcYXHuaphz1bcW5cM/i/OmCRnGcBDEsjP+ymNaLYW2DqWY0wzX2HnoFg2tPS9raUn8o29xQiFHeBZFARA2FCH/a2r7wtDNJEJx8n47ngwvJ1JVsbZ/mlDvPHOsjvO93TWyKEqn11Paik0tTEQyWxq0PkoOY0Tna6tE6O4++hmptayEweGiKAbsPvwJn0pC6Krvj6Vbq7iwLXP3c6CL0vj1G5lcvCEg/0dXOCS009Vz0U+dwSod1gT5N7biAEsQ6Qt8tCcj5/lU2v/AZtBORtCmGOL30PLbNqlNMsRizJBEXi7Mob+UZA/AupA52bVqIhl3KYjKf4pKENi/xYWwJ61BTDnuXl64r2qKUZ9B1aY4JzWida1/xeq5+xVfT5qX8yQpZ25zsjtcJlNKQ1fVMOYcLjrvOrSNtDKKsX3xdRC8R8cWx6ILIluN0EtZOteJ4POk5PG0NWxbQgWNztRPWmsF4MfeUkrY6R1sM2Hn0NVLTLKx5zXiD/YdeIWltTb24mA8715UDmsFInucg7tbDNRGSXBvWII228qLAm4TDCw/RDMbYrGD/JS/j2Ve+kWde9/Vce/nrZQ319C8xjp0rtMtUM1yWs/vIq6jLIS5Jqcbr2CyjHoyxSdrvgpcf7Cycpo9/Gv/J430XiUQikUgkErn3uGnx6Vu+5Vv42Z/92f7/SikODw9573vfy3/6n/6nt7Ntd4yf+Zmf4S/9pb/E93//9/Pa176WD37wgwwGA/7+3//7x46tqor9/f2VP7cL++8/wfBPPsN8+xKgMHs7jD73KQliFb1jIZlP6WrMnBSUSADg+7f1TTkMzgW76tI4EnxIAKb7QNxrteTecSEtSpxVzphjTpzdR18t9ZiOcDSoWnbp2CxbpHnAEXeNXxE4rueu2nnZa9l96atEZIDeNWCaqm+3D9f2StEWwz49rrsfl+aS7paICDHfOM9s60IIpCRgtqnUYkonB9d11sh1QxDbiTdJysEDLw1uFks93uTggZdSD0ZBsNLXdwfMJniT8szr3szv/NX388wb/hSf/It/hXq0wfjpL6BsI/1nW3GahOuBkr5rar74jd9KPdpg7anPM9u8gDcJ6fQAHZx0LlzLK/nMQnByS3MnOLGOuIx2X/Ya/uB7/m9y/i9/jmQ24fDCw3ilzybEADbLehfMwmnkJDVHKdowl3s3kjK0xQivlNT2cY56tM7VV33NsT5a+/LnSKaH1MM1Di4+ijeGJh+w8xVfxdVXvhGXFieOm8sLrr7qa5ivbeG1oVrb4sprvo7DS49w9SvfyJVXvYnZxnlm2xeZXHwY7TyzrYtU6+ekJlFb9yJGWw5ld7xuxgfn3eLfi6936WWE9LLlfvFKByE19GNWSHqpWnb0hPN0AkooLN0Lmt5jk4z0cJetP/4EHth76BWQpEsus+55nITzq5D22gktvq8Hpp2TVEsW4tJym5zW/fzp0ts6Z5fyjvnGea68+mv7vjx4ycuYr21j0xyf5lTr2xy85FGm2xeZb57nyqvexLOvfIM4cYZj6qHUUmuLAUmooYTWR1xTnVPILkT5o3OwE+WDiCsfWnbxlFIbyS1eungtLjjd1iKaLrmRjj2Hp6xhywJ6/7W1TXZf+tqFsJaX7Dz6Gpl7r/yasHukuD0PLr2UerCG6sR7Yzh44KVUa1siVo3W++LfOE89GHPtK17P7ktfLQJaklGtb/P069/CtZe/XtJdUcFFpvBJKnXM8Fz5qse4/NXfKM9QKZteVGubXHn11608J6vnIrjQElxe9ufyScZ84xz7D71C+jKkYrbF4ER37fSpE9y1kUgkEolEIpF7jpuu+fTTP/3TvPWtb+W1r30t8/mc7/qu7+Kzn/0s586d45d/+ZfvRBtvK3Vd8/u///u85z3v6b+mteabv/mb+ehHP3rs+B//8R/nR3/0R+9IW9zVaxI0bZd471n78uMSTOWlpLoEJ4NNc7RtsEmGWnIn7Tz6GpqhFOhe3vnu6iu+Gm1tX6CY4CJp8pK9R74SM5+z9finaNOS/YdfQZuXbD7+6bBTVMdyqpEO9XYkMBtce5rZ9kU++Rd+4MR6TMtBVVuOSKdLLp2OENQerXMk/ze4JL2uuwqt+eRf/Ct8wwfezdqXP8d08yI7j7yStS9/nuxgV8J7pfBICp3XWoLLY/cjtYTacsD+wxIMbX7+U7KteJoHcadh/PQXmJ5/CX/wPX9Ddnj77MfZf8mwdyt0fa3aBq8UTTli/8GXYU3K6Nkv4pKE6fZFUJJes/n4p0jqmQhNtpXUs2qGywv2Lz1KNtnDFiV/+N0/1NeLAXjm9W/hd975fr7m//XjvORj/wYzn0CS0gzXJfAMfdX13eU3fBNXv/INfXH3arhObkWI9EmCCilKbTHAprm4TkJhYJtlqGoW6rQ4tK1pi6G4jNY2+x0If+ed718pLD/bukg6PSQ/uCbBudb9NZxJ8MEhglJ9vS1J8+mcRn4h3CQp4CVF0UialbIt3iQ885qv43Pf/J8fK0p/rE07z8jubdsPgILJuZeAUtcftzQPosactpRd0bodysq9Kxw++DJ+56/8LZrR+mInx4dfyVt/+D+X3fsuPiJFtif7+CQLBc9rccxo3dfw6fq2K7itQn0smxcAffphn16WpsE1pzrPYkitW9Sk0r5zVi0Eza7vTCNpdC6VXSSn5x6g3L3SF0nvn0frkO3KjtZgWhKjfLBRhppX3WYGHi9OyaxAVVNUGGfVVH36nc1LKfi99+zxvjxl17xy94psnhDGwSWpFMY2GjVvIc0l9TGI7E4bsskBioUor7wT1w/065l2dvV4v3DxaCeplN5pOmGqEyj3zz9Eee0yZu9af422GLD3yCuPPYcnrWGdgN6tJZ0Y2Qlrxd5VqvVtmuG4XzOn5x8kD+ubti3jy1/AphmzrYugoBptyBq8timbByztvrfz6Kux+YB891mZZ1nG3sOvAKX649PpgaQqVjP+f3/pR6m2zve7z1345O+urLfdOBx9TurhGnsPvoLRM1+SNey7Frui5rtXedMv/i2q8UZIQw6ppEacZEfr3Nksx22esP5HIpFIJBKJRO45blp8euihh/j4xz/Ohz70IT7+8Y9zeHjIO97xDr77u7+bsixvfIIXmGeffRZrLRcvXlz5+sWLF/n0pz997Pj3vOc9vOtd7+r/v7+/z8MPP3xb2pKe35ZdveYzEuVIZxNcluOVWSkOi9ZYnZM0koqSHe6vBCUnBytKgokjW7Pnh/vgHW05ZP8ljzI99xJAhKyjO0LVa+vMti6S718lmx6Km6kY8Mzr3tzvRHQSR4Oq1ULUPjgxFDZJMV2B5y5VLexS1ZRD1r78ea6+8o0nuqvgBJGhrpiee4BnX/0mdh59NZuf/xQXPvm7JPOZ7MK1tsV8bWvlfmyaSzrcSxaFmHde9hrGTz1OOptA26C8Z+dlr+UP3v5uuWetV4Kw5WBL4ZluXSSp5uSH+9is4srr3kyx+yzDK0+upILJ7lhSl8erzh2whlJw5ase68Wdk+77N9//a7z13X9RhI5LL+3HHADvGew8veg7rXnmdY/1hY7za1f4+v/n+/rUwbUn/0R2NkOC53S6L+lWSoodKw2mrkCp3mW03LZnXv+WlfOfWYgxKc4YkqZivnWB6fo5Nr/wGZxJaMuhCC9tg2lrXF6w89JX43TC+OkvsPOy1/Kb7//fIDl5CTupTZ2IcdZxe+ar37K6Q9nOM9gslx0PTxmbP3j7u/mGD7ybcu9ZZpsXSMOOfj6kyIrg6nuXESHdy6UpuppJ+mshaVSdO0i5lmxygNOGvYdfwdrlLwahWNLCvBFBiuBWZEko7oSSnZe+GmcS0sk+xf41vEmYbl0EFAcPPMrm5z8l9atCLSq8RXkRtdpyCHiywwav5Wud2KXbuq955ZVepLYFAU23DRjkvkO6m0vz3gVzvb5c5piYmOX9+Dz6f/6/TxZih+uc//S/6/uuF+WP7ORZjzekEPtwnfOf+nfkh7vUow2eee3Xy055lx8nP9zrRcL++PEmhxceWrlG90LgxOfwKCcI6EeFNZemJNOF8DnYeZrZ+QeOCZ9H53Z3fNJW7D/yCqZblyj2rmJ2rpwoVsmEUzSDMeXuFa6++k184c++beXlwomi7tI4HH1OTlrDLv3hv8U09fENAcIGGv0GAk1NfrjL1Ve+Efvqk9f/SCQSiUQikci9hfK+KxhyOm9605v48Ic/zObmJj/2Yz/GD/3QDzEYDG70sbuSL3/5yzz44IN85CMf4S1vWfxS/Df+xt/g//g//g9+93d/97qfv53bDh5Oa/a//XsYferjNGsbrH32E1KoNWxdnR3u47WmHo5BGcx8QjMYk86nVOtb7F96tA8yxk89TrF/7djXBztSL+ios+CN/+in2P7jj7P/kpcv0n+8X3lTfuXVb8LmA8x8uniLfcSJcxr9bneHu9TFiM0v/Uec0mjXrlzP97uQOWySiaPggZeR1DNp9199/w0DU5xbFT46F4xzvOK3fpk3/NJPkcxnHFx8+Pj9fNe7eOR3fvt4X+BJJweML3+Bay97Hb/1/n+yInRc+PcfXRG9bCZOkk/+hR84LsQsuQayw91FcHikHZ07YOUeztjHywFnP+an9Z1z/Lkf+74gDr6c/GBXds2zDTbNjtT6URyef5D9h1/BF7/xW4+5jM7avjYrWHvqcXRTSwqotVLPSWt8mvVj7o1hunWJ0eUvMnrmCfCy+524kYob39sZ2nQz49bNoxO/foZrZPs7ZJN9FNBmOaauVv7dCTii2ihJNcxL2WAgSdl59DXgPef+4x9ik5RnX/lGTF2x9uTnKPav0e1AV483RVjde3ZFWJlvXVjscOc9a1/+HAcPPMrg2aeoxhuyGQCSKjt+6nGywz1MKGjvklQcaKE9XRqqaWpMNUN5T1MMmG5dYrD7DDrsiKa8711GPklXRcNHX8Pv/V9/jHx6cOZ53nPaOLTtqUJsvn9tpe+653/9ic+SH+5Rj9bZffgr5eunraPzKaOnv0hxsENbDHj2lW8U4TBw4jXO8hzeYE6uCDpH5+oJ57uZud2JVTe9dlxvHM7wnGz+ySf4s/+Pd1CN1mnL0WLHTtuI09R7TFtLCvT2RX7nr76fb/iut3BxLT+5LWfgTm0VfD/w8z//8/zkT/4kly9f5g1veAM/93M/x5vf/OYTj/17f+/v8Q//4T/kE5/4BABf+7Vfy9/6W3/r1ONPIo5FJBKJRCL3BnfqZ/aZxKeyLPnsZz/LQw89hDGGp556igsXLty2Rjyf1HXNYDDgn/yTf8Lb3va2/utvf/vb2d3d5Z/9s3923c/fzoGYVJbP/tN/y8N/693kV58m37mCTTJ8KMS9CPYalJWg7sk3/Vm+8E3/lxODkpsJVq4nXHQCQLF39UxBz2n0wdDjn2b85c9jmppqbYuDlzwKnt75Y6oZIPV96tEa1XjzOV3vhu04pV9uSsRZDrCOpAfdjChxK/16O8559J5NPZeUxcn+LQlO12vfaULMsTEPgfKlj/+fPPKRf8ng2acwTX1b+gu4aTHplq+xPE9O+Pelf/8RHvnIv2TtS3/MKLjjjgpux57JNKPNCwbXZJOEZWH1NGFlWYhepI4eF1zXv/gf+zTJY+1J8l4w/dyfeRsbT/wJG19cjG0vpoW0tdslGt6I57KenbZeXu/rr/qX/+jOrJm3IOic6Tyn9NntXo/Ocp/LwjdKke/vLH4WBHftl77hW3p37be8El56PopPt5sPfehDfO/3fi8f/OAHeeyxx/jZn/1ZfvVXf5XPfOYzJ/5+993f/d38qT/1p/jGb/xGiqLgb//tv80//af/lE9+8pM8+OCDZ7pmHItIJBKJRO4NXlDx6S1veQuj0Yhv+qZv4kd/9Ef5oR/6IUaj0YnH/siP/Mhta9yd4rHHHuPNb34zP/dzPwfIDn6PPPII73znO3n3u9993c/ezoGYVpZ//2QLH/koD/6j/5ELH/ltTKg11AzGkjoyktS5Y6lGtyFYeU4ukJsltOfSx/9PXvPP/hd0UzHdunRbnD/PpR2n3c9ZArETj3npq66bgniz7TiNEpid9s3neM5j95NmTM89cMuC03Xbd5oQc1q7nw+h6G5g6Tk5VXA7xVH3XFwzNxRcg1PyhgLgCWPbiWm3XTS8AbfV1XbK15+XNfP55AV4vk6ce6e4aw3w518Jj0bx6bbz2GOP8fVf//V84AMfAOT3oIcffpgf/MEfvOHvQQDWWjY3N/nABz7A937v9554TFVVVNWilmRXtiCORSQSiUQidzcvqPj0mc98hve+9738yZ/8CR/72Md47WtfS3JCrRWlFB/72MduW+PuFB/60Id4+9vfzv/0P/1PvPnNb+Znf/Zn+V//1/+VT3/608dqQR3ldg5E3Tr+/RMNhzUk3jH6tV/m5f/LT+GnSyliN5G+8Zx4HoOPF+RN+81wnUD0K37rl3njP/opzHzK4aVHpMhuNWNw7Wnq0Qa/88474+joeO0luLYHl09VoJ4jLxZx5yYoNczcC9iA2+V2uQ2C63Nqz3P9zO3g+Xa1xWfmOXHWuZcCb30dPLARxafbya06wAEODg64cOECv/qrv8p/9p/9Zyce8773ve/EDVviWEQikUgkcnfzgopPy2ituXz58j2bdtfxgQ98oK918MY3vpG/+3f/Lo899tgNP3c7B6JqHH/8dMP+XGKX2sHaxz7K8O/dxQLNrXKPBW4X/v1Hed0/+QUe/t3fIplPsFlBPRhxeOlRqrVFHZ2rr3wj/5//+z+4I/eylcDrXqq4euj5D0/f9tPfN2jgdmhG2wVcnd+GE90L3GPPY+Q+4gxzb2DgW14L52PNp9vKrda+BPgv/8v/kt/8zd/kk5/8JEVRnHhMdD5FIpFIJHJvcqd+fzrTbnfLBcff+973nppydy/xzne+k3e+850vdDMYFBpjHLNaNqnae+Nb+MMfeYzh/RoQas3OV3zVC92KM9Glh5TXLqNsQ12OQCmyyT6bj3+KnUdfQ7W2yXTzIhuPf5rNz/+HO3JvowFsDTVlYu8a8WmUgG9h8kI3ZIlLY7h2ALeiG2lgXEIzh/3b1bC7CB3+tP0X7p3n8V7FIKLoTb3leTFwg7mngTwFY+6Tn333Ee9///v5lV/5Ff71v/7XpwpPAHmek+fPXTiMRCKRSCRyf3Gm3+o+9alPMZlImPljP/ZjHB4e3tFGvVhIjKJIFEWq2R4bNocwSGGYyi/ll9/4p+WX8/tFeLqXcI7X/W+/QHaww3TrEkDYUj6hzQco2zC6/IWw21iJqSvyg5070pSNEraGhmGuMHfkCjdHDjyyDUX2QrdkgQLKDMozyemnM1RwbgRleVuaddMM7vAAjxPYzM648EdumaERobablrkSMUpd70MRAEoDRRLn6p3g3LlzGGN4+unVtxlPP/00ly5duu5nf+qnfor3v//9/NZv/RZf/dVffSebGYlEIpFI5D7jTKHaG9/4Rr7/+7+fb/qmb8J7z0/91E/d0wXH7xaMVgxzxdx6ausxRjEqPDoB7Avduhc3m5//D2x84TNMty+hvAdtUM7iTdLvQphND0mnB3ilsVku29nfAbyCRCuc94wz2Ktv7KJIWHK33Ga2RpAZyHOgvkMXuUkGQKLBGG7pxsdjGBYKY27Np1IoSI2IDPtnbM9QQ5nDdHpLlz6VBFgfQprC3rN3zdC9IJjw5072QalEDNVISrX2sldErgAP+80dvPh9gNHyDGVJlJ9uN1mW8bVf+7V8+MMf7ms+Oef48Ic/fF1H+E/8xE/wP/wP/wO/+Zu/ydd93dc9T62NRCKRSCRyv3Am8ekXf/EXee9738u/+Bf/AqUU//Jf/stTC45H8enmyFKFUTBvPUaJIFXmHqobfzZy58gPdmTb77wErWnKIelkn9aIb8FrA75Ctw354S5XX/lGSY+8A3RunsRoBoXDebAOpvZkEWpkQBvYv0ORddOI0LMxgC8f3Jlr3CyjEsYpHGbc0rPzknV4ZDPh6n7Dl2/B4Lk1gjwB70Htwd4ZtKzUwDCD2fTOpDMOU3hgC+oatILUw/2kf9xMza8EUBpyd+eW2lEBgxxaL8+kdSKoGCXPrWvgLFMsQcTe6YvshYQmiMmRO8K73vUu3v72t/N1X/d1/cYrk8mE7//+7wfge7/3e3nwwQf58R//cQD+9t/+2/zIj/wI//gf/2MeffRRLl++DMBoNLovSjFEIpFIJBK585xJfHrVq17Fr/zKrwBScPzDH/7wPV9w/G7BWihTTZlC1Xq8h42B5Yn7seDMXUaCBKsnBazVeBOb5STVjLYccfDAo2x+/lMk8yk2zcUN5aG89jTz7Yt88i/8wB1Ljzw3lr/LVDPKHLYVcaloJaD1HuoWGgdZIqJQoiVl5Zk74KJZK+GBDU3VuLumBtWgFNfQlocnb0EQ0x5Jgx2e/TNdfKwRMWcAnB+BUzI2FtjbvfF5BiWMcjDn4HPP3mzLb8zFNRhkmpFxZAlU7d0jQN1qsfg85LG5M95PmgBKnhdX35k+GJdSs6h1kAfxKZiecB5UCYdn2L1ylIkwmcxh/0VUOCo1IpLam9sTJXJGvuM7voMrV67wIz/yI/3GK//qX/2rfsffL37xi+iln2m/8Au/QF3XfPu3f/vKed773vfyvve97/lseiQSiUQikXuUm66Q4twLuQf5/YV1nsZCniiMVuSJxwPb1YvsFfdt4mYC2BRxIFh/8md2XvZadl/6KrY/+3H2XzIMhd9fw/ipx0mnh+i6oi0GXHndm/nkX/wrd2wnwqGB7XEKSPrJ1gAqK/eaahE2vJV/V60Eu4NcAjevgTsgPj26DefGCYezlkI55ndBbDhMQSko0ls8T6iNu3FG8SlD+hoABamFtSFsDsF7hfVQGs8Tu9dPldTAo5swHmrmc3dHxCdjoEwUWaHYGHquTWD+AitPOYvnz3BjEajQ4Jz0pUcyLHMlfW6tuLqasHwqFmvC0b43yFwxWtJYQcayO+etTumURdrYKAfv4KCBYSJ9bj34FK7NFql/XZjf3RtApuDcmsxtW8L02iKrVHFvFTG/6VRgJWMatac7x/U2XvnX//pfr/z/8ccfv/MNikQikUgkcl9zJvHpn//zf863fuu3kqYp//yf//PrHvtt3/Ztt6VhLwaCeQYd3tqb8I8ik6Ds+cy8u13b1J+EYVHC6k4FTCnSj80pYtJRilTSbrSHeS0Nq5c/qzWf/It/hW/4wLtZ+/LnmG5epB6ssfvQKxg//SXaouTj3/1D/PG3fOcdczwVCh7YgNY6SDXew/aapvGOwxnYBJQHn0HewqaB9QISI8FqlsAzOzC7jR1ugGEpNai0UWwO4NnJC+ueKRSsl1A7Rao82znsVDc/nxNgayTPYKIVA+WZ3qDv8iBgaCDPpEiySkBpxSjRoOAQy3oGu9dJgxxn4twqjGa/dRQa5je4gQwRlCp7tnvdLGF7pFFec37Y4IDD6fXbdScZJdJ31ok4szkS4WhSw+EJEypF5rVSso4YLX0wzKVIPA4O59AeQhVcRoaQ5haebYusrYNC3E/awyCR62YppCElblbBGUxJJ2KAQSZzclQEx2IOj191VK18zyiYNCIU+2pVcOr+ToG1QsSrIrRxZwq7c7m3YN6i5s6sqXk4v9Iwu8UfDjlS76o9o/qkkD5CxeLskUgkEolEIvcLZxKf3va2t3H58mUuXLjQF6c8CaUU1kbXzlnpgijnwy/aAeckEPXV81MUOEeEm+qMwk0X1J2WsnaUwoTaNyEV7Or8Vlor1/ZLfxRSKydRkn62f4MpuJnDS89Ba+VzTQvXppIes5zu+Mzr38LvvPP9vO5/+wU2vvAZzM4z2Cznma96jE/+hR+47W6nzo2ltQgFo0IcOEnYalwpGKSGBzdgL3MczMVBYRQMR1JIOtGGQerRWjGZW54qQc2l0+oQ0D/XetwJEgh35kflYX0AKJjV4uhwXuaS9mczXXWpj2dxvRwlRUSfMhOxYZSLA2xjJG1qLEybkObE6QF6J4iuF1B0NialGJYeO5XPntS20khKZJZI+9fK4JxxC1eaCvN+kItY4oDpXP5WiNCcqs5xpWidHF9mUDiYtyeLUCkyP/JU3D5Xb6BUa+DiuqJINNZ5tscK6z2G5198ypHC5+uluPWqWgTTi2vy/VkNzxzIvSsvfdO0Mrc8gAlpaEbS2YpMdglVSH9oLeJRSxjbbk4GQXaUybhpI67BUQl7MxHAlJbrFCnMDhd9pzh5D4hBEP+64wZB1B7nsDnQGKUYF4r10vBy3XJ513JQydqjNWwORDhzXoSlzuVTLjn5Eg1eKbTyrEsJOlwrtaQ8YCxMl+ZIZ8S7mZ/EJ70UWB8u2jGZwpXn+DYkBx7clHXq8jU4S1asRl4GlEGAikQikUgkEonc+5xJfFpOtYtpd7cPoxWp8VStBKYdw8Kwllt8KFTb1BJo1O72b4K3HLAlVoJBi/zyn2gJ2LwPzgEv7oBxEYK0Fvbmi0K4mtU3+CBBcplAkso3igQmc5gjk89ysijQpcx0wgEER0Eqgb130CgJXE0I7pWSgNRV0laH9JkP5xqmcq+jHB7ZhLnVzCpPFtIdr04WqSGdW+uZ17+FZ173GJuf/w/kBzsh/e6113U7pch9grTNO9gLik/GqmBnuzEw8JItSctRQJ4ptPeUmVpxxqXG47zhwc2EeWN78alIDdNaJJbUGDyQJp7tNUeai/A0D2PZNGdzdSQsAu9BEf7OYJDLvWeJZlxYUBKoTqsl8UnBkzunC0oGSaFKUxGJ2vbGrrjO7dHNsSyROTrIZGy3hprWwtZQKrE3DoYhbcdamFSLIH15u3sNjFI4vwat8/211ko5f9VK/3V97VkISudGMMoVSoFH6mBtD2FjkDBvZF55rzg/8kwaacs4X4imKLn+eADDXFGkCqM048xx2MCloQgVLtx0ZWF/Jo6ncSGC6/UWhU4kLg00Vu7NaMXGwNA6i3eeJ65/CgAGId3NspqWNkxEJAJ5tmbN4t5KI3O/DAJvHQrkn1uX+Z4YcR9ZRMQpU+njNDxajRO3zLwCk8i9duJsnoqo7ZQUdl8vJHXZA4l2HCSQZiFFz4nQNExhWoub6NJ6glJQNY7aOikO72S9cF7autHI+iK7TYpDy7mFg0ohbS4LsKFTsiAm5hk461gbJQzD87JWJKxdSjict7Revn9tCrPK45RiY+BRoUZY6+ScWSpCdJoo6tZTu1DIHlnvvBWR5tphcHAic0Mj86bTi3SYC5rjTqmcsJyFNDeL3O/6QPoMZByuXLnBJAnX6MZPhYkwLEQQHiRwZZczvbGwiIAta0lUnyKRSCQSiUTuB2665lPk9pKnCus8Vet7sUchwWjjg9sljFLTiGvIImk6ENIu6rOJCUX42yLXcUEMGmQS3GUaDitJe8mMBGlaMoeoWklpGRawPZLPz1oJhjMtgeQsuBN01zAPykiaVuskoMkzOYdpJLBqXajrgQR8FhFoyizEKC6IE14+X6aLc+OgKMW99OCWiBE4eGJHUlOybnZ3bpJEAsj1EjaHKQ44mDkmlUcrj8IzqUE5cfEcdkGS1ux8xVedaTyHwY1hUgm+kkSC0WYigVmZizvL+4XzrQ0pP+sZpKnqxSilFeulXtlqfHm+pEaTh3GsWk+eKAa57t0ew8wwqZ3sGOXEBeSsXP+JM9gPtgaLQNcY6ZOtIYyDspYYxeZQHDTWS5u7+6pD8XPXHk/p1GH+rQ1E1GobmVsH1UKMdEvHFkHA80raobz8vTGQa44HcH6cYLTsHHlh5PDeU7cwaWU8u2dpiLhmqnohJm0MREAoEkm3AxjmhvXSiQiVy3k6YS3XkjKVGPmM90GY8Y5xodgeG4pEU6SygYArFLVtyeYeG9xYrru3ROb2IIU80RgFZWbYHjnme/JM5MHK4j3Mrczj9UHoXw86EQHBskgx6wSgNAnXycAs2SuHuZYdE+uWQSpzAkI/sfjB0KUFb49k/LUKOy02QfTNZI6A9EGL/EmR9hUJFLkIR9cm0rbSyHNhtPx/q5QaWQpF03hUED6UgkRr6swxaeS+s1TaUKSK1immlWOUK9LE9CLz9tBjvQg5g8GitlvrFJsDz/ZYo1QQqoxmXHockGrNrHZ4YF57Wgt1FuozhXXIOmlDt2aNcul3q6SvB5nMzdzAxsiwVup+TnWMisWPXetbPA7voAptSgGcpzYiVOZZEsRkxTizZEbuyYUXAm14pstERDZrF/OrrsU5lyWwUUiftw1cmYlbsDChTlp4PnQaaspp+UyWyLmyM7712CxkzVfIea2T52ScSSH/m3l5VWadc+1OJBVGIpFIJBKJRJ5vbkp8cs7xi7/4i/zar/0ajz/+OEopXvayl/Ht3/7tfM/3fA8qvqG8aRKtGORQNVJ83HoJiF6ybkmNvM2etRLo5AZGVgLEYSZCjAfmCVTTRcDRpfQc/ZW9LETA6QSf1ouDYGMkQYgOIlJjJWjMc3n77ILboNsKPgvBcJkEMSiX3b1mzeLtexMcNt3nCA6FYQbVALJG3pDXDdjggmhaCa6NFuFLKQmspo2IGONSxKsuPcYjn0kyGGWKMjOyW2DVMm+knWm6uAeCGHRxjV7QKcaa9dLhPEyqlrn1eAX7Uzi8yR0HFbC1JkWCs+DQQoe6M1ruLTcS0HXjo5E0o60RnF9T/det02QJjMtVh9VJ80UhfZun6kigq9gaGurG0gTXmvJSDyk5EJFg2a12dM50IgaIM2m9hEfOqb422bKDpmrEwddRpCKoEIJ1t3TiTsDIEkl1myYiUKp9GW+Q79dOxjDTIsIkRv7vlZx7O9T52RoqskQHAQ62xgmtt0wrzzBc2HnYCe6V7bXgiPFdbSzNvHaMC8jThavr/EhEKmVgK2NZ8yQxkjJVpLoXpYa5YlxqijC3TD8WivWhprYOUsWwcEvWJwnI1waSX9SEWkWPntMo7dgN6aDd4YMUiiE8sqXQYXSmtRwzrxcOyu7ejCYIWpAviU+JVqyVGus0T+w4ZpXcwzzsoKi0iGzWLZxGOgjURosQNW8XTqRhEMOf2RfxYpDA+bGsN40NTq3BYq4aEwqgB8fa+XFC0zoOQvX6LBGRtW48M6PRiUN7+XpiFIlSKDxrA80g06R6MT55kpAnlmnjmDfSp1rJXNseJwwzg3U+9JEiNbAz8xilWC+kA+vEcTj3KEScbIPA2IRcvr1peElQSj/nRvpYa03rHMNcUu3MEeHpKONSUwfxqMhcfw91q8m9Z63UFP16oXBOo2rPMNf9+Deto27hoBaRJ0kW4z+tYedQ1onOxpimkFUyjhvDJTcf8kxO5+LqW89lXmUaVBqewxtoR0UeCqwjgqNF3FPjQpMmGqXcmQpUKULtw4T4e0UkEolEIpHIfcKZxSfvPd/2bd/Gb/zGb/CGN7yB17/+9Xjv+dSnPsX3fd/38Wu/9mv8+q//+h1s6v1LohVJrpYCIiiyFKUts8pTO4+3EgRvFnBlssj6UgTRCBETRumiNopREvg1Tv49yhZ1Z4pU3EGllgCxe4OeGnhoU77ftAtBaziQNJ80kVS1zsk0Sj17FeAlkNSEa9by73NDqdmSBXGrdSKAbAwkmNmZSZCSZfL/g0qCnyS0y4Sg0uQi0AB9pKS1HJun4hJqwo1vDBQoT92Eui+dyKDFYXFhfXVLtE6ISk3KWlGzOxOH0s2SA6+9KP09X3LWjAvFw1ueL16T+8sNaAcujOHaAB5YBxAhQykJ4JaFjBvNl9OC3LXSYB3szxx1K8JaUQcRLIhxy2XaTEjzdMiYFIkIEWsFXBgrzo9W+65z0MxqT20XwbNtPWUW3GdqkTqmVSiI7hfik53KPayXIsSBzD1tZRzKRBx5qRGnlGslyNVAWcIo071zsBPgLqwtXG29OJQ59sNcTVQQML0UdC8T2BquigUX1lNq27AzEfGh738F5zfhoa1UxF7f1RM6PRVzvTBYC/tzR2uXRCDjWRsatoamd6zJeKaUueXqgeXZQ4918ixsDiDL1GLyqOBqyS07iPjQusVzmxoRic6PYX2wOnaJVmwNEx5cq3lyP8zVUgSnphUBWTvYHsIj29JfeIX3UDeenZkIznUrgmBmYHssqWB5Ls9v3cqcWivhnIG1QqGV6vtsrTT9mCWZIU18L6xqrShzGBYeo2WeNUvzqEg1Jjh9GrsQ3fME1sqEi1oxqxepqWWnmrP6vAxyjXWOae1pg5irjWZUWHwtrtCgDWKtvAxo8iA4pSKuGi2CGECaajZKfUPhCaBINNsjmauzZvH8r5chvdWrlXvbGGjKTFx9HhGrk9SwXlh0EGq9DJO49grp/zSsly6IiesD2Wmvc2d2acatlXX21Q/I2tP13bMHLUYtir7XS89D98wr5DqpWQhZaHhgLOKi9zAoRbi7EYbFy4qoPUUikUgkEoncH5xZfPrFX/xF/s2/+Td8+MMf5s/9uT+38r3//X//33nb297GP/yH/5Dv/d7vve2NfLGwHKwYrbi4FEB3weeFEZzfcOwcSg0b6yRAX29F7BgUEsB36Q552NrbJF0dEhEU1kpxK2WpCDiLFCTFxlBjlOZgbpcElEWQWLeuDwAd8NRuy95MgvwyleuaEASVqQScRSrbzu9OHWlo1yBTaOMlbS9RJFqTJZZhKm/eu0CpDLVkYDUQ8UHE2hqqFQfKxiDhwrpnWnl2JrYPxDeH5lRBp+/zDc28dexObn78FPCSzYzklKC3zKTg8LXpIoDeGsClDcNakaz06/WEjJPmy2kkWrE5NAwyzaSS85fGsjsTUaJzpvTBo4E2pEu98pykAWoFm8PkBGfVwkGTJ555sxAVamsZFB7tRLixfnHPRomAow2sDRTawMHMM8oBH1xOOQyQsTdK0o/S4OjQodB2GdIME6NlTi21r0j0iqtNK9A6YWdiV4Q4Fdw0a6VmrTQr91Ykmoe2UtZLx+7ESuqngo0bzKPTxmFraBgujYO4pfSJ/QqSNjncNpwfr86l1olAM28WwtorLsLnnpXnJE3BeEkFa1vYKOGR7dPn/MPbhhbL/lSEU4Jzr0DEqJduKS6uZyvX9QWMS0djPdcmnlkrfbM1EJHKhvpxsnbAemkoM+nnVZHt+Hw6Lqwu2n6i4Jqc8nVWBafrjc241GSJ7+t0KeCl24arE8thHXbP80FkS+HhEkaFwlmFV0v3oxRlpvo6T2ehm6unPf9H+2JlHEJbh1uGnZmjaqRzVWgTSrE1hLWBpq79iug3a1qe2vHszujn9rkxPLSt2TwiVKJaeSHAIl26a5NGHFYOEYU3ysW1h7liY0nUHZacaSeCUtMX3s9v4jmLRCKRSCQSidy9nFl8+uVf/mV++Id/+JjwBPDn//yf593vfje/9Eu/FMWn28hJAXSWSPBxYeTZnbZ9UDqpPF/eWwT481D4NzEwDs4DYyRFba2E7aUA+jR3QJGqEwO6o8LIAxsJo9yxN7E0TtLNRqUmT0KxZquorZzn4pphmMuOT3miZKt1K0Vlu4LIl9YlnatLoxqXZiEa2EUAlRkJZjePuUZCoJPBeqlvStDZGiTYzRbrHOze3HhlelEz6KSg92jB4USt1n85S/ueC11A34/n2HBY1XxxJ6SyHVkFtIWHNuDRC9kNnVWr518EybPaM0it1NtxkorViYl5ECeth0GqWSs1B7njYOYYpV7mil7UK0oNFJnMVa08aaLITCgwfYP2He3To0LcjQSgxTN4c/Po+v1043Yvc3QundTfRueUecMTVx27s1A0muuICUuMS8Mjm7BXOA4rj7MiDI5yqTm2MTSnXFfcPefHlr2ZY956Uq2x3tO0nkR5klKxVujr9vFJnNYvN/v1s3JynyrKXHMwc+zPXL9GrpWacajldFQELFJ1U/e5zGnz6jSB7nhb3XG331IqqC1Wjx/mGedGsDdt+vXoqDuuY700lKmVlwBK1o2VNoUdCLeGch8npaFCSME+A2Uo3D7I1C2PbSQSiUQikUjk7uDM4tMf/dEf8RM/8ROnfv9bv/Vb+bt/9+/elkZFVjkalCyCj7QPJhrn0VpShKpWBIWm7QIQOD9WlCkMS80gWS1ifZo74Ky/9CdaMcg0rV28ie+cUptHnFJZIoGb2bdMKinybT3UleS7DFJJN2udOFIGuVpx7zyz10gtIA0X1k9241yv785yL+fHCVVd87lnYHIT2wvm2dmOWxacnk+Wx/Ol5w3z1krqjaN3SngNF8by/ZsN+paPHxUJ49yyM4PNgaF0rhefEq3ZmVo2y0VfHBVZYckpdQaR6aw8VwHodgqDtyuYPnqezUHK5uBsYsIyiRZ3ShlEud5Nc4pgdPS6ZWZIE70kxCiGmQgNWaJIzb0jIBxt52kvADpOEoHu1rae1razzJEi1VxatzyxG0TkJbeX87L2PbQBj2waEqNPFWnNGbtHKdgeK4pU6nPdK/MnEolEIpFIJHI6Z46Cr127xsWLF0/9/sWLF9nZ2bktjYqcjaNpel2K0HKq2TBXjApNmeo74qxpnedgFuqluEX9j92pY5B16Syr1y0SvVKTx2iPNZ48VWSJCkV9JbKZ1VKTp08RmdOnIB5WzQ1dHc+FRCu2R/Kmv7bQnPFz2RnFp7uBtSLhVQ/A5V3L1emiT7eX0gBvlUsbhmlj2ZlKKmXnctuZW/JEvr/MnXJ+ncT9HMyeRUw4ynMV5Y5//oURYu4015ubd9t93onnKEs0D28qKuuZziVltxvnQSLp3g9vqhsK6+0ZN7srMtgsDQ6Zj5FIJBKJRCKRe58zR5jWWpLk9MONMbRte+r3I3ee25kidD2Wa5BMK8fOTLYK951lwkOrPJX1snNdedxZddJbeg9M5rLteWak1pDz8Mx+wxd2pKbIKJH6VdZLwdzDy45XX2puuwDVpZZkYfe/s6DPvov4XcGN0gBvx/lffl4EroMKXNj9cLO8fQJX5PZyq0LK3SbERG4fW+OER6zU95tULDnkYL1UbI1v/DyfoQQXIGl3Sql+s4hIJBKJRCKRyL3PTe12933f933k+cnbgFVVddsaFbk17pSDpCt02xWods6zM22pLWSJQSvZmtwrcCiaRmqlDPPTd35abuukkvyvMllydCm4dii7x60P5NwtgJLd+/YreOKqY3Nwm+/VevJUNhWbHJztM+Ye1VLuZBrgnRa4IpHI80ORaC5tJAxzWdc7d21XA+ssBfg3yrNda6MQl1SeREEzEolEIpFI5H7hzFHg29/+9hseE4uN37+0TnaPa53skKYVzKxnfyZvv41yNH4pZUd58J5JI0LOjQII60TUOhq/7E0b9irIw65sRbJwSbVeipvvzuW455JudBpGKwap1M7aO4CzSKsqbsp0KlFwikTufW5UV+pGrJ3xJYFXoPDkaVxUI5FIJBKJRO4XzhwR/oN/8A/uZDsidzlV48ObaIXzspuS91JgvLZA7Skz1QtDjZfCtDiPdTcu2uG9fO6oRuUQ0SkLO6RpFdIxwrEWz7wRIep2UqSatdKyP4e1Aq7Mb/yZjeL2tiESiUTuRp6ru3Z2RoN0Hdy1kUgkEolEIpH7h2hHiNyQzpWklO8Li3tkN726DbuSaRGEloWhwxrSM6ZNKCUOKudXd0TynXAlm+EdwwMoULe5Km2WaLZHiqr1x7YVP41o7olEIpHTac5YF08MT4qq8SR5TLuLRCKRSCQSuR+InvbIDfEeGuepak9tZdIkKkweJTulzVuP817cUN7TOo9Wst36WQrGGq1IzfHdkNYGKYMUpk0QqI6cbNrAMIO18rmn3Fnnae1xh9b2OOHcWJGeNfaJMVIkEomcyll/4TBGUrAby5mcs5FIJBKJRCKRu5/o1bgHmNUWGxxB5Vm3C7qN18V7WivCUJEqWudwTmocjTLYc5Ji1zrZ3a7Ll8hTGGQa76Xu00nbry/vnJenCus8VevBu76o+dZAtvY+qGCUyjWsE+EpS+DSJrjQxqPXuF7fHS2groDUePJUkWiFd55RDuaMutZyjLR8X2ctmFu3z62Oylk57fyn9dFzuYebvfYyy9ezzp94/J3uo+eDm+3XF+r5P62dz6U9N1tw/mbH+WbberNjcL3jb9dzcrvm9s0+53e6PcvXPmv3lCakVfuwi2okEolEIpFI5J4nik93MZPacvXAMqnpg4BhZtkeG4aZOTXouVWR4eh1wdO0IibNGses8X2NJuchMfTuIGs9xsh1jZY33Xsz16flFakiDwcfF34A5TicOw7mvm9rmsAjW3A4h92ZCE9Gw2YJGwMYpIaDucfj+2tY79iduFP7brmAunMOpSTIcV5zOG+ZNo79qQhch4dnG6+qWQhaB/NFX48L0wtaJ43DvHUczByTaiG4DHN3wx2kThvno19fPn/Xd8PckRjPwcxzsPT1cW7ZGGqM0kwqt9QevXIPZ8E6z7xxHMzDtcM9H90da1kErFrHtHJU1qOVIjOKYe7IU+nf/Zk79TwnsTdtetHjVgrS3w4hprvPeeP7Od89Dyf1a/cc7k4XfbcxuPHzfytiiKTYeurW47xaEWW7Z+rofOnac9K19+ctl3ctB5UI1Dp85tKGYe0EEepGz8LR858mIJ/2/Hdz+zTB+bTzz5tFe46uYWcdz9Po7nnW0F+7TE+/59PG+YbP+dKaOi5On0c3as/NzLGjP0t2Zjfuj+79hQup1mdxzkYikUgkEolE7n6i+HSXMqktT+5YqhYGCb3bZ28O07ple+xItVkJoFAiqBwNGrrg4yyBWGtbrkwcrVX9desWdmp4+hDKxFOmcg7nYVqDU6AS8E0IFhxo72gBlwBKoawEaPPGkydSIwpUv3Oe83Awd+zOrAROBhIvux61Vr4/LOhFIqVglEtfzRpJ8VPIfexMWg4qUAbGiVrpu3lreXAT8Ipp7ahbz7xdnNO7hmtTSfcAua4740t/p+Dpg4bdQymC3gWARerYHmkGuToWEKe6xXpwXmGUtKH1ck+zxnNhjWPiymnBYSfQLH/dqJZZ42mtwgVxzlvYn8JBLcJhGXYQtBaePvA8vWcZFDb0hzjc9ivHWqHZGppTA+suILXBhTapHE8fWKaVTK5Uy7kOasta5XjJRkKi1YoIuDu1TGsZx0R5bOo5nMFhK2k4Ssn88kfOc7SPdqYNT1x17FeLcVjLKx7a1mzehAh1s+LGshBz9DwHM8e0XggV3fMwyBTjUq/066S2fP7Zlv25HKuR4vuHe57dWcsDG8eff2NkDE8TVs5yn5PKMQltHKaKIlMoFLtTy9MHjtZDoRfz5cqhZ1q3vGTTY5ReEWJaa3lyT/quTECbhQAxbSwvPy9zu+s/Bzyzb5lUHrVUbnrWKA4rx9pAg1MrYrWk6a6uI7tTy5VDB3r1+d+Zeq5NLefHnnFu+uOrVgRbrcEvCW5aOeatCO+1dUtjpsnCT8665UzjeRrz1nH10FG3UJjQRw4OK5g1lmHhMOgbjrP3lp2Zo25krisl339qx3FQQZJAkYJB1pcrB57DquX8msM7tViPDOxXHufUsfbU1rExkEX5NMFtWfhunD/2M6yqF311GgnSXtng4tZdl5FIJBKJRCKRu4MoPt2lXD2QX9rXy0Ugqw2MjOfKgcU6x8U11Ysx8wb25w5tFEOj+qDh2QPL7lwCj7XsxoHYM/sSUF9Y0319pUx5Em1pW7BahCG8BBN5DruHcq0HN0Rg6ISe1sL5dUj1op2tg6tTyyBRbI2Sfuc8pRCXzAwGhaJMdB+lzJzj2YknT2FrsDjXYRAtzo0hN4uvX5lLit7FNYU2StI9DKynmr2Z5cpeyyA37M8dzinyZCFqfWkX9iqpI1Vm0u9nffO+O4Gq9Rgl6YBJCLb357BXOTIjuwUui4mXD6CycHHNU6amD8xaJ2JcZiyX1hfCymnB6rWJONKGuWKU6v7rT+17Disos9Vwb28qItW5MWSp7q9btY5nDmBQw/mhiEWuhUnrqRuLMbA9WF02loWLzjWTJZrDueVgLk6L7k9ioHWKnYknS1o2y6TfRfGpXcveTOZqnmipGwYctp5r+1AWsJ4jBeadFC++eijneWgj69uzM2349GXpo2EqaZPWwbUZHF52vPpScyYBatkd17S2nyOTihPFjWVx86gANa0c+5UnUUpEuKXnYb/yGO1YW3rWn9pr2ZlKEfssiHbewdzClUNwOF6+bZZEYE9tPVmiwDkcQbDy4mwZ5JwqhrTOsz9zzGrP/tzSWnEbeqdpPYwLxcHMcTiHcbE6X4yD3ZmjaS1bo1Uh5slrnmkL2wOwKKyTbw5S2J17PvuU5fz6Qiidzi0zC5lRLBdQc87z9Awmc8vGcPGM7E4dRiu2RgYTHlKjRPSsWtgcaFKpXI02UOLYmTomc8dGmfTHg2dn5kkUDPOF82Z36tibSxG65ZTaVFuck7k8LpIzjecyywLNwUzm6ShfPONaQ6k9VyeO2noujPSJ45wb1X/98r64y8alJltS4p+tLbsz2BotROwUaPA8feDZmzk2h6ofuGnt0RoeWEvQoU+1hlECezPLrLaUqcF21lcF80aRaI9DxO/le2uB7eFivcjTVgSwE3tG6ATyRNM7zCKRSCQSiUQi9z5RfLoLmdWSpjA4YXQaK+LGzhTAkhiNUlDV4krYHmmMUXgvIlFrCcENJIkGL2+VS/yxQKxuLJWTwLNqPUX4xd85T91AFoqHpwYSLdf1cyepcRoUCqU1Bk9qJAB2FnTYrUgpMHi8hZl3HM4tLngcmtZx9VDe6puw9Z0KfzeheHmioMwUqdahxpPjsPY0rUdnco15Y6mdBJXPHnqyxPepG1niSIzswjdrLXjFsFhKV6tF8Ft+LW9DIH4WGgttBVslIgIEjIGndjypgVdeWoh6zju08jgH8wrGXT8hfe1a2J97toauT6s7LVhVIeAeZGGcgdY5agvTSgLjjYGcvG7p3UXzBsCjlMZ7cWx1x3gNqdF4I2LPrHFcO7BsFKZ3I7TOszOx7M8cjZM0pNZBYiy7UwkgB8Uivc55KFPNgbNcPfBkWhwnT+9ZntwjOKegseLkapwIiS444FSYH56uTZ6rB54Lo0UfPXFV+mhruOijBMgzEemeuOookhuny3Xpk5PKMWkWLrD5XILni2ur4sZ6KgH61QPLcHs1rXVSebSHbCmYVkqEJVfL94e5x2jFrLZcPZRxLdLFPSgDiXegJAW1sY4iNb2AcjCzUqDZLwSdQeoYFhqjzam7hk0qx7WpZdZ4JhUoD7qFxDjmFprGsleJEHZsV0sjxz87hWHpGKYGpWAyazkIrrBpI0KuChrHvPU0NVwDNoeWYW6Y145nDuX7G0NPbhYC16zxzGq5p82hJzWa1noap6idZ1Y5RoX096y2TBoRHZ0H7z1KKZyTVLRh2Lxg3liKVD5TtR7vPHXQU7SW43em4pzLE1jLF4LOrPHsz0Wg3houNkE4Op5F6tBKnZrOZq24zNYGnbdtQd16UgXOKZz3GK37ca7bsD54edZaK89+1z4Vns26scytHCsuKY9Wcp3GikuqttKnZaqpG8c8bOxwUFvW8yMLn3Ncm8H6wJLoRXsnrYjMqYZhodDA1HquHEKZQ+McaTje2uu7nghjrg0M8ptLX4xEIpFIJBKJ3N1E8ekuRNKwxB2zjHOeqnZUjbhllJbAqGkltUJpSTmRlBBFYz37lYgnh5WkZqSJiAwiLq0GYg4JsItkNXBrQ/GNNKRCWA+ZkqBi2sAglyC+SCQFo7GeSaUYJZ6qFRFkOVhBeSYN5IkIXEpB7TxzCyUiNpVegr22FQGlTCVdxHkJDttW0nkGCceu0VhoGrBIm8TFIUKLbkQ4yAysZav9W1k5ZxHSWupGBICzUrcwTBYuiV5kclI8vXHS12XI2WlDQDxIpKB63VqyZCFapIm4kxrryRJxTMwaad/qdSX4HKarfWGdBO1JcM6gkODTO7QB30qfNFZSIRvrmLVh3gVHxbLIYFsR7qrWMQiCzf7McvXQgVKkRoS0VEtK38EMNgeLdhq1mFelhsMGDiuL84pJBfiQGqS6+wj313Rbr4ubK0kWbUpbEUzmrYhPe9OG/Ur64iRSDU/sQuNa8lSdmi5nnWd/Julb1gbxJMy1vbkIsLPakSdqZQfGQQKTWkSQTtRqrad2kJ9SEio1UDk5zmjFrHX9XFqmExtKLfNlHsQn6zyHc9vXQ1svZcxdEO5mretrFZ1ULHtnZjmYi/KSAkkqY1EH4boKInaZHhcOnJc6QlaMYCGdFtBBNPHSjmXBqrXyGaVEKNFao7Sk2lkPbQtlEG+9X9Qvsr5bexRaB5el9UxrzyCXGmHdGma6tgZ3jg//NBqaVs7T3X/Veqz3NFaRpyJyV86zNxORKMlC24MYniUO23oqRb+rZ4fRCq18cD9Bmug+Le5oOts8bJqgZp7EOLJOoHEyzmkiY+CW2to6SQe8eigdqFBUrWN/BqNidd1uwvqSGRmf7jl33jMN60JnMFNaowxkRkTkw5lnLfP93LbOM22gdpKaaK3rXW7TCiYzGJSwqRVKK1prUVqcUIdzx+YgCNB+2dN2MgniKovCUyQSiUQikcj9xb25XdR9jlGhpopb/boHpiEoLxJJT5HATWMMzOZw5QD2ZnAwk7fze3OYziSI1CoMuBdxxbX0TgmQ7ykttVf6wI1Q/0RLUJZocTrYcA6jIQ/ihjZKnBEhSJMaKqspKyCfE0fR4nitJX2pcSKydRGKI7g4WLSl55RrdMFllojrSCmNNpoi1cydBNJGybmPnK6/f60WTg191g3GlAgMIpItNSgE5m6pr/t7CaYHz+r3QIJo1CLtzwVHy0mCWCdWLvdFJ9yZBFjuo+CQ0CEodaEjun8nXV8cuUaSyLi1oaHWSdqO87KrYaK6uajJk+ByqSUY7u+p+0e4h1ktAfYgVZLOiQgYeaJorIhv3Xj0fbZEV0fIhja1flHj6Sh16zisREBSWgSqTMsz8uSOZVLbRTu9pF21LYxLQ2IMRkvKV5Yu6uAcVWOMDu05qtKcxe4RUGG++6P30B0TMlKVX3x5d+pxVpwnqdFobUgSw7gwNC3sTNyJu4a11rM/lVpdZabRiUy47nnxhLpuPji/jnzeOo+1sjYsp6f6MNn0keehc+N1Jbq62k4uuOIy3Qkurj+/c3L+Tljp+0mJSFG7xZzs1jDrlp4vFvPZuuDAVIu+qxqPbSX1MwnrUbfbotGyXhwlSSQF8mBmmQan07QWEXBSO5qW3hGqlTjuJjOpB5UkGq01SaIZpIrKwmS+uhr5rr/VYu57oG5kM4ZJLX3SpWXWraSDVq3r54lWoP1i2nTD01hHHYq/Lz/nOvRpFsTfaukHkHVSS9C2sD8TV9OVQ3hqH549FGeic/KsKiX9mIUd66YV2LDInEVPcvrGAlUkEolEIpFI5N4jik93IWVmGGYiNC1jW0drJZgrEnqXjEbcIXUrjiitZGe6TItY0BVFTsyS0GMUlQuihVq6birB5nLgliaa1IjbYpxLHaoyVQxTqZdUIQ6sPET8Rktdm7pdDZ46Wi9v9ZffbGeJpjASeC4H4l1ANLOLWkDXu4bRUri78RKYanXk4iFQLlM5d2Ml5cZ7T27ks62ToNkYKdCrbiQc0F1b7u2Y0KDBB6HMLDWn69emla42R5o6DyJjd8+dIOaOqmYsxMrlvkgSLe6QkJLTfV3qxch1tV6IWUbLn5kV4S4/UsS7Da6oJDS0ahyzWtoIco3uFrJE5sbMSh+zOEQ+W4vjRyFiV5poSQ9aujfD4n5mIe0zOdJJTSPnyYM1KlGLelpHmcxFbC3SMP7GkKaG9dJQtVJnre/7xjJt5NhljFmIHlUrNZ6WsU7au9zMxCiyZPXeVu7BdTXC5EPD3FCmItytoBZ9V6T07rN5HdKrkpOD9iI46ObNcRWltiIG5VqeleTI/MrVItV22nZzcPUqlZX1pkwXKu2gSHpX4srzELSRqh8HmTxpokmTINodEZO9gtqLkJMurTFJN85Lx3Zr2KRZbWsnbk8aqTnVpdw5J24rr7pC3UvHB5HWeklZ6zBaobyMWxvE4MTI39PGc1DJvWWp7oUs60VcrdrFebJERFrtFo7FDqXC858u7lkB0+B8HeZaXFVaU2SGUSHjU4W0WYA8NaSprP+5WZzHBxG728G064skPINdE5fFSus8k3k350M9piAuzVoRkeetbDYAkGWGIjhOJY1Wvp4ocaReD+9iradIJBKJRCKR+5EoPt2lbI8NeSjy2jQWZy2NlZo8iYbxYPHLudaKxongUhgJhJTSZOki6LVWajLBIsisWwkgsiWRYWtoMEbexLetw1mLtRIxGiNv/L3zaCRFyAW3zKhcpB8ZrSgzRW1Ba49G4b2X2lE2FPZNRQhwQfhRSJDcORka63DO9WKLczDKz3aNNJVAtbGSwmeto7aOg8qRJpKWVGYKbxSpkbf11oNONFtDIAg5OgSWZ3lbb5BixZWlD/689zgvbSOkoxVLAbrWilEWBDTAoPDOYVvHtJZUqfWh7lOlskSLKHEkeuuCWEllpE8/NFoxzCXNsHNEOedw3ksdq+Bi8x6cs6iQIoWSNDO/dA+N8zReaod1opRHgvbelaYkjc16acOokH/PQ2DdWjnXrPVYYKOEIhPXXutFFFBOAvi5FfuP0Yu0Qa0luHXO0TrHrHFYYH2waNP6IGUtl75YprZSv8g5uc6g264ssJwuF27mxF25MmMozGI3xKPV6KdtV6x+Mc5GKwaZCqlsvp/z3fOAh0GmVsb5/Fg+e1DJ3LXW0Tp5/p2H7eGSKBHEEOtPFod818wTKudrpVZcgGko3N+NVXfOcRaEydbTthbnLG0rrp/UwGhw/LobAxHhZq24h6x14mar5VnYHC2aZMKzgJfnQfrIobw4q7yHQXFUsFZYQCkfCn57rPMMc3kepq1brJ2NDWmSMCx02JlRJCUXCtvny3XatKJIZU31/Z/QJ0FAS5W0p3egWd+LYUYvhO/OvZkFsWzZvTXMNUkCs9pLIXLn8M5ThVTJ0VJNui7trhNkl4WyUQapF5Gxbq2cx3uKRJyPFnEfWScTtwkvNtbK1XErM41zIsArwrPWOuaN71PmhpkiCS7XxMi63VqC22txrlEhgt+sCvPJWuoz1nyyx6yDkUgkEolEIpF7nVjz6S5lmBke3BQ3xqSWlC2H7DY1zMEoLaktSgplO0JtjyWRoQ3pR3lwaUwaR5nQ746XpyIytFYCSKmnpHlw3TMNxWddcFJdGEsQU7eKynqJZpTUGSk9gKIN25V3wcu4lALLXc2ooGYwKjXDXPW7Q3XpJRtDQ5pYppW8Ke9q/oxzqSvl1Y2vYZ3UNRmNQ7HiVlwTWsE4FWEgSQ0bpaRbSfFe3+8aNS5UX1unsYs/N8Ij48IstM1K8OaRoGxjLO6S/blb2e2udbA1gCKXOjNdvyYG1grN+pECT+NSU1vHYeWkdkzoCw/9rn1dH2nEsVJmIq7YVoQoFeZRqkCF7erbcN2tgQTcWagl1u3iZb24MLbGi2LjqVGkStxqoWY9eaLwjad1ntzAWi6dM6/DVu5K+mV7pNgeaXanIvI5wKeaYSFuKtwixXBrEBxxwenWoZDg+fzaok0AD21rDi87rk2c7HYXas9MQtHs8+vHx8/o1bTIbsdCvNT1WXYylZkIKNaGtDBrsU6EpzwR4fgow1xjnewo13pYVraGhWK4VEAe4MJ6Sm0brk3E1dh9JE+kjtbaQGo9aRXE4KUUKhfEXM/CGZSb4866bgw7l1Wjfb9e1FYKW7fB1XRxQ7NhPbuHUputm0iDVMZHa90LyyHrljLXbA1EIGxcEFk1bBRhp7jcrIjJa6XmoHbijvFgG3mmB5l8vgwbKYBfzEmjyDOZDU1ItdsYGMalYnfi+rVTK9gcKDaGGqP0SmH2USG1oloLiRYhK9GKIqTWJSaMswpiLVKDbS2T45bXHu894wISI5siaKV692Ynp3TF4EGExrVcBqm1MA/Hbg5E3MGrfpxbJ/fdOY6Wx9kkmvWhPDtVs3AgrZeyfjZWRODu2muFjF+Z6pXzoBSDnJA2q5kHZ2lm/GJ9Ce1RBGE+nNN5eWmQBFG0zAyjoiVL5bqTRtbjG2EJIn4kEolEIpFI5L4iik93McPMMNw2zOrFzlyHlWev8pJOFQJ0q0KR7ETqdRBSQjwiMqwVYXesFnASAK6XnZNIS9DgFsHtWplwMey6tbwjWOs8VeOZVIutwoe52GemldQE8SFYWS8VgzwBr5g3vj++SHUotK3IUwmsusDaaB2CUN87dW72GkVi0NpSe8V6bhZOFuQeDitHmcKoSEiSbvcp1TsKtoaKBzYkgLuyZ9mbn018cogAs7Et/VzZrmC39PX2SFPm1w+Ij/Zrnh7f7alINNsjFrtmtV27NXkq7V7++sU1xVrjaa1IYV3wqVBsDmF9oGka34/zINNMa9lFsG59KHolBaCPimFZolkrFc9OPEnr+wLGmYFpK+N6cSwus1krAW5uFONSMy41RaKpmpbDSjHKNVkiNXEaK9eWHeDg0nrSt6mqF3Mpz463CWBzkPLqSw1PXJXdymwjQsMwg4vrMMyOL3tH0+XKzLBWWK7NPYNQx6mbp4NcU3uHcdKPXYrXesGxwuUdSRBX8sQfeR7UqeP80FbKeunYm1haLylL60PDIBdRohNQ8tSwUToOm+AG6mrvEAqjW1gv1Im7+mWJZmOguRJUqi5dUZwtHqfh3FhxbpTSOs9GITsAdvNlXIhTclr5Y8JaquHcumaQaWwrArkGUJr9uaN2nvSImLw9FDFZefoON0phvceoI0I2sDbQrJVdUW/6neVAs1ZwbA1bjHf3LCiKRjGt5YTLYvjWSOOV7NophkU5xlsYD+D8SKPQVK2MZxJSUosE0EEoUyGlOHEczmX3t6MGNKc0l9ZhvdT9vMgS3a+3y0JZkUk6q0LWrO6ey0RRaEWViyDYFTof5uIstFY2B1iedzszR9WIA29ZZN4cai6sGalTF46vreLZaSsitV8UDveIKB0MfPLyw0l9MUmtVDyyrSlTJY5I1faf0xyvuwciPk0rEbli0fFIJBKJRCKR+4coPt0DLAdNSksazrJjR4dALDdwfqxRIfjUSJAwmTnOr8G5ocIYjQ7nrFp5m12k6kjgdvy6IAF0kqsTjx9mUtB5OXjqKFK/cnzrREiqgmDR7YIm7VEM8pOCybNfY1gorh527iDVB7eHlSNLxD0EEuAXY33yOYM7Y73yXN51fGnvxuOUaXj0XNoHel0cvlaaXmC4XkB82jgc5UbtXv160m/xPqkWO4cNc9ULQItAPKSI5ZrxCSLjSSLJxtBQW8u0cpKihcw9A5wbKc6PDUWq+wLOR8ftqJMr0aARAWV7LO6oYWZuqk0gAtTmAPamTS/c7M08e/OT+3Taini0PB7bY8O8tbIzZCLuJ0kjVGwUigc3JUA/aSxPYvH8+Jsa56OiRMfyuKVJwpM7oa1LTr55K+mpJ7mxOmQMYVL5vgA4SNrYsFx89nrPf6L9CcLaQvhodNI/D6mBcaluQrBW/XnOItwtc9qYLPd7ni5ciJ3zyXvwGF6SyK5xVbMoZL8eUtWKRIf0vMU4zBvPvJZ1bVlkGheaSWOpGkdhtAh7jr5W17jUK2O73N/9OBcGpaTQ/SiXZ2r5fg4rccVtDc3x+XXCOl/mi3Vh8Uwt1oVlrLOUCbRKxCHn6X/IpKWMaR3Su+chDzHVsFZq1krTj1GetBjEOBe06qMlwVCIS25aeQZ53PUuEolEIpFI5H4hik/3GKvOFxWKYxvODS2VAx8K2xpClluorzNKYJgnfVDaCT/5Cduv34jTjj8aPJ12fKIltWP5rX7nurpRMHmWaxitTnQHjXJODKxOOqd1HoVmXMCzySmVoo+gtYzPSYHeMmcJiM/CaX1x9OsLEeNk4e6k8TlNZDhKkWgurLESxCYKhoPVIPZ6nz9prNbK1c/fTJuWWR8sKoYniWXeWvZmdiX18bR0udXUV9Wnb17P4XQWbtc4L5/naFudO3tbTxrD6wkRJ7X/usJawjGBU9p8dsG6O89ZhbubYXU9Un2NrMyIqyzR6lg7J5WjapdqO4Wm5InULJOaVeI2FNec4vxQS+00e+M16bT+Pi3t9rDxvYh1Wr8c/fqN1oVlyswwLiw7U88o0zR2MU9So5gox/lMUh6vJw7nqawPbRBsuzTX7giH/FJiEqisxzSQ5FF8ikQikUgkErkfiOLTPchJzhe3pnlm34ozRNG/vXcetkeKtYHut4A/q9BzJzn2Vv82BpNwA3fQGfBdxpk6e1X+5dbfznu5XdzM/cPZ7+Fmgtjrff4sY3Ur/XpSHbUbCTQnpb7eyOH0QnErbb3VMew4q/DRcbPjfKeeqxutR0fb2aUMdyJ+J+q3Dtby4LY8tt6eLGTdDKeJtWcRsU7jrG1YcQKuuOtEqHxw01Ak+rrreWoUw9zLFqlKamh10r5BfiEpElAO2sYzQwTHu3E9jUQikUgkEoncHFF8uoc5GjTcyL1wp4SeW+FOt+O5BNCwKJrsfCg8fZZrpTc+5n7mufb17fr8WXiuAs3dKjidxK209fkYg7uZs65H13dvahJ9diHrZrlVYf25civuuo5BZtgYtDikNp5zIu5rZDfVTMv5RqXGIs7dpc0BI5FIJBKJRCL3MFF8uo+42fSqyOkYrUiNp2qloO6NUMiOfJF7g3tJTIrcndzILXW3Cuu3wq06AfNUc3EM01Ck33vAgw4phEbD1hjyRGOtp3Gyq9+qrzQSiUQikUgkci8Sxaf7kBe7e+FmOS147FJr6gYyoL7OOXLodwqLRCIvHl6Mov5zFW+NVmwMFZtzz+FcnE8e2WggNVITapxLQXfru5TGF1//RiKRSCQSidyPRPEpcl9wmoB0vVTD5a3MFztx+b4WlnMeoz1eQZrIDkxHUd3nsuNbqL9QPJe+uJPXvdeucTdzr97/vdruyO2hSxH03pMYzebQkhpQGpqQelekUKaAgqpxKA15ou6adTUSiUQikUgkcmtE8eke4Pmu7XEjbjaQfC6B51nv+TQBqd/ifenrWjmyRJEa2dFqWvmwvTpLuwDCrLY0zjOrPNbDpJLvJ8i57NL1NVIoNwvnuJV7vtUA/UZ9cTBfpMqMC3PbCs7fSMQ7ylnEMWDlmO4a82ZRz6xI1QtaNP/5ZPn+uz6+0/d/2jN4M/O0a/f+zPbnWitvPPdu1xpzWnrY7RTD7jZh7bT23OzPkdvxc2feur4OoThDZT4kCWyUCms9cytraJ7JTnjWQWKk7cVz2I01EolEIpFIJHJ3EsWnu5jlX9wXBcTdc97V6GY5GrjdrABwFlHiaKB0o3tePv40AWlae2rryRJFbmS783ntmTSyQ9MgDW/TlWKQSuHeBhGSFPDlPUvVQJLIbkyth6qBFkm/W0k4CddEwXqZ9vc8qdx1txw/qZ9uJUBf7guF73c7nNawP2uZNiLEdQORHzq2R5pz4wQFz9kp1TrfX1crjw6XqFpJWRzk9PdwmoCyLBS2ztO0XlJujCLVitTAvPU0LdTWSXuBeaMpM8VaqU/tp8N5S+slqB0Vt3+5ey7Cw83Wy2md52DmmNaeqrFYZA7OU8Mgkw0Fkpsct+vRPYOzZjEvytQxyBV4dea53TrPlYOWaxNH1YJ34nS5NnVsDTXnx8mxz92syHbaGmO9Y3fiZFfDrq2ZZWOoMUqfWSi9Xp/ebkHwZsWeo206rS9Q8owezNxCfC71qT9HThv/5ePPMsfmrePpfcus8hgtxzbWc20q7ctTOYd3srYaJ2uuRo7NE+nLSCQSiUQikcj9QRSf7lLmreOZfcu08mgtv5C3wPzQM2s8F9Yg1eqmgszTgt6jQc+ktovt6DuRKWnJMgVOBKBOAZg3qhcAnFsIRlqrU51F1nmy1B9zJnlv2Z05qgY8fklkUBxWjrWBxqD74xvregGpwygAT91CZuTAydwzqyVArK2nbhwORaY9E6Oo20U/TuaOg0pqj2QKlAEXiuMStgVfDte8lzYaYN5Yqrlif+6oW98H2/uVY63QbA3NsV2wPDznAH257xrbBZaK1i2CxoNZy9MHMgbrhRT1dQ5mLTy566htTaoXfbpWml4MOosYVjWeykonVG7RnkSLa8w0kORqRUDpxxuYVA4UlJkmUTBvHLPKUzsJWItEUbeeaSPFiN3SzleptsxbhdGwXq6KOPvzlsu7lr0Zvfi0XloubRjWnoMIdVqgfzMi40nP1TCzN9wpbFo5rhy2TOZQLdnucmMZFmB0wjDXNNZTtx7n1U0JKyvXqi1XDhyth4FRaCPzZW/meebAojW9YHDS3F5eS3bnlst78v8yAZ2GudfA5T2HMS0bhVlZM06aI/PG9yLbWdaY3anlyqHkco0TmR/Wwc7Uc21qOT/2jHNzbE0a5BwTYq/nJpxV/rptPWuf30jsOYvIpJWjdQBqpS8O5o5rE8u8DTt4evAKDirLWuV4YCNZEaDmrePqoaNuoTD0439YifC7MZATnEW825lYJjNPHp5tFGg8zjuuHUCWQZHIPVsPTQXTuRQcL1LFIH9xuBojkUgkEolEXixE8ekuZXdi2Z97ykSTdJYcD62S4Mo5x8YgPTEAOIuYNMws41LRWrUS9OAb9ivwXjFI6AO3Zw+hsp6tgSUzum+P0p7JXIJ8o83SeRxZqhnnBuv80lbkimktAWYW7q0LlC7vy3nKXIrMdpsctc6zfwCttZwfKxHinGdaQ6Y9NhHxwwPOSTBaGGgdNHPLQQWJUqRhN6W6gbr17NRQpp71UpxQTet49lDOkxqoLeAV01YEQGUl5a5z90DoYyR4enLH0cqtL6JRD03rmTcWlGeYGiaV68etaiyXD+Q8pwXoF0aL7faWnUZd3zXWczD3OCuBXmYUSkNrPVcP5T5GuQTrKBEUhhq+vOfYOYTNkVRKVwquHji0DsGgu74YZp0IoW3jcUqh/MJxVXuF9p4ZUKSeg5lld+aDk0n1xx02nlnryY2nAg7nYa4oxbzxtE4KE0/mMC7lPhaCm2JuPYm2jHLdC7D785Y/fsYyqSBPJCXSenj6AA5ryysucGYB6rRAf1o7DmtPu+QmOyrELDOpLU/uWKqWledqbw7z1vLgJicKUNZ5rk5ark7k/4VZCIhzC9NDsK5le2iYWxmvIvEUmUKhVoSV6wXy3X0+s285rGGUaxoPuVIkiUI1Lc8eSrs3cpkTroVJ66kbi/WOROl+LfHe8/S+wyvYGhicFwFFGxGErk4sjz/juLAmY60UWGuxKMpEJOZujngUz04se7MWfcoa02GUCJpVC5sDTRqEaW2gxLEzdUzmjo0y6Y83Gqa1o2odqdE3FHSqFmZTS+0g05o0uHq8lzVnv/IY7VgrTxYUl9dnB6eKPbPGMizciuB+usjkcQ7WhwoT8lalLyzXDiWlbZSrflmqW3j20JOZlgc3s75tBzNpyyhfCFJawyiBvZmlbh3rZYL3i90VnNf9HOvEwdY6DuYi0qVmed7JM9N4aOuQXof0n/Vy785C+SJJp41EIpFIJBJ5MRHFp7uQunXszzypgjRZ+gU8vDm2FnYmsFY4skQfq1XUWHVDMenqxPPknmdzAOu56YOeL+2Ju+IlG4pUhwBEebSxVHM4mMPF9UUQM6sdu1MRax5Yl1SppvXsziFpLNZ5tNJ9exLtaVpH4xTDfLGTkbXy5r92kFhJjet2166sp3KwO4UscaSJxjkRV6z3NBNPmsg1nJcgepBJIDivPBpFmiqsc1jncUrEhGCcQmsVdleSYLlpYVZDmYXtwJ30TYoEYpkW94BGgicbvn910rkW5DgUEl0C8wq+eNWxXjislxtz3vPsvpzr0ppGhb7QGsYh2Lu679ge+F5YqRoRnvKledENU+NFCNPdsa2lCiLVtCYojNLGWe2ZNdLuTQWDVL595UDGeG0A5wbXF8O8FxGvceJSW3ZcJdrT4mlrj1aeZw+d1HxJFQ5PngR3jlKkynM4d1g8tYVEa4wSV0TVeiZzOXfVyDyTmxA3U9PA/szTri366Mkdy+EcxqWii3tTpGj8wczz5I5l7YEbL33LQp9zbiGYVY6dqSfLFAOtejGosnBt4jAGtger5796IMLTskNLG1hPwzgfWIbbx8WKTkB0DtbKVUFgoD1XJ55nD2GcObTSpImi9TCvRcTNE0XVhjo7+cnBfHef09oxbz2iy4R1xHnSxLM7Eyef16ATMErjDSgHB5Vjf+45v+Z7t9TBzLE3lyLSk9rKmPUWIUfbwqGFc84xzA1N67kyBZRHDSzKL9YM5yz7UxGAL6ytrjG5dSG9VvpmVlsmDQxT+gLXSsnmAdbJ16eNuBQLmUyyo6UVUWS9FIH0qKBjre9TcxOtOKw8RkE2WPSpUrI2uNozqTzD3K84Uk9yOM1ri9KqF8O6sS215+rEUVvPhZG+rsiE92itltY++XrdOnZnYAxkiUIr1a8xZQZ2Zrl26BnlDcbosAYrilNMeAbP/szjaWjtQhArEhHWd6fgvPRd3Th257A5WD2HdZ5Z2DbUdD9etPwiYhTUtay9rfNkRCKRSCQSiUTuJ6L4dBfSWE/jYXBCENBY2X66BWaNwyvV1yq6MnEoD+MuvcrDkyeISdpA0rTUrQgtyVC+XrUWj3x2WjnWy0V9j7qWNLbWyVvtLDEiOFjfp0IppdBakySezDgOK491jnNDjQrpOrPaM289eRA7HOKIqK1j3kiqWydIKaV6xwQWDlu44D2JkvuvWo+1HpPAlpFAr7Xi2DmsPYny4lRSjr3wRt86+X7TihjROLm/xEhw7F3QvIJIo5QiS32fsiL2g1CAXEuNElcDTt7cew+ph7ILOsMb/WklhXXTBNYycXpMq0U62axxDI44XwYJTBpJhRoXCdaJaHa0TEvn9sqCsNgF3AoRLbSH2sMglwDPes/+DNrQnkSLa0362vVimjE6jOnJYpjzXsag9WBU71YBqJ3CNuIEUyicEzFJE1ItnScNKTeZEQfNrOoCZY9SYe4hTihJaYJhIe31EBwgkkJYt4481RzOW3ZnkCXHnT6JknPvzqQW1I1qQFWNCDKS9hfq0+A5mImmOMwVJgyG0TAADivL3sSxUSyEh1ktrsPBKZcbJDCp5bijNaBmjaRMnWSiaZ0n1dKf09azXii0VmRIemknRCThGOv8iem5XeqkDS4zKfbsKFKNVVDPHdNK5roJD0c3v7QB28DMwYMGlO5ERRmnqpF/rxWLNNP9mYjlqRahVGuN0g6jROTcn3o2hwvz4O5MxOdBurrGlKmnto7DuSMPa5hDnmGTBndieGaDCRGj5dm3S+mbVUiRTRMVBGwRhrVWzBvL5V0LSwK6wVE3UOaqf9aWSY2koLZ20d8npbPNaxGHiswzyB2ZXjzYdSsvH5yT58yEfMeTRCZPWHd0cHtah1aKWSO164quL46gFVw+gMY78sTTWqmrdm4NElYXGetk3Z7WwQmVLdxe+zPHwVye3XEuImHVSgodQJK4/mdPE0TANDj4Ui3zDcI4pbImVyesh5FIJBKJRCKRe5soPt2FKEJtjiNf797eOw+Hc0iVJ63EkVHVUvOnSOWtvNZKHEYSNzGtHGuFRGGtddRWXACzRkSnPEQAzkOpCEKNw2ips2KR4ML5ReDWtnKeIpG6Otb54EwJga4Kb8LxJEqLMyCR3eNq75gZhSPsPDcX8WmYrd639xI4a8Kb8iAIpYki0Y5pDcOkS92Rrw+cY2/uGaS+d8w4L+KM0pLmUQFVHQQw5/Fa2utZFLztUmMSJQHcbgXGhlQdJfdcy0t/hpnUScqTxa53vZMJT93QpwOa8MpfKUcaRLlpJSmAy4Gs1kCzqHPU1Zc6qh9oLQ4f51Zr1mgtglAdHB8m9FHbelovopRiIWZVraOy4oqorfy/c4fAcTFMUiNFgEqVlzS9MH+N9kxqESyKVDNpxB2ltCJFRFTfyv1WrWd/Ko6HNLidMmPJUxkr7xFVIVn0ayd81I0XF1rn9goB9PgU20Su4aCGaeMogqh4kiBjndRz2p1JAB8yFqkaRDBIpT6VbAW/+HyhYd5K33XBsw2ChtHHLgOEWlZ2VRDpUEr16VnLOB+Ky4d2ybGL7ydK5tukaiUd1cMoP77cd6mTh5Wk+U4aqdNljAiiRcj4bD1k4eFY7q7WOVxQiaZz1ws4jYO2lWN8UIGU0ljnCJue4RUi+vbnknZ3jiWtNbZ1eB/upz3aN/JMzxsRXFKj5dkNImyfrhz+Uizcjt1lbRBuwVPVHuc6J5vncGYlldHDeuHRRgXnGxw2kCSruzOucGQsT0pnSxLIE4e1nsnckQ0WYn/r5Fmo7dLzz6rING8sSi0EMOek+HlrpYj/tJJnP3UynsvUtWVnIut8pmV9qJTMbbsPD2xYymT1Q9NK5qikuC7uw3rHYS1rX5mC9gptRIQ6mEGZOTbDveGROno1QVwTYbxbhwzglsYtEolEIpFIJHL/cEo4FHkhyVNNmUkQu4xH6hLtTAENg0yRJ6C8Y28G+3MpDFy1smPYPKQw+EbcBnszy7SVXd+qNqSUsRr0aiWpNZ0DAIK4EQJkxSJwc3TiTVc7ZTVi0EfO0+G8uIBqF9JYFOSJFsdVLYHf4p49DnE6pQpSswjQlFLkhlAbyOG9l88qcYp4FFUtwWmWiNCltSLPJEjqhBKUkjpDRjPOpd021DtyXhQVrUJtkvDH+cUfpSTFSYV0vKMaQmu97OZ0JKBKQ8qW0uJOa+yqxFC3YBLITOcEW1x7GQWyK5SW+lLiJvMkWpGYIFopgrNJnGouOLUKI2lu0N1vEHzc8fvQWga9u37nSmsRRxv4UJ1GhJvaL0SbVIsg0ZEoGR/nLFen0r4spIUmSpwT+zMJRNMEETjoxDUv4ov1OCXOqW7qmdDOo2JNPxZBPJ3OPTtTx+7UMakc7ZFO9T48LxUkiSZNNKnRmHCtpulSGY+MRSgI5pe+bpR8xp7SKOvC/Doh4M6Mokjo00z7MQxCtHehrlUQRjqq1vL0XssT1xxP7Di+vOt44lodUuBW7/OgsuxNZZIME7mHNDwDh/MwDxXMXdfXix8bzsn3vQ/10IKTJUs0SRBPmnbhyOtENuvFyZQtKXKd43B5zejWGFgV2oxWvQNu+fgyMwxTEUm1WhKAwxo2aeS6najqkX49rOW5SLUikUeJg0rSF5NEYbRGa40xmnFhIPTNScJT44LzLgxo3Uqq3UnpbDo8G1UrQt7yuPguLXhZQFPQOMfutOXKgePKgePqxLM7bbk6lZcNiVmsqYmSnwsi/i0ae1DB1MJaCcNCo42hzBO2BrJe7k2OrkWOSSPC9LLw1LaOw0qE7DZkVyZGkRrNoOxqWkHVtDjn5F6cPM9ZKnNNhUXVK3GM5Ym0PRKJRCKRSCRyfxF/w7sLMVqxXkqdj2ntsNbhnMNZEZkssD2EJDEhZUWDglklQUxXiDYxElwd1vTujc5B5Dx97ZEu6C0zwyCRgGs56DFaRJ7u3KnW8rY9vKFvkKBkOc3JGIUKbiiWA+ZwPQtkWvX1ltJEs15I3aJZI8KGcw7nxMmCg0Gxeg2tFGkiLhTnpdaNQ4rVbo01aXBqaSQNSStPbiAxuhdyUiOfH6aKYabYHok4legu/UMKOytglMJ6HvpRyTGjQlLBUiOClnOhBlQv9ISaQcEVlS4F21lmGOXyvU4M6j7TOKl/tFkudiY0WpGaRbrZ8nzpHDhlBrDoi62htNG14hxpWqkZZkOAPCgW50lCCl5lg4hwZHU4KobpUChadk+U6/uQklWkkg6qg2DYpQg1rcc7EaisE3eUDwXRB8H11vqFe8UFZwahv32YU87KOTK6/pfGjsuEUSZpbEdxzrMzCwKV0dRWnCK7U8f+bFWAaqy4OYwKImFwjWWJCL4emaeNWx2MppXnbrnIcpkZhhlMj4jJHdNWnHNHU+66z24OJDDv+qxdKuAvBb1hmJt+Xswby+V96dssFcGoNHBQK57csSsClPOew5mcr0y1pBJqEYZNeAZmdRDHfEgzXZrbFkkFzRIpmN71k1KKjVKeC3EmydjXVoS7MpO6Yp2wZLQiTxfPQbdmKCcuPY9cQy9ZYjJRMGXcwvHWedl1MIFp62gai7OWprHMakeeiNgiO8jJmjSpJV15VOh+PeochjbMm2UnjtbynDVO3GFN62it/F2HHNFBpnoxPjQPfeR5yhJpZ1crbVn/VEHsK9LF3DZa4Z3j2UOpm5QacZ2mSvr4YAZOub6PskTEdJA13TmH8455Y9mvRfQa5atiUplpykQcUJOqwTlH2zpmjaTJlsEJZ52jsY7Kyu6k0KVrquDWU6xlmnEhz/G0hnkrYvEwkzk5a2BvuvhzMA1rQRbFp0gkEolEIpH7kZh2d5eyVhqsk3oa3fbqbSjsvFYe2RnLScoTIR1jFuoIKSVpV5WDxC9qGKXGUCaWqxMRsfKl9Ir1gWZ/Ltd01qO8xQZBJc9lx7GuwLTXityEtK5Mr7xZT7Si0jA0oLUWQQEwSgo161ZSr1IWjp4iVYxzCd7mrRcXloc8lWOGaefukKCxcR5jFGWqGeWqF0O0UljnKVNYKy0+1HnSoZAwzksNnSykETpPquW6Hgnmy0KK3zovgfOwlL+NgqwVkayrV9KJLKMM9qyISa0B5SUlzHoJnIvsuDtsrVQcVCKwiYvE9dccl3B+bfURzVO5t6r1K7tdgYhuWSK7+ilkLlhnKFIpdj1tglMmg/OjIDAocZfhRVTME8ekglEpQan3vnfH1RbOjxciiQvpPmUiHZAs7VBmnaJIZNCd9wwyjfUSxLYerPXUToSw7REMcs3hTNI4Q110SalqQ80a1blJFn3hPRQD2CjNiiPmgXXFLIhKg2zRRztTuf/tdciDAOm9iF2TuexQ1hUEd53z5IgelGhNmUodptaGukuhj1on82K7UGRHguftsWHeWvZmdqXw/7QVUXJ7fHp9mwvrCVXbMglimArzrUEC+e2xITcyL+rWc20iu72tlaCUJjFSeNxoday4eRvEnW4/xSTRrCPjVDuklpmSdaIOTqvGu6VxluezyFh5/hUiZKwPHNbKDxqPiCXZUETMIjErzqE80Uy1pKKCElFJK3IddrBM9crxJqjA41RS9JqQdroxMIxLxe7EyQ6fVvprc6DYGGqM0lIDKwg+eUIvmCyjNSQhfdB5L29qwnwZZSLuTmu3ct+plsLww+Xd4lRXOP24ADXMNfPaUjVBbFfSx1UrLqFRsfqBqhWxb5irPn3XK0mzThOPcou6V0rBubFGa6nZNW1kTa2CU229hLXB6vmzRLNROq7NRITu3GajIGJZD1cPWzr9ct6KsJSlInAuL29aK8aZpCWvlzIfnPO41jHZFUGsL8alpF8HRuZTJBKJRCKRSOT+I4pPdymJVmwODYNMM6lcv321UaHguINELd7Id1tUe70ITp33JAlQi2ultaCV7bcEz1I5rm4tiVbBdaC4uA4o+UwXuJ0bQZYpcBq7lN+zMZDt7lskBUPrRfCUGsW5NUOqF7vvOa+YNzAupMh36xaB0lqpyVNJUcmUR+mwBXtwdAwLvRAFtGKQemonrp/0SEGdNhS1LTOD9h6H1BYKcQ7jXDNuZWes1sIcacPmIBQ01hpfyIVntWVvFvoCIJE39E4t0u5AgqYN5AJd/SOtZGv6VEnguTJuXlxYW6WcONUS3CVa2rE9NqsiY5gXg1yKRHcBtEKcFmOjsFaEK4cE54PMgUq4mGrmje3rWHkPj1+V7eLrVlxhzkufrZUhFahxvXBzkhimlfR9o7t6Ooti03kaUt/8QhQcpIvi15WHgZGdxdYKRWKMpAkmTtxRYU7XTgLfDS1uuqpdBPGDTMQ2qUGziHq3xynWNTy975m1C3EuVVJM+dw4WSpqLzsEzp1nWntGYYeyzhWnEYFmOSUuTyTQrqwIE7WSukTWw7hQbAyPC0nDzPDgpux6tyyIrBecOM5HP/vwtnz2oPJ9PaMuoDchDa5MYXfacjCH3IQUsuDC6vrnaHFz76VflBYx2IR+HhpF0joRaRU8vGWYt7A/lwLsXXG0LBXHGogQk2v6NaBupWbUxrqWYuuhNplWissHlqpxFEajtRT8bp1nmMP6UINT/Vy9kGp251IbyVqP1rLj29yK4257tLrGyL1q1gq5z85tuewsE+dTSAfE0FgR7hLdCUUyB4ss1HezUjepmxdeK3LnKTMVap91taTUMYE5SzRlKulpoyM/cbNEk2eOAo9HM2+X1yEFXoUdQ6XG2KyBjQLyTIVURkK6oGwo4LUmM17cnYDRCWVq2Z05WiuNzI08EPKcH3cYifMWLo0VeSoO3CxJeGK35slroe6gDH//s8TOZT4up2SCiLHDHC6ME7JEHGeX9xzah/p+R9xe3ouDd/nrkUgkEolEIpH7gyg+3cUkWpHkksIkhbeleHcnFPTBBxIEuvBvrwgpKBIsSbHpbscrCTQ3B/BQBpVVIkzpxRvucZlSJPpY4NY62WVp3vg+MCxSBUq2ap814E8InrxfuE/q1pMYKDJNZkL6C12Rak3eKjIjQbBeEgEkpUihltw1idaYoL50AZoLwVCiYZAbWmc5rESgyJJFRGO04tDDpQGsl7q/nyzR/X02Vv7dBOHOdelg4a2/Cp9prFxzfaDQSlOH3dc6skSzPZJaW3XjcJoV58jmWHNxzeCX0hJPSsE6Oi+6AHqlaHbCytc9hmkVioIbvdJHD296po24Iro+e3BDxK1pJdu6X08MkwLyCtWAU4rU+H6HMucVw0RTOc/e1MpcCN90zrNWKorUSP0yv+inda2oWxECautICO4NFXLvvFuq1aVJdKh3daR/LqynrA88O5M21ErzNF71Drmj9HV3wg5leaoZFYrD2pOHNNXuukWmsTjGiABGKAo+zBXjUlOckjI0zAzDbXOqIHI9TvvsYq5KDa0s0RSpY72ANNF9IfaOo8XNU6PIUoVrvexcF4QFhaThOeXQiaJINYNcMVwSw7vnX1wwIt7Nl9aAtVIFV6NcIwnOw9bB+aGmcaHdK2uGCL9aLc8lLSLnkeNlrTq9v+H0/u2el25XPqPCTp5BDE8SzSgTB+gwNxSppPx17tFnDx15qjg/SvvaZ53rsmplTJJ80ffjUsvOfJWT3e40vYA2KjTbIymWfvI6tFq0flxoEmMkpRkZs6pVKMQ5qJRaSU9OjGZrqMkT3xewv7zXsjc/uc+mrYii64NVC5Kz0hajoUxk/UuBeSVu23kNLndS+85J/SalZF3MUxGI543loAp1t/KwGQQiZGVGUjz35pI6OjLx15NIJBKJRCKR+4n42909QBcoJcZQpm0vpvgQ9DRaMUhEbMoN4BfOmzwV8SnL4NxQUjU0EpRZ5xl6VoKS5XSho4HbQgw7LnoMs0XK2GnBU+fQyRJxySzfW4dHBWFi1cmwONfCXTPIWHH7dNfIExEkEq1ODfoOG0+WSFB4NEWqu8+qdUzmkGeaNHFM55J61hXWNWqRIpYmsFEm4s5pPPNGLcSKVJGninXnOZg5Jp17xYhz7EYB9I3mxY2+fpJTKk9grUy4qNXJYsjodNfI8nXKVPVb2rdO9cJFZsBqhbJA2NGw28FRikUrykzcWMuOEKMVZabIEi9fz+HcKF0RBLt+Tc1inI+ymKsp3svcvDLxXFfqWTpNV3etalxwhEnalUNE4DJRXFjTjPJV4fIsnFVwOstnjwqRqVYMc3mWjwpPcLy4eZZo1grF1Uk4l14ItA5FoxQbS2mEy2J492xOKkfVKraHisYu1oDUaKa1o5PturQ4eT7F6Xb6mrGYS9c7/laROmqeqlUMMrUihhdJsuLQQkua6LSRtMONUq6vu7zhfkw6od/3z2KRaLZHsuvdskh/PQHt6Ng2iWLe6l6s7c5ttMI6J7X69PHdMNtQxHt57txsGmjdOuaNYrOQuk11cFdqJWmzk0rW1Unj+10GO2F4c2D6ttZWUii79NnEiJhvkXNaL+nOezNLkZkTn+1IJBKJRCKRyL1JFJ/uMU4SUwgpP0UiYkaKpIRpL2+fq8aTJ4phnqwIEycFJWfhNNHjNBHnqEOndb534yzXLercN3l6PHXlZtw+y599LkFf3z8WUEqKRzvZEtw66VfnxGHWetlZCqQNeapPFegSrSjGmvXy9gbQN+K6fcfp43+WeSE1qLo0x1Xnk209WaoZpEcdbgt3yPUcIWUmNXrOcg+nsXC4aDJtxblxwm01VgSzZCm/brnuWrO0SVyqPWulZq28e4Lj7j5HJmGY1ezNYf2E2jmdq2V5bDeGhtpaJpWTmlKdK8/7E9MIj/b7ah0ySa10XuoT5YlikOuwS+HxcTvrmnHa8beDo3XUjOqcbupEh9YwB9Tpa4dW3eYBq18vEk0x1jctoB1/+XBS+p7ioIJc+5AG6I+tqcvcbBpoYz2Nh0GuMImhbV3vWFJaUSSW/UpeQuSJChteyEYDg6X6V6rrHwe+Cc976KvGh/MZSWedVp5Bzl3zjEUikUgkEolEbo0oPt1jnCSmeC9pdFpLwASLbQyN8pRagmrnvQgn1wlK7gQnCUmnuXFOc7Kcdq4bfR2eW9BnQ8CZBEfAvFk4epoWSR9D0k+cldSTs7bn+RCcTuIsYs3NsjqWC7dKoj3OqH5nvONzQASfIlVsj/SZxcHneg8mOIJ2Zqu1fbqaNU6FIs7L6Ur6eN01Sa/TN5ynLyQ362opEs2FNXpX3uI+z+bKu5Xn+TTuxFw9jeu3/7jjymjFwVz6yZzQzG5zvBOyO4Fbe/6vJ9aOC8WwkNTGs4zBzaSBKhbORZC0xGWKVIT4caHIU7Pi+Fy+9jA35CbUvyqkYLnzch+phsM5jDNYHya04cXJcvpiJBKJRCKRSOTeJYpP9yAniSmNNUxrCQ1q6/uizF1dJRN2kFpNfXnhAujn6mS5FW4m6PN+UTC8aR2NC24nL/VMHIATIUohQkptHYPrJ3bdl5w0lt4rbOWPpQB1LLtDnqsj5GYZ5BrrHNPa989B58Zay1cdGkfv7Wiq2d3Mcylu3o3Bc3XlvRDP8+3kZh1XkqoH5oQu6hyld+L+r+/kNBShqPfNjMHZHI6aMrPM6uOuK4DGKTYGcD4U8z/t2kbLcfNW0uwIO24qJWtoEjY8MFqh/fH0xUgkEolEIpHIvUsUn+5hlgMirX2f/jRYcnV4VEh9UaemvryQ3C3tOEpXxqUrNN2GWk9dBZsupca3EjxZt9hV7cXK8lha5/v+O6s75E47wroaYFkiRfOP1uR6Lo67u5XnWtz8VsfgXuuno5y1/UdT9U5KHb5T3EisvRNjsFwDbVo7crP4GVN14uYJ9fOO4j1sjgzWWp45EDeeCj+T0gS2BrA21P0mFSelL0YikUgkEolE7k2i+HSfcDT9qSvKnV2nKHPkdBaFiEWgsKGIe5KwIuJpRJSq7fFCvy9mlvvv+XaHXI/rFc2/H7mV4uaR07kTqYY3y/OdvrtcA61aqYFGXwPtRsjugooyh/UW3Ez6LjEwymQXvESLc+pG6YuRSCQSiUQikXuLKD7dR9zrqS93G527oW4ljRFPX0xZq1DsHUm9e7G7nk7ihXSH3Ij4XERulRfbens7aqAZrWitY9JCkSvWkRTY1MiaMLVQWodWhsr6F0SgjkQikUgkEoncGaL4dB8Sf1m/PXTuht2pbGHe7ZKWKPqt1RWQhaLOrY0K1DJ3gzskErnTvJjW21utgdaJ0a4Bb2CQiWvUOflbOZg3nlnjyIx6QQXqSCQSiUQikcjtJYpPkch1SLRikCnKzJMZqe3UdIWfkJSTMpe39pHjvNjcIZHIi4Hn+gy31jNvIM/AKIX1isR7LB4DWC07i2rlGeQ6CtSRSCQSiUQi9xFRfIpEbsAgNwySlgMrRXGNY2nbdXH0DBI5LnIyUXCKRCLWe6yHQiuSVOOchyV3U9NYKiebAEThKRKJRCKRSOT+IopPkch1aJ2ntZCmUE9Be8iUFMjtCpE7YH0AebQ/RSKRyKkYpTAKWi+/fOgjApNXitTIcZFIJBKJRCKR+4t7Jlp+9NFHUUqt/Hn/+9+/cswf/dEf8af/9J+mKAoefvhhfuInfuLYeX71V3+VV7/61RRFwetf/3p+4zd+4/m6hcg9Rus800p2bBtnsJ5DmYBTUDv5u0hhvYBB/kK3NhKJRO5uEqMYZgoHNK3HO4/38nfTehwwzBSJieJTJBKJRCKRyP3GPSM+AfzYj/0YTz31VP/nB3/wB/vv7e/v8y3f8i289KUv5fd///f5yZ/8Sd73vvfxP//P/3N/zEc+8hG+8zu/k3e84x38wR/8AW9729t429vexic+8YkX4nYidzlV42VnNgNZqtgew6iAMoXMyJ9xARfHkBodC45HIpHIdTBasVZq8kThlaf1ntbK31558kS+H9N0I5FIJBKJRO4/7qm0u/F4zKVLl0783i/90i9R1zV//+//fbIs43Wvex1/+Id/yM/8zM/wl//yXwbg7/ydv8N/8p/8J/y3/+1/C8B//9//9/z2b/82H/jAB/jgBz/4vN1H5O7HOtmhLdFSZNzjMUqKi5ep7M7kFAyTkIIXY6VIJBK5IYNcYx1Ma0/rFoJ9t7nDIL+n3olFIpFIJBKJRM7IPfVb3vvf/362t7f5mq/5Gn7yJ3+Stm377330ox/lz/yZP0OWZf3X3vrWt/KZz3yGnZ2d/phv/uZvXjnnW9/6Vj760Y+ees2qqtjf31/5E7n/8V42tPPeU1vPrIZpI7VI0rBF+DhXjEpD2yrwPqaKRCKRyA1ItGJcajYGmlGuGeby98ZAMy7jDneRSCQSiUQi9yv3jPPpr/21v8ab3vQmtra2+MhHPsJ73vMennrqKX7mZ34GgMuXL/Oyl71s5TMXL17sv7e5ucnly5f7ry0fc/ny5VOv++M//uP86I/+6G2+m8jdjlLgnGfaepyF1IgDyjmpS+KAVEnKiDaQJjFgikQikbOQaEWSK4rU472stzHVLhKJRCKRSOT+5gV1Pr373e8+VkT86J9Pf/rTALzrXe/iz/7ZP8tXf/VX8wM/8AP89E//ND/3cz9HVVV3tI3vec972Nvb6/986UtfuqPXi9wdGK1w3lO3IiyVmWaUgVby0MxaqFtQGsaZIk81PpZ8ikQikTNjtBQXj8JTJBKJRCKRyP3PC+p8+m/+m/+G7/u+77vuMS9/+ctP/Ppjjz1G27Y8/vjjvOpVr+LSpUs8/fTTK8d0/+/qRJ12zGl1pADyPCfP41ZmLzas8yilKIyk3SmgSBXGwKzxFBkURnZmylOFQsW6T5FIJBKJRCKRSCQSiZzACyo+nT9/nvPnzz+nz/7hH/4hWmsuXLgAwFve8hb+u//uv6NpGtI0BeC3f/u3edWrXsXm5mZ/zIc//GH+6//6v+7P89u//du85S1vubUbidx3eC9v5dNCHE7WeiqryBNFkXiMARBHlHWQJTFtJBKJRCKRSCQSiUQikZO4JwqOf/SjH+Vnf/Zn+fjHP87nPvc5fumXfom//tf/Ov/Ff/Ff9MLSd33Xd5FlGe94xzv45Cc/yYc+9CH+zt/5O7zrXe/qz/Nf/Vf/Ff/qX/0rfvqnf5pPf/rTvO997+Pf/bt/xzvf+c4X6tYidylKgQIUikGm2RhqxrkiMVCkmiTYnOrWk2jI0yg8RSKRSCQSiUQikUgkchL3RMHxPM/5lV/5Fd73vvdRVRUve9nL+Ot//a+vCEvr6+v81m/9Fn/1r/5VvvZrv5Zz587xIz/yI/zlv/yX+2O+8Ru/kX/8j/8xf/Nv/k1++Id/mK/8yq/k13/91/mqr/qqF+K2IncxRitS46laMBoyozGlp2o8rYPKQm5gENLu4g5NkUgkEolEIpFIJBKJnIzyPpZJvhn29/dZX19nb2+PtbW1F7o5kTtI6zzTSsSmREuxceehth4NDAtFntwT5sFIJBJ5URJ/Zt89xLGIRCKRSOTe4E79zL4nnE+RyAtBohWDHKrG01iwXlLxyjS6nSKRSCQSiUQikUgkEjkrUXyKRK5DohVJrrDO473UgoqFxSORSCQSiUQikUgkEjk7UXyKRM5AFJwikUgkEolEIpFIJBJ5bsSCNZFIJBKJRCKRSCQSiUQikTtGFJ8ikUgkEolEIpFIJBKJRCJ3jCg+RSKRSCQSiUQikUgkEolE7hhRfIpEIpFIJBKJRCKRSCQSidwxovgUiUQikUgkEolEIpFIJBK5Y0TxKRKJRCKRSCQSiUQikUgkcseI4lMkEolEIpFIJBKJRCKRSOSOEcWnSCQSiUQikUgkEolEIpHIHSOKT5FIJBKJRCKRSCQSiUQikTtGFJ8ikUgkEolEIpFIJBKJRCJ3jCg+RSKRSCQSibzI+Pmf/3keffRRiqLgscce4/d+7/eue/yv/uqv8upXv5qiKHj961/Pb/zGbzxPLY1EIpFIJHI/EMWnSCQSiUQikRcRH/rQh3jXu97Fe9/7Xj72sY/xhje8gbe+9a0888wzJx7/kY98hO/8zu/kHe94B3/wB3/A2972Nt72trfxiU984nlueSQSiUQikXsV5b33L3Qj7iX29/dZX19nb2+PtbW1F7o5kUgkEolETiH+zD6Zxx57jK//+q/nAx/4AADOOR5++GF+8Ad/kHe/+93Hjv+O7/gOJpMJ/+Jf/Iv+a9/wDd/AG9/4Rj74wQ+e6ZpxLCKRSCQSuTe4Uz+zk9t2phcJnVa3v7//ArckEolEIpHI9eh+Vsf3bAvquub3f//3ec973tN/TWvNN3/zN/PRj370xM989KMf5V3vetfK19761rfy67/+66dep6oqqqrq/7+3twfE358ikUgkErnbuVO/P0Xx6SY5ODgA4OGHH36BWxKJRCKRSOT/396dx0VV/X8cf80AAyIikoobiutXc99wl9x3w0qNSk3Nb4ua5TeXyq9Wmksuaa5pKlkq5pZmfilzKZcWF1wxzAXEBXENRGSZub8//DFFaokCA/h+Ph48HnDvuTOfyzmH4X7uOefei/j4eAoWLOjoMHKES5cuYbVa8fHxSbfdx8eHX3/99Y7HxMTE3LF8TEzMXd9nwoQJvPvuu7dt1/9PIiIiucPly5cz9f8nJZ8yqESJEkRHR1OgQAFMJlOGj4+Li8PX15fo6GgNO5eHhtq9SOZSn7o3hmEQHx9PiRIlHB3KQ+fNN99MN1rq2rVrlClThtOnTysR6GD6+5EzqB5yDtVFzqG6yBl+//13Spcujbe3d6a+rpJPGWQ2mylVqtQDv46np6c6lDx01O5FMpf61D9ToiO9woUL4+TkxIULF9Jtv3DhAsWKFbvjMcWKFctQeQBXV1dcXV1v216wYEG12RxCfz9yBtVDzqG6yDlUFzmD2Zy5z6fT0+5EREREHhIWi4W6deuyefNm+zabzcbmzZtp1KjRHY9p1KhRuvIAmzZtumt5ERERkb/SyCcRERGRh8jQoUPp06cP9erVw9/fn+nTp5OQkEDfvn0B6N27NyVLlmTChAkADBkyhICAAKZOnUqnTp0ICQlhz549zJ8/35GnISIiIrmIkk/ZzNXVlTFjxtxxKLpIXqV2L5K51KfkQfTs2ZOLFy8yevRoYmJiqFWrFqGhofZFxU+fPp1uqH3jxo1ZtmwZo0aN4q233qJixYp8+eWXVKtW7Z7fU20251Bd5Ayqh5xDdZFzqC5yhqyqB5Oh5w+LiIiIiIiIiEgW0ZpPIiIiIiIiIiKSZZR8EhERERERERGRLKPkk4iIiIiIiIiIZBkln0REREREREREJMso+SQiIiIiD2z27Nn4+fnh5uZGgwYN+OWXX/62/MqVK6lcuTJubm5Ur16djRs3ZlOkeV9G6mLBggU0a9aMQoUKUahQIVq3bv2PdSf3JqN9Ik1ISAgmk4nAwMCsDfAhktG6uHbtGgMHDqR48eK4urpSqVIl/Y3KBBmth+nTp/Ovf/2LfPny4evry+uvv87NmzezKdq864cffqBLly6UKFECk8nEl19++Y/HbNu2jTp16uDq6kqFChUIDg7O8Psq+SQiD0wPzRTJfOpXkpusWLGCoUOHMmbMGPbt20fNmjVp164dsbGxdyy/a9cugoKC6N+/P2FhYQQGBhIYGMjhw4ezOfK8J6N1sW3bNoKCgti6dSs//vgjvr6+tG3blrNnz2Zz5HlLRushTWRkJG+88QbNmjXLpkjzvozWRXJyMm3atCEyMpJVq1YRERHBggULKFmyZDZHnrdktB6WLVvGyJEjGTNmDEePHmXhwoWsWLGCt956K5sjz3sSEhKoWbMms2fPvqfyp06dolOnTrRo0YL9+/fz2muv8cILL/DNN99k6H1Nhv67fWApKSlYrVbc3NwcHYpItkhMTCQ5ORkPDw+cnJwAsNlsmM3KZ4vcr/j4eBITE7FYLHh5eQG3ElAmk8mxgYncgwYNGlC/fn1mzZoF3PpM8PX1ZfDgwYwcOfK28j179iQhIYENGzbYtzVs2JBatWoxb968bIs7L8poXfyV1WqlUKFCzJo1i969e2d1uHnW/dSD1WqlefPm9OvXj+3bt3Pt2rV7GpEgfy+jdTFv3jwmT57Mr7/+iouLS3aHm2dltB4GDRrE0aNH2bx5s33bf/7zH37++Wd27NiRbXHndSaTibVr1/7tSMsRI0bw9ddfp7tB9PTTT3Pt2jVCQ0Pv+b10pfiAjhw5wrPPPstjjz1Gv3797mv4mUhucvjwYbp160bjxo0JDAxk7NixAJjNZmw2m4OjE8mdDh06RIcOHWjUqBHt27dnwIAB2Gw2JZ4kV0hOTmbv3r20bt3avs1sNtO6dWt+/PHHOx7z448/pisP0K5du7uWl3tzP3XxVzdu3CAlJQVvb++sCjPPu996eO+99yhatCj9+/fPjjAfCvdTF+vXr6dRo0YMHDgQHx8fqlWrxvjx47FardkVdp5zP/XQuHFj9u7da5+ad/LkSTZu3EjHjh2zJWb5Q2Z9Ziv59ACOHTtG06ZNcXd3p0OHDpw5c4apU6fSp08fR4cmkiVOnDhBQEAA5cuXZ9CgQZQoUYLg4GBatWqFYRhKQInch8jISFq1akXDhg2ZNGkS3bp1Y+vWrdStW5eTJ086OjyRf3Tp0iWsVis+Pj7ptvv4+BATE3PHY2JiYjJUXu7N/dTFX40YMYISJUrcdqEh9+5+6mHHjh0sXLiQBQsWZEeID437qYuTJ0+yatUqrFYrGzdu5L///S9Tp05l3Lhx2RFynnQ/9fDMM8/w3nvv0bRpU1xcXChfvjyPPfaYpt05wN0+s+Pi4khMTLzn13HO7MAeJqtXr6Z58+b20U5xcXGsXLmS8ePH89RTT7Fq1SrHBiiSybZs2UKNGjWYPn06Li4uJCcns337dgYMGECzZs3YsWMHZrNZU4VEMmDPnj2UKVOGMWPGUKBAAQCefPJJgoKC6Nq1K9u2baNw4cKa2ioiWW7ixImEhISwbds2LSeRjeLj4+nVqxcLFiygcOHCjg7noWez2ShatCjz58/HycmJunXrcvbsWSZPnsyYMWMcHd5DY9u2bYwfP545c+bQoEEDjh8/zpAhQxg7diz//e9/HR2e3Af9F/sAoqKiOHPmjP1nT09PgoKCGDt2LEeOHGHYsGEOjE4k80VHRxMVFWWf/26xWGjZsiWff/45586do2fPngBKPIlkwPnz5zl9+rQ98WSz2ahQoQLr1q3DbDbz5JNPAijxJDlW4cKFcXJy4sKFC+m2X7hwgWLFit3xmGLFimWovNyb+6mLNFOmTGHixIl8++231KhRIyvDzPMyWg8nTpwgMjKSLl264OzsjLOzM0uWLGH9+vU4Oztz4sSJ7Ao9z7mfPlG8eHEqVapkX9cUoEqVKsTExJCcnJyl8eZV91MP//3vf+nVqxcvvPAC1atXp1u3bowfP54JEyZopkU2u9tntqenJ/ny5bvn19F/sg+gZcuWAOkWPHN3d6dz58707NmTHTt2EB0d7ajwRDJdx44dcXJyYvny5fZtJpOJ+vXr8+6773L06FF+/vlnB0YokvukXWxMnjwZ+GP9tBIlSjBnzhzOnj3LypUrHRylyN1ZLBbq1q2bblFYm83G5s2badSo0R2PadSoUbryAJs2bbprebk391MXAB988AFjx44lNDSUevXqZUeoeVpG66Fy5cocOnSI/fv327+6du1qf7KUr69vdoafp9xPn2jSpAnHjx9Pl+A4duwYxYsXx2KxZHnMedH91MONGzduu/GWlhDUM9OyV6Z9Zhty33777TejWrVqxnPPPWecOnUq3b5Tp04ZTk5Oxtq1ax0Sm0hWOH/+vNG5c2eja9euxo4dO27b5+XlZSxYsMBB0YnkTnFxccarr75qPPbYY0ZISEi6fdeuXTMqVqxoTJgwwUHRidybkJAQw9XV1QgODjbCw8ONf//734aXl5cRExNjGIZh9OrVyxg5cqS9/M6dOw1nZ2djypQpxtGjR40xY8YYLi4uxqFDhxx1CnlGRuti4sSJhsViMVatWmWcP3/e/hUfH++oU8gTMloPf9WnTx/j8ccfz6Zo87aM1sXp06eNAgUKGIMGDTIiIiKMDRs2GEWLFjXGjRvnqFPIEzJaD2PGjDEKFChgLF++3Dh58qTx7bffGuXLlzd69OjhqFPIM+Lj442wsDAjLCzMAIxp06YZYWFhRlRUlGEYhjFy5EijV69e9vInT5403N3djWHDhhlHjx41Zs+ebTg5ORmhoaEZel8ln+6TzWYzDMMwfvjhB8PNzc3o06ePER4ebt//+++/G/Xr1ze+/fZbR4UokiX27t1rVK5c2QgMDDQ2bdpk3261Wo3mzZsbS5cudWB0IrlTRESE0aFDB6Nly5ZGcHBwun3t2rUzpk2bZhjGH589IjnRzJkzjdKlSxsWi8Xw9/c3fvrpJ/u+gIAAo0+fPunKf/HFF0alSpUMi8ViVK1a1fj666+zOeK8KyN1UaZMGQO47WvMmDHZH3gek9E+8WdKPmWujNbFrl27jAYNGhiurq5GuXLljPfff99ITU3N5qjznozUQ0pKivHOO+8Y5cuXN9zc3AxfX1/jlVdeMa5evZr9gecxW7duvePf/bTff58+fYyAgIDbjqlVq5ZhsViMcuXKGYsXL87w+5oMQ2PW7lfa4q9bt26le/fuNGnShHbt2tGoUSOWLVvGkiVL2L17N6VLl3Z0qCKZwvj/hcR/+eUXBg4cSL58+WjatCktW7Zkw4YNLFmyhL1791K2bFlHhyqSa6T1q/DwcMaMGcOxY8eoXbs2bdu2ZceOHSxbtozdu3dTsWJFR4cqIiIiInJflHx6QGkJqD179jB16lR27txJvnz5cHJyYunSpdSuXdvRIYo8MONPT69La/NHjx7ls88+Y+XKlbi5ueHq6sonn3xCrVq1HBusSA5ktVrTLVwK6ftV2vfR0dGEhoYyZ84cnJ2dyZ8/PzNmzKBmzZqOCFtEREREJFMo+fQ3jh8/zoYNG4iOjqZjx45UqFCBMmXKAH9cKNhsNkwmEyaTiYSEBBISEoiPj8fb25tChQo5+AxEMiYiIoKlS5dy8uRJ2rZtS/Xq1e0J1LQ2/+eLaKvVSmpqKvHx8bi6utqf1iUifzh69CizZ8/m5MmTNG7cmMaNG9sfWHGnfpUmMTERIENPERERERERyYmUfLqLw4cPExAQQI0aNbh27Rrnzp2jQYMGDBw4kHbt2gHp72QnJibqAkFytfDwcJo2bUqzZs2Ij48nNjYWi8XC8OHDefrpp4H0bf769et4eHikG70hIun9+uuvNGzYkC5dupCcnMylS5c4ePAg77zzDgMHDgTS96vff/+dggUL2kcYioiIiIjkBfrP9g5u3rzJqFGjePrpp9m0aRNhYWF88sknuLm5MXz4cL766ivgj0c9Tp48mZEjRxIXF+fIsEXuW2pqKh988AFdu3blyy+/ZMuWLSxcuJDGjRszcOBAlixZAvzR5qdNm0bPnj25fPmyEk8if2PevHm0atWKzz77jBUrVrBw4UKGDBnC4MGDmTZtGvBHv5oxYwYNGjTg/PnzSjyJiIiISJ7i7OgAcqrIyEjq16+Ps/OtX1GXLl3w8fFhxowZjB8/nsKFC9OoUSMAjh07Rnh4ODdv3sTT09ORYYvcF8MwOHHiBHXq1LEnkxo0aICPjw8Wi4W3334bb29vOnfuDEBSUhIJCQncvHnTkWGL5GiGYRAZGYm7u7t9m5+fH6+//jpubm6MGDGCIkWK0KtXLwB8fHzw9fVVvxIRERGRPEe3Vu/A2dmZKlWqEB0dbV9zA8Df358XX3wRZ2dnVq9ebd8+f/581qxZQ9GiRR0RrsgDc3Fxwd/fn2PHjhETE2Pf7ufnx7///W8aNWrE559/zvXr1wF48803WbNmDSVLlnRUyCI5nslkolmzZuzfv5+IiAj79vz589OvXz9eeeUV5s2bx7lz5wB4+umnWbt2rZ4WKSIiIiJ5jpJPd+Ds7EzDhg1ZsWIFW7ZsSbevefPmdOvWjUWLFnHt2jX7ejc+Pj4OilYkc/j7+xMREcHatWtJSEiwb69cuTJdu3bl66+/5vLly/bt3t7ejghTJFepX78++fPnJzg42J5kglv9p1OnThw+fJgLFy7Yt3t4eDgiTBERERGRLKXk01+krb8+ZMgQOnXqxPPPP8/WrVuxWq32MvXr16dEiRIkJSVpvRvJM3r27ElgYCDDhg3jiy++4OrVq/Z9devWxdfXl6SkJAdGKJL7NG/enO7du7N8+XLmz5/PqVOn7Ptq1KhBqVKlNM1ORERERPI8rfn0FyaTieTkZCwWC59++im9e/fm8ccf58MPPyQgIAA/Pz/Wrl2L2WzG1dXV0eGKZIq0Nj9t2jRMJhNvvPEGJ0+eJDAwkHLlyrFo0SJSUlI02kkkA9L61fDhw3FxcWHevHkcP36cfv36Ua5cOebOnUt8fLym2YmIiIhInqfk0/9Lmz5ntVqxWCycP3+eiIgIli5dyuDBg5k8eTIjRoygYsWK/Pbbb3z33Xd4eXk5OmyRDEtr62mPck9r86dPn2bnzp1MnTqVRx55hI0bNzJ58mSqVq3KuXPn2LhxI4ULF3Z0+CI50t36VVRUFF988QXDhg3Dy8uLdevW0aZNG6pWrUpcXBzr1q2jWLFijg5fRERERCRLmYy0eWYPmRs3bgC3Rjrly5cPgJSUFFxcXIiKiqJWrVoMHz6cN998E4A9e/bYp0v4+/tTpkwZxwQucp/i4uKwWq0kJyfb1yhLu1COioqifv36vPjii4wdOxaA6Ohojh8/jtlspkKFClpcXOQOrly5QmJiIgkJCVSqVCndvqioKBo2bMizzz7LlClTgFufPWn9qkiRIlovUEREREQeCg9l8unw4cMMHz6c06dPU6ZMGZo0acJbb70FQGxsLOXLl+e5555j9uzZmEwmreskud6hQ4d4+eWXiY2Nxd3dnebNmzNx4kTc3d25du0axYsX5/nnn2fOnDkAavMi9+DgwYP07t2b69evc/PmTZo0acK4ceMoW7YsSUlJFCxYkAEDBjBnzhz1KRERERF5qD10yacTJ07g7+/Pc889R9myZYmOjmbhwoW0bNmSRYsWERsbS2hoKIMGDcJs1nrskvtFRkbi7+9Pnz59qFWrFpcvX+b999+nUqVKzJ07lzJlyrBq1Sr69OmjNi9yj86cOUODBg3o3bs3LVq04ObNm7z22msULFiQsWPH0rlzZ1atWkW3bt1wcnJydLgiIiIiIg710CWf5s6dy7Jly9i8eTMWi4XU1FR++uknevToQd26dVm7di3Ozs726Ugiud2KFSuYNGkSP/zwg/0x7mfOnKFly5Z4enqyatUq/Pz87GvWiMg/Cw0NZejQoXz//fcUKVIEuLXAeJs2bbhy5Qpz5syhWbNmDo5SRERERCRneOiyK2fPnuXq1atYLBYAzGYzTZs2ZcOGDfz444+8+OKL9u0iecHFixe5evWqPfGUnJxMqVKl+Omnn7hy5QqDBw8GNNVOJCOuX79OXFwczs63ntuRmJiIxWIhNDSUfPnyMWzYMGw2G3BrMXIRERERkYfZQ5dh6dSpE+fOnWPFihXArSSTYRjUqVOHuXPnsmnTJr7//nsHRymSedq2bUtsbCwfffQRABaLheTkZLy9vfniiy/YuXMnISEhDo5SJHdp1qwZN27cYPLkyQDky5eP5ORk8uXLx8aNGzl27BgzZswAlNgVEREREXnokk9ly5alY8eOLFmyhK1btwJ/XBg0bNgQq9VKVFSUI0MUyTSGYVC6dGleffVVgoOD7UnXtJF/FStWpFSpUpw5c8aRYYrkKjabDR8fH8aPH8/ixYuZOXMmcKtfpaSkUKhQIerUqcO5c+ccHKmIiIiISM7w0CWfihUrxoABA/j999+ZMWMGoaGh9n2+vr6ULVvWPlVCJLczmUy4ubkRFBREpUqVmD59OkuWLLHvL1iwoH29GtD0IJF7kTYtu3Pnzjz33HN8+OGHTJ06FQAXFxecnJxwdXW1T8lTvxIRERGRh12eXnD87xZQ3rRpE5MnT+by5ct069YNf39//ve//7FkyRL27NlD2bJlszlakQfzTwuG79mzhzlz5rBp0yYCAwOpW7cue/futbf5ihUrZmO0InnDyZMnWbx4MR9++CEdO3akatWqxMTE8Pnnn7N7924qV67s6BBFRERERBwuTyafTpw4gbe3N4UKFbpt358v0MPCwvjqq6+YPXs2xYsXx8nJiYULF1KrVq1sjljkwZw6dYrdu3fTrl07ChYseNdyUVFRbN26lUmTJuHp6YmbmxsfffQRNWvWzMZoRXKXf0rsxsfHs2/fPt59913MZjPu7u6MGzeOGjVqZGOUIiIiIiI5V55LPh04cIDatWvzySef0K9fvzuWSU1NtU+HAEhISCAlJQWz2Yynp2d2hSqSKQ4ePEirVq144YUX6N+/PxUqVMBms6V7YuNf27zVasVms5GSkoK7u7sjwhbJ0c6cOcOFCxeoW7fuXcv8tV+l9bukpCRcXV2zI0wRERERkVwhTyWfDhw4QJMmTRg0aBATJ068bX/aqf71DrbVasXJySlbYhTJTNHR0TRt2pTu3bszZcoU+/bk5GQsFsttSai0ERx/vWgWkT9EREQQEBBA6dKlmTZtGk2bNv3b8leuXMHb29vev/5ppJSIiIiIyMMmzyw4/uuvv1KvXj1GjBjBxIkTsdlsbNmyhfnz57Nr1y7Onj2b7mJg4sSJtG7dGsMwlHiSXGvXrl2UK1eOKVOmYLPZGDVqFEFBQQQFBbFly5Z0iaf333/fPipKiSeRO4uJieGll16iQoUKFC5cmLFjx7J9+/a7lp8+fTr/+te/iIyMtH/GKPEkIiIiIpJenkg+2Ww2vvjiC6xWK0899RQAbdq0YejQoQwfPpzevXvTp08fDh48iMlkIjk5mXz58hEXF8fZs2cdHL3I/YuOjrav8dS0aVP27NlDvnz5MJlMtG7dmkWLFgG3pgfVqlULT09PoqKiHBmySI525swZnJyc+OCDD3j11VdxcnJi3Lhxd01AtWnThpo1a2K1WrM5UhERERGR3CPPTLu7cOECo0eP5tNPP6VixYpUqlSJ0aNH8+ijj7JhwwbmzZtHwYIFWbhwIQUKFCAxMZGkpCS8vLwcHbrIfVu2bBlDhw7l/fffZ82aNXz22Wd4e3sDMH78eMaMGUNYWBjVqlXDarWSlJSkNZ5E/sGBAwfsi/Bv3LiRWbNmYbVaefvtt2nevDnwx3Rtm81GamoqFovFkSGLiIiIiORoeWLkE4CPjw/jxo2jf//+uLm5MW7cOGrWrImLiwvdunWjQ4cObN++nbi4OADy5cunxJPkOhcvXiQ2Ntb+c/PmzWnQoAFz587lxo0beHt7Y7PZAHjhhRcoW7YsR44cAcDJyUmJJ5F78Oen1HXs2JHBgwdjNpsZP368fQTU0KFD+emnnzCbzUo8iYiIiIj8g1y78Mu5c+fYt28fycnJlC5dmnr16lGkSBFGjRpFVFQU5cuXB/64O12hQgUKFSqkiwTJtfbt20fHjh1ZtWoVRYsWBaBUqVI89thjTJw4keTkZE6dOkXZsmUB8PDwwMvLCzc3N0eGLZKjRUZGsmnTJuDWTYyuXbva12xK+/zo0KEDJpOJjz76iPHjx+Pm5sa6det4/vnnHRi5iIiIiEjukSuTT4cOHSIwMJDChQtz8uRJ/Pz8GD58ON27d6d48eIUK1bMfvGQtpj4d999R6lSpTTyQ3KlAwcOEBAQQP/+/W978tbrr7/OzZs3mTlzJoGBgcyfP5/8+fOzcuVKLl68SJ06dRwUtUjOdujQIVq3bk316tVJTEzkwIEDPP7444waNYoqVarg5ORkT0C1b9+e1NRUevfujWEYhIWF2afmiYiIiIjI38t1yacTJ07QsWNHnnnmGd566y2OHz/OzJkzCQ0N5YknnsBsNqd70tDp06eZOXMmn332Gdu2bSN//vwOjF4k4w4dOkRAQAAvv/wyH3zwATabjfDwcK5fv467uzs1atTgzTffpGTJkoSEhNCoUSMeffRRkpKSWLNmDb6+vo4+BZEc5/Llyzz77LP07duXiRMncuPGDbZs2UJgYCCJiYmMGjWKOnXq4OTkhGEYGIbB5s2bSU1NZdeuXVSrVs3RpyAiIiIikmvkqgXHk5OTefPNNzlz5gyfffaZfQrdokWLGD58OBERETzyyCP28r/88gsff/wxu3btYvny5dSqVctBkYvcn9TUVKpXr050dDSXL1+2r2F29uxZfv31Vx555BF69+7N2LFjAewjMjw9PfH09LRPzxOR9CIiInjuuecICQmhfPnyWK1WTp8+TadOnYiMjKRVq1asXbsWZ+db92gOHTpEhw4dWLduHXXr1nVw9CIiIiIiuUuuGvlks9koVaoUVapUwWKxYBgGJpOJxo0b4+HhQUpKSrry/v7+xMfH895771GyZEkHRS1y/5ydnVm9ejUBAQF0796dq1ev4u7uzocffojZbGbv3r0MHTqUAgUKMHz4cEwmk6bZidyD5ORkDh48yOHDhylfvrx9ip2fnx+TJk3i6aefZvbs2QwZMgSA6tWrEx4ejqenp4MjFxERERHJfXJV8snNzY3AwED7gsppvLy8cHFxSZd82rt3L3Xr1qVVq1bZHaZIpnr00Uf5/vvvqV+/PpUqVWLVqlX4+PgAUK9ePU6dOsX69esZMGAAXl5e6aadisid+fr60qNHD6ZOncrx48epWLEiffv2pWfPnnTp0oW+ffty8OBB4NaND7PZTIECBRwctYiIiIhI7pTjk0/nz58nOjqaK1eu0LZtW3viKW0RWIDff/+dq1ev2o8ZPXo0s2bN4rfffsPb21sX45KrpLX5q1ev0rp1a+BWAurIkSNs3boVb29ve1lXV1fc3d1JTk6mQIECausid/HnftWmTRu8vLwYPHgwwcHBTJgwAR8fH1566SXef/99ABITE4mOjgbAbDYDqH+JiIiIiNynHJ18OnjwIF27dsXV1ZULFy5QvHhxRo8eTbt27fD29rZPuzOZTJjNZjw8PBg3bhxTpkxh+/bt6dZ/EskN7tbmW7VqhZ+fH71797YnXdNcunSJGjVqYLPZHBS1SM72137l4+PDe++9R9euXZkzZw5jxowhOTnZvjh/amoqN2/epF69eg6OXEREREQkb8ixC45fvHiR5s2b88QTT9C/f3/c3NwYOnQoBw8epEePHgwcOJAiRYoAEBsbS/v27alUqRJr165l165dWhBWcp2MtHmAmJgYZs2axbx58/jhhx949NFHHRi9SM50t361f/9+goKCeOmll+zTWAGOHj3K8uXLmTVrFjt37qRKlSoOjF5EREREJG8wOzqAu7l48SI3b97kiSeeoFy5cpQoUYKQkBC6du3KmjVrCA4O5saNG8CtR2bv37+f9evX8/PPPyvxJLlSRtr8rl27GDFiBIsXL+a7775T4knkLu7WrwIDA1m9ejVLliwhMTERgOvXrzNlyhSWLFnCli1blHgSEREREckkOTb5lJKSQmpqqv1iO+3iYOLEibRo0YK5c+dy/PhxAAoVKsQrr7zCvn37qFWrlqNCFnkgGWnzRYsWpUOHDmzfvl1tXuRv3Eu/+u233wDw8PBg/Pjx6lciIiIiIpksx067A/D398fDw4MtW7YAkJSUhKurKwD169enQoUKLF++HICbN2/i5ubmsFhFMsM/tfny5csTEhICYF/zTET+3r1+lvz5QRYiIiIiIpJ5cszIp4SEBOLj44mLi7Nv+/jjjzly5AjPPPMMcOvJXqmpqQA0b96chIQEe1klniS3uZ82nzZ6A/TkLZE7eZDPEiWeRERERESyRo5IPoWHh/PEE08QEBBAlSpVWLp0KQBVqlRhxowZbNq0ie7du5OSkmJ/5HVsbCz58+cnNTWVHDx4S+SO1OZFMp/6lYiIiIhIzuTs6ADCw8Np3rw5vXv3pl69euzdu5e+ffvy6KOPUrt2bbp27Ur+/Pl55ZVXqFGjBpUrV8ZisfD111/z008/4ezs8FMQyRC1eZHMp34lIiIiIpJzOXTNpytXrhAUFETlypWZMWOGfXuLFi2oXr06H330kX1bfHw848aN48qVK7i5ufHyyy/rCV+S66jNi2Q+9SsRERERkZzNobd6U1JSuHbtGk899RQANpsNs9lM2bJluXLlCnBrUWXDMChQoACTJk1KV04kt1GbF8l86lciIiIiIjmbQ//r9vHx4fPPP6dZs2YAWK1WAEqWLGm/IDCZTJjN5nSLx2qhZcmt1OZFMp/6lYiIiIhIzubwW74VK1YEbt2BdnFxAW7doY6NjbWXmTBhAp988on96US6YJDcTG1eJPOpX4mIiIiI5Fw5ZoVVs9mMYRj2i4G0u9WjR49m3LhxhIWFaUFYyVPU5kUyn/qViIiIiEjO4/CRT3+Wtva5s7Mzvr6+TJkyhQ8++IA9e/ZQs2ZNB0cnkvnU5kUyn/qViIiIiEjOkqNu/6bdoXZxcWHBggV4enqyY8cO6tSp4+DIRLKG2rxI5lO/EhERERHJWXLUyKc07dq1A2DXrl3Uq1fPwdGIZD21eZHMp34lIiIiIpIzmIy0+Qk5TEJCAvnz53d0GCLZRm1eJPOpX4mIiIiIOF6OTT6JiIiIiIiIiEjulyOn3YmIiIiIiIiISN6g5JOIiIiIiIiIiGQZJZ9ERERERERERCTLKPkkIiIiIiIiIiJZRsknERERERERERHJMko+iYiIiIiIiIhIllHySUQkBzCZTHz55ZeODkNERERERCTTKfkkItnKMAxat25Nu3btbts3Z84cvLy8OHPmTJa9//fff4+vry8Azz//PCaTiZdeeum2cgMHDsRkMvH8889n6vu/88471KpVK1NfU0REREREJCdT8klEspXJZGLx4sX8/PPPfPzxx/btp06dYvjw4cycOZNSpUpl6numpKTYv1+3bh1dunSx/+zr60tISAiJiYn2bTdv3mTZsmWULl06U+MQERERERF5GCn5JCLZztfXlxkzZvDGG29w6tQpDMOgf//+tG3bltq1a9OhQwc8PDzw8fGhV69eXLp0yX5saGgoTZs2xcvLi0ceeYTOnTtz4sQJ+/7IyEhMJhMrVqwgICAANzc3li5dat+/fv16unbtav+5Tp06+Pr6smbNGvu2NWvWULp0aWrXrp0u7qSkJF599VWKFi2Km5sbTZs2Zffu3fb927Ztw2QysXnzZurVq4e7uzuNGzcmIiICgODgYN59910OHDiAyWTCZDIRHBxsP/7SpUt069YNd3d3KlasyPr16x/8ly0iIiIiIuJgSj6JiEP06dOHVq1a0a9fP2bNmsXhw4f5+OOPadmyJbVr12bPnj2EhoZy4cIFevToYT8uISGBoUOHsmfPHjZv3ozZbKZbt27YbLZ0rz9y5EiGDBnC0aNH7VP8jhw5QmxsLC1btkxXtl+/fixevNj+86JFi+jbt+9tMQ8fPpzVq1fz6aefsm/fPipUqEC7du24cuVKunJvv/02U6dOZc+ePTg7O9OvXz8AevbsyX/+8x+qVq3K+fPnOX/+PD179rQf9+6779KjRw8OHjxIx44defbZZ297bRERERERkdzGZBiG4eggROThFBsbS9WqVbly5QqrV6/m8OHDbN++nW+++cZe5syZM/j6+hIREUGlSpVue41Lly5RpEgRDh06RLVq1YiMjKRs2bJMnz6dIUOGpCs7fvx4wsLCWLlyJXBrzadr166xYMEC+3sAVK5cmejoaF544QW8vLwIDg4mISGBQoUKERwczDPPPAPcms7n5+fHa6+9xrBhw9i2bRstWrTgu+++o1WrVgBs3LiRTp06kZiYiJubG++88w5ffvkl+/fvTxebyWRi1KhRjB07FriVZPPw8OB///sf7du3z5xfuIiIiIiIiANo5JOIOEzRokV58cUXqVKlCoGBgRw4cICtW7fi4eFh/6pcuTKAfWrdb7/9RlBQEOXKlcPT0xM/Pz8ATp8+ne6169Wrd9v7rVu3Lt2UuzRFihShU6dOBAcHs3jxYjp16kThwoXTlTlx4gQpKSk0adLEvs3FxQV/f3+OHj2armyNGjXs3xcvXhy4lWj7J38+Ln/+/Hh6et7TcSIiIiIiIjmZs6MDEJGHm7OzM87Ot/4UXb9+nS5dujBp0qTbyqUlcbp06UKZMmVYsGABJUqUwGazUa1aNZKTk9OVz58/f7qfz58/T1hYGJ06dbpjHP369WPQoEEAzJ49+4HOycXFxf69yWQCuG1a4D8dl3bsvRwnIiIiIiKSkyn5JCI5Rp06dVi9ejV+fn72hNSfXb58mYiICBYsWECzZs0A2LFjxz299ldffUXjxo3x9va+4/727duTnJyMyWSyrxH1Z+XLl8disbBz507KlCkD3Jp2t3v3bl577bV7PEOwWCxYrdZ7Li8iIiIiIpLbadqdiOQYAwcO5MqVKwQFBbF7925OnDjBN998Q9++fbFarRQqVIhHHnmE+fPnc/z4cbZs2cLQoUPv6bX/+pS7v3JycuLo0aOEh4fj5OR02/78+fPz8ssvM2zYMEJDQwkPD2fAgAHcuHGD/v373/M5+vn5cerUKfbv38+lS5dISkq652NFRERERERyIyWfRCTHKFGiBDt37sRqtdK2bVuqV6/Oa6+9hpeXF2azGbPZTEhICHv37qVatWq8/vrrTJ48+R9fNyEhgc2bN/9t8gnA09MTT0/Pu+6fOHEiTz75JL169aJOnTocP36cb775hkKFCt3zOT755JO0b9+eFi1aUKRIEZYvX37Px4qIiIiIiORGetqdiOR5a9asYdSoUYSHhzs6FBERERERkYeORj6JSJ7n4eFxx0XMRUREREREJOtp5JOIiIiIiIiIiGQZjXwSEREREREREZEso+STiIiIiIiIiIhkGSWfREREREREREQkyyj5JCIiIiIiIiIiWUbJJxERERERERERyTJKPomIiIiIiIiISJZR8klERERERERERLKMkk8iIiIiIiIiIpJllHwSEREREREREZEs8393Q/P4JPt9KwAAAABJRU5ErkJggg==" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 142 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-03T14:12:13.623863Z", + "start_time": "2024-12-03T14:12:13.603444Z" + } + }, + "cell_type": "code", + "source": "np.exp(y_weather*results_of_weather_model.params[0])", + "id": "67c146cbaf46fdea", + "outputs": [ + { + "data": { + "text/plain": [ + "array([ nan, nan, nan, ..., 1.00129752, 1.00003705,\n", + " nan])" + ] + }, + "execution_count": 81, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 81 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "# Machine learning ", + "id": "290e6e0d3720d32c" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-04T09:12:49.938543Z", + "start_time": "2024-12-04T09:12:49.911991Z" + } + }, + "cell_type": "code", + "source": [ + "from sklearn.neural_network import MLPRegressor\n", + "from sklearn.pipeline import Pipeline\n", + "from sklearn.model_selection import train_test_split, RandomizedSearchCV, KFold\n", + "from sklearn.compose import ColumnTransformer\n", + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.feature_selection import SelectKBest, f_regression\n", + "from sklearn.metrics import mean_squared_error\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "\n" + ], + "id": "eea77739eebf1a64", + "outputs": [], + "execution_count": 10 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-03T08:46:13.101372Z", + "start_time": "2024-12-03T08:46:13.098450Z" + } + }, + "cell_type": "code", + "source": [ + "def permutation_importances(rf, X_train, y_train, metric): \n", + " baseline = metric(rf, X_train, y_train)\n", + " imp = []\n", + " for col in X_train.columns:\n", + " save = X_train[col].copy()\n", + " X_train[col] = np.random.permutation(X_train[col])\n", + " m = metric(rf, X_train, y_train)\n", + " X_train[col] = save\n", + " imp.append(baseline - m)\n", + " return np.array(imp)" + ], + "id": "5df54fabff166b66", + "outputs": [], + "execution_count": 10 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-03T08:46:13.107016Z", + "start_time": "2024-12-03T08:46:13.103427Z" + } + }, + "cell_type": "code", + "source": [ + "param_grid = {\n", + " \"hidden_layer_sizes\": [(50,), (100,), (50, 50), (100, 50), (100, 100)],\n", + " \"activation\": [\"relu\", \"tanh\"],\n", + " \"solver\": [\"adam\", \"lbfgs\"],\n", + " \"alpha\": [0.0001, 0.001, 0.01], # Regularization parameter\n", + " \"learning_rate\": [\"constant\", \"adaptive\"],\n", + " \"max_iter\": [500, 1000],\n", + "}\n" + ], + "id": "a9e28657a33410f6", + "outputs": [], + "execution_count": 11 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "ANC case model ", + "id": "a04ffeecf105ead1" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-03T10:53:32.402992Z", + "start_time": "2024-12-03T10:53:32.398505Z" + } + }, + "cell_type": "code", + "source": [ + "y = monthly_reporting_by_facility.values.flatten()\n", + "if np.nanmin(y) < 1:\n", + " y += 1 # Shift to ensure positivity as taking log\n", + "y[y > 4e3] = np.nan\n", + "log_y = False" + ], + "id": "bd1752d3d5101a2b", + "outputs": [], + "execution_count": 32 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-03T15:52:29.916138Z", + "start_time": "2024-12-03T15:52:29.733746Z" + } + }, + "cell_type": "code", + "source": [ + "if log_y:\n", + " y = np.log(y)\n", + " \n", + "X = np.column_stack([\n", + " year_flattened,\n", + " #month_flattened,\n", + " month_encoded,\n", + " resid_encoded,\n", + " zone_encoded,\n", + " owner_encoded,\n", + " ftype_encoded,\n", + " facility_encoded,\n", + " altitude,\n", + " np.array(minimum_distance)\n", + "])\n", + "mask_ANC = (~np.isnan(X).any(axis=1) & ~np.isnan(y) & (X[:, 0] >= mask_threshold) & (y <= 1e4))\n", + "X_masked = X[mask_ANC]\n", + "y_masked = y[mask_ANC]\n", + "X_train, X_test, y_train, y_test = train_test_split(X_masked, y_masked, test_size=0.2, random_state=42)\n", + "model = MLPRegressor(random_state=42)\n" + ], + "id": "4ff8fb67bad7645a", + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_92649/1973427723.py:2: RuntimeWarning: invalid value encountered in log\n", + " y = np.log(y)\n" + ] + } + ], + "execution_count": 116 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-03T15:56:33.423431Z", + "start_time": "2024-12-03T15:52:32.457218Z" + } + }, + "cell_type": "code", + "source": [ + "\n", + "# Feature Selection with Recursive Feature Elimination and Cross-Validation\n", + "cv = KFold(n_splits=5, shuffle=True, random_state=42)\n", + "random_search = RandomizedSearchCV(\n", + " estimator=model,\n", + " param_distributions=param_grid,\n", + " n_iter=10, \n", + " scoring=\"neg_mean_squared_error\",\n", + " cv=cv,\n", + " verbose=2,\n", + " random_state=42,\n", + " n_jobs=-1,\n", + ")\n", + "\n", + "# Pipeline with preprocessing, feature selection, and model fitting\n", + "pipeline_cases = Pipeline([\n", + " (\"feature_selection\", SelectKBest(score_func=f_regression, k = 'all')), \n", + " (\"model\", random_search),\n", + "])\n", + "pipeline_cases.fit(X_train, y_train)\n", + "y_pred = pipeline_cases.predict(X_test)\n", + "\n" + ], + "id": "ee2d866d43353e41", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fitting 5 folds for each of 10 candidates, totalling 50 fits\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/neural_network/_multilayer_perceptron.py:545: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + " self.n_iter_ = _check_optimize_result(\"lbfgs\", opt_res, self.max_iter)\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/neural_network/_multilayer_perceptron.py:545: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + " self.n_iter_ = _check_optimize_result(\"lbfgs\", opt_res, self.max_iter)\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/neural_network/_multilayer_perceptron.py:545: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + " self.n_iter_ = _check_optimize_result(\"lbfgs\", opt_res, self.max_iter)\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/neural_network/_multilayer_perceptron.py:545: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + " self.n_iter_ = _check_optimize_result(\"lbfgs\", opt_res, self.max_iter)\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/neural_network/_multilayer_perceptron.py:545: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + " self.n_iter_ = _check_optimize_result(\"lbfgs\", opt_res, self.max_iter)\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/neural_network/_multilayer_perceptron.py:545: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + " self.n_iter_ = _check_optimize_result(\"lbfgs\", opt_res, self.max_iter)\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/neural_network/_multilayer_perceptron.py:545: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + " self.n_iter_ = _check_optimize_result(\"lbfgs\", opt_res, self.max_iter)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[CV] END activation=relu, alpha=0.0001, hidden_layer_sizes=(100, 50), learning_rate=constant, max_iter=500, solver=adam; total time= 8.1s\n", + "[CV] END activation=relu, alpha=0.01, hidden_layer_sizes=(100,), learning_rate=adaptive, max_iter=500, solver=lbfgs; total time= 1.4min\n", + "[CV] END activation=relu, alpha=0.01, hidden_layer_sizes=(100, 50), learning_rate=constant, max_iter=500, solver=adam; total time= 5.6s\n", + "[CV] END activation=relu, alpha=0.01, hidden_layer_sizes=(100, 50), learning_rate=constant, max_iter=500, solver=adam; total time= 4.8s\n", + "[CV] END activation=tanh, alpha=0.001, hidden_layer_sizes=(100,), learning_rate=adaptive, max_iter=500, solver=adam; total time= 2.9s\n", + "[CV] END activation=tanh, alpha=0.001, hidden_layer_sizes=(100,), learning_rate=adaptive, max_iter=500, solver=adam; total time= 4.6s\n", + "[CV] END activation=tanh, alpha=0.01, hidden_layer_sizes=(100, 100), learning_rate=constant, max_iter=500, solver=lbfgs; total time= 53.0s\n", + "[CV] END activation=tanh, alpha=0.0001, hidden_layer_sizes=(50, 50), learning_rate=adaptive, max_iter=1000, solver=lbfgs; total time= 2.2s\n", + "[CV] END activation=tanh, alpha=0.0001, hidden_layer_sizes=(50, 50), learning_rate=adaptive, max_iter=1000, solver=lbfgs; total time= 1.4s\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/joblib/externals/loky/process_executor.py:752: UserWarning: A worker stopped while some jobs were given to the executor. This can be caused by a too short worker timeout or by a memory leak.\n", + " warnings.warn(\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/neural_network/_multilayer_perceptron.py:545: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + " self.n_iter_ = _check_optimize_result(\"lbfgs\", opt_res, self.max_iter)\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/neural_network/_multilayer_perceptron.py:545: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + " self.n_iter_ = _check_optimize_result(\"lbfgs\", opt_res, self.max_iter)\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/neural_network/_multilayer_perceptron.py:545: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + " self.n_iter_ = _check_optimize_result(\"lbfgs\", opt_res, self.max_iter)\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/neural_network/_multilayer_perceptron.py:545: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + " self.n_iter_ = _check_optimize_result(\"lbfgs\", opt_res, self.max_iter)\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/neural_network/_multilayer_perceptron.py:545: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + " self.n_iter_ = _check_optimize_result(\"lbfgs\", opt_res, self.max_iter)\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/neural_network/_multilayer_perceptron.py:545: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + " self.n_iter_ = _check_optimize_result(\"lbfgs\", opt_res, self.max_iter)\n" + ] + } + ], + "execution_count": 117 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-03T15:03:58.571077Z", + "start_time": "2024-12-03T15:03:58.407583Z" + } + }, + "cell_type": "code", + "source": [ + "plt.figure(figsize=(10, 5))\n", + "if log_y:\n", + " plt.plot(range(len(y_test)),np.exp(y_test), 'o',color=\"blue\", label=\"Actual\")\n", + " plt.plot(range(len(y_pred)), np.exp(y_pred), 'o',color=\"red\", label=\"Predicted\")\n", + "else:\n", + " plt.plot(range(len(y_test)),y_test, 'o',color=\"blue\", label=\"Actual\")\n", + " plt.plot(range(len(y_pred)), y_pred, 'o',color=\"red\", label=\"Predicted\")\n", + "plt.title(\"Model Predictions vs Actual\")\n", + "plt.xlabel(\"Samples\")\n", + "plt.ylabel(\"Values\")\n", + "plt.legend()\n", + "plt.show()" + ], + "id": "90ec40d744cffc4e", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 96 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-03T15:04:08.714945Z", + "start_time": "2024-12-03T15:04:08.701861Z" + } + }, + "cell_type": "code", + "source": [ + "train_indices = np.where(np.isin(y_train, y_masked))[0]\n", + "test_indices = np.where(np.isin(y_test,y_masked))[0]\n" + ], + "id": "50e6670434ff8e59", + "outputs": [], + "execution_count": 97 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Add in weather data", + "id": "55e43602ba697986" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-03T15:04:09.675585Z", + "start_time": "2024-12-03T15:04:09.669632Z" + } + }, + "cell_type": "code", + "source": "use_residuals", + "id": "9cea91afae0f881b", + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 98, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 98 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-03T15:14:32.906276Z", + "start_time": "2024-12-03T15:09:49.867412Z" + } + }, + "cell_type": "code", + "source": [ + "\n", + "if use_residuals:\n", + " y_weather = np.exp(y_test) - np.exp(y_pred)\n", + " y_weather[np.isinf(y_weather)] = np.nan\n", + " X_weather = np.column_stack([\n", + " weather_data[mask_ANC],\n", + " np.array(year_flattened)[mask_ANC],\n", + " #np.array(month_flattened)[mask_ANC_data],\n", + " np.array(month_encoded)[mask_ANC],\n", + " resid_encoded[mask_ANC],\n", + " zone_encoded[mask_ANC],\n", + " owner_encoded[mask_ANC],\n", + " ftype_encoded[mask_ANC],\n", + " facility_encoded[mask_ANC],\n", + " lag_1_month[mask_ANC],\n", + " lag_2_month[mask_ANC],\n", + " lag_3_month[mask_ANC],\n", + " lag_4_month[mask_ANC],\n", + " np.array(altitude)[mask_ANC],\n", + " np.array(minimum_distance)[mask_ANC]\n", + " ])\n", + " X_weather = X_weather[test_indices,:]\n", + "\n", + "else:\n", + " y_weather = y\n", + " y_weather[np.isinf(y_weather)] = np.nan\n", + " X_weather = np.column_stack([\n", + " weather_data,\n", + " year_flattened,\n", + " #month_flattened,\n", + " month_encoded,\n", + " resid_encoded,\n", + " zone_encoded,\n", + " owner_encoded,\n", + " ftype_encoded,\n", + " lag_1_month,\n", + " lag_2_month,\n", + " lag_3_month,\n", + " lag_4_month,\n", + " facility_encoded,\n", + " np.array(altitude), \n", + " np.array(minimum_distance)\n", + " ])\n", + "\n", + "# Define the column index for weather_data in X_weather (assuming it's the first column)\n", + "weather_column_index = [0] # Index 0 represents the first column in X_weather\n", + "\n", + "preprocessor = ColumnTransformer(\n", + " transformers=[\n", + " (\"weather_scaler\", StandardScaler(), weather_column_index) # Scale only the first column\n", + " ],\n", + " remainder=\"passthrough\" # Leave other columns as they are\n", + ")\n", + "\n", + "mask_weather = (~np.isnan(X_weather).any(axis=1) & ~np.isnan(y_weather) & (X_weather[:, 0] >= mask_threshold) & (y_weather <= 1e4))\n", + "X_weather_masked = X_weather[mask_weather]\n", + "y_masked = y_weather[mask_weather]\n", + "X_weather_train, X_weather_test, y_weather_train, y_weather_test = train_test_split(X_weather_masked, y_masked, test_size=0.2, random_state=42)\n", + "\n", + "\n", + "# Feature Selection with Recursive Feature Elimination and Cross-Validation\n", + "cv_weather = KFold(n_splits=5, shuffle=True, random_state=42)\n", + "random_search = RandomizedSearchCV(\n", + " estimator=model,\n", + " param_distributions=param_grid,\n", + " n_iter=10, \n", + " scoring=\"neg_mean_squared_error\",\n", + " cv=cv_weather,\n", + " verbose=2,\n", + " random_state=42,\n", + " n_jobs=-1,\n", + ")\n", + "pipeline_weather = Pipeline([\n", + " (\"preprocessing\", preprocessor),\n", + " (\"feature_selection\", SelectKBest(score_func=f_regression, k='all')), \n", + " (\"model\", random_search)\n", + "])\n", + "pipeline_weather.fit(X_weather_train, y_weather_train)\n", + "y_weather_pred = pipeline_weather.predict(X_weather_test)\n", + "\n", + "plt.figure(figsize=(10, 5))\n", + "plt.plot(range(len(y_weather_test)), y_weather_test, 'o',color=\"blue\", label=\"Actual\")\n", + "plt.plot(range(len(y_weather_pred)), y_weather_pred, 'o',color=\"red\", label=\"Predicted\")\n", + "plt.title(\"Model Predictions vs Actual\")\n", + "plt.xlabel(\"Samples\")\n", + "plt.ylabel(\"Values\")\n", + "plt.legend()\n", + "plt.show()\n" + ], + "id": "b6fbfc12a49714b6", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fitting 5 folds for each of 10 candidates, totalling 50 fits\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/neural_network/_multilayer_perceptron.py:545: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + " self.n_iter_ = _check_optimize_result(\"lbfgs\", opt_res, self.max_iter)\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/neural_network/_multilayer_perceptron.py:545: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + " self.n_iter_ = _check_optimize_result(\"lbfgs\", opt_res, self.max_iter)\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/neural_network/_multilayer_perceptron.py:545: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + " self.n_iter_ = _check_optimize_result(\"lbfgs\", opt_res, self.max_iter)\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/neural_network/_multilayer_perceptron.py:545: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + " self.n_iter_ = _check_optimize_result(\"lbfgs\", opt_res, self.max_iter)\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/neural_network/_multilayer_perceptron.py:545: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + " self.n_iter_ = _check_optimize_result(\"lbfgs\", opt_res, self.max_iter)\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/neural_network/_multilayer_perceptron.py:545: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + " self.n_iter_ = _check_optimize_result(\"lbfgs\", opt_res, self.max_iter)\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/neural_network/_multilayer_perceptron.py:545: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + " self.n_iter_ = _check_optimize_result(\"lbfgs\", opt_res, self.max_iter)\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/neural_network/_multilayer_perceptron.py:545: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + " self.n_iter_ = _check_optimize_result(\"lbfgs\", opt_res, self.max_iter)\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/neural_network/_multilayer_perceptron.py:545: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + " self.n_iter_ = _check_optimize_result(\"lbfgs\", opt_res, self.max_iter)\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/neural_network/_multilayer_perceptron.py:545: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + " self.n_iter_ = _check_optimize_result(\"lbfgs\", opt_res, self.max_iter)\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/neural_network/_multilayer_perceptron.py:545: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + " self.n_iter_ = _check_optimize_result(\"lbfgs\", opt_res, self.max_iter)\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/neural_network/_multilayer_perceptron.py:545: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + " self.n_iter_ = _check_optimize_result(\"lbfgs\", opt_res, self.max_iter)\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/neural_network/_multilayer_perceptron.py:545: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + " self.n_iter_ = _check_optimize_result(\"lbfgs\", opt_res, self.max_iter)\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/neural_network/_multilayer_perceptron.py:545: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + " self.n_iter_ = _check_optimize_result(\"lbfgs\", opt_res, self.max_iter)\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/neural_network/_multilayer_perceptron.py:545: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + " self.n_iter_ = _check_optimize_result(\"lbfgs\", opt_res, self.max_iter)\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/neural_network/_multilayer_perceptron.py:545: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + " self.n_iter_ = _check_optimize_result(\"lbfgs\", opt_res, self.max_iter)\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/neural_network/_multilayer_perceptron.py:545: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + " self.n_iter_ = _check_optimize_result(\"lbfgs\", opt_res, self.max_iter)\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/neural_network/_multilayer_perceptron.py:545: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + " self.n_iter_ = _check_optimize_result(\"lbfgs\", opt_res, self.max_iter)\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/neural_network/_multilayer_perceptron.py:545: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + " self.n_iter_ = _check_optimize_result(\"lbfgs\", opt_res, self.max_iter)\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/neural_network/_multilayer_perceptron.py:545: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + " self.n_iter_ = _check_optimize_result(\"lbfgs\", opt_res, self.max_iter)\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/neural_network/_multilayer_perceptron.py:545: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + " self.n_iter_ = _check_optimize_result(\"lbfgs\", opt_res, self.max_iter)\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/neural_network/_multilayer_perceptron.py:545: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + " self.n_iter_ = _check_optimize_result(\"lbfgs\", opt_res, self.max_iter)\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/neural_network/_multilayer_perceptron.py:545: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + " self.n_iter_ = _check_optimize_result(\"lbfgs\", opt_res, self.max_iter)\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 100 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-03T15:42:05.228017Z", + "start_time": "2024-12-03T15:42:05.079739Z" + } + }, + "cell_type": "code", + "source": [ + "plt.figure(figsize=(10, 5))\n", + "plt.plot(X_weather_test[:,0], np.exp(y_weather_test), 'o',color=\"blue\", label=\"Actual\")\n", + "plt.title(\"Model Predictions vs Actual\")\n", + "plt.xlabel(\"Precip (mm)\")\n", + "plt.ylabel(\"No. ANC visits \")\n", + "plt.legend()\n", + "plt.show()" + ], + "id": "4ec9e0fcb4419266", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 102 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-03T10:59:25.483519Z", + "start_time": "2024-12-03T10:59:25.384624Z" + } + }, + "cell_type": "code", + "source": [ + "plt.figure(figsize=(10, 5))\n", + "plt.plot(range(len(y_weather_test)), y_weather_test, 'o',color=\"blue\", label=\"Actual\")\n", + "plt.plot(range(len(y_weather_pred)), y_weather_pred, 'o',color=\"red\", label=\"Predicted\")\n", + "plt.title(\"Model Predictions vs Actual\")\n", + "plt.xlabel(\"Samples\")\n", + "plt.ylabel(\"Values\")\n", + "plt.legend()\n", + "plt.show()" + ], + "id": "224757b934a5b47b", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 38 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Masks\n", + "id": "2d78473af476f0a" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "CMIP 6 data", + "id": "458e8122ba7ea3a4" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-03T17:01:02.256250Z", + "start_time": "2024-12-03T17:00:58.588654Z" + } + }, + "cell_type": "code", + "source": [ + "X_basis_weather_prediction = np.column_stack([\n", + " weather_data_prediction_flatten,\n", + " np.array(year_flattened_prediction),\n", + " np.array(month_encoded_prediction),\n", + " resid_encoded_prediction,\n", + " zone_encoded_prediction,\n", + " owner_encoded_prediction,\n", + " ftype_encoded_prediction,\n", + " lag_1_month_prediction,\n", + " lag_2_month_prediction,\n", + " lag_3_month_prediction,\n", + " lag_4_month_prediction,\n", + " facility_encoded_prediction,\n", + " altitude_prediction, \n", + " minimum_distance_prediction\n", + "])\n", + "\n", + "X_basis_prediction = np.column_stack([\n", + " np.array(year_flattened_prediction),\n", + " np.array(month_encoded_prediction),\n", + " resid_encoded_prediction,\n", + " zone_encoded_prediction,\n", + " owner_encoded_prediction,\n", + " ftype_encoded_prediction,\n", + "\n", + " facility_encoded_prediction,\n", + " altitude_prediction, \n", + " minimum_distance_prediction\n", + "])\n", + "\n", + "#X_basis_prediction_masked = X_basis_prediction[:, selected_features_mask]\n", + "#X_basis_weather_prediction_masked = X_basis_weather_prediction[:,selected_features_weather_mask]\n", + "#y_weather_prediction_pred = pipeline_weather.predict(X_basis_weather_prediction_masked)\n", + "#y_no_weather_prediction_pred = pipeline.predict(X_basis_prediction_masked)\n", + "mask_prediction = (~np.isnan(X_basis_weather_prediction).any(axis=1) & (X_basis_weather_prediction[:, 0] >= mask_threshold) & ~np.isnan(X_basis_prediction).any(axis=1) )\n", + "\n", + "X_basis_prediction_masked = X_basis_prediction[mask_prediction,:]\n", + "X_basis_weather_prediction_masked = X_basis_weather_prediction[mask_prediction,:]\n", + "\n", + "y_weather_prediction_pred = pipeline_weather.predict(X_basis_weather_prediction_masked)\n", + "y_no_weather_prediction_pred = pipeline_cases.predict(X_basis_prediction_masked)\n", + "\n", + "plt.figure(figsize=(10, 5))\n", + "plt.plot(X_basis_weather_prediction_masked[:,0],(np.exp(y_weather_prediction_pred) - np.exp(y_no_weather_prediction_pred)), 'o', color=\"blue\", label=\"Difference\")\n", + "# plt.plot(X_basis_weather_prediction_masked[:,0],np.exp(y_weather_prediction_pred), 'o', color=\"red\", label=\"Predicted\")\n", + "plt.title(\"Model Predictions CMIP6\")\n", + "plt.xlabel(\"year\")\n", + "plt.ylabel(\"Difference in prediction between weather and no weather\")\n", + "plt.legend()\n", + "plt.show()\n", + "\n" + ], + "id": "d5c4aea72dd33e93", + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_92649/1473954178.py:44: RuntimeWarning: overflow encountered in exp\n", + " plt.plot(X_basis_weather_prediction_masked[:,0],(np.exp(y_weather_prediction_pred) - np.exp(y_no_weather_prediction_pred)), 'o', color=\"blue\", label=\"Difference\")\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 129 + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": "", + "id": "276c18b3d740f4cd" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "####### CROSS VALIDATION OF OLS REGRESSOR #####################", + "id": "fd850557158879a9" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-04T09:31:40.570927Z", + "start_time": "2024-12-04T09:31:34.542774Z" + } + }, + "cell_type": "code", + "source": [ + "\n", + "X_base_for_cross_validation_model1 = np.column_stack([\n", + " year_flattened,\n", + " #month_flattened,\n", + " month_encoded,\n", + " resid_encoded,\n", + " zone_encoded,\n", + " owner_encoded,\n", + " ftype_encoded,\n", + " facility_encoded,\n", + " altitude, \n", + " minimum_distance\n", + "])\n", + "\n", + "X_base_for_cross_validation_model2 = np.column_stack([\n", + " year_flattened,\n", + " month_encoded,\n", + " resid_encoded,\n", + " zone_encoded,\n", + " owner_encoded,\n", + " ftype_encoded,\n", + " #facility_encoded,\n", + " altitude, \n", + " minimum_distance\n", + "])\n", + "\n", + "y_base_for_cross_validation = y\n", + "\n", + "mask_for_cv = (~np.isnan(X_base_for_cross_validation_model1).any(axis=1) & ~np.isnan(y_base_for_cross_validation) & (y_base_for_cross_validation <= 1e4))\n", + "X_train_m1, X_test_m1, y_train_m1, y_test_m1 = train_test_split(X_base_for_cross_validation_model1[mask_for_cv,:], y_base_for_cross_validation[mask_for_cv], test_size=0.5)\n", + "X_train_m2, X_test_m2, y_train_m2, y_test_m2 = train_test_split(X_base_for_cross_validation_model2[mask_for_cv,:], y_base_for_cross_validation[mask_for_cv], test_size=0.5)\n", + "\n", + "\n", + "results_model1, y_pred_model1, mask_ANC_data_model1 = build_model(X_train_m1 , y_train_m1, poisson = poisson, log_y=log_y, X_mask_mm=mask_threshold)\n", + "\n", + "results_model2, y_pred_model2, mask_ANC_data_model2 = build_model(X_train_m2 , y_train_m2, poisson = poisson, log_y=log_y, X_mask_mm=mask_threshold)\n" + ], + "id": "76d5a14db4730f38", + "outputs": [], + "execution_count": 55 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-04T09:31:40.578632Z", + "start_time": "2024-12-04T09:31:40.573279Z" + } + }, + "cell_type": "code", + "source": [ + "print(\"Model 1 Train\", results_model1.rsquared)\n", + "print(\"Model 2 Train\", results_model2.rsquared)\n" + ], + "id": "bc35f53eb40d16cc", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model 1 Train 0.9770703294949092\n", + "Model 2 Train 0.9252845334223552\n" + ] + } + ], + "execution_count": 56 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-04T09:31:40.581295Z", + "start_time": "2024-12-04T09:31:40.579139Z" + } + }, + "cell_type": "code", + "source": "from sklearn.metrics import r2_score", + "id": "dfba92e3795db22f", + "outputs": [], + "execution_count": 57 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-04T09:31:40.590043Z", + "start_time": "2024-12-04T09:31:40.582525Z" + } + }, + "cell_type": "code", + "source": [ + "y_test_pred1 = results_model1.predict(X_test_m1)\n", + "y_test_pred2 = results_model2.predict(X_test_m2)" + ], + "id": "857060579867cb3e", + "outputs": [], + "execution_count": 58 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-04T09:31:40.595333Z", + "start_time": "2024-12-04T09:31:40.590481Z" + } + }, + "cell_type": "code", + "source": [ + "print(\"Module 1 Test\", r2_score(np.log(y_test_m1), y_test_pred1))\n", + "print(\"Module 2 Test\", r2_score(np.log(y_test_m2), y_test_pred2))\n" + ], + "id": "b725155bf0db02d", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Module 1 Test 0.6683064832148353\n", + "Module 2 Test 0.004429883540881807\n" + ] + } + ], + "execution_count": 59 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-04T09:37:32.580507Z", + "start_time": "2024-12-04T09:37:32.391577Z" + } + }, + "cell_type": "code", + "source": [ + "plt.plot(range(len(y_test_m2)), y_test_m2, 'o', color=\"green\", label=\"Test set\")\n", + "plt.plot(range(len(y_test_pred1)), np.exp(y_test_pred1), 'o', color=\"blue\", label=\"Model 1\", alpha=0.5)\n", + "plt.plot(range(len(y_test_pred2)), np.exp(y_test_pred2), 'o', color=\"red\", label=\"Model 2\")" + ], + "id": "bb7b7ade8866c861", + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 65, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 65 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-04T19:36:03.991252Z", + "start_time": "2024-12-04T16:35:28.285946Z" + } + }, + "cell_type": "code", + "source": [ + "from sklearn.inspection import permutation_importance\n", + "from sklearn.model_selection import GridSearchCV\n", + "param_grid = [\n", + " {'penalty':['l1','l2','elasticnet','none'],\n", + " 'C' : np.logspace(-4,4,20),\n", + " 'solver': ['lbfgs','newton-cg','liblinear','sag','saga'],\n", + " 'max_iter' : [100,1000,2500,5000]\n", + "}\n", + "]\n", + "model_1_LR = LogisticRegression().fit(X_train_m1, y_train_m1)\n", + "\n", + "clf = GridSearchCV(model_1_LR,param_grid = param_grid, cv = 3, verbose=True,n_jobs=-1)\n", + "\n", + "clf.fit(X_train_m1, y_train_m1)\n", + "PI_model_1 = permutation_importance(clf, X_test_m1, y_test_m1,\n", + " n_repeats=30,\n", + " random_state=0)\n", + "\n", + "for i in PI_model_1.importances_mean.argsort()[::-1]:\n", + " if PI_model_1.importances_mean[i] - 2 * PI_model_1.importances_std[i] > 0:\n", + " print(f\"{X_base_for_cross_validation_model1.columns[i]:<8}\"\n", + " f\"{PI_model_1.importances_mean[i]:.3f}\"\n", + " f\" +/- {PI_model_1.importances_std[i]:.3f}\")" + ], + "id": "7c17f83226c126cb", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fitting 3 folds for each of 1600 candidates, totalling 4800 fits\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:469: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + "Please also refer to the documentation for alternative solver options:\n", + " https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n", + " n_iter_i = _check_optimize_result(\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/model_selection/_split.py:776: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", + " warnings.warn(\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:469: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + "Please also refer to the documentation for alternative solver options:\n", + " https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n", + " n_iter_i = _check_optimize_result(\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:469: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + "Please also refer to the documentation for alternative solver options:\n", + " https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n", + " n_iter_i = _check_optimize_result(\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:469: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + "Please also refer to the documentation for alternative solver options:\n", + " https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n", + " n_iter_i = _check_optimize_result(\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/linear_model/_sag.py:349: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", + " warnings.warn(\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/linear_model/_sag.py:349: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", + " warnings.warn(\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/linear_model/_sag.py:349: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", + " warnings.warn(\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/linear_model/_sag.py:349: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", + " warnings.warn(\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/linear_model/_sag.py:349: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", + " warnings.warn(\n", + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/linear_model/_sag.py:349: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", + " warnings.warn(\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m", + "\u001B[0;31mKeyboardInterrupt\u001B[0m Traceback (most recent call last)", + "Cell \u001B[0;32mIn[76], line 14\u001B[0m\n\u001B[1;32m 10\u001B[0m model_1_LR \u001B[38;5;241m=\u001B[39m LogisticRegression()\u001B[38;5;241m.\u001B[39mfit(X_train_m1, y_train_m1)\n\u001B[1;32m 12\u001B[0m clf \u001B[38;5;241m=\u001B[39m GridSearchCV(model_1_LR,param_grid \u001B[38;5;241m=\u001B[39m param_grid, cv \u001B[38;5;241m=\u001B[39m \u001B[38;5;241m3\u001B[39m, verbose\u001B[38;5;241m=\u001B[39m\u001B[38;5;28;01mTrue\u001B[39;00m,n_jobs\u001B[38;5;241m=\u001B[39m\u001B[38;5;241m-\u001B[39m\u001B[38;5;241m1\u001B[39m)\n\u001B[0;32m---> 14\u001B[0m \u001B[43mclf\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mfit\u001B[49m\u001B[43m(\u001B[49m\u001B[43mX_train_m1\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43my_train_m1\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 15\u001B[0m PI_model_1 \u001B[38;5;241m=\u001B[39m permutation_importance(clf, X_test_m1, y_test_m1,\n\u001B[1;32m 16\u001B[0m n_repeats\u001B[38;5;241m=\u001B[39m\u001B[38;5;241m30\u001B[39m,\n\u001B[1;32m 17\u001B[0m random_state\u001B[38;5;241m=\u001B[39m\u001B[38;5;241m0\u001B[39m)\n\u001B[1;32m 19\u001B[0m \u001B[38;5;28;01mfor\u001B[39;00m i \u001B[38;5;129;01min\u001B[39;00m PI_model_1\u001B[38;5;241m.\u001B[39mimportances_mean\u001B[38;5;241m.\u001B[39margsort()[::\u001B[38;5;241m-\u001B[39m\u001B[38;5;241m1\u001B[39m]:\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/base.py:1473\u001B[0m, in \u001B[0;36m_fit_context..decorator..wrapper\u001B[0;34m(estimator, *args, **kwargs)\u001B[0m\n\u001B[1;32m 1466\u001B[0m estimator\u001B[38;5;241m.\u001B[39m_validate_params()\n\u001B[1;32m 1468\u001B[0m \u001B[38;5;28;01mwith\u001B[39;00m config_context(\n\u001B[1;32m 1469\u001B[0m skip_parameter_validation\u001B[38;5;241m=\u001B[39m(\n\u001B[1;32m 1470\u001B[0m prefer_skip_nested_validation \u001B[38;5;129;01mor\u001B[39;00m global_skip_validation\n\u001B[1;32m 1471\u001B[0m )\n\u001B[1;32m 1472\u001B[0m ):\n\u001B[0;32m-> 1473\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[43mfit_method\u001B[49m\u001B[43m(\u001B[49m\u001B[43mestimator\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43margs\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mkwargs\u001B[49m\u001B[43m)\u001B[49m\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/model_selection/_search.py:1019\u001B[0m, in \u001B[0;36mBaseSearchCV.fit\u001B[0;34m(self, X, y, **params)\u001B[0m\n\u001B[1;32m 1013\u001B[0m results \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_format_results(\n\u001B[1;32m 1014\u001B[0m all_candidate_params, n_splits, all_out, all_more_results\n\u001B[1;32m 1015\u001B[0m )\n\u001B[1;32m 1017\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m results\n\u001B[0;32m-> 1019\u001B[0m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_run_search\u001B[49m\u001B[43m(\u001B[49m\u001B[43mevaluate_candidates\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 1021\u001B[0m \u001B[38;5;66;03m# multimetric is determined here because in the case of a callable\u001B[39;00m\n\u001B[1;32m 1022\u001B[0m \u001B[38;5;66;03m# self.scoring the return type is only known after calling\u001B[39;00m\n\u001B[1;32m 1023\u001B[0m first_test_score \u001B[38;5;241m=\u001B[39m all_out[\u001B[38;5;241m0\u001B[39m][\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mtest_scores\u001B[39m\u001B[38;5;124m\"\u001B[39m]\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/model_selection/_search.py:1573\u001B[0m, in \u001B[0;36mGridSearchCV._run_search\u001B[0;34m(self, evaluate_candidates)\u001B[0m\n\u001B[1;32m 1571\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21m_run_search\u001B[39m(\u001B[38;5;28mself\u001B[39m, evaluate_candidates):\n\u001B[1;32m 1572\u001B[0m \u001B[38;5;250m \u001B[39m\u001B[38;5;124;03m\"\"\"Search all candidates in param_grid\"\"\"\u001B[39;00m\n\u001B[0;32m-> 1573\u001B[0m \u001B[43mevaluate_candidates\u001B[49m\u001B[43m(\u001B[49m\u001B[43mParameterGrid\u001B[49m\u001B[43m(\u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mparam_grid\u001B[49m\u001B[43m)\u001B[49m\u001B[43m)\u001B[49m\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/model_selection/_search.py:965\u001B[0m, in \u001B[0;36mBaseSearchCV.fit..evaluate_candidates\u001B[0;34m(candidate_params, cv, more_results)\u001B[0m\n\u001B[1;32m 957\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mverbose \u001B[38;5;241m>\u001B[39m \u001B[38;5;241m0\u001B[39m:\n\u001B[1;32m 958\u001B[0m \u001B[38;5;28mprint\u001B[39m(\n\u001B[1;32m 959\u001B[0m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mFitting \u001B[39m\u001B[38;5;132;01m{0}\u001B[39;00m\u001B[38;5;124m folds for each of \u001B[39m\u001B[38;5;132;01m{1}\u001B[39;00m\u001B[38;5;124m candidates,\u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[1;32m 960\u001B[0m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124m totalling \u001B[39m\u001B[38;5;132;01m{2}\u001B[39;00m\u001B[38;5;124m fits\u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;241m.\u001B[39mformat(\n\u001B[1;32m 961\u001B[0m n_splits, n_candidates, n_candidates \u001B[38;5;241m*\u001B[39m n_splits\n\u001B[1;32m 962\u001B[0m )\n\u001B[1;32m 963\u001B[0m )\n\u001B[0;32m--> 965\u001B[0m out \u001B[38;5;241m=\u001B[39m \u001B[43mparallel\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m 966\u001B[0m \u001B[43m \u001B[49m\u001B[43mdelayed\u001B[49m\u001B[43m(\u001B[49m\u001B[43m_fit_and_score\u001B[49m\u001B[43m)\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m 967\u001B[0m \u001B[43m \u001B[49m\u001B[43mclone\u001B[49m\u001B[43m(\u001B[49m\u001B[43mbase_estimator\u001B[49m\u001B[43m)\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 968\u001B[0m \u001B[43m \u001B[49m\u001B[43mX\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 969\u001B[0m \u001B[43m \u001B[49m\u001B[43my\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 970\u001B[0m \u001B[43m \u001B[49m\u001B[43mtrain\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mtrain\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 971\u001B[0m \u001B[43m \u001B[49m\u001B[43mtest\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mtest\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 972\u001B[0m \u001B[43m \u001B[49m\u001B[43mparameters\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mparameters\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 973\u001B[0m \u001B[43m \u001B[49m\u001B[43msplit_progress\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43m(\u001B[49m\u001B[43msplit_idx\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mn_splits\u001B[49m\u001B[43m)\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 974\u001B[0m \u001B[43m \u001B[49m\u001B[43mcandidate_progress\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43m(\u001B[49m\u001B[43mcand_idx\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mn_candidates\u001B[49m\u001B[43m)\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 975\u001B[0m \u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mfit_and_score_kwargs\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 976\u001B[0m \u001B[43m \u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 977\u001B[0m \u001B[43m \u001B[49m\u001B[38;5;28;43;01mfor\u001B[39;49;00m\u001B[43m \u001B[49m\u001B[43m(\u001B[49m\u001B[43mcand_idx\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mparameters\u001B[49m\u001B[43m)\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43m(\u001B[49m\u001B[43msplit_idx\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43m(\u001B[49m\u001B[43mtrain\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mtest\u001B[49m\u001B[43m)\u001B[49m\u001B[43m)\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;129;43;01min\u001B[39;49;00m\u001B[43m \u001B[49m\u001B[43mproduct\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m 978\u001B[0m \u001B[43m \u001B[49m\u001B[38;5;28;43menumerate\u001B[39;49m\u001B[43m(\u001B[49m\u001B[43mcandidate_params\u001B[49m\u001B[43m)\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 979\u001B[0m \u001B[43m \u001B[49m\u001B[38;5;28;43menumerate\u001B[39;49m\u001B[43m(\u001B[49m\u001B[43mcv\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43msplit\u001B[49m\u001B[43m(\u001B[49m\u001B[43mX\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43my\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mrouted_params\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43msplitter\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43msplit\u001B[49m\u001B[43m)\u001B[49m\u001B[43m)\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 980\u001B[0m \u001B[43m \u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 981\u001B[0m \u001B[43m\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 983\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;28mlen\u001B[39m(out) \u001B[38;5;241m<\u001B[39m \u001B[38;5;241m1\u001B[39m:\n\u001B[1;32m 984\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m \u001B[38;5;167;01mValueError\u001B[39;00m(\n\u001B[1;32m 985\u001B[0m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mNo fits were performed. \u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[1;32m 986\u001B[0m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mWas the CV iterator empty? \u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[1;32m 987\u001B[0m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mWere there no candidates?\u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[1;32m 988\u001B[0m )\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/sklearn/utils/parallel.py:74\u001B[0m, in \u001B[0;36mParallel.__call__\u001B[0;34m(self, iterable)\u001B[0m\n\u001B[1;32m 69\u001B[0m config \u001B[38;5;241m=\u001B[39m get_config()\n\u001B[1;32m 70\u001B[0m iterable_with_config \u001B[38;5;241m=\u001B[39m (\n\u001B[1;32m 71\u001B[0m (_with_config(delayed_func, config), args, kwargs)\n\u001B[1;32m 72\u001B[0m \u001B[38;5;28;01mfor\u001B[39;00m delayed_func, args, kwargs \u001B[38;5;129;01min\u001B[39;00m iterable\n\u001B[1;32m 73\u001B[0m )\n\u001B[0;32m---> 74\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28;43msuper\u001B[39;49m\u001B[43m(\u001B[49m\u001B[43m)\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[38;5;21;43m__call__\u001B[39;49m\u001B[43m(\u001B[49m\u001B[43miterable_with_config\u001B[49m\u001B[43m)\u001B[49m\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/joblib/parallel.py:2007\u001B[0m, in \u001B[0;36mParallel.__call__\u001B[0;34m(self, iterable)\u001B[0m\n\u001B[1;32m 2001\u001B[0m \u001B[38;5;66;03m# The first item from the output is blank, but it makes the interpreter\u001B[39;00m\n\u001B[1;32m 2002\u001B[0m \u001B[38;5;66;03m# progress until it enters the Try/Except block of the generator and\u001B[39;00m\n\u001B[1;32m 2003\u001B[0m \u001B[38;5;66;03m# reaches the first `yield` statement. This starts the asynchronous\u001B[39;00m\n\u001B[1;32m 2004\u001B[0m \u001B[38;5;66;03m# dispatch of the tasks to the workers.\u001B[39;00m\n\u001B[1;32m 2005\u001B[0m \u001B[38;5;28mnext\u001B[39m(output)\n\u001B[0;32m-> 2007\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m output \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mreturn_generator \u001B[38;5;28;01melse\u001B[39;00m \u001B[38;5;28;43mlist\u001B[39;49m\u001B[43m(\u001B[49m\u001B[43moutput\u001B[49m\u001B[43m)\u001B[49m\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/joblib/parallel.py:1650\u001B[0m, in \u001B[0;36mParallel._get_outputs\u001B[0;34m(self, iterator, pre_dispatch)\u001B[0m\n\u001B[1;32m 1647\u001B[0m \u001B[38;5;28;01myield\u001B[39;00m\n\u001B[1;32m 1649\u001B[0m \u001B[38;5;28;01mwith\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_backend\u001B[38;5;241m.\u001B[39mretrieval_context():\n\u001B[0;32m-> 1650\u001B[0m \u001B[38;5;28;01myield from\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_retrieve()\n\u001B[1;32m 1652\u001B[0m \u001B[38;5;28;01mexcept\u001B[39;00m \u001B[38;5;167;01mGeneratorExit\u001B[39;00m:\n\u001B[1;32m 1653\u001B[0m \u001B[38;5;66;03m# The generator has been garbage collected before being fully\u001B[39;00m\n\u001B[1;32m 1654\u001B[0m \u001B[38;5;66;03m# consumed. This aborts the remaining tasks if possible and warn\u001B[39;00m\n\u001B[1;32m 1655\u001B[0m \u001B[38;5;66;03m# the user if necessary.\u001B[39;00m\n\u001B[1;32m 1656\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_exception \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;01mTrue\u001B[39;00m\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/joblib/parallel.py:1762\u001B[0m, in \u001B[0;36mParallel._retrieve\u001B[0;34m(self)\u001B[0m\n\u001B[1;32m 1757\u001B[0m \u001B[38;5;66;03m# If the next job is not ready for retrieval yet, we just wait for\u001B[39;00m\n\u001B[1;32m 1758\u001B[0m \u001B[38;5;66;03m# async callbacks to progress.\u001B[39;00m\n\u001B[1;32m 1759\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m ((\u001B[38;5;28mlen\u001B[39m(\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_jobs) \u001B[38;5;241m==\u001B[39m \u001B[38;5;241m0\u001B[39m) \u001B[38;5;129;01mor\u001B[39;00m\n\u001B[1;32m 1760\u001B[0m (\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_jobs[\u001B[38;5;241m0\u001B[39m]\u001B[38;5;241m.\u001B[39mget_status(\n\u001B[1;32m 1761\u001B[0m timeout\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mtimeout) \u001B[38;5;241m==\u001B[39m TASK_PENDING)):\n\u001B[0;32m-> 1762\u001B[0m time\u001B[38;5;241m.\u001B[39msleep(\u001B[38;5;241m0.01\u001B[39m)\n\u001B[1;32m 1763\u001B[0m \u001B[38;5;28;01mcontinue\u001B[39;00m\n\u001B[1;32m 1765\u001B[0m \u001B[38;5;66;03m# We need to be careful: the job list can be filling up as\u001B[39;00m\n\u001B[1;32m 1766\u001B[0m \u001B[38;5;66;03m# we empty it and Python list are not thread-safe by\u001B[39;00m\n\u001B[1;32m 1767\u001B[0m \u001B[38;5;66;03m# default hence the use of the lock\u001B[39;00m\n", + "\u001B[0;31mKeyboardInterrupt\u001B[0m: " + ] + } + ], + "execution_count": 76 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-04T16:31:07.916623Z", + "start_time": "2024-12-04T16:31:07.838256Z" + } + }, + "cell_type": "code", + "source": " PI_model_1", + "id": "a086d6f005fbe01b", + "outputs": [ + { + "data": { + "text/plain": [ + "{'importances_mean': array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0.]),\n", + " 'importances_std': array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0.]),\n", + " 'importances': array([[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " ...,\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]])}" + ] + }, + "execution_count": 74, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 74 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "# Now weather", + "id": "ca2a7f5cafed8c90" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-04T10:15:10.941267Z", + "start_time": "2024-12-04T10:14:57.196671Z" + } + }, + "cell_type": "code", + "source": [ + "\n", + "X_base_for_cross_validation_weather_model1 = np.column_stack([\n", + " weather_data,\n", + " year_flattened,\n", + " #month_flattened,\n", + " month_encoded,\n", + " resid_encoded,\n", + " zone_encoded,\n", + " owner_encoded,\n", + " ftype_encoded,\n", + " facility_encoded,\n", + " altitude, \n", + " minimum_distance\n", + "])\n", + "\n", + "X_base_for_cross_validation_weather_model2 = np.column_stack([\n", + " weather_data,\n", + " year_flattened,\n", + " month_encoded,\n", + " resid_encoded,\n", + " zone_encoded,\n", + " owner_encoded,\n", + " ftype_encoded,\n", + " #facility_encoded,\n", + " altitude, \n", + " minimum_distance\n", + "])\n", + "\n", + "y_base_for_cross_validation_weather = y\n", + "\n", + "mask_for_cv_weather = (~np.isnan(X_base_for_cross_validation_weather_model1).any(axis=1) & ~np.isnan(y_base_for_cross_validation_weather) & (y_base_for_cross_validation_weather <= 1e4))\n", + "\n", + "X_train_m1_weather, X_test_m1_weather, y_train_m1_weather, y_test_m1_weather = train_test_split(X_base_for_cross_validation_weather_model1[mask_for_cv_weather,:], y_base_for_cross_validation_weather[mask_for_cv_weather], test_size=0.5)\n", + "\n", + "X_train_m2_weather, X_test_m2_weather, y_train_m2_weather, y_test_m2_weather = train_test_split(X_base_for_cross_validation_weather_model2[mask_for_cv_weather,:], y_base_for_cross_validation_weather[mask_for_cv_weather], test_size=0.5)\n", + "\n", + "\n", + "results_model1_weather, y_pred_model1_weather, mask_ANC_data_model1_weather = build_model(X_train_m1_weather , y_train_m1_weather, poisson = poisson, log_y=log_y, X_mask_mm=mask_threshold)\n", + "\n", + "results_model2_weather, y_pred_model2_weather, mask_ANC_data_model2_weather = build_model(X_train_m2_weather , y_train_m2_weather, poisson = poisson, log_y=log_y, X_mask_mm=mask_threshold)\n", + "\n", + "print(\"Model 1 Train\", results_model1_weather.rsquared)\n", + "print(\"Model 2 Train\", results_model2_weather.rsquared)\n", + "\n", + "y_test_pred1_weather = results_model1_weather.predict(X_test_m1_weather)\n", + "y_test_pred2_weather = results_model2_weather.predict(X_test_m2_weather)\n", + "\n", + "print(\"Module 1 Test\", r2_score(np.log(y_test_m1_weather), y_test_pred1_weather))\n", + "print(\"Module 2 Test\", r2_score(np.log(y_test_m2_weather), y_test_pred2_weather))" + ], + "id": "fa308bc3d1d92da4", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model 1 Train 0.9765587980092865\n", + "Model 2 Train 0.9269536425397121\n", + "Module 1 Test 0.663155638367235\n", + "Module 2 Test -0.0003346727400466154\n" + ] + } + ], + "execution_count": 72 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-04T10:15:28.717576Z", + "start_time": "2024-12-04T10:15:28.521241Z" + } + }, + "cell_type": "code", + "source": [ + "plt.plot(range(len(y_test_m2_weather)), y_test_m2_weather, 'o', color=\"green\", label=\"Test set\")\n", + "plt.plot(range(len(y_test_pred1_weather)), np.exp(y_test_pred1_weather), 'o', color=\"blue\", label=\"Model 1\", alpha=0.5)\n", + "plt.plot(range(len(y_test_pred2_weather)), np.exp(y_test_pred2_weather), 'o', color=\"red\", label=\"Model 2\")" + ], + "id": "ce4f35dbb97e4ede", + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 73, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 73 + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": "", + "id": "1fdf39e05447eb0a" + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/scripts/climate_change/plot_raw_reanalysis_data.py b/src/scripts/climate_change/plot_raw_reanalysis_data.py index 59418842a5..82657979bd 100644 --- a/src/scripts/climate_change/plot_raw_reanalysis_data.py +++ b/src/scripts/climate_change/plot_raw_reanalysis_data.py @@ -4,38 +4,38 @@ import pandas as pd from netCDF4 import Dataset -# # Load the dataset and the variable -# file_path = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/139ef85ab4df0a12fc01854395fc9a6d.nc" -# dataset = Dataset(file_path, mode='r') -# pr_data = dataset.variables['tp'][:] # in kg m-2 s-1 = mm s-1 x 86400 to get to day -# time_data = dataset.variables['date'][:] -# lat_data = dataset.variables['latitude'][:] -# long_data = dataset.variables['longitude'][:] -# -# ## Initial plot -# for i in range(len(lat_data)): -# for j in range(len(long_data)): -# pr_data_time_series_grid_1 = pr_data[:, i, j] -# pr_data_time_series_grid_1 *= 86400 # to get to days -# plt.plot(pr_data_time_series_grid_1) -# -# plt.title('Average Precipitation Over Time - Grid ') -# plt.ylabel('Precip (mm)') -# plt.xlabel('Time') -# # plt.show() -# -# -# weather_data_historical = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facility_lm.csv", index_col=0) -# -# for i in range(len(weather_data_historical.columns)): -# plt.plot(weather_data_historical.iloc[:, i], label = weather_data_historical.columns[i]) -# -# plt.title('Average Precipitation Over Time - Facility ') -# plt.ylabel('Precip (mm)') -# plt.xlabel('Time') -# plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) -# #plt.show() -# +# Load the dataset and the variable +file_path = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/monthly_data/724bab97773bb7ba4e1635356ad0d12.nc" +dataset = Dataset(file_path, mode='r') +pr_data = dataset.variables['tp'][:] +time_data = dataset.variables['date'][:] +lat_data = dataset.variables['latitude'][:] +long_data = dataset.variables['longitude'][:] + +## Initial plot +for i in range(len(lat_data)): + for j in range(len(long_data)): + pr_data_time_series_grid_1 = pr_data[:, i, j] + pr_data_time_series_grid_1 *= 1000 # to get to days + plt.plot(pr_data_time_series_grid_1) + +plt.title('Average Precipitation Over Time - Grid ') +plt.ylabel('Precip (mm)') +plt.xlabel('Time') +plt.show() + + +weather_data_historical = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facility_lm.csv", index_col=0) + +for i in range(len(weather_data_historical.columns)): + plt.plot(weather_data_historical.iloc[:, i], label = weather_data_historical.columns[i]) + +plt.title('Average Precipitation Over Time - Facility ') +plt.ylabel('Precip (mm)') +plt.xlabel('Time') +plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) +#plt.show() + # # # monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm.csv", index_col=0) @@ -63,25 +63,25 @@ # #plt.show() - -########### Plot daily maximum data - why is it so high? ########## - -file_path = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_maximum/2011/d7caf4e3506d13b9726aa4f77589c384.nc" -dataset = Dataset(file_path, mode='r') -pr_data = dataset.variables['tp'][:] # m per day, so multiply by 1000 to get mm per day -time_data = dataset.variables['valid_time'][:] -lat_data = dataset.variables['latitude'][:] -long_data = dataset.variables['longitude'][:] - -## Initial plot -for i in range(len(lat_data)): - for j in range(len(long_data)): - pr_data_time_series_grid = pr_data[:, i, j] - pr_data_time_series_grid *= 1000 # to get to mm - plt.plot(pr_data_time_series_grid) - -plt.title('Daily Maximum Precipitation Over Time - Grid ') -plt.ylabel('Precip (mm)') -plt.xlabel('Time') -plt.show() - +# +# ########### Plot daily maximum data - why is it so high? ########## +# +# file_path = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_maximum/2011/d7caf4e3506d13b9726aa4f77589c384.nc" +# dataset = Dataset(file_path, mode='r') +# pr_data = dataset.variables['tp'][:] # m per day, so multiply by 1000 to get mm per day +# time_data = dataset.variables['valid_time'][:] +# lat_data = dataset.variables['latitude'][:] +# long_data = dataset.variables['longitude'][:] +# +# ## Initial plot +# for i in range(len(lat_data)): +# for j in range(len(long_data)): +# pr_data_time_series_grid = pr_data[:, i, j] +# pr_data_time_series_grid *= 1000 # to get to mm +# plt.plot(pr_data_time_series_grid) +# +# plt.title('Daily Maximum Precipitation Over Time - Grid ') +# plt.ylabel('Precip (mm)') +# plt.xlabel('Time') +# plt.show() +# diff --git a/src/scripts/climate_change/process_CMIP6_data.py b/src/scripts/climate_change/process_CMIP6_data.py index a47b93fa13..ae637be828 100644 --- a/src/scripts/climate_change/process_CMIP6_data.py +++ b/src/scripts/climate_change/process_CMIP6_data.py @@ -11,8 +11,8 @@ from netCDF4 import Dataset import geopandas as gpd -five_day = True -monthly_cumulative = False +five_day = False +monthly_cumulative = True multiplier = 86400 years = range(2015, 2100) reporting_data = pd.read_csv( @@ -71,6 +71,31 @@ def extract_nc_files_from_unzipped_folders(directory): shutil.copy2(source_file_path, output_directory) +def get_facility_lat_long(reporting_facility, facilities_df, cutoff=0.90, n_matches=3): + """ + Function to find the closest matching facility name and return its latitude and longitude. + + Parameters: + - reporting_facility: The facility name for which latitude and longitude are needed. + - facilities_df : DataFrame containing facility names ('Fname') and their corresponding latitudes ('A109__Latitude') and longitudes ('A109__Longitude'). + - cutoff: The minimum similarity score for a match. Default is 0.90. + - n_matches: The maximum number of matches to consider. Default is 3. + + Returns: match_name, lat_for_facility, long_for_facility + + """ + matching_facility_name = difflib.get_close_matches(reporting_facility, facilities_df['Fname'], n=n_matches, + cutoff=cutoff) + + if matching_facility_name: + match_name = matching_facility_name[0] # Access the string directly + lat_for_facility = facilities_df.loc[facilities_df['Fname'] == match_name, "A109__Latitude"].iloc[0] + long_for_facility = facilities_df.loc[facilities_df['Fname'] == match_name, "A109__Longitude"].iloc[0] + return match_name, lat_for_facility, long_for_facility + else: + return np.nan, np.nan, np.nan + + # unzip files and extract the netCDF files base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/" @@ -180,6 +205,7 @@ def extract_nc_files_from_unzipped_folders(directory): cumulative_sum_by_grid[grid].append(max_cumulative_sums) begin_day += month_length df_cumulative_sum = pd.DataFrame.from_dict(cumulative_sum_by_grid, orient='index') + df_cumulative_sum.astype(float) df_cumulative_sum = df_cumulative_sum.T df_cumulative_sum.to_csv(Path(scenario_directory) / "five_day_cumulative_sum_by_grid.csv") @@ -188,22 +214,16 @@ def extract_nc_files_from_unzipped_folders(directory): facilities_with_location = [] cumulative_sum_by_facility = {} for reporting_facility in reporting_data.columns: - matching_facility_name = difflib.get_close_matches(reporting_facility, facilities_with_lat_long['Fname'], n=3, cutoff=0.90) - if matching_facility_name: - match_name = matching_facility_name[0] # Access the string directly - facilities_with_location.append(reporting_facility) - lat_for_facility = facilities_with_lat_long.loc[ - facilities_with_lat_long['Fname'] == match_name, "A109__Latitude"].iloc[0] - long_for_facility = facilities_with_lat_long.loc[ - facilities_with_lat_long['Fname'] == match_name, "A109__Longitude"].iloc[0] - index_for_x = ((long_data - long_for_facility)**2).argmin() - index_for_y= ((lat_data - lat_for_facility)**2).argmin() + match_name, lat_for_facility, long_for_facility = get_facility_lat_long(reporting_facility, facilities_with_lat_long) + + index_for_x = ((long_data - long_for_facility)**2).argmin() + index_for_y= ((lat_data - lat_for_facility)**2).argmin() # which grid number is it - grid = index_for_x * index_for_y + 1 - cumulative_sum_by_facility[reporting_facility] = df_cumulative_sum[grid] # across all time points + grid = index_for_x * index_for_y + 1 + cumulative_sum_by_facility[reporting_facility] = df_cumulative_sum[grid] # across all time points ## below are not in facilities file? - elif reporting_facility == "Central East Zone": + if reporting_facility == "Central East Zone": grid = general_facilities[general_facilities["District"] == "Nkhotakota"]["Grid_Index"].iloc[ 0] # furtherst east zone cumulative_sum_by_facility[reporting_facility] = df_cumulative_sum[grid] @@ -239,7 +259,9 @@ def extract_nc_files_from_unzipped_folders(directory): max_cumulative_sums = max(cumulative_sums) cumulative_sum_by_grid[grid].append(max_cumulative_sums) begin_day += month_length + df_cumulative_sum = pd.DataFrame.from_dict(cumulative_sum_by_grid, orient='index') + df_cumulative_sum.astype(float) df_cumulative_sum = df_cumulative_sum.T df_cumulative_sum.to_csv(Path(scenario_directory) / "monthly_cumulative_sum_by_grid.csv") @@ -248,23 +270,16 @@ def extract_nc_files_from_unzipped_folders(directory): ############### NOW HAVE LAT/LONG OF FACILITIES ##################### facilities_with_location = [] for reporting_facility in reporting_data.columns: - matching_facility_name = difflib.get_close_matches(reporting_facility, facilities_with_lat_long['Fname'], - n=3, cutoff=0.90) - if matching_facility_name: - match_name = matching_facility_name[0] # Access the string directly - facilities_with_location.append(reporting_facility) - lat_for_facility = facilities_with_lat_long.loc[ - facilities_with_lat_long['Fname'] == match_name, "A109__Latitude"].iloc[0] - long_for_facility = facilities_with_lat_long.loc[ - facilities_with_lat_long['Fname'] == match_name, "A109__Longitude"].iloc[0] - index_for_x = ((long_data - long_for_facility) ** 2).argmin() - index_for_y = ((lat_data - lat_for_facility) ** 2).argmin() + match_name, lat_for_facility, long_for_facility = get_facility_lat_long(reporting_facility, facilities_with_lat_long) + + index_for_x = ((long_data - long_for_facility) ** 2).argmin() + index_for_y = ((lat_data - lat_for_facility) ** 2).argmin() # which grid number is it - grid = index_for_x*index_for_y + 1 - cumulative_sum_by_facility[reporting_facility] = df_cumulative_sum[grid] # across all time points + grid = index_for_x*index_for_y + 1 + cumulative_sum_by_facility[reporting_facility] = df_cumulative_sum[grid] # across all time points ## below are not in facilities file? - elif reporting_facility == "Central East Zone": + if reporting_facility == "Central East Zone": grid = general_facilities[general_facilities["District"] == "Nkhotakota"]["Grid_Index"].iloc[ 0] # furtherst east zone cumulative_sum_by_facility[reporting_facility] = df_cumulative_sum[grid] diff --git a/src/scripts/climate_change/process_CMIP6_data_KDBall.py b/src/scripts/climate_change/process_CMIP6_data_KDBall.py new file mode 100644 index 0000000000..f123f6d070 --- /dev/null +++ b/src/scripts/climate_change/process_CMIP6_data_KDBall.py @@ -0,0 +1,237 @@ +import glob +import os +import re +import shutil +import zipfile +from pathlib import Path +import difflib +from scipy.spatial import KDTree + +import numpy as np +import pandas as pd +from netCDF4 import Dataset +import geopandas as gpd + +ANC = True +Inpatient = False +monthly_cumulative = False +multiplier = 86400 +years = range(2015, 2100) +month_lengths = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] * len(years) +if monthly_cumulative: + window_size = np.nan +else: + window_size = 5 + +if ANC: + reporting_data = pd.read_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_ANC_by_smaller_facility_lm.csv") +elif Inpatient: + reporting_data = pd.read_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_Inpatient_by_smaller_facility_lm.csv") +general_facilities = gpd.read_file("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_districts.shp") + +facilities_with_lat_long = pd.read_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_lat_long_region.csv") + + +def unzip_all_in_directory(directory): + """ + Unzips all .zip files in the specified directory, extracting each into a separate folder. + + Parameters: + directory (str): The path to the folder containing the .zip files. + """ + for filename in os.listdir(directory): + if filename.endswith('.zip'): + file_path = os.path.join(directory, filename) + extract_dir = os.path.join(directory, filename[:-4]) + os.makedirs(extract_dir, exist_ok=True) + + try: + with zipfile.ZipFile(file_path, 'r') as zip_ref: + zip_ref.extractall(extract_dir) + except zipfile.BadZipFile: + print(f"Skipped {filename}: not a valid zip file.") + +def get_facility_lat_long(reporting_facility, facilities_df, cutoff=0.90, n_matches=3): + """ + Function to find the closest matching facility name and return its latitude and longitude. + + Parameters: + - reporting_facility: The facility name for which latitude and longitude are needed. + - facilities_df : DataFrame containing facility names ('Fname') and their corresponding latitudes ('A109__Latitude') and longitudes ('A109__Longitude'). + - cutoff: The minimum similarity score for a match. Default is 0.90. + - n_matches: The maximum number of matches to consider. Default is 3. + + Returns: match_name, lat_for_facility, long_for_facility + + """ + matching_facility_name = difflib.get_close_matches(reporting_facility, facilities_df['Fname'], n=n_matches, + cutoff=cutoff) + + if matching_facility_name: + match_name = matching_facility_name[0] # Access the string directly + lat_for_facility = facilities_df.loc[facilities_df['Fname'] == match_name, "A109__Latitude"].iloc[0] + long_for_facility = facilities_df.loc[facilities_df['Fname'] == match_name, "A109__Longitude"].iloc[0] + return match_name, lat_for_facility, long_for_facility + else: + return np.nan, np.nan, np.nan + +def extract_nc_files_from_unzipped_folders(directory): + """ + Searches for .nc files in the specified directory and all its subfolders, + and copies them to the output directory, maintaining the folder structure. + + Parameters: + directory (str): The path to the folder containing the unzipped folders. + """ + output_directory = os.path.join(directory, 'nc_files') + if not os.path.exists(output_directory): + os.makedirs(output_directory) + + for root, _, files in os.walk(directory): + # Skip the output directory to prevent recursive copying + if root == output_directory: + continue + + for filename in files: + if filename.endswith('.nc'): + source_file_path = os.path.join(root, filename) + destination_file_path = os.path.join(output_directory, filename) + + # Only copy if the file does not already exist in the output directory + if not os.path.exists(destination_file_path): + shutil.copy2(source_file_path, output_directory) + + +# unzip files and extract the netCDF files + +base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/" + +scenarios = ["ssp1_1_9", "ssp2_4_5"] + +for scenario in scenarios: + scenario_directory = os.path.join(base_dir, scenario) + unzip_all_in_directory(scenario_directory) + extract_nc_files_from_unzipped_folders(scenario_directory) + + +# Put all into one csv file +file_list = glob.glob(os.path.join(base_dir, "*.nc")) +data_by_model_and_grid = {} + +for scenario in scenarios: + print(scenario) + scenario_directory = os.path.join(base_dir, scenario) + nc_file_directory = os.path.join(scenario_directory, 'nc_files') + grid_centroids = {} + for file in glob.glob(os.path.join(nc_file_directory, "*.nc")): + model = re.search(r'pr_day_(.*?)_' + scenario.replace('_', ''), file).group(1) + data_per_model = Dataset(file, mode='r') + pr_data = data_per_model.variables['pr'][:] # in kg m-2 s-1 = mm s-1 x 86400 to get to day + lat_data = data_per_model.variables['lat'][:] + long_data = data_per_model.variables['lon'][:] + lon_grid, lat_grid = np.meshgrid(long_data, lat_data) + centroids = np.column_stack((lat_grid.ravel(), lon_grid.ravel())) + + # Store centroids + grid_centroids[model] = centroids + grid_dictionary = {} + grid = 0 + for i in range(len(long_data)): + for j in range(len(lat_data)): + precip_data_for_grid = pr_data[:,j,i] # across all time points + precip_data_for_grid = precip_data_for_grid * multiplier # to get from per second to per day + grid_dictionary[grid] = precip_data_for_grid.data.values + grid += 1 + data_by_model_and_grid[model] = grid_dictionary + data_by_model_and_grid = pd.DataFrame.from_dict(data_by_model_and_grid) + data_by_model_and_grid.to_csv(Path(scenario_directory)/"data_by_model_and_grid.csv") + # now find the modal length of data for each model in the dictionary - this tells us the resolution, and most of the models are at different resolutions + non_na_lengths = data_by_model_and_grid.count() + # now drop all columns that are not that length, so the rest can be aggregated over + modal_non_na_length = non_na_lengths.mode()[0] + data_by_model_and_grid_same_length = data_by_model_and_grid.loc[:, non_na_lengths == modal_non_na_length] + na_values = data_by_model_and_grid_same_length.isna() + na_values_count = na_values.sum() + data_by_model_and_grid_same_length = data_by_model_and_grid_same_length.dropna(axis=0) + data_by_model_and_grid_same_length.to_csv(Path(scenario_directory)/"data_by_model_and_grid_modal_resolution.csv", index = True) + + # # Now loop over facilities to locate each one in a grid cell for each model + # facilities_with_location = [] + # # see which facilities have reporting data and data on latitude and longitude + # median_precipitation_by_facility = {} + # percentiles_25_by_facility = {} + # percentiles_75_by_facility = {} + # cumulative_sum_window = {} + # for reporting_facility in reporting_data.columns: + # grid_precipitation_for_facility = {} + # match_name, lat_for_facility, long_for_facility = get_facility_lat_long(reporting_facility, facilities_with_lat_long) + # if not np.isnan(long_for_facility) and not np.isnan(lat_for_facility): + # facility_location = np.array([lat_for_facility, long_for_facility]) + # kd_trees_by_model = {} + # for model in grid_centroids.keys(): + # if model in data_by_model_and_grid_same_length.columns: + # centroids = grid_centroids[model] + # kd_tree = KDTree(centroids) + # distance, closest_grid_index = kd_tree.query(facility_location) + # grid_precipitation_for_facility[model] = data_by_model_and_grid_same_length[model][closest_grid_index].data + # first_model = next(iter(grid_precipitation_for_facility)) + # median_all_timepoints_for_facility = [] + # p25_all_timepoints_for_facility = [] + # p75_all_timepoints_for_facility = [] + # + # for t in range(len(grid_precipitation_for_facility[first_model])): #all should be the same length + # per_time_point_by_model = [] + # for precip_data in grid_precipitation_for_facility.values(): + # if len(precip_data) == len(grid_precipitation_for_facility[first_model]): # ensure same time resolution + # per_time_point_by_model.append(precip_data[t]) + # p25_all_timepoints_for_facility.append(np.percentile(per_time_point_by_model, 25)) + # p75_all_timepoints_for_facility.append(np.percentile(per_time_point_by_model, 75)) + # median_all_timepoints_for_facility.append(np.median(per_time_point_by_model)) + # cumulative_sum_window[reporting_facility] = [] + # begin_day = 0 + # for month_idx, month_length in enumerate(month_lengths): + # if monthly_cumulative: + # window_size = month_length + # days_for_grid = median_all_timepoints_for_facility[begin_day:begin_day + month_length] + # cumulative_sums = [ + # sum(days_for_grid[day:day + window_size]) + # for day in range(month_length - window_size + 1) + # ] + # max_cumulative_sums = max(cumulative_sums) + # cumulative_sum_window[reporting_facility].append(max_cumulative_sums) + # begin_day += month_length + # median_precipitation_by_facility[reporting_facility] = median_all_timepoints_for_facility + # percentiles_25_by_facility[reporting_facility] = p25_all_timepoints_for_facility + # percentiles_75_by_facility[reporting_facility] = p75_all_timepoints_for_facility + # + # weather_df_median = pd.DataFrame.from_dict(median_precipitation_by_facility, orient='index').T + # weather_df_p25 = pd.DataFrame.from_dict(percentiles_25_by_facility, orient='index').T + # weather_df_p75 = pd.DataFrame.from_dict(percentiles_75_by_facility, orient='index').T + # df_cumulative_sum = pd.DataFrame.from_dict(cumulative_sum_window, orient='index').T + # df_cumulative_sum.astype(float) + # if ANC: + # weather_df_median.to_csv(Path(scenario_directory) / "median_daily_prediction_weather_by_facility_KDBall.csv", index=False) + # weather_df_p25.to_csv(Path(scenario_directory) / "p25_daily_prediction_weather_by_facility_KDBall.csv", index=False) + # weather_df_p75.to_csv(Path(scenario_directory) / "p75_daily_prediction_weather_by_facility_KDBall.csv", index=False) + # if monthly_cumulative: + # df_cumulative_sum.to_csv(Path(scenario_directory) / "monthly_cumulative_sum_by_facility_KDBall.csv") + # + # else: + # df_cumulative_sum.to_csv(Path(scenario_directory) / f"{window_size}day__cumulative_sum_by_facility_KDBall.csv") + # elif Inpatient: + # weather_df_median.to_csv(Path(scenario_directory) / "median_daily_prediction_weather_by_facility_with_inpatient_KDBall.csv", + # index=False) + # weather_df_p25.to_csv(Path(scenario_directory) / "p25_daily_prediction_weather_by_facility_with_inpatient__KDBall.csv", + # index=False) + # weather_df_p75.to_csv(Path(scenario_directory) / "p75_daily_prediction_weather_by_facility_with_inpatient__KDBall.csv", + # index=False) + # if monthly_cumulative: + # df_cumulative_sum.to_csv(Path(scenario_directory) / "monthly_cumulative_sum_by_facility_with_inpatient__KDBall.csv") + # + # else: + # df_cumulative_sum.to_csv( + # Path(scenario_directory) / f"{window_size}day__cumulative_sum_by_facility_with_inpatient__KDBall.csv") + # diff --git a/src/scripts/climate_change/process_daily_max_data.py b/src/scripts/climate_change/process_daily_max_data.py index 33eac803fe..5d8801b5f1 100644 --- a/src/scripts/climate_change/process_daily_max_data.py +++ b/src/scripts/climate_change/process_daily_max_data.py @@ -107,6 +107,8 @@ facilities_with_lat_long['Fname'] == match_name, "A109__Latitude"].iloc[0] long_for_facility = facilities_with_lat_long.loc[ facilities_with_lat_long['Fname'] == match_name, "A109__Longitude"].iloc[0] + if pd.isna(lat_for_facility): + continue index_for_x = ((long_data - long_for_facility) ** 2).argmin() index_for_y = ((lat_data - lat_for_facility) ** 2).argmin() pr_data_for_square = pr_data[:, index_for_y, index_for_x] diff --git a/src/scripts/climate_change/process_daily_total_historical_data.py b/src/scripts/climate_change/process_daily_total_historical_data.py index b8f8f168cd..8405293f98 100644 --- a/src/scripts/climate_change/process_daily_total_historical_data.py +++ b/src/scripts/climate_change/process_daily_total_historical_data.py @@ -10,7 +10,7 @@ ANC = True # facility data multiplier = 1000 -five_day = False +five_day = True cumulative = True general_facilities = gpd.read_file("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_districts.shp") @@ -59,7 +59,6 @@ years = range(2011, 2025) month_lengths = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] -window_size = 1 max_average_by_grid = {} for year in years: @@ -115,12 +114,15 @@ if matching_facility_name: match_name = matching_facility_name[0] # Access the string directly # Initialize facility key if not already - if reporting_facility not in max_average_by_facility: - max_average_by_facility[reporting_facility] = [] + lat_for_facility = facilities_with_lat_long.loc[ facilities_with_lat_long['Fname'] == match_name, "A109__Latitude"].iloc[0] long_for_facility = facilities_with_lat_long.loc[ facilities_with_lat_long['Fname'] == match_name, "A109__Longitude"].iloc[0] + if pd.isna(lat_for_facility): + continue + if reporting_facility not in max_average_by_facility: + max_average_by_facility[reporting_facility] = [] index_for_x = ((long_data - long_for_facility) ** 2).argmin() index_for_y = ((lat_data - lat_for_facility) ** 2).argmin() pr_data_for_square = pr_data[:, index_for_y, index_for_x] @@ -134,13 +136,11 @@ for day in range(month_length - window_size + 1): window_average = sum(days_for_grid[day:day + window_size]) / window_size_for_average moving_averages.append(window_average) - max_moving_average = max(moving_averages) max_average_by_facility[reporting_facility].append(max_moving_average * multiplier) begin_day += month_length # -print(max_average_by_facility) df_of_facilities = pd.DataFrame.from_dict(max_average_by_facility, orient='index') df_of_facilities = df_of_facilities.iloc[:, :-3] ## THESE ARE OCT/NOV/DEC OF 2024, and for moment don't have that reporting data df_of_facilities = df_of_facilities.T diff --git a/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py b/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py index 1ca6b9dedd..d6a7dac7dc 100644 --- a/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py +++ b/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py @@ -5,14 +5,17 @@ import numpy as np import pandas as pd from netCDF4 import Dataset +from scipy.spatial.distance import cdist # Data accessed from https://dhis2.health.gov.mw/dhis-web-data-visualizer/#/YiQK65skxjz # Reporting rate is expected reporting vs actual reporting ANC = True - -multiplier = 86400 +Inpatient = False +multiplier = 1000 if ANC: reporting_data = pd.read_csv('/Users/rem76/Desktop/Climate_change_health/Data/ANC_data/ANC_data_2011_2024.csv') +elif Inpatient: + reporting_data = pd.read_csv('/Users/rem76/Desktop/Climate_change_health/Data/Inpatient_Data/HMIS_Total_Number_Admissions.csv') else: reporting_data = pd.read_csv('/Users/rem76/Desktop/Climate_change_health/Data/Reporting_Rate/Reporting_Rate_by_smaller_facilities_2011_2024.csv') #January 2011 - January 2024 @@ -21,20 +24,21 @@ reporting_data = reporting_data.drop(columns=columns_to_drop) # drop NAs reporting_data = reporting_data.dropna(subset = reporting_data.columns[3:], how='all') # drops 90 clinics - ### now aggregate over months monthly_reporting_data_by_facility = {} - if ANC: months = set(col.split("HMIS Total Antenatal Visits ")[1] for col in reporting_data.columns if "HMIS Total Antenatal Visits " in col) - +if Inpatient: + months = set(col.split("HMIS Total # of Admissions (including Maternity) ")[1] for col in reporting_data.columns if "HMIS Total # of Admissions (including Maternity) " in col) else: months = set(col.split(" - Reporting rate ")[1] for col in reporting_data.columns if " - Reporting rate " in col) +months = set(col.split("HMIS Total Antenatal Visits ")[1] for col in reporting_data.columns if "HMIS Total Antenatal Visits " in col) # put in order months = [date.strip() for date in months] # extra spaces?? dates = pd.to_datetime(months, format='%B %Y', errors='coerce') months = dates.sort_values().strftime('%B %Y').tolist() # puts them in ascending order +print(months) for month in months: columns_of_interest_all_metrics = [reporting_data.columns[1]] + reporting_data.columns[reporting_data.columns.str.endswith(month)].tolist() data_of_interest_by_month = reporting_data[columns_of_interest_all_metrics] @@ -45,7 +49,7 @@ monthly_reporting_by_facility["facility"] = reporting_data["organisationunitname"].values # Weather data -directory = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical" # from 2011 on +directory = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/monthly_data" # from 2011 on malawi_grid = gpd.read_file("/Users/rem76/Desktop/Climate_change_health/Data/malawi_grid.shp") # find indices of interest from the malawi file @@ -56,7 +60,6 @@ file_path = os.path.join(directory, file) # Open the NetCDF file - unsure of name, should only be one though weather_monthly_all_grids = Dataset(file_path, mode='r') - # the historical data is at a different resolution to the projections. so try and find the closest possible indicses # to create a new grid for the historical data pr_data = weather_monthly_all_grids.variables['tp'][:] # total precipitation in kg m-2 s-1 = mm s-1 x 86400 to get to day @@ -65,7 +68,10 @@ date = weather_monthly_all_grids['date'][:] grid = 0 regridded_weather_data = {} +days_in_month = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] + for polygon in malawi_grid["geometry"]: + month = 0 minx, miny, maxx, maxy = polygon.bounds index_for_x_min = ((long_data - minx)**2).argmin() index_for_y_min = ((lat_data - miny)**2).argmin() @@ -73,32 +79,47 @@ index_for_y_max = ((lat_data - maxy)**2).argmin() precip_data_for_grid = pr_data[:, index_for_y_min,index_for_x_min] # across all time points - precip_data_for_grid = precip_data_for_grid * multiplier # to get from per second (monthly data) to per day OR m to mm (daily max data) - weather_by_grid[grid] = precip_data_for_grid + precip_data_for_grid = precip_data_for_grid * multiplier # tday OR m to mm (daily max data). Monthly data is average per day... + precip_data_monthly = [] + for i in range(len(precip_data_for_grid)): #from ECMWF website: monthly means is daily means, so need to multiply by number of days in a month + month = i % 12 + precip_total_for_month = precip_data_for_grid[i] * days_in_month[month] + precip_data_monthly.append(precip_total_for_month) + weather_by_grid[grid] = precip_data_monthly grid += 1 - +# ############### NOW HAVE LAT/LONG OF FACILITIES ##################### general_facilities = gpd.read_file("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_districts.shp") facilities_with_lat_long = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_lat_long_region.csv") - +print(facilities_with_lat_long.columns) weather_data_by_facility = {} facilities_with_location = [] for reporting_facility in monthly_reporting_by_facility["facility"]: matching_facility_name = difflib.get_close_matches(reporting_facility, facilities_with_lat_long['Fname'], n=3, cutoff=0.90) if matching_facility_name: match_name = matching_facility_name[0] # Access the string directly - facilities_with_location.append(reporting_facility) lat_for_facility = facilities_with_lat_long.loc[ facilities_with_lat_long['Fname'] == match_name, "A109__Latitude"].iloc[0] long_for_facility = facilities_with_lat_long.loc[ facilities_with_lat_long['Fname'] == match_name, "A109__Longitude"].iloc[0] + if pd.isna(lat_for_facility): + print(reporting_facility) + continue + facilities_with_location.append(reporting_facility) + index_for_x = ((long_data - long_for_facility)**2).argmin() index_for_y= ((lat_data - lat_for_facility)**2).argmin() precip_data_for_facility = pr_data[:, index_for_y,index_for_x] # across all time points - weather_data_by_facility[reporting_facility] = precip_data_for_facility * multiplier # to get from per second to per day + precip_data_monthly_for_facility = [] + + for i in range(len(precip_data_for_facility)): # from ECMWF website: monthly means is daily means, so need to multiply by number of days in a month + month = i % 12 + precip_total_for_month = precip_data_for_facility[i] * days_in_month[month] * multiplier + precip_data_monthly_for_facility.append(precip_total_for_month) + weather_data_by_facility[reporting_facility] = precip_data_monthly_for_facility # to get from per second to per day ## below are not in facilities file? elif reporting_facility == "Central East Zone": grid = general_facilities[general_facilities["District"] == "Nkhotakota"]["Grid_Index"].iloc[0] # furtherst east zone @@ -115,7 +136,6 @@ weather_df.columns = facilities_with_location monthly_reporting_by_facility = monthly_reporting_by_facility.set_index('facility').T monthly_reporting_by_facility.index.name = "date" - # ### Save CSVs monthly_reporting_by_facility = monthly_reporting_by_facility.loc[:, monthly_reporting_by_facility.columns.isin(facilities_with_location)] monthly_reporting_by_facility = monthly_reporting_by_facility[facilities_with_location] @@ -124,28 +144,41 @@ if ANC: monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_ANC_by_smaller_facility_lm.csv") weather_df.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_ANC_lm.csv") +if Inpatient: + monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_Inpatient_by_smaller_facility_lm.csv") + weather_df.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_Inpatient_lm.csv") else: monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm.csv") weather_df.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facility_lm.csv") - - ## Get additional data - e.g. which zone it is in, altitude included_facilities_with_lat_long = facilities_with_lat_long[ facilities_with_lat_long["Fname"].isin(facilities_with_location) ] -additional_rows = ["Zonename", "Resid", "A105", "A109__Altitude", "Ftype"] +additional_rows = ["Zonename", "Resid", "A105", "A109__Altitude", "Ftype", 'A109__Latitude', 'A109__Longitude'] expanded_facility_info = included_facilities_with_lat_long[["Fname"] + additional_rows] expanded_facility_info.columns = ["Fname"] + additional_rows expanded_facility_info.set_index("Fname", inplace=True) +# minimum distances between facilities +coordinates = expanded_facility_info[['A109__Latitude', 'A109__Longitude']].values +distances = cdist(coordinates, coordinates, metric='euclidean') +np.fill_diagonal(distances, np.inf) +expanded_facility_info['minimum_distance'] = np.nanmin(distances, axis=1) + + expanded_facility_info = expanded_facility_info.T expanded_facility_info = expanded_facility_info.reindex(columns=facilities_with_location) if ANC: expanded_facility_info.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_with_ANC.csv") +elif Inpatient: + expanded_facility_info.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_with_inpatient_days.csv") + else: expanded_facility_info.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm.csv") + + diff --git a/src/scripts/climate_change/scratch.ipynb b/src/scripts/climate_change/scratch.ipynb new file mode 100644 index 0000000000..10253a0fa0 --- /dev/null +++ b/src/scripts/climate_change/scratch.ipynb @@ -0,0 +1,294 @@ +{ + "cells": [ + { + "cell_type": "code", + "id": "initial_id", + "metadata": { + "collapsed": true, + "ExecuteTime": { + "end_time": "2024-12-02T15:47:53.508841Z", + "start_time": "2024-12-02T15:47:53.490839Z" + } + }, + "source": [ + "from pathlib import Path\n", + "\n", + "import numpy as np\n", + "from matplotlib import pyplot as plt\n", + "\n", + "from tlo import Date, Simulation, logging\n", + "from tlo.analysis.utils import parse_log_file\n", + "from tlo.methods import (\n", + " demography,\n", + " enhanced_lifestyle,\n", + " healthburden,\n", + " healthseekingbehaviour,\n", + " healthsystem,\n", + " rti,\n", + " simplified_births,\n", + " symptommanager,\n", + ")\n", + "from tlo.analysis.utils import summarize,extract_results" + ], + "outputs": [], + "execution_count": 175 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-02T15:58:14.063537Z", + "start_time": "2024-12-02T15:58:14.046153Z" + } + }, + "cell_type": "code", + "source": [ + "from tlo.analysis.utils import create_pickles_locally, parse_log_file\n", + "\n", + "# File paths\n", + "\n", + "\n", + "# Parse the log file\n", + "\n", + "folder = Path(\"/Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-11-19T091704Z\")\n", + "# # get the pickled files if not generated at the batch run\n", + "create_pickles_locally(scenario_output_dir = folder, compressed_file_name_prefix='longterm_trends_all_diseases__')" + ], + "id": "59e5fd5c2ebc1d63", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Opening /Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-11-19T091704Z/0/9/longterm_trends_all_diseases__2024-11-19T091939.log\n", + "Processing log file /Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-11-19T091704Z/0/9/longterm_trends_all_diseases__2024-11-19T091939.log\n", + "Writing module-specific log files to /Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-11-19T091704Z/0/9\n", + "Finished writing module-specific log files.\n", + " - Writing tlo.simulation.pickle\n", + "Opening /Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-11-19T091704Z/0/0/longterm_trends_all_diseases__2024-11-19T091958.log\n", + "Processing log file /Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-11-19T091704Z/0/0/longterm_trends_all_diseases__2024-11-19T091958.log\n", + "Writing module-specific log files to /Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-11-19T091704Z/0/0\n", + "Finished writing module-specific log files.\n", + " - Writing tlo.simulation.pickle\n", + "Opening /Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-11-19T091704Z/0/7/longterm_trends_all_diseases__2024-11-19T091939.log\n", + "Processing log file /Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-11-19T091704Z/0/7/longterm_trends_all_diseases__2024-11-19T091939.log\n", + "Writing module-specific log files to /Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-11-19T091704Z/0/7\n", + "Finished writing module-specific log files.\n", + " - Writing tlo.simulation.pickle\n", + "Opening /Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-11-19T091704Z/0/6/longterm_trends_all_diseases__2024-11-19T091939.log\n", + "Processing log file /Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-11-19T091704Z/0/6/longterm_trends_all_diseases__2024-11-19T091939.log\n", + "Writing module-specific log files to /Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-11-19T091704Z/0/6\n", + "Finished writing module-specific log files.\n", + " - Writing tlo.simulation.pickle\n", + "Opening /Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-11-19T091704Z/0/1/longterm_trends_all_diseases__2024-11-19T091953.log\n", + "Processing log file /Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-11-19T091704Z/0/1/longterm_trends_all_diseases__2024-11-19T091953.log\n", + "Writing module-specific log files to /Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-11-19T091704Z/0/1\n", + "Finished writing module-specific log files.\n", + " - Writing tlo.simulation.pickle\n", + "Opening /Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-11-19T091704Z/0/8/longterm_trends_all_diseases__2024-11-19T091939.log\n", + "Processing log file /Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-11-19T091704Z/0/8/longterm_trends_all_diseases__2024-11-19T091939.log\n", + "Writing module-specific log files to /Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-11-19T091704Z/0/8\n", + "Finished writing module-specific log files.\n", + " - Writing tlo.simulation.pickle\n", + "Opening /Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-11-19T091704Z/0/4/longterm_trends_all_diseases__2024-11-19T091959.log\n", + "Processing log file /Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-11-19T091704Z/0/4/longterm_trends_all_diseases__2024-11-19T091959.log\n", + "Writing module-specific log files to /Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-11-19T091704Z/0/4\n", + "Finished writing module-specific log files.\n", + " - Writing tlo.simulation.pickle\n", + "Opening /Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-11-19T091704Z/0/3/longterm_trends_all_diseases__2024-11-19T091943.log\n", + "Processing log file /Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-11-19T091704Z/0/3/longterm_trends_all_diseases__2024-11-19T091943.log\n", + "Writing module-specific log files to /Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-11-19T091704Z/0/3\n", + "Finished writing module-specific log files.\n", + " - Writing tlo.simulation.pickle\n", + "Opening /Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-11-19T091704Z/0/2/longterm_trends_all_diseases__2024-11-19T091942.log\n", + "Processing log file /Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-11-19T091704Z/0/2/longterm_trends_all_diseases__2024-11-19T091942.log\n", + "Writing module-specific log files to /Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-11-19T091704Z/0/2\n", + "Finished writing module-specific log files.\n", + " - Writing tlo.simulation.pickle\n", + "Opening /Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-11-19T091704Z/0/5/longterm_trends_all_diseases__2024-11-19T091946.log\n", + "Processing log file /Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-11-19T091704Z/0/5/longterm_trends_all_diseases__2024-11-19T091946.log\n", + "Writing module-specific log files to /Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-11-19T091704Z/0/5\n", + "Finished writing module-specific log files.\n", + " - Writing tlo.simulation.pickle\n" + ] + } + ], + "execution_count": 178 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-02T15:47:55.191534Z", + "start_time": "2024-12-02T15:47:54.186582Z" + } + }, + "cell_type": "code", + "source": [ + "\n", + "\n", + "pop_model = summarize(extract_results(\n", + " folder,\n", + " module=\"tlo.methods.demography\",\n", + " key=\"population\",\n", + " column=\"total\",\n", + " index=\"date\",\n", + " do_scaling=True\n", + "),\n", + " collapse_columns=True\n", + ")\n", + "\n", + "mean_li_urban_immediate_death = summarize(extract_results(\n", + " folder,\n", + " module=\"tlo.methods.demography.detail\",\n", + " key=\"properties_of_deceased_persons\",\n", + " custom_generate_series=(\n", + " lambda df: df.loc[(df['li_urban']) &\n", + " (df['cause_of_death'].str.contains('RTI_imm_death'))].assign(\n", + " year=df['date'].dt.year).groupby(['year'])['year'].count()\n", + " ),\n", + " do_scaling=True\n", + "))\n", + "\n", + "mean_li_urban_immediate_death = mean_li_urban_immediate_death.reset_index()\n", + "mean_li_urban_immediate_death.columns = ['year', 'lower', 'mean', 'upper']\n", + "\n", + "mean_li_urban_non_immediate_death = summarize(extract_results(\n", + " folder,\n", + " module=\"tlo.methods.demography.detail\",\n", + " key=\"properties_of_deceased_persons\",\n", + " custom_generate_series=(\n", + " lambda df: df.loc[(df['li_urban']) &\n", + " (df['cause_of_death'].str.contains('RTI_')) &\n", + " (~df['cause_of_death'].str.contains('RTI_imm_death'))].assign(\n", + " year=df['date'].dt.year).groupby(['year'])['year'].count()\n", + " ),\n", + " do_scaling=True\n", + "))\n", + "\n", + "mean_li_urban_non_immediate_death = mean_li_urban_non_immediate_death.reset_index()\n", + "mean_li_urban_non_immediate_death.columns = ['year', 'lower', 'mean', 'upper']\n", + "\n", + "pop_model = pop_model.reset_index()\n", + "pop_model.columns = ['year', 'lower', 'mean', 'upper']\n", + "\n", + "mean_li_all_immediate_death = summarize(extract_results(\n", + " folder,\n", + " module=\"tlo.methods.demography.detail\",\n", + " key=\"properties_of_deceased_persons\",\n", + " custom_generate_series=(\n", + " lambda df: df.loc[\n", + " (df['cause_of_death'].str.contains('RTI_imm_death'))].assign(\n", + " year=df['date'].dt.year).groupby(['year'])['year'].count()\n", + " ),\n", + " do_scaling=True\n", + "))\n", + "\n", + "mean_li_all_immediate_death = mean_li_all_immediate_death.reset_index()\n", + "mean_li_all_immediate_death.columns = ['year', 'lower', 'mean', 'upper']\n", + "\n", + "mean_li_all_non_immediate_death = summarize(extract_results(\n", + " folder,\n", + " module=\"tlo.methods.demography.detail\",\n", + " key=\"properties_of_deceased_persons\",\n", + " custom_generate_series=(\n", + " lambda df: df.loc[\n", + " (df['cause_of_death'].str.contains('RTI_')) &\n", + " (~df['cause_of_death'].str.contains('RTI_imm_death'))].assign(\n", + " year=df['date'].dt.year).groupby(['year'])['year'].count()\n", + " ),\n", + " do_scaling=True\n", + "))\n", + "\n", + "mean_li_all_non_immediate_death = mean_li_all_non_immediate_death.reset_index()\n", + "mean_li_all_non_immediate_death.columns = ['year', 'lower', 'mean', 'upper']\n", + "mean_li_all_non_immediate_death = mean_li_all_non_immediate_death.sort_values(by='year', ascending=True)\n", + "\n", + "mean_li_all_death_with_med = summarize(extract_results(\n", + " folder,\n", + " module=\"tlo.methods.demography.detail\",\n", + " key=\"properties_of_deceased_persons\",\n", + " custom_generate_series=(\n", + " lambda df: df.loc[(df['cause_of_death'].str.contains('RTI_death_with_med'))].assign(\n", + " year=df['date'].dt.year).groupby(['year'])['year'].count()\n", + " ),\n", + " do_scaling=True\n", + "))\n", + "\n", + "mean_li_all_death_with_med = mean_li_all_death_with_med.reset_index()\n", + "mean_li_all_death_with_med.columns = ['year', 'lower', 'mean', 'upper']\n", + "mean_li_all_death_with_med = mean_li_all_death_with_med.sort_values(by='year', ascending=True)\n", + "\n", + "plt.plot(range(len(mean_li_all_non_immediate_death['year'])),\n", + " mean_li_all_non_immediate_death['mean'] / pop_model['mean'] * 100000, color='blue')\n", + "plt.title(\"mean_li_all_immediate_death\")\n", + "plt.ylabel(\"Deaths due to RTI per 100,000\")\n", + "plt.xlabel(\"Year\")\n", + "plt.show()\n", + "\n", + "mean_li_all_immediate_death = mean_li_all_immediate_death.sort_values(by='year', ascending=True)\n", + "plt.plot(range(len(mean_li_all_immediate_death['year'])),\n", + " mean_li_all_immediate_death['mean'] / pop_model['mean'] * 100000, color='red')\n", + "plt.title(\"mean_li_all_immediate_death\")\n", + "plt.ylabel(\"Deaths due to RTI per 100,000\")\n", + "plt.xlabel(\"Year\")\n", + "plt.show()\n", + "\n", + "mean_li_all_death_with_med = mean_li_all_death_with_med.sort_values(by='year', ascending=True)\n", + "plt.plot(range(len(mean_li_all_death_with_med['year'])),\n", + " mean_li_all_death_with_med['mean'] / pop_model['mean'][0:len(mean_li_all_death_with_med['mean'])] * 100000,\n", + " color='blue')\n", + "plt.title(\"mean_li_all_death_with_med\")\n", + "plt.ylabel(\"Deaths due to RTI per 100,000\")\n", + "plt.xlabel(\"Year\")\n", + "plt.show()\n" + ], + "id": "683c4a9ec16bc46e", + "outputs": [ + { + "ename": "ValueError", + "evalue": "All objects passed were None", + "output_type": "error", + "traceback": [ + "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m", + "\u001B[0;31mValueError\u001B[0m Traceback (most recent call last)", + "Cell \u001B[0;32mIn[176], line 3\u001B[0m\n\u001B[1;32m 1\u001B[0m folder \u001B[38;5;241m=\u001B[39m Path(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124m/Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-11-19T091704Z\u001B[39m\u001B[38;5;124m\"\u001B[39m)\n\u001B[0;32m----> 3\u001B[0m pop_model \u001B[38;5;241m=\u001B[39m summarize(\u001B[43mextract_results\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m 4\u001B[0m \u001B[43m \u001B[49m\u001B[43mfolder\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 5\u001B[0m \u001B[43m \u001B[49m\u001B[43mmodule\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;124;43m\"\u001B[39;49m\u001B[38;5;124;43mtlo.methods.demography\u001B[39;49m\u001B[38;5;124;43m\"\u001B[39;49m\u001B[43m,\u001B[49m\n\u001B[1;32m 6\u001B[0m \u001B[43m \u001B[49m\u001B[43mkey\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;124;43m\"\u001B[39;49m\u001B[38;5;124;43mpopulation\u001B[39;49m\u001B[38;5;124;43m\"\u001B[39;49m\u001B[43m,\u001B[49m\n\u001B[1;32m 7\u001B[0m \u001B[43m \u001B[49m\u001B[43mcolumn\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;124;43m\"\u001B[39;49m\u001B[38;5;124;43mtotal\u001B[39;49m\u001B[38;5;124;43m\"\u001B[39;49m\u001B[43m,\u001B[49m\n\u001B[1;32m 8\u001B[0m \u001B[43m \u001B[49m\u001B[43mindex\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;124;43m\"\u001B[39;49m\u001B[38;5;124;43mdate\u001B[39;49m\u001B[38;5;124;43m\"\u001B[39;49m\u001B[43m,\u001B[49m\n\u001B[1;32m 9\u001B[0m \u001B[43m \u001B[49m\u001B[43mdo_scaling\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43;01mTrue\u001B[39;49;00m\n\u001B[1;32m 10\u001B[0m \u001B[43m)\u001B[49m,\n\u001B[1;32m 11\u001B[0m collapse_columns\u001B[38;5;241m=\u001B[39m\u001B[38;5;28;01mTrue\u001B[39;00m\n\u001B[1;32m 12\u001B[0m )\n\u001B[1;32m 14\u001B[0m mean_li_urban_immediate_death \u001B[38;5;241m=\u001B[39m summarize(extract_results(\n\u001B[1;32m 15\u001B[0m folder,\n\u001B[1;32m 16\u001B[0m module\u001B[38;5;241m=\u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mtlo.methods.demography.detail\u001B[39m\u001B[38;5;124m\"\u001B[39m,\n\u001B[0;32m (...)\u001B[0m\n\u001B[1;32m 23\u001B[0m do_scaling\u001B[38;5;241m=\u001B[39m\u001B[38;5;28;01mTrue\u001B[39;00m\n\u001B[1;32m 24\u001B[0m ))\n\u001B[1;32m 26\u001B[0m mean_li_urban_immediate_death \u001B[38;5;241m=\u001B[39m mean_li_urban_immediate_death\u001B[38;5;241m.\u001B[39mreset_index()\n", + "File \u001B[0;32m~/PycharmProjects/TLOmodel/src/tlo/analysis/utils.py:341\u001B[0m, in \u001B[0;36mextract_results\u001B[0;34m(results_folder, module, key, column, index, custom_generate_series, do_scaling)\u001B[0m\n\u001B[1;32m 338\u001B[0m res[draw_run] \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;01mNone\u001B[39;00m\n\u001B[1;32m 340\u001B[0m \u001B[38;5;66;03m# Use pd.concat to compile results (skips dict items where the values is None)\u001B[39;00m\n\u001B[0;32m--> 341\u001B[0m _concat \u001B[38;5;241m=\u001B[39m \u001B[43mpd\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mconcat\u001B[49m\u001B[43m(\u001B[49m\u001B[43mres\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43maxis\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;241;43m1\u001B[39;49m\u001B[43m)\u001B[49m\n\u001B[1;32m 342\u001B[0m _concat\u001B[38;5;241m.\u001B[39mcolumns\u001B[38;5;241m.\u001B[39mnames \u001B[38;5;241m=\u001B[39m [\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mdraw\u001B[39m\u001B[38;5;124m'\u001B[39m, \u001B[38;5;124m'\u001B[39m\u001B[38;5;124mrun\u001B[39m\u001B[38;5;124m'\u001B[39m] \u001B[38;5;66;03m# name the levels of the columns multi-index\u001B[39;00m\n\u001B[1;32m 343\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m _concat\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/pandas/core/reshape/concat.py:382\u001B[0m, in \u001B[0;36mconcat\u001B[0;34m(objs, axis, join, ignore_index, keys, levels, names, verify_integrity, sort, copy)\u001B[0m\n\u001B[1;32m 379\u001B[0m \u001B[38;5;28;01melif\u001B[39;00m copy \u001B[38;5;129;01mand\u001B[39;00m using_copy_on_write():\n\u001B[1;32m 380\u001B[0m copy \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;01mFalse\u001B[39;00m\n\u001B[0;32m--> 382\u001B[0m op \u001B[38;5;241m=\u001B[39m \u001B[43m_Concatenator\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m 383\u001B[0m \u001B[43m \u001B[49m\u001B[43mobjs\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 384\u001B[0m \u001B[43m \u001B[49m\u001B[43maxis\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43maxis\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 385\u001B[0m \u001B[43m \u001B[49m\u001B[43mignore_index\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mignore_index\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 386\u001B[0m \u001B[43m \u001B[49m\u001B[43mjoin\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mjoin\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 387\u001B[0m \u001B[43m \u001B[49m\u001B[43mkeys\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mkeys\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 388\u001B[0m \u001B[43m \u001B[49m\u001B[43mlevels\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mlevels\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 389\u001B[0m \u001B[43m \u001B[49m\u001B[43mnames\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mnames\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 390\u001B[0m \u001B[43m \u001B[49m\u001B[43mverify_integrity\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mverify_integrity\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 391\u001B[0m \u001B[43m \u001B[49m\u001B[43mcopy\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mcopy\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 392\u001B[0m \u001B[43m \u001B[49m\u001B[43msort\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43msort\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 393\u001B[0m \u001B[43m\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 395\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m op\u001B[38;5;241m.\u001B[39mget_result()\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/pandas/core/reshape/concat.py:445\u001B[0m, in \u001B[0;36m_Concatenator.__init__\u001B[0;34m(self, objs, axis, join, keys, levels, names, ignore_index, verify_integrity, copy, sort)\u001B[0m\n\u001B[1;32m 442\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mverify_integrity \u001B[38;5;241m=\u001B[39m verify_integrity\n\u001B[1;32m 443\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mcopy \u001B[38;5;241m=\u001B[39m copy\n\u001B[0;32m--> 445\u001B[0m objs, keys \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_clean_keys_and_objs\u001B[49m\u001B[43m(\u001B[49m\u001B[43mobjs\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mkeys\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 447\u001B[0m \u001B[38;5;66;03m# figure out what our result ndim is going to be\u001B[39;00m\n\u001B[1;32m 448\u001B[0m ndims \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_get_ndims(objs)\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/pandas/core/reshape/concat.py:541\u001B[0m, in \u001B[0;36m_Concatenator._clean_keys_and_objs\u001B[0;34m(self, objs, keys)\u001B[0m\n\u001B[1;32m 538\u001B[0m keys \u001B[38;5;241m=\u001B[39m Index(clean_keys, name\u001B[38;5;241m=\u001B[39mname, dtype\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mgetattr\u001B[39m(keys, \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mdtype\u001B[39m\u001B[38;5;124m\"\u001B[39m, \u001B[38;5;28;01mNone\u001B[39;00m))\n\u001B[1;32m 540\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;28mlen\u001B[39m(objs_list) \u001B[38;5;241m==\u001B[39m \u001B[38;5;241m0\u001B[39m:\n\u001B[0;32m--> 541\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m \u001B[38;5;167;01mValueError\u001B[39;00m(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mAll objects passed were None\u001B[39m\u001B[38;5;124m\"\u001B[39m)\n\u001B[1;32m 543\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m objs_list, keys\n", + "\u001B[0;31mValueError\u001B[0m: All objects passed were None" + ] + } + ], + "execution_count": 176 + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": "", + "id": "f2a260cfc87adadc" + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/scripts/longterm_projections/longterm_projections_draws.json b/src/scripts/longterm_projections/longterm_projections_draws.json new file mode 100644 index 0000000000..6c09fc27aa --- /dev/null +++ b/src/scripts/longterm_projections/longterm_projections_draws.json @@ -0,0 +1,161 @@ +{ + "scenario_script_path": "src/scripts/longterm_projections/longterm_projections.py", + "scenario_seed": 0, + "arguments": [], + "runs_per_draw": 10, + "draws": [ + { + "draw_number": 0, + "parameters": { + "SymptomManager": { + "spurious_symptoms": true + }, + "HealthSystem": { + "Service_Availability": [ + "*" + ], + "use_funded_or_actual_staffing": "actual", + "mode_appt_constraints": 1, + "cons_availability": "default", + "beds_availability": "default", + "equip_availability": "all" + } + }, + "draw_name": "0" + }, + { + "draw_number": 1, + "parameters": { + "SymptomManager": { + "spurious_symptoms": true + }, + "HealthSystem": { + "Service_Availability": [ + "*" + ], + "use_funded_or_actual_staffing": "funded_plus", + "mode_appt_constraints": 1, + "cons_availability": "default", + "beds_availability": "all", + "equip_availability": "default", + "cons_availability_postSwitch": "all", + "year_cons_availability_switch": 2020, + "equip_availability_postSwitch": "all", + "year_equip_availability_switch": 2020 + }, + "ImprovedHealthSystemAndCareSeekingScenarioSwitcher": { + "max_healthsystem_function": [ + false, + true + ], + "max_healthcare_seeking": [ + false, + true + ], + "year_of_switch": 2020 + }, + "Malaria": { + "type_of_scaleup": "max", + "scaleup_start_year": 2020 + }, + "Tb": { + "type_of_scaleup": "max", + "scaleup_start_year": 2020 + }, + "Hiv": { + "type_of_scaleup": "max", + "scaleup_start_year": 2020 + } + }, + "draw_name": "1" + }, + { + "draw_number": 2, + "parameters": { + "SymptomManager": { + "spurious_symptoms": true + }, + "HealthSystem": { + "Service_Availability": [ + "*" + ], + "use_funded_or_actual_staffing": "actual", + "mode_appt_constraints": 1, + "cons_availability": "default", + "beds_availability": "default", + "equip_availability": "all" + }, + "Malaria": { + "type_of_scaleup": "target", + "scaleup_start_year": 2020 + }, + "Tb": { + "type_of_scaleup": "target", + "scaleup_start_year": 2020 + }, + "Hiv": { + "type_of_scaleup": "target", + "scaleup_start_year": 2020 + } + }, + "draw_name": "2" + }, + { + "draw_number": 3, + "parameters": { + "SymptomManager": { + "spurious_symptoms": true + }, + "HealthSystem": { + "Service_Availability": [ + "*" + ], + "use_funded_or_actual_staffing": "actual", + "mode_appt_constraints": 1, + "cons_availability": "default", + "beds_availability": "default", + "equip_availability": "all" + }, + "Lifestyle": { + "r_urban": 0.00075, + "r_higher_bmi": 0.00075, + "r_high_salt_urban": 0.0045000000000000005, + "r_high_sugar": 0.00015000000000000001, + "r_low_ex": 0.0015, + "r_tob": 0.0002666666666666667, + "r_ex_alc": 0.0045000000000000005, + "r_non_wood_burn_stove": 0.0015, + "r_clean_drinking_water": 0.0015, + "r_improved_sanitation": 0.0015, + "r_access_handwashing": 0.0015 + } + }, + "draw_name": "3" + }, + { + "draw_number": 4, + "parameters": { + "SymptomManager": { + "spurious_symptoms": true + }, + "HealthSystem": { + "Service_Availability": [ + "*" + ], + "use_funded_or_actual_staffing": "actual", + "mode_appt_constraints": 1, + "cons_availability": "default", + "beds_availability": "default", + "equip_availability": "all" + }, + "Lifestyle": { + "r_tob": 0.0006000000000000001, + "r_ex_alc": 0.0045000000000000005 + } + }, + "draw_name": "4" + } + ], + "commit": "fc3328e0ad4ca56c6ce39a4af283331468c3fe98", + "github": "https://github.com/UCL/TLOmodel/tree/fc3328e0ad4ca56c6ce39a4af283331468c3fe98" +} \ No newline at end of file From 674bf96575377d35a1925b48c917f7677faf19d5 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 3 Jan 2025 13:59:06 +0000 Subject: [PATCH 142/291] Added in facilities to map --- .../climate_change/grid_malawi_CMIP6.py | 39 ++++++++++++++++++- 1 file changed, 38 insertions(+), 1 deletion(-) diff --git a/src/scripts/climate_change/grid_malawi_CMIP6.py b/src/scripts/climate_change/grid_malawi_CMIP6.py index aee593ee9c..d545f99e5c 100644 --- a/src/scripts/climate_change/grid_malawi_CMIP6.py +++ b/src/scripts/climate_change/grid_malawi_CMIP6.py @@ -11,7 +11,7 @@ # Load netCDF data for gridding info #file_path = "/Users/rem76/Downloads/821bebfbcee0609d233c09e8b2bbc1f3/pr_Amon_UKESM1-0-LL_ssp119_r1i1p1f2_gn_20150116-20991216.nc" -file_path_historical_data = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/139ef85ab4df0a12fc01854395fc9a6d.nc" +file_path_historical_data = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/2011/60ab007aa16d679a32f9c3e186d2f744.nc" dataset = Dataset(file_path_historical_data, mode='r') print(dataset.variables.keys()) pr_data = dataset.variables['tp'][:] # ['pr'][:] pr for projections, tp for historical @@ -92,3 +92,40 @@ plt.show() + +# Add in facility information +expanded_facility_info = pd.read_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_with_ANC.csv", + index_col=0 +) + +# Transpose and reset index to reshape into long format +long_format = expanded_facility_info.T.reset_index() +long_format.columns = ['Facility', 'Zonename', 'Resid', 'A105', 'A109__Altitude', 'Ftype', + 'A109__Latitude', 'A109__Longitude', 'minimum_distance'] + +facilities_gdf = gpd.GeoDataFrame( + long_format, + geometry=gpd.points_from_xy(long_format['A109__Longitude'], long_format['A109__Latitude']), + crs="EPSG:4326" +) + +# Read Malawi shapefile +fig, ax = plt.subplots(figsize=(10, 10)) + +# Plot the map of Malawi +malawi_admin2.plot(ax=ax, edgecolor='black', color='white') +#grid.plot(ax=ax, edgecolor='#1C6E8C', color='white') +grid_clipped_ADM2.plot(ax=ax,edgecolor='#1C6E8C', alpha=0.4) +grid_clipped_ADM1.plot(column='ADM1_EN', ax=ax, cmap=cmap, edgecolor='#1C6E8C', alpha=0.7) + +# Plot the facilities +facilities_gdf.plot(ax=ax, color='#FEB95F', markersize=10, label='Facilities') + +# Customize the plot +plt.title("Malawi with Facilities") +plt.xlabel("Longitude") +plt.ylabel("Latitude") +plt.legend() + +plt.show() From 20331e454496b041b835ed24e82ee381809e4142 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 3 Jan 2025 14:17:00 +0000 Subject: [PATCH 143/291] Added calculation of average precipitation --- ...g_and_monthly_weather_data_small_facilities.py | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py b/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py index d6a7dac7dc..5528bcf36a 100644 --- a/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py +++ b/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py @@ -169,10 +169,21 @@ np.fill_diagonal(distances, np.inf) expanded_facility_info['minimum_distance'] = np.nanmin(distances, axis=1) - +average_precipitation_by_facility = { + facility: np.mean(precipitation) + for facility, precipitation in weather_data_by_facility.items() +} + +average_precipitation_df = pd.DataFrame.from_dict( + average_precipitation_by_facility, orient='index', columns=['average_precipitation'] +) + +average_precipitation_df.index.name = "Fname" +expanded_facility_info['average_precipitation'] = expanded_facility_info.index.map( + average_precipitation_df['average_precipitation'] +) expanded_facility_info = expanded_facility_info.T expanded_facility_info = expanded_facility_info.reindex(columns=facilities_with_location) - if ANC: expanded_facility_info.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_with_ANC.csv") elif Inpatient: From 6b108694fb784936b0af8986d1f9771627508299 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 3 Jan 2025 15:24:47 +0000 Subject: [PATCH 144/291] Coloured dots of clinics by average annual precipitation --- .../climate_change/grid_malawi_CMIP6.py | 35 ++++++++++++------- 1 file changed, 22 insertions(+), 13 deletions(-) diff --git a/src/scripts/climate_change/grid_malawi_CMIP6.py b/src/scripts/climate_change/grid_malawi_CMIP6.py index d545f99e5c..f948cd39bb 100644 --- a/src/scripts/climate_change/grid_malawi_CMIP6.py +++ b/src/scripts/climate_change/grid_malawi_CMIP6.py @@ -8,7 +8,7 @@ from netCDF4 import Dataset from shapely.geometry import Polygon import matplotlib.cm as cm - +from matplotlib import colors as mcolors # Load netCDF data for gridding info #file_path = "/Users/rem76/Downloads/821bebfbcee0609d233c09e8b2bbc1f3/pr_Amon_UKESM1-0-LL_ssp119_r1i1p1f2_gn_20150116-20991216.nc" file_path_historical_data = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/2011/60ab007aa16d679a32f9c3e186d2f744.nc" @@ -91,18 +91,22 @@ ax.set_ylabel('Latitude') -plt.show() +#plt.show() # Add in facility information + expanded_facility_info = pd.read_csv( "/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_with_ANC.csv", index_col=0 ) -# Transpose and reset index to reshape into long format long_format = expanded_facility_info.T.reset_index() -long_format.columns = ['Facility', 'Zonename', 'Resid', 'A105', 'A109__Altitude', 'Ftype', - 'A109__Latitude', 'A109__Longitude', 'minimum_distance'] +long_format.columns = [ + 'Facility', 'Zonename', 'Resid', 'A105', 'A109__Altitude', 'Ftype', + 'A109__Latitude', 'A109__Longitude', 'minimum_distance', 'average_precipitation' +] + +long_format = long_format.dropna(subset=['A109__Latitude']) facilities_gdf = gpd.GeoDataFrame( long_format, @@ -110,20 +114,25 @@ crs="EPSG:4326" ) -# Read Malawi shapefile +facilities_gdf['average_precipitation'] = pd.to_numeric(facilities_gdf['average_precipitation'], errors='coerce') + +norm = mcolors.Normalize(vmin=facilities_gdf['average_precipitation'].min(), + vmax=facilities_gdf['average_precipitation'].max()) +cmap_facilities = plt.cm.YlOrBr +facilities_gdf['color'] = facilities_gdf['average_precipitation'].apply(lambda x: cmap_facilities(norm(x))) + fig, ax = plt.subplots(figsize=(10, 10)) -# Plot the map of Malawi malawi_admin2.plot(ax=ax, edgecolor='black', color='white') -#grid.plot(ax=ax, edgecolor='#1C6E8C', color='white') -grid_clipped_ADM2.plot(ax=ax,edgecolor='#1C6E8C', alpha=0.4) +grid_clipped_ADM2.plot(ax=ax, edgecolor='#1C6E8C', alpha=0.4) grid_clipped_ADM1.plot(column='ADM1_EN', ax=ax, cmap=cmap, edgecolor='#1C6E8C', alpha=0.7) -# Plot the facilities -facilities_gdf.plot(ax=ax, color='#FEB95F', markersize=10, label='Facilities') +facilities_gdf.plot(ax=ax, color=facilities_gdf['color'], markersize=10, label='Facilities') -# Customize the plot -plt.title("Malawi with Facilities") +sm = plt.cm.ScalarMappable(cmap=cmap_facilities, norm=norm) +sm.set_array([]) +cbar = plt.colorbar(sm, ax=ax, orientation='vertical', fraction=0.03, pad=0.04) +cbar.set_label('Average Precipitation') plt.xlabel("Longitude") plt.ylabel("Latitude") plt.legend() From dba70c85147d2e69953bf65ecf80ed7403d5cc35 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 3 Jan 2025 15:25:17 +0000 Subject: [PATCH 145/291] removed facilities --- src/scripts/climate_change/grid_malawi_CMIP6.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/scripts/climate_change/grid_malawi_CMIP6.py b/src/scripts/climate_change/grid_malawi_CMIP6.py index f948cd39bb..724ffb7c4f 100644 --- a/src/scripts/climate_change/grid_malawi_CMIP6.py +++ b/src/scripts/climate_change/grid_malawi_CMIP6.py @@ -127,7 +127,7 @@ grid_clipped_ADM2.plot(ax=ax, edgecolor='#1C6E8C', alpha=0.4) grid_clipped_ADM1.plot(column='ADM1_EN', ax=ax, cmap=cmap, edgecolor='#1C6E8C', alpha=0.7) -facilities_gdf.plot(ax=ax, color=facilities_gdf['color'], markersize=10, label='Facilities') +facilities_gdf.plot(ax=ax, color=facilities_gdf['color'], markersize=10) sm = plt.cm.ScalarMappable(cmap=cmap_facilities, norm=norm) sm.set_array([]) From 9654cc38a80d7f78fcb085d669f08a2a71e795af Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 3 Jan 2025 15:25:41 +0000 Subject: [PATCH 146/291] removed facilities legend --- src/scripts/climate_change/grid_malawi_CMIP6.py | 1 - 1 file changed, 1 deletion(-) diff --git a/src/scripts/climate_change/grid_malawi_CMIP6.py b/src/scripts/climate_change/grid_malawi_CMIP6.py index 724ffb7c4f..e660fdc81f 100644 --- a/src/scripts/climate_change/grid_malawi_CMIP6.py +++ b/src/scripts/climate_change/grid_malawi_CMIP6.py @@ -135,6 +135,5 @@ cbar.set_label('Average Precipitation') plt.xlabel("Longitude") plt.ylabel("Latitude") -plt.legend() plt.show() From baf90388324b510fbb90e4be485cfe291d9a7644 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 3 Jan 2025 15:46:07 +0000 Subject: [PATCH 147/291] isort --- .../climate_change/CIL_CMIP6_downscaling.py | 12 +- src/scripts/climate_change/cohort_model.ipynb | 4817 +++++++++-------- .../climate_change/grid_malawi_CMIP6.py | 6 +- ...al_realtionship_reporting_precipitation.py | 8 +- ...ip_reporting_precipitation_missing_data.py | 4 +- .../linear_model_predicting_CMIP6.py | 2 +- .../climate_change/plot_raw_data_CMIP6.py | 7 +- .../climate_change/process_CMIP6_data.py | 4 +- .../process_CMIP6_data_KDBall.py | 6 +- 9 files changed, 2439 insertions(+), 2427 deletions(-) diff --git a/src/scripts/climate_change/CIL_CMIP6_downscaling.py b/src/scripts/climate_change/CIL_CMIP6_downscaling.py index 67ca05caec..d139e1aa84 100644 --- a/src/scripts/climate_change/CIL_CMIP6_downscaling.py +++ b/src/scripts/climate_change/CIL_CMIP6_downscaling.py @@ -3,20 +3,18 @@ # From https://planetarycomputer.microsoft.com/dataset/cil-gdpcir-cc0#Ensemble-example -import planetary_computer -import pystac_client +import collections -# required to load a zarr array using xarray -import xarray as xr import numpy as np # optional imports used in this notebook import pandas as pd +import planetary_computer +import pystac_client +# required to load a zarr array using xarray +import xarray as xr from dask.diagnostics import ProgressBar from tqdm.auto import tqdm -import collections - - # Load and organise data diff --git a/src/scripts/climate_change/cohort_model.ipynb b/src/scripts/climate_change/cohort_model.ipynb index caf641d294..7c0c959519 100644 --- a/src/scripts/climate_change/cohort_model.ipynb +++ b/src/scripts/climate_change/cohort_model.ipynb @@ -6,8 +6,8 @@ "metadata": { "collapsed": true, "ExecuteTime": { - "end_time": "2025-01-03T10:30:32.359076Z", - "start_time": "2025-01-03T10:30:31.921107Z" + "end_time": "2025-01-03T11:32:03.586678Z", + "start_time": "2025-01-03T11:32:03.348700Z" } }, "source": [ @@ -187,13 +187,13 @@ ] } ], - "execution_count": 19 + "execution_count": 35 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-03T10:30:33.173930Z", - "start_time": "2025-01-03T10:30:33.167871Z" + "end_time": "2025-01-03T11:32:04.219692Z", + "start_time": "2025-01-03T11:32:04.213220Z" } }, "cell_type": "code", @@ -599,12 +599,12 @@ "" ] }, - "execution_count": 20, + "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 20 + "execution_count": 36 }, { "metadata": {}, @@ -615,34 +615,34 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-03T10:30:35.121476Z", - "start_time": "2025-01-03T10:30:35.119468Z" + "end_time": "2025-01-03T11:37:12.464113Z", + "start_time": "2025-01-03T11:37:12.460627Z" } }, "cell_type": "code", - "source": "scenario = 'ssp245'", + "source": "scenario = 'ssp585'#'ssp245'", "id": "bbff583692196586", "outputs": [], - "execution_count": 21 + "execution_count": 49 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-03T10:30:38.768507Z", - "start_time": "2025-01-03T10:30:38.623973Z" + "end_time": "2025-01-03T11:37:12.993354Z", + "start_time": "2025-01-03T11:37:12.844542Z" } }, "cell_type": "code", "source": "predictions_from_cmip = pd.read_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}.csv')", "id": "3be0a4515f3e890e", "outputs": [], - "execution_count": 22 + "execution_count": 50 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-03T10:30:39.582983Z", - "start_time": "2025-01-03T10:30:39.450683Z" + "end_time": "2025-01-03T11:37:13.426894Z", + "start_time": "2025-01-03T11:37:13.308115Z" } }, "cell_type": "code", @@ -656,52 +656,52 @@ "data": { "text/plain": [ " Year Month Facility_ID Altitude \\\n", - "0 2025 24642 620396 3302918.0 \n", - "1 2026 25447 640288 3423381.0 \n", - "2 2027 24346 613299 3249211.0 \n", - "3 2028 24165 609869 3233056.0 \n", - "4 2029 23856 600707 3182788.0 \n", - "5 2030 24743 621446 3305374.0 \n", - "6 2031 22311 564387 2993610.0 \n", - "7 2032 25011 629286 3346578.0 \n", - "8 2033 23162 584299 3096405.0 \n", - "9 2034 24560 617891 3283369.0 \n", - "10 2035 25040 629510 3351904.0 \n", - "11 2036 23845 597393 3180499.0 \n", - "12 2037 23332 586786 3128727.0 \n", - "13 2038 24976 626428 3359830.0 \n", - "14 2039 24253 610545 3257219.0 \n", - "15 2040 25057 629920 3355680.0 \n", - "16 2041 23909 603172 3217069.0 \n", - "17 2042 24546 614459 3284010.0 \n", - "18 2043 25169 634991 3380638.0 \n", - "19 2044 23565 591583 3151148.0 \n", - "20 2045 24921 627096 3335948.0 \n", - "21 2046 23776 598458 3181465.0 \n", - "22 2047 22152 556685 2957237.0 \n", - "23 2048 23385 588872 3114865.0 \n", - "24 2049 25584 643536 3435564.0 \n", - "25 2050 23985 603121 3199136.0 \n", - "26 2051 24460 615031 3269170.0 \n", - "27 2052 23610 593948 3148362.0 \n", - "28 2053 24612 617265 3291913.0 \n", - "29 2054 23846 600531 3190334.0 \n", - "30 2055 24956 628421 3345467.0 \n", - "31 2056 23703 596560 3172864.0 \n", - "32 2057 23884 602103 3215112.0 \n", - "33 2058 24352 611347 3261366.0 \n", - "34 2059 24055 603579 3200088.0 \n", - "35 2060 22401 560380 3000088.0 \n", - "36 2061 25450 639870 3417374.0 \n", - "37 2062 23155 582547 3074410.0 \n", - "38 2063 23057 580043 3084421.0 \n", - "39 2064 23503 592241 3138838.0 \n", - "40 2065 23680 594336 3169648.0 \n", - "41 2066 23743 598339 3198839.0 \n", - "42 2067 24569 619436 3283765.0 \n", - "43 2068 24122 608216 3240015.0 \n", - "44 2069 24546 618608 3287355.0 \n", - "45 2070 23805 598800 3180887.0 \n", + "0 2025 23814 599734 3182595.0 \n", + "1 2026 22590 566009 3008054.0 \n", + "2 2027 24474 614678 3269771.0 \n", + "3 2028 23968 600596 3207601.0 \n", + "4 2029 23330 583610 3116929.0 \n", + "5 2030 24073 605374 3226700.0 \n", + "6 2031 23580 593098 3161559.0 \n", + "7 2032 23000 576874 3067975.0 \n", + "8 2033 23581 593277 3157142.0 \n", + "9 2034 24459 614471 3272543.0 \n", + "10 2035 24070 601705 3227338.0 \n", + "11 2036 22412 563438 2989556.0 \n", + "12 2037 23224 583884 3111738.0 \n", + "13 2038 23088 581270 3091620.0 \n", + "14 2039 23796 598440 3178339.0 \n", + "15 2040 24867 625341 3333272.0 \n", + "16 2041 23418 588798 3126883.0 \n", + "17 2042 24483 614818 3264448.0 \n", + "18 2043 22584 568163 3020289.0 \n", + "19 2044 23377 588639 3133986.0 \n", + "20 2045 23817 599233 3190091.0 \n", + "21 2046 24583 616970 3286711.0 \n", + "22 2047 22492 563400 2990632.0 \n", + "23 2048 23857 599713 3190814.0 \n", + "24 2049 23922 602508 3200414.0 \n", + "25 2050 23672 596141 3153492.0 \n", + "26 2051 23898 601388 3209981.0 \n", + "27 2052 23496 591222 3151911.0 \n", + "28 2053 24894 627569 3335143.0 \n", + "29 2054 21946 552383 2937089.0 \n", + "30 2055 23076 579568 3072851.0 \n", + "31 2056 23967 601469 3194980.0 \n", + "32 2057 23389 588821 3139033.0 \n", + "33 2058 22093 555609 2950853.0 \n", + "34 2059 23733 596624 3169901.0 \n", + "35 2060 23173 582978 3100047.0 \n", + "36 2061 23689 595156 3162324.0 \n", + "37 2062 22794 574103 3036727.0 \n", + "38 2063 22722 573325 3024141.0 \n", + "39 2064 23581 590848 3149704.0 \n", + "40 2065 23523 591233 3157907.0 \n", + "41 2066 22993 578310 3065123.0 \n", + "42 2067 23261 583580 3099017.0 \n", + "43 2068 23318 586603 3118001.0 \n", + "44 2069 23422 588499 3133720.0 \n", + "45 2070 23609 593756 3146747.0 \n", "\n", " Zone \\\n", "0 Central WestSouth EastNorthernSouth EastNorthe... \n", @@ -848,196 +848,196 @@ "45 GovernmentGovernmentGovernmentGovernmentGovern... \n", "\n", " Facility_Type Precipitation \\\n", - "0 ClinicDistrict HospitalRural/Community Hospita... 440334.234308 \n", - "1 ClinicDistrict HospitalRural/Community Hospita... 368143.657611 \n", - "2 ClinicDistrict HospitalRural/Community Hospita... 389512.271746 \n", - "3 ClinicDistrict HospitalRural/Community Hospita... 467236.272652 \n", - "4 ClinicDistrict HospitalRural/Community Hospita... 510281.500940 \n", - "5 ClinicDistrict HospitalRural/Community Hospita... 415561.678186 \n", - "6 ClinicDistrict HospitalRural/Community Hospita... 306576.789734 \n", - "7 ClinicDistrict HospitalRural/Community Hospita... 322789.637078 \n", - "8 ClinicDistrict HospitalRural/Community Hospita... 417617.290163 \n", - "9 ClinicDistrict HospitalRural/Community Hospita... 397886.401018 \n", - "10 ClinicDistrict HospitalRural/Community Hospita... 459406.340711 \n", - "11 ClinicDistrict HospitalRural/Community Hospita... 397647.735041 \n", - "12 ClinicDistrict HospitalRural/Community Hospita... 391610.416555 \n", - "13 ClinicDistrict HospitalRural/Community Hospita... 441416.106096 \n", - "14 ClinicDistrict HospitalRural/Community Hospita... 375365.449796 \n", - "15 ClinicDistrict HospitalRural/Community Hospita... 410970.020588 \n", - "16 ClinicDistrict HospitalRural/Community Hospita... 409283.988225 \n", - "17 ClinicDistrict HospitalRural/Community Hospita... 473493.289947 \n", - "18 ClinicDistrict HospitalRural/Community Hospita... 469347.741866 \n", - "19 ClinicDistrict HospitalRural/Community Hospita... 367242.325518 \n", - "20 ClinicDistrict HospitalRural/Community Hospita... 315560.724644 \n", - "21 ClinicDistrict HospitalRural/Community Hospita... 371782.115694 \n", - "22 ClinicDistrict HospitalRural/Community Hospita... 434630.692016 \n", - "23 ClinicDistrict HospitalRural/Community Hospita... 341127.222055 \n", - "24 ClinicDistrict HospitalRural/Community Hospita... 431988.493807 \n", - "25 ClinicDistrict HospitalRural/Community Hospita... 421327.798951 \n", - "26 ClinicDistrict HospitalRural/Community Hospita... 321024.804561 \n", - "27 ClinicDistrict HospitalRural/Community Hospita... 469034.752168 \n", - "28 ClinicDistrict HospitalRural/Community Hospita... 479370.138921 \n", - "29 ClinicDistrict HospitalRural/Community Hospita... 378828.522395 \n", - "30 ClinicDistrict HospitalRural/Community Hospita... 478046.700552 \n", - "31 ClinicDistrict HospitalRural/Community Hospita... 370264.174609 \n", - "32 ClinicDistrict HospitalRural/Community Hospita... 378162.247570 \n", - "33 ClinicDistrict HospitalRural/Community Hospita... 414908.289481 \n", - "34 ClinicDistrict HospitalRural/Community Hospita... 455684.817802 \n", - "35 ClinicDistrict HospitalRural/Community Hospita... 359900.771691 \n", - "36 ClinicDistrict HospitalRural/Community Hospita... 522352.080349 \n", - "37 ClinicDistrict HospitalRural/Community Hospita... 376936.757775 \n", - "38 ClinicDistrict HospitalRural/Community Hospita... 467723.711737 \n", - "39 ClinicDistrict HospitalRural/Community Hospita... 323517.333199 \n", - "40 ClinicDistrict HospitalRural/Community Hospita... 345713.935117 \n", - "41 ClinicDistrict HospitalRural/Community Hospita... 395462.015387 \n", - "42 ClinicDistrict HospitalRural/Community Hospita... 406529.105098 \n", - "43 ClinicDistrict HospitalRural/Community Hospita... 574552.855124 \n", - "44 ClinicDistrict HospitalRural/Community Hospita... 446939.143675 \n", - "45 ClinicDistrict HospitalRural/Community Hospita... 478443.587177 \n", + "0 ClinicDistrict HospitalRural/Community Hospita... 356930.256793 \n", + "1 ClinicDistrict HospitalRural/Community Hospita... 442012.194055 \n", + "2 ClinicDistrict HospitalRural/Community Hospita... 401910.341187 \n", + "3 ClinicDistrict HospitalRural/Community Hospita... 458028.122792 \n", + "4 ClinicDistrict HospitalRural/Community Hospita... 406191.851826 \n", + "5 ClinicDistrict HospitalRural/Community Hospita... 409387.038984 \n", + "6 ClinicDistrict HospitalRural/Community Hospita... 400600.129109 \n", + "7 ClinicDistrict HospitalRural/Community Hospita... 447521.070185 \n", + "8 ClinicDistrict HospitalRural/Community Hospita... 456815.880827 \n", + "9 ClinicDistrict HospitalRural/Community Hospita... 443520.485079 \n", + "10 ClinicDistrict HospitalRural/Community Hospita... 411313.075371 \n", + "11 ClinicDistrict HospitalRural/Community Hospita... 401467.863756 \n", + "12 ClinicDistrict HospitalRural/Community Hospita... 419545.873961 \n", + "13 ClinicDistrict HospitalRural/Community Hospita... 463682.059169 \n", + "14 ClinicDistrict HospitalRural/Community Hospita... 439471.811655 \n", + "15 ClinicDistrict HospitalRural/Community Hospita... 451058.889825 \n", + "16 ClinicDistrict HospitalRural/Community Hospita... 364816.739985 \n", + "17 ClinicDistrict HospitalRural/Community Hospita... 474909.052258 \n", + "18 ClinicDistrict HospitalRural/Community Hospita... 437730.151447 \n", + "19 ClinicDistrict HospitalRural/Community Hospita... 467117.570232 \n", + "20 ClinicDistrict HospitalRural/Community Hospita... 398139.357152 \n", + "21 ClinicDistrict HospitalRural/Community Hospita... 443421.655978 \n", + "22 ClinicDistrict HospitalRural/Community Hospita... 494553.446600 \n", + "23 ClinicDistrict HospitalRural/Community Hospita... 472153.619753 \n", + "24 ClinicDistrict HospitalRural/Community Hospita... 465094.209967 \n", + "25 ClinicDistrict HospitalRural/Community Hospita... 452834.779144 \n", + "26 ClinicDistrict HospitalRural/Community Hospita... 460721.942570 \n", + "27 ClinicDistrict HospitalRural/Community Hospita... 309639.446977 \n", + "28 ClinicDistrict HospitalRural/Community Hospita... 332821.767357 \n", + "29 ClinicDistrict HospitalRural/Community Hospita... 418144.175624 \n", + "30 ClinicDistrict HospitalRural/Community Hospita... 300680.970171 \n", + "31 ClinicDistrict HospitalRural/Community Hospita... 461243.283456 \n", + "32 ClinicDistrict HospitalRural/Community Hospita... 379993.626328 \n", + "33 ClinicDistrict HospitalRural/Community Hospita... 381230.056855 \n", + "34 ClinicDistrict HospitalRural/Community Hospita... 501263.956015 \n", + "35 ClinicDistrict HospitalRural/Community Hospita... 459757.304011 \n", + "36 ClinicDistrict HospitalRural/Community Hospita... 403898.123577 \n", + "37 ClinicDistrict HospitalRural/Community Hospita... 468021.236699 \n", + "38 ClinicDistrict HospitalRural/Community Hospita... 414958.264565 \n", + "39 ClinicDistrict HospitalRural/Community Hospita... 441414.054493 \n", + "40 ClinicDistrict HospitalRural/Community Hospita... 433793.080907 \n", + "41 ClinicDistrict HospitalRural/Community Hospita... 358327.837808 \n", + "42 ClinicDistrict HospitalRural/Community Hospita... 385266.544939 \n", + "43 ClinicDistrict HospitalRural/Community Hospita... 444523.181015 \n", + "44 ClinicDistrict HospitalRural/Community Hospita... 445720.962431 \n", + "45 ClinicDistrict HospitalRural/Community Hospita... 400991.290205 \n", "\n", " Lag_1_Precipitation Lag_2_Precipitation Lag_3_Precipitation \\\n", - "0 353904.731005 325681.489860 297561.640581 \n", - "1 401420.433758 403405.854504 402539.554951 \n", - "2 371731.795831 352017.560308 341274.411245 \n", - "3 463195.874132 489324.647136 467717.368493 \n", - "4 502657.340862 482774.102033 508613.994882 \n", - "5 430082.709305 433194.385110 426679.595380 \n", - "6 309978.599600 325681.193935 315680.278887 \n", - "7 346456.981332 346504.507849 343190.362299 \n", - "8 357429.121158 338700.251142 340245.308388 \n", - "9 399155.990738 376194.009554 375103.117941 \n", - "10 495631.995766 495403.900197 486208.445508 \n", - "11 394956.683884 407506.319795 414531.165308 \n", - "12 343980.571323 350808.137426 347057.035888 \n", - "13 452575.562133 454464.217285 452146.877154 \n", - "14 362433.347050 371149.568476 363933.535093 \n", - "15 447884.643580 447682.568270 449803.904849 \n", - "16 389442.315269 385668.859805 378426.274901 \n", - "17 451147.769581 430615.696082 425669.313089 \n", - "18 494545.073752 499347.930783 493783.833404 \n", - "19 371711.781452 374913.433345 377110.720066 \n", - "20 343353.455376 345223.997177 342021.238793 \n", - "21 305812.333010 294432.924965 293503.944334 \n", - "22 457467.620834 474432.706520 472613.554807 \n", - "23 315111.678821 294945.264077 285233.426898 \n", - "24 443731.169805 451146.067144 447883.026972 \n", - "25 396769.929491 408562.425855 418502.725903 \n", - "26 345132.495319 329562.416251 323549.743210 \n", - "27 469662.194769 448426.362540 446609.577932 \n", - "28 461118.374422 452747.999276 442215.228495 \n", - "29 435684.567230 434997.915598 436064.621612 \n", - "30 428881.409055 453508.028054 449527.028001 \n", - "31 415190.572889 426911.392935 433321.292498 \n", - "32 377205.366488 342790.975990 332326.448483 \n", - "33 333540.646309 362992.743057 366721.297324 \n", - "34 472393.409198 478349.032980 477401.048276 \n", - "35 372597.770047 360489.465892 363261.114549 \n", - "36 579014.399822 568925.720500 565835.475117 \n", - "37 379134.096954 381629.099749 364270.180436 \n", - "38 401612.564532 392392.393319 396304.528597 \n", - "39 367831.340554 346112.375544 324946.993397 \n", - "40 293320.941908 318220.999319 326566.490286 \n", - "41 445201.806887 440143.467266 438945.020171 \n", - "42 356852.651551 349188.139601 335367.151073 \n", - "43 543870.172353 546057.722361 548303.362147 \n", - "44 511156.014302 533278.121296 529131.538903 \n", - "45 441135.161700 433665.355653 444075.669003 \n", + "0 294609.145696 251778.819911 240074.691709 \n", + "1 397157.668329 397273.347895 348266.651361 \n", + "2 414186.725872 420900.694753 423488.413324 \n", + "3 454173.805476 433342.964932 425159.752149 \n", + "4 439691.054081 445950.755762 418870.421666 \n", + "5 389364.247808 392455.710835 397461.356243 \n", + "6 392631.249314 374449.656015 373894.307761 \n", + "7 402914.631768 394545.775941 380305.249049 \n", + "8 498011.574391 475942.063738 466685.963435 \n", + "9 441306.486897 449381.026641 430634.351876 \n", + "10 461142.612330 444654.932360 434587.827755 \n", + "11 357763.087422 364775.944769 347716.667867 \n", + "12 416541.339977 409043.550166 391920.926233 \n", + "13 442526.600924 451303.450407 456286.448435 \n", + "14 486171.696867 502289.466180 498044.017229 \n", + "15 431633.402209 402153.409212 398040.518931 \n", + "16 335208.786306 354775.001534 338447.362232 \n", + "17 506841.062275 463684.071161 461858.642099 \n", + "18 415617.644419 410420.270555 407615.216190 \n", + "19 486817.869497 480637.195403 474544.770943 \n", + "20 362850.193582 402219.531548 399839.624296 \n", + "21 468076.690976 465542.221447 467423.630271 \n", + "22 444767.223650 409485.605985 387260.946000 \n", + "23 503414.718730 491261.349692 495127.838946 \n", + "24 455038.002255 477898.743986 469420.838584 \n", + "25 465973.024854 462746.331497 425762.806114 \n", + "26 407556.892301 401004.293570 421749.445065 \n", + "27 390992.045894 420441.094988 413192.196815 \n", + "28 320904.427223 316776.074425 316292.885898 \n", + "29 404366.782226 391164.519869 373727.874006 \n", + "30 346289.174108 340245.279011 329299.172958 \n", + "31 391853.983192 387762.882037 372651.645513 \n", + "32 421170.962261 417222.716525 405927.199113 \n", + "33 354587.101006 350957.265087 326505.718272 \n", + "34 490253.713022 477610.230551 460159.597378 \n", + "35 436835.494548 419958.086643 435515.915955 \n", + "36 446026.892969 459573.706453 436904.851847 \n", + "37 450100.730558 416050.220079 373748.278834 \n", + "38 415976.330050 443797.927964 453085.545667 \n", + "39 435767.269524 415051.021426 406769.043607 \n", + "40 435494.327000 421305.379992 408124.267918 \n", + "41 382545.188235 359818.742372 354980.088513 \n", + "42 357229.405339 389448.072900 382553.140857 \n", + "43 449728.133273 439791.891824 438856.705942 \n", + "44 418703.399054 431958.526817 430211.684701 \n", + "45 429393.430690 411181.980311 405133.787228 \n", "\n", " Lag_4_Precipitation Predicted_Weather_Model Predicted_No_Weather_Model \\\n", - "0 282054.887587 282875.789559 435056.523872 \n", - "1 403356.754888 446973.452602 448297.963620 \n", - "2 330719.679227 429699.165446 428855.082772 \n", - "3 464588.245545 426390.662966 425105.144739 \n", - "4 503630.296180 419862.210285 417366.002941 \n", - "5 423888.501330 429293.165886 430209.704481 \n", - "6 290028.482608 388423.461274 388929.485473 \n", - "7 342685.296868 434991.492594 436710.225310 \n", - "8 340546.248413 400294.397759 402492.398969 \n", - "9 373789.068455 425657.584762 427231.110037 \n", - "10 482900.825373 433154.044585 434659.478247 \n", - "11 393286.530926 409005.784582 408150.336768 \n", - "12 341463.248905 399090.628516 401572.454562 \n", - "13 450786.011451 431402.659483 429626.731487 \n", - "14 360843.806040 412578.359715 415007.121480 \n", - "15 448981.207566 428390.924640 428879.058208 \n", - "16 374044.680265 407922.043693 409972.692203 \n", - "17 429496.615643 412187.659372 413257.478800 \n", - "18 488803.549502 430347.112355 430015.937504 \n", - "19 377895.449896 401348.874670 401054.748615 \n", - "20 334436.491016 423672.932007 425227.379946 \n", - "21 296392.880809 398552.821055 401775.342808 \n", - "22 440392.213570 373087.409200 374239.513003 \n", - "23 253195.609983 390315.605105 391466.290883 \n", - "24 446049.207337 430832.507546 432053.418987 \n", - "25 419774.688159 402422.115951 403916.440618 \n", - "26 317332.704749 409463.606493 410180.385199 \n", - "27 435340.199013 391160.953917 393091.155764 \n", - "28 400887.449181 409930.626615 412238.859114 \n", - "29 432867.449960 396400.887798 396070.808867 \n", - "30 444985.809368 416341.114108 417028.311391 \n", - "31 423776.044021 395081.647605 391936.636790 \n", - "32 330739.987217 394811.555047 396221.517042 \n", - "33 367575.167706 401393.780962 403754.537706 \n", - "34 438412.338758 391860.264252 393873.141006 \n", - "35 359252.347918 367209.410297 366611.581462 \n", - "36 550598.603341 417434.381690 420020.233730 \n", - "37 356574.164485 377882.767541 377365.440971 \n", - "38 394369.022680 374082.177605 374460.254161 \n", - "39 312443.249634 382423.385030 382966.454764 \n", - "40 323628.322020 384159.066998 384056.354457 \n", - "41 435197.782687 385665.968172 385827.443170 \n", - "42 336038.756644 398291.557836 400458.849287 \n", - "43 547679.218868 391932.655476 393162.031631 \n", - "44 529176.140345 396645.182138 399251.911588 \n", - "45 439392.286115 383002.326955 384919.782302 \n", + "0 212611.355306 262073.177045 414580.859514 \n", + "1 329607.014297 391897.166673 394712.494598 \n", + "2 427242.313426 424216.303078 426507.644233 \n", + "3 409583.757336 418663.778757 419005.094793 \n", + "4 404708.312917 405721.982368 407774.686109 \n", + "5 389452.051202 422077.382352 421235.583604 \n", + "6 361847.942122 406625.933041 406869.091856 \n", + "7 367935.056473 390456.768764 393982.523859 \n", + "8 443793.819493 404036.109552 407105.988595 \n", + "9 428705.248932 419086.106241 421792.859293 \n", + "10 424916.410268 414353.849683 416718.943844 \n", + "11 321868.628640 379822.724678 383326.342849 \n", + "12 378814.601365 396472.620305 397095.249567 \n", + "13 441830.397786 392687.251512 394380.103735 \n", + "14 485302.039523 402985.471692 406826.384026 \n", + "15 371349.124368 425017.218302 426405.341430 \n", + "16 321940.022061 397017.066601 399458.496395 \n", + "17 454618.554156 416691.544445 416997.757878 \n", + "18 384771.629007 383660.669690 383755.734156 \n", + "19 455304.239249 394673.545565 394754.939189 \n", + "20 377344.967272 401135.309503 402985.317847 \n", + "21 464577.255028 412242.557813 413773.489936 \n", + "22 360098.331291 372146.903936 375589.196357 \n", + "23 485805.294721 401945.091876 402709.253238 \n", + "24 440243.139280 398685.865173 401567.430428 \n", + "25 427139.769513 399252.955628 398635.670647 \n", + "26 405452.318421 400477.291574 400608.907041 \n", + "27 409041.464387 390999.580252 392078.841473 \n", + "28 306048.398243 416471.045063 418092.099246 \n", + "29 343975.955350 360207.713252 364273.522362 \n", + "30 309663.520488 379799.778479 382254.450494 \n", + "31 355108.240357 389694.500461 393327.366843 \n", + "32 379013.465979 382707.973900 382588.827454 \n", + "33 294446.256154 361165.891802 361939.932800 \n", + "34 444568.857000 389684.514691 391135.437740 \n", + "35 425013.325154 383317.152377 381266.519178 \n", + "36 419966.747362 390113.556785 387064.014493 \n", + "37 351040.543393 372856.397814 373879.275648 \n", + "38 444035.139054 367768.692199 368187.001270 \n", + "39 396642.228590 378200.181200 380644.486568 \n", + "40 399546.170001 383210.897923 380769.053462 \n", + "41 342669.140660 373477.131153 373664.729920 \n", + "42 367803.054399 375480.781577 376740.673312 \n", + "43 426322.297655 374245.788665 375335.534050 \n", + "44 419976.194936 379224.450236 378005.108376 \n", + "45 386202.176410 383743.213561 381667.545696 \n", "\n", " Difference_in_Expectation \n", - "0 -1479.431742 \n", - "1 -1324.511018 \n", - "2 844.082675 \n", - "3 1285.518227 \n", - "4 2496.207344 \n", - "5 -916.538595 \n", - "6 -506.024199 \n", - "7 -1718.732715 \n", - "8 -2198.001210 \n", - "9 -1573.525275 \n", - "10 -1505.433662 \n", - "11 855.447814 \n", - "12 -2481.826046 \n", - "13 1775.927996 \n", - "14 -2428.761765 \n", - "15 -488.133568 \n", - "16 -2050.648510 \n", - "17 -1069.819428 \n", - "18 331.174851 \n", - "19 294.126054 \n", - "20 -1554.447940 \n", - "21 -3222.521752 \n", - "22 -1152.103803 \n", - "23 -1150.685778 \n", - "24 -1220.911442 \n", - "25 -1494.324667 \n", - "26 -716.778707 \n", - "27 -1930.201847 \n", - "28 -2308.232499 \n", - "29 330.078931 \n", - "30 -687.197283 \n", - "31 3145.010815 \n", - "32 -1409.961995 \n", - "33 -2360.756744 \n", - "34 -2012.876754 \n", - "35 597.828835 \n", - "36 -2585.852040 \n", - "37 517.326570 \n", - "38 -378.076555 \n", - "39 -543.069734 \n", - "40 102.712541 \n", - "41 -161.474998 \n", - "42 -2167.291450 \n", - "43 -1229.376155 \n", - "44 -2606.729450 \n", - "45 -1917.455347 " + "0 -1806.379897 \n", + "1 -2815.327925 \n", + "2 -2291.341155 \n", + "3 -341.316036 \n", + "4 -2052.703741 \n", + "5 841.798749 \n", + "6 -243.158815 \n", + "7 -3525.755094 \n", + "8 -3069.879043 \n", + "9 -2706.753053 \n", + "10 -2365.094162 \n", + "11 -3503.618171 \n", + "12 -622.629263 \n", + "13 -1692.852223 \n", + "14 -3840.912333 \n", + "15 -1388.123129 \n", + "16 -2441.429794 \n", + "17 -306.213433 \n", + "18 -95.064467 \n", + "19 -81.393624 \n", + "20 -1850.008344 \n", + "21 -1530.932123 \n", + "22 -3442.292421 \n", + "23 -764.161361 \n", + "24 -2881.565255 \n", + "25 617.284980 \n", + "26 -131.615467 \n", + "27 -1079.261220 \n", + "28 -1621.054183 \n", + "29 -4065.809111 \n", + "30 -2454.672016 \n", + "31 -3632.866382 \n", + "32 119.146445 \n", + "33 -774.040998 \n", + "34 -1450.923049 \n", + "35 2050.633200 \n", + "36 3049.542292 \n", + "37 -1022.877835 \n", + "38 -418.309071 \n", + "39 -2444.305368 \n", + "40 2441.844461 \n", + "41 -187.598767 \n", + "42 -1259.891735 \n", + "43 -1089.745385 \n", + "44 1219.341861 \n", + "45 2075.667865 " ], "text/html": [ "
\n", @@ -1080,894 +1080,894 @@ " \n", " 0\n", " 2025\n", - " 24642\n", - " 620396\n", - " 3302918.0\n", + " 23814\n", + " 599734\n", + " 3182595.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 440334.234308\n", - " 353904.731005\n", - " 325681.489860\n", - " 297561.640581\n", - " 282054.887587\n", - " 282875.789559\n", - " 435056.523872\n", - " -1479.431742\n", + " 356930.256793\n", + " 294609.145696\n", + " 251778.819911\n", + " 240074.691709\n", + " 212611.355306\n", + " 262073.177045\n", + " 414580.859514\n", + " -1806.379897\n", " \n", " \n", " 1\n", " 2026\n", - " 25447\n", - " 640288\n", - " 3423381.0\n", + " 22590\n", + " 566009\n", + " 3008054.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 368143.657611\n", - " 401420.433758\n", - " 403405.854504\n", - " 402539.554951\n", - " 403356.754888\n", - " 446973.452602\n", - " 448297.963620\n", - " -1324.511018\n", + " 442012.194055\n", + " 397157.668329\n", + " 397273.347895\n", + " 348266.651361\n", + " 329607.014297\n", + " 391897.166673\n", + " 394712.494598\n", + " -2815.327925\n", " \n", " \n", " 2\n", " 2027\n", - " 24346\n", - " 613299\n", - " 3249211.0\n", + " 24474\n", + " 614678\n", + " 3269771.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 389512.271746\n", - " 371731.795831\n", - " 352017.560308\n", - " 341274.411245\n", - " 330719.679227\n", - " 429699.165446\n", - " 428855.082772\n", - " 844.082675\n", + " 401910.341187\n", + " 414186.725872\n", + " 420900.694753\n", + " 423488.413324\n", + " 427242.313426\n", + " 424216.303078\n", + " 426507.644233\n", + " -2291.341155\n", " \n", " \n", " 3\n", " 2028\n", - " 24165\n", - " 609869\n", - " 3233056.0\n", + " 23968\n", + " 600596\n", + " 3207601.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 467236.272652\n", - " 463195.874132\n", - " 489324.647136\n", - " 467717.368493\n", - " 464588.245545\n", - " 426390.662966\n", - " 425105.144739\n", - " 1285.518227\n", + " 458028.122792\n", + " 454173.805476\n", + " 433342.964932\n", + " 425159.752149\n", + " 409583.757336\n", + " 418663.778757\n", + " 419005.094793\n", + " -341.316036\n", " \n", " \n", " 4\n", " 2029\n", - " 23856\n", - " 600707\n", - " 3182788.0\n", + " 23330\n", + " 583610\n", + " 3116929.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 510281.500940\n", - " 502657.340862\n", - " 482774.102033\n", - " 508613.994882\n", - " 503630.296180\n", - " 419862.210285\n", - " 417366.002941\n", - " 2496.207344\n", + " 406191.851826\n", + " 439691.054081\n", + " 445950.755762\n", + " 418870.421666\n", + " 404708.312917\n", + " 405721.982368\n", + " 407774.686109\n", + " -2052.703741\n", " \n", " \n", " 5\n", " 2030\n", - " 24743\n", - " 621446\n", - " 3305374.0\n", + " 24073\n", + " 605374\n", + " 3226700.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 415561.678186\n", - " 430082.709305\n", - " 433194.385110\n", - " 426679.595380\n", - " 423888.501330\n", - " 429293.165886\n", - " 430209.704481\n", - " -916.538595\n", + " 409387.038984\n", + " 389364.247808\n", + " 392455.710835\n", + " 397461.356243\n", + " 389452.051202\n", + " 422077.382352\n", + " 421235.583604\n", + " 841.798749\n", " \n", " \n", " 6\n", " 2031\n", - " 22311\n", - " 564387\n", - " 2993610.0\n", + " 23580\n", + " 593098\n", + " 3161559.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 306576.789734\n", - " 309978.599600\n", - " 325681.193935\n", - " 315680.278887\n", - " 290028.482608\n", - " 388423.461274\n", - " 388929.485473\n", - " -506.024199\n", + " 400600.129109\n", + " 392631.249314\n", + " 374449.656015\n", + " 373894.307761\n", + " 361847.942122\n", + " 406625.933041\n", + " 406869.091856\n", + " -243.158815\n", " \n", " \n", " 7\n", " 2032\n", - " 25011\n", - " 629286\n", - " 3346578.0\n", + " 23000\n", + " 576874\n", + " 3067975.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 322789.637078\n", - " 346456.981332\n", - " 346504.507849\n", - " 343190.362299\n", - " 342685.296868\n", - " 434991.492594\n", - " 436710.225310\n", - " -1718.732715\n", + " 447521.070185\n", + " 402914.631768\n", + " 394545.775941\n", + " 380305.249049\n", + " 367935.056473\n", + " 390456.768764\n", + " 393982.523859\n", + " -3525.755094\n", " \n", " \n", " 8\n", " 2033\n", - " 23162\n", - " 584299\n", - " 3096405.0\n", + " 23581\n", + " 593277\n", + " 3157142.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 417617.290163\n", - " 357429.121158\n", - " 338700.251142\n", - " 340245.308388\n", - " 340546.248413\n", - " 400294.397759\n", - " 402492.398969\n", - " -2198.001210\n", + " 456815.880827\n", + " 498011.574391\n", + " 475942.063738\n", + " 466685.963435\n", + " 443793.819493\n", + " 404036.109552\n", + " 407105.988595\n", + " -3069.879043\n", " \n", " \n", " 9\n", " 2034\n", - " 24560\n", - " 617891\n", - " 3283369.0\n", + " 24459\n", + " 614471\n", + " 3272543.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 397886.401018\n", - " 399155.990738\n", - " 376194.009554\n", - " 375103.117941\n", - " 373789.068455\n", - " 425657.584762\n", - " 427231.110037\n", - " -1573.525275\n", + " 443520.485079\n", + " 441306.486897\n", + " 449381.026641\n", + " 430634.351876\n", + " 428705.248932\n", + " 419086.106241\n", + " 421792.859293\n", + " -2706.753053\n", " \n", " \n", " 10\n", " 2035\n", - " 25040\n", - " 629510\n", - " 3351904.0\n", + " 24070\n", + " 601705\n", + " 3227338.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 459406.340711\n", - " 495631.995766\n", - " 495403.900197\n", - " 486208.445508\n", - " 482900.825373\n", - " 433154.044585\n", - " 434659.478247\n", - " -1505.433662\n", + " 411313.075371\n", + " 461142.612330\n", + " 444654.932360\n", + " 434587.827755\n", + " 424916.410268\n", + " 414353.849683\n", + " 416718.943844\n", + " -2365.094162\n", " \n", " \n", " 11\n", " 2036\n", - " 23845\n", - " 597393\n", - " 3180499.0\n", + " 22412\n", + " 563438\n", + " 2989556.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 397647.735041\n", - " 394956.683884\n", - " 407506.319795\n", - " 414531.165308\n", - " 393286.530926\n", - " 409005.784582\n", - " 408150.336768\n", - " 855.447814\n", + " 401467.863756\n", + " 357763.087422\n", + " 364775.944769\n", + " 347716.667867\n", + " 321868.628640\n", + " 379822.724678\n", + " 383326.342849\n", + " -3503.618171\n", " \n", " \n", " 12\n", " 2037\n", - " 23332\n", - " 586786\n", - " 3128727.0\n", + " 23224\n", + " 583884\n", + " 3111738.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 391610.416555\n", - " 343980.571323\n", - " 350808.137426\n", - " 347057.035888\n", - " 341463.248905\n", - " 399090.628516\n", - " 401572.454562\n", - " -2481.826046\n", + " 419545.873961\n", + " 416541.339977\n", + " 409043.550166\n", + " 391920.926233\n", + " 378814.601365\n", + " 396472.620305\n", + " 397095.249567\n", + " -622.629263\n", " \n", " \n", " 13\n", " 2038\n", - " 24976\n", - " 626428\n", - " 3359830.0\n", + " 23088\n", + " 581270\n", + " 3091620.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 441416.106096\n", - " 452575.562133\n", - " 454464.217285\n", - " 452146.877154\n", - " 450786.011451\n", - " 431402.659483\n", - " 429626.731487\n", - " 1775.927996\n", + " 463682.059169\n", + " 442526.600924\n", + " 451303.450407\n", + " 456286.448435\n", + " 441830.397786\n", + " 392687.251512\n", + " 394380.103735\n", + " -1692.852223\n", " \n", " \n", " 14\n", " 2039\n", - " 24253\n", - " 610545\n", - " 3257219.0\n", + " 23796\n", + " 598440\n", + " 3178339.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 375365.449796\n", - " 362433.347050\n", - " 371149.568476\n", - " 363933.535093\n", - " 360843.806040\n", - " 412578.359715\n", - " 415007.121480\n", - " -2428.761765\n", + " 439471.811655\n", + " 486171.696867\n", + " 502289.466180\n", + " 498044.017229\n", + " 485302.039523\n", + " 402985.471692\n", + " 406826.384026\n", + " -3840.912333\n", " \n", " \n", " 15\n", " 2040\n", - " 25057\n", - " 629920\n", - " 3355680.0\n", + " 24867\n", + " 625341\n", + " 3333272.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 410970.020588\n", - " 447884.643580\n", - " 447682.568270\n", - " 449803.904849\n", - " 448981.207566\n", - " 428390.924640\n", - " 428879.058208\n", - " -488.133568\n", + " 451058.889825\n", + " 431633.402209\n", + " 402153.409212\n", + " 398040.518931\n", + " 371349.124368\n", + " 425017.218302\n", + " 426405.341430\n", + " -1388.123129\n", " \n", " \n", " 16\n", " 2041\n", - " 23909\n", - " 603172\n", - " 3217069.0\n", + " 23418\n", + " 588798\n", + " 3126883.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 409283.988225\n", - " 389442.315269\n", - " 385668.859805\n", - " 378426.274901\n", - " 374044.680265\n", - " 407922.043693\n", - " 409972.692203\n", - " -2050.648510\n", + " 364816.739985\n", + " 335208.786306\n", + " 354775.001534\n", + " 338447.362232\n", + " 321940.022061\n", + " 397017.066601\n", + " 399458.496395\n", + " -2441.429794\n", " \n", " \n", " 17\n", " 2042\n", - " 24546\n", - " 614459\n", - " 3284010.0\n", + " 24483\n", + " 614818\n", + " 3264448.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 473493.289947\n", - " 451147.769581\n", - " 430615.696082\n", - " 425669.313089\n", - " 429496.615643\n", - " 412187.659372\n", - " 413257.478800\n", - " -1069.819428\n", + " 474909.052258\n", + " 506841.062275\n", + " 463684.071161\n", + " 461858.642099\n", + " 454618.554156\n", + " 416691.544445\n", + " 416997.757878\n", + " -306.213433\n", " \n", " \n", " 18\n", " 2043\n", - " 25169\n", - " 634991\n", - " 3380638.0\n", + " 22584\n", + " 568163\n", + " 3020289.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 469347.741866\n", - " 494545.073752\n", - " 499347.930783\n", - " 493783.833404\n", - " 488803.549502\n", - " 430347.112355\n", - " 430015.937504\n", - " 331.174851\n", + " 437730.151447\n", + " 415617.644419\n", + " 410420.270555\n", + " 407615.216190\n", + " 384771.629007\n", + " 383660.669690\n", + " 383755.734156\n", + " -95.064467\n", " \n", " \n", " 19\n", " 2044\n", - " 23565\n", - " 591583\n", - " 3151148.0\n", + " 23377\n", + " 588639\n", + " 3133986.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 367242.325518\n", - " 371711.781452\n", - " 374913.433345\n", - " 377110.720066\n", - " 377895.449896\n", - " 401348.874670\n", - " 401054.748615\n", - " 294.126054\n", + " 467117.570232\n", + " 486817.869497\n", + " 480637.195403\n", + " 474544.770943\n", + " 455304.239249\n", + " 394673.545565\n", + " 394754.939189\n", + " -81.393624\n", " \n", " \n", " 20\n", " 2045\n", - " 24921\n", - " 627096\n", - " 3335948.0\n", + " 23817\n", + " 599233\n", + " 3190091.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 315560.724644\n", - " 343353.455376\n", - " 345223.997177\n", - " 342021.238793\n", - " 334436.491016\n", - " 423672.932007\n", - " 425227.379946\n", - " -1554.447940\n", + " 398139.357152\n", + " 362850.193582\n", + " 402219.531548\n", + " 399839.624296\n", + " 377344.967272\n", + " 401135.309503\n", + " 402985.317847\n", + " -1850.008344\n", " \n", " \n", " 21\n", " 2046\n", - " 23776\n", - " 598458\n", - " 3181465.0\n", + " 24583\n", + " 616970\n", + " 3286711.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 371782.115694\n", - " 305812.333010\n", - " 294432.924965\n", - " 293503.944334\n", - " 296392.880809\n", - " 398552.821055\n", - " 401775.342808\n", - " -3222.521752\n", + " 443421.655978\n", + " 468076.690976\n", + " 465542.221447\n", + " 467423.630271\n", + " 464577.255028\n", + " 412242.557813\n", + " 413773.489936\n", + " -1530.932123\n", " \n", " \n", " 22\n", " 2047\n", - " 22152\n", - " 556685\n", - " 2957237.0\n", + " 22492\n", + " 563400\n", + " 2990632.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 434630.692016\n", - " 457467.620834\n", - " 474432.706520\n", - " 472613.554807\n", - " 440392.213570\n", - " 373087.409200\n", - " 374239.513003\n", - " -1152.103803\n", + " 494553.446600\n", + " 444767.223650\n", + " 409485.605985\n", + " 387260.946000\n", + " 360098.331291\n", + " 372146.903936\n", + " 375589.196357\n", + " -3442.292421\n", " \n", " \n", " 23\n", " 2048\n", - " 23385\n", - " 588872\n", - " 3114865.0\n", + " 23857\n", + " 599713\n", + " 3190814.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 341127.222055\n", - " 315111.678821\n", - " 294945.264077\n", - " 285233.426898\n", - " 253195.609983\n", - " 390315.605105\n", - " 391466.290883\n", - " -1150.685778\n", + " 472153.619753\n", + " 503414.718730\n", + " 491261.349692\n", + " 495127.838946\n", + " 485805.294721\n", + " 401945.091876\n", + " 402709.253238\n", + " -764.161361\n", " \n", " \n", " 24\n", " 2049\n", - " 25584\n", - " 643536\n", - " 3435564.0\n", + " 23922\n", + " 602508\n", + " 3200414.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 431988.493807\n", - " 443731.169805\n", - " 451146.067144\n", - " 447883.026972\n", - " 446049.207337\n", - " 430832.507546\n", - " 432053.418987\n", - " -1220.911442\n", + " 465094.209967\n", + " 455038.002255\n", + " 477898.743986\n", + " 469420.838584\n", + " 440243.139280\n", + " 398685.865173\n", + " 401567.430428\n", + " -2881.565255\n", " \n", " \n", " 25\n", " 2050\n", - " 23985\n", - " 603121\n", - " 3199136.0\n", + " 23672\n", + " 596141\n", + " 3153492.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 421327.798951\n", - " 396769.929491\n", - " 408562.425855\n", - " 418502.725903\n", - " 419774.688159\n", - " 402422.115951\n", - " 403916.440618\n", - " -1494.324667\n", + " 452834.779144\n", + " 465973.024854\n", + " 462746.331497\n", + " 425762.806114\n", + " 427139.769513\n", + " 399252.955628\n", + " 398635.670647\n", + " 617.284980\n", " \n", " \n", " 26\n", " 2051\n", - " 24460\n", - " 615031\n", - " 3269170.0\n", + " 23898\n", + " 601388\n", + " 3209981.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 321024.804561\n", - " 345132.495319\n", - " 329562.416251\n", - " 323549.743210\n", - " 317332.704749\n", - " 409463.606493\n", - " 410180.385199\n", - " -716.778707\n", + " 460721.942570\n", + " 407556.892301\n", + " 401004.293570\n", + " 421749.445065\n", + " 405452.318421\n", + " 400477.291574\n", + " 400608.907041\n", + " -131.615467\n", " \n", " \n", " 27\n", " 2052\n", - " 23610\n", - " 593948\n", - " 3148362.0\n", + " 23496\n", + " 591222\n", + " 3151911.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 469034.752168\n", - " 469662.194769\n", - " 448426.362540\n", - " 446609.577932\n", - " 435340.199013\n", - " 391160.953917\n", - " 393091.155764\n", - " -1930.201847\n", + " 309639.446977\n", + " 390992.045894\n", + " 420441.094988\n", + " 413192.196815\n", + " 409041.464387\n", + " 390999.580252\n", + " 392078.841473\n", + " -1079.261220\n", " \n", " \n", " 28\n", " 2053\n", - " 24612\n", - " 617265\n", - " 3291913.0\n", + " 24894\n", + " 627569\n", + " 3335143.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 479370.138921\n", - " 461118.374422\n", - " 452747.999276\n", - " 442215.228495\n", - " 400887.449181\n", - " 409930.626615\n", - " 412238.859114\n", - " -2308.232499\n", + " 332821.767357\n", + " 320904.427223\n", + " 316776.074425\n", + " 316292.885898\n", + " 306048.398243\n", + " 416471.045063\n", + " 418092.099246\n", + " -1621.054183\n", " \n", " \n", " 29\n", " 2054\n", - " 23846\n", - " 600531\n", - " 3190334.0\n", + " 21946\n", + " 552383\n", + " 2937089.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 378828.522395\n", - " 435684.567230\n", - " 434997.915598\n", - " 436064.621612\n", - " 432867.449960\n", - " 396400.887798\n", - " 396070.808867\n", - " 330.078931\n", + " 418144.175624\n", + " 404366.782226\n", + " 391164.519869\n", + " 373727.874006\n", + " 343975.955350\n", + " 360207.713252\n", + " 364273.522362\n", + " -4065.809111\n", " \n", " \n", " 30\n", " 2055\n", - " 24956\n", - " 628421\n", - " 3345467.0\n", + " 23076\n", + " 579568\n", + " 3072851.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 478046.700552\n", - " 428881.409055\n", - " 453508.028054\n", - " 449527.028001\n", - " 444985.809368\n", - " 416341.114108\n", - " 417028.311391\n", - " -687.197283\n", + " 300680.970171\n", + " 346289.174108\n", + " 340245.279011\n", + " 329299.172958\n", + " 309663.520488\n", + " 379799.778479\n", + " 382254.450494\n", + " -2454.672016\n", " \n", " \n", " 31\n", " 2056\n", - " 23703\n", - " 596560\n", - " 3172864.0\n", + " 23967\n", + " 601469\n", + " 3194980.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 370264.174609\n", - " 415190.572889\n", - " 426911.392935\n", - " 433321.292498\n", - " 423776.044021\n", - " 395081.647605\n", - " 391936.636790\n", - " 3145.010815\n", + " 461243.283456\n", + " 391853.983192\n", + " 387762.882037\n", + " 372651.645513\n", + " 355108.240357\n", + " 389694.500461\n", + " 393327.366843\n", + " -3632.866382\n", " \n", " \n", " 32\n", " 2057\n", - " 23884\n", - " 602103\n", - " 3215112.0\n", + " 23389\n", + " 588821\n", + " 3139033.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 378162.247570\n", - " 377205.366488\n", - " 342790.975990\n", - " 332326.448483\n", - " 330739.987217\n", - " 394811.555047\n", - " 396221.517042\n", - " -1409.961995\n", + " 379993.626328\n", + " 421170.962261\n", + " 417222.716525\n", + " 405927.199113\n", + " 379013.465979\n", + " 382707.973900\n", + " 382588.827454\n", + " 119.146445\n", " \n", " \n", " 33\n", " 2058\n", - " 24352\n", - " 611347\n", - " 3261366.0\n", + " 22093\n", + " 555609\n", + " 2950853.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 414908.289481\n", - " 333540.646309\n", - " 362992.743057\n", - " 366721.297324\n", - " 367575.167706\n", - " 401393.780962\n", - " 403754.537706\n", - " -2360.756744\n", + " 381230.056855\n", + " 354587.101006\n", + " 350957.265087\n", + " 326505.718272\n", + " 294446.256154\n", + " 361165.891802\n", + " 361939.932800\n", + " -774.040998\n", " \n", " \n", " 34\n", " 2059\n", - " 24055\n", - " 603579\n", - " 3200088.0\n", + " 23733\n", + " 596624\n", + " 3169901.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 455684.817802\n", - " 472393.409198\n", - " 478349.032980\n", - " 477401.048276\n", - " 438412.338758\n", - " 391860.264252\n", - " 393873.141006\n", - " -2012.876754\n", + " 501263.956015\n", + " 490253.713022\n", + " 477610.230551\n", + " 460159.597378\n", + " 444568.857000\n", + " 389684.514691\n", + " 391135.437740\n", + " -1450.923049\n", " \n", " \n", " 35\n", " 2060\n", - " 22401\n", - " 560380\n", - " 3000088.0\n", + " 23173\n", + " 582978\n", + " 3100047.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 359900.771691\n", - " 372597.770047\n", - " 360489.465892\n", - " 363261.114549\n", - " 359252.347918\n", - " 367209.410297\n", - " 366611.581462\n", - " 597.828835\n", + " 459757.304011\n", + " 436835.494548\n", + " 419958.086643\n", + " 435515.915955\n", + " 425013.325154\n", + " 383317.152377\n", + " 381266.519178\n", + " 2050.633200\n", " \n", " \n", " 36\n", " 2061\n", - " 25450\n", - " 639870\n", - " 3417374.0\n", + " 23689\n", + " 595156\n", + " 3162324.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 522352.080349\n", - " 579014.399822\n", - " 568925.720500\n", - " 565835.475117\n", - " 550598.603341\n", - " 417434.381690\n", - " 420020.233730\n", - " -2585.852040\n", + " 403898.123577\n", + " 446026.892969\n", + " 459573.706453\n", + " 436904.851847\n", + " 419966.747362\n", + " 390113.556785\n", + " 387064.014493\n", + " 3049.542292\n", " \n", " \n", " 37\n", " 2062\n", - " 23155\n", - " 582547\n", - " 3074410.0\n", + " 22794\n", + " 574103\n", + " 3036727.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 376936.757775\n", - " 379134.096954\n", - " 381629.099749\n", - " 364270.180436\n", - " 356574.164485\n", - " 377882.767541\n", - " 377365.440971\n", - " 517.326570\n", + " 468021.236699\n", + " 450100.730558\n", + " 416050.220079\n", + " 373748.278834\n", + " 351040.543393\n", + " 372856.397814\n", + " 373879.275648\n", + " -1022.877835\n", " \n", " \n", " 38\n", " 2063\n", - " 23057\n", - " 580043\n", - " 3084421.0\n", + " 22722\n", + " 573325\n", + " 3024141.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 467723.711737\n", - " 401612.564532\n", - " 392392.393319\n", - " 396304.528597\n", - " 394369.022680\n", - " 374082.177605\n", - " 374460.254161\n", - " -378.076555\n", + " 414958.264565\n", + " 415976.330050\n", + " 443797.927964\n", + " 453085.545667\n", + " 444035.139054\n", + " 367768.692199\n", + " 368187.001270\n", + " -418.309071\n", " \n", " \n", " 39\n", " 2064\n", - " 23503\n", - " 592241\n", - " 3138838.0\n", + " 23581\n", + " 590848\n", + " 3149704.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 323517.333199\n", - " 367831.340554\n", - " 346112.375544\n", - " 324946.993397\n", - " 312443.249634\n", - " 382423.385030\n", - " 382966.454764\n", - " -543.069734\n", + " 441414.054493\n", + " 435767.269524\n", + " 415051.021426\n", + " 406769.043607\n", + " 396642.228590\n", + " 378200.181200\n", + " 380644.486568\n", + " -2444.305368\n", " \n", " \n", " 40\n", " 2065\n", - " 23680\n", - " 594336\n", - " 3169648.0\n", + " 23523\n", + " 591233\n", + " 3157907.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 345713.935117\n", - " 293320.941908\n", - " 318220.999319\n", - " 326566.490286\n", - " 323628.322020\n", - " 384159.066998\n", - " 384056.354457\n", - " 102.712541\n", + " 433793.080907\n", + " 435494.327000\n", + " 421305.379992\n", + " 408124.267918\n", + " 399546.170001\n", + " 383210.897923\n", + " 380769.053462\n", + " 2441.844461\n", " \n", " \n", " 41\n", " 2066\n", - " 23743\n", - " 598339\n", - " 3198839.0\n", + " 22993\n", + " 578310\n", + " 3065123.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 395462.015387\n", - " 445201.806887\n", - " 440143.467266\n", - " 438945.020171\n", - " 435197.782687\n", - " 385665.968172\n", - " 385827.443170\n", - " -161.474998\n", + " 358327.837808\n", + " 382545.188235\n", + " 359818.742372\n", + " 354980.088513\n", + " 342669.140660\n", + " 373477.131153\n", + " 373664.729920\n", + " -187.598767\n", " \n", " \n", " 42\n", " 2067\n", - " 24569\n", - " 619436\n", - " 3283765.0\n", + " 23261\n", + " 583580\n", + " 3099017.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 406529.105098\n", - " 356852.651551\n", - " 349188.139601\n", - " 335367.151073\n", - " 336038.756644\n", - " 398291.557836\n", - " 400458.849287\n", - " -2167.291450\n", + " 385266.544939\n", + " 357229.405339\n", + " 389448.072900\n", + " 382553.140857\n", + " 367803.054399\n", + " 375480.781577\n", + " 376740.673312\n", + " -1259.891735\n", " \n", " \n", " 43\n", " 2068\n", - " 24122\n", - " 608216\n", - " 3240015.0\n", + " 23318\n", + " 586603\n", + " 3118001.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 574552.855124\n", - " 543870.172353\n", - " 546057.722361\n", - " 548303.362147\n", - " 547679.218868\n", - " 391932.655476\n", - " 393162.031631\n", - " -1229.376155\n", + " 444523.181015\n", + " 449728.133273\n", + " 439791.891824\n", + " 438856.705942\n", + " 426322.297655\n", + " 374245.788665\n", + " 375335.534050\n", + " -1089.745385\n", " \n", " \n", " 44\n", " 2069\n", - " 24546\n", - " 618608\n", - " 3287355.0\n", + " 23422\n", + " 588499\n", + " 3133720.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 446939.143675\n", - " 511156.014302\n", - " 533278.121296\n", - " 529131.538903\n", - " 529176.140345\n", - " 396645.182138\n", - " 399251.911588\n", - " -2606.729450\n", + " 445720.962431\n", + " 418703.399054\n", + " 431958.526817\n", + " 430211.684701\n", + " 419976.194936\n", + " 379224.450236\n", + " 378005.108376\n", + " 1219.341861\n", " \n", " \n", " 45\n", " 2070\n", - " 23805\n", - " 598800\n", - " 3180887.0\n", + " 23609\n", + " 593756\n", + " 3146747.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 478443.587177\n", - " 441135.161700\n", - " 433665.355653\n", - " 444075.669003\n", - " 439392.286115\n", - " 383002.326955\n", - " 384919.782302\n", - " -1917.455347\n", + " 400991.290205\n", + " 429393.430690\n", + " 411181.980311\n", + " 405133.787228\n", + " 386202.176410\n", + " 383743.213561\n", + " 381667.545696\n", + " 2075.667865\n", " \n", " \n", "\n", "
" ] }, - "execution_count": 23, + "execution_count": 51, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 23 + "execution_count": 51 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-03T10:30:40.235961Z", - "start_time": "2025-01-03T10:30:40.208890Z" + "end_time": "2025-01-03T11:37:13.805358Z", + "start_time": "2025-01-03T11:37:13.778402Z" } }, "cell_type": "code", @@ -1981,52 +1981,52 @@ "data": { "text/plain": [ " Year Month Facility_ID Altitude \\\n", - "0 2025 24642 620396 3302918.0 \n", - "1 2026 25447 640288 3423381.0 \n", - "2 2027 24346 613299 3249211.0 \n", - "3 2028 24165 609869 3233056.0 \n", - "4 2029 23856 600707 3182788.0 \n", - "5 2030 24743 621446 3305374.0 \n", - "6 2031 22311 564387 2993610.0 \n", - "7 2032 25011 629286 3346578.0 \n", - "8 2033 23162 584299 3096405.0 \n", - "9 2034 24560 617891 3283369.0 \n", - "10 2035 25040 629510 3351904.0 \n", - "11 2036 23845 597393 3180499.0 \n", - "12 2037 23332 586786 3128727.0 \n", - "13 2038 24976 626428 3359830.0 \n", - "14 2039 24253 610545 3257219.0 \n", - "15 2040 25057 629920 3355680.0 \n", - "16 2041 23909 603172 3217069.0 \n", - "17 2042 24546 614459 3284010.0 \n", - "18 2043 25169 634991 3380638.0 \n", - "19 2044 23565 591583 3151148.0 \n", - "20 2045 24921 627096 3335948.0 \n", - "21 2046 23776 598458 3181465.0 \n", - "22 2047 22152 556685 2957237.0 \n", - "23 2048 23385 588872 3114865.0 \n", - "24 2049 25584 643536 3435564.0 \n", - "25 2050 23985 603121 3199136.0 \n", - "26 2051 24460 615031 3269170.0 \n", - "27 2052 23610 593948 3148362.0 \n", - "28 2053 24612 617265 3291913.0 \n", - "29 2054 23846 600531 3190334.0 \n", - "30 2055 24956 628421 3345467.0 \n", - "31 2056 23703 596560 3172864.0 \n", - "32 2057 23884 602103 3215112.0 \n", - "33 2058 24352 611347 3261366.0 \n", - "34 2059 24055 603579 3200088.0 \n", - "35 2060 22401 560380 3000088.0 \n", - "36 2061 25450 639870 3417374.0 \n", - "37 2062 23155 582547 3074410.0 \n", - "38 2063 23057 580043 3084421.0 \n", - "39 2064 23503 592241 3138838.0 \n", - "40 2065 23680 594336 3169648.0 \n", - "41 2066 23743 598339 3198839.0 \n", - "42 2067 24569 619436 3283765.0 \n", - "43 2068 24122 608216 3240015.0 \n", - "44 2069 24546 618608 3287355.0 \n", - "45 2070 23805 598800 3180887.0 \n", + "0 2025 23814 599734 3182595.0 \n", + "1 2026 22590 566009 3008054.0 \n", + "2 2027 24474 614678 3269771.0 \n", + "3 2028 23968 600596 3207601.0 \n", + "4 2029 23330 583610 3116929.0 \n", + "5 2030 24073 605374 3226700.0 \n", + "6 2031 23580 593098 3161559.0 \n", + "7 2032 23000 576874 3067975.0 \n", + "8 2033 23581 593277 3157142.0 \n", + "9 2034 24459 614471 3272543.0 \n", + "10 2035 24070 601705 3227338.0 \n", + "11 2036 22412 563438 2989556.0 \n", + "12 2037 23224 583884 3111738.0 \n", + "13 2038 23088 581270 3091620.0 \n", + "14 2039 23796 598440 3178339.0 \n", + "15 2040 24867 625341 3333272.0 \n", + "16 2041 23418 588798 3126883.0 \n", + "17 2042 24483 614818 3264448.0 \n", + "18 2043 22584 568163 3020289.0 \n", + "19 2044 23377 588639 3133986.0 \n", + "20 2045 23817 599233 3190091.0 \n", + "21 2046 24583 616970 3286711.0 \n", + "22 2047 22492 563400 2990632.0 \n", + "23 2048 23857 599713 3190814.0 \n", + "24 2049 23922 602508 3200414.0 \n", + "25 2050 23672 596141 3153492.0 \n", + "26 2051 23898 601388 3209981.0 \n", + "27 2052 23496 591222 3151911.0 \n", + "28 2053 24894 627569 3335143.0 \n", + "29 2054 21946 552383 2937089.0 \n", + "30 2055 23076 579568 3072851.0 \n", + "31 2056 23967 601469 3194980.0 \n", + "32 2057 23389 588821 3139033.0 \n", + "33 2058 22093 555609 2950853.0 \n", + "34 2059 23733 596624 3169901.0 \n", + "35 2060 23173 582978 3100047.0 \n", + "36 2061 23689 595156 3162324.0 \n", + "37 2062 22794 574103 3036727.0 \n", + "38 2063 22722 573325 3024141.0 \n", + "39 2064 23581 590848 3149704.0 \n", + "40 2065 23523 591233 3157907.0 \n", + "41 2066 22993 578310 3065123.0 \n", + "42 2067 23261 583580 3099017.0 \n", + "43 2068 23318 586603 3118001.0 \n", + "44 2069 23422 588499 3133720.0 \n", + "45 2070 23609 593756 3146747.0 \n", "\n", " Zone \\\n", "0 Central WestSouth EastNorthernSouth EastNorthe... \n", @@ -2173,196 +2173,196 @@ "45 GovernmentGovernmentGovernmentGovernmentGovern... \n", "\n", " Facility_Type Precipitation \\\n", - "0 ClinicDistrict HospitalRural/Community Hospita... 440334.234308 \n", - "1 ClinicDistrict HospitalRural/Community Hospita... 368143.657611 \n", - "2 ClinicDistrict HospitalRural/Community Hospita... 389512.271746 \n", - "3 ClinicDistrict HospitalRural/Community Hospita... 467236.272652 \n", - "4 ClinicDistrict HospitalRural/Community Hospita... 510281.500940 \n", - "5 ClinicDistrict HospitalRural/Community Hospita... 415561.678186 \n", - "6 ClinicDistrict HospitalRural/Community Hospita... 306576.789734 \n", - "7 ClinicDistrict HospitalRural/Community Hospita... 322789.637078 \n", - "8 ClinicDistrict HospitalRural/Community Hospita... 417617.290163 \n", - "9 ClinicDistrict HospitalRural/Community Hospita... 397886.401018 \n", - "10 ClinicDistrict HospitalRural/Community Hospita... 459406.340711 \n", - "11 ClinicDistrict HospitalRural/Community Hospita... 397647.735041 \n", - "12 ClinicDistrict HospitalRural/Community Hospita... 391610.416555 \n", - "13 ClinicDistrict HospitalRural/Community Hospita... 441416.106096 \n", - "14 ClinicDistrict HospitalRural/Community Hospita... 375365.449796 \n", - "15 ClinicDistrict HospitalRural/Community Hospita... 410970.020588 \n", - "16 ClinicDistrict HospitalRural/Community Hospita... 409283.988225 \n", - "17 ClinicDistrict HospitalRural/Community Hospita... 473493.289947 \n", - "18 ClinicDistrict HospitalRural/Community Hospita... 469347.741866 \n", - "19 ClinicDistrict HospitalRural/Community Hospita... 367242.325518 \n", - "20 ClinicDistrict HospitalRural/Community Hospita... 315560.724644 \n", - "21 ClinicDistrict HospitalRural/Community Hospita... 371782.115694 \n", - "22 ClinicDistrict HospitalRural/Community Hospita... 434630.692016 \n", - "23 ClinicDistrict HospitalRural/Community Hospita... 341127.222055 \n", - "24 ClinicDistrict HospitalRural/Community Hospita... 431988.493807 \n", - "25 ClinicDistrict HospitalRural/Community Hospita... 421327.798951 \n", - "26 ClinicDistrict HospitalRural/Community Hospita... 321024.804561 \n", - "27 ClinicDistrict HospitalRural/Community Hospita... 469034.752168 \n", - "28 ClinicDistrict HospitalRural/Community Hospita... 479370.138921 \n", - "29 ClinicDistrict HospitalRural/Community Hospita... 378828.522395 \n", - "30 ClinicDistrict HospitalRural/Community Hospita... 478046.700552 \n", - "31 ClinicDistrict HospitalRural/Community Hospita... 370264.174609 \n", - "32 ClinicDistrict HospitalRural/Community Hospita... 378162.247570 \n", - "33 ClinicDistrict HospitalRural/Community Hospita... 414908.289481 \n", - "34 ClinicDistrict HospitalRural/Community Hospita... 455684.817802 \n", - "35 ClinicDistrict HospitalRural/Community Hospita... 359900.771691 \n", - "36 ClinicDistrict HospitalRural/Community Hospita... 522352.080349 \n", - "37 ClinicDistrict HospitalRural/Community Hospita... 376936.757775 \n", - "38 ClinicDistrict HospitalRural/Community Hospita... 467723.711737 \n", - "39 ClinicDistrict HospitalRural/Community Hospita... 323517.333199 \n", - "40 ClinicDistrict HospitalRural/Community Hospita... 345713.935117 \n", - "41 ClinicDistrict HospitalRural/Community Hospita... 395462.015387 \n", - "42 ClinicDistrict HospitalRural/Community Hospita... 406529.105098 \n", - "43 ClinicDistrict HospitalRural/Community Hospita... 574552.855124 \n", - "44 ClinicDistrict HospitalRural/Community Hospita... 446939.143675 \n", - "45 ClinicDistrict HospitalRural/Community Hospita... 478443.587177 \n", + "0 ClinicDistrict HospitalRural/Community Hospita... 356930.256793 \n", + "1 ClinicDistrict HospitalRural/Community Hospita... 442012.194055 \n", + "2 ClinicDistrict HospitalRural/Community Hospita... 401910.341187 \n", + "3 ClinicDistrict HospitalRural/Community Hospita... 458028.122792 \n", + "4 ClinicDistrict HospitalRural/Community Hospita... 406191.851826 \n", + "5 ClinicDistrict HospitalRural/Community Hospita... 409387.038984 \n", + "6 ClinicDistrict HospitalRural/Community Hospita... 400600.129109 \n", + "7 ClinicDistrict HospitalRural/Community Hospita... 447521.070185 \n", + "8 ClinicDistrict HospitalRural/Community Hospita... 456815.880827 \n", + "9 ClinicDistrict HospitalRural/Community Hospita... 443520.485079 \n", + "10 ClinicDistrict HospitalRural/Community Hospita... 411313.075371 \n", + "11 ClinicDistrict HospitalRural/Community Hospita... 401467.863756 \n", + "12 ClinicDistrict HospitalRural/Community Hospita... 419545.873961 \n", + "13 ClinicDistrict HospitalRural/Community Hospita... 463682.059169 \n", + "14 ClinicDistrict HospitalRural/Community Hospita... 439471.811655 \n", + "15 ClinicDistrict HospitalRural/Community Hospita... 451058.889825 \n", + "16 ClinicDistrict HospitalRural/Community Hospita... 364816.739985 \n", + "17 ClinicDistrict HospitalRural/Community Hospita... 474909.052258 \n", + "18 ClinicDistrict HospitalRural/Community Hospita... 437730.151447 \n", + "19 ClinicDistrict HospitalRural/Community Hospita... 467117.570232 \n", + "20 ClinicDistrict HospitalRural/Community Hospita... 398139.357152 \n", + "21 ClinicDistrict HospitalRural/Community Hospita... 443421.655978 \n", + "22 ClinicDistrict HospitalRural/Community Hospita... 494553.446600 \n", + "23 ClinicDistrict HospitalRural/Community Hospita... 472153.619753 \n", + "24 ClinicDistrict HospitalRural/Community Hospita... 465094.209967 \n", + "25 ClinicDistrict HospitalRural/Community Hospita... 452834.779144 \n", + "26 ClinicDistrict HospitalRural/Community Hospita... 460721.942570 \n", + "27 ClinicDistrict HospitalRural/Community Hospita... 309639.446977 \n", + "28 ClinicDistrict HospitalRural/Community Hospita... 332821.767357 \n", + "29 ClinicDistrict HospitalRural/Community Hospita... 418144.175624 \n", + "30 ClinicDistrict HospitalRural/Community Hospita... 300680.970171 \n", + "31 ClinicDistrict HospitalRural/Community Hospita... 461243.283456 \n", + "32 ClinicDistrict HospitalRural/Community Hospita... 379993.626328 \n", + "33 ClinicDistrict HospitalRural/Community Hospita... 381230.056855 \n", + "34 ClinicDistrict HospitalRural/Community Hospita... 501263.956015 \n", + "35 ClinicDistrict HospitalRural/Community Hospita... 459757.304011 \n", + "36 ClinicDistrict HospitalRural/Community Hospita... 403898.123577 \n", + "37 ClinicDistrict HospitalRural/Community Hospita... 468021.236699 \n", + "38 ClinicDistrict HospitalRural/Community Hospita... 414958.264565 \n", + "39 ClinicDistrict HospitalRural/Community Hospita... 441414.054493 \n", + "40 ClinicDistrict HospitalRural/Community Hospita... 433793.080907 \n", + "41 ClinicDistrict HospitalRural/Community Hospita... 358327.837808 \n", + "42 ClinicDistrict HospitalRural/Community Hospita... 385266.544939 \n", + "43 ClinicDistrict HospitalRural/Community Hospita... 444523.181015 \n", + "44 ClinicDistrict HospitalRural/Community Hospita... 445720.962431 \n", + "45 ClinicDistrict HospitalRural/Community Hospita... 400991.290205 \n", "\n", " Lag_1_Precipitation Lag_2_Precipitation Lag_3_Precipitation \\\n", - "0 353904.731005 325681.489860 297561.640581 \n", - "1 401420.433758 403405.854504 402539.554951 \n", - "2 371731.795831 352017.560308 341274.411245 \n", - "3 463195.874132 489324.647136 467717.368493 \n", - "4 502657.340862 482774.102033 508613.994882 \n", - "5 430082.709305 433194.385110 426679.595380 \n", - "6 309978.599600 325681.193935 315680.278887 \n", - "7 346456.981332 346504.507849 343190.362299 \n", - "8 357429.121158 338700.251142 340245.308388 \n", - "9 399155.990738 376194.009554 375103.117941 \n", - "10 495631.995766 495403.900197 486208.445508 \n", - "11 394956.683884 407506.319795 414531.165308 \n", - "12 343980.571323 350808.137426 347057.035888 \n", - "13 452575.562133 454464.217285 452146.877154 \n", - "14 362433.347050 371149.568476 363933.535093 \n", - "15 447884.643580 447682.568270 449803.904849 \n", - "16 389442.315269 385668.859805 378426.274901 \n", - "17 451147.769581 430615.696082 425669.313089 \n", - "18 494545.073752 499347.930783 493783.833404 \n", - "19 371711.781452 374913.433345 377110.720066 \n", - "20 343353.455376 345223.997177 342021.238793 \n", - "21 305812.333010 294432.924965 293503.944334 \n", - "22 457467.620834 474432.706520 472613.554807 \n", - "23 315111.678821 294945.264077 285233.426898 \n", - "24 443731.169805 451146.067144 447883.026972 \n", - "25 396769.929491 408562.425855 418502.725903 \n", - "26 345132.495319 329562.416251 323549.743210 \n", - "27 469662.194769 448426.362540 446609.577932 \n", - "28 461118.374422 452747.999276 442215.228495 \n", - "29 435684.567230 434997.915598 436064.621612 \n", - "30 428881.409055 453508.028054 449527.028001 \n", - "31 415190.572889 426911.392935 433321.292498 \n", - "32 377205.366488 342790.975990 332326.448483 \n", - "33 333540.646309 362992.743057 366721.297324 \n", - "34 472393.409198 478349.032980 477401.048276 \n", - "35 372597.770047 360489.465892 363261.114549 \n", - "36 579014.399822 568925.720500 565835.475117 \n", - "37 379134.096954 381629.099749 364270.180436 \n", - "38 401612.564532 392392.393319 396304.528597 \n", - "39 367831.340554 346112.375544 324946.993397 \n", - "40 293320.941908 318220.999319 326566.490286 \n", - "41 445201.806887 440143.467266 438945.020171 \n", - "42 356852.651551 349188.139601 335367.151073 \n", - "43 543870.172353 546057.722361 548303.362147 \n", - "44 511156.014302 533278.121296 529131.538903 \n", - "45 441135.161700 433665.355653 444075.669003 \n", + "0 294609.145696 251778.819911 240074.691709 \n", + "1 397157.668329 397273.347895 348266.651361 \n", + "2 414186.725872 420900.694753 423488.413324 \n", + "3 454173.805476 433342.964932 425159.752149 \n", + "4 439691.054081 445950.755762 418870.421666 \n", + "5 389364.247808 392455.710835 397461.356243 \n", + "6 392631.249314 374449.656015 373894.307761 \n", + "7 402914.631768 394545.775941 380305.249049 \n", + "8 498011.574391 475942.063738 466685.963435 \n", + "9 441306.486897 449381.026641 430634.351876 \n", + "10 461142.612330 444654.932360 434587.827755 \n", + "11 357763.087422 364775.944769 347716.667867 \n", + "12 416541.339977 409043.550166 391920.926233 \n", + "13 442526.600924 451303.450407 456286.448435 \n", + "14 486171.696867 502289.466180 498044.017229 \n", + "15 431633.402209 402153.409212 398040.518931 \n", + "16 335208.786306 354775.001534 338447.362232 \n", + "17 506841.062275 463684.071161 461858.642099 \n", + "18 415617.644419 410420.270555 407615.216190 \n", + "19 486817.869497 480637.195403 474544.770943 \n", + "20 362850.193582 402219.531548 399839.624296 \n", + "21 468076.690976 465542.221447 467423.630271 \n", + "22 444767.223650 409485.605985 387260.946000 \n", + "23 503414.718730 491261.349692 495127.838946 \n", + "24 455038.002255 477898.743986 469420.838584 \n", + "25 465973.024854 462746.331497 425762.806114 \n", + "26 407556.892301 401004.293570 421749.445065 \n", + "27 390992.045894 420441.094988 413192.196815 \n", + "28 320904.427223 316776.074425 316292.885898 \n", + "29 404366.782226 391164.519869 373727.874006 \n", + "30 346289.174108 340245.279011 329299.172958 \n", + "31 391853.983192 387762.882037 372651.645513 \n", + "32 421170.962261 417222.716525 405927.199113 \n", + "33 354587.101006 350957.265087 326505.718272 \n", + "34 490253.713022 477610.230551 460159.597378 \n", + "35 436835.494548 419958.086643 435515.915955 \n", + "36 446026.892969 459573.706453 436904.851847 \n", + "37 450100.730558 416050.220079 373748.278834 \n", + "38 415976.330050 443797.927964 453085.545667 \n", + "39 435767.269524 415051.021426 406769.043607 \n", + "40 435494.327000 421305.379992 408124.267918 \n", + "41 382545.188235 359818.742372 354980.088513 \n", + "42 357229.405339 389448.072900 382553.140857 \n", + "43 449728.133273 439791.891824 438856.705942 \n", + "44 418703.399054 431958.526817 430211.684701 \n", + "45 429393.430690 411181.980311 405133.787228 \n", "\n", " Lag_4_Precipitation Predicted_Weather_Model Predicted_No_Weather_Model \\\n", - "0 282054.887587 282875.789559 435056.523872 \n", - "1 403356.754888 446973.452602 448297.963620 \n", - "2 330719.679227 429699.165446 428855.082772 \n", - "3 464588.245545 426390.662966 425105.144739 \n", - "4 503630.296180 419862.210285 417366.002941 \n", - "5 423888.501330 429293.165886 430209.704481 \n", - "6 290028.482608 388423.461274 388929.485473 \n", - "7 342685.296868 434991.492594 436710.225310 \n", - "8 340546.248413 400294.397759 402492.398969 \n", - "9 373789.068455 425657.584762 427231.110037 \n", - "10 482900.825373 433154.044585 434659.478247 \n", - "11 393286.530926 409005.784582 408150.336768 \n", - "12 341463.248905 399090.628516 401572.454562 \n", - "13 450786.011451 431402.659483 429626.731487 \n", - "14 360843.806040 412578.359715 415007.121480 \n", - "15 448981.207566 428390.924640 428879.058208 \n", - "16 374044.680265 407922.043693 409972.692203 \n", - "17 429496.615643 412187.659372 413257.478800 \n", - "18 488803.549502 430347.112355 430015.937504 \n", - "19 377895.449896 401348.874670 401054.748615 \n", - "20 334436.491016 423672.932007 425227.379946 \n", - "21 296392.880809 398552.821055 401775.342808 \n", - "22 440392.213570 373087.409200 374239.513003 \n", - "23 253195.609983 390315.605105 391466.290883 \n", - "24 446049.207337 430832.507546 432053.418987 \n", - "25 419774.688159 402422.115951 403916.440618 \n", - "26 317332.704749 409463.606493 410180.385199 \n", - "27 435340.199013 391160.953917 393091.155764 \n", - "28 400887.449181 409930.626615 412238.859114 \n", - "29 432867.449960 396400.887798 396070.808867 \n", - "30 444985.809368 416341.114108 417028.311391 \n", - "31 423776.044021 395081.647605 391936.636790 \n", - "32 330739.987217 394811.555047 396221.517042 \n", - "33 367575.167706 401393.780962 403754.537706 \n", - "34 438412.338758 391860.264252 393873.141006 \n", - "35 359252.347918 367209.410297 366611.581462 \n", - "36 550598.603341 417434.381690 420020.233730 \n", - "37 356574.164485 377882.767541 377365.440971 \n", - "38 394369.022680 374082.177605 374460.254161 \n", - "39 312443.249634 382423.385030 382966.454764 \n", - "40 323628.322020 384159.066998 384056.354457 \n", - "41 435197.782687 385665.968172 385827.443170 \n", - "42 336038.756644 398291.557836 400458.849287 \n", - "43 547679.218868 391932.655476 393162.031631 \n", - "44 529176.140345 396645.182138 399251.911588 \n", - "45 439392.286115 383002.326955 384919.782302 \n", + "0 212611.355306 262073.177045 414580.859514 \n", + "1 329607.014297 391897.166673 394712.494598 \n", + "2 427242.313426 424216.303078 426507.644233 \n", + "3 409583.757336 418663.778757 419005.094793 \n", + "4 404708.312917 405721.982368 407774.686109 \n", + "5 389452.051202 422077.382352 421235.583604 \n", + "6 361847.942122 406625.933041 406869.091856 \n", + "7 367935.056473 390456.768764 393982.523859 \n", + "8 443793.819493 404036.109552 407105.988595 \n", + "9 428705.248932 419086.106241 421792.859293 \n", + "10 424916.410268 414353.849683 416718.943844 \n", + "11 321868.628640 379822.724678 383326.342849 \n", + "12 378814.601365 396472.620305 397095.249567 \n", + "13 441830.397786 392687.251512 394380.103735 \n", + "14 485302.039523 402985.471692 406826.384026 \n", + "15 371349.124368 425017.218302 426405.341430 \n", + "16 321940.022061 397017.066601 399458.496395 \n", + "17 454618.554156 416691.544445 416997.757878 \n", + "18 384771.629007 383660.669690 383755.734156 \n", + "19 455304.239249 394673.545565 394754.939189 \n", + "20 377344.967272 401135.309503 402985.317847 \n", + "21 464577.255028 412242.557813 413773.489936 \n", + "22 360098.331291 372146.903936 375589.196357 \n", + "23 485805.294721 401945.091876 402709.253238 \n", + "24 440243.139280 398685.865173 401567.430428 \n", + "25 427139.769513 399252.955628 398635.670647 \n", + "26 405452.318421 400477.291574 400608.907041 \n", + "27 409041.464387 390999.580252 392078.841473 \n", + "28 306048.398243 416471.045063 418092.099246 \n", + "29 343975.955350 360207.713252 364273.522362 \n", + "30 309663.520488 379799.778479 382254.450494 \n", + "31 355108.240357 389694.500461 393327.366843 \n", + "32 379013.465979 382707.973900 382588.827454 \n", + "33 294446.256154 361165.891802 361939.932800 \n", + "34 444568.857000 389684.514691 391135.437740 \n", + "35 425013.325154 383317.152377 381266.519178 \n", + "36 419966.747362 390113.556785 387064.014493 \n", + "37 351040.543393 372856.397814 373879.275648 \n", + "38 444035.139054 367768.692199 368187.001270 \n", + "39 396642.228590 378200.181200 380644.486568 \n", + "40 399546.170001 383210.897923 380769.053462 \n", + "41 342669.140660 373477.131153 373664.729920 \n", + "42 367803.054399 375480.781577 376740.673312 \n", + "43 426322.297655 374245.788665 375335.534050 \n", + "44 419976.194936 379224.450236 378005.108376 \n", + "45 386202.176410 383743.213561 381667.545696 \n", "\n", " Difference_in_Expectation Percentage_Difference \n", - "0 -1479.431742 -0.003401 \n", - "1 -1324.511018 -0.002955 \n", - "2 844.082675 0.001968 \n", - "3 1285.518227 0.003024 \n", - "4 2496.207344 0.005981 \n", - "5 -916.538595 -0.002130 \n", - "6 -506.024199 -0.001301 \n", - "7 -1718.732715 -0.003936 \n", - "8 -2198.001210 -0.005461 \n", - "9 -1573.525275 -0.003683 \n", - "10 -1505.433662 -0.003463 \n", - "11 855.447814 0.002096 \n", - "12 -2481.826046 -0.006180 \n", - "13 1775.927996 0.004134 \n", - "14 -2428.761765 -0.005852 \n", - "15 -488.133568 -0.001138 \n", - "16 -2050.648510 -0.005002 \n", - "17 -1069.819428 -0.002589 \n", - "18 331.174851 0.000770 \n", - "19 294.126054 0.000733 \n", - "20 -1554.447940 -0.003656 \n", - "21 -3222.521752 -0.008021 \n", - "22 -1152.103803 -0.003079 \n", - "23 -1150.685778 -0.002939 \n", - "24 -1220.911442 -0.002826 \n", - "25 -1494.324667 -0.003700 \n", - "26 -716.778707 -0.001747 \n", - "27 -1930.201847 -0.004910 \n", - "28 -2308.232499 -0.005599 \n", - "29 330.078931 0.000833 \n", - "30 -687.197283 -0.001648 \n", - "31 3145.010815 0.008024 \n", - "32 -1409.961995 -0.003559 \n", - "33 -2360.756744 -0.005847 \n", - "34 -2012.876754 -0.005110 \n", - "35 597.828835 0.001631 \n", - "36 -2585.852040 -0.006156 \n", - "37 517.326570 0.001371 \n", - "38 -378.076555 -0.001010 \n", - "39 -543.069734 -0.001418 \n", - "40 102.712541 0.000267 \n", - "41 -161.474998 -0.000419 \n", - "42 -2167.291450 -0.005412 \n", - "43 -1229.376155 -0.003127 \n", - "44 -2606.729450 -0.006529 \n", - "45 -1917.455347 -0.004981 " + "0 -1806.379897 -0.004357 \n", + "1 -2815.327925 -0.007133 \n", + "2 -2291.341155 -0.005372 \n", + "3 -341.316036 -0.000815 \n", + "4 -2052.703741 -0.005034 \n", + "5 841.798749 0.001998 \n", + "6 -243.158815 -0.000598 \n", + "7 -3525.755094 -0.008949 \n", + "8 -3069.879043 -0.007541 \n", + "9 -2706.753053 -0.006417 \n", + "10 -2365.094162 -0.005676 \n", + "11 -3503.618171 -0.009140 \n", + "12 -622.629263 -0.001568 \n", + "13 -1692.852223 -0.004292 \n", + "14 -3840.912333 -0.009441 \n", + "15 -1388.123129 -0.003255 \n", + "16 -2441.429794 -0.006112 \n", + "17 -306.213433 -0.000734 \n", + "18 -95.064467 -0.000248 \n", + "19 -81.393624 -0.000206 \n", + "20 -1850.008344 -0.004591 \n", + "21 -1530.932123 -0.003700 \n", + "22 -3442.292421 -0.009165 \n", + "23 -764.161361 -0.001898 \n", + "24 -2881.565255 -0.007176 \n", + "25 617.284980 0.001548 \n", + "26 -131.615467 -0.000329 \n", + "27 -1079.261220 -0.002753 \n", + "28 -1621.054183 -0.003877 \n", + "29 -4065.809111 -0.011161 \n", + "30 -2454.672016 -0.006422 \n", + "31 -3632.866382 -0.009236 \n", + "32 119.146445 0.000311 \n", + "33 -774.040998 -0.002139 \n", + "34 -1450.923049 -0.003710 \n", + "35 2050.633200 0.005378 \n", + "36 3049.542292 0.007879 \n", + "37 -1022.877835 -0.002736 \n", + "38 -418.309071 -0.001136 \n", + "39 -2444.305368 -0.006421 \n", + "40 2441.844461 0.006413 \n", + "41 -187.598767 -0.000502 \n", + "42 -1259.891735 -0.003344 \n", + "43 -1089.745385 -0.002903 \n", + "44 1219.341861 0.003226 \n", + "45 2075.667865 0.005438 " ], "text/html": [ "
\n", @@ -2406,940 +2406,940 @@ " \n", " 0\n", " 2025\n", - " 24642\n", - " 620396\n", - " 3302918.0\n", + " 23814\n", + " 599734\n", + " 3182595.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 440334.234308\n", - " 353904.731005\n", - " 325681.489860\n", - " 297561.640581\n", - " 282054.887587\n", - " 282875.789559\n", - " 435056.523872\n", - " -1479.431742\n", - " -0.003401\n", + " 356930.256793\n", + " 294609.145696\n", + " 251778.819911\n", + " 240074.691709\n", + " 212611.355306\n", + " 262073.177045\n", + " 414580.859514\n", + " -1806.379897\n", + " -0.004357\n", " \n", " \n", " 1\n", " 2026\n", - " 25447\n", - " 640288\n", - " 3423381.0\n", + " 22590\n", + " 566009\n", + " 3008054.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 368143.657611\n", - " 401420.433758\n", - " 403405.854504\n", - " 402539.554951\n", - " 403356.754888\n", - " 446973.452602\n", - " 448297.963620\n", - " -1324.511018\n", - " -0.002955\n", + " 442012.194055\n", + " 397157.668329\n", + " 397273.347895\n", + " 348266.651361\n", + " 329607.014297\n", + " 391897.166673\n", + " 394712.494598\n", + " -2815.327925\n", + " -0.007133\n", " \n", " \n", " 2\n", " 2027\n", - " 24346\n", - " 613299\n", - " 3249211.0\n", + " 24474\n", + " 614678\n", + " 3269771.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 389512.271746\n", - " 371731.795831\n", - " 352017.560308\n", - " 341274.411245\n", - " 330719.679227\n", - " 429699.165446\n", - " 428855.082772\n", - " 844.082675\n", - " 0.001968\n", + " 401910.341187\n", + " 414186.725872\n", + " 420900.694753\n", + " 423488.413324\n", + " 427242.313426\n", + " 424216.303078\n", + " 426507.644233\n", + " -2291.341155\n", + " -0.005372\n", " \n", " \n", " 3\n", " 2028\n", - " 24165\n", - " 609869\n", - " 3233056.0\n", + " 23968\n", + " 600596\n", + " 3207601.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 467236.272652\n", - " 463195.874132\n", - " 489324.647136\n", - " 467717.368493\n", - " 464588.245545\n", - " 426390.662966\n", - " 425105.144739\n", - " 1285.518227\n", - " 0.003024\n", + " 458028.122792\n", + " 454173.805476\n", + " 433342.964932\n", + " 425159.752149\n", + " 409583.757336\n", + " 418663.778757\n", + " 419005.094793\n", + " -341.316036\n", + " -0.000815\n", " \n", " \n", " 4\n", " 2029\n", - " 23856\n", - " 600707\n", - " 3182788.0\n", + " 23330\n", + " 583610\n", + " 3116929.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 510281.500940\n", - " 502657.340862\n", - " 482774.102033\n", - " 508613.994882\n", - " 503630.296180\n", - " 419862.210285\n", - " 417366.002941\n", - " 2496.207344\n", - " 0.005981\n", + " 406191.851826\n", + " 439691.054081\n", + " 445950.755762\n", + " 418870.421666\n", + " 404708.312917\n", + " 405721.982368\n", + " 407774.686109\n", + " -2052.703741\n", + " -0.005034\n", " \n", " \n", " 5\n", " 2030\n", - " 24743\n", - " 621446\n", - " 3305374.0\n", + " 24073\n", + " 605374\n", + " 3226700.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 415561.678186\n", - " 430082.709305\n", - " 433194.385110\n", - " 426679.595380\n", - " 423888.501330\n", - " 429293.165886\n", - " 430209.704481\n", - " -916.538595\n", - " -0.002130\n", + " 409387.038984\n", + " 389364.247808\n", + " 392455.710835\n", + " 397461.356243\n", + " 389452.051202\n", + " 422077.382352\n", + " 421235.583604\n", + " 841.798749\n", + " 0.001998\n", " \n", " \n", " 6\n", " 2031\n", - " 22311\n", - " 564387\n", - " 2993610.0\n", + " 23580\n", + " 593098\n", + " 3161559.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 306576.789734\n", - " 309978.599600\n", - " 325681.193935\n", - " 315680.278887\n", - " 290028.482608\n", - " 388423.461274\n", - " 388929.485473\n", - " -506.024199\n", - " -0.001301\n", + " 400600.129109\n", + " 392631.249314\n", + " 374449.656015\n", + " 373894.307761\n", + " 361847.942122\n", + " 406625.933041\n", + " 406869.091856\n", + " -243.158815\n", + " -0.000598\n", " \n", " \n", " 7\n", " 2032\n", - " 25011\n", - " 629286\n", - " 3346578.0\n", + " 23000\n", + " 576874\n", + " 3067975.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 322789.637078\n", - " 346456.981332\n", - " 346504.507849\n", - " 343190.362299\n", - " 342685.296868\n", - " 434991.492594\n", - " 436710.225310\n", - " -1718.732715\n", - " -0.003936\n", + " 447521.070185\n", + " 402914.631768\n", + " 394545.775941\n", + " 380305.249049\n", + " 367935.056473\n", + " 390456.768764\n", + " 393982.523859\n", + " -3525.755094\n", + " -0.008949\n", " \n", " \n", " 8\n", " 2033\n", - " 23162\n", - " 584299\n", - " 3096405.0\n", + " 23581\n", + " 593277\n", + " 3157142.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 417617.290163\n", - " 357429.121158\n", - " 338700.251142\n", - " 340245.308388\n", - " 340546.248413\n", - " 400294.397759\n", - " 402492.398969\n", - " -2198.001210\n", - " -0.005461\n", + " 456815.880827\n", + " 498011.574391\n", + " 475942.063738\n", + " 466685.963435\n", + " 443793.819493\n", + " 404036.109552\n", + " 407105.988595\n", + " -3069.879043\n", + " -0.007541\n", " \n", " \n", " 9\n", " 2034\n", - " 24560\n", - " 617891\n", - " 3283369.0\n", + " 24459\n", + " 614471\n", + " 3272543.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 397886.401018\n", - " 399155.990738\n", - " 376194.009554\n", - " 375103.117941\n", - " 373789.068455\n", - " 425657.584762\n", - " 427231.110037\n", - " -1573.525275\n", - " -0.003683\n", + " 443520.485079\n", + " 441306.486897\n", + " 449381.026641\n", + " 430634.351876\n", + " 428705.248932\n", + " 419086.106241\n", + " 421792.859293\n", + " -2706.753053\n", + " -0.006417\n", " \n", " \n", " 10\n", " 2035\n", - " 25040\n", - " 629510\n", - " 3351904.0\n", + " 24070\n", + " 601705\n", + " 3227338.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 459406.340711\n", - " 495631.995766\n", - " 495403.900197\n", - " 486208.445508\n", - " 482900.825373\n", - " 433154.044585\n", - " 434659.478247\n", - " -1505.433662\n", - " -0.003463\n", + " 411313.075371\n", + " 461142.612330\n", + " 444654.932360\n", + " 434587.827755\n", + " 424916.410268\n", + " 414353.849683\n", + " 416718.943844\n", + " -2365.094162\n", + " -0.005676\n", " \n", " \n", " 11\n", " 2036\n", - " 23845\n", - " 597393\n", - " 3180499.0\n", + " 22412\n", + " 563438\n", + " 2989556.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 397647.735041\n", - " 394956.683884\n", - " 407506.319795\n", - " 414531.165308\n", - " 393286.530926\n", - " 409005.784582\n", - " 408150.336768\n", - " 855.447814\n", - " 0.002096\n", + " 401467.863756\n", + " 357763.087422\n", + " 364775.944769\n", + " 347716.667867\n", + " 321868.628640\n", + " 379822.724678\n", + " 383326.342849\n", + " -3503.618171\n", + " -0.009140\n", " \n", " \n", " 12\n", " 2037\n", - " 23332\n", - " 586786\n", - " 3128727.0\n", + " 23224\n", + " 583884\n", + " 3111738.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 391610.416555\n", - " 343980.571323\n", - " 350808.137426\n", - " 347057.035888\n", - " 341463.248905\n", - " 399090.628516\n", - " 401572.454562\n", - " -2481.826046\n", - " -0.006180\n", + " 419545.873961\n", + " 416541.339977\n", + " 409043.550166\n", + " 391920.926233\n", + " 378814.601365\n", + " 396472.620305\n", + " 397095.249567\n", + " -622.629263\n", + " -0.001568\n", " \n", " \n", " 13\n", " 2038\n", - " 24976\n", - " 626428\n", - " 3359830.0\n", + " 23088\n", + " 581270\n", + " 3091620.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 441416.106096\n", - " 452575.562133\n", - " 454464.217285\n", - " 452146.877154\n", - " 450786.011451\n", - " 431402.659483\n", - " 429626.731487\n", - " 1775.927996\n", - " 0.004134\n", + " 463682.059169\n", + " 442526.600924\n", + " 451303.450407\n", + " 456286.448435\n", + " 441830.397786\n", + " 392687.251512\n", + " 394380.103735\n", + " -1692.852223\n", + " -0.004292\n", " \n", " \n", " 14\n", " 2039\n", - " 24253\n", - " 610545\n", - " 3257219.0\n", + " 23796\n", + " 598440\n", + " 3178339.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 375365.449796\n", - " 362433.347050\n", - " 371149.568476\n", - " 363933.535093\n", - " 360843.806040\n", - " 412578.359715\n", - " 415007.121480\n", - " -2428.761765\n", - " -0.005852\n", + " 439471.811655\n", + " 486171.696867\n", + " 502289.466180\n", + " 498044.017229\n", + " 485302.039523\n", + " 402985.471692\n", + " 406826.384026\n", + " -3840.912333\n", + " -0.009441\n", " \n", " \n", " 15\n", " 2040\n", - " 25057\n", - " 629920\n", - " 3355680.0\n", + " 24867\n", + " 625341\n", + " 3333272.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 410970.020588\n", - " 447884.643580\n", - " 447682.568270\n", - " 449803.904849\n", - " 448981.207566\n", - " 428390.924640\n", - " 428879.058208\n", - " -488.133568\n", - " -0.001138\n", + " 451058.889825\n", + " 431633.402209\n", + " 402153.409212\n", + " 398040.518931\n", + " 371349.124368\n", + " 425017.218302\n", + " 426405.341430\n", + " -1388.123129\n", + " -0.003255\n", " \n", " \n", " 16\n", " 2041\n", - " 23909\n", - " 603172\n", - " 3217069.0\n", + " 23418\n", + " 588798\n", + " 3126883.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 409283.988225\n", - " 389442.315269\n", - " 385668.859805\n", - " 378426.274901\n", - " 374044.680265\n", - " 407922.043693\n", - " 409972.692203\n", - " -2050.648510\n", - " -0.005002\n", + " 364816.739985\n", + " 335208.786306\n", + " 354775.001534\n", + " 338447.362232\n", + " 321940.022061\n", + " 397017.066601\n", + " 399458.496395\n", + " -2441.429794\n", + " -0.006112\n", " \n", " \n", " 17\n", " 2042\n", - " 24546\n", - " 614459\n", - " 3284010.0\n", + " 24483\n", + " 614818\n", + " 3264448.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 473493.289947\n", - " 451147.769581\n", - " 430615.696082\n", - " 425669.313089\n", - " 429496.615643\n", - " 412187.659372\n", - " 413257.478800\n", - " -1069.819428\n", - " -0.002589\n", + " 474909.052258\n", + " 506841.062275\n", + " 463684.071161\n", + " 461858.642099\n", + " 454618.554156\n", + " 416691.544445\n", + " 416997.757878\n", + " -306.213433\n", + " -0.000734\n", " \n", " \n", " 18\n", " 2043\n", - " 25169\n", - " 634991\n", - " 3380638.0\n", + " 22584\n", + " 568163\n", + " 3020289.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 469347.741866\n", - " 494545.073752\n", - " 499347.930783\n", - " 493783.833404\n", - " 488803.549502\n", - " 430347.112355\n", - " 430015.937504\n", - " 331.174851\n", - " 0.000770\n", + " 437730.151447\n", + " 415617.644419\n", + " 410420.270555\n", + " 407615.216190\n", + " 384771.629007\n", + " 383660.669690\n", + " 383755.734156\n", + " -95.064467\n", + " -0.000248\n", " \n", " \n", " 19\n", " 2044\n", - " 23565\n", - " 591583\n", - " 3151148.0\n", + " 23377\n", + " 588639\n", + " 3133986.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 367242.325518\n", - " 371711.781452\n", - " 374913.433345\n", - " 377110.720066\n", - " 377895.449896\n", - " 401348.874670\n", - " 401054.748615\n", - " 294.126054\n", - " 0.000733\n", + " 467117.570232\n", + " 486817.869497\n", + " 480637.195403\n", + " 474544.770943\n", + " 455304.239249\n", + " 394673.545565\n", + " 394754.939189\n", + " -81.393624\n", + " -0.000206\n", " \n", " \n", " 20\n", " 2045\n", - " 24921\n", - " 627096\n", - " 3335948.0\n", + " 23817\n", + " 599233\n", + " 3190091.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 315560.724644\n", - " 343353.455376\n", - " 345223.997177\n", - " 342021.238793\n", - " 334436.491016\n", - " 423672.932007\n", - " 425227.379946\n", - " -1554.447940\n", - " -0.003656\n", + " 398139.357152\n", + " 362850.193582\n", + " 402219.531548\n", + " 399839.624296\n", + " 377344.967272\n", + " 401135.309503\n", + " 402985.317847\n", + " -1850.008344\n", + " -0.004591\n", " \n", " \n", " 21\n", " 2046\n", - " 23776\n", - " 598458\n", - " 3181465.0\n", + " 24583\n", + " 616970\n", + " 3286711.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 371782.115694\n", - " 305812.333010\n", - " 294432.924965\n", - " 293503.944334\n", - " 296392.880809\n", - " 398552.821055\n", - " 401775.342808\n", - " -3222.521752\n", - " -0.008021\n", + " 443421.655978\n", + " 468076.690976\n", + " 465542.221447\n", + " 467423.630271\n", + " 464577.255028\n", + " 412242.557813\n", + " 413773.489936\n", + " -1530.932123\n", + " -0.003700\n", " \n", " \n", " 22\n", " 2047\n", - " 22152\n", - " 556685\n", - " 2957237.0\n", + " 22492\n", + " 563400\n", + " 2990632.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 434630.692016\n", - " 457467.620834\n", - " 474432.706520\n", - " 472613.554807\n", - " 440392.213570\n", - " 373087.409200\n", - " 374239.513003\n", - " -1152.103803\n", - " -0.003079\n", + " 494553.446600\n", + " 444767.223650\n", + " 409485.605985\n", + " 387260.946000\n", + " 360098.331291\n", + " 372146.903936\n", + " 375589.196357\n", + " -3442.292421\n", + " -0.009165\n", " \n", " \n", " 23\n", " 2048\n", - " 23385\n", - " 588872\n", - " 3114865.0\n", + " 23857\n", + " 599713\n", + " 3190814.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 341127.222055\n", - " 315111.678821\n", - " 294945.264077\n", - " 285233.426898\n", - " 253195.609983\n", - " 390315.605105\n", - " 391466.290883\n", - " -1150.685778\n", - " -0.002939\n", + " 472153.619753\n", + " 503414.718730\n", + " 491261.349692\n", + " 495127.838946\n", + " 485805.294721\n", + " 401945.091876\n", + " 402709.253238\n", + " -764.161361\n", + " -0.001898\n", " \n", " \n", " 24\n", " 2049\n", - " 25584\n", - " 643536\n", - " 3435564.0\n", + " 23922\n", + " 602508\n", + " 3200414.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 431988.493807\n", - " 443731.169805\n", - " 451146.067144\n", - " 447883.026972\n", - " 446049.207337\n", - " 430832.507546\n", - " 432053.418987\n", - " -1220.911442\n", - " -0.002826\n", + " 465094.209967\n", + " 455038.002255\n", + " 477898.743986\n", + " 469420.838584\n", + " 440243.139280\n", + " 398685.865173\n", + " 401567.430428\n", + " -2881.565255\n", + " -0.007176\n", " \n", " \n", " 25\n", " 2050\n", - " 23985\n", - " 603121\n", - " 3199136.0\n", + " 23672\n", + " 596141\n", + " 3153492.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 421327.798951\n", - " 396769.929491\n", - " 408562.425855\n", - " 418502.725903\n", - " 419774.688159\n", - " 402422.115951\n", - " 403916.440618\n", - " -1494.324667\n", - " -0.003700\n", + " 452834.779144\n", + " 465973.024854\n", + " 462746.331497\n", + " 425762.806114\n", + " 427139.769513\n", + " 399252.955628\n", + " 398635.670647\n", + " 617.284980\n", + " 0.001548\n", " \n", " \n", " 26\n", " 2051\n", - " 24460\n", - " 615031\n", - " 3269170.0\n", + " 23898\n", + " 601388\n", + " 3209981.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 321024.804561\n", - " 345132.495319\n", - " 329562.416251\n", - " 323549.743210\n", - " 317332.704749\n", - " 409463.606493\n", - " 410180.385199\n", - " -716.778707\n", - " -0.001747\n", + " 460721.942570\n", + " 407556.892301\n", + " 401004.293570\n", + " 421749.445065\n", + " 405452.318421\n", + " 400477.291574\n", + " 400608.907041\n", + " -131.615467\n", + " -0.000329\n", " \n", " \n", " 27\n", " 2052\n", - " 23610\n", - " 593948\n", - " 3148362.0\n", + " 23496\n", + " 591222\n", + " 3151911.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 469034.752168\n", - " 469662.194769\n", - " 448426.362540\n", - " 446609.577932\n", - " 435340.199013\n", - " 391160.953917\n", - " 393091.155764\n", - " -1930.201847\n", - " -0.004910\n", + " 309639.446977\n", + " 390992.045894\n", + " 420441.094988\n", + " 413192.196815\n", + " 409041.464387\n", + " 390999.580252\n", + " 392078.841473\n", + " -1079.261220\n", + " -0.002753\n", " \n", " \n", " 28\n", " 2053\n", - " 24612\n", - " 617265\n", - " 3291913.0\n", + " 24894\n", + " 627569\n", + " 3335143.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 479370.138921\n", - " 461118.374422\n", - " 452747.999276\n", - " 442215.228495\n", - " 400887.449181\n", - " 409930.626615\n", - " 412238.859114\n", - " -2308.232499\n", - " -0.005599\n", + " 332821.767357\n", + " 320904.427223\n", + " 316776.074425\n", + " 316292.885898\n", + " 306048.398243\n", + " 416471.045063\n", + " 418092.099246\n", + " -1621.054183\n", + " -0.003877\n", " \n", " \n", " 29\n", " 2054\n", - " 23846\n", - " 600531\n", - " 3190334.0\n", + " 21946\n", + " 552383\n", + " 2937089.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 378828.522395\n", - " 435684.567230\n", - " 434997.915598\n", - " 436064.621612\n", - " 432867.449960\n", - " 396400.887798\n", - " 396070.808867\n", - " 330.078931\n", - " 0.000833\n", + " 418144.175624\n", + " 404366.782226\n", + " 391164.519869\n", + " 373727.874006\n", + " 343975.955350\n", + " 360207.713252\n", + " 364273.522362\n", + " -4065.809111\n", + " -0.011161\n", " \n", " \n", " 30\n", " 2055\n", - " 24956\n", - " 628421\n", - " 3345467.0\n", + " 23076\n", + " 579568\n", + " 3072851.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 478046.700552\n", - " 428881.409055\n", - " 453508.028054\n", - " 449527.028001\n", - " 444985.809368\n", - " 416341.114108\n", - " 417028.311391\n", - " -687.197283\n", - " -0.001648\n", + " 300680.970171\n", + " 346289.174108\n", + " 340245.279011\n", + " 329299.172958\n", + " 309663.520488\n", + " 379799.778479\n", + " 382254.450494\n", + " -2454.672016\n", + " -0.006422\n", " \n", " \n", " 31\n", " 2056\n", - " 23703\n", - " 596560\n", - " 3172864.0\n", + " 23967\n", + " 601469\n", + " 3194980.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 370264.174609\n", - " 415190.572889\n", - " 426911.392935\n", - " 433321.292498\n", - " 423776.044021\n", - " 395081.647605\n", - " 391936.636790\n", - " 3145.010815\n", - " 0.008024\n", + " 461243.283456\n", + " 391853.983192\n", + " 387762.882037\n", + " 372651.645513\n", + " 355108.240357\n", + " 389694.500461\n", + " 393327.366843\n", + " -3632.866382\n", + " -0.009236\n", " \n", " \n", " 32\n", " 2057\n", - " 23884\n", - " 602103\n", - " 3215112.0\n", + " 23389\n", + " 588821\n", + " 3139033.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 378162.247570\n", - " 377205.366488\n", - " 342790.975990\n", - " 332326.448483\n", - " 330739.987217\n", - " 394811.555047\n", - " 396221.517042\n", - " -1409.961995\n", - " -0.003559\n", + " 379993.626328\n", + " 421170.962261\n", + " 417222.716525\n", + " 405927.199113\n", + " 379013.465979\n", + " 382707.973900\n", + " 382588.827454\n", + " 119.146445\n", + " 0.000311\n", " \n", " \n", " 33\n", " 2058\n", - " 24352\n", - " 611347\n", - " 3261366.0\n", + " 22093\n", + " 555609\n", + " 2950853.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 414908.289481\n", - " 333540.646309\n", - " 362992.743057\n", - " 366721.297324\n", - " 367575.167706\n", - " 401393.780962\n", - " 403754.537706\n", - " -2360.756744\n", - " -0.005847\n", + " 381230.056855\n", + " 354587.101006\n", + " 350957.265087\n", + " 326505.718272\n", + " 294446.256154\n", + " 361165.891802\n", + " 361939.932800\n", + " -774.040998\n", + " -0.002139\n", " \n", " \n", " 34\n", " 2059\n", - " 24055\n", - " 603579\n", - " 3200088.0\n", + " 23733\n", + " 596624\n", + " 3169901.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 455684.817802\n", - " 472393.409198\n", - " 478349.032980\n", - " 477401.048276\n", - " 438412.338758\n", - " 391860.264252\n", - " 393873.141006\n", - " -2012.876754\n", - " -0.005110\n", + " 501263.956015\n", + " 490253.713022\n", + " 477610.230551\n", + " 460159.597378\n", + " 444568.857000\n", + " 389684.514691\n", + " 391135.437740\n", + " -1450.923049\n", + " -0.003710\n", " \n", " \n", " 35\n", " 2060\n", - " 22401\n", - " 560380\n", - " 3000088.0\n", + " 23173\n", + " 582978\n", + " 3100047.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 359900.771691\n", - " 372597.770047\n", - " 360489.465892\n", - " 363261.114549\n", - " 359252.347918\n", - " 367209.410297\n", - " 366611.581462\n", - " 597.828835\n", - " 0.001631\n", + " 459757.304011\n", + " 436835.494548\n", + " 419958.086643\n", + " 435515.915955\n", + " 425013.325154\n", + " 383317.152377\n", + " 381266.519178\n", + " 2050.633200\n", + " 0.005378\n", " \n", " \n", " 36\n", " 2061\n", - " 25450\n", - " 639870\n", - " 3417374.0\n", + " 23689\n", + " 595156\n", + " 3162324.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 522352.080349\n", - " 579014.399822\n", - " 568925.720500\n", - " 565835.475117\n", - " 550598.603341\n", - " 417434.381690\n", - " 420020.233730\n", - " -2585.852040\n", - " -0.006156\n", + " 403898.123577\n", + " 446026.892969\n", + " 459573.706453\n", + " 436904.851847\n", + " 419966.747362\n", + " 390113.556785\n", + " 387064.014493\n", + " 3049.542292\n", + " 0.007879\n", " \n", " \n", " 37\n", " 2062\n", - " 23155\n", - " 582547\n", - " 3074410.0\n", + " 22794\n", + " 574103\n", + " 3036727.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 376936.757775\n", - " 379134.096954\n", - " 381629.099749\n", - " 364270.180436\n", - " 356574.164485\n", - " 377882.767541\n", - " 377365.440971\n", - " 517.326570\n", - " 0.001371\n", + " 468021.236699\n", + " 450100.730558\n", + " 416050.220079\n", + " 373748.278834\n", + " 351040.543393\n", + " 372856.397814\n", + " 373879.275648\n", + " -1022.877835\n", + " -0.002736\n", " \n", " \n", " 38\n", " 2063\n", - " 23057\n", - " 580043\n", - " 3084421.0\n", + " 22722\n", + " 573325\n", + " 3024141.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 467723.711737\n", - " 401612.564532\n", - " 392392.393319\n", - " 396304.528597\n", - " 394369.022680\n", - " 374082.177605\n", - " 374460.254161\n", - " -378.076555\n", - " -0.001010\n", + " 414958.264565\n", + " 415976.330050\n", + " 443797.927964\n", + " 453085.545667\n", + " 444035.139054\n", + " 367768.692199\n", + " 368187.001270\n", + " -418.309071\n", + " -0.001136\n", " \n", " \n", " 39\n", " 2064\n", - " 23503\n", - " 592241\n", - " 3138838.0\n", + " 23581\n", + " 590848\n", + " 3149704.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 323517.333199\n", - " 367831.340554\n", - " 346112.375544\n", - " 324946.993397\n", - " 312443.249634\n", - " 382423.385030\n", - " 382966.454764\n", - " -543.069734\n", - " -0.001418\n", + " 441414.054493\n", + " 435767.269524\n", + " 415051.021426\n", + " 406769.043607\n", + " 396642.228590\n", + " 378200.181200\n", + " 380644.486568\n", + " -2444.305368\n", + " -0.006421\n", " \n", " \n", " 40\n", " 2065\n", - " 23680\n", - " 594336\n", - " 3169648.0\n", + " 23523\n", + " 591233\n", + " 3157907.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 345713.935117\n", - " 293320.941908\n", - " 318220.999319\n", - " 326566.490286\n", - " 323628.322020\n", - " 384159.066998\n", - " 384056.354457\n", - " 102.712541\n", - " 0.000267\n", + " 433793.080907\n", + " 435494.327000\n", + " 421305.379992\n", + " 408124.267918\n", + " 399546.170001\n", + " 383210.897923\n", + " 380769.053462\n", + " 2441.844461\n", + " 0.006413\n", " \n", " \n", " 41\n", " 2066\n", - " 23743\n", - " 598339\n", - " 3198839.0\n", + " 22993\n", + " 578310\n", + " 3065123.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 395462.015387\n", - " 445201.806887\n", - " 440143.467266\n", - " 438945.020171\n", - " 435197.782687\n", - " 385665.968172\n", - " 385827.443170\n", - " -161.474998\n", - " -0.000419\n", + " 358327.837808\n", + " 382545.188235\n", + " 359818.742372\n", + " 354980.088513\n", + " 342669.140660\n", + " 373477.131153\n", + " 373664.729920\n", + " -187.598767\n", + " -0.000502\n", " \n", " \n", " 42\n", " 2067\n", - " 24569\n", - " 619436\n", - " 3283765.0\n", + " 23261\n", + " 583580\n", + " 3099017.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 406529.105098\n", - " 356852.651551\n", - " 349188.139601\n", - " 335367.151073\n", - " 336038.756644\n", - " 398291.557836\n", - " 400458.849287\n", - " -2167.291450\n", - " -0.005412\n", + " 385266.544939\n", + " 357229.405339\n", + " 389448.072900\n", + " 382553.140857\n", + " 367803.054399\n", + " 375480.781577\n", + " 376740.673312\n", + " -1259.891735\n", + " -0.003344\n", " \n", " \n", " 43\n", " 2068\n", - " 24122\n", - " 608216\n", - " 3240015.0\n", + " 23318\n", + " 586603\n", + " 3118001.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 574552.855124\n", - " 543870.172353\n", - " 546057.722361\n", - " 548303.362147\n", - " 547679.218868\n", - " 391932.655476\n", - " 393162.031631\n", - " -1229.376155\n", - " -0.003127\n", + " 444523.181015\n", + " 449728.133273\n", + " 439791.891824\n", + " 438856.705942\n", + " 426322.297655\n", + " 374245.788665\n", + " 375335.534050\n", + " -1089.745385\n", + " -0.002903\n", " \n", " \n", " 44\n", " 2069\n", - " 24546\n", - " 618608\n", - " 3287355.0\n", + " 23422\n", + " 588499\n", + " 3133720.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 446939.143675\n", - " 511156.014302\n", - " 533278.121296\n", - " 529131.538903\n", - " 529176.140345\n", - " 396645.182138\n", - " 399251.911588\n", - " -2606.729450\n", - " -0.006529\n", + " 445720.962431\n", + " 418703.399054\n", + " 431958.526817\n", + " 430211.684701\n", + " 419976.194936\n", + " 379224.450236\n", + " 378005.108376\n", + " 1219.341861\n", + " 0.003226\n", " \n", " \n", " 45\n", " 2070\n", - " 23805\n", - " 598800\n", - " 3180887.0\n", + " 23609\n", + " 593756\n", + " 3146747.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 478443.587177\n", - " 441135.161700\n", - " 433665.355653\n", - " 444075.669003\n", - " 439392.286115\n", - " 383002.326955\n", - " 384919.782302\n", - " -1917.455347\n", - " -0.004981\n", + " 400991.290205\n", + " 429393.430690\n", + " 411181.980311\n", + " 405133.787228\n", + " 386202.176410\n", + " 383743.213561\n", + " 381667.545696\n", + " 2075.667865\n", + " 0.005438\n", " \n", " \n", "\n", "
" ] }, - "execution_count": 24, + "execution_count": 52, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 24 + "execution_count": 52 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-03T10:30:42.894912Z", - "start_time": "2025-01-03T10:30:40.961325Z" + "end_time": "2025-01-03T11:37:16.139858Z", + "start_time": "2025-01-03T11:37:14.298561Z" } }, "cell_type": "code", @@ -3353,17 +3353,17 @@ "data": { "text/plain": [ " 0 1 2 3 4 5 6 7 8 9 \\\n", - "0 214.572104 67.082516 2025.0 1.0 1.0 1.0 0.0 0.0 0.0 1.0 \n", - "1 271.627509 91.681733 2025.0 2.0 1.0 0.0 0.0 1.0 0.0 1.0 \n", - "2 274.068079 81.536862 2025.0 3.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", - "3 282.787174 72.338774 2025.0 4.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", - "4 307.947498 93.346663 2025.0 5.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", + "0 318.723452 111.486502 2025.0 1.0 1.0 1.0 0.0 0.0 0.0 1.0 \n", + "1 367.076374 115.202853 2025.0 2.0 1.0 0.0 0.0 1.0 0.0 1.0 \n", + "2 302.196208 76.629523 2025.0 3.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", + "3 546.639789 153.713254 2025.0 4.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", + "4 297.013829 80.416504 2025.0 5.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", "... ... ... ... ... ... ... ... ... ... ... \n", - "170566 352.682126 110.401419 2070.0 8.0 0.0 0.0 1.0 0.0 0.0 1.0 \n", - "170567 278.709500 86.588583 2070.0 9.0 0.0 0.0 0.0 1.0 0.0 0.0 \n", - "170568 278.709500 86.588583 2070.0 10.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", - "170569 261.926852 80.761265 2070.0 11.0 0.0 0.0 1.0 0.0 0.0 1.0 \n", - "170570 253.265239 115.377080 2070.0 12.0 0.0 0.0 0.0 0.0 0.0 1.0 \n", + "166277 273.660745 102.473417 2070.0 8.0 0.0 0.0 1.0 0.0 0.0 1.0 \n", + "166278 147.334300 60.726971 2070.0 9.0 0.0 0.0 0.0 1.0 0.0 0.0 \n", + "166279 147.334300 60.726971 2070.0 10.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", + "166280 249.590817 83.738491 2070.0 11.0 0.0 0.0 1.0 0.0 0.0 1.0 \n", + "166281 163.427095 90.067341 2070.0 12.0 0.0 0.0 0.0 0.0 0.0 1.0 \n", "\n", " ... 344 345 346 347 348 349 350 351 352 353 \n", "0 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 1099.0 0.084097 \n", @@ -3372,13 +3372,13 @@ "3 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 873.0 NaN \n", "4 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 873.0 NaN \n", "... ... ... ... ... ... ... ... ... ... ... ... \n", - "170566 ... 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0 485.0 0.162431 \n", - "170567 ... 0.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 508.0 0.116303 \n", - "170568 ... 0.0 0.0 0.0 0.0 0.0 1.0 0.0 0.0 873.0 NaN \n", - "170569 ... 0.0 0.0 0.0 0.0 0.0 0.0 1.0 0.0 1149.0 0.233156 \n", - "170570 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 1.0 873.0 0.098121 \n", + "166277 ... 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0 485.0 0.162431 \n", + "166278 ... 0.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 508.0 0.116303 \n", + "166279 ... 0.0 0.0 0.0 0.0 0.0 1.0 0.0 0.0 873.0 NaN \n", + "166280 ... 0.0 0.0 0.0 0.0 0.0 0.0 1.0 0.0 1149.0 0.233156 \n", + "166281 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 1.0 873.0 0.098121 \n", "\n", - "[170571 rows x 354 columns]" + "[166282 rows x 354 columns]" ], "text/html": [ "
\n", @@ -3425,8 +3425,8 @@ " \n", " \n", " 0\n", - " 214.572104\n", - " 67.082516\n", + " 318.723452\n", + " 111.486502\n", " 2025.0\n", " 1.0\n", " 1.0\n", @@ -3449,8 +3449,8 @@ " \n", " \n", " 1\n", - " 271.627509\n", - " 91.681733\n", + " 367.076374\n", + " 115.202853\n", " 2025.0\n", " 2.0\n", " 1.0\n", @@ -3473,8 +3473,8 @@ " \n", " \n", " 2\n", - " 274.068079\n", - " 81.536862\n", + " 302.196208\n", + " 76.629523\n", " 2025.0\n", " 3.0\n", " 0.0\n", @@ -3497,8 +3497,8 @@ " \n", " \n", " 3\n", - " 282.787174\n", - " 72.338774\n", + " 546.639789\n", + " 153.713254\n", " 2025.0\n", " 4.0\n", " 0.0\n", @@ -3521,8 +3521,8 @@ " \n", " \n", " 4\n", - " 307.947498\n", - " 93.346663\n", + " 297.013829\n", + " 80.416504\n", " 2025.0\n", " 5.0\n", " 0.0\n", @@ -3568,9 +3568,9 @@ " ...\n", " \n", " \n", - " 170566\n", - " 352.682126\n", - " 110.401419\n", + " 166277\n", + " 273.660745\n", + " 102.473417\n", " 2070.0\n", " 8.0\n", " 0.0\n", @@ -3592,9 +3592,9 @@ " 0.162431\n", " \n", " \n", - " 170567\n", - " 278.709500\n", - " 86.588583\n", + " 166278\n", + " 147.334300\n", + " 60.726971\n", " 2070.0\n", " 9.0\n", " 0.0\n", @@ -3616,9 +3616,9 @@ " 0.116303\n", " \n", " \n", - " 170568\n", - " 278.709500\n", - " 86.588583\n", + " 166279\n", + " 147.334300\n", + " 60.726971\n", " 2070.0\n", " 10.0\n", " 0.0\n", @@ -3640,9 +3640,9 @@ " NaN\n", " \n", " \n", - " 170569\n", - " 261.926852\n", - " 80.761265\n", + " 166280\n", + " 249.590817\n", + " 83.738491\n", " 2070.0\n", " 11.0\n", " 0.0\n", @@ -3664,9 +3664,9 @@ " 0.233156\n", " \n", " \n", - " 170570\n", - " 253.265239\n", - " 115.377080\n", + " 166281\n", + " 163.427095\n", + " 90.067341\n", " 2070.0\n", " 12.0\n", " 0.0\n", @@ -3689,22 +3689,22 @@ " \n", " \n", "\n", - "

170571 rows × 354 columns

\n", + "

166282 rows × 354 columns

\n", "
" ] }, - "execution_count": 25, + "execution_count": 53, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 25 + "execution_count": 53 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-03T10:30:42.899853Z", - "start_time": "2025-01-03T10:30:42.896457Z" + "end_time": "2025-01-03T11:37:16.149964Z", + "start_time": "2025-01-03T11:37:16.144056Z" } }, "cell_type": "code", @@ -3719,13 +3719,13 @@ ], "id": "fd6b107fed0933cb", "outputs": [], - "execution_count": 26 + "execution_count": 54 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-03T10:30:45.693252Z", - "start_time": "2025-01-03T10:30:45.672287Z" + "end_time": "2025-01-03T11:37:16.175671Z", + "start_time": "2025-01-03T11:37:16.152005Z" } }, "cell_type": "code", @@ -3736,52 +3736,52 @@ "data": { "text/plain": [ " Year Month Facility_ID Altitude \\\n", - "0 2025 24642 620396 3302918.0 \n", - "1 2026 25447 640288 3423381.0 \n", - "2 2027 24346 613299 3249211.0 \n", - "3 2028 24165 609869 3233056.0 \n", - "4 2029 23856 600707 3182788.0 \n", - "5 2030 24743 621446 3305374.0 \n", - "6 2031 22311 564387 2993610.0 \n", - "7 2032 25011 629286 3346578.0 \n", - "8 2033 23162 584299 3096405.0 \n", - "9 2034 24560 617891 3283369.0 \n", - "10 2035 25040 629510 3351904.0 \n", - "11 2036 23845 597393 3180499.0 \n", - "12 2037 23332 586786 3128727.0 \n", - "13 2038 24976 626428 3359830.0 \n", - "14 2039 24253 610545 3257219.0 \n", - "15 2040 25057 629920 3355680.0 \n", - "16 2041 23909 603172 3217069.0 \n", - "17 2042 24546 614459 3284010.0 \n", - "18 2043 25169 634991 3380638.0 \n", - "19 2044 23565 591583 3151148.0 \n", - "20 2045 24921 627096 3335948.0 \n", - "21 2046 23776 598458 3181465.0 \n", - "22 2047 22152 556685 2957237.0 \n", - "23 2048 23385 588872 3114865.0 \n", - "24 2049 25584 643536 3435564.0 \n", - "25 2050 23985 603121 3199136.0 \n", - "26 2051 24460 615031 3269170.0 \n", - "27 2052 23610 593948 3148362.0 \n", - "28 2053 24612 617265 3291913.0 \n", - "29 2054 23846 600531 3190334.0 \n", - "30 2055 24956 628421 3345467.0 \n", - "31 2056 23703 596560 3172864.0 \n", - "32 2057 23884 602103 3215112.0 \n", - "33 2058 24352 611347 3261366.0 \n", - "34 2059 24055 603579 3200088.0 \n", - "35 2060 22401 560380 3000088.0 \n", - "36 2061 25450 639870 3417374.0 \n", - "37 2062 23155 582547 3074410.0 \n", - "38 2063 23057 580043 3084421.0 \n", - "39 2064 23503 592241 3138838.0 \n", - "40 2065 23680 594336 3169648.0 \n", - "41 2066 23743 598339 3198839.0 \n", - "42 2067 24569 619436 3283765.0 \n", - "43 2068 24122 608216 3240015.0 \n", - "44 2069 24546 618608 3287355.0 \n", - "45 2070 23805 598800 3180887.0 \n", + "0 2025 23814 599734 3182595.0 \n", + "1 2026 22590 566009 3008054.0 \n", + "2 2027 24474 614678 3269771.0 \n", + "3 2028 23968 600596 3207601.0 \n", + "4 2029 23330 583610 3116929.0 \n", + "5 2030 24073 605374 3226700.0 \n", + "6 2031 23580 593098 3161559.0 \n", + "7 2032 23000 576874 3067975.0 \n", + "8 2033 23581 593277 3157142.0 \n", + "9 2034 24459 614471 3272543.0 \n", + "10 2035 24070 601705 3227338.0 \n", + "11 2036 22412 563438 2989556.0 \n", + "12 2037 23224 583884 3111738.0 \n", + "13 2038 23088 581270 3091620.0 \n", + "14 2039 23796 598440 3178339.0 \n", + "15 2040 24867 625341 3333272.0 \n", + "16 2041 23418 588798 3126883.0 \n", + "17 2042 24483 614818 3264448.0 \n", + "18 2043 22584 568163 3020289.0 \n", + "19 2044 23377 588639 3133986.0 \n", + "20 2045 23817 599233 3190091.0 \n", + "21 2046 24583 616970 3286711.0 \n", + "22 2047 22492 563400 2990632.0 \n", + "23 2048 23857 599713 3190814.0 \n", + "24 2049 23922 602508 3200414.0 \n", + "25 2050 23672 596141 3153492.0 \n", + "26 2051 23898 601388 3209981.0 \n", + "27 2052 23496 591222 3151911.0 \n", + "28 2053 24894 627569 3335143.0 \n", + "29 2054 21946 552383 2937089.0 \n", + "30 2055 23076 579568 3072851.0 \n", + "31 2056 23967 601469 3194980.0 \n", + "32 2057 23389 588821 3139033.0 \n", + "33 2058 22093 555609 2950853.0 \n", + "34 2059 23733 596624 3169901.0 \n", + "35 2060 23173 582978 3100047.0 \n", + "36 2061 23689 595156 3162324.0 \n", + "37 2062 22794 574103 3036727.0 \n", + "38 2063 22722 573325 3024141.0 \n", + "39 2064 23581 590848 3149704.0 \n", + "40 2065 23523 591233 3157907.0 \n", + "41 2066 22993 578310 3065123.0 \n", + "42 2067 23261 583580 3099017.0 \n", + "43 2068 23318 586603 3118001.0 \n", + "44 2069 23422 588499 3133720.0 \n", + "45 2070 23609 593756 3146747.0 \n", "\n", " Zone \\\n", "0 Central WestSouth EastNorthernSouth EastNorthe... \n", @@ -3928,196 +3928,196 @@ "45 GovernmentGovernmentGovernmentGovernmentGovern... \n", "\n", " Facility_Type Precipitation \\\n", - "0 ClinicDistrict HospitalRural/Community Hospita... 440334.234308 \n", - "1 ClinicDistrict HospitalRural/Community Hospita... 368143.657611 \n", - "2 ClinicDistrict HospitalRural/Community Hospita... 389512.271746 \n", - "3 ClinicDistrict HospitalRural/Community Hospita... 467236.272652 \n", - "4 ClinicDistrict HospitalRural/Community Hospita... 510281.500940 \n", - "5 ClinicDistrict HospitalRural/Community Hospita... 415561.678186 \n", - "6 ClinicDistrict HospitalRural/Community Hospita... 306576.789734 \n", - "7 ClinicDistrict HospitalRural/Community Hospita... 322789.637078 \n", - "8 ClinicDistrict HospitalRural/Community Hospita... 417617.290163 \n", - "9 ClinicDistrict HospitalRural/Community Hospita... 397886.401018 \n", - "10 ClinicDistrict HospitalRural/Community Hospita... 459406.340711 \n", - "11 ClinicDistrict HospitalRural/Community Hospita... 397647.735041 \n", - "12 ClinicDistrict HospitalRural/Community Hospita... 391610.416555 \n", - "13 ClinicDistrict HospitalRural/Community Hospita... 441416.106096 \n", - "14 ClinicDistrict HospitalRural/Community Hospita... 375365.449796 \n", - "15 ClinicDistrict HospitalRural/Community Hospita... 410970.020588 \n", - "16 ClinicDistrict HospitalRural/Community Hospita... 409283.988225 \n", - "17 ClinicDistrict HospitalRural/Community Hospita... 473493.289947 \n", - "18 ClinicDistrict HospitalRural/Community Hospita... 469347.741866 \n", - "19 ClinicDistrict HospitalRural/Community Hospita... 367242.325518 \n", - "20 ClinicDistrict HospitalRural/Community Hospita... 315560.724644 \n", - "21 ClinicDistrict HospitalRural/Community Hospita... 371782.115694 \n", - "22 ClinicDistrict HospitalRural/Community Hospita... 434630.692016 \n", - "23 ClinicDistrict HospitalRural/Community Hospita... 341127.222055 \n", - "24 ClinicDistrict HospitalRural/Community Hospita... 431988.493807 \n", - "25 ClinicDistrict HospitalRural/Community Hospita... 421327.798951 \n", - "26 ClinicDistrict HospitalRural/Community Hospita... 321024.804561 \n", - "27 ClinicDistrict HospitalRural/Community Hospita... 469034.752168 \n", - "28 ClinicDistrict HospitalRural/Community Hospita... 479370.138921 \n", - "29 ClinicDistrict HospitalRural/Community Hospita... 378828.522395 \n", - "30 ClinicDistrict HospitalRural/Community Hospita... 478046.700552 \n", - "31 ClinicDistrict HospitalRural/Community Hospita... 370264.174609 \n", - "32 ClinicDistrict HospitalRural/Community Hospita... 378162.247570 \n", - "33 ClinicDistrict HospitalRural/Community Hospita... 414908.289481 \n", - "34 ClinicDistrict HospitalRural/Community Hospita... 455684.817802 \n", - "35 ClinicDistrict HospitalRural/Community Hospita... 359900.771691 \n", - "36 ClinicDistrict HospitalRural/Community Hospita... 522352.080349 \n", - "37 ClinicDistrict HospitalRural/Community Hospita... 376936.757775 \n", - "38 ClinicDistrict HospitalRural/Community Hospita... 467723.711737 \n", - "39 ClinicDistrict HospitalRural/Community Hospita... 323517.333199 \n", - "40 ClinicDistrict HospitalRural/Community Hospita... 345713.935117 \n", - "41 ClinicDistrict HospitalRural/Community Hospita... 395462.015387 \n", - "42 ClinicDistrict HospitalRural/Community Hospita... 406529.105098 \n", - "43 ClinicDistrict HospitalRural/Community Hospita... 574552.855124 \n", - "44 ClinicDistrict HospitalRural/Community Hospita... 446939.143675 \n", - "45 ClinicDistrict HospitalRural/Community Hospita... 478443.587177 \n", + "0 ClinicDistrict HospitalRural/Community Hospita... 356930.256793 \n", + "1 ClinicDistrict HospitalRural/Community Hospita... 442012.194055 \n", + "2 ClinicDistrict HospitalRural/Community Hospita... 401910.341187 \n", + "3 ClinicDistrict HospitalRural/Community Hospita... 458028.122792 \n", + "4 ClinicDistrict HospitalRural/Community Hospita... 406191.851826 \n", + "5 ClinicDistrict HospitalRural/Community Hospita... 409387.038984 \n", + "6 ClinicDistrict HospitalRural/Community Hospita... 400600.129109 \n", + "7 ClinicDistrict HospitalRural/Community Hospita... 447521.070185 \n", + "8 ClinicDistrict HospitalRural/Community Hospita... 456815.880827 \n", + "9 ClinicDistrict HospitalRural/Community Hospita... 443520.485079 \n", + "10 ClinicDistrict HospitalRural/Community Hospita... 411313.075371 \n", + "11 ClinicDistrict HospitalRural/Community Hospita... 401467.863756 \n", + "12 ClinicDistrict HospitalRural/Community Hospita... 419545.873961 \n", + "13 ClinicDistrict HospitalRural/Community Hospita... 463682.059169 \n", + "14 ClinicDistrict HospitalRural/Community Hospita... 439471.811655 \n", + "15 ClinicDistrict HospitalRural/Community Hospita... 451058.889825 \n", + "16 ClinicDistrict HospitalRural/Community Hospita... 364816.739985 \n", + "17 ClinicDistrict HospitalRural/Community Hospita... 474909.052258 \n", + "18 ClinicDistrict HospitalRural/Community Hospita... 437730.151447 \n", + "19 ClinicDistrict HospitalRural/Community Hospita... 467117.570232 \n", + "20 ClinicDistrict HospitalRural/Community Hospita... 398139.357152 \n", + "21 ClinicDistrict HospitalRural/Community Hospita... 443421.655978 \n", + "22 ClinicDistrict HospitalRural/Community Hospita... 494553.446600 \n", + "23 ClinicDistrict HospitalRural/Community Hospita... 472153.619753 \n", + "24 ClinicDistrict HospitalRural/Community Hospita... 465094.209967 \n", + "25 ClinicDistrict HospitalRural/Community Hospita... 452834.779144 \n", + "26 ClinicDistrict HospitalRural/Community Hospita... 460721.942570 \n", + "27 ClinicDistrict HospitalRural/Community Hospita... 309639.446977 \n", + "28 ClinicDistrict HospitalRural/Community Hospita... 332821.767357 \n", + "29 ClinicDistrict HospitalRural/Community Hospita... 418144.175624 \n", + "30 ClinicDistrict HospitalRural/Community Hospita... 300680.970171 \n", + "31 ClinicDistrict HospitalRural/Community Hospita... 461243.283456 \n", + "32 ClinicDistrict HospitalRural/Community Hospita... 379993.626328 \n", + "33 ClinicDistrict HospitalRural/Community Hospita... 381230.056855 \n", + "34 ClinicDistrict HospitalRural/Community Hospita... 501263.956015 \n", + "35 ClinicDistrict HospitalRural/Community Hospita... 459757.304011 \n", + "36 ClinicDistrict HospitalRural/Community Hospita... 403898.123577 \n", + "37 ClinicDistrict HospitalRural/Community Hospita... 468021.236699 \n", + "38 ClinicDistrict HospitalRural/Community Hospita... 414958.264565 \n", + "39 ClinicDistrict HospitalRural/Community Hospita... 441414.054493 \n", + "40 ClinicDistrict HospitalRural/Community Hospita... 433793.080907 \n", + "41 ClinicDistrict HospitalRural/Community Hospita... 358327.837808 \n", + "42 ClinicDistrict HospitalRural/Community Hospita... 385266.544939 \n", + "43 ClinicDistrict HospitalRural/Community Hospita... 444523.181015 \n", + "44 ClinicDistrict HospitalRural/Community Hospita... 445720.962431 \n", + "45 ClinicDistrict HospitalRural/Community Hospita... 400991.290205 \n", "\n", " Lag_1_Precipitation Lag_2_Precipitation Lag_3_Precipitation \\\n", - "0 353904.731005 325681.489860 297561.640581 \n", - "1 401420.433758 403405.854504 402539.554951 \n", - "2 371731.795831 352017.560308 341274.411245 \n", - "3 463195.874132 489324.647136 467717.368493 \n", - "4 502657.340862 482774.102033 508613.994882 \n", - "5 430082.709305 433194.385110 426679.595380 \n", - "6 309978.599600 325681.193935 315680.278887 \n", - "7 346456.981332 346504.507849 343190.362299 \n", - "8 357429.121158 338700.251142 340245.308388 \n", - "9 399155.990738 376194.009554 375103.117941 \n", - "10 495631.995766 495403.900197 486208.445508 \n", - "11 394956.683884 407506.319795 414531.165308 \n", - "12 343980.571323 350808.137426 347057.035888 \n", - "13 452575.562133 454464.217285 452146.877154 \n", - "14 362433.347050 371149.568476 363933.535093 \n", - "15 447884.643580 447682.568270 449803.904849 \n", - "16 389442.315269 385668.859805 378426.274901 \n", - "17 451147.769581 430615.696082 425669.313089 \n", - "18 494545.073752 499347.930783 493783.833404 \n", - "19 371711.781452 374913.433345 377110.720066 \n", - "20 343353.455376 345223.997177 342021.238793 \n", - "21 305812.333010 294432.924965 293503.944334 \n", - "22 457467.620834 474432.706520 472613.554807 \n", - "23 315111.678821 294945.264077 285233.426898 \n", - "24 443731.169805 451146.067144 447883.026972 \n", - "25 396769.929491 408562.425855 418502.725903 \n", - "26 345132.495319 329562.416251 323549.743210 \n", - "27 469662.194769 448426.362540 446609.577932 \n", - "28 461118.374422 452747.999276 442215.228495 \n", - "29 435684.567230 434997.915598 436064.621612 \n", - "30 428881.409055 453508.028054 449527.028001 \n", - "31 415190.572889 426911.392935 433321.292498 \n", - "32 377205.366488 342790.975990 332326.448483 \n", - "33 333540.646309 362992.743057 366721.297324 \n", - "34 472393.409198 478349.032980 477401.048276 \n", - "35 372597.770047 360489.465892 363261.114549 \n", - "36 579014.399822 568925.720500 565835.475117 \n", - "37 379134.096954 381629.099749 364270.180436 \n", - "38 401612.564532 392392.393319 396304.528597 \n", - "39 367831.340554 346112.375544 324946.993397 \n", - "40 293320.941908 318220.999319 326566.490286 \n", - "41 445201.806887 440143.467266 438945.020171 \n", - "42 356852.651551 349188.139601 335367.151073 \n", - "43 543870.172353 546057.722361 548303.362147 \n", - "44 511156.014302 533278.121296 529131.538903 \n", - "45 441135.161700 433665.355653 444075.669003 \n", + "0 294609.145696 251778.819911 240074.691709 \n", + "1 397157.668329 397273.347895 348266.651361 \n", + "2 414186.725872 420900.694753 423488.413324 \n", + "3 454173.805476 433342.964932 425159.752149 \n", + "4 439691.054081 445950.755762 418870.421666 \n", + "5 389364.247808 392455.710835 397461.356243 \n", + "6 392631.249314 374449.656015 373894.307761 \n", + "7 402914.631768 394545.775941 380305.249049 \n", + "8 498011.574391 475942.063738 466685.963435 \n", + "9 441306.486897 449381.026641 430634.351876 \n", + "10 461142.612330 444654.932360 434587.827755 \n", + "11 357763.087422 364775.944769 347716.667867 \n", + "12 416541.339977 409043.550166 391920.926233 \n", + "13 442526.600924 451303.450407 456286.448435 \n", + "14 486171.696867 502289.466180 498044.017229 \n", + "15 431633.402209 402153.409212 398040.518931 \n", + "16 335208.786306 354775.001534 338447.362232 \n", + "17 506841.062275 463684.071161 461858.642099 \n", + "18 415617.644419 410420.270555 407615.216190 \n", + "19 486817.869497 480637.195403 474544.770943 \n", + "20 362850.193582 402219.531548 399839.624296 \n", + "21 468076.690976 465542.221447 467423.630271 \n", + "22 444767.223650 409485.605985 387260.946000 \n", + "23 503414.718730 491261.349692 495127.838946 \n", + "24 455038.002255 477898.743986 469420.838584 \n", + "25 465973.024854 462746.331497 425762.806114 \n", + "26 407556.892301 401004.293570 421749.445065 \n", + "27 390992.045894 420441.094988 413192.196815 \n", + "28 320904.427223 316776.074425 316292.885898 \n", + "29 404366.782226 391164.519869 373727.874006 \n", + "30 346289.174108 340245.279011 329299.172958 \n", + "31 391853.983192 387762.882037 372651.645513 \n", + "32 421170.962261 417222.716525 405927.199113 \n", + "33 354587.101006 350957.265087 326505.718272 \n", + "34 490253.713022 477610.230551 460159.597378 \n", + "35 436835.494548 419958.086643 435515.915955 \n", + "36 446026.892969 459573.706453 436904.851847 \n", + "37 450100.730558 416050.220079 373748.278834 \n", + "38 415976.330050 443797.927964 453085.545667 \n", + "39 435767.269524 415051.021426 406769.043607 \n", + "40 435494.327000 421305.379992 408124.267918 \n", + "41 382545.188235 359818.742372 354980.088513 \n", + "42 357229.405339 389448.072900 382553.140857 \n", + "43 449728.133273 439791.891824 438856.705942 \n", + "44 418703.399054 431958.526817 430211.684701 \n", + "45 429393.430690 411181.980311 405133.787228 \n", "\n", " Lag_4_Precipitation Predicted_Weather_Model Predicted_No_Weather_Model \\\n", - "0 282054.887587 282875.789559 435056.523872 \n", - "1 403356.754888 446973.452602 448297.963620 \n", - "2 330719.679227 429699.165446 428855.082772 \n", - "3 464588.245545 426390.662966 425105.144739 \n", - "4 503630.296180 419862.210285 417366.002941 \n", - "5 423888.501330 429293.165886 430209.704481 \n", - "6 290028.482608 388423.461274 388929.485473 \n", - "7 342685.296868 434991.492594 436710.225310 \n", - "8 340546.248413 400294.397759 402492.398969 \n", - "9 373789.068455 425657.584762 427231.110037 \n", - "10 482900.825373 433154.044585 434659.478247 \n", - "11 393286.530926 409005.784582 408150.336768 \n", - "12 341463.248905 399090.628516 401572.454562 \n", - "13 450786.011451 431402.659483 429626.731487 \n", - "14 360843.806040 412578.359715 415007.121480 \n", - "15 448981.207566 428390.924640 428879.058208 \n", - "16 374044.680265 407922.043693 409972.692203 \n", - "17 429496.615643 412187.659372 413257.478800 \n", - "18 488803.549502 430347.112355 430015.937504 \n", - "19 377895.449896 401348.874670 401054.748615 \n", - "20 334436.491016 423672.932007 425227.379946 \n", - "21 296392.880809 398552.821055 401775.342808 \n", - "22 440392.213570 373087.409200 374239.513003 \n", - "23 253195.609983 390315.605105 391466.290883 \n", - "24 446049.207337 430832.507546 432053.418987 \n", - "25 419774.688159 402422.115951 403916.440618 \n", - "26 317332.704749 409463.606493 410180.385199 \n", - "27 435340.199013 391160.953917 393091.155764 \n", - "28 400887.449181 409930.626615 412238.859114 \n", - "29 432867.449960 396400.887798 396070.808867 \n", - "30 444985.809368 416341.114108 417028.311391 \n", - "31 423776.044021 395081.647605 391936.636790 \n", - "32 330739.987217 394811.555047 396221.517042 \n", - "33 367575.167706 401393.780962 403754.537706 \n", - "34 438412.338758 391860.264252 393873.141006 \n", - "35 359252.347918 367209.410297 366611.581462 \n", - "36 550598.603341 417434.381690 420020.233730 \n", - "37 356574.164485 377882.767541 377365.440971 \n", - "38 394369.022680 374082.177605 374460.254161 \n", - "39 312443.249634 382423.385030 382966.454764 \n", - "40 323628.322020 384159.066998 384056.354457 \n", - "41 435197.782687 385665.968172 385827.443170 \n", - "42 336038.756644 398291.557836 400458.849287 \n", - "43 547679.218868 391932.655476 393162.031631 \n", - "44 529176.140345 396645.182138 399251.911588 \n", - "45 439392.286115 383002.326955 384919.782302 \n", + "0 212611.355306 262073.177045 414580.859514 \n", + "1 329607.014297 391897.166673 394712.494598 \n", + "2 427242.313426 424216.303078 426507.644233 \n", + "3 409583.757336 418663.778757 419005.094793 \n", + "4 404708.312917 405721.982368 407774.686109 \n", + "5 389452.051202 422077.382352 421235.583604 \n", + "6 361847.942122 406625.933041 406869.091856 \n", + "7 367935.056473 390456.768764 393982.523859 \n", + "8 443793.819493 404036.109552 407105.988595 \n", + "9 428705.248932 419086.106241 421792.859293 \n", + "10 424916.410268 414353.849683 416718.943844 \n", + "11 321868.628640 379822.724678 383326.342849 \n", + "12 378814.601365 396472.620305 397095.249567 \n", + "13 441830.397786 392687.251512 394380.103735 \n", + "14 485302.039523 402985.471692 406826.384026 \n", + "15 371349.124368 425017.218302 426405.341430 \n", + "16 321940.022061 397017.066601 399458.496395 \n", + "17 454618.554156 416691.544445 416997.757878 \n", + "18 384771.629007 383660.669690 383755.734156 \n", + "19 455304.239249 394673.545565 394754.939189 \n", + "20 377344.967272 401135.309503 402985.317847 \n", + "21 464577.255028 412242.557813 413773.489936 \n", + "22 360098.331291 372146.903936 375589.196357 \n", + "23 485805.294721 401945.091876 402709.253238 \n", + "24 440243.139280 398685.865173 401567.430428 \n", + "25 427139.769513 399252.955628 398635.670647 \n", + "26 405452.318421 400477.291574 400608.907041 \n", + "27 409041.464387 390999.580252 392078.841473 \n", + "28 306048.398243 416471.045063 418092.099246 \n", + "29 343975.955350 360207.713252 364273.522362 \n", + "30 309663.520488 379799.778479 382254.450494 \n", + "31 355108.240357 389694.500461 393327.366843 \n", + "32 379013.465979 382707.973900 382588.827454 \n", + "33 294446.256154 361165.891802 361939.932800 \n", + "34 444568.857000 389684.514691 391135.437740 \n", + "35 425013.325154 383317.152377 381266.519178 \n", + "36 419966.747362 390113.556785 387064.014493 \n", + "37 351040.543393 372856.397814 373879.275648 \n", + "38 444035.139054 367768.692199 368187.001270 \n", + "39 396642.228590 378200.181200 380644.486568 \n", + "40 399546.170001 383210.897923 380769.053462 \n", + "41 342669.140660 373477.131153 373664.729920 \n", + "42 367803.054399 375480.781577 376740.673312 \n", + "43 426322.297655 374245.788665 375335.534050 \n", + "44 419976.194936 379224.450236 378005.108376 \n", + "45 386202.176410 383743.213561 381667.545696 \n", "\n", " Difference_in_Expectation Percentage_Difference \n", - "0 -1479.431742 -0.003401 \n", - "1 -1324.511018 -0.002955 \n", - "2 844.082675 0.001968 \n", - "3 1285.518227 0.003024 \n", - "4 2496.207344 0.005981 \n", - "5 -916.538595 -0.002130 \n", - "6 -506.024199 -0.001301 \n", - "7 -1718.732715 -0.003936 \n", - "8 -2198.001210 -0.005461 \n", - "9 -1573.525275 -0.003683 \n", - "10 -1505.433662 -0.003463 \n", - "11 855.447814 0.002096 \n", - "12 -2481.826046 -0.006180 \n", - "13 1775.927996 0.004134 \n", - "14 -2428.761765 -0.005852 \n", - "15 -488.133568 -0.001138 \n", - "16 -2050.648510 -0.005002 \n", - "17 -1069.819428 -0.002589 \n", - "18 331.174851 0.000770 \n", - "19 294.126054 0.000733 \n", - "20 -1554.447940 -0.003656 \n", - "21 -3222.521752 -0.008021 \n", - "22 -1152.103803 -0.003079 \n", - "23 -1150.685778 -0.002939 \n", - "24 -1220.911442 -0.002826 \n", - "25 -1494.324667 -0.003700 \n", - "26 -716.778707 -0.001747 \n", - "27 -1930.201847 -0.004910 \n", - "28 -2308.232499 -0.005599 \n", - "29 330.078931 0.000833 \n", - "30 -687.197283 -0.001648 \n", - "31 3145.010815 0.008024 \n", - "32 -1409.961995 -0.003559 \n", - "33 -2360.756744 -0.005847 \n", - "34 -2012.876754 -0.005110 \n", - "35 597.828835 0.001631 \n", - "36 -2585.852040 -0.006156 \n", - "37 517.326570 0.001371 \n", - "38 -378.076555 -0.001010 \n", - "39 -543.069734 -0.001418 \n", - "40 102.712541 0.000267 \n", - "41 -161.474998 -0.000419 \n", - "42 -2167.291450 -0.005412 \n", - "43 -1229.376155 -0.003127 \n", - "44 -2606.729450 -0.006529 \n", - "45 -1917.455347 -0.004981 " + "0 -1806.379897 -0.004357 \n", + "1 -2815.327925 -0.007133 \n", + "2 -2291.341155 -0.005372 \n", + "3 -341.316036 -0.000815 \n", + "4 -2052.703741 -0.005034 \n", + "5 841.798749 0.001998 \n", + "6 -243.158815 -0.000598 \n", + "7 -3525.755094 -0.008949 \n", + "8 -3069.879043 -0.007541 \n", + "9 -2706.753053 -0.006417 \n", + "10 -2365.094162 -0.005676 \n", + "11 -3503.618171 -0.009140 \n", + "12 -622.629263 -0.001568 \n", + "13 -1692.852223 -0.004292 \n", + "14 -3840.912333 -0.009441 \n", + "15 -1388.123129 -0.003255 \n", + "16 -2441.429794 -0.006112 \n", + "17 -306.213433 -0.000734 \n", + "18 -95.064467 -0.000248 \n", + "19 -81.393624 -0.000206 \n", + "20 -1850.008344 -0.004591 \n", + "21 -1530.932123 -0.003700 \n", + "22 -3442.292421 -0.009165 \n", + "23 -764.161361 -0.001898 \n", + "24 -2881.565255 -0.007176 \n", + "25 617.284980 0.001548 \n", + "26 -131.615467 -0.000329 \n", + "27 -1079.261220 -0.002753 \n", + "28 -1621.054183 -0.003877 \n", + "29 -4065.809111 -0.011161 \n", + "30 -2454.672016 -0.006422 \n", + "31 -3632.866382 -0.009236 \n", + "32 119.146445 0.000311 \n", + "33 -774.040998 -0.002139 \n", + "34 -1450.923049 -0.003710 \n", + "35 2050.633200 0.005378 \n", + "36 3049.542292 0.007879 \n", + "37 -1022.877835 -0.002736 \n", + "38 -418.309071 -0.001136 \n", + "39 -2444.305368 -0.006421 \n", + "40 2441.844461 0.006413 \n", + "41 -187.598767 -0.000502 \n", + "42 -1259.891735 -0.003344 \n", + "43 -1089.745385 -0.002903 \n", + "44 1219.341861 0.003226 \n", + "45 2075.667865 0.005438 " ], "text/html": [ "
\n", @@ -4161,940 +4161,940 @@ " \n", " 0\n", " 2025\n", - " 24642\n", - " 620396\n", - " 3302918.0\n", + " 23814\n", + " 599734\n", + " 3182595.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 440334.234308\n", - " 353904.731005\n", - " 325681.489860\n", - " 297561.640581\n", - " 282054.887587\n", - " 282875.789559\n", - " 435056.523872\n", - " -1479.431742\n", - " -0.003401\n", + " 356930.256793\n", + " 294609.145696\n", + " 251778.819911\n", + " 240074.691709\n", + " 212611.355306\n", + " 262073.177045\n", + " 414580.859514\n", + " -1806.379897\n", + " -0.004357\n", " \n", " \n", " 1\n", " 2026\n", - " 25447\n", - " 640288\n", - " 3423381.0\n", + " 22590\n", + " 566009\n", + " 3008054.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 368143.657611\n", - " 401420.433758\n", - " 403405.854504\n", - " 402539.554951\n", - " 403356.754888\n", - " 446973.452602\n", - " 448297.963620\n", - " -1324.511018\n", - " -0.002955\n", + " 442012.194055\n", + " 397157.668329\n", + " 397273.347895\n", + " 348266.651361\n", + " 329607.014297\n", + " 391897.166673\n", + " 394712.494598\n", + " -2815.327925\n", + " -0.007133\n", " \n", " \n", " 2\n", " 2027\n", - " 24346\n", - " 613299\n", - " 3249211.0\n", + " 24474\n", + " 614678\n", + " 3269771.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 389512.271746\n", - " 371731.795831\n", - " 352017.560308\n", - " 341274.411245\n", - " 330719.679227\n", - " 429699.165446\n", - " 428855.082772\n", - " 844.082675\n", - " 0.001968\n", + " 401910.341187\n", + " 414186.725872\n", + " 420900.694753\n", + " 423488.413324\n", + " 427242.313426\n", + " 424216.303078\n", + " 426507.644233\n", + " -2291.341155\n", + " -0.005372\n", " \n", " \n", " 3\n", " 2028\n", - " 24165\n", - " 609869\n", - " 3233056.0\n", + " 23968\n", + " 600596\n", + " 3207601.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 467236.272652\n", - " 463195.874132\n", - " 489324.647136\n", - " 467717.368493\n", - " 464588.245545\n", - " 426390.662966\n", - " 425105.144739\n", - " 1285.518227\n", - " 0.003024\n", + " 458028.122792\n", + " 454173.805476\n", + " 433342.964932\n", + " 425159.752149\n", + " 409583.757336\n", + " 418663.778757\n", + " 419005.094793\n", + " -341.316036\n", + " -0.000815\n", " \n", " \n", " 4\n", " 2029\n", - " 23856\n", - " 600707\n", - " 3182788.0\n", + " 23330\n", + " 583610\n", + " 3116929.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 510281.500940\n", - " 502657.340862\n", - " 482774.102033\n", - " 508613.994882\n", - " 503630.296180\n", - " 419862.210285\n", - " 417366.002941\n", - " 2496.207344\n", - " 0.005981\n", + " 406191.851826\n", + " 439691.054081\n", + " 445950.755762\n", + " 418870.421666\n", + " 404708.312917\n", + " 405721.982368\n", + " 407774.686109\n", + " -2052.703741\n", + " -0.005034\n", " \n", " \n", " 5\n", " 2030\n", - " 24743\n", - " 621446\n", - " 3305374.0\n", + " 24073\n", + " 605374\n", + " 3226700.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 415561.678186\n", - " 430082.709305\n", - " 433194.385110\n", - " 426679.595380\n", - " 423888.501330\n", - " 429293.165886\n", - " 430209.704481\n", - " -916.538595\n", - " -0.002130\n", + " 409387.038984\n", + " 389364.247808\n", + " 392455.710835\n", + " 397461.356243\n", + " 389452.051202\n", + " 422077.382352\n", + " 421235.583604\n", + " 841.798749\n", + " 0.001998\n", " \n", " \n", " 6\n", " 2031\n", - " 22311\n", - " 564387\n", - " 2993610.0\n", + " 23580\n", + " 593098\n", + " 3161559.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 306576.789734\n", - " 309978.599600\n", - " 325681.193935\n", - " 315680.278887\n", - " 290028.482608\n", - " 388423.461274\n", - " 388929.485473\n", - " -506.024199\n", - " -0.001301\n", + " 400600.129109\n", + " 392631.249314\n", + " 374449.656015\n", + " 373894.307761\n", + " 361847.942122\n", + " 406625.933041\n", + " 406869.091856\n", + " -243.158815\n", + " -0.000598\n", " \n", " \n", " 7\n", " 2032\n", - " 25011\n", - " 629286\n", - " 3346578.0\n", + " 23000\n", + " 576874\n", + " 3067975.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 322789.637078\n", - " 346456.981332\n", - " 346504.507849\n", - " 343190.362299\n", - " 342685.296868\n", - " 434991.492594\n", - " 436710.225310\n", - " -1718.732715\n", - " -0.003936\n", + " 447521.070185\n", + " 402914.631768\n", + " 394545.775941\n", + " 380305.249049\n", + " 367935.056473\n", + " 390456.768764\n", + " 393982.523859\n", + " -3525.755094\n", + " -0.008949\n", " \n", " \n", " 8\n", " 2033\n", - " 23162\n", - " 584299\n", - " 3096405.0\n", + " 23581\n", + " 593277\n", + " 3157142.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 417617.290163\n", - " 357429.121158\n", - " 338700.251142\n", - " 340245.308388\n", - " 340546.248413\n", - " 400294.397759\n", - " 402492.398969\n", - " -2198.001210\n", - " -0.005461\n", + " 456815.880827\n", + " 498011.574391\n", + " 475942.063738\n", + " 466685.963435\n", + " 443793.819493\n", + " 404036.109552\n", + " 407105.988595\n", + " -3069.879043\n", + " -0.007541\n", " \n", " \n", " 9\n", " 2034\n", - " 24560\n", - " 617891\n", - " 3283369.0\n", + " 24459\n", + " 614471\n", + " 3272543.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 397886.401018\n", - " 399155.990738\n", - " 376194.009554\n", - " 375103.117941\n", - " 373789.068455\n", - " 425657.584762\n", - " 427231.110037\n", - " -1573.525275\n", - " -0.003683\n", + " 443520.485079\n", + " 441306.486897\n", + " 449381.026641\n", + " 430634.351876\n", + " 428705.248932\n", + " 419086.106241\n", + " 421792.859293\n", + " -2706.753053\n", + " -0.006417\n", " \n", " \n", " 10\n", " 2035\n", - " 25040\n", - " 629510\n", - " 3351904.0\n", + " 24070\n", + " 601705\n", + " 3227338.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 459406.340711\n", - " 495631.995766\n", - " 495403.900197\n", - " 486208.445508\n", - " 482900.825373\n", - " 433154.044585\n", - " 434659.478247\n", - " -1505.433662\n", - " -0.003463\n", + " 411313.075371\n", + " 461142.612330\n", + " 444654.932360\n", + " 434587.827755\n", + " 424916.410268\n", + " 414353.849683\n", + " 416718.943844\n", + " -2365.094162\n", + " -0.005676\n", " \n", " \n", " 11\n", " 2036\n", - " 23845\n", - " 597393\n", - " 3180499.0\n", + " 22412\n", + " 563438\n", + " 2989556.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 397647.735041\n", - " 394956.683884\n", - " 407506.319795\n", - " 414531.165308\n", - " 393286.530926\n", - " 409005.784582\n", - " 408150.336768\n", - " 855.447814\n", - " 0.002096\n", + " 401467.863756\n", + " 357763.087422\n", + " 364775.944769\n", + " 347716.667867\n", + " 321868.628640\n", + " 379822.724678\n", + " 383326.342849\n", + " -3503.618171\n", + " -0.009140\n", " \n", " \n", " 12\n", " 2037\n", - " 23332\n", - " 586786\n", - " 3128727.0\n", + " 23224\n", + " 583884\n", + " 3111738.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 391610.416555\n", - " 343980.571323\n", - " 350808.137426\n", - " 347057.035888\n", - " 341463.248905\n", - " 399090.628516\n", - " 401572.454562\n", - " -2481.826046\n", - " -0.006180\n", + " 419545.873961\n", + " 416541.339977\n", + " 409043.550166\n", + " 391920.926233\n", + " 378814.601365\n", + " 396472.620305\n", + " 397095.249567\n", + " -622.629263\n", + " -0.001568\n", " \n", " \n", " 13\n", " 2038\n", - " 24976\n", - " 626428\n", - " 3359830.0\n", + " 23088\n", + " 581270\n", + " 3091620.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 441416.106096\n", - " 452575.562133\n", - " 454464.217285\n", - " 452146.877154\n", - " 450786.011451\n", - " 431402.659483\n", - " 429626.731487\n", - " 1775.927996\n", - " 0.004134\n", + " 463682.059169\n", + " 442526.600924\n", + " 451303.450407\n", + " 456286.448435\n", + " 441830.397786\n", + " 392687.251512\n", + " 394380.103735\n", + " -1692.852223\n", + " -0.004292\n", " \n", " \n", " 14\n", " 2039\n", - " 24253\n", - " 610545\n", - " 3257219.0\n", + " 23796\n", + " 598440\n", + " 3178339.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 375365.449796\n", - " 362433.347050\n", - " 371149.568476\n", - " 363933.535093\n", - " 360843.806040\n", - " 412578.359715\n", - " 415007.121480\n", - " -2428.761765\n", - " -0.005852\n", + " 439471.811655\n", + " 486171.696867\n", + " 502289.466180\n", + " 498044.017229\n", + " 485302.039523\n", + " 402985.471692\n", + " 406826.384026\n", + " -3840.912333\n", + " -0.009441\n", " \n", " \n", " 15\n", " 2040\n", - " 25057\n", - " 629920\n", - " 3355680.0\n", + " 24867\n", + " 625341\n", + " 3333272.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 410970.020588\n", - " 447884.643580\n", - " 447682.568270\n", - " 449803.904849\n", - " 448981.207566\n", - " 428390.924640\n", - " 428879.058208\n", - " -488.133568\n", - " -0.001138\n", + " 451058.889825\n", + " 431633.402209\n", + " 402153.409212\n", + " 398040.518931\n", + " 371349.124368\n", + " 425017.218302\n", + " 426405.341430\n", + " -1388.123129\n", + " -0.003255\n", " \n", " \n", " 16\n", " 2041\n", - " 23909\n", - " 603172\n", - " 3217069.0\n", + " 23418\n", + " 588798\n", + " 3126883.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 409283.988225\n", - " 389442.315269\n", - " 385668.859805\n", - " 378426.274901\n", - " 374044.680265\n", - " 407922.043693\n", - " 409972.692203\n", - " -2050.648510\n", - " -0.005002\n", + " 364816.739985\n", + " 335208.786306\n", + " 354775.001534\n", + " 338447.362232\n", + " 321940.022061\n", + " 397017.066601\n", + " 399458.496395\n", + " -2441.429794\n", + " -0.006112\n", " \n", " \n", " 17\n", " 2042\n", - " 24546\n", - " 614459\n", - " 3284010.0\n", + " 24483\n", + " 614818\n", + " 3264448.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 473493.289947\n", - " 451147.769581\n", - " 430615.696082\n", - " 425669.313089\n", - " 429496.615643\n", - " 412187.659372\n", - " 413257.478800\n", - " -1069.819428\n", - " -0.002589\n", + " 474909.052258\n", + " 506841.062275\n", + " 463684.071161\n", + " 461858.642099\n", + " 454618.554156\n", + " 416691.544445\n", + " 416997.757878\n", + " -306.213433\n", + " -0.000734\n", " \n", " \n", " 18\n", " 2043\n", - " 25169\n", - " 634991\n", - " 3380638.0\n", + " 22584\n", + " 568163\n", + " 3020289.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 469347.741866\n", - " 494545.073752\n", - " 499347.930783\n", - " 493783.833404\n", - " 488803.549502\n", - " 430347.112355\n", - " 430015.937504\n", - " 331.174851\n", - " 0.000770\n", + " 437730.151447\n", + " 415617.644419\n", + " 410420.270555\n", + " 407615.216190\n", + " 384771.629007\n", + " 383660.669690\n", + " 383755.734156\n", + " -95.064467\n", + " -0.000248\n", " \n", " \n", " 19\n", " 2044\n", - " 23565\n", - " 591583\n", - " 3151148.0\n", + " 23377\n", + " 588639\n", + " 3133986.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 367242.325518\n", - " 371711.781452\n", - " 374913.433345\n", - " 377110.720066\n", - " 377895.449896\n", - " 401348.874670\n", - " 401054.748615\n", - " 294.126054\n", - " 0.000733\n", + " 467117.570232\n", + " 486817.869497\n", + " 480637.195403\n", + " 474544.770943\n", + " 455304.239249\n", + " 394673.545565\n", + " 394754.939189\n", + " -81.393624\n", + " -0.000206\n", " \n", " \n", " 20\n", " 2045\n", - " 24921\n", - " 627096\n", - " 3335948.0\n", + " 23817\n", + " 599233\n", + " 3190091.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 315560.724644\n", - " 343353.455376\n", - " 345223.997177\n", - " 342021.238793\n", - " 334436.491016\n", - " 423672.932007\n", - " 425227.379946\n", - " -1554.447940\n", - " -0.003656\n", + " 398139.357152\n", + " 362850.193582\n", + " 402219.531548\n", + " 399839.624296\n", + " 377344.967272\n", + " 401135.309503\n", + " 402985.317847\n", + " -1850.008344\n", + " -0.004591\n", " \n", " \n", " 21\n", " 2046\n", - " 23776\n", - " 598458\n", - " 3181465.0\n", + " 24583\n", + " 616970\n", + " 3286711.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 371782.115694\n", - " 305812.333010\n", - " 294432.924965\n", - " 293503.944334\n", - " 296392.880809\n", - " 398552.821055\n", - " 401775.342808\n", - " -3222.521752\n", - " -0.008021\n", + " 443421.655978\n", + " 468076.690976\n", + " 465542.221447\n", + " 467423.630271\n", + " 464577.255028\n", + " 412242.557813\n", + " 413773.489936\n", + " -1530.932123\n", + " -0.003700\n", " \n", " \n", " 22\n", " 2047\n", - " 22152\n", - " 556685\n", - " 2957237.0\n", + " 22492\n", + " 563400\n", + " 2990632.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 434630.692016\n", - " 457467.620834\n", - " 474432.706520\n", - " 472613.554807\n", - " 440392.213570\n", - " 373087.409200\n", - " 374239.513003\n", - " -1152.103803\n", - " -0.003079\n", + " 494553.446600\n", + " 444767.223650\n", + " 409485.605985\n", + " 387260.946000\n", + " 360098.331291\n", + " 372146.903936\n", + " 375589.196357\n", + " -3442.292421\n", + " -0.009165\n", " \n", " \n", " 23\n", " 2048\n", - " 23385\n", - " 588872\n", - " 3114865.0\n", + " 23857\n", + " 599713\n", + " 3190814.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 341127.222055\n", - " 315111.678821\n", - " 294945.264077\n", - " 285233.426898\n", - " 253195.609983\n", - " 390315.605105\n", - " 391466.290883\n", - " -1150.685778\n", - " -0.002939\n", + " 472153.619753\n", + " 503414.718730\n", + " 491261.349692\n", + " 495127.838946\n", + " 485805.294721\n", + " 401945.091876\n", + " 402709.253238\n", + " -764.161361\n", + " -0.001898\n", " \n", " \n", " 24\n", " 2049\n", - " 25584\n", - " 643536\n", - " 3435564.0\n", + " 23922\n", + " 602508\n", + " 3200414.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 431988.493807\n", - " 443731.169805\n", - " 451146.067144\n", - " 447883.026972\n", - " 446049.207337\n", - " 430832.507546\n", - " 432053.418987\n", - " -1220.911442\n", - " -0.002826\n", + " 465094.209967\n", + " 455038.002255\n", + " 477898.743986\n", + " 469420.838584\n", + " 440243.139280\n", + " 398685.865173\n", + " 401567.430428\n", + " -2881.565255\n", + " -0.007176\n", " \n", " \n", " 25\n", " 2050\n", - " 23985\n", - " 603121\n", - " 3199136.0\n", + " 23672\n", + " 596141\n", + " 3153492.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 421327.798951\n", - " 396769.929491\n", - " 408562.425855\n", - " 418502.725903\n", - " 419774.688159\n", - " 402422.115951\n", - " 403916.440618\n", - " -1494.324667\n", - " -0.003700\n", + " 452834.779144\n", + " 465973.024854\n", + " 462746.331497\n", + " 425762.806114\n", + " 427139.769513\n", + " 399252.955628\n", + " 398635.670647\n", + " 617.284980\n", + " 0.001548\n", " \n", " \n", " 26\n", " 2051\n", - " 24460\n", - " 615031\n", - " 3269170.0\n", + " 23898\n", + " 601388\n", + " 3209981.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 321024.804561\n", - " 345132.495319\n", - " 329562.416251\n", - " 323549.743210\n", - " 317332.704749\n", - " 409463.606493\n", - " 410180.385199\n", - " -716.778707\n", - " -0.001747\n", + " 460721.942570\n", + " 407556.892301\n", + " 401004.293570\n", + " 421749.445065\n", + " 405452.318421\n", + " 400477.291574\n", + " 400608.907041\n", + " -131.615467\n", + " -0.000329\n", " \n", " \n", " 27\n", " 2052\n", - " 23610\n", - " 593948\n", - " 3148362.0\n", + " 23496\n", + " 591222\n", + " 3151911.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 469034.752168\n", - " 469662.194769\n", - " 448426.362540\n", - " 446609.577932\n", - " 435340.199013\n", - " 391160.953917\n", - " 393091.155764\n", - " -1930.201847\n", - " -0.004910\n", + " 309639.446977\n", + " 390992.045894\n", + " 420441.094988\n", + " 413192.196815\n", + " 409041.464387\n", + " 390999.580252\n", + " 392078.841473\n", + " -1079.261220\n", + " -0.002753\n", " \n", " \n", " 28\n", " 2053\n", - " 24612\n", - " 617265\n", - " 3291913.0\n", + " 24894\n", + " 627569\n", + " 3335143.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 479370.138921\n", - " 461118.374422\n", - " 452747.999276\n", - " 442215.228495\n", - " 400887.449181\n", - " 409930.626615\n", - " 412238.859114\n", - " -2308.232499\n", - " -0.005599\n", + " 332821.767357\n", + " 320904.427223\n", + " 316776.074425\n", + " 316292.885898\n", + " 306048.398243\n", + " 416471.045063\n", + " 418092.099246\n", + " -1621.054183\n", + " -0.003877\n", " \n", " \n", " 29\n", " 2054\n", - " 23846\n", - " 600531\n", - " 3190334.0\n", + " 21946\n", + " 552383\n", + " 2937089.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 378828.522395\n", - " 435684.567230\n", - " 434997.915598\n", - " 436064.621612\n", - " 432867.449960\n", - " 396400.887798\n", - " 396070.808867\n", - " 330.078931\n", - " 0.000833\n", + " 418144.175624\n", + " 404366.782226\n", + " 391164.519869\n", + " 373727.874006\n", + " 343975.955350\n", + " 360207.713252\n", + " 364273.522362\n", + " -4065.809111\n", + " -0.011161\n", " \n", " \n", " 30\n", " 2055\n", - " 24956\n", - " 628421\n", - " 3345467.0\n", + " 23076\n", + " 579568\n", + " 3072851.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 478046.700552\n", - " 428881.409055\n", - " 453508.028054\n", - " 449527.028001\n", - " 444985.809368\n", - " 416341.114108\n", - " 417028.311391\n", - " -687.197283\n", - " -0.001648\n", + " 300680.970171\n", + " 346289.174108\n", + " 340245.279011\n", + " 329299.172958\n", + " 309663.520488\n", + " 379799.778479\n", + " 382254.450494\n", + " -2454.672016\n", + " -0.006422\n", " \n", " \n", " 31\n", " 2056\n", - " 23703\n", - " 596560\n", - " 3172864.0\n", + " 23967\n", + " 601469\n", + " 3194980.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 370264.174609\n", - " 415190.572889\n", - " 426911.392935\n", - " 433321.292498\n", - " 423776.044021\n", - " 395081.647605\n", - " 391936.636790\n", - " 3145.010815\n", - " 0.008024\n", + " 461243.283456\n", + " 391853.983192\n", + " 387762.882037\n", + " 372651.645513\n", + " 355108.240357\n", + " 389694.500461\n", + " 393327.366843\n", + " -3632.866382\n", + " -0.009236\n", " \n", " \n", " 32\n", " 2057\n", - " 23884\n", - " 602103\n", - " 3215112.0\n", + " 23389\n", + " 588821\n", + " 3139033.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 378162.247570\n", - " 377205.366488\n", - " 342790.975990\n", - " 332326.448483\n", - " 330739.987217\n", - " 394811.555047\n", - " 396221.517042\n", - " -1409.961995\n", - " -0.003559\n", + " 379993.626328\n", + " 421170.962261\n", + " 417222.716525\n", + " 405927.199113\n", + " 379013.465979\n", + " 382707.973900\n", + " 382588.827454\n", + " 119.146445\n", + " 0.000311\n", " \n", " \n", " 33\n", " 2058\n", - " 24352\n", - " 611347\n", - " 3261366.0\n", + " 22093\n", + " 555609\n", + " 2950853.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 414908.289481\n", - " 333540.646309\n", - " 362992.743057\n", - " 366721.297324\n", - " 367575.167706\n", - " 401393.780962\n", - " 403754.537706\n", - " -2360.756744\n", - " -0.005847\n", + " 381230.056855\n", + " 354587.101006\n", + " 350957.265087\n", + " 326505.718272\n", + " 294446.256154\n", + " 361165.891802\n", + " 361939.932800\n", + " -774.040998\n", + " -0.002139\n", " \n", " \n", " 34\n", " 2059\n", - " 24055\n", - " 603579\n", - " 3200088.0\n", + " 23733\n", + " 596624\n", + " 3169901.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 455684.817802\n", - " 472393.409198\n", - " 478349.032980\n", - " 477401.048276\n", - " 438412.338758\n", - " 391860.264252\n", - " 393873.141006\n", - " -2012.876754\n", - " -0.005110\n", + " 501263.956015\n", + " 490253.713022\n", + " 477610.230551\n", + " 460159.597378\n", + " 444568.857000\n", + " 389684.514691\n", + " 391135.437740\n", + " -1450.923049\n", + " -0.003710\n", " \n", " \n", " 35\n", " 2060\n", - " 22401\n", - " 560380\n", - " 3000088.0\n", + " 23173\n", + " 582978\n", + " 3100047.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 359900.771691\n", - " 372597.770047\n", - " 360489.465892\n", - " 363261.114549\n", - " 359252.347918\n", - " 367209.410297\n", - " 366611.581462\n", - " 597.828835\n", - " 0.001631\n", + " 459757.304011\n", + " 436835.494548\n", + " 419958.086643\n", + " 435515.915955\n", + " 425013.325154\n", + " 383317.152377\n", + " 381266.519178\n", + " 2050.633200\n", + " 0.005378\n", " \n", " \n", " 36\n", " 2061\n", - " 25450\n", - " 639870\n", - " 3417374.0\n", + " 23689\n", + " 595156\n", + " 3162324.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 522352.080349\n", - " 579014.399822\n", - " 568925.720500\n", - " 565835.475117\n", - " 550598.603341\n", - " 417434.381690\n", - " 420020.233730\n", - " -2585.852040\n", - " -0.006156\n", + " 403898.123577\n", + " 446026.892969\n", + " 459573.706453\n", + " 436904.851847\n", + " 419966.747362\n", + " 390113.556785\n", + " 387064.014493\n", + " 3049.542292\n", + " 0.007879\n", " \n", " \n", " 37\n", " 2062\n", - " 23155\n", - " 582547\n", - " 3074410.0\n", + " 22794\n", + " 574103\n", + " 3036727.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 376936.757775\n", - " 379134.096954\n", - " 381629.099749\n", - " 364270.180436\n", - " 356574.164485\n", - " 377882.767541\n", - " 377365.440971\n", - " 517.326570\n", - " 0.001371\n", + " 468021.236699\n", + " 450100.730558\n", + " 416050.220079\n", + " 373748.278834\n", + " 351040.543393\n", + " 372856.397814\n", + " 373879.275648\n", + " -1022.877835\n", + " -0.002736\n", " \n", " \n", " 38\n", " 2063\n", - " 23057\n", - " 580043\n", - " 3084421.0\n", + " 22722\n", + " 573325\n", + " 3024141.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 467723.711737\n", - " 401612.564532\n", - " 392392.393319\n", - " 396304.528597\n", - " 394369.022680\n", - " 374082.177605\n", - " 374460.254161\n", - " -378.076555\n", - " -0.001010\n", + " 414958.264565\n", + " 415976.330050\n", + " 443797.927964\n", + " 453085.545667\n", + " 444035.139054\n", + " 367768.692199\n", + " 368187.001270\n", + " -418.309071\n", + " -0.001136\n", " \n", " \n", " 39\n", " 2064\n", - " 23503\n", - " 592241\n", - " 3138838.0\n", + " 23581\n", + " 590848\n", + " 3149704.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 323517.333199\n", - " 367831.340554\n", - " 346112.375544\n", - " 324946.993397\n", - " 312443.249634\n", - " 382423.385030\n", - " 382966.454764\n", - " -543.069734\n", - " -0.001418\n", + " 441414.054493\n", + " 435767.269524\n", + " 415051.021426\n", + " 406769.043607\n", + " 396642.228590\n", + " 378200.181200\n", + " 380644.486568\n", + " -2444.305368\n", + " -0.006421\n", " \n", " \n", " 40\n", " 2065\n", - " 23680\n", - " 594336\n", - " 3169648.0\n", + " 23523\n", + " 591233\n", + " 3157907.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 345713.935117\n", - " 293320.941908\n", - " 318220.999319\n", - " 326566.490286\n", - " 323628.322020\n", - " 384159.066998\n", - " 384056.354457\n", - " 102.712541\n", - " 0.000267\n", + " 433793.080907\n", + " 435494.327000\n", + " 421305.379992\n", + " 408124.267918\n", + " 399546.170001\n", + " 383210.897923\n", + " 380769.053462\n", + " 2441.844461\n", + " 0.006413\n", " \n", " \n", " 41\n", " 2066\n", - " 23743\n", - " 598339\n", - " 3198839.0\n", + " 22993\n", + " 578310\n", + " 3065123.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 395462.015387\n", - " 445201.806887\n", - " 440143.467266\n", - " 438945.020171\n", - " 435197.782687\n", - " 385665.968172\n", - " 385827.443170\n", - " -161.474998\n", - " -0.000419\n", + " 358327.837808\n", + " 382545.188235\n", + " 359818.742372\n", + " 354980.088513\n", + " 342669.140660\n", + " 373477.131153\n", + " 373664.729920\n", + " -187.598767\n", + " -0.000502\n", " \n", " \n", " 42\n", " 2067\n", - " 24569\n", - " 619436\n", - " 3283765.0\n", + " 23261\n", + " 583580\n", + " 3099017.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 406529.105098\n", - " 356852.651551\n", - " 349188.139601\n", - " 335367.151073\n", - " 336038.756644\n", - " 398291.557836\n", - " 400458.849287\n", - " -2167.291450\n", - " -0.005412\n", + " 385266.544939\n", + " 357229.405339\n", + " 389448.072900\n", + " 382553.140857\n", + " 367803.054399\n", + " 375480.781577\n", + " 376740.673312\n", + " -1259.891735\n", + " -0.003344\n", " \n", " \n", " 43\n", " 2068\n", - " 24122\n", - " 608216\n", - " 3240015.0\n", + " 23318\n", + " 586603\n", + " 3118001.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 574552.855124\n", - " 543870.172353\n", - " 546057.722361\n", - " 548303.362147\n", - " 547679.218868\n", - " 391932.655476\n", - " 393162.031631\n", - " -1229.376155\n", - " -0.003127\n", + " 444523.181015\n", + " 449728.133273\n", + " 439791.891824\n", + " 438856.705942\n", + " 426322.297655\n", + " 374245.788665\n", + " 375335.534050\n", + " -1089.745385\n", + " -0.002903\n", " \n", " \n", " 44\n", " 2069\n", - " 24546\n", - " 618608\n", - " 3287355.0\n", + " 23422\n", + " 588499\n", + " 3133720.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 446939.143675\n", - " 511156.014302\n", - " 533278.121296\n", - " 529131.538903\n", - " 529176.140345\n", - " 396645.182138\n", - " 399251.911588\n", - " -2606.729450\n", - " -0.006529\n", + " 445720.962431\n", + " 418703.399054\n", + " 431958.526817\n", + " 430211.684701\n", + " 419976.194936\n", + " 379224.450236\n", + " 378005.108376\n", + " 1219.341861\n", + " 0.003226\n", " \n", " \n", " 45\n", " 2070\n", - " 23805\n", - " 598800\n", - " 3180887.0\n", + " 23609\n", + " 593756\n", + " 3146747.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 478443.587177\n", - " 441135.161700\n", - " 433665.355653\n", - " 444075.669003\n", - " 439392.286115\n", - " 383002.326955\n", - " 384919.782302\n", - " -1917.455347\n", - " -0.004981\n", + " 400991.290205\n", + " 429393.430690\n", + " 411181.980311\n", + " 405133.787228\n", + " 386202.176410\n", + " 383743.213561\n", + " 381667.545696\n", + " 2075.667865\n", + " 0.005438\n", " \n", " \n", "\n", "
" ] }, - "execution_count": 27, + "execution_count": 55, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 27 + "execution_count": 55 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-03T10:30:46.773318Z", - "start_time": "2025-01-03T10:30:46.694886Z" + "end_time": "2025-01-03T11:37:16.273771Z", + "start_time": "2025-01-03T11:37:16.179184Z" } }, "cell_type": "code", @@ -5110,10 +5110,10 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 28, + "execution_count": 56, "metadata": {}, "output_type": "execute_result" }, @@ -5122,19 +5122,19 @@ "text/plain": [ "
" ], - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 28 + "execution_count": 56 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-03T10:30:47.618102Z", - "start_time": "2025-01-03T10:30:47.547801Z" + "end_time": "2025-01-03T11:37:19.075390Z", + "start_time": "2025-01-03T11:37:19.004816Z" } }, "cell_type": "code", @@ -5148,10 +5148,10 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 29, + "execution_count": 57, "metadata": {}, "output_type": "execute_result" }, @@ -5160,13 +5160,13 @@ "text/plain": [ "
" ], - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 29 + "execution_count": 57 }, { "metadata": {}, @@ -5177,8 +5177,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-03T10:30:48.984030Z", - "start_time": "2025-01-03T10:30:48.982048Z" + "end_time": "2025-01-03T11:37:21.994238Z", + "start_time": "2025-01-03T11:37:21.991947Z" } }, "cell_type": "code", @@ -5193,11 +5193,11 @@ "name": "stdout", "output_type": "stream", "text": [ - "Sum of values < 0: -82646.73650538316\n" + "Sum of values < 0: -124529.77354513475\n" ] } ], - "execution_count": 30 + "execution_count": 58 }, { "metadata": {}, @@ -5208,8 +5208,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-03T10:38:42.682938Z", - "start_time": "2025-01-03T10:38:42.475970Z" + "end_time": "2025-01-03T11:37:23.670682Z", + "start_time": "2025-01-03T11:37:23.521042Z" } }, "cell_type": "code", @@ -5226,7 +5226,7 @@ "plt.xlabel(\"Year\")\n", "plt.ylabel(\"Change ANC cases due to weather\")\n", "plt.axhline(y=0, color='black', linestyle='--')\n", - "\n", + "plt.ylim(-1.5, 0)\n", "plt.legend(title='Zones')\n", "plt.show()" ], @@ -5236,31 +5236,31 @@ "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_89216/2748134374.py:8: SettingWithCopyWarning: \n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_89216/4003818095.py:7: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_89216/2748134374.py:8: SettingWithCopyWarning: \n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_89216/4003818095.py:7: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_89216/2748134374.py:8: SettingWithCopyWarning: \n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_89216/4003818095.py:7: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_89216/2748134374.py:8: SettingWithCopyWarning: \n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_89216/4003818095.py:7: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_89216/2748134374.py:8: SettingWithCopyWarning: \n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_89216/4003818095.py:7: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", @@ -5273,13 +5273,26 @@ "text/plain": [ "
" ], - "image/png": "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" + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1kAAAISCAYAAAA+6QUoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/OQEPoAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOy9Z7gkV3ktvCp2DifOOXMmz0gaSaOEEhICgxBIIgobLHPxvSbjgIwlHISxSfqwfDHZ4WIyBmMwGIRIMiCMBEgoh1GYkTQ5nJw6V9zfjx2quru6uzqcM0G9nmeememurq7urtq1117rXa9ECCHoo48++uijjz766KOPPvrooyeQj/UB9NFHH3300UcfffTRRx99nEzok6w++uijjz766KOPPvroo48eok+y+uijjz766KOPPvroo48+eog+yeqjjz766KOPPvroo48++ugh+iSrjz766KOPPvroo48++uijh+iTrD766KOPPvroo48++uijjx6iT7L66KOPPvroo48++uijjz56iD7J6qOPPvroo48++uijjz766CH6JKuPPvroo48++uijjz766KOH6JOsPvroo48++uijjz766KOPHuKEI1n//M//jE2bNiEajeLiiy/Gvffe23T7b33rW9i+fTui0SjOOuss/OhHP1qlI+2jjz766KOPPvroo48+no04oUjWN7/5Tdxwww14//vfjwcffBDnnHMOrrzySszMzARuf9ddd+H1r3893vKWt+Chhx7CNddcg2uuuQaPPfbYKh95H3300UcfffTRRx999PFsgUQIIcf6IMLi4osvxoUXXoh/+qd/AgC4rov169fjuuuuw4033li3/bXXXotisYgf/OAH4rHnPve5OPfcc/GZz3xm1Y67jz766KOPPvroo48++nj2QD3WBxAWpmnigQcewHve8x7xmCzLuOKKK3D33XcHvubuu+/GDTfcUPXYlVdeiVtuuaXh+xiGAcMwxP9d18XCwgKGhoYgSVJ3H6KPPvroo48++uijjz76OGFBCEE+n8fatWshy41NgScMyZqbm4PjOFizZk3V42vWrMGuXbsCXzM1NRW4/dTUVMP3ufnmm/HBD36w+wPuo48++uijjz766KOPPk5KHDp0COvWrWv4/AlDslYL73nPe6rUr+XlZWzYsAG7d+9GKpWq215RFESjUfH/YrHYcN+yLCMWi3W0balUQiNnpyRJiMfjHW1bLpfhum7D40gkEh1tm9uzB3te+zpIsRhO+elPxOOzn/0sFv/tqxj53WvxlthzcWSxgpecNoibXnV6Q6UwHo/jP3b9Bz790Kdx+fjleO9F763fyDaBT+5AXAOkd+0EEoNYWsjja397FwDgD26+FLJCVxuO7F7AT77wBEYmsrj2ry/Ggbe+DbkHH8Qnzv0djF+0FX89fQOgxYDrHgJkGX/ysz/Bk/kn8ZkHz0b8joeQue46pF732obfQzQahaIoAKgCa1lWqG0ty4JpmgCAG++8EfdM3YN3n/9uvGLrKwAAf3nXX+KB2QfwNxf/Da7ccKXYNgiRSASqSi9v27ar1Nla6LoOTdPa3tZxHFQqlYbbapoGXdfb3tZ1XZTLZQDAr5+exZ998xEkIyp+8KeXIRFRG24bhL1zZbz+iw9gKKHjF3/xQpRKpYbbqqqKSCQCgK5SNdu29rp/4OAD+KPb/wjDsWF865Xfqtr2tT94LRadRXzpqi/h9MHTez5GWDOz2Hv11SjKCu666EMAgP/1/oshqRL+/W9/Q///wedicDgDALh7zzze8oVfYdNgHKee9UPcdfQuXP+c6/Gqba8CEDxGTP/zv2Dx3/8d6Ze8BGPvf1/VcRiKgZd/5+UgIPjmld/EcHQ48HgNy8ELPkFdB3e/53JocOA4TsPP5x9PKpVK023j8bgYPwzDgG3bPdk2FouJVcpG1/LBt7wVd8evhplaj+e+civu/cE+RJMSzvrhnwEAtv3kvyH7vk+g/THib+76G/zPof/BCwbeiJ/eOYRfRem+cd39QCQttvVf9/7xpBa5n/wUCzfdhH0TEgY/82lctOYiPP3GN6Ly+BNYe/PfIfn854tt/+up/8I/7/xnvMio4O8xAvtNt7U1RiwXlnHVd64CAPzhlv+Hj952GJdsHcKnX39eT8aIbrdt57pvtu2/P/nv+PzOz+PFG16Mv3nu3wTODSqmg+d/5H9wuqXgRWUN6yMP44orbSiPfxtRYxa/Z7wXR0/7T1QqRXz16q9iXap+8hZ2jHjmwRn86pvPYGZwP+4/9xb88Ld/2HRu8O0HDuMfbt+Pm8fvwCsX/w2lU38b5KqbAQBzRwv4/icfhmYu49obz4c+Pr7i84jZI0v41s33oaTk8dq/fQ6Mr74fpX/bCVeRsf2OO+r2W6lU8Jsjv8Ff3vmX2JDagK9c/RUAwP/+wm+wa7KAj77+Qrzs7LUA6HX/6KF5/MEX7sOadARfe8dZeM33XgMA+Mlrf4JMMtPWGCFJEi75+qVwHQcffuSFGP75zzBwSgEjN7wXOOu1Vdu2Gk84otEo9jz/BSCGgXUvnQHOejHw6n9quG3QPILj609+HZ/b+TlYy2cja/we/uevrmi4rR8N5xHP/A9wyzuwlN6Ol8z8KT6w+7s4Y/9OrL3xrzD4u7/bdB5BCMGrfvAqlNwSvnb117A5vXnF5xHdbht03efzeZx22mmBvKDqtU2fPY4wPDwMRVEwPT1d9fj09DTGxsYCXzM2NtbW9gA9qfiXWbuvdDod8IpqhNnm2bCtpuvIaxrUoSGMj497j4+vhaZp2L1/HpMbZaxfM4SP/8HzkYlpTfdnaiaUmIK1Y2ur9iewfBhIyYCsAms2ALIMmBoyiSGomoyJdRNi04SWxT2Jadh5CclEEtGZGaiqitzQRsjJ7Rg3ooBjAHELGNiELRu24On9T0OKSkgqCgY1FcNBx9BDFGNFaFkN2zdtF593+8R2PFx4GNPuNIaGhlb0/Y81stksAOCWHx6EmhrE71+2Gds2rW+6bSDiZciROApEQjqdRiaTCX0M7WyLNKBlNawfWl93fq4fX4/cfA5lpYx0Ot3za86Ym0NSURAdHEcmQc+LDZvXQVZkjI8fQClnIq5kxL5mjUWoyUGctmUUBXaenbbptODrih1D6lWvxIH//E8oDz+MsdFRSOyGznHehvPwyOwj2GXtwus2vy5wP4QQaLEEHJdAjSYwmo4Gbtfp93CsUFZkpBIjqERSGBkbREyfQURRMRqNAo6D0WQSWo2jol1IUQlKTEE0mcVgKorxqAxIMrDhFDrWtQl5ehquqmJmQsJgDBgcHMT4yCiK2tMY0XVkfedC6XAJakrFZtdFujwLDA629V4DAwMYHx/HXHkOg2s1qKlBFJRUw/MtLJpe911s2+kYkdubg5bVsGPzjsDPlk6nMblchpoaRMZUkZE1jEYjGB8fAYqnA/vncJq0iPl4Ck7URHwojvGh1t9Ro2ujvFZFOj6PorYoxp1m11E0XYYcmcFozEW6JCE9tgZgn8NZmEUmMYS4ZGFiyxYoNd/RiswjTA2p+ACichxG3MD42hHkGXkPGoPS6TRKCyU6nq2j41nRsLGvFIGa0vFbZ21EOu2R09PUBNTUHuRlGaesPwV6VgcBQXwwjkysjbEfgOmYUOIyFMgYjyUxoGkYTqgYWbtWfIedIJ1IwLFtDOoKIlGj432tW14H7ZAGyDLmj0RA1Bgy8eZzrqaY1YCUDGlwAGp5EJtdEwOqisGNG1v+vouVRRgRAwoUnDFxBqJq+PtAu1jJMYIT/FZlRCdMuqCu6zj//PNx++23i8dc18Xtt9+OSy65JPA1l1xySdX2APDTn/604fZ99A5uPg8AUNLVLJ+v6E5PL0KWgE/93rktCRYA5MwcACATaTD4FRiZTq4Rkw7LoCvfWrR6ME4NRqGoMlyHIDeVh82I+HR8AEuGCwyfRjeceRIAsDZBV7/yMl3xcSuNV3F7hekSPabR+Kh4bHNmMwBg//L+FX//4wG7p/L41TNzkCXgDy7d1NE+sjG6UmU5BCWzsRLSLWbLswCAkfhI3XP8sZlScApqt+DXmpuik18tqgjVNjNKJxXLM94q3YF5uvK9cSiB2RI9bv95FoTYuedCTqXgLC2hsnNn3fO/te63AAB3Hrqz4T4kSUJcp9diwWi8MnyiwTVMuDIdw2Iper6ZhgMpmaTPs9+nG1QcunrrugrSElMuIumOCBYAVJ58AgCwd0xCyaJqjMxWZN18oWrbo4WjAIAJywbKC4DVeCW5EdYm6RjqyPMAgJlc+/s43nEgdwAAsCG9oeE2SyWqXKRUeh2oMIFIEhjaBgDYLE9CAZ10FsxC8E5CQtXpuaG6GhJaosXWQNmi42MCbKzQk+K5yjI951S7AjmZrHvtSkDRvOM/mDsENeVN3kkDNeNg/iAA7zd4+NASHJdgIhvDeCZWte1Qgi6mm46LskWQ0un5v2wst32sZdsbX3Wm0kkKAbR4o5eEgsQUS9eRgNJCx/tJ6PT3j0bo+ffUTJdjkkHnYxWZ7jdVXAIAaKPN7yOAd52MJ8ZXlGAdLzhhSBYA3HDDDfjc5z6Hr3zlK3jyySfxR3/0RygWi3jTm94EAPg//+f/VAVjvOtd78Jtt92Gj33sY9i1axc+8IEP4P7778c73/nOY/URnjVwcvQilFPVqxpLhN5cYo6J6y4/BRdsCrcqumQsAQAyegOSlecky7vIzQojWZFqkiXJkph8zj91FCAEJBLBsp5ErmwDo6fTDWfoRGQ8SVePlkAHdlJpLCv3AoZjiM+7Ju6tgG/KbAIA7MvtW9H3P17wpV/Tz3nlmWNYP9jZzSqqydBVOswtlRtbM7pFECnm4L/hSpEsp0AnYw4jWZG4Z1DIjDCSNevZmvbP039vGIpgvkInva1IlqSqSFz2PABA4c56IvWCdS8AAPxm8jeo2I0n0MkIPbaSsXKEd7VBDMMjWUlKsohLIKWyAACnByTLdOgCj+OoyICRrFi2o30RQlB5gi4g7V8joWjR/SkpRgoL1ccrSBZh04X8ZNvvOZGgToIymQMAzBdNWE5jy9iJCD7B35je2HAbTrISbExSJQPQU4JkbZGmIBF6zRasHpEsR0dMjbXYGqgwkhVn9zlEPDJlLjGSRcw6BWmloLIFGQkyDi4dhJr05hJuA2vXodwhAMCGFCVZ9+9fBACcv3GgbtuYrohFn/mCiWwkC8Cba7QDw6ELr4TI0Gz6PUpy9yRLZnZTYktAebHj/SRUSoYiOiNZ092SLPr6shwHCEG8sAQAUEfqFxlrsT+3H0Dz6+RkwglFsq699lp89KMfxfve9z6ce+65ePjhh3HbbbeJcIuDBw9ictK7AVx66aX4+te/js9+9rM455xz8O1vfxu33HILduzYcaw+wrMGQsny+VVtx8WXH6ITzRHFwXWXbwu9P7661FrJ8qygVoWulmvReldsdg0d/Ob30pu+PL4WkCTkK5aPZFUrWUtscuOWV3YVlk/GI0qk6vNuyWwBABzKH4LlrhxhOB5g2i6++9ARAMCbL9vc8X4kSUKWKaVLpcbe827RTBEaia2wklWg56UTzwIAIj5l2CNZ3qRk/xzdPpsy4BIXqqRiMNp6sSP5AqpWFe6oJ1mnDpyKscQYKk4F9041bhCfYCTrZFKy/CQrmvS+ezdNv1O30N1kGfAmcY7jU7Ki7VmaOOyjR+EuL8NVJBwahiBZcpKO1U6NknW4cBgAsDbCzpF84+CoRuBK1qI5DVWm9prZ/Mo7AlYLRauIuTK9lzRTspbLdAyKM6JCSVbCR7ImQRyqsHSvZLH3cHXEQ0z2uZIVI2xBxq9k5crseFfvulU1b3p6ZOkoIok0JIUSc6cByTqQpyrJ+jS1lt9/gKo/F2yqJ1kAMMQWReaL3ZEssbDkalAcem/uuZLVBclKst9SVen59/R0l2MSU7LKUhxpswSF1cuqw8H1uH5wJatPso5TvPOd78SBAwdgGAbuueceXHzxxeK5X/ziF/jyl79ctf3rXvc67N69G4Zh4LHHHsPLXvayVT7iZyecHCVZss+f+48/fwaPL9IBaEtShqqEP/3Ckyxvksvtgnq0fuWNk6ylo/Q4tQm60lo0HTjD2+lGjGRxJWue0IGJGCtLsqaLniri9/uOxkcRU2OwXRtH8kdW9BiONeYKBgzbhaZIOH9D8A0yLLLMe75cWjliOlNmiwex+pU8Trz4Nr0GVx6cGL3WqpUsep5zkuW6BAcW6CQqHqPn83B8GLLU+lpMPv8yAEDl8cdhz85WPSdJkmcZPNzYMphgE7/iSUSyHNOEq9DJmqrLUJlyTpL0vO2FXdCwKSGxbQVpsElwNNvRvipP0nEtv24Atuq3C9bbG3NmDnmT/n8iwRaw8kfbfk9OsiaLRzGaoiRi5iQiWQdzVMUaiAwgrTeuSVlkY1BM5koWswsOnwIA2CRNwbEZyepWydI4yQpnF6xYlMBEXUZgIt4CqZGn9zxNXj31UVYkgN3+ji5NIRJPQVZpaEdpuf67cVwHh/N0QWBjeiMcl+Chg0sAgpUswLMMzhcMZNn11IldkNt5CdEgs5AMWQag90bJch0JsMuA1ZmLhv/+RKLHuXuqN0pWAXEMVuj3pQwMQGJBEs3QJ1l99NEDuHm60sGVrPv3L+Aff/40Kiod1NQ2iUromqyUp2Q1sgsCQHaUTT4Z6Yut91KcCplT6T/mngIcSyhZy2yAWi0ly28VBABZkrEpvQmAJ7mfrOCr3MPJCGS5u/50vC5rJe2CzZQsQbJWTMmiEw6bTYqqSFZNTdZUrgLTdqmaoCw3POYgqMPDiDIXQOGXv6p7nlsG7zh8R8MEM65kFc2Th2S5vlo/VVegs/HGTdCxii84dQOuZJm2gkyXSlblCWqDLm2m44uwC3Ily2cXnCxQZ8hAZADxNAsP6kDJmkjS1x4pHMEICzyZPonqsrhVkCsojbBUR7KYXTC7AURSEZcMKBa9dnpZkxVXW0/2DaZkRd16JcssUgVEU4Ov65WAJElQNDr2T+VmoEYSkBX6/sVcfaLidGkalmtBkzWMxceweyqPgmEjGVGxfSyY+A4leq9kyTb9rqiS1dqm2QxyjNkFHTaH6VDNSmr0t7QIvQ88M9utksVJVgyDFfpvNUQ9FtAnWX300RMIJYuRrL/+7k64BLjkTEpm3CYxuUEQSlYbNVkWWy3XIvV2wYExetPJl+lzkfXrhD97SV9DbzCOCSzsRVJPIqWnYDInkLvCNVnN6ns4ydq3fHLXZXGSNZKqT/psFzxFaWkFlSxOsoKCL/jvyLfpNXhNls0mRX6SlR6mN/lSzoRZsbGfhV6sH4xjrsKIYSzczREAki+gRCqoLuvi8YsRU2OYKk7hqcWnAl8f1xnJOklqsohtwyXeIoCqyiJox42zIIlC9ySL12RZtuopWR3WZPF6LHMrU+9tZhcMCL4QVsHkWiDFks1ynStZRwtHMcIsWiejkrUx1XziuMTsgjpzKAglS9FgZajNMG7R76X7mix6HmpuJBTJ4nZBnZMsf00Ws1rr2uqRLADQ2GewLRvzkguJkbzicv01xSfv61LroMgKHjhICcl5G7JQGizUcbvgQtEUC7hLlaW2j9OrydIgs1h2WpPVWkFsBinK7IIsYKJTksXtohWnBMDFbN7AcjeLjoxk5UkMQ0zJClOP5RJXXCt8LnOyo0+y+lgR+NMFy6aDp5gH+K0vPZM+3wbJslxL3HDaqslqZhdkSlaZxODIOrSJCaSjdDKeq7jACLMMTj8OgNZlGWzuSlY4XbCRkgV4CYMnPckqMJKV7J5kiZqs8srUZJmOiUWD3vyCCAsnWUvGkrgZ9xJ8Umyz4vaIL5o3mtAQTbDzeq6MAyz0YuNQXJxnYZUsAEj+FiVZxV//GqSmx0tEieDicWrfvuPwHcGvZypP6SRRsvz1WAAgqxJ0VgPqRINrnDqB4TIly5K6V7KYXdDeRif13C6oBNgFRehFcsIjWR0EX3CSVbJLGEjR63D2JFKywiQLAp5lmZuqRE0WAGmIWgYHmCrSq+ALAIhLYeyC7H7pcCXLswuavL5ZX90pI7c8Kq6GA05B2AXLhXol61C+OvTigf20HquRVRAABpldcK5gdKVklbiNz9UgMZLcEyUrynozSYwkd6lkAcCaDP0Nn5np4vxiNVk50p6SNVOaQcWpQJVUMSac7OiTrD5WBDxRS06lcGSJDtqpiIoh1hDVbdIUsRY5dkEDaOx390e4MzSzC0aTGiIJlnQWH4U2MYEUmxwFhV+MJ8d9StYK12QxJWtNojHJerbYBXuiZMVWtiaLx7frsh64CJDW04gorA5lBSyDbpHeLC2FWkv8ShYApH3hFzz0YtNQoiOSFd2xA8rAANx8HuWHH657/qKxiwAAuxZ2Bb7+ZAu+cE0TjkLPL0WTIUmSGG/cCJ3Y9rImy7RkpHm6YAc1Wfb8PG1ZIUmQT6FBOqImS9gFvclXFclKc5LVvl0wokREvWI0Rsfz6dxJpGSFSBYEPDVdc+m9j5IsFkowQknWGhY80bVd0BccEQtBsriSpdkBSlaFHm9tO5SVhhfjruOQlRd2wUq+nmRxors+xUMvGicLcgz7lKxuSFbBpCSLEA2SSecHkgxBoDuFp2QxstZhjHtEiUCV6Nj7oswepFHAnq5IFh3Tlt2oqMlSR8MnC65LrYMqnzBtertCn2T1sSJwWYS7kk7j0CIdgCYGYlB4jw1CQJp02PZj2aQXcUpPQZEDBnlCfDVZHjGxOMlqcGPIsslnKUZJVjrGlSwLGD2DbsRi3CeSEzC5khXyuDtFU7sgj3E/yZWsuULvSJYIvlihmiy/VTCoMaEkSStqGRR2QdDvqpZkiYTBmbKwC24aiosgjnZIlqQoSLAAjCDL4ECUTmh4DWUtRE3WSUKy/EoWn9TqMaZksQmW06VdkBAiFNCK2V1NFrcK6hs3Ip6hjatFumCAktUru6DYBwBFp5PfmfyzT8niarrKeimpkilIljRMEwbXufTa6VbJkhUZROaJga3tgjT4gkBl9lF/TZbFQjEisdWdGPvDOw4YC8IuaAQoWX6iO52r4PBiGbIEnNckOEmkCxY8u2AnwRd5kxFTVwNMVpOlqUDQfKUNiAh3wu6DHSpZkiSJXllvX/wgPqd/HM900yurQs/RJSeKIfbvMHbBA8vPrnosoE+y+lgh+JWsw4xkrRuIQ4pGATYRDWsZ5EpWw3qs8iKtnwKARH1Nlh4Q4Q4A6SSzHqTXQhkYQJptlyvbwBpOspiSlRiHwYpwXePY2QX54LRkLGGx0nmk6/GO3tZkseCLFVKywihCKxnjziPcTdDJfu1ESIRfzPrsgsOdKVlA8yh3rjTzRLpaJHhN1go2hl5N+EkWX3XnSpbNlMXa5r7twnZtELDJpSX7arLaT93kVsHoGaeLxDFek8VDihoqWX67YEgXgh+cZNkyXY0/WZSsglnAQoV+ppY1WWwMklmPMFUlgMKuV5YwuIEsi/12C1dhYRYIQ7IcRGBBJmwBxK9kWfTep8dbp8f1EtzyqLgaDlbmhJJlFurnDv4eWbw/1vaxtOjNF4Re2QWLTMmSiEey5Ej39y6JBV+43GDag15ZBVnGxfIuyIfu6vzAmJI1b0fbsgs+23pkAX2S1ccKwcl7StbhRTogrhuIQZJlyLz3Q0iSNVWk9pSGvXwKbOIazQKa10HcamIXBICUSgfGyuBGSJIUrGQt7AWsMtYm18JgdsGVVLIc12maVBdTYxhP0MnOyWwZ9KcLdouVrsnidsGg+HaOlWxIzJUHy6Xnub8mC/AU2+WZkk/J6pxkJZ53KSDLMJ56CtZkdX0OJ1l+i2/VayMnV4S7G6RkMeXcUTnJ6k7J4vHQAFAx5e6UrCepMh894wxRDO8pWZRkkVIJxLZBCKkhWaze1a4AHYQD8ITBMqHXy8kSfMF7Mw1GB0U/okYQCz2MZGk+Sx/vlbXJpRPpbpUsAHAUep1FEK4ZcQI+ddGvZDn0OCM9GI/bgSrsghoOlaZFTZZVQ7Jc4no1WekNLftjcfB0wW7tgkVmEZSlCIjJarIi0WYvCQWZ2wVdNqaXO7MLAkBCYmMvW+R+0czXOj8wRrIWbV3YBbUwStazLFkQ6JOsPlYIbs5rRuwpWXTAkBL05h6WZD0+T8MnTh86PXiDAqsRSFYrP6bR3C4Yt+nNrMQmwCL4omwBiREgPgSAALO7sTaxVtgFV7Ima6GyAIc4kCUZw7Hgxn6iLmt5/4odx7HGbL6C9/3mS1j/0b8NXbvXCNkVThdsZu/k4KmDK1mTZdpskl9rF2QhLwszJVQsF4osIZtwxeS6XZKlDgwgds45AIDCnb+sek6QrJZ2wZNFyTLhstoChVmbePNzW6YTOKdLksWtghIklE10VZPF49sjp58uVrZF8EXSm1S7hQJyZk5M9Ncm19Iifq6e5ToPv8hZ9BqYLxqwndXru7RS4GlpPHChGfhCD7FZTZZfZUmuQUWKIUPod9ILkmXLdMyLuK0n/BXLRUJiC4havMrqZhO2gJPuLsihXSh+u2DxqLALusXqa2q6OA3TNaHKKsYSY3ggRD0WEJwuuGwst33PKbLgCwUaiMnSBXtBsniEu9tdhDsAJJmtb3n4VNhExsXuQzAOPtD+jhyL9uwCMG/pbSlZ3NL5bEkWBPokq48VAHEc0btHTqdxmDU/XT9IJ3tyvD2StXNuJwDgzKEzgzfgSlaqmmRxJUtvYBeIM3JWlDMghIjgi1zFppbGUc8yuFrBF3wSPhwdblgY+myIcS8s5nDJ1ONQ7/k1nPn5rvbF+2StdE2Wn6z8yy+ewed/uVf8fyUbEjvcLsg+Xl3wBYtxLy+ZUAgwkY1hyZwDQJtUhmlUWgueMlhbl5WOeHZBl9RPoE+6miyziZLF7JvdKlk8vj2iRFCx3I6VLKdQgHWATnKiZ5whfveSTUOIJE2jdm627ZECbXg+FB1ClKlySLFEsA4SBicSVMmaLU9CkSUQAswVVkZdXk0IktWiHqtiOaLhr8tIlhLxqc6ShNnIBiRYvVYv7IK2zKLXSesJf9lykORKlk/FIoTAIqzVySqTLNHri+go22XPTVKqvqb45H1dch1MG3j8KCUUF2xq4H5hGGRKlu0SyC79zA5xkLfau2Z5uqAiReDyCPdo99+VCL5gSmLHJKuyjESe3qcqZ74S/y09DwBg/M9H29+X4X03RtGGRug8Sx0OXhTmOJg7KJpFt7pWTib0SVYfPYfr8/QryWSdkiXHWepWsTXJclwHT8zT1dezhs8K3igfrGR5fbKClazI7D6AuLCIinLeqrYLAr6EwScwEBnwVqYsC8RemUniVIl+lmbqgohxz52cJKto2HB9lkx7oXOLBLDySlZtj6yFoomP3LYbH/7Rkyiz2qOVbEjs5vMgAEyDTtyiNXbBWEoTam7GlbCpi3osDt4vq3j33XBNb6KcYrHPBCRwJT7B+t6cLM2IiWHA4TVZak1NFhjZKnQ3WeZKlq7osB0HKbBro80+WcYumviojo9DHRgQJMslLspsZdofflFlFeTglsEuYtyPFo+KVLeToSFx2GRBvsijyBIcdvpr0eoap+X4BiQZySpaxcCFinZgyfTcUV2txZbcLsjOLV89lmO7IMxqFsk2t0P2GnzhYlClIS1LrKZTKlcHX/iDRx4+tATHJRjPRDGRbU50IqqCVISnClM7PgAsV9oLv+AkS5V0EDa29YJkCSXLZoFK5aXOdvTwfyDh0POvmJnAT4f+FwAgte/HwGxwT8OG4FZwNQaNOZakbBaS3rhez3It3PjLG+EQBxeNXRRYb36yok+y+ug5uD1GikZRhox51i1+3UD7Stbe5b0o22XE1bggF3UIiG8HfBHuDeyC7tFDiLL+RkszJZ9dkN0BfTHukiRhMOv14HJXqFeWCL0IiG/n4AmDJ6tdcDZvIOp4E3enS5LFmxGXLUf0guklREof65HF68noSj3990qlCxLXhVsswlEiIoug1i4oSZJIGBxwJZos2CXJipx+OtSREZBSCeX77/ceVyIirj4o/OJkU7KqarJ0rmTRz2g5LMq9UOjK8spJlibrSKEMWWL7alPJ4smC0dPpuBZVo5BAJ28lm1sGeW+vvFCyqkgWj3HvwC44nqSvLdtlDGfo738y1GWFThZkizyZqAabTZrVSDX5KSY3IcnOFQIirJydwpTYueM2r6VyXQLDdpGU6pUss8zGTOIiOtBdJHm78EgWVUkW2LUlV6pJlr9H1oMhrYIcQQmD7dZlVViLBR06wEiyFO3+u+LKMlc+O4pwJwS47/PivCraJUTGd+AnzvmQQIBff7K9/TEli0RSyJQoGVWGm9djfeaRz2Dn3E6k9BQ+fNmHA1N4T1b0SVYfPYdoRJxK4QhTsVJRVfQraodkPTb3GADgjKEzguPbgYYky2pRk2UdPow4q6dZmi4hHeN2Qa5kVScMjmS8yQYxVmYFdrrYur5nc5qSzUP5Q7CclVFnjiVmCwYitve57C7tgqmICkWmg3puBSyDtUoWJ1YAxAIDJ2AzpZmua8z8cEtlgBDRiFhWpar+OByZEXrNZR0JG32hF52uKEqShMQLng+gPmWwWfiFSBc8qWqyatIF2Xhj84/ouqFU+0bwlKwI0hLdD1FjgNpeCAGvx+IkS5ZksXIvemWx8AvXZxesahrahV0wokTEdZBK0nPjZIhx53bB1smCdCwY9KXdqtHq39DMbkWEELDSo67qshzXgclIk+I2j143bEoMRPBFxNeImC06Ko4hEihXC7wmK6tSwrTAVGK5Uh0+5e+RxftjXRCaZNHfYKHYecIgV4JjxPue5WjrRMdWECFhzGbakV1w3x3A/NNIMGW9YBWwbTSJf7FfTZ9/9JvA0qHw+2Mky9VTGGR1XtqaxvOVB6YfwOd3fh4A8L5L3oexxFjDbU9G9ElWHz2HwyRkOZ2uim/n8EhWfa+LWvB6rIZWQcDXI6v64m2WLugaBuzZWcTZZHNpulQdfAEAI9vp37nDQHkJ4+m1MHj4RXllJgdhFIbR+CjiahwOcXCo0MbgeIKgTsma707JkiRJEPylHpOsklUSEyH+m1WRLN7vixGwilNpGArRCVzWg8lmtVCRmBq4Sshj3AdcuUrJapaI2Aoiyr22LqtJ+IVIFzxZ7IKmIYIv1Bq7oGUSQKXPuV30yuI1WaqkI8NCL6SOkgW9+HYOEePOQlB4+IXfLlhNsjq3C/r3FY3RFfATPcY9Z+awyNwQrXtk0bFnMOqpV2qsxlI2tA0S0JO6rLJdFjVZst2cZHGFXwRf+JQsg5Es1a4IEr5a4AtGaSULAJhhCxiKWU2yuJK13qdktarH4uB1WXPdKFlsISThI7NSrHtrpcRi4Al3YHRCsu6jBCe5ZgcAoGgWsW00iYfJNjyknA24NnDXP4bfn49k8R5Z+prgxbqcmcN7fvkeuMTFq7a+Cldtuqr94z/B0SdZffQcLo9vT6Wq4ts5BMkKsbrLlawdwzsab5TnSpZHTBzHhcNW54L6ZFlH6QQi7iwBoCSLB1/kK2wCGMsCaaZeze6qShgkNStpvUIYhUGSpJO6KfFcwUDER7Lshe6ULAAeyepxXRb/vfwBEv5i/nn276gaFeSjl5ZBXv/opuiEoja+nSM9TG0nWbdayerULggAiUsvAVQV5r59MA8e9N4r0phkJX12wV4qescK1C5IJ2mKVm0XNA2nirR0iopNF3RUSUeah160WY/lGgaMPXsA0NALjlqSxSfRTt5TstYl13k7SjPC1W1DYm0JAE0RPZHBVazh2HDLABmuZGWZmivDghytnohrIzTGPeXSSXU3SlbJLsFW2HhnN5/qldkkPiNzJctHsnL0Pq06FciJ1a3JUpgFNynT83ImwmyWpkfO/fHtrjmEXMVGXFewfSwcIRz2JQwORKj61W5DYoO1WRBKlkQg9VLJMvjvWAasNuYey0eAXT8CAMQ30LALrmQBwCeNV9LtHvwKUAh5X2Iky1YTIr69USPiD//mw5gsTmJdch3++uK/Dn/cJxH6JKuPnsNTslI4xJSs9X4lK8EKrlsoWYZj4OnFpwG0IFnCLugpWVzFAoKVLOsInSSkE5SIUbtgTfAFUBV+MZ4cF+lGK1WTxePAW9m4TuYY99m8gajtr8nqvumyR7J6m2YW1CPLr2TNFb1/r0T4BSdZTpJODmqTBQWS9PGsK2H9YKxruyBAF1Hiz3kOgOoodx5+EVSTFWckyyUQSWsnMvwR7mqNXdCqOD7S0r2SpUiaL769PSXLeOppwLahZLNQx7xxkvfK4jVZPPjCyeca2AW5kjXV9ucAvPouW6ELJye6kiXqscLEt7MFngFWh6VKJqBXE7NUdhDTJIuUSxcguiJZVkkoWXzBsREqgmSx38OvZC3SY1DsMuRE98ShHfBrKi7R45nUWfS95Y3jM6UZGI4BVVJxcIYqP+euz0JVwk1vuZI1XzA6VrK4pTfGou4lmdT9tp1AZjVZxDABqYMY9we+BBAH2HgZkgNbANDzYiIbQ1STcYd9BiprzqO9737zL+H2yWzglpr0xbfXk6zv7/k+frTvR1AkBX//gr/vKMX2ZECfZPXRc3hKVrq5ktWiJmvXwi7YxMZgdFA04K2D5WuM6VOyeD2WrEoi9avqZUfoBCI7TAfl5dkykmyFsWDYcNlNzh9+sdJKFiHEI1lNgi+A8DHuH/r+E7jhmw/DcU8c1WA2byDiqzXrhZLFEwZ7HeMepAjNV9kFvcmAaEjcwxh3Ht9ux+nkoBHJWlLo759xZaiSJI6B2xg7hRflfod4rFlNVlzzFjxOBssg8QVf8PoRoWRV7Kq0vk7BJ3BUyWJjZps9srwmxKdX2Unr7YKUFJaW5kSdCQ+sAODVZBVnICLy2gAnbBXRkPjEVrKeWXoGQLhIam4XTPHeT5JRpRgBwEBcxz4y3hO7YNEuij5Zttm8BpIveKQVNnb5arKMZXrOabBWPbBAZd9VlNCQlhwjWYrljeNcTZxITeChAyy6PWQ9FgAMJegcYL6LhsQmU7ISTMmSFNBeY11CRLhXKl6PurAkyzaBB75C/33RW5FgpK9gFSDLErYMJwFI2LXtrXSb+z4PhElVZBZBU00Iu2CtknU4fxgfvufDAIA/POcPcc7IOeGO+SREn2T10XP4laza+HYgPMniVsGzhs9qPLgX2YRV0b1BCHSCAzTukcVJVnrtABRVhusQSEX6GkKAPE8/84VfrE2uFb2y7HJ3qU9BKFgFMbFpZeMSSlZuf8NtioaNL/56H77z0BHcu6+7uqbVBCVZvavJAoBsbGVIVm3oBUDtgu9Uvou3KT+oIlwr0ZCY1/o4UTopamQXPFIxYYFABpCbK2GuRPtkdWMXBLwo99I994rY/WY1WbIsIc5j3E+ChEFiGnCU6uAL3ifLNl3ISfpdOPnOJ8ucZMnQRE1W28mCoh7rjKrHeUNizy5IJ/2FRS8xk6dF0heM0Bkkcb2xtw1wkrXMGhKfyErWZGESX3/y6wCA54w+p+X2XMlKsTo9qmRVk6xsXMNed1zEuPdKybLM5koWtwum5fp0QYMRYVVe/euVJ3a6NjCeGIeh0XmAZtswWLIMj9D3h16cH7IeC6hOF+yUZFku/Z7j8ClZWg8j3MtlIM4+U1iS9eSt9BpNjgHbX4GkRn9Tfq1zy+Dd6sW0/tzIifqtpmB2QUNJeMEXvkbEtmvjPb98D4pWEeeNnoe3nvXWcMd7kqJPsvroORyuZCVTTYMvSAuSJZoQDzdoQgz46rHW0AbCDC2TBRnJ0tdNiFCA8oKBCFO9RPgFJ1nTj2MkOgyTDfJLy73vd8STBVN6SqR+NYJfyWpU2+KPR77tsc4K1Y8FZgvVwRe9UbLojbTXNVlceeSpaQBg5Obw59q38B71P5DPeSuDK2kXtNnKcyQWvKhwcKGMJZmeJ4ePzMImNmRJxnCseQPJVtC3bYO6dhzEMFC6914AzWuyAH+M+4mfMFgV4V5jFwQAN5mlf3cRfMFJlgSt45osg8W3R04/vepxbhcUShazN5aX6TVXZRUEAFn2LIMdxLhzu+B8ZQoAwXzBgO2ceLZRQgg+ePcHUbJLOHfkXLxq66tavma5TMe0ZJWSVV03FNMUHJTWirjt7oMvwilZBiNZKSmgJouRLE1e/d+JX1O25WJDeoOw66uOjQJbSOVK1kh0AgcXSpAk4LwN2dDv4SlZndsFLZdeo3FmF5R7ZBfkEe7EskAYAQwd484J0/lvBBRNqNacuHOS9cxsCbjsBrrt3f8CmC0WkBnJKktxDBr1Stbndn4OD88+jKSWxM3Pvxmq3Dx05WRHn2T10XO4TMly4gkssAjrCb+SlQgXfPH43OMAQiYL1sa3N0kWBGh8OwBoExPIrqHHQ8Mv6Cguwi9GTgMgAeUFKOVFgKX9LC71nrS0UyezMb2R2id86VZ1+/M1+vzxY1OeBfI4R61dsBdKlpcuuDI1WX5FyC1QlUiWCOT8EfG4P8a9V+CNbm12A21kF9w/XxQka3KSHt9QdKjrG6AkSULN4lHuKY1OHBuRLBF+cVLYBb2aLK5kKaoMmbUMIAk6aeumJstPsjpRsojjoLJ7N33Z6TVKFjtvRIQ7swuay0sAAkgWAKSYfTDffvgFt31XnApktQiXeG0OTiR8b8/38Oujv4Yu6/jg8z7YuL2ID3yBJ8FqhVTJqJuIS5KE2ci6nihZRasIW6HfrR1SyQrqk2Ww30c7BnNlbsG1TQcbUhtEuq/qOOIezZUs16ANi09bkxJJwWEw5Au+4EpWu8EXFmEkiytZSq+ULG8frsqu+TBK1tRjwMG7qep8/hsB1FuDPZJVAHb8DpDdAJTmgIe+1nzfjGRVDBUaC2hRGMl6eOZh/Osj/woAeO9z31vdY+9Zij7J6qPn4BOKZYWuwqR9PbKAcHbBZWNZWOF2DDULvWAF2A1Ilt5AyTKP0slvLcmq65WlxYA4HbxRnBGD3lK+t01lgfChFwBNq+MToEZ1WdM+JWsmb+ChQ90HSKw0XJdgrlAdfOEWCnDN7iZivCar10pWrV2QEALXt9IYKXlkfCUaErvMhmYr9LysbUTMcWC+hCWFTrTmp/NVx9wtRJT7HXeAENJSyeJ2wcLJYBf0pQvyVXdJkoSa5TCS5XZhF+TBFxLROqrJMvftA6lUIMfj0DdV93KKq9VKlqghY8pb4CSpi/ALXdHFYsNgmr7nzAlmGZwpzeAj930EAPDH5/4xtmS2hHodH3tiMlM8JaPOLggAS7FNHskKCI8JC79dMGxNVnCfLHrcenje0jPwa8rhSha91KDYLgrsHs3DRxaX6bV2wabw9VgAMJTwSFZa70zJsgmzCxI2BigAehD0wCPcAYAobZAsrmKd/grRQLyRXXDPTAFEVoDnvYu+5tefovVcjcDUq0qeLtqVY0nIuo6CWcCNv7wRDnHw8i0vxyu2vCLUZzzZ0SdZffQcvMh7XqKD1/rB6gLQMCTr8XmqYq1LrkO22YSiwFSBVG0jYjqB0wLi291KBc4sXc3X100gO8pI1kxAryzAI1mleagxum0+N9f4mDpE2NALjlYx7n4lCwB+tLOzRLDVxHLZguWQqposAHAWulOzViv4omDYiLvexChleAriStoFLbagEQ2oySKEYP9cEYtMySrMmlXH0y0Sz70YkqbBOnIE5qN3I/34rQCAvBE8QeR2wdLJYBf098nyNYHmJMuN8XTBznujVVhRPYjakZLF67Ei27dDkqtv+ULJYumCotlsgf4/kGR1GeM+kaL7TKfo+XEihV8QQnDTb25C3szjzKEz8Qdn/kHo1/Jk0yj7DRSYdXZBAKgk1yHOLo18FwsyJbvk2QVbJHnydME46vtkea6Q1Z8u8gh323KrlCwJQC5fhEtcHM5TV8r+KbrQdMHG8PVYADDASJZLAIXQz92ukuUwJSsGqmD3qiZLkiRIPMZdYb9JucW9sLIMPPqf9N8Xvk08zK91wzFgORY2DSWgyBIKhk1rI8/9fSAxSvuC7vxW4/3zmqwCPadKKUpqb773ZhwpHMHaxFq89+L3tvtRT1r0SVYfPQdXsmYJHbz8oRdASJIVxioINLQLmk3sgtZRqi7IiQTkTKZGyeIx7r5Vdl5wWppHJE5visV874Mk2u1dtDndPMZ9lilZG4fo57vtsanjvjcRjz/PSNUqhz3fXV1WNtb7mixCSF2E+1zBxAA8cjGGeUHsRLPiyhwctzcEwykykgX6+fSAmqyFoom8YYuEQWOR/t1NfLsfcjyO+EUXAQAKn3gr0k/+AECTmqyTKfjCMH3pgt7tlCcMOjpPF+xeySKu6ilZbdRkVR5nyYI19VhAfU0WtwuqjBBwQlQFYRd89jUkvm3/bfjFoV9AlVV86Hkfastuy9MFo6x2uJGSlYrHYbrM2tVBuAhH0SqGVrK4XTBOGMny1WSZRuN+kysNni5oWy42pjeK4CkAKC4XMVuaRcWpQJEUPHWEHt/5bSQLAoCmyGIRzrZYfbZdFv3pWoEQAgdcyfLZBfXexN2LGHeZKWOtlKxHvgFYRRpmseky8bA/Qr1oFaGrMjayBfBnZgqAFgUufSfd4FefABrdo3iEe46ez5XMIH6878e4dc+tkCUZNz//ZtHGo48+yepjBeDm6EV41KYDjj/0AgCkECSLh1407Y8FVAdf+MCDL/TAHlmeVVCSJAwwklVYNJBhg3ojJSvK7D+l4lLz4+oAIkQhLMliCYP7cg3sgkzJ+p3nrENcV3BkqYxHD7e3Qrfa4MQwLVUP8N0qWZl472uycmZO1Mtw6918wUCWhxMAGMc85lmvrMHoIBRJgUtczFe6D/MAvMm7xaKDI4n6idD+eXqd6RnmtclpkIjUMyULAJLnbgUAFPZVkGJBBi2DL46zmqxD+UO47vbr8PDMw6FfUx3h7lOy2LjjRNgqdA9qsojbWU2WlyxYT7Jqa7IUZhfU2SLTRGIFSFaCkixZp5PFE0XJWqgs4OZ7bgYAvP3st+PUgVNDv9awHZQY0dGZ2hEU4Q4AAwkNBScLACi0Ui2aoErJalGTxZWsGGH3ZL9d0KSLMkELOCsNYRc0HUykJuAqkuirXMoVRT3WUGQMliNjNBWpW9QNA94rq1TRoEr0c4a1DFquBYB+RzG2hinL6EmEO+CFX7gy218zkkWIZxW88K1VYWCqrCLKHA+81m8rr8uaYePTBW+mY8v808CuHwS/B29GzOYX5XQcN919EwDgbWe9Dc9Z0zpp89mEPsnqo+fgStYhi5OsBkpWsXEzYh7f3pJkNQq+EOmC9TcGP8kCgGhSE5PTAZdeEvlAJWsB8VQWAFApdm7/aYR2G8TyhMFGShZPF9wwGMeLttMJ9Y+O85TBWaZkpUj1BLxru2Cs9zVZ/PfKRrIi5nquYCAjearFuDSPOdYrS5EVDMWGql7bLYRd0GH9ZALsggfm6XU2PBqHrEiQXBkJM1vVQLkr7P81kkf/HwCgNBtB2qAzjZyRC1RORfDFcaZkffbRz+IXh3+Bf330X0O/hhgGHJ4uqHoLOrwW1GU1TzygpBNwJctxFS9dMGRNFiGkYXw74CuGt3lNFp1cx0xAdoGxxFjda3iNRyfpgoBnQXTkE6sh8c333IxFYxGnDpyKt+5oL5aaq9mSBCisv1hQM2KAJqEuO3ScKDRYqAiD9mqy6PNRl5Esv13QphP1CAuIWE2oPrtgRIlgTMugwg6jnC+IZMEI6P3tgk0DHfXyGmYJg4slS9SUhrUMCjsvgBhhdkGF9IxkCSVLon+j1IRk7bsTmHuK/n5nX1v3dNPwC4CS64veQf/9y49R0lYLRrIIWxzZE3sGeSuPs4fPxjvOeUdbn+3ZgD7J6qOnIK4rVm33V4KVLDlBL3S3VAqchE0XpzFbnoUiKdg+uL35G3KSlaq1C7KarEAly0sW5OBqVspiE8RKkJK1gGSS/tsqFXpuveMR7mFJFleyDhcOi4lY1f7YStNoOoKrd9DJ0vFuGeRKVgK1dsEulayYlxrZq8joRj2yBuBNqNdK88ICCfQ+YZCTLJNNhIJWm7mStWkkgfQwXfBIV4Z7Yxd86ifA134bemQZ2oAKuICWo0qFTWzR982PuGj6ffzUZFmOhdsP3g4AeHD6QdhuOALor8ni9SOAt7hjs5XjbpQsPolznfZrsqwjR6izQNMQ2bq17vn6ZsTe5HqjOgpNCUg7EEpWZzWe3C5YJrSudfYEULJuP3A7btt/GxRJwYee96Hg76UJltniTiamwanw5tIGEGCrGohrmHfpmFKwO+/HWLJKsJWwSpYLCS4iLrcLesdlsYXHSCIS9NIVheKLcAeADbFhmGyIq+Q9Jcso04XQ89usx+LgStZ80Wi7Vxa3FRIiI0LocdKarB4pWaxXlkvY999Mybrvc/Tvs68Foum6p5N6TfjFCFeyfItAF/8hPfbJR4A9t9e/ByNZco6+5nBsHnE1jr9//t9Dk49BOspxjj7J6qOncItFsfrxTIn+Xa9ksdU71wUx6lcxuYq1NbtV1AwEv5nrBV80inAPSBesVbIAiPCLeIWRrAZ2wVSa9hVSTLthdHonMB1T7C/s5Hc4NoykloRLXBzKH6p7nitZo6koXnTaKCKqjAPzJTwx2XsVrlfgJCvOItxV1uTQ6bJXlj/dsqrergvMlL2GrRxzBQNZqZpkzftSHnsdfuEUC3AlBbbDVpsD0gX3z9Eb6qahBDIj9FrMVIa7twvu/DbwjdcDdgU49SokX/Y6AIA5OwCVjQFBlsEkW/goHUd2wbuO3oU8S3Ir2SXsWtgV6nX+mixV9dVkcbugQidvThd9skRNlg1EJTYuhazJqjxB67Eip2yDpNcrETxdkNsFJV2HG6GfZ5PUQOnkJMtYBszGboRG4EpWzp4BQI57JWvZWMZNv6F2qDfteBPOHGrSt7EBeD1WNqbB5iRLcQCl/nrNxnVMO/Q7LridK+/ULsiULKu1khWH73fwKVm2S89lPd0b0tAOeE2WY7kghGBDfAwVNpQbhZJQsmYXKCm8oM16LI5uGhIbNvveXBU6Uymb1WQtTBZx9y17UCmG+23lKLMctyJZy0eAXT+i/77obYGb8Ou9rlfWjO86TgyJ2Hf88hPVO3BsgI0VyNN78mIK+OuL/xrr0+tDfZ5nG/okq4+egtdjQdcxy8aeOpLFVmaA4LosXo/VMvSivAjwm1CiesIoarICSJbJSdY6j2RlmJKllenrgpWseWiMIEYsYLLQO+sdn3Trsi4aIraCJElVTYn9KJteH5HRdASJiIrfOpVOmm577PhNGeQkK+Ky3izr1gHoXslSFRkpZlPrVcJgsJJlIOtTsmKSieKSR6h6TbLcfAG2r3F1kJLF7YIbhxJIDNPJRKYy0l2E+31fAP7rrYBrA2e9Drj2a0i+8HIAQHFvCWmHXUcBJCse4UrW8UOybtt/W9X/75u6L9TrGtZksd/BAn2um+ALXpOl2PT7IpACFZAgNLMKAvVKFgDYLCRmvdRAFYimvUl4B5bBscQYJEiwXAOSUjzua7I+ct9HMF+Zx+bMZvzhOX/Y0T64TTkT12FX6NimNihxGojrOGzTe1MBpHmcdhP47YJWiD5ZIr5dkkUyHiEENjuHI5nu0/LahepThx3LxcbkhAi/MIoloWQVi1nENAVnrK1Xb8JgKEDJCmsXLDtU/SNEh8Z72jWpybrvh/vw4G0H8ORd4a4dYRdkdbcNSdYDXwaIA2y8DBitr78E6pUsXpM1VzCE2goAuOSdgKwBB34FHPyN9zgLvShJEjRWD58ZDdeM+9mKPsnqo6cQTTcT9OLNxjXR4JdDUhQvljSAZD0232Y9VmwQUKtXaZumCx6h0cN6gF0QeTqRyZX9NVkeyZIidMDTbeBosbMI4yD4Qy/a8ZRzyyDvKcbBJy4xTRHk4mVn0dXRH+08fuuyeE2WbjGSxX4ju0slC/CFX5R6E37BfzN/bdN8waxSsgDAWfY1JO41ySoUYLPVST2miia4fgi74HAccoae11ljFGm9gwkJIdSr/8MbABBaXP2azwKKhvhFF0KKRmEvFnHqDFWy8gF9fo63CPeKXcHPD/4cAPDSjS8FANw/fX+o1xLTI1n+CaFQskA/q1sogLid2VT5Srlq00mQpaVZZX2I1z7BSFZAsiAQTLIqUbrvtVK28Y5Fr6z2xxJd0QXBl7RFzOYNOMdpo/Q7D9+JW/fcCgkSPnTph0TtZbtYZGNONqbBMphK38BZlY1rmHPoOGHIEqz5pzt6z6Jd9AVfOE1t4hXLRVLi8e0pEZhgmy6IRM+H6EB9SMdKw98WwbZcrE+tF0qWVSgIB4drDuOc9RloSmdT2qEk/V3nC6ZoGdORksWsg81qshYn6Xi8cDTcwouYK7G6W9hlwKqxYdsmJVkAcOFbGu6r9npPRlSMZ+ic5plZ31idmQDOfT399y8/7j3OrIL/d2gY2SIdv5+3/R0d1cE9W9AnWX30FLz2wGKKT6OkHy/8oppkucQV8e2tSRZTZFL1xdmiT1akernQrVTgzNFagCq7ICNZzrIJECBvBNdkcRVOt4Cjhd6RLBF6EbJHFkejXlnCKpiOiAHw8tNHoSkS9swW8fR05/allQRXsjSL/T1B6zeche6tmaIhcY+VLL+9069kuRK9Kcq5w+J50ZC43H1DYuK6cItFWIxkRQJUrKWSKZS7DYNxWAl6bIPGmvZvjIQAP30fcPuH6P+f/+fAyz4qJvxyJILEc58LAHjOU8wuWKhXTbld8HhJF/zVkV+hZJcwnhjHm896M4DwdVmuP8LdZxfkNmVezwJCmgb9NANXsjS28OC0EY/M7YLR04OVLG7HLtkluKyepMR4xKjbZFLdZcIgtwwq+iJcApHAeTwhb+bxobvpuf77Z/w+zh09t+N9cZVgIK7BFiSrfgGQbwPXc3sUZp7o6D39ShYI4NiNSX7Fr2T549vZYqNEHOiZ1SdZsiJDYgtHjuViY2YTTI3+v1KaR9kuQ4IMYmXb7o/lh7ALFk3hJAldk+Xwmiwdmllhxy3VLfzSbQiWZ+mcZ3EqXL2dULJsAHIDNevJW4HiDJAcA05/ZcN91TYkBvyWwRrS97w/o5Lc0/8NTFF3EYw8fhqP4SdKFBpbI0uNbQr1OZ6t6JOsPnoKrmQZEXrzXpcNXs3xemVVTzwO5A6gYBUQVaLYmq0v1K6CqMeqry1pZBe0jlJiJCeTkNPeSn5mJAZIgGu4iJNaJcvrk8XjVCM26SnJ4qEX7dbJiBj3GpLFQy/WpLybdTqq4fmn0BXk47UxMQ+JUExOslgSWZd9sgCvV9ZyjxIGRY+seK2SRc/pYpL+NpGiNxHl2/ZCyeKTdptNlJvFt69JRxDXVRQT1AKTKA+2F4DiOsD3/xS469P0/y/9/4AX/21VRDAApK54MQDgsntlnHHARW62foLoBV8cHySLWwWv3HQltg9sR0pLoWAVsHthd8vXEsOAqzTuk2VZADRuGexsYYOTLK7uOiHtxPbcHOzZWUCSED0tOG6c12gAXgF/TqO/y5DTxB7WbUNiRrKSSWo/mjkO67I+/sDHMV2axvrUelx33nVd7Yu3jsjGdTgs6c+vfPqRjesAZOguvbYK8+HqA2tRtstwZG+saxZ+UbEcn5LlI1nMcq7YFRHvv9pQRfiFg3WZrTA0wo6NqliSMwhAxfmbOqvHAnzBFwVf8EVlKdRrRT8tV4PCFCZJC/aClnKm+B0Wp4KDv2ohgi8qFSDGPmMtybrvC/Tv898INAll4UoWr8kCgK1B4RcAMLQVOOMa+u9ffQKEEOyefxIfGB7EAJu2LetxxBOrX6t3IqFPsvroKRxWk1Vgnu6WSlaNXZCHXpw+dHrrpBqebpWsV38a2QWtw16yoH8lX9UVpAboYDbgysE1WVYRMlut1q2VsQuOxQMik5vAH+PuH7D5pGUkXW1v4SmDPz4Oo9xtx8V8ka28GvTGpfOarIWFrlMRe20XDGoevVAoiYaxxjAtkI9XPELLVa+ekCyWLGizleeg0Atej7VpiN5cF7VpuHChOCpKuZDfg20C334z8OC/0ZXNV/0TcGnwpDPzmtcg9ZKXQHWAv/gvF9Zjj9RtkzyO7IIlq4Q7D98JALhq81VQZEX0eQljGXR9NVl+ZUIoWYYjEvucDuuyePBFhPfLCkmyeD2WvnmzSHStRUyNQWZ2sKJVhEtcLKr0fQbsJpHdwi7YXcJgNEpJ//FWl/Wbyd/g2099GwDwwUs/iJjahHCGwJIvXdBiSXlqJHgizttNqC5bjFjY09F7Fq0iXNmFxF1mTUhWuYGSZbDjVp0KlNSxaTArYtxNF5FYFqyNFYh9AABglgchScBzNnROsoaZXXCh2EHwBb8uiQaFOTAkLXjusjzj2fzMsh1qDBbBF5WyR7JKvhrl6ceBg3cBkgKc/wdN9yVIlumNRY2UrNnSLP7ntN/CpwcyeMfcL3HZf1yK197/IeQUBefm6G+yEM0gpgcrsn1Q9ElWHz2Fm6OrtcvMu75+sJWSVU2yeOhFqASnBsmCAGDxCPeaPllByYIc2TV0MBtwJOQrtjepj6SFTC9JdFDU7ZUJvmhXydqQ3gBZkpG38lUNbqfz9UoWALzkjDVQZQm7pvLYN9eZfWmlsFA0QQgggwAVevz8dyKVCkiT5tVhIHpl9cAu6LgO5srUdsprsgzbgVzxiqWlMXoOZ0yPUHElK2fmvBXQDsFJlpOgN95IrP7Gvm+ummTNGNMoROgN2n/DbwizCPzH7wFP3EILoV/7JeA5/7vh5pKiYO0/fARzG2NIGMC2f31YqMcccXZTPh6UrDsO34GyXcb61HqcMUgtdReOXQggXPgFj5YGqutHdDaBtiq26D3ldpgwyO1IMX6+hE0WfJxbBYPrsQAansPVrKJVxFx5DoUIHfcSRhM7aYopWfnulCyFNyQ+jpSsklXCB+76AADg2tOuFedDNxDpgnFNkB21weRUVWSkoirg0HtoYflgR+/JEyOFEtSkVxa1C9YrWZUlFu1vVyAnj42SVRXjrsWhKywm3aUE3zWHcOpoqipBtl1wJWuxZCGltdcnS7SpcDUozC4o6cEEmlsFORYnW9+D5Sg9D0jFCFay7mWx7ae/wlOYG4DbBUu+1gDbRpOAXMGTSw/i8zs/j+v/53pc8a0rcPm3LsefPvQxfC6bwV2xKHJWAbqk4KJyBW8t0DFtIZoS43kfweiTrD56CidPlawF0IGhlZJVO3Hm9VgtkwUBryYriGQ1sgs2JVl0IjroSnBcghK/KUkSDdcAILPVvsgKKVntkqyIEsHaBB1Y/ZbB2ZxXk+VHNq7jkq1UmTve1CxeRzYWk0UbAGVwSBT+2t02JBZKVvcka9FYhEMcyJIsGgz7Qy9IJI3YyBYAwDCZE80+U1pKrIp3q2ZxZcSJ0UlBsJJFr6+Nw3HxnstRSg6XZ1uQrPIS8NXX0F4pWhz4X98Ezrym5XHJ0Sge/ZPn4tAwEMk7OPi2t8NZWhLPCyXrOKjJum0ftQpetekqoWxfMHYBAFqX5bjN1TbHR7Kq0gXZuGNWHKEAOB3aBbmSxUmWFLIRsZcs2JhkAV5dVtEu4mjhqKjJIs1qyHqkZNkyvaaPpxj3Tz/0aRwpHMF4YhzXn399T/bJLcrZuAab9WJUI41DNAbiOmyXxW3njjTcrhEs14LJEloV3bPbNQINvuBKlqdYGYxkqU4FUpPjXUl4Me4OICuIKvT705mC5JpDeE6H0e0cA3FdOJ9lQolIWCWrZPGaLBUSV7IC2iUA9QtbYeqypColi5UucJJVWQYe/U/67wtbN8jmStaB3AF8/cmv472/ei9ueviNSJ32ARQH/xmfevBT+NnBn2G6NA0JErZlt+Gasefhb+cW8I3JWfxm4rfxhakZpCssKCSa7pOsFuiTrD56Cq5kzRA6oa1tRMzBSZbju5FbjoUnF+jEIBzJYpPUmuAL1yVitbDWLsjj2/V1jZWsIVasHmQZlFizxohFC6P9sns36DT4Agiuy+JK1miq/sZ49Q5atP7j46wuiycLTvgOWY5FoQ7QG6jTDsnKTwNP3AoU58RDoiarB0oW/72GokNQmcrpD72QYgOIDW8AAExIc1hgNkhJkoTy1S3JcovMLsiaTupBPbJq7IKzpVnkBMlqcoMvzABffgVw6B7a+Pb/fA/Y9uLQxxZfexr+7loFxQSBuWcPDv3xn9CaAnjpgsVjbBcsmAX86sivANB6LI7tA9uR1JLIW3nsXmxcl0VsGy6/hUqs2J1B2AUrjqdkdWgX5HakBFO05Hg21Otaxbdz8IlXySrhcOEwShH6OZoer6jJ6jD4IkHH3wqZA0COG7vgg9MP4utPfh0A8IFLPiC+m24harJiOmzWOFyNNrZjZuMaDIdO9gtWjk6m2wBXsQBAY6pKq5qsICXLXKbjhwb7mCXI+e2CAJBg11mEOe1ca7jj/lgciixhME5/D+LQuUlYkpU32Xft6pDMFiSLLWypbF4SSsliNVmkHFCT9cg3AKsIjGwHNj2/5b74+fzA9AO4+d6bceueW3Ewv58evjmAi0dfhHef/2588cov4u7/dTe+++rv4qYrP4PfHTwHZ1bK0Jhqxk+vhWgasQYBLn1Q9ElWHz0FX61dkOggM9FIyWI1An4l66nFp2C5FjKRDNal1rV+M1GTFdwjC6hvRszj24OVLDq4DhFGsgJi3GXQ49XZU71Qs1ziBibVhUVQjDu336xJR+u2f+mZayBLwM4jyzi00J0Fr5fgyYJjUXoTlXQdkqJAGaLffcteWeUl4MGvAv/2auDj24H//N/AT/5WPM3tJL2oyQrqkVUV3x4fhJSh5/AaLGI+561g9irGXdgFdXotRZspWUP03J4uTbdWspYOAl+8EpjeSfvPvfFHwPqL2jq2dHoC82kJt15jQ07EUX7wQRz58z8HcRwk2KTPdFyYTRLPVhr/c+h/YLomNmc249QBLxjCX5fVzDJIquqx5KpJKLcLmoYtAgO4yt8uOMkaIPT3UkKQLCefh3WQ2sya2QUBIKF6sc5+JaupvdGfLthBND3vleXAhKQUjgslq2JX8P673g8Cgtdsew0unbi0Z/teLPI+WZogWVqssTKUjeuwXfq75CUZmG+vLotb2DRZg8aUhpZ2Qam+JqvCApRU+dipzqrfLgggxSb1EXZIrjmEC7oIveDglkHLpHOWvJlvqWQDnpIFokJi4TRyA9WPj7kbTqeK1EIoJSso+GKBuj3u+zz9/4VvrQshCsJzRp+DlJbCQGQAl01chj8654/wzy/+Z2wt/QOKe/4Krxz/K7xxxxtx4diF1QsMz7+B/s36ZNlFqiYuRNP9mqwW6JOsPnoKl00kiloMA3FNWINqEVSTxUMvdgztCLdqJmqyqpUsi4VeyLJUFasMtLALjtJjStsSJFKrZNFBUXLoxFa3ARDSk7qshcoCbGJDgiSsZ+0gKMZdRLgHKFnDyQgu2kw/z/HUmJiTrFGWHsVtguogPVYnqFeWWQIe+w7wjTcAHz0FuPWdwN5fACyOGr4eM5keRrjPlFkNXcwj+LP+RsSxASA1BgcyNMlBbt6z/HBi1m2MO1/QsNjNUK+pSVguW0JB2ziUACGEKVn0fQNrsgqzwBevBhb2AtkNwJtvA8ZatFIIQIr14DowKmHdu14OSdNQ+NntmLrpJsR8qWrH0jL4430/BgBcvenquvHmgjXUMtgs/MI1TbhMxfRbBYEaJSvZuZJFCBEkK8usylqidVQ1V7HUteNQstmm2/p75/hJVtOgDm7Rdi064WsTmqKJxQbaK+vYK1n/8si/YH9uP0ZiI/jzC/+8p/vm6vlAXIft0HNFjTazC2ogLn2+KMvA/DNtvR+P6I5rcVH71Sr4IsmDL/xKFovW15Rj18dMYaSK2x2zOmuObAKESBjUx7ChQe13O+Ax7hWTKUcggc3Ua1FgSpaMCIjBlaz6xU1CCJZnWM/Cs+l9fmkqTE2Wzy4Y9ylZ++4E5p6iv9fZ17bcDwCsT6/Hr17/K9xx7R34f1f8P/zxuX+MF6x7AbaPUmW6LmGQY+uLgfFzxH+tPD2fFyJpkRbbRzD6JKuPnsJhdsGCFquyClaKFnLz3qROTtT3yeKhFy37YwG0GR8vTK1TsnjohVI1eXJLJREFHkSykoNRKKoMBUDalZDzT8a5kuXQzycTQHV6o2Txeqzh2HDrRMUAbE4zJWt5PwC6Kslv6qMBShbga0x8HNVlcZI1otMbusxIVp2S5VjAUz8BvvN2Sqy+/SZg1w8Ax6S2icv/BrjmM3TbkkfMePBFLyLcuQrVKL4dsQFAVrCoDAMAjPlDYjuuVvLfvVO4BRbhrrC2AjVKFk8WHElFkIyoWDKWYLpmlZJVldjousAtfwTkDgODW4E3/zeN8e0A6QglWTlZRiKzgLX/8A+AJGHpG99E7nOfhc4WP45V+MWysYy7j94NALhy85V1z/OwgwemH2i4mk2VLDoxU2sWc3gtqOsQkGTnwReW652rQ8yqLIcIvjBCWgUBX02WVWR2Qfp408h5VQcS7NzvMsZd1haPuZL12Nxj+MrjXwEAvO+S93XWqLsBLMcV53kmqsJmTWXVeGNiMBDXAYde1/kOSBa3CybUBDS2qGE1VbJczy7oTxdkizSaeuxIlhfcQUniAFOJIjZArAFcuHGkJ1bGoQTd71LRRkqj1+yi0bo/I1eyFEkHYUoWV5/8qBQsmnosARt30PtCcdmEUW4+Bja0C97HAi/OvhaIhj9fZUmu+74a9srikCTgshvEf212veaSWShyvxFxM/RJVh89Bb8xF7Uo1g96VsHvfuxBfP0D96DCbBNNlawwJKvAJqhqlNaM+NAwvp33yEqloKTrByVZlpAZpcc86NKEQQFOsmzPGx+xepMw2GmPLA6uZB0pHIHhGIKsRFQZ6WjwKtOVZ1L176GDS5hcDpEytwrgPbKGFKZEshuVOsSUrP07gR9cD3z0VODrrwMe/SZgFoDMBuCy64E//DXwx78BXvAXwAS1e/mjbrPx3tVkBdkF5woGshKbmLIC5ZxOCZWz6CWEiYbEpe6ULG4XtGQ26aghWbxH1qYhL/QCAJQ0/X7Nsg2j6DvH7/4n4Jmf0mvq2q+2TKoKwsJkEd+6+T6Ye+h3nZNlYPIRpK+6Emve+14AwOynPo2XH6Y2vFKTid9K4vaDt8MmNk4dOBVbMlvqnt8+uB0JLYG8mcfTS08H7IGTLKZk1Vhm/KmmboyOT50EX3AVCwCGwAl8tuXrKk8wktXCKgj4GhJbpWolqxUpFOEX3TUklvVFzBUMuO6xmcibjom//fXfwiUuXr7l5Xjh+hf2dP/+8SapqyBs2qXGGpOsbFwDYQ2Ji7IEzAWfg43A0+PiWtxTghooWYQQVGzHC77wNbvmzYh1/dhNpDnJ4iEzEabs6FbvrIKAp2Qt+BoSh0kYLLPeWKqkwzXpby1F6knWEnMOJLMRxNM64hmWaNhCzfKCL3wka/oJYNeP6L9DBF60wtZWJAugTY6HTgEhgMPs7+VUtuv3PtnRJ1l99BR8IuFXslzHxcLRIhzLRX6eF29Xk6yiVcTe5b0AQpKsPCNZydE6LzKvyWonvp2D12UNuFJw8IWxCCj0pqXbvVGyROhFB/VYAA1fSOkpEBAcyB3wGhGnow1X+Nako6JY+HixDHJyOMAjemMx4OjDUGbvAQDYD94K3P9Fak9KjAAXvR14y0+BP3sUuOID1NbGPy/vbVZZAhw6Ucj67ILd9twK+s3mCway8ClZAMoxNhHN1dsFexV8YYHerCPxahX0AItv38jj23lYR2oQiSxbteXhF4fvB27/IP33VTcDa0K0UAjAwz87iJkDecw+SK+dnCwDM08CtoHB338Dht72NgDAW+75Ji6ceuKYKVn+VMEgqLKK80bPA9C4Lss1DDi+miw/ZFkSBftuvHO7ICdZEiQMsnrQ2kWlIFSe4PHtrZUsXpOVt/KYLE6GC74AfDHunZEsnjAoa4uwXYKFHvWvaxefffSzeGbpGQxGB3HjhTf2fP88zTQdVUF8NYhqg95lAFXduV2wEyVL2AXVuFCyGtVkGbYLQhCoZHkLlsduquilI/ruCwCiFoFrDuH8LkMvOHhN1lzBbKshcdlmlkopAsJJVrS+Fp0HDfGF3IEx1rtwsnldlqdk+dIFF/YAxAE2Pg9Y0/oab4VtrCHx/vkibKeBrVRWgNd9Ge45bwdsel4Y6d589ycz+iSrj57CzXk1WTy+vVzwyAqXxqUakvXE/BMgIBhPjGM4Ntz6jbiSVVOPBfh6ZDVIFgxDsgYdOdAuiNK8UFj0HilZnfbI4pAkqcoy2Kwey4+rRGPi44RkMSUrKzElK78P+OxvQZ2kzWIdUwfOfQPw+98BbtgFvOwfaCBDEJGMZgGwx1kSEw++cFzS9eSe11PxpECA3ZwlX00WACtBbZl60TtPetWQmNfMWKxpaVglazQ+iswIvTaXZ8o0MOTbbwJcGzjjGuD8N3V0PK7jYt8j1Ipo5iiJrcgyTNeiRAvAyA3XI/PqV0MhLv76vq/C2PloR+/VDebL87hnihL3RiQLaN0viximCL6orf0EvEUeN8oi3DuwC3KSpck6MhInWdmmr3ErFRh76YJVq/h2wKvJ2r+8H7Zrw+RWx1bKW5qFX3SaMMiULD26BABicWg1MVmYxBd2fgEA8N6L34tsyHj8drDMkwXjulCTJDiQo41J1kBCB2F2wYLMgi/aWBjyK1miJssKnjwb7HERfOGrybIMph7Fjl3dTVWEOzwbuW4BsrkBZ64N15y7FYZYQ+L5goEMW8gIkzDI+x1qcgTEYvObaL1KyWtgM6z2e3CM/t1ayQoIvuDogYoFABPZGGKaAsshONAsDGtsB6wddKFsWY9DiwWXI/ThoU+y+ugZCCE1ShYjWXkfySoF2wXbqscCfCSrnpjw1bdGPbKC4ts5ePjFoCshF2AXRGlerKRFbGrR6xa8NqeT+HYOf/gFn6zU9siqxdWsLuu+/QvHRYQyV7LSnGTZSwAA5dSLAQB2+gzgmn+hUeJKi5u+onq2KlaXFdUURJni0G2vrCBi7I9w50EphCUMxsoekfVHuHejqLmFAggkWKyQvlFNllCyyj6SNcpJVgn4/rtoomB2A/CqT4dKqQrC5DPLqLAFlfKyBYmRXG4ZBOiCwPj/dxOe2rgDUcdC6oN/BWPfvob7XAn87MDP4BIXZw6difXp9Q234+EXD0w/AJfUT1CJ6UsX1OtvpTpb5HGYHa8bJUuVdaRDKlnG008DjgNlcBDqmtZjCrcLcltkcpC+xi2VQJwmdk5/wmAH4EqWoi8B8MJ6VhMPzTwEm9g4c+hMvHTTS1fkPZZ8PbJ4XZQqmZB8/ahqkY3rgLALyjSmu43vmddkxdW4LwI9+LcsM/Iigi/8ShYbJmtDdVYTtTVZfO4wVIpgR/ZyUd/ZLYYTnl1wIELJTCi7oJ9k2ZwI1hNonizIF7gGxpmS1SJhkJNKUkuykmuA7a9oeXxhIMsStozQ42lqGQRgz9IFxoV+j6xQ6JOsPnoGt1gScb5Fn12wnPdsIEaJEpdaktVWPRbgkaxUgJJlNKjJahLfziHsgk5t8AUb3EoLIp41YgHzlfmquolOIEhWh3ZBoDrG3VOymq8yTWRjOGddBoQAP3m8uxCGblGxHFEDlyTMcqEQID4E9TU3AwCchdZFyFXwEWOOXvTKshwLCxVa61Vdk1WvZKkDdBKfMT2SxYmZ6Zqh0qsawS0U4CgREEZmGilZm4er7YJVStbux4AnbgFkFXjtl0NZ0Rphz8NejVk5byGt0n3lFI9kAYCkafjeNe/EU9l1UHLLOPS2t4sb92rgtv3NrYIcpw+djrgaR87M4enF+poYf4R7sJLFSJbOaio6iHA3uBUJGmSJEfIWv5G/HitMIIC/QSkADA577TN43V8gekSyHHkBAMHMMVCynlp8CgBw5lBn9tgwWGQkKxPTRF2RKhlVZKYWA76arLzGFsvasAwKkhUiXZA3Sg+qybIcev7oyWPTiBjw9cnidsE4PV8jtosLN7afxtsI3C44X/TZBUMoWQbrX6crERD2XQYrWfQ3yY6wOQZXslr0yuJNoN1KRSzeAQDOfyMNoOkRWoZfMNgzPpKl9ZMFW6FPsvroGfgkwpIUmLKKiSxXsjySxQtpZTZQ1pKsUE2IAV+PrHpiwiPc63tktbYLDjCSlSYyCsVgu6DEJPIkoQNct5bBboMvAC9hsB0lC/DUrB8f45RBrmLpqoyIw3qNqARIjkFhEe724mJ7yk8QyeJ1WV0oWXNlaolTZVXcjB2XYKFYE+EOIDpEGxIPOR6J0BVdvK6bhEGnUICl0vNVUWVhqwGAfMUSQSIbAu2C9LHcQVZT+OL3A+vO7/hYiEuw96FqojRC6CQ6J8vAVLUtMJJK4v3PfQsqo+OwDh/GwXe8A06hdZxxt5gpzeCB6QcAVDcgDoIma6IuKyjK3fUFX9TWZAGAzuyCPP2xaSR6A/AFHAX0tzUlHdCaL56IeqwQVkHAI1lcrRvPrhcTu6bH3GVD4rH4GGRJBpEsSEpB9PZbTfBm0/4+ab0G78s3ENd9SpZRZcurxUDcswsWFaYitUOymF0woSV8SlCwklWxOcmqr8kSKnmyd5P5duFFuHMlix6f7hK88dJNPXufKrtgJLxdkJOsiOIpWVKAFVQoWaPVSlZurizi6YPAlSy3UqHnTGY9/fv8N4b4VOHB67L2tCRZ9D6yEOn3yAqDPsnqo2fg8e1FLYqhZAQJ1iOr2i5Yo2QVi5grz2GyOAkJEs4YClnEKXpk1ZMsk9Xb6DU9uqzDhwE0J1nRpAaJFflay76bPp+w2xWhZI0rdPLfbfhFt8EXgGcXpEoWC75ooWQBwNWsLus3exdET6VjAV6PNZKMwC2zqGqFAKk1gmTBtkXNXygEkCzRkLjc+Wf198iSJW4/NOESVEe4A0iNbgQADJJlENs7n3rRkNgtFGAzq1e9VZBOsoYSOtJRreq9RuOjyGTpdsv2GmDbS4BL3tnxcQDAzIE8iksGtIiC5AC9PoYcej7nZRmYekwEkABAIqJiKZrCw9d9CMrgIIwnnsSRP70OxFzZc/An+38CAoJzR87FeHK85fYXjFHLYFBdFjFMuAqdfNb2yQJ8ShZLf2xZ4xQAky04aOxWXZIbW8w4Km3EtwOeXZBjbWIt5FSI2Pku0wVre2XNH4PxhytZpw2etmLvwVXzbFyDXaGfkZKsJsEXcQ3gwRdcwZzrQMlS/UpWA7sgezwR0CfLJqzeM9N9H6pOIdIF2XHKCXpuKo7bsEVJJxhiSlauYiOphSdZpsvSfJUIXBZsIiWqr9NK0RJzn/QwJU3xtA49qoCQBj0LGXgNOCwLxLZpa40//FVH6a/NIJSs2XB2wflYGjGtT7JaoU+y+ugZuJLlr8cCGtgFeZ+sUgmPzz0OANiS2VLdZbwZCk2ULKNeyXKLRTiL1G6mrW0+OEXYJJHkfDVZehJgEyqJDfqjMh2Iu1GyCmZBrDp2o2StT62HIikoWkVM5dlkOoSStXEogTPG03Bcgp8+cewCMESPrFSE9gOBp2TJui4mfaJXVhjwJKYgktWFkhUc325CgYM0Dydg750dHkeFUKtXftbrlSUaEncR4+4WCrBVVh/YgGRtHPImR1Uk66G/AwCU3QyMK/8JkLu7Fex9mO5741lDYhKRtelnzOlxwC5XNYZOsInffHoE6//1XyHF4yjedTeOvvdvQNzGTVO7hbAKbm5uFeTg4Rf3T99fV5dFa7K4klU/2eA1WTazFLrFYvMapwCImixCf5+K0lj9AABi2zB2U3UmTHw74KULckykJqAk6fs0JYY8XbA0B9idqVBrEyxhUF9c9aTJpcqSuCZOGThl5d6H12TFNNgsEVSFCTSpyUpGVMiEXkdF4oAAbSlZRdvfjLjableLiuVCgYMI2H2aHRdxCWywxr/pY0iyau2CSdp+hdhu29dTM2Rimuj5pBJ6TYQiWQ4nWTEQmxJiKVZ9nXISlcjoooxBkqRQdVm8Bhyg6jkyE8Dg5jAfqS1wkrVnptDUMcKVrMVIvyYrDPokq4+ewVOyqhsRV5MsFnyR8OyCO2eplSh0PRbgKVmpJnZBX02W6JGVTgf2yPIjMUxXjpSibwCXJK9XFiNZwzLdTzdKFreLpbRU3YpyO9AVHetStJZi1qCK3ZqQq3wvO+vYpwxya9tIylOyJJWI31dlapazMB+8gyBw/3rZq+XidsFuarIahV5k4LO7sbqZqK5iCjQtMz/tBTz0oiGxUyjAVoOVrP0s9GITC73w15GN7r8H+mNfQkxeAgDkyiEXNhqAEII9D1KyuOXcEaFkpSyq5uWyTDn21WVxlbto2oidtQPrPvVJQFWR+/73MfOxj3V1PI0wWZjEI7OPQIKEl2x8SajXnDF0BmJqDMvGMp5Zqp7k+iPcg5UsZheEFxrgFtuzRAqSxebHFbW5kmXs3QtiGJATCWgbNoR6j9pxZyI5IRY1mtoF44Ni4UnYt9uEvyFxyVxdksWtguuS68Iv7nWAJTbWZOI6bDa2qbIFKI3DJCRJQibKiC4IypLUWU2WGq4mS8S3A0LJsgxHhOBEB5qT+5UEr3cUdsGkd/92y72r45NlSdRlwaXXRJjgC4spWXFZBxg3kWLVcwwvvr36WhsIkTAo6br4HUh55XpabhxKQJElFE0Hk8uNv1ehZEX7dsEw6JOsEwj/ePvT+NtbHsNyl8loKwVuLSnWKFklv12wXG0XhG3jyek2kwVdp6ldkEe4674+WSK+vUmyIAdPGIyWa1bJOMlS6YA3JNEbTzdKVi+SBTk2pTcBAEqEHk+rCHeOq3ZQ29Svn5nrSaPeTsCVrOFkBG7FZxdkEf3KEP3u21KyAmuy6E10qYuePJxkVce3G17oRSRTlX44r1CSVZnzGhLz13aqZBHHASmVYAklq6ZHFidZLPSCR85rsoqB22hT4MwAszrONE+3aoWFo0Usz5ahqDI27hgSJCtu0IlGji+EBJEspl4kn/98jN90E93fF76IpVtu6eqYgvDf+/8bAHD+mvNDq8b+uqxay2BVhHsTu6BtsYkS2rcMigh3trJstiJZzCoYOX07pJDqZC3BWJtYCyXFJvjN7IKS5LMMdkiyUnQ8lrRFFIzVbUzNrYIrWY8FeGNNNqbBLtGxTVNaf9ZsLAnCFMy8LAOL+wE73Ljlj3Bv1SerYjlesqCiizAF0W7FtaFljh3J4iSRR7hL8Qw4myHl7sauWnDLoGPTOUAYJcsi9BpNwBvz5Rq7YG2yIIfXK6sJyZIkoWa5lZULh9FVWTgfmoVfiJqsfrpgKPRJ1gmEL921H1/9zQFMHYMUpjDgSlZBiza2CxYZyfJJ4M9Mthl6UVqgjfgg0aa0NQiyC4r49ib1WBxDTMJPWKiWzZkyIin0sSyhA1JXSlYPQi84eMKgHJmBrsrCGtcK20aTOHVNEpZDcPuTxyZlsMouyCYisk/JUgapKuIsdkeyemIX5D2yapMFRXx7dS+TnE4/g73o2QW7rcniighXsvSaPjb756rtgkJ9s11IZh7YcCky27bR45vrbnV0L0sVXH/GIPSoikSWKqiRMp2Y5eJZuqGfZLGbc9E38cu+5hoM/8mfAACmPnRTz6PduVXw6s1Xt/U6f5S7H/50wcDgC6akm4bjU4baI1miJsulY46th00WDN+g1G8X1GQNI/ERyMmQxysaEnc2Bgq7oLYgCPdqYfcCVbJWsh4LqKnJYsqLGoJkDcZ1gIdf6Al6z1s6EOo9uZKV0BIiOMJqEnwR1CPLZIuVql2GkmpdC7hSEMEd3C4YSVCXA3pPOoZYwIdteiSrVdiSTeg1moQ335AS1UoWX8jioRcc3C640CrGnffKWkElC/DCLxqRLEJIjZLVTxdshT7JOoHAV1nmC6ufwhQGvCarzi4Y1IxYVUWClVnIQZO18CuKPL49PhRouTCD7II8vn1ta5I1to7eUAYcScTbivcDIMv0sQzowNeNktWL0AsOrmTJ+hxGU5FQ8c0cXM360c5jYxn0kyx+45R8SpY6yJWsduyCjdMFe2EX9P9m834lq6ZhZDHGVvtzXk810ZC43CHJYtHaNksCi7awCwr1zSzT4/udzyEzSp9rVnQdBnse8qyCAISSpZZZBLXOxoLJR0WLh1oli2P4j/8I8QsvBCmVcPTdf96zIIyDuYN4fP5xKJKCKzZe0dZrRV3W1P1VEy5/TVaQksWJr1m2w9U4BaDC46HZ92brzSe7IlkwZD0WUG0XXJtcC1mSIXMlq1UiYrdKls8uuNokS4ReDKwsyVrkSlZch11haZEh5qbZuA7Cwy+yLFY/pGUwuE9WsF2wbLpIcrugv0dWgR634lQgJ4+hXbCmTxa0OHU5AHBLvSUdgwn6fZcq9G/btYUqGARCCGymZCUl9qNKBFK0xi7IGxGPBNsFl6ZLcN3GZI6TLLKCShbQOvzCXV4WY/JitB98EQZ9knUCga+yzB3DFLhmcHJe8MX6wWAly/QpCNwyGDWB7YPboTXxqFeBh14E9MgCgvtkhUkW5BhbmwABQZRImPOv8rNJuyQzi5NLf4/p0jRst7MJQlB9T6cQSpY+E9oqyMHrsu58enbVC9CBmnRBFutfpWQNsZqsbu2CrE/WUhckKzj4oj6+ncNkq/VawVvt56/tVMnitTJOjCobuo9klUxb9EoTJGv/HQCAUdsGXv0vQGad1ytrtvOJyvJsCfOHC5BkCZvPprbIRJaee1KRXs85WQbUKGDmgUWqTjUiWZKiYO0/fARKJoPKE09g5hOf7PjY/OBWwYvGLsJgdLDF1tU4c+hMxNQYFo1F7FnaIx6nEe70fApSsvj4Y1UpWe3FuHMlS2cF/k4TJYsQgsquXQDCx7cD1XZBTnqUZIh0QcAX496hksV6ZUnaEgornCzph+3a4rdcebugT8kymP1Tbd2KIhvzemUVMywJc66+X1sQ/MEXGq/Jahh84VeyPBJfWaS/vWpXxCLBsYBae/x6gt4bAJBKb0kWX8jOlyVEFDqONbMM0vs+PRZuF5RkAmjVilVtfDtHejgGRZXhWC7y840J1GrYBYHWvbK4ilWOJWEpat8uGAJ9knUCwd/HYdXx5A+AfzgF+NS5wJdfAXznHcDtHwLu+wLw1H8DUztRYRdgUYthIksJlG06IogC8NIFgWqS1VHoRTKYmHCS5a/JstqoydIiKgps7Jg64ptkcCVLojfNmC1BlVU4xOm4tobXZPWCZPEYd0lbxnAqvIoFAKetSWHzcAKm7eLnuzqPFe8U1XZB5k9XCUiCB18wJWuhE5LlvUYoWV3YBf0R7hzzBRMDQsmqmcSzupN4ub4h8Xx5viOC7rKUMjtKJ0X+miyeLJiNa8jENWD5CGYe/zZ935EdwPaXAfBWVZe7qMna+xDtGTZxahbRJD0GrmS5RRkSkZGz8sAa1ux18mEAfpJVb2HSxsYwfjNNP1z40pdQuPPOjo+Po91UwarjUTScM3IOAOC+aa8ui9ZkNUkXZOOPVbE9ZagVaakBr8mKsnOERLMNt7UOH4abz0PSNES2bg39HhElAkWix89JT2hS2GWM+5rEGsiQIck2ilbrkIFe4UDuAEzXRFyNi7qwlYDtuKLJejamwa7QcUfVWo/PAwmfkpVkCzrtKllaiAh3f/CFT8mqLNN9qMSApIVcAF0BiAh37irR4oJk9do+N5zkbiHT65VVWWq4fdnx3j/N0kclBVXx/EbJQoW5eWprsmRZQnYNfaxZ+MVqK1mNemVZrB6rkMgCQD/4IgROGJK1sLCAN7zhDUin08hms3jLW96CQpNu9AsLC7juuutw2mmnIRaLYcOGDfjTP/1TLC+v3kDeawwnvAFg1fH4d4DiDF2J3v9L4NFvAL/8GPDDG4Cv/y7wmcugPEwncm+L/xixb/w2cMufoPyTT1TtxrZc0fVekCyLtEeyRCPiYCWLe8mr7YKtGxH7UdTpTXBu0jcBZZNnCXTiQwwTY3F6DEcKR9AJuJIxlgj+LO1gIDIAXUpCkghiicXWL/BBkiTRM+vHO1e3MTEhRJCs0VQEbqkAAuBn2vvw3X/cBeISqELJ6iBd0MiJgvFu+2SV7TLyJp0o1ypZmQZ2QWWAWn1SplfvNhgdhCqpICCiuXE7EHZBpkL40wUP+K2Cjg3811sxA3qTX7P9VWI7vqpaXDYb1mu0Ao9u51ZBAIildMiyBBAJcTOFnJEDxilJwSRNEvVqsoIJZuryyzHwhjcAAI7e+B6xgtrRMS7txVOLT0GVVLx4w4s72ge3DPrDL/w1Wc2CL8yKAyVF7UPt1mTVkiyeWlmLhaNF/PBzu7Gc3ozIqae2NSmWJElYBoWSJeyCYWuyOrMLarKGYbZYUSKd/8btgtdjnTJwiuh1txLIVbzzOxPTYLPzXdVbk6xsXPNqshJsLAtLsuwgu2DwNW5YDlK8EbG/JivHSBZW39ngR53dUU+IuuhekyxuF5wvGqJhfDMly2CtCwiRkHLpPaVWyeIqViytVy38cmTXhIhxFzVZK0uytrKarPmiicUAx5Q9Q6/RXJyOQ30lqzVOGJL1hje8AY8//jh++tOf4gc/+AHuvPNOvP3tb2+4/dGjR3H06FF89KMfxWOPPYYvf/nLuO222/CWt7xlFY+6txBKVvEYKFn8JvqCvwR++3PAFR8ALnwbcNrLgLGzgfgQHIueTiPaIrD3F8DDX0P57q8DAOKypyaIuqw4HYh6rmTxmizeDLRQhLO0RB8LSbIqUfpZcv5Vfq5ksSQmUimLSclksTNi0kslS5IkxCVqK5H19ifuV7O6rF/snl3VOOW8YcNgTRyHkxG4pSIcJYopcjomn1lGcdkUDYntdoIvolmAT6DK9HVcyeo0+IIrljE1hqTmTUho8EV1I2KOyBCN0k64ecCg5EiWZAzHqb2uE8sgn6wHRbjvY6EXm4biwJ0fAQ7ehRmNLtCM+BrwRhOaeF2uA8tgccnA1F5qEfaTLFmWEM/S90uYWUpKBcmi4RfNlCyO0b/8C0ROPRXOwgKO/tWNHffP4irWpROXitXpduEPv+B1Wa7pI1lqQE1W1G8XDFnjVAM+iYu59HyVYtnA7Z66dwpHZ2QcGX9eW1ZBDm4ZFDVSPPiipV2QnU8d2gUBYJzZaR15Hpazcj3S/ODx7Stdj8WTBVMRFaoiw2L22CDlsxYDcV3YBfNcYQpBsgghbdVkVWzXa0Ts691lsIAtXV7d1Mda8O8q0C7Y45osXpIxXzRDkSxeMwmiIe6y/o4yofZoBk6ysjUqFsfAeOsYd0/JWtngi0RExdoMfa+guiy+2LUYp4tG/Zqs1jghSNaTTz6J2267DZ///Odx8cUX47LLLsM//uM/4hvf+AaOHg0e3Hfs2IH/+q//witf+Ups3boVl19+OT784Q/j+9//Pmy78QTSMAzkcrmqP8cLRE3WsVCyuB1k64uAs38XuOx64OUfBV7/H8Af/hL4y72YidBEq++Pvxm45jPA5X+D8pbXAgDiah66RAcR3iurwlbzsk5UhDaEQpOaLOISsSov7DpHqcqkZDKhveVOgq20+33SPF2Q0IHOLVcwziatRwvtTzJMxxS9i3oRfAEAsk3JmiW3v7K8YyKNdQMxlC0Hd+xevVXlOaZipSIqYroCUi7DUbyassJSRZCstmqyZNkjPCVOslg8se1Wh5qEhL+GjgeLEEIwVzAwILEJabzaLpjJDiHHkij94RfcbtiJ1dQtsHRBhSX5VdkF6XPPU54E7vgIPe70GnHcVcfWRV0WTxUc25IWdVgcSZYwmDCzyJm5apJFCJINarL8kCMRTHz8Y5CiURTvugsLX/pS28dICPGsgpvatwpy7BjegagSxUJlAXuX99J9G6bokxVck8WCLyp2+BqnGnAlK+6w/oI8qbEG5SJ93oxkED0jfLIgx8bURkiQsH1wO32f0MEXjGTlJ4EWKWyNsC7l65W1SjHuqxbfLnpk0fOEuzjUEArAQNyrySrobIJemAYqzeckpmvCIfR7TGiJKrtgUFJe2Qy2CxpsMVdVOvtdewURfOGzCwolq9hbZ9JQIsAu2Ixk2WzB1dUQZeqhpEqirxXgD70IJlmDIsa9WUPi1VGyAGBrk7osf3w7sPp2wcLi8Rn61gwnBMm6++67kc1mccEFF4jHrrjiCsiyjHvuuSf0fpaXl5FOp6GqjaN9br75ZmQyGfFn/fr1XR17LzHEpezVrskiBMgxktUgbAIACIuVLq67ADj39cAL/gLlM94EAIivGUeEkyx2/DmFksXN2lh7lo0mSpZlOqIhoCg8b9MqCABSit4UDf9FzZUsl34O16iICOJOlCweBa7Lulg16xZ2haojBbd90ldlGVzFxsSiRxYL63ArRhXJKi4ZUFmfLGdpCaTJIkkdasIvEroCVaY3wE7ULBHf7uuRVWBKXKaBkjWc1HGUsONYPiwe54Snk4bE3C5oSXRSEIn57YIlDCKHVzzzPgAE5Jw3YIbVDtSSeUGyOkgY5CRry7n11yGvy0qaWRSsApzh0wBZpYri8mFhMylbDpwmqVqRbduw5q/fAwCY+cQnUX700baO8anFp7BveR90WceL1r+ordf6oSu6qMu6f+p+ANwu2DhdkCvpVsUXfJFrM8KdWZCSLMFMrWkPwGEwkmXombaSBTk+/qKP4zuv+o4Iz+GR3S1JIb8fWCVqy+0AmzMbAQByZBqFVVLQn1pgyYIrHd/uC70APDVJjbSOF8zGdRBmFyy4FpBg11kLNYurWABV3DnJIgRwnfprrWI5SAYEX5jsnDqG5VgAvAUM1yYgLqmqySrddz+K99wL89ChniSRcrfQQtHEQIRea80aEvNFEBANMUGyqscCrxFxayWrUVy8HOXBFyurZAHNwy/saXqvmmfnSXwVI9yn9+fwHx/8De79/t6WsfrHE04IkjU1NYXR0eobuaqqGBwcxNRUuMng3NwcbrrppqYWQwB4z3veg+XlZfHn0KFDTbdfTQz7pOxVRWUZsNnFnRpvuJnCAguGxobEYyWWLBgbm0BEpQO5sedeAMCCRAefDVqbVrkmNVk89EKSPC+3dbh9kqUNsOahOcuLVuUky6ETD9KlksV7ZI3ER9qKW2+GYpEe44LVWY3Y1WfRz3P7k9MdKT2dwJ8sCACuacFRdPF8YdGAks3SH5UQYf0MhRqSJUlSV3VZIgrdV4/FayQH5UYkK4JJwu2OHsni++DErR1wG5cF+ln8dsHJpSI+pv0/xIxZYPhUFF7yfpTZ9es/bgDIsMbbfCIQFpWChSNPLQEAtpw3XPd8gpGshEFXg/OuCYywyf/kI8IuCKClNTX7utchddVVgG3jyLv/HE6TWtxa8FTByyYuQ1IPp2I3wgVjdJGPh1+07JPFlXTDERHY7SpZfKU85TKSlQgmWeVF+vsZkSwip7VPHNJ6GtsGton/e32yWnzXeoI23wa8hbg2wfsjKrFDqxLjvlhZFOE1pwycsrLvxeyCA0xBt9i6jhrRG71EIBvXABZ8UbAKwBD7feb3NHkVULToOBRVolBkRdwHgeC6rEbBF7y2WQ9RP7aS8C9g2LYLyDIUZudf/v6PcPAP/gB7XvJS7DrnXDz9/Bdg37XX4vCfXY/p//sRLPzbV5H/2c9Qfvxx2IuLLSfng0zJKhg2khpVa5opWXxcJa4G3aL/lpTq78trRFwd386RHY0DEg0FK+eDF/7k2OoEXwDNSZa5n6bDHkzQMX+1arJmDuTw/U8/DLPi4MhTS4GLBccrjinJuvHGG2k36yZ/drFI2m6Qy+Xw8pe/HGeccQY+8IEPNN02EokgnU5X/Tle4KULrjLJ4qQmmq2LJuUghCBi0MF9dNybdPFBI5aJIpKmN27jCRonPQ268rlWDp44NIRQsuotdpavRxYnLp0oWfFsBDYI4MKLVhUR7vQzdatk9bJHFgCYtovlHP0up4oHO1rtOXddFmPpKIqmg1893X5dVyeoSha0LMAh1UrWogFJUSjRAmB3GeOe6aIuS9gFfcmCc4wkNiJZmZiGKdBrojJ/UDzeTUNit1CEK6lwCL3JcZLlugQvzn8PL1IeAVEiwGu/hBmb3ixTegoxtfr67dQuuO/RORCXYGhdMnDykGT2wYxNv//auqyIKkNhimKzuiyAEuPxD30Q2tq1sA4dwtQHPhjq3CaE4Mf7fgyg/QbEQfCHXxBCaE2W0jr4AgDcWHcR7gnCwnwakixmH9UScNXWE/hWEMEXYezyvC6rw4TBHSO0HlfW5zGZX/kxh1sF1yXXVcXXrwT4GMMXdrgIH4Zk+WuyCmYBGGKJka2ULB56wcJMFEWmQTQIrsuqWK5PyfKTLGa7jxzbtXi/tdJhxz90DpDdWkTignOgb95MgyFYo9zKI48if9ttWPjSlzD9d3+Hw++8Dvt/57V4+pJLsfu852DP1S/DwTe/BXOf+1zde6WjKjRGklSJfhdNgy98SpbGCJdUU6ck7IINlCxVV5Aeor/z4mRwXZbElaxVsAs2akhMLAvGftoM+xm2WLcaNVmzh/K49VMPwyjZGN+awcv/5OzAGtjjFce0XfO73/1uvPGNb2y6zZYtWzA2NoaZmeqJiG3bWFhYwNhY81S2fD6Pq666CqlUCt/97nehHWvtuwvwmqyCYaNiOYiuVtFhnqk0TVQst1SCwgrTxye8CSjvkRVL6YiMrgXmyjAn96I89xRmCL2BD6ONbvJmkfbbAUQPJT+CemTZM1QxUsfCk5l0XMOiTDDiSliaKdHJqB4H1Bhkhb6HX8maLE6CENKWIsVtYr0iWbMFA8QcBCEyyk4Z06XptlMLZVnCVTvG8OW79uNHj03iijN6c2zNENSIuLomizXwHBqEs7gIp53wC14f5Y9xj3VOsoJ7ZLHkQrDzsibCXZYlLGqjgAtYCx7JEg2JOyJZBVi8iazkqSZzRQOvkegihnv5+6CM7cD00buq3s+PTkkWtwpuPW8k8Hleo5UyKckSdVkPfw2YfASSJCGhK8hV7IYJg34o6TTWfvSjOPC//zdyP/gBEpc9D9lrrmn6mifmn8DhwmHE1BhesO4FbXy6YJw1fBYiSgQLlQXsy+2DbJhwda5k1Y/FqiZz8RVOtLNmxHwSFyEELpEQTWaDtytaAFM1i0tmw/qPsJDZ4qJbKoE4DiSlyb0mNQ7M7uqYZKX1NFRnDLYyhSfmH8Nvbdvc0X7CQjQhXmGrIODVZAm7ICdZsdZ9DLNxTdgFlyp5gCl+mG/eK8sfesGh6DLcihOYImrYji/4wkeyTLqQoceO6TQRsixBViS4DmF1WRr04QTGLzwIvOXdwPoLQZjDwTp6FPbkJKyjk7Am+Z+jsI9Owp6dBalUYO7bB3PfPhTvuguZl78c2tq14r0kScJQIoKpXAWySwl4swh3f02WbpXhAJBV71oxKzZKOXZ/aHJNDownkJurYHGqiInT6hdSViv4AvCUrCNLZZRMW1gCzYMHAcuCFI/jsLo6NVnzRwq49ZOUYK3ZnMYrrjsnMKHxeMYxPdqRkRGMjATfpP245JJLsLS0hAceeADnn38+AODnP/85XNfFxRdf3PB1uVwOV155JSKRCG699VZEo9GG254ISEVU6IoM03ExXzQxke3uRhoaXMlKNyZZS7N0EmtLMjaNe4OEULJSGvRsFkAZhhvHrnv/GSWNDuKxdua6BVa/osWrVt04RHy770J0lqinWh0Ir5iloxr2KQQjLu3GvvFMpojEhyApdFLsVioYi49BggTDMTBfmcdwrN461QiCZCV6Q2RmchUAChRnGK46g33L+zqKhr+akayfPTEN03ahr/CqURXJYmlRjq8xdZGRLHVwCCb2wG4rxj2gITGz7ix3Yhcs16uPcwUDKmwkCLPcxerPs2J0DCihKviim4bEbqEAm6lSkZgKia1UTy6WcKpEF0WU066q2n9QgiW3CxYWKnAsN1CRqYVZsXHoCXq9+1MF/UgO8OALaiVbNpfrEgaTEZWSrJAWsfhzzsPIO/8Es5/6NKY+dBNi55yDyObGE3IeePGCdS8Qq/rdgNdl3Tt1L+6fuh8XGgbcaGMlS5IkaFEVZtmGy0hWy7S+GnAlK0II8oghpgcvEhqW9/7FZaNrkuUPCHILBSiZJqmMfPGti4TBmLsZeWUKu5ceA/DKjvcTBjy+faVDLwBgmdkFeRN026G/kxprPReJqAp0mZ63OTPvswuGq8nyn/OqrsCqOIFKVlXwha8mi1sb9fixX5hWNRmm4zt+rkAya6QkSVAHBug9/swzA/fhmibs6WlYRydx5Prr4SwswJ6fryJZALUMTuUqIA79/kKlC7oaVLMCB4CkeXMPvngVTWpV4US1GFgTx4Gd8w1j3EXwRWXl6/GHkhEMxDUslizsnS1ixwS99o1nqE1V27xFBHuspF1w/mgB3/vkQ6gULYxuTOGVf3ruCUewgBOkJuv000/HVVddhbe97W2499578etf/xrvfOc78Xu/93tYyy6QI0eOYPv27bj3Xlrvk8vl8NKXvhTFYhFf+MIXkMvlMDU1hampKTjOsY0k7RSSJHkRo6sZfsFXKJsoWZNHqM2jrMcQ8xVDVilZbEXMIEns3PvfqDDHhNtODGuekazkmqoEHw6vEbHPYsBqeORmE4UapGMaFmQ6oC9N+2PcByGr9HFSqUBTNDFZniy0t5LbbPLbCaZzLO4ZlFjtz+3vaD8XbBrEcDKCXMXGXXtW3r7jr8niK3WuFqxkAW0mDAaRLKZkLZd7pWQZSMN3jgT0MjLj9NpRfbV7/HfvJF3QKeQD49sXj+5BTDJhQQUGNlUfc6yeEMVSGtSIQrNt5sNdhwcem4dju8iMxjC4NthuxYMvIkYCIBJVssZ2AJBoOmh+CvEQMe61GHr72xG/6CKQUglH3v1uuA2K3V3iinqsblIFa8Gj3O+fuh/ENHzNiINvpXwc4r9VuxHufBKnE4JlkghcObYtBw68x/miRDeQdB1ShP6GLS2Owi7YeVhORqYEYm/+iY73ERZCyVrh+HYgQMly6PmixcKR4BRbSMybBWCI1Y/N72ma5Mjtgn4rpMZj3APqbCu2L/jCp2RZDr2/RhKtVbeVhsITEkWMOyOQZvhaUlnXoa9fj8TFF0FdQxfJgup7+RzLtpjK3yT4QihZRIPK/l1FslokC3IMjPNeWcF2QR58sRpKFhBcl2XsoeRe2rJFPBZVV4ZkLUwW8b1PPIRy3sLIhhRe9a5zq8KdTiScECQLAP793/8d27dvx4tf/GK87GUvw2WXXYbPfvaz4nnLsrB7926USvSie/DBB3HPPfdg586d2LZtG8bHx8Wf4ynMol0M+TqSrxpCJAvOHKWTcTNavWJcRbLYZNBQhvGYZKLCFnbcUhtF9wUfyQqAvyaLw2ENqFVW0xMGqaiKBZneyGpJloiPZdY2Xpd1tNjeSi4PvugVyZrN0+PJqLT2bN/yvo72o8gSrtpBv9/bViFlsErJyi8BAFzNq1koLhoghEAdpITJXmhDyeLWvR7UZBFCREiFvyZrvmB68e3RDKDU3wzcND1HoiUv6prvI2/lqxLBwsAtFD0ly7dCak7RSeqMvl4cR7NebJIktW0Z9FsFG9lj4xkdkADZVRC1E7QmS08Aw0w9mHzU1ysrfNiBpChY+w8fgZLJwHjiScx+/BOB2z06+ygmi5NIaAlcNnFZ6P23gj/8wjUMEeHeSAHkirqjslCXNu2CfiUrhwQiAaqyUaz+/krLvbk3yKETBruryQKAYY0SiCPl3XDclVsEtV0bzyzRyeJqKFl1NVkOvS8pIUlWmpGsolWgiyaSDJiFpoTW34iYw4txb6Vk+UiWy+o9U8feAaQGxLgDoKmWHUDJ0oWwQJLFwi9Mk/5GoWqyXA2yyUiWT21ulSzIMcBj3BspWVE2fqxCTRYQTLJMpmSRDdQ9ENMUUevXSyxNlwTBGl6fpATrOFBTO8UJQ7IGBwfx9a9/Hfl8HsvLy/jiF7+IpM/SsGnTJhBC8MIXvhAA8MIXvhCEkMA/mzZtOjYfoksQQpBILALwiu1XBSGUrIVpOol14t5vQgipsgsKkpU+HY9FdJ+S1bgJXx04yQqoxwIa2QWXALSpZEU1LCpBJGsIMuNvhHWbF3VZHSpZvarJ4krWmhhtO7B/eX/H++KNif/78SnYK9wglJ/LI6kI3AVKVP1KlmO7qBQtKIPUhucsLIbfOVeyyv6aLHriLbWpZOWtvEiT4o2E+fE3im/nkDPrAACaWwHK9PiTelJMhNq1DLqFAiz2Wn/NhDRHV+mXE56NrtV5lm2DZNmWgwM76bUeFN3OoSgy4mn6PSeNLHI83ptbBqceQYJN/MLUZPmhrVmD8Zv/DgCw8OUvo3DnnXXbcKvgi9a/CFG1d5PEs0fOhi7rmCvPwSyXQZqkCwKekuWwfmZuqdRWCwJ/TVZBSgaS2kqx+jzuhZIFeJbBlsSwFyRL3wji6jDdcseLQ2Gwf3k/LNdCXI1jIhU+CKlT8GbE3KJsE3q+aPFwgRvZKCW6ZbsIqDqQpXH3zSyDPF2wyi7ISUpATVbFcpEIULJsQseVSKZ7q2234MfPgy+gs+/PbGPu4AMPUXIWl+qe4wFj5TL9u2SXYDnB94oySxQE0SBbXMnyk6zmyYIcA2PMtr1oiDmMH6sZ4Q4AWwPCL4xn6DlnraPn4EpYBZdmSrjl4w+ilDMxNJHAq991HqKJE5dgAScQyXq2o2gVccW3r8ATyt9AUoqrG+MegmTl5ujEUUr5PN0VB45NB0WqZLHCbH0chzTNR7J6qGTVBF8Qy4LL+ncpbShZ6Zgq7IKFRcMrGI4PQeLd5i0LxHE6UrJc4gbW93SDGaZkbUhtAgDsy3U+Wbl486DwZd+7rw17XptwXSKCI4aTEZBFukLratUTY3+vrLaUrMCaLGYXbFPJ4ra72pS++YKJrMRuRg1I1kAmhVnCkkoDemW1G+NO7YL0GKI+u2AiR1cbDV8cNz/uRoopX2UNQ7IOP7kIy3CQHIhgdGPzwBqeMCgaEgNVdVmJDuyCHKnLL8fAG94AADh643tg+YKRHNfBT/b/BEBvrYIAEFEiOHvkbACAaXhjcEMli41DtuRNFNw2Iuj9JKskB0/MS3PVCYCFHpEs0durlV2QLSBg8lHgsf/q6L3SUR1Ome7n0bn2eqG1A38T4rZ6M3YIvpAzwO2CLr3pqb4F4mYYiNGFQYsYsFwLGOaWwcYkKyj4opmSVbEcJGtqslzHhcPO2Uj22JMsryExr8lix/TUfwOHHwDc9hYCBclaql+w426hXEkV50gjNatoeRHuMrMuS77kyLB2wWhCQ4wtSgWpWSLCfbWVrFl67RPbhrmPzicqazcAQM+D15Zny/jeJx5CcdnE4NoEXv1n5yGaPLEJFtAnWScMElqCNccjUBJPrXJNFrMmNCFZxYUlAIDqi7wvs8mzGlGg6Yrw1C6X6UpNRmYpfe2QrHxIksVXkJlVEJIEpY04/nRUQ0UGyhIlVKJZa3wIsuL54UmlgrVJRrLa6JW1UFmA7dqQIFWpIt2AK1nbstQzPVWcatuGxqEqMl56BrWH/uixzleoW2GxZIpmtENJHe4i/X2dmlYBhUUDymAnNVkB6YLcLthm8EUjRWiuYGAAnGQN1r4MADCciGCSNyT2hV902pCY2gWZkuUjWYOl/QAAifekQuvaP77KGqYh8R5mFdx87ogI22gEHn6RbECykh3YBf0Y/cu/QOS00+AsLGDyxhtB2ETrwZkHMVueRUpP4dK1l3a072bgUe6Or1dLI5LFC7VtG16NU4ckqygHk9rSkWqCXlrukZLFY9xb2QXHzwFOfyXgWsC33wz88mNNa4aCkIiocMp08vbo7MqRrN2Lqxd6AXh2wWxcg2MacFnWmBoPR7KG495vXrJKocIvaiPcAa9nZLCSZdelC/L4dgCIZLvrL9cL8PROh5OsQabU7/4h8PnLgU+cAfzgBuCZnwF263Gdh2A1swsuFC1kdEpyG5GsElOvQDRIJr3uZN1HsriS1cIuCACDY15T4lpIUR58sboka/9cEZbj0mbPlgUpFkNpgNb29lLJys2VccsnHkRh0cDAWByv/rPzEEt134rieECfZJ1AeP665wMA1OSu1avJct1Q6YKVRUpmogOeJY9bBeOp6oap5SIdjNYT+rxT6MAu2IBkeb09qkmWnE43jyGuQZp56Bdr67LiQ6ImC6CDniBZbShZfOI7FBuCJvdmtWaG1TZtGhwR3eoP5A50vL8XbaeT8ocOLnV9bI3AQy8GEzo0RYa7TCeMQSSrKyXLLADshpjpMMKdq021ARKzBaOlkjWU1D2S5VOyREPiNsIviG2DlMsiwl341QnBhE1/78TaMwDQGpS5Cq2XbESy0sIu2JyQu46LfY+weqwGqYJ+iIbEZpbWZAHAGIuhXjqIIdZXrF27IIcciWDi4x+DFI2ieNfdWPjiFwEAt+2jVsEXb3gxNKX3K6E8/AIsKU6SqT0yCHyxx6w4Xo1TG3VZgmS5BBUleLJbnF4CACguvScUe1WTJRoStzheSQJe9xXguX9M/3/7h4Bb3xlqssuRiKhwy9Tm/MjsIx0dbxisZny74xLkKrwmS4dT9L5HNRGubclQIg7i0nM4b+ZD9criC2v+4AtPyaomWYQQENuAKnEbHiNZbCFUdkxomTZarKwQ1Nrgjhe+B/jtzwNnXEOPOT8J3P8F4Gu/A/zDVkr2d34bqASHVnhK1lLdc0Ms6GOhaCITaU6yuJIlER2w6LUq6fT1lukI6262hV0Q8NVlTQYpWasbfLE2E0NMU2C7BAfmSzD3UIdEZMsWlNniUq9IVn6hgu998iEUFgxk18Tx6uvPE1bzkwF9knUCgfd6UZNPYba4OhcbirMAcQBIQCJ4kkYIgc2aViaGsuJx3h+Cr0jwFXe7Qi/SzWxll7Cwg1AocFUtOITDU7JYwTkjWU0jiAPAV9nrEgbjg5AkQFLpKj6p+BoSt1GT1evQC8ALvhhNRbEpswlA5+EXAHDKGnrD3TtbhOuuTId1EXrBfPAkx2r7aiK3i0sdKlnRDCCxmwGry+qUZHFi7E8WNGwH+YqNTEuSFcHRAJLVSUNibjfzR7gDgLk0iRRKcIiEwY1UyZovz8MlLhRJwWA0WGXjVpb8XAVuk/q7o08vwSjaiCY1jG9rfT0Ju6CR8WqyYlmRerjFpjfuTpUsAIhs3Yo17/1rAMDMJz+FwsMP4WcHfwYAuHpT9w2Ig3D2yNmIQIXEVIlmjTH5Yo9lOFBSIUmLD/7gC0MNnuyWmV0wLdG/e1WTJXMlK0wioqwAV90MvOyjlHU+9DXg338HKC+Feq+Erggla8/SHtp8dwXw1IJnF1xp5CuWEPQyMQ22TxFUQkS4A7SWizckLlpFL2FwrnGvrODgixq7HYPlEMRc36Rer1ayVKdSFed/rKDW2gUVDTj7dcDvfgX4iz3AG74NnP9GOkcxctS2+l9vAT6yFfjqa4D7Pl/VYqAZyRpkdsG5golshG7XSslSJB3EpPcTKUJ/rxxTsSJxFZFE62S8gfHGShbvk7VawReyLGHrKCV9z8wURD1WZNtWlBhR70WPrMKigVs+8RBycxWkR2J49Z+dh0Tm2KdZ9hJ9knUC4ezhsxFXU5CUMibLu1fnTXk9VnI0MDUNABZLFiIVOlCnh72JnD9ZEAAibHIrWxpAgK3bXgQAcMttEMbCjHc8AbB48AVXstgg2k49FkAT9lIRFQu14RdMGWHJzbRXFutFVbAKni2qBXodemE5rqhtWpOOYHOG2ik6jXEHgA2DcaiyhLLlYCq3MoO7P1kQANw8JUIOIxA8CrywZEBlJMstFBpGd9dBkurqsrw+WZ2RLD8x5oryECdZ8WAiM5TQBckifrtgrH2SxZVfm9VPcIV46eBjAIDDGMVghlpjufo2FBuCIgffFJPZCBRVhusSFBYbT9D3PsSsgucMQ26g3PjBGxJX2QUBYRlcb9CJYqGDmiw/sq99LVJXXQXYNvZf/y6Ul+cxEBnAReMXdbXfRoiqUZyX3QFHZvU1TXqL8cUes2L70vrCEQhCiFCydEJgag1I1hJLMIvT89kyHKFEdAMlGTJd0I+L3ga8/pt0sr7vTuALLwUW97d8WSKigjgp6GQIBASPzT/W4VE3xmJlUdTBnjJwSs/3Xwu+iJPQFeiqDLtEf3dVMkI3rc/GNMCh11He3ytrcT/QIIyhUZ8soF7JqtiOCL0gWgKQ6bls5Ok9WbHL4rw9llC0xjVl0KLAKS8BXvkp4N27gbf8DHjen1FC6lrAnp8DP3w38PHTgc++CLjzo1BY43g7IPhimClZ80UjBMmi35MmR+CyGk0pWl3jmhmJhfq9B9Y0ThiUYjz4YnVIFgBsY+EXe2YLokeWvnUbyuwciuutiWMzFJcN3PKJB5GbLSM9HMU1158n7vcnE/ok6wSCIis4d4g2X14gK2epqEKIeqzDiyUk2GATyfhqsniyICte5Ks5MpERIwmccsk7AFChjBwJ4cN3HaqsAa3tgrwma6kzJQuglsFFrmTNVJMsiT3uliuIa3FhzwurZjWL1e4EPKFPlSUMxHVsTlOS1Y2SpSkyNgzSG/Xe2c5SnFqhnmTR38tR6E2Fpy4VFyuQ02lAZQrlQue9snifrIJhw2ojOTGo3xQnWaMaWygIYRd0Fr0WEh0pWUU6WXNY/QS/ropHHgcAHFY3iJu6aHjdhMxLsuRZBhvUZRGXiOj2Rg2Ia5EUdsFMIMlayxaKSh3aBTkkScL4hz4Ibe1aKJOzeNNPXVyx8QqocneTgGY4f+Ac0SNLaVIAzu2CVsURioCTC7cQY7reQkKEEFha8BhWYYtZyYwmxr1iD+qyQgdf1OLUlwJv+jGQWgvM7QY+92Lg0H1NX8KdAxGHjlsrUZfFrYLrU+urrHQrBa9HFiXjFqs9VuXwizsDCU0oWQWrQO/DWpzeNBeDreAiXdCvZLGFAKuGpFRMX+iFL1mwssAIoVOBHD/2wRd1dsFGkGVg/YXASz4IXHc/8Cf3AVd8AFjHFlyOPgj8/CYoP30XAMBZbBx8UbFcJNk116hXFu+TpUo6iFWtZPE5A2/43gpcyVqeLYvAMPGxojz4YpUcTKiOcTe4XXDbVjFex7oIvijlTHzvEw9heaaM1GAUr77+PKQGj32rgJVAn2SdYHj+BLUMGvrjIG0WF3eEPJPYm5KsMpJcNk97q148+IIrWaomA6zG6bTEGYiPbxfbur/5UutjKc4BxKV2lETwRK8u+KJDJQtgvbJ8ShYhxFOyFBbaYdDPzWPcw4Zf8MkvV8G6BQ+9GElFIMuSsAt2o2QBwJYROhnZO7cy9p06ksXqFnjkdZat7hWWTEiSJNQse76duqzq8Atebwe0p2YFpUFycjskMxLegGTFdRULKj1nyXJ98EU76YLCLsgmilwhJjO7AADzsU3eMYdseJ1pUZc1vT+H4rIJLapg/fZgta4WSV9NlrALAoJkjRQoyerGLsihpNMY+fCHAACXPEl6nipYi+dkd8BtEd8OeIs91TVZ4a4l0YMHlGRx5bJuuzKz7wwmhXrYC8ugCL5os7cXAGD8bOBttwNjZwOlOeArrwAe/27DzXljatnaBGBlSNbuhdUNvVhk8e2iRxZLuVXl8Od7Nq6DOD6SJcu+uqxgy2Bw8EUDJctyReiF5OuRZSyzYyVmW7XMKwUR4W6FXxQDAIycClx2PfDWn1KV6xWfBE55KdjtJTBdMK4roh9dRKbfyVJlKXD3ZUaydDnqkawAJSsMEtkItKgC4pK6xS6+T9dYvcAzTrL2TOVg7t0LAIhs24aS1Z1dsJQzccsnHsLiVAnJgQiuueE8pIfCfUcnIvok6wTDFZueD0IkyJFJPLNwpPULukWI0Au/kiWnApQsFnwhSRJIhN5gtifOgKTrkJgy4T70ndbd23k9VnwYaGB98uyC3dVkAXQyvsRIoVGyaT8alh4nGhKXO2tIHHbyGxYzzM43mqZ3D2EXXN4Pl3Te54r3y1gpJUv0yOI1WaxnGrdiZdd4ShYAKCz8oj0lq7ohsSJLSDMbVzt1WULJ8tVk8eMfaFGTBQBGnJ4jamGSqrKoVrLCLprwmh6L9X/idkGdNVktpb349nZJ1lKDGHduFdx01nDDJL1a8Am/5kZglG3v841RkpUu7kcSpY4i3IMwt5aRTht4zvC5PdlnI2xPbhEky1UaHz8fhyzD9mqcQtrvDJullRECFYCjZ4O3Y6dwfCSDOKtn6EX4hQi+aMcu6Ed6LVW0Tr0KsCvAt94I/OoTgcmDSWbv5uEXO+d29nwRUYReDKx86AXgtYgYYH1+HBZaoDY5X2oxENdBXGaZ5nVqLRIGgyLcNZEuWKNk2Q4SUr2SZeSYDU5aucbQ7UBtZhcMi9QYcMGbgDd8C8oEJdqkYtQRF0mSMMzuRwphJKuBXZAvhGhKBIQpPHKUjkMivj1EsiB/34E1wXVZPMIdti3I3EqDk6z8gYMghgEpEoE2MYGKsAu2T7LKBRO3fuohLE4WkchG8Orrz0N6+OQlWECfZJ1wGEsNQzJogfDP9v9i5d8wRI+sw4tlQbKqlKyamiwAMBS63dYYHeTkBB2Q3GIBePw7zY+F12M1aEQMeEqWXluT1QnJiqqwJUBik0qjaFP/t5YQMe487afdhsS9tgtOM0VolClCE8kJqLKKilMRIRudgCtZe2ZXSMliJGU4pQOOLerzbImeM/ymY1YcmBVbRO+2p2Rxu6A/xr29uiyXuIH9pngdXJp5/BtFuAMAUmtgExkSscW5zK2Hlms1vJHXHQuvyZKrSVamQK2h7pC3Ut+2khVgFySEiOj2sFZBgE6Mokl6bPFKWtiYkBwB0rQR7OnSwY7TBWsxD+8clYzuSUYzRBwJLksurKDx4pBQssqOqHEKa7/z6rEACQCJ1regIITActh3vHYIiSw9r3uhZLUVfNEIkSTwe18HLv5D+v+ffQC49bq6eiLeM61SGIcma1ioLOBw4TB6CX+PrNWAaEQc43ZBZi1ri2RpALMLLhtsjGlFsuwm6YI1druy6SDJ49t9SqnBQpRU+fggWUpYu2BIHJAvw9HxSwA0CL9gMe6Syyx8DeyChsOVrAiITY9NinHbH7MLhkgW5BgY53VZ1SSLR7gDq1eXtXEoAVWWMDpPF471LVsgKUrHwReEEPzoX3Zi/kgR8YyOa64/D9mQVsoTGX2SdQIiZu8AANw9+euVf7McJ1mNbW2HFkpIBipZ9CYTZyTLcR3kpSUAwPrIJgCAlKAXmWtLwP0tLINcVWtQjwU07pPViV0wHWU2LJYkyPftj3F3K3Qy06mS1avgi1mmZK1JU5Klyio2pCgZ76Yua8sKK1leumAUKM6COPS7dgiddMXSuldnsmT4lKx6m0dDNGtIHLJX1mJlETahfc2GYkPica5kJVxOshorWQPJOKbBnmfhF5qiidS/sHVZbqEAAgkWI6KRuAaUF5Gy6efTxzwbbmiSxVZbc3P1JGv+SBG52TIUTcaGM8NZBTl4r6xEg/CLM+X9KPTALggA804OLqsvb6vBeQdwDVMoWQWnsdLD+2RZhg053V6Eu5csyFbvo/XnlrO0BJMpFol1oyLRsTd2wQ6CL4IgK8DV/xe4+iMsefCrNGrblzyYYEX0JRM4fZAmY/bSMmi7Np5hSu+pg6tEstgCToY3Imb3Ck0Nr9Clo15N1nyJTfRFwmALJSvQLlijZFle8IVfyTIZQdSVVShJCIG6dMEu4Doufrr7Cuw67fdRjI81rctyHKYsGcH3G74QElV8JCuagG05IkQorF0Q8GqQF2pi3CVNE6EkbQWFdQFNkbFxKI4NrDdpZCu1qXK7YFxrr+a1UrAwtZeew9dcf55wqZzs6JOsExAjyrkAgMcX7xc34hWDCL5Y23CTwwslJOz6mqwSswtGmV1wf24/yqw3zoDEaptYUa3rasCR+4HJJoEeokdWY8LHgy/q0wU7swsCgKtIbN9sMhgfhKx2rmQVzIJY1e8VyZoRSpa34rUpvQkAsC/XBckapitrR5fLIlWol6iqySpMUbINwHbp0KRFFCTYRL2w6CUMOp30yvKRrHZj3HnN1GB0sKqv2XzBgAobUYeR0CYka7hBr6x2GxK7hTxsNQqqb7AI91m6Sj9JBjEy4qlN4ZUsr+ia1MT1732I7mPDGYOCNIRFskXC4A55P0o9sgvOVxZQ4S3DVngiQkxDBF8sO0sNrW3+PllKm/Y7fyNiAECsfgyzJydFU+pYJuazC/ZAyWpTeWuJi98B/N5/AFoC2HcH8MUrRXiDULIsFzuGaS+1XpKs/cv7YbkW4mocE8mJnu23GUQj4lg1yWoQ0hsIWZYQkdlEvxJOyWoWfFFbk1W2fMEX/pqsIj12rfdt5jqC0mlNVgAKiwZspv4uZbc1VbIskyn8DZQs06XznqgahcuOTYonkZurAIRe/7xcIgxEr6xaJUuSvPCLVUwYPGU05ZGsbZRklYWS1R594KQzntbF53w2oE+yTkCsjW2Fa6VguhXcP33/yr5ZvrmSRQjBzHwOGqsx4UoWcQkqBd6MmA5YO+d2wlTpgG6V6YAkx5ldcIymJjZVswTJatyvi9dk6bV9sjpSstg+mCoeqGR1UJPFJ74pLVW12tgNpmuULMCry+pGyRpM6MjENBAC7JvrrZpl2i4W2URkJBUB8tNwHQkEEmwmSWgRBUmfBYorWXY7vbIClSy6z7AkqxFZmSuYyMD3vcSyDfdBEwaZEuRvSBxrryGxUyiIibWqyXQCMkeL+p9x12Ii6xHtIItjEFKDNDDFsdy6CbpIFTwvvFWQI+FTskRDYsBTsqR9PQm+AID5yjwMNp9Z6dVeYhhwGNkukUJDa5s/XbDT4IsIIagQDZFo/VhRPjwFV6HncjSpiR4zxaXuF9+6Cr5ohNOuAt78Y2o/n90FfP7FwOEHkIh41qNTs9Sp0UuStXvRC72QpdWZ9iyLdEFGsljxnNomcYmr9HdYLLNFCh58UZgCjOrfxiUuyjY998MpWV7wRZWSJWqbj48pYk9qshj8luilTDDJ4jVZlQr9u5GV22IJoBElAsKSaqVYou34dg6uZC1Nl+oWu0SM+yr1ygJoXZZHsii590hWewtu+QV63CdjTHszHB9XUB9tYTgVgV2kxbu/PPzLlXsj26DJUEDDmqyFogmZhRVAliEz+59RssUgEWUR7o/NPQZDLbHn6Q1HKFkTl9F97PxW3Y1DgJOsBoTPsVxRU+3ZBZcAdB58AQAWGyOtikeyRE0WSxdcm6Qka6GyIG5yjdDreiyggZLFEwaX93e8X0mSVixhcL7oxc5nY5pQsqgNyyNZVUrWEEsX7FLJ4qvLSyFrsoJCLwBqF8zy0ItopmEgCwAMJSI4Qobpf/y9stqMcXcLRdGImDf4NqeeBAA8QyYwnqHPlawS8ha9lng/rkaQFRmpIVb74Z+ETJcwf6RIEyvPGg51fH5wgpwwghMGT5GOwDZLPQk5mC/7SFZpZUmWaxjCLmjLFu6fCl7s4os9pmEL0uLkw0W4+0lWDonAyOTiYTqWSHDptZLtoZLFSWGxCOL0UMUePwd46+3A2Fm0JceXX4bIUz+AxhwDm5PU7rprYZeIyO4WIvRicHVCL4D6mixOsjQt/KQbAOKstirHgy9iWS9dt0bNqtgVENBrKbAZcY2SZfiDL3xKlmVQwqAfLyRL50pW9+ehP0F1KbM1kGQNMSWrXGGNhc1cYICU7TJ1Ro2AOPR7l2JpLM+0X49Ft49BViTYpov8YvW57ylZqxjjPuzZBfU6u2B7NVlcyUqepFHtjXB8XEF9tIWhRAROgd6IfnlkBUkWJzWK3rDJKo1v5/VYKbFqU2L1WJG4CoXFoT4295gIvjBKLImHB18k1lMbhFmgRCvweJo3IuZWQQDQ9Jo+WR1GuAOAKdHBs0rJUquVrLSeFoXGk8XmlsGVIFn+CHcOoWR1YRcEgC3DK1OXxa2Cw0mqoiA/DWJLcBQvKEXVZGE5KywZUAaYXbAtJas6wh3w1WSVwq34cwLk75EF1ChZTayCQHWvrCC7II+IbwU3n4fFJlAR9jnMKRrffkTdIKxX/JjjahxJ3wSqEXhd1rIvYZCrWBOnZRFNtO8dSmS5klXTKys1DhIfhiq5OBUHUemBDWi+Mo8KO3Xc8srWZBFfTZYj2w0dBdy27NoEJNZekISfZC2TYJJVmqK1IrpsQ5IkJDJM9V02uiau/ia0brHHNZmZCZo8eMqVNHnwP/8PXqrvBACk1FEMRgdhExu7Fnb15O38StZqgav0oiaL3T/UNgMD0iyQomj5zhthGdxTtS0PvZAgIaZ6tUBe8EX1dVYVfBHxfm/TpOdOJHZ8+AV7WZPlH9+M6CByU/WLHtwuuFyif7vErVbiGSxCr9GUooh6YjmeEu+RDZksyCErsuirVduUWGIJg6uqZJECoo4FS1agr6fJn2UWVNRuumBhsa9k9XGCYCipwy6eAgkKDuQO4EAuuClh1xD1WGNAA8m7KlnQd1OuTRY0HRO7F3fD/P/Z+/M4ya76PBh/zl1r7+p9mX1GO1oRAiQEiMVgsDEGjBcgyY8EHOc1PzBxiDEGbOxgG+fFECd4AYwdEggmBC/YxAYDQoAFRhJaGW2zaGZ6uqe3qura7n7eP85y76197emB/n4++kjq7qq+XXXr3vOcZxNMVp2DLMFk1erAM/41e/B3P9Ey5jcMvmjNZLlcdqSZKohCEDgOKDfAD5YuyG4wNt8ZDD1ZIZMV8F0lQggW0735smToRXo0fizPDyQrNJ9r9mSt1dbiC9w+RzJZI04YbOzIQmUVgU/gqzy8g7+P0e4fwWQNVEZcDx8z0SeTJQBQFBgHAcVW1cYk6SFZECymXsoFh2Cy/GpFMlkJzmSpm2ynvpQ5Eh5znzUBUV+WmFAqONiGgLihNnmyCIn5skYRfrFR35BM1s54sjjIIi6+u9q6bFeEtgCAb/INpR7ld3EmK9Uyzau2xjaRTA4uhVww8CirnBhiFMMAMYy+jrmvMbMsefDqVwAAXqh8DwBQdQJcP3s9AOCB9Q4e3T7miS3WKbWTIEvIBSe5NFkk42kRsOyXy3DOda5iyXEZXxxkia6sOJMVDb2IytTaMVks+KIFk8VPHWOAjZVxzEjlgg01FWurzRttQi5YrPpy87RRMugGLijY8eQUSJBFIiCr1/j26ExxyWBhpSHGXXRl7SCTtVBka5lzmTkUOLs5aLqgZLIm95isvdnlM50xgcBEKmApQ2OTDG53LyI+W4gkC8bi2+MdWY9tPQYv8KAmeBx6rRFkVYEbfg5QTeDCQ8Dyvc2/rAuT1S6+HYoS25XtdYRcsB40MllT0pNFrVCWIySD3XxZo+7I2qg4oJT1PwmZAwBMmBM4lDsEALh3tcXr2ePIrqwRe7JkR5YAWeULCLwQZIluF7FQrxSs0JO1tdX7Tr0AP25NdrH1HXzRwttUqDkIKJDvmckycb4Dk9WrJ4vJBdnnxkhpgFNDosoWau7k5fLnWgHDTtNYSFwpWLhwahsgwJEb+pcKAtFC4okmoE8ivqzaCGLcmVyQLXR2wpMV7claqa5gudK8WFZURZr2A4O9Z36l3wj39kxWvcDOPQm2dUXKs0fhyxLXzV6Pue9RNWDfMwAAWYX9vVXbww2z7Nx4aOOhoX9FwSrIz8Llkc/HuEfKBQWTxVkYzQy9LGfe9CaceOlLUf7q19o+zySP7rf8CLMhEwbjhcSyiFiLy9QESHEbQEq9jSfL9XkZb2Z3sA6jjHCXAChg9+m1UjOQFEzWZsVB3swDaAZZUSnrpApQ7iMmicTAckEgGuMeZ7JCueDOFRKTp5gK5kx2Hk+usWuA9GT1LRfcY7L25hKZGX4BUOos6vauc3eN5xdJJqtbETFPFmwR356MhF4AwMIUW6w1ebJqNSbretqr2BM0BmDYZUD27LRmgBqTBQMRepHLgSj9n+qCyapxLXYrT1Z0V6lXJkv0Vo0uWZC9/rNCdheZZy8+GwDw7ZVvD/z8xySTVR1pQWgoF+TAsCLkghxk8fdRXJSrxTBdkFqWZCm7jpkFRCIgZ7Nk8EWvTFYLYCw6shZNfg70IBc8zz1ZtLIGeE7sOXtOFyyX4elCLqgBm0+AgGKLZpCZClnevpmsBrngyfuZH3Px6IRkSPodwUKafgrbjQv1ETJZlFJsWVs77Mlii+XJdB4AurJZns5eX1qv91QoGka4A9tItZTnWDzwxozIhNMjTBhUM2MIv2gcg11fMhxkVWwP188wJmsU4RfCj3UgeyDWHTXOCQIaBl+IdEEuwdPMcFHvnDwF+D6Wf/mXUX/o4ZbPNZ1k91UniIKs1gmDIlmw8e/sxGSFPVkRkBWwc83I7g7WQRtRuiANqLy+HTMYS7rhNSsQRIT7ZsXBhMlUMEWrGPsZsQlCKUGOeAj4oQWagfIme00HYbJE+EVTwmBy55ks+0kmR30qCrKEJ2vA4Ivsnidrb3b7TPPdpXqJmXjvuXCPlAmMdMrdmayoJ6tTEfHDG+wGcnB6PwDAaZIL8uMXksGH/w9Qj3RTCBbLyMR23KIjQJAMvZDx7fm2x99pckl2Eal67OrpRDxZYYR7/0yWWEyPDGRxP9ZcrnkhLEDW3St3D/z8B6dTUAhb/AhgNIpplgte4HJBds4IkCUW6vWyC6onZDGj16tkkJCm8It+PVkiwj3qydrkTNyizm96bXyLYiZTBgokC4vqIKDy8yVA0Ja1BTfovvgOKhW4XC5oJnUZ3/4k3YelyXDntH+5YFhITCnFyfvZ4wdJFRRjJDTA4DKTYsPfxkHWleQs6kMyT9vONtzAlRHuO+nJWsixz3G78AtZJ6GEn89emCEpFwwClGgaiQaQRX0fVp3vKkfe99EWEosY93GCLHY9zxB2vDXHw9NmngaFKFiprvQso203j23tvB+rbHsQ4XBCEeHxfQQtwd4fSqm879F6HWd/4RfgnGtOqZxJs0W+i0hATBRkRTa+xDog6scCQo9yU7pgNPgi4snywO595sTuiNpWZQT9cCCrWrLhuwEUheDYNHutK+q0TEIWM51mn1XHD5DRGchtZLJkwBXVkVY8KResVNhbohkKUjkD/Y6McV9px2TtnCfLfpKB+CiTNYhcMAioZNb3mKy92fUjdlmK2xPYn9kPN3CHYiraTtST1Wainqx4EXFcLvjwJgNZR+cPA2iWC0pW4sAzgblrAK8OPPAXzcfSoYjYaRffPoAfCwCynMmq8C0q4fmKygWj7esixr0rkzXi4IsLnMmaa7HreMvCLVCIglOlU1itrg70/Kam4sAUe59OjDD8Yl3IBTMmQClo+QKor8jFqFicJtK6DE+plqJdWYPHuPeTLugGLjbr7HHRdEF5/Nxn2I3JUhWCqVTEl1Vi8rK8mYfGWZENkebZYfxqKBc0UxqLwgaLb1+aCBdX/YKs3HQSIEwWW1ip4fzjRQDA0RsHB1kAoGXZZ8XebpD6TB5GhaRhEg90fbiAg02LvT+BKBDfAU+WiHDfn2ef+7bhF/x65HmR3eheQJYnPFnANtJNTJa3sQlPYc+XnAoXyGGM+yhAVqbn4x14OJOV4oxKxWY+mMvyDEg8tD6cZFCEXlw5uXPJgiWu1EjqKhJCquexa5iWYO8PdRyApzYaR4/C39zE2Z//t/K+JWY+k+f/FcDy+f1m6ggrdnYqYUAVInLBhmoQwWTRgML3Q6BiOc09Wb4XICDsnE3kd0dhrPRkDSkXFMmp2ekEMot5pPg9ceVEMfZzSUOVn7eE0hpkic8nDXSkaB2gDGSV+XVuYjbVV3y7mDxnsqyqKzerAcjNxZ0KvqCUwj7BmKwzuXk8uR6XC/YTfFErOaABBVGI7PL7YZk9kHUJzmTKACGMpr5l/jkAxiQZFB1ZudZFxJTSBrlgCyYrY8DxHRnOccU8M+yG6YINTBYhIZt175+Fu3SyI6s9yBKeqcYiYmWAImIgTBd0Rbpgqwj3yGJOFBJ3YrJc38WWxcDBqIIvOjFZE+YEnjb9NADAd1a+M/DvEKXEo4xxD5msBFAvgDpsYSKDL/hFnBAid+crA3dlxRMGReLXdt1FEHSWQG7WN0FBoRENU4mQrdrkcsEptTdPFtA6YVAhioxY70UyGER6ssyUJjuyTtB9WMoPDrJUXUGWm5Lv/8oZUArMHMggN9O/5CU65gSX+pQbFhyE4LTOFtL6WmupVK8jQLAEMTsY4X5gcj9UomK5sozzlebPvhErJOYL2e3uQTTdPFne6gpcLgtLRnbMwxj3EXRlZXaAyeLKhBRl75noTZPhFxvDhV88UeChF1M7x2QV63E/FgD4nOnQxGI5Inc++Kcfh7awAOfkSZz7xbcgcML3bj6TA+UL+IqIcddMIH+Q/XdEMiiYrGa5YHjuRNkgyw2QIXFPlgx4AmDmu6eS7sSMSi4YDaRQ5w8hX2Kv3fknm8uGxWa2QdhnoLGQWAJeqiHph9eb7ZIvf8cgoxuqlNRFfVk7HeHurayA1mqgqorz6RmcWKvA8wM4HKT3A7KEHyudN5osDT/osweyLsFhO+LsAnD1xDMBsCj3UfplAADbnYuIN6sOu0i3Cr6ohEzWuco5BDRASkthYYrtiru2D98PQrlgNUKNX//TgJ5iO/RnuMxNdmR1AFmNckG+I6gNKBfUVQUpQ4UjerKEXDA5FUa410LQIZistdpaW9mXkJ3pio5Js/uivJdZk0xW6x2iUUgGj/LwixNrI2SyonLBMuvIAtAkFwTCRKJqIcpkDd6VJYIvAsqkPR2PkwdSzKRmYkWmIrhjEqK/pgeQlTZxHqIrK1JIzBkycX60G+q6oJYVA1mUywWfoPuwFCkiHiRgRSwMHvsO2+E9NoRUUEySx4rTarOG/1yCLXzTm48M9TsEk6WKcvOxB1840pOVNBNyI6MVmyW7siyvr0JiAbISIl2wAWS5K6twpTcvXMxH0ziHnX4LlAcazqAkGkHWCHxZbuDiySJbSF+U+PZIBLrLW+01EcXN73kkmYS+uIgDf/InUDIZ1O65Byvv/FVQrqCYTBtAwMN/YgmDzeEX7YIvFJXIgOCoL6vu+kgLJovLBYWUX/VtaBM57IaRnrKhQVYYSKEuHcFEiTE1K08Umn52iksGFdo6XVAEX9DAQCryvmwX+Hs/O/jm1ORisy9rpyPcBYulHzoEX1GxXKxjsxqC/0QfwRciWTD7Q5YsCOyBrEt2xC7LonktEmoCa7U1afAd2XQJvji7xS5Y02AfvFbBF6msgTPbZwAAh3KHkIgsBpy61+zJAlip63U/xf77nk+wf/fEZHG5YCOTNaBcEGDhF6InS/ZwaYaMU6W18CI4nZyGrugIaNDWRxCVCg4iJWg1gsmKxrdH59alWwEA3z7/7YGB+DgKiWMgqxKCrIBHXUdBllg4VgqDMllxkGVqoRyk1CVhUKb0NRT6CpCVpb1FuAOsSPx8g1wQ6D3GXXh5pCcrQYAtdjM8QffJcyCggQSH/Xj/xMIg8Nh5cvTG4SWt4saqVJv9CatpJuHKFYcEWZzJ0tNc3jZ2T5aNgG8GaLqCZyywhLxW4Rdi08e1/Ij8rjsz1MRkNewcu6srcDX2WYl2mImurNoogi/6ON6Bh8sFzUCALHadFUzWIxuPwAsGC0Z5qvQU3MBFWk9jX2bfCA62txHJgiK+Hb4HL2DvkSa6Ifm9Q9wDE1degf1/8F8ATcP2F7+I9Q99GAAL6aEB+wzFuppahF9EI9yjQwgJu7IiIMt2XKS5Fw68j0vUq6heHUp6tzBZPMzKp12VB51GyAUnZpNQ912OPAdZ62fKcBtCQUTAGHz2WjaBrAiTZYqkQQKUNtjrmZ8bXGrZype10xHu9hPsvEpecYVMLX54mW1cKwQwtd7hww9rsiCwB7IunQkC4B9+DfjM6wFrWxozSzWKZy0+C8CIi4ntMiAu6G2YrHMF9mGfouyGEo1Jr0WCL4RU8GDuIBRVkYtnuxoBWY1llze/kf37+38NVDeBcj9yQe7JGqKIWEwuqUHs3bgRGQVJ8x3eyGJOIYpMGGwlGwJGH3oBRD1ZrS9gN8zegISawKa1KXd1+x0Z4z4iT1bN8VDlNzXGZF2QxmEBsrQokxXtyppijNFgTFakkFj6sjrLqgRYifqxgFAumPIFyOqFyYrIBQfoyhKfE08sTL11kMBDlZrwM/ugq+ySXrAK8KgHAoLp5HTX4xKTi+y+5udTckd1mMlPcdBcTzWB/M0MK1WfKj8GBIP7LQTIMtNso2dnerLC2PRnzDOQ1Sr8Qmz6uLYnN6L8Ppgs1pPVQi64sgpPFyArZAlHymTthFyQn8tGEGeyjkwcQUbPwPItKfnrd4Qf6/L85TEWetwjkwXFpqJTgUc5KE/GfcjiHggA6dtuw+Jv/RYAYPNjH0PhM3+ByZQO6jOQtVGLyExlV1ZYSCzSBRuZLCCaMBiyQdSNXM+FXLDIjkvzLAmyL/aICHegOSGxnylG5IJk6jBS/jpMu4AgAKuriIyIcfc93h/YIBcUniwEBhL8dSQaibBlQzBZLRIGFc5k0R1jsthawTx2DMfm2HnwEAdZKUPra5O4svXD2ZEF7IGsS2cUBXjwL4BH/xYonI5FjD5v//MAjNiXJVgsIxtLHYqOAFk5vqMj0gV9P4BdZTfKZE6XTNbBLNOQm7zTxa57UOSuXsPO876nA4s3Ar4D3P+pnpgsp41ccNDgC4CFXwgmS8oFASgZ9pyNST/Cl7VSbR1+sVYdbUcW0J3JMlQDN8/fDAC4+/xgkkHBZJ0r1GB7w3eVbAgQrqtIG2qMyfJ5n1CMyRJdWUUL6pToymqWeLQd6ckKgdmEiHHvxmRx4BNNFgRCJsv0+M23B5A108KTBfQBsvhiV8oF6+yzdYIuYXGy2Y81lZiCrujodfKRXpejN82OhG2dnmGflZSdk8BBTD13GFVqQg+spjjqfkbIBRP8c7mTnixNV3DT3E1QiYpzlXNNwTe6lAtGmKweQEsY4U5RIxloavx27a6uwhXnQbpZLljbdhD4w8mrwuMdv1xQDywoCFDhnWkKUXDdzHUABu/LEuqOK6d2LvQCCK8pcZDFvaZJXhjdAmQBQP5VP4mZt7wFALD6m78J/5++CULZtX2tUgx/cJb/TWe/DVgMILQLvgAQYbLCc4LY7H0NiApo7HfUC+xrmm9Jj+PFHi3Cmgzqy6I0jG+fmE0CyUloCYqJIpcMPlmM/bxIcbYd9u+CHb/fCCaLUh26kA5qOsobg8e3ixFdWVtRuaBksnYGZDk8vt287BguEyDrHLvX9V9EzJmsqT0ma29280weZv8unJaN5JtVG8/d91wAwAPrDzTttgw8IvSiY7IgN9k6Il2QgSwRh0oIkEjpeKrMmCxRjCtAllNrIxcUEw3AkNLFPjxZQ0a4A0AuocFt9GQBIFm2oA7s+KJR+LJaFZMCo2ey/IDKxX47JguISAYHTKGczZjImhoCCjy1ObwUa73CLrozWYMt5Mssvh0AAoPdTPTIhTwsJLahTXNP1ubgniwAmOAR/d0SBtt5mzYqDjR40IUev0uEO8Bu3Mu8KysKsgSA61ZILFLePC4XNGrsRvjEkKEXYqILg1H4sQBgeoaxN2kn31RInDINHKfsuoCVwQMOBJOVyrL3YBBP1mrJwjv/z4P4/vnuoRTRCHdVV5AxMrLo9tGteFJiVC4ogyT6kAualMLRmze6nEjwRVQumMyKYKQw5XXQUbO9H+/AE+lnSsFCLeKRlOEX64OdG4LJ2kk/FhCCrIkkl5zZIZMlrmsSZLUAMjO/+P9g4lWvAoIAy//+l3EZ33tZr0bu7wdvY5LBegG4+78B6MZkNcsFFX7t8rU0hGnL3uZMFtyRSdqHHaIQmTA7qC+rtu3As32AiCRVAjWlS8lgI8gS/Y2WxcBnyWoIvhASwUCHzn3pdmoaQUCh6srA3YIAMMXlgpUtWwaRSCZrB0BWNFnQOHYMl3ElywPnBJPVH8gqF/aYrL25FCYCsqYjjeSLmUVclr8MAQ3wreVvjeZ3CVCT69yRBQCmzS7Kao4tpsSNPZHRQRQS82QBgMEXt1bN7Qyyrn0NY9K2TgJr3LPRg1xQerIkk5Vv/3d2mVwywmRZvpQ7KWIxZ8elZqIrq12M+6CL33azWbERUKaRFjtvrUaEX9xz4R64fv8LL0JI6MtaH35XW/qxxDFXVkEFk8V3VFt5sqpFO8JkDZ4uCAB5vgDq1pUlwiii7xmlDNxOICK3SXRnTJlckB+LVQQc9ngBurulC/qVCnxFDyOWt9mC/kSwD0sT4Q1sUDCfX0hh7lAW+6+axOzB1gx2vyNurEkvg0IlvlBJmxoeDg6z/xkByEpn2bkxCMj67D1n8ZnvnsUf3tmdUaMxJoudp2KDZbUWr0owuHzZsfsMvuA9PCalcPXmc8te3QTlksUoyFIUIvt5hi0kFnLBYHuMIEszAcJewxRs6ckCQpA1aPjF41uMydpxkNWYLhhlsrj0rR2TBbDr7eJvvg/p224FrdXwzr9+CjMliq16ZANA1YAXvof99z/9N6CyJrubWpUui4Q+Nway2PUniPy8s82eQyfDFYSPetoVKvc6gsXKTiZk75aaScqEwdWT2zHmV8gFqzV2/SraxZjcOcpkaXyj2eKJwROzSZAhUvQSGV3W3xQv8IAUkUq5AyDLW1tjG3qqCvPwYclkiQ3dRulyt9nzZO3NpTFRkMUXpxvcFyIkgyPzZW33UkTMd7y4gVfsekaLiG3flv1MB3NCLsguHk7dAxE9WbYN6jVc1M0McMPPxL+Wac+siR0fIc8ZDZOly3TBIKDweTExybHFHHW82IW3WyGxDL5IjwZkrXGwMpMxoXa4qF8+eTmmElOoe/WBd4VlwuAIfFlNRcQRJsvXm0FWhqfmVUsOlEnuyRqSyRILoJ7lghFPVtXxYXsB8oQvlhMTgNL9xjOdMVFBChXwhRUPv+g1XZDFt7Odb0IAfYttPjxJl2JMlixPTvXHRqmqgtf+6i145S/dNLJdbDOlwVPYa7y5WYx9L21qeIQeZv8zDMjicsHsBGMJ6QDBF6c32Xl9fKUHJivSkyUWbAtpdm26UI0D5RiTxeV3frmHCHcOwPWAIjDi3hjqOKiXeAm8RuQCVMyofFk7EnxBiGSz0sRCJcpk8YTB09un+1ZpbFlb8nOw0yBLhOkI32cUZInzRYKsdGvfI9F17Psv/wXmFVcgX3Xxq5/1Udlq6NG75pXA0tMBtwrc9f+2Db4AWnuyNI/LBSPnl809vro6nNR01DMsk7Ud8WOJ0SaySFdXoBMbru1j41y4+SHWWKUqX68ETlhAjDiTpXEmq8Y34obxY4nJzwtfFj9PRNjWmP2mQBh6YRw6BGIYEmSJ6Ucu6HsBatuiiHiPydqb3TwxkMWZrCq7iQrJ4DeXvwl/CAO5nC7Jgqwjqw7dd0FcHnwhmawQZJ3dPgsKiqyelZHl0pNVCz1ZQJvdZxGAAbDdTrFYbjFNPVmCyRqwJwtgwRfRJbj4HcoEX7xSFqstRgRfdGOyFlLtwWI/c2Gbh1606MiKjkIUGZAyqGRQdmWNA2RFPVkNZcQAkJowQBQCGlA4BjvPvEKh97TEKMjijxFdWd3kgpLJiqQLbvDjX9BFEXF3qSAQSlDCQuKzAELGqepWpeSn1UQ7soyUBrIp4tv3Y3GIIuJxDiEETpL9TYXNOIOTNlU8HBxh/7PyYNiL18dQSrFR3wAosPzEAs7uu2MgT9a5LfaYUxtVWF1KT4NIhLvWALKamKxIT5Zkhnpgshzur6FUh2nEfXXu2nroy0vrTYBYFH4O25Wl9BHUMdREComrTgiy8om8VED068sSfqwD2QMtQcc4p1CLM1nUqsBHg1yw2p7JEqNmszjw0T9BMZPAgQ3gRR//MisxFkMI8OLfYP99zydQFbLZFnJB8Xujhb6aOMeiIIsDRF0bcSXMkCNA4qCerJgfi486OQUCihnKpNsrkb4soRbaqkD6WqNAX8h5KdWhcpBVT8w2/Y5BR/iyRPgF4SXWO8FkOZHQCwBYnEgw7zSffuSC1aINUAaSBTv3wzR7IOtSmpgnK5QLAsCNczciq2dRtIt4eHO4Yk8AEU9Wa5C1XrFhewGyMrqUSMAk5IKpbOjHOpg7KBcCUZBFdB3Q2P+3lAwuXAvsZ11gyMyxAJA2I0FWQkVgWVK7PGzwBSVAwH+t8H1JkIX4zpKUC1ZXEND4zSAa7T6qxa9gsuaz3XeIbl0czpcVMlkjkAtWhFyQH3f5gpQLymjsyIU8KoGyCF9AeB6CHkpdAYQgy7elRE/IBTsxWZZnyRtrlBUSsokDCc4U9BB6AUB6Kc8F8YTBlJ5CRmevb6fwCz/CZJkmAK8OBxrO0DnsizBZ40ixHGb8FHudyoU4+EkbGp6g++BCA+wSUDjd93OX3TLcwMVUbREnHyE4cfQnBpILnuGVFAEFnrjQ+RyPygUFMyFea8HcixHMumt5fQVfWHzh5gVm06LGa+PHEpMZNZM1znRBQCbbpWHF5IIAZPhFv5JBIRW8cnJnQy+AcOMmz8N1vEifotbgySIdQBYA6AsL+NTr70DNAA6dWMf5d787vrl09PnAsRcCgYtaiUnzew2+MDy+oRMBWQ4HiPouWw+rugCJA4KstbAjSz7nNLumT9ZYeuX5iC9LbGQXqi7yZh5APMY9ymQRh33OagZj0ieGiG8XI3xZjUzWTkS42zz0wriMgSxCiEwYBICk3tx52G6iUsHd4vHbydkDWZfSCJBVPINp7mva5Is9TdFw277bAIwoZbBL8IXwYx0y2QVPyWZBOAAS8e2JSEeWSBYEADMpQBYz1rYsJI7OLf+G/Vv8/W1GyAUNU5MsFlQVSmbwGNpcgt1pfJVdHGT4RXYW4F6twAoXMnOpOShEgRu40icipmAV4AYuCEhTUt2g0yuTBYS+rIc3Ho73rfQ4UU/WsMXXMSbLLgNuVcoFPcJe8yiTBYR67lolkN6Wnruy9JRMzxKSQbHLXOoQ4S5YLFM1kTPCHjgh010y+Y22R5CVMlQkdCWSMBgGpAgQ1wlkBZVqmCins4XcqWABPlQsDllEPNZJs2OtFuOvddrU4EHDSfUw+8IAkkHxOVt02HMEqgm/z5hjy/VlFQIAHF/tDN5pQ7og0F4uGEa4+9K3KvrOOo3DPR8uTbQuIm7RkSUmned+kiFBlvSQVaug/ggUEu2GM1lpYskIdzGD+rIuVugFEJEL8muMF6ko0Rrlgl1AFgDUDh3Eh16lwCfA9t98Aet/8AfxH+BsVs1m523nCPfwfTQCsYAP/Zcipdcwe2crdmLE6zasJysqF1Rn2SbyJPe2rjwZ+q6EJ8sLKLLcExkFWTUuHaRUh2Kzz2rVYAqFkTBZIsZ9hfep7WCEuwi9MI9dJr8mwi+A/pissohv/yFMFgT2QNalNdlFQDWAwMUMZQuLquOjzi860pd1bgS+LAGyckstvy1A1mEOstQIkLFkEbEe68gSIzxZovSwY/gFAFz/M8BP/hHw4x/qeMjRdEHpx5qYGGr3JMcBISdZ5A2IpGegqOxiTCM7S7qiy4Vtoy8rFqutjmabUDBZcz0wWYuZRRzOHYZP/Zalqd3myEwahADblhdrfh9kYiCLd6AF3LPgtwFZspC4aEOb4gmDvXZlERKyWXUGzIRfotRBLijS/hrLowWTJeWCPSQLssMgmE6bOC+7svqLcQ/KZXh8l9pU2M33SboEQ1OkvCV63P16ssY1apZ9VqxSfIGU5qEQx3GUfWEYkGUfll/znAA06H3He7lYjykVH1vtvAnhO44MnWjyZNUuxFhs4cly6p7c8OmFGRI9PG6QaF1E3IHJCuWCowFZQIsuw1GOETJZddeHHymcFSDroY2HmtQBnUZ0a10xtbMgi1IaMlmcLXf5wlhVfBmI0A/ImjCzeOCogk+9nN1HN//oj1H83OfCH1i8Abj2Najx527JZEmQwl5Dzw+Q4N1kxAzv367Nvt94/b3YM4xckFKKYqSIWIw6z6So2cITUDUF9bIrgyZMTUWWX5+SGvscREFWlYddINAB1wEFQV3Ns98xRHy7GCEXLK3V4fvBjkW4R5MFzctDkBVnsno/N0Im64fPjwXsgaxLaxQVyLOLbLp2FgY3ggpf1nOWngMCguNbx7tGQXccSiOerHZMFrsQHTC4fC4X7vLXuFwwmTVwphxPFgTiEe5AFGS1uYkTAtz4OmDu6o6HHfVkjaKIGAiZrDBhkO+ypqZBVMFkxS96ImWs0ZclQy/G0JHVC5MFQPqyBunLSuiqlKQN68sSTNBs1gQq7FyjCg8FADs/mpgsKYGyoHKQ1TOTBYS+Kc5kTfQQfLFWb92RJWS6M5rwZPXGZAEdurKSPYCsaujJMmkRAPAk3Y+liYQEgbZvy8XAbpELmjm+wGvAFhn+Hj80RMKgCL2YqocbQr5q9BV1fHYrvsHzaBcmKyq5Eob82dQsCAjcwMWWFZ6XhujJsv2+ItGdgJ1jNk22LiKWnqxm6U4YfDGkJ8swQAwGFMYqGRSeLMIZgYgv64rJK2CqJradbblp123cwJXF6zvNZFVsT4JEwWT5/FzU1HCTIQRZzUmAjTOVZPfXr12XwPS/+wUAwMqv/wYq3/hm+EMv+DXU+DUgfeF403M0RrhbXoA04eEpifD+7Tjs2FudVxdzJEgcAGTZVQ8O39SNFq6rS9wPWncxd5B9feVExJfFJYMJpRlk1UU3VqADjg3LnERANCgaGQmgyEya0EwVQUCxvV6PMFnjlQt66+sISiVAUWAcPiy/Hg2/6Cf4oiLj2/eYrL25FIZL5kjhNGYiMe4AMJ2cxrUz1wJgARgDT22LlQADbdP8BJO1oLILlxrZ8YwGX7RmskSEewPIGmKn1HcDBD67ORgNTNYwk+Nsh9gPlnLB1DQUbgymDeBQFBK3Y7Lm06Nb+K5xiVMvnixgdL6sYWLcKaWSyZrJGLJoOuBeK4+yC3gTkxXpylJFV1Zh8Bh36cnqkcmKjmCypgh/7/sAWdMZE+fRLBfshcnyK1W4wpPls6SxJ4Ollh1ZjRLHiznJPPddVuK3nJTBvn6/G+nK6lOKKpisTCUMxfFVsy9flgBZC7zQ+/hKuaMk1o+GB/DFn67omEkyT0Y0il+mC9o+iGCyeohEtwTICpJN8hx3dbU3T9aQTBYQslm9SBwHHg6ysoR7WyK+LF3R8bTppwHoXTJ4unQabuAiraexL7NvxAfbecSmjakpSAgfEWeytEiYRFDvncmaTrL7mENrmH3rWzHxyp8AfB/Lb3sbrOMMUPmTh2FxyX7qGx9u+hw1erIs10cGnGGLyAVdLtswUgZ200hP1gByweI67/TMm7H+RXWWrW98W8HSPvZ6rTxRlN8XkkEN7HMbkwtyz6RKDMBxUOcbcRMzSShDxLeLIYRgUiQMrtRiEe7DyvU7jSP6sQ4cgGKGwCgKsvqRC1Z+iDuygD2QdelNixh3wWQBYcrgUL4sIRVMzQBa6wutWJTMkXiyIBCCLCVF5YLvULYFk9WrXLCHcSI6ft1U4ZeKAEbBZHFAyGUqQi6I5GTIZJXisbqCyTpfiYOscYQR9Mtk3bJ4CxSi4PT26SaDfi8jEwY3BgfE23UPDu8jmclE5IIwQQF4PGVEM9oxWTY00ZU1RIy79GTV3LY3rVbx7UD4mZsAXyz3mC4IsNSqUC64LBdDvcS4B+VyyGDY7Px6ku6LJQtKqWBydtcYjQWzQqrx64mQCz7s7QMlKlDbCOsjepxNaxOab0CvhIvVvkEW3zR6wVVzIATYqjoynKXVCMkSUQBFDW+jMmEw8tkSTBYoQI1IZYXTmWVyAnZNq9O0XKyLcVc6ywVFEapVcQdOYxOj9iFxHHi4XDCvsde8MqQvSyQLXjF5BRSys8ucUj3uxwIAl/t2oyCL9iEXnMswkOXROuvQ+q3fQupZz0JQq2H1N94HAKh54f0zvXwf8Ojfxp5DerL4BkHd8ZHmICsmF+TXXzOzuxbF4fH3fz6XWkgFgXB94DsKFqeLABrDL/h1K+DSvUi6YJ3LeXXFRGDbIcgagR9LzOQiOze2VqthaXUQAG77jcFhJwy9uCz29UNTKejcm94fyPrh7cgC9kDWpTctYtyF9AoIfVl3r9w9UOksgK7x7QCwzBclk5T97jiTxX5vgbDFXs7IIZ/Iy+8bgh3iO34ilXAYkCX8WKquQFGVSBHxcExWlssF6xxkSSZL1aAIA3MpvigWTNZKtUEuWB0tyPIDKheCvXiyAPZeXDvN2M5BJIPHRlBIvF5hF91cQmOLRyEXpAYo0UDBLuSCARCTacVk9SMXbABZE/w8dPwA9TaR3TJAItnAZPGNhAwVIKs/JmtVRLi7NaBeANBbIXE0wt0MNhGA4CRdxL7dHHoBYGKKnTealYAfKfwUscA2DPjTPAWuT8ngZn0Tk/V5EISA0leMvq4nYtPoyvkMjkyzY310pT2o8PjpomnxW2grkKUZCgTW9bTwferGDNmUy7qCVJM8x1tZ6Rh8YaaZbAkYnS/L3wmQpbLPVdvwi43eQNbFDL2Q8e3JcEPBs9m9TtPCc1RGuLfpyYrOPAdZlMspiWFg4Td+HQBgPfooaBDIjiwNBDoAfOU3AT98HRuZLNvzpVwQZoTJCtjPmbldBrK0wT1ZrUIvgMgmLCWYU08yz/GGJQNjRIoz9dl7FE8X5KXNigHquhGQNbq6gMl59hkvrtagJML3Y5y+LLshvl2Mpio4zK+NSaOPdEEefJGd2l3n007NHsi61CYKstKcyYqArKunr8Z0YhpVt4r71u4b7HeURRFxa6lgEFCcK/KLFk/AUnI87c3xJRBZCxjIiPqxgHiEO6VU7uTRYUAW/52ik2YURcQAkBV+CiJ+T3jTIry7hpbjbEo7JmvUi9+tqgM/oCAkvBn0MsP0ZYVywcGZrLUWRcQAEPgqfDX8O/SmglV2ka4UbaiTnMnaGhxkpQxV7sy182XJjqw2csGk1z/ImskYsGGgzE3SIsZdMlkd/JR+NRLhrlSxri3ChhGTC+62+HYAmMxn4RMPBAS1SHeTpiow+eLJnmXgfxCQNVWLbwj5qtmXd0HEtx+YSuGqRXYta+fLop6HgLLzRoReiJFAOZIwSAiR0lfPi6SpdgAtAQ3ggLEeVZpBKsJkBfU6/GIxDEBp4Z0hhEg2a/iuLFFIPH65YE5hn6smkMVLiR8vPC7BRKeJMlk7PcVaM5MlQZYeAVl9MFmLOX59UWw4Hk/RPXAA0HVQ24a3uiqZrKSeBklOARuPAw98Wj5HYzpf3QmkXFCAXEopPAbRYE5094rt5KjG4HLB0rqIb4+DLMU0QfjzqhsnMb2fvQ6CzZIJgw57XAxk8Z4sQzFBXRc1fv0eReiFGMFkFVar8bqbMSYM2k9ykHX5ZU3fu+FAHgCwNNEbYHIdH1aVnft7TNbeXBrTsisr3KlUiILb990OYAjJoGCycq2ZrI2KDccLoBAgyRN2VF5aWa9wdkojOGs3+7GAEGQFPoXnBKORC4pkwREWEQMs7CFlqBDLFMGYAYBisptRsB1f6EtPVuV8TIY26uALEd8+nTahqb1/lG9dCn1Z/Wq7RYz7U1s1ON5gMqRWRcQAEPgKfJV9TdWUmAwLCGOpfTeAn2WLDn8IuSAhBBNdurLapfQJkGW6XD7SF8hif+OGwvw7IvxCLNDXa+ttU9SCciWMcCdVnALzmyy28GTtKiYrMYGqwV4rodEXk+GSwcoU8930DbKsTUzW4htCvmoM5Mk6OJXCVQvsWtaOyaKO0xTfLqZdIbHoynIsL8IMtQctjh8Co6qfiTFZ7ip7bpcvjBOpZiYLCCWDQ3dlZXaCyWLXlYzCmayGhfR8eh5zqTkENMAjm490fTrRkXVRQFYLuaAABlpk46gfkLWUzcv/XimzzxHRNAa0ADinT0vwmTYywHN/mf3w134H4N4hwWS5wpMVY7J46JAbMNkugER+d4Es8VnzB7jvhHLB5tdazbBrp3/hLBYvywMIS4nFRrblMFBRsqJlxOz+aygmqOONRy4Y6cqilEo2i46pK4tSCueJ1kwWALznx67Bn7/xFrzkaa034BunssVeI91UYSR3V5DKTs0eyLrUJs9ZodomFhLshtQYpy2j3JcHjHIXnog2ckHhX1icSAJ8d1PlTFZdxrcbOFvhyYLZOJOlm6qMsbVr3khAlmCYdL5gGxWTBQCHptMyXdCJGLIJN4XSSjH284LJqnk1bDvhbviogy8EWJnv0Y8l5obZG5DUktiytuSOb6+zkEsgZajwAyp3//udEGSFRcQAEHiQTJZmNl+aNF1FIsOlpiYDNd4QwRdAuBAqtujKopS2BMa252Obp0xqdiH+3D2MkPmeRxxkTSenQUDgUQ8Fq9DysUGlEolwr+D7HvuMRuWCuy2+HQByeg5Vowgg1OiLSfGNkeLENewLgzBZ9WYmK6j1thAp1Vz5fu6fTOGqBXYtO94mxj2IFhE3yPjEZ7upK0uEX1h+hBlqD1psPwRGFZqNgSyPgyzPYMcpPhONkx5RIbHsyuoACoceEXyh8HTBBiYLYNctoLsva8vakgz0xenIaiUX5JuAkfexH5CVMhJAwO5t58uR5Eqe/mafOiWZrJSWAm55E5Dbz1Qp//xRAM09WXXHb2KypOeYBjDyg/dLjmMaI+j7mXZyQQBQJ/gmwsYqljjIEkyWuFbX6+yzFGWyxGc0raoIAoJ6QhQRjw5kTcyxEA3X9lEp2LHwi3GMv7XFNqgJgXHkSPPxpHTcceUc1B6DPWToxVRi1/iDd3r2QNalNomc3JE/AHYj2WgwaN+6dCs0ouFU6RTOls/2/zt6jG/fN5mEX2YgQuG7nbXtzsmCAGMQZCFx3ZWa9LZlxD2MYJjEYiYQEe5DerIAxt5IuaAV3vyFETVoAFkJLYGpBFt0C8lg1a2i4rJFyqhkXLKIONsfyDJUA0+ffzqA/iWDhJBYKfEgI3xks5k4k0XdQDJZ7TpahOTAUtgxDObJioAs0ZXVgsmqulXUue4+GuG+xTc1EooP4vDXoB9PFt8dPevxx3C5oK7o8rxplTAYOA6o40i5oEGqOO6yz6gIvrjr3F342tmvAQD2Z/f3fEzjnpyZQ4WDrO1CHPykub5/M3M5AMIWhpXeKigopdi0QrlgMsfjxlVDprd1m7P8ejabNZE0VFy9yJisE2sVuH7zgi7OZMXP04VUsycLCM9nx/Z7YoYEk6VSijLNxiLc3ZVVUACuwhZcZjsmSxQSD+nJUnsAhUMP9wSJIIbG4AsglAw+tPFQx6cSG0cHsgda9kWNe1rKBbmPSI14WfoBWQBAKHu/L5SL8msCZDmnn5JMVkpLAXoCeMG72A994/eBelECPHEslusjjbgnS4RRqb4NLRf6tHbDDBp8Ydc9WFxh04pl0iaFv3cDi5ex9cLmcgV23ZPX6nKNKx4iIMvhICurENQwiUA1QEBH6j1SVUWCtsJqNWSyxhTjLkIv9P37w6CNIUZsqGV/SKWCwB7IujSHSwYXAnYjj3qyACBrZHHT/E0ABiwmFumC2c5FxPsnkzKKWJFMFu/Iyug4s93ckSUm6ssaqVxQeLJEuuAIQNaxmTRc0ZMVZbJ4OSCtNi8+pC+Lx7gLRiSjZ5DWRyPDWJNMVv8X9WGi3I/OcF/WgAmDMr49awCeLYMfAscLQVab9CKxO2+BSzyKRVCveUHWchrkgkCUyWoGWaIjK6NnYos1EXpxOC0eQ4BE7+eZkPmecvPsCz3GuIuKAyEXTChVPBHsx0RSR9rU8IUTX8Bbv/pWWL6F2/fdLhnt3TAZPSOZrMJm/PMi5ILbQQKY5j6AU1/v6XmrbhXUVpBxGGCdP8wAUj+eLOnHmmTn1L58EhlTg+MHONXiHKe2jaChiFiMkAuu1dYaConZz7sRuWCnGHdLSJEoRQnpWJqXu7oCX02A8tS8RJs+o/SoCol3UC6YQnsmS4RfPLD+QEeZ82NbLPTiyskrR32UPY24lkzEQBY7Xp0HKVHPA7XZ+9IryFJ5xcVaJZSsGUcOA2BywarLzlV5f7nhZ4HZqwGrCHzrvzQxWawnK85k2XwDSfPqsjh7t4yMcG8TUtRutjmLlczqYdJn9Hmn2QaaXywhndVYjxYFVk+UpCerxFNRK24FbsDeXzdg719OISgTtnGaNt0mmfuwIyWDKzXZlTUuJkuGXlzW7McaZH7YO7KAPZB1aQ4HWdMuA0PRCHcxMsp9eQBflgRZXYqIJ1Pyxht6sthFWk8rUrLRyGQB8UJiMhK5oPBkCbngaMqIARb2EDJZEU9WSqQiNjM6MmGQFxKPwycjOrL6ZbIA4NmLzwYA3Hvh3pj/o5cZlsmSRcQZU3ZkQTUQWA58hd3M2jJZHGTVbJWVVFMqpaFdR8oFN2VseidPVreOrMMp/rlLTLCi8B5nkt+4zwctCokFyKq3AFnlMigI/AiTdYIuYXEigf/x/f+Bd33zXfCpjx87+mP4gxf+AXSlNcNxMUZVVHgpdr5uN8hMU/wzW7V94NrXsC9+/feAoPtiaqO+gck6W+BkJk0Jwn2ld7ng2UjoBQAoCsEV82yBeXylOfyCRuSCjZ6smeQMFKLAo57s7wJCht2x/J6YIcdlr5VJKbZpKhbh7q2EHVmarjRVHYgZWSGxON4dkAsmKHvPGj1ZAAt10oiGjfpGx/oJGXoxtfNSQSDCZEXlgvzyopmcaY1sAPQKsnTCPvcb9fCcNCWTdToSfMEZCEUFXvRe9t/f/iNoLtvMkiArKhfkniy7xICa5ltyM2C3jPRk9SkXLK6J0IvWr7M6y+7Vng2gvIolzmadf7IoN8QKZVWml4oYdwmyCFBR2TUom+g/lKPbTC5Ewi/4xm4/ftN+xhGhF5c1+7EGGeHJyvyQJgsCeyDr0hwOsnIWW5xtVpymnT2xi/3dle9KyVNP43tAhS/w2niy4kwWu+CrDUyWa/KId3OyZSGqMEHaNXe0nqyEChpZeI9MLohmJktJs7+5sYwYaMFkVUcbegEAF3hH1uwATNblk5djKjGFulfHA+v9eWCGTRiMBV9wPxYy86D1ele5oFw4bjsSQHu9SgZFl1XgAjZb4MqurFZMVpuOLAGy9iX4AqUPqSAA6KqCfErHMuWerO0WIKsVk1UJkwUBIEgmUUYSQf6L+L3v/h4A4A1XvwG/fftv7yqAJYameKhBg0cow9/rquMBt/4/7PXceAx48LNdnzMqFZxaSstEyn6CL85EQi/EXMUlg4+28GUFtgNfeLIaQJamaFJaGgUCugRZXoQZag9abKsIgIMspBvkgpGOrDZ+LCD8rNSGlguKMuLxR7gnaHsmK6klJXB6YKP9NetiJgsCQJF7siYFk+V7Yfdfgr0n8l6n6yBGb8mwCS6RLkRAlpALusvLqNfY11NaBExc+TLgwLMBrw7twf8OIBLh7lgwCb/u8dffKrBzUvMtKD0e107NoHLBTn4sAFDzPETJUYDt5Uj4RVFuiAVUQZavY0p2CW7gIgBbC0yoQEXjICs9XCddqwlBVi0SfDEmJkt0ZLUIvRhk9pisPZB1aQ4HWckK81t5AcV2PX5TOjpxFEvpJTiBg39e+efen7u6BoACRAXSrY3zIcgKmSxRRiyCL6oau+C3YrGA0Edg1yNywergseBCLmiYKmi9DsrL+kbBZB2ZScPlTJYVeZ1Jmv3NrRZz7ZiskRYRC7ngAEyWQhTJZvUrGRy2kDgGsoQfKz2HwLIkyNK6eLKq0a6sXsMvjBQgZH+ikFh4sloEX7TtyOJM3KLB3/c+QRbAEgZXZCHxCiuYROcYdz8CsjRSx1ryAMyFv8QK+TsAwFtveiv+4y3/ccfLV3sdJcv+xnopfq1KGREmKzEBPOeX2Dfu/G3A68zCROPbp5Yy8rzx+/JksffxwGS4OL2ah1882orJctozWUAYfhFNGDSkXNCXG1KdItxtzoIZlHWIpSJeHnd1JUyYbOPHAoD0BJc4DRt8kdm54Asz4ExWC5AFhL6sduEXbuDiRJEtFHeNXNCpwKP8upbkIEt0ZPXIYgFAkveiFazwnFRnZljPZBAgWGYbejE5OiHAi3+D/e5HPwcgZLL8euT8454suyS6tnqUYO/gaAPKBSXIapP6JwuJbQUonZXhF2uny1CCsE8xrbH7fdEuwvbCz1ROCVDV2D0iOwaF5eSiSBisggi54Jgi3O0T7LNjHhuNXLAsQdYek9XTuK6LY8eO4fjx4+M6nr3pZSZZ6otSfApZLrXZaJAMEkLw3P1MMthXyuB2RCqoNJ8eQUBlEfG+tCp3VMRupwBZRYUtElr5sYBGT9YIyoiFXDChhvIxXZdSxGEmm9CR5oWf9YisTMnkAbTeVWrnyRqpXFAEXwxYGilB1vk2IItS4MH/DRTPxL4s5IJbVQeFaudFcOP4AcVWNcpkcZCVmgd8v3vwRaQrS5viXVkDxbgzYCY9Wa3kgvXWKX2iMmFe4+drH8mCYqbTBtaQB4XCmLVqHIS3KiQOKvH49t/IOjAm/xkECt5763vx5uvfvKsTnIwcOza3TBEEIfOekXJBvrB75s8DmXl23t333zs+Z4zJWkxLL18/nqxGuSDQmcmKygUbmSwgDL+IJgzG0gUz3Zkhm6dLaryPKxmJ/o7KBROZ9rHIgslyLR+ONfiiWcobd6CM2PDZe9FKLghESonbgKzTpdNwAxdpPY2lTGtP8binSS7oVOFRnpqa4MxIn6EXAJDiIGvbDsEuIUSyWerZNf5zDc956Fbgih+FxkMuBBMUWOx5XGIAKt/05BJ0XRm97G3YUQdMFywJuWA7JmsyD0CArGVMzCWRzOrwvQAXntqWCYNJlX1ui3ZReiYpJQxk6ey+nsuNfoMrP8/ez3rZhWey6xK1Rw+yvEJBVqKYR5uTBfsdSmkoF9xjsnobXddhjbFpem96HNGVVTyD2TS7eTeGXwChZPCuc3f13ock/VitpYJrZRuOH0BVCOaUKOBgN0khF1znRcQHsgdaPk8MZIl0wWFAliUi3NVYR9aoFp3z0+wC7UQ8WYR3NQV282svbvCCyRKLZmGMH3aCgA4c4S5G9GU9vPlwLGpezsP/B/j8m4C/++XYl1OGhkVeRnhyo7/d7c2qjYACCuEpe9yTRQ0mnRMR7t2CL6rFCJPVV8JgxJcFYCLV3pPVzkcn5IIzKj9fB2SyfKiomRzAcV+WkJq1YrKi8e0bho3v6QXQQMXPHHoXXnvFa/s+hp2eZFZnEpuAyM0YAEhzQC0T5YwU8Lx3sP++6/8FnPbXhc36JiZ5fPv0vnTYk9djhHt00+jAVLgIu5IzWSslqyl5MhrhrmktQJboyorKBTmQdGyvJ4+Tw8NgVC4zS3Imyy+XEVSr8PiCu11HFsDYM/F61IYoJJa9XmMtI2aviRZYUBC0Z7I4yDq+ebyllzQqFbwYjC6lVLLi+VZMFmdjAi4x7wdkZflrVHHiYFdEbevL7JrRMlHxRe+FRthxBT6F7weg/HkcNfx5m1/bdHX0srdhR0a4DyoXbOfJisoFS+dACJFs1sqTRUxzyaBB2OegZJdgeXwdTDWk4YQgK9+7N7fXMRJaqOAw2CbhOJgs4cfS9+1j7Oiwz1f35Ob3nierj/nFX/xFfOADH4DXa6LX3ox+ckuAogO+g8tS7GK9WWmWhNyycAtM1cRKdUVKKLpOj6EXC7kEFHGjyGRAVHZxEYun80H7ZEEgCrLc0TBZMsJdC0HWCPxYYvZx9saPXOCVLFuwB44H+PGFmJALFuwCam5t5MEXWzUHXkBBSFhu2+8spBdwOHcYAQ3w3dXvNv/A43/P/n3+/qZvCTbrRJ++LAEMp9Im69rgTFZgcMDETdvdItztmgdMMGDmbQ1eSCykIK3SBdsFX4heujzpP75djNgdLRpcPspBVidPFpMLsoVCUbegBjrqZ9+IHzn0I33//osx2UQWNYMt7KKFxEIKV3Mi95Sn/ysgf5DJSb/7sbbPuVXYRsrNAqCYXIiALKU3T9aFsgXHD6ApRMbgA0AuoWMfL3h+dDW+AUFtp21PFhCykVG5oB5hsgTr3yn4wuLmeoVykMUX5+4Kuz57WXYemx08WcBourLEBtp4maxwUZeC1TLCHQAOZg9iwpyAEzgyRTA6jxXY1y6WH6vm+HB9tqEpQZZdgStAFmckB2GyJrikr+rFr7mCyUquMGDeMr12/mnQrn+l/F/fCUAt9n66EZDl8Gubvgt7Y8Vr5/cBslzblxsMvckF2XU4WkosYtxVCLlmQYIsGuhIeAF8NQHQAJmJ8fjYhGSwrPCN3TGUEQupoDGq0At+jTfTWttN0x+G6Rtkffe738XnP/95HDx4EC996Uvx6le/OvbP3uzAKCpbgAC4Qt8AAGy0kG0ltSSeufBMAH2kDHZhss5Fdn1DPxYPgKBUMlmnXfaB7erJGhWT1UIuOAo/lpiDc+wiR3yKgHfnkBy74FGfxLqXACBn5JDR2eJktbo6cpC1xkMvptMG9CEiY4Vk8O7zd8e/EQTACda3hOpa0993bMDwi5gfC5BMVqDl2b8Ndi6082QZSU0uWO0cey0H6sqqc7mg7Mlq/vxIuWAyLhcUf8MEFSBrELkg+/s3FBF+wWLcxflRsAtNO/XFzWW43JMVqDXo594Av3aZZBV3++SMsJA4uujPRNMFxWgGcMevsv/+5ocAK4ytjk51jS3GlYkAuqnKpD1fNXsCWWc2w86/xoLNqxe5L6tBMsg8WeyYOzFZreSCTlQu2CHC3bYZsCOUPU5EuIsiYj/HzptOTBYwmq4sCQqrVdBgTAyHZjIfMIAU7LZMFiEk9GVtNEsGH9+6yKEXfLPGUJUwrMQph3JB/j7SAUBWPsmkYpbfGmRlVthnJKm1ARMv+hUA7P1zH78LW9zL6uuhkcjhx6/vrswLAINFuAsWy0xrSKRbf1akXNAhMoRI9GWtnChhWjzOZ2uAkl0Ky8KpDrXOrhsJa0t67kY9IvyiAr7WGgOTJUIvRubHklLBS+P+NK7pe3WWz+fxmte8Bi996UuxtLSEiYmJ2D97s0PDJYOHVbYQbMVkAZC+rLvO9Qqy+O5rrh3IYjeH/ZMp+CJZkC8aXMuH77GL+KrPLlaHsm2YLJ4u6ESCL2i9DuoPpgWXPVmmGsa3T+QHeq5Wc3QhjLMVgE4ycD6JdS+JEWzWU9tPyTjnUQVfiPj22exwFzAhGfzOynfi37jwEFDbCP9//dHYt2X4RZ8x7rIjizM50pOl8hARDrLaMVlAGOPucHDj9Rp8ATQxWe16siilHeSCDPykA85wDMFkrYKDLN6VlTfzMhlQgDwAeKLwBL7w4Gclk3WLV8Z69QoQAixcKiArUkgcZ7Ii6YLRuf5ngJkrWY/a3X/Y8jm9Db4wn2O3Mj0SfEF7CL4QoRfRZEExVy0IX1Yjk9XFkyXkgrVmuaBrez15nBwhCaPscSYHc+4KB1lpds61WziKEV1Zw4RfyChvSocKJ+o4hMgY8TSxUGvjyQI6+7KEXPDKqYsUesE3ayZSeihVd6rwR8BkTXOQZfvx81qArNwae2/aFTCTyUPQuAzQvfO/4Nwq2wRIZcJ1WxggtfvCc2SEex9MVmm9c3w7EG7GUl9BsMnWLTP7M9BNFU7dw4zH3zOPgdeoJwuBDtjsM5qsr4MY40l1FV1Z5YCvOcZg25EdWSNOFhxlOfOlOH2Twn/2Z382juPYm36Hg6x9uADgupaeLCDsy7p/7X5sO9st49Rj0yOTtX8yiYD/rGCyalwqqBgEnupiKjGFjNE6bsfgckErUkYMMK2xmulfDywi3A1TizBZowP9ly1m8QgoVBDYdQ9mSgcx2Y2Teq1B1lJ6CU8UnsCDGw+CgkJTNEwm+l+QtxrBZA3qxxJzy8ItUIiC09unsVJZkcAQJ77a8AuPA4duk/8rY9z7TBiUHVmSyWJAJlDZ8/k6uyB3khek8yYKqzVYWg4J9MlkCdZJpgsysFNzfNieD1Njv7doF2Xp5ExyRj48iAR3JLzBQZYAmWd9/tgSSwolhGAuNYflyjLWa+vYl9mH+9fuxy9+5Rfx2mpVgqyJhAZ4BHNZcygmcyeHMVlsEVMthouEpuALMYoKvPDXgM/+S+Du/8YCMdLT8R8psIVPfjEuMw169GSJ+Pb9k82LMOHLOr4SB0OBbcPnQQGa0fzai42U9do6/MCHqqhxJivHrkudPE42rxhAoCOpq3LB7q6ya65rZgGb7dB3GgGyakN0ZSmmCaLroK6LoFyWzNbIx8gAVglp1HGhDZMFtAdZW9YW1uvrICC4PH/5eI6xywhv52SUYbQrcBuYrEFA1kyKnTcubQRZbCMzXXaRslSktfb3Tz2ZgFfx4K+dwKsVJi9MREGWzQBMq9Leiz1hmXIfIGutc7IgAOY/0lTA8+EXClCcGhQjhYWjOZw9XkCmwoCn60ZAlpALUh1+nb3XqfoaFHM8TNbUIjtPyvwY6Bjkgo5gskYmF9wLvQAGjHD3PA//+I//iD/5kz9Bme/GnT9/HpVxGmP3Jj4cZM157Ka71SblbX92P45OHIVPffzT+X/q/rzRdMEWE4tvF0yWKCLmUkElyS6C7fxYQEMZsWnKJMOgRedULxOTC5ZGz2Ttn0zJGPdzfHdMSXLplk+k/Cw6Ivzi/rX7AbDF16jM2MMUEUcna2Rx7cy1ABqi3AXIEgBiPe5/EJ6spzar8Pzeb3oxuWDgy1S9AOy1FEW7mqngg/d8EB+690NNoS2CybIIu/H058mKg6xsQoPYcI52ZQkWa9KchKGG2plCzYEIxjMcLmEbMPgCAE65/LFcLgiEzNmF2gV849w38OYvvRnbzjaWyKSMcPd5KeVSvv3iYbdNzsihahYBxJmsNAdZFbsFe3H1TwCLNwBOBfjm78e+RSlFsswWiHP78gDiTFYvcsFzMlmw+XUUcsHHVsuxNMSYJ6uFXHAmOQONaPCpL9lIXUa4e1B78DjZLrsOBlSXTB8AeOe5J4v7aLoyWcKTNWRXlgy/2IEY93QHuSAAXDdzHQgIzlXOxQqfBYt1IHugLZsz7mlVRMzkgjw1dQgma5aDIapYsCKSOTWTgTbLJM2LW+2ZLADQuP/Rg4k7VNY1RiIboa6ozeoiQ70YE0a498Nkde7IAtjGVrwriyUCC1+WtsXWVnWLbQCW7FKMyXLr7L1lTNZ4dJb5efbZqDoafEUfefCFXyrBW2fXKmNEcsG9jiw2fa/4nnrqKVx33XV45StfiV/8xV/EOn9jPvCBD+A//If/MPIDFLO1tYXXv/71yOVyyOfz+Df/5t/0DOoopXjZy14GQgj+6q/+amzHuKPDQdakzS4IG23kgkCYMviNcz1EuUsmq3X87VkpF0zKRUJYRMwuRp7JLgAHs639WEAoF7RrLgghoWRwQF9WXC5YZMc1QvmqqhAEKluNP7XGzjtZDNhGLihi3B/eeBjAeIqI54aUCwLArYtMMnj3CvdlOVXgDAdcz/jX7N/r8dqGpYkkEroC16cSePcy6/w8nc2YQHUDoAEAAgreH8Mj3B8uPYg/f+TP8YmHP4FzlXOx50jzi3bdZze0gTxZ3GOmKESGX0RT5MTiuG3oRUoH4QlwA0W4c5D1hJVnXyg1g6z//fj/xlu/+lZYvoXb992OZ2avlRHudb4gXZq4dEBW1si2lAuKdMFao1wQYDKyF76X/fd3Py4XQABQdavIVxlrdOAwe82kOb5XT1aLImIxh6fTMDQFddeXPwfEPVmt5IKqosrYf5EqKiPcbV8CFuo4CJzWm2O2y35fEBhIRIuIuSfLATv3dw5kcWA41kJidk6nuFwwCmyjkzWyODpxFADw0MZD8usiCONi+bEAoFgP5YJy7DBdUPiKBunJmuNMFlFsFBo8pEIyuLhFWwdf8BGfjwKNMMJmRArvsXuckd59pizxWaMBS0fsZYRcMN+ByQIALRbjzlQFImHQXa0DFKjWeVhRA5NlWey5U2MEWcmszllrglpqfuTBFyL0QltcHEhJ1GpCJuuHWy7YN8h629vehmc84xkoFApIJsMT91WvehW+8pWvjPTgovP6178ejzzyCL785S/jb//2b3HXXXfh53/+53t67Ic//OFd3R8z0HCQla2xC8Jmh74iIRn85vI3EdAOFye3DlhF9t8tmCw/oDhfDOWCwritSCaLHYOlMxDSmcliNyHHYjdTWUg8IMgS6YIxJmuEwRcAoPCL/DLXvhMOsoI2ckEhvRO7XiPtyOJM1rByQSAMv/jOynfY+fHUPwG+w8JVrvwx/gvjnixFITg8LUqJe9/dXpdesrCIGOlZGYMvItz/5qm/ko95YP2B2HOIi3bd5rvClUrbxWrTNHiygDD8IurLEsmCjR1ZG9JTZjKvEDCUJ+uEzTcCKhdk8a4I2vjOynfgUQ8vP/Jy/MEL/wCkWpcR7psaWxgt5S+dG1jOzKFqsM9m1COUbicXFHPZi4CDtwGeBdz1n+WXl1fXYPopBPCxuMSArvA++YrZUxmx2DQ60EIuqKkKrphn4CLqy2IR7lz+1QJkAc0x7oJhcyw/Fo/cjs1yPN5pRI0YkyXkgo7Pfm93uSAPvhiykFj4bv0d6MpKg10jah0CDlpJBmV8+9RFBFmSyYqArGhPViOTle4nwp2DIcVqqpwQIGtpizb3ZEVGyBX/t/v88ItRkBWo/Eu777oS/az5PUoGQyar8+ssVC8ixh0A5o7koKgEbsXDREBQroYgSwZf+DpqFvs8J+vr0kIw6iGEYIr7sqqp+ZEHX9hPjtaPBQCVLeHJ2mOy+ppvfOMbePe73w2jAbEfPnwYy8vLbR413Bw/fhx///d/j49//ON41rOehdtvvx3/9b/+V3zmM5/B+fPnOz72/vvvxwc/+EF84hOfGMuxXbSZZABGt7eQRr1t8AUA3DR/E9J6GlvWFr6/+f32zylYLC0JJJpZoLWyBden0BSChVwCQZnLBSWTxS78JZWxBO2SBYFQLgjEwy8GMVb7fiADN4yENhYmCwhjmFe32IU7zmS1kAum42zgqEIvgJDJGjb4AgBumL0BSS2JLWsLTxSeCKWCx14IzPIFy4gSBmNywTJPX8vOS9bB54vXDS+MMH9gLQ6y5O58JQA0vqje6pHNagGyRFdWlMlqVx4tUjzn0wogwgkGAFlZU4OhKthEDlQ1AVCgzK5l0fPk9Ve/Hr/z3N+BrujwK2UpF1wGO7cvObmgSBcs2FIGmjZapAtGhxDgRe9h/33fJ4GtUwCA5bMsmKWaLshdbp0b9qmiwq93Bt6W68vPUSsmCwjDL6K+LCYX5OmCbUCWjHHnIEt4XHw3QAAigZaQXDcdmwBZQQJJkUhHKbzVC6AgEHsKPTNZRaf3rsQWI9i3Tt1eQw8HWRnCFpAdJYOz1wFoA7IuIpMlJMf5KJPlVOBByAUH92QJfzNRLekLFRMyWd3kgux8/Sf/RlxQuf82ArI8KkDW7ruuRFnjXiSDnutLxryTJwsIEwY9W5HSbd1QMXuQvTb7fQUlDrJKdgl1/vk0vSw83wBogIS1CTLGWEaRMFhLLSAYcRmxc0IkC44GZFFKI3LB3QfYd3L6BllBEMBvkQB37tw5ZMdkiL377ruRz+fxjGc8Q37txS9+MRRFwXe+8522j6vVanjd616Hj3zkI1hY6K0E1rZtbG9vx/7ZlZOYkCb+A2QdhZrb1hujKzpuW2KhBR1TBqPJgi2YPyELW8wnoKmK1Oc3MlmbYAvkTkyWqinygm9Hwi8GYbLcSEFwvIw43/dzdZoElziu89eBcCaXBgS0stH08zJEgs8omaxhi4ijo6s6njHPPlvfXvl2HGSZWWCCF0o3JAwek11Z/TBZQuYYYbIyC6AcZLngunvFwSuPsV6XJiYrHyamaVM8YXCzR19WVC7IF50dmaxkaybrQFIsckjLDYluQwjhbBaBk+bnCZcMvuDgC3D11NX49zf/e/zKLb8ifXxBqSiDL05wA/TiJSQXZCCLfTZ9L4BVZa+3YLLqrg+/jUQMh24DLnsxEHjAnb8LAFhfZtdmeyIEQNHof9fxOwILcT3LmFp8URyZqxZCX5aYeLpg64AWGePOwbrYoAHY9UqCljaSd4fvlDs0IaPA/UIB1Lbh6Ulx6nYFWSnOZPlewLrlBhx1B+WCkzq7j7TrygIgY9wf2ngIfuDDDVzZBXnl5MVJFgTCdMF8KlxsU6sMj7KFZmPwBekHZPGodUJ8bFTj90n14H4ATC7YGWSx30+g4u7r3w8cexFwHSsyp5TCBTufzPzF8bR1GkKIBFpeh/RJMdsbFkDZZy/RpU9OerIickEglAzu9xRQn70mPvWxUWf3+7zF7j+mXYQaeGNLFwTCrqxqamH0TNYTjMkaVUdWveyyjW8SbvT8sE7fIOslL3kJPvzhD8v/J4SgUqng13/91/Hyl798lMcmZ3V1FXNz8QWqpmmYmprC6upqm0cBb3/723Hbbbfhla98ZdufaZzf+Z3fiUXSHzhwYODjHvtwyeAhhd3It1p0/YiJSgbbjvA7tE0W5H4sfgEOthuZLPb7i4RdgDp5soCGGPf04IXEMlJdI1A1ZSzpggCQ4RKvAvc3RJOE6HYzyJpOTMNUw5+ZT4+GyaKUhsEXudHsEsm+rDN3MjBFFOAI8/Jh9ir278YYd85k9VpIbLk+ti22cJrNJBqYLPb32JSB+xv2XY+33PQWAGyHuuaG54Uw0ta3HZBpBoJ6Z7K4f4r6sntJxrhHPj9tmSzOGO83OchKTLAUvAFGSAZrCb4BxHdQD+UO4bOv+CzeeO0bYzLnoFKWPVnnOSDcd4kxWYHio6azhbqQsKUjwKgpxj06L3w3+/eDfwGsHUd5lb8Hk+GCQ1UVKNw76RMdtIOMVEoFp1Jt5eRXLzbHuDNPVvsId6BZLqhqigzJcKzuMe4270hzIkyWKCIO5tiCWjfVlsEb0dF0VUoKhysk3rngi7zK/vZOTNZl+cuQ1JKoeTWcLJ3E6dJpuIGLtJ7Gvsy+8R1jlxEyvomIXNCP+GcE8zkIk8XAEztPL1QKse/5B9n5trQFJNT29wRFY4/XKHDVs34E+BefB2ZYEqNr++y6DyA52ToV+GKPjHH3ujNZUio4m+xqF5GFxI4S88cuXs6+fjBQAarDVNn1VnTgTTjs+ynu4R1XuiAQxrjX0gsjj3AXnizzslGFXrDjS2WNrteoH/Tp+6//4Ac/iG9961u45pprYFkWXve610mp4Ac+8IG+nuud73wnCCEd/3n00Ue7P1GL+Zu/+Rt89atfjQHCXuZXf/VXUSqV5D9nz57t/qCLNRxkXWWyBWa7GHcAeOYiKyU+vnU81BM3jmCy2iULboV+LCDU54sbcL3CbjB1vYzZ5GzXhCeRYGTV3JEwWYapgVI6NiYrn2OL4nrNQ83xpCcLAILtZiaFEILFdAhYRyUXLNRcuD7byp7NjOai/uwlBrLuXb8fDgDsuzmUwc3yneG1RpAlurJ6A1kCoBiqglxSizFZwsgb8FaJf/v0N2MhvYD51Dx86uORzUfk8yQyulwseJNMktkzk6WZgPA2cMmgDL7gwIVSKsNKjuXjO3viM7ag8/N0AKmgGFFIXDI4kCud6/DTgF+rSyZrhUvhFi8hT5au6khqSSkZFHISQ1Wg8SLgWjvJIAAs3cTSBkGBr/4n2LxGzIyTjZGEQbPj9eSsSBacbA9UBZP11FZNLvoD24bPQVY3uWC0kFiwWYzJYuCtHWixA/b+2jQlmSxRREzn2MZfNz+WmMwIwi+UHrq9Bp1KwcI/ff5JlD3GMudUdpxt5aNg4SLXzYSSwccKYejFxfRfhxHuIZPlWeHrrg6RLqgQBRrY5329GlfY2HN5+ARIuADZKLY/Pn4OT5k6rpyPK4/EfZRQH/rE7gZZvcS4l9a6d2SJkSDLVmLX4cWjbKM27xEkAyCtsc+t6MCbsNnjkhxkjSv4AojIBZNz8EfIZPnlMrwL7Do16o6sH/ZkQWAAkLV//3488MADeNe73oW3v/3tuOmmm/C7v/u7+N73vtfENnWbX/7lX8bx48c7/nP06FEsLCxgbW0t9ljP87C1tdVWBvjVr34VJ06cQD6fh6Zp0Lh34zWveQ3uuOOOtsdkmiZyuVzsn107HGQd0xiL0glkLaWXMJWYghd4OL55vPUPdenIOhspIgbQwpPFo071Skc/lphEJMZdGICDav8gy+E3Dt1U2eM99v+j9mSl+Y3ToAxYEEWR8gBabs2kREHWqOSCgsWaShswRrRLdHn+ckwnpmFRDw8kTCYVFDN3Nft3A5N1hBcSb1RsbFtxI3arER1ZMxmDLYQioN6tVkBBQAh7jQ9Ns4XkjXM3AohLBgkhYSHxBPv8+1vxnd2Ok+LAiHvMpFyQL5Ce2n4Km9YmdEWX8fbh38DljgJkDZAsKEbEuG8qHCV0AFmBbcMPVFDuBaqDwtAUTO/CFLBO0yphkBASiXHvIml7wa8BRAE9/negW+x9yy7EXwMJshRDylBbzdkOyYJipjMmZjImKAUev8AARtST1ZXJihQSxxMGO8jvPAc2DyiygmSEyWLPFUyx5+4mFRQjurKGYbLC4IvRyudpQPEPH3sE3/vSGTz4FFvg5ZTuTBYQCb/YeHBX+LGAMF0wKj8VIEtRKFS1EWT1l+RmKOxc3aqVYl+vwcFanv23c+pU28dfqLFjuXw63QRG7Tq/b3qWrGXZbaMavce49xLfLp83xmSdk1LyREbH1BJ7j/Z7CkyFfQ7E5kneYf+frK8DCgHRxtcvlp1KQNUIqKKhGoxOwSD8WNrcHNQRrXcFk/XDXkQMDFBGDDCp3hve8Iahf/ns7CxmZ2e7/tytt96KYrGIe++9FzfffDMABqKCIMCznvWslo955zvfiTe96U2xr1133XX40Ic+hFe84hVDH/uuGA6yDhIGQDer7W+ihBBcP3M97jx3Jx7aeEguXmPTRxExgKZ0wVo5ZLIO5Z7W9fBFIbFd85AcAZOlJ8L4dmKassdqVCN2onWwEt5r902AmCao4yKolFo+RnRlAcBccjQgK4xvH90uESEEz158Fv7u1BdxdzKBW6Igq41cMJvQMZc1sVa2cXK9ihsP5Dv+jljoBcAS9QAgM4/j5/8B8xFppcYDDG6YvQH/cPofZNeYmHTexPaGBSc9Ax2A31dX1jRQPBMyWRw8C0/WfWv3AWB9PFG5JxAGX0wpnL0bgskShcSrhJcdR7qyGieoVCSLRQiFC+DwROKSS02NhV9EEwYNFaW62zrGPTpzVwHX/yy27/0KiK/BIy7m5uI78sJ30i3G/cxWKBfsNFcvZvGNJ2w8ulrGTQcnY56sbumCG/UNeIEHTdFk8qFjeZ3T+qwSbP6+WjQtmSx3hcm5/fwssNk7yEpFwi8GnXEFXxy/ewWrJ9m1s859hlkRfNHlXBC+rAfXH5TM4UUHWS3kgp7FXnct8naJPsh+mCwAMNUUasEmtqw42K15NaxMESwWKJzTp5F+dut10bltC5cBONxCZuxU2OuuefWRxXiPeiST1SF5UkxULtht1MmIJ8urs+RYvoG2eFkeW+er2O+rWAN7XYScUTAeIwABAABJREFUfMJln4tUfQ1EH2+3GFEI8tMGNi/YqCj5kT1vKBUcfbLgD3voBTAgyHriiSfwta99DWtrawiC+I7Ce9/73pEcWHSuvvpq/OiP/ije/OY344//+I/hui7e8pa34Gd/9mextMQWscvLy3jRi16ET37yk3jmM5+JhYWFlizXwYMHceTIkZEf40UZDrIWKdvh3OjAZAEskenOc3fiofWHWv9AN7kgB1liUeJHerJoQGFFmawufiwgTBgcOviCy0qMhAq/VGTHNGIWCwh3yA1KcJKHPSjJJIJyhS3mPJvJ0SIjmKypxBR0dTQX4bXt0fqxxDw7uYS/A/DtVBpv3Xdz+A0hF6xcYOxPhL05OpvmIKvSP8jinqxzmorTFx7FjMqN3QqROu4bZm8AwBZSlFIJKgSTZZt5pAF4A3VlMZAVMlns/L33wr0AgJvnb256qAi+yJPhQZbwZJ0L+OtZ6gCytrfhcvmtYhCAXFrJgmLihcSh5KVnJgsA7vgVbH33JACgmLyAa9LxTaG4XLATk8W+14nJAphk8BtPbODRFbawjXmy2jDJU4kpaIoGL/CwXlvHYmYxZLIsH7qU37UALVYRDj/PaRCWEXucyfLT032BLBnjPoRcUHjI/BEGX1gVF3d//oT8f9tjx5km3eWCQJgweKJ4QpaHXzl18UIvKKVyoybKZLk2+5qmRfyVA0S4A0Bay6DgAiU7/j4wkAXgBOCcPt3ysWc2a9i0XFwGHYstUmmtAjsXNd+CktndcsFeItyFXDDfD5Pl8vetdDYEWccm8Mhdy9jnKdigDGQJy0XejcS3jzH0QszkXAKbF2xUtcnY/XCYCUMvRuPHAiIdWT/k8e3AAHLBj33sY7j66qvx3ve+F5/73Ofwl3/5l/KfcRb9fupTn8JVV12FF73oRXj5y1+O22+/HR/96Efl913XxWOPPYbagD1Ll+RwkDXtroIg6BjjDiDUsG882PoHBJOVay4ibuzIoq4ri4OVbBZWzZWJV5ZW7UkuaPLFrT20JyuUC4ahF/m+n6fbiBhmnYY+JJLgCYPtYtw5kzXK+Pa18uiZLAB4drkIAHjE0FDyIu+DmQVyzGyP9cdijznaR4x7DGRRKj1Z//nUX0FzAtmRpRuKvHlcPXU1DMVAwS7gTPmMfK403yGzODDz+mWygBBkpeKeLAGynj7/9NjDKKVSLpgL+E5ycnC5oPBknebmaWy3lwv6F05KJsvnzMallCwoJmfk2hQSd4lxj87kYWzOsTCjrdQqZhLTsW8LkBWoRtuuLEpp6Mma6vw6yhh3njAY2E7IZBmtb6EKUcIYdy4ZFEy4Y/lQsx3kdxEmi1I9ZLK4J8tLsuMxewRZ0pM1TPAFVyuMksm6+y+fhFV1oXA/nu2wvyfdQ4Q7AMwkZ7Avsw8UFNvONggILs9fPrLj63csN4DDAxmi6YI+T8KLnit0gDJiALJoeNuOvw9Vt4rzU+x1bAeyvv74Gly+JldaYBSryK7hWuCMVfY2zGg9ygV9L0B5k51HfXmyHP4eRaTbSzz8Yt4nUJxQTme6KSQCds4m6xtj9WOJmVxi97tqaqFjqE8/I5msY6MEWXtMlpi+P0n/6T/9J7z//e/Hr/zKr4zjeNrO1NQUPv3pT7f9/uHDh7v2gAzTE7IrJ7cPUDRogYt5FDp6sgDg2plrQUCwXFnGlrWFqURkgUgpsC3kgs1M1oVtC17AOrLmcwnJGAGAms1ie519qGythkDx+2Oy6p7Upg8CshwpF9QQiNCLMTNZT2yETBYABD4vJM7Fd9Wft/95eO6+5+LHj/74yI5DMFmjiG+PzsJT/4wjnotTho7vrn4XLz704vCbc1cxELD+KHDoVvnlozO9FxKvcznKrCjy9R18K5nAV1e/jdtcAp9L86Ix3Lqq42kzT8P31r6HB9YfkLUAYuFYD9hF3B+GyZLpgi4uVC9gubIMhSi4cfbG2MOqjg+bL6KSvgBZwzNZj3PzNOoFwKnKlLXoBMuPyY4shy9K911CoRdicmYOjxtsAROTC/L3vKtckM9W4pkAtrGVWsH06qNABBBH5YLtPFmluosyX8Tvb1FEHJ2rFsMYd0opkwumBZPVPllyPjWP5cqy9G8IuaBrezIsqCVoqRclyALVkOQ9YqKI2NXTAGwkegy+SAlPVmnwRVm3NMR+Z/VkCd//Fvt7bn75YXz3b0/BdjVAB5KUXSd6YTWvn7keyxXGAB/IHugatjTOEX4sTSFIRwukJcjifWdBIGWs/YIsUUhccePnTc2t4Ty/nbcDWXc+tg7xiraKQHe22TFpZPCo/3GP2qNcsLxpgVLGfIkag47Py3uyApuCBgCJqAqyUwmQtAal6iG3NQ+wH8WExWTeKWxCDVwoOwCypvax97+WWoBfKkHpMweh1dgneBHxCOWCZcFk7QVf9M9kFQoFvPa1rx3HsexNv6NqssPoIFnr6MkC2AX6yASTSjZJBq0S0yIDLT1ZQiq4lE9CVYiMb1dSKRBNk6EXNY3dhHtiskYtFzRVeGOKbwfCnWgDwKn1KiilYSGxR2IFt2ImzAn84Yv/EC8/Orp6g5DJGuEi2y4DZ7+DZ/PUom+vfDv+/Ta+rGNzPMZ9rU8mq3IBLoDfnWGAZ58+K0GWbsYXrkIyGPVlie6NutdnGTEQyh1luiD3ZNUc6ce6cvJKWf4pRkgFU4YK3eEevKE8WexvOFvVwsTDNpLBYPVJuJzJsgjbLFq8VOWCvCsrxmQZfcgFAWyssZ/bSq1g+u6PABHZuigk7uTJEn6suayJRJuuKzGXzWWgKgSluovVbQu+7YDy2P52niygOcbdiDJZOdGT1cqTFQFZgYakroD6PrwLTBLnEva571kuOBImizNvbXq9+pnAD3DnpxkjftVtizhyPVus2jZ7LROUvWfdmCwgDL8ALq5UEAAK1VAqKGVcgQ/PZZ9XjYNsalkyWKFfkDWR4CFTXvx6W/fqWBFM1rlzoG48iMhyffzTiU14/NrRCmRZZfa660oPbPJFml7TBaOhF71I6tRcTnaDsvCLeKp0ah97nyaKYYZAzmL/nQP7fJMxxreLmdzPmLRqah6bn/jzoZ/Pr1ThnWebHcbRo0M/HwAEAZX+zz0mawCQ9drXvhZf+tKXxnEsezPIiPALZa2rJwvoIBkUfqxEHtCbF29CWhPGt3MmJyeKiMPQi7nUHJJa9wVga5DVWxx4dATI0k01ZLLGIBeMMllVx8eFbVvGuEsmawfmwjiYrNPfAgIXt6rs/ewZZM0wIHJqs9q+SJZPDGSVV/E/JrI4ramYTkxjQcnDV7hcsA3IiiYMih0ygcm9ra3emWrBZNVZIqFgsrYtD99dvQdAaz+W2MSYzhihNHQETNZW1QGd4HLMNpLBYO2MlAuWOaC4FD1ZWSMrQZZr+3B4opmQC3aMcOfj+wFKF9giqpY4j9Tqw8D3/0p+P5ou2M6TJfxY3UIvAMDUVFm8/ehKObaLrraRCwJhL16jXNC1/M69U1FPFtWRNFR4GxuA7wOaBsfnYKTPdMHatoOgy2e03QiPziiYrIfuXMbmuQrMlIbbXnUMBu9LtLlFT4KsHgpnoyDr8smLJxUEosmCEUbDqcCjnKHnnh25kUhIrAakl5lKsOuz5ddi72XVraKQBTxDBTwPzrn4deS7p7dQd30kueS9FUhx+PpBV7v7nS7WSE9WF7lgab33+HYAIKoqk/UaY9wBYPoQ+7zmt8PNW8FkZcGYamKMH1Dk51IgBPC1JFb/4q+l1G/QcU6yx6szM9AmB7+XRadWckADCkUhPbGIP+jTk97gD/7gD+R/X3bZZXjPe96Db3/727juuuugNySqvPWtbx3tEe5N5+Eg6wBZw3e6MFkAuyn99Ym/bmayyt2KiOPJgjK+nctIBJNl6VUp6eo2wpPl1COerEEi3IUnK6GFnqwxyAXFTnRaYRf6k+sVHBBMlo8dA1lrEqyM8KJ+4qsAgGcceD7U4jfw1PZTOF85H6YjCpDV0JW1bzIJQ1PgeAHOF+sdF63r3M80kzFxYf0J/AlnG99+89tB/vxP4Kvs/9uBrCeLT6LiVJAxMnJ3vlbxQUEAywKt1UDSPaRiNcgFo0lg9662D71YL4sIelMCtGEi3Kd4/LoXUHiZRejrx9syWf7GeXgaY4dLngeowNLEpbdLmDNy8FQHvuFAdQxUCjamkpqUC/bCZJXW6gh8ClexYaZdVs/6td9mHVqqBl3KBdt7skQdRbfQCzFXLeTw+IUKjq9uYy6ywOtUtLmQYkyWkAsKT6djeVAWO4AWqwRLEXJBHUlDg8eLiLW5WVhV9hr16slK5XQQwuLS62VHgq5+RnjIgmoVNAhAlMGqIyoFG9/5GxZacuurjiGZNUAUtkHneYBPNRg+e296YbKumroKuqLDDVxcOXlxmawSTxbMR64nsCvwKPucCyYr2pHVb3DBdIp7ghQLZduT166aVwMlBJWFLPJnCnBOn4YZCfj6+mOsx+nyfTmgUGkpt3NqLgAdYw7JG2rCCPfOALyfZEH53Pk8/FKJgayGpNcDV07izJeXMVPLQAkUBEqAHAdZmWDnmCxVU5CZTKC8ZcHSJ3Dht38HBz7+sYEDMOwnR1tCDESKiPOG9Fv+ME9PIOtDH/pQ7P8zmQy+/vWv4+tf/3rs64SQPZC10xOJce/myQJCJuvhjYcR0AAKb3iXTFauNciSccfcv9Ac3y6SBcs9+bGAeIS7kh7ckyWZrIQKvzhOJosdr8mWdTixUcVB4cnyWgdfjHoopVgbQ4S7AFnZy1+Ca08V8MD6A/j2yrfx6stfzb4vEwZXGcDgDI6qEByeTuHxCxWcWK+0BVmUUmzwc2Q2a+L37/0iaoqCG5QMXnHsFThR/zB8lckvdCMOsmZTs9iX2YflyjIe2ngIty7ditSEAUKYNMHNzsAor8Pb2oLRC8hKxuWCuqogY2qouNs4uc1uOjfN3dT0MMlkpU1gq8ifa/DdP1NTkUto2LY81JKLmABad2VRiqBwoYnJuiTlgia7XjiJGpKOgUrRwtRSOmSyevBkbZ1nbPdWagXTk4eA1AVg8wngwc8AN71Bevo6ebLO9FBEHJ0rF7LAA4zJup2DLEVBx0VEo1wwymTJ4ItWcsF6NF1QQ1JX4Z7hz7GwCKvGXiPRM9htFFVBMmegVnJQKw0GsoRcEJQiqFbl8fc73/rcE3BtH/NHcrjmOWwDx0xqAAFAATtIw/B7lwsaqoGfu+rncO+Fe/HMhWcOdEyjmlbJgnCq8MBl0Py6NkgRsZg8Z7KIaqFYcyTIqrrsM1FfnOQg66nY4+58nIGsaw/msfZwpSWTZdcZyDL03bswDiPce5cL9jpqPg889VTYlRWZg4cm8I+EIkkVzFQPYC37FCa4XDAbcCbL3BnWJjvNQVZmDtVvfQuVr3wF2Re/uPsDW4z0Y42ohBgAylu8I2tPKgigR7ngqVOnevrn5MmT4z7evWmcCMiqOX7XRcrlk5cjoSZQdss4vX06/EaXjqxTPNjgCJfNhEwWu9laUi5Y6Z3JioGsIeSCVigXFEyWMsbgC52rNE6uV6Dw3SvqKzvCZJXqLhyf3WDmRiUXLJ5hi1SiAoefi1uXWLDFt89HJIOJHAtaAZoTBme6JwxWHR91vvt4tvYwvlg5AUIp3jV1MxSigNbrbT1ZQCgLEpJBVVWQynEmaIaBen+zx9e/gckCGJulpk4DAA7nDmM6Od30sBAkGiGTNQTIAkJf1rbBDcyt5ILVdQR1W0a4WwTIJTRkzN2ZANZpcgaXF5vs+iF8WaEnq7tEbOs8uxZtJVcxnZoDbn87+8advwt4dk8R7md77MgSczUPv3h0dRs+99i0KyIW01hIHGOyOgVfRNIFQTWkDFUWEesLC7C59yeR6Z1yEMCqMqAvSzFN2QM0qGTwzPc38eS9ayAEeP7PXQnCASpRCANaAGyagRZYUBD07M97xy3vwGd+/DNNHsqdnrAjKyoXLEfkgsODrIwuai4sFGqh76rmsud09jF2JRp+ca5Qw5NrFagKwXUH8wBae7Jci91XxGbAbpxeI9xLa4MxWQDg2QpbD/nh+ZdPGziv8c2tMvMuCZCV8ZlXcieCLwAgN83AC3nOjwAALvzO7yKwrE4PaTuOZLJG2JElkwX3Qi+AATxZv/mbv9kyJr1er+M3f/M3R3JQe9PHNBYSd2GzNEXDNdPXAGgIv+iQLAiw8l0AOMLT5CSTJT1ZESarh9ALAOGNdcjgC5EuyHqyxshk8ZsP8SjAY9xJUniysCMgSxQR51M6zA7JZn3Nia+xf+9/BpDM49mLzwbAfFkBjdzM2viyjs52TxgUfqy0AXzoe78HAPipcgXXTLLnDCIgS2sBslr5soRk0J1kO+LeVqHLH8on6skK2LkzkdShcZDVSioIQMa3z6UUwOELzSFBlvBlbaocZLWSC64/Bt9VZLqgTegl6ccCQpBV4V1ZIowhjHDvnckqpFYYGL7lTWxzqHQWuPe/R0CW0Tb4ol+QJWLcT6xX4fk8yEDrvOMvItw365twfVcel2v7Ye9UudzkJfTrBbgklAsmdFUWEasLC7A5k2Wm+gBZowy/GCDG3XN93PW/HgcAXPeC/Zg9GGfC5IZbwF6XFCzUevBk7aYJPVmNckH22gv/npDEkz47soBGkBXe62u8csPfz84559Qp+b07uVTwpgN5THD1g9vKk8W/ZuxmkNVDhHsQUGxvCCar99dYFhK7GkCDcOMZjLHeSrHP5ML2URheEkmPvRcZn8sF9Z1jsgAgOHYDtIUFuMvL2PzEJwZ6LuHpMkbIZIUdWXtMFjAAyHrf+96HSouEoVqthve9730jOai96WOmmO56lpSQhIXNau+SwYc2IiCrA5O1VXXkLp0EWQ1MVi1SRHwo2yOTxT0Fvhcg4KZROoAny7VFT5YWgqwxMlkAoIOBCkX0ZLVJFxz1rJV56MUY/Fg49kIALBY5qSVRsAt4vPB4+HNtfFm9dGUJkJWZuwePFx5Hjip4a6EEZBdAfR/UcToyWTfO3QiAlRIL4CeSi5wsAyh+r11ZwkdFA5aqCbYwUlNsYdIOZAm54KIhdg0JkBjuPBNdWWuEA7/tFiBr4zEELpFyQYsA+y5RkCUiqEsae69CJqv3CPfNqFwwMc2Cep7/H9k37/rP0FT2HL7S2pPlBxTLxd6KiMUsTiSQS2ignoeAssVWNyZrKjEFQzFAQbFWX4ulC0r5neuC2nHg41hF+d9CLiiKiOnMPvm9XiPcgdEUEisixn2AQuLvfekMSut1pCYMPOsVzSlmAjBaYGA2DasnwL2bpqUnywk9Wbo+AiZLsHWKLX8fEDJZ5CA7P6JMlgBZd1w5K7u6WjJZ/OnM9O4NK+glwr2yZSHwKRSNyM2Fnp5bdGXxc7BRMmjl2fu6WD4qWSxPdaD6bO2zE54sAMhOs2t/edvD/H98BwBg86Mfg3v+fF/PE9RqcHlAymg9WXsdWdHpG2S1a5l+4IEHMDU1uAl8bwacxITcTT9A1rsWEgPAdbM8YXA9kjAoPFktQJaQCi5NJJDisp5AMlm8t4Mn3llaFQdyB3o6dMNUwe1N8Ai7QAX1OmjQWQrQOHFPVhHAmJgsIzxenbIwEJ/vXu1UuqD0Y41KKhj4wMk72X9zkKWrOm5ZuAVAg2RwrguT1QVkEbUCK/NFAMBbLYJ8EACZeQQ8Nj4sI24GWVdMXoGEmsC2s43TpdMAwt15m3usvF67slQdMDk44u9ZNhlASTCA01hCLEbIBRcMzo4kJgBluF1fwWSdCzjIKp2T8c5y1h9H0MBkLV6CHVlAyGRtqczHIEGW2VuEu+f6KK2xBeWWYLIA4KZ/wVj96hr0s8wr3M6TtbptwfUpdJV1/vUyhBBctZiDHngyBVPtEv1OCAkTBqur0Llc0LW4B5XfRxvld1GQJeWCvIg4mGQbCkZChaL2fvuWQTFDMFmqTETsD2SV1mu49/8yj9DtP3W5TBOMjkwYVNj7mSZWz3LB3TKCWWryZEm5IGeyRiEXVFszWdpBdu/11tYQVKtwvAD/dGIDAHDHlXNhKEwLJsj12flo7GKQ1UuEu/RjzST7Cl6QIMvnvt6GDS91yoALioSXwaHC0wAA1LBAAy573WG5YHnTQvZlL0PqlltALQsXfu8/9/U89km2qahOTUEb4dq9srXXkRWdnq/Sk5OTmJqaAiEEV1xxBaampuQ/ExMT+JEf+RH89E//9DiPdW/aTZ/hF9fPMH/LE4UnYHl8V74Dk3WCL56FHwuIMllxuWAmZ8JUe/twRbX4LvgFilLWI9LHyDJiQ4kwWfm+nqOXIQqRN6lJXWP9zZTvTvok9OmMcS5wJmtkHVnn7wesIgMMSyG4EJLBu1fuDn+2S4z76nb7hdF62YIx+w8ISA1XTV2Fn9piN35kF0AtdlOUTFYLuYqusFJiIJQMiou4rfPFX69MFtDUlRUYT4GQAGl1GkvppZYP2eBM1oxajT/HEDPNPVlPuXn2BbfWfB6tPwrfJbGerEtWLsiDL8oGA8TVIr8hy+CLzhKxwmoNlAKebqOmbzMmC2DA+Y53AQD0E38HoL0nS0gF9/HOv17n6oUsjMBDoLBj1VpsBjSOkAyuVlclk+XaPoiiyFj0RvmdbfOia0oAqEgaqiwi9rLs7+3HjwVE5IJDFBIL9q2lj6zNUEpx12ceh+8F2H/VJC57RuvyVBHiYRO2YZi6BJksofaIRbjbrTxZ7PqhpHoI6WkYwWS182Qlpmag8gWz89RTuOf0FmqOj5mMiWsWcxLoua2YrIAdnzlKlcSIp5cI90GSBYEIyPL4+9fQlTWVS2CF+7KuXGebkKppgfo7C7KyEZAFCsy/+9cARUH57/8e1W9/p+fnccYQegGEG2fZPbkggD5A1oc//GH8/u//PiileN/73ocPfehD8p8//uM/xje/+U185CMfGeex7k27iYCsjR5i3BfSC5hJzsCjHo5vHWdFnh3SBQVDIQIOgDiT5fsBvDrbfZ+Z7m/hKbT4jq+EO7t9+rIEk6UFtiwlHUcZMRACgCN8kbvp8RSwnZILjprJElLBI89n5dZ8BMi678J9sH1+TomEwfIKUC/Kn51I6ZjhjMypNmzW8cIj0POsg+pdT387VOFpysxL30xgMBDRbvHa6MuShcRgi5WePVlAJPyCL/aVJwAAU+pVbeNwRRnxlML/xiH9WADk63ahRoAUM603SQY34kyWRYCliUsTZCXUBHRFDwuJi2HBM9CdyRJ+rFJ6DSCIB5Rc/QoAgO4wf2rQxpN1pk8/lpirFnMwfA+BwgBOLyBLhF9cqF2QMlixKdROfmc7DGSRgH0eEySAv8GuLV4qD6A/PxYwfPAFENZ19CMXPPm9dZx5ZAuKRljYRZvPlrwPEHbdTsNGzfUH7vW6GFNqmS5YgSsi3BuZrGT/n+G0zoGZ4qBQDTcjRbpgSkvBOHyY/erTp2Wq4POvmIWiEGhCsuhRBH4cqHiUp+fmdu+1RbDHneSCgunutSNLPrfwZPFS7KaurLSBc7xDLGvzzQ6jGoKsHUoXzEyaIAqB7wWolR0krrwSkz/7swCAC+9/P6jX2+aEiG83Rhh6IY5JHOfe9BjhDgD/6l/9KwDAkSNHcNtttzX1Y+3NRRwJsi7gbA9MFiEE181ch6+d/RoeXH8QNyWXeNETAdLNO40n19nO5dEok8VvtGo2C6vCbi4BAuyfbh2c0W6kTKTuQ0kmEdRq/YMs3pOl2FyXnkzK1L9Rj5HQUCs5OJBLAptlrDnAFDiT5dYApwYY/ctAep01yWSNGGRxqaCYy/KXYSY5g436Bh5YewDPXHwmY7uyS6xTbf0x4OCz5M8fnclgo7KFkxsVXLc/DnADGuBbhY+DEIrLU8/HTQm2uw89BZhZBHUuheIl2K08WQBw4+yNAID71+4HAGQEyPLZza3ndEGgKWFwy2fsXDpoXWjqeAG2+Xk2Ab6TPxKQxf6GzaoNTOwDahss/GKBSXphlYDyCjx3Af4PQPAFIQRZI4uKUQQA2FUPruP3HHwhQNYGl3bOJGfCbxopIDUNzRHyU7MlyDo3KMhayMIIXAmyOnVkiYnGuBv7Q7kgpRRqJgsPK3H5HaWwnQqADChf9OpbGwClIKYJh7Dd4f6ZLPYZqQ3jyepUoNxiHMvDNz7LNi+e/pJDyM+3f72bPFmkDhoAdTc8N3b7SCYrmi5oV+CPMF1QeBoJodioheeNkAumdAay6vfdB/vUKdzpsHv286+c5ccQnrOeG8DgklMaUHiEHbeZ759h26kJPWU9MFl9xLcDESaLb4I0hhBNpw18TQuAyEcomahAZEPtVLqgoirI5E2UtyyUNy2kJ0zMvvX/j+0vfhH2E0+g8L8+g6l/8YauzyNCL8xjo/NjVYs2QJl3rt9r1A/q9O3Jev7zny8BlmVZ2N7ejv2zNxdhYnLB3m6iIhL7oY2HQqlgZi7GZog5xZMFRcABEGGystlIEXEFByd6SxYUI26uTt2TaUv9gKwgoPKCq1gc+I0h9EKMAABLPLBghW8mUp8Dg/p4u7IEk9Wrl6TjWNvAuX9m/33sBbFvEUIkm/U/j/9PfGflOyg75a6+rBMtmKy/fvKvUQpOgPomXrb0JqDC/DjIzAOESN+Mr7G/qR3IEufsidIJbDvbSPOdsrqtgALwtvp47SMgy/VdXLBZwIfmtt7VE6EXmkKQ9BgLI/u2hphp7n/YrDhAbj/7YlSmssEWqQ7Cz55FWBDDpTo5IwdHtcCtTagW7LAnq0uEu4hvX0uy10jKBcVMHIBO2HvFQFbztUQwWb2GXoi5Yj4LPcZkdb99RuWCggWnlC1wW8rv7DJsUP5zOnSVAGvs86ItzMPpsyNLjGCy6mUXvtef51WMZN569GR9929PoVq0kZtJ4OYf7RyGZKZFhDt7TTKEXVgvJclgy3RBpxqWEfPzhQ4BskzVhErYa7VVD9dbdZddQ6NMVunxE3j8QgUKAZ53OduMiIa1RIGKE/ncJSYvbhR+p5FywQ7n8NByQREe1shkZUyc1wJQhOxq2tjecU8WEEoGtzfZ36rm85j9pV8CAKz/1//a073QfpLLBUcYeiE6sjJ5c+CC5B+06Rtk1Wo1vOUtb8Hc3BzS6TQmJydj/+zNRZgoyOohXRCIJAyuP9Qx9MIPKJ7aZDeFozNRTxYHNLkc6tu8I0vrvSNLTKwrS8S4V3vvyvIiNwe1xn1iYwi9ECMAwHyKLVqWuUwyoPzGOmbJ4IVRMlmnvwkEHjB1TJ5D0XnOvucAAL529mt405fehNv+1214BVnBr85O41NP/V88sP6AlBKG4RfxXe5tZxsfvu/DAAB740U4OrUYOd/YLr8MvtDipZ2NM52cxoEsM3Y/tP6QZLI8H/C0ZJ9MVujJ+v7W9+FRG4GXglVr7scCwtCL6YwBRQQTjIDJEp6s9QpnsoC4XHD9UVAK2JS9vi4CQAEWLmWQZeYAAmhZ9tmpFG2k+eeq6nhNkebRkcmCyRWYqhnKp8RM7IfGF+i+YoC28mQV2NdEsXqvkzY1HMpqAzNZ0fPatXyo0pMV2Zy0SrCJYBcMFt++GikiFh1Z6f52iRMZHYrKFj217cF8WTL4oge54OZyBQ98lS1Sn/szV3SVVorNNjtg7+ekxv7OSyX8wnJ9WNwnNBEDWWW4gslqTBccIMIdABIqe42KFjtvKKWoeuxzkdbTMI4cZt9/gjEVNx7IS58YIaRlwqBTZ68zCVwYE4MVTe/EiNewHZNFAzo8k1Vhvs8mT1bagEuAQir8vOYShYgna+fkcdHwCzH51/4UzGuuRrC9jfUPfbjj4wPLgnuW/X1j6cia2pMKiukbZL3jHe/AV7/6VfzRH/0RTNPExz/+cbzvfe/D0tISPvnJT47jGPem2/AF8gGyjs1yb6ERT5t+GggIzlfPY6PAdstbgaxzhRocP4ChKTGJUrAdRrjXuFelrldwMNsvkxUtJOZFx30wWcLfQBQCuj2++HYxYjd6mu+8n62y30+5f2KcIItSOlomq41UUMyPHv5R/OozfxUvOfQS7MswAHDar+JvM2n8bvkRvOGLb8CzP/Vs/PQXfhr3VD4GfeK7eHTzMXhBuDD6w/v/EFvWFog7B3frNsxmzTiTBUi2oVOEuxghGXxg/QFohhrugJt5eIVCxwV6bCTI2sJ9F+5jv79+GNv11kyK8DpOp82RFREDoSerbHnwsjxwIypTWX8M1Ac8NfRjzWVN6H0ky+22EQmDJMNe62rBksEXAYVcrDaOY3lyUVFIrWI6Md28W5o/CF2ALNWA30IueHZAJgsAjk3oYfBFlwh3IO7JIgoJfVl1rzWTZRVhi4osyuLb3fNMaaAvLEiQZfYJsgghks0atCur1+ALGlB8/dOPgQYUR2+axeHrZjr+PBC5D/jsPclrDAheKl1Zwo+lKgTZqLwx0pOlNfRkDcJkAUCaJwyWbPY+2L4tay1SegomZ7K0ZZZUeseVcQuA7JqKABWbSx01zwrrBXbhiK6xdp6sasmG7wZQFNJ38II6mWf/4QcIXMICoezwXBfX6tUkW2fUtCoyalVULV4cJmsjXO8RVcXCu98NACh+7nOoP/Rw28c7p04BlEKdmIA63XpjcZCRHVl78e1y+hY7f+ELX8AnP/lJ3HHHHXjjG9+I5z73ubjssstw6NAhfOpTn8LrX//6cRzn3nSa3H5QosKEC1JZ7ekhGSODY/ljeLL4JB7aPI4XAC2LiGUJ8XRaJnFRz5Nsk5LLYeNRtmi2jAr2Z/f3deiykLgeZbJ6B1miI8tIqAgEyBojk2XwRdKEoYEQoODzG2fAF1y18ckFty0PNpdJzI6CyeoCsjRFw+uufh1ed/XrAABb1hYePv55PPL19+HhdA4P52awZW2x8BQcR2IJuADg1k//Pq6evhpXTF6Bzz3+OQCAtfoKABo77gYmS6RJimjsVmXEYm6YvQFfOPmFiC8rAbtagW1OIlNdQbC93RvIjsgF771wL/v9tcMoOW7LHxehFzNZM3yPRwCycgkdmkLgBRRlcwGTQJzJ2ngcgafEOrIuVT+WGOEr8VM2AA2Voo2kroIQJqWr2B6SLZiPwgq7LqhpCkuvYjrZ3LeEif0SZIEo8Kz4+2m5Ptb4e3lgqv/X8UjOgK9yJquX4IsUO8e3rC04vgMjocK1fVZIzOsvYkESVgmOLCIW8e0MZGmLC7AHZLIA5ssqb1kDgyy1R7ngo99ewcqJEjRTxe2vbe1xbBx5H/DZ4mxCZSDrUmGyRJz6RFKPA3+nAg9CLji8JwsAMnoaa3WgwsODhB8LAJJaEjh4ECAEpl1D3q7gDu7HEqO16JpyymwzQvMtmXq5G6dbumBpjf0d2elEXxUHAPNUKakUgloNPp2AiiK7FvPAJ6E6OGVUcA2AzeQaEtS+SHJB3pW1Gd9ESj396cj9xCuw/TdfwIX3vx+HPv0pEKX5dQhDLy4bqayvsrWXLNg4fW+Hbm1t4ehRdnPL5XLY4trP22+/HXfddddoj25vehtVg8/9HNn6cs+JTFIyWGEdJsg1R1fLZMFI6EUQKaNWMxms8X4iJRnAUPu70EiZSM0NQVYfTJbsyDIjHVk74MmCG2BpIglbY3+vkAyMk8la411kE0kdiS4dPV2ncBrYOgEoGnD49p4eMpWYwvOu+in8u+I2PrJ8Dnf+xF/jS6/5Ej74/A/iX13z/4NfPQbqm7B8C99b+x7+4rG/gE99PG/fC+FU2GJrOt2CyeKSLp+wc6ETk3XDHEsYfGjjIQQ0kAlGTo4tZnvuyuIgK6ht4Htr32O/v3YExZrbkg0TMtyZtBEyWSOIcFcUginuyyqofDEUlamsPwrfaYhvv0STBcUIJstNss95pWAzpsXoHH6xyf1YyhQDGk1+LACYOACNhHI4t0FWdK7Afmc2oWEi2T9QOZRTQ09WD3LBCXNCVlpcqF6QXVmO5bUOkqgXYfNFD6UaEpEi4rhcsP8wCMlkDRh+IY+30p7Jsiou/un/sAXcM3/sSM+LLXkf8NgxTqiXlicrjG9vOKdG3JMFABMmex8svwbHC2SyYFJLQiEKFNOEP8euh9f4RVy7FL8fhkxWCLKsAnsO1bMGPq6dmG5ywdLGYFJBMVIyqHP2L+LLEtfpx+Dh76/4U3x16eswEe3J2rmgh5z0ZDUrl+Z++T9ASaVQv/9+lP7mb1o+XvqxRh7fvteR1Th9g6yjR4/i1ClWYnbVVVfhs5/9LADGcOXHyCDsTedRpg4DAPbRC9i2Wu/GN44sJbbCzqLGER6bIy38WCSZBDEMFAvs/5PZ/ndyZHRvzZO9IYPIBXVTDTuyxunJEoWito+js2k4fMElFXLjBFl8B34kfizBYu1/JpDI9f64ZJ4lDAIgG49jMbOIlxx+Cf7DLb+MxfovofL4r+O9N/453n/7+/FzV/0cXnbkZfgXl/8SAGAypcPQlGZPFu/J8iTIan9Zuix/GZJaEhW3ghPFEzLG3Z1ggK3nriwOsp60NrHtbCOpJRFYS/ACimoLiVKMyRqhXBAId0gvEBHhvsKqCNw6UHiKM1mR+PZLtIhYjABZlsmuG0LHL2Lcq07rhbVIFnTz7JoUi28Xkz8AhQQSaPlUAXXD66GMb59MDbSDeyAderKI1v3xhJDQl1WLdGVZfusgCasEW3R3BXqsiFhfWoRVZa9Nv3JBINKVVRzMk9VL8MXdf3UCVtXF1FIa17+od1WDlAu67N9Z/v61+izuxgmTBRvel0hPlt7AZJEhQRZRLRTrjuzISmnh823k2fXwecl6UyFv2JUVAhWryD5TOnVaMh+7ZdQWLFx0BJPVb3y7fH4BspRIOTyfXEKDrhL49WOwctdho/ACxmTxDdZxJRq3GtmVtWWBNmyq6/NzmPl//h0AYO2DH2y5KWKfGH3oBQCUhSdrTy4op+9P0xvf+EY88ADrqXnnO9+Jj3zkI0gkEnj729+Od7zjHSM/wL3pbZSpIwCAg8oaNnqIcQfCUuKHaQ0+0NKTFTJZoYTAj/ixAKDCGZbcRP/RryLC3YoGX/TDZPFYbT2hwS8V2XHtAJPlWD6OzWZga+ymSoV8YYxywQv8dR5JR1YXqWDHEX1ZTQmDGQAKatVp/MSxn8C7nvUu/N7zfg+ew84TKXGUTBbbLaT1OigAH+y11TtENmuKJs/b+9fvDwuJ0wyg9Mtk3UvZDeiG2Rtg8PeyWGv+/Gzw1M6ZjBF2hI0IZAmt/4qfB4gCBC5QXQM2nwRAEZCslAvahGLxEmeyJkz2+RRdWUK+lpEx7q0XUFsr7FpUzbL3uCXImmDBKBo4O6rEY9zPbvHQiwGkggAwrUOCrEqHrp7oCMlgNGHQsT15/YwFSVhxJitpqPBWuFww4skaTC44HJPV8ngjs3qyhO9/8zwA4Pk/dyXUPuRawlvpehoCqiCjXFpMVkkmCzZsNDqhJ0sAhGGZLCG3hWKhVHNR93iyoB4+32M6uzZdR0tNj9dbMFkOv7doZHe/3jK0ww1aKg5K66Ijazgmy+NVAlGQRYhQHSiobz4TgTMHPbBY+w12Vi4ourICj7YMspn8l/8SxqFD8Nc3sPGHf9T0fYfLBUcZegHsMVmtpm+Q9fa3vx1vfetbAQAvfvGL8eijj+LTn/40vve97+Ftb3vbyA9wb3ocGX7Re4z7sfwxJLUkqgQ4pestQVYY3x6RC3J5i8I9BQ4Pf5iZyvd92JLJinqyar2nCwq5oJGIyAXHymSFO9FHZ9OwBZPl+CyRaAeYrPnskLtEvgec5NLeQUDW3NX8gFrHuDcmDK5X2IVXdEJJJisTpguyhStbXHaLxhZR7g+sPSAXjraZB9A/k3WfwsDxzfM3y11osSsdHSEXZMEXo/NkAeHrslH3w89gaZl1kQHwE/vg8gWUpfzgeLJKBnuvREGu7Mpqx2Qts/OqkGTnT0u5YGoa0JIyxr2xkHjQ+HY5riNB1pbdm2JgPs1YBVZILLqyfCm/E3UYAHi6oPBk6cjClwy9vrg4nCdrgi0CBw6+EMfbIvgi8AN8/X+x8/WqWxewdHm+r+cWniyAJWmmeRnRpQKy2jFZ1KrICPdGJksoN/qdjME2PIlqo1BzpVxQJG2uliw8rLCNjMXyWtPjW3VN2fwarauDxfvv1MiwGcoKlRtn0GRBMbKQmAewNBbDT/PqltUSe70Mal0UT5boygJaSwYVw8D8r70LALD1yU/CPnlSfi9wHDhnzgAAjBF2ZLmOD5sz7Zk9T5acoXhhy7Jw6NAhvPrVr8b1118/qmPam0FmgBh3TdFwzRRbMD9kGk0gq2p7WOU7XPH4ds5k8ZsurbPTaHGmuci42wzryWotFxwfk2VE5YIzGdjCg0YpEGCsIEswWbPDMlnn7wPsEpDIA0s39v/4NkzWsRl28xdhKWJE/Pls1gQ8JwQpMsK9LpMFgfYR7mJunGPH/MD6A/JGYynsd/fclZXIg4LgvgR7/26ev1n6KURSWHTWOcCdTRHAGV0ZMRB2ZW1UHCDHY9xLZyXICsx5KRdkRcSX9g1MyAULClsA1rcd+F4QygVbLKytqotqiZ1HqybzkLZksghhMe6cCfFUM3Y9OTtgEbGYwLZluuBGj9fZaFeWkAs6li+DJGLMUMSThUDDLGdNlXQaSKXl9W4QkJWScsEhgy8qFdAgvhh/6M5lbJytwExpuO3V/S/cFFWRG1h2kEES7P27VIIvivyaMdHgyQocC5Qz9KPyZGV4uiBRLBRqTlhEzNnurz++huUM83fSs2eaHq/qzUyWzTdmdz/ICu8NXkNXFqU0Ihcc0pPl8ft6Q4z7NFcdeFyipwcWgosQ4Q5EJIMN4RdiMs97HjJ33AF4Hi789u9I5s85dRoIWE+fNjfb8rGDTIV3ZOkJNbZp8sM+fYMs3/fxW7/1W9i3bx8ymQxOcoT8nve8B3/6p3868gPcmx5ngEJiALg+x2SGDyaSTUZ+wWJNpY2YDEIWEeeyoJRCs9mH/eBcc3BGt2nZk9WXXJCDrMTOBl84lseYLC28qQY+GatccGRMlpAKHr0DUAYI0JjlTFabQuKTDYXE6/x8nM2YTAYHsMANXuZLrRBkaYYConT2ugi54Ont0whSbKFbp+w18XuVC6oazqXzWNM0aETDdTPXIZ9k53gnJmtWEzc0AiRGc54JT9ZGY1fWBgdZ2nQkXZBe8kyWAFlbWJddU9WiHZELNi+shR8rM2VizevAZAFA/oBMGAxUQ5ZdAxFP1oAgi9oOAp6CuVrt7TorY9wjwReu5UHJstchHuFeisgFdUxVmf+PJQvy14UARp9lxEA0+GJQTxaXqVEau0ZbVRff+QJbB9z6qmMDeXOBSMJgkEGKyz0vlQj3kMmK/O1BAC/Cysp0QX4+DtqTJZksxUKx5oTBFzq7Ltz52DrOpdni2TlzBtSPv4Z6CybL4cev67u7QFbRiBA8xEAiwIq2XdsHIUBuekiQ5fClcWMhcTp+bmt+/aIwWUDn8Asx87/6ThBdR/Wb30Tla18DANhPssoe89ixsSQL7vmx4tM3yHr/+9+PP//zP8fv/d7vwYicVNdeey0+/vGPj/Tg9qaP4SBrjhRRLG13/tnIXJdg7NNDyRTbBY6MYCSiLBYQYbKyOayULkD32c378EJ/8e1AXC5IkuymQ/tKF+QR7qaGoLgDwRccZLm2j4VcArphwOdXfQayxsdkrfOOrKE9WcP4sYCQydpeBqzwXBO+veViHfXIDVCyQFkTKEeSBRWxs1uHzxnBTsmCYvKJPA7nDgMATvmPAwDcQIOv6L0zWQDuzeQBANdmDyGhJeQudLEeX4QGAcWWBFkcQCbzgwHUFiN2RzdjTNYysM7+tkDJSSbLU0nTjf5Sm5zJwEXZLSPNtfuVoo1UB0+W8GNNL2WwabHPWEsmC+Ax7uyc89XQk0UpxbkBi4jF0AiTdb7HzaxY8IXYpLH91pHoVjEW4T5VZedzNFnQTGpNYQa9jGB9nbonZdb9DDFNQNebjvns97fgWj4mF1K45jn9b7SJkaoGmoYZsPfpkmGyasKTFS0iDv1YhACKSkAdB+BBLMMyWVAtFGquDL5Ia2m4foBvPrGBjVQeVDcA14V7/nzs8TJdMBrhzsuIdxgn9D2EkLYx7qU19jpkJhPS/9bvSJBV469NaZmpVPiIDTExDGTxY9vBdEEgymS1B1nGoUOYeuMbAQAXfud3Edg2nBPcj3X5qEMv2HFk9/xYsen7TPzkJz+Jj370o3j9618PVQ0XGTfccAMeffTRDo/cm7FOchKWyuV7hVM9P+w6hQGoJ1TIi7UY4a2J+rGAOJN1cpVJd3ziIZXqfwdDgCxKAd9kNx2/2rsny+GLBc0gYSDHDpQRu7YPRSE4MpsJY9w9DrJ6LcTtcy7woumhiojrReDcPey/j71gsOdI5kNpKZe0AYLxZDeaUxHJYAxkiR43Ht8OsPb5XoqIo3PDLI9yLz0ge7VsMw9/s3eQK6SCT08zYNPOk1Wsu/C5PCSP0UoFgTD4YrNqy+AGFJ/iwReAT5Mywj2d0Ue6+3gxRjBZ2862XPhXCzYyZnu5oPBj5RZMuXPfHmRFC4lNWRFQrLly0b5/crCdburY8Lkna6Pm9JTkGpUL6rF0wTASXZr4o0xWoCG3zZgsPdKRNUiyIMCuXeKzMkj4BSEEKu9Q8iMg69zj7BgPPm26KwvdaaSqIQhB1iXnyWoDsjRDBSEkxgAqycHOwVAuaKNYc0O5oJ7C984UUbY9TKRNmIcPscM4fTr2+FZlxCJpUMjhd/O0i3Ef1o8FRDxZVRsAAXwbqG7I7081bHCpnnVR0gWB9l1ZjTPzb38e2vw83LNnsfVnfxZ2ZI08vl0wWXsgKzp9g6zl5WVc1iL2MQgCuG5vRuC9Gc9UU4xJ0rebddjtZsGuY87zEBDg+5vfj31PyL6OzMTLCcUNVs3mcG6NJV/5CWegxZ+mq1Iy5HFzP+2njFjIBYkvwc04QZYRMa4DDIDavJw08PlF2ekdJPY6lFKsCSZrmAj3098AqA9MXw7kDw7+PO0SBjnreXIjlEDFmax4fDsABPUafCVcjPQyoi/rwY0H5ULdNvP9MVkKew9vNthiXSyQths8WSJZMJ/Sodk8rWuEIEuYqTcrTigXfOpbLGVQTyFwwwj3iVEkS17kEcEXtm8jmedJfQU77MlqIRHb5HJBfYYvBhUDWT3b+hfkD0ATIEsxENTZ9URIBedz5sA9c8yTxY7ZA8Xjq52LeYGQySraRRCDXaPcSE8WPE8Wcsc8WVRHtsw2DYZNFgQYSBo6/CIrCpTDz/fyowxk7b9yuM+EBFk0A+NSA1l1AbIii3CnKkMvGv1YxDRBtMEATaNcUDJZehp3Psbk2M+7Yhbm4cPsME6djj0+DL6IMFkOOy+NS8BLEyYMxq8TEmQN6McCIkxWaTu8R0V8WWJDTP68X5cgazfKBQHm55zjyd8bf/wnqH+P9UKaIwy9ACLJgnuhF7HpG2Rdc801+MY3vtH09c997nO46aabRnJQezPY2Dm2aE5Uz3X5yciUV3CdzaQOD208FPuWWCg3M1mcMcplsbq5zv47NTh7I/wFwncySBmxGrC/QUmlxnqxk54sfvM/OpuRXVkUfAE8Bslg2fZQ5zeVuWE8WcNKBcW08WUd45LBqC9LerKyzUXEAEDr/TNZN87eCICBrFSevd+2mYffI8jaqG/gDBwQSnEj2OspFkiNTJbsyMpEkwWHLyIWM5MNQRYVckHRxTVzOYJqVX428pd46AXAFoMKYbcegZMqRSsiF4wvrCml0pMVTLKF1HRyuv2mzsT+GJMlPFlnC0MmC0J4sjjIIsDxHkBWzsghyUFynbC/w7F85snhklnJDMXSBTWkiuxaoi8uyY6sQYqIxQxbSCyYLCEXLG9ZKK3XQQiw2GeiYOMIhs4O0tB89l61i/PfbVMScsFouqBdhkvjm0fDhl4AESZLbQ6+uPMxdj++48pZGAJknY4rW4TcLsZk8UueMSCA38kJu7JaywUH7cgCIiCrWAyl25GEwal0uMmlIIDi2xfNk9WpK6txcj/2ciSfcTOoZcFbZ+fI6OPb9zxZraZvkPXe974Xb3nLW/CBD3wAQRDg85//PN785jfj/e9/P9773veO4xj3pseheSYPmKj3C7LYhyMKsiilOMUXysdmGz1ZXC6YzWGzwACXmRncn5LgIMsl7AI2SE+W6rFF1Tj9WEBcLgiw10aEXwQaZ9DGALIEi5VNsO6cgWdkIIszWWvHY18WvqwTXGrq+kHoZ8q0Y7L682QBrH4go2dQ9+oIUuy1scw8/GIR1Ou++33vhXsBAFc4LnI2O89zQi7Y4MnakPHtxsiLiOXzAnD8AJXEfPybM1fCq5Qlyzs3oKF7N41CFMlmkTR7r1jwRWu5YG3bYSwOAeoZxiS2Db0AgIkDEU9WGOEeLSIedKKeLA/Aoyvd/a+EECkZrID9vGN5IIRAaQAtUU8WDTQkikyqpC8Oz2QBoygk5hJHHtaxzKWCs4dyQyeKRZkszbegwm8b57/bJmSy2sgFR9SRBYRMFhQ75skKfB3fX9kGIcDzLo+CrNOxx2sterJcnx2fmd79TLn0ZI1DLhgBWXLDKxJ+MR1hspK8ZiAQPVk7LBfs1pUVHUIIFt79brmpo6TT0BYWOj6m3xHpgpmp3X8O7eT0DbJe+cpX4gtf+AL+8R//Eel0Gu9973tx/PhxfOELX8CP/MiPjOMY96bH0aaPAgCm3ZXeH1RewfWcyXpw/UH55bWyjarjQyHNSVxRJqtcYhf4bG7wm4aQKLiEXcAGiXBX+Y1GGWN8OwAZwRx4FL4X4OhMBhYHCFTh2/JjSBhcE0XEw0gFt04ChdOAogOHbx/ugERXVsSTBTQnDG7yYmxVIZhMGa2ZrEi6YK8gSyEKrpu5DgBQ0hiotc1JgFKZMtlpBMh6umXL96udJ0syWVlzLCAroasyWW/dzwKROHvMXgm3YoMS9roszAz+OdtNI3xZNM1e60rBRkrKBeMLaxF6MTGTRMHvEnoBALklaNHgC+7JCouIhwBZTigX9AnwaA9MFhBKBrdRBBBh4KMgy3MAtwYrEuFubLFdZ21heE8WMHwhsSLDOtg9YFRSQSCeLggAKdiXRPCF7fkyBTGWLmhX4EHIBcfAZDWkCy5vMTbjun0TmM6YMI4cZofRBmS5USYrYF8zc7t/E0dG0I9RLkhtGzQpOgtDkDUTAaFJsHubZLL0nWWyFFWR/qdukkEASFx1FSZ/9mcAAObll4/U20splUxWdo/Jis1AESzPfe5z8eUvfxlra2uo1Wr45je/iZe85CWjPra96XOS84z+XQxW4fo99l2UV/E024ECggu1C1irMU23YCIOTKVgavGFr8/1+CSThl1hN8GpydzAxy1SpVzKGaFB5IIOe4w2biYrAgJcy8eR2TQc7slyCWf86mMAWSK+fZjQC8FiHXgWYGY6/2y3kQmD52IJg8cihcSUUulnmk4bLBGtJZNlSSarV08WEPqyVsA8iA7vhvF6iHG/78J9AICn27ZkHtv1ZG3yqO6ZtBEC6BGCLCCSMFjzgFwkoW32Stg19hkLaIClHxCQJZgsN8W9N7EI9/jiaWuZV0kspbFZ7wFkqTp0HmrCmCx2bRi2IwsAAttBoIaerMdWy2FoRYcRIEuARLE5pOTYddMvVwCLsXSCyUo5FKrFXh99YQFWTcgFhwBZ3JNVG7QrKxMyWZRSGXqx78r8wMckJkwXZL8jBeuS8GSJ6wUhTGkgJxZ8MXomiygetmp1KRc8uc6O444r2HXQOMLqWbzzKwiscBHeytPkgR23cQmALK2FXNCquvI6mRsCZCnpFAhP0PRVfo2JgKypKJNFLJYsSIVccOellrkuXVmNM/vv/z2m/s2/xtx/fMdIjyOaWJreC76IzUBywa997WuwrO7IeW92djLzzMh4kKyh0GtX1vYKUpTisizzcz20ziSDp9rEtwMhk1XSPeg2u6DNTA2+6JQx7kG429fLwgUIQZZSZ8BPGWPoBcB2j4Qm3LE9ZEwNlJcQ1v3xebLWyiNgsk6wnoyBUwWjk5wEMhwobTwuv3xwKg1VIag6PtbKdjz0AmjJZEXLiIUcs5cRvqwnXCZZtLlPyi90BlnbzjYeL7BjvtmyQpDVpidLlCkzTxZnslKj82QBoWRws2IDE5EqhJkrZbyyiwD7LvGOLDGCybJMxgRVSw5SfIe6ick6zz7b0/syIcjqJBcEoKfY6+QrzZ6sAwMmCwJCLsgXUypBxfZkLHynESBr02ObWFLmLJisSlmCLBGkM8PPOzWfh5JMwqoIueAQnqx8GJk/yMjgi3IZ2xt1VLZsKCrB4rH8wMckRsoFwX5HmlioXQKeLHG9mEjq8Wj9CMgSBesBD3UatCMLYFHtYrbtspQLPn6evafPv5LVsqj5vLwfOk+FYVh6Q7pg4AfwCTvnEhPN9/vdNgIkRiPcRQlxOm92LbPvNISQUDIIvnEcAVlpQ4XJg7qScCSLBex8uiAQ+rJ6YbIAdr2Zf8c7kHr600d6HILFSqT1oV7/H8TpG2TdfffdeMUrXoF8Po/nPve5ePe7341//Md/RL3eG5Lem/GNMnkAPhQkiIvi2tnuD7DLgMMWOdfNhmltQCj3Eh6b6AhP1grZRtJj308PwbCIm6vr8Q9nEIDavS0CHL5YUWpcwjhmJguIdGWJZEO+K1lx+S7XGEDWhe0hmSzfBU7dxf57WD+WmBa+LENT5CL2xHolDrICH6jwMuIIk0WjIKuPC/R1s0wu+JTPos5tnd0UvS4x7vev3Q8KioPJOcz6QROT1ejJEkzWdBRkjZzJEoXEka4sRQOmjsDmyV82oVj8AQNZFa0ERSGgAYXhsr+zkb0QyYJTS+nuHVl8dAFeVIP1sAUUyxwMHZwe1pPFzpP9fAOqF8mg8GSJImVx7Qg9TmXAKgIAHJVdD2cqbOGkLTLZkl0bgSdryEJi0e3lV8o4x6WC80dyPct8O03oyeIgCxaqjtfzhtvFGgGyJlMNcjE7BFlqgyeLDMFkqYqKFA/CcWkdFZ5mW7N15FM6bjyQZ7+DEBgixv1UGH4hgyO4xFGwqgCQmGqT2LmLRka4R0HWugi9GP76KEGWz9+jSPAFIWFPYQo2aGQPYKeDL4BojPvFJT3Ke36sttM3yPryl7+MYrGIr3zlK3j5y1+Oe+65B69+9auRz+dx++1D+jz2ZrhRdawrMwCA+tqJ7j8vpFtGFtcv3AwgDL8QHVlHGpgsGgQyvvcstpB02UU5mR38xi+0+E6EQOhVMiiZrBovIh4zkwWEvizxu80Mu9Bt23yHeSxMVgMj1O8s3wvY2ywVb/GG0RyU9GU1xLhHEgZlsmDG5B1iPgACpNluK6U0zmT1sVjLGTkcmziGqsEZAJJEQBT4XeSC0o81fS37ApcAijJiyw1gRaQ06xXBZI0n+EI+N0SMO2eypi8DVTQ4LtstdVVISd2lPqKQuOKVZTqkZrNFU1QuSCmVnqypxR7lggC0LLsOeLyMeKVUhxdQGKqC+SHSOf1IT9bReXae9xJ+IZisC9wv67kBAj+IeJwqEmRZ3Jw+W2ULF50b1K0RerJqRXsg8KJkc/J4lx9nx7tvBH4sIASPdsDuOWliIaCQqarjGEopPnbXSXz98fWBn0MUEU8kG94XpxKJcB+dJwuISAZVCxXuyUJg4LmXz0KNsGlmi/CLRiZLMOWK70DL7X6Q1QgSgdGEXsjn5yDLE5um5VXml+QjNsSyqotAMFmKMnAk/zDTr1xwXLOXLNh+BvJkaZqG5zznOXjNa16DV73qVXjpS1+KIAj2yoh3wWzozM/hbfRQSFzmARnZBRki8MjGI/ADHyeFXLAxvr1SkX1Up701JF12sU9mB9/FERHutuWB8ILGXkAWpVQCHbLNFsrqRH7g4+h1GpmsVJa9RtsW/ziNhcnicsFBmSzhxzp6B6CMiM5v05V1LBJ+0bIjKz0D8N166jgsrELpL11QzI1zN6KuV0CVAACBY0zA2+r8+gs/1s2Lz2RfsEuA7yJranKBEvVltQ6+GK1ccIbfuDerdvi6Lt4IWq/DU9h7Tn+AZBjCk8UKifk5zRd7UblgpWCz4l6FID+fCpmsbnLBCbbwDzjIEqEX+yeTcUlXnxPYHsDj5y9b4iCrl66sFANKy3aoMHBtP/Q4VcqsKByAw59/hkvL9MU4yBqFJ8tzA7m47mckk1Uu49xjowu9AKJlxLx4m8fwjzP84uHlbbz/i8fxxj/7Z/zfh/oIjIpMy2RBIMZk6dKTxe6rQ4OsSPhFzWXnNg0MPJ/7scQIX1YUZDX2ZNn8PNC8unx/d/OEnrJmueBImCxRSFz3eQgRBcrn5feFfzanOWFH1kWQCgL9ywXHNTJZcM+P1TR9g6yPfvSjeN3rXod9+/bhtttuw9///d/j9ttvxz333IP19cF3g/ZmNFNKsF1wUjzd/YfFoje3iKMTR5HSUqh5NTy6+aQ0iR9rkAv622xBQUwTp63zI2GyEvzm5NQ8efMJqt0LfV3bB/hmLClzkLUjckEt/P0AMhPsNSoJXDiGdEEBVuYHZbJGFd0eHdmV1ZgwyJmsjQa5YCs/FgfTgdpfGbGYG2ZvAAiFY7Lnsc18RybL8iw8vPkwAODmfc+RC2bUtkAIkbvRQgJEKY0EX0RBVr6v4+w2oSfLAZ72KuC1/x146fvhVyoyvl1J7rwcZVwj5ILb9ra8MdMa+zxF5YKby4w1zy+koGpKz0yWPsEWmyL4QlzP9g8RegEAfgQAXrnI2LLjq92ZrPk0O+eLXgGKyhZmjuWHHqftiCeLB1/M8AW5tsDkgqPoydIMVYKZQXxZokC5VNNQ33ag6goWjoxGPSBSZm0/AUoJJlXGHozTlyU2rwIKvO0z9+MbT/S/hinxa0W+JZPVridrOO9TtJC45rHzhAZmM8hqwWQ1RrjbBfYZ03xLVgrs5hFyQb+lXHD4YKCwkLgYlsOXol1ZHGQp7kXryBLTT1fWOCdksvZAVuP0DbJ+4Rd+AV/5ylfwtre9DadPn8Zf/uVf4m1vextuuOGGkUZC7s1gU88wkGWUz3T5SQDbfHcmuwhVUXHtDJNP3XXmHgSUmTwbgxZEdK+Sy+L81ipUym6MQzFZ4uYaA1ndmSwBckAA8NLOnZALinAGUUicz7OFR1kw9ruNyaoXmFwQGDHI4oxL6Szz9/ERYSlNniwB6mPx7bw0VmN/V79M1g3cS1jU2eLINvPwOgRfPLTxELzAw2xyFvtzh0LZX70xxp0t8KqOD4vfzGdSABy2IBmXJ2u9YgOqDjztJ4H0DIJKFS4vsjWHWFzvtpEgy9mWaVQeBxGuT+F47DXfivixbN9GxeUhGF2YLG2SyVF9xQCt1SNFxMPtdPsRidLV+9nfcHqjirrTGQhkjSzSOvtcqCaXf1o+VC7PYsEXRQCAxW+jsxxk6YuL8N0AnpAnNzImfU4oGezflyXkjRsuO/8Xj01I+dawk5B/F4FNU5jUebz/GJmsrVr4Gjh+gJ//5L2496lCX88hPJz5Rk9WTC44unRBIGSyoFpwAnYNvWp+pklO3hpkxZkgu8TOM9W3QRK7X+61U3JBv1gKpdvRGHcpF3SkJ+tiJAsCQCbfe1fWOKdSYOdgdmr3nz87PX1fHT//+c/j9a9/PT7zmc9gdnYWt912G971rnfhS1/6Emp9RG/vzXjGzzGja7rWQyFxQ5y2kAzeu/oAAODIbLoJOAsmS83msFEosv82yVCJMmLxaNc9KGm2EOlFLiiDJ0wVQYl7snaAyTIa5IK5PLvhuR5/rUYMsiq2J3tYBkoXPHUXQANg9qpwZ24Uk5oKAdN6mDAomKxzhTqWi+zmN5MxgUrrImIA8PXBQNbhicPIGlmUdbYwsrowWcKPdfP8zezcTvHFOn/PJhpi3De5pyypq0h5AkgSIJHv6zi7jYxwb0gFDaoVeNzkns78ADFZ3JNVdsrI8EW/E1kkCDarlR9LV3QJ0tqNPsXOMdaTVRlJETEAuB7bLVZVtuExnTYQUOCJtd4lg0Rnz+HYnmSGYhHunJ6fqbLn1BcXYNXCmPBhS3+FZHCQriyVM28bKvtbRuXHAtjiWcRzO0Eakyo7vnHGuBd40fiPXb+I510xi7rr441/9s843oPPTkw0XTA2djOTRUcMshQtPO+ef9n+pp8zDrLUYL9YhFcoxI5FeLKsIgfzcC6JjfLGCHe77qFe5u/BKIMvCgVg4gD7YimU+QomK6uG6YLKDndkiem3K2tcU97zZLWdvkHWT/7kT+L3f//3cd9992F1dRXvete7sLy8jB//8R/H1NRofQp7M8BMMg32pH2+yw8i4sliPi6R1vZk6fsAgKMzzdIBwWT5KROawz7c6WFixREpoay6IZNV61EuCAZ6RAGtOuYyYiBksmRHF4+LpmItUNuUvrVRjGCxMqaG9CDBB+OQCoqRvqwwYXAmYyCb0EApJMhiTFbr+HZgcCZLIQpumL0hDL8w8x09WTL0Yp5H2DaALMlkcZAler5mskZcKqiMZvdeTOjJiu9GBuUyPM5k5XI/QCBLjzBZoiC3aCPBF1CCvRBM1vRSJiYV7LYY1HlAg6+aCCplKRc8OKxckC/sVI2AEIIrFxjoeHSlh4RBLhkMdM7Y1X3pgQnKoSfLpgFAKWbq7Dm1hcUw9CKlgwzhKQOGKyRWMllQEBSSbPE+Kj+WmDBhMIOckAt2YQmHmQIHSPPZBP74DU/HMw5NYtvy8C/+9J9xeqP7PQiIpgt2CL7QxxR8obHrHqUEL7qyeQNNSaWg8eAUwWbJCHQvQBBQONvsGqyR3R+XDzQzcducxUrmDBiJ4dl+6ckqFsOk10jCoJB2p8nF92QBFz/8glKK6p5csO0MtFLY3NzE5z//ebznPe/Bu971LvzP//k/kcvl8LKXvWzUx7c3fY4xexQAkPc3AacLGxQJvgCA62euBwBsumcAYjeFXgB8xxWAlVQjfqzhFn+yhLIekQv2wmTxhZieUNkiBTvryRLx8cTkuzfiHhV4LMlvRLPG49vncgNcwCgFnhwnyGpOGCSENEX/xzxZDfHtQOjJ0s3+L0kMZBUBdPZkeYGHB9YZS/v0OQ6yRICFYLL+P/beO06Sq74WP5U7T0/c2TybtEHaFYuEMoiMkMhBgAQYJIKfAZtkHjh8bGwwhp8FzyBAYFs8kogSmPRkMoooIAkt0mqlzXl3Uk/n6q6q+/vj3ltVnau7q2d6Zut8Pvrsaqa7p7anuuqee873HEay+JzFZL2OLJ+tgoBz407lyxVF4mbWUbIGk0tnl5ArWelS2t79zKV0RFX62cqXTFiWK1nQHd/ewioIOGTdklSY+TwOs+CLboqIAbowBQCJdeVsGaf/Dk/hFyxh0GDkoaQbToR7lipZJgADFhJ5QLVMQBCgLBuDzkMvYt3bkuwY9w7sglI8hmxsJcpyFIomYXStv2l0PDmxaEURF+l1r5d2Qa5kDUUVRFQZ//WWZ2Dr8gSmsjqu/c/7cHKutTrQ3C5YVUbsQ08W4Aq+kOl9RiAadq6pf11S103Qwzl4iB2Ls5FllEzobCNJkaya5/Yj7JksRr5Tp9k81og/9RZ8o9ZMperaBfnGyrKQZacLLtRMFuAKv5haGCWrkCnT66IQFBHXQ9srmu3bt2PZsmV45zvfiWPHjuHtb387Hn74YUxNTeEHP/hBL44xQBsYGBpFmrALeKrFXJZNsuhg9WhklC0ECKTw0Zr4dsBRsnIa8SVZEHB2L42SBYS92wV5v4c7OVVKNLcR+YFqJUsM04ucbJoosSQ4P8MvuiointkPzB0GJBVYe4lvx2TD7sqqShh0nTuaLCKuyQ2KiOm/zbBJVvs7kZUkaxBWNgurVLuAfGLmCRSMAuJqHJsGN9EvRipJFl8o8YWT3ZEV1ey5Lb+TBfnP5QLFrEvNMrNZlBnJGu1ynqifUC/4IpvSEWULwKxuID1ZgFm2ICkiEqNhTBWmALQOvQAA2aWIlnXTViS7tQsabOeaz4VsWc6ULA/hF9wuWJIo4SsXTTtowGI9WXboBXs5eWQEgqLYoRf8WtkN3MphuxDjccwmzwIAjK+LQZL8VXTdShYnWb20C/KZrEG2yTEQVvC16y7AupEojqUKeON/3YeZXHMyatsF66QLlqtJls9KlqjQE0UVQ5Ab/C6q57Jk2XmcUbKgs3/fYiFZUpVd0M95LMA9k5VykSxHydqxKomf/uVleMFZCddM1kKSLN6VtTBKFp/HiiRU368HSwEdBV888sgjmJycxK233or3vOc92LFjRy+OLUAHGImFcJjQoW/MHmz8QEIq0gU5+FyWFD5SkywIODNZKdVwkazudldV14yBGaaLL9LOTJZIrXliPD4vXRXVEe5cydLMEuYERvL8JFlcyeqk34dbBddcBKjdJVrVhd2VVZ0w6Pys0bhG7V1VM4AAYBXo75l3D/HFSDvYPrIdOc2xCwKAOVP7/ttWwbGnQ+SpgrZdkHVlVaULTjEla7TCLui/kiWJAoairkJihsx0yrYLjvm0U9sP4CQrb+ShxkVAACyDYJB9fnO6UTGPJYqCYxf0oGTRuQ16XSizNP5ESK5dCLcBYpqwLPfrA1uZkrX7RLpl7xRXsgoC/XeViqY940RJ1hxKjGQNp+lr8SLiYi+UrA7sgoKmYXaIbqysWO3/rrXtarBiiAq9V7J4wI27SHg0ruHr11+A5QMh7D2dxVu+cj8yxXKjl7CvFfXSBU30qCdLqbQLxtXGqYDVXVmCKLjmmkyU2PGrav/PYwEuu2M1yfJhHgtoRLIqZ9zPXjEA1Sw46YLawpGsxALHuGdngnmsZmh7RfOud70L55xzTi+OJYAPGI6pNskqTTUpJM7PACZbzMWcRe+mgW0AADF0pKmSNS0VfbMLiqJgF/waIbbo8GQXZEqWyGaj5iFZEKgtI+ZKlmYamLbYzc7H8AuuZC3rxC7Yy3ksgIZpAFQt07P2l90EfTSuUVJfR8my0wVBFyidKFkxNYbRUUp8dHUABAKM6dr3v2YeC6idyYpUzmRVKlm9I1mAq5A45yx+09MpO8J9KQVfxFyLwryZQ4TNm60J0T8fPpzCzHF6Pg0tp9ch2y7oQckSBAGKTBdhJlEgEqtrqyAplWDZmwH0GrBpWQyiQGd7eJJmIyyL0PM+B7pRVa6yC5L8rK1kDafpn9VFxKEukwWB7pQsYhGkBjYCAMbHuj6UGtjzuVYUUdDFcy9nsrhKNVhl9Vs1GMHXr78QQ1EVjx6dw9u/9mBFQbkbc3ZPVtXns0LJ6hXJoufScKSxbdNWsg443ZmS3ZVl2Y4QpYMNroUAtwvaSha3C/qsZFnZLEiYneT6HFCsUqvLBXsmS+wDu2BmgUhWhicLBlbBulgcn6oAnhFRJRwX6M1cn9zf+IHcKhgZAWTnApGU6A1UjR6tG7LAlaxTYhYhpmRFuiRZgFNIbGjMPuMhwp3PREmE3uTmi2RxJYvfnHjsrWaWcNpgxNRHknWqUyXLMoEDd9K/r3+Ob8dTgcgQEGU3oilHzXLPZI3GNJqcZrCbgFvJyhdgCRIIU5Y6mckCgC2rNoLAAhFllJVYjZJlEQsPn34YAE0WdI6/PsniM1l28EVMddTJHpEsnjA45UoYzM6k7ZksP6xi/QJZlO1Ic1pITG/QFy5PAgB+9MdjmD7mzGMBaEvJAgBZoQsgS1KhGaWuQy+IrsOS6PkhsYVeSJHszaj8Lz4O/H8bga9cBfzP3wKPfpemblr0OsGVrDRJAahUsmCaINm0YxecYySLFRHrPhQRc0ST9DzLz5Xa7tY5fTgDUwpBLueRDLdP0lrBbReMgF4vepouyD7nPDHOjY1jMXz1rRcgpsn4/f4ZvPuWhyrmJQGgbFq20lahZFkWUM7VzmT5HXwh0N/fQKixkmWTrEOHQJgUq7i6sko8QCq8OMrO5aoI97StZHXfkQWwkQMWbGQWDCdJ1hV+AQAo50DY6SAsULogsPBdWdkgWbApApK1xCAIAmZVmhZoTR9s/EDburW88uv6KhAigkhzOJk7WfM0kylZJ4Q5W8nyw8LCbSJ8QdmWkmXR3cj5CL0A3GXE9OYqMpIVIQZmwBZNPVCy2g6+mDsClDK0tX58u2/HU4Mxpma55rLWDkfAA+AqQi+0AUBxdhytYgGm5Py75DbTBTnOXbYDeYVuAOhaskbJOjB3ACk9hZAUwrahbc43quyCyXDlTBa37g27gy/4HJfPGGZ2wWmXXbCQStvvT7f9SP2Gyrks+hnakghDlUXsm8zh+GF6rbFJFlOyRsIjnl6fb4aYkoaQWepaybJ0l5LlOk+3LKf/jtE93wJyk8Chu4B7bwRuezvw+WcAn1gN3HwFlt39eQBATmBKVtGEEA7TPHgAZibjKFkZ+qdjF2QzWT50pYUTKrVnWgSFbGMbXD0c20M/A8nUk0Au2+LR7cMmWVYUIUIXz72yC1oWcdkF63+2tq8awH/92fnQZBG/3H0aH/r+o7BcC1muYgkCkHCTrDLdILBJlt/pgkolqYrIjV9PWbkSUBQQXYdxkt7T3THu5RL996hdVgPMFyRXumBZN5Gbo79Dv+yCgiTZs93UMshj3KtqcUp5WH2QLmh3ZZnEfi/mE3wmKzYUKFn1EJCsJYhshPqIpblDjR+U4UXE4xVfPjpjwNKpErZralfN0yymZGU0CxGDEgo/lCxuE+HzJ1bOQ4Q7U5Ikk37I503JqrILciUrTAzMkh6QrE6VrKmn6J/DGwCxh7uU3DLoShgMKRJWDdLf5UjMVUQcX1bxVFIowJTo+SPKQseDs08be5od417UkjBnKgtFuVVwx+gOKJJrMdSgJytVo2T13i7oKFkukuWyoC2WRZBXcJKVKWVsC5uRNfDczWMQCZBjaVnDK+mC0h3h7gUKI8ympCFqFnywC+o2yZJk5/O0dTyOOPKIlmghNl7yGeCCdwCrLgDkMF1wH74X0Qf+E3HTQpn1P5V3/QzCz/4aEjtOq0RqZrKUcUqy/FSyJEm0Ld7tWgY5yRpMPWknzfoJeyaLRKFZvVWy0sUyOF+qsfq5cOH6YXzxjU+HLAr4wcPH8I8/fsyev+MkLRFSILmj9Zl12l1GTEzTtkcL80iyBFmGupoSheoYd6Nk2v2OWmRxLJJ5cIdRtpCeokRci8q+fDY46s9lHal8UNk1k7WAdkF3V9ZChF8EM1nNEZCsJQg9TjtMQtkjjfua6oReAMD+yRzMAn3+rslakmWyqPScBkQNukgKJ/xQspg6xNL5PKUL8p6qMr2wzJeSpVbZBcUwJRMhs4SZXpAsttBueyaLk6yRTb4dS13UIVkAcNYYfS9WJEN157EAmi7IlZpuCq3XxNegFKLnjK4lYVZ1ZblLiCtgpwtyJavKLsje+14HXwCuriyXXbBcYDUBggmxy36kfkNljLuTMPiyp63AoCVAIHRDg3+vXbugEqLPMyUVK80prB7sbqeb6DoskV6nuGUJADaPJ7BeYJtWsXHg/OuAK/8/4G2/AP7mGPAXvwde+SXgwv+FZaJqk6xSNgc88B8QCb2mmmUBukzPv+EMs3Utr5rJ8mkh2UkhsVm2cGIv3cgYTD0JK9s6tr5d2MX0VgyqRT/PuR7NZPF5rLgmQ5WbL4Weu2UZbrj6XAgC8LV7D+HTv6Dl63boRZ2OLAAwCOv/UyW7ExAAxGh3IUSxqqCLiNKctHHLoM7mstxzTWWT/tvVRTLzyVU4s2Ri7rS/VkEOvpYwZmeBAdaVNVfHLmguPMkCFjb8IlCymqOjrdFUKoX/+q//wu7dtID07LPPxnXXXYeBeVISArRAYhXMowJkqwhkT9eoBwBq4ts59k/mYBZXA4P34dGpR2ueZqWphSevilDL9MLWbfAF4IpxF+kH1ZNdkM9k6VT1mo8iYgBQQtwuyEgWswoo5RJmfbYL5nTDtsuMJdpVsuhCACNn+XIsDdGAZP31FZuxdXkCV+1YATxYmywI0DJim2R1aBUEqE02klSAaW4XdGayCCH1Qy8AR8kqZQBDt3e0M7qBQslEmp1jvY5wpz+DB184SpbFLbFLyykIAIgr9LOSLqWxjilZ2VkdV2wZw5cYmdGGaDKlburIlNmQv0cli1v6TFHDKmOy65ksS9ftFEzJRbK2jMexkZEsa+Ssyp1LUaIJnGNbgXNfj/FfzuEUU+jKY+cD578b4q9/AuRKsMoiiiObIFjTGMpSkiWPV9oF/SJZsaSGqSPZtpSsUwfTMMoWVKGEaO6EveHmJxwlKwbVZCSrR0oWn8dKenxPX/60lcgUDfzdD/+Ez/16LwbCCiaGKVmqlywIVCpZFrdXyjIEpbvfY1ytDLrwSrKcriyXkkVkQABCA/4SlV7BHeGemmShFz5ZBe2f4S4kXlE/YdAdfLGQ6YLAwoVfWJZjUYwHSlZdtK1kPfjgg9iwYQM+85nPYGZmBjMzM/j0pz+NDRs24KGHHurFMQZoEwOJKE6ALUQaxbinK4uIAcC0CA5M52AVqLXg8enHYViVNzgzy24eagQCoRcYP2eySoT+2U5PlsSsGfM3k8Uj3JnKwJQs0Shj1k4X9CfCnatYEVVCrN3kPVvJ6jHJ4jHuqcqEwS3jCXzwRZvpcTdQskixAFOkN6huSBYAjI4mATCS5VKyjueO41T+FGRBtgu3bYQGAIH93PwMEiHnPd4/Rf8tsijQaPdCin5jHpUssI+f2mEgSD+jnpKVS+kIKRLOT9LP0WmRko0ZRnBlUbZthq3gnslaYU1jZddKlmsmy0WyVg2GsVWh19O56LqmrzEeHXeULHkYeNHHIa09lx7n8/8Npef+PQazgEQAS5Qgj9DrOFey/JjJAoAITxhsY4bjKLMKjoUyEABYvbALutIF5V6TLF5E3MQqWI03XrQWf/0iGmH/sZ/uxlfvPQgAGKiTLGgRERa48inBytPNQDESoZUWXYCHxnA0swsCgDqxFoDbLujMZBnsGNXE4iBZsotk+d2RxeHYBeeazmTx4IuFTBcEFq4rKz+ng1gEoijQWc8ANWj7zv2+970PL3vZy3Dw4EHcdtttuO2223DgwAG85CUvwXvf+94eHGKAdjES1XDYatGVZStZK+wvHU8VUDIsyOYyxJQYCkYB+1JODDyxLNrnAsCU6E6aFpF9KaCz7YKE/tlO8IWQp+rafEe4GyULlkXs4AsAyJj0YkcKPpGsNI9v72CXyFayemwXjAwB0dHKn1mNOh1ZAE0X9EPJAoC1y6mtQ9eSMF1K1kOn6ObP1uGttTu+glBRSCxLrDgZwL5Jlm4XValVz7YLJrs6zkaonskqmxZEi362wksoWZCjbiHxbBGEEKxl0t2uTB6GadmhF0OhIc8LVIdkqVgrpqHJ3Z1fFTNZLpIlCAJ2hE4DAI5Iq5q+xrLIModkcbsxG7K3TA06TLuIuDAwBIGFYvg5kwW4urLaULL4PNayJL0m9cQuGHHsgpKpQ4LZs+CL6iJir/iLZ2/AO5+1HgBw51O0ILueksVVLIApWT6FXgBASApBFpxrQjXpqoa2jpL/6pmsYr4Mi72ONtCDHsUewLYLli07vj3pt5LlnslKMLtgulrJyvfFTBawcHZBniwYTWpLzs7uFzpSsv73//7fkF2lr7Is40Mf+hAefPBBXw8uQGdwd2W1JlnOonf/FF1Urh2O4eyRswGgwjJo5fPgbZxE4EXE/lxc+FB/yaxMYWoGriSJWTonMN9KFgAYumkHXwBAwWIzZbkpX37WKXsmqE2/cyEF5OjCD8MbfTmWpmhgGbTRaCar6MxkyV3MZAHAWavoQkLXkihNT9pfbziPxdEg/GLvabpTPxLTAKNkW4B6lS7IlayprA5CCE7OFSGxRX20k460PodNskppJ/iiZEHPGxAz9LN9yCjjnn3Tbc9jAS67oKRiBdItHt0adCarlmQBwDrQBdhjpeU1z3NjPDqOssjsgtzuHGO1FdkMdFO3Qy/0QZqiaJRMuxNooWayyiUTJw/Q6+w420/pdfAFIUAEes96smYbdGS1giAI+PCLt+ANF6y2v1Yzk6Vn7WRBgJ4vxEeSJQgCoq5y+dZK1gQAoHzsGKxSyb7WFtKOkhkaahwD309wq8gzx+maZWCsNzNZ5uysK/jimL3+AQCUXemC6sJenxfKLpiZCeaxWqFtkpVIJHD48OGarx85cgTxeLzOMwLMN4ZjWnOSZRp0VguomMnaP0lvmutGoratyh1+weexyhKgEE6y/Lnph7iSxZKO2lGyxCzdYZ0vJUtSRAhs16asmxBE0d7JSkSS9JgKs5UX5A7RsZI1vZf+GV8BaPPwuWxFsriSVW0XLOQdJSvUHckaHqG/f10bRHlmxk4As+exxp5e/4kNurL2sc/DcMwVegGBxtD3AFzJ0g0LuZKJE6kCRIEei7ZIhtLbAZ8rSZfSkBXJth3PnS7YNqApycKP/ni87fh2wAlSMSUNg2b3qovlIlnuhR6MEoZLdCbrvkxzEjgeHUdJZiSLX794IXEmC93UMcIOtTRE2QyfxxJFoevPCEe7hcQn983BMgiiSQ2JEbaR1IuZLGaHJJBQJiFEUeiZksVnstolWQAlOR97xXa8ZAe9f24er7rGlrIVHVmCIPiqZAGVCYOtZrKkkREatmFZKB8+DIWdv3lGsiSjCDmxONZvkqs0uZChv0P/Z7KSAJiSFV8OCCJglWlFA0ADxcp5EMb/F1rJWqiurCBZsDXaJlmve93rcP311+M73/kOjhw5giNHjuDb3/423va2t+ENb3hDL44xQJsYjqo4YpOsA7UPyJ0GQOgsCrd5ATjAlKz1ozFsH6G9Su4Yd3eyYMKku/l+xLcDgMpnstjGmpXP24vkRrDtgnPUGjZfSpYgCK5C4sq5rNEEXYALxKQt8V2Cz2SNtatkzZdVkKNOV1YFuJJVE3xRtCPcu0kXBJyFoylpIIYEks9jujCNg+mDAICdYzvrP5ErU4XKrqx9TMkarYhvT9pFlX4josoIs9Sv6ayOE6dmYcr05hXqxC7a53DPZAGwLYNHds8ABJDDEnIC8D9/OolTbHHjNfQCqJzJipX9ULJKddMFMbMfIjGRIWH8/nTz6+GyyDKURccuSAiBGGdKViaDklmylSxrhF7D3fNY3c7ycETbnMniVsFVmwftxbjZA7ugrIgQZfpv1EkMUaGInG60vBd0Ansmq0N1UBIFfO4NO/HrD1yOay5YU/nNUhblHnVkcbRDsgRBcIVfHITErrWcZMtmwSb7/Q5JcjY5AWrf92MuvOJnuO2CkuxsRvO5LJZo3C92wYXqyrKTBQcDJasR2l4t/Nu//Rte9apX4c1vfjMmJiYwMTGBt7zlLXjNa16DT37yk704xgBtYsSlZJF6SpY79MK1YNw/yUlWFNtHKcnal9qHLLNJ2cmCIWBMpLNcftkFbS8+K0aEYYCUmxdl8pkGgSlZ4jymW6pVXVk8YXB1PIQMYbtqPoRfPHmKLmQ6J1k9Dr3gaKZklfKAzha5NRHuzkxWp0XEHIomQQzR86eoDcKYmcHDpx8GAGxMbkQylKz/xKpCYm4X5PbZkXjvkwU53HNZk6em7XLuUMLfndp+gHsmC3AW/ocfp6rV2Ko4lidDyOgG/nicLm7asQvaJEtUoRWzjessPIKUdDukxd2Thak9AIB9ZAVOZnS7O6kexqPjKEl0YUIsArNsQYo5pIXaBeljrTH6WfF7HgtwZrIKmRJMs7XizkMvVm4ehMiOtxfBF4IgOJZBK4YIdFgEKJa7dwVUo9OZLDcEQcD60Vgt+dWzMOEkCwI9IFmuGPdWdkEAFSSLH1M+xTomjSKkLmPl5xNuu25iNOzb5oP9+m6SBdR2ZVWTrAVOFxQlEfGh+e/K4jNZgZLVGG2TLFVV8e///u+YnZ3FI488gkceeQQzMzP4zGc+A62HrdczMzO49tprkUgkkEwmcf311yObbX2Rv/fee/Hc5z4X0WgUiUQCz3rWs1AozN9J6BeIZaH4xBOY++lPQczmHvWhqDOTJWRO2BcEG3XmsQDHLrhhNIqR8AhWRFeAgOCx6ccAVCpZw+z1Qz7ZBXmqVKno3EybFRITQuyZBtnUAUGwW9rnA07CICN6YXqRWR2VMEt4wmB3Me73H5jBb/dMQhSAZ28ea+/J85UsyDHKEwYPAaWq31uWWQXlEE3zc8FdRtxt8AXgLNR1LYnC5MnW81hArV2QDbGXDHouDkd735HFMexKGJw5PWOTLG0JB19kSvS6EmO/u5P7KcsYWhG17VhPTlE7XjtKFp87sSQNKJtdfx4td0+Wy7KESbqhcUKhMzqPHW+smoXlMCIRhzCXiqZLycpCN5yZLIGRLL87sgAgHFPooDoB8i12vktFA6cP0d/Rys1JSC7lrRdwJwxGBVZIXPLfMsjJcCd2wZaosAuy8zDnL8niFQhAayULAFQWfqEfPGi7BvIZ+h7IVmnB1Zh24FaS/e7IAuqQLDv8gnVllek9jlj0fVzodEHAsQzOZ/hFoGS1Rtsk67rrrkMmk0EkEsH27duxfft2RCIR5HI5XHfddb04RgDAtddei8ceewy/+MUv8JOf/AR33HEH3vGOdzR9zr333osrrrgCL3zhC3H//ffjgQcewLvf/W6IPbL79BSE4ODrXo/jH/ggykePNn2oKoswQ4OOopKqmqGr05GVLxk4Pkc/MOtG6E2Uq1ncMmhyJUsTEDeTAPyzC9q7l3kDYGSd35TqwSxb9sa0ZOoQEwk7iWs+YNsFuZIVou/1ipCAGR+6siyL4J9+Qsnt6y9YU+v5bwVbyZqH0AsAiA4DkZHKn83B5/9iy2ianwsVPVld2gUBYJANb+taEocOPdp6HgtoOJPFMVJhF+wtyRqNOV1Zc1NzKMv0vNKqB+uXANzBF4Bzo+YzBcMronjZuXRxc4oFybSjZIkKPddMSaMD6tXXwTbhjnCvCL5g57sxRK25v9/f/HM/HnUsg2XdgGTPZKUrZrKkZZVFxJqPJEsQBUQ8hl8cfyoFYhEkRkJIDIedGTIPm5ydwHY1kBgGZUoCehHjPtNh8IUn6BnHLlitZEX9IQXu4Iuo3FqFqqdk6QVWeo3mrpF+QwXJ8jm+HXCRrLk5EMtyKVls7VWiv0tC6D2rHwiqE+M+fyQrw5Ss+FCgZDVC22zjq1/9al0lqFAo4Gtf+5ovB1WN3bt34/bbb8d//ud/4sILL8Rll12Gz33uc/j2t7+N48ePN3ze+973PvzlX/4lPvzhD+Pss8/G5s2bcfXVV/dUcesVBElydqL27W/5+JFYyDWXdbDym3VI1sEpFoUaUTDE7BN8LuvRSZowyO0h+RAQKvubLshvrMQiILEk/Xn5xkoWtwoClGTNV+gFh1NIzGayQvScGg8Bs4QuQsqZyfpP9oBbHzqKPx1LI67JeP8L2lSjzDIww86R+VKyAKcvq3ouq0F8O8DSBUV/ItwBZ6Gua0k8deAP2DNLrVw1JcRucAugrWRVntPDMdWxfrZBsjqZIxmOOkpWZjoFg+1Q8939pQQ+k5UpZWARC9Fk5Y16aEUM56xMYN1IFERqr4gYALJMiTQlFZYh1PbctAniUrIk2U2y6Dk2uPYcAMBde5sniy6LLrMtg1TJYhHumSzKxTyS7LKnLudFxFzJ8vcc4KpvPtVcyTrmsgoCgGinIWZ7Mivl2AWjGFLosfUi/IIHXwx1YRdsiFLOUbL6YCYLcJGsAwdrklxlsTfhIr2C+/j9Dr0AAJnPd1sWHZOwu7K4XbD/SFbCThicH6eWWbbsdMogXbAxPJOsdDqNubk5EEKQyWSQTqft/2ZnZ/Gzn/0MY2NtWpo84t5770UymcT5559vf+35z38+RFHEfffdV/c5p0+fxn333YexsTFccsklWLZsGS6//HLcddddTX+WrusV/7Z0uvuBab+grWddFwdak6ymMe51Fr28eHX9iLMjtmOUJQxO7QIhBGaGvhe5ECAW6UXFr3RBWRXtngUzThe9pEnCICc3sgwIIPMWesFRbRfkSlYcJjISJXyzUyc7eu2cbuBT/0MXbu953kY72tszZg8BlgEo0YoetJ5jlJZ01sxlNYhvB6iSZfXILrhn3/2wiIWVsZUYj9YSPBsNItw5KpQsD/HtxDRx4LVX4+DrX99yrrAa7pmsfCp9RtgFCQiy5WyN5WRoRRSCIOCl566AKLM4/TbSBWdL9L03JRXEEJwFUocgJd0+V227oGXZ1txN26gl9Y9HUkgXG//exyNOIXG5aFbY78Qpep7pkojQCCU1OksX9FPJAtzhF82VrKOu0AsAtvIGy2rqNugUlUoWfR/9jnG3LOKyC/ZAJXb1ZFUrWUIvSJanmSxaSGxOT0M0Kn/niuj/zFsv4VaSkz1QsgRVpWmMYJbBAWYXnON2Qfq7tEyRPX7hScZ82wWzLDRFUkRfrcxLDZ5JVjKZxNAQLYI866yzMDg4aP83MjKC6667Du9617t6cpAnT56sIXCyLGNoaAgnT9ZfyO7fT4nIP/7jP+Ltb387br/9djz96U/H8573PDz11FMNf9YnPvEJDAwM2P+tXr264WPnG+r6DQC8KVnDUQ2HWilZCWcB7oReOBfurUNbIQsypgpTOJk7CWOOpuXlNMDKU0Lkl5IlCIId32uxGPRmMe48cEJmN4f5VrJqgi9YVxbRi7Yykp051dFrf+G3ezGZ0TExHMFbLlnX/gu4rYLzaY1tFH7RQMki5TJQLvtWRgw4A7i6loSapudP03ksoCb4orpYdDTenl3QmJpGcdcuFP/4KDK//GUbR+/MZB2azkHM55a0XVCVVIQktvtaylSQrMiAat+4X3zOCASJ7s5Klnfb7DQjOqaowTLErpUsq56SlT5GF1yigmVrt2DdSBQWAe7b3zj0Zjw67iokNirsd8okvcZORcMIqfRnFfP+z2QB3gqJi7kypo5SgsuVLCEUortb6E0hcSjizGQNsPfJbyUrXSyDJ10ne2IXrDOT1cPgi1ZlxADtY5NG2SZFqtLSqiyyy0uvZ7KAqrmsarsgD74g/ZEuCLiVrHkiWa55LL+DR5YSPK/AfvOb3+BXv/oVCCH4/ve/j1//+tf2f3fddRcOHz6Mv/3bv23rh3/4wx+GIAhN/3viiQaR0C1gsY6id77znXjrW9+KnTt34jOf+Qw2b96Mm2++ueHzPvKRj2Bubs7+78iR7nY//YS2gbbMl/bta/nY4Zja2C7oThdk4PHt61xKVkgOYdMgnTN4dOpRZGboYrkcDqNUoOTCLyULcAqJjTAlTM1IFrcLygL9c6GULDvhkJEsq1CEHKM3smK6fbvgkZk8/uNOGrv/N1duhSp3QJLmO1mQoxHJalJEDMCVLtg9IXQrWQlmu2pNsrhdkJGsqkXXUFR1pQu2JllWxlG/Z77xTQ9H7WCEKVm7jqURKReXtJIFVCYM8t8dQOexOAYTVHEgRMRdTza2EFfjVJ4u0E1Jo3ZBH2ey7EUeswpiaD0gKbh0IyXsdzexDC6LLkNZcrqy3PY7bYqSlqloBBFOsrI9IllJNpPVhGQdfzIFEGBwPGKTMkEQnALlnnRl8ULiGBJsds3vmSw+jxXX5M6usa1QytgkS6meyQr7q2TJogxF8nZuaBN0045Mn674uqIsrkUyVwdlRbRnC/0GX1MYs7OOXTB3GjB0O9yJ2GXEC89S7ZmseerKCpIFvcHznfvyyy8HABw4cABr1qzxhbl+4AMfwFve8pamj1m/fj3Gx8dx+nTlRcEwDMzMzGB8vL4NaDnzs2/btq3i61u3bq1bpsyhaVrfzmyp6ynJ0g8cACGk6e9gOKbhkZYzWW4ly0kWdGPH6A7sntmNXZO7MDY7iRCA0MBKYI5mGIR83GGnu/UFmCEWEdxMyeIkiw3sLtxMVq2SFR4YBSYBM9d+8MW/3v4ESoaFSzYM4wXbau11njDfyYIcfCZr9hAdDFbZYqKBkmWx2U5HyeqeSLhnshJsnds09AJwlKxyDigXMOBSspIRBYokupSs1nZBM+0sPAt/+AOKu3cjtHWrp+PnM1lTWR1R06AlmFi6JCuuxnG6cBrpUhrqsAw1LKNUMDC0wtmlny7QzxExYvjxH0/ijRd5U3dP5EpYBzaTZfpgF9R1mHbwBVNd+WdtlH7WLts4gm/8/nDTuazxyDhK0kEAQKlgQGL2aFgWYidS9GUjEbszTc9TguE/yWptFzz6ZOU8FocYj8NMpezEWT/BN9uKVhRxkVnUfSZZfB4r2SubUyln2wUlW8miC3O/lSwvKhaHOjGB/AMPgJw+AcD5HGnaIiNZ7LMxMOZ/fDuHNEjPeTM1RzfX5DBgFJh6zZQsRrLEPlgzRgdUiK6urF4n/mVm6EZRPEgWbIq2t3DWrl3r20k9OjqKLVu2NP1PVVVcfPHFSKVS+MMf/mA/99e//jUsy8KFF15Y97UnJiawYsUK7Nmzp+LrTz75JNauXevL8c831IkJQBRhpdMwp5oPV49Uz2TxAeVyASim6N/ZopcQUtcuCKCilLjESn8jMSqdh+JqRSlgt+ALSSPEdkk92AUli5GsBZvJ4mXEjpI1MELfV6nQ2DJUDw8cnMFPHz0BUQD+/iXbOv+ccSVreJ6SBTmiI4ywkMqEQVvJqrILcpLFCncV1T8lq6zEEC/IGAoNYW2ixeddiwNs8Yz8TEW64DAfim/DLuhWsgBg5pve1Sw+kwUAEdZfJMKqTLNbQmhUSDzkUrKmi4xkmTHcf3AGJ+e82WGOpLlSymeyugy+KOm1StYku7+M0HnEi9ePQBCAvaezDY9zPDruKiQ2Kux3A0fp+zAZjSPMFufuMmI/YdsFm0S4H6uax+IQexjjbs9kWTHEBHqNyOn+zmTZRcS9sAoCFXZBRelNTxaPcPcyj8XBwy/IycoNByW88EpMO+Cfv15ZBYEqu6AgVFoGeYQ7Oy37wS4oSqIdQDEf4Re2khUkCzbForhzb926FVdccQXe/va34/7778fdd9+Nd7/73Xj961+PFSuoGnPs2DFs2bIF999/PwBqafjrv/5rfPazn8X3v/997N27F3//93+PJ554Atdff/1C/nM6hqhpUFbRD7q+/0DTxw5HNRwjo7Ag0JmBHLOucRVLDtudRZNZHRndgCAAa4YqL1o8xv3x6cdhsBCQaJQeQ8RHqyDgIllsZ67ZUHXJ7shiZYoLPZOlOUrW8BhVUcNGynP6lmUR/NOPHwcAvO4Za7B1eYedX4QsnF0QcPqy3JZBW8lqYBeU/VOytIgMib1M2EjiBWtf0JqsCkJF+IVbybJDRwop9qKtSRZXsvhNOv3jn1DLiQe4Q04i7NRRZWvJet6ru7K2XrIcwytjWHuOkyLIlayEMghCgJ882jhR1o0jGbbbLCowTIkGm1R3uLUBSy85M1m2XbDyszYQUbB9Jb0W3bOv/kbYWGQMJZme+9lcntrv2FzW8AnqKJiMxGwlqxc9WUDrmax8uoSZ4/T9WnFWsuJ7doFyDwqJuTuiRKKICT2yC/pQRNwUFcEXVTNZPkW4L4/R+0zTUJ8qqOsmAADmsUqSpS6y9FLJJlm9K2lvXEjsVrJYp10fkCxgfsMvgo4sb1gUJAsAvvnNb2LLli143vOehyuvvBKXXXYZvvzlL9vfL5fL2LNnD/Iu9eO9730vPvKRj+B973sfzj33XPzqV7/CL37xC2zYsGEh/gm+QGMx7qX9zeeyhmMqypAxKbBBV24Z5AvexHK7s+gAU7FWDYYR4jYYhonEBOJKHEWzCDNNh7KjIUpsQzF/Lyw8pprPoXixC0rsYrfgM1kuJWt8nCYRDZA0pnPN45E5bn3oKHYdm0Nck/GBF3ZBjvLTTKkUgOEFOM95wuDp3fRPswzk2WKzkZLl40yWIAiIJeh5GSJD+OD5H/T2RBfJCikSQuwmbpMeHuEe8UCymJIVecYzoG3dCqLrmLvtNk+HMRhR7CqxECNZitJ7f/1CwT2TBQBPe/4avP7vL7AJAOAoWesG6fnzoz+2Jlk53cAp12evzDsDeTpYB6AR7tUzWYxkjTqf2Us30mtuI8tgSA6BhRQixYIjePhFcoYe83RkAKosghDSO5LFZrL0vAGjTnrfMWYVHF4VQ7jqWs+PtxfBF24lKwJGRn0uI57tZUeWZVWVEdNzhfhcRnzW4Fm46fk34RPP/ITn53AlyzxysOLrWrsJtguMNduGoEVlTOzwXunQLmySxTfI7ITBo3ZPlsVqIoQ+sAsC7q6seVCyZoKZLC9YNCRraGgIt9xyCzKZDObm5nDzzTcjFnOsbRMTEyCE4NnPfnbF8z784Q/jyJEjyOVyuOeee3DZZZfN85H7C3WDt4RBPkBfE+NepyNrPwu9WD9SaRUEAFEQcc4I7X8JseLCiEYViV4pWWWWOObFLiiynWkpOd8zWVzJojd/PpNlFQvQEvQ9TyKH/adaVwB0HdnuBl/0JdcASu92+RqCz2VxGxUvIhYkh8gw2DNZIotw96GMGACi7Eajywkouebx1Dbs8IvKrqyRmEoHnZk9xJNdkClZ4kACQ2+8FgAwe8u3QMzWlidZEu2Fn8aSqzR1aapYAJ3JAhy7YD1wJWv7+CpIooBHj87ZQT2NcHS2ABOABUpQy2ALgbnOwy8sF8mSFJESb+4QGN5kP+4yRrLu3jvVUMkOsfMrm2PXr1jltTcdp+eZUbJgGfQ1/J7LU8OyTRbrzWXZ0e1n1Z7z/Hh7MZPFbZFFEkWIkaxezWT1hGSxeO9epwsCwKUrL8XK2ErPj1dXrQIkCWKu8vOmRfuDJHjF5ouW4/p/eyZWbOpdObw0mATgVrJcXVm8J4srWUp/KFmJQMnqO3REsgzDwC9/+Ut86UtfQoZdZI8fP45sjxrgAziwu7L2NydZfIB+vzFKv8BJVp1kQR56sX60/gDt9tHtACGIsPuwJtMFqV/x7Rw8ptoQ6LFbucYLKZvcFOixz7tdkFnbylXpgqSo2wtxUSA4eqL1rvsXf7sPkxkda4cj+LNLJro7sIW0CgKuriymZGWZchobq4mTtwpFEAiwBPpecuLaLbhHXNeSMKY9zsXVJAzSc5F2ZKXo9wQR0FqfZ1zJkuIJJK66CtLAAMrHjiH72996OhQ+B6awy7Pq0/vSj6ieyaoHTrJWJcZwyQZK1H/cQs06MpMHBMBi/NS0NDqWmuo8/MIsle0gElkRnc9aYhWgOSTpvLWD0GQRp9I69k3WvyeGw8yql6cbDVwZ4sgk6PnIVSxRFnypOHBDEAQn/KJOIfGxJ1joxZbahaytZPXALuiUEcegmfT9yfdqJqsXwRcl+p4YqFSyekGy2oWgqlBWrYRkVv6+tcQCbMh1iV5bqBvaBVltA7EA3gPQD+mCgGMX7HWMe1k37UCeeDCT1RRtk6xDhw5h+/btePnLX453vetdmJykO3mf/OQn8cEPerTmBOgYdldWC5I1EFYgiYInJeuArWTVJ1k7RnZAKwMS25QVTHqT8JtkcV94GfR1vUS4iwW2oF2o4As7XZDepKxiAZAUFCS6CJk81XwxeHQ2jy/fSX+Xf3PlVmhylwspO1lwU/PH9Qp8JosnDGaaFRHnYUrOOeSXkhVLOiTLnPGY8FhdSMzmsoZjmhPfHkp66h3jSpaUiEMMhZB87WsAADPf+IanQ+HhFzLo+7FUkwWBWrtgPUwVqe1uODyMl51Lrco/+uPxpvOOh2fYtUNmBeeSRpPAugi/cFvqJDfJGq3c0AgpEs6foMTk7r31z78Ym8spFuhilwdJAEBeA0iEvi+2VTCi9GRR2ShhMDNTxNxkAYIArNiUrHmelOi9XdCCAtmk/36/e7J6OpOlM5Il0N+xrEoghPQFyQKoZVC0KsuyteTCHlM/ooZkJSrtgsRyPo/9kC4IzJ+SxVUsNSQtunm++UbbJOuv/uqvcP7552N2dhbhsLP78cpXvhK/+tWvfD24ALXgSpZx8iTMbGOlRxQFDEXrdGXZIQQuu2CDZEGO7aPbEWWfWVMEisw26GdHFuCyCxL6up7SBYsLo2QpVcEXQoheZEmB9d9odJE1O3Wi6ev86/9zIttf2Glkuxu2krVAJCs6wmLOWQAHV7LitcPZpFi057EEAb4l6Llj3L0rWYxkMUL1umesxrmrk3j25tG2kgUBx0IlxulCefANbwBEEfl7fw/dU8cdPX5JoJ8DrVfD+X0Am2SVWytZw+FhvOiccaiyiL2ns9h9ovEC/8gsvXYIjLibkkq7srqIcTdLlv13SRZrkgXdaDWXNcCCI/hmEQ+SAICpOBBinwubZMV6s1MeHajflcXnsUbXxO1ZWTfEHgZfKJpkzyUSg/4l5/NMVirfw5ksFuJSBidZIkixaCf8LjTJ0iYmIIBAhHM+h5L17/1nMmqVLG4XpOmCxCWu9k/wBV2TZ2eKsHrYlWXPYwUqVku0vaq588478Xd/93dQq06qiYkJHDvW+VBxAG+QkklIw3RBWDrQKmFQbaJk0UVv2bTsXd9GdsGh0BDWSfR1ShEVBVaO6b9dkN7MS1alh70e7OALUwdEscZu02tUB1/YSpZOSZbA7Ge52dN1nk3xwMEZ/MSPyHY3Fqoji0MQKueymilZ+YIr9ELybaee784Xu1CyXvX0Vfjvd12KFclw2yTLYimcfLdfWbkSsec+BwAw6yHOfYSRKonN/2g+f876CXwmK6M3Jkw8+GI4NIxESMFzNlMLdLMAjCPsmsY/p3YhcRdKlllm1xyJWZWabGjwuazf75uGYVo13x+K000hTtzc16/phICQwjYKcpRc9ErNjNh2wSqSxeex6lgFgd5GuAuCAC1MrwVWmf6Z9dkuONPL4As2J2ywOUBZkSruZUJ4Ya15KgvPksCIK7GgDs7v/XMxQHYFXxBCgATrFS1lgcxJWFzJEkUIcn+oOe6urHyT/rtukQnmsTyjbZJlWRbMOgPcR48eRXyeF7pnKjRWStwqYXAkpjkkK30cKBcdksUuGIdn8jAsgrAiYTzReFdiu0Z/JomFUcjQG1SvZrJKZqWHvR7cEe5SIgHBg43LT6iuMmJCCESWLsiVLCVOF1lGdhrlOoss3yLb3SgXgdQh+veFIllA5VxWEyXLKhZcRcT+zZtUKFkzbSpZ+TqkjCcLtq1kOdfDoTe+EQCQ+uF/twwLGI5pEIgFItJ/R3gRzkt4ha1kNZjJKltlzOk01XQkTD9TLzuX2nZ+3MQyeGSGzvKEmApjiiq1C3Yxk2WU6edYYhZExy5Yq2SdvWIAA2EFGd3Ao8fmar4/nKDnEinR15IqSBYQYd1xvUoW5IjZdkFnRocQYodeVJcQc/DjNXtgFwRcSbNlel3I9yj4YqiXdkHXTBa/lwmRyLzfq6rBEwZFgy7CZbMIOR4oWdXgZcSkXAbJ5wE14twnpp60i4j7JVkQqOzK6qVlMDvDSVagZLVC25/2F77whfg//+f/2P8vCAKy2Sz+4R/+AVdeeaWfxxagAdQNlPC07MqKqZhBHCUpAoAAqcM1wRc8vn3dSLSpkvDq5VcAAAaGViCf4UqWz3ZBPpPF7OJWvlnwhaNkzfc8FuDYBYlFYJYtCBpPF6QXHy1Bd9sHSNqZD3HhtoePYdexOcS6jWx3Y2Y/QCzafxYd9ec1O8GoNyWLFAq+JwsCjpJVUhMoT7UbfFGHZHEliz+mBRwlyyHOkQsvhLpxA0g+j7kf/KDp89eNRBEySjBYOqSWrK8wLwW0Cr6YYfZNSZAwwEJHnrd1DFFVwrFUAQ8dru0fI4TYn7kI27ixlaz0McDsbMFuspQ/SRZoT85s4w0NSRRw8Xq6ILunjmVwbIB+PoWyTDdpXCRrKiEgos4PyarXlZWeKiA7o0OUBCzfkKz7PG4X7EXwBeBsuJUNFRJMX9MFLYu47II9DL5wpQv2yzwW4CJZJVZ/YhTn3QmyGCCEw7YNsCb8Ij9tz2T1i1WQYz7CL+wi4kDJaom2SdYNN9yAu+++G9u2bUOxWMQ111xjWwU/+clP9uIYA1TBq5JFEwYFpDQmc598FDBYfwKbydo/1TxZkGPQoBcScWAIBiM4kR7ZBctlwBJEbzNZhj7v81hAJSkoFU1HySpyuyBdYA0KGXvmjSOnG/jU7bSs9z3P7TKy3Q13suBClte6u7KyjGTVU7IKzkyWX8mCAFVYBYEAgojctMfyWVvJqkPKOp7JchYugiBg6FoW5/7NW0CsWnWT48XnjOOLrzzL7osLNVGYFzvcSlY9VYpbBYdCQxBZsl9IkfDCs1ln1iO1lsHpXAmFsglBAGJRTrJUWJYMENNRV9sEJ1myIgLTewEQGobSYEPj0k2N57LGk/Q5iqkhpacguZSE6bijZOm9JlmsK8sdfHFsTwoAsGxdoqHCLPXQLgg4c4g6iSGKoq/BF+limYfCIdkLuyCzvhoW/Z0pqgTL546sbiCPjUEIhyFZlGjKRgFidOlu5HQKQRDsDVzDDr9YZX+fz2T1S7Igx3x0ZTnx7Uv33uQX2iZZq1atwh//+Ef8zd/8Dd73vvdh586d+Nd//Vc8/PDDGBsb68UxBqiCnTDYoiuLp5SdlljIxaF76J+hpN2h1Cr0gsNkiWlGjC4cJFn0dWEMAKpr7sCUwnZ5Yz1U2AUXQMkSRAGyK2FQsNMF2e4RW7QPIWNH5HN88bf7cJpFtr/l0gn/DorPYw0vUOgFB5/Jmj3o2Bdj9UiWky7op5IligIirMk3l/E4yxF2KVnVi/2Cd7sgIcQmWW4lCwAGXvYyiPE4SocOIXf33Q1fQ5ZEXDwetkmW1qMFdj+AkyzDMlAwahcFUwUnWdANnjL4010namaeuIq1PBGCxmy9pqTBUlkxe4eWQYOdSpIsVloFG2xo8Lmshw6lkK8KbohE6PVCsTScyJywlSEAmEoAUaVSyeLdUX4jMuDYBTnJta2CdfqxOETbLtgjJYvdu3ghca5kNk2TbAd8HiuuyVDlHlj3+EyW5XSq9ZOSJYgi1LVrIbIYd5mUIUhLtyaiGziFxCn6hQEXyWJKlqj2l5ozHwmDtpI11F//9n5ER1cYWZbxxje+EZ/61KfwhS98AW9729sqkgYD9BYaswuWDh8GKZcbPo4XEh8TmFXr8L30z7pFxM13sizW/VOO0BtvOO5/pLAkiQ5xUSLelCxTn/ciYg4nxt2AaKcLsoViAyXL98h2NxY6WZAjOuokDHL7XbyeXbDYk5ksAIhEWcmq1/sMV7KMol00acNWslrbBUmxaPtdpSoLjhiNIvmqVwJoHeduZbMoy/SaGuqFpalPEJbDkFlPWj3LoJ0sGKokWZdtGsFgRMFUtoR791daPHnoxaqhiE3eTUkF4SSrg/ALYpqwWDm0rErAZOvP2sRwBCuTYZRMCw8crLQ1qmHnfD8+e7Iiwn0qLiGq0d95kQVf9E7Jop8/QzdRKpoV81irGsxjAYDIyoitbNY38uMGt47rVhRRoQjTItCNxupvO+DzWEn+nj76XeDEH315bQCOXdCi/wZZFWEV+odkAYC6bgISi3FX0HgNcaaDz2XV2AUBZybrDLMLEkKQYSQrHihZLdH29tjXvva1pt9/85vf3PHBBPAGeXwcQiQCks+jdOSIbR+sBi8kPmgyO8tpGrRQWUTMlazmJItH9ZZDSWDO/9ALjlBERlY3YchhkMIkSKlU9yLmpAsWIS6AXRAAVE1CgR2LEOfpgjoIIbZdcEjI2JZMwIlsv3i9T5HtbkwvcLIghyAAo1uAw/c4X4vWqtxWoTJd0E9EEyomp0ooljxe4tQoIGmAqVNiqLo+D23YBbniC0mCUGdBNfiGN2Dmq19D7o47UTp0COratfVfJ5N1lKwl3JMlCAISWgIzxRmkS2mMRysVTztZsErJUiQRL96+HLfcdxg/euQ4nrnJsewdnaUbHWuGIpBFV7qgzK4Tc4fbPk5SKsFiaY+yKrk2NGpDL9z/tks2DON7fziKe/ZO4fKznGOUZBFEsCAQEafmpiDFt9jfm4kqCDFy2Gu7oKJK0CIy9LyBXEpHDkAhXYKkiFi2vnEYj72BYFmwcnlIMX/tZnYhMYkhArqgy+kGQkr31wm7iDiiAqceA257O1X/3/Ng168NANAzIESAyVJyFVVCqY+ULIB1ZR1hSpbob3LjUkJtjPtK+3tWn85k9VrJ0vOGPTISzGS1Rtt377/6q7+q+P9yuYx8Pg9VVRGJRAKSNQ8QBAHaunUoPvYY9H37GpMspmQ9WapcoPBkwXSxjKksvYGta6FkGVO0dLrE7D1+h15wqGEZmNVhsF18q1CAVHURM8sWLJMNoS9Q8AXgzBGVdBPiGNvRMU2qZHAlC46S9WAvIts5CFn4+HY3xlwkKzIMyLU3oop0QR/tggDr79hfQsH0eAMUBHqcmeN0Liu5xvleGySLK75SPF7396tOTCD6rGcid8edmL3lW1j2kQ/XfZ1yOguLWSmXetljQqUkK1Oqne9ppGQB1DJ4y32HcftjJ/GxV55jq8KHp+mCdvVgBEqR1UGIGiyRkYYO7IJE12GK9PcgqXLTZEE3Lts0gu/94WjNXJYgCIBiASURk3PTUM5dDogiTiYs6LKCiEJ/Vq+DLwBqGdTzBnJzOlIn6Xs3vn4AchNCI4RCgCwDhgErm+kByXKUrCFZB8pATjcx7EMIXkURMVc1p/fS8nTVBxJUysIgznVHViUU+4xkaRMTkH5Hz2FF9kchXIpo2JUF90xWf5Gs6q4sUfTXccStgqGYQjecAjRF23bB2dnZiv+y2Sz27NmDyy67DN/61rd6cYwB6kC1wy8aJwzyQIXHi1U2J6Zk8cX/WFxDPNT8Jq7v3g0AMAep+tIrJYvfXA2NpVflaoMLyq7OFMlcmOALwGUXLJp00cFgFYvOTJaQwXSuhNlcCf/0EyeyfdsKHyLb3cicoDYVUQaG1vn72p1g1NmZrzePBQAkX3BmsnxWsmJMmS0IUZA6lRN10SjGPc/TBb0rWWKi8e/XjnO/7ba65zcAFFPs64TULYNdSrDDL/Q6dsEGShYAXDAxhPFECJmigd/umbS/zouI1wyHK+yClsiIQAd2QUt3KVmK6NrQaG7NvWQDtSg+djxtzwJxsIR+zGRmIY+OwvzCP+Hjr5cAoiCs0luzM5PVO5LFC4nzKd2TVRBgoQCx3oVf2CSLRDGk0PfAr0LiWXdHlh10Q4CZ1kXhnlDK2fHtAD1f+mkmC2BKFpvJUpf25aUrSK6uLAB1Z7IErb9IVjSp9bQrKxt0ZLUFX6Y+N23ahH/913+tUbkC9A72XFaThEGuZO0vD4HAtZvBZrIOMBtbKxXLyuftkA0jRhc7vSNZLA0sMmD/7Grw0AuRGBCJtXBKlsa7sgwIigKw/hM3yRoQ8pBg4oZf7MGjR32ObHeD76wPTgBSH8zwuElWnXksgL5Pltgbu2B8GV2461rS+yLQjnGvShjsUMlqhOhll0FZuwZWJoO5H/+47mOKc9TyJgsGBJ93IvsNvJC43kwWj3CvR7JEUcBLdtBrmbuYmAdfrB6MQNHoZ9KUNFgCmxue60DJKukOyUKR2kolDUjWt3tyjMY1bBmn/7579lWqWTI7thTrmtK3TuDUoABYMsKKBEKIXUbcSyWLz2VlUzqOPdm8hNgNO/yiBzHutl3QimFQoWTArxh3PpM1GFGdUBvAuYZ2C91RsiRZhCAKfZUuCFCSFdJTAICI5m8H2VKCNJgE4FKyYsvoRiacmSyxz5QsURR62pXlxLcH81he4Fu0jizLOH68Nk43QG/AlaxmXVkRld6sdagwY07YhR3f7jFZsPjEHsCyII2OQDfpzS8c681Nn+9gmuHGJIsrWTKLoJUGkj05llZQQ650QUGAGHLFuIeTACO2SWTxjd/TORBfI9vd6CerIOBJyXLPZPmuZA3TjYOSNgAzXb+DqQb1lCxDB8pMVWpjJktMNCZZgihi6JprAACz3/xm3eAAPUNvZKq09OclmhUS20pWHbsgALzsadT6/Kvdp5DTDZRNCyfm6MJi9VDEJu+mpIKw3iLMHa1NkGwBojskSzIZqRjZBIitz1uuZt1dZRnUmHsgzRL6dFYOS4iMsCqjXDRhsazxUI/SBQGHZB1+bAZ6zoCsSRhd27o3iYd1WD0oJOZpijqJYUCi13m/YtztmayoUrmhwq+h3aKUdXVksY03rmRF+4NkSQMDWJd9ENt3fQnrEnW6AQMAqGMXFCUgTq85hNBzVFD6i2QB7hh3/0lWhhURxwMlyxPavnL/6Ec/qvh/QghOnDiBG2+8EZdeeqlvBxagOZyurP00aKHBfM9wTMXR2QIKsVWIZxkJriJZG1qEXhQfewwAEN52NgoZeoPqmZLFrFFGiNkFm5AsyaSLkgWfyWIhHEIoBOTzsApFejEOJ4HCLAaFDKbJANYM+RzZ7oZH+9K8ITZGSUlhlv69DkihADPhf4Q74PT/6OoAjNQc1DUtngDUJ1lcxRJEQGttSzVtJau5HXTgVa/C6X//LPSn9iJ/3/2IXnRhxfeLbCGoSkt/XoIXEtebyWoU4c6xfeUA1g5HcGg6j188fgpPXzMI0yLQZBGjMQ1Zm2RpsEyJ3vFKWfp79VguDdBAG5tkGSn6RY+ftcs2DePmuw/g7r2Vi9lwREMWeeTzBVjEgs6uZyAKwopkWwUlRezp7AMvJD7+VAoAsGJjEpLUev9VinElqwcky5UumJS4kuXPhkPFTNZkL5SsTEURMYC+swsCQGTNCow+9BDU+M6FPpS+RQ3JAqhlcO4wLNB7jKD1H9lIDIdwDL3pyrLtgkOBkuUFbZOsV7ziFRX/LwgCRkdH8dznPhc33HCDX8cVoAXUNWsASYKVy8E4dQrKeH21YDhKSVY6tApx3E+/mOBFxJRktbILFh+ns0Shs89G3iZZPQq+4DNZLN2tmV1QKrPG+oWOcGckSwyFYAIguqsrqzCLIdBFiO+R7W64i4j7AXbC4L11i4gBpmQN+l9GDDgLR0tSUZyeg6elTTOSFUradtBmsDwoWQC1Ew68/GVIfevbmP3mN2pIll6g53ifOVF6gkZKVtkqI8UsTY2ULEEQ8LJzV+Bzv96LH/3xOEbj9Pe+ajAMURScmSxRhaWXgYFRIDdJ1aw2SBZxz2SV2DnRJFnQjQvWDUMWBRyeyePwdB5rhunZGI2EMYk8REPBTHEGusWULEtGRJXmJfQCcDYkOFZuTnp6HrcLWj22C46K9Hrq10xWKl9vJgs+Klk5lDnJUqqUrD4iWdqG9Sg89JAdUx6gFnJdkkUTBonASFYfXqTjPUwYzM5wu2D/kct+RNt2QcuyKv4zTRMnT57ELbfcguXLl7d+gQC+QFBVSrRA1axGGGbWtBmF/24EIDoGyyL2TFZLuyBTskJnb0MxS2/8kUSvItzpzZXHV1t1Cont+HaDk6xkT46lFdQQn8liSlaYJyJWFRKLGTx78yhedLbPke1u9JtdEAAu/HNg9UXA5ivrftsqFl1lxP6WgsqqBIXQm0H2tMdFoD2TVYdkebAKAt6VLAAYuvZaAEDmV79G+dixiu+VCvScUrWlPY8FuGayqoIvZov0vRcFEUkt2fD5vJj4jicn8ejROQA0vh2Ayy6o0a4iPrje5lyWeyZLKjHbn0clK6bJ2LmGHv/drrmsELMLKqaGU/lTKLEgAhAFIUVyzWP1NpmAb0hwtAq94LCDL3phF+SbbdAQZT1Ofs1kzbiDL9wzWdN7AcsH5biUhclmsqqVrHq1DguF4be/HcNvux4DrLsvQC1qgi8A+xpCQD+//UiyEj3synKCLwIlywt6UHceYL5gz2Xta0KyovQCcFJiakJsDJBknEgXUSxbUCQBqwcbF0lbxSL0fTRcQ9u2zaVk9ebCwuOqDYkRllZ2QVmGGPU3PtgrHCWLBXEw20CFkgXgX69YiS+/6Xzfy5tt6FkgzRLThjf25md0grNfAVz/P8BgbTgAsSxqF7RnsvxfSIYE+nvITjcuta5APSWL73R7VD24kiW1ULIAQNu4EZGLLgIsC7Pf/k7F90o6XexpPit8/YhGShaPbx8KDUFqMvu0aVkcW8bjMCyC/3sPnVFdzUhWRRlxvuBEMLcZ405nsli5bOEU/WKL+HY3+FyWO8pdYZs0qhnCydxJFA16vhIy30qWQ7K0iIyR1a3PXaDHwRdhGQCdRwuz+Tm/gy+GolVKVjkPpI81eFYb0LOOklU9k9VHJEtdswZjH/wglLH6du4AThmxlc+DlNgmSIIpWYSRrD5LFwScmSy/lSxiEWRTgZLVDjytbN7//vd7fsFPf/rTHR9MgPagrV+P7K9+Bb1pwiD9IOyWN+MFogysPB8AsH+S3hjXDEUgN/Hf6088AZgmpOFhWAMjsAx24+tx8EVZpLsk9e2CXMkqQhoY6B15aQGbZDVUsujCPEnSgNzD/YzpveznjbRlgVpIEJ1eqJ0yYv/fn7BsIGMAublS6wcDzntXcO1atq1kMbugByULAIbeeC3yv/89Ut/7Hkbe9Rd2eEqpLABSb6O7+wWNZrJahV648bKnrcATt+/BqTQ9r7iSpbiVrFwBGJigT2hTybJ0HaYdfJEBILS1oXHZphH8+6+ewr37pu3uGm6RVUwNJ3MnnQAUS0HYRbJ6fQ5EBpxF4opNSc+9OnbwRQ9msgRRgKZa0EsSFDaKlfVhJsuyiMsu6Aq+EESAWNR2nVzd5BVagJCKnqx+nskK0BpiPE5t4pYFI5WihHTZ2QAAIsUAFPouXRBw7IJ+d2UVsmW6BhSAaECyPMETyXr44Ycr/v+hhx6CYRjYvJnu5D355JOQJAnnnXee/0cYoCG8dWXRC8De8hjw/t32YvGAPY/V3CpYsOextqGYoTd9RZN6Nohtkyzmd7by9Xqy6I6mvIAdWUBlGTHgUrKKbNjUVkZmap7rK/rRKtgCVoG+R70qIwaAsGYBBpBn521LNJvJ8kiyLJZk6EXJAoDYc54DZcUKlI8fR/qnP0Py1a8CAJQMSjq1aP/dwP1GKyWrUeiFGy/dsQKfun2P/f+rBitJliWpMAsFZwHdrl1QL8Fi1QiyUKJl1UpjB0A1nrY6iagqYSZXwu6TaZy9YsBOJ1XMEE7lT2FAZdcyQlNh0/n5UbIkSUQ4rqCQKWOlR6sg4Aq+6IFdEAA0jZIsmXGrvA8zWeliGSywEUm3XXDZ2cDJXfRauvF5nf+AUg4AqZMuSO9jYmRhXBcBOoMgipAGBmDOzsLkJGvNxcAbbwW55Q7gnu/1pV2wuivLL2sftwpGE6qncJwAHu2Cv/nNb+z/XvrSl+Lyyy/H0aNH8dBDD+Ghhx7CkSNH8JznPAdXXXVVr483gAu8K6u5kkUvANM5nVkF6Q273WTB0LZtrmTB3t30+cBzmUnxde2CRccuuJAkS+U9WcUqJavIUsIaldv6jek+Sxb0AFJNsnpgi4tE6O5dnVOowRNcvy+uKvBFWNtKljeSJUgSBq95AwBg5pvfsNWMkkXfDy2+9H3vjWay7GRBD0rW6qEIns7mnoDamSwiSDCKumMXbLOQuGImSyi1ZRUEAEUSceF6+u/gUe58ppMrWW67YFiVUMzOz0wWAKzeOgQtImP900Y9P8dRsvy3CwLOPKLI+oj8iHDn81hxTYZqFQH2nmP1RfTPbhMGS/S+apMsJVCyFjucuawU/YIgABufD4vQ362g9p+i06uuLDv0IkgW9Iy2qegNN9yAT3ziExh0JdIMDg7iYx/7WJAuOM/gSpY5OdWwC2g4Sj9o09lKy9S+SR560YpkOcmCBRZ60at5LMClZBEJBICVq1WySvZMVnHBQi8At12QzWTZPVnVSlaPSVa/JQt6QLWS1QtlNBKn51Kh5PEyF2Z2QbNEY74Bl5LldSaLK1ne7IIAMPDqV0PQNOiP70bh4UcAAGU2VB0eWPo3s4ZKVtG7kgU4ARgAsHqIbni4A1WMoukEX7Q5k2W5ZrIklDv6rF2ygf477mJR7nxjQTU1nMqdQr7MFkMWi3DPz49dEACe/9ZteOsnL0O8jcWTZKcL9kjJClNyRZiq68dM1iyzCiajirOBIsrAyqfTv3dNsuh1w5Doe8PPP8LLiPukJyuAd/C5rIqEQcCe0epHJQtwdWVN+RfjnrFDL/qPWPYr2iZZ6XQak5OTNV+fnJxEpkcX2wD1IcVikNnQaqOEQa5kTVWRLG4XbJYsaOk69L103id8du87sgCnH8UiIixRaaBksQh3s9gfdkG7J4vFhlelC/aeZC1Gu2ARBDRaG/C/jBgAYmygv2B4XKSqEUBhiyD+O+t4JsubkgUA8uAgEi+hLoDZb3wDxDRhCPTYQ4PN7bxLAXwmq2gWnYQ9uOyCHpQsAHjJuSswFFVx9ooE4iy5T5RESBJdrBsli9r8ACB3Gih73+GlEe5szkbQO/qsXbaJhl88cGAGumHaSji3C+bKrjJiZf6CLwAahS8p7S0HRNsu2J2SVT51Gqc++SmUjx+v+HoozFQgg/7pR0/WLHtPh9zx7ZFhJ46fz7d2Cp1+/g2RvjfBTNbiR92uLACkRM+lfiVZiR7EuGdneejF0t/88wttk6xXvvKVeOtb34rbbrsNR48exdGjR3Hrrbfi+uuvx6te9apeHGOAJlC5ZbBBwuAIj3DP6bCYGb1YNnEsRXc3mnVk6Xv2AIYBaXAQ8vLl82IXVEISeI6FIUeapgvKhr6wSlaoMvhCDDG7IE8X5OpHoYczWZbpLAxG+ihZsAWsQp7ar9gvuxckK8r6iIqkjV23amLcBskihNgkqx0lCwCG3vhGAED65z9H6eBBlFmFQWho6ZOsmBKDAHoeuNWsdpWskZiGX3/gcnzvzy+u+DqfiymXLJBQ0iHSbSTJVaQLCuW27YIAsHlZHCMxFYWyiYcPpyqCLyjJotc6SVAgigL0eSRZnUDyKfji1Mf+GTNf+QpmvvHNiq9z67hh0Pfdj56siiJi2wo85Fw7MyeAYn1XiCdwJUug91VJFUFKJZAy/V0GJGvxoSHJYuFN/ZguCDjhF37GuKdO0WtUoGR5R9sk66abbsKLX/xiXHPNNVi7di3Wrl2La665BldccQW+8IUv9OIYAzSBtn4DAKB0oD7JGoywAAkCpAr0Qn9wOgdCgERItiPe68EuId62DYIg2AECvVSyBEGwC4nLcgSk1UzWAhURA3XKiMPMLlijZPWQZM0doXMFkgoka6PS+xWkWLStgkBv7IKxUUp0dDEKwqfdW4GTKf47yzOSFfFAsopFgC2mpDaULAAIbd2K8HnnAYaB6ZtvhiFTwq4lvIcrLFaIgoiYShfsFSSrjeALjmRERUStnGGyEwYFGcQwXDHuhz2/LimVXDNZndkFBUHApRupmnX33inHLmiFYFgGTmZP0P9nillxnnqyOoUd4d6FklU6eBCZX/4KAGBUOWR46Ith0D99sQu6O7Lc9QyhASDGegz5jGsn4DNZolMhwK3RACCGl/7neamhblcWHLtgP6YLAv4rWcVcGUcep5+ZlWcFBdZe0TbJikQi+MIXvoDp6Wk8/PDDePjhhzEzM4MvfOELiC5QX9GZDHX9OgCNlSxVFjEQpouD6SzdeeGhF+tHY03jz50SYhpZypWsSA9JFuDawZTDdcuI7Qj3BZ7J4oPrpmHBNC0IGoudt2eymJKlpwHDY4x4u5hiKtbwRqBJl1C/wcoX7CJiWRF9i5h1I7Z8ACAWiCDa/W4t0YWSZbKOLEhSR6WjQ9deAwBI/fePbZLVryqG37DnslzhFzNFekP3ahdsBE5mTEmjmzbJ9sMvSMkV4R4Kd1yVcKmrL4vbBVWTXjeO5eicmCLSzYf5inDvFNwuaGUyTvx8m5j+6lftkJnqRawWo+9L2eQkywe7IJtzqygi5p9tTpynuiBZ3C4IFryiik4RsapCUPrzdxmgMaTBJIBFPJM17c9M1pP3n4JpWBhZHcPomvY2Ec9kdJzBGI1GsWPHDuzYsSMgVwsIbQNVsrwkDPK5LHseq4lVEAAKNSSLK1m9vVHwuSxDDje3Cy50hLvL4lYumo6SxdMFQ0navwL0zjJoh14snmRBgBLRXiYLAoCSHIDKupdysx5386rVxzZIlpVhoRfxeEfdbfEXvADy2BgMyPZ5w4Ngljqqwy8My8Bskb737ShZ9cCLrk1RpaoCD79oI8bd0h0lSx5c3vGxXMrmsh49OgddoORCMennYKpIS44VUQWxyKKxC8Ky6m6GtYIxO4u5235g/38NyYrTRaJuhiHD8MUuyJWsoahSWzTOr6HdhF9wuyDovUBWpGAea5GjkV3QKjG7YN+SLN6V5YyKdIPd99CZya2XdH79OxMRBN0vcvCEwfKRo7BK9XfrR3jCYI5eFLwkC1qlEvSnqEpSrWT10i4IOAtLQ2k0k8WDLxZ2JkuSRYiywI7JhMBnsopsQS+KzlxWr8IvFmGyIEAj3E2xd8mCACAODEArzQEAsidT3p7kVrIMHSizdEsP6YJcyRLbnMfiEBQFyde/zlaxRGLYEdBLHdWFxLPFWRAQiIKIQa07awo/v0xJYySL2wW9kyz3TJY0tLLjY1mZDGPdSBSmRfDHk5RQikSCaEkgsAAAmqyhVDTsFoFQpD9JlhAOAxILduigK2v2W98C0XWIMUrWqhexWozen3Qrhgh0X+yCFTNZeddMFuBSsrogWTq9t5Y5yXIpWQHJWpxoHXzRn/NJdleWRZBL6V291uThDKaOZCHKAs56xrhPR3hmICBZixzy6Ci9SVkWSgcP1n2M3ZXFlCy3XbAR9CefAspliAMDUFbSaOT5CL4AXCSrQfBFhV1wAZUsoHIuS2TpgsTlwe95wuAiTBYEaLqgrWT1IPQCoF55rUwXf5lTHheB7t8XV7EEEdBaEye3ktUpBq++GkaI/iyF9Mhi2oeoVrJ46EVSS0Lq0gZrz2RJGqy8i2S1oWRRksWUrJE1XR3PpRvpOfb7Q466zS2DAKCJmm0VlDWp7dS/+YIgCJBinYVfWLqOWRZ0Mfy26wHUU7Loe6KTKCIoomwS6EZ3lsFU3jWTVWikZHWRMMhmskzCrNCqZKt8QXz74oTckGT1t13Q3ZXVbfjF7nvpvOj6c0cRivXnpk+/oj+v3gE8QxAEO2GwtP9A3cc4JEsHIQT7PShZfB4rfDYNvbAsguI89GQBjl2w3MIuKC1wuiDgKiR2K1m6a9eo5ySL7boOL55kQYCmC/KZrF6RLAAIgRLe7FRt31pdRFzKIydZoSRVJVuAd9WJic5JljwyAvXiywEAitj9zv1iQfVMFg+9GAmPdP3aDslSQQrumaw27ILuMuLRia6Ox57L2j8NmREoxUWyQnLICb3oc7uoHX7RZiHx3H//N8yZGcgrliP5utcBoDHnbjcGn83VrSiiAl0kdjuXNVMv+KJayZrZB5gdfvaYEmtYnGS5ZrICJWtRolXwhaD2L+nwYy7LKJt48r6TAAKrYCcISNYSgLaOxbi75rIs00JuTsfk4QxG0hbO0SUUd6Xwx9+fQL5gQBCAieHWJItbBfVc2bGv9Hgnwwm+iIDoOk0EY7BMC2aZ2moWeiYLcHVl6YYrXdCtZPXQLlhI0b4fYNHNZLnTBXtlFwSAkExvhB3NZFXPbLQAJ1lSvDO7IEf4xS+jfw539zqLCY2UrG5DLwCqBgGUZFXYBeeOAZbl6TWsQhEWD2oZW9/V8Vy8YRiCAOw9nYWkOYXEHCFZdTqy+nzXmJOsduyCxLIw85X/CwAYevOb6SKW2Q7N2ZT9OO5o0EkMgxL7HHdpGeTBF0PROkpWYhUgh2kZeepQZz+A2wUJUz3VYCZrscMuI06nQUyH5PMId1HrT7sg4E/C4IE/TkHPG4gNali1tbPAnzMZbW+TffWrX8XIyAiuuoqWZ37oQx/Cl7/8ZWzbtg3f+ta3sHbt4omRXmwghKBcNJFPl5Cb05FPl5CfK2FKOx+pLXFYjw3D/Nj9yM/pKGTLACNFCoAXQwWeyuHup57AuxDCiYiAI3+cwtpzhu2UPDdqkwV50pUMSeotN1dddkGA7nDy3iFuFQQASTQXfHfQbRd00gVdF7Rexrjzfqz4CkBbXGk/1C7YeyUrrNJFNK8faIl6dkGPRcTcMtWNkgUAZS0B4CQiy7snGIsF1TNZncS3N4KiVtkF48sBQQKsMpA9BSRa786a+QxYYBykoVVdHU8yomL7ygE8enQOBruUupWsiBKyQy+0Pp3H4uB2QbMNu2D2d79D6cABiPE4kq95LbUdDg7CnJqCmZqFsmwMAL3XAECZRDCslAGju64syyIuu6BSWUYMULV6eCNwahe1YQ9vaP+H8OALk3WqKSKsPFXRxUgQELYYYW/kEgIznYbMSFe/2wUBf7qydt9DrYJbLl7ekxTgpY62Sda//Mu/4Itf/CIA4N5778XnP/95fOYzn8FPfvITvO9978Ntt93m+0EGoATrvz54J/RcvZvMIDB+EWACOOrYNgSBWvsMVcATqTyicQXLyyLUrIG1eeDn//kYJEXE2rOHsX7nKCZ2jEALyyClEvQnqQ0ttG0bgPmLbwcci4yh1JIsbhUUrDKUgeYR9PMB1VVI7KQL1iNZPVCyFmmyIMDtgr2dyQKACFu75nLeFIu6dkGPJIsHX3SjZBGL4E930hSnsYkzWMkq+KdkKRplMpbIgi8kGUisoHbBuSMeSVbeJlmy1r2F79KNI3j06BzylgUNTsIgUGUX7NNkQQ5byWrDLjhz81cAAIOvuxoSC7eQB5OUZLksWdw2DgDDIv38dqNkpYtl8JC1ZEWEu2t3fmQTI1lPApuvaP+H8J4si17TAiVr8UNQFIixGKxsFmYqtahIVrdKVmamiCO76edky8WBVbATtH23OHLkCDZupPMfP/zhD/HqV78a73jHO3DppZfi2c9+tt/HF4BBEASomgw9Z0AJSYgOaIgkVEQSKjQUUfje16CRIjZ8+uOIDoYQSWgIxRSIooD79k/j41/+PdYPK3jBthH88NcH8ZqxIYxnCNKTBex/ZBL7H5mEKAtYs3UIa8YNECJDS4ShrKbWGt4zNB/2FVvJ0thQtWsuq6KIeIGtgoATD10uGhBG6ilZfNHeAyVrkSYLArSweT5IVjQmAlmgUPRIxjkpLsw4xNizksXsgl0oWQcencL00SwUTcKO53SnmCwmxFX6nnGSNVWcAuCTklVhF2TXkoFVDslafUHL1zB4wTgIRKn7jZ1LN4zgi7/dh9mygXEICFnOAjwihxy7YJ8WEXNIbdoFC7t2If/AA4AsY/BNb3JeZyAJoHLuRZREKGIJZUvFgEjZUbaLmSw+jxXXZKiCBRRp8miFHbjbhEHek8UkyiBdcGlASiYpyZpNAbSa1J4fFPrYLtjtTNYT954ACLBycxIDo0GRdido+woei8UwPT2NNWvW4Oc//zne//73AwBCoRAKhc6H6wK0xqv++jxoEblmUUoMA3s+ex1IuYzlgyWoq0Yrvj8cYz0sWR37p/I4JROMXTaON168FtPHstj30CT2/uE0UqfyOLhrGgd3AcIln8QIOQnznhNYd+6IbRecDyXLnslS6C6nu4OlxHYy5QWOb+dwZrJMiKFmdsEp/3+4nSy4GJWsAiyRLtCUHs5kRQZUIAvohgTTsCDJLayufFfbMoDU4cqvtYAd4d6hkkUIwQM/peE125+zqu9VDD/RKPjCD5LljnC35yUHVgO413OMu8HimiXB9EU9P39iEKosImdaACQMSU7AR1QNQc/2d0cWR7vBFzNfoSrWwFVXQlm2zP66PfdSHeOulFDWVSRAyVW+CyVrllkFk1EFKLp+Tijp/J1fS6c7TBjkdkGDniOKKqEYkKxFD2lwEOWjRyvOT1vJUvpXyaruymrH7kcsYlsFt16yoifHdyagbZL1ghe8AG9729uwc+dOPPnkk7jyyisBAI899hgmJib8Pr4ALsQG6++YCLIMdWIt9Kf2onRgP9RVlT0uIyxdMF00sOckXQiuH41CEASMrIpjZFUcF7x0HWZO5LDvoUnsuf1PSBtRTGIlfvP1J/DbbwoIMwWr18mCQGUZMVClZNnJgkV793MhURnhXscuOMi2vY79gfYuyT7uei1mu2CxAJMtLHtVRgwA4WQUwhEDRJSRm9ORGG6xG6eEADVGF0t8oTVPStahXdOYOpKFrEl42vNXd/QaixWcZNkzWT4GX9REuAOuhMGjnl6Dh+1IPp2qIUXCMyYGUfojPWcGReffGVPDtpKl9T3J8h7hXjp6DOnb/wcAMPTWt1Z8j5MsozrGXSkjq9tOTWS7IVnsPR2KqI5KHRqg9lGOrpWsLAhxSJakBErWUkB1VxYxDICFYPRzumA0qUGUBFgm7cqKD4VaP4nh2JOzyEwXoYZlbNg52voJAeqi7QSDz3/+87j44osxOTmJW2+9FcPD9Obwhz/8AW94wxt8P8AA3qDyhMF9+2q+lwgpkNkOxuEZesGv7sgSBAHDK2K44CXrcNnpb+DC+z6Kp20pY2R1DMQiyKfZTNbAfChZzIInMmUo78RvV9gFkwtvF3TPZAlhuoAnug7CU8tWX0CDKYpzwFO/8O8Hm2VghkX2L0a7YL7gShfsXZCKPJCwC4nzcx57p7h9aJp9ltqcyRI76MmqULEuX4lwrH93R3sBHnxRPZPld4S7ZStZzIrpJcadEPB6JtnHzqpLNoygxDaWB0TnHIupi2cmS4oxJcuDXXD2618DLAvRSy5BaMuWytexY7JTFV/XVPrGh9jltJuZrKZFxBw87CI/DeQ6mKMt5WDC+Z0p7p6sgGQtWtSQLFfVQD+nC9KurM7CL7iKtekZy3qaALzU0baSlUwmceONN9Z8/aMf/agvBxSgMzTryhJFAUNRFaczNHI0pIhYnqi/o0HKZehPPIFoqYQdr9iMSycmMDeZx76HJpE6nce2y3ovG9t2QUEFgVA1k0VvsnQmK9nzY2kFR8kyKi62RNcp6RIl4JxXAffeCOz6LrD1Jf784NlDNB1NiVISt8hgFd0zWb2bO5EGElD1SRRDw95b7yPD1CqYZiqH1wh3W8lq3y54+LEZnD6UgayKeNrzuyu7XYzgM1nZchZls4yUngLgs11QVGEVJukXB9h77EXJypyEadFzVPJx1/qyjSN4QKBEPgZnwyimhVDM0XOp32eyHCWruV3QnJvD7Pe+DwAYuu66mu83tAtqlF0phJLbXKnzmaxZd0dW4Rj9YvVnW41SK+ncEWD6KSDa5vlXysIgzn1Acs9kBWXEixbVXVluktXPwRcADb9ITxboXNampKfn6Pky9j1Mr5VBN1Z36Ghb7s4778Qb3/hGXHLJJTh2jF6svv71r+Ouu+7y9eACeIe2vrYryw0+lwXQfqxG3lx93z6QUgliLAZlDV2IDIxG8PQXrcVz37QV0YHe79rYqVKCAEMO1bULymaxP2ayKsqIHeJaMZe142r6557bgWLanx9sWwU3eirK7TdYhYIrwr13xy8mEtDYgj3bDslyI5z09DSrQyXLrWKd86yViCT6+6bdC3CSBQCHM4dhEQsCBCS1ZNev7bYLknyVkuVlJmtqD0yB/k4kH5Wsc1YOQGAzgkR3rh1xLWxHuPe9kmWnCzZXsma/+12QfB7aWWcheuklta8zmARQW/jKWjEgmfR+1Y2SxTuy6hYRu8Ht1+1aBgmpIFmiJECSArvgUoB9frJNALs0WxQhyP29ERLvIGHwqQdPwyxbGFoRxdjaxVUP029o+45x66234kUvehHC4TAeeugh6KyQbW5uDv/yL//i+wEG8AaVkazSvv11vz/ish9tqLIKumH3Y23bBmGBFu+SItq2HEOOgLhIVqnf0gVdwReCJEFQ6KKoopB4fAe19Jk6sPvH/vzgeUgWNGZmcOTP/xfSP/+5769NCoV5UrIGXHbBTklWa7sgIcTuCmpXyTqyewanDqQhKSKe9oIzT8UCAEVUEGG9eAfmKOEcDA1CFrs/NypmsqrtgvqckzLXCJNPwiSsiFjxzzYjiQJWjtJwHz3LrhuWhIiqLJ6ZLNsu2FjJIqUSZr/+DQB0FqtecEi1UsChheh9QDDp+94VyWJK1lBUqS0idqPTuaxyHiCWTbL4PSwgWYsfjeyC/ZwsyJHooCtr9920RmTrJcsXvCZnsaPtVfTHPvYx3HTTTfiP//gPKIpzA7j00kvx0EMP+XpwAbxDW0cDFszZ2ZrhYQAYjjoka/1o41LE4mOPA3BKiBcKTiFxuH7wRb+QLFfwBQB7Lssquhb0ggBsZ2rWru/584N5suBw70IvUt/5DrK//S1mvvJ/fX9tt5LVy5ksKZGAptNFdC7lcSarenfbQ7ogKRQAg1lZ21CyCCF44CcHAQDnPHPlvCjF/Qo+l3UwfRAAMBTyZtNshbozWVrMIc8tLIPk9B6YAr3X+T2bsG453fAq5NjrEhkhSYReWCQzWR6CL+Z+9jMYp09DHhvDwFVX1n0M7x6qIVkR+r4QRrK6inCvN5NVvaECuJSsNhMGeUcWJ1nsXOH3L35vCLD4IDciWX1uFQScGHevStbU0SxOH8pAlARsvnC8l4d2RqDt1c2ePXvwrGc9q+brAwMDSFX5qQPMH8RIBPIK6p0t7a9Vs9x2wXUjzUiWo2QtJPhcVlmOwMrVBl/IRn/YBdWQYxcE4EoYrKoz2P5q+ueB3wGZU93/4HlIFsz+9ncAAGNy0vfXrpzJ6t1QrZhIQCulAADZlMedvA6ULK5iQZIgtLFjfWzPLE7un4Mki9j5wjNTxeLglkGuZPkxjwW4FruS5vRkASzGHS0tg+TUE7BEej2SfCZZm1fRjSI9J0MsbkI59QyoBAArzdX6fiaruZJFCHHKh9/0xoaL0oYzWew+YJn0fehGyUrl3TNZzeyCHSpZvCNLTgJwNo8CJWvxo6GS1cfJghxxW8nyVrH0BAu8WLdjZF7SpJc62iZZ4+Pj2Lu3dofnrrvuwnpmWQuwMNDW02SkegmDwzG3klXfLkgMA8U9ewAsvJLljnF3K1m8J6tf0gU5QSixQA6hXlcWAAytB1Y9AyAW8Nht3f1QQnpuFzRmZlB49FH696kpEEJ8e21SKgGGAVPsPcmSBgagciVr1ivJci28BBHQWtv/rDQLvYjH27JXPPDTgwCAbZetQDR55qpYgBPjzkmWH8mCQIMIdwBI8vCLViRrr02yZJ+trStH6cJbIQLmDlwP/fRLIJXpZ00NSZCk/p635HZBK5ute43I3X0P9CefhBCJYPDqqxu+DidZVj4PS3dcABpzYJgG/TNX6iJd0B18YStZdTZQuDtg9iCt3fAK1pFVluh5XK1kiZHGm5sB+hucZBkpFnzBzlFR7f9rdqKqK6sZTMPCnvtOAgC2BIEXvqDtK/jb3/52/NVf/RXuu+8+CIKA48eP45vf/CY++MEP4n/9r//Vi2MM4BFak4TBkahzMWhkF9T37QcpFiFGo1An1vbmID2C7+AacqSyjLgiwj25EIdWAcUV4Q6gflcWx/bX0j+7tQzmp1mZpuBEDvuM7B13UDIH+m9xq4ndghPQeVGyNA0hQhfWOc8R7i4FJTzoKViEK1liG/NYx56cxfGnUhBlAU9/0ZmtYgG1JMuPjiyg0o7K00kBeItxL87BSp92SJbPShbfTFJdax/JoP/T7/NYgGMXhGlWzM5yzNx8MwAg+ZpXN7V3i7EYwAIE3GqWxu5bZZORLB+CL4aiKlBgtsR6SlZ8HFDjADGdmgwv0FkRscxIVvVMVpAuuGjhKK1zIIQsKrtgZIB1ZVmkZcLuwUenUMyVER1QsWabP3btMx1tk6wPf/jDuOaaa/C85z0P2WwWz3rWs/C2t70N73znO/Ge97ynF8cYwCPsrqw6CYNcyRqJaUiE6t+8bavg1q0LFnrB4ShZkcqZrBy9SEhmsU9nshooWQBw9isBQaLFxNP1UyA9gatYyTWA0hufP7cKcvhpGeRzMU66YG87OCKsZKesW7bi2PwJVSTLA0yXkuUVPFFw2yUrEBv0XhK5VMFJVrZMF6t+2QUVFzEquxfpXuyCU0+BmIJjF/QxXRBwQl9U4qifIis+7vd5LIDNGbGG5mrLYHHPHuTuuQcQRQy9+c+av44g1FiyACAUp8SkbNLPR67DmSzLIi67oOKUEdcLvhCEzhIGmZJliPQaIKsSiGnaIUiBXXDxwt7QLZdh5fJ2uuBiIFntdGU9fje1Cm6+eDnEPlfRFwvafhcFQcDf/u3fYmZmBn/605/w+9//HpOTk/jnf/7nXhxfgDbQTMnauWYQa4cjePV5Kxs+v/g4D71Y2HkswCFZZaXKLsgsH7JgQeyDQWJ7JqtkglgEIssctgp1/M+xMWD9s+nfd32/8x/a43ksUi4jx+sY2O6ynySLFAqwBAmEJcf1uuhQjYcgGfTm4qmQuAOSZdlKljeSdfypFI7tSUGUBDz9ioVVjfsF7hh3wD8lSxAFyAolMUbJcr5hK1lNgi8m94CYAkyJKVmyzySLKeFuJQs6J1n9PY8FMHIUqx9+wWexEle8COqqxvcdDrlOjLvKSJZu0Wt9p3bBdLEM7pRKtopwBzqby6pDsqyCs6gNSNbihRgO20mCZioFoi8ekgU4lsF0k7ms7GwRRx6nmw9bLw6sgn6h4zuGqqrYtm0btmzZgl/+8pfYvXu3n8cVoAOoG6h1rHzsWI2SMhRV8bu/fg4+8uKtDZ9vK1kLPI8FOFaZaiWrVKCWDzXUHw3ktgpDKNHiShYpNpDlbcvgd207XtvgyYI9msfK/+EhWNkspKEhhHfsAACYU1O+vb47WRDovZIlJZwYd0+FxF0pWd7sgg/+jG6EbLlkOeJDgYoFOOmCHH4pWYBj3aogWUmmZDWzC049CWIBlsjLiP09V/kmjQrBDruwmFqzGOyCgCv8wkWyyidPYu6nPwVAY9u9gJfLu0mWlqAErmSFAdK5XZDPY8U1GaokNI9wB1xK1lPefwi3C4rUjq+oIqw8s1mL4qKI+w7QGO6aASfCfXGQrLiHGPcnfn8ShAArNiWRXBZsCPiFtknW1VdfjRtvvBEAUCgU8IxnPANXX301duzYgVtvvdX3AwzgHdLgILXQEYLSgTa85ACIaaL4xBMA+oNkqQ2CL/jskxrtj4ubrIrgOQdl3YQY4hHuDXaMtr4EkEPA9F7gxCOd/VCbZPVGycr+jloFY898JuRlYwBo+IVfsApOsqAoCZB8VgeqISUSUFkhcc5LV5Z74eUhvh1oT8k6uX8OR3bPQhQFnPeiQMXi4HZBDr+ULMAh8gYRQVjUPgbYHFzmJGA0UDinnoTlsgv2SskCAAWAKABGgV7jFoNdEHBIluWyC85+4xuAYSBy/vkIb9/u6XX43Iu7giQ0wD9PIqLE6NguOMusgsmoQlMALXYOtFKyptsgWVzJEijJklTRnlMTI5Ggb2iRw52AScr0fBIXnZJVn2QRQrCbpQpuDQIvfEXbd4w77rgDz3zmMwEAP/jBD2BZFlKpFD772c/iYx/7mO8HGMA7BEGw1Sy9Tox7M5T27wcpFCBEIlAnJnpwdO1BizSYyWI70Wq0P3YFBUGomMsSQ/S46gZfAIAWBza/mP790Q4DMHqcLJj97W8BALHnPBvyyCgAwJj0k2Tl5yX0gkMaSNhKVtaLkiUpgMbm/TwrWayI2IOSxWexNl88jsTIwlte+wXVJMuvdEEAUJhiZIquQuLoCN3wAAHSx+o/kdkFezWTJSvOJo1KgIgqQ2dFxIuFZFXbBc1sDrPf+S4AYOi667y/Tp0YdymSgAz6mU2SEkqmhZJh1Xt6U8yy93TIHd8uhwC1wY69W8ny6jjgSpZAP9OyKgXx7UsI7plBW8lSFgfJ4l1ZjWLcT+xNIT1ZgKJJ2PD0sfk8tCWPtu8Yc3NzGBqiuz+33347Xv3qVyMSieCqq67CU0+1sesToCdQ19NS4tK+9kiWPY+1ZQsEaeGteFqjMmIebxzvn8WpTbJ0E4KtZDUZMOXFxH+6FbDa3JktF4HUIfr3HpCs0qFDVAWVZUQvvRTyCF3o+jqTVSzCFOcn9AIAxMSAXUic91pIzKOdPc9kMbtgCyXr1IE0Dj82A0EUcN4VE96O5QzBgOYE2QgQMBjy9t57AQ+YMCXViXEXhOYJg4YOzB6sIFl+F2cLgmATwAtXDeI1561CMb84iog5HLsgJRlzt34fViYDdd06xJ59uefXsUnWbMr5oqxCE6nlLkno+5LvYC6rbhFxM5V6aD2tb9DTQNZjryFXskDvAYoSkKylBDfJ4jUDi8UC2souyAMvNp0/Ni/35DMJbd8xVq9ejXvvvRe5XA633347XvjCFwIAZmdnEQr1brZgZmYG1157LRKJBJLJJK6//npkGxQgcpw8eRJvetObMD4+jmg0iqc//elL3tJod2W1qWQV+mgeC6gqI2Y3KssiMC16ymoD/XPTUuxCYqN5hDvHxucDoSSQPQkcvKu9Hzazn3ZthQaA6GiHR9wY3CoYOe88SPE45FGmZPlpF8wXbCWr16EXALUL2jNZXuyCgDOX1WhmowpcyRJbKFkPsFmszRcuw8Bo/2wU9APcwRdJLQlZ9C/4QXZ1ZZGKQuIm4Rcz+wFiwhIjjpLVA2srny/9xMvOwT++7GwUmerS70XEHDzG3cpmQAwD01/9KgBg6C1vaSul1j3z4oYm0d/XoEg3pLIdzGXNujuy7Hks+hnnoUUVkDVgcIL+3Wv4BSdZhN4DZFUMSNYSAu/lrJjJWmR2weyMDsusVIJLBQP7/nAaALD10hXzfmxLHW3fMd773vfi2muvxapVq7BixQo8+9nPBkBthNs9eq87wbXXXovHHnsMv/jFL/CTn/wEd9xxB97xjnc0fc6b3/xm7NmzBz/60Y+wa9cuvOpVr8LVV1+Nhx9+uGfHudBwEgbbVLIe659kQaCyjJgUCiCmCcPlx9cG+qfY0SkkNp0y4kITkiWrwNmvoH/f9d32fhi/4Q9vAnrg8efR7bHL6Q60PMqULD9JVrEwv3bBRBwan8nyYhcEgJHN9M/hjZ4e7kXJOn0ojUO7piEICFSsOnDbBf0MvQDchcRqZfJnsxj3SVrMTiLL7eAL2We7oPvYeIfXYrML8kJiM5NB+n/+B8bxE5CGhjDw8pe19ToSTxd02QUBQJPpZ3ZIokSok7ks3pFFi4gZiYsMIp8u4f9+6C78vy/tqn1SuwmD3C5I+AZSQLKWEipmskr0fFosJKuiK6sqYfepB0/BKFsYHI9g2TrvPY8BvKHtO8Zf/MVf4Pe//z1uvvlm3HXXXRDZTtX69et7NpO1e/du3H777fjP//xPXHjhhbjsssvwuc99Dt/+9rdx/Pjxhs+755578J73vAcXXHAB1q9fj7/7u79DMpnEH/7wh54cZz9AXc9I1sGDIKa3mxExTRRZOmS4b5QsZyYLoIl0vIhYICaUwYXvyOJQXYXEIk8X1Jv3Udgpg4//mFoAvaKHyYJmNofcAw8AAGJs86QndsHC/JIsMTEAVW9TybryU8DbfuVE7reAo2Q1JlkP/PQgAGDTBcuC9KY6qCBZPoZeAM55ZklaJclKsvCLenZB9lkj4WWwmL3V75kswFHC+fWtuNhIFleyMlk7tn3w2mtsVd8rZNsuWKVkyXRROCBQktWNkjUUVRwlKzyEUwfmUCqaOLpnFqR69qrdhEFbyXKKq60cJVlCUES86CG7Z7Jsu+DiIFmVXVmVc1lO4MWKIJylB+jojnHeeefhla98JWJs4BUArrrqKlx66aW+HZgb9957L5LJJM4//3z7a89//vMhiiLuu+++hs+75JJL8J3vfAczMzOwLAvf/va3USwWbfWtHnRdRzqdrvhvMUFZsQKCpoGUSigfazDMXYXSoUMg+TyEUAjqunU9PkJv4CTLklSYogwrl7eLRCVDt6X7foA7+MKTkgUAay4BEisBfQ546ufef9h075IFc/feA5TLUNasgbpuAoBDssyZGSeVrUvQdMH5m8lyB1/kUqXaxVQ9aHFg1fme1ULTVrLq7wROHs7g4KNTgACc/+IJT695psEd4T7kMdXRKxQ2S2VImjOTBTSfyZpiSlZoBKatZPl/vro3aQCgmFtcM1m8gDt7xx0oPvYYBE3D4DXXtP86jeyCCiWdfLXR/UyWU0ScnqLX6XLRhJ6vel1byWqXZNFrWxB8sbRQL/hisaQLAvUTBmeO53DqQBqCKGDzReMLdWhLGh2Zvo8ePYof/ehHOHz4MEqlSunx05/+tC8H5sbJkycxNlaZeCLLMoaGhnDy5MmGz/vud7+L173udRgeHoYsy4hEIvjBD36AjRsbW4A+8YlP4KMf/ahvxz7fECQJ6rp10J94Avq+fVDXrGn5HLsfa8sWCHJ/zAGoIRkQABDAlMKw8jmURXqRkEzdaWDvAzgzWaa9e9swwp1DFIFzXg3c81lg1/eAbR6tNT1MFrSj2599ub2jJQ0N0WO1LBgzM1CqPoedwJ0uOG8zWUzJMg0Les5AKObvAtZqoWQ9+LODAIBN5y/D4Hj/WF37CZqkQRVVlKyS70oWn8myRBVWxUxWE7sg+6xZ2nDP0gUBV6F50YBlWigV6GJ/scxkcbtg+Qh9Dwde+QpblWoHdoR7tV1QpeSTTzB20pWVyrtmsqYcJSs95VynMzPFSmI73KaSxe2CJi9ZD+yCSwl10wUXEcmqF36x+x7qBJvYPoxIYvH8WxYT2r5j/OpXv8LmzZvxxS9+ETfccAN+85vf4Ctf+QpuvvlmPPLII2291oc//GEIgtD0vydYd1Mn+Pu//3ukUin88pe/xIMPPoj3v//9uPrqq7FrVx3/NcNHPvIRzM3N2f8dOdKkqLJPofGEQY9zWcU/9VfoBQAIomDPZZUVGn7B7TSSWaR9YH0C3nVTKhq2ktWwjNiNHSxl8Mn/AYpzrR9PSM/sgsSyHJJ1uZMIJkgSpGGqKvhVSEzcStY8lEqLiQREYkAxaEqZZ8ugRxBC7CLWekrW1NEs9j8yGahYHsDVLD/j2wH3TJYGUqinZB2tjOq2LMcuqAw4ZcQ9sQs6M51uNYWH//Q7ePAFAEAQMPRnf9bZ6zCSRfJ5O70NADSNJcoS+t5nO5jJmqkbfFFFsqqT1/g1du4wUMqjJZiSVTbp71OuSBcMNlYWOzjJMlKzsErMLqgujnRBoFbJMk0Le+6jIkXQjdU7tL1V9pGPfAQf/OAH8dGPfhTxeBy33norxsbGcO211+KKK65o67U+8IEP4C1veUvTx6xfvx7j4+M4ffp0xdcNw8DMzAzGx+tLnPv27cONN96IP/3pTzibkYdzzz0Xd955Jz7/+c/jpptuqvs8TdOgLZJYzkZQ20wYLPZZsiCHGpah5w0afpHPo6zRm6vcb0qWuycr2qKM2I1l5wCjW4DJJ4DdPwZ2vrH54zMn6I1ckJzkK59QfHw3zMkpiJEIIs94RsX35JFRmJNTvs1lWYUCLJHNZM2HksUIuaqnUJajyKV0DK+MtXiWd5BCAWBWSqmOksVVrI1PH8PQimCx1QwJNYGpwlRvgy/cdsHESgACYOpAbhKIMaU2fRQo5wFRARGj9kxWL4IvVFcFhJ0sGJEhiotjPsKt3sae91xoHVrOxVgMkGXAMGCmUhCXLQMAaCFKsmRLAITOlCwefDFUFeHutk5lZ6tIVnSYxrwXZmh5/PIdzX8IU7JoAq4ZKFlLDE7wxdwiVbIqu7IO7ZpGIVNGOKFizTn+Xm8DOGj7jrF79268+c1vBkAte4VCAbFYDP/0T/+ET37yk2291ujoKLZs2dL0P1VVcfHFFyOVSlUEVvz617+GZVm48MIL6752nl/cqiJkJUmCZbVfZriYoLXRlUUsyw696JdkQY7qQuJSgd4oJVOHNJBcwCOrhFrRk8XKiFvNZAF03ocHYDzqIWWQWwWH1tGEQh/BC4ijl15S4zO3wy98UrLmP12QqiNaMQXAfyWLq1iQJAhVi6np41nse5huEJ1/5YSvP3cpYiIxAQDYmPSW6ugV3JZqVgdfyCoQZ7u47rksO8VzA0i53GMliwdfGPY8lrZI5rEARo4YhtsoH66GIAh157K0ECWbIlOIcm3OZFkWcdkFneALUm0XrNch1E7CYIkq5WWDniOyKtnW1IBkLX7wc5Pk87Cy9He9uEhWpV2QB15suWgckuT/dS0ARdvvbDQateewli9fjn379tnfm/Ix5tmNrVu34oorrsDb3/523H///bj77rvx7ne/G69//euxYgXN9T927Bi2bNmC+++/HwCwZcsWbNy4Ee985ztx//33Y9++fbjhhhvwi1/8Aq94xSt6cpz9AnWDo2S1GvIvHToEK5eDoGnQ2PP6BZxklVkhcWmO3rAks9hnwRdskaQbEHkZcat0QY7tr6F/HrgDyDSeLwTQ02RBZx7r2TXfs7uyJv2yCxZcwRe9v7gLoRAERXGFX/hLsiwWjiPF4zXpTH/42UGAABt2jvqqni1V/PNl/4xvXfUtnDNyjq+vWxnhXmX94pZB91zWJJ993ARLLzllxD20C5aLjpIViiyOeSwACJ11FpTVqxF/4QsR3rmzq9eS68S4c9u4wGad2lWy0sUyeA1W0hXhXrCSMErOhmtmph7J8jiXRQhQopstBv0VQlZFkEDJWjIQ43FAop9V4xQtqF4s6YJAZVdWdraIQ3+iATCBVbC3aPuOcdFFF+Guu2iB6pVXXokPfOAD+PjHP47rrrsOF110ke8HyPHNb34TW7ZswfOe9zxceeWVuOyyy/DlL3/Z/n65XMaePXtsBUtRFPzsZz/D6OgoXvrSl2LHjh342te+hq9+9au48sore3ac/QB1YgIQBFjpNMzp6aaP5f1Y2pbNfRN6waGF6cKGK1n6HLVjyDAg9pGl071IsiPcvShZALX9rb4QAAH+dFvzx071JlnQmJxEkc0pxp71rJrv+65kFYouJav355wgCBAHBuzwi1yq1OIZ7YErWWLVPNbMiRyeYiWP5wUqlick1ITvBAtwkSyxaiYLAJIs/KJCyaLJghjZDKLrsCROsnqXLlgqmouuIwsAxGgUG37+P1j57/+n6whoKVkb424nzdokq72ZLD6PFddkqLJoK1npYqW1t6mSNd2CZJULtCQegFFm9kbFiXAPSNbihyAItvXcYOMriyldMOrqyvrD7YdALILx9QNBEFOP0fYK59Of/jSyWbrY/ehHP4psNovvfOc72LRpU0+SBTmGhoZwyy23NPz+xMREjWqzadMm3HrrrT07pn6FqGlQVq1C+cgR6Pv224vkeuDzWP3Sj+VGhV0wl4depoujPuOCzkyWbkIIsV4vvQ21ZPtrgSP30WLii/+i8eN6lCyYveNOAHQmj6tWbvjdlWW5erJkdX5sClIi0Tu7oEvJcuMP/+8gQIB1545gdHXj/qwAvYeiumeyqjYL3OEXHHxDY3QziP5QT9MF+UZDWTecmaxFRLIA+NavY4cLuElWlC5kTZO+J+32ZM0yq2AyqgBGyQ6oSOfoNUiL0Nnf5kpWC7sge00AMAxGstwzWUFP1pKANDgIc2YGZXYvXEx2QUEUEB8KYW6ygMfvoqmCWy8NVKxeo+07xvr167FjBx0AjUajuOmmm/Doo4/i1ltvxdq1a30/wACdQeOlxAeaz2X1a+gFAKg2yaIR7qUMvQkqfUayKsqIebpg9W55M2x7BQ2zOP4wMLW38eP4wm/YXyWLz2PVswoCgDzG7IK+pQvO70wWQEmWXUjst13QVrIcIpU6lcdTD1BLyTOu6o/uuTMZstZgJguoH+M+yZWsTTB13SFZci8i3JmSVTAXXRGx35DqFBJrMXqtMEwNIO33ZM2y93TInSwoiEjPUWK4fGMSAFDIlGGUqlQyeyZrL02cbARGsogSsy2IStCTteRgB26V6Tm1mNIFAWcuyzIJZE3CxvO6r2QJ0Bxt3zEeeOCBugXA9913Hx588EFfDipA97DnspqEXxDLQvFxahcMbeuv0AvAmUsoMyWrlKeL4/mY42kHnCiU3GXERY92QQCIjQIbnkv/vut79R+jZ2niGeCrXZCUSsjdfTc9jGdfXvcxjl3QTyVr/sqIAUCsKCTulZLl2AUf/H8HQQjtHxldE6hYCw2lgmRVzWQlWZcgtwvmZwCudo2cBdOlnPR0Jks3oNtFxH22kzRPcCe4cWgxOudKIEJB+xHudYuIw4NIT9PrwNjauH1+1KhZybWAqABGwbn+1gNLFrTUBIhVR8kKSNaSQHWq8WJSsgBnLgsANp43Znf0Begd2r5jvOtd76rbHXXs2DG8613v8uWgAnQPJ2FwX8PHlI8cgZXNQlBVaE0KmhcKqj2TRYMvyqykUw311y6v4ioT5UoWTBOE7XZ5Ak8Z3PW9yr4ejmmmcEVGgMhQF0dbifyDD8LK5yGNjDRUMx27oF/pgs5MljxvStYAND0FAMinS7Cs5oEw7aBaySoVDDx5P1Wxzg9UrL4AtwtakgqSr1ayuF2Q3de4NWxgNaBGYbiUE6kH9lbVThc0F61d0C9IPPjCpWTJkRhEMIWPCG0HX8y6O7LytUXEiZGwk7xWTbIkGRhmgVDNLINMyTJkp4S5sicrIFlLAdWBW4uNZPEYdyAIvJgvtH3HePzxx/H0pz+95us7d+7E40wVCbDwsLuyDhxo+BhuFdQ2b4ag9N9N3Z7JssuI6c1V6bOSTrddUAg7F7G21KwtVwFyGJjZBxx/qPb7nGT5PY/FUwWf9SwIYv3LgTRC7YIkn4eVy3X9M0mhAFOcXyVLSiSgljIACAgBCmn/wi/MNCsiZkrW7Mk8iEUQGVCxbKK2nDjA/ENm6ndTu2BhlioSLqsgAJjMQiaA9KS7qm664JlKsupEuAtaFJpIrzsh0n66IO/Iqi0iptfnxEgY8SEnea0GXhIGmZJlKPT4BQEQZSEgWUsM8uBgxf8L6uL6nA6Mhe0/l2/on4TmpYy2SZamaTjF4ivdOHHiBOR+SyQ4g8GVLOPEiYYL44I9j9V/VkHAHXxBlSzudddioWZPm3e4y4ghy/QOC9Qu5ppBiwFbWOrlru/Xfn/KiZT2Exl7Hqu+VRAApFjU7n/yYy7LHXwxH2XEACANJCCAICRScuVn+IWVYXZBpmTNnqKft8HxYGHVL+CfUUtUYFYnf4YSgMYWHHNHXZ+1zQAAo0yvO5Ik+Bbw4IatZLmCL85UkiXbdsGU80U1Bk2gJCZkCW33ZHElayiq2EqWqQ3b5cOJkZBNsuqHX3joyuJKlpSk/w6unDKSVd2fF2Bxotou2E8px16wfucoLnjpOrzobef05FoWoBZtk6wXvvCF+MhHPoK5OccznUql8Dd/8zd4wQte4OvBBegcUjIJaZi2eOv766tZ/TyPBTj9KGUW4c7dd2q/kSy2SLIsAmLCVrNIOwmDALD9avrnn24FrKq5gx4kC+oHDqB86DCgKIhecmnTx/oV404sC0TX5z34gserh0CJr59zWVzJ4j9j9iRdWA0uC6Jx+wXu86xcrGPjdce488/aKP2s2SSrR3uINgE0CPJMYT1TSVa94AuojpKlkQ4i3N0zWUzJyoqrQAhNi4wk1Jqi1goMe1CybLsgJeuyKoKUSoBJj1WMBNeCpYDFPpMlSSKecdW6YE54HtE2yfq3f/s3HDlyBGvXrsVznvMcPOc5z8G6detw8uRJ3HDDDb04xgAdolnCICEExcd3A+jPZEEA0CJVM1km3XlRB/prV1BxzWnQQmIWftGOkgXQ8IvwIJA9RcuJ3ehBR1b2t9QqGH3G+ZBizRcBfsW4k0IBBAKseQ6+kBJ08aMZdDHkJ8lylCxKslKMZCUDJatvIMkiF5hhFOss0t1zWbZdkJIss0wfL0m92fnldmMAyM9RQqCdqcEXPMLdrWRpLiWLCG1HuKfytTNZaXMcAA0CEATBo5LV2i5YFmnhuHseC4DdnxhgcWOxk6wA84+2SdbKlSvx6KOP4lOf+hS2bduG8847D//+7/+OXbt2YfXq1b04xgAdQmUkq17CYPnoUVhzcxAUBaFN/lrQ/IK7J8vM52EQuhjRkrGFPKwaiJJop46ViyaEEFVpSDszWQAgq8DZr6R/d1sGLcs1k+UjyeLzWJc3tgrah8b6s7oNv6ChF86Nad5I1gAlQHbC4Jz/M1ki68maPcnsgssCktUvEAQBskJJUqlUJ4qbz2VN7QVSh+nfmV3QZL1HktwbkiVKYk3/1pmuZJF83ukaVKPQREpiIsRCybBQNpvEqVdhxh18UaAKWbpMN40So9R10FTJGmGhUNmTQHGu9vuArWSZIr0GyKpoFxEL4TAEaX6ucwF6ixqStcjsggHmHx1tl0WjUbzjHe/w+1gC+AxtA1Oy9teSLDv04qyz+nY3hpMsCCLKhTIMdrpqQ/0ndSshCUbZYl1Z9MbdVvAFx/bXAg/eDOz+EXDVDYASorvrRhGQVBop7APMTAZ5VrnQqB/LDb/sgu55LAi9KXetB64yaYUZIOSzXdClZFmmhblJqmAGSlZ/QVZFlEumbf+rALcL7v8NAAKEkkCUnfNMOOlFfDuHGpJQYMclCI5V+kyDGIvRuVbDgJlKQVy2DFCiCDG7YIyYAETkdRMDEW+/Dx58MRR1KVk6vR4kWNpabJAFX6R0WKYFUXK9dmgAiI1TkjW1F1h1Xu0P0elGi61kqRKsPD3mIPRi6UCqDr5Q+nPtFKB/0F+FQwF8hZ0wWJdk9fc8FkAX4CLbANRLBKZAd3dDw/2XimOHX7gLiTshWasvorvqehp46n/o1+wS4o2w35Aukbv7HsAwoE5MQPVQIi6P+tOVRapCL+Zr+FZkdkElQ4/fV7ugnS4YR3qqSIseFRHxwcAi1E/gn1HDoLOBFeB2wdMsIXd0sxNgYzIlS+mdGuFWdLWIAqEHKYaLAYIg1Ma4yypUiYVUgP4ush7DLyyLuOyCit2TNZejxCcxQj+j0QEVoiSAWKS+ym0nDDYIvyhRQmUIUXbIIkiQLLjkUGsXPDMV5wDeEZCsJQy7K+vQoZrOpqKdLNif81gAveFqbF6hUFIAgZ6uodHBZk9bECh2143hFBJXp5h5gSgC57ya/v3R79I/e5AsmLVTBZ/t6fF+zWRZCxDfDjh2QWXuJAD/0gUJITAzTvDF7ClnHutMXSj3KxSNfkZNSQWpiXFfU/n/roAZ03TKZXt2bK5S0DN1HotDrhPjrin0/hVnHymvMe7pYhm8Ei/pinDPZOk1KDFClSxBFBAbpJs/9S2DLRIGefAF6OtRJSsgWUsN0kDlBu9iSxcMMP8ISNYShrx8OY2ONQyUjjht9YSQRUGyAMc2UxTYjYpY0PpQyVJdMe62kqV3QLIAYAdLGXzq50Ah5dzYh/0hWcSykL3zTgDNo9vdsGeyurYLzn8RMeCyCxbpwi2X8mcmixQKtp9MiseDeaw+Bicy9buyVlX+P1tUE8uCSehtUuph3YA7/OJMncfikJK1Me6aSsNHeAuhV5LF57HimgxVFm27IA9H5iQLQONCYsDZ4JpuEH7Be7IE+hqyIgYkawlCkGV79hYIgi8CtEZAspYwBEGAto6pWfv32V8vHzsOc24OkGVom/0tt/UbKksY1EP0xitZpb7cPVLqFBJ3pGQBwLKzgbFtgFmis1l2sqA/v6vin/4Ec3oaYiyGSJ1i8XqQmJJldht8UcjbwRfzqWQJ4TCgKND0FACgmCvDrDeb0ya4igVZhhAOO8mCAcnqO/DzrS7Jii2jM48cozT0gpRKsER6DZLV3ilMXGUDApLF514Ml5IVUllHIiO8XmPcZ5lVMBlVaIBQMQXdikAvUHmL2wUBtEgYbBHjXqLXgUDJWvqw57JEEULQDRugBTyTrNnZWXzuc59DOp2u+d7c3FzD7wVYWNRLGCw+zkIvNm2C2Oc7MaEYPb6iNgQAkEmdjps+AF/AlYqmTQJJsc0Idze2v4b+uet7vtsFuVUweumlnnfi5BGmZE1Pg5jt9dS4QYrFeS8iBtisRyIB2ciDB335YRm02DVPischCAJSzC44OB704vQbOJGxJBVWvuqzKYpAYqXz/1zJ0nWHZGm9W1C5lawz3S4o1bMLhigpUhjJ8hrjPsvKnYciKlBMAcRC2hwDAIRiil0EDbQiWWyDa3ofYNb52Xwmi/BrW6BkLVXw8zNIFgzgBZ5J1o033og77rgDCWa7cWNgYAB33nknPve5z/l6cAG6R72EQTv04uz+Db3g4AmDRS0JAJDRXkfKfIFbkcq6AYF1oljFLhbx5zCSdeBOIHea/t03ksWi2z3OYwGAPDxEgwAsq7IotE1YeVfwRWj+SBZALYMCgHCYDnb4EX7hzGPx+PagI6tfIWv0dmdKGkghX/sAbhmUNCBJZ7QsXYcl0s92YBecHziFxCn7a1qIfmYlkytZHu2CFUXE9LqVEWjQj9sqCDh2wWy9mazEKkAOA1YZSB2q/T63CxL6u5NUyY5wD0jW0oKUpOMKgVUwgBd4Jlm33nor/vzP/7zh99/5znfi+9//fsPvB1gYqOuYklVBsqiSFe7zeSzAKSTmdkFZ7N7i1QsoFTNZPMK9CyVrcC1NGmRpWoivALTuo+vLp06j+PjjgCAg9qxnen6eIMuQhqia2M1cllUsOEXE86hkAc5cVkSj55AfXVmmrWQlUMiWUGQ754FdsP/AzzdTrGMXBGxihZFNdoonKZVg2nbBHqYLhgK7IIedLuieyQqz996SAQLkPaYLzro7svg8ljABoNIqCLRQskTR6cuqF37Bgy8sfm1zKVnR4FqwlGArWUGyYAAP8Eyy9u3bh01NSms3bdqEffv2Nfx+gIWBW8kihCyq0AsAUG0li5IsRSYLeTgNoboi3O0y4k5nsjh2vNb5u18q1h1UxQrt2A55eLjl4/PpEgiL53ISBjsnWRUR7vM4kwUAIksYDMmUCPmhZFlMyZIScVvFig1p804gA7SGM5OltiBZzuxjhV1Q7mW6YKBkcdS1C/L3hIiQAWQ9z2TRz/qgO1mQrABQq2TFOMmaLoKQOveZZgmDXMmy6P0qmMlaupCZ0iqqgV0wQGt4vmtIkoTjx483/P7x48chikGORr9BXbMGkCRYuRyM06dhnDxJb16SBO2s/g69ABy7YFmlC2RZ6c9YbL5IKrnLiDtNF+TY9kqAWZV8twpe3jpV8OSBOXzlQ3fhd9+miwo/YtytQhGmOP/pggAgsa6skEB/L77YBZmSJcYTwTxWn0N2k6zqmSwAeNo1wPargUv/0v6Sm2T1sjhbdc17nekzWbJtF3RIlhLWIIASK414twtyJWsoqjhKFpvJSgxXKVms184oWyhm68z+DjcIvyDEUbJMRrIUh2QJAclaUnCUrMAuGKA1PN81du7ciR/+8IcNv/+DH/wAO3fu9OOYAvgIQVWhrl4NACjt22erWNrGjXbUeD+DR7hzKFp/Enk+VF8umhDZTFbXSlZ0GNj0Qvr35ed291qg8yW5e+8FAMQ9zGMd/hMt7jy5j+Yd+xHjTtMFF0bJ4nbBkEWH1H0JvqijZAXx7f0J2y4oabDqzWQl1wCv/g9ghXMfs9xKVg9JVqBkObBnslx2QUGLQhPo5zZEBM/BFxUzWayIOKPT10+MVipZkiIiMkAXzm0lDBpFgFACaLCZMTkIvliyCEhWgHbg+a7x7ne/GzfccANuvPFGmK50MdM08bnPfQ6f+cxn8K53vasnBxmgO6gbNgAA9P0HUFhEVkHAmcnicKdB9RNUO8LdgKCx4ItulSwA1ks+h/RzbgLZ8YauXyt//wMg+TzksTFoW7e2fPzkYUogsrP03yGPMiVrqnMlixSKToR7D8td64HbBbUSVZ/8UbJY8EU8gRTvyApCL/oS7gj3mjLiBiB6aX6UrIBk2bAj3F0kC2oMmkjVohARPM9kpfKumazCDAgRkC7GAACJ4XDN4+Muy2ANGtkFmVUQAAyDOi0CkrV0wc/PIF0wgBd4vmu8+tWvxoc+9CH85V/+JYaGhrBz507s3LkTQ0NDeO9734v3v//9eM1rXtPLYw3QIbT1fC5rn2seq/+TBQHHLsihhPtz96gi+MIvJQvA73+Rwte/tQwHH0t1/VrZ3zlWQUFobrskhOD0IUog9LyBsm7adkGzKyWrsCBlxIBjF1SLKQD+BF9YGRZ84VKykoFdsC9hkyyxgV2wDkjJSReUlSD4Yj7AlQKSz8MqsmuoGoUmciXLe0/WTFXwRd5KwrQkCKKA2FDtIrlpIfEwC74ozAC5aefrrCMLShQG696jM1n0eMVIcD1YSohedBEi55+Pwatf2/rBAc54tCULfPzjH8fLX/5yfPOb38TevXtBCMHll1+Oa665BhdccEGvjjFAl3B3Zel79wIAQtsWJ8lSo/25e+SeybKVrGL3JOvkfmrVO/zYDNadO9rx6xBC7H6s2LNbz2PlUiXk0w4Jyc4W7UJi43QXM1nFAkyJBm6oC2QXVPOTgOivkkWicaSn6MI9sAv2J+RWdsE6sHTdThfs7UyWuyfrzCZZYiwGyDJgGDBTKYjj41TJEuhMVTt2QR58MRSlStacOQ4AiA1qkKTa32fThEE1AgysAeYOUzUrejH9OuvIghZDueQmWYGStRQhJZNY+42vL/RhBFgkaNt7dcEFFwSEapGBJwwW/vhHkGIREEWEtmxZ4KPyhmqSpSVqLR79AGcmy3CULB9IFretnDrYXdF3af9+lI8ehaCqiF50UcvHTx6u/HnZGR1DPsxkkfwCKlnMLqjOnQYGaRJkqWBADXduQeVKVl4aACGUbPO5jgD9hcp0QW/nsNsuOB8zWYIoVFgHz0QIggBpMAlzcgpmKgWFkyzxCAAafOHFLmhZxGUXpMEXGR56MVL/PtLULgjQuSxOstYyksXtgmoURp4qbLIiohyQrAABznh4Xl0cPnzY0+PWrFnT8cEE6A24ksUX/dqGDRDD/UlWqqGFq2ayEv15w3JmskwIdk9WdyTLLFvIMrVl+mgWRtns2LLEVazIBRdAjLa2r3CrIEdmtoix5T4EXxSLCxfhHqckS0jPQF0uoVQ0kZvTuyJZXMnKmFEABIPLIi2tmAEWBjw0x2prJmt+0gXjwyGIkoBkcP4AAOQkI1k8YVCtDL6Y9WAXTBfLYO0TSEZoGfGcSR0c1R1ZHE3tggAlWft+VTmXVeIkK1ZhF9R5GXHQkxUgwBkLz6uLiYmJuhd/Qoj9dUEQYBjeZPwA8wcpFoM8Ngbj9GkAiyf0AgDUcOVCXEvGFuhImqNeGbHXhVwjZGaKdhexZRFMHclifP1AR69lR7d7SBUEHJIlySJMw0J2Voe8g9oFrWwWVqHQEVG3CgWYrF9k3suImZJlptOIJjWUTuaRS+ldRa6bTMnKlDQAxSC+vY/B1eaGEe514J7JknrYkxWOqXj9319QE/RzpkJKVsW4q1E7+EKzBE8R7nweK67JUGURyM8gbVC7IFeyzGwOh978JsQuuQRjH/xgc7sg4CQMTu91vqazDSktDqPElKwg+CJAgABog2Q9/PDDdb9OCMG3v/1tfPazn0Us1p8L4ACAumG9Q7IWyTwWAIiSCFmy7Gjc0GB/nmPc7mOULRCVpwt2N/OTnq5cCJ4+lO6IZJlzc8g/9BAAb/NYhBDbLrhq6yAO7ZpGdrYIMRaDoGkgug5jasquBmgHpFCAGWLpggs0k2Wm04gOaJhlJKsbWEzJSufo+ZkM5rH6FjJLszRFrX4ZcR1Yug6LpWHKPU7DDAi6g5qEQS0GTeDpgt56smaZVTDJZ9wKM0jbdkF6jS788RHoj++GcfxEBcnScwZKRaM2zbZewiCfyVJjMNhMlhLMZAUIEABtpAuee+65Nf9NTk7ibW97G77whS/gQx/6EPbt29fLYw3QBbR16+2/h85ZPEoWAKiuzV0l0p/zLm7CYMlUqelWyUpPVe6mdjqXlbv7bsA0oW7cAHXVqpaPz87qKGTKEEUBE+cM218TBMHpyprszDJI0wXZonW+7YIsXRDlMiJx+rO7SRgkhMBkPVlzc1RyDOLb+xfuCHevwRd0JounC/ZnR99ShFRdSKzGXOmCAnIeZrJmcyz0IqICpTxgFJE2lwFwlCzj5Cn6c1IpWMUi1LBszwHX78piJGv2IGCwDZqSayaLKVmiYIGU6LVlsVjzAwQI4D86ums89NBDeMELXoCXvOQluOiii7B371784z/+I+LxuN/HF8AnqCz8YjGFXnBoLl7Vr0PhkixCFKlttgzKCrudycowJYuXZp4+mGn28Mavw1MFL2+tYgFOP9bgiigGxihpyLIFB49x77Qra0FnsqIRQKI/M6xRUtSNkkUKBcAwQADMTbNd84Bk9S34+UZECWbe2++9YiZL7s9rz1IEj3E3Z1P0Cy67YIgAxbIFw7SavkZ1EbFBFOSsIQDAACNZ5ZMn7McbpyjhijULv4gtA7QEQCxgZj/9Ggu+sJQ4LJNeVyTT2bwJlKwAAc5ctEWy9u3bh9e97nW44IILMDo6iscffxw33ngjxsbGenV8AXxCePt2ANQquNgu+mrUYVnzvTD3CkEQbMsgj3wmug5iNV8INEOa3eQ3nkc/X6lTeegsktgriGkid8edALyTrNOHqGI2tjZu22eyszoIIU4h8WSHJCufXzCSJQiCbRkMK3THOTfXOcniKlYpPIRS0YQgAMnRxfXZOpPgVk7LRW+zw6TkRLj32i4YwIE0mASABsEX9Eu5UvPwi1l3R1ZhBhlzFIAIWZMQitHfKVeyAKB84iQAVFzzaiAIzlwWtwyynixDcqzcosEImqJAUPvTfREgQIDew/Nd4y/+4i+wbds2zM3N4cEHH8Qtt9yC9evXt35igL5AeMcOrP7STVj56RsW+lDaRmQsaf+dD6/3I2w7EnGOkXQxl8XtgsvWJuwZgurUv1YoPPoo7ZpJJBDZudPTcybZzxhbm0B0kBIiHncudxHjTgihdhqBXnYWgjDbJEuk7203SpaVpmS0ODwBgFqQeplAF6A7SJIIkf16Sh7LbC1XhHsvgy8CVELmdkE+k6XGbCUrzElWi7ks3pHFi4i5VXBgJGSHdZVPnrQfb5xiJGu4RYz7cDXJouTPkBP2Q4QSdSEstg3NAAEC+AvPK9abbroJoVAIp0+fxnXXXdfwcQ+xAfsA/QevSka/QXNFbPerXRAAlJAMQIcB13xWsdixJ5/bBePDIYxNJJCeKuLUwTRWbx3y/Bp2quBll0JQWieXEUJwmtkFR9fEoagSQlEFxVwZ2VndLiQ2OyFZpRJMwfldyvOcLggA4gDdbQ6hAEBALtX5TBZXsvJJOucWWAX7H7IioKQTO6CgFahdkKULBgR63uDYBZmSJSnQZEqaNFCC1KoriytZQ1GFhV5QkhUfdq7HhotklZmq5TlhcIolDDK7oCHQUCZZEUHyAckKECBAGyTrH/7hH3p5HAECNIQ71ni+wxLagR3jXiIQFAWkXO64kLhUNFDI0EVFYiSEZRMJ7H3wNE63GX6R/V170e2ZmSKK2TJEScDISrpoiA1pKObKyMwUMcBnsjoIviAFp4hYUpwZtvkEV7K0cgZAArk5vaKGoh2YTMkqRJcDAAaDZMG+h6KKKOmmHVDQClZRB5mHMuIAlXDSBWftr2lsjlImIkQCZFuokZUzWTNIG1zJckhWuYJk0fms1oXEVQmDLPjCEGk6pBwkCwYIEIAhIFkB+h4qS3uS1YVZmHtFRSFxOAxSLsMqdEay+A1ei8jQIgrGJig5aIdkmakU9CeeAABEL7vM03O4VXB4ZczeuY8NhjB1JIvsrI7hEZ4u2P5MllUowBQXZh6Lg5MsRU8BSMAyCYrZMsLx9ucmLKZk5TRKPIMI7v6HrElAxkTZIJ7IddmllgRK1vzBThdMzdlf00ISAAuA6CnGPZV3zWTNzDpKFrNem9mc/RkGnPms1oXEnGQ9BRBi92QZIlOyVBFWnloIA5IVIMCZDV/uGul0Gl/84hdx/vnn+/FyAQJUgEfqKtWdJX0GThxKRROixmLci53FuHOSxW/4o6vjEAQaOV53ILsOirt30+NavRrykDeLodsqyBFjc1nZ2WJXM1lWwZUsuABWQQAQWSGxkE0jHKcKRafhF1zJyopJAIFdcDHALiQWNU/zkqZrIR8oWfMHTrJIPm+ntApaBJpAFaIQEZBtQbJm3MEXeacjiytZfAaLg6taXMnKzekwjTq20qF1gCDRwIvMSWcmC/R1AyUrQIAAHF3dNX7zm9/gTW96E5YvX45//ud/xoUXXujXcQUIYIOTLLWPrYKAU0jMlSyA2o06AS8i5n0uiiZhaAXdKfWqZhUffxxAe+XTk65kQQ6HZOlOuuD0dNvJiVYhb3dkKQs0WyexrixzLo1okv67Op3LsjIZmKKCAuhCKujI6n8oIVavIKmeColNZisUBAJRCkjWfEGMRgGZEWI7/CIK1dWV1XImiwVfDEVVNpM1DsBRsmyroMKTBun/h+MKVS1Jg4RBWQMGJ+jfp5607YJlgZMsMSBZAQIEANAByTp27Bg+/vGPY+PGjXjta1+LW265BTfffDOOHTuGz3/+8704xgBnOEJRehPkZKtfobJd8nLRgBiiN/JOlSyeLJhgShYALJugxOfUIY8k67H2SBYhxE4vHFvrJGXFBlmk8UzRUcQMw1n8eARxdWQtROgF4NgFzXQa0QFOsjpVsjLIR6gFSYvKCMeCqOZ+B1fDTUkDybcuJDbKdCNB6u/9nSUHQRBqY9y1GDSBEhqtxUyWZRGXXVBBMZ1DiVA7r1NETElVaOtW++dYOi1dbx1+4ZrLYsEXJuhzZEWyz62AZAUIcGbDM8m69dZbceWVV2Lz5s145JFHcMMNN+D48eMQRRHbt2/vaHA8QAAvWL1lCOdcvhIXvLS/KwNsu6BuQmAkq9NC4vQUTxZ0hrTbnctqV8nKTBeh5w2IsoChFc58UXyIkpHMrA5BVe3kr3bDL6hdkClZCzWTNcBJ1hyiA/RYOrULWpk08mFqQRpcFsxjLQYoGr3lmaI3Jcso04W8JAX3t/mGnKwX4+4oWc1mstLFMiwW9Z6MqEinKFkOR4htVeZKVmjzWfb12rAtg0y9b0iyNtI/p/faPVllwkhWoGQFCBCAwTPJet3rXoedO3fixIkT+N73voeXv/zlUIOSvQDzAEkRcfkbNmPtOcMLfShN4bYLOkpWhySLzWTxfiygkmQRvoJoADObRengQQBA6GxvJIurWCMrYxWdQFzJytmFxHwuq73wC6uQh7VARcQcIlOyrAq7YDdKFrUgBVbBxQG+wDYlzZtdMFCyFgw1Me5qFCGmZLUKvuDzWHFNhiqLSGeoG2Jg0PlFckIlj49DGaefY+8x7kzJmtzjRLgTuh4KZrICBAjA4ZlkXX/99fj85z+PK664AjfddBNmZ2dbPylAgDMIdoR70YQQZkpWB+mChBBkmJKVcClZQyuikBURpaKJ1OnmVieeKigvX+499ILZEEddVkEAlIwIgGlYKGTK9lxWu11ZbrvgwqULspmsdPcky8qkkWN2wSD0YnGAV0CYkgor74FkGSw2PCginnfYMe4uksWVLI0IyDWxC84yq2CSWc3TOXodjQ9r9mM4oVLGl0NmJMtzITEnWSd3AYQeh2GxqH9VhJVjJCsaXBcCBDiT4fnO8aUvfQknTpzAO97xDnzrW9/C8uXL8fKXvxyEEFhtDsAHCLAUobJ5j7JuQtQYydLbJ1l63kCpSG/ccZeSJUkiRlbTuaxWlsHiY48BaDP0giULjrmSBQFAkkVEWMR5drZoFxK3G+Nu5QswRWYXVBdm0erYBV0zWXOdBV+4Z7KCjqzFAUVzK1mtZ7J4upykBHbB+YYT456iX1Cj0ERvStZsjoVeRFTANJDWkwCAgTHn2mawXix5fJmjZJ2oTBhsqWTlnY0mw+JVI4GSFSBAAIq2VjrhcBh/9md/ht/97nfYtWsXzj77bCxbtgyXXnoprrnmGtx22229Os4AAfoejpJlQGRKFulAyeK7p+GEWhN1voxZBk8dzNQ8zw1nHmurp5/pDr0YXRuv+X5lwiDvympXyXLKiBeqVFqy7YJziCTZTFaHSpaRSSMfYTNZQUfWooCbZBEvM1lMLJECJWve4QRfpOgX1DhUwZnJyjZJF6woIi7M2vHtifGk/RhbyVq+HPI43SzxrGRFhoCIy76uRGCUqeqpKM5MlhCQrAABzmh0fOfYtGkT/uVf/gVHjhzBN77xDeTzebzhDW/w89gCBFhUqIhwD/EI9/bTBdO2VTBU872xdUzJapEw2G7oxdxkAaWCAUkWK0IvOGJsZzc7W4Q80llXllUoLLhdUBygdkFSLiMSoouifKYEy2xfjc8XRFiSBlGsVBwD9C9ktV27IHueEgxlzTfqzmTZSpaAfFMly9WRVZixi4gTo/Ta5i4iVpYtq5nJ4nOomdli4/lXrmYBgBqDweL+AyUrQIAAHF1vz4miiJe+9KX44Q9/iCNHjvhxTAECLEpUlBGHeBlx+ypJvfh2Dq5kTR7J1C/KBCUz+r79AIDQtrM9/UxuFRxeFYNUpw/IVrJmdMjcLtg2yVr4mSwxGrVTDFSzAFEUAALk0+1ZBgkhyJgsEnpYq/ueBeg/2EqWx3RBzr0XSnk9kyFzu6B7JkvgM1loMZNF7YKDERVWdhoZk24MJUYri4jFRAJiNGrPZJWZhTA6qEEQAMsgyGcaXBuGNzp/12IwSsxaGqQLBggQgMHXlcHY2JifLxcgwKKCeybLUbLatwvyIuL4SLjme4mRMLSoDMsgmD6Wrft8fc8ewLIgjYxAHhv19DOdfqxaqyDg6sqaLTqFxO3OZLnLiBdo0SoIAqQ4/TdamTQiPMa9zUJiks8jH6LvbZAsuHjQzkwWIcQmWdIC9bqdyaidyYo5M1mWgKwHJWsoqiA3mYIFBaJg2mE3fPZKWUYVLq5kGUzJkiTRfuz/396Zh0dRZm3/rqW3JJ2VhCSQsAhhFQUBBYQEBMMwOsAoIigKgoqIvAoKiMoiLojwgsjg4AY64yejosg7LIoQcEAGEE1cWEUgAgkhZO10equq749aujtrJ3SS7uT8rqsvSK1Pd1dX1an7nPvUan4BAPpQze5f56VkURoxQbRk6PErQfgJr5osTcmqT7pg9UoWwzBorbj/XT5bdcpguZoq2KO7z/3rrijph9UHWVXUZNXVXbC86ZsRAwCrmF+Ing6DdeyVJZS6TS8iE6v+zIjAw9PCvbaaLMnhgMiqjnGB3Qi9OaL14yvybEbsoWT5WJNVkic/QDIbSmXlGm4li0+QgyteCbaEggKIdvlcoNVl1WZ+AQB6s6ZkUZ8sgiBUKMgiCD/hWZMFg6pk1T1dsFRRssKrULIAj35Z1dRl1bUeSxIlLV0wNjm8ymU0t61Cm5YuKJaUaDckviDXZDWtkgVUsHFXHQbraH4hlJRoQVY0mV4EDbzSjFj0oSZLstvdQZaBgqzGRlOyNOMLT3fBmi3ci6zumiyt52CoO1hyK1lykMVFRrobEl/2tVdWZ/f/DRVqssrJwp0gCAqyCMJvqIGDJAGSQW1GXDclS5IkLT0lvBozhbhaHAZtv9bD9MImgNOxiE6o+qZAVbLKihxAmBmM0oi8Lg6Doq3pjS8At8OgUFyC0Ij6OQyKpaXUIysI0SnBki/NiD2DLI6CrEZHDbKk8nI57dojyDKAgdVWezPiqBA9Sgrl4Cfc7F6+opLFMIyWOujM9bZxt1SXLhjZDlAeGkEfBqeqZOlYSGWkZBEEUc8gq6ioCO+++y6effZZFBQUAAB++OEHXLx40a+DI4hgwtNu3cUpSlYdLdytJQ64nCIYxl0HVRE1pa8wtwyOCjcaosMB++nTAACTj0FWXrasiLVqGwa2GgOHkAgDGJaBJEooL3FqapaQ73tdlmQth8AGQJClpQsWIzSqfumC5VeL4TBEAqAeWcGETlGyZOOLmmuyRLtHuqCOnkc2NmxoKKCTP3+hqAjQh0HPuL8zySFAqMb5TzW+iA7Vo6RE/u4UARtAZSULgLshsRpk1ZYuyPFA9HXy//WhEJSaLI5ntACegiyCaNnU+crx008/ISUlBa+99hpWrFiBIqUo9fPPP8ezzz7r7/ERRNDAsIwWPIg6tSarbkGWqmKFRhqq7c0TGmFAWLQBkIAr573VLPup04DLBS4iAnxiok/7dJteVJ0qCAAsy2iqj6XQBi627g6Dos0WEOmCrJeSVb90waJc+WbPIJXDEKLz7wCJBoOvU02WR7ogWbg3OgzDgItUUnsLCwF9KDhGgI6RvzeDxFRZlyWKkke6oA4lFvk3Hh7j/p2qSpYuwR1kVbRxrzVdEABaKQ6DBrNbyWIEOZ0BFGQRREunzkHW7NmzMXnyZJw+fRpGo/tJ+6hRo/Dtt9/6dXAEEWyowYNLUWzq6i6o9ciqph5Lxd2U2Lsuy3bsVwB1Nb2o2VlQxe0waK9Xr6xA6JMFVFOTVVw3d8GifHn5MLbMv4MjGhS3u6AeQh1qsjhSspoEPtLDxl0fBgAwMGpdFmCtoi6rxOaEKnBFhuhRUq62WnAHPKqSpapXnv9XlSy1N2C17oIA0CFV/jf+eq0mixVkFQ0Mo9V5EQTRMqnzlePIkSN49NFHK01v06YNcpWTE0G0VFTzC4GVFZu6NiPWirSrcBb0RFWd8ioFWddielFLkBWtOgy6zS9ceXVIF/QwvmhKd0EtXbDUw12wjkpWSZFS52Gou7EJ0XRowT3DwlVec2At2e0QWLkWi9IFmwYvG3e9HCx5ml9UZeOu1mOZDTwYUYLVKQdn4fGKgm2xQLTI21DrsAC3qlWxJsthE2BX0g8r0W8aMOcUcONEzV2QFeRzAhsS4vODLoIgmid1vnIYDAaUlFR2NTt16hRiY33ryVMfXn75ZQwcOBAhISGIVKxda0OSJCxcuBAJCQkwmUwYPnw4Tiv1KgTREKi9slyM/AS8rs2IS/Or75HliaZkna8YZB0HABh7+NaEuCjPCqddAK9na+33pClZBfWzcXeV2yEpykDApAtGykGf3erSnkT7QrFFvnkKD626ITQRmHgG984ajBMApSaLU5SsalJ3iYZFs3EvLAQ4HcAZPGzcGZRVEWQVKqmCkaE6lCrtMPRMGQxR0fK2cr0bEauoNu7qfJ2BgzFM/v6rTRlkGMCsrKfWZHkEWQRBtGzqfOX4y1/+ghdffBFOp/xkh2EYZGdnY968ebjrrrv8PkAVh8OBcePG4bHHHvN5neXLl2PNmjX4+9//jkOHDiE0NBTp6emw1aNBLEH4gpYuCPniXOd0wVqcBVVi25kBRg54VNMGyemE/cQJAL4rWWo9VmySuVrTCxV3rywPJasOQZbT6Q5IAiVdUG/iNZWiLuYXJXY5OIuIoCfVwQTLMuCUQ89ZQzNboEJNlp6CrKagZht3VB1klSmmFyF6lOTLtZPh3GUwoTEA3DVXOo9UQc+/nR4ZOWZfUgYVNCXLSUEWQRAydb5yrFy5EhaLBXFxcSgvL0dqaio6deoEs9mMl19+uSHGCABYsmQJnnrqKVx//fU+LS9JElavXo3nn38eo0ePRq9evfDhhx/i0uD5TCsAAINlSURBVKVL2LJlS4ONk2jZaOmCkmLnXktxfUW0mqyYmpUsvZFHlNKfSQ2U7L//DsnhABsWBl1Skk/7U+uxaksVBABzlNoryw6+HsYXLqV+gmGbVhlQ0wWFkmIwDOORMuhbXZYoSigT5O8nIkbfMIMkGgydTmlI66hZhaSarKaHi4oEoKQLAoA+DAalDtIoMSirQn32akScK68Xzl0GTKqSlQMA4ONbe62n1mRV3ZC45gcwkihBUB4isQ75HM5QjyyCaPHUuflHREQEdu3ahf379+Onn36CxWJBnz59MHz48IYYX705e/YscnNzvcYVERGBm2++GQcPHsS9995b5Xp2ux12jwarVaVGEkR1qAqNU+LBA3Vr1itKsBR4X9xronV7MwpzypB3rgQderVy98fq1g0M69tNoWrfXpvpBVBNTdYV32qyJJcLLlEek64J67EAd58ssVh+76GRBhRfKfe5Lqv0ajlEcGAFB8yx1Ig42OD1HGBzaW5w1SHa7RCVmixKF2wa1HRBobBQnmAI80gXrE7J8uiRdbkYABCuuwro5aDHrWQlVNoXYzBAstvhysuDPinJN4dBAC4PlZ5xkH07QRAy9e6weOutt+LWW2/151j8imrC0bq199Oq1q1b12jQ8eqrr2LJkiUNOjai+aJX0wUl5abM5YLkdILR1W7zbSm0QRQlsJxbXamJ1u3DceJgrmZ+UVfTC9HT9KIG+3YVtSbLWuIAE+1WsiRJqrXAW7Zvb3pnQcCjJkt5gKI1JPYxXbBQsW8PKc8DH57cACMkGhL5+HPBWXO2ICS7AyLb9EYtLRk+ysNdEKiQLli18YXaIysqRI+Si/JvPDzE7QLqrEbJYhgGfHxrOM9nw5mT4x1k1ZIuqNZjAQBjp0bEBEHI1DnIWrNmTZXTGYaB0WhEp06dMGTIEHBc7Rel+fPn47XXXqtxmePHj6Nr1651HWa9efbZZzF79mzt75KSEiT5mHpFEDqDYnzhcgcdos0GzocgS72Qm6ONYNnaa33iPGzcJUlyB1k9fAuyinKtcDlE8AYOkT401DWF6cDyDESXBBuvKF9OJ8TiYu2Jc3VInvbtxno/2/ELqpIl2e0Q7fY6OwxqQZb1Mrjwng0zSKLB4NVeduAgORxg9FWnfMo1WYq7IClZTYJak+Uq8giyGHeQVZOSFR2qQ0mBEwCD8FB3KrBLVbJax1daVxefAOf5bLguK72yamtIrG5TUUU5ngXK5YCODSGVmyBaOnW+21m1ahWuXLkCq9WKKOUEWFhYiJCQEISFhSEvLw8dO3ZERkZGrcHJnDlzMHny5BqX6dixY12HCACIV/KrL1++jIQEd1rA5cuXceONN1a7nsFggMFQu4pAEFWh1mQ5XZCdpyRJbkhsrj0dryTfN9MLlZg2YWB5BnarC8W5ZbDV1fRCSRWMTQrzKahjWAZhkQaU5NtgtYhgIyIgFhfDdeVKrUFWoPTIAgA2LEz7boTiYneQ5WOvrKJc+SYqxHoZnA/fKxFY6E3yAw+BM0AsLwdXXZBlt2tKFtVkNQ1eFu6AUpMln7eMEmqsyYoM0aGkWALAIDzCvZyqZHk2IlbRKepWRRv32oMsefu8noVoJSWLIAiZOl85XnnlFfTr1w+nT5/G1atXcfXqVZw6dQo333wz3njjDWRnZyM+Ph5PPfVUrduKjY1F165da3zpq7kA1kaHDh0QHx+P3bt3a9NKSkpw6NAhDBgwoF7bJIja0Gqy7AIYk2yO4KvDYMlV3+zbVTieRWySfJN/6ejvkKxWMCYT9B06+LR+ntaEuPZUQRV3Q2JbncwvxHIbRKVHVlMHWQzLaimDomdD4nooWep2iOBBVVIFVg+xBmMa0e6AQO6CTYq7JqtInuCRLlithbuiZEWwHJxO+XszR7jPOaqSxcdXDrJ4pU7LleMdZJWXOLxSAiuiKlm8joIsgiDc1PnK8fzzz2PVqlW47rrrtGmdOnXCihUr8Oyzz6Jt27ZYvnw5Dhw44NeBZmdnIzMzE9nZ2RAEAZmZmcjMzIRFaSoIAF27dsUXX3wBQE5ffPLJJ/HSSy9h69at+Pnnn/HAAw8gMTERY8aM8evYCEJFb3QHWayiiEo+BllqT5faGhF7oqYM5vwqP501du0KxodUXaBuzoIqbvMLO/hWvvfKksqtmpIVCPUtnEddVp3TBS/LSlYoKVlBiZouKHAGiNbqgywvd0FKF2wSVCVLKi+XH1bp3cYX1Vq4K0qWSRGmQ9l88OZIANU3IlbRlCwlXdAQymvHi6UGh0G3ksVBoiCLIAiFOqcL5uTkwOWqfGJzuVyaoURiYiJKS0uvfXQeLFy4EB988IH2d+/evQEAGRkZSEtLAwCcPHkSxcXF2jJz585FWVkZHnnkERQVFeHWW2/Fzp07YTT6fhNLEHVBfUrutLnAmIxAYd2VrNrs2z1p3c6MnwFcuWRDIupgeiGIyP9DVbLqEGRpDYltaK05DPqgZAWQ8QUgB1lOQE4XTHIbX9Rm4mGzOGGzyOc/k+OqplYSwYPqbimnC1qrXc6zJovSBZsGNjQU0OkApxNCURFYfaiXhXtuFemCqvGFrlyeF87ledi3V92IWIVX6rRcOfJDK4ZhYI42ojCnDKVXbdXWrmpKlp4jJYsgCI06XzmGDh2KRx99FD/++KM27ccff8Rjjz2GYcOGAQB+/vlndPAxZclXNm7cCEmSKr3UAAuQe2N51ngxDIMXX3wRubm5sNls+Oabb5CSkuLXcRGEJ2oA4bAJYI1KuqCPvbLUmiyzjzVZgFvJKrSZIDKsz0FWYa4VLqcInZFDZJzvNwNmpSFxaaG9TjbuorUcAqumCzb9DavaK8szXdDlEOEor9lyrvCyfANlsBXAEGqo1VWRCDx0mpKlr7GPneihZPEUZDUJDMOAi1SahxcWKkqWmi4IlNmcXsuLooQiRclCmfxbDucuAyFykOVU0gArNiJWUeu0VCUL8KjLKqz+YZnTsyarjIIsgiBk6nzleO+99xAdHY2bbrpJM4no27cvoqOj8d577wEAwsLCsHLlSr8PliACHZ1HuiBjVNIFfeiVJThFzUK8LkpWZFwI9CYOIsOjLDTRZ2dBtR4rNskMxgfTCxXvmqw6pAvaPIwvAiBdkA1XbtyKS8DrORhCZMWitobEhR6mF2w4pQoGI7xHkFVjTZbNAUl1F9Q1/THbUuEjPWzc9aEwKjVZDBiUW70fipTYnBAl+f/OEjkA82pEfFkOsirat2v7UhsSX70K0SGfCzSHwRps3NV6LS/jC2pGTBAtnjqnC8bHx2PXrl04ceIETp06BQDo0qULunTpoi0zdOhQ/42QIIIIzfiijkpWaYENkOSLtMlcu927CsMyaNVaj0vnylEa2REGj1rJmrhy3vcmxJ541WRdrxpf+KBklZdDUI0vjE1/w8pV7JUVaYDd6kJZsR3RidVbLxcpSpZcj0WmF8GIV7pgDTVZLrtbJaF0waZDs3EvLATiw8AxLnCME4Kkg7OC8lygmF6YDTzKFEfAcP4yEBIDwFPJ8m5ErO3LsyHx5ctKryxFva/BYZDSBQmCqIp6N6xR3f8IgnCjV/pkOe0CWKPvxhdaPVYrU51T0KL1FlwCB0vbXj41PQaAPK0JcR2DLEXJslmcQKR84yL46C4YUMYXEWqQJddwhkboUXCprFbzC68eWXGkZAUjWrogW3NNluBw38BTkNV0eNm4J4cBAPS8DeVOHQSbd02WanoRGapDSb5yTvVMF6xFyfJsSOzKzZWDLF+ULM1dkIIsgiDc1DnIEgQBGzduxO7du5GXlwdRFL3m79mzx2+DI4hgQ1VpHHYXGKPvFu4l9XAWVAkvzQbQAaVhvjXNFgQR+RfklJu45LqpMYYQHryehcshwmaIBAC48nxRsqwBZXyhWbgXK0qWauNeXHOQpSpZIdbLYM3tG26ARIOhHn9iLTVZTrt8bWMZyac+ckTD4GXjrpf7ZhrYcpTDDMFeIcgqk9XHGJMOpeeU9GvuMmBS1LBalCxAblLsPJ8Np2L1bo6Wz+M1K1nyOHTUJ4sgCA/qHGT9z//8DzZu3Ig///nP6NmzJxV+E4QH2g2cSwIU5zlflKxStUdWHeqxVEKyMwFdB5S4QuG0C7UGMYU5ZRCcIvQmHhGxddsfwzAIizKi6LIVNk5WcoTiYogOB9gaetpJ5YHmLqjUZHmkCwI112QJLhHFV+TvKaT8Mrjw6xt4lERDwCvGK65a0gUFhwvgAZZErCaFi4oE4K7JAqA5DEoVgiy1EXEcr4MkOsHBgVC2sJKSpatGyQI8zC+UpsVqumBZoR2iWHXArQZZnEe6IENBFkG0eOocZG3atAmffPIJRo0a1RDjIYigxrPeSDDINwRiuS/pgoqSVQdnQUB21GSOHYW+61A4DJG4kl2KxM6RNa6jmV4kh9XJ9EIlLMqAostWWB2821756lWwCdU/HZZrsuRUn4AIsiIq12QBNffKKr5SDkmUwDECDPYisFSTFZSoNVkiZ6ixXtLlEAAe8LHtHNFA8J7pgkqQpZpfwCl5BT5qI+JWjPylmbk8+RxnkB+qqEoWX4OSpdm4K0pWSIQBLMtAFCWUFdk1t0FPXE61JouULIIg3NT5GZ1er0enTp0aYiwEEfRwHKs1LhWUGwLJXpd0wbopS66cHAiFhQi3ZAMA8hRDi5pQmxDXNVVQJUy5ySgrsoOPkeuyarNxFz3cBQOiJktNF9RqsmpPF1RTBc1cGRgAHLkLBiU6L3fB6muyXC7lxpmnbI2mxJ0uWAjo5d+cAfJ5zigxsDrdapbaIytCkL8zLVWQZeVGxGWyAlaTksVrDYmVnlosoxn+VJcy6K7J8gyyqjfQIQiiZVDnIGvOnDl44403IElSQ4yHIIIeVc0SDKq7YB3SBeuoZNmOHQMgm18AwOVztQdZaiBWV9MLlTDPXlk+2rhLnn2yAsBd0NPCHfBNyVLt28NEOTBjzRRkBSOahTtbc02W4JSvcRxHQVZTorkLFnmkC0L+DRoloMzuNihRlaxQl/zdhfMejYiVBsNsRESNKpNar6WqXoBHr6xqzC/UdEGeA+CSx0MW7gRB1DldcP/+/cjIyMCOHTvQo0cP6Cq4mX3++ed+GxxBBCM6AwebxQmRU40varZwd9hcKC9Verq0qpuSpQZZsYlGnCoF8moJsgSXiKsX5WChrvbtKma1V1aBZ0PimoMs0WYLqD5ZldMF5QDQWuyAJEpVplEWKc6CoY6r8jbCKV0wGPHVwl1QlCxOR0FWU6K5CxYWudMFPZQsi90FVZdSa7L0NglOAOFcrrseS0n/07WuXsUC3CpXVQ2JLdU0JFaDLFZyB3ysqe71tQRBNC/qHGRFRkZi7NixDTEWgmgW6BWlxqUzggMg2Wp2rFOfjhpCeBhMdftJ2n6Vg6z4HonAf+W0w3KLA6awqk0oCi6VQXCJMITwdQ7oVFQly1JocwdZtfTK8kwXDIiaLCVAkmw2iA4HTOF6gAFEUUK5xYmQ8MqfX6HqLFgm33yRkhWcuNMFa67JEhQ1RE3/JZoGroqaLNX4wlCNksWWydPCObeSpRpZ8IqxRXVoDYnz8zVDn7BabNy1mizI+2WMRjBUzAdBEOB0OmtfkCACDJ1OB84Pv+E6B1kbNmy45p0SRHPGfRMnB1m1KVmq6YW5HvbtqpIV3qsbIs/aUXTZirxzpWjXM6bK5bVUwWRzvZ1B1V5ZlkI7+A6qklVzkCVZyyEYlXTBAAiyWLMZYBhAkiAWF4OPjUWIWQ9riQNlRfZKQZYkSVqPLFPJBQCkZAUrnhbuQk01WUqpD6+nIKspUWuypPJyiA4XWM6gBVlGiUGZ3bMmSw6yBIsaZOUCIXKDdpemZNUcZHFRUWD0ekgOB1x5edC3betOF6y2JktRskQ5oGjpKpYkScjNzUVRUVFTD4Ug6k1kZCTi4+OvyUW93s2ICYKoGp1R/lkJrJxKK9VSk1Xq0Yi4Ljjz8uTghmVh7NoFcVlnUXTZisvnSqoNsq4oTYjrmyoIQCsCd5S7IEXFAai9Jkuw2SCGBo7xBcOyYM1miCUlEEpKwMfGIjTSIAdZxXbEwvvzKS91wlHuAhjAWCCbjHCkZAUlvEeQ77JW/5RdUIMsXdMfry0ZNjTU7WJaVATWEAZDmVyDapAYbyXL6oROAlxWDyUrxFvJ0tWiZMkNiePhzFYaErdtW2tDYtX4ghMVJa2FOwuqAVZcXBxCQkKo1Q8RVEiSBKvViry8PABAQg3OybVRryDrs88+wyeffILs7Gw4HN59ZX744Yd6D4YgmgPqk3IXIwcVYi3ugvVtRGw/fhwAoO/YAWxICFq3D8epQ5drrMty27fXX4XRG3noTTwc5S7YQuRgTqilJstpc9/MBoLxBSArUWJJidv8IkKPK6ja/EI1vQiPMQIlhQDcDY2J4ILXuZUpp81V7XKifN8MLgAeCrRkGIYBHxkJ15UrEIqKoNOHwqBYuBsloMwhf4eiKKHI6kC0KN/QG3R2GFir2/hCUbL4WpQsANApQZZTMb9Q61BLC2xy24wKQYNTVbJcDoho2UGWIAhagBUTU/XDPoIIdEyKGp2Xl4e4uLh6pw7WOQ9izZo1mDJlClq3bo0ff/wR/fv3R0xMDH7//Xf86U9/qtcgCKI5odfcy+RnGLUpWSX59VOyyn/9FQBg7N4dABDXXr7pzztfUqX7p+AUcfWifHNyLUoW4K7LsuuU/jO1KFkuu6j93/MmtylR0/0E1ca9BodBNVUwMtaoSRykZAUnDMOAVx4vqjfHFZEkCYJys84bKOGjqfG2cQ+DgamcLlhic0KUgEjle4swyL9rt5KlNCKuRckC3DbuLsXGXVXvXQ4RtrLK6qeg1GSxgnzuaMlBllqDFdKCPwOieaAew9dSV1jnu51169bh7bffxptvvgm9Xo+5c+di165dmDVrFoqLi+s9EIJoLqjpgi5J/le01RJk1bMmS63HUoOsVm3DwHIMykudVaa1XL1kgShIMITy9ar/8kStyypn5EJ015UrNbZ1UG9mdTomYFJH2Ai1V1YFG/diR6VlVWfBiAjllMnzYFp43UUwo1McA50Oscr5ksMBUUn35fUUZDU1mo17oWzj7qlkWRSVvEAxvYhj5O/LrJNdQN1KltKI2BclS1lGdSTkdZxWp1nVuVVTspzyPLJvR8Cc5wmivvjjGK5zkJWdnY2BAwcCkOW00lI5/WjSpEn4+OOPr3lABBHsaOmCSpAl1RBkSZKEUlXJqmMj4opBFq/jENMmDEDV/bLUVMG4duHXfPIwK092rU6l7szhgKicC6pCfRAUSCYCXMVeWRE1KFmKs2B4mFJ7Ya6/cQjR9Kh1gS57NUqW3e4OskjJanIq2rirQRYLBmWKsqSaXsSy8ncbwck1WAiJhlBa6lMjYhXVgVCt4wLcD8GqMr9Qa7JYh3wuZ0jFIQgC9Qiy4uPjUVBQAABITk7Gf//7XwDA2bNnqUExQcBdc+SS5J9XTUqW3eqCwybf6NWlEbGrsBCuS/INgLFbN216ay1lsHLAc0VxFoxLvvY0N1XJKit1aVbm1aUMSpKk2WEHgrOgSrXpgsWVg6yiy0pNltHptS4RnOgM8m/TWU1JlmS3Q+CUIMtIQVZTw0VFAlBt3MPAwwEwcmBjVYMs5d8oSX74YZZkF1CYojUVq7ZGxCo6xcZdreMCPHplFVQ+P2jugnY5yGrJ6YIEQbipc5A1bNgwbN26FQAwZcoUPPXUUxgxYgTGjx9P/bMIAu5AwinIPy+phl48auqJKVxfpya9qoqla5fsVRuk1WVVpWQpzoKx11iPBbhrFCyFHg2J86q2cZfsdgisat8eODesXKV0QXmMFZUsl0PQUjrDODnYItOL4EZVpwSJhSRUVrNEuwOiUlPJkbtgk1OxJothAJ6XI2S74iSoNiIOcyk1WdJZeeWQaHc9VnztqYIAwCsNi9X1AHeQVTFdUJIkrU8WY1fODxRkERXYu3cvGIap9jV06NCmHiLRANT5juftt9+GqNguPf7444iJicF3332Hv/zlL3j00Uf9PkCCCDa0ZsSCfLEX7dU3I9ZML+pZj2Xq0cNrelx7OYDKyy6FKEpgWXkMLqeAgovyDUBcu2sPELx6ZcXGwnH2bLVKllju0Yi4js2WGxK2mnTB8lInBJeoNaEtyisHJLlZtN5RBIBML4IdvUlWqQRWbkjMhYV5zZccHumCAWLU0pLhtXTBQq0hMc854HLqYbeqSpZD/p0qJjtmVgmQTO4gi/chVRAAdIpls5CfD8nhAKPXV5suKLhEQEniYbUgK7Q+b5NoxgwcOBA5OTmVpm/duhXTp0/HjBkzmmBURENT56sHy7LgefeN0r333os1a9bgiSeegF6vr2FNgmgZqGqNmook2WzVptJq9u11dBasWI+lEhUfCp2Bg8suoDCnTJt+9UIZRFGCyazTnAGvBXUblgIbuBhFycqvRskqL4fABU4jYhV3uqAcZBnDdGA5OSi1lrjNL1T79sjWIVrdGSlZwY1ODbI4A0Rr5YbEnjVZarBNNB1aTVZRkRZk6Xn5N+osl0+0hVYnQiWAFeU+42YuH9CHAbwerhxVyfKt343akBgAnIpCX11DYpeHeQpTrtSKkZJFVECv1yM+Pt7rVVhYiKeffhoLFizAuHHjAAD79u1D//79YTAYkJCQgPnz58Plcuc1p6WlYdasWZg7dy6io6MRHx+PxYsXe+2rqKgI06ZNQ2xsLMLDwzFs2DBkZWVp87OysjB06FCYzWaEh4fjpptuwvfff98on0NLo16PlYuKinD48GHk5eVpqpbKAw884JeBEUSwotVkOd2BlWS3gzFWVqtKrtZTyfq16iCLZRnEtTPj4qkiXD5XohlhXMmWA4nYZP8YNqhBlsspQlScuAQflKxAaESsoqYLqjVZDMMgNMKA0gIbyors2k1VkWJ6ERUfArFU/hxJyQpu1ONQ4PRVpvN6GV8EkFlLS0VNF3QVFQL6FACAgZeDHZdS01pY5kCEKH9XoWYGHONy27dfVoMs35Qs74bEOdC3bYOwatIFtXoslgHKKV2Q8I2ioiKMHj0aaWlpWLp0KQDg4sWLGDVqFCZPnowPP/wQJ06cwMMPPwyj0egVSH3wwQeYPXs2Dh06hIMHD2Ly5MkYNGgQRowYAQAYN24cTCYTduzYgYiICKxfvx633XYbTp06hejoaNx3333o3bs33nrrLXAch8zMTOh0uqb4GJo9dQ6y/u///g/33XcfLBYLwsO9XcoYhqEgi2jxaDVZHk84xfJysFUFWfl1t28XSkrgzM4GABg8TC9U4tqF4+KpIuSdK0H3QYkAvJ0F/QGv42Ay61Be6oTdHAdAtnGvCrHcBoFV0gUDpBEx4FajxGJ3/VpopF4LslTUHllR8aEQMlUli4KsYEY9DgVOD7GKIEuuySIlK1Dwchc0yA+OjJz8vUlKemCB1YEItUdWuAC44LZvz1HTBX1TsgBA17q13JBYMb9Qz9G2MiecdsHtIquc53k9q6miFGQRNSGKIiZOnAie5/HRRx9p99Hr1q1DUlIS1q5dC4Zh0LVrV1y6dAnz5s3DwoULwbLyuahXr15YtGgRAKBz585Yu3Ytdu/ejREjRmD//v2aCGIwyNfdFStWYMuWLfjss8/wyCOPIDs7G8888wy6du2qbYNoGOp89ZgzZw4eeughWCwWFBUVobCwUHuproME0ZJRa7KcdhFQng5VZ+NeqipZdUgXtB0/AQDQJSZqtQqeqOYXnjbumumFH5wFVdS6LLspBgDgulKNu2C51V2TFUhKllqT5WE9r9m4ezgMqkpWZOsQCJqSRemCwYxOU7IMEK1VKFkOu2Z8QTVZTQ9XRU2WkZV/l5LDU8lSnAVDlfOtpmTJgZKvShYA8KrDoKKCGUw89EpNqaea5XLK++f1HCQ1yKI+WUQNLFiwAAcPHsSXX34Js0dWxPHjxzFgwAAv8WLQoEGwWCy4cOGCNq1Xr15e20tISEBeXh4AORXQYrEgJiYGYWFh2uvs2bM4c+YMAGD27NmYNm0ahg8fjmXLlmnTCf9T56vHxYsXMWvWLOrmTRDVoNZkOeyCpl5VZeMuSZJ2sQ6vg327Vo/Vo3uV81t3kAOAgotlcDkEuBwCCi6pphf+DLLkgMTGyfur1vjCZgvMmqwI75oswMPGvUiu95BESavJiooPgVhCSlZzQD0OBc4AsbzqmizVEZPcBZseLlIOsiSbDaIkfy9GTq5/YpS07EKrA5GqkmWS58EULbv/KYYDvI/ugoDbidCZU4XDoEddlpeSVUZKFlEzmzZtwooVK7Bp06Z6K0gVU/sYhtFKdywWCxISEpCZmen1OnnyJJ555hkAwOLFi/Hrr7/iz3/+M/bs2YPu3bvjiy++uLY3RlRJnYOs9PR0KpAjiBrQ0kjsAhijrFBVpWRZSxxwOUUwDLR8f1+ozvRCJSzKAFO4HqIoIf+CBfkXLJBECaZwvRZE+ANVySqH/G+1QZbVoyYrkIIsJV1QslohKd2SK/bKshTZ4XKIYFkG4bEmUrKaCWqdlcBWXZMl2knJCiTY0BAtK0BQTqUmRnngodinF1qdiFAcXc36QnmhkGiIFouWxuerhTvgdiJUlSyg6obETodbyaJ0QaImMjMzMXXqVCxbtgzp6emV5nfr1g0HDx70Mso6cOAAzGYz2rZt69M++vTpg9zcXPA8j06dOnm9WintVgAgJSUFTz31FL7++mv89a9/xYYNG679DRKV8KkmS+2LBQB//vOf8cwzz+DYsWO4/vrrK0XUf/nLX/w7QoIIMvQedUeiyQwgD2J55SBLVbFCowzgON9v5GoLshiGQet2Zpz7+Souny3RHPPi/GR6oaIqWVaH0nOooACS0wmmwjlBsgWmuyDrkaYhlJSAj4lBaIR3ryw1VTA81gSOYzUliyMlK6hR1WaRM1RZkyV51mRRkNXkMAwDPjISritXIJRL0AEwQTas4QVAECUUWR2IEOVzUgQvp07BFA2nomJxERFgTb6nZfuqZAmqkqWjmiyievLz8zFmzBikpaXh/vvvR65HDzYA4DgOM2bMwOrVq/HEE09g5syZOHnyJBYtWoTZs2dr9Vi1MXz4cAwYMABjxozB8uXLkZKSgkuXLmHbtm0YO3YsevTogWeeeQZ33303OnTogAsXLuDIkSO46667GuJtt3h8CrLGjBlTadqLL75YaRrDMBCqaOxIEC0JTseCYQBJkoMsBoBkrxxkuXtk+X7hF61WOH7/HQBgrNAjy5O49uE49/NV5J13B1n+aELsidqQ2FomARwHCAJcBQXQtfaue/DqkxVANVkMx4ENC4NosUAoVoIsLV1QDrLcphfyTZNav8WSkhXU6AyKksXpa6jJoj5ZgQQXFaUEWfI9hhGyWmWQgNwSGyAC4ZJ8rgtnL8orhUTDpdRj1SVV0HN55+UqgqyrpGQRdWPbtm04f/48zp8/j4SEygYs7dq1w7lz57B9+3Y888wzuOGGGxAdHY2pU6fi+eef93k/DMNg+/bteO655zBlyhRcuXIF8fHxGDJkCFq3bg2O43D16lU88MADuHz5Mlq1aoW//vWvWLJkiT/fLqHgU5BV0aadIIjqYRgGOiMPR7kLgskMHqhSydJ6ZNXBWdB24gQgSeDj4sB7SP8Vae1hfqG6o/nLWVBFa0hcZAcfEwNXXh5cV/KrCLJs7iArgNwFATllULRYICo27u50Qbkmq8ijRxYAiEr9FilZwQ2vr70mS2RlFztSsgIDzca9TP5tGkXZaMsoMfijwIpwkQEDBryehcl5SV7JFA3neVnJqkuqoOfyQv7VSg2JLVXWZFGQRVTPgw8+iAcffLDW5VJTU3H48OFq5+/du7fStC1btnj9bTabsWbNGqxZs6bKbXz88ce1joPwD3T1IIgGQE2LEw2yE5Zkq/y0XHUWNNfFWbCa/lgVUQOq4rxyrSlxnB+dBQGPhsSFdnBKwOe6kldpObHcqpkIBJKSBQBshOIwqARPqrugo9wFp11AoUePLEmSSMlqJriNL6qryXJoNVkUZAUGmsNgmawyG8SrAOQg60JhuWZ6Ed7KBKZccToOiYIrt35KFhcVJac+S5LWkFhV772NLxQli2cg2eWxMRRkEQSBOgRZqgNJiYcTl0pxcTF69OiBb7/91q+DI4hgRa3LEgyKAmKzV1qm5FqcBWsJsoxhOoTHKqYbEhAS4V/TC0BRfRhAFCQIsUkAqja/kDyUrEAyvgDc5heC0itLb+K1G/CyIrtHI+JQ2Z5ZSYcmJSu40YIsthoLdzulCwYaXFQkAEAolb8vg1KTZZCACwVlmn17eIwR0IKsGDiV2hddQt2CLIZlK9m4q+mCZUV2CIKsYLkU4w2Oc5sVsKGhddoXQRDNE5+vHqtXr8bDDz+M8PDKT3AjIiLw6KOPYtWqVX4dHEEEK5qSpfR0EatQsupTk1Wbfbsnasog4P9UQQDgOBah4bJC5YiUc8yFKoIsuSYr8IwvAI8gS0kXBNwpg0WXrbAUysGx3CNL6ael04GporE0ETx4W7hXU5PFqUFWYB2zLRU1XVAolR98GBnZpp0Hgwv55e4gq5UJsCpBlikaLiXI4lvXLcgCoKU+q4FaiFkPjmchSUCZcm5QlSyOUcoqeL6S+Q9BEC0Tn4OsrKwsjBw5str5t99+O44ePeqXQRFEsKPWHgk6RU2qUJMlihIsBfJF2lclS7TbYf/tNwC1K1mAd5DlzybEnqjW8/awWABVNyQWbYFpfAEArNIrS/TslaU4DF44JRfWm8w6GEN1WkohZ/avSyPR+LhrsvRV1mS5bHZIjLwMpQsGBmrjdaGoGOCN0DHlkCCrR5evWt1BViQLCErmQEh0vZUsAOAVgwI1UGNYxp0yqGQiaDVZkIMtNiSEzg8EQQCoQ5B1+fLlSnbtnvA8jytXrvhlUAQR7KgW0QKvNCOu4C5oKbRBFCWwHKPVAdWG/dQpQBDARUX5VF/g2XjYn02IPVHrsux6+QbIVcU5QPLokxV4SpZSk1VcuSHxxZNykKWZXihKFmemVMFgp7aaLMHm0v5PQVZgoNVkFRUC+lAwDCAqKXpXC2yIFOXvKdws97wDq4OkC9WCLL6CIY8v6OJVJeuyNq2ijbuqZLGQjxkyvSAIQsXnq0ebNm3wyy+/VDv/p59+qtKWkiBaItpNnBJkVVSy1Keg5mgjGNa3p56a6UWPHj49KW2VbAZv4MByTIOkCwJuh0EbJwceVdVkCZ7uggEXZKnpgp5KljzW/AtyOlJUfKjXMmwVKdNEcKEehxKrg8ta2fnTZXcHWTxPQVYgoAZZrqIiQEnDBi8HOKWldreSFaIok0ojYqkejYhV1BRDl0dPo4oNibWaLImCLIIgvPH56jFq1Ci88MILsNkqX5DKy8uxaNEi3HHHHX4dHEEEK5rxBSvfsIsVfjeafXtdTC9+/RWAb6mCgJya95dZN+LOJ25AiFI75W+0hsRKE9CqgiyXzQYw8qkm4IKsiOprspRMJK1HFilZzQfPtFVnubPSfJdDuWFmJJ8fghANi1aTVVgE6BV7fSXIMgsMTEqPLLNB+S2b3KmCdW1ErKKmGDo9g6xqlCxOko8jCrIIglDxqU8WADz//PP4/PPPkZKSgpkzZ6JLly4AgBMnTuBvf/sbBEHAc88912ADJYhgQg0mXIp1uVQxyKqPfbuPzoKeJFwX4fOy9UFVsqx25f3m50OSJC+lzWUTACVuCTR3QVWVEqtIF1RR0wWFklKvdYjgheUZrWG40yM1UEW7cWalSvOIpkFLFywsBPRyywiOc0EA0FqQH+KwJg56QXnQE+JhelHPLJsalawKNVmcIPfvoiCLIAgVn4Os1q1b47vvvsNjjz2GZ599FpIkX3wYhkF6ejr+9re/oXU9cp4JojmiMyo1WYxcx1hRySqtYyNiyeGQa7Lgm7NgY6EWgZeVyTcaUnk5xLIycGFh2jJOu3LDygFsgKkCWk1WFcYXKm4ly218QQQ3DMOA5wGn061aeSI4RICXj1kiMOAi5SBLstkgMiawAPQ6J8oBxLnk84ox0uDhLBjlNr2o572JWpPlys93NySOqqYmi4IsgiAq4HOQBQDt2rXD9u3bUVhYiN9++w2SJKFz586IUp4wEQQhoylZyk+sYjNiVckK91HJsp85A8npBGs2Q9e2rR9Hem2oNxzWYgcQagbKSuG6csU7yFLdt/jACrAAz3TBqpUslmdgViz23UoWBVnNAZ2OgdMpwWkXK81zOQUlyAq8Y7alwoaGADod4HRCcBnAAjDwDpTDrWSZY4zuICskGq5zqpJV93osAOCio8HodJCcTriuXIGuTRtNybIU2CGJklaTxTrloIuCLILwZu/evRg6dCgKCwsRqaT9thTqVdEbFRWFfv36oX///hRgEUQVqDVZapBVsRmxVpPlY48sz1TBQLIHNoXrwbIMJAkQWrcDULlXlppOo9MHzrhVOC1d0F2TFeKhZEXGhWjqm6ApWZQu2BxQbdydjsopgYJLSQELwAcDLRWGYcCrdVlO+Tdq1MnnVQPk7ykqzlShEbHsClgf0wtAaUis9sq6LG8rNMoAhpGPEWupw61kqUFWKAVZwcjevXvBMEy1r6FDhzb1EAEAGRkZGDVqFGJiYhASEoLu3btjzpw5uHjxot/2ce7cOTAMg8zMTL9tszbat29f5ee+bNkyv2x/8eLFuPHGG/2yrbpAtkkE0QCofbJcovyv7dgxWJU+coJTRFmxfHNg9jFdUHMWrEM9VmPAsoym/DhaJQGobOPudMo3sXyA9cgCADZCThcUrVZITrlwnddxMIbKaZ5qqiAAiKRkNSs0tdlVOcjSHOMoyAooNIdBh/zdmXjvDIHY+LAKjYhzAMCnlhfVoQZozhx5WxzHaue80gKbptSzTnkspGQFJwMHDkROTk6l1/r168EwDGbMmNHUQ8T69esxfPhwxMfHY/PmzTh27Bj+/ve/o7i4GCtXrmz08TgcDr9u78UXX6z0+T/xxBN+3UdjQ0EWQTQAWp8sQyj4+HgIV6/i/P2TkPvKKyi+VAhIAK9nYTJX33vOE03J6tGjwcZcX9S6LGeE0rizopIlP+gNOGdBwLu+SlDcAwEgNFJ+Uq7at8vzSclqTmgPQlyAJHqnDApK4BWIKa4tGc38wiHfupg470bS0V5KVvQ1K1mAO0BzVdUr66pNU7IYuxxkMRRkBSV6vR7x8fFer8LCQjz99NNYsGABxo0bpy27b98+9O/fHwaDAQkJCZg/fz5cLndtZ1paGmbNmoW5c+ciOjoa8fHxWLx4sdf+ioqKMG3aNMTGxiI8PBzDhg1DVlZWteO7cOECZs2ahVmzZuH9999HWloa2rdvjyFDhuDdd9/FwoULtWX379+PwYMHw2QyISkpCbNmzUJZWZk2v3379njllVfw0EMPwWw2Izk5GW+//bY2v0OHDgCA3r17g2EYpKWlAQAmT56MMWPG4OWXX0ZiYqJmgPePf/wDffv2hdlsRnx8PCZOnIi8vLw6fwfq+p6v0FClhYogYOrUqejQoQNMJhO6dOmCN954w2v9vXv3on///ggNDUVkZCQGDRqE8+fPY+PGjViyZAmysrI0hWzjxo11Hl99oCCLIBoAvfqUXGDQceuXiLjrr4AkofDDf+DUrAUA5HosX1L/JJcLthMnAASekgW4HQbtIbLjl+uKO8iSnE4ISsqkzuRbQNmYMDwPVj2Je6QMqo6CsUnuIExVsjhSspoFOqN8PAqcvpL7pxpkcbrAezDQktFs3JWvK7RCkBXeyqQpWZLRw/jimpQsNV3Q7TAYFu2uy9JqsuzyWEjJqowkSbA6XI3+Ug3a6kNRURFGjx6NtLQ0LF26VJt+8eJFjBo1Cv369UNWVhbeeustvPfee3jppZe81v/ggw8QGhqKQ4cOYfny5XjxxRexa9cubf64ceOQl5eHHTt24OjRo+jTpw9uu+02FBQUVDmeTz/9FA6HA3Pnzq1yvlrrdObMGYwcORJ33XUXfvrpJ/zrX//C/v37MXPmTK/lV65cib59++LHH3/EjBkz8Nhjj+HkyZMAgMOHDwMAvvnmG+Tk5ODzzz/X1tu9ezdOnjyJXbt24d///jcAwOl0YunSpcjKysKWLVtw7tw5TJ482YdP2XdEUUTbtm3x6aef4tixY1i4cCEWLFiATz75BADgcrkwZswYpKam4qeffsLBgwfxyCOPgGEYjB8/HnPmzEGPHj00hWz8+PF+HV911Mn4giAI31CfkjvtArjwcCS+/DLCR45EzgsLYSkRgQRAX/AHxLKe2k1+dTjOnoVks4ENCYG+fbvGGH6dUHtl2fRy6p2nkiXaPBoRGwPzdMNGhEMsK4PoYX4xeHwKOt3UGu1vaKVNU5UulpSsZoEa9AucAWJ5udfNsaAIW7yenkMGElxUJABAKBcBExDCudVnEcq5SFGyRMmkNSLmr8H5mI9XFPqcqhsSa0qWzQIJFGRVRblTQPeFXzX6fo+9mI4Qfd2vO6IoYuLEieB5Hh999JHXw9B169YhKSkJa9euBcMw6Nq1Ky5duoR58+Zh4cKFYFn5nNGrVy8sWrQIANC5c2esXbsWu3fvxogRI7B//34cPnwYeXl5MBjk6+OKFSuwZcsWfPbZZ3jkkUcqjen06dMIDw9HQi3tCF599VXcd999ePLJJ7V9r1mzBqmpqXjrrbdgNMrH7qhRo7QUyHnz5mHVqlXIyMhAly5dEBsbCwCIiYlBfIUHFKGhoXj33Xeh17trlx966CHt/x07dsSaNWvQr18/WCwWhHmYYNXGvHnz8Pzzz3tN27FjBwYPHgydToclS5Zo0zt06ICDBw/ik08+wT333IOSkhIUFxfjjjvuwHXXXQcA6Natm7Z8WFgYeJ6v9H4aGrqCEEQDoKbGqfblABA2eDA6/t9WSDcOAgDwv/2E30ePQdl/D9W4LTVV0NCtGxg28H6yqpJlY+SbC8+aLNFaDkHpFRaIShZQnY27AZ1uivOynFeDMFKymgdaSq8SZHkiCPL3zgVgHWFLRksXtMrn1VDWHWQ5DAxYjgWshQAAZ4mcvsVFRtarEbGKW8mqIl2wwKYZ+7A25SFMSM0PzYjAZ8GCBTh48CC+/PJLmCu07Dh+/DgGDBjgFXgNGjQIFosFFy5c0Kb16tXLa72EhAQthS4rKwsWiwUxMTEICwvTXmfPnsWZM2eqHFPF/pPVkZWVhY0bN3ptNz09HaIo4uzZs1WOj2EYxMfH+5Tid/3113sFWABw9OhR3HnnnUhOTobZbEZqaioAIDs7u9btefLMM88gMzPT69W3b19t/t/+9jfcdNNNiI2NRVhYGN5++21tH9HR0Zg8eTLS09Nx55134o033kCOUkfZlATmo2WCCHLUGziHTfA6OXJmM8TufYGjeQjVO+D87QKyJ09G5IR7ETfnaXBhlS/Q9WlC3JioSpbVJf/rqWRJtnK3khWANVmA22FQ8GhIXBFJkkjJamaox6PA6SFavdPO3EoWXSIDCc1d0OoEYoAQplCbJ4ZwgOAC7HLar0sxF7oW0wvAoyGxxw2bqmQV51khiUrPUKsFAClZVWHScTj2YnqT7LeubNq0CStWrMC2bdvQuXPneu9bp/N+qMgwDESl9tNisSAhIQF79+6ttF51FucpKSkoLi5GTk5OjWqWxWLBo48+ilmzZlWal5yc7NP4aiK0QuZNWVkZ0tPTkZ6ejo8++gixsbHIzs5Genp6nY0xWrVqhU6dOlU5b9OmTXj66aexcuVKDBgwAGazGa+//joOHXI/pN6wYQNmzZqFnTt34l//+heef/557Nq1C7fcckudxuFP6ApCEA2AauEuiRIElwje42RfclUuKGj/zOMI/cqIok3/QtHHm1C271skvPwSQgcM8NpWoDoLqqhPda02OZD0ShcsD4IgS+uVVVztMpLVCghKU2VSspoFvBZkGSB5KFmSJEGQ5GM5EB0xWzKakmWRA6hQyR1ksWE6oNz9t7NADnqupR4LAHRKjy1Xfj4kpxOMTqf1ByzO81BArfJDGgqyKsMwTL3S9hqbzMxMTJ06FcuWLUN6etVBYbdu3bB582avh6cHDhyA2WxGWx97WPbp0we5ubngeR7t27f3aZ27774b8+fPx/Lly7Fq1apK84uKihAZGYk+ffrg2LFj1QYrvqAqVYIg1LIkcOLECVy9ehXLli1DUpLsMPz999/Xe9/VceDAAQwcONDL5bEq1a93797o3bs3nn32WQwYMAD/7//9P9xyyy3Q6/U+vR9/E3i5RwTRDOA9AgqnzfuHXao0Io5oG4mExYuRvHEDdG3awHnpErKnPIScRYshWOQbBEkUYTt+HEDgBlmqklVuFSEyPISCAkjKycwryArQG1ZW7ZVVUr2SpTkP6nRgjL7Z7hOBjU6ptxJZ73RByemEqKS4cobATHFtqWgW7qXy92WSCiFBVpIMkXrAelVe0BgBp5L6xMfXvx4LkBsSQ6cDJElLhVaVLFFVsRiAKVOULOqTFZTk5+djzJgxSEtLw/3334/c3Fyv1xXlu58xYwb++OMPPPHEEzhx4gS+/PJLLFq0CLNnz9bqsWpj+PDhGDBgAMaMGYOvv/4a586dw3fffYfnnnuu2gAlKSkJq1atwhtvvIGpU6di3759OH/+PA4cOIBHH31UM+eYN28evvvuO8ycOROZmZk4ffo0vvzyy0rGFzURFxcHk8mEnTt34vLlyygurv4BZHJyMvR6Pd588038/vvv2Lp1q5dRSF0oLS2t9LmXKNflzp074/vvv8dXX32FU6dO4YUXXsCRI0e0dc+ePYtnn30WBw8exPnz5/H111/j9OnTWl1W+/btcfbsWWRmZiI/Px92u73KMfgbCrIIogFgWUYrmvesy3LYXCgvlfsxhbeS6wRCb7kFHbd+iaiJEwEARf/6F36/8y+w7D8AZ3Y2xLIyMAYDDNd1bOR34RvGMB04nfxe7aYoQBThuirf7Ejl5RA4pSbLGJhBllaTVUO6oFqvxZnNAdUMmqg/7posPUSrR5Blt0NkFUfMADVraalwkaqSpTj5ucqg3iqFRhvd9u2maM1yXRdfs1FAbTAsC53akFh1KzS4e+kBsuKpmmyQkhWcbNu2DefPn8f27duRkJBQ6dWvXz8AQJs2bbB9+3YcPnwYN9xwA6ZPn46pU6dWMmyoCYZhsH37dgwZMgRTpkxBSkoK7r33Xpw/fx6tazBpmTFjBr7++mtcvHgRY8eORdeuXTFt2jSEh4fj6aefBiDXWu3btw+nTp3C4MGD0bt3byxcuBCJiYk+j4/neaxZswbr169HYmIiRo8eXe2ysbGx2LhxIz799FN0794dy5Ytw4oVK3zelycLFy6s9LmrboqPPvoo/vrXv2L8+PG4+eabcfXqVS9VKyQkBCdOnMBdd92FlJQUPPLII3j88cfx6KOPAgDuuusujBw5EkOHDkVsbCw+/vjjeo2xrtAVhCAaCJ2Rh8vhgMNDySpVUgUNITwMJvfPjw0NRfzCF2BOT0fOc8/BeeEC/pg2DcaePeXlu3YBwwfmz5VhGIRFGlB8pRyO2GSYzl+BkJ8PXVycl7tgoKZe+ZIuKCpKFmemVMHmgs4gPxgQOD3EcndNlhxkyTfQpGQFFpq7YLH8e2QcFlh4CUYXg6iEEMCqFPaHxMCpNSK+NiVL3YbzwgW4cr0dBm1lSgNzPavV9VGQFZw8+OCDePDBB31aNjU1VbM5r4qqaq22bNni9bfZbMaaNWuwZs2augwTw4cPx/Dhw2tcpl+/fvj666+rnX/u3LlK0zIzM73+njZtGqZNm+Y1rbreUhMmTMCECRO8pnna56elpdVqp1/VmDwxGAzYsGEDNmzY4DX91VdfBQC0bt0aX3zxRY3rf/bZZzXuoyEgJYsgGgjNYdDmblKo1mOpKlZFQm/uL6takyYBAGy//AIgcFMFVbSGxNFyTrpalyVaPZSsAK3J8ildUJmnLksEP9XWZHkEWbyOLpGBhKpkSXYHRBcDOCw4ECPhixA7WieFezUi9peSBQA6xfzCWUVDYgDgdRwFWQRBVIKuIATRQOiNlW3c1Xqs8Jjq63rYkBDEP7cA7f75D+jayW5AoTff3IAjvXZUG3eHWX5qrNYuSLZyCGyAG1/4kC5ISlbzQ60RFDiDV7qgaHd4BFmBecy2VNjQEDCKK5pgZwHRhSF9WkFqY0LPNuHVNCK+diVLNb9Q1TGgYpDFAMqTegqyCIJQCZog6+WXX8bAgQMREhJSrcWlJ06nE/PmzcP111+P0NBQJCYm4oEHHsClS5cafrAEAXdQ4ZkuWJIvK1nmGoIslZC+fdFx61Z0+HILzNU4HQUKqvmF3RQDAHBd8VSyAtv4wp0uWJOSpdi3k5LVbNAs3Fm9t/GFwyNdkJSsgIJhGHCqjbtDro18fkQ77J6TBrNR525EzJg1dfJaLdwBDxt3TyXL4xzOqac2hiFjHIIgNILmCuJwODBu3Dg89thjPi1vtVrxww8/4IUXXsAPP/yAzz//HCdPnsRf/vKXBh4pQciohfWeSlZJvqJkVZMuWBHWYICxS5eAN1vQGhLzstKjpQvabAGfLqj1yaqxJsttfEE0D3jPPlmVarLk3y6lCwYemsOgSwlmHBb3TEXJcpYr7pCRkWD9EPSodV1Oz5qsaM8gS1GxTKaAbBhPEETTEJiV9FWwZMkSANUX3lUkIiICu3bt8pq2du1a9O/fH9nZ2V5N2Tyx2+1e1o4lNTzdJoia0Gqy7JVrsnxRsoIJzcZdkoNHLcgqt0Lg5JsiPkCDLK0mqyZ3wWK1JouCrOaCZ7qgZ02WaLdDICUrYNF6ZblMACyA3SPIUvpkuaxKn7MamrbWBbWuy9P4Qq1DBQCeVazcyb6dIAgPWtQVpLi4GAzD1Jhu+OqrryIiIkJ7qc3VCKKuVKzJkiQJpXVUsoIFrSGxU7451WqyyoNAyYqQa7LEsjJILleVywiakkXpgs0FnaHqmizJqyarRV0igwItyBKUIMdR5p6pKlmlIgBo1uvXilrX5bpyBZJTdhT0Shdk5P1RPRZBEJ60mCuIzWbDvHnzMGHCBITXUFfx7LPPori4WHv98ccfjThKojmh9oVSa7LsVpf2/5qML4IRVclyOBkIrA6ufDnI8mpGHKhBlkcKoNZ0uAKiVpNFSlZzQT0eRU4PwUo1WcECF6kY1Tjkhzfe6YJyfz5niQMAwCdcez0WAHAxMZUaEhtDdVovRA7yeZ0NCfXL/giCaB406RVk/vz5YBimxteJEyeueT9OpxP33HMPJEnCW2+9VeOyBoMB4eHhXi+CqA9uC3f5Aqz2yAoJ1wdsz6j6ojfx2vu1GaIgKMYXQrkNknLDGqhBFqPTaU+gxWo62wuauyCdD5oLavqqxHBwlbtTxD1rsijICjw0JcuhnE88lSzF+MJVKNfYqdbr1wrDstDFxQFw27gzDKMp+JwkK+CkZBEE4UmT1mTNmTMHkydPrnGZjh07XtM+1ADr/Pnz2LNnDwVNRKOhN6rGF/IFWDW9aG71WIDSkDjKgMJcK+zGaIQW5kEsK4PT6tSWCVR3QQBgIyIgWq01KFlKuiApWc0Gnd4dQLlsDu3/ot0BUUlxJQv3wINXgyy78v2pQZYkaTVZzgL596rzk5IFyC6FzosX4brs3ZC4MNcKTpLPc6ypeaWBEwRxbTRpkBUbG4vY2NgG274aYJ0+fRoZGRmIiYlpsH0RREUqKlmqfXtzq8dSCYuWbzjs5tZA4Qm48vPhsLsADmAYCSwfuA6JnNkMV05Otb2y1OCLJSWr2cByLFhWgigycJa7a/HIXTCw0SzcVfHRoTwYsZcAovw9uq7IihbvJyULAHTx8SgH4MxxB1nhMfK5XAuySMkiiErs3bsXQ4cORWFhoU8tmJoTQXMFyc7ORmZmJrKzsyEIAjIzM5GZmQmLxZ2P3bVrV3zxxRcA5ADr7rvvxvfff4+PPvoIgiAgNzcXubm5cDgc1e2GIPyGroLxRYkPjYiDGa0uKzIRgOww6LTJNx88h4C2oVdt3MVqbNxJyWqe6JTA3+lwt1nwqsnig+YS2WLQLNzLZUc/TclSGxFzJjgv5wHwt5KlmF94KFk9U9ugc984tI+QFTQKsoKXvXv31li6MnTo0KYeIgAgIyMDo0aNQkxMDEJCQtC9e3fMmTMHFy9e9Ns+zp07B4ZhkJmZ6bdt1sS9996LkSNHek3buXMnGIbB4sWLvaYvXry4WnfwurBx48ZGCfiC5gqycOFC9O7dG4sWLYLFYkHv3r3Ru3dvfP/999oyJ0+eRLFSU3Hx4kVs3boVFy5cwI033oiEhATt9d133zXV2yBaEBWbETd7JUvpleUIk9Vp15V8uByy6xavC9wAC5DTBYGqGxJLkkRKVjNFPS6dynEKeFu48/qguUS2GLhIJV3QqqiPapClNiLmotyNiP3kLgi467ucHg2JY9qE4fZpPREmyvcdFGQFLwMHDkROTk6l1/r168EwDGbMmNHUQ8T69esxfPhwxMfHY/PmzTh27Bj+/ve/o7i4GCtXrmz08fhLsBg6dCgOHDgAl4e7b0ZGBpKSkrB3716vZTMyMgIm4PWFoLmCbNy4EZIkVXqlpaVpy0iSpNV4tW/fvsrlK65DEA2FvkIz4lJFyTK3at5Kls2gPGm+ckW7edUFeJClNSSuIl1QLLMCoqgsR0pWc0INoryCLJuD3AUDGM34Qq331JQspR7LFaEt549GxCqqU6EzN6fSPLFMNtpgqU9W0KLX6xEfH+/1KiwsxNNPP40FCxZg3Lhx2rL79u1D//79YTAYkJCQgPnz53sFCGlpaZg1axbmzp2L6OhoxMfHV1JkioqKMG3aNMTGxiI8PBzDhg1DVlZWteO7cOECZs2ahVmzZuH9999HWloa2rdvjyFDhuDdd9/FwoULtWX379+PwYMHw2QyISkpCbNmzUJZmdsgpn379njllVfw0EMPwWw2Izk5GW+//bY2v0OHDgCA3r17g2EY7Z558uTJGDNmDF5++WUkJiaiS5cuAIB//OMf6Nu3L8xmM+Lj4zFx4kTk5eX5/NkPHToUFovFSzTZu3cv5s+fj0OHDsFmkx9Q22w2HDp0SAuyavsMs7KyMHToUJjNZoSHh+Omm27C999/j71792LKlClaW6eqFDN/QVcQgmgg3OmCLkiSpDUiVvP4mxtmRcmycWEAlHRBp5zSE8imF4BHkFVFuqCo9MiCTgfGjzdtRNOjUx6ECMpxCshKFhjFmpvSBQMOtSZLcgoQXYzbwl1RspxOOdDh4/2XKgjINVkA4PJQslREqxJkkZJVNZIkB8ON/ZKk2sdWDUVFRRg9ejTS0tKwdOlSbfrFixcxatQo9OvXD1lZWXjrrbfw3nvv4aWXXvJa/4MPPkBoaCgOHTqE5cuX48UXX8SuXbu0+ePGjUNeXh527NiBo0ePok+fPrjttttQUFBQ5Xg+/fRTOBwOzJ07t8r5aurbmTNnMHLkSNx111346aef8K9//Qv79+/HzJkzvZZfuXIl+vbtix9//BEzZszAY489hpMnTwIADh8+DAD45ptvkJOTg88//1xbb/fu3Th58iR27dqFf//73wDk8pylS5ciKysLW7Zswblz52o1tfMkJSUFiYmJyMjIAACUlpbihx9+wLhx49C+fXscPHgQAPDdd9/BbrdrQVZtn+F9992Htm3b4siRIzh69Cjmz58PnU6HgQMHYvXq1QgPD9cUy6efftrn8daFJjW+IIjmjGZ8YRdgLXFAcIpgGCAs2tDEI2sY1PdVLhohAXDlX9FuXgPVvl2FjVBrsiorWUKJat9uDui6MqLuaA9CXHImBMMwcNndT6QpXTDwYENDwOh0kJxOCHYWrF0JspSaLJdN6cvXUEHWlSuQXC4wvPv2iYKsWnBagVcSG3+/Cy4B+rr3LhNFERMnTgTP8/joo4+8zvvr1q1DUlIS1q5dC4Zh0LVrV1y6dAnz5s3DwoULwbLyOaNXr15YtGgRAKBz585Yu3Ytdu/ejREjRmD//v04fPgw8vLyYDDIx+uKFSuwZcsWfPbZZ3jkkUcqjen06dMIDw9HQkJCjWN/9dVXcd999+HJJ5/U9r1mzRqkpqbirbfeglF5UDhq1CgtBXLevHlYtWoVMjIy0KVLF82QLiYmBvEVfkehoaF49913odfrtWkPPfSQ9v+OHTtizZo16NevHywWC8LCwmr/wCGrWXv37sWzzz6L//znP0hJSUFsbCyGDBmiGWfs3bsXHTp0QLt27Xz6DLOzs/HMM8+ga9eu2mehEhERAYZhKr0/f0NXEIJoIDybEas9skKjDOC45vmzC1N6xrhEFi7eJCtZovxeeWNgP8/hwpWarKrSBRUly7NpMdE80BnltECB1UNS6gtUsxaAlKxAhGEYt/mFnfVIF1QaEVuVc068/+qxAKUhMc8Doqg1JFZRgyyGgqxmwYIFC3Dw4EF8+eWXMFc47x8/fhwDBgzwCrwGDRoEi8WCCxcuaNN69erltV5CQoKWQpeVlQWLxYKYmBiEhYVpr7Nnz+LMmTNVjkl9CFQbWVlZ2Lhxo9d209PTIYoizp49W+X41GDDlxS/66+/3ivAAoCjR4/izjvvRHJyMsxmM1JTUwHIhnW+kpaWhgMHDsDpdGLv3r1aimJqaqpWl6UGW+r7rO0znD17NqZNm4bhw4dj2bJl1X62DUlg3/kQRBCj11KRRBTlyRfh5poqCMgpgYZQHvYyF+yGKLgu50EQ5AaeelNgn2q4CDVdsHoli6Uee80OnUkJsjg9RKsVrMEAwaE0lmVEUi4DFC4yEq68PAgOtlK6oMuiqOfxNT/xrytqQ2LnpUtw5uZC56EokJJVC7oQWVVqiv3WkU2bNmHFihXYtm2bl/JR513rdF5/MwwDUanttVgsSEhIqGTqAKBax7uUlBQUFxcjJyenRjXLYrHg0UcfxaxZsyrN83Tlq2l8NREa6q0MlpWVIT09Henp6fjoo48QGxuL7OxspKen18kYY+jQoSgrK8ORI0eQkZGBZ555BoAcZD300EMoKCjAoUOH8Oijj2rvs7bPcPHixZg4cSK2bduGHTt2YNGiRdi0aRPGjh3r87iulcC+8yGIIEZVsgDg6kX5aWt4MzW9UAmLMsJeZoHNEAXnhfMQopIAuG9mAxVfarJIyWp+eAZZUnk5EBUFQTGqaaaCc7OA82xIXMHC3VkiK5E6PytZAMAnJMB56RJcuble0ynIqgWGqVfaXmOTmZmJqVOnYtmyZUhPT69ymW7dumHz5s1eytKBAwdgNpvRtm1bn/bTp08f5Obmgud5tG/f3qd17r77bsyfPx/Lly/HqlWrKs0vKipCZGQk+vTpg2PHjqFTp04+bbcqVKVKEIRalgROnDiBq1evYtmyZUhKkq/3ngYWvnLdddchKSkJW7duRWZmpqaGtWnTBm3atMHKlSvhcDg0JcvXzzAlJQUpKSl46qmnMGHCBGzYsAFjx46FXq/36f1dK3QZIYgGguNZsJx8Ei64KD9tba727SpmxWHQboiCaLFA4OSTtS5EX9NqTY6qUolVpAuSktV8UQ1ZBM4AUbH9djqVIIurf9E80bBUGWSpSlaRYt/uZyULAHSKJbyzgvmFO8gK/ECCqJr8/HyMGTMGaWlpuP/++7W+qurripIiOmPGDPzxxx944okncOLECXz55ZdYtGgRZs+erdVj1cbw4cMxYMAAjBkzBl9//TXOnTuH7777Ds8991y1AUpSUhJWrVqFN954A1OnTsW+fftw/vx5HDhwAI8++qhmzjFv3jx89913mDlzJjIzM3H69Gl8+eWXlYwvaiIuLg4mkwk7d+7E5cuXtdZIVZGcnAy9Xo8333wTv//+O7Zu3eplFFIXhg4dinXr1qFTp05o7dF+ITU1FW+++aZmkAHU/hmWl5dj5syZ2Lt3r/Y5HTlyBN26dQMgOyxaLBbs3r0b+fn5sCq/YX9DQRZBNCCqmnVVDbKaaSNiFbVXls2o3ARxShG6IbBFc66GPlkCKVnNFp1BvgSKrAGiVb45FxxqkEWpgoEKF6n8Xu0e6YLWAkgS4Lwq/14bRMnSHAZJyWpubNu2DefPn8f27du9+qqqr379+gGQlZXt27fj8OHDuOGGGzB9+nRMnToVzz//vM/7YhgG27dvx5AhQzBlyhSkpKTg3nvvxfnz572Ci4rMmDEDX3/9NS5evIixY8eia9eumDZtGsLDwzV3vF69emHfvn04deoUBg8ejN69e2PhwoVacOILPM9jzZo1WL9+PRITEzF69Ohql42NjcXGjRvx6aefonv37li2bBlWrFjh8748GTp0KEpLSyu1WUpNTUVpaalXf6zaPkOO43D16lU88MADSElJwT333IM//elPWLJkCQC5L9r06dMxfvx4xMbGYvny5fUac20wknQNHpctgJKSEkRERKC4uBjh9CSbqCMfLDgAS4Fd+3vsnD5I7BzZdANqYI7uPIf/bvkdCYU/olvWuziRMgGXEm9F/zs7oN+fOzT18KrFlZ+P07cOBgB0/fUXMJw71fPystdQsHEjoqc+hNZKnjjRPDiy7SwO/99ZJF7aj9ufH4nQ/v3xw+S5OGgcifAwEZNWDG/qIRJVkPfGG7j61t8R1bkM8YMAzM8GVvWEkHcBp76QFawuWZlgDf51ci348B+4/MorMKeno+0bq7XpJ2++BWJxMTpu3wZDx45+3WewYbPZcPbsWXTo0EFzsiOIYKSmY9nX2ICULIJoQPQVXPVaQk0WANhDWgHwVLIC28Kd8zhJiqWlXvPcShY9ZGluqMelwBnkmiwALqdc/M3zpGQFKnzFdEFJAqwFcFrl75OLivJ7gAW4HQtJySIIwhcoyCKIBsQzuGB5BqERzbNHlkqYWpOljwQArSaLD/BmxIxeD8Yk18tVTBkUtZosShdsbngGWWpNliDIyR1k3x64eFm4iy7AXgo4y+Asl79PPqFhet+ovbKcHkGW5HAATtlsg4IsgiA8oasIQTQgnkGWOdoIhm3eT8dVJaucCYEEuf8QEPhKFuDhMFjB/EIoVZsRk5LV3OA14wu9uybLpQRZOro8BiqcYtEs2JXvqEjux+OyypkDutYNE2TxFRoSA24VCwBYU/M2NiIIom7QVYQgGhDPdMHm7iwIAGGRspIlgoNTFxY06YJA9TbuoqJscaRkNTs0JYvVQyyXb5ZVV1+egqyAhYtU0gUdynlFCbKcTtndT9dAShbv2ZA4Px+ARyNivR6MLrBbVRAE0bjQVYQgGhDP4KK5OwsC8tN/U7isXtkNUUEVZLFKQ2KxpGoliyUlq9lRZU2WGmQFeIprS8Zt4a5kBhT/AQBw2eRzLN9AShbDcdDFyQ3WnTk5AKgeiyCI6qEgiyAaEM+GxOYWEGQB7l5ZtiALsrhwxRa6uGJNFilZzRWvmiw1XVD2vQCnC/xjtqWipgtKAgPRxbiVLKUmq6GULMAjZfCy3CuLgiyCIKqDgiyCaEC8lKwWkC4IeDgMGqPczYiDIshS0wXdQZYkSaRkNWO8arIUJUsUZHWED/Debi0ZNjRES80T7KxbyVJaZjWUkgW4+2+p5hdakBVKQRZBEN5QkEUQDYje6Jku2FKCLFXJitSUrGBIveK0dEF3TZZYZgVEWdogJav5oQb/ImeAWG6Vg2qJgqxAh2EYb4fBoj/kRsSlsstfwypZch8uV453kMWQkkUQRAUoyCKIBkRn8DS+aBnpgqqSZTNEQwyidEG2CndBUemRBZ0ODDXWbHa4jS90EK3lkJxOiKyskFCQFdhodVkOFijKhuBgIKk9zlq3brD9akqWmi5YRumCBEFUDQVZBNGAqDVZvIGDMaxlOE+FRcuBVXmo+2lyMARZWk2WR7qgUKLat5vBMM3bfr8lwuuVSyDDwml1QLLbtSCLM+qbcGREbXjZuFvz4VIbEUdHN0gjYhU1FdFVyfgitMH2SRBNCcMw2LJlS1MPIyihIIsgGhA1uAiPMbaYm3RVybKGxClTpKCww1bTBT0t3FUlizNTqmBzROeRxuq0OSHZ7RBUJctISlYg43YYlM8tTiXI4uMbTsUC3KmITjK+aFbs3bsXDMNU+xo6dGhTDxEMw8BoNOL8+fNe08eMGYPJkydf8/YXL16MG2+88Zq3Q7gJ/DsfgghiEjtHIjoxFN0GJjT1UBoNtSZLbUTMs1JQNGFW0wXF4spKljqPaF4wLAOOk5sPO20uLyWLJ3fBgIaLigTgDrJcqrNgfMOeazUlS2lIrPZXoyAruBk4cCBycnIqvdavXw+GYTBjxoymHiIAOdBauHChX7cpSRJcSnPtxsLhcDTq/poKCrIIogEJjTBgwsKbcePw5KYeSqMRGqGHp2jH6wI/wAKqThckJav5o+Pl49NpFyDaHRBZWcEKBvW1JaOlCzq8lSxdAytZfCulIbEgwJWfD4mUrFqRJAlWp7XRX5Ik+TxGvV6P+Ph4r1dhYSGefvppLFiwAOPGjdOW3bdvH/r37w+DwYCEhATMnz/fK0hJS0vDrFmzMHfuXERHRyM+Ph6LFy/22l9RURGmTZuG2NhYhIeHY9iwYcjKyqp1nDNnzsQ///lP/PLLL9UuY7fbMWvWLMTFxcFoNOLWW2/FkSNHtPmqardjxw7cdNNNMBgM+Oc//4klS5YgKytLU+82btyorZOfn4+xY8ciJCQEnTt3xtatW732+csvv+BPf/oTwsLC0Lp1a0yaNAn5SsNu9TOZOXMmnnzySbRq1Qrp6enaOHbv3o2+ffsiJCQEAwcOxMmTJ2v9HIIFyocgCMKvsByL0EgDLIV2AIDeHByuiu50QVKyWhK8jgHsElwOAZLDDpFTarIoyApo+Arpgi4tXbBhlSyG48DHxcJ1KQeu3FxKF/SBclc5bv5/Nzf6fg9NPIQQXf2+l6KiIowePRppaWlYunSpNv3ixYsYNWoUJk+ejA8//BAnTpzAww8/DKPR6BVIffDBB5g9ezYOHTqEgwcPYvLkyRg0aBBGjBgBABg3bhxMJhN27NiBiIgIrF+/HrfddhtOnTqF6Ojoasc1aNAgnDp1CvPnz8e///3vKpeZO3cuNm/ejA8++ADt2rXD8uXLkZ6ejt9++81r2/Pnz8eKFSvQsWNHGI1GzJkzBzt37sQ333wDAIiIiNCWXbJkCZYvX47XX38db775Ju677z6cP38e0dHRKCoqwrBhwzBt2jSsWrUK5eXlmDdvHu655x7s2bPH6zN57LHHcODAAQBAjlLX+Nxzz2HlypWIjY3F9OnT8dBDD2nLBDt0FSEIwu+oKYNAcJheAO4+WWJpKSTFtl0gJavZo5pfOB1ShXRBujwGMl4W7mg8JQsAdErKoDP3MrkLNkNEUcTEiRPB8zw++ugjr3rqdevWISkpCWvXrkXXrl0xZswYLFmyBCtXroSoXDcAoFevXli0aBE6d+6MBx54AH379sXu3bsBAPv378fhw4fx6aefom/fvujcuTNWrFiByMhIfPbZZ7WO79VXX8XOnTvxn//8p9K8srIyvPXWW3j99dfxpz/9Cd27d8c777wDk8mE9957z2vZF198ESNGjMB1112HNm3aICwsDDzPa0qeyeR+QDp58mRMmDABnTp1wiuvvAKLxYLDhw8DANauXYvevXvjlVdeQdeuXdG7d2+8//77yMjIwKlTp7RtdO7cGcuXL0eXLl3QpUsXbfrLL7+M1NRUdO/eHfPnz8d3330Hm81W6+cQDJCSRRCE35HNL+QAJViCLFZ9aidJEEtLwUVEQNSULAqymivy8SnA5ZIgeroLUpAV0HCRFZSsclXJargeWSq6hHiU/wg4c3OoGbEPmHgTDk081CT7rQ8LFizAwYMHcfjwYZgrPGA7fvw4BgwY4BV4DRo0CBaLBRcuXEByslwa0KtXL6/1EhISkJeXBwDIysqCxWJBTEyM1zLl5eU4c+ZMrePr3r07HnjgAcyfP7+S4nPmzBk4nU4MGjRIm6bT6dC/f38cP37ca9m+ffvWui8Vz/cTGhqK8PBwr/eTkZGBsLCwSuudOXMGKSkpAICbbrqp1m0nJMhKdF5envZZBjMUZBEE4Xc8laxgaEQMAKxeD8ZohGSzQSgpARcR4aFkUbpgc0Vn5AE44HQBkkdNFsdTkBXIeFq4S5KnktXwQZZmfpF7mdIFfYBhmHqn7TU2mzZtwooVK7Bt2zZ07ty53tvR6bxbtjAMoyldFosFCQkJ2Lt3b6X1IpXjujaWLFmClJSUa7JWDw31ve1Abe/nzjvvxGuvvVZpPTVoqml/nttWg1dPVTCYoSCLIAi/o9q4A8GjZAFyyqDLZpMbEieBlKwWgM4oX+AFcBDLyiCqrphB8nCgpeLZjFhwsJAE+easIRsRq2gNiakmq1mRmZmJqVOnYtmyZUhPT69ymW7dumHz5s2QJEkLCA4cOACz2Yy2bdv6tJ8+ffogNzcXPM+jffv29RprUlISZs6ciQULFuC6667Tpl933XXQ6/U4cOAA2rVrBwBwOp04cuQInnzyyRq3qdfrIQhCncfSp08fbN68Ge3btwfPU1jhCT2qIwjC76gNiYEgC7IU8wtR6ZUllKrNiEnJaq7oQuSgSuQMEIqKIJC7YFDAKxbuksDAUdo4jYi1fSvmGmR80XzIz8/HmDFjkJaWhvvvvx+5ublerytXrgAAZsyYgT/++ANPPPEETpw4gS+//BKLFi3C7NmzwbK+nTOGDx+OAQMGYMyYMfj6669x7tw5fPfdd3juuefw/fff+zzmZ599FpcuXdKMKgBZLXrsscfwzDPPYOfOnTh27BgefvhhWK1WTJ06tcbttW/fHmfPnkVmZiby8/Nht9t9Gsfjjz+OgoICTJgwAUeOHMGZM2fw1VdfYcqUKfUK2poTdBUhCMLvBKuSxVawcReVf9Xgi2h+6JSmwwKrh1BU5K7JonTBgIYJCQGjk787W6H8nTVGqqC8H0XJukzpgs2Fbdu24fz589i+fTsSEhIqvfr16wcAaNOmDbZv347Dhw/jhhtuwPTp0zF16lQ8//zzPu+LYRhs374dQ4YMwZQpU5CSkoJ7770X58+fR+s6KLHR0dGYN29eJZOIZcuW4a677sKkSZPQp08f/Pbbb/jqq68Qpai/1XHXXXdh5MiRGDp0KGJjY/Hxxx/7NI7ExEQcOHAAgiDg9ttvx/XXX48nn3wSkZGRPgeezRVGqksjgRZISUkJIiIiUFxcjHCycSYInygrtmPjPLkg94bhSbj17vrntjcmfzw2A5aMDMQvWYKo8ffgtxG3w/nHH2j38f9DSO/eTT08ogH4zyen8NOeC2h3/iv0S43GltPd4dKFYuLimxEV73vNAtH4nL51EFz5BYjsWIai30MRNmwYktb9rcH367ych99SUwGOA2c2QygqQoetX8KoFPi3ZGw2G86ePYsOHTrAaDTWvgJBBCg1Hcu+xgYtO8QkCKJBCDHrwXJyvrouiGpbOKX2SlDSBTUlix6wNFvU41NQ0gVJyQoeVPMLW1HjKll8qxiA4wBBgFBUBABgQyggJwjCG7qKEAThdxiW0RwGgzFdUCwphSRJWk0WS32ymi06oxpk6eEqKnK7C1JNVsDDKY1V7cVKb7NGCrLkhsRxXtPIwp0giIrQVYQgiAZBrcsKpiBLVayEkhK5yahiI0tKVvOF91CynEUlAMN6TScCFy5K7jOkOgvqEhonyAIqq2ZUk0UQREUoyCIIokHodFMcQiL0SOwc2dRD8RnV4EIoKYao9MhidDowjeBYRjQN6kMAgdPDWWzRpvOULhjwcNHehfyNYd+u7SveY18cB0avb7R9EwQRHJChPUEQDcL1aW3RM7WN1kskGGAVxUosLoGg9cgKD6r3QNQNrSaLNcBZWqZNZ3n6zgMdvoJbms6j8WlDo2vtVrLYkBA6RxAEUQl6VEcQRIMRbDcenIeFu6pkcVSP1azxUrLKZCtkjhGD7thtiajGFyqNqWR5piZSqiBBEFVBQRZBEISCO13QW8kimi+8wV2TJTKK6QVLnU2CAc5DyeJiYsA2Ysoe35qCLIIgaoaCLIIgCAVOSxcsJiWrheBp4a7Zt9OVMSjgIt1Blq4RVSyAlCyCIGqHLiUEQRAKqoW7UFoKobhYmUZBVnNGTRcUOb1m386SsWBQ4Klk8Y1YjwV428VTkEUQRFVQkEUQBKGgpgtCFOHMyZWnmSldsDnDG+TLoMDqNSWLpyArKPCsyWpsJYtv1UpuSAwKsojmz+TJkzFmzJimHkbQQUEWQRCEAms0albMzgsXAAAcKVnNGk8lS+Bkq36OnAWDAj4q0v3/RuyRBXg3JKZGxMHP3r17wTBMta+hQ4c29RCxb98+DBs2DNHR0QgJCUHnzp3x4IMPwuFw+G0f586dA8MwyMzMvOZtbdy4scrP0mg0XvtAFRiGwZYtW/y2PX9DFu4EQRAesBHhEK7kw3FRDrJYUrKaNTqPpsNOPhQABVnBAhMSAkavh+RwVGoO3BjoWreGKycHDClZQc/AgQORk5NTafrWrVsxffp0zJgxowlG5ebYsWMYOXIknnjiCaxZswYmkwmnT5/G5s2bIQhCk46tJsLDw3Hy5EmvaS3JuZWULIIgCA9UG3fnhYvK36RkNWc4HQsGspugUycHWbyOLo3BAMMw4KKjATRujywVtS6LNVGQVROSJEG0Whv9JUm+u4Tq9XrEx8d7vQoLC/H0009jwYIFGDdunLbsvn370L9/fxgMBiQkJGD+/PlwuVza/LS0NMyaNQtz585FdHQ04uPjsXjxYq/9FRUVYdq0aYiNjUV4eDiGDRuGrKysasf39ddfIz4+HsuXL0fPnj1x3XXXYeTIkXjnnXdgMpm05TZv3owePXrAYDCgffv2WLlypdd2qlJ+IiMjsXHjRgBAhw4dAAC9e/cGwzBIS0vzWnbFihVISEhATEwMHn/8cTidzho/V4ZhKn2urT1Se3fu3Ilbb70VkZGRiImJwR133IEzZ85o8x0OB2bOnImEhAQYjUa0a9cOr776KgCgffv2AICxY8eCYRjt70CClCyCIAgPNIfBEtldkJSs5g3DMOB5wOkCnLowAHLgRQQHsU88AesPR2G68cZG37ehUyeUAk2iogUTUnk5Tva5qdH32+WHo/VWGYuKijB69GikpaVh6dKl2vSLFy9i1KhRmDx5Mj788EOcOHECDz/8MIxGo1cg9cEHH2D27Nk4dOgQDh48iMmTJ2PQoEEYMWIEAGDcuHEwmUzYsWMHIiIisH79etx22204deoUopUHB57Ex8cjJycH3377LYYMGVLlmI8ePYp77rkHixcvxvjx4/Hdd99hxowZiImJweTJk31634cPH0b//v3xzTffoEePHtB7tEXIyMhAQkICMjIy8Ntvv2H8+PG48cYb8fDDD/u07aooKyvD7Nmz0atXL1gsFixcuBBjx45FZmYmWJbFmjVrsHXrVnzyySdITk7GH3/8gT/++AMAcOTIEcTFxWHDhg0YOXIkOC7wimkpyCIIgvCAq9AXi5Ss5g/PM0qQpSpZgXexJqom8q6/IvKuvzbJvmOmTIaxaxeEDhrUJPsnGgZRFDFx4kTwPI+PPvrIK71t3bp1SEpKwtq1a8EwDLp27YpLly5h3rx5WLhwIVhWfkDTq1cvLFq0CADQuXNnrF27Frt378aIESOwf/9+HD58GHl5eTAY5DrQFStWYMuWLfjss8/wyCOPVBrTuHHj8NVXXyE1NRXx8fG45ZZbcNttt+GBBx5AuHLN+t///V/cdttteOGFFwAAKSkpOHbsGF5//XWfg6zY2FgAQExMDOIrPDyIiorC2rVrwXEcunbtij//+c/YvXt3jUFWcXExwsLCvKYNHjwYO3bsAADcddddXvPef/99xMbG4tixY+jZsyeys7PRuXNn3HrrrWAYBu3atas01sjIyEpjDRQoyCIIgvCAjfAOsljqk9Xs4XUMYJO0IIvTU5BF1A4bGgrz8OFNPYyAhzGZ0OWHo02y3/qwYMECHDx4EIcPH4a5wvn/+PHjGDBggFfgNWjQIFgsFly4cAHJyckA5CDLk4SEBOTl5QEAsrKyYLFYEBMT47VMeXm5V6qcJxzHYcOGDXjppZewZ88eHDp0CK+88gpee+01HD58GAkJCTh+/DhGjx7ttd6gQYOwevVqCIJwzUpPjx49vLaRkJCAn3/+ucZ1zGYzfvjhB69pnumNp0+fxsKFC3Ho0CHk5+dDFEUAQHZ2Nnr27InJkydjxIgR6NKlC0aOHIk77rgDt99++zW9j8aEgiyCIAgP1Jos99+ULtjc0elZAIKWLshTkEUQfoNhmKAxB9m0aRNWrFiBbdu2oXPnzvXejk6n8/qbYRgtgLBYLEhISMDevXsrrRfp0ZagKtq0aYNJkyZh0qRJWLp0KVJSUvD3v/8dS5Ys8WlcDMNUqlWrra5Kpab3VB0sy6JTp07Vzr/zzjvRrl07vPPOO0hMTIQoiujZs6fmmNinTx+cPXsWO3bswDfffIN77rkHw4cPx2effebTmJsaCrIIgiA8qBhUkZLV/OENHLyCLANdGgmipZGZmYmpU6di2bJlSE9Pr3KZbt26YfPmzZAkSVOzDhw4ALPZjLZt2/q0nz59+iA3Nxc8z1+TWUNUVBQSEhJQVlamje3AgQNeyxw4cAApKSmaAhUbG+vlonj69GlYrVbtb7UGqzEcC69evYqTJ0/inXfeweDBgwEA+/fvr7RceHg4xo8fj/Hjx+Puu+/GyJEjUVBQgOjoaOh0uoB2V6QrCUEQhAdcRMWaLFKymjs6Aw/A4U4XpCCLIFoU+fn5GDNmDNLS0nD//fcjNzfXaz7HcYiNjcWMGTOwevVqPPHEE5g5cyZOnjyJRYsWYfbs2Vo9Vm0MHz4cAwYMwJgxY7B8+XKkpKTg0qVL2LZtG8aOHYu+fftWWmf9+vXIzMzE2LFjcd1118Fms+HDDz/Er7/+ijfffBMAMGfOHPTr1w9Lly7F+PHjcfDgQaxduxbr1q3TtjNs2DCsXbsWAwYMgCAImDdvnpdCFRcXB5PJhJ07d6Jt27YwGo2IiIioNB5fkSSp0mep7icqKgoxMTF4++23kZCQgOzsbMyfP99ruf/93/9FQkICevfuDZZl8emnnyI+Pl5T/Nq3b4/du3dj0KBBMBgMiIqKqvdYGwKyUCIIgvCA9UgXZHQ6MEphMtF80Znkmwy1T5bOqK9pcYIgmhnbtm3D+fPnsX37diQkJFR69evXD4Ccrrd9+3YcPnwYN9xwA6ZPn46pU6fi+eef93lfDMNg+/btGDJkCKZMmYKUlBTce++9OH/+vJe9uSf9+/eHxWLB9OnT0aNHD6SmpuK///0vtmzZgtTUVACyQvbJJ59g06ZN6NmzJxYuXIgXX3zRy/Ri5cqVSEpKwuDBgzFx4kQ8/fTTCPFI5eR5HmvWrMH69euRmJhYqcarrpSUlFT5eebl5YFlWWzatAlHjx5Fz5498dRTT+H111/3Wt9sNmP58uXo27cv+vXrh3PnzmH79u1aQLty5Urs2rULSUlJ6N279zWNtSFgpLo0EmiBlJSUICIiAsXFxZqDC0EQzZfSPXtwYcbjAAAuJgYpByqnLxDNi13v/IRTR/O1v/vf0Q797riuCUdEEMGJzWbD2bNn0aFDBxiNxqYeDkHUm5qOZV9jg6BRsl5++WUMHDgQISEhtRYGVsX06dPBMAxWr17t97ERBNF88EwP5Kgeq0XAh3grV1STRRAEQVwrQRNkORwOjBs3Do899lid1/3iiy/w3//+F4mJiQ0wMoIgmhOsR5DFknrdItAZvN0EdeQuSBAEQVwjQfO4TrWn3LhxY53Wu3jxIp544gl89dVX+POf/9wAIyMIojnBeRT5kpLVMqgYZHG6oHn+SBAEQQQoQRNk1QdRFDFp0iQ888wz6NGjh0/r2O122O127e+SkpKGGh5BEAEI56VkUZDVEqioXFGQRRAEQVwrzfpK8tprr4HnecyaNcvndV599VVERERor6SkpAYcIUEQgQZjNIJRLG05M6ULtgQqKlk8T+mCBEEQxLXRpEHW/Pnz5U7gNbxOnDhRr20fPXoUb7zxBjZu3Kg1jPOFZ599FsXFxdrrjz/+qNf+CYIIThiGAaukDHKkZLUI+IpKlr5ZP38kCIIgGoEmTRecM2eOl39/VXTs2LFe2/7Pf/6DvLw8JCcna9MEQcCcOXOwevVqnDt3rsr1DAYDDNQXhyBaNFx4OIT8fLCkZLUIKitZFGQRBEEQ10aTBlmxsbGIjY1tkG1PmjQJw4cP95qWnp6OSZMmYcqUKQ2yT4IgmgdqXRYpWS0DMr4gCIIg/E3QGF9kZ2ejoKAA2dnZEAQBmZmZAIBOnTohLCwMANC1a1e8+uqrGDt2LGJiYhATE+O1DZ1Oh/j4eHTp0qWxh08QRBBh6NwZ5ZmZ0F9HDWlbAjqDd1DFU7ogQRAEcY0ETZC1cOFCfPDBB9rfvXv3BgBkZGQgLS0NAHDy5EkUFxc3xfAIgmhGxL/wPKKnTIGhY4emHgrRCFSqyaJ0QYIgCI3JkyejqKgIW7ZsaeqhBBVBcyXZuHEjJEmq9FIDLACQJKnGGq9z587hySefbPCxEgQR3DB6PQVYLQhKFySIls3evXtrNGEbOnRoUw8R+/btw7BhwxAdHY2QkBB07twZDz74IBwOh9/2ce7cOTAMo2WL1ZcTJ06AYRj897//9Zp+yy23wGg0wmazadNsNhuMRiPee++9a9onALRv3x6rV6++5u34C7qSEARBEC2aSsYXOrJwJ4iWxMCBA5GTk1PptX79ejAMgxkzZjTp+I4dO4aRI0eib9+++Pbbb/Hzzz/jzTffhF6vhyAITTq2qujatSvi4+Oxd+9ebVppaSl++OEHxMbGegVfBw8ehN1ux7Bhw5pgpA0LBVkEQRBEi6ZiuiBPShZB+A1JkuC0C43+kiTJ5zHq9XrEx8d7vQoLC/H0009jwYIFGDdunLbsvn370L9/fxgMBiQkJGD+/PlwuVza/LS0NMyaNQtz585FdHQ04uPjsXjxYq/9FRUVYdq0aYiNjUV4eDiGDRuGrKysasf39ddfIz4+HsuXL0fPnj1x3XXXYeTIkXjnnXdgMpm05TZv3owePXrAYDCgffv2WLlypdd2GIaplPIXGRmJjRs3AgA6dJAzOHr37g2GYbyyxQBgxYoVSEhIQExMDB5//HE4nc5qxzx06FCvIGv//v1ISUnBnXfe6TV97969aNeunbbvL7/8En369IHRaETHjh2xZMkS7fOVJAmLFy9GcnIyDAYDEhMTtV64aWlpOH/+PJ566ilNgWxqgqYmiyAIgiAaAkoXJIiGw+UQ8fb/7Gv0/T7yRmql37avFBUVYfTo0UhLS8PSpUu16RcvXsSoUaMwefJkfPjhhzhx4gQefvhhGI1Gr0Dqgw8+wOzZs3Ho0CEcPHgQkydPxqBBgzBixAgAwLhx42AymbBjxw5ERERg/fr1uO2223Dq1ClER0dXGk98fDxycnLw7bffYsiQIVWO+ejRo7jnnnuwePFijB8/Ht999x1mzJiBmJiYWtslqRw+fBj9+/fHN998gx49ekCv12vzMjIykJCQgIyMDPz2228YP348brzxRjz88MNVbmvo0KF46qmn4HK5wPO85qEwePBgrFu3Tvu8MjIytHTM//znP3jggQewZs0aDB48GGfOnMEjjzwCAFi0aBE2b96MVatWYdOmTejRowdyc3O14PTzzz/HDTfcgEceeaTaMTU2dCUhCIIgWjQcz4LllKeeDNz/JwiixSGKIiZOnAie5/HRRx95KSLr1q1DUlIS1q5di65du2LMmDFYsmQJVq5cCVEUteV69eqFRYsWoXPnznjggQfQt29f7N69G4Cs6Bw+fBiffvop+vbti86dO2PFihWIjIzEZ599VuWYxo0bhwkTJiA1NRUJCQkYO3Ys1q5di5KSEm2Z//3f/8Vtt92GF154ASkpKZg8eTJmzpyJ119/3ef3rrZViomJQXx8vFfAFxUVpb3vO+64A3/+85+191QVQ4cORVlZGY4cOQJAVqxSU1MxZMgQHDp0CDabDeXl5Th8+LAWZC1ZsgTz58/Hgw8+iI4dO2LEiBFYunQp1q9fD0B2Go+Pj8fw4cORnJyM/v37awFVdHQ0OI6D2WzW1MimhpQsgiAIosWjM3CwW13gdWxApJkQRHOB17N45I3UJtlvfViwYAEOHjyIw4cPw2z27pV4/PhxDBgwwOscMWjQIFgsFly4cAHJyckA5CDLk4SEBOTl5QEAsrKyYLFYKrUZKi8vx5kzZ6ocE8dx2LBhA1566SXs2bMHhw4dwiuvvILXXnsNhw8fRkJCAo4fP47Ro0d7rTdo0CCsXr0agiCA466t1rRHjx5e20hISMDPP/9c7fKdOnVC27ZtsXfvXvTo0QM//vgjUlNTERcXh+TkZBw8eBCSJMFut2tBVlZWFg4cOICXX35Z244gCLDZbLBarRg3bhxWr16Njh07YuTIkRg1ahTuvPNO8HxghjOBOSqCIAiCaER4vRxkUaogQfgXhmHqnbbX2GzatAkrVqzAtm3b0Llz53pvR6fTef3NMIymdFksFiQkJHjVJalERkbWuN02bdpg0qRJmDRpEpYuXYqUlBT8/e9/x5IlS3waF8MwlWrVaqqr8qSm91QdaWlpyMjIQK9evdC5c2fExcUBAFJTU5GRkQFJktCpUyckJSUBkD+bJUuW4K9//WulbRmNRiQlJeHkyZP45ptvsGvXLsyYMQOvv/469u3bV2l8gQAFWQRBEESLR70J5KlHFkG0SDIzMzF16lQsW7YM6enpVS7TrVs3bN68GZIkaWrWgQMHYDab0bZtW5/206dPH+Tm5oLnebRv377e442KikJCQgLKysq0sR04cMBrmQMHDiAlJUVToGJjY5GTk6PNP336NKxWq/a3WoPlL8fCoUOHYtasWejevbuXicaQIUPwzjvvQJIkL3v8Pn364OTJk+jUqVO12zSZTLjzzjtx55134vHHH0fXrl3x888/o0+fPgHntkhBFkEQBNHiUYMsTh8cT9wJgvAf+fn5GDNmDNLS0nD//fcjNzfXaz7HcYiNjcWMGTOwevVqPPHEE5g5cyZOnjyJRYsWYfbs2WBZ3x7QDB8+HAMGDMCYMWOwfPlypKSk4NKlS9i2bRvGjh2Lvn37Vlpn/fr1yMzMxNixY3HdddfBZrPhww8/xK+//oo333wTADBnzhz069cPS5cuxfjx43Hw4EGsXbsW69at07YzbNgwrF27FgMGDIAgCJg3b56XAhQXFweTyYSdO3eibdu2MBqNiIiIqM9HCsBdl/X+++/jnXfe0aanpqZi2rRpAOBlj79w4ULccccdSE5Oxt133w2WZZGVlYVffvkFL730EjZu3AhBEHDzzTcjJCQE//znP2EymdCuXTsAcp+sb7/9Fvfeey8MBgNatWpV77H7A3pkRxAEQbR41PoNsm8niJbHtm3bcP78eWzfvh0JCQmVXv369QMgp+tt374dhw8fxg033IDp06dj6tSpeP75533eF8Mw2L59O4YMGYIpU6YgJSUF9957L86fP4/WrVtXuU7//v1hsVgwffp09OjRA6mpqfjvf/+LLVu2IDVVrnfr06cPPvnkE2zatAk9e/bEwoUL8eKLL3o5C65cuRJJSUkYPHgwJk6ciKeffhohISHafJ7nsWbNGqxfvx6JiYmVarzqSocOHdCuXTuUlpZq4wSA5ORkJCYmwuFweClc6enp+Pe//42vv/4a/fr1wy233IJVq1ZpQVRkZCTeeecdDBo0CL169cI333yD//u//9Pq21588UWcO3cO1113nWbi0ZQwUl0aCbRASkpKEBERgeLiYoSHhzf1cAiCIIgG4P/ezET2rwWITTbjngX9mno4BBGU2Gw2nD17Fh06dIDRaGzq4RBEvanpWPY1NqBHdgRBEESLR6vJqqcjGUEQBEF4QlcTgiAIosWjU2qxODK+IAiCIPwAXU0IgiCIFg+vKllUk0UQBEH4AbqaEARBEC0eTcmiIIsgCILwA3Q1IQiCIFo8OqOqZJGFO0FcK+SpRgQ7/jiGKcgiCIIgWjwJnSLBGzgkpkQ29VAIImhRey55NrgliGBEPYY9+4jVFWpGTBAEQbR42naJwsOrhoBlmaYeCkEELRzHITIyEnl5eQCAkJAQMAz9pojgQZIkWK1W5OXlITIyEhxX/+wGCrIIgiAIAqAAiyD8QHx8PABogRZBBCORkZHasVxfKMgiCIIgCIIg/ALDMEhISEBcXBycTmdTD4cg6oxOp7smBUuFgiyCIAiCIAjCr3Ac55cbVYIIVsj4giAIgiAIgiAIwo9QkEUQBEEQBEEQBOFHKMgiCIIgCIIgCILwI1STVQtqM7KSkpImHglBEARBEARBEE2JGhPU1rCYgqxaKC0tBQAkJSU18UgIgiAIgiAIgggESktLERERUe18RqotDGvhiKKIS5cuwWw2U0O9IKWkpARJSUn4448/EB4e3tTDIVoAdMwRjQ0dc0RjQscb0dgE0jEnSRJKS0uRmJgIlq2+8oqUrFpgWRZt27Zt6mEQfiA8PLzJf5hEy4KOOaKxoWOOaEzoeCMam0A55mpSsFTI+IIgCIIgCIIgCMKPUJBFEARBEARBEAThRyjIIpo9BoMBixYtgsFgaOqhEC0EOuaIxoaOOaIxoeONaGyC8Zgj4wuCIAiCIAiCIAg/QkoWQRAEQRAEQRCEH6EgiyAIgiAIgiAIwo9QkEUQBEEQBEEQBOFHKMgiCIIgCIIgCILwIxRkEUHBq6++in79+sFsNiMuLg5jxozByZMnvZax2Wx4/PHHERMTg7CwMNx11124fPmyNv/q1asYOXIkEhMTYTAYkJSUhJkzZ6KkpMRrO3v37kWfPn1gMBjQqVMnbNy4sTHeIhFA+ON48+Tq1ato27YtGIZBUVGR1zw63gjAf8ccwzCVXps2bfJaho45AvDveW7jxo3o1asXjEYj4uLi8Pjjj3vN/+mnnzB48GAYjUYkJSVh+fLlDfreiMDDH8fbxo0bqzzHMQyDvLw8bbmAOcdJBBEEpKenSxs2bJB++eUXKTMzUxo1apSUnJwsWSwWbZnp06dLSUlJ0u7du6Xvv/9euuWWW6SBAwdq8wsKCqR169ZJR44ckc6dOyd98803UpcuXaQJEyZoy/z+++9SSEiINHv2bOnYsWPSm2++KXEcJ+3cubNR3y/RtPjjePNk9OjR0p/+9CcJgFRYWKhNp+ONUPHXMQdA2rBhg5STk6O9ysvLtfl0zBEq/jrmVq5cKSUmJkofffSR9Ntvv0lZWVnSl19+qc0vLi6WWrduLd13333SL7/8In388ceSyWSS1q9f32jvlWh6/HG8Wa1Wr3NbTk6OlJ6eLqWmpmrLBNI5joIsIijJy8uTAEj79u2TJEmSioqKJJ1OJ3366afaMsePH5cASAcPHqx2O2+88YbUtm1b7e+5c+dKPXr08Fpm/PjxUnp6up/fARFMXMvxtm7dOik1NVXavXt3pSCLjjeiOup7zAGQvvjii2q3S8ccUR31OeYKCgokk8kkffPNN9Vud926dVJUVJRkt9u1afPmzZO6dOnSQO+ECAb8cR+Xl5cn6XQ66cMPP9SmBdI5jtIFiaCkuLgYABAdHQ0AOHr0KJxOJ4YPH64t07VrVyQnJ+PgwYNVbuPSpUv4/PPPkZqaqk07ePCg1zYAID09vdptEC2D+h5vx44dw4svvogPP/wQLFv5dEvHG1Ed13KOe/zxx9GqVSv0798f77//PiSPdph0zBHVUZ9jbteuXRBFERcvXkS3bt3Qtm1b3HPPPfjjjz+0dQ4ePIghQ4ZAr9dr09LT03Hy5EkUFhY2xlsjAhB/3Md9+OGHCAkJwd13361NC6RzHAVZRNAhiiKefPJJDBo0CD179gQA5ObmQq/XIzIy0mvZ1q1bIzc312vahAkTEBISgjZt2iA8PBzvvvuuNi83NxetW7eutI2SkhKUl5c3zBsiApr6Hm92ux0TJkzA66+/juTk5Cq3TccbURXXco578cUX8cknn2DXrl246667MGPGDLz55pvafDrmiKqo7zH3+++/QxRFvPLKK1i9ejU+++wzFBQUYMSIEXA4HNp2qjrm1HlEy+Na7+NU3nvvPUycOBEmk0mbFkjnOL5R90YQfuDxxx/HL7/8gv3799dr/VWrVmHRokU4deoUnn32WcyePRvr1q3z8yiJ5kJ9j7dnn30W3bp1w/33399AIyOaK9dyjnvhhRe0//fu3RtlZWV4/fXXMWvWLH8OkWhm1PeYE0URTqcTa9aswe233w4A+PjjjxEfH4+MjAykp6c3xHCJIOda7+MAWbE6fvw4/vGPf/hxZP6FlCwiqJg5cyb+/e9/IyMjA23bttWmx8fHw+FwVHJuu3z5MuLj472mxcfHo2vXrvjLX/6C9evX46233kJOTo42r6Jz0uXLlxEeHu71pIRoGVzL8bZnzx58+umn4HkePM/jtttuAwC0atUKixYt0rZDxxvhiT/OcZ7cfPPNuHDhAux2u7YdOuYIT67lmEtISAAAdO/eXZsfGxuLVq1aITs7W9tOVcecOo9oWfjrHPfuu+/ixhtvxE033eQ1PZDOcRRkEUGBJEmYOXMmvvjiC+zZswcdOnTwmn/TTTdBp9Nh9+7d2rSTJ08iOzsbAwYMqHa7oigCgHYDMmDAAK9tAHLOeU3bIJof/jjeNm/ejKysLGRmZiIzM1NLS/3Pf/6j2RvT8UaoNNQ5LjMzE1FRUTAYDADomCPc+OOYGzRokDZdpaCgAPn5+WjXrh0A+Zj79ttv4XQ6tWV27dqFLl26ICoqqsHeHxFY+PMcZ7FY8Mknn2Dq1KmV9hNQ57hGt9ogiHrw2GOPSREREdLevXu9rDutVqu2zPTp06Xk5GRpz5490vfffy8NGDBAGjBggDZ/27Zt0vvvvy/9/PPP0tmzZ6V///vfUrdu3aRBgwZpy6jWn88884x0/Phx6W9/+xvZG7dA/HG8VSQjI6NaC3c63gh/HHNbt26V3nnnHennn3+WTp8+La1bt04KCQmRFi5cqC1Dxxyh4q/z3OjRo6UePXpIBw4ckH7++WfpjjvukLp37y45HA5JkmTXuNatW0uTJk2SfvnlF2nTpk1SSEgIWbi3MPx5XX333Xclo9HodT1VCaRzHAVZRFAAoMrXhg0btGXKy8ulGTNmSFFRUVJISIg0duxYKScnR5u/Z88eacCAAVJERIRkNBqlzp07S/Pmzav0I83IyJBuvPFGSa/XSx07dvTaB9Ey8MfxVpGqgix1Oh1vhD+OuR07dkg33nijFBYWJoWGhko33HCD9Pe//10SBMFrX3TMEZLkv/NccXGx9NBDD0mRkZFSdHS0NHbsWCk7O9trmaysLOnWW2+VDAaD1KZNG2nZsmWN8RaJAMKf19UBAwZIEydOrHZfgXKOYyTJw9uVIAiCIAiCIAiCuCaoJosgCIIgCIIgCMKPUJBFEARBEARBEAThRyjIIgiCIAiCIAiC8CMUZBEEQRAEQRAEQfgRCrIIgiAIgiAIgiD8CAVZBEEQBEEQBEEQfoSCLIIgCIIgCIIgCD9CQRZBEARBEARBEIQfoSCLIAiCIAiCIAjCj1CQRRAEQbQoJEnC8OHDkZ6eXmneunXrEBkZiQsXLjTByAiCIIjmAgVZBEEQRIuCYRhs2LABhw4dwvr167XpZ8+exdy5c/Hmm2+ibdu2ft2n0+n06/YIgiCIwIaCLIIgCKLFkZSUhDfeeANPP/00zp49C0mSMHXqVNx+++3o3bs3/vSnPyEsLAytW7fGpEmTkJ+fr627c+dO3HrrrYiMjERMTAzuuOMOnDlzRpt/7tw5MAyDf/3rX0hNTYXRaMRHH33UFG+TIAiCaCIYSZKkph4EQRAEQTQFY8aMQXFxMf76179i6dKl+PXXX9GjRw9MmzYNDzzwAMrLyzFv3jy4XC7s2bMHALB582YwDINevXrBYrFg4cKFOHfuHDIzM8GyLM6dO4cOHTqgffv2WLlyJXr37g2j0YiEhIQmfrcEQRBEY0FBFkEQBNFiycvLQ48ePVBQUIDNmzfjl19+wX/+8x989dVX2jIXLlxAUlISTp48iZSUlErbyM/PR2xsLH7++Wf07NlTC7JWr16N//mf/2nMt0MQBEEECJQuSBAEQbRY4uLi8Oijj6Jbt24YM2YMsrKykJGRgbCwMO3VtWtXANBSAk+fPo0JEyagY8eOCA8PR/v27QEA2dnZXtvu27dvo74XgiAIInDgm3oABEEQBNGU8DwPnpcvhxaLBXfeeSdee+21Ssup6X533nkn2rVrh3feeQeJiYkQRRE9e/aEw+HwWj40NLThB08QBEEEJBRkEQRBEIRCnz59sHnzZrRv314LvDy5evUqTp48iXfeeQeDBw8GAOzfv7+xh0kQBEEEOJQuSBAEQRAKjz/+OAoKCjBhwgQcOXIEZ86cwVdffYUpU6ZAEARERUUhJiYGb7/9Nn777Tfs2bMHs2fPbuphEwRBEAEGBVkEQRAEoZCYmIgDBw5AEATcfvvtuP766/Hkk08iMjISLMuCZVls2rQJR48eRc+ePfHUU0/h9ddfb+phEwRBEAEGuQsSBEEQBEEQBEH4EVKyCIIgCIIgCIIg/AgFWQRBEARBEARBEH6EgiyCIAiCIAiCIAg/QkEWQRAEQRAEQRCEH6EgiyAIgiAIgiAIwo9QkEUQBEEQBEEQBOFHKMgiCIIgCIIgCILwIxRkEQRBEARBEARB+BEKsgiCIAiCIAiCIPwIBVkEQRAEQRAEQRB+hIIsgiAIgiAIgiAIP/L/AXeWoioOil3VAAAAAElFTkSuQmCC" }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 34 + "execution_count": 59 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-03T11:32:12.479307Z", + "start_time": "2025-01-03T11:32:12.476573Z" + } + }, + "cell_type": "code", + "source": "", + "id": "a6f75ad676cb7db5", + "outputs": [], + "execution_count": 47 }, { "metadata": {}, @@ -5287,7 +5300,7 @@ "outputs": [], "execution_count": null, "source": "", - "id": "a6f75ad676cb7db5" + "id": "d99dea658199bd53" } ], "metadata": { diff --git a/src/scripts/climate_change/grid_malawi_CMIP6.py b/src/scripts/climate_change/grid_malawi_CMIP6.py index e660fdc81f..29988e9f01 100644 --- a/src/scripts/climate_change/grid_malawi_CMIP6.py +++ b/src/scripts/climate_change/grid_malawi_CMIP6.py @@ -1,14 +1,16 @@ import glob import os import re + import geopandas as gpd +import matplotlib.cm as cm import matplotlib.pyplot as plt import numpy as np import pandas as pd +from matplotlib import colors as mcolors from netCDF4 import Dataset from shapely.geometry import Polygon -import matplotlib.cm as cm -from matplotlib import colors as mcolors + # Load netCDF data for gridding info #file_path = "/Users/rem76/Downloads/821bebfbcee0609d233c09e8b2bbc1f3/pr_Amon_UKESM1-0-LL_ssp119_r1i1p1f2_gn_20150116-20991216.nc" file_path_historical_data = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/2011/60ab007aa16d679a32f9c3e186d2f744.nc" diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index a24a5280cc..81a1fd7c36 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -1,10 +1,10 @@ +import joblib import matplotlib.pyplot as plt import numpy as np import pandas as pd import statsmodels.api as sm +from statsmodels.genmod.families import NegativeBinomial, Poisson from statsmodels.genmod.generalized_linear_model import GLM -from statsmodels.genmod.families import Poisson, NegativeBinomial -import joblib ANC = True daily_max = False @@ -529,7 +529,7 @@ def repeat_info(info, num_facilities, year_range, historical): data_path = "/Users/rem76/Desktop/Climate_change_health/Data/" # Define SSP scenario -ssp_scenario = "ssp245" # Change this to "ssp5_8_5" as needed +ssp_scenario = "ssp585" # Change this to "ssp585" as needed # Load and preprocess weather data if use_all_weather: @@ -648,9 +648,7 @@ def repeat_info(info, num_facilities, year_range, historical): X_basis_weather_filtered = X_basis_weather[X_basis_weather[:, 0] > mask_threshold] # format output -print(X_basis_weather_filtered[:, 3]) year_month_labels = np.array([f"{y}-{m}" for y, m in zip(X_basis_weather_filtered[:, 2], X_basis_weather[:, 3])]) -print(year_month_labels) predictions_weather = results_of_weather_model.predict(X_basis_weather_filtered) if log_y: data_weather_predictions = pd.DataFrame({ diff --git a/src/scripts/climate_change/linear_model_historical_relationship_reporting_precipitation_missing_data.py b/src/scripts/climate_change/linear_model_historical_relationship_reporting_precipitation_missing_data.py index 3c4fecd5e3..655fd9a9ec 100644 --- a/src/scripts/climate_change/linear_model_historical_relationship_reporting_precipitation_missing_data.py +++ b/src/scripts/climate_change/linear_model_historical_relationship_reporting_precipitation_missing_data.py @@ -1,10 +1,10 @@ +import joblib import matplotlib.pyplot as plt import numpy as np import pandas as pd import statsmodels.api as sm -from statsmodels.genmod.generalized_linear_model import GLM from statsmodels.genmod.families import Binomial -import joblib +from statsmodels.genmod.generalized_linear_model import GLM min_year_for_analyis = 2015 absolute_min_year = 2011 diff --git a/src/scripts/climate_change/linear_model_predicting_CMIP6.py b/src/scripts/climate_change/linear_model_predicting_CMIP6.py index ad27671220..54ed19a01e 100644 --- a/src/scripts/climate_change/linear_model_predicting_CMIP6.py +++ b/src/scripts/climate_change/linear_model_predicting_CMIP6.py @@ -1,7 +1,7 @@ +import joblib import matplotlib.pyplot as plt import numpy as np import pandas as pd -import joblib # Configuration and constants ANC = True diff --git a/src/scripts/climate_change/plot_raw_data_CMIP6.py b/src/scripts/climate_change/plot_raw_data_CMIP6.py index 7d3017efd7..c73a0b86a5 100644 --- a/src/scripts/climate_change/plot_raw_data_CMIP6.py +++ b/src/scripts/climate_change/plot_raw_data_CMIP6.py @@ -1,11 +1,12 @@ +import math + import geopandas as gpd +import imageio.v2 as imageio +import matplotlib.animation as animation import matplotlib.pyplot as plt import numpy as np import pandas as pd from netCDF4 import Dataset -import matplotlib.animation as animation -import math -import imageio.v2 as imageio # Load the dataset and the variable file_path = "/Users/rem76/Downloads/821bebfbcee0609d233c09e8b2bbc1f3/pr_Amon_UKESM1-0-LL_ssp119_r1i1p1f2_gn_20150116-20991216.nc" diff --git a/src/scripts/climate_change/process_CMIP6_data.py b/src/scripts/climate_change/process_CMIP6_data.py index ae637be828..e39a1a02eb 100644 --- a/src/scripts/climate_change/process_CMIP6_data.py +++ b/src/scripts/climate_change/process_CMIP6_data.py @@ -1,15 +1,15 @@ +import difflib import glob import os import re import shutil import zipfile from pathlib import Path -import difflib +import geopandas as gpd import numpy as np import pandas as pd from netCDF4 import Dataset -import geopandas as gpd five_day = False monthly_cumulative = True diff --git a/src/scripts/climate_change/process_CMIP6_data_KDBall.py b/src/scripts/climate_change/process_CMIP6_data_KDBall.py index f123f6d070..5e237919fb 100644 --- a/src/scripts/climate_change/process_CMIP6_data_KDBall.py +++ b/src/scripts/climate_change/process_CMIP6_data_KDBall.py @@ -1,16 +1,16 @@ +import difflib import glob import os import re import shutil import zipfile from pathlib import Path -import difflib -from scipy.spatial import KDTree +import geopandas as gpd import numpy as np import pandas as pd from netCDF4 import Dataset -import geopandas as gpd +from scipy.spatial import KDTree ANC = True Inpatient = False From 8018c8fc90ed118c645604e5d9709ce1dad4eed5 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 6 Jan 2025 09:23:33 +0000 Subject: [PATCH 148/291] Put era5 and CMIP6 on same graph Issues with CI --- .../plotting_heavy_precipitation.py | 130 ++++++++++++------ 1 file changed, 85 insertions(+), 45 deletions(-) diff --git a/src/scripts/climate_change/plotting_heavy_precipitation.py b/src/scripts/climate_change/plotting_heavy_precipitation.py index 0db4fb9c53..17f57a3a98 100644 --- a/src/scripts/climate_change/plotting_heavy_precipitation.py +++ b/src/scripts/climate_change/plotting_heavy_precipitation.py @@ -1,53 +1,93 @@ import argparse +import os from pathlib import Path +import matplotlib.pyplot as plt import numpy as np import pandas as pd +import xarray as xr from matplotlib import pyplot as plt +# Load ERA5 data +era5_data_xr = xr.open_dataset('/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/monthly_data/724bab97773bb7ba4e1635356ad0d12.nc') +era5_data_xr_until_2024 = era5_data_xr.sel(date=slice('20110101', '20250101')) +era5_data_xr_until_2024['date'] = pd.to_datetime(era5_data_xr_until_2024['date'], format='%Y%m%d') +era5_data_xr_until_2024 = era5_data_xr_until_2024.mean(dim=["latitude", "longitude"]) +dates = pd.to_datetime(era5_data_xr_until_2024['date'].values) +days_in_month = dates.to_series().dt.days_in_month +era5_data_xr_until_2024 = era5_data_xr_until_2024 * days_in_month.values +era5_precipitation_data = era5_data_xr_until_2024['tp'].resample(date='Y').sum('date') +print(era5_precipitation_data) +# Plot ERA5 annual precipitation data +plt.plot(era5_precipitation_data * 1000, color="blue", linewidth=2, linestyle='--', marker='s', markersize=4, label='ERA5') +plt.show() # -# def apply(results_folder: Path, output_folder: Path): -output_folder = Path("/Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/Climate_health") - -all_data_max_5_day_precip = pd.ExcelFile( - '/Users/rem76/Documents/Climate_change_data/Max_5_day_precip/ssp126/cmip6-x0.25_timeseries_rx5day_timeseries_seasonal_2015-2100_p90_ssp126_ensemble_all.xlsx') -median_max_5_day_precip = pd.read_excel(all_data_max_5_day_precip, 'median') -median_max_5_day_precip.drop("code", inplace=True, axis=1) -p10_max_5_day_precip = pd.read_excel(all_data_max_5_day_precip, 'p10') -p10_max_5_day_precip.drop("code", inplace=True, axis=1) -p90_max_5_day_precip = pd.read_excel(all_data_max_5_day_precip, 'p90') -p90_max_5_day_precip.drop("code", inplace=True, axis=1) - -median_values = pd.to_numeric( - median_max_5_day_precip[median_max_5_day_precip['name'] == 'Central Region'].iloc[0, 1:].values, errors='coerce') -p10_values = pd.to_numeric(p10_max_5_day_precip[median_max_5_day_precip['name'] == 'Central Region'].iloc[0, 1:].values, - errors='coerce') -p90_values = pd.to_numeric(p90_max_5_day_precip[median_max_5_day_precip['name'] == 'Central Region'].iloc[0, 1:].values, - errors='coerce') -median_values = np.nan_to_num(median_values, nan=0.0, posinf=0.0, neginf=0.0) -p10_values = np.nan_to_num(p10_values, nan=0.0, posinf=0.0, neginf=0.0) -p90_values = np.nan_to_num(p90_values, nan=0.0, posinf=0.0, neginf=0.0) -name_of_plot = f'Max 5-day precipitation (mm) under ssp126' -x_labels = [p10_max_5_day_precip.columns[i] if i % 4 == 0 and i >= 2 else "" for i in range(len(median_values))] - -make_graph_file_name = lambda stub: output_folder / f"Precipitation_by_region_{stub}.png" # noqa: E731 - -fig, ax = plt.subplots(figsize=(20, 10)) -ax.plot(range(len(median_values)), median_values, label='Central Region', color='red', marker='o') -ax.fill_between(range(len(median_values)), p10_values, p90_values, color="grey", alpha=0.3) -ax.set_title(name_of_plot, {'size': 12, 'color': 'black'}) -ax.set_xticks(range(len(x_labels))) -ax.set_xticklabels(x_labels, rotation=45, ha='right') -fig.savefig(make_graph_file_name(name_of_plot)) -ax.set_title(name_of_plot, {'size': 12, 'color': 'black'}) -print(make_graph_file_name(name_of_plot)) -fig.savefig(make_graph_file_name(name_of_plot)) -plt.close(fig) -# -# if __name__ == "__main__": -# parser = argparse.ArgumentParser() -# parser.add_argument("results_folder", type=Path) -# args = parser.parse_args() -# apply( -# results_folder=args.results_folder, -# output_folder=args.results_folder) +# Load CMIP6 downscaled data +base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data" +scenario = "ssp585" +scenario_directory = os.path.join(base_dir, scenario) +file_path_downscaled = f"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/CIL_subsetted_all_model_{scenario}.nc" +data_all_models = xr.open_dataset(file_path_downscaled) + +pr_aggregated = data_all_models.mean(dim=["model", 'lat', 'lon'], skipna=True) +pr_aggregated_annual = pr_aggregated['pr'].resample(time='Y').sum('time') + +std_pr = pr_aggregated_annual.std(dim=["model", 'lat', 'lon'], skipna=True) +std_pr_annual = std_pr['pr'].resample(time='Y').sum('time') + +# Print results +upper_bound = pr_aggregated_annual + std_pr_annual +lower_bound = pr_aggregated_annual - std_pr_annual + +# Plot annual precipitation with confidence interval +plt.figure(figsize=(10, 6)) +plt.plot(pr_aggregated_annual, color="blue", linewidth=2, linestyle='--', marker='s', markersize=4, label='Annual Precipitation') +plt.fill_between(range(0,len(pr_aggregated_annual)), lower_bound.values, upper_bound.values, color="blue", alpha=0.2, label="95% Confidence Interval") + +# Labels and title +plt.xlabel("Time") +plt.ylabel("Annual Precipitation (mm)") +plt.title(f"Annual Precipitation for {scenario} (with 95% Confidence Interval)") +plt.legend() +plt.show() + +## Plot together +plt.figure(figsize=(12, 7)) + +plt.plot( + range(0, len(era5_precipitation_data)), + era5_precipitation_data * 1000, + color="#1C6E8C", + linewidth=2, + linestyle='--', + marker='o', + markersize=6, + label='ERA5 Precipitation', +) + +plt.plot( + range(len(era5_precipitation_data) , len(era5_precipitation_data) + len(pr_aggregated_annual) - 1), + pr_aggregated_annual[:-1], + color="#9AC4F8", + linewidth=2, + linestyle='-', + marker='s', + markersize=6, + label=f'CMIP6 Scenario {scenario}', +) + +plt.fill_between( + range(len(era5_precipitation_data), len(era5_precipitation_data) + len(pr_aggregated_annual)), + lower_bound.values, + upper_bound.values, + color="#9AC4F8", + alpha=0.3, +) +years = np.arange(2011, 2071, 5) # Array of years from 2011 to 2070 +plt.xticks(np.linspace(0, len(era5_precipitation_data) + len(pr_aggregated_annual) - 1, len(years)), years) +plt.xlabel("Time (Years)", fontsize=14, labelpad=10) +plt.ylabel("Annual Precipitation (mm)", fontsize=14, labelpad=10) +plt.legend(loc="upper left", fontsize=12, frameon=True, shadow=True, fancybox=True) +plt.tight_layout() +plt.show() + From 7bbf91afa41037e0144185620ff3bb2da93623d6 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 6 Jan 2025 09:47:29 +0000 Subject: [PATCH 149/291] Added loop for going over each scenario of the CMIP6 and then the median/highest/lowest models --- ...al_realtionship_reporting_precipitation.py | 473 +++++++++--------- 1 file changed, 246 insertions(+), 227 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 81a1fd7c36..352b17fbaa 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -521,7 +521,31 @@ def repeat_info(info, num_facilities, year_range, historical): ############### ADD IN CMIP DATA ########################### - +def get_weather_data(ssp_scenario, model_type): + if model_type == 'highest': + file_suffix = 'highest' + elif model_type == 'median': + file_suffix = 'median' + elif model_type == 'lowest': + file_suffix = 'lowest' + else: + raise ValueError("Model type must be one of 'highest', 'median', or 'lowest'") + + weather_data_prediction_five_day_cumulative_original = pd.read_csv( + f"{data_path}Precipitation_data/Downscaled_CMIP6_data_CIL/{ssp_scenario}/{file_suffix}_model_daily_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{ssp_scenario}.csv", + dtype={'column_name': 'float64'} + ) + weather_data_prediction_monthly_original = pd.read_csv( + f"{data_path}Precipitation_data/Downscaled_CMIP6_data_CIL/{ssp_scenario}/{file_suffix}_model_monthly_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{ssp_scenario}.csv", + dtype={'column_name': 'float64'} + ) + + weather_data_prediction_monthly_df = weather_data_prediction_monthly_original.drop(columns=zero_sum_columns) + weather_data_prediction_five_day_cumulative_df = weather_data_prediction_five_day_cumulative_original.drop( + columns=zero_sum_columns) + + return weather_data_prediction_five_day_cumulative_df, weather_data_prediction_monthly_df +model_types = ['lowest', 'median', 'highest'] # Configuration and constants min_year_for_analysis = 2025 absolute_min_year = 2025 @@ -529,233 +553,228 @@ def repeat_info(info, num_facilities, year_range, historical): data_path = "/Users/rem76/Desktop/Climate_change_health/Data/" # Define SSP scenario -ssp_scenario = "ssp585" # Change this to "ssp585" as needed +ssp_scenarios = ["ssp245", "ssp585"] # Load and preprocess weather data -if use_all_weather: - weather_data_prediction_five_day_cumulative_original = pd.read_csv( - f"{data_path}Precipitation_data/Downscaled_CMIP6_data_CIL/{ssp_scenario}/highest_model_daily_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{ssp_scenario}.csv", - dtype={'column_name': 'float64'}) - weather_data_prediction_monthly_original = pd.read_csv( - f"{data_path}Precipitation_data/Downscaled_CMIP6_data_CIL/{ssp_scenario}/highest_model_monthly_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{ssp_scenario}.csv", - dtype={'column_name': 'float64'}) - weather_data_prediction_monthly_df = weather_data_prediction_monthly_original.drop(columns=zero_sum_columns) - weather_data_prediction_five_day_cumulative_df = weather_data_prediction_five_day_cumulative_original.drop(columns=zero_sum_columns) - - lag_1_month_prediction = weather_data_prediction_monthly_df.shift(1).values - lag_2_month_prediction = weather_data_prediction_monthly_df.shift(2).values - lag_3_month_prediction = weather_data_prediction_monthly_df.shift(3).values - lag_4_month_prediction = weather_data_prediction_monthly_df.shift(4).values - - lag_1_month_prediction = lag_1_month_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() - lag_2_month_prediction = lag_2_month_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() - lag_3_month_prediction = lag_3_month_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() - lag_4_month_prediction = lag_4_month_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() - - lag_1_5_day_prediction = weather_data_prediction_five_day_cumulative_df.shift(1).values - lag_2_5_day_prediction = weather_data_prediction_five_day_cumulative_df.shift(2).values - lag_3_5_day_prediction = weather_data_prediction_five_day_cumulative_df.shift(3).values - lag_4_5_day_prediction = weather_data_prediction_five_day_cumulative_df.shift(4).values - - lag_1_5_day_prediction = lag_1_5_day_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() - lag_2_5_day_prediction = lag_2_5_day_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() - lag_3_5_day_prediction = lag_3_5_day_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() - lag_4_5_day_prediction = lag_4_5_day_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() - weather_data_prediction_five_day_cumulative = weather_data_prediction_five_day_cumulative_df # keep these seperate for binary features - - # need for binary comparison - lag_12_month = weather_data_prediction_monthly_df.shift(12).values - lag_12_month = lag_12_month[(min_year_for_analysis - absolute_min_year) * 12:].flatten() - - weather_data_prediction_monthly = weather_data_prediction_monthly_df # keep these seperate for binary features - - weather_data_prediction_five_day_cumulative = weather_data_prediction_five_day_cumulative.iloc[(min_year_for_analysis - absolute_min_year) * 12:] - weather_data_prediction_monthly = weather_data_prediction_monthly.iloc[(min_year_for_analysis - absolute_min_year) * 12:] - weather_data_prediction_monthly_flattened = weather_data_prediction_monthly.values.flatten() - weather_data_prediction_five_day_cumulative_flattened = weather_data_prediction_five_day_cumulative.values.flatten() - weather_data_prediction_flatten = np.vstack((weather_data_prediction_monthly_flattened, weather_data_prediction_five_day_cumulative_flattened)).T - num_facilities = len(weather_data_prediction_monthly.columns) -else: - if five_day: - weather_data_prediction = pd.read_csv( - f"{data_path}Precipitation_data/Downscaled_CMIP6_data/{ssp_scenario}/prediction_weather_by_smaller_facilities_with_ANC_lm.csv", index_col=0, - dtype={'column_name': 'float64'}) - else: - weather_data_prediction = pd.read_csv( - f"{data_path}Precipitation_data/Downscaled_CMIP6_data/{ssp_scenario}/prediction_weather_monthly_by_smaller_facilities_with_ANC_lm.csv", - index_col=0, dtype={'column_name': 'float64'}) - weather_data_prediction = weather_data_prediction.iloc[(min_year_for_analysis - absolute_min_year) * 12:] - weather_data_prediction_flatten = weather_data_prediction.values.flatten() - num_facilities = len(weather_data_prediction.columns) - -missing_facility = [col for col in expanded_facility_info.index if col not in weather_data_prediction_monthly.columns] -expanded_facility_info = expanded_facility_info.drop(missing_facility) -year_range_prediction = range(min_year_for_analysis, max_year_for_analysis) -month_repeated_prediction = [m for _ in year_range_prediction for m in range(1, 13)] -year_flattened_prediction = np.repeat(year_range_prediction, 12 * num_facilities) -month_flattened_prediction = month_repeated_prediction * num_facilities -facility_flattened_prediction = np.tile(range(num_facilities), len(year_flattened_prediction) // num_facilities) -# Encode facilities and create above/below average weather data -facility_encoded_prediction = pd.get_dummies(facility_flattened_prediction, drop_first=True) - -# Load and preprocess facility information -zone_info_prediction = repeat_info(expanded_facility_info["Zonename"], num_facilities, year_range_prediction, historical = False) -zone_encoded_prediction = pd.get_dummies(zone_info_prediction, drop_first=True) - -resid_info_prediction = repeat_info(expanded_facility_info['Resid'], num_facilities, year_range_prediction, historical = False) - -resid_encoded_prediction = pd.get_dummies(resid_info_prediction, drop_first=True) -owner_info_prediction = repeat_info(expanded_facility_info['A105'], num_facilities, year_range_prediction, historical = False) -owner_encoded_prediction = pd.get_dummies(owner_info_prediction, drop_first=True) -ftype_info_prediction = repeat_info(expanded_facility_info['Ftype'], num_facilities, year_range_prediction, historical = False) -ftype_encoded_prediction = pd.get_dummies(ftype_info_prediction, drop_first=True) -altitude_prediction = [float(x) for x in repeat_info(expanded_facility_info['A109__Altitude'],num_facilities, year_range_prediction, historical = False)] -minimum_distance_prediction = [float(x) for x in repeat_info(expanded_facility_info['minimum_distance'],num_facilities, year_range_prediction, historical = False)] -# minimum_distance_prediction = np.nan_to_num(minimum_distance_prediction, nan=np.nan, posinf=np.nan, neginf=np.nan) # just in case - -altitude_prediction = np.array(altitude_prediction) -altitude_prediction = np.where(altitude_prediction < 0, np.nan, altitude_prediction) -mean_altitude_prediction = round(np.nanmean(altitude_prediction)) -altitude_prediction = np.where(np.isnan(altitude_prediction), float(mean_altitude), altitude_prediction) -altitude_prediction = np.nan_to_num(altitude_prediction, nan=mean_altitude_prediction, posinf=mean_altitude_prediction, neginf=mean_altitude_prediction) -altitude_prediction = list(altitude_prediction) - -minimum_distance_prediction = np.nan_to_num(minimum_distance_prediction, nan=np.nan, posinf=np.nan, neginf=np.nan) # just in case - -# Weather data - -X_basis_weather = np.column_stack([ - weather_data_prediction_flatten, - np.array(year_flattened_prediction), - np.array(month_flattened_prediction), - resid_encoded_prediction, - zone_encoded_prediction, - owner_encoded_prediction, - ftype_encoded_prediction, - lag_1_month_prediction, - lag_2_month_prediction, - lag_3_month_prediction, - lag_4_month_prediction, - lag_1_5_day_prediction, - lag_2_5_day_prediction, - lag_3_5_day_prediction, - lag_4_5_day_prediction, - facility_encoded_prediction, - altitude_prediction, - minimum_distance_prediction, - #above_below_X_prediction -]) - -X_basis_weather_filtered = X_basis_weather[X_basis_weather[:, 0] > mask_threshold] -# format output -year_month_labels = np.array([f"{y}-{m}" for y, m in zip(X_basis_weather_filtered[:, 2], X_basis_weather[:, 3])]) -predictions_weather = results_of_weather_model.predict(X_basis_weather_filtered) -if log_y: - data_weather_predictions = pd.DataFrame({ - 'Year_Month': year_month_labels, - 'y_pred_weather': np.exp(predictions_weather) - }) -else: - data_weather_predictions = pd.DataFrame({ - 'Year_Month': year_month_labels, - 'y_pred_weather': predictions_weather - }) - -if use_residuals: - predictions = results_of_weather_model.predict(X_basis_weather_filtered) -else: - X_bases_ANC = np.column_stack([ - year_flattened_prediction, - month_flattened_prediction, - resid_encoded_prediction, - zone_encoded_prediction, - owner_encoded_prediction, - ftype_encoded_prediction, - facility_encoded_prediction, - altitude_prediction, - minimum_distance_prediction - ]) - - y_pred_ANC = results.predict(X_bases_ANC) - if log_y: - predictions = np.exp(predictions_weather) - np.exp(y_pred_ANC[X_basis_weather[:, 0] > mask_threshold]) - data_weather_predictions['y_pred_no_weather'] = np.exp(y_pred_ANC[X_basis_weather[:, 0] > mask_threshold]) - - else: - predictions = predictions_weather - y_pred_ANC[X_basis_weather[:, 0] > mask_threshold] - data_weather_predictions['y_pred_no_weather'] = y_pred_ANC[X_basis_weather[:, 0] > mask_threshold] - - -data_weather_predictions['difference_in_expectation'] = predictions -data_weather_predictions['weather'] = X_basis_weather[X_basis_weather[:, 0] > mask_threshold, 0] -data_weather_predictions_grouped = data_weather_predictions.groupby('Year_Month').mean().reset_index() - -# Plotting results -fig, axs = plt.subplots(1, 2, figsize=(14, 6)) -#axs[0].scatter(data_weather_predictions['Year_Month'], data_weather_predictions['difference_in_expectation'], color='#9AC4F8', alpha=0.1, label ='Predictions from weather model') -axs[0].scatter(data_weather_predictions_grouped['Year_Month'], data_weather_predictions_grouped['difference_in_expectation'], color='red', alpha=0.7, label='Mean of predictions') -axs[0].set_xlabel('Year/Month') -xticks = data_weather_predictions['Year_Month'][::len(year_range) * 12 * num_facilities] -axs[0].set_xticks(xticks) -axs[0].set_xticklabels(xticks, rotation=45, ha='right') -axs[0].set_ylabel('Difference Predicted ANC visits due to rainfall') -axs[0].legend(loc='upper left') -# -# # if log_y: -# # -# # axs[1].scatter(X_basis_weather_filtered[:, 0], np.exp(data_weather_predictions['y_pred_weather']), color='#9AC4F8', -# # alpha=0.3, label='Predictions of weather model') -# # axs[1].scatter(X_basis_weather_filtered[:, 0], np.exp(data_weather_predictions['y_pred_no_weather']), color='#9AC4F8', -# # alpha=1, label='Predictions of no weather model') -# # else: -# # axs[1].scatter(X_basis_weather_filtered[:, 0], data_weather_predictions['y_pred_weather'], color='#9AC4F8', alpha=0.7, -# # label='Predictions of weather model') -# # -# # axs[1].scatter(X_basis_weather_filtered[:, 0], data_weather_predictions['y_pred_no_weather'], color='#9AC4F8', alpha=1, -# # label='Predictions of no weather model') -# # axs[1].set_xlabel('Precipitation (mm)') -# # axs[1].set_ylabel('Frequency') -# # axs[1].legend() -#plt.tight_layout() -plt.show() - -fig, axs = plt.subplots(1, 2, figsize=(14, 6)) - -axs[0].scatter(data_weather_predictions['weather'],data_weather_predictions['difference_in_expectation'], color='#9AC4F8', alpha=0.1, - label='Predictions') +for ssp_scenario in ssp_scenarios: + for model_type in model_types: + if use_all_weather: + weather_data_prediction_five_day_cumulative_df, weather_data_prediction_monthly_df = get_weather_data(ssp_scenario, + model_type) + lag_1_month_prediction = weather_data_prediction_monthly_df.shift(1).values + lag_2_month_prediction = weather_data_prediction_monthly_df.shift(2).values + lag_3_month_prediction = weather_data_prediction_monthly_df.shift(3).values + lag_4_month_prediction = weather_data_prediction_monthly_df.shift(4).values + + lag_1_month_prediction = lag_1_month_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() + lag_2_month_prediction = lag_2_month_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() + lag_3_month_prediction = lag_3_month_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() + lag_4_month_prediction = lag_4_month_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() + + lag_1_5_day_prediction = weather_data_prediction_five_day_cumulative_df.shift(1).values + lag_2_5_day_prediction = weather_data_prediction_five_day_cumulative_df.shift(2).values + lag_3_5_day_prediction = weather_data_prediction_five_day_cumulative_df.shift(3).values + lag_4_5_day_prediction = weather_data_prediction_five_day_cumulative_df.shift(4).values + + lag_1_5_day_prediction = lag_1_5_day_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() + lag_2_5_day_prediction = lag_2_5_day_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() + lag_3_5_day_prediction = lag_3_5_day_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() + lag_4_5_day_prediction = lag_4_5_day_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() + weather_data_prediction_five_day_cumulative = weather_data_prediction_five_day_cumulative_df # keep these seperate for binary features + + # need for binary comparison + lag_12_month = weather_data_prediction_monthly_df.shift(12).values + lag_12_month = lag_12_month[(min_year_for_analysis - absolute_min_year) * 12:].flatten() + + weather_data_prediction_monthly = weather_data_prediction_monthly_df # keep these seperate for binary features + + weather_data_prediction_five_day_cumulative = weather_data_prediction_five_day_cumulative.iloc[(min_year_for_analysis - absolute_min_year) * 12:] + weather_data_prediction_monthly = weather_data_prediction_monthly.iloc[(min_year_for_analysis - absolute_min_year) * 12:] + weather_data_prediction_monthly_flattened = weather_data_prediction_monthly.values.flatten() + weather_data_prediction_five_day_cumulative_flattened = weather_data_prediction_five_day_cumulative.values.flatten() + weather_data_prediction_flatten = np.vstack((weather_data_prediction_monthly_flattened, weather_data_prediction_five_day_cumulative_flattened)).T + num_facilities = len(weather_data_prediction_monthly.columns) + else: + if five_day: + weather_data_prediction = pd.read_csv( + f"{data_path}Precipitation_data/Downscaled_CMIP6_data/{ssp_scenario}/prediction_weather_by_smaller_facilities_with_ANC_lm.csv", index_col=0, + dtype={'column_name': 'float64'}) + else: + weather_data_prediction = pd.read_csv( + f"{data_path}Precipitation_data/Downscaled_CMIP6_data/{ssp_scenario}/prediction_weather_monthly_by_smaller_facilities_with_ANC_lm.csv", + index_col=0, dtype={'column_name': 'float64'}) + weather_data_prediction = weather_data_prediction.iloc[(min_year_for_analysis - absolute_min_year) * 12:] + weather_data_prediction_flatten = weather_data_prediction.values.flatten() + num_facilities = len(weather_data_prediction.columns) + + missing_facility = [col for col in expanded_facility_info.index if col not in weather_data_prediction_monthly.columns] + expanded_facility_info = expanded_facility_info.drop(missing_facility) + year_range_prediction = range(min_year_for_analysis, max_year_for_analysis) + month_repeated_prediction = [m for _ in year_range_prediction for m in range(1, 13)] + year_flattened_prediction = np.repeat(year_range_prediction, 12 * num_facilities) + month_flattened_prediction = month_repeated_prediction * num_facilities + facility_flattened_prediction = np.tile(range(num_facilities), len(year_flattened_prediction) // num_facilities) + # Encode facilities and create above/below average weather data + facility_encoded_prediction = pd.get_dummies(facility_flattened_prediction, drop_first=True) + + # Load and preprocess facility information + zone_info_prediction = repeat_info(expanded_facility_info["Zonename"], num_facilities, year_range_prediction, historical = False) + zone_encoded_prediction = pd.get_dummies(zone_info_prediction, drop_first=True) + + resid_info_prediction = repeat_info(expanded_facility_info['Resid'], num_facilities, year_range_prediction, historical = False) + + resid_encoded_prediction = pd.get_dummies(resid_info_prediction, drop_first=True) + owner_info_prediction = repeat_info(expanded_facility_info['A105'], num_facilities, year_range_prediction, historical = False) + owner_encoded_prediction = pd.get_dummies(owner_info_prediction, drop_first=True) + ftype_info_prediction = repeat_info(expanded_facility_info['Ftype'], num_facilities, year_range_prediction, historical = False) + ftype_encoded_prediction = pd.get_dummies(ftype_info_prediction, drop_first=True) + altitude_prediction = [float(x) for x in repeat_info(expanded_facility_info['A109__Altitude'],num_facilities, year_range_prediction, historical = False)] + minimum_distance_prediction = [float(x) for x in repeat_info(expanded_facility_info['minimum_distance'],num_facilities, year_range_prediction, historical = False)] + # minimum_distance_prediction = np.nan_to_num(minimum_distance_prediction, nan=np.nan, posinf=np.nan, neginf=np.nan) # just in case + + altitude_prediction = np.array(altitude_prediction) + altitude_prediction = np.where(altitude_prediction < 0, np.nan, altitude_prediction) + mean_altitude_prediction = round(np.nanmean(altitude_prediction)) + altitude_prediction = np.where(np.isnan(altitude_prediction), float(mean_altitude), altitude_prediction) + altitude_prediction = np.nan_to_num(altitude_prediction, nan=mean_altitude_prediction, posinf=mean_altitude_prediction, neginf=mean_altitude_prediction) + altitude_prediction = list(altitude_prediction) + + minimum_distance_prediction = np.nan_to_num(minimum_distance_prediction, nan=np.nan, posinf=np.nan, neginf=np.nan) # just in case + + # Weather data + + X_basis_weather = np.column_stack([ + weather_data_prediction_flatten, + np.array(year_flattened_prediction), + np.array(month_flattened_prediction), + resid_encoded_prediction, + zone_encoded_prediction, + owner_encoded_prediction, + ftype_encoded_prediction, + lag_1_month_prediction, + lag_2_month_prediction, + lag_3_month_prediction, + lag_4_month_prediction, + lag_1_5_day_prediction, + lag_2_5_day_prediction, + lag_3_5_day_prediction, + lag_4_5_day_prediction, + facility_encoded_prediction, + altitude_prediction, + minimum_distance_prediction, + #above_below_X_prediction + ]) + + X_basis_weather_filtered = X_basis_weather[X_basis_weather[:, 0] > mask_threshold] + # format output + year_month_labels = np.array([f"{y}-{m}" for y, m in zip(X_basis_weather_filtered[:, 2], X_basis_weather[:, 3])]) + predictions_weather = results_of_weather_model.predict(X_basis_weather_filtered) + if log_y: + data_weather_predictions = pd.DataFrame({ + 'Year_Month': year_month_labels, + 'y_pred_weather': np.exp(predictions_weather) + }) + else: + data_weather_predictions = pd.DataFrame({ + 'Year_Month': year_month_labels, + 'y_pred_weather': predictions_weather + }) -axs[0].set_xlabel('Precipitation (mm)') -axs[0].set_ylabel('Difference in of ANC visits between weather and non-weather model') + if use_residuals: + predictions = results_of_weather_model.predict(X_basis_weather_filtered) + else: + X_bases_ANC = np.column_stack([ + year_flattened_prediction, + month_flattened_prediction, + resid_encoded_prediction, + zone_encoded_prediction, + owner_encoded_prediction, + ftype_encoded_prediction, + facility_encoded_prediction, + altitude_prediction, + minimum_distance_prediction + ]) + + y_pred_ANC = results.predict(X_bases_ANC) + if log_y: + predictions = np.exp(predictions_weather) - np.exp(y_pred_ANC[X_basis_weather[:, 0] > mask_threshold]) + data_weather_predictions['y_pred_no_weather'] = np.exp(y_pred_ANC[X_basis_weather[:, 0] > mask_threshold]) -plt.tight_layout() -plt.show() - -## Save predictions - -# Format output: Add all relevant X variables -full_data_weather_predictions = pd.DataFrame({ - 'Year': year_flattened_prediction[X_basis_weather[:, 0] > mask_threshold], - 'Month': np.array(month_flattened_prediction)[X_basis_weather[:, 0] > mask_threshold], - 'Facility_ID': facility_flattened_prediction[X_basis_weather[:, 0] > mask_threshold], - 'Altitude': np.array(altitude_prediction)[X_basis_weather[:, 0] > mask_threshold], - 'Zone': np.array(zone_info_prediction)[X_basis_weather[:, 0] > mask_threshold], - 'Resid': np.array(resid_info_prediction)[X_basis_weather[:, 0] > mask_threshold], - 'Owner': np.array(owner_info_prediction)[X_basis_weather[:, 0] > mask_threshold], - 'Facility_Type': np.array(ftype_info_prediction)[X_basis_weather[:, 0] > mask_threshold], - 'Precipitation': X_basis_weather[X_basis_weather[:, 0] > mask_threshold, 0], - 'Lag_1_Precipitation': np.array(lag_1_month_prediction)[X_basis_weather[:, 0] > mask_threshold], - 'Lag_2_Precipitation': np.array(lag_2_month_prediction)[X_basis_weather[:, 0] > mask_threshold], - 'Lag_3_Precipitation': np.array(lag_3_month_prediction)[X_basis_weather[:, 0] > mask_threshold], - 'Lag_4_Precipitation': np.array(lag_4_month_prediction)[X_basis_weather[:, 0] > mask_threshold], - 'Predicted_Weather_Model': np.exp(predictions_weather), - 'Predicted_No_Weather_Model': np.exp(y_pred_ANC[X_basis_weather[:, 0] > mask_threshold]), - 'Difference_in_Expectation': predictions, -}) - -# Save the results -full_data_weather_predictions.to_csv(f"{data_path}weather_predictions_with_X_{ssp_scenario}.csv", index=False) - -X_basis_weather_filtered = pd.DataFrame(X_basis_weather_filtered) - -# Save to CSV -X_basis_weather_filtered.to_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/X_basis_weather_filtered_predictions_{ssp_scenario}.csv', index=False) + else: + predictions = predictions_weather - y_pred_ANC[X_basis_weather[:, 0] > mask_threshold] + data_weather_predictions['y_pred_no_weather'] = y_pred_ANC[X_basis_weather[:, 0] > mask_threshold] + + + data_weather_predictions['difference_in_expectation'] = predictions + data_weather_predictions['weather'] = X_basis_weather[X_basis_weather[:, 0] > mask_threshold, 0] + data_weather_predictions_grouped = data_weather_predictions.groupby('Year_Month').mean().reset_index() + + # Plotting results + fig, axs = plt.subplots(1, 2, figsize=(14, 6)) + #axs[0].scatter(data_weather_predictions['Year_Month'], data_weather_predictions['difference_in_expectation'], color='#9AC4F8', alpha=0.1, label ='Predictions from weather model') + axs[0].scatter(data_weather_predictions_grouped['Year_Month'], data_weather_predictions_grouped['difference_in_expectation'], color='red', alpha=0.7, label='Mean of predictions') + axs[0].set_xlabel('Year/Month') + xticks = data_weather_predictions['Year_Month'][::len(year_range) * 12 * num_facilities] + axs[0].set_xticks(xticks) + axs[0].set_xticklabels(xticks, rotation=45, ha='right') + axs[0].set_ylabel('Difference Predicted ANC visits due to rainfall') + axs[0].legend(loc='upper left') + # + # # if log_y: + # # + # # axs[1].scatter(X_basis_weather_filtered[:, 0], np.exp(data_weather_predictions['y_pred_weather']), color='#9AC4F8', + # # alpha=0.3, label='Predictions of weather model') + # # axs[1].scatter(X_basis_weather_filtered[:, 0], np.exp(data_weather_predictions['y_pred_no_weather']), color='#9AC4F8', + # # alpha=1, label='Predictions of no weather model') + # # else: + # # axs[1].scatter(X_basis_weather_filtered[:, 0], data_weather_predictions['y_pred_weather'], color='#9AC4F8', alpha=0.7, + # # label='Predictions of weather model') + # # + # # axs[1].scatter(X_basis_weather_filtered[:, 0], data_weather_predictions['y_pred_no_weather'], color='#9AC4F8', alpha=1, + # # label='Predictions of no weather model') + # # axs[1].set_xlabel('Precipitation (mm)') + # # axs[1].set_ylabel('Frequency') + # # axs[1].legend() + #plt.tight_layout() + plt.show() + + fig, axs = plt.subplots(1, 2, figsize=(14, 6)) + + axs[0].scatter(data_weather_predictions['weather'],data_weather_predictions['difference_in_expectation'], color='#9AC4F8', alpha=0.1, + label='Predictions') + + axs[0].set_xlabel('Precipitation (mm)') + axs[0].set_ylabel('Difference in of ANC visits between weather and non-weather model') + + plt.tight_layout() + plt.show() + + ## Save predictions + + # Format output: Add all relevant X variables + full_data_weather_predictions = pd.DataFrame({ + 'Year': year_flattened_prediction[X_basis_weather[:, 0] > mask_threshold], + 'Month': np.array(month_flattened_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'Facility_ID': facility_flattened_prediction[X_basis_weather[:, 0] > mask_threshold], + 'Altitude': np.array(altitude_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'Zone': np.array(zone_info_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'Resid': np.array(resid_info_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'Owner': np.array(owner_info_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'Facility_Type': np.array(ftype_info_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'Precipitation': X_basis_weather[X_basis_weather[:, 0] > mask_threshold, 0], + 'Lag_1_Precipitation': np.array(lag_1_month_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'Lag_2_Precipitation': np.array(lag_2_month_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'Lag_3_Precipitation': np.array(lag_3_month_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'Lag_4_Precipitation': np.array(lag_4_month_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'Predicted_Weather_Model': np.exp(predictions_weather), + 'Predicted_No_Weather_Model': np.exp(y_pred_ANC[X_basis_weather[:, 0] > mask_threshold]), + 'Difference_in_Expectation': predictions, + }) + + # Save the results + full_data_weather_predictions.to_csv(f"{data_path}weather_predictions_with_X_{ssp_scenario}_{model_type}.csv", index=False) + + X_basis_weather_filtered = pd.DataFrame(X_basis_weather_filtered) + + # Save to CSV + X_basis_weather_filtered.to_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/X_basis_weather_filtered_predictions_{ssp_scenario}_{model_type}.csv', index=False) From 0e7f0c14d04321ff2ce58fb00f0e540c6b62524d Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 6 Jan 2025 09:50:28 +0000 Subject: [PATCH 150/291] tidied function --- ...storical_realtionship_reporting_precipitation.py | 13 ++----------- 1 file changed, 2 insertions(+), 11 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 352b17fbaa..8256dad470 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -522,21 +522,12 @@ def repeat_info(info, num_facilities, year_range, historical): ############### ADD IN CMIP DATA ########################### def get_weather_data(ssp_scenario, model_type): - if model_type == 'highest': - file_suffix = 'highest' - elif model_type == 'median': - file_suffix = 'median' - elif model_type == 'lowest': - file_suffix = 'lowest' - else: - raise ValueError("Model type must be one of 'highest', 'median', or 'lowest'") - weather_data_prediction_five_day_cumulative_original = pd.read_csv( - f"{data_path}Precipitation_data/Downscaled_CMIP6_data_CIL/{ssp_scenario}/{file_suffix}_model_daily_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{ssp_scenario}.csv", + f"{data_path}Precipitation_data/Downscaled_CMIP6_data_CIL/{ssp_scenario}/{model_type}_model_daily_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{ssp_scenario}.csv", dtype={'column_name': 'float64'} ) weather_data_prediction_monthly_original = pd.read_csv( - f"{data_path}Precipitation_data/Downscaled_CMIP6_data_CIL/{ssp_scenario}/{file_suffix}_model_monthly_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{ssp_scenario}.csv", + f"{data_path}Precipitation_data/Downscaled_CMIP6_data_CIL/{ssp_scenario}/{model_type}_model_monthly_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{ssp_scenario}.csv", dtype={'column_name': 'float64'} ) From 0d7402aa4c16a00a55c60fb19ca844196cb1acd3 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 6 Jan 2025 10:47:46 +0000 Subject: [PATCH 151/291] Saved model prediction coefficients --- ...historical_realtionship_reporting_precipitation.py | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 8256dad470..f56d2787c4 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -304,7 +304,9 @@ def repeat_info(info, num_facilities, year_range, historical): ]) results, y_pred, mask_ANC_data = build_model(X , y, poisson = poisson, log_y=log_y, X_mask_mm=mask_threshold) - +coefficients = results.params +coefficients_df = pd.DataFrame(coefficients, columns=['coefficients']) +coefficients_df.to_csv('/Users/rem76/Desktop/Climate_change_health/Data/results_of_model_historical.csv') if use_residuals: if log_y: y_weather = (y[mask_ANC_data] - np.exp(y_pred)) + 1 # for poisson @@ -434,6 +436,9 @@ def repeat_info(info, num_facilities, year_range, historical): results_of_weather_model, y_pred_weather, mask_all_data = build_model(X_weather, y, poisson = poisson, log_y=log_y, X_mask_mm=mask_threshold) +coefficients = results_of_weather_model.params +coefficients_df = pd.DataFrame(coefficients, columns=['coefficients']) +coefficients_df.to_csv('/Users/rem76/Desktop/Climate_change_health/Data/results_of_weather_model_historical.csv') print("All predictors", results_of_weather_model.summary()) # @@ -536,7 +541,7 @@ def get_weather_data(ssp_scenario, model_type): columns=zero_sum_columns) return weather_data_prediction_five_day_cumulative_df, weather_data_prediction_monthly_df -model_types = ['lowest', 'median', 'highest'] +model_types = ['lowest']#, 'median', 'highest'] # Configuration and constants min_year_for_analysis = 2025 absolute_min_year = 2025 @@ -631,7 +636,7 @@ def get_weather_data(ssp_scenario, model_type): altitude_prediction = list(altitude_prediction) minimum_distance_prediction = np.nan_to_num(minimum_distance_prediction, nan=np.nan, posinf=np.nan, neginf=np.nan) # just in case - + print(lag_4_month_prediction) # Weather data X_basis_weather = np.column_stack([ From 8b83ff96ffdad69900fe864452d79d2d1beedcce Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 6 Jan 2025 11:21:19 +0000 Subject: [PATCH 152/291] added p value and coefficient names to saving --- ...al_realtionship_reporting_precipitation.py | 20 ++++++++++++++----- 1 file changed, 15 insertions(+), 5 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index f56d2787c4..edd34fec2a 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -302,11 +302,15 @@ def repeat_info(info, num_facilities, year_range, historical): altitude, np.array(minimum_distance) ]) - +coefficient_names = ["year", "month", resid_encoded.columns, zone_encoded.columns, owner_encoded.columns, ftype_encoded.columns, facility_encoded.columns, "altitude", "minimum_distance"] +coefficient_names = pd.Series(coefficient_names) results, y_pred, mask_ANC_data = build_model(X , y, poisson = poisson, log_y=log_y, X_mask_mm=mask_threshold) coefficients = results.params coefficients_df = pd.DataFrame(coefficients, columns=['coefficients']) -coefficients_df.to_csv('/Users/rem76/Desktop/Climate_change_health/Data/results_of_model_historical.csv') +p_values = results.pvalues +p_values_df = pd.DataFrame(p_values, columns=['p_values']) +results_df = pd.concat([coefficient_names, coefficients_df, p_values_df], axis=1) +results_df.to_csv('/Users/rem76/Desktop/Climate_change_health/Data/results_of_model_historical.csv') if use_residuals: if log_y: y_weather = (y[mask_ANC_data] - np.exp(y_pred)) + 1 # for poisson @@ -436,9 +440,15 @@ def repeat_info(info, num_facilities, year_range, historical): results_of_weather_model, y_pred_weather, mask_all_data = build_model(X_weather, y, poisson = poisson, log_y=log_y, X_mask_mm=mask_threshold) -coefficients = results_of_weather_model.params -coefficients_df = pd.DataFrame(coefficients, columns=['coefficients']) -coefficients_df.to_csv('/Users/rem76/Desktop/Climate_change_health/Data/results_of_weather_model_historical.csv') +coefficient_names_weather = ["precip_monthly_total", "precip_5_day_max", "year", "month", resid_encoded.columns, zone_encoded.columns, owner_encoded.columns, ftype_encoded.columns, "lag_1_month","lag_2_month","lag_3_month", "lag_4_month", "lag_1_5_day", "lag_2_5_day","lag_3_5_day", "lag_4_5_day",facility_encoded.columns, "altitude", "minimum_distance"] +coefficient_names_weather = pd.Series(coefficient_names_weather) +coefficients_weather = results_of_weather_model.params +coefficients_weather_df = pd.DataFrame(coefficients_weather, columns=['coefficients']) +p_values_weather = results_of_weather_model.pvalues +p_values_weather_df = pd.DataFrame(p_values_weather, columns=['p_values']) +results_weather_df = pd.concat([coefficient_names_weather, coefficients_weather_df, p_values_weather_df], axis=1) +results_weather_df.to_csv('/Users/rem76/Desktop/Climate_change_health/Data/results_of_weather_model_historical.csv') + print("All predictors", results_of_weather_model.summary()) # From 3112713e1533072cc365008c597eba88cf6c0aa6 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 7 Jan 2025 09:00:41 +0000 Subject: [PATCH 153/291] file for accessing CIL downscaled data --- .../climate_change/CIL_CMIP6_downscaling.py | 116 +++++++++++------- 1 file changed, 72 insertions(+), 44 deletions(-) diff --git a/src/scripts/climate_change/CIL_CMIP6_downscaling.py b/src/scripts/climate_change/CIL_CMIP6_downscaling.py index d139e1aa84..ef2706ba18 100644 --- a/src/scripts/climate_change/CIL_CMIP6_downscaling.py +++ b/src/scripts/climate_change/CIL_CMIP6_downscaling.py @@ -1,62 +1,90 @@ -#!/usr/bin/env python -# coding: utf-8 - -# From https://planetarycomputer.microsoft.com/dataset/cil-gdpcir-cc0#Ensemble-example - -import collections - -import numpy as np -# optional imports used in this notebook -import pandas as pd import planetary_computer import pystac_client -# required to load a zarr array using xarray + import xarray as xr +import numpy as np +import pandas as pd from dask.diagnostics import ProgressBar from tqdm.auto import tqdm -# Load and organise data +import os +import re +import glob +import shutil +import zipfile +from pathlib import Path +import difflib +from scipy.spatial import KDTree -catalog = pystac_client.Client.open( - "https://planetarycomputer.microsoft.com/api/stac/v1/", - modifier=planetary_computer.sign_inplace, -) -collection_cc0 = catalog.get_collection("cil-gdpcir-cc0") +import matplotlib.pyplot as plt +import geopandas as gpd +import regionmask +import cartopy.crs as ccrs -collection_cc0.summaries.to_dict() -print(collection_cc0) -search = catalog.search( - collections=["cil-gdpcir-cc0", "cil-gdpcir-cc-by"], # both creative licenses - query={"cmip6:experiment_id": {"eq": "ssp585"}}, -) -ensemble = search.item_collection() -print(len(ensemble)) +from netCDF4 import Dataset -collections.Counter(x.collection_id for x in ensemble) +from carbonplan import styles # noqa: F401 +import intake +import cmip6_downscaling +from dask.distributed import Client +from planetary_computer import sign_inplace +from pystac_client import Client -variable_id = "pr" +# Open the catalog +catalog = Client.open( + "https://planetarycomputer.microsoft.com/api/stac/v1/", + modifier=sign_inplace, +) -datasets_by_model = [] +# Get the collections +scenarios = ["ssp245"] # Change as needed +variable_id = "pr" # Precipitation variable -for item in tqdm(ensemble): - asset = item.assets[variable_id] - datasets_by_model.append( - xr.open_dataset(asset.href, **asset.extra_fields["xarray:open_kwargs"]) +for scenario in scenarios: + search = catalog.search( + collections=["cil-gdpcir-cc0", "cil-gdpcir-cc-by"], + query={"cmip6:experiment_id": {"eq": scenario}}, ) + ensemble = search.item_collection() + print(f"Number of items found: {len(ensemble)}") -all_datasets = xr.concat( - datasets_by_model, - dim=pd.Index([ds.attrs["source_id"] for ds in datasets_by_model], name="model"), - combine_attrs="drop_conflicts", -) + # Read and process each dataset + datasets_by_model = [] + for item in tqdm(ensemble): + asset = item.assets[variable_id] + datasets_by_model.append( + xr.open_dataset(asset.href, **asset.extra_fields["xarray:open_kwargs"]) + ) + + # Combine datasets by model + all_datasets = xr.concat( + datasets_by_model, + dim=pd.Index([ds.attrs["source_id"] for ds in datasets_by_model], name="model"), + combine_attrs="drop_conflicts", + ) + # Define the spatial and temporal bounds + lon_bounds = slice(32.67161823, 35.91841716) + lat_bounds = slice(-17.12627881, -9.36366167) + time_range = pd.date_range("2065-01-01", "2071-01-01", freq="Y") -# Subset for Malawi and 2025-2100 -subset = all_datasets.pr.sel( - lon=slice(32.67161823,35.91841716), - lat=slice(-17.12627881, -9.36366167), - time=slice("2025-01-01", "2100-01-01"), -) + # Process each year + output_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/" + yearly_files = [] + for year in time_range.year: + yearly_subset = all_datasets.pr.sel( + lon=lon_bounds, + lat=lat_bounds, + time=slice(f"{year}-01-01", f"{year}-12-31"), + ) + yearly_file = f"{output_dir}/CIL_subset_{scenario}_{year}.nc" + yearly_subset.to_netcdf(yearly_file) + yearly_files.append(yearly_file) + print(f"Saved yearly data for {year} to {yearly_file}") -subset.to_netcdf("/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/CIL_subsetted_all_model_ssp585.nc") + # Combine all yearly files into one NetCDF file + combined_output = f"{output_dir}/CIL_subsetted_all_model_{scenario}.nc" + combined_dataset = xr.open_mfdataset(yearly_files, combine="by_coords") + combined_dataset.to_netcdf(combined_output) + print(f"Saved combined dataset to {combined_output}") From 9278314bc2e68b6226b60a6c2935c6ed44869b65 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 7 Jan 2025 10:22:24 +0000 Subject: [PATCH 154/291] Did piecewise downloading of downscaled data (as kept getting nan) Then made requisite edits to the kdball algorithm etc to accommodate the new data types --- .../CIL_CMIP6_downscaling.ipynb | 7746 ++--------------- 1 file changed, 890 insertions(+), 6856 deletions(-) diff --git a/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb b/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb index 5d5adf989b..361eb7c09f 100644 --- a/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb +++ b/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb @@ -9,8 +9,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2024-12-20T15:37:32.374596Z", - "start_time": "2024-12-20T15:37:30.837930Z" + "end_time": "2025-01-07T09:41:20.078055Z", + "start_time": "2025-01-07T09:41:18.319974Z" } }, "cell_type": "code", @@ -58,190 +58,465 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-02T21:43:37.377707Z", - "start_time": "2025-01-02T21:42:39.868201Z" + "end_time": "2025-01-07T09:12:15.018110Z", + "start_time": "2025-01-07T08:36:55.986715Z" } }, "cell_type": "code", "source": [ - "catalog = pystac_client.Client.open(\n", + "import xarray as xr\n", + "import pandas as pd\n", + "from pystac_client import Client\n", + "from planetary_computer import sign_inplace\n", + "from tqdm import tqdm\n", + "\n", + "# Open the catalog\n", + "catalog = Client.open(\n", " \"https://planetarycomputer.microsoft.com/api/stac/v1/\",\n", - " modifier=planetary_computer.sign_inplace,\n", + " modifier=sign_inplace,\n", ")\n", - "collection_cc0 = catalog.get_collection(\"cil-gdpcir-cc0\")\n", - "collection_cc0.summaries.to_dict()\n", - "scenarios = [\"ssp245\"]\n", + "\n", + "# Get the collections\n", + "scenarios = [\"ssp585\"] # Change as needed\n", + "variable_id = \"pr\" # Precipitation variable\n", + "\n", "for scenario in scenarios:\n", " search = catalog.search(\n", - " collections=[\"cil-gdpcir-cc0\", \"cil-gdpcir-cc-by\"], # both creative licenses\n", - " query={\"cmip6:experiment_id\": {\"eq\": f\"{scenario}\"}}, # stick with 245 for the moment \n", + " collections=[\"cil-gdpcir-cc0\", \"cil-gdpcir-cc-by\"],\n", + " query={\"cmip6:experiment_id\": {\"eq\": scenario}},\n", " )\n", " ensemble = search.item_collection()\n", - " print(len(ensemble))\n", - " \n", - " # read in only the precipitation\n", - " variable_id = \"pr\"\n", - " \n", + " print(f\"Number of items found: {len(ensemble)}\")\n", + "\n", + " # Read and process each dataset\n", " datasets_by_model = []\n", - " \n", " for item in tqdm(ensemble):\n", " asset = item.assets[variable_id]\n", " datasets_by_model.append(\n", " xr.open_dataset(asset.href, **asset.extra_fields[\"xarray:open_kwargs\"])\n", " )\n", - " \n", + "\n", + " # Combine datasets by model\n", " all_datasets = xr.concat(\n", " datasets_by_model,\n", " dim=pd.Index([ds.attrs[\"source_id\"] for ds in datasets_by_model], name=\"model\"),\n", " combine_attrs=\"drop_conflicts\",\n", " )\n", - " \n", - " #Subset for Malawi and 2025-2100\n", - " \n", - " subset = all_datasets.pr.sel(\n", - " lon=slice(32.67161823,35.91841716),\n", - " lat=slice(-17.12627881, -9.36366167),\n", - " time=slice(\"2025-01-01\", \"2071-01-01\"),\n", - " )\n", - " \n", - " subset.to_netcdf(f\"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/CIL_subsetted_all_model_{scenario}.nc\")" + "\n", + " # Define the spatial and temporal bounds\n", + " lon_bounds = slice(32.67161823, 35.91841716)\n", + " lat_bounds = slice(-17.12627881, -9.36366167)\n", + " time_range = pd.date_range(\"2061-01-01\", \"2071-01-01\", freq=\"Y\")\n", + "\n", + " # Process each year\n", + " output_dir = \"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/\"\n", + " yearly_files = []\n", + " for year in time_range.year:\n", + " yearly_subset = all_datasets.pr.sel(\n", + " lon=lon_bounds,\n", + " lat=lat_bounds,\n", + " time=slice(f\"{year}-01-01\", f\"{year}-12-31\"),\n", + " )\n", + " yearly_file = f\"{output_dir}/CIL_subset_{scenario}_{year}.nc\"\n", + " yearly_subset.to_netcdf(yearly_file)\n", + " yearly_files.append(yearly_file)\n", + " print(f\"Saved yearly data for {year} to {yearly_file}\")\n", + "\n", + " # Combine all yearly files into one NetCDF file\n", + " combined_output = f\"{output_dir}/CIL_subsetted_all_model_{scenario}.nc\"\n", + " combined_dataset = xr.open_mfdataset(yearly_files, combine=\"by_coords\")\n", + " combined_dataset.to_netcdf(combined_output)\n", + " print(f\"Saved combined dataset to {combined_output}\")" ], - "id": "aaa18487dc9d770f", + "id": "fc5f8a6d54c1a89d", "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "23\n" + "Number of items found: 22\n" ] }, { - "data": { - "text/plain": [ - " 0%| | 0/23 [00:00 exception=SocketTimeoutError('Timeout on reading data from socket')>\n", + "Traceback (most recent call last):\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 77, in process_chunk\n", + " chunk_data, _ = await self._download_chunk(chunk_start, chunk_end - 1)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 141, in _download_chunk\n", + " chunk_data = await process_content(response, offset[0], offset[1], self.encryption_options)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 49, in process_content\n", + " await data.response.read()\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/core/rest/_aiohttp.py\", line 215, in read\n", + " self._content = await self._internal_response.read()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/client_reqrep.py\", line 1214, in read\n", + " self._body = await self.content.read()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 415, in read\n", + " block = await self.readany()\n", + " ^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 437, in readany\n", + " await self._wait(\"readany\")\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 344, in _wait\n", + " await waiter\n", + "aiohttp.client_exceptions.SocketTimeoutError: Timeout on reading data from socket\n", + "Task exception was never retrieved\n", + "future: exception=SocketTimeoutError('Timeout on reading data from socket')>\n", + "Traceback (most recent call last):\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 77, in process_chunk\n", + " chunk_data, _ = await self._download_chunk(chunk_start, chunk_end - 1)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 141, in _download_chunk\n", + " chunk_data = await process_content(response, offset[0], offset[1], self.encryption_options)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 49, in process_content\n", + " await data.response.read()\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/core/rest/_aiohttp.py\", line 215, in read\n", + " self._content = await self._internal_response.read()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/client_reqrep.py\", line 1214, in read\n", + " self._body = await self.content.read()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 415, in read\n", + " block = await self.readany()\n", + " ^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 437, in readany\n", + " await self._wait(\"readany\")\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 344, in _wait\n", + " await waiter\n", + "aiohttp.client_exceptions.SocketTimeoutError: Timeout on reading data from socket\n", + "Task exception was never retrieved\n", + "future: exception=SocketTimeoutError('Timeout on reading data from socket')>\n", + "Traceback (most recent call last):\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 77, in process_chunk\n", + " chunk_data, _ = await self._download_chunk(chunk_start, chunk_end - 1)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 141, in _download_chunk\n", + " chunk_data = await process_content(response, offset[0], offset[1], self.encryption_options)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 49, in process_content\n", + " await data.response.read()\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/core/rest/_aiohttp.py\", line 215, in read\n", + " self._content = await self._internal_response.read()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/client_reqrep.py\", line 1214, in read\n", + " self._body = await self.content.read()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 415, in read\n", + " block = await self.readany()\n", + " ^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 437, in readany\n", + " await self._wait(\"readany\")\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 344, in _wait\n", + " await waiter\n", + "aiohttp.client_exceptions.SocketTimeoutError: Timeout on reading data from socket\n", + "Task exception was never retrieved\n", + "future: exception=SocketTimeoutError('Timeout on reading data from socket')>\n", + "Traceback (most recent call last):\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 77, in process_chunk\n", + " chunk_data, _ = await self._download_chunk(chunk_start, chunk_end - 1)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 141, in _download_chunk\n", + " chunk_data = await process_content(response, offset[0], offset[1], self.encryption_options)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 49, in process_content\n", + " await data.response.read()\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/core/rest/_aiohttp.py\", line 215, in read\n", + " self._content = await self._internal_response.read()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/client_reqrep.py\", line 1214, in read\n", + " self._body = await self.content.read()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 415, in read\n", + " block = await self.readany()\n", + " ^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 437, in readany\n", + " await self._wait(\"readany\")\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 344, in _wait\n", + " await waiter\n", + "aiohttp.client_exceptions.SocketTimeoutError: Timeout on reading data from socket\n", + "Task exception was never retrieved\n", + "future: exception=SocketTimeoutError('Timeout on reading data from socket')>\n", + "Traceback (most recent call last):\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 77, in process_chunk\n", + " chunk_data, _ = await self._download_chunk(chunk_start, chunk_end - 1)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 141, in _download_chunk\n", + " chunk_data = await process_content(response, offset[0], offset[1], self.encryption_options)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 49, in process_content\n", + " await data.response.read()\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/core/rest/_aiohttp.py\", line 215, in read\n", + " self._content = await self._internal_response.read()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/client_reqrep.py\", line 1214, in read\n", + " self._body = await self.content.read()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 415, in read\n", + " block = await self.readany()\n", + " ^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 437, in readany\n", + " await self._wait(\"readany\")\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 344, in _wait\n", + " await waiter\n", + "aiohttp.client_exceptions.SocketTimeoutError: Timeout on reading data from socket\n", + "Task exception was never retrieved\n", + "future: exception=SocketTimeoutError('Timeout on reading data from socket')>\n", + "Traceback (most recent call last):\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 77, in process_chunk\n", + " chunk_data, _ = await self._download_chunk(chunk_start, chunk_end - 1)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 141, in _download_chunk\n", + " chunk_data = await process_content(response, offset[0], offset[1], self.encryption_options)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 49, in process_content\n", + " await data.response.read()\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/core/rest/_aiohttp.py\", line 215, in read\n", + " self._content = await self._internal_response.read()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/client_reqrep.py\", line 1214, in read\n", + " self._body = await self.content.read()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 415, in read\n", + " block = await self.readany()\n", + " ^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 437, in readany\n", + " await self._wait(\"readany\")\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 344, in _wait\n", + " await waiter\n", + "aiohttp.client_exceptions.SocketTimeoutError: Timeout on reading data from socket\n", + "Task exception was never retrieved\n", + "future: exception=SocketTimeoutError('Timeout on reading data from socket')>\n", + "Traceback (most recent call last):\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 77, in process_chunk\n", + " chunk_data, _ = await self._download_chunk(chunk_start, chunk_end - 1)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 141, in _download_chunk\n", + " chunk_data = await process_content(response, offset[0], offset[1], self.encryption_options)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 49, in process_content\n", + " await data.response.read()\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/core/rest/_aiohttp.py\", line 215, in read\n", + " self._content = await self._internal_response.read()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/client_reqrep.py\", line 1214, in read\n", + " self._body = await self.content.read()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 415, in read\n", + " block = await self.readany()\n", + " ^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 437, in readany\n", + " await self._wait(\"readany\")\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 344, in _wait\n", + " await waiter\n", + "aiohttp.client_exceptions.SocketTimeoutError: Timeout on reading data from socket\n", + "Task exception was never retrieved\n", + "future: exception=SocketTimeoutError('Timeout on reading data from socket')>\n", + "Traceback (most recent call last):\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 77, in process_chunk\n", + " chunk_data, _ = await self._download_chunk(chunk_start, chunk_end - 1)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 141, in _download_chunk\n", + " chunk_data = await process_content(response, offset[0], offset[1], self.encryption_options)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 49, in process_content\n", + " await data.response.read()\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/core/rest/_aiohttp.py\", line 215, in read\n", + " self._content = await self._internal_response.read()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/client_reqrep.py\", line 1214, in read\n", + " self._body = await self.content.read()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 415, in read\n", + " block = await self.readany()\n", + " ^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 437, in readany\n", + " await self._wait(\"readany\")\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 344, in _wait\n", + " await waiter\n", + "aiohttp.client_exceptions.SocketTimeoutError: Timeout on reading data from socket\n", + "Task exception was never retrieved\n", + "future: exception=SocketTimeoutError('Timeout on reading data from socket')>\n", + "Traceback (most recent call last):\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 77, in process_chunk\n", + " chunk_data, _ = await self._download_chunk(chunk_start, chunk_end - 1)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 141, in _download_chunk\n", + " chunk_data = await process_content(response, offset[0], offset[1], self.encryption_options)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 49, in process_content\n", + " await data.response.read()\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/core/rest/_aiohttp.py\", line 215, in read\n", + " self._content = await self._internal_response.read()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/client_reqrep.py\", line 1214, in read\n", + " self._body = await self.content.read()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 415, in read\n", + " block = await self.readany()\n", + " ^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 437, in readany\n", + " await self._wait(\"readany\")\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 344, in _wait\n", + " await waiter\n", + "aiohttp.client_exceptions.SocketTimeoutError: Timeout on reading data from socket\n", + "Task exception was never retrieved\n", + "future: exception=SocketTimeoutError('Timeout on reading data from socket')>\n", + "Traceback (most recent call last):\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 77, in process_chunk\n", + " chunk_data, _ = await self._download_chunk(chunk_start, chunk_end - 1)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 141, in _download_chunk\n", + " chunk_data = await process_content(response, offset[0], offset[1], self.encryption_options)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 49, in process_content\n", + " await data.response.read()\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/core/rest/_aiohttp.py\", line 215, in read\n", + " self._content = await self._internal_response.read()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/client_reqrep.py\", line 1214, in read\n", + " self._body = await self.content.read()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 415, in read\n", + " block = await self.readany()\n", + " ^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 437, in readany\n", + " await self._wait(\"readany\")\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 344, in _wait\n", + " await waiter\n", + "aiohttp.client_exceptions.SocketTimeoutError: Timeout on reading data from socket\n", + "Task exception was never retrieved\n", + "future: exception=SocketTimeoutError('Timeout on reading data from socket')>\n", + "Traceback (most recent call last):\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 77, in process_chunk\n", + " chunk_data, _ = await self._download_chunk(chunk_start, chunk_end - 1)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 141, in _download_chunk\n", + " chunk_data = await process_content(response, offset[0], offset[1], self.encryption_options)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 49, in process_content\n", + " await data.response.read()\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/core/rest/_aiohttp.py\", line 215, in read\n", + " self._content = await self._internal_response.read()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/client_reqrep.py\", line 1214, in read\n", + " self._body = await self.content.read()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 415, in read\n", + " block = await self.readany()\n", + " ^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 437, in readany\n", + " await self._wait(\"readany\")\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 344, in _wait\n", + " await waiter\n", + "aiohttp.client_exceptions.SocketTimeoutError: Timeout on reading data from socket\n", + "Task exception was never retrieved\n", + "future: exception=SocketTimeoutError('Timeout on reading data from socket')>\n", + "Traceback (most recent call last):\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 77, in process_chunk\n", + " chunk_data, _ = await self._download_chunk(chunk_start, chunk_end - 1)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 141, in _download_chunk\n", + " chunk_data = await process_content(response, offset[0], offset[1], self.encryption_options)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 49, in process_content\n", + " await data.response.read()\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/core/rest/_aiohttp.py\", line 215, in read\n", + " self._content = await self._internal_response.read()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/client_reqrep.py\", line 1214, in read\n", + " self._body = await self.content.read()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 415, in read\n", + " block = await self.readany()\n", + " ^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 437, in readany\n", + " await self._wait(\"readany\")\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 344, in _wait\n", + " await waiter\n", + "aiohttp.client_exceptions.SocketTimeoutError: Timeout on reading data from socket\n", + "Task exception was never retrieved\n", + "future: exception=SocketTimeoutError('Timeout on reading data from socket')>\n", + "Traceback (most recent call last):\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 77, in process_chunk\n", + " chunk_data, _ = await self._download_chunk(chunk_start, chunk_end - 1)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 141, in _download_chunk\n", + " chunk_data = await process_content(response, offset[0], offset[1], self.encryption_options)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 49, in process_content\n", + " await data.response.read()\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/core/rest/_aiohttp.py\", line 215, in read\n", + " self._content = await self._internal_response.read()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/client_reqrep.py\", line 1214, in read\n", + " self._body = await self.content.read()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 415, in read\n", + " block = await self.readany()\n", + " ^^^^^^^^^^^^^^^^^^^^\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 437, in readany\n", + " await self._wait(\"readany\")\n", + " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 344, in _wait\n", + " await waiter\n", + "aiohttp.client_exceptions.SocketTimeoutError: Timeout on reading data from socket\n", + "100%|██████████| 22/22 [02:45<00:00, 7.53s/it]\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_24684/2600312277.py:43: FutureWarning: 'Y' is deprecated and will be removed in a future version, please use 'YE' instead.\n", + " time_range = pd.date_range(\"2061-01-01\", \"2071-01-01\", freq=\"Y\")\n" + ] }, { - "ename": "PermissionError", - "evalue": "[Errno 13] Permission denied: '/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/CIL_subsetted_all_model_ssp245.nc'", - "output_type": "error", - "traceback": [ - "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m", - "\u001B[0;31mKeyError\u001B[0m Traceback (most recent call last)", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/backends/file_manager.py:211\u001B[0m, in \u001B[0;36mCachingFileManager._acquire_with_cache_info\u001B[0;34m(self, needs_lock)\u001B[0m\n\u001B[1;32m 210\u001B[0m \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[0;32m--> 211\u001B[0m file \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_cache\u001B[49m\u001B[43m[\u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_key\u001B[49m\u001B[43m]\u001B[49m\n\u001B[1;32m 212\u001B[0m \u001B[38;5;28;01mexcept\u001B[39;00m \u001B[38;5;167;01mKeyError\u001B[39;00m:\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/backends/lru_cache.py:56\u001B[0m, in \u001B[0;36mLRUCache.__getitem__\u001B[0;34m(self, key)\u001B[0m\n\u001B[1;32m 55\u001B[0m \u001B[38;5;28;01mwith\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_lock:\n\u001B[0;32m---> 56\u001B[0m value \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_cache\u001B[49m\u001B[43m[\u001B[49m\u001B[43mkey\u001B[49m\u001B[43m]\u001B[49m\n\u001B[1;32m 57\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_cache\u001B[38;5;241m.\u001B[39mmove_to_end(key)\n", - "\u001B[0;31mKeyError\u001B[0m: [, ('/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/CIL_subsetted_all_model_ssp245.nc',), 'a', (('clobber', True), ('diskless', False), ('format', 'NETCDF4'), ('persist', False)), '5d9c3923-1729-4151-9ec2-02ebe797fa4f']", - "\nDuring handling of the above exception, another exception occurred:\n", - "\u001B[0;31mPermissionError\u001B[0m Traceback (most recent call last)", - "Cell \u001B[0;32mIn[6], line 41\u001B[0m\n\u001B[1;32m 33\u001B[0m \u001B[38;5;66;03m#Subset for Malawi and 2025-2100\u001B[39;00m\n\u001B[1;32m 35\u001B[0m subset \u001B[38;5;241m=\u001B[39m all_datasets\u001B[38;5;241m.\u001B[39mpr\u001B[38;5;241m.\u001B[39msel(\n\u001B[1;32m 36\u001B[0m lon\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mslice\u001B[39m(\u001B[38;5;241m32.67161823\u001B[39m,\u001B[38;5;241m35.91841716\u001B[39m),\n\u001B[1;32m 37\u001B[0m lat\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mslice\u001B[39m(\u001B[38;5;241m-\u001B[39m\u001B[38;5;241m17.12627881\u001B[39m, \u001B[38;5;241m-\u001B[39m\u001B[38;5;241m9.36366167\u001B[39m),\n\u001B[1;32m 38\u001B[0m time\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mslice\u001B[39m(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124m2025-01-01\u001B[39m\u001B[38;5;124m\"\u001B[39m, \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124m2071-01-01\u001B[39m\u001B[38;5;124m\"\u001B[39m),\n\u001B[1;32m 39\u001B[0m )\n\u001B[0;32m---> 41\u001B[0m \u001B[43msubset\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mto_netcdf\u001B[49m\u001B[43m(\u001B[49m\u001B[38;5;124;43mf\u001B[39;49m\u001B[38;5;124;43m\"\u001B[39;49m\u001B[38;5;124;43m/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/CIL_subsetted_all_model_\u001B[39;49m\u001B[38;5;132;43;01m{\u001B[39;49;00m\u001B[43mscenario\u001B[49m\u001B[38;5;132;43;01m}\u001B[39;49;00m\u001B[38;5;124;43m.nc\u001B[39;49m\u001B[38;5;124;43m\"\u001B[39;49m\u001B[43m)\u001B[49m\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/core/dataarray.py:4211\u001B[0m, in \u001B[0;36mDataArray.to_netcdf\u001B[0;34m(self, path, mode, format, group, engine, encoding, unlimited_dims, compute, invalid_netcdf, auto_complex)\u001B[0m\n\u001B[1;32m 4207\u001B[0m \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[1;32m 4208\u001B[0m \u001B[38;5;66;03m# No problems with the name - so we're fine!\u001B[39;00m\n\u001B[1;32m 4209\u001B[0m dataset \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mto_dataset()\n\u001B[0;32m-> 4211\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[43mto_netcdf\u001B[49m\u001B[43m(\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;66;43;03m# type: ignore[return-value] # mypy cannot resolve the overloads:(\u001B[39;49;00m\n\u001B[1;32m 4212\u001B[0m \u001B[43m \u001B[49m\u001B[43mdataset\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 4213\u001B[0m \u001B[43m \u001B[49m\u001B[43mpath\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 4214\u001B[0m \u001B[43m \u001B[49m\u001B[43mmode\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mmode\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 4215\u001B[0m \u001B[43m \u001B[49m\u001B[38;5;28;43mformat\u001B[39;49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43mformat\u001B[39;49m\u001B[43m,\u001B[49m\n\u001B[1;32m 4216\u001B[0m \u001B[43m \u001B[49m\u001B[43mgroup\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mgroup\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 4217\u001B[0m \u001B[43m \u001B[49m\u001B[43mengine\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mengine\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 4218\u001B[0m \u001B[43m \u001B[49m\u001B[43mencoding\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mencoding\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 4219\u001B[0m \u001B[43m \u001B[49m\u001B[43munlimited_dims\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43munlimited_dims\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 4220\u001B[0m \u001B[43m \u001B[49m\u001B[43mcompute\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mcompute\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 4221\u001B[0m \u001B[43m \u001B[49m\u001B[43mmultifile\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43;01mFalse\u001B[39;49;00m\u001B[43m,\u001B[49m\n\u001B[1;32m 4222\u001B[0m \u001B[43m \u001B[49m\u001B[43minvalid_netcdf\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43minvalid_netcdf\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 4223\u001B[0m \u001B[43m \u001B[49m\u001B[43mauto_complex\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mauto_complex\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 4224\u001B[0m \u001B[43m\u001B[49m\u001B[43m)\u001B[49m\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/backends/api.py:1856\u001B[0m, in \u001B[0;36mto_netcdf\u001B[0;34m(dataset, path_or_file, mode, format, group, engine, encoding, unlimited_dims, compute, multifile, invalid_netcdf, auto_complex)\u001B[0m\n\u001B[1;32m 1853\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m auto_complex \u001B[38;5;129;01mis\u001B[39;00m \u001B[38;5;129;01mnot\u001B[39;00m \u001B[38;5;28;01mNone\u001B[39;00m:\n\u001B[1;32m 1854\u001B[0m kwargs[\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mauto_complex\u001B[39m\u001B[38;5;124m\"\u001B[39m] \u001B[38;5;241m=\u001B[39m auto_complex\n\u001B[0;32m-> 1856\u001B[0m store \u001B[38;5;241m=\u001B[39m \u001B[43mstore_open\u001B[49m\u001B[43m(\u001B[49m\u001B[43mtarget\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mmode\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;28;43mformat\u001B[39;49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mgroup\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mkwargs\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 1858\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m unlimited_dims \u001B[38;5;129;01mis\u001B[39;00m \u001B[38;5;28;01mNone\u001B[39;00m:\n\u001B[1;32m 1859\u001B[0m unlimited_dims \u001B[38;5;241m=\u001B[39m dataset\u001B[38;5;241m.\u001B[39mencoding\u001B[38;5;241m.\u001B[39mget(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124munlimited_dims\u001B[39m\u001B[38;5;124m\"\u001B[39m, \u001B[38;5;28;01mNone\u001B[39;00m)\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/backends/netCDF4_.py:452\u001B[0m, in \u001B[0;36mNetCDF4DataStore.open\u001B[0;34m(cls, filename, mode, format, group, clobber, diskless, persist, auto_complex, lock, lock_maker, autoclose)\u001B[0m\n\u001B[1;32m 448\u001B[0m kwargs[\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mauto_complex\u001B[39m\u001B[38;5;124m\"\u001B[39m] \u001B[38;5;241m=\u001B[39m auto_complex\n\u001B[1;32m 449\u001B[0m manager \u001B[38;5;241m=\u001B[39m CachingFileManager(\n\u001B[1;32m 450\u001B[0m netCDF4\u001B[38;5;241m.\u001B[39mDataset, filename, mode\u001B[38;5;241m=\u001B[39mmode, kwargs\u001B[38;5;241m=\u001B[39mkwargs\n\u001B[1;32m 451\u001B[0m )\n\u001B[0;32m--> 452\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28;43mcls\u001B[39;49m\u001B[43m(\u001B[49m\u001B[43mmanager\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mgroup\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mgroup\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mmode\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mmode\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mlock\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mlock\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mautoclose\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mautoclose\u001B[49m\u001B[43m)\u001B[49m\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/backends/netCDF4_.py:393\u001B[0m, in \u001B[0;36mNetCDF4DataStore.__init__\u001B[0;34m(self, manager, group, mode, lock, autoclose)\u001B[0m\n\u001B[1;32m 391\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_group \u001B[38;5;241m=\u001B[39m group\n\u001B[1;32m 392\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_mode \u001B[38;5;241m=\u001B[39m mode\n\u001B[0;32m--> 393\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mformat \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mds\u001B[49m\u001B[38;5;241m.\u001B[39mdata_model\n\u001B[1;32m 394\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_filename \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mds\u001B[38;5;241m.\u001B[39mfilepath()\n\u001B[1;32m 395\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mis_remote \u001B[38;5;241m=\u001B[39m is_remote_uri(\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_filename)\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/backends/netCDF4_.py:461\u001B[0m, in \u001B[0;36mNetCDF4DataStore.ds\u001B[0;34m(self)\u001B[0m\n\u001B[1;32m 459\u001B[0m \u001B[38;5;129m@property\u001B[39m\n\u001B[1;32m 460\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21mds\u001B[39m(\u001B[38;5;28mself\u001B[39m):\n\u001B[0;32m--> 461\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_acquire\u001B[49m\u001B[43m(\u001B[49m\u001B[43m)\u001B[49m\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/backends/netCDF4_.py:455\u001B[0m, in \u001B[0;36mNetCDF4DataStore._acquire\u001B[0;34m(self, needs_lock)\u001B[0m\n\u001B[1;32m 454\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21m_acquire\u001B[39m(\u001B[38;5;28mself\u001B[39m, needs_lock\u001B[38;5;241m=\u001B[39m\u001B[38;5;28;01mTrue\u001B[39;00m):\n\u001B[0;32m--> 455\u001B[0m \u001B[43m \u001B[49m\u001B[38;5;28;43;01mwith\u001B[39;49;00m\u001B[43m \u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_manager\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43macquire_context\u001B[49m\u001B[43m(\u001B[49m\u001B[43mneeds_lock\u001B[49m\u001B[43m)\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;28;43;01mas\u001B[39;49;00m\u001B[43m \u001B[49m\u001B[43mroot\u001B[49m\u001B[43m:\u001B[49m\n\u001B[1;32m 456\u001B[0m \u001B[43m \u001B[49m\u001B[43mds\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43m \u001B[49m\u001B[43m_nc4_require_group\u001B[49m\u001B[43m(\u001B[49m\u001B[43mroot\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_group\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_mode\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 457\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m ds\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/contextlib.py:137\u001B[0m, in \u001B[0;36m_GeneratorContextManager.__enter__\u001B[0;34m(self)\u001B[0m\n\u001B[1;32m 135\u001B[0m \u001B[38;5;28;01mdel\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39margs, \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mkwds, \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mfunc\n\u001B[1;32m 136\u001B[0m \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[0;32m--> 137\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28mnext\u001B[39m(\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mgen)\n\u001B[1;32m 138\u001B[0m \u001B[38;5;28;01mexcept\u001B[39;00m \u001B[38;5;167;01mStopIteration\u001B[39;00m:\n\u001B[1;32m 139\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m \u001B[38;5;167;01mRuntimeError\u001B[39;00m(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mgenerator didn\u001B[39m\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mt yield\u001B[39m\u001B[38;5;124m\"\u001B[39m) \u001B[38;5;28;01mfrom\u001B[39;00m \u001B[38;5;28;01mNone\u001B[39;00m\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/backends/file_manager.py:199\u001B[0m, in \u001B[0;36mCachingFileManager.acquire_context\u001B[0;34m(self, needs_lock)\u001B[0m\n\u001B[1;32m 196\u001B[0m \u001B[38;5;129m@contextlib\u001B[39m\u001B[38;5;241m.\u001B[39mcontextmanager\n\u001B[1;32m 197\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21macquire_context\u001B[39m(\u001B[38;5;28mself\u001B[39m, needs_lock\u001B[38;5;241m=\u001B[39m\u001B[38;5;28;01mTrue\u001B[39;00m):\n\u001B[1;32m 198\u001B[0m \u001B[38;5;250m \u001B[39m\u001B[38;5;124;03m\"\"\"Context manager for acquiring a file.\"\"\"\u001B[39;00m\n\u001B[0;32m--> 199\u001B[0m file, cached \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_acquire_with_cache_info\u001B[49m\u001B[43m(\u001B[49m\u001B[43mneeds_lock\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 200\u001B[0m \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[1;32m 201\u001B[0m \u001B[38;5;28;01myield\u001B[39;00m file\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/backends/file_manager.py:217\u001B[0m, in \u001B[0;36mCachingFileManager._acquire_with_cache_info\u001B[0;34m(self, needs_lock)\u001B[0m\n\u001B[1;32m 215\u001B[0m kwargs \u001B[38;5;241m=\u001B[39m kwargs\u001B[38;5;241m.\u001B[39mcopy()\n\u001B[1;32m 216\u001B[0m kwargs[\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mmode\u001B[39m\u001B[38;5;124m\"\u001B[39m] \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_mode\n\u001B[0;32m--> 217\u001B[0m file \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_opener\u001B[49m\u001B[43m(\u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_args\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mkwargs\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 218\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_mode \u001B[38;5;241m==\u001B[39m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mw\u001B[39m\u001B[38;5;124m\"\u001B[39m:\n\u001B[1;32m 219\u001B[0m \u001B[38;5;66;03m# ensure file doesn't get overridden when opened again\u001B[39;00m\n\u001B[1;32m 220\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_mode \u001B[38;5;241m=\u001B[39m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124ma\u001B[39m\u001B[38;5;124m\"\u001B[39m\n", - "File \u001B[0;32msrc/netCDF4/_netCDF4.pyx:2470\u001B[0m, in \u001B[0;36mnetCDF4._netCDF4.Dataset.__init__\u001B[0;34m()\u001B[0m\n", - "File \u001B[0;32msrc/netCDF4/_netCDF4.pyx:2107\u001B[0m, in \u001B[0;36mnetCDF4._netCDF4._ensure_nc_success\u001B[0;34m()\u001B[0m\n", - "\u001B[0;31mPermissionError\u001B[0m: [Errno 13] Permission denied: '/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/CIL_subsetted_all_model_ssp245.nc'" + "name": "stdout", + "output_type": "stream", + "text": [ + "Saved yearly data for 2061 to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL//CIL_subset_ssp585_2061.nc\n", + "Saved yearly data for 2062 to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL//CIL_subset_ssp585_2062.nc\n", + "Saved yearly data for 2063 to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL//CIL_subset_ssp585_2063.nc\n", + "Saved yearly data for 2064 to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL//CIL_subset_ssp585_2064.nc\n", + "Saved yearly data for 2065 to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL//CIL_subset_ssp585_2065.nc\n", + "Saved yearly data for 2066 to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL//CIL_subset_ssp585_2066.nc\n", + "Saved yearly data for 2067 to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL//CIL_subset_ssp585_2067.nc\n", + "Saved yearly data for 2068 to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL//CIL_subset_ssp585_2068.nc\n", + "Saved yearly data for 2069 to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL//CIL_subset_ssp585_2069.nc\n", + "Saved yearly data for 2070 to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL//CIL_subset_ssp585_2070.nc\n" ] - } - ], - "execution_count": 6 - }, - { - "metadata": {}, - "cell_type": "code", - "outputs": [], - "execution_count": null, - "source": " subset.to_netcdf(f\"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/CIL_subsetted_all_model_{scenario}.nc\")", - "id": "6136b5a191f194f1" - }, - { - "metadata": {}, - "cell_type": "markdown", - "source": "Find lowest, median, and highest value model across all lat/long and across all time points", - "id": "8564e555060bf10a" - }, - { - "metadata": { - "ExecuteTime": { - "end_time": "2025-01-03T08:44:03.671513Z", - "start_time": "2025-01-03T08:44:03.284844Z" - } - }, - "cell_type": "code", - "source": [ - "subset_xr = xr.Dataset(\n", - " data_vars=dict(\n", - " pr=([\"time\", \"lat\",\"lon\", \"model\"],np.asarray(subset.data)),\n", - " ),\n", - " coords=dict(\n", - " time=subset.time.data,\n", - " lat=subset.lat.data,\n", - " lon=subset.lon.data,\n", - " model=subset.model.data\n", - " ),\n", - " attrs=dict(description=\"Weather related data.\"),\n", - ")\n" - ], - "id": "5dbaad05c9de5cdf", - "outputs": [ + }, { - "ename": "ClientAuthenticationError", - "evalue": "Server failed to authenticate the request. Make sure the value of Authorization header is formed correctly including the signature.\nRequestId:356fa9fc-a01e-0046-0fbb-5da77d000000\nTime:2025-01-03T08:44:03.5582125Z\nErrorCode:AuthenticationFailed\nauthenticationerrordetail:Signature not valid in the specified time frame: Start [Wed, 01 Jan 2025 21:42:40 GMT] - Expiry [Thu, 02 Jan 2025 22:27:40 GMT] - Current [Fri, 03 Jan 2025 08:44:03 GMT]\nContent: AuthenticationFailedServer failed to authenticate the request. Make sure the value of Authorization header is formed correctly including the signature.\nRequestId:356fa9fc-a01e-0046-0fbb-5da77d000000\nTime:2025-01-03T08:44:03.5582125ZSignature not valid in the specified time frame: Start [Wed, 01 Jan 2025 21:42:40 GMT] - Expiry [Thu, 02 Jan 2025 22:27:40 GMT] - Current [Fri, 03 Jan 2025 08:44:03 GMT]", + "ename": "KeyboardInterrupt", + "evalue": "", "output_type": "error", "traceback": [ "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m", - "\u001B[0;31mClientAuthenticationError\u001B[0m Traceback (most recent call last)", - "Cell \u001B[0;32mIn[7], line 3\u001B[0m\n\u001B[1;32m 1\u001B[0m subset_xr \u001B[38;5;241m=\u001B[39m xr\u001B[38;5;241m.\u001B[39mDataset(\n\u001B[1;32m 2\u001B[0m data_vars\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mdict\u001B[39m(\n\u001B[0;32m----> 3\u001B[0m pr\u001B[38;5;241m=\u001B[39m([\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mtime\u001B[39m\u001B[38;5;124m\"\u001B[39m, \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mlat\u001B[39m\u001B[38;5;124m\"\u001B[39m,\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mlon\u001B[39m\u001B[38;5;124m\"\u001B[39m, \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mmodel\u001B[39m\u001B[38;5;124m\"\u001B[39m],\u001B[43mnp\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43masarray\u001B[49m\u001B[43m(\u001B[49m\u001B[43msubset\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mdata\u001B[49m\u001B[43m)\u001B[49m),\n\u001B[1;32m 4\u001B[0m ),\n\u001B[1;32m 5\u001B[0m coords\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mdict\u001B[39m(\n\u001B[1;32m 6\u001B[0m time\u001B[38;5;241m=\u001B[39msubset\u001B[38;5;241m.\u001B[39mtime\u001B[38;5;241m.\u001B[39mdata,\n\u001B[1;32m 7\u001B[0m lat\u001B[38;5;241m=\u001B[39msubset\u001B[38;5;241m.\u001B[39mlat\u001B[38;5;241m.\u001B[39mdata,\n\u001B[1;32m 8\u001B[0m lon\u001B[38;5;241m=\u001B[39msubset\u001B[38;5;241m.\u001B[39mlon\u001B[38;5;241m.\u001B[39mdata,\n\u001B[1;32m 9\u001B[0m model\u001B[38;5;241m=\u001B[39msubset\u001B[38;5;241m.\u001B[39mmodel\u001B[38;5;241m.\u001B[39mdata\n\u001B[1;32m 10\u001B[0m ),\n\u001B[1;32m 11\u001B[0m attrs\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mdict\u001B[39m(description\u001B[38;5;241m=\u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mWeather related data.\u001B[39m\u001B[38;5;124m\"\u001B[39m),\n\u001B[1;32m 12\u001B[0m )\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/dask/array/core.py:1709\u001B[0m, in \u001B[0;36mArray.__array__\u001B[0;34m(self, dtype, **kwargs)\u001B[0m\n\u001B[1;32m 1708\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21m__array__\u001B[39m(\u001B[38;5;28mself\u001B[39m, dtype\u001B[38;5;241m=\u001B[39m\u001B[38;5;28;01mNone\u001B[39;00m, \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39mkwargs):\n\u001B[0;32m-> 1709\u001B[0m x \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mcompute\u001B[49m\u001B[43m(\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 1710\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m dtype \u001B[38;5;129;01mand\u001B[39;00m x\u001B[38;5;241m.\u001B[39mdtype \u001B[38;5;241m!=\u001B[39m dtype:\n\u001B[1;32m 1711\u001B[0m x \u001B[38;5;241m=\u001B[39m x\u001B[38;5;241m.\u001B[39mastype(dtype)\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/dask/base.py:372\u001B[0m, in \u001B[0;36mDaskMethodsMixin.compute\u001B[0;34m(self, **kwargs)\u001B[0m\n\u001B[1;32m 348\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21mcompute\u001B[39m(\u001B[38;5;28mself\u001B[39m, \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39mkwargs):\n\u001B[1;32m 349\u001B[0m \u001B[38;5;250m \u001B[39m\u001B[38;5;124;03m\"\"\"Compute this dask collection\u001B[39;00m\n\u001B[1;32m 350\u001B[0m \n\u001B[1;32m 351\u001B[0m \u001B[38;5;124;03m This turns a lazy Dask collection into its in-memory equivalent.\u001B[39;00m\n\u001B[0;32m (...)\u001B[0m\n\u001B[1;32m 370\u001B[0m \u001B[38;5;124;03m dask.compute\u001B[39;00m\n\u001B[1;32m 371\u001B[0m \u001B[38;5;124;03m \"\"\"\u001B[39;00m\n\u001B[0;32m--> 372\u001B[0m (result,) \u001B[38;5;241m=\u001B[39m \u001B[43mcompute\u001B[49m\u001B[43m(\u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mtraverse\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43;01mFalse\u001B[39;49;00m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mkwargs\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 373\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m result\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/dask/base.py:660\u001B[0m, in \u001B[0;36mcompute\u001B[0;34m(traverse, optimize_graph, scheduler, get, *args, **kwargs)\u001B[0m\n\u001B[1;32m 657\u001B[0m postcomputes\u001B[38;5;241m.\u001B[39mappend(x\u001B[38;5;241m.\u001B[39m__dask_postcompute__())\n\u001B[1;32m 659\u001B[0m \u001B[38;5;28;01mwith\u001B[39;00m shorten_traceback():\n\u001B[0;32m--> 660\u001B[0m results \u001B[38;5;241m=\u001B[39m \u001B[43mschedule\u001B[49m\u001B[43m(\u001B[49m\u001B[43mdsk\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mkeys\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mkwargs\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 662\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m repack([f(r, \u001B[38;5;241m*\u001B[39ma) \u001B[38;5;28;01mfor\u001B[39;00m r, (f, a) \u001B[38;5;129;01min\u001B[39;00m \u001B[38;5;28mzip\u001B[39m(results, postcomputes)])\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/core/indexing.py:580\u001B[0m, in \u001B[0;36mImplicitToExplicitIndexingAdapter.__array__\u001B[0;34m(self, dtype, copy)\u001B[0m\n\u001B[1;32m 578\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m np\u001B[38;5;241m.\u001B[39masarray(\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mget_duck_array(), dtype\u001B[38;5;241m=\u001B[39mdtype, copy\u001B[38;5;241m=\u001B[39mcopy)\n\u001B[1;32m 579\u001B[0m \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[0;32m--> 580\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m np\u001B[38;5;241m.\u001B[39masarray(\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mget_duck_array\u001B[49m\u001B[43m(\u001B[49m\u001B[43m)\u001B[49m, dtype\u001B[38;5;241m=\u001B[39mdtype)\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/core/indexing.py:583\u001B[0m, in \u001B[0;36mImplicitToExplicitIndexingAdapter.get_duck_array\u001B[0;34m(self)\u001B[0m\n\u001B[1;32m 582\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21mget_duck_array\u001B[39m(\u001B[38;5;28mself\u001B[39m):\n\u001B[0;32m--> 583\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43marray\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mget_duck_array\u001B[49m\u001B[43m(\u001B[49m\u001B[43m)\u001B[49m\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/core/indexing.py:794\u001B[0m, in \u001B[0;36mCopyOnWriteArray.get_duck_array\u001B[0;34m(self)\u001B[0m\n\u001B[1;32m 793\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21mget_duck_array\u001B[39m(\u001B[38;5;28mself\u001B[39m):\n\u001B[0;32m--> 794\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43marray\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mget_duck_array\u001B[49m\u001B[43m(\u001B[49m\u001B[43m)\u001B[49m\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/core/indexing.py:657\u001B[0m, in \u001B[0;36mLazilyIndexedArray.get_duck_array\u001B[0;34m(self)\u001B[0m\n\u001B[1;32m 653\u001B[0m array \u001B[38;5;241m=\u001B[39m apply_indexer(\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39marray, \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mkey)\n\u001B[1;32m 654\u001B[0m \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[1;32m 655\u001B[0m \u001B[38;5;66;03m# If the array is not an ExplicitlyIndexedNDArrayMixin,\u001B[39;00m\n\u001B[1;32m 656\u001B[0m \u001B[38;5;66;03m# it may wrap a BackendArray so use its __getitem__\u001B[39;00m\n\u001B[0;32m--> 657\u001B[0m array \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43marray\u001B[49m\u001B[43m[\u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mkey\u001B[49m\u001B[43m]\u001B[49m\n\u001B[1;32m 659\u001B[0m \u001B[38;5;66;03m# self.array[self.key] is now a numpy array when\u001B[39;00m\n\u001B[1;32m 660\u001B[0m \u001B[38;5;66;03m# self.array is a BackendArray subclass\u001B[39;00m\n\u001B[1;32m 661\u001B[0m \u001B[38;5;66;03m# and self.key is BasicIndexer((slice(None, None, None),))\u001B[39;00m\n\u001B[1;32m 662\u001B[0m \u001B[38;5;66;03m# so we need the explicit check for ExplicitlyIndexed\u001B[39;00m\n\u001B[1;32m 663\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(array, ExplicitlyIndexed):\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/backends/zarr.py:226\u001B[0m, in \u001B[0;36mZarrArrayWrapper.__getitem__\u001B[0;34m(self, key)\u001B[0m\n\u001B[1;32m 224\u001B[0m \u001B[38;5;28;01melif\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(key, indexing\u001B[38;5;241m.\u001B[39mOuterIndexer):\n\u001B[1;32m 225\u001B[0m method \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_oindex\n\u001B[0;32m--> 226\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[43mindexing\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mexplicit_indexing_adapter\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m 227\u001B[0m \u001B[43m \u001B[49m\u001B[43mkey\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43marray\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mshape\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mindexing\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mIndexingSupport\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mVECTORIZED\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mmethod\u001B[49m\n\u001B[1;32m 228\u001B[0m \u001B[43m\u001B[49m\u001B[43m)\u001B[49m\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/core/indexing.py:1018\u001B[0m, in \u001B[0;36mexplicit_indexing_adapter\u001B[0;34m(key, shape, indexing_support, raw_indexing_method)\u001B[0m\n\u001B[1;32m 996\u001B[0m \u001B[38;5;250m\u001B[39m\u001B[38;5;124;03m\"\"\"Support explicit indexing by delegating to a raw indexing method.\u001B[39;00m\n\u001B[1;32m 997\u001B[0m \n\u001B[1;32m 998\u001B[0m \u001B[38;5;124;03mOuter and/or vectorized indexers are supported by indexing a second time\u001B[39;00m\n\u001B[0;32m (...)\u001B[0m\n\u001B[1;32m 1015\u001B[0m \u001B[38;5;124;03mIndexing result, in the form of a duck numpy-array.\u001B[39;00m\n\u001B[1;32m 1016\u001B[0m \u001B[38;5;124;03m\"\"\"\u001B[39;00m\n\u001B[1;32m 1017\u001B[0m raw_key, numpy_indices \u001B[38;5;241m=\u001B[39m decompose_indexer(key, shape, indexing_support)\n\u001B[0;32m-> 1018\u001B[0m result \u001B[38;5;241m=\u001B[39m \u001B[43mraw_indexing_method\u001B[49m\u001B[43m(\u001B[49m\u001B[43mraw_key\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mtuple\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 1019\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m numpy_indices\u001B[38;5;241m.\u001B[39mtuple:\n\u001B[1;32m 1020\u001B[0m \u001B[38;5;66;03m# index the loaded np.ndarray\u001B[39;00m\n\u001B[1;32m 1021\u001B[0m indexable \u001B[38;5;241m=\u001B[39m NumpyIndexingAdapter(result)\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/backends/zarr.py:216\u001B[0m, in \u001B[0;36mZarrArrayWrapper._getitem\u001B[0;34m(self, key)\u001B[0m\n\u001B[1;32m 215\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21m_getitem\u001B[39m(\u001B[38;5;28mself\u001B[39m, key):\n\u001B[0;32m--> 216\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_array\u001B[49m\u001B[43m[\u001B[49m\u001B[43mkey\u001B[49m\u001B[43m]\u001B[49m\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/zarr/core.py:795\u001B[0m, in \u001B[0;36mArray.__getitem__\u001B[0;34m(self, selection)\u001B[0m\n\u001B[1;32m 793\u001B[0m result \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mvindex[selection]\n\u001B[1;32m 794\u001B[0m \u001B[38;5;28;01melif\u001B[39;00m is_pure_orthogonal_indexing(pure_selection, \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mndim):\n\u001B[0;32m--> 795\u001B[0m result \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mget_orthogonal_selection\u001B[49m\u001B[43m(\u001B[49m\u001B[43mpure_selection\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mfields\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mfields\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 796\u001B[0m \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[1;32m 797\u001B[0m result \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mget_basic_selection(pure_selection, fields\u001B[38;5;241m=\u001B[39mfields)\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/zarr/core.py:1077\u001B[0m, in \u001B[0;36mArray.get_orthogonal_selection\u001B[0;34m(self, selection, out, fields)\u001B[0m\n\u001B[1;32m 1074\u001B[0m \u001B[38;5;66;03m# setup indexer\u001B[39;00m\n\u001B[1;32m 1075\u001B[0m indexer \u001B[38;5;241m=\u001B[39m OrthogonalIndexer(selection, \u001B[38;5;28mself\u001B[39m)\n\u001B[0;32m-> 1077\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_get_selection\u001B[49m\u001B[43m(\u001B[49m\u001B[43mindexer\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mindexer\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mout\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mout\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mfields\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mfields\u001B[49m\u001B[43m)\u001B[49m\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/zarr/core.py:1340\u001B[0m, in \u001B[0;36mArray._get_selection\u001B[0;34m(self, indexer, out, fields)\u001B[0m\n\u001B[1;32m 1337\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m math\u001B[38;5;241m.\u001B[39mprod(out_shape) \u001B[38;5;241m>\u001B[39m \u001B[38;5;241m0\u001B[39m:\n\u001B[1;32m 1338\u001B[0m \u001B[38;5;66;03m# allow storage to get multiple items at once\u001B[39;00m\n\u001B[1;32m 1339\u001B[0m lchunk_coords, lchunk_selection, lout_selection \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mzip\u001B[39m(\u001B[38;5;241m*\u001B[39mindexer)\n\u001B[0;32m-> 1340\u001B[0m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_chunk_getitems\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m 1341\u001B[0m \u001B[43m \u001B[49m\u001B[43mlchunk_coords\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 1342\u001B[0m \u001B[43m \u001B[49m\u001B[43mlchunk_selection\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 1343\u001B[0m \u001B[43m \u001B[49m\u001B[43mout\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 1344\u001B[0m \u001B[43m \u001B[49m\u001B[43mlout_selection\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 1345\u001B[0m \u001B[43m \u001B[49m\u001B[43mdrop_axes\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mindexer\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mdrop_axes\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 1346\u001B[0m \u001B[43m \u001B[49m\u001B[43mfields\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mfields\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 1347\u001B[0m \u001B[43m \u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 1348\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m out\u001B[38;5;241m.\u001B[39mshape:\n\u001B[1;32m 1349\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m out\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/zarr/core.py:2181\u001B[0m, in \u001B[0;36mArray._chunk_getitems\u001B[0;34m(self, lchunk_coords, lchunk_selection, out, lout_selection, drop_axes, fields)\u001B[0m\n\u001B[1;32m 2179\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;129;01mnot\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_meta_array, np\u001B[38;5;241m.\u001B[39mndarray):\n\u001B[1;32m 2180\u001B[0m contexts \u001B[38;5;241m=\u001B[39m ConstantMap(ckeys, constant\u001B[38;5;241m=\u001B[39mContext(meta_array\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_meta_array))\n\u001B[0;32m-> 2181\u001B[0m cdatas \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mchunk_store\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mgetitems\u001B[49m\u001B[43m(\u001B[49m\u001B[43mckeys\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mcontexts\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mcontexts\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 2183\u001B[0m \u001B[38;5;28;01mfor\u001B[39;00m ckey, chunk_select, out_select \u001B[38;5;129;01min\u001B[39;00m \u001B[38;5;28mzip\u001B[39m(ckeys, lchunk_selection, lout_selection):\n\u001B[1;32m 2184\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m ckey \u001B[38;5;129;01min\u001B[39;00m cdatas:\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/zarr/storage.py:1435\u001B[0m, in \u001B[0;36mFSStore.getitems\u001B[0;34m(self, keys, contexts)\u001B[0m\n\u001B[1;32m 1432\u001B[0m \u001B[38;5;28;01mcontinue\u001B[39;00m\n\u001B[1;32m 1433\u001B[0m \u001B[38;5;28;01melif\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(v, \u001B[38;5;167;01mException\u001B[39;00m):\n\u001B[1;32m 1434\u001B[0m \u001B[38;5;66;03m# Raise any other exception\u001B[39;00m\n\u001B[0;32m-> 1435\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m v\n\u001B[1;32m 1436\u001B[0m \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[1;32m 1437\u001B[0m \u001B[38;5;66;03m# The function calling this method may not recognize the transformed\u001B[39;00m\n\u001B[1;32m 1438\u001B[0m \u001B[38;5;66;03m# keys, so we send the values returned by self.map.getitems back into\u001B[39;00m\n\u001B[1;32m 1439\u001B[0m \u001B[38;5;66;03m# the original key space.\u001B[39;00m\n\u001B[1;32m 1440\u001B[0m results[keys_transformed[k]] \u001B[38;5;241m=\u001B[39m v\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/adlfs/spec.py:1506\u001B[0m, in \u001B[0;36mAzureBlobFileSystem.cat\u001B[0;34m(self, path, recursive, on_error, **kwargs)\u001B[0m\n\u001B[1;32m 1504\u001B[0m \u001B[38;5;28;01mfor\u001B[39;00m path \u001B[38;5;129;01min\u001B[39;00m paths:\n\u001B[1;32m 1505\u001B[0m \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[0;32m-> 1506\u001B[0m out[path] \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mcat_file\u001B[49m\u001B[43m(\u001B[49m\u001B[43mpath\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mkwargs\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 1507\u001B[0m \u001B[38;5;28;01mexcept\u001B[39;00m \u001B[38;5;167;01mException\u001B[39;00m \u001B[38;5;28;01mas\u001B[39;00m e:\n\u001B[1;32m 1508\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m on_error \u001B[38;5;241m==\u001B[39m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mraise\u001B[39m\u001B[38;5;124m\"\u001B[39m:\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/fsspec/asyn.py:118\u001B[0m, in \u001B[0;36msync_wrapper..wrapper\u001B[0;34m(*args, **kwargs)\u001B[0m\n\u001B[1;32m 115\u001B[0m \u001B[38;5;129m@functools\u001B[39m\u001B[38;5;241m.\u001B[39mwraps(func)\n\u001B[1;32m 116\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21mwrapper\u001B[39m(\u001B[38;5;241m*\u001B[39margs, \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39mkwargs):\n\u001B[1;32m 117\u001B[0m \u001B[38;5;28mself\u001B[39m \u001B[38;5;241m=\u001B[39m obj \u001B[38;5;129;01mor\u001B[39;00m args[\u001B[38;5;241m0\u001B[39m]\n\u001B[0;32m--> 118\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[43msync\u001B[49m\u001B[43m(\u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mloop\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mfunc\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43margs\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mkwargs\u001B[49m\u001B[43m)\u001B[49m\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/fsspec/asyn.py:103\u001B[0m, in \u001B[0;36msync\u001B[0;34m(loop, func, timeout, *args, **kwargs)\u001B[0m\n\u001B[1;32m 101\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m FSTimeoutError \u001B[38;5;28;01mfrom\u001B[39;00m \u001B[38;5;21;01mreturn_result\u001B[39;00m\n\u001B[1;32m 102\u001B[0m \u001B[38;5;28;01melif\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(return_result, \u001B[38;5;167;01mBaseException\u001B[39;00m):\n\u001B[0;32m--> 103\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m return_result\n\u001B[1;32m 104\u001B[0m \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[1;32m 105\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m return_result\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/fsspec/asyn.py:56\u001B[0m, in \u001B[0;36m_runner\u001B[0;34m(event, coro, result, timeout)\u001B[0m\n\u001B[1;32m 54\u001B[0m coro \u001B[38;5;241m=\u001B[39m asyncio\u001B[38;5;241m.\u001B[39mwait_for(coro, timeout\u001B[38;5;241m=\u001B[39mtimeout)\n\u001B[1;32m 55\u001B[0m \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[0;32m---> 56\u001B[0m result[\u001B[38;5;241m0\u001B[39m] \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;01mawait\u001B[39;00m coro\n\u001B[1;32m 57\u001B[0m \u001B[38;5;28;01mexcept\u001B[39;00m \u001B[38;5;167;01mException\u001B[39;00m \u001B[38;5;28;01mas\u001B[39;00m ex:\n\u001B[1;32m 58\u001B[0m result[\u001B[38;5;241m0\u001B[39m] \u001B[38;5;241m=\u001B[39m ex\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/adlfs/spec.py:1466\u001B[0m, in \u001B[0;36mAzureBlobFileSystem._cat_file\u001B[0;34m(self, path, start, end, max_concurrency, **kwargs)\u001B[0m\n\u001B[1;32m 1462\u001B[0m \u001B[38;5;28;01masync\u001B[39;00m \u001B[38;5;28;01mwith\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mservice_client\u001B[38;5;241m.\u001B[39mget_blob_client(\n\u001B[1;32m 1463\u001B[0m container\u001B[38;5;241m=\u001B[39mcontainer_name, blob\u001B[38;5;241m=\u001B[39mblob\n\u001B[1;32m 1464\u001B[0m ) \u001B[38;5;28;01mas\u001B[39;00m bc:\n\u001B[1;32m 1465\u001B[0m \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[0;32m-> 1466\u001B[0m stream \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;01mawait\u001B[39;00m bc\u001B[38;5;241m.\u001B[39mdownload_blob(\n\u001B[1;32m 1467\u001B[0m offset\u001B[38;5;241m=\u001B[39mstart,\n\u001B[1;32m 1468\u001B[0m length\u001B[38;5;241m=\u001B[39mlength,\n\u001B[1;32m 1469\u001B[0m version_id\u001B[38;5;241m=\u001B[39mversion_id,\n\u001B[1;32m 1470\u001B[0m max_concurrency\u001B[38;5;241m=\u001B[39mmax_concurrency \u001B[38;5;129;01mor\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mmax_concurrency,\n\u001B[1;32m 1471\u001B[0m \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39m\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_timeout_kwargs,\n\u001B[1;32m 1472\u001B[0m )\n\u001B[1;32m 1473\u001B[0m \u001B[38;5;28;01mexcept\u001B[39;00m ResourceNotFoundError \u001B[38;5;28;01mas\u001B[39;00m e:\n\u001B[1;32m 1474\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m \u001B[38;5;167;01mFileNotFoundError\u001B[39;00m(\n\u001B[1;32m 1475\u001B[0m errno\u001B[38;5;241m.\u001B[39mENOENT, os\u001B[38;5;241m.\u001B[39mstrerror(errno\u001B[38;5;241m.\u001B[39mENOENT), path\n\u001B[1;32m 1476\u001B[0m ) \u001B[38;5;28;01mfrom\u001B[39;00m \u001B[38;5;21;01me\u001B[39;00m\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/core/tracing/decorator_async.py:114\u001B[0m, in \u001B[0;36mdistributed_trace_async..decorator..wrapper_use_tracer\u001B[0;34m(*args, **kwargs)\u001B[0m\n\u001B[1;32m 112\u001B[0m span_impl_type \u001B[38;5;241m=\u001B[39m settings\u001B[38;5;241m.\u001B[39mtracing_implementation()\n\u001B[1;32m 113\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m span_impl_type \u001B[38;5;129;01mis\u001B[39;00m \u001B[38;5;28;01mNone\u001B[39;00m:\n\u001B[0;32m--> 114\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28;01mawait\u001B[39;00m func(\u001B[38;5;241m*\u001B[39margs, \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39mkwargs)\n\u001B[1;32m 116\u001B[0m \u001B[38;5;66;03m# Merge span is parameter is set, but only if no explicit parent are passed\u001B[39;00m\n\u001B[1;32m 117\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m merge_span \u001B[38;5;129;01mand\u001B[39;00m \u001B[38;5;129;01mnot\u001B[39;00m passed_in_parent:\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_blob_client_async.py:746\u001B[0m, in \u001B[0;36mBlobClient.download_blob\u001B[0;34m(self, offset, length, encoding, **kwargs)\u001B[0m\n\u001B[1;32m 728\u001B[0m options \u001B[38;5;241m=\u001B[39m _download_blob_options(\n\u001B[1;32m 729\u001B[0m blob_name\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mblob_name,\n\u001B[1;32m 730\u001B[0m container_name\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mcontainer_name,\n\u001B[0;32m (...)\u001B[0m\n\u001B[1;32m 743\u001B[0m client\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_client,\n\u001B[1;32m 744\u001B[0m \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39mkwargs)\n\u001B[1;32m 745\u001B[0m downloader \u001B[38;5;241m=\u001B[39m StorageStreamDownloader(\u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39moptions)\n\u001B[0;32m--> 746\u001B[0m \u001B[38;5;28;01mawait\u001B[39;00m downloader\u001B[38;5;241m.\u001B[39m_setup() \u001B[38;5;66;03m# pylint: disable=protected-access\u001B[39;00m\n\u001B[1;32m 747\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m downloader\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py:328\u001B[0m, in \u001B[0;36mStorageStreamDownloader._setup\u001B[0;34m(self)\u001B[0m\n\u001B[1;32m 319\u001B[0m \u001B[38;5;66;03m# pylint: disable-next=attribute-defined-outside-init\u001B[39;00m\n\u001B[1;32m 320\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_initial_range, \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_initial_offset \u001B[38;5;241m=\u001B[39m process_range_and_offset(\n\u001B[1;32m 321\u001B[0m initial_request_start,\n\u001B[1;32m 322\u001B[0m initial_request_end,\n\u001B[0;32m (...)\u001B[0m\n\u001B[1;32m 325\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_encryption_data\n\u001B[1;32m 326\u001B[0m )\n\u001B[0;32m--> 328\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_response \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;01mawait\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_initial_request()\n\u001B[1;32m 329\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mproperties \u001B[38;5;241m=\u001B[39m cast(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mBlobProperties\u001B[39m\u001B[38;5;124m\"\u001B[39m, \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_response\u001B[38;5;241m.\u001B[39mproperties) \u001B[38;5;66;03m# type: ignore [attr-defined]\u001B[39;00m\n\u001B[1;32m 330\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mproperties\u001B[38;5;241m.\u001B[39mname \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mname\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py:410\u001B[0m, in \u001B[0;36mStorageStreamDownloader._initial_request\u001B[0;34m(self)\u001B[0m\n\u001B[1;32m 408\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_file_size \u001B[38;5;241m=\u001B[39m \u001B[38;5;241m0\u001B[39m\n\u001B[1;32m 409\u001B[0m \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[0;32m--> 410\u001B[0m \u001B[43mprocess_storage_error\u001B[49m\u001B[43m(\u001B[49m\u001B[43merror\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 412\u001B[0m \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[1;32m 413\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39msize \u001B[38;5;241m==\u001B[39m \u001B[38;5;241m0\u001B[39m:\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/_shared/response_handlers.py:186\u001B[0m, in \u001B[0;36mprocess_storage_error\u001B[0;34m(storage_error)\u001B[0m\n\u001B[1;32m 183\u001B[0m error\u001B[38;5;241m.\u001B[39margs \u001B[38;5;241m=\u001B[39m (error\u001B[38;5;241m.\u001B[39mmessage,)\n\u001B[1;32m 184\u001B[0m \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[1;32m 185\u001B[0m \u001B[38;5;66;03m# `from None` prevents us from double printing the exception (suppresses generated layer error context)\u001B[39;00m\n\u001B[0;32m--> 186\u001B[0m exec(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mraise error from None\u001B[39m\u001B[38;5;124m\"\u001B[39m) \u001B[38;5;66;03m# pylint: disable=exec-used # nosec\u001B[39;00m\n\u001B[1;32m 187\u001B[0m \u001B[38;5;28;01mexcept\u001B[39;00m \u001B[38;5;167;01mSyntaxError\u001B[39;00m \u001B[38;5;28;01mas\u001B[39;00m exc:\n\u001B[1;32m 188\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m error \u001B[38;5;28;01mfrom\u001B[39;00m \u001B[38;5;21;01mexc\u001B[39;00m\n", - "File \u001B[0;32m:1\u001B[0m\n", - "\u001B[0;31mClientAuthenticationError\u001B[0m: Server failed to authenticate the request. Make sure the value of Authorization header is formed correctly including the signature.\nRequestId:356fa9fc-a01e-0046-0fbb-5da77d000000\nTime:2025-01-03T08:44:03.5582125Z\nErrorCode:AuthenticationFailed\nauthenticationerrordetail:Signature not valid in the specified time frame: Start [Wed, 01 Jan 2025 21:42:40 GMT] - Expiry [Thu, 02 Jan 2025 22:27:40 GMT] - Current [Fri, 03 Jan 2025 08:44:03 GMT]\nContent: AuthenticationFailedServer failed to authenticate the request. Make sure the value of Authorization header is formed correctly including the signature.\nRequestId:356fa9fc-a01e-0046-0fbb-5da77d000000\nTime:2025-01-03T08:44:03.5582125ZSignature not valid in the specified time frame: Start [Wed, 01 Jan 2025 21:42:40 GMT] - Expiry [Thu, 02 Jan 2025 22:27:40 GMT] - Current [Fri, 03 Jan 2025 08:44:03 GMT]" + "\u001B[0;31mKeyboardInterrupt\u001B[0m Traceback (most recent call last)", + "Cell \u001B[0;32mIn[52], line 62\u001B[0m\n\u001B[1;32m 60\u001B[0m combined_output \u001B[38;5;241m=\u001B[39m \u001B[38;5;124mf\u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;132;01m{\u001B[39;00moutput_dir\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m/CIL_subsetted_all_model_\u001B[39m\u001B[38;5;132;01m{\u001B[39;00mscenario\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m.nc\u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[1;32m 61\u001B[0m combined_dataset \u001B[38;5;241m=\u001B[39m xr\u001B[38;5;241m.\u001B[39mopen_mfdataset(yearly_files, combine\u001B[38;5;241m=\u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mby_coords\u001B[39m\u001B[38;5;124m\"\u001B[39m)\n\u001B[0;32m---> 62\u001B[0m \u001B[43mcombined_dataset\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mto_netcdf\u001B[49m\u001B[43m(\u001B[49m\u001B[43mcombined_output\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 63\u001B[0m \u001B[38;5;28mprint\u001B[39m(\u001B[38;5;124mf\u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mSaved combined dataset to \u001B[39m\u001B[38;5;132;01m{\u001B[39;00mcombined_output\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m\"\u001B[39m)\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/core/dataset.py:2372\u001B[0m, in \u001B[0;36mDataset.to_netcdf\u001B[0;34m(self, path, mode, format, group, engine, encoding, unlimited_dims, compute, invalid_netcdf, auto_complex)\u001B[0m\n\u001B[1;32m 2369\u001B[0m encoding \u001B[38;5;241m=\u001B[39m {}\n\u001B[1;32m 2370\u001B[0m \u001B[38;5;28;01mfrom\u001B[39;00m \u001B[38;5;21;01mxarray\u001B[39;00m\u001B[38;5;21;01m.\u001B[39;00m\u001B[38;5;21;01mbackends\u001B[39;00m\u001B[38;5;21;01m.\u001B[39;00m\u001B[38;5;21;01mapi\u001B[39;00m \u001B[38;5;28;01mimport\u001B[39;00m to_netcdf\n\u001B[0;32m-> 2372\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[43mto_netcdf\u001B[49m\u001B[43m(\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;66;43;03m# type: ignore[return-value] # mypy cannot resolve the overloads:(\u001B[39;49;00m\n\u001B[1;32m 2373\u001B[0m \u001B[43m \u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[43m,\u001B[49m\n\u001B[1;32m 2374\u001B[0m \u001B[43m \u001B[49m\u001B[43mpath\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 2375\u001B[0m \u001B[43m \u001B[49m\u001B[43mmode\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mmode\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 2376\u001B[0m \u001B[43m \u001B[49m\u001B[38;5;28;43mformat\u001B[39;49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43mformat\u001B[39;49m\u001B[43m,\u001B[49m\n\u001B[1;32m 2377\u001B[0m \u001B[43m \u001B[49m\u001B[43mgroup\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mgroup\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 2378\u001B[0m \u001B[43m \u001B[49m\u001B[43mengine\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mengine\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 2379\u001B[0m \u001B[43m \u001B[49m\u001B[43mencoding\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mencoding\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 2380\u001B[0m \u001B[43m \u001B[49m\u001B[43munlimited_dims\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43munlimited_dims\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 2381\u001B[0m \u001B[43m \u001B[49m\u001B[43mcompute\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mcompute\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 2382\u001B[0m \u001B[43m \u001B[49m\u001B[43mmultifile\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43;01mFalse\u001B[39;49;00m\u001B[43m,\u001B[49m\n\u001B[1;32m 2383\u001B[0m \u001B[43m \u001B[49m\u001B[43minvalid_netcdf\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43minvalid_netcdf\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 2384\u001B[0m \u001B[43m \u001B[49m\u001B[43mauto_complex\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mauto_complex\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 2385\u001B[0m \u001B[43m\u001B[49m\u001B[43m)\u001B[49m\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/backends/api.py:1882\u001B[0m, in \u001B[0;36mto_netcdf\u001B[0;34m(dataset, path_or_file, mode, format, group, engine, encoding, unlimited_dims, compute, multifile, invalid_netcdf, auto_complex)\u001B[0m\n\u001B[1;32m 1879\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m multifile:\n\u001B[1;32m 1880\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m writer, store\n\u001B[0;32m-> 1882\u001B[0m writes \u001B[38;5;241m=\u001B[39m \u001B[43mwriter\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43msync\u001B[49m\u001B[43m(\u001B[49m\u001B[43mcompute\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mcompute\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 1884\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(target, BytesIO):\n\u001B[1;32m 1885\u001B[0m store\u001B[38;5;241m.\u001B[39msync()\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/backends/common.py:351\u001B[0m, in \u001B[0;36mArrayWriter.sync\u001B[0;34m(self, compute, chunkmanager_store_kwargs)\u001B[0m\n\u001B[1;32m 348\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m chunkmanager_store_kwargs \u001B[38;5;129;01mis\u001B[39;00m \u001B[38;5;28;01mNone\u001B[39;00m:\n\u001B[1;32m 349\u001B[0m chunkmanager_store_kwargs \u001B[38;5;241m=\u001B[39m {}\n\u001B[0;32m--> 351\u001B[0m delayed_store \u001B[38;5;241m=\u001B[39m \u001B[43mchunkmanager\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mstore\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m 352\u001B[0m \u001B[43m \u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43msources\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 353\u001B[0m \u001B[43m \u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mtargets\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 354\u001B[0m \u001B[43m \u001B[49m\u001B[43mlock\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mlock\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 355\u001B[0m \u001B[43m \u001B[49m\u001B[43mcompute\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mcompute\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 356\u001B[0m \u001B[43m \u001B[49m\u001B[43mflush\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43;01mTrue\u001B[39;49;00m\u001B[43m,\u001B[49m\n\u001B[1;32m 357\u001B[0m \u001B[43m \u001B[49m\u001B[43mregions\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mregions\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 358\u001B[0m \u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mchunkmanager_store_kwargs\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 359\u001B[0m \u001B[43m\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 360\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39msources \u001B[38;5;241m=\u001B[39m []\n\u001B[1;32m 361\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mtargets \u001B[38;5;241m=\u001B[39m []\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/namedarray/daskmanager.py:247\u001B[0m, in \u001B[0;36mDaskManager.store\u001B[0;34m(self, sources, targets, **kwargs)\u001B[0m\n\u001B[1;32m 239\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21mstore\u001B[39m(\n\u001B[1;32m 240\u001B[0m \u001B[38;5;28mself\u001B[39m,\n\u001B[1;32m 241\u001B[0m sources: Any \u001B[38;5;241m|\u001B[39m Sequence[Any],\n\u001B[1;32m 242\u001B[0m targets: Any,\n\u001B[1;32m 243\u001B[0m \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39mkwargs: Any,\n\u001B[1;32m 244\u001B[0m ) \u001B[38;5;241m-\u001B[39m\u001B[38;5;241m>\u001B[39m Any:\n\u001B[1;32m 245\u001B[0m \u001B[38;5;28;01mfrom\u001B[39;00m \u001B[38;5;21;01mdask\u001B[39;00m\u001B[38;5;21;01m.\u001B[39;00m\u001B[38;5;21;01marray\u001B[39;00m \u001B[38;5;28;01mimport\u001B[39;00m store\n\u001B[0;32m--> 247\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[43mstore\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m 248\u001B[0m \u001B[43m \u001B[49m\u001B[43msources\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43msources\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 249\u001B[0m \u001B[43m \u001B[49m\u001B[43mtargets\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mtargets\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 250\u001B[0m \u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mkwargs\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 251\u001B[0m \u001B[43m \u001B[49m\u001B[43m)\u001B[49m\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/dask/array/core.py:1245\u001B[0m, in \u001B[0;36mstore\u001B[0;34m(***failed resolving arguments***)\u001B[0m\n\u001B[1;32m 1243\u001B[0m \u001B[38;5;28;01melif\u001B[39;00m compute:\n\u001B[1;32m 1244\u001B[0m store_dsk \u001B[38;5;241m=\u001B[39m HighLevelGraph(layers, dependencies)\n\u001B[0;32m-> 1245\u001B[0m \u001B[43mcompute_as_if_collection\u001B[49m\u001B[43m(\u001B[49m\u001B[43mArray\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mstore_dsk\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mmap_keys\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mkwargs\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 1246\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28;01mNone\u001B[39;00m\n\u001B[1;32m 1248\u001B[0m \u001B[38;5;28;01melse\u001B[39;00m:\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/dask/base.py:397\u001B[0m, in \u001B[0;36mcompute_as_if_collection\u001B[0;34m(cls, dsk, keys, scheduler, get, **kwargs)\u001B[0m\n\u001B[1;32m 395\u001B[0m schedule \u001B[38;5;241m=\u001B[39m get_scheduler(scheduler\u001B[38;5;241m=\u001B[39mscheduler, \u001B[38;5;28mcls\u001B[39m\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mcls\u001B[39m, get\u001B[38;5;241m=\u001B[39mget)\n\u001B[1;32m 396\u001B[0m dsk2 \u001B[38;5;241m=\u001B[39m optimization_function(\u001B[38;5;28mcls\u001B[39m)(dsk, keys, \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39mkwargs)\n\u001B[0;32m--> 397\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[43mschedule\u001B[49m\u001B[43m(\u001B[49m\u001B[43mdsk2\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mkeys\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mkwargs\u001B[49m\u001B[43m)\u001B[49m\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/dask/threaded.py:91\u001B[0m, in \u001B[0;36mget\u001B[0;34m(dsk, keys, cache, num_workers, pool, **kwargs)\u001B[0m\n\u001B[1;32m 88\u001B[0m \u001B[38;5;28;01melif\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(pool, multiprocessing\u001B[38;5;241m.\u001B[39mpool\u001B[38;5;241m.\u001B[39mPool):\n\u001B[1;32m 89\u001B[0m pool \u001B[38;5;241m=\u001B[39m MultiprocessingPoolExecutor(pool)\n\u001B[0;32m---> 91\u001B[0m results \u001B[38;5;241m=\u001B[39m \u001B[43mget_async\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m 92\u001B[0m \u001B[43m \u001B[49m\u001B[43mpool\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43msubmit\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 93\u001B[0m \u001B[43m \u001B[49m\u001B[43mpool\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_max_workers\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 94\u001B[0m \u001B[43m \u001B[49m\u001B[43mdsk\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 95\u001B[0m \u001B[43m \u001B[49m\u001B[43mkeys\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 96\u001B[0m \u001B[43m \u001B[49m\u001B[43mcache\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mcache\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 97\u001B[0m \u001B[43m \u001B[49m\u001B[43mget_id\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43m_thread_get_id\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 98\u001B[0m \u001B[43m \u001B[49m\u001B[43mpack_exception\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mpack_exception\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 99\u001B[0m \u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mkwargs\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 100\u001B[0m \u001B[43m\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 102\u001B[0m \u001B[38;5;66;03m# Cleanup pools associated to dead threads\u001B[39;00m\n\u001B[1;32m 103\u001B[0m \u001B[38;5;28;01mwith\u001B[39;00m pools_lock:\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/dask/local.py:505\u001B[0m, in \u001B[0;36mget_async\u001B[0;34m(submit, num_workers, dsk, result, cache, get_id, rerun_exceptions_locally, pack_exception, raise_exception, callbacks, dumps, loads, chunksize, **kwargs)\u001B[0m\n\u001B[1;32m 503\u001B[0m \u001B[38;5;28;01mwhile\u001B[39;00m state[\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mwaiting\u001B[39m\u001B[38;5;124m\"\u001B[39m] \u001B[38;5;129;01mor\u001B[39;00m state[\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mready\u001B[39m\u001B[38;5;124m\"\u001B[39m] \u001B[38;5;129;01mor\u001B[39;00m state[\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mrunning\u001B[39m\u001B[38;5;124m\"\u001B[39m]:\n\u001B[1;32m 504\u001B[0m fire_tasks(chunksize)\n\u001B[0;32m--> 505\u001B[0m \u001B[38;5;28;01mfor\u001B[39;00m key, res_info, failed \u001B[38;5;129;01min\u001B[39;00m \u001B[43mqueue_get\u001B[49m\u001B[43m(\u001B[49m\u001B[43mqueue\u001B[49m\u001B[43m)\u001B[49m\u001B[38;5;241m.\u001B[39mresult():\n\u001B[1;32m 506\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m failed:\n\u001B[1;32m 507\u001B[0m exc, tb \u001B[38;5;241m=\u001B[39m loads(res_info)\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/dask/local.py:140\u001B[0m, in \u001B[0;36mqueue_get\u001B[0;34m(q)\u001B[0m\n\u001B[1;32m 139\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21mqueue_get\u001B[39m(q):\n\u001B[0;32m--> 140\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[43mq\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mget\u001B[49m\u001B[43m(\u001B[49m\u001B[43m)\u001B[49m\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/queue.py:171\u001B[0m, in \u001B[0;36mQueue.get\u001B[0;34m(self, block, timeout)\u001B[0m\n\u001B[1;32m 169\u001B[0m \u001B[38;5;28;01melif\u001B[39;00m timeout \u001B[38;5;129;01mis\u001B[39;00m \u001B[38;5;28;01mNone\u001B[39;00m:\n\u001B[1;32m 170\u001B[0m \u001B[38;5;28;01mwhile\u001B[39;00m \u001B[38;5;129;01mnot\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_qsize():\n\u001B[0;32m--> 171\u001B[0m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mnot_empty\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mwait\u001B[49m\u001B[43m(\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 172\u001B[0m \u001B[38;5;28;01melif\u001B[39;00m timeout \u001B[38;5;241m<\u001B[39m \u001B[38;5;241m0\u001B[39m:\n\u001B[1;32m 173\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m \u001B[38;5;167;01mValueError\u001B[39;00m(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mtimeout\u001B[39m\u001B[38;5;124m'\u001B[39m\u001B[38;5;124m must be a non-negative number\u001B[39m\u001B[38;5;124m\"\u001B[39m)\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/threading.py:327\u001B[0m, in \u001B[0;36mCondition.wait\u001B[0;34m(self, timeout)\u001B[0m\n\u001B[1;32m 325\u001B[0m \u001B[38;5;28;01mtry\u001B[39;00m: \u001B[38;5;66;03m# restore state no matter what (e.g., KeyboardInterrupt)\u001B[39;00m\n\u001B[1;32m 326\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m timeout \u001B[38;5;129;01mis\u001B[39;00m \u001B[38;5;28;01mNone\u001B[39;00m:\n\u001B[0;32m--> 327\u001B[0m \u001B[43mwaiter\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43macquire\u001B[49m\u001B[43m(\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 328\u001B[0m gotit \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;01mTrue\u001B[39;00m\n\u001B[1;32m 329\u001B[0m \u001B[38;5;28;01melse\u001B[39;00m:\n", + "\u001B[0;31mKeyboardInterrupt\u001B[0m: " ] } ], - "execution_count": 7 + "execution_count": 52 }, { "metadata": {}, "cell_type": "markdown", - "source": "Now find overall lowest/median/highest for model ensemble", - "id": "f303bfb90133f238" + "source": "Find lowest, median, and highest value model across all lat/long and across all time points", + "id": "8564e555060bf10a" }, { "metadata": {}, @@ -252,8 +527,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-03T09:24:55.643333Z", - "start_time": "2025-01-03T09:24:55.442582Z" + "end_time": "2025-01-07T09:41:43.642027Z", + "start_time": "2025-01-07T09:41:43.455377Z" } }, "cell_type": "code", @@ -282,18 +557,18 @@ "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/4112377517.py:16: DtypeWarning: Columns (58,59,105,127,136,142,149,150,258,285,296,319,344,345,360,393,394,427,428,437,449,450,452,453,461,462,478,479,489,490,492,493,494,497,498,499,500,501,502,503,572,580,585,586,587,588,591,592,593,594,607,608,609,610,619,620,621,622,626,634,872,887,967,978,1066,1510) have mixed types. Specify dtype option on import or set low_memory=False.\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_51565/4112377517.py:16: DtypeWarning: Columns (58,59,105,127,136,142,149,150,258,285,296,319,344,345,360,393,394,427,428,437,449,450,452,453,461,462,478,479,489,490,492,493,494,497,498,499,500,501,502,503,572,580,585,586,587,588,591,592,593,594,607,608,609,610,619,620,621,622,626,634,872,887,967,978,1066,1510) have mixed types. Specify dtype option on import or set low_memory=False.\n", " facilities_with_lat_long = pd.read_csv(\n" ] } ], - "execution_count": 20 + "execution_count": 2 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-03T09:24:56.355595Z", - "start_time": "2025-01-03T09:24:56.349672Z" + "end_time": "2025-01-07T09:41:45.213570Z", + "start_time": "2025-01-07T09:41:45.207554Z" } }, "cell_type": "code", @@ -369,13 +644,15 @@ ], "id": "a9a92aa8bbb6b45a", "outputs": [], - "execution_count": 21 + "execution_count": 3 }, { "metadata": { + "jupyter": { + "is_executing": true + }, "ExecuteTime": { - "end_time": "2025-01-03T09:28:36.461864Z", - "start_time": "2025-01-03T09:28:22.793075Z" + "start_time": "2025-01-07T10:13:26.237514Z" } }, "cell_type": "code", @@ -383,7 +660,8 @@ "base_dir = \"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/\"\n", "nc_file_directory = os.path.join(base_dir, 'nc_files')\n", "# NB these are daily \n", - "scenarios = [\"ssp245\", \"ssp585\"] # don't have ssp19 scenario\n", + "scenarios = [\"ssp245\"]#, \"ssp585\"] \n", + "#scenarios = [\"ssp585\"] \n", "\n", "data_by_model_and_grid = {}\n", "for scenario in scenarios:\n", @@ -392,36 +670,43 @@ "\n", " grid_centroids = {}\n", " cumulative_sum_by_models = {}\n", - " file_path_downscaled = f\"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/CIL_subsetted_all_model_{scenario}.nc\"\n", - " data_all_models = xr.open_dataset(file_path_downscaled)\n", + " file_path_downscaled = f\"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/\"\n", + " output_file = f\"CIL_combined_{scenario}_2025_2070.nc\"\n", + " file_pattern = os.path.join(file_path_downscaled, \"CIL_subset_ssp245_*.nc\")\n", + " data_all_models = xr.open_mfdataset(file_pattern, combine='nested', concat_dim=\"time\")\n", + " data_all_models.compute()\n", + "\n", + " data_all_models.to_netcdf(output_file)\n", + " #data_all_models = xr.open_dataset(file_path_downscaled)\n", " \n", " ## Get models of interest - min, med, max\n", " # Assuming 'pr' is the variable representing precipitation in the dataset\n", - " pr_aggregated = data_all_models.mean(dim=[\"lat\", \"lon\", \"time\"]) # Work with the 'pr' DataArray \n", + " pr_aggregated = data_all_models.mean(dim=[\"lat\", \"lon\", \"time\"], skipna=True) # Work with the 'pr' DataArray \n", "\n", " # Find the model with the lowest value\n", " min_model_object = pr_aggregated['pr'].idxmin(dim=\"model\")\n", " min_model = min_model_object.values.item()\n", - " \n", - " median_value = pr_aggregated['pr'].median(dim=\"model\").values.item()\n", " # Find the model with the median value\n", " sorted_models = pr_aggregated.sortby(\"model\")\n", " n_models = len(pr_aggregated.model)\n", " median_index = n_models // 2\n", " median_model_object = sorted_models[\"model\"][median_index]\n", + " print(median_model_object)\n", " median_model = median_model_object.values.item()\n", - " \n", + " print(median_model)\n", " # Find the model with the highest value\n", " max_model_object = pr_aggregated['pr'].idxmax(dim=\"model\")\n", " max_model = max_model_object.values.item()\n", "\n", " models_of_interest = [min_model, median_model, max_model]\n", + " #models_of_interest = [median_model]\n", + "\n", " print(\"Models of interest\", models_of_interest)\n", " # see which facilities have reporting data and data on latitude and longitude\n", " weather_df_lowest_window = pd.DataFrame()\n", " weather_df_median_window = pd.DataFrame()\n", " weather_df_highest_window = pd.DataFrame()\n", - " \n", + "\n", " weather_df_lowest_monthly = pd.DataFrame()\n", " weather_df_median_monthly = pd.DataFrame()\n", " weather_df_highest_monthly = pd.DataFrame()\n", @@ -451,17 +736,17 @@ " if not np.isnan(long_for_facility) and not np.isnan(lat_for_facility):\n", " facility_location = np.array([lat_for_facility, long_for_facility])\n", " kd_trees_by_model = {}\n", - " \n", + "\n", " # Loop over each model of interest\n", " for model in models_of_interest:\n", " centroids = grid_centroids[model]\n", " kd_tree = KDTree(centroids)\n", " distance, closest_grid_index = kd_tree.query(facility_location)\n", - " grid_precipitation_for_facility[model] = data_by_model_and_grid[model][closest_grid_index].data\n", - " \n", + " grid_precipitation_for_facility[model] = data_by_model_and_grid[model][closest_grid_index]\n", + "\n", " cumulative_sum_monthly = []\n", " cumulative_sum_window = []\n", - " \n", + "\n", " begin_day = 0\n", " # Calculate monthly cumulative sums\n", " for month_idx, month_length in enumerate(month_lengths):\n", @@ -472,21 +757,21 @@ " max_cumulative_sums_monthly = max(cumulative_sums_monthly)\n", " cumulative_sum_monthly.append(max_cumulative_sums_monthly)\n", " begin_day += month_length\n", - " \n", + "\n", " begin_day = 0\n", " # Calculate windowed cumulative sums\n", " for month_idx, month_length in enumerate(month_lengths):\n", " days_for_grid_window = grid_precipitation_for_facility[model][begin_day:begin_day + month_length]\n", - " \n", + "\n", " cumulative_sums_window = [\n", " sum(days_for_grid_window[day:day + window_size])\n", " for day in range(month_length - window_size + 1)\n", " ]\n", - " \n", + "\n", " max_cumulative_sums_window = max(cumulative_sums_window)\n", " cumulative_sum_window.append(max_cumulative_sums_window)\n", " begin_day += month_length\n", - " \n", + "\n", " # Assign the calculated data to the correct dataframe based on the model\n", " if model == min_model:\n", " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", @@ -497,12 +782,12 @@ " elif model == max_model:\n", " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - " \n", + "\n", " if ANC:\n", " weather_df_lowest_window.to_csv(Path(scenario_directory) / f\"lowest_model_daily_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{scenario}.csv\", index=False)\n", " weather_df_median_window.to_csv(Path(scenario_directory) / f\"median_model_daily_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{scenario}.csv\", index=False)\n", " weather_df_highest_window.to_csv(Path(scenario_directory) / f\"highest_model_daily_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{scenario}.csv\", index=False)\n", - " \n", + "\n", " weather_df_lowest_monthly.to_csv(Path(scenario_directory) / f\"lowest_model_monthly_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{scenario}.csv\", index=False)\n", " weather_df_median_monthly.to_csv(Path(scenario_directory) / f\"median_model_monthly_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{scenario}.csv\", index=False)\n", " weather_df_highest_monthly.to_csv(Path(scenario_directory) / f\"highest_model_monthly_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{scenario}.csv\", index=False)\n" @@ -514,6697 +799,446 @@ "output_type": "stream", "text": [ "ssp245\n", - "Models of interest ['HadGEM3-GC31-LL', 'GFDL-CM4', 'MIROC-ES2L']\n", - "date\n", - "Akasale Pvt Clinic\n", - "Area 30 Police Clinic\n", - "Balaka District Hospital\n", - "Bangwe Health Centre\n", - "Benga Health Centre\n", - "Bilira Health Centre\n", - "Bolero Rural Hospital\n", - "Bondo Health Centre\n", - "Bula Health Centre\n", - "Bulala Health Centre\n", - "Bvumbwe Health Centre\n", - "Bwanje Health Centre\n", - "Chadza Health Centre\n", - "Chakhaza Health Centre\n", - "Chamama Health Centre\n", - "Chambe Health Centre\n", - "Chang'ambika Health Centre\n", - "Chapananga Health Centre\n", - "Chifunga Health Centre\n", - "Chikande Health Centre\n", - "Chikole Dispensary\n", - "Chikuse Health Centre\n", - "Chikwawa District Hospital\n", - "Chikweo Health Centre\n", - "Chikwina Health Centre\n", - "Chileka Health Centre\n", - "Chileka Sda Health Centre\n", - "Chilonga Health Centre\n", - "Chilumba Rural Hospital\n", - "Chimatiro Health Centre\n", - "Chimbalanga Health Centre\n", - "Chimoto Health Centre\n", - "Chingale Health Centre\n", - "Chingazi Health Centre\n", - "Chintheche Rural Hospital\n", - "Chinyama Health Centre\n", - "Chioshya Health Centre\n", - "Chipho Health Centre\n", - "Chipoka Health Centre\n", - "Chiradzulu District Hospital\n", - "Chiringa Health Centre\n", - "Chiringa Maternity\n", - "Chisala Health Centre\n", - "Chisepo Health Centre\n", - "Chisi Health Centre\n", - "Chisimuka Health Centre\n", - "Chisitu Health Centre\n", - "Chitala Health Centre\n", - "Chitekesa Health Centre\n", - "Chitera Health Centre\n", - "Chitheka Health Centre\n", - "Chitimba Health Centre\n", - "Chitipa District Hospital\n", - "Chitowo Health Centre\n", - "Chiwamba Health Centre\n", - "Chiwe Health Centre\n", - "Choma Health Centre\n", - "City Clinic Zomba\n", - "Dedza District Hospital\n", - "Diamphwe Health Centre\n", - "Dickson Health Centre\n", - "Domasi Rural Hospital\n", - "Dr David Livingstone Memorial Clinic\n", - "Dwambazi Rural Hospital\n", - "Dzenje Health Centre\n", - "Dzenza Health Centre\n", - "Dziwe Health Centre\n", - "Emsizini Health Centre\n", - "Endindeni Health Centre\n", - "Engucwini Health Centre\n", - "Euthini Rural Hospital\n", - "Fulirwa Health Centre\n", - "Gaga Health Centre\n", - "Ganya Health Centre\n", - "Hora Health Centre\n", - "Ifumbo Health Centre\n", - "Jalasi Health Centre\n", - "Jalawe Health Centre\n", - "Jenda Health Centre\n", - "Kabudula Rural Hospital\n", - "Kabuwa Health Centre\n", - "Kabwafu Health Centre\n", - "Kachere Clinic\n", - "Kachere Health Centre\n", - "Kafele Health Centre\n", - "Kaigwazanga Health Centre\n", - "Kakoma Health Centre\n", - "Kalemba Health Centre\n", - "Kalembo Health Centre\n", - "Kalimanjira Health Centre\n", - "Kalinde Health Centre\n", - "Kalulu Health Centre\n", - "Kaluluma Rural Hospital\n", - "Kambenje Health Centre\n", - "Kamboni Health Centre\n", - "Kameme Health Centre\n", - "Kamsonga Health Centre\n", - "Kamteteka Health Centre\n", - "Kamwe Health Centre\n", - "Kande Health Centre\n", - "Kandeu Health Centre\n", - "Kangolwa Health Centre\n", - "Kanyama Health Centre\n", - "Kanyezi Health Centre\n", - "Kapanga Health Centre\n", - "Kapelula Health Centre\n", - "Kapenda Health Centre\n", - "Kapeni Health Centre\n", - "Kaphuka Health Centre\n", - "Kapire Health Centre\n", - "Kaporo Rural Hospital\n", - "Karonga District Hospital\n", - "Kaseye Mission Hospital\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Kasina Health Centre\n", - "Kasinje Health Centre\n", - "Kasoba Health Centre\n", - "Kasungu District Hospital\n", - "Katchale Health Centre\n", - "Katimbila Health Centre\n", - "Katowo Rural Hospital\n", - "Katsekera Health Centre\n", - "Katuli Health Centre\n", - "Kaundu Health Centre\n", - "Kavuzi Health Centre\n", - "Kawamba Health Centre\n", - "Kaweche Health Centre\n", - "Kawinga Dispensary\n", - "Kayembe Health Centre\n", - "Khanda Health Centre\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Khola Health Centre\n", - "Khondowe Health Centre\n", - "Khosolo Health Centre\n", - "Khuwi Health Centre\n", - "Khuyukuyu Health Centre\n", - "Kochilira Rural Hospital\n", - "Kukalanga Dispensary\n", - "Kunenekude Health Centre\n", - "Kwitanda Health Centre\n", - "Lambulira Health Centre\n", - "Lemwe Health Centre\n", - "Lilongwe City Assembly Chinsapo\n", - "Limbe Health Centre\n", - "Lirangwe Health Centre\n", - "Liuzi Health Centre\n", - "Livwezi Health Centre\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Liwonde Medical Clinic\n", - "Lizulu Health Centre\n", - "Lobi Health Centre\n", - "Lulwe Health Centre\n", - "Lundu Health Centre\n", - "Lungwena Health Centre\n", - "Lupembe Health Centre\n", - "Lura Health Centre\n", - "Luwalika Health Centre\n", - "Luwani Health Centre\n", - "Luwawa Health Centre\n", - "Luwerezi Health Centre\n", - "Luzi Health Centre\n", - "Lwazi Health Centre\n", - "M'mambo Heaith Centre\n", - "Mabili Health Centre\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Machinga District Hospital\n", - "Machinjiri Health Centre\n", - "Madziabango Health Centre\n", - "Maganga Health Centre\n", - "Magareta Health Centre\n", - "Makanjira Health Centre\n", - "Makapwa Health Centre\n", - "Makhanga Health Centre\n", - "Makiyoni Health Centre\n", - "Makwapala Health Centre\n", - "Makwasa Estate Clinic\n", - "Malambo Health Centre\n", - "Malembo Health Centre\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Malombe Dispensary\n", - "Malomo Health Centre\n", - "Malukula Health Centre\n", - "Maluwa Health Centre\n", - "Mangamba Health Centre\n", - "Mangochi District Hospital\n", - "Mangunda Health Centre\n", - "Manjawira Health Centre\n", - "Manolo Health Center\n", - "Maonde Health Centre\n", - "Masasa Health Centre\n", - "Masenjere Health Centre\n", - "Matanda Health Centre\n", - "Matapila Health Centre\n", - "Matiki Health Centre\n", - "Matiya Health Centre\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Matuli Health Centre\n", - "Matumba Health Centre\n", - "Maula Health Centre\n", - "Mauwa Health Centre\n", - "Mayaka Health Centre\n", - "Mayani Health Centre\n", - "Mbabvi Health Centre\n", - "Mbalachanda Health Centre\n", - "Mbang'ombe 1 Health Centre\n", - "Mbang'ombe 2 Health Centre\n", - "Mbayani Health Center\n", - "Mbenje Health Centre\n", - "Mbera Health Centre\n", - "Mbingwa Health Centre\n", - "Mbiza Health Centre\n", - "Mchima Clinic\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Mchinji District Hospital\n", - "Mchoka Health Centre\n", - "Mdunga Heallth Centre\n", - "Mfera Health Centre\n", - "Mhalaunda Health Centre\n", - "Mhuju Rural Hospital\n", - "Mikolongwe Health Centre\n", - "Mikundi Health Centre\n", - "Milepa Health Centre\n", - "Milonde Health Centre\n", - "Mimosa Dispensary\n", - "Misomali Health Centre (CHAM)\n", - "Misuku Health Centre\n", - "Mkanda Health Centre\n", - "Mkoma Health Centre\n", - "Mkumba Health Centre\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Mlanda Health Centre\n", - "Mlangeni Health Centre\n", - "Mlowe Health Centre\n", - "Mnyanja Health Centre\n", - "Monkey-Bay Community Hospital\n", - "Mpala Health Centre\n", - "Mpamba Health Centre\n", - "Mpasa Health Centre\n", - "Mpata Health Centre\n", - "Mpemba Health Centre\n", - "Mpherembe Health Centre\n", - "Mphompha Health Centre\n", - "Mpondasi Health Centre\n", - "Mponela Rural Hospital\n", - "Msenjere Health Centre\n", - "Msese Health Centre\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Msumbe Health Centre\n", - "Mtakataka Health Centre\n", - "Mtende Health Centre\n", - "Mtendere Health Centre\n", - "Mtengowanthenga Hospital\n", - "Mtonda Health Centre\n", - "Mtwalo Health Centre\n", - "Mulanje District Hospital\n", - "Mulomba Health Centre\n", - "Muloza Health Centre\n", - "Mvera Mission Health Centre\n", - "Mwandama Health Centre\n", - "Mwanga Health Centre\n", - "Mwangala Health Centre\n", - "Mwansambo Health Centre\n", - "Mwanza District Hospital\n", - "Mwazisi Health Centre\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Mzambazi Rural Hospital\n", - "Mzandu Health Centre\n", - "Mzenga Health Centre\n", - "Mzimba District Hospital\n", - "Mziza Health Centre\n", - "Mzuzu University Clinic\n", - "Naisi Health Centre\n", - "Nalunga Health Centre\n", - "Namadzi Health Centre\n", - "Namalaka Health Centre\n", - "Namandanje Health Centre\n", - "Namanja Health Centre\n", - "Namanolo Health Centre\n", - "Nambazo Health Centre\n", - "Nambuma Health Centre\n", - "Namphungo Health Centre\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Namulenga Health Centre\n", - "Namwera Health Centre\n", - "Nankhwali Health Centre\n", - "Nathenje Health Centre\n", - "Nayuchi Health Centre\n", - "Ndakwela Health Centre\n", - "Ndamera Health Centre\n", - "Ndaula Health Centre\n", - "Neno District Hospital\n", - "Ng'onga Health Centre\n", - "Ngabu Rural Hospital\n", - "Ngala Health Centre\n", - "Ngana Health Centre\n", - "Ngapani Health Centre\n", - "Ngodzi Health Centre\n", - "Ngoni Health Centre\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Ngwelero Health Centre\n", - "Nkasala Health Centre\n", - "Nkhata Bay District Hospital\n", - "Nkhotakota District Hospital\n", - "Nkhulambe Health Centre\n", - "Nkhunga Health Centre\n", - "Nkhwazi Health Centre\n", - "Nkomaula Health Centre\n", - "Nkula Health Centre\n", - "Nsanama Health Centre\n", - "Nsanje District Hospital\n", - "Nsiyaludzu Health Centre\n", - "Ntaja Health Centre\n", - "Ntcheu District Hospital\n", - "Ntchisi District Hospital\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Nthalire Health Centre\n", - "Nthungwa Health Centre\n", - "Nyambi Health Centre\n", - "Nyamithuthu Health Centre\n", - "Nyungwe Health Centre\n", - "Nzama Health Centre\n", - "Pensulo Health Centre\n", - "Phalombe Health Centre\n", - "Phirilongwe Health Centre\n", - "Phokera Health Centre\n", - "Raiply Clinic\n", - "Rumphi District Hospital\n", - "Salima District Hospital\n", - "Sankhulani Health Centre\n", - "Sharpe Valley Health Centre\n", - "Somba Health Centre\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Sorgin Health Centre\n", - "South Lunzu Health Centre\n", - "Tembwe Health Centre\n", - "Thekerani Rural Hospital\n", - "Thembe Health Centre\n", - "Thomas Health Centre\n", - "Thonje Health Centre\n", - "Thumbwe Health Centre\n", - "Thunduwike Health Centre\n", - "Thyolo District Hospital\n", - "Usisya Health Centre\n", - "Utale 1 Health Centre\n", - "Utale 2 Health Centre\n", - "Wiliro Health Centre\n", - "Wimbe Health Centre\n", - "Zomba Central Prison Clinic\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_42435/3240928208.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Zomba Mental Hospital\n", - "ssp585\n", - "Models of interest ['MIROC-ES2L', 'HadGEM3-GC31-LL', 'MIROC6']\n", + " Size: 64B\n", + "array('GFDL-CM4', dtype=' Size: 2kB\n", + "Dimensions: (model: 22)\n", + "Coordinates:\n", + " * model (model) \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 2kB\n",
+       "Dimensions:  (model: 22)\n",
+       "Coordinates:\n",
+       "  * model    (model) <U16 1kB 'NESM3' 'GFDL-ESM4' ... 'FGOALS-g3' 'BCC-CSM2-MR'\n",
+       "Data variables:\n",
+       "    pr       (model) float64 176B nan nan nan nan nan ... nan nan nan nan nan
" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" } ], - "execution_count": 24 + "execution_count": 27 }, { "metadata": {}, @@ -7212,7 +1246,7 @@ "outputs": [], "execution_count": null, "source": "", - "id": "2c870698f447d57e" + "id": "4d60f3606b689dd2" } ], "metadata": { From 39af21eb7722974f1ce6038ca885877a7ca8bac0 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 7 Jan 2025 15:34:03 +0000 Subject: [PATCH 155/291] Changed params --- src/scripts/climate_change/cohort_model.ipynb | 5220 ++++++++--------- 1 file changed, 2403 insertions(+), 2817 deletions(-) diff --git a/src/scripts/climate_change/cohort_model.ipynb b/src/scripts/climate_change/cohort_model.ipynb index 7c0c959519..f76d06bf20 100644 --- a/src/scripts/climate_change/cohort_model.ipynb +++ b/src/scripts/climate_change/cohort_model.ipynb @@ -6,8 +6,8 @@ "metadata": { "collapsed": true, "ExecuteTime": { - "end_time": "2025-01-03T11:32:03.586678Z", - "start_time": "2025-01-03T11:32:03.348700Z" + "end_time": "2025-01-07T10:26:36.875228Z", + "start_time": "2025-01-07T10:26:35.806549Z" } }, "source": [ @@ -33,7 +33,7 @@ ")\n", "\n", "min_year = 2020\n", - "max_year = 2060\n", + "max_year = 2070\n", "\n", "results_folder = Path(\"/Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-09-25T110820Z\")\n", "resourcefilepath = Path(\"/Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-09-25T110820Z\")\n", @@ -187,424 +187,7 @@ ] } ], - "execution_count": 35 - }, - { - "metadata": { - "ExecuteTime": { - "end_time": "2025-01-03T11:32:04.219692Z", - "start_time": "2025-01-03T11:32:04.213220Z" - } - }, - "cell_type": "code", - "source": "births_model", - "id": "479ae4c0646f4003", - "outputs": [ - { - "data": { - "text/plain": [ - " Model_lower Model_mean Model_upper\n", - "year \n", - "2010 608693.460981 628838.089250 642643.447996\n", - "2011 516519.609725 534156.155442 546314.903468\n", - "2012 545969.587755 555064.113184 568324.236592\n", - "2013 571166.730152 580508.428934 589330.336695\n", - "2014 580748.332483 595716.859948 614567.463016\n", - "2015 603957.183349 617046.466351 623505.687649\n", - "2016 608864.301386 632342.135019 644061.059873\n", - "2017 628325.568033 643813.886520 657408.420935\n", - "2018 637281.967177 654020.692038 670265.070193\n", - "2019 645326.005856 661639.447154 675942.787508\n", - "2020 639499.257549 659705.679157 676615.244424\n", - "2021 628659.979040 645355.085074 656761.408335\n", - "2022 633287.209604 643217.762551 651839.750688\n", - "2023 642123.656974 653482.726505 662660.854686\n", - "2024 651127.309847 661086.942012 669734.374465\n", - "2025 668095.033550 677196.828784 690704.125545\n", - "2026 662213.761709 682387.469197 702328.542941\n", - "2027 685800.642410 699326.113682 710503.438101\n", - "2028 689617.289772 708180.735563 724050.718787\n", - "2029 706646.806814 725279.315747 747732.106945\n", - "2030 702688.398263 722938.438698 738441.296794\n", - "2031 725253.871431 741563.677827 751385.183707\n", - "2032 723669.054050 738394.043065 753606.108981\n", - "2033 726889.577444 750621.854234 772009.619073\n", - "2034 743770.063493 766644.503352 790162.320910\n", - "2035 758571.385455 776429.660209 790914.745675\n", - "2036 774706.716543 796203.528449 812880.459972\n", - "2037 770388.452670 793426.463130 808416.800009\n", - "2038 793568.224318 808780.290234 823810.611038\n", - "2039 795861.847638 812386.113266 824766.590330\n", - "2040 804672.850692 823974.181639 833326.785128\n", - "2041 810943.057073 824599.384826 835060.633502\n", - "2042 831661.999898 843515.416135 853722.221653\n", - "2043 826809.405394 842788.435685 863529.187924\n", - "2044 833155.944723 850741.601808 865412.067289\n", - "2045 835911.200628 853067.939248 880936.734799\n", - "2046 852104.690152 858229.500443 866866.028189\n", - "2047 849200.403254 865586.542597 884124.544072\n", - "2048 834559.016991 867767.483947 888024.794186\n", - "2049 859083.702472 869512.237027 887770.351029\n", - "2050 855772.306522 873088.980841 889195.232711\n", - "2051 858571.181255 882859.598089 899096.706440\n", - "2052 873158.043984 889911.308454 901888.311368\n", - "2053 870668.135943 891074.477174 917125.821600\n", - "2054 865615.621815 889024.392305 904607.218251\n", - "2055 875626.142612 892804.690645 906173.861121\n", - "2056 876934.707422 890929.081084 907391.553374\n", - "2057 874684.702929 895479.978701 912160.545126\n", - "2058 875455.302206 903404.065606 931480.050585\n", - "2059 901899.216075 910732.028542 924439.244927\n", - "2060 17949.147311 19599.392932 22111.110387" - ], - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Model_lowerModel_meanModel_upper
year
2010608693.460981628838.089250642643.447996
2011516519.609725534156.155442546314.903468
2012545969.587755555064.113184568324.236592
2013571166.730152580508.428934589330.336695
2014580748.332483595716.859948614567.463016
2015603957.183349617046.466351623505.687649
2016608864.301386632342.135019644061.059873
2017628325.568033643813.886520657408.420935
2018637281.967177654020.692038670265.070193
2019645326.005856661639.447154675942.787508
2020639499.257549659705.679157676615.244424
2021628659.979040645355.085074656761.408335
2022633287.209604643217.762551651839.750688
2023642123.656974653482.726505662660.854686
2024651127.309847661086.942012669734.374465
2025668095.033550677196.828784690704.125545
2026662213.761709682387.469197702328.542941
2027685800.642410699326.113682710503.438101
2028689617.289772708180.735563724050.718787
2029706646.806814725279.315747747732.106945
2030702688.398263722938.438698738441.296794
2031725253.871431741563.677827751385.183707
2032723669.054050738394.043065753606.108981
2033726889.577444750621.854234772009.619073
2034743770.063493766644.503352790162.320910
2035758571.385455776429.660209790914.745675
2036774706.716543796203.528449812880.459972
2037770388.452670793426.463130808416.800009
2038793568.224318808780.290234823810.611038
2039795861.847638812386.113266824766.590330
2040804672.850692823974.181639833326.785128
2041810943.057073824599.384826835060.633502
2042831661.999898843515.416135853722.221653
2043826809.405394842788.435685863529.187924
2044833155.944723850741.601808865412.067289
2045835911.200628853067.939248880936.734799
2046852104.690152858229.500443866866.028189
2047849200.403254865586.542597884124.544072
2048834559.016991867767.483947888024.794186
2049859083.702472869512.237027887770.351029
2050855772.306522873088.980841889195.232711
2051858571.181255882859.598089899096.706440
2052873158.043984889911.308454901888.311368
2053870668.135943891074.477174917125.821600
2054865615.621815889024.392305904607.218251
2055875626.142612892804.690645906173.861121
2056876934.707422890929.081084907391.553374
2057874684.702929895479.978701912160.545126
2058875455.302206903404.065606931480.050585
2059901899.216075910732.028542924439.244927
206017949.14731119599.39293222111.110387
\n", - "
" - ] - }, - "execution_count": 36, - "metadata": {}, - "output_type": "execute_result" - } - ], - "execution_count": 36 + "execution_count": 1 }, { "metadata": {}, @@ -615,34 +198,37 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-03T11:37:12.464113Z", - "start_time": "2025-01-03T11:37:12.460627Z" + "end_time": "2025-01-07T15:20:29.960Z", + "start_time": "2025-01-07T15:20:29.953891Z" } }, "cell_type": "code", - "source": "scenario = 'ssp585'#'ssp245'", + "source": [ + "scenario = 'ssp245'\n", + "model_type = 'lowest'" + ], "id": "bbff583692196586", "outputs": [], - "execution_count": 49 + "execution_count": 55 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-03T11:37:12.993354Z", - "start_time": "2025-01-03T11:37:12.844542Z" + "end_time": "2025-01-07T15:20:30.644229Z", + "start_time": "2025-01-07T15:20:30.416235Z" } }, "cell_type": "code", - "source": "predictions_from_cmip = pd.read_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}.csv')", + "source": "predictions_from_cmip = pd.read_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv')", "id": "3be0a4515f3e890e", "outputs": [], - "execution_count": 50 + "execution_count": 56 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-03T11:37:13.426894Z", - "start_time": "2025-01-03T11:37:13.308115Z" + "end_time": "2025-01-07T15:20:31.088305Z", + "start_time": "2025-01-07T15:20:30.927992Z" } }, "cell_type": "code", @@ -656,52 +242,52 @@ "data": { "text/plain": [ " Year Month Facility_ID Altitude \\\n", - "0 2025 23814 599734 3182595.0 \n", - "1 2026 22590 566009 3008054.0 \n", - "2 2027 24474 614678 3269771.0 \n", - "3 2028 23968 600596 3207601.0 \n", - "4 2029 23330 583610 3116929.0 \n", - "5 2030 24073 605374 3226700.0 \n", - "6 2031 23580 593098 3161559.0 \n", - "7 2032 23000 576874 3067975.0 \n", - "8 2033 23581 593277 3157142.0 \n", - "9 2034 24459 614471 3272543.0 \n", - "10 2035 24070 601705 3227338.0 \n", - "11 2036 22412 563438 2989556.0 \n", - "12 2037 23224 583884 3111738.0 \n", - "13 2038 23088 581270 3091620.0 \n", - "14 2039 23796 598440 3178339.0 \n", - "15 2040 24867 625341 3333272.0 \n", - "16 2041 23418 588798 3126883.0 \n", - "17 2042 24483 614818 3264448.0 \n", - "18 2043 22584 568163 3020289.0 \n", - "19 2044 23377 588639 3133986.0 \n", - "20 2045 23817 599233 3190091.0 \n", - "21 2046 24583 616970 3286711.0 \n", - "22 2047 22492 563400 2990632.0 \n", - "23 2048 23857 599713 3190814.0 \n", - "24 2049 23922 602508 3200414.0 \n", - "25 2050 23672 596141 3153492.0 \n", - "26 2051 23898 601388 3209981.0 \n", - "27 2052 23496 591222 3151911.0 \n", - "28 2053 24894 627569 3335143.0 \n", - "29 2054 21946 552383 2937089.0 \n", - "30 2055 23076 579568 3072851.0 \n", - "31 2056 23967 601469 3194980.0 \n", - "32 2057 23389 588821 3139033.0 \n", - "33 2058 22093 555609 2950853.0 \n", - "34 2059 23733 596624 3169901.0 \n", - "35 2060 23173 582978 3100047.0 \n", - "36 2061 23689 595156 3162324.0 \n", - "37 2062 22794 574103 3036727.0 \n", - "38 2063 22722 573325 3024141.0 \n", - "39 2064 23581 590848 3149704.0 \n", - "40 2065 23523 591233 3157907.0 \n", - "41 2066 22993 578310 3065123.0 \n", - "42 2067 23261 583580 3099017.0 \n", - "43 2068 23318 586603 3118001.0 \n", - "44 2069 23422 588499 3133720.0 \n", - "45 2070 23609 593756 3146747.0 \n", + "0 2025 25584 643536 3435564.0 \n", + "1 2026 25584 643536 3435564.0 \n", + "2 2027 25584 643536 3435564.0 \n", + "3 2028 25584 643536 3435564.0 \n", + "4 2029 25584 643536 3435564.0 \n", + "5 2030 25584 643536 3435564.0 \n", + "6 2031 25584 643536 3435564.0 \n", + "7 2032 25584 643536 3435564.0 \n", + "8 2033 25584 643536 3435564.0 \n", + "9 2034 25584 643536 3435564.0 \n", + "10 2035 25584 643536 3435564.0 \n", + "11 2036 25584 643536 3435564.0 \n", + "12 2037 25584 643536 3435564.0 \n", + "13 2038 25584 643536 3435564.0 \n", + "14 2039 25584 643536 3435564.0 \n", + "15 2040 25584 643536 3435564.0 \n", + "16 2041 25584 643536 3435564.0 \n", + "17 2042 25584 643536 3435564.0 \n", + "18 2043 25584 643536 3435564.0 \n", + "19 2044 25584 643536 3435564.0 \n", + "20 2045 25584 643536 3435564.0 \n", + "21 2046 25584 643536 3435564.0 \n", + "22 2047 25584 643536 3435564.0 \n", + "23 2048 25584 643536 3435564.0 \n", + "24 2049 25584 643536 3435564.0 \n", + "25 2050 25584 643536 3435564.0 \n", + "26 2051 25584 643536 3435564.0 \n", + "27 2052 25584 643536 3435564.0 \n", + "28 2053 25584 643536 3435564.0 \n", + "29 2054 25584 643536 3435564.0 \n", + "30 2055 25584 643536 3435564.0 \n", + "31 2056 25584 643536 3435564.0 \n", + "32 2057 25584 643536 3435564.0 \n", + "33 2058 25584 643536 3435564.0 \n", + "34 2059 25584 643536 3435564.0 \n", + "35 2060 25584 643536 3435564.0 \n", + "36 2061 25584 643536 3435564.0 \n", + "37 2062 25584 643536 3435564.0 \n", + "38 2063 25584 643536 3435564.0 \n", + "39 2064 25584 643536 3435564.0 \n", + "40 2065 25584 643536 3435564.0 \n", + "41 2066 25584 643536 3435564.0 \n", + "42 2067 25584 643536 3435564.0 \n", + "43 2068 25584 643536 3435564.0 \n", + "44 2069 25584 643536 3435564.0 \n", + "45 2070 25584 643536 3435564.0 \n", "\n", " Zone \\\n", "0 Central WestSouth EastNorthernSouth EastNorthe... \n", @@ -848,196 +434,196 @@ "45 GovernmentGovernmentGovernmentGovernmentGovern... \n", "\n", " Facility_Type Precipitation \\\n", - "0 ClinicDistrict HospitalRural/Community Hospita... 356930.256793 \n", - "1 ClinicDistrict HospitalRural/Community Hospita... 442012.194055 \n", - "2 ClinicDistrict HospitalRural/Community Hospita... 401910.341187 \n", - "3 ClinicDistrict HospitalRural/Community Hospita... 458028.122792 \n", - "4 ClinicDistrict HospitalRural/Community Hospita... 406191.851826 \n", - "5 ClinicDistrict HospitalRural/Community Hospita... 409387.038984 \n", - "6 ClinicDistrict HospitalRural/Community Hospita... 400600.129109 \n", - "7 ClinicDistrict HospitalRural/Community Hospita... 447521.070185 \n", - "8 ClinicDistrict HospitalRural/Community Hospita... 456815.880827 \n", - "9 ClinicDistrict HospitalRural/Community Hospita... 443520.485079 \n", - "10 ClinicDistrict HospitalRural/Community Hospita... 411313.075371 \n", - "11 ClinicDistrict HospitalRural/Community Hospita... 401467.863756 \n", - "12 ClinicDistrict HospitalRural/Community Hospita... 419545.873961 \n", - "13 ClinicDistrict HospitalRural/Community Hospita... 463682.059169 \n", - "14 ClinicDistrict HospitalRural/Community Hospita... 439471.811655 \n", - "15 ClinicDistrict HospitalRural/Community Hospita... 451058.889825 \n", - "16 ClinicDistrict HospitalRural/Community Hospita... 364816.739985 \n", - "17 ClinicDistrict HospitalRural/Community Hospita... 474909.052258 \n", - "18 ClinicDistrict HospitalRural/Community Hospita... 437730.151447 \n", - "19 ClinicDistrict HospitalRural/Community Hospita... 467117.570232 \n", - "20 ClinicDistrict HospitalRural/Community Hospita... 398139.357152 \n", - "21 ClinicDistrict HospitalRural/Community Hospita... 443421.655978 \n", - "22 ClinicDistrict HospitalRural/Community Hospita... 494553.446600 \n", - "23 ClinicDistrict HospitalRural/Community Hospita... 472153.619753 \n", - "24 ClinicDistrict HospitalRural/Community Hospita... 465094.209967 \n", - "25 ClinicDistrict HospitalRural/Community Hospita... 452834.779144 \n", - "26 ClinicDistrict HospitalRural/Community Hospita... 460721.942570 \n", - "27 ClinicDistrict HospitalRural/Community Hospita... 309639.446977 \n", - "28 ClinicDistrict HospitalRural/Community Hospita... 332821.767357 \n", - "29 ClinicDistrict HospitalRural/Community Hospita... 418144.175624 \n", - "30 ClinicDistrict HospitalRural/Community Hospita... 300680.970171 \n", - "31 ClinicDistrict HospitalRural/Community Hospita... 461243.283456 \n", - "32 ClinicDistrict HospitalRural/Community Hospita... 379993.626328 \n", - "33 ClinicDistrict HospitalRural/Community Hospita... 381230.056855 \n", - "34 ClinicDistrict HospitalRural/Community Hospita... 501263.956015 \n", - "35 ClinicDistrict HospitalRural/Community Hospita... 459757.304011 \n", - "36 ClinicDistrict HospitalRural/Community Hospita... 403898.123577 \n", - "37 ClinicDistrict HospitalRural/Community Hospita... 468021.236699 \n", - "38 ClinicDistrict HospitalRural/Community Hospita... 414958.264565 \n", - "39 ClinicDistrict HospitalRural/Community Hospita... 441414.054493 \n", - "40 ClinicDistrict HospitalRural/Community Hospita... 433793.080907 \n", - "41 ClinicDistrict HospitalRural/Community Hospita... 358327.837808 \n", - "42 ClinicDistrict HospitalRural/Community Hospita... 385266.544939 \n", - "43 ClinicDistrict HospitalRural/Community Hospita... 444523.181015 \n", - "44 ClinicDistrict HospitalRural/Community Hospita... 445720.962431 \n", - "45 ClinicDistrict HospitalRural/Community Hospita... 400991.290205 \n", + "0 ClinicDistrict HospitalRural/Community Hospita... 370655.578345 \n", + "1 ClinicDistrict HospitalRural/Community Hospita... 305845.723518 \n", + "2 ClinicDistrict HospitalRural/Community Hospita... 380236.133055 \n", + "3 ClinicDistrict HospitalRural/Community Hospita... 396234.125976 \n", + "4 ClinicDistrict HospitalRural/Community Hospita... 317163.607434 \n", + "5 ClinicDistrict HospitalRural/Community Hospita... 385409.189618 \n", + "6 ClinicDistrict HospitalRural/Community Hospita... 406289.858606 \n", + "7 ClinicDistrict HospitalRural/Community Hospita... 333604.956760 \n", + "8 ClinicDistrict HospitalRural/Community Hospita... 322006.856259 \n", + "9 ClinicDistrict HospitalRural/Community Hospita... 391560.967791 \n", + "10 ClinicDistrict HospitalRural/Community Hospita... 367661.767185 \n", + "11 ClinicDistrict HospitalRural/Community Hospita... 378095.303002 \n", + "12 ClinicDistrict HospitalRural/Community Hospita... 374197.949271 \n", + "13 ClinicDistrict HospitalRural/Community Hospita... 374291.695816 \n", + "14 ClinicDistrict HospitalRural/Community Hospita... 398962.867137 \n", + "15 ClinicDistrict HospitalRural/Community Hospita... 329938.705708 \n", + "16 ClinicDistrict HospitalRural/Community Hospita... 349982.489824 \n", + "17 ClinicDistrict HospitalRural/Community Hospita... 265019.061881 \n", + "18 ClinicDistrict HospitalRural/Community Hospita... 317116.288589 \n", + "19 ClinicDistrict HospitalRural/Community Hospita... 358615.638348 \n", + "20 ClinicDistrict HospitalRural/Community Hospita... 441360.716573 \n", + "21 ClinicDistrict HospitalRural/Community Hospita... 485128.815221 \n", + "22 ClinicDistrict HospitalRural/Community Hospita... 339348.499913 \n", + "23 ClinicDistrict HospitalRural/Community Hospita... 353296.312971 \n", + "24 ClinicDistrict HospitalRural/Community Hospita... 333745.253478 \n", + "25 ClinicDistrict HospitalRural/Community Hospita... 513923.146927 \n", + "26 ClinicDistrict HospitalRural/Community Hospita... 271825.288644 \n", + "27 ClinicDistrict HospitalRural/Community Hospita... 365895.719222 \n", + "28 ClinicDistrict HospitalRural/Community Hospita... 325208.687060 \n", + "29 ClinicDistrict HospitalRural/Community Hospita... 382143.812346 \n", + "30 ClinicDistrict HospitalRural/Community Hospita... 287994.569053 \n", + "31 ClinicDistrict HospitalRural/Community Hospita... 332374.359974 \n", + "32 ClinicDistrict HospitalRural/Community Hospita... 392877.314013 \n", + "33 ClinicDistrict HospitalRural/Community Hospita... 302066.178485 \n", + "34 ClinicDistrict HospitalRural/Community Hospita... 327708.324530 \n", + "35 ClinicDistrict HospitalRural/Community Hospita... 309435.437644 \n", + "36 ClinicDistrict HospitalRural/Community Hospita... 320279.427886 \n", + "37 ClinicDistrict HospitalRural/Community Hospita... 330832.389669 \n", + "38 ClinicDistrict HospitalRural/Community Hospita... 435362.126119 \n", + "39 ClinicDistrict HospitalRural/Community Hospita... 304940.147499 \n", + "40 ClinicDistrict HospitalRural/Community Hospita... 353974.887443 \n", + "41 ClinicDistrict HospitalRural/Community Hospita... 295464.487169 \n", + "42 ClinicDistrict HospitalRural/Community Hospita... 297221.496710 \n", + "43 ClinicDistrict HospitalRural/Community Hospita... 409016.019784 \n", + "44 ClinicDistrict HospitalRural/Community Hospita... 420878.539429 \n", + "45 ClinicDistrict HospitalRural/Community Hospita... 405718.142702 \n", "\n", " Lag_1_Precipitation Lag_2_Precipitation Lag_3_Precipitation \\\n", - "0 294609.145696 251778.819911 240074.691709 \n", - "1 397157.668329 397273.347895 348266.651361 \n", - "2 414186.725872 420900.694753 423488.413324 \n", - "3 454173.805476 433342.964932 425159.752149 \n", - "4 439691.054081 445950.755762 418870.421666 \n", - "5 389364.247808 392455.710835 397461.356243 \n", - "6 392631.249314 374449.656015 373894.307761 \n", - "7 402914.631768 394545.775941 380305.249049 \n", - "8 498011.574391 475942.063738 466685.963435 \n", - "9 441306.486897 449381.026641 430634.351876 \n", - "10 461142.612330 444654.932360 434587.827755 \n", - "11 357763.087422 364775.944769 347716.667867 \n", - "12 416541.339977 409043.550166 391920.926233 \n", - "13 442526.600924 451303.450407 456286.448435 \n", - "14 486171.696867 502289.466180 498044.017229 \n", - "15 431633.402209 402153.409212 398040.518931 \n", - "16 335208.786306 354775.001534 338447.362232 \n", - "17 506841.062275 463684.071161 461858.642099 \n", - "18 415617.644419 410420.270555 407615.216190 \n", - "19 486817.869497 480637.195403 474544.770943 \n", - "20 362850.193582 402219.531548 399839.624296 \n", - "21 468076.690976 465542.221447 467423.630271 \n", - "22 444767.223650 409485.605985 387260.946000 \n", - "23 503414.718730 491261.349692 495127.838946 \n", - "24 455038.002255 477898.743986 469420.838584 \n", - "25 465973.024854 462746.331497 425762.806114 \n", - "26 407556.892301 401004.293570 421749.445065 \n", - "27 390992.045894 420441.094988 413192.196815 \n", - "28 320904.427223 316776.074425 316292.885898 \n", - "29 404366.782226 391164.519869 373727.874006 \n", - "30 346289.174108 340245.279011 329299.172958 \n", - "31 391853.983192 387762.882037 372651.645513 \n", - "32 421170.962261 417222.716525 405927.199113 \n", - "33 354587.101006 350957.265087 326505.718272 \n", - "34 490253.713022 477610.230551 460159.597378 \n", - "35 436835.494548 419958.086643 435515.915955 \n", - "36 446026.892969 459573.706453 436904.851847 \n", - "37 450100.730558 416050.220079 373748.278834 \n", - "38 415976.330050 443797.927964 453085.545667 \n", - "39 435767.269524 415051.021426 406769.043607 \n", - "40 435494.327000 421305.379992 408124.267918 \n", - "41 382545.188235 359818.742372 354980.088513 \n", - "42 357229.405339 389448.072900 382553.140857 \n", - "43 449728.133273 439791.891824 438856.705942 \n", - "44 418703.399054 431958.526817 430211.684701 \n", - "45 429393.430690 411181.980311 405133.787228 \n", + "0 298710.995438 260619.466056 255428.892934 \n", + "1 324216.805408 351108.236956 352944.118983 \n", + "2 351903.960266 349493.164255 344770.234996 \n", + "3 379492.789825 375543.857029 381029.229862 \n", + "4 375481.180687 385373.062799 381129.073629 \n", + "5 311938.841921 285932.285061 289579.937651 \n", + "6 433698.584038 455288.388297 455102.702313 \n", + "7 315844.250082 324314.368396 316195.532608 \n", + "8 371283.829234 345593.426372 354934.926046 \n", + "9 399207.341834 400410.349670 392246.728746 \n", + "10 341985.164411 327819.997189 330789.556355 \n", + "11 398497.779822 408894.912655 378604.565588 \n", + "12 348875.547726 360367.235995 389923.203199 \n", + "13 370981.253838 381170.945543 378471.104964 \n", + "14 394083.987840 401617.097706 408341.613660 \n", + "15 344469.424679 340683.245254 342518.356804 \n", + "16 331135.927791 335947.246630 335248.047067 \n", + "17 328321.508621 302510.901036 300226.263604 \n", + "18 252246.251731 271260.885375 274124.334082 \n", + "19 410050.158172 387974.439450 387736.897200 \n", + "20 369108.855991 362046.586240 342819.132014 \n", + "21 482869.984890 480685.090489 500151.794189 \n", + "22 419334.638122 449504.867423 447116.625283 \n", + "23 317922.916948 310749.912224 313141.518581 \n", + "24 325481.247456 336295.941280 330700.546457 \n", + "25 502910.647286 435891.016355 437939.836711 \n", + "26 325017.559932 392209.231985 393915.875687 \n", + "27 355003.796484 335224.704315 335946.670289 \n", + "28 360724.744731 376450.353321 368811.709372 \n", + "29 329764.214376 325974.066284 334512.344383 \n", + "30 331417.631119 333207.967531 331162.787180 \n", + "31 265016.427098 267520.943494 269888.025290 \n", + "32 457908.115607 448849.771066 446651.780946 \n", + "33 278375.606401 291501.477315 289945.485496 \n", + "34 318063.470421 302154.611762 306083.376401 \n", + "35 327543.125082 336866.204386 331980.842360 \n", + "36 330945.691553 322432.738606 318079.159985 \n", + "37 285321.675202 301954.830856 310662.088357 \n", + "38 433776.704399 419118.260070 404772.957169 \n", + "39 317030.377297 304945.762400 319651.502857 \n", + "40 329874.956467 337015.684029 328940.852077 \n", + "41 354202.699889 365879.087584 373323.111876 \n", + "42 272255.281494 280888.319603 281510.797522 \n", + "43 378752.521246 360679.750486 359521.705424 \n", + "44 445824.370857 462306.136722 461148.128688 \n", + "45 364719.332490 323443.731437 324834.166014 \n", "\n", " Lag_4_Precipitation Predicted_Weather_Model Predicted_No_Weather_Model \\\n", - "0 212611.355306 262073.177045 414580.859514 \n", - "1 329607.014297 391897.166673 394712.494598 \n", - "2 427242.313426 424216.303078 426507.644233 \n", - "3 409583.757336 418663.778757 419005.094793 \n", - "4 404708.312917 405721.982368 407774.686109 \n", - "5 389452.051202 422077.382352 421235.583604 \n", - "6 361847.942122 406625.933041 406869.091856 \n", - "7 367935.056473 390456.768764 393982.523859 \n", - "8 443793.819493 404036.109552 407105.988595 \n", - "9 428705.248932 419086.106241 421792.859293 \n", - "10 424916.410268 414353.849683 416718.943844 \n", - "11 321868.628640 379822.724678 383326.342849 \n", - "12 378814.601365 396472.620305 397095.249567 \n", - "13 441830.397786 392687.251512 394380.103735 \n", - "14 485302.039523 402985.471692 406826.384026 \n", - "15 371349.124368 425017.218302 426405.341430 \n", - "16 321940.022061 397017.066601 399458.496395 \n", - "17 454618.554156 416691.544445 416997.757878 \n", - "18 384771.629007 383660.669690 383755.734156 \n", - "19 455304.239249 394673.545565 394754.939189 \n", - "20 377344.967272 401135.309503 402985.317847 \n", - "21 464577.255028 412242.557813 413773.489936 \n", - "22 360098.331291 372146.903936 375589.196357 \n", - "23 485805.294721 401945.091876 402709.253238 \n", - "24 440243.139280 398685.865173 401567.430428 \n", - "25 427139.769513 399252.955628 398635.670647 \n", - "26 405452.318421 400477.291574 400608.907041 \n", - "27 409041.464387 390999.580252 392078.841473 \n", - "28 306048.398243 416471.045063 418092.099246 \n", - "29 343975.955350 360207.713252 364273.522362 \n", - "30 309663.520488 379799.778479 382254.450494 \n", - "31 355108.240357 389694.500461 393327.366843 \n", - "32 379013.465979 382707.973900 382588.827454 \n", - "33 294446.256154 361165.891802 361939.932800 \n", - "34 444568.857000 389684.514691 391135.437740 \n", - "35 425013.325154 383317.152377 381266.519178 \n", - "36 419966.747362 390113.556785 387064.014493 \n", - "37 351040.543393 372856.397814 373879.275648 \n", - "38 444035.139054 367768.692199 368187.001270 \n", - "39 396642.228590 378200.181200 380644.486568 \n", - "40 399546.170001 383210.897923 380769.053462 \n", - "41 342669.140660 373477.131153 373664.729920 \n", - "42 367803.054399 375480.781577 376740.673312 \n", - "43 426322.297655 374245.788665 375335.534050 \n", - "44 419976.194936 379224.450236 378005.108376 \n", - "45 386202.176410 383743.213561 381667.545696 \n", + "0 253508.982217 301084.510508 452103.379475 \n", + "1 353891.586301 448829.801850 451249.680342 \n", + "2 345157.532117 450130.102782 450397.593235 \n", + "3 379415.048009 446465.064103 449547.115109 \n", + "4 382864.345741 446875.456426 448698.242927 \n", + "5 289345.079079 445094.075488 447850.973656 \n", + "6 455034.373344 443152.899063 447005.304268 \n", + "7 314871.921748 445109.242713 446161.231744 \n", + "8 356543.998012 444390.632491 445318.753068 \n", + "9 391937.348081 443363.169753 444477.865230 \n", + "10 329650.101725 441484.287781 443638.565226 \n", + "11 379596.718666 443252.418520 442800.850059 \n", + "12 389558.939179 440302.572113 441964.716734 \n", + "13 377682.655534 441220.746519 441130.162266 \n", + "14 409745.578729 442599.508715 440297.183673 \n", + "15 341977.330400 437729.663871 439465.777979 \n", + "16 335789.435760 435203.049238 438635.942214 \n", + "17 296296.047432 436957.723991 437807.673415 \n", + "18 278184.608227 434305.862192 436980.968621 \n", + "19 387661.416146 434323.547929 436155.824879 \n", + "20 340516.424995 434015.417381 435332.239243 \n", + "21 502277.800794 434856.288139 434510.208770 \n", + "22 445805.292269 435279.971776 433689.730522 \n", + "23 313923.715557 430636.491081 432870.801570 \n", + "24 330244.876504 430911.874972 432053.418987 \n", + "25 438231.552425 428660.978812 431237.579854 \n", + "26 393957.931607 430121.833314 430423.281257 \n", + "27 336884.175544 427569.904956 429610.520285 \n", + "28 365595.615071 427736.660883 428799.294036 \n", + "29 337541.046047 425208.288593 427989.599612 \n", + "30 331449.273326 426741.194309 427181.434120 \n", + "31 269433.014822 425551.827998 426374.794674 \n", + "32 445524.032754 424893.403624 425569.678390 \n", + "33 291038.100935 423223.667713 424766.082395 \n", + "34 305678.254498 422131.112511 423964.003816 \n", + "35 330169.889911 421573.506857 423163.439788 \n", + "36 317973.894415 422575.707068 422364.387452 \n", + "37 312810.479228 420956.703710 421566.843952 \n", + "38 405190.542219 418934.469956 420770.806441 \n", + "39 319575.723877 419086.943369 419976.272074 \n", + "40 329238.343810 418729.313756 419183.238012 \n", + "41 372541.004296 418355.425750 418391.701423 \n", + "42 281840.507716 417412.937075 417601.659480 \n", + "43 359548.833442 414765.010421 416813.109359 \n", + "44 461552.424105 415927.049193 416026.048243 \n", + "45 323233.055405 412876.186407 415240.473322 \n", "\n", " Difference_in_Expectation \n", - "0 -1806.379897 \n", - "1 -2815.327925 \n", - "2 -2291.341155 \n", - "3 -341.316036 \n", - "4 -2052.703741 \n", - "5 841.798749 \n", - "6 -243.158815 \n", - "7 -3525.755094 \n", - "8 -3069.879043 \n", - "9 -2706.753053 \n", - "10 -2365.094162 \n", - "11 -3503.618171 \n", - "12 -622.629263 \n", - "13 -1692.852223 \n", - "14 -3840.912333 \n", - "15 -1388.123129 \n", - "16 -2441.429794 \n", - "17 -306.213433 \n", - "18 -95.064467 \n", - "19 -81.393624 \n", - "20 -1850.008344 \n", - "21 -1530.932123 \n", - "22 -3442.292421 \n", - "23 -764.161361 \n", - "24 -2881.565255 \n", - "25 617.284980 \n", - "26 -131.615467 \n", - "27 -1079.261220 \n", - "28 -1621.054183 \n", - "29 -4065.809111 \n", - "30 -2454.672016 \n", - "31 -3632.866382 \n", - "32 119.146445 \n", - "33 -774.040998 \n", - "34 -1450.923049 \n", - "35 2050.633200 \n", - "36 3049.542292 \n", - "37 -1022.877835 \n", - "38 -418.309071 \n", - "39 -2444.305368 \n", - "40 2441.844461 \n", - "41 -187.598767 \n", - "42 -1259.891735 \n", - "43 -1089.745385 \n", - "44 1219.341861 \n", - "45 2075.667865 " + "0 -317.566395 \n", + "1 -2419.878492 \n", + "2 -267.490453 \n", + "3 -3082.051006 \n", + "4 -1822.786501 \n", + "5 -2756.898168 \n", + "6 -3852.405205 \n", + "7 -1051.989032 \n", + "8 -928.120577 \n", + "9 -1114.695477 \n", + "10 -2154.277446 \n", + "11 451.568461 \n", + "12 -1662.144621 \n", + "13 90.584253 \n", + "14 2302.325042 \n", + "15 -1736.114108 \n", + "16 -3432.892977 \n", + "17 -849.949424 \n", + "18 -2675.106429 \n", + "19 -1832.276951 \n", + "20 -1316.821862 \n", + "21 346.079370 \n", + "22 1590.241254 \n", + "23 -2234.310489 \n", + "24 -1141.544015 \n", + "25 -2576.601042 \n", + "26 -301.447942 \n", + "27 -2040.615329 \n", + "28 -1062.633153 \n", + "29 -2781.311019 \n", + "30 -440.239811 \n", + "31 -822.966676 \n", + "32 -676.274766 \n", + "33 -1542.414682 \n", + "34 -1832.891305 \n", + "35 -1589.932931 \n", + "36 211.319617 \n", + "37 -610.140243 \n", + "38 -1836.336485 \n", + "39 -889.328705 \n", + "40 -453.924256 \n", + "41 -36.275673 \n", + "42 -188.722404 \n", + "43 -2048.098937 \n", + "44 -98.999050 \n", + "45 -2364.286915 " ], "text/html": [ "
\n", @@ -1080,894 +666,894 @@ " \n", " 0\n", " 2025\n", - " 23814\n", - " 599734\n", - " 3182595.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 356930.256793\n", - " 294609.145696\n", - " 251778.819911\n", - " 240074.691709\n", - " 212611.355306\n", - " 262073.177045\n", - " 414580.859514\n", - " -1806.379897\n", + " 370655.578345\n", + " 298710.995438\n", + " 260619.466056\n", + " 255428.892934\n", + " 253508.982217\n", + " 301084.510508\n", + " 452103.379475\n", + " -317.566395\n", " \n", " \n", " 1\n", " 2026\n", - " 22590\n", - " 566009\n", - " 3008054.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 442012.194055\n", - " 397157.668329\n", - " 397273.347895\n", - " 348266.651361\n", - " 329607.014297\n", - " 391897.166673\n", - " 394712.494598\n", - " -2815.327925\n", + " 305845.723518\n", + " 324216.805408\n", + " 351108.236956\n", + " 352944.118983\n", + " 353891.586301\n", + " 448829.801850\n", + " 451249.680342\n", + " -2419.878492\n", " \n", " \n", " 2\n", " 2027\n", - " 24474\n", - " 614678\n", - " 3269771.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 401910.341187\n", - " 414186.725872\n", - " 420900.694753\n", - " 423488.413324\n", - " 427242.313426\n", - " 424216.303078\n", - " 426507.644233\n", - " -2291.341155\n", + " 380236.133055\n", + " 351903.960266\n", + " 349493.164255\n", + " 344770.234996\n", + " 345157.532117\n", + " 450130.102782\n", + " 450397.593235\n", + " -267.490453\n", " \n", " \n", " 3\n", " 2028\n", - " 23968\n", - " 600596\n", - " 3207601.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 458028.122792\n", - " 454173.805476\n", - " 433342.964932\n", - " 425159.752149\n", - " 409583.757336\n", - " 418663.778757\n", - " 419005.094793\n", - " -341.316036\n", + " 396234.125976\n", + " 379492.789825\n", + " 375543.857029\n", + " 381029.229862\n", + " 379415.048009\n", + " 446465.064103\n", + " 449547.115109\n", + " -3082.051006\n", " \n", " \n", " 4\n", " 2029\n", - " 23330\n", - " 583610\n", - " 3116929.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 406191.851826\n", - " 439691.054081\n", - " 445950.755762\n", - " 418870.421666\n", - " 404708.312917\n", - " 405721.982368\n", - " 407774.686109\n", - " -2052.703741\n", + " 317163.607434\n", + " 375481.180687\n", + " 385373.062799\n", + " 381129.073629\n", + " 382864.345741\n", + " 446875.456426\n", + " 448698.242927\n", + " -1822.786501\n", " \n", " \n", " 5\n", " 2030\n", - " 24073\n", - " 605374\n", - " 3226700.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 409387.038984\n", - " 389364.247808\n", - " 392455.710835\n", - " 397461.356243\n", - " 389452.051202\n", - " 422077.382352\n", - " 421235.583604\n", - " 841.798749\n", + " 385409.189618\n", + " 311938.841921\n", + " 285932.285061\n", + " 289579.937651\n", + " 289345.079079\n", + " 445094.075488\n", + " 447850.973656\n", + " -2756.898168\n", " \n", " \n", " 6\n", " 2031\n", - " 23580\n", - " 593098\n", - " 3161559.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 400600.129109\n", - " 392631.249314\n", - " 374449.656015\n", - " 373894.307761\n", - " 361847.942122\n", - " 406625.933041\n", - " 406869.091856\n", - " -243.158815\n", + " 406289.858606\n", + " 433698.584038\n", + " 455288.388297\n", + " 455102.702313\n", + " 455034.373344\n", + " 443152.899063\n", + " 447005.304268\n", + " -3852.405205\n", " \n", " \n", " 7\n", " 2032\n", - " 23000\n", - " 576874\n", - " 3067975.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 447521.070185\n", - " 402914.631768\n", - " 394545.775941\n", - " 380305.249049\n", - " 367935.056473\n", - " 390456.768764\n", - " 393982.523859\n", - " -3525.755094\n", + " 333604.956760\n", + " 315844.250082\n", + " 324314.368396\n", + " 316195.532608\n", + " 314871.921748\n", + " 445109.242713\n", + " 446161.231744\n", + " -1051.989032\n", " \n", " \n", " 8\n", " 2033\n", - " 23581\n", - " 593277\n", - " 3157142.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 456815.880827\n", - " 498011.574391\n", - " 475942.063738\n", - " 466685.963435\n", - " 443793.819493\n", - " 404036.109552\n", - " 407105.988595\n", - " -3069.879043\n", + " 322006.856259\n", + " 371283.829234\n", + " 345593.426372\n", + " 354934.926046\n", + " 356543.998012\n", + " 444390.632491\n", + " 445318.753068\n", + " -928.120577\n", " \n", " \n", " 9\n", " 2034\n", - " 24459\n", - " 614471\n", - " 3272543.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 443520.485079\n", - " 441306.486897\n", - " 449381.026641\n", - " 430634.351876\n", - " 428705.248932\n", - " 419086.106241\n", - " 421792.859293\n", - " -2706.753053\n", + " 391560.967791\n", + " 399207.341834\n", + " 400410.349670\n", + " 392246.728746\n", + " 391937.348081\n", + " 443363.169753\n", + " 444477.865230\n", + " -1114.695477\n", " \n", " \n", " 10\n", " 2035\n", - " 24070\n", - " 601705\n", - " 3227338.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 411313.075371\n", - " 461142.612330\n", - " 444654.932360\n", - " 434587.827755\n", - " 424916.410268\n", - " 414353.849683\n", - " 416718.943844\n", - " -2365.094162\n", + " 367661.767185\n", + " 341985.164411\n", + " 327819.997189\n", + " 330789.556355\n", + " 329650.101725\n", + " 441484.287781\n", + " 443638.565226\n", + " -2154.277446\n", " \n", " \n", " 11\n", " 2036\n", - " 22412\n", - " 563438\n", - " 2989556.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 401467.863756\n", - " 357763.087422\n", - " 364775.944769\n", - " 347716.667867\n", - " 321868.628640\n", - " 379822.724678\n", - " 383326.342849\n", - " -3503.618171\n", + " 378095.303002\n", + " 398497.779822\n", + " 408894.912655\n", + " 378604.565588\n", + " 379596.718666\n", + " 443252.418520\n", + " 442800.850059\n", + " 451.568461\n", " \n", " \n", " 12\n", " 2037\n", - " 23224\n", - " 583884\n", - " 3111738.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 419545.873961\n", - " 416541.339977\n", - " 409043.550166\n", - " 391920.926233\n", - " 378814.601365\n", - " 396472.620305\n", - " 397095.249567\n", - " -622.629263\n", + " 374197.949271\n", + " 348875.547726\n", + " 360367.235995\n", + " 389923.203199\n", + " 389558.939179\n", + " 440302.572113\n", + " 441964.716734\n", + " -1662.144621\n", " \n", " \n", " 13\n", " 2038\n", - " 23088\n", - " 581270\n", - " 3091620.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 463682.059169\n", - " 442526.600924\n", - " 451303.450407\n", - " 456286.448435\n", - " 441830.397786\n", - " 392687.251512\n", - " 394380.103735\n", - " -1692.852223\n", + " 374291.695816\n", + " 370981.253838\n", + " 381170.945543\n", + " 378471.104964\n", + " 377682.655534\n", + " 441220.746519\n", + " 441130.162266\n", + " 90.584253\n", " \n", " \n", " 14\n", " 2039\n", - " 23796\n", - " 598440\n", - " 3178339.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 439471.811655\n", - " 486171.696867\n", - " 502289.466180\n", - " 498044.017229\n", - " 485302.039523\n", - " 402985.471692\n", - " 406826.384026\n", - " -3840.912333\n", + " 398962.867137\n", + " 394083.987840\n", + " 401617.097706\n", + " 408341.613660\n", + " 409745.578729\n", + " 442599.508715\n", + " 440297.183673\n", + " 2302.325042\n", " \n", " \n", " 15\n", " 2040\n", - " 24867\n", - " 625341\n", - " 3333272.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 451058.889825\n", - " 431633.402209\n", - " 402153.409212\n", - " 398040.518931\n", - " 371349.124368\n", - " 425017.218302\n", - " 426405.341430\n", - " -1388.123129\n", + " 329938.705708\n", + " 344469.424679\n", + " 340683.245254\n", + " 342518.356804\n", + " 341977.330400\n", + " 437729.663871\n", + " 439465.777979\n", + " -1736.114108\n", " \n", " \n", " 16\n", " 2041\n", - " 23418\n", - " 588798\n", - " 3126883.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 364816.739985\n", - " 335208.786306\n", - " 354775.001534\n", - " 338447.362232\n", - " 321940.022061\n", - " 397017.066601\n", - " 399458.496395\n", - " -2441.429794\n", + " 349982.489824\n", + " 331135.927791\n", + " 335947.246630\n", + " 335248.047067\n", + " 335789.435760\n", + " 435203.049238\n", + " 438635.942214\n", + " -3432.892977\n", " \n", " \n", " 17\n", " 2042\n", - " 24483\n", - " 614818\n", - " 3264448.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 474909.052258\n", - " 506841.062275\n", - " 463684.071161\n", - " 461858.642099\n", - " 454618.554156\n", - " 416691.544445\n", - " 416997.757878\n", - " -306.213433\n", + " 265019.061881\n", + " 328321.508621\n", + " 302510.901036\n", + " 300226.263604\n", + " 296296.047432\n", + " 436957.723991\n", + " 437807.673415\n", + " -849.949424\n", " \n", " \n", " 18\n", " 2043\n", - " 22584\n", - " 568163\n", - " 3020289.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 437730.151447\n", - " 415617.644419\n", - " 410420.270555\n", - " 407615.216190\n", - " 384771.629007\n", - " 383660.669690\n", - " 383755.734156\n", - " -95.064467\n", + " 317116.288589\n", + " 252246.251731\n", + " 271260.885375\n", + " 274124.334082\n", + " 278184.608227\n", + " 434305.862192\n", + " 436980.968621\n", + " -2675.106429\n", " \n", " \n", " 19\n", " 2044\n", - " 23377\n", - " 588639\n", - " 3133986.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 467117.570232\n", - " 486817.869497\n", - " 480637.195403\n", - " 474544.770943\n", - " 455304.239249\n", - " 394673.545565\n", - " 394754.939189\n", - " -81.393624\n", + " 358615.638348\n", + " 410050.158172\n", + " 387974.439450\n", + " 387736.897200\n", + " 387661.416146\n", + " 434323.547929\n", + " 436155.824879\n", + " -1832.276951\n", " \n", " \n", " 20\n", " 2045\n", - " 23817\n", - " 599233\n", - " 3190091.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 398139.357152\n", - " 362850.193582\n", - " 402219.531548\n", - " 399839.624296\n", - " 377344.967272\n", - " 401135.309503\n", - " 402985.317847\n", - " -1850.008344\n", + " 441360.716573\n", + " 369108.855991\n", + " 362046.586240\n", + " 342819.132014\n", + " 340516.424995\n", + " 434015.417381\n", + " 435332.239243\n", + " -1316.821862\n", " \n", " \n", " 21\n", " 2046\n", - " 24583\n", - " 616970\n", - " 3286711.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 443421.655978\n", - " 468076.690976\n", - " 465542.221447\n", - " 467423.630271\n", - " 464577.255028\n", - " 412242.557813\n", - " 413773.489936\n", - " -1530.932123\n", + " 485128.815221\n", + " 482869.984890\n", + " 480685.090489\n", + " 500151.794189\n", + " 502277.800794\n", + " 434856.288139\n", + " 434510.208770\n", + " 346.079370\n", " \n", " \n", " 22\n", " 2047\n", - " 22492\n", - " 563400\n", - " 2990632.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 494553.446600\n", - " 444767.223650\n", - " 409485.605985\n", - " 387260.946000\n", - " 360098.331291\n", - " 372146.903936\n", - " 375589.196357\n", - " -3442.292421\n", + " 339348.499913\n", + " 419334.638122\n", + " 449504.867423\n", + " 447116.625283\n", + " 445805.292269\n", + " 435279.971776\n", + " 433689.730522\n", + " 1590.241254\n", " \n", " \n", " 23\n", " 2048\n", - " 23857\n", - " 599713\n", - " 3190814.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 472153.619753\n", - " 503414.718730\n", - " 491261.349692\n", - " 495127.838946\n", - " 485805.294721\n", - " 401945.091876\n", - " 402709.253238\n", - " -764.161361\n", + " 353296.312971\n", + " 317922.916948\n", + " 310749.912224\n", + " 313141.518581\n", + " 313923.715557\n", + " 430636.491081\n", + " 432870.801570\n", + " -2234.310489\n", " \n", " \n", " 24\n", " 2049\n", - " 23922\n", - " 602508\n", - " 3200414.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 465094.209967\n", - " 455038.002255\n", - " 477898.743986\n", - " 469420.838584\n", - " 440243.139280\n", - " 398685.865173\n", - " 401567.430428\n", - " -2881.565255\n", + " 333745.253478\n", + " 325481.247456\n", + " 336295.941280\n", + " 330700.546457\n", + " 330244.876504\n", + " 430911.874972\n", + " 432053.418987\n", + " -1141.544015\n", " \n", " \n", " 25\n", " 2050\n", - " 23672\n", - " 596141\n", - " 3153492.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 452834.779144\n", - " 465973.024854\n", - " 462746.331497\n", - " 425762.806114\n", - " 427139.769513\n", - " 399252.955628\n", - " 398635.670647\n", - " 617.284980\n", + " 513923.146927\n", + " 502910.647286\n", + " 435891.016355\n", + " 437939.836711\n", + " 438231.552425\n", + " 428660.978812\n", + " 431237.579854\n", + " -2576.601042\n", " \n", " \n", " 26\n", " 2051\n", - " 23898\n", - " 601388\n", - " 3209981.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 460721.942570\n", - " 407556.892301\n", - " 401004.293570\n", - " 421749.445065\n", - " 405452.318421\n", - " 400477.291574\n", - " 400608.907041\n", - " -131.615467\n", + " 271825.288644\n", + " 325017.559932\n", + " 392209.231985\n", + " 393915.875687\n", + " 393957.931607\n", + " 430121.833314\n", + " 430423.281257\n", + " -301.447942\n", " \n", " \n", " 27\n", " 2052\n", - " 23496\n", - " 591222\n", - " 3151911.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 309639.446977\n", - " 390992.045894\n", - " 420441.094988\n", - " 413192.196815\n", - " 409041.464387\n", - " 390999.580252\n", - " 392078.841473\n", - " -1079.261220\n", + " 365895.719222\n", + " 355003.796484\n", + " 335224.704315\n", + " 335946.670289\n", + " 336884.175544\n", + " 427569.904956\n", + " 429610.520285\n", + " -2040.615329\n", " \n", " \n", " 28\n", " 2053\n", - " 24894\n", - " 627569\n", - " 3335143.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 332821.767357\n", - " 320904.427223\n", - " 316776.074425\n", - " 316292.885898\n", - " 306048.398243\n", - " 416471.045063\n", - " 418092.099246\n", - " -1621.054183\n", + " 325208.687060\n", + " 360724.744731\n", + " 376450.353321\n", + " 368811.709372\n", + " 365595.615071\n", + " 427736.660883\n", + " 428799.294036\n", + " -1062.633153\n", " \n", " \n", " 29\n", " 2054\n", - " 21946\n", - " 552383\n", - " 2937089.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 418144.175624\n", - " 404366.782226\n", - " 391164.519869\n", - " 373727.874006\n", - " 343975.955350\n", - " 360207.713252\n", - " 364273.522362\n", - " -4065.809111\n", + " 382143.812346\n", + " 329764.214376\n", + " 325974.066284\n", + " 334512.344383\n", + " 337541.046047\n", + " 425208.288593\n", + " 427989.599612\n", + " -2781.311019\n", " \n", " \n", " 30\n", " 2055\n", - " 23076\n", - " 579568\n", - " 3072851.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 300680.970171\n", - " 346289.174108\n", - " 340245.279011\n", - " 329299.172958\n", - " 309663.520488\n", - " 379799.778479\n", - " 382254.450494\n", - " -2454.672016\n", + " 287994.569053\n", + " 331417.631119\n", + " 333207.967531\n", + " 331162.787180\n", + " 331449.273326\n", + " 426741.194309\n", + " 427181.434120\n", + " -440.239811\n", " \n", " \n", " 31\n", " 2056\n", - " 23967\n", - " 601469\n", - " 3194980.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 461243.283456\n", - " 391853.983192\n", - " 387762.882037\n", - " 372651.645513\n", - " 355108.240357\n", - " 389694.500461\n", - " 393327.366843\n", - " -3632.866382\n", + " 332374.359974\n", + " 265016.427098\n", + " 267520.943494\n", + " 269888.025290\n", + " 269433.014822\n", + " 425551.827998\n", + " 426374.794674\n", + " -822.966676\n", " \n", " \n", " 32\n", " 2057\n", - " 23389\n", - " 588821\n", - " 3139033.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 379993.626328\n", - " 421170.962261\n", - " 417222.716525\n", - " 405927.199113\n", - " 379013.465979\n", - " 382707.973900\n", - " 382588.827454\n", - " 119.146445\n", + " 392877.314013\n", + " 457908.115607\n", + " 448849.771066\n", + " 446651.780946\n", + " 445524.032754\n", + " 424893.403624\n", + " 425569.678390\n", + " -676.274766\n", " \n", " \n", " 33\n", " 2058\n", - " 22093\n", - " 555609\n", - " 2950853.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 381230.056855\n", - " 354587.101006\n", - " 350957.265087\n", - " 326505.718272\n", - " 294446.256154\n", - " 361165.891802\n", - " 361939.932800\n", - " -774.040998\n", + " 302066.178485\n", + " 278375.606401\n", + " 291501.477315\n", + " 289945.485496\n", + " 291038.100935\n", + " 423223.667713\n", + " 424766.082395\n", + " -1542.414682\n", " \n", " \n", " 34\n", " 2059\n", - " 23733\n", - " 596624\n", - " 3169901.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 501263.956015\n", - " 490253.713022\n", - " 477610.230551\n", - " 460159.597378\n", - " 444568.857000\n", - " 389684.514691\n", - " 391135.437740\n", - " -1450.923049\n", + " 327708.324530\n", + " 318063.470421\n", + " 302154.611762\n", + " 306083.376401\n", + " 305678.254498\n", + " 422131.112511\n", + " 423964.003816\n", + " -1832.891305\n", " \n", " \n", " 35\n", " 2060\n", - " 23173\n", - " 582978\n", - " 3100047.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 459757.304011\n", - " 436835.494548\n", - " 419958.086643\n", - " 435515.915955\n", - " 425013.325154\n", - " 383317.152377\n", - " 381266.519178\n", - " 2050.633200\n", + " 309435.437644\n", + " 327543.125082\n", + " 336866.204386\n", + " 331980.842360\n", + " 330169.889911\n", + " 421573.506857\n", + " 423163.439788\n", + " -1589.932931\n", " \n", " \n", " 36\n", " 2061\n", - " 23689\n", - " 595156\n", - " 3162324.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 403898.123577\n", - " 446026.892969\n", - " 459573.706453\n", - " 436904.851847\n", - " 419966.747362\n", - " 390113.556785\n", - " 387064.014493\n", - " 3049.542292\n", + " 320279.427886\n", + " 330945.691553\n", + " 322432.738606\n", + " 318079.159985\n", + " 317973.894415\n", + " 422575.707068\n", + " 422364.387452\n", + " 211.319617\n", " \n", " \n", " 37\n", " 2062\n", - " 22794\n", - " 574103\n", - " 3036727.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 468021.236699\n", - " 450100.730558\n", - " 416050.220079\n", - " 373748.278834\n", - " 351040.543393\n", - " 372856.397814\n", - " 373879.275648\n", - " -1022.877835\n", + " 330832.389669\n", + " 285321.675202\n", + " 301954.830856\n", + " 310662.088357\n", + " 312810.479228\n", + " 420956.703710\n", + " 421566.843952\n", + " -610.140243\n", " \n", " \n", " 38\n", " 2063\n", - " 22722\n", - " 573325\n", - " 3024141.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 414958.264565\n", - " 415976.330050\n", - " 443797.927964\n", - " 453085.545667\n", - " 444035.139054\n", - " 367768.692199\n", - " 368187.001270\n", - " -418.309071\n", + " 435362.126119\n", + " 433776.704399\n", + " 419118.260070\n", + " 404772.957169\n", + " 405190.542219\n", + " 418934.469956\n", + " 420770.806441\n", + " -1836.336485\n", " \n", " \n", " 39\n", " 2064\n", - " 23581\n", - " 590848\n", - " 3149704.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 441414.054493\n", - " 435767.269524\n", - " 415051.021426\n", - " 406769.043607\n", - " 396642.228590\n", - " 378200.181200\n", - " 380644.486568\n", - " -2444.305368\n", + " 304940.147499\n", + " 317030.377297\n", + " 304945.762400\n", + " 319651.502857\n", + " 319575.723877\n", + " 419086.943369\n", + " 419976.272074\n", + " -889.328705\n", " \n", " \n", " 40\n", " 2065\n", - " 23523\n", - " 591233\n", - " 3157907.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 433793.080907\n", - " 435494.327000\n", - " 421305.379992\n", - " 408124.267918\n", - " 399546.170001\n", - " 383210.897923\n", - " 380769.053462\n", - " 2441.844461\n", + " 353974.887443\n", + " 329874.956467\n", + " 337015.684029\n", + " 328940.852077\n", + " 329238.343810\n", + " 418729.313756\n", + " 419183.238012\n", + " -453.924256\n", " \n", " \n", " 41\n", " 2066\n", - " 22993\n", - " 578310\n", - " 3065123.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 358327.837808\n", - " 382545.188235\n", - " 359818.742372\n", - " 354980.088513\n", - " 342669.140660\n", - " 373477.131153\n", - " 373664.729920\n", - " -187.598767\n", + " 295464.487169\n", + " 354202.699889\n", + " 365879.087584\n", + " 373323.111876\n", + " 372541.004296\n", + " 418355.425750\n", + " 418391.701423\n", + " -36.275673\n", " \n", " \n", " 42\n", " 2067\n", - " 23261\n", - " 583580\n", - " 3099017.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 385266.544939\n", - " 357229.405339\n", - " 389448.072900\n", - " 382553.140857\n", - " 367803.054399\n", - " 375480.781577\n", - " 376740.673312\n", - " -1259.891735\n", + " 297221.496710\n", + " 272255.281494\n", + " 280888.319603\n", + " 281510.797522\n", + " 281840.507716\n", + " 417412.937075\n", + " 417601.659480\n", + " -188.722404\n", " \n", " \n", " 43\n", " 2068\n", - " 23318\n", - " 586603\n", - " 3118001.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 444523.181015\n", - " 449728.133273\n", - " 439791.891824\n", - " 438856.705942\n", - " 426322.297655\n", - " 374245.788665\n", - " 375335.534050\n", - " -1089.745385\n", + " 409016.019784\n", + " 378752.521246\n", + " 360679.750486\n", + " 359521.705424\n", + " 359548.833442\n", + " 414765.010421\n", + " 416813.109359\n", + " -2048.098937\n", " \n", " \n", " 44\n", " 2069\n", - " 23422\n", - " 588499\n", - " 3133720.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 445720.962431\n", - " 418703.399054\n", - " 431958.526817\n", - " 430211.684701\n", - " 419976.194936\n", - " 379224.450236\n", - " 378005.108376\n", - " 1219.341861\n", + " 420878.539429\n", + " 445824.370857\n", + " 462306.136722\n", + " 461148.128688\n", + " 461552.424105\n", + " 415927.049193\n", + " 416026.048243\n", + " -98.999050\n", " \n", " \n", " 45\n", " 2070\n", - " 23609\n", - " 593756\n", - " 3146747.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 400991.290205\n", - " 429393.430690\n", - " 411181.980311\n", - " 405133.787228\n", - " 386202.176410\n", - " 383743.213561\n", - " 381667.545696\n", - " 2075.667865\n", + " 405718.142702\n", + " 364719.332490\n", + " 323443.731437\n", + " 324834.166014\n", + " 323233.055405\n", + " 412876.186407\n", + " 415240.473322\n", + " -2364.286915\n", " \n", " \n", "\n", "
" ] }, - "execution_count": 51, + "execution_count": 57, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 51 + "execution_count": 57 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-03T11:37:13.805358Z", - "start_time": "2025-01-03T11:37:13.778402Z" + "end_time": "2025-01-07T15:20:32.501456Z", + "start_time": "2025-01-07T15:20:32.475207Z" } }, "cell_type": "code", @@ -1981,52 +1567,52 @@ "data": { "text/plain": [ " Year Month Facility_ID Altitude \\\n", - "0 2025 23814 599734 3182595.0 \n", - "1 2026 22590 566009 3008054.0 \n", - "2 2027 24474 614678 3269771.0 \n", - "3 2028 23968 600596 3207601.0 \n", - "4 2029 23330 583610 3116929.0 \n", - "5 2030 24073 605374 3226700.0 \n", - "6 2031 23580 593098 3161559.0 \n", - "7 2032 23000 576874 3067975.0 \n", - "8 2033 23581 593277 3157142.0 \n", - "9 2034 24459 614471 3272543.0 \n", - "10 2035 24070 601705 3227338.0 \n", - "11 2036 22412 563438 2989556.0 \n", - "12 2037 23224 583884 3111738.0 \n", - "13 2038 23088 581270 3091620.0 \n", - "14 2039 23796 598440 3178339.0 \n", - "15 2040 24867 625341 3333272.0 \n", - "16 2041 23418 588798 3126883.0 \n", - "17 2042 24483 614818 3264448.0 \n", - "18 2043 22584 568163 3020289.0 \n", - "19 2044 23377 588639 3133986.0 \n", - "20 2045 23817 599233 3190091.0 \n", - "21 2046 24583 616970 3286711.0 \n", - "22 2047 22492 563400 2990632.0 \n", - "23 2048 23857 599713 3190814.0 \n", - "24 2049 23922 602508 3200414.0 \n", - "25 2050 23672 596141 3153492.0 \n", - "26 2051 23898 601388 3209981.0 \n", - "27 2052 23496 591222 3151911.0 \n", - "28 2053 24894 627569 3335143.0 \n", - "29 2054 21946 552383 2937089.0 \n", - "30 2055 23076 579568 3072851.0 \n", - "31 2056 23967 601469 3194980.0 \n", - "32 2057 23389 588821 3139033.0 \n", - "33 2058 22093 555609 2950853.0 \n", - "34 2059 23733 596624 3169901.0 \n", - "35 2060 23173 582978 3100047.0 \n", - "36 2061 23689 595156 3162324.0 \n", - "37 2062 22794 574103 3036727.0 \n", - "38 2063 22722 573325 3024141.0 \n", - "39 2064 23581 590848 3149704.0 \n", - "40 2065 23523 591233 3157907.0 \n", - "41 2066 22993 578310 3065123.0 \n", - "42 2067 23261 583580 3099017.0 \n", - "43 2068 23318 586603 3118001.0 \n", - "44 2069 23422 588499 3133720.0 \n", - "45 2070 23609 593756 3146747.0 \n", + "0 2025 25584 643536 3435564.0 \n", + "1 2026 25584 643536 3435564.0 \n", + "2 2027 25584 643536 3435564.0 \n", + "3 2028 25584 643536 3435564.0 \n", + "4 2029 25584 643536 3435564.0 \n", + "5 2030 25584 643536 3435564.0 \n", + "6 2031 25584 643536 3435564.0 \n", + "7 2032 25584 643536 3435564.0 \n", + "8 2033 25584 643536 3435564.0 \n", + "9 2034 25584 643536 3435564.0 \n", + "10 2035 25584 643536 3435564.0 \n", + "11 2036 25584 643536 3435564.0 \n", + "12 2037 25584 643536 3435564.0 \n", + "13 2038 25584 643536 3435564.0 \n", + "14 2039 25584 643536 3435564.0 \n", + "15 2040 25584 643536 3435564.0 \n", + "16 2041 25584 643536 3435564.0 \n", + "17 2042 25584 643536 3435564.0 \n", + "18 2043 25584 643536 3435564.0 \n", + "19 2044 25584 643536 3435564.0 \n", + "20 2045 25584 643536 3435564.0 \n", + "21 2046 25584 643536 3435564.0 \n", + "22 2047 25584 643536 3435564.0 \n", + "23 2048 25584 643536 3435564.0 \n", + "24 2049 25584 643536 3435564.0 \n", + "25 2050 25584 643536 3435564.0 \n", + "26 2051 25584 643536 3435564.0 \n", + "27 2052 25584 643536 3435564.0 \n", + "28 2053 25584 643536 3435564.0 \n", + "29 2054 25584 643536 3435564.0 \n", + "30 2055 25584 643536 3435564.0 \n", + "31 2056 25584 643536 3435564.0 \n", + "32 2057 25584 643536 3435564.0 \n", + "33 2058 25584 643536 3435564.0 \n", + "34 2059 25584 643536 3435564.0 \n", + "35 2060 25584 643536 3435564.0 \n", + "36 2061 25584 643536 3435564.0 \n", + "37 2062 25584 643536 3435564.0 \n", + "38 2063 25584 643536 3435564.0 \n", + "39 2064 25584 643536 3435564.0 \n", + "40 2065 25584 643536 3435564.0 \n", + "41 2066 25584 643536 3435564.0 \n", + "42 2067 25584 643536 3435564.0 \n", + "43 2068 25584 643536 3435564.0 \n", + "44 2069 25584 643536 3435564.0 \n", + "45 2070 25584 643536 3435564.0 \n", "\n", " Zone \\\n", "0 Central WestSouth EastNorthernSouth EastNorthe... \n", @@ -2173,196 +1759,196 @@ "45 GovernmentGovernmentGovernmentGovernmentGovern... \n", "\n", " Facility_Type Precipitation \\\n", - "0 ClinicDistrict HospitalRural/Community Hospita... 356930.256793 \n", - "1 ClinicDistrict HospitalRural/Community Hospita... 442012.194055 \n", - "2 ClinicDistrict HospitalRural/Community Hospita... 401910.341187 \n", - "3 ClinicDistrict HospitalRural/Community Hospita... 458028.122792 \n", - "4 ClinicDistrict HospitalRural/Community Hospita... 406191.851826 \n", - "5 ClinicDistrict HospitalRural/Community Hospita... 409387.038984 \n", - "6 ClinicDistrict HospitalRural/Community Hospita... 400600.129109 \n", - "7 ClinicDistrict HospitalRural/Community Hospita... 447521.070185 \n", - "8 ClinicDistrict HospitalRural/Community Hospita... 456815.880827 \n", - "9 ClinicDistrict HospitalRural/Community Hospita... 443520.485079 \n", - "10 ClinicDistrict HospitalRural/Community Hospita... 411313.075371 \n", - "11 ClinicDistrict HospitalRural/Community Hospita... 401467.863756 \n", - "12 ClinicDistrict HospitalRural/Community Hospita... 419545.873961 \n", - "13 ClinicDistrict HospitalRural/Community Hospita... 463682.059169 \n", - "14 ClinicDistrict HospitalRural/Community Hospita... 439471.811655 \n", - "15 ClinicDistrict HospitalRural/Community Hospita... 451058.889825 \n", - "16 ClinicDistrict HospitalRural/Community Hospita... 364816.739985 \n", - "17 ClinicDistrict HospitalRural/Community Hospita... 474909.052258 \n", - "18 ClinicDistrict HospitalRural/Community Hospita... 437730.151447 \n", - "19 ClinicDistrict HospitalRural/Community Hospita... 467117.570232 \n", - "20 ClinicDistrict HospitalRural/Community Hospita... 398139.357152 \n", - "21 ClinicDistrict HospitalRural/Community Hospita... 443421.655978 \n", - "22 ClinicDistrict HospitalRural/Community Hospita... 494553.446600 \n", - "23 ClinicDistrict HospitalRural/Community Hospita... 472153.619753 \n", - "24 ClinicDistrict HospitalRural/Community Hospita... 465094.209967 \n", - "25 ClinicDistrict HospitalRural/Community Hospita... 452834.779144 \n", - "26 ClinicDistrict HospitalRural/Community Hospita... 460721.942570 \n", - "27 ClinicDistrict HospitalRural/Community Hospita... 309639.446977 \n", - "28 ClinicDistrict HospitalRural/Community Hospita... 332821.767357 \n", - "29 ClinicDistrict HospitalRural/Community Hospita... 418144.175624 \n", - "30 ClinicDistrict HospitalRural/Community Hospita... 300680.970171 \n", - "31 ClinicDistrict HospitalRural/Community Hospita... 461243.283456 \n", - "32 ClinicDistrict HospitalRural/Community Hospita... 379993.626328 \n", - "33 ClinicDistrict HospitalRural/Community Hospita... 381230.056855 \n", - "34 ClinicDistrict HospitalRural/Community Hospita... 501263.956015 \n", - "35 ClinicDistrict HospitalRural/Community Hospita... 459757.304011 \n", - "36 ClinicDistrict HospitalRural/Community Hospita... 403898.123577 \n", - "37 ClinicDistrict HospitalRural/Community Hospita... 468021.236699 \n", - "38 ClinicDistrict HospitalRural/Community Hospita... 414958.264565 \n", - "39 ClinicDistrict HospitalRural/Community Hospita... 441414.054493 \n", - "40 ClinicDistrict HospitalRural/Community Hospita... 433793.080907 \n", - "41 ClinicDistrict HospitalRural/Community Hospita... 358327.837808 \n", - "42 ClinicDistrict HospitalRural/Community Hospita... 385266.544939 \n", - "43 ClinicDistrict HospitalRural/Community Hospita... 444523.181015 \n", - "44 ClinicDistrict HospitalRural/Community Hospita... 445720.962431 \n", - "45 ClinicDistrict HospitalRural/Community Hospita... 400991.290205 \n", + "0 ClinicDistrict HospitalRural/Community Hospita... 370655.578345 \n", + "1 ClinicDistrict HospitalRural/Community Hospita... 305845.723518 \n", + "2 ClinicDistrict HospitalRural/Community Hospita... 380236.133055 \n", + "3 ClinicDistrict HospitalRural/Community Hospita... 396234.125976 \n", + "4 ClinicDistrict HospitalRural/Community Hospita... 317163.607434 \n", + "5 ClinicDistrict HospitalRural/Community Hospita... 385409.189618 \n", + "6 ClinicDistrict HospitalRural/Community Hospita... 406289.858606 \n", + "7 ClinicDistrict HospitalRural/Community Hospita... 333604.956760 \n", + "8 ClinicDistrict HospitalRural/Community Hospita... 322006.856259 \n", + "9 ClinicDistrict HospitalRural/Community Hospita... 391560.967791 \n", + "10 ClinicDistrict HospitalRural/Community Hospita... 367661.767185 \n", + "11 ClinicDistrict HospitalRural/Community Hospita... 378095.303002 \n", + "12 ClinicDistrict HospitalRural/Community Hospita... 374197.949271 \n", + "13 ClinicDistrict HospitalRural/Community Hospita... 374291.695816 \n", + "14 ClinicDistrict HospitalRural/Community Hospita... 398962.867137 \n", + "15 ClinicDistrict HospitalRural/Community Hospita... 329938.705708 \n", + "16 ClinicDistrict HospitalRural/Community Hospita... 349982.489824 \n", + "17 ClinicDistrict HospitalRural/Community Hospita... 265019.061881 \n", + "18 ClinicDistrict HospitalRural/Community Hospita... 317116.288589 \n", + "19 ClinicDistrict HospitalRural/Community Hospita... 358615.638348 \n", + "20 ClinicDistrict HospitalRural/Community Hospita... 441360.716573 \n", + "21 ClinicDistrict HospitalRural/Community Hospita... 485128.815221 \n", + "22 ClinicDistrict HospitalRural/Community Hospita... 339348.499913 \n", + "23 ClinicDistrict HospitalRural/Community Hospita... 353296.312971 \n", + "24 ClinicDistrict HospitalRural/Community Hospita... 333745.253478 \n", + "25 ClinicDistrict HospitalRural/Community Hospita... 513923.146927 \n", + "26 ClinicDistrict HospitalRural/Community Hospita... 271825.288644 \n", + "27 ClinicDistrict HospitalRural/Community Hospita... 365895.719222 \n", + "28 ClinicDistrict HospitalRural/Community Hospita... 325208.687060 \n", + "29 ClinicDistrict HospitalRural/Community Hospita... 382143.812346 \n", + "30 ClinicDistrict HospitalRural/Community Hospita... 287994.569053 \n", + "31 ClinicDistrict HospitalRural/Community Hospita... 332374.359974 \n", + "32 ClinicDistrict HospitalRural/Community Hospita... 392877.314013 \n", + "33 ClinicDistrict HospitalRural/Community Hospita... 302066.178485 \n", + "34 ClinicDistrict HospitalRural/Community Hospita... 327708.324530 \n", + "35 ClinicDistrict HospitalRural/Community Hospita... 309435.437644 \n", + "36 ClinicDistrict HospitalRural/Community Hospita... 320279.427886 \n", + "37 ClinicDistrict HospitalRural/Community Hospita... 330832.389669 \n", + "38 ClinicDistrict HospitalRural/Community Hospita... 435362.126119 \n", + "39 ClinicDistrict HospitalRural/Community Hospita... 304940.147499 \n", + "40 ClinicDistrict HospitalRural/Community Hospita... 353974.887443 \n", + "41 ClinicDistrict HospitalRural/Community Hospita... 295464.487169 \n", + "42 ClinicDistrict HospitalRural/Community Hospita... 297221.496710 \n", + "43 ClinicDistrict HospitalRural/Community Hospita... 409016.019784 \n", + "44 ClinicDistrict HospitalRural/Community Hospita... 420878.539429 \n", + "45 ClinicDistrict HospitalRural/Community Hospita... 405718.142702 \n", "\n", " Lag_1_Precipitation Lag_2_Precipitation Lag_3_Precipitation \\\n", - "0 294609.145696 251778.819911 240074.691709 \n", - "1 397157.668329 397273.347895 348266.651361 \n", - "2 414186.725872 420900.694753 423488.413324 \n", - "3 454173.805476 433342.964932 425159.752149 \n", - "4 439691.054081 445950.755762 418870.421666 \n", - "5 389364.247808 392455.710835 397461.356243 \n", - "6 392631.249314 374449.656015 373894.307761 \n", - "7 402914.631768 394545.775941 380305.249049 \n", - "8 498011.574391 475942.063738 466685.963435 \n", - "9 441306.486897 449381.026641 430634.351876 \n", - "10 461142.612330 444654.932360 434587.827755 \n", - "11 357763.087422 364775.944769 347716.667867 \n", - "12 416541.339977 409043.550166 391920.926233 \n", - "13 442526.600924 451303.450407 456286.448435 \n", - "14 486171.696867 502289.466180 498044.017229 \n", - "15 431633.402209 402153.409212 398040.518931 \n", - "16 335208.786306 354775.001534 338447.362232 \n", - "17 506841.062275 463684.071161 461858.642099 \n", - "18 415617.644419 410420.270555 407615.216190 \n", - "19 486817.869497 480637.195403 474544.770943 \n", - "20 362850.193582 402219.531548 399839.624296 \n", - "21 468076.690976 465542.221447 467423.630271 \n", - "22 444767.223650 409485.605985 387260.946000 \n", - "23 503414.718730 491261.349692 495127.838946 \n", - "24 455038.002255 477898.743986 469420.838584 \n", - "25 465973.024854 462746.331497 425762.806114 \n", - "26 407556.892301 401004.293570 421749.445065 \n", - "27 390992.045894 420441.094988 413192.196815 \n", - "28 320904.427223 316776.074425 316292.885898 \n", - "29 404366.782226 391164.519869 373727.874006 \n", - "30 346289.174108 340245.279011 329299.172958 \n", - "31 391853.983192 387762.882037 372651.645513 \n", - "32 421170.962261 417222.716525 405927.199113 \n", - "33 354587.101006 350957.265087 326505.718272 \n", - "34 490253.713022 477610.230551 460159.597378 \n", - "35 436835.494548 419958.086643 435515.915955 \n", - "36 446026.892969 459573.706453 436904.851847 \n", - "37 450100.730558 416050.220079 373748.278834 \n", - "38 415976.330050 443797.927964 453085.545667 \n", - "39 435767.269524 415051.021426 406769.043607 \n", - "40 435494.327000 421305.379992 408124.267918 \n", - "41 382545.188235 359818.742372 354980.088513 \n", - "42 357229.405339 389448.072900 382553.140857 \n", - "43 449728.133273 439791.891824 438856.705942 \n", - "44 418703.399054 431958.526817 430211.684701 \n", - "45 429393.430690 411181.980311 405133.787228 \n", + "0 298710.995438 260619.466056 255428.892934 \n", + "1 324216.805408 351108.236956 352944.118983 \n", + "2 351903.960266 349493.164255 344770.234996 \n", + "3 379492.789825 375543.857029 381029.229862 \n", + "4 375481.180687 385373.062799 381129.073629 \n", + "5 311938.841921 285932.285061 289579.937651 \n", + "6 433698.584038 455288.388297 455102.702313 \n", + "7 315844.250082 324314.368396 316195.532608 \n", + "8 371283.829234 345593.426372 354934.926046 \n", + "9 399207.341834 400410.349670 392246.728746 \n", + "10 341985.164411 327819.997189 330789.556355 \n", + "11 398497.779822 408894.912655 378604.565588 \n", + "12 348875.547726 360367.235995 389923.203199 \n", + "13 370981.253838 381170.945543 378471.104964 \n", + "14 394083.987840 401617.097706 408341.613660 \n", + "15 344469.424679 340683.245254 342518.356804 \n", + "16 331135.927791 335947.246630 335248.047067 \n", + "17 328321.508621 302510.901036 300226.263604 \n", + "18 252246.251731 271260.885375 274124.334082 \n", + "19 410050.158172 387974.439450 387736.897200 \n", + "20 369108.855991 362046.586240 342819.132014 \n", + "21 482869.984890 480685.090489 500151.794189 \n", + "22 419334.638122 449504.867423 447116.625283 \n", + "23 317922.916948 310749.912224 313141.518581 \n", + "24 325481.247456 336295.941280 330700.546457 \n", + "25 502910.647286 435891.016355 437939.836711 \n", + "26 325017.559932 392209.231985 393915.875687 \n", + "27 355003.796484 335224.704315 335946.670289 \n", + "28 360724.744731 376450.353321 368811.709372 \n", + "29 329764.214376 325974.066284 334512.344383 \n", + "30 331417.631119 333207.967531 331162.787180 \n", + "31 265016.427098 267520.943494 269888.025290 \n", + "32 457908.115607 448849.771066 446651.780946 \n", + "33 278375.606401 291501.477315 289945.485496 \n", + "34 318063.470421 302154.611762 306083.376401 \n", + "35 327543.125082 336866.204386 331980.842360 \n", + "36 330945.691553 322432.738606 318079.159985 \n", + "37 285321.675202 301954.830856 310662.088357 \n", + "38 433776.704399 419118.260070 404772.957169 \n", + "39 317030.377297 304945.762400 319651.502857 \n", + "40 329874.956467 337015.684029 328940.852077 \n", + "41 354202.699889 365879.087584 373323.111876 \n", + "42 272255.281494 280888.319603 281510.797522 \n", + "43 378752.521246 360679.750486 359521.705424 \n", + "44 445824.370857 462306.136722 461148.128688 \n", + "45 364719.332490 323443.731437 324834.166014 \n", "\n", " Lag_4_Precipitation Predicted_Weather_Model Predicted_No_Weather_Model \\\n", - "0 212611.355306 262073.177045 414580.859514 \n", - "1 329607.014297 391897.166673 394712.494598 \n", - "2 427242.313426 424216.303078 426507.644233 \n", - "3 409583.757336 418663.778757 419005.094793 \n", - "4 404708.312917 405721.982368 407774.686109 \n", - "5 389452.051202 422077.382352 421235.583604 \n", - "6 361847.942122 406625.933041 406869.091856 \n", - "7 367935.056473 390456.768764 393982.523859 \n", - "8 443793.819493 404036.109552 407105.988595 \n", - "9 428705.248932 419086.106241 421792.859293 \n", - "10 424916.410268 414353.849683 416718.943844 \n", - "11 321868.628640 379822.724678 383326.342849 \n", - "12 378814.601365 396472.620305 397095.249567 \n", - "13 441830.397786 392687.251512 394380.103735 \n", - "14 485302.039523 402985.471692 406826.384026 \n", - "15 371349.124368 425017.218302 426405.341430 \n", - "16 321940.022061 397017.066601 399458.496395 \n", - "17 454618.554156 416691.544445 416997.757878 \n", - "18 384771.629007 383660.669690 383755.734156 \n", - "19 455304.239249 394673.545565 394754.939189 \n", - "20 377344.967272 401135.309503 402985.317847 \n", - "21 464577.255028 412242.557813 413773.489936 \n", - "22 360098.331291 372146.903936 375589.196357 \n", - "23 485805.294721 401945.091876 402709.253238 \n", - "24 440243.139280 398685.865173 401567.430428 \n", - "25 427139.769513 399252.955628 398635.670647 \n", - "26 405452.318421 400477.291574 400608.907041 \n", - "27 409041.464387 390999.580252 392078.841473 \n", - "28 306048.398243 416471.045063 418092.099246 \n", - "29 343975.955350 360207.713252 364273.522362 \n", - "30 309663.520488 379799.778479 382254.450494 \n", - "31 355108.240357 389694.500461 393327.366843 \n", - "32 379013.465979 382707.973900 382588.827454 \n", - "33 294446.256154 361165.891802 361939.932800 \n", - "34 444568.857000 389684.514691 391135.437740 \n", - "35 425013.325154 383317.152377 381266.519178 \n", - "36 419966.747362 390113.556785 387064.014493 \n", - "37 351040.543393 372856.397814 373879.275648 \n", - "38 444035.139054 367768.692199 368187.001270 \n", - "39 396642.228590 378200.181200 380644.486568 \n", - "40 399546.170001 383210.897923 380769.053462 \n", - "41 342669.140660 373477.131153 373664.729920 \n", - "42 367803.054399 375480.781577 376740.673312 \n", - "43 426322.297655 374245.788665 375335.534050 \n", - "44 419976.194936 379224.450236 378005.108376 \n", - "45 386202.176410 383743.213561 381667.545696 \n", + "0 253508.982217 301084.510508 452103.379475 \n", + "1 353891.586301 448829.801850 451249.680342 \n", + "2 345157.532117 450130.102782 450397.593235 \n", + "3 379415.048009 446465.064103 449547.115109 \n", + "4 382864.345741 446875.456426 448698.242927 \n", + "5 289345.079079 445094.075488 447850.973656 \n", + "6 455034.373344 443152.899063 447005.304268 \n", + "7 314871.921748 445109.242713 446161.231744 \n", + "8 356543.998012 444390.632491 445318.753068 \n", + "9 391937.348081 443363.169753 444477.865230 \n", + "10 329650.101725 441484.287781 443638.565226 \n", + "11 379596.718666 443252.418520 442800.850059 \n", + "12 389558.939179 440302.572113 441964.716734 \n", + "13 377682.655534 441220.746519 441130.162266 \n", + "14 409745.578729 442599.508715 440297.183673 \n", + "15 341977.330400 437729.663871 439465.777979 \n", + "16 335789.435760 435203.049238 438635.942214 \n", + "17 296296.047432 436957.723991 437807.673415 \n", + "18 278184.608227 434305.862192 436980.968621 \n", + "19 387661.416146 434323.547929 436155.824879 \n", + "20 340516.424995 434015.417381 435332.239243 \n", + "21 502277.800794 434856.288139 434510.208770 \n", + "22 445805.292269 435279.971776 433689.730522 \n", + "23 313923.715557 430636.491081 432870.801570 \n", + "24 330244.876504 430911.874972 432053.418987 \n", + "25 438231.552425 428660.978812 431237.579854 \n", + "26 393957.931607 430121.833314 430423.281257 \n", + "27 336884.175544 427569.904956 429610.520285 \n", + "28 365595.615071 427736.660883 428799.294036 \n", + "29 337541.046047 425208.288593 427989.599612 \n", + "30 331449.273326 426741.194309 427181.434120 \n", + "31 269433.014822 425551.827998 426374.794674 \n", + "32 445524.032754 424893.403624 425569.678390 \n", + "33 291038.100935 423223.667713 424766.082395 \n", + "34 305678.254498 422131.112511 423964.003816 \n", + "35 330169.889911 421573.506857 423163.439788 \n", + "36 317973.894415 422575.707068 422364.387452 \n", + "37 312810.479228 420956.703710 421566.843952 \n", + "38 405190.542219 418934.469956 420770.806441 \n", + "39 319575.723877 419086.943369 419976.272074 \n", + "40 329238.343810 418729.313756 419183.238012 \n", + "41 372541.004296 418355.425750 418391.701423 \n", + "42 281840.507716 417412.937075 417601.659480 \n", + "43 359548.833442 414765.010421 416813.109359 \n", + "44 461552.424105 415927.049193 416026.048243 \n", + "45 323233.055405 412876.186407 415240.473322 \n", "\n", " Difference_in_Expectation Percentage_Difference \n", - "0 -1806.379897 -0.004357 \n", - "1 -2815.327925 -0.007133 \n", - "2 -2291.341155 -0.005372 \n", - "3 -341.316036 -0.000815 \n", - "4 -2052.703741 -0.005034 \n", - "5 841.798749 0.001998 \n", - "6 -243.158815 -0.000598 \n", - "7 -3525.755094 -0.008949 \n", - "8 -3069.879043 -0.007541 \n", - "9 -2706.753053 -0.006417 \n", - "10 -2365.094162 -0.005676 \n", - "11 -3503.618171 -0.009140 \n", - "12 -622.629263 -0.001568 \n", - "13 -1692.852223 -0.004292 \n", - "14 -3840.912333 -0.009441 \n", - "15 -1388.123129 -0.003255 \n", - "16 -2441.429794 -0.006112 \n", - "17 -306.213433 -0.000734 \n", - "18 -95.064467 -0.000248 \n", - "19 -81.393624 -0.000206 \n", - "20 -1850.008344 -0.004591 \n", - "21 -1530.932123 -0.003700 \n", - "22 -3442.292421 -0.009165 \n", - "23 -764.161361 -0.001898 \n", - "24 -2881.565255 -0.007176 \n", - "25 617.284980 0.001548 \n", - "26 -131.615467 -0.000329 \n", - "27 -1079.261220 -0.002753 \n", - "28 -1621.054183 -0.003877 \n", - "29 -4065.809111 -0.011161 \n", - "30 -2454.672016 -0.006422 \n", - "31 -3632.866382 -0.009236 \n", - "32 119.146445 0.000311 \n", - "33 -774.040998 -0.002139 \n", - "34 -1450.923049 -0.003710 \n", - "35 2050.633200 0.005378 \n", - "36 3049.542292 0.007879 \n", - "37 -1022.877835 -0.002736 \n", - "38 -418.309071 -0.001136 \n", - "39 -2444.305368 -0.006421 \n", - "40 2441.844461 0.006413 \n", - "41 -187.598767 -0.000502 \n", - "42 -1259.891735 -0.003344 \n", - "43 -1089.745385 -0.002903 \n", - "44 1219.341861 0.003226 \n", - "45 2075.667865 0.005438 " + "0 -317.566395 -0.000702 \n", + "1 -2419.878492 -0.005363 \n", + "2 -267.490453 -0.000594 \n", + "3 -3082.051006 -0.006856 \n", + "4 -1822.786501 -0.004062 \n", + "5 -2756.898168 -0.006156 \n", + "6 -3852.405205 -0.008618 \n", + "7 -1051.989032 -0.002358 \n", + "8 -928.120577 -0.002084 \n", + "9 -1114.695477 -0.002508 \n", + "10 -2154.277446 -0.004856 \n", + "11 451.568461 0.001020 \n", + "12 -1662.144621 -0.003761 \n", + "13 90.584253 0.000205 \n", + "14 2302.325042 0.005229 \n", + "15 -1736.114108 -0.003951 \n", + "16 -3432.892977 -0.007826 \n", + "17 -849.949424 -0.001941 \n", + "18 -2675.106429 -0.006122 \n", + "19 -1832.276951 -0.004201 \n", + "20 -1316.821862 -0.003025 \n", + "21 346.079370 0.000796 \n", + "22 1590.241254 0.003667 \n", + "23 -2234.310489 -0.005162 \n", + "24 -1141.544015 -0.002642 \n", + "25 -2576.601042 -0.005975 \n", + "26 -301.447942 -0.000700 \n", + "27 -2040.615329 -0.004750 \n", + "28 -1062.633153 -0.002478 \n", + "29 -2781.311019 -0.006499 \n", + "30 -440.239811 -0.001031 \n", + "31 -822.966676 -0.001930 \n", + "32 -676.274766 -0.001589 \n", + "33 -1542.414682 -0.003631 \n", + "34 -1832.891305 -0.004323 \n", + "35 -1589.932931 -0.003757 \n", + "36 211.319617 0.000500 \n", + "37 -610.140243 -0.001447 \n", + "38 -1836.336485 -0.004364 \n", + "39 -889.328705 -0.002118 \n", + "40 -453.924256 -0.001083 \n", + "41 -36.275673 -0.000087 \n", + "42 -188.722404 -0.000452 \n", + "43 -2048.098937 -0.004914 \n", + "44 -98.999050 -0.000238 \n", + "45 -2364.286915 -0.005694 " ], "text/html": [ "
\n", @@ -2406,945 +1992,945 @@ " \n", " 0\n", " 2025\n", - " 23814\n", - " 599734\n", - " 3182595.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 356930.256793\n", - " 294609.145696\n", - " 251778.819911\n", - " 240074.691709\n", - " 212611.355306\n", - " 262073.177045\n", - " 414580.859514\n", - " -1806.379897\n", - " -0.004357\n", + " 370655.578345\n", + " 298710.995438\n", + " 260619.466056\n", + " 255428.892934\n", + " 253508.982217\n", + " 301084.510508\n", + " 452103.379475\n", + " -317.566395\n", + " -0.000702\n", " \n", " \n", " 1\n", " 2026\n", - " 22590\n", - " 566009\n", - " 3008054.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 442012.194055\n", - " 397157.668329\n", - " 397273.347895\n", - " 348266.651361\n", - " 329607.014297\n", - " 391897.166673\n", - " 394712.494598\n", - " -2815.327925\n", - " -0.007133\n", + " 305845.723518\n", + " 324216.805408\n", + " 351108.236956\n", + " 352944.118983\n", + " 353891.586301\n", + " 448829.801850\n", + " 451249.680342\n", + " -2419.878492\n", + " -0.005363\n", " \n", " \n", " 2\n", " 2027\n", - " 24474\n", - " 614678\n", - " 3269771.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 401910.341187\n", - " 414186.725872\n", - " 420900.694753\n", - " 423488.413324\n", - " 427242.313426\n", - " 424216.303078\n", - " 426507.644233\n", - " -2291.341155\n", - " -0.005372\n", + " 380236.133055\n", + " 351903.960266\n", + " 349493.164255\n", + " 344770.234996\n", + " 345157.532117\n", + " 450130.102782\n", + " 450397.593235\n", + " -267.490453\n", + " -0.000594\n", " \n", " \n", " 3\n", " 2028\n", - " 23968\n", - " 600596\n", - " 3207601.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 458028.122792\n", - " 454173.805476\n", - " 433342.964932\n", - " 425159.752149\n", - " 409583.757336\n", - " 418663.778757\n", - " 419005.094793\n", - " -341.316036\n", - " -0.000815\n", + " 396234.125976\n", + " 379492.789825\n", + " 375543.857029\n", + " 381029.229862\n", + " 379415.048009\n", + " 446465.064103\n", + " 449547.115109\n", + " -3082.051006\n", + " -0.006856\n", " \n", " \n", " 4\n", " 2029\n", - " 23330\n", - " 583610\n", - " 3116929.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 406191.851826\n", - " 439691.054081\n", - " 445950.755762\n", - " 418870.421666\n", - " 404708.312917\n", - " 405721.982368\n", - " 407774.686109\n", - " -2052.703741\n", - " -0.005034\n", + " 317163.607434\n", + " 375481.180687\n", + " 385373.062799\n", + " 381129.073629\n", + " 382864.345741\n", + " 446875.456426\n", + " 448698.242927\n", + " -1822.786501\n", + " -0.004062\n", " \n", " \n", " 5\n", " 2030\n", - " 24073\n", - " 605374\n", - " 3226700.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 409387.038984\n", - " 389364.247808\n", - " 392455.710835\n", - " 397461.356243\n", - " 389452.051202\n", - " 422077.382352\n", - " 421235.583604\n", - " 841.798749\n", - " 0.001998\n", + " 385409.189618\n", + " 311938.841921\n", + " 285932.285061\n", + " 289579.937651\n", + " 289345.079079\n", + " 445094.075488\n", + " 447850.973656\n", + " -2756.898168\n", + " -0.006156\n", " \n", " \n", " 6\n", " 2031\n", - " 23580\n", - " 593098\n", - " 3161559.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 400600.129109\n", - " 392631.249314\n", - " 374449.656015\n", - " 373894.307761\n", - " 361847.942122\n", - " 406625.933041\n", - " 406869.091856\n", - " -243.158815\n", - " -0.000598\n", + " 406289.858606\n", + " 433698.584038\n", + " 455288.388297\n", + " 455102.702313\n", + " 455034.373344\n", + " 443152.899063\n", + " 447005.304268\n", + " -3852.405205\n", + " -0.008618\n", " \n", " \n", " 7\n", " 2032\n", - " 23000\n", - " 576874\n", - " 3067975.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 447521.070185\n", - " 402914.631768\n", - " 394545.775941\n", - " 380305.249049\n", - " 367935.056473\n", - " 390456.768764\n", - " 393982.523859\n", - " -3525.755094\n", - " -0.008949\n", + " 333604.956760\n", + " 315844.250082\n", + " 324314.368396\n", + " 316195.532608\n", + " 314871.921748\n", + " 445109.242713\n", + " 446161.231744\n", + " -1051.989032\n", + " -0.002358\n", " \n", " \n", " 8\n", " 2033\n", - " 23581\n", - " 593277\n", - " 3157142.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 456815.880827\n", - " 498011.574391\n", - " 475942.063738\n", - " 466685.963435\n", - " 443793.819493\n", - " 404036.109552\n", - " 407105.988595\n", - " -3069.879043\n", - " -0.007541\n", + " 322006.856259\n", + " 371283.829234\n", + " 345593.426372\n", + " 354934.926046\n", + " 356543.998012\n", + " 444390.632491\n", + " 445318.753068\n", + " -928.120577\n", + " -0.002084\n", " \n", " \n", " 9\n", " 2034\n", - " 24459\n", - " 614471\n", - " 3272543.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 443520.485079\n", - " 441306.486897\n", - " 449381.026641\n", - " 430634.351876\n", - " 428705.248932\n", - " 419086.106241\n", - " 421792.859293\n", - " -2706.753053\n", - " -0.006417\n", + " 391560.967791\n", + " 399207.341834\n", + " 400410.349670\n", + " 392246.728746\n", + " 391937.348081\n", + " 443363.169753\n", + " 444477.865230\n", + " -1114.695477\n", + " -0.002508\n", " \n", " \n", " 10\n", " 2035\n", - " 24070\n", - " 601705\n", - " 3227338.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 411313.075371\n", - " 461142.612330\n", - " 444654.932360\n", - " 434587.827755\n", - " 424916.410268\n", - " 414353.849683\n", - " 416718.943844\n", - " -2365.094162\n", - " -0.005676\n", + " 367661.767185\n", + " 341985.164411\n", + " 327819.997189\n", + " 330789.556355\n", + " 329650.101725\n", + " 441484.287781\n", + " 443638.565226\n", + " -2154.277446\n", + " -0.004856\n", " \n", " \n", " 11\n", " 2036\n", - " 22412\n", - " 563438\n", - " 2989556.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 401467.863756\n", - " 357763.087422\n", - " 364775.944769\n", - " 347716.667867\n", - " 321868.628640\n", - " 379822.724678\n", - " 383326.342849\n", - " -3503.618171\n", - " -0.009140\n", + " 378095.303002\n", + " 398497.779822\n", + " 408894.912655\n", + " 378604.565588\n", + " 379596.718666\n", + " 443252.418520\n", + " 442800.850059\n", + " 451.568461\n", + " 0.001020\n", " \n", " \n", " 12\n", " 2037\n", - " 23224\n", - " 583884\n", - " 3111738.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 419545.873961\n", - " 416541.339977\n", - " 409043.550166\n", - " 391920.926233\n", - " 378814.601365\n", - " 396472.620305\n", - " 397095.249567\n", - " -622.629263\n", - " -0.001568\n", + " 374197.949271\n", + " 348875.547726\n", + " 360367.235995\n", + " 389923.203199\n", + " 389558.939179\n", + " 440302.572113\n", + " 441964.716734\n", + " -1662.144621\n", + " -0.003761\n", " \n", " \n", " 13\n", " 2038\n", - " 23088\n", - " 581270\n", - " 3091620.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 463682.059169\n", - " 442526.600924\n", - " 451303.450407\n", - " 456286.448435\n", - " 441830.397786\n", - " 392687.251512\n", - " 394380.103735\n", - " -1692.852223\n", - " -0.004292\n", + " 374291.695816\n", + " 370981.253838\n", + " 381170.945543\n", + " 378471.104964\n", + " 377682.655534\n", + " 441220.746519\n", + " 441130.162266\n", + " 90.584253\n", + " 0.000205\n", " \n", " \n", " 14\n", " 2039\n", - " 23796\n", - " 598440\n", - " 3178339.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 439471.811655\n", - " 486171.696867\n", - " 502289.466180\n", - " 498044.017229\n", - " 485302.039523\n", - " 402985.471692\n", - " 406826.384026\n", - " -3840.912333\n", - " -0.009441\n", + " 398962.867137\n", + " 394083.987840\n", + " 401617.097706\n", + " 408341.613660\n", + " 409745.578729\n", + " 442599.508715\n", + " 440297.183673\n", + " 2302.325042\n", + " 0.005229\n", " \n", " \n", " 15\n", " 2040\n", - " 24867\n", - " 625341\n", - " 3333272.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 451058.889825\n", - " 431633.402209\n", - " 402153.409212\n", - " 398040.518931\n", - " 371349.124368\n", - " 425017.218302\n", - " 426405.341430\n", - " -1388.123129\n", - " -0.003255\n", + " 329938.705708\n", + " 344469.424679\n", + " 340683.245254\n", + " 342518.356804\n", + " 341977.330400\n", + " 437729.663871\n", + " 439465.777979\n", + " -1736.114108\n", + " -0.003951\n", " \n", " \n", " 16\n", " 2041\n", - " 23418\n", - " 588798\n", - " 3126883.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 364816.739985\n", - " 335208.786306\n", - " 354775.001534\n", - " 338447.362232\n", - " 321940.022061\n", - " 397017.066601\n", - " 399458.496395\n", - " -2441.429794\n", - " -0.006112\n", + " 349982.489824\n", + " 331135.927791\n", + " 335947.246630\n", + " 335248.047067\n", + " 335789.435760\n", + " 435203.049238\n", + " 438635.942214\n", + " -3432.892977\n", + " -0.007826\n", " \n", " \n", " 17\n", " 2042\n", - " 24483\n", - " 614818\n", - " 3264448.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 474909.052258\n", - " 506841.062275\n", - " 463684.071161\n", - " 461858.642099\n", - " 454618.554156\n", - " 416691.544445\n", - " 416997.757878\n", - " -306.213433\n", - " -0.000734\n", + " 265019.061881\n", + " 328321.508621\n", + " 302510.901036\n", + " 300226.263604\n", + " 296296.047432\n", + " 436957.723991\n", + " 437807.673415\n", + " -849.949424\n", + " -0.001941\n", " \n", " \n", " 18\n", " 2043\n", - " 22584\n", - " 568163\n", - " 3020289.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 437730.151447\n", - " 415617.644419\n", - " 410420.270555\n", - " 407615.216190\n", - " 384771.629007\n", - " 383660.669690\n", - " 383755.734156\n", - " -95.064467\n", - " -0.000248\n", + " 317116.288589\n", + " 252246.251731\n", + " 271260.885375\n", + " 274124.334082\n", + " 278184.608227\n", + " 434305.862192\n", + " 436980.968621\n", + " -2675.106429\n", + " -0.006122\n", " \n", " \n", " 19\n", " 2044\n", - " 23377\n", - " 588639\n", - " 3133986.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 467117.570232\n", - " 486817.869497\n", - " 480637.195403\n", - " 474544.770943\n", - " 455304.239249\n", - " 394673.545565\n", - " 394754.939189\n", - " -81.393624\n", - " -0.000206\n", + " 358615.638348\n", + " 410050.158172\n", + " 387974.439450\n", + " 387736.897200\n", + " 387661.416146\n", + " 434323.547929\n", + " 436155.824879\n", + " -1832.276951\n", + " -0.004201\n", " \n", " \n", " 20\n", " 2045\n", - " 23817\n", - " 599233\n", - " 3190091.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 398139.357152\n", - " 362850.193582\n", - " 402219.531548\n", - " 399839.624296\n", - " 377344.967272\n", - " 401135.309503\n", - " 402985.317847\n", - " -1850.008344\n", - " -0.004591\n", + " 441360.716573\n", + " 369108.855991\n", + " 362046.586240\n", + " 342819.132014\n", + " 340516.424995\n", + " 434015.417381\n", + " 435332.239243\n", + " -1316.821862\n", + " -0.003025\n", " \n", " \n", " 21\n", " 2046\n", - " 24583\n", - " 616970\n", - " 3286711.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 443421.655978\n", - " 468076.690976\n", - " 465542.221447\n", - " 467423.630271\n", - " 464577.255028\n", - " 412242.557813\n", - " 413773.489936\n", - " -1530.932123\n", - " -0.003700\n", + " 485128.815221\n", + " 482869.984890\n", + " 480685.090489\n", + " 500151.794189\n", + " 502277.800794\n", + " 434856.288139\n", + " 434510.208770\n", + " 346.079370\n", + " 0.000796\n", " \n", " \n", " 22\n", " 2047\n", - " 22492\n", - " 563400\n", - " 2990632.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 494553.446600\n", - " 444767.223650\n", - " 409485.605985\n", - " 387260.946000\n", - " 360098.331291\n", - " 372146.903936\n", - " 375589.196357\n", - " -3442.292421\n", - " -0.009165\n", + " 339348.499913\n", + " 419334.638122\n", + " 449504.867423\n", + " 447116.625283\n", + " 445805.292269\n", + " 435279.971776\n", + " 433689.730522\n", + " 1590.241254\n", + " 0.003667\n", " \n", " \n", " 23\n", " 2048\n", - " 23857\n", - " 599713\n", - " 3190814.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 472153.619753\n", - " 503414.718730\n", - " 491261.349692\n", - " 495127.838946\n", - " 485805.294721\n", - " 401945.091876\n", - " 402709.253238\n", - " -764.161361\n", - " -0.001898\n", + " 353296.312971\n", + " 317922.916948\n", + " 310749.912224\n", + " 313141.518581\n", + " 313923.715557\n", + " 430636.491081\n", + " 432870.801570\n", + " -2234.310489\n", + " -0.005162\n", " \n", " \n", " 24\n", " 2049\n", - " 23922\n", - " 602508\n", - " 3200414.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 465094.209967\n", - " 455038.002255\n", - " 477898.743986\n", - " 469420.838584\n", - " 440243.139280\n", - " 398685.865173\n", - " 401567.430428\n", - " -2881.565255\n", - " -0.007176\n", + " 333745.253478\n", + " 325481.247456\n", + " 336295.941280\n", + " 330700.546457\n", + " 330244.876504\n", + " 430911.874972\n", + " 432053.418987\n", + " -1141.544015\n", + " -0.002642\n", " \n", " \n", " 25\n", " 2050\n", - " 23672\n", - " 596141\n", - " 3153492.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 452834.779144\n", - " 465973.024854\n", - " 462746.331497\n", - " 425762.806114\n", - " 427139.769513\n", - " 399252.955628\n", - " 398635.670647\n", - " 617.284980\n", - " 0.001548\n", + " 513923.146927\n", + " 502910.647286\n", + " 435891.016355\n", + " 437939.836711\n", + " 438231.552425\n", + " 428660.978812\n", + " 431237.579854\n", + " -2576.601042\n", + " -0.005975\n", " \n", " \n", " 26\n", " 2051\n", - " 23898\n", - " 601388\n", - " 3209981.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 460721.942570\n", - " 407556.892301\n", - " 401004.293570\n", - " 421749.445065\n", - " 405452.318421\n", - " 400477.291574\n", - " 400608.907041\n", - " -131.615467\n", - " -0.000329\n", + " 271825.288644\n", + " 325017.559932\n", + " 392209.231985\n", + " 393915.875687\n", + " 393957.931607\n", + " 430121.833314\n", + " 430423.281257\n", + " -301.447942\n", + " -0.000700\n", " \n", " \n", " 27\n", " 2052\n", - " 23496\n", - " 591222\n", - " 3151911.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 309639.446977\n", - " 390992.045894\n", - " 420441.094988\n", - " 413192.196815\n", - " 409041.464387\n", - " 390999.580252\n", - " 392078.841473\n", - " -1079.261220\n", - " -0.002753\n", + " 365895.719222\n", + " 355003.796484\n", + " 335224.704315\n", + " 335946.670289\n", + " 336884.175544\n", + " 427569.904956\n", + " 429610.520285\n", + " -2040.615329\n", + " -0.004750\n", " \n", " \n", " 28\n", " 2053\n", - " 24894\n", - " 627569\n", - " 3335143.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 332821.767357\n", - " 320904.427223\n", - " 316776.074425\n", - " 316292.885898\n", - " 306048.398243\n", - " 416471.045063\n", - " 418092.099246\n", - " -1621.054183\n", - " -0.003877\n", + " 325208.687060\n", + " 360724.744731\n", + " 376450.353321\n", + " 368811.709372\n", + " 365595.615071\n", + " 427736.660883\n", + " 428799.294036\n", + " -1062.633153\n", + " -0.002478\n", " \n", " \n", " 29\n", " 2054\n", - " 21946\n", - " 552383\n", - " 2937089.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 418144.175624\n", - " 404366.782226\n", - " 391164.519869\n", - " 373727.874006\n", - " 343975.955350\n", - " 360207.713252\n", - " 364273.522362\n", - " -4065.809111\n", - " -0.011161\n", + " 382143.812346\n", + " 329764.214376\n", + " 325974.066284\n", + " 334512.344383\n", + " 337541.046047\n", + " 425208.288593\n", + " 427989.599612\n", + " -2781.311019\n", + " -0.006499\n", " \n", " \n", " 30\n", " 2055\n", - " 23076\n", - " 579568\n", - " 3072851.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 300680.970171\n", - " 346289.174108\n", - " 340245.279011\n", - " 329299.172958\n", - " 309663.520488\n", - " 379799.778479\n", - " 382254.450494\n", - " -2454.672016\n", - " -0.006422\n", + " 287994.569053\n", + " 331417.631119\n", + " 333207.967531\n", + " 331162.787180\n", + " 331449.273326\n", + " 426741.194309\n", + " 427181.434120\n", + " -440.239811\n", + " -0.001031\n", " \n", " \n", " 31\n", " 2056\n", - " 23967\n", - " 601469\n", - " 3194980.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 461243.283456\n", - " 391853.983192\n", - " 387762.882037\n", - " 372651.645513\n", - " 355108.240357\n", - " 389694.500461\n", - " 393327.366843\n", - " -3632.866382\n", - " -0.009236\n", + " 332374.359974\n", + " 265016.427098\n", + " 267520.943494\n", + " 269888.025290\n", + " 269433.014822\n", + " 425551.827998\n", + " 426374.794674\n", + " -822.966676\n", + " -0.001930\n", " \n", " \n", " 32\n", " 2057\n", - " 23389\n", - " 588821\n", - " 3139033.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 379993.626328\n", - " 421170.962261\n", - " 417222.716525\n", - " 405927.199113\n", - " 379013.465979\n", - " 382707.973900\n", - " 382588.827454\n", - " 119.146445\n", - " 0.000311\n", + " 392877.314013\n", + " 457908.115607\n", + " 448849.771066\n", + " 446651.780946\n", + " 445524.032754\n", + " 424893.403624\n", + " 425569.678390\n", + " -676.274766\n", + " -0.001589\n", " \n", " \n", " 33\n", " 2058\n", - " 22093\n", - " 555609\n", - " 2950853.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 381230.056855\n", - " 354587.101006\n", - " 350957.265087\n", - " 326505.718272\n", - " 294446.256154\n", - " 361165.891802\n", - " 361939.932800\n", - " -774.040998\n", - " -0.002139\n", + " 302066.178485\n", + " 278375.606401\n", + " 291501.477315\n", + " 289945.485496\n", + " 291038.100935\n", + " 423223.667713\n", + " 424766.082395\n", + " -1542.414682\n", + " -0.003631\n", " \n", " \n", " 34\n", " 2059\n", - " 23733\n", - " 596624\n", - " 3169901.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 501263.956015\n", - " 490253.713022\n", - " 477610.230551\n", - " 460159.597378\n", - " 444568.857000\n", - " 389684.514691\n", - " 391135.437740\n", - " -1450.923049\n", - " -0.003710\n", + " 327708.324530\n", + " 318063.470421\n", + " 302154.611762\n", + " 306083.376401\n", + " 305678.254498\n", + " 422131.112511\n", + " 423964.003816\n", + " -1832.891305\n", + " -0.004323\n", " \n", " \n", " 35\n", " 2060\n", - " 23173\n", - " 582978\n", - " 3100047.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 459757.304011\n", - " 436835.494548\n", - " 419958.086643\n", - " 435515.915955\n", - " 425013.325154\n", - " 383317.152377\n", - " 381266.519178\n", - " 2050.633200\n", - " 0.005378\n", + " 309435.437644\n", + " 327543.125082\n", + " 336866.204386\n", + " 331980.842360\n", + " 330169.889911\n", + " 421573.506857\n", + " 423163.439788\n", + " -1589.932931\n", + " -0.003757\n", " \n", " \n", " 36\n", " 2061\n", - " 23689\n", - " 595156\n", - " 3162324.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 403898.123577\n", - " 446026.892969\n", - " 459573.706453\n", - " 436904.851847\n", - " 419966.747362\n", - " 390113.556785\n", - " 387064.014493\n", - " 3049.542292\n", - " 0.007879\n", + " 320279.427886\n", + " 330945.691553\n", + " 322432.738606\n", + " 318079.159985\n", + " 317973.894415\n", + " 422575.707068\n", + " 422364.387452\n", + " 211.319617\n", + " 0.000500\n", " \n", " \n", " 37\n", " 2062\n", - " 22794\n", - " 574103\n", - " 3036727.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 468021.236699\n", - " 450100.730558\n", - " 416050.220079\n", - " 373748.278834\n", - " 351040.543393\n", - " 372856.397814\n", - " 373879.275648\n", - " -1022.877835\n", - " -0.002736\n", + " 330832.389669\n", + " 285321.675202\n", + " 301954.830856\n", + " 310662.088357\n", + " 312810.479228\n", + " 420956.703710\n", + " 421566.843952\n", + " -610.140243\n", + " -0.001447\n", " \n", " \n", " 38\n", " 2063\n", - " 22722\n", - " 573325\n", - " 3024141.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 414958.264565\n", - " 415976.330050\n", - " 443797.927964\n", - " 453085.545667\n", - " 444035.139054\n", - " 367768.692199\n", - " 368187.001270\n", - " -418.309071\n", - " -0.001136\n", + " 435362.126119\n", + " 433776.704399\n", + " 419118.260070\n", + " 404772.957169\n", + " 405190.542219\n", + " 418934.469956\n", + " 420770.806441\n", + " -1836.336485\n", + " -0.004364\n", " \n", " \n", " 39\n", " 2064\n", - " 23581\n", - " 590848\n", - " 3149704.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 441414.054493\n", - " 435767.269524\n", - " 415051.021426\n", - " 406769.043607\n", - " 396642.228590\n", - " 378200.181200\n", - " 380644.486568\n", - " -2444.305368\n", - " -0.006421\n", + " 304940.147499\n", + " 317030.377297\n", + " 304945.762400\n", + " 319651.502857\n", + " 319575.723877\n", + " 419086.943369\n", + " 419976.272074\n", + " -889.328705\n", + " -0.002118\n", " \n", " \n", " 40\n", " 2065\n", - " 23523\n", - " 591233\n", - " 3157907.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 433793.080907\n", - " 435494.327000\n", - " 421305.379992\n", - " 408124.267918\n", - " 399546.170001\n", - " 383210.897923\n", - " 380769.053462\n", - " 2441.844461\n", - " 0.006413\n", + " 353974.887443\n", + " 329874.956467\n", + " 337015.684029\n", + " 328940.852077\n", + " 329238.343810\n", + " 418729.313756\n", + " 419183.238012\n", + " -453.924256\n", + " -0.001083\n", " \n", " \n", " 41\n", " 2066\n", - " 22993\n", - " 578310\n", - " 3065123.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 358327.837808\n", - " 382545.188235\n", - " 359818.742372\n", - " 354980.088513\n", - " 342669.140660\n", - " 373477.131153\n", - " 373664.729920\n", - " -187.598767\n", - " -0.000502\n", + " 295464.487169\n", + " 354202.699889\n", + " 365879.087584\n", + " 373323.111876\n", + " 372541.004296\n", + " 418355.425750\n", + " 418391.701423\n", + " -36.275673\n", + " -0.000087\n", " \n", " \n", " 42\n", " 2067\n", - " 23261\n", - " 583580\n", - " 3099017.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 385266.544939\n", - " 357229.405339\n", - " 389448.072900\n", - " 382553.140857\n", - " 367803.054399\n", - " 375480.781577\n", - " 376740.673312\n", - " -1259.891735\n", - " -0.003344\n", + " 297221.496710\n", + " 272255.281494\n", + " 280888.319603\n", + " 281510.797522\n", + " 281840.507716\n", + " 417412.937075\n", + " 417601.659480\n", + " -188.722404\n", + " -0.000452\n", " \n", " \n", " 43\n", " 2068\n", - " 23318\n", - " 586603\n", - " 3118001.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 444523.181015\n", - " 449728.133273\n", - " 439791.891824\n", - " 438856.705942\n", - " 426322.297655\n", - " 374245.788665\n", - " 375335.534050\n", - " -1089.745385\n", - " -0.002903\n", + " 409016.019784\n", + " 378752.521246\n", + " 360679.750486\n", + " 359521.705424\n", + " 359548.833442\n", + " 414765.010421\n", + " 416813.109359\n", + " -2048.098937\n", + " -0.004914\n", " \n", " \n", " 44\n", " 2069\n", - " 23422\n", - " 588499\n", - " 3133720.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 445720.962431\n", - " 418703.399054\n", - " 431958.526817\n", - " 430211.684701\n", - " 419976.194936\n", - " 379224.450236\n", - " 378005.108376\n", - " 1219.341861\n", - " 0.003226\n", + " 420878.539429\n", + " 445824.370857\n", + " 462306.136722\n", + " 461148.128688\n", + " 461552.424105\n", + " 415927.049193\n", + " 416026.048243\n", + " -98.999050\n", + " -0.000238\n", " \n", " \n", " 45\n", " 2070\n", - " 23609\n", - " 593756\n", - " 3146747.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 400991.290205\n", - " 429393.430690\n", - " 411181.980311\n", - " 405133.787228\n", - " 386202.176410\n", - " 383743.213561\n", - " 381667.545696\n", - " 2075.667865\n", - " 0.005438\n", + " 405718.142702\n", + " 364719.332490\n", + " 323443.731437\n", + " 324834.166014\n", + " 323233.055405\n", + " 412876.186407\n", + " 415240.473322\n", + " -2364.286915\n", + " -0.005694\n", " \n", " \n", "\n", "
" ] }, - "execution_count": 52, + "execution_count": 58, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 52 + "execution_count": 58 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-03T11:37:16.139858Z", - "start_time": "2025-01-03T11:37:14.298561Z" + "end_time": "2025-01-07T15:20:35.922798Z", + "start_time": "2025-01-07T15:20:33.592575Z" } }, "cell_type": "code", "source": [ - "X_Data = pd.read_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/X_basis_weather_filtered_predictions_{scenario}.csv')\n", + "X_Data = pd.read_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/X_basis_weather_filtered_predictions_{scenario}_{model_type}.csv')\n", "X_Data" ], "id": "23e931c4a52c75e0", @@ -3353,17 +2939,17 @@ "data": { "text/plain": [ " 0 1 2 3 4 5 6 7 8 9 \\\n", - "0 318.723452 111.486502 2025.0 1.0 1.0 1.0 0.0 0.0 0.0 1.0 \n", - "1 367.076374 115.202853 2025.0 2.0 1.0 0.0 0.0 1.0 0.0 1.0 \n", - "2 302.196208 76.629523 2025.0 3.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", - "3 546.639789 153.713254 2025.0 4.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", - "4 297.013829 80.416504 2025.0 5.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", + "0 278.839565 104.469566 2025.0 1.0 1.0 1.0 0.0 0.0 0.0 1.0 \n", + "1 314.940604 105.141358 2025.0 2.0 1.0 0.0 0.0 1.0 0.0 1.0 \n", + "2 243.284699 75.971366 2025.0 3.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", + "3 376.344881 171.678366 2025.0 4.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", + "4 310.515664 76.252856 2025.0 5.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", "... ... ... ... ... ... ... ... ... ... ... \n", - "166277 273.660745 102.473417 2070.0 8.0 0.0 0.0 1.0 0.0 0.0 1.0 \n", - "166278 147.334300 60.726971 2070.0 9.0 0.0 0.0 0.0 1.0 0.0 0.0 \n", - "166279 147.334300 60.726971 2070.0 10.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", - "166280 249.590817 83.738491 2070.0 11.0 0.0 0.0 1.0 0.0 0.0 1.0 \n", - "166281 163.427095 90.067341 2070.0 12.0 0.0 0.0 0.0 0.0 0.0 1.0 \n", + "181051 328.073671 113.592252 2070.0 8.0 0.0 0.0 1.0 0.0 0.0 1.0 \n", + "181052 272.709461 99.514648 2070.0 9.0 0.0 0.0 0.0 1.0 0.0 0.0 \n", + "181053 272.709461 99.514648 2070.0 10.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", + "181054 272.737490 79.155316 2070.0 11.0 0.0 0.0 1.0 0.0 0.0 1.0 \n", + "181055 175.643851 76.903689 2070.0 12.0 0.0 0.0 0.0 0.0 0.0 1.0 \n", "\n", " ... 344 345 346 347 348 349 350 351 352 353 \n", "0 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 1099.0 0.084097 \n", @@ -3372,13 +2958,13 @@ "3 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 873.0 NaN \n", "4 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 873.0 NaN \n", "... ... ... ... ... ... ... ... ... ... ... ... \n", - "166277 ... 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0 485.0 0.162431 \n", - "166278 ... 0.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 508.0 0.116303 \n", - "166279 ... 0.0 0.0 0.0 0.0 0.0 1.0 0.0 0.0 873.0 NaN \n", - "166280 ... 0.0 0.0 0.0 0.0 0.0 0.0 1.0 0.0 1149.0 0.233156 \n", - "166281 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 1.0 873.0 0.098121 \n", + "181051 ... 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0 485.0 0.162431 \n", + "181052 ... 0.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 508.0 0.116303 \n", + "181053 ... 0.0 0.0 0.0 0.0 0.0 1.0 0.0 0.0 873.0 NaN \n", + "181054 ... 0.0 0.0 0.0 0.0 0.0 0.0 1.0 0.0 1149.0 0.233156 \n", + "181055 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 1.0 873.0 0.098121 \n", "\n", - "[166282 rows x 354 columns]" + "[181056 rows x 354 columns]" ], "text/html": [ "
\n", @@ -3425,8 +3011,8 @@ " \n", " \n", " 0\n", - " 318.723452\n", - " 111.486502\n", + " 278.839565\n", + " 104.469566\n", " 2025.0\n", " 1.0\n", " 1.0\n", @@ -3449,8 +3035,8 @@ " \n", " \n", " 1\n", - " 367.076374\n", - " 115.202853\n", + " 314.940604\n", + " 105.141358\n", " 2025.0\n", " 2.0\n", " 1.0\n", @@ -3473,8 +3059,8 @@ " \n", " \n", " 2\n", - " 302.196208\n", - " 76.629523\n", + " 243.284699\n", + " 75.971366\n", " 2025.0\n", " 3.0\n", " 0.0\n", @@ -3497,8 +3083,8 @@ " \n", " \n", " 3\n", - " 546.639789\n", - " 153.713254\n", + " 376.344881\n", + " 171.678366\n", " 2025.0\n", " 4.0\n", " 0.0\n", @@ -3521,8 +3107,8 @@ " \n", " \n", " 4\n", - " 297.013829\n", - " 80.416504\n", + " 310.515664\n", + " 76.252856\n", " 2025.0\n", " 5.0\n", " 0.0\n", @@ -3568,9 +3154,9 @@ " ...\n", " \n", " \n", - " 166277\n", - " 273.660745\n", - " 102.473417\n", + " 181051\n", + " 328.073671\n", + " 113.592252\n", " 2070.0\n", " 8.0\n", " 0.0\n", @@ -3592,9 +3178,9 @@ " 0.162431\n", " \n", " \n", - " 166278\n", - " 147.334300\n", - " 60.726971\n", + " 181052\n", + " 272.709461\n", + " 99.514648\n", " 2070.0\n", " 9.0\n", " 0.0\n", @@ -3616,9 +3202,9 @@ " 0.116303\n", " \n", " \n", - " 166279\n", - " 147.334300\n", - " 60.726971\n", + " 181053\n", + " 272.709461\n", + " 99.514648\n", " 2070.0\n", " 10.0\n", " 0.0\n", @@ -3640,9 +3226,9 @@ " NaN\n", " \n", " \n", - " 166280\n", - " 249.590817\n", - " 83.738491\n", + " 181054\n", + " 272.737490\n", + " 79.155316\n", " 2070.0\n", " 11.0\n", " 0.0\n", @@ -3664,9 +3250,9 @@ " 0.233156\n", " \n", " \n", - " 166281\n", - " 163.427095\n", - " 90.067341\n", + " 181055\n", + " 175.643851\n", + " 76.903689\n", " 2070.0\n", " 12.0\n", " 0.0\n", @@ -3689,22 +3275,22 @@ " \n", " \n", "\n", - "

166282 rows × 354 columns

\n", + "

181056 rows × 354 columns

\n", "
" ] }, - "execution_count": 53, + "execution_count": 59, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 53 + "execution_count": 59 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-03T11:37:16.149964Z", - "start_time": "2025-01-03T11:37:16.144056Z" + "end_time": "2025-01-07T15:20:39.426328Z", + "start_time": "2025-01-07T15:20:39.421298Z" } }, "cell_type": "code", @@ -3719,13 +3305,13 @@ ], "id": "fd6b107fed0933cb", "outputs": [], - "execution_count": 54 + "execution_count": 60 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-03T11:37:16.175671Z", - "start_time": "2025-01-03T11:37:16.152005Z" + "end_time": "2025-01-07T15:20:40.500895Z", + "start_time": "2025-01-07T15:20:40.462242Z" } }, "cell_type": "code", @@ -3736,52 +3322,52 @@ "data": { "text/plain": [ " Year Month Facility_ID Altitude \\\n", - "0 2025 23814 599734 3182595.0 \n", - "1 2026 22590 566009 3008054.0 \n", - "2 2027 24474 614678 3269771.0 \n", - "3 2028 23968 600596 3207601.0 \n", - "4 2029 23330 583610 3116929.0 \n", - "5 2030 24073 605374 3226700.0 \n", - "6 2031 23580 593098 3161559.0 \n", - "7 2032 23000 576874 3067975.0 \n", - "8 2033 23581 593277 3157142.0 \n", - "9 2034 24459 614471 3272543.0 \n", - "10 2035 24070 601705 3227338.0 \n", - "11 2036 22412 563438 2989556.0 \n", - "12 2037 23224 583884 3111738.0 \n", - "13 2038 23088 581270 3091620.0 \n", - "14 2039 23796 598440 3178339.0 \n", - "15 2040 24867 625341 3333272.0 \n", - "16 2041 23418 588798 3126883.0 \n", - "17 2042 24483 614818 3264448.0 \n", - "18 2043 22584 568163 3020289.0 \n", - "19 2044 23377 588639 3133986.0 \n", - "20 2045 23817 599233 3190091.0 \n", - "21 2046 24583 616970 3286711.0 \n", - "22 2047 22492 563400 2990632.0 \n", - "23 2048 23857 599713 3190814.0 \n", - "24 2049 23922 602508 3200414.0 \n", - "25 2050 23672 596141 3153492.0 \n", - "26 2051 23898 601388 3209981.0 \n", - "27 2052 23496 591222 3151911.0 \n", - "28 2053 24894 627569 3335143.0 \n", - "29 2054 21946 552383 2937089.0 \n", - "30 2055 23076 579568 3072851.0 \n", - "31 2056 23967 601469 3194980.0 \n", - "32 2057 23389 588821 3139033.0 \n", - "33 2058 22093 555609 2950853.0 \n", - "34 2059 23733 596624 3169901.0 \n", - "35 2060 23173 582978 3100047.0 \n", - "36 2061 23689 595156 3162324.0 \n", - "37 2062 22794 574103 3036727.0 \n", - "38 2063 22722 573325 3024141.0 \n", - "39 2064 23581 590848 3149704.0 \n", - "40 2065 23523 591233 3157907.0 \n", - "41 2066 22993 578310 3065123.0 \n", - "42 2067 23261 583580 3099017.0 \n", - "43 2068 23318 586603 3118001.0 \n", - "44 2069 23422 588499 3133720.0 \n", - "45 2070 23609 593756 3146747.0 \n", + "0 2025 25584 643536 3435564.0 \n", + "1 2026 25584 643536 3435564.0 \n", + "2 2027 25584 643536 3435564.0 \n", + "3 2028 25584 643536 3435564.0 \n", + "4 2029 25584 643536 3435564.0 \n", + "5 2030 25584 643536 3435564.0 \n", + "6 2031 25584 643536 3435564.0 \n", + "7 2032 25584 643536 3435564.0 \n", + "8 2033 25584 643536 3435564.0 \n", + "9 2034 25584 643536 3435564.0 \n", + "10 2035 25584 643536 3435564.0 \n", + "11 2036 25584 643536 3435564.0 \n", + "12 2037 25584 643536 3435564.0 \n", + "13 2038 25584 643536 3435564.0 \n", + "14 2039 25584 643536 3435564.0 \n", + "15 2040 25584 643536 3435564.0 \n", + "16 2041 25584 643536 3435564.0 \n", + "17 2042 25584 643536 3435564.0 \n", + "18 2043 25584 643536 3435564.0 \n", + "19 2044 25584 643536 3435564.0 \n", + "20 2045 25584 643536 3435564.0 \n", + "21 2046 25584 643536 3435564.0 \n", + "22 2047 25584 643536 3435564.0 \n", + "23 2048 25584 643536 3435564.0 \n", + "24 2049 25584 643536 3435564.0 \n", + "25 2050 25584 643536 3435564.0 \n", + "26 2051 25584 643536 3435564.0 \n", + "27 2052 25584 643536 3435564.0 \n", + "28 2053 25584 643536 3435564.0 \n", + "29 2054 25584 643536 3435564.0 \n", + "30 2055 25584 643536 3435564.0 \n", + "31 2056 25584 643536 3435564.0 \n", + "32 2057 25584 643536 3435564.0 \n", + "33 2058 25584 643536 3435564.0 \n", + "34 2059 25584 643536 3435564.0 \n", + "35 2060 25584 643536 3435564.0 \n", + "36 2061 25584 643536 3435564.0 \n", + "37 2062 25584 643536 3435564.0 \n", + "38 2063 25584 643536 3435564.0 \n", + "39 2064 25584 643536 3435564.0 \n", + "40 2065 25584 643536 3435564.0 \n", + "41 2066 25584 643536 3435564.0 \n", + "42 2067 25584 643536 3435564.0 \n", + "43 2068 25584 643536 3435564.0 \n", + "44 2069 25584 643536 3435564.0 \n", + "45 2070 25584 643536 3435564.0 \n", "\n", " Zone \\\n", "0 Central WestSouth EastNorthernSouth EastNorthe... \n", @@ -3928,196 +3514,196 @@ "45 GovernmentGovernmentGovernmentGovernmentGovern... \n", "\n", " Facility_Type Precipitation \\\n", - "0 ClinicDistrict HospitalRural/Community Hospita... 356930.256793 \n", - "1 ClinicDistrict HospitalRural/Community Hospita... 442012.194055 \n", - "2 ClinicDistrict HospitalRural/Community Hospita... 401910.341187 \n", - "3 ClinicDistrict HospitalRural/Community Hospita... 458028.122792 \n", - "4 ClinicDistrict HospitalRural/Community Hospita... 406191.851826 \n", - "5 ClinicDistrict HospitalRural/Community Hospita... 409387.038984 \n", - "6 ClinicDistrict HospitalRural/Community Hospita... 400600.129109 \n", - "7 ClinicDistrict HospitalRural/Community Hospita... 447521.070185 \n", - "8 ClinicDistrict HospitalRural/Community Hospita... 456815.880827 \n", - "9 ClinicDistrict HospitalRural/Community Hospita... 443520.485079 \n", - "10 ClinicDistrict HospitalRural/Community Hospita... 411313.075371 \n", - "11 ClinicDistrict HospitalRural/Community Hospita... 401467.863756 \n", - "12 ClinicDistrict HospitalRural/Community Hospita... 419545.873961 \n", - "13 ClinicDistrict HospitalRural/Community Hospita... 463682.059169 \n", - "14 ClinicDistrict HospitalRural/Community Hospita... 439471.811655 \n", - "15 ClinicDistrict HospitalRural/Community Hospita... 451058.889825 \n", - "16 ClinicDistrict HospitalRural/Community Hospita... 364816.739985 \n", - "17 ClinicDistrict HospitalRural/Community Hospita... 474909.052258 \n", - "18 ClinicDistrict HospitalRural/Community Hospita... 437730.151447 \n", - "19 ClinicDistrict HospitalRural/Community Hospita... 467117.570232 \n", - "20 ClinicDistrict HospitalRural/Community Hospita... 398139.357152 \n", - "21 ClinicDistrict HospitalRural/Community Hospita... 443421.655978 \n", - "22 ClinicDistrict HospitalRural/Community Hospita... 494553.446600 \n", - "23 ClinicDistrict HospitalRural/Community Hospita... 472153.619753 \n", - "24 ClinicDistrict HospitalRural/Community Hospita... 465094.209967 \n", - "25 ClinicDistrict HospitalRural/Community Hospita... 452834.779144 \n", - "26 ClinicDistrict HospitalRural/Community Hospita... 460721.942570 \n", - "27 ClinicDistrict HospitalRural/Community Hospita... 309639.446977 \n", - "28 ClinicDistrict HospitalRural/Community Hospita... 332821.767357 \n", - "29 ClinicDistrict HospitalRural/Community Hospita... 418144.175624 \n", - "30 ClinicDistrict HospitalRural/Community Hospita... 300680.970171 \n", - "31 ClinicDistrict HospitalRural/Community Hospita... 461243.283456 \n", - "32 ClinicDistrict HospitalRural/Community Hospita... 379993.626328 \n", - "33 ClinicDistrict HospitalRural/Community Hospita... 381230.056855 \n", - "34 ClinicDistrict HospitalRural/Community Hospita... 501263.956015 \n", - "35 ClinicDistrict HospitalRural/Community Hospita... 459757.304011 \n", - "36 ClinicDistrict HospitalRural/Community Hospita... 403898.123577 \n", - "37 ClinicDistrict HospitalRural/Community Hospita... 468021.236699 \n", - "38 ClinicDistrict HospitalRural/Community Hospita... 414958.264565 \n", - "39 ClinicDistrict HospitalRural/Community Hospita... 441414.054493 \n", - "40 ClinicDistrict HospitalRural/Community Hospita... 433793.080907 \n", - "41 ClinicDistrict HospitalRural/Community Hospita... 358327.837808 \n", - "42 ClinicDistrict HospitalRural/Community Hospita... 385266.544939 \n", - "43 ClinicDistrict HospitalRural/Community Hospita... 444523.181015 \n", - "44 ClinicDistrict HospitalRural/Community Hospita... 445720.962431 \n", - "45 ClinicDistrict HospitalRural/Community Hospita... 400991.290205 \n", + "0 ClinicDistrict HospitalRural/Community Hospita... 370655.578345 \n", + "1 ClinicDistrict HospitalRural/Community Hospita... 305845.723518 \n", + "2 ClinicDistrict HospitalRural/Community Hospita... 380236.133055 \n", + "3 ClinicDistrict HospitalRural/Community Hospita... 396234.125976 \n", + "4 ClinicDistrict HospitalRural/Community Hospita... 317163.607434 \n", + "5 ClinicDistrict HospitalRural/Community Hospita... 385409.189618 \n", + "6 ClinicDistrict HospitalRural/Community Hospita... 406289.858606 \n", + "7 ClinicDistrict HospitalRural/Community Hospita... 333604.956760 \n", + "8 ClinicDistrict HospitalRural/Community Hospita... 322006.856259 \n", + "9 ClinicDistrict HospitalRural/Community Hospita... 391560.967791 \n", + "10 ClinicDistrict HospitalRural/Community Hospita... 367661.767185 \n", + "11 ClinicDistrict HospitalRural/Community Hospita... 378095.303002 \n", + "12 ClinicDistrict HospitalRural/Community Hospita... 374197.949271 \n", + "13 ClinicDistrict HospitalRural/Community Hospita... 374291.695816 \n", + "14 ClinicDistrict HospitalRural/Community Hospita... 398962.867137 \n", + "15 ClinicDistrict HospitalRural/Community Hospita... 329938.705708 \n", + "16 ClinicDistrict HospitalRural/Community Hospita... 349982.489824 \n", + "17 ClinicDistrict HospitalRural/Community Hospita... 265019.061881 \n", + "18 ClinicDistrict HospitalRural/Community Hospita... 317116.288589 \n", + "19 ClinicDistrict HospitalRural/Community Hospita... 358615.638348 \n", + "20 ClinicDistrict HospitalRural/Community Hospita... 441360.716573 \n", + "21 ClinicDistrict HospitalRural/Community Hospita... 485128.815221 \n", + "22 ClinicDistrict HospitalRural/Community Hospita... 339348.499913 \n", + "23 ClinicDistrict HospitalRural/Community Hospita... 353296.312971 \n", + "24 ClinicDistrict HospitalRural/Community Hospita... 333745.253478 \n", + "25 ClinicDistrict HospitalRural/Community Hospita... 513923.146927 \n", + "26 ClinicDistrict HospitalRural/Community Hospita... 271825.288644 \n", + "27 ClinicDistrict HospitalRural/Community Hospita... 365895.719222 \n", + "28 ClinicDistrict HospitalRural/Community Hospita... 325208.687060 \n", + "29 ClinicDistrict HospitalRural/Community Hospita... 382143.812346 \n", + "30 ClinicDistrict HospitalRural/Community Hospita... 287994.569053 \n", + "31 ClinicDistrict HospitalRural/Community Hospita... 332374.359974 \n", + "32 ClinicDistrict HospitalRural/Community Hospita... 392877.314013 \n", + "33 ClinicDistrict HospitalRural/Community Hospita... 302066.178485 \n", + "34 ClinicDistrict HospitalRural/Community Hospita... 327708.324530 \n", + "35 ClinicDistrict HospitalRural/Community Hospita... 309435.437644 \n", + "36 ClinicDistrict HospitalRural/Community Hospita... 320279.427886 \n", + "37 ClinicDistrict HospitalRural/Community Hospita... 330832.389669 \n", + "38 ClinicDistrict HospitalRural/Community Hospita... 435362.126119 \n", + "39 ClinicDistrict HospitalRural/Community Hospita... 304940.147499 \n", + "40 ClinicDistrict HospitalRural/Community Hospita... 353974.887443 \n", + "41 ClinicDistrict HospitalRural/Community Hospita... 295464.487169 \n", + "42 ClinicDistrict HospitalRural/Community Hospita... 297221.496710 \n", + "43 ClinicDistrict HospitalRural/Community Hospita... 409016.019784 \n", + "44 ClinicDistrict HospitalRural/Community Hospita... 420878.539429 \n", + "45 ClinicDistrict HospitalRural/Community Hospita... 405718.142702 \n", "\n", " Lag_1_Precipitation Lag_2_Precipitation Lag_3_Precipitation \\\n", - "0 294609.145696 251778.819911 240074.691709 \n", - "1 397157.668329 397273.347895 348266.651361 \n", - "2 414186.725872 420900.694753 423488.413324 \n", - "3 454173.805476 433342.964932 425159.752149 \n", - "4 439691.054081 445950.755762 418870.421666 \n", - "5 389364.247808 392455.710835 397461.356243 \n", - "6 392631.249314 374449.656015 373894.307761 \n", - "7 402914.631768 394545.775941 380305.249049 \n", - "8 498011.574391 475942.063738 466685.963435 \n", - "9 441306.486897 449381.026641 430634.351876 \n", - "10 461142.612330 444654.932360 434587.827755 \n", - "11 357763.087422 364775.944769 347716.667867 \n", - "12 416541.339977 409043.550166 391920.926233 \n", - "13 442526.600924 451303.450407 456286.448435 \n", - "14 486171.696867 502289.466180 498044.017229 \n", - "15 431633.402209 402153.409212 398040.518931 \n", - "16 335208.786306 354775.001534 338447.362232 \n", - "17 506841.062275 463684.071161 461858.642099 \n", - "18 415617.644419 410420.270555 407615.216190 \n", - "19 486817.869497 480637.195403 474544.770943 \n", - "20 362850.193582 402219.531548 399839.624296 \n", - "21 468076.690976 465542.221447 467423.630271 \n", - "22 444767.223650 409485.605985 387260.946000 \n", - "23 503414.718730 491261.349692 495127.838946 \n", - "24 455038.002255 477898.743986 469420.838584 \n", - "25 465973.024854 462746.331497 425762.806114 \n", - "26 407556.892301 401004.293570 421749.445065 \n", - "27 390992.045894 420441.094988 413192.196815 \n", - "28 320904.427223 316776.074425 316292.885898 \n", - "29 404366.782226 391164.519869 373727.874006 \n", - "30 346289.174108 340245.279011 329299.172958 \n", - "31 391853.983192 387762.882037 372651.645513 \n", - "32 421170.962261 417222.716525 405927.199113 \n", - "33 354587.101006 350957.265087 326505.718272 \n", - "34 490253.713022 477610.230551 460159.597378 \n", - "35 436835.494548 419958.086643 435515.915955 \n", - "36 446026.892969 459573.706453 436904.851847 \n", - "37 450100.730558 416050.220079 373748.278834 \n", - "38 415976.330050 443797.927964 453085.545667 \n", - "39 435767.269524 415051.021426 406769.043607 \n", - "40 435494.327000 421305.379992 408124.267918 \n", - "41 382545.188235 359818.742372 354980.088513 \n", - "42 357229.405339 389448.072900 382553.140857 \n", - "43 449728.133273 439791.891824 438856.705942 \n", - "44 418703.399054 431958.526817 430211.684701 \n", - "45 429393.430690 411181.980311 405133.787228 \n", + "0 298710.995438 260619.466056 255428.892934 \n", + "1 324216.805408 351108.236956 352944.118983 \n", + "2 351903.960266 349493.164255 344770.234996 \n", + "3 379492.789825 375543.857029 381029.229862 \n", + "4 375481.180687 385373.062799 381129.073629 \n", + "5 311938.841921 285932.285061 289579.937651 \n", + "6 433698.584038 455288.388297 455102.702313 \n", + "7 315844.250082 324314.368396 316195.532608 \n", + "8 371283.829234 345593.426372 354934.926046 \n", + "9 399207.341834 400410.349670 392246.728746 \n", + "10 341985.164411 327819.997189 330789.556355 \n", + "11 398497.779822 408894.912655 378604.565588 \n", + "12 348875.547726 360367.235995 389923.203199 \n", + "13 370981.253838 381170.945543 378471.104964 \n", + "14 394083.987840 401617.097706 408341.613660 \n", + "15 344469.424679 340683.245254 342518.356804 \n", + "16 331135.927791 335947.246630 335248.047067 \n", + "17 328321.508621 302510.901036 300226.263604 \n", + "18 252246.251731 271260.885375 274124.334082 \n", + "19 410050.158172 387974.439450 387736.897200 \n", + "20 369108.855991 362046.586240 342819.132014 \n", + "21 482869.984890 480685.090489 500151.794189 \n", + "22 419334.638122 449504.867423 447116.625283 \n", + "23 317922.916948 310749.912224 313141.518581 \n", + "24 325481.247456 336295.941280 330700.546457 \n", + "25 502910.647286 435891.016355 437939.836711 \n", + "26 325017.559932 392209.231985 393915.875687 \n", + "27 355003.796484 335224.704315 335946.670289 \n", + "28 360724.744731 376450.353321 368811.709372 \n", + "29 329764.214376 325974.066284 334512.344383 \n", + "30 331417.631119 333207.967531 331162.787180 \n", + "31 265016.427098 267520.943494 269888.025290 \n", + "32 457908.115607 448849.771066 446651.780946 \n", + "33 278375.606401 291501.477315 289945.485496 \n", + "34 318063.470421 302154.611762 306083.376401 \n", + "35 327543.125082 336866.204386 331980.842360 \n", + "36 330945.691553 322432.738606 318079.159985 \n", + "37 285321.675202 301954.830856 310662.088357 \n", + "38 433776.704399 419118.260070 404772.957169 \n", + "39 317030.377297 304945.762400 319651.502857 \n", + "40 329874.956467 337015.684029 328940.852077 \n", + "41 354202.699889 365879.087584 373323.111876 \n", + "42 272255.281494 280888.319603 281510.797522 \n", + "43 378752.521246 360679.750486 359521.705424 \n", + "44 445824.370857 462306.136722 461148.128688 \n", + "45 364719.332490 323443.731437 324834.166014 \n", "\n", " Lag_4_Precipitation Predicted_Weather_Model Predicted_No_Weather_Model \\\n", - "0 212611.355306 262073.177045 414580.859514 \n", - "1 329607.014297 391897.166673 394712.494598 \n", - "2 427242.313426 424216.303078 426507.644233 \n", - "3 409583.757336 418663.778757 419005.094793 \n", - "4 404708.312917 405721.982368 407774.686109 \n", - "5 389452.051202 422077.382352 421235.583604 \n", - "6 361847.942122 406625.933041 406869.091856 \n", - "7 367935.056473 390456.768764 393982.523859 \n", - "8 443793.819493 404036.109552 407105.988595 \n", - "9 428705.248932 419086.106241 421792.859293 \n", - "10 424916.410268 414353.849683 416718.943844 \n", - "11 321868.628640 379822.724678 383326.342849 \n", - "12 378814.601365 396472.620305 397095.249567 \n", - "13 441830.397786 392687.251512 394380.103735 \n", - "14 485302.039523 402985.471692 406826.384026 \n", - "15 371349.124368 425017.218302 426405.341430 \n", - "16 321940.022061 397017.066601 399458.496395 \n", - "17 454618.554156 416691.544445 416997.757878 \n", - "18 384771.629007 383660.669690 383755.734156 \n", - "19 455304.239249 394673.545565 394754.939189 \n", - "20 377344.967272 401135.309503 402985.317847 \n", - "21 464577.255028 412242.557813 413773.489936 \n", - "22 360098.331291 372146.903936 375589.196357 \n", - "23 485805.294721 401945.091876 402709.253238 \n", - "24 440243.139280 398685.865173 401567.430428 \n", - "25 427139.769513 399252.955628 398635.670647 \n", - "26 405452.318421 400477.291574 400608.907041 \n", - "27 409041.464387 390999.580252 392078.841473 \n", - "28 306048.398243 416471.045063 418092.099246 \n", - "29 343975.955350 360207.713252 364273.522362 \n", - "30 309663.520488 379799.778479 382254.450494 \n", - "31 355108.240357 389694.500461 393327.366843 \n", - "32 379013.465979 382707.973900 382588.827454 \n", - "33 294446.256154 361165.891802 361939.932800 \n", - "34 444568.857000 389684.514691 391135.437740 \n", - "35 425013.325154 383317.152377 381266.519178 \n", - "36 419966.747362 390113.556785 387064.014493 \n", - "37 351040.543393 372856.397814 373879.275648 \n", - "38 444035.139054 367768.692199 368187.001270 \n", - "39 396642.228590 378200.181200 380644.486568 \n", - "40 399546.170001 383210.897923 380769.053462 \n", - "41 342669.140660 373477.131153 373664.729920 \n", - "42 367803.054399 375480.781577 376740.673312 \n", - "43 426322.297655 374245.788665 375335.534050 \n", - "44 419976.194936 379224.450236 378005.108376 \n", - "45 386202.176410 383743.213561 381667.545696 \n", + "0 253508.982217 301084.510508 452103.379475 \n", + "1 353891.586301 448829.801850 451249.680342 \n", + "2 345157.532117 450130.102782 450397.593235 \n", + "3 379415.048009 446465.064103 449547.115109 \n", + "4 382864.345741 446875.456426 448698.242927 \n", + "5 289345.079079 445094.075488 447850.973656 \n", + "6 455034.373344 443152.899063 447005.304268 \n", + "7 314871.921748 445109.242713 446161.231744 \n", + "8 356543.998012 444390.632491 445318.753068 \n", + "9 391937.348081 443363.169753 444477.865230 \n", + "10 329650.101725 441484.287781 443638.565226 \n", + "11 379596.718666 443252.418520 442800.850059 \n", + "12 389558.939179 440302.572113 441964.716734 \n", + "13 377682.655534 441220.746519 441130.162266 \n", + "14 409745.578729 442599.508715 440297.183673 \n", + "15 341977.330400 437729.663871 439465.777979 \n", + "16 335789.435760 435203.049238 438635.942214 \n", + "17 296296.047432 436957.723991 437807.673415 \n", + "18 278184.608227 434305.862192 436980.968621 \n", + "19 387661.416146 434323.547929 436155.824879 \n", + "20 340516.424995 434015.417381 435332.239243 \n", + "21 502277.800794 434856.288139 434510.208770 \n", + "22 445805.292269 435279.971776 433689.730522 \n", + "23 313923.715557 430636.491081 432870.801570 \n", + "24 330244.876504 430911.874972 432053.418987 \n", + "25 438231.552425 428660.978812 431237.579854 \n", + "26 393957.931607 430121.833314 430423.281257 \n", + "27 336884.175544 427569.904956 429610.520285 \n", + "28 365595.615071 427736.660883 428799.294036 \n", + "29 337541.046047 425208.288593 427989.599612 \n", + "30 331449.273326 426741.194309 427181.434120 \n", + "31 269433.014822 425551.827998 426374.794674 \n", + "32 445524.032754 424893.403624 425569.678390 \n", + "33 291038.100935 423223.667713 424766.082395 \n", + "34 305678.254498 422131.112511 423964.003816 \n", + "35 330169.889911 421573.506857 423163.439788 \n", + "36 317973.894415 422575.707068 422364.387452 \n", + "37 312810.479228 420956.703710 421566.843952 \n", + "38 405190.542219 418934.469956 420770.806441 \n", + "39 319575.723877 419086.943369 419976.272074 \n", + "40 329238.343810 418729.313756 419183.238012 \n", + "41 372541.004296 418355.425750 418391.701423 \n", + "42 281840.507716 417412.937075 417601.659480 \n", + "43 359548.833442 414765.010421 416813.109359 \n", + "44 461552.424105 415927.049193 416026.048243 \n", + "45 323233.055405 412876.186407 415240.473322 \n", "\n", " Difference_in_Expectation Percentage_Difference \n", - "0 -1806.379897 -0.004357 \n", - "1 -2815.327925 -0.007133 \n", - "2 -2291.341155 -0.005372 \n", - "3 -341.316036 -0.000815 \n", - "4 -2052.703741 -0.005034 \n", - "5 841.798749 0.001998 \n", - "6 -243.158815 -0.000598 \n", - "7 -3525.755094 -0.008949 \n", - "8 -3069.879043 -0.007541 \n", - "9 -2706.753053 -0.006417 \n", - "10 -2365.094162 -0.005676 \n", - "11 -3503.618171 -0.009140 \n", - "12 -622.629263 -0.001568 \n", - "13 -1692.852223 -0.004292 \n", - "14 -3840.912333 -0.009441 \n", - "15 -1388.123129 -0.003255 \n", - "16 -2441.429794 -0.006112 \n", - "17 -306.213433 -0.000734 \n", - "18 -95.064467 -0.000248 \n", - "19 -81.393624 -0.000206 \n", - "20 -1850.008344 -0.004591 \n", - "21 -1530.932123 -0.003700 \n", - "22 -3442.292421 -0.009165 \n", - "23 -764.161361 -0.001898 \n", - "24 -2881.565255 -0.007176 \n", - "25 617.284980 0.001548 \n", - "26 -131.615467 -0.000329 \n", - "27 -1079.261220 -0.002753 \n", - "28 -1621.054183 -0.003877 \n", - "29 -4065.809111 -0.011161 \n", - "30 -2454.672016 -0.006422 \n", - "31 -3632.866382 -0.009236 \n", - "32 119.146445 0.000311 \n", - "33 -774.040998 -0.002139 \n", - "34 -1450.923049 -0.003710 \n", - "35 2050.633200 0.005378 \n", - "36 3049.542292 0.007879 \n", - "37 -1022.877835 -0.002736 \n", - "38 -418.309071 -0.001136 \n", - "39 -2444.305368 -0.006421 \n", - "40 2441.844461 0.006413 \n", - "41 -187.598767 -0.000502 \n", - "42 -1259.891735 -0.003344 \n", - "43 -1089.745385 -0.002903 \n", - "44 1219.341861 0.003226 \n", - "45 2075.667865 0.005438 " + "0 -317.566395 -0.000702 \n", + "1 -2419.878492 -0.005363 \n", + "2 -267.490453 -0.000594 \n", + "3 -3082.051006 -0.006856 \n", + "4 -1822.786501 -0.004062 \n", + "5 -2756.898168 -0.006156 \n", + "6 -3852.405205 -0.008618 \n", + "7 -1051.989032 -0.002358 \n", + "8 -928.120577 -0.002084 \n", + "9 -1114.695477 -0.002508 \n", + "10 -2154.277446 -0.004856 \n", + "11 451.568461 0.001020 \n", + "12 -1662.144621 -0.003761 \n", + "13 90.584253 0.000205 \n", + "14 2302.325042 0.005229 \n", + "15 -1736.114108 -0.003951 \n", + "16 -3432.892977 -0.007826 \n", + "17 -849.949424 -0.001941 \n", + "18 -2675.106429 -0.006122 \n", + "19 -1832.276951 -0.004201 \n", + "20 -1316.821862 -0.003025 \n", + "21 346.079370 0.000796 \n", + "22 1590.241254 0.003667 \n", + "23 -2234.310489 -0.005162 \n", + "24 -1141.544015 -0.002642 \n", + "25 -2576.601042 -0.005975 \n", + "26 -301.447942 -0.000700 \n", + "27 -2040.615329 -0.004750 \n", + "28 -1062.633153 -0.002478 \n", + "29 -2781.311019 -0.006499 \n", + "30 -440.239811 -0.001031 \n", + "31 -822.966676 -0.001930 \n", + "32 -676.274766 -0.001589 \n", + "33 -1542.414682 -0.003631 \n", + "34 -1832.891305 -0.004323 \n", + "35 -1589.932931 -0.003757 \n", + "36 211.319617 0.000500 \n", + "37 -610.140243 -0.001447 \n", + "38 -1836.336485 -0.004364 \n", + "39 -889.328705 -0.002118 \n", + "40 -453.924256 -0.001083 \n", + "41 -36.275673 -0.000087 \n", + "42 -188.722404 -0.000452 \n", + "43 -2048.098937 -0.004914 \n", + "44 -98.999050 -0.000238 \n", + "45 -2364.286915 -0.005694 " ], "text/html": [ "
\n", @@ -4161,940 +3747,940 @@ " \n", " 0\n", " 2025\n", - " 23814\n", - " 599734\n", - " 3182595.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 356930.256793\n", - " 294609.145696\n", - " 251778.819911\n", - " 240074.691709\n", - " 212611.355306\n", - " 262073.177045\n", - " 414580.859514\n", - " -1806.379897\n", - " -0.004357\n", + " 370655.578345\n", + " 298710.995438\n", + " 260619.466056\n", + " 255428.892934\n", + " 253508.982217\n", + " 301084.510508\n", + " 452103.379475\n", + " -317.566395\n", + " -0.000702\n", " \n", " \n", " 1\n", " 2026\n", - " 22590\n", - " 566009\n", - " 3008054.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 442012.194055\n", - " 397157.668329\n", - " 397273.347895\n", - " 348266.651361\n", - " 329607.014297\n", - " 391897.166673\n", - " 394712.494598\n", - " -2815.327925\n", - " -0.007133\n", + " 305845.723518\n", + " 324216.805408\n", + " 351108.236956\n", + " 352944.118983\n", + " 353891.586301\n", + " 448829.801850\n", + " 451249.680342\n", + " -2419.878492\n", + " -0.005363\n", " \n", " \n", " 2\n", " 2027\n", - " 24474\n", - " 614678\n", - " 3269771.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 401910.341187\n", - " 414186.725872\n", - " 420900.694753\n", - " 423488.413324\n", - " 427242.313426\n", - " 424216.303078\n", - " 426507.644233\n", - " -2291.341155\n", - " -0.005372\n", + " 380236.133055\n", + " 351903.960266\n", + " 349493.164255\n", + " 344770.234996\n", + " 345157.532117\n", + " 450130.102782\n", + " 450397.593235\n", + " -267.490453\n", + " -0.000594\n", " \n", " \n", " 3\n", " 2028\n", - " 23968\n", - " 600596\n", - " 3207601.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 458028.122792\n", - " 454173.805476\n", - " 433342.964932\n", - " 425159.752149\n", - " 409583.757336\n", - " 418663.778757\n", - " 419005.094793\n", - " -341.316036\n", - " -0.000815\n", + " 396234.125976\n", + " 379492.789825\n", + " 375543.857029\n", + " 381029.229862\n", + " 379415.048009\n", + " 446465.064103\n", + " 449547.115109\n", + " -3082.051006\n", + " -0.006856\n", " \n", " \n", " 4\n", " 2029\n", - " 23330\n", - " 583610\n", - " 3116929.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 406191.851826\n", - " 439691.054081\n", - " 445950.755762\n", - " 418870.421666\n", - " 404708.312917\n", - " 405721.982368\n", - " 407774.686109\n", - " -2052.703741\n", - " -0.005034\n", + " 317163.607434\n", + " 375481.180687\n", + " 385373.062799\n", + " 381129.073629\n", + " 382864.345741\n", + " 446875.456426\n", + " 448698.242927\n", + " -1822.786501\n", + " -0.004062\n", " \n", " \n", " 5\n", " 2030\n", - " 24073\n", - " 605374\n", - " 3226700.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 409387.038984\n", - " 389364.247808\n", - " 392455.710835\n", - " 397461.356243\n", - " 389452.051202\n", - " 422077.382352\n", - " 421235.583604\n", - " 841.798749\n", - " 0.001998\n", + " 385409.189618\n", + " 311938.841921\n", + " 285932.285061\n", + " 289579.937651\n", + " 289345.079079\n", + " 445094.075488\n", + " 447850.973656\n", + " -2756.898168\n", + " -0.006156\n", " \n", " \n", " 6\n", " 2031\n", - " 23580\n", - " 593098\n", - " 3161559.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 400600.129109\n", - " 392631.249314\n", - " 374449.656015\n", - " 373894.307761\n", - " 361847.942122\n", - " 406625.933041\n", - " 406869.091856\n", - " -243.158815\n", - " -0.000598\n", + " 406289.858606\n", + " 433698.584038\n", + " 455288.388297\n", + " 455102.702313\n", + " 455034.373344\n", + " 443152.899063\n", + " 447005.304268\n", + " -3852.405205\n", + " -0.008618\n", " \n", " \n", " 7\n", " 2032\n", - " 23000\n", - " 576874\n", - " 3067975.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 447521.070185\n", - " 402914.631768\n", - " 394545.775941\n", - " 380305.249049\n", - " 367935.056473\n", - " 390456.768764\n", - " 393982.523859\n", - " -3525.755094\n", - " -0.008949\n", + " 333604.956760\n", + " 315844.250082\n", + " 324314.368396\n", + " 316195.532608\n", + " 314871.921748\n", + " 445109.242713\n", + " 446161.231744\n", + " -1051.989032\n", + " -0.002358\n", " \n", " \n", " 8\n", " 2033\n", - " 23581\n", - " 593277\n", - " 3157142.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 456815.880827\n", - " 498011.574391\n", - " 475942.063738\n", - " 466685.963435\n", - " 443793.819493\n", - " 404036.109552\n", - " 407105.988595\n", - " -3069.879043\n", - " -0.007541\n", + " 322006.856259\n", + " 371283.829234\n", + " 345593.426372\n", + " 354934.926046\n", + " 356543.998012\n", + " 444390.632491\n", + " 445318.753068\n", + " -928.120577\n", + " -0.002084\n", " \n", " \n", " 9\n", " 2034\n", - " 24459\n", - " 614471\n", - " 3272543.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 443520.485079\n", - " 441306.486897\n", - " 449381.026641\n", - " 430634.351876\n", - " 428705.248932\n", - " 419086.106241\n", - " 421792.859293\n", - " -2706.753053\n", - " -0.006417\n", + " 391560.967791\n", + " 399207.341834\n", + " 400410.349670\n", + " 392246.728746\n", + " 391937.348081\n", + " 443363.169753\n", + " 444477.865230\n", + " -1114.695477\n", + " -0.002508\n", " \n", " \n", " 10\n", " 2035\n", - " 24070\n", - " 601705\n", - " 3227338.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 411313.075371\n", - " 461142.612330\n", - " 444654.932360\n", - " 434587.827755\n", - " 424916.410268\n", - " 414353.849683\n", - " 416718.943844\n", - " -2365.094162\n", - " -0.005676\n", + " 367661.767185\n", + " 341985.164411\n", + " 327819.997189\n", + " 330789.556355\n", + " 329650.101725\n", + " 441484.287781\n", + " 443638.565226\n", + " -2154.277446\n", + " -0.004856\n", " \n", " \n", " 11\n", " 2036\n", - " 22412\n", - " 563438\n", - " 2989556.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 401467.863756\n", - " 357763.087422\n", - " 364775.944769\n", - " 347716.667867\n", - " 321868.628640\n", - " 379822.724678\n", - " 383326.342849\n", - " -3503.618171\n", - " -0.009140\n", + " 378095.303002\n", + " 398497.779822\n", + " 408894.912655\n", + " 378604.565588\n", + " 379596.718666\n", + " 443252.418520\n", + " 442800.850059\n", + " 451.568461\n", + " 0.001020\n", " \n", " \n", " 12\n", " 2037\n", - " 23224\n", - " 583884\n", - " 3111738.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 419545.873961\n", - " 416541.339977\n", - " 409043.550166\n", - " 391920.926233\n", - " 378814.601365\n", - " 396472.620305\n", - " 397095.249567\n", - " -622.629263\n", - " -0.001568\n", + " 374197.949271\n", + " 348875.547726\n", + " 360367.235995\n", + " 389923.203199\n", + " 389558.939179\n", + " 440302.572113\n", + " 441964.716734\n", + " -1662.144621\n", + " -0.003761\n", " \n", " \n", " 13\n", " 2038\n", - " 23088\n", - " 581270\n", - " 3091620.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 463682.059169\n", - " 442526.600924\n", - " 451303.450407\n", - " 456286.448435\n", - " 441830.397786\n", - " 392687.251512\n", - " 394380.103735\n", - " -1692.852223\n", - " -0.004292\n", + " 374291.695816\n", + " 370981.253838\n", + " 381170.945543\n", + " 378471.104964\n", + " 377682.655534\n", + " 441220.746519\n", + " 441130.162266\n", + " 90.584253\n", + " 0.000205\n", " \n", " \n", " 14\n", " 2039\n", - " 23796\n", - " 598440\n", - " 3178339.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 439471.811655\n", - " 486171.696867\n", - " 502289.466180\n", - " 498044.017229\n", - " 485302.039523\n", - " 402985.471692\n", - " 406826.384026\n", - " -3840.912333\n", - " -0.009441\n", + " 398962.867137\n", + " 394083.987840\n", + " 401617.097706\n", + " 408341.613660\n", + " 409745.578729\n", + " 442599.508715\n", + " 440297.183673\n", + " 2302.325042\n", + " 0.005229\n", " \n", " \n", " 15\n", " 2040\n", - " 24867\n", - " 625341\n", - " 3333272.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 451058.889825\n", - " 431633.402209\n", - " 402153.409212\n", - " 398040.518931\n", - " 371349.124368\n", - " 425017.218302\n", - " 426405.341430\n", - " -1388.123129\n", - " -0.003255\n", + " 329938.705708\n", + " 344469.424679\n", + " 340683.245254\n", + " 342518.356804\n", + " 341977.330400\n", + " 437729.663871\n", + " 439465.777979\n", + " -1736.114108\n", + " -0.003951\n", " \n", " \n", " 16\n", " 2041\n", - " 23418\n", - " 588798\n", - " 3126883.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 364816.739985\n", - " 335208.786306\n", - " 354775.001534\n", - " 338447.362232\n", - " 321940.022061\n", - " 397017.066601\n", - " 399458.496395\n", - " -2441.429794\n", - " -0.006112\n", + " 349982.489824\n", + " 331135.927791\n", + " 335947.246630\n", + " 335248.047067\n", + " 335789.435760\n", + " 435203.049238\n", + " 438635.942214\n", + " -3432.892977\n", + " -0.007826\n", " \n", " \n", " 17\n", " 2042\n", - " 24483\n", - " 614818\n", - " 3264448.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 474909.052258\n", - " 506841.062275\n", - " 463684.071161\n", - " 461858.642099\n", - " 454618.554156\n", - " 416691.544445\n", - " 416997.757878\n", - " -306.213433\n", - " -0.000734\n", + " 265019.061881\n", + " 328321.508621\n", + " 302510.901036\n", + " 300226.263604\n", + " 296296.047432\n", + " 436957.723991\n", + " 437807.673415\n", + " -849.949424\n", + " -0.001941\n", " \n", " \n", " 18\n", " 2043\n", - " 22584\n", - " 568163\n", - " 3020289.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 437730.151447\n", - " 415617.644419\n", - " 410420.270555\n", - " 407615.216190\n", - " 384771.629007\n", - " 383660.669690\n", - " 383755.734156\n", - " -95.064467\n", - " -0.000248\n", + " 317116.288589\n", + " 252246.251731\n", + " 271260.885375\n", + " 274124.334082\n", + " 278184.608227\n", + " 434305.862192\n", + " 436980.968621\n", + " -2675.106429\n", + " -0.006122\n", " \n", " \n", " 19\n", " 2044\n", - " 23377\n", - " 588639\n", - " 3133986.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 467117.570232\n", - " 486817.869497\n", - " 480637.195403\n", - " 474544.770943\n", - " 455304.239249\n", - " 394673.545565\n", - " 394754.939189\n", - " -81.393624\n", - " -0.000206\n", + " 358615.638348\n", + " 410050.158172\n", + " 387974.439450\n", + " 387736.897200\n", + " 387661.416146\n", + " 434323.547929\n", + " 436155.824879\n", + " -1832.276951\n", + " -0.004201\n", " \n", " \n", " 20\n", " 2045\n", - " 23817\n", - " 599233\n", - " 3190091.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 398139.357152\n", - " 362850.193582\n", - " 402219.531548\n", - " 399839.624296\n", - " 377344.967272\n", - " 401135.309503\n", - " 402985.317847\n", - " -1850.008344\n", - " -0.004591\n", + " 441360.716573\n", + " 369108.855991\n", + " 362046.586240\n", + " 342819.132014\n", + " 340516.424995\n", + " 434015.417381\n", + " 435332.239243\n", + " -1316.821862\n", + " -0.003025\n", " \n", " \n", " 21\n", " 2046\n", - " 24583\n", - " 616970\n", - " 3286711.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 443421.655978\n", - " 468076.690976\n", - " 465542.221447\n", - " 467423.630271\n", - " 464577.255028\n", - " 412242.557813\n", - " 413773.489936\n", - " -1530.932123\n", - " -0.003700\n", + " 485128.815221\n", + " 482869.984890\n", + " 480685.090489\n", + " 500151.794189\n", + " 502277.800794\n", + " 434856.288139\n", + " 434510.208770\n", + " 346.079370\n", + " 0.000796\n", " \n", " \n", " 22\n", " 2047\n", - " 22492\n", - " 563400\n", - " 2990632.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 494553.446600\n", - " 444767.223650\n", - " 409485.605985\n", - " 387260.946000\n", - " 360098.331291\n", - " 372146.903936\n", - " 375589.196357\n", - " -3442.292421\n", - " -0.009165\n", + " 339348.499913\n", + " 419334.638122\n", + " 449504.867423\n", + " 447116.625283\n", + " 445805.292269\n", + " 435279.971776\n", + " 433689.730522\n", + " 1590.241254\n", + " 0.003667\n", " \n", " \n", " 23\n", " 2048\n", - " 23857\n", - " 599713\n", - " 3190814.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 472153.619753\n", - " 503414.718730\n", - " 491261.349692\n", - " 495127.838946\n", - " 485805.294721\n", - " 401945.091876\n", - " 402709.253238\n", - " -764.161361\n", - " -0.001898\n", + " 353296.312971\n", + " 317922.916948\n", + " 310749.912224\n", + " 313141.518581\n", + " 313923.715557\n", + " 430636.491081\n", + " 432870.801570\n", + " -2234.310489\n", + " -0.005162\n", " \n", " \n", " 24\n", " 2049\n", - " 23922\n", - " 602508\n", - " 3200414.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 465094.209967\n", - " 455038.002255\n", - " 477898.743986\n", - " 469420.838584\n", - " 440243.139280\n", - " 398685.865173\n", - " 401567.430428\n", - " -2881.565255\n", - " -0.007176\n", + " 333745.253478\n", + " 325481.247456\n", + " 336295.941280\n", + " 330700.546457\n", + " 330244.876504\n", + " 430911.874972\n", + " 432053.418987\n", + " -1141.544015\n", + " -0.002642\n", " \n", " \n", " 25\n", " 2050\n", - " 23672\n", - " 596141\n", - " 3153492.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 452834.779144\n", - " 465973.024854\n", - " 462746.331497\n", - " 425762.806114\n", - " 427139.769513\n", - " 399252.955628\n", - " 398635.670647\n", - " 617.284980\n", - " 0.001548\n", + " 513923.146927\n", + " 502910.647286\n", + " 435891.016355\n", + " 437939.836711\n", + " 438231.552425\n", + " 428660.978812\n", + " 431237.579854\n", + " -2576.601042\n", + " -0.005975\n", " \n", " \n", " 26\n", " 2051\n", - " 23898\n", - " 601388\n", - " 3209981.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 460721.942570\n", - " 407556.892301\n", - " 401004.293570\n", - " 421749.445065\n", - " 405452.318421\n", - " 400477.291574\n", - " 400608.907041\n", - " -131.615467\n", - " -0.000329\n", + " 271825.288644\n", + " 325017.559932\n", + " 392209.231985\n", + " 393915.875687\n", + " 393957.931607\n", + " 430121.833314\n", + " 430423.281257\n", + " -301.447942\n", + " -0.000700\n", " \n", " \n", " 27\n", " 2052\n", - " 23496\n", - " 591222\n", - " 3151911.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 309639.446977\n", - " 390992.045894\n", - " 420441.094988\n", - " 413192.196815\n", - " 409041.464387\n", - " 390999.580252\n", - " 392078.841473\n", - " -1079.261220\n", - " -0.002753\n", + " 365895.719222\n", + " 355003.796484\n", + " 335224.704315\n", + " 335946.670289\n", + " 336884.175544\n", + " 427569.904956\n", + " 429610.520285\n", + " -2040.615329\n", + " -0.004750\n", " \n", " \n", " 28\n", " 2053\n", - " 24894\n", - " 627569\n", - " 3335143.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 332821.767357\n", - " 320904.427223\n", - " 316776.074425\n", - " 316292.885898\n", - " 306048.398243\n", - " 416471.045063\n", - " 418092.099246\n", - " -1621.054183\n", - " -0.003877\n", + " 325208.687060\n", + " 360724.744731\n", + " 376450.353321\n", + " 368811.709372\n", + " 365595.615071\n", + " 427736.660883\n", + " 428799.294036\n", + " -1062.633153\n", + " -0.002478\n", " \n", " \n", " 29\n", " 2054\n", - " 21946\n", - " 552383\n", - " 2937089.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 418144.175624\n", - " 404366.782226\n", - " 391164.519869\n", - " 373727.874006\n", - " 343975.955350\n", - " 360207.713252\n", - " 364273.522362\n", - " -4065.809111\n", - " -0.011161\n", + " 382143.812346\n", + " 329764.214376\n", + " 325974.066284\n", + " 334512.344383\n", + " 337541.046047\n", + " 425208.288593\n", + " 427989.599612\n", + " -2781.311019\n", + " -0.006499\n", " \n", " \n", " 30\n", " 2055\n", - " 23076\n", - " 579568\n", - " 3072851.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 300680.970171\n", - " 346289.174108\n", - " 340245.279011\n", - " 329299.172958\n", - " 309663.520488\n", - " 379799.778479\n", - " 382254.450494\n", - " -2454.672016\n", - " -0.006422\n", + " 287994.569053\n", + " 331417.631119\n", + " 333207.967531\n", + " 331162.787180\n", + " 331449.273326\n", + " 426741.194309\n", + " 427181.434120\n", + " -440.239811\n", + " -0.001031\n", " \n", " \n", " 31\n", " 2056\n", - " 23967\n", - " 601469\n", - " 3194980.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 461243.283456\n", - " 391853.983192\n", - " 387762.882037\n", - " 372651.645513\n", - " 355108.240357\n", - " 389694.500461\n", - " 393327.366843\n", - " -3632.866382\n", - " -0.009236\n", + " 332374.359974\n", + " 265016.427098\n", + " 267520.943494\n", + " 269888.025290\n", + " 269433.014822\n", + " 425551.827998\n", + " 426374.794674\n", + " -822.966676\n", + " -0.001930\n", " \n", " \n", " 32\n", " 2057\n", - " 23389\n", - " 588821\n", - " 3139033.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 379993.626328\n", - " 421170.962261\n", - " 417222.716525\n", - " 405927.199113\n", - " 379013.465979\n", - " 382707.973900\n", - " 382588.827454\n", - " 119.146445\n", - " 0.000311\n", + " 392877.314013\n", + " 457908.115607\n", + " 448849.771066\n", + " 446651.780946\n", + " 445524.032754\n", + " 424893.403624\n", + " 425569.678390\n", + " -676.274766\n", + " -0.001589\n", " \n", " \n", " 33\n", " 2058\n", - " 22093\n", - " 555609\n", - " 2950853.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 381230.056855\n", - " 354587.101006\n", - " 350957.265087\n", - " 326505.718272\n", - " 294446.256154\n", - " 361165.891802\n", - " 361939.932800\n", - " -774.040998\n", - " -0.002139\n", + " 302066.178485\n", + " 278375.606401\n", + " 291501.477315\n", + " 289945.485496\n", + " 291038.100935\n", + " 423223.667713\n", + " 424766.082395\n", + " -1542.414682\n", + " -0.003631\n", " \n", " \n", " 34\n", " 2059\n", - " 23733\n", - " 596624\n", - " 3169901.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 501263.956015\n", - " 490253.713022\n", - " 477610.230551\n", - " 460159.597378\n", - " 444568.857000\n", - " 389684.514691\n", - " 391135.437740\n", - " -1450.923049\n", - " -0.003710\n", + " 327708.324530\n", + " 318063.470421\n", + " 302154.611762\n", + " 306083.376401\n", + " 305678.254498\n", + " 422131.112511\n", + " 423964.003816\n", + " -1832.891305\n", + " -0.004323\n", " \n", " \n", " 35\n", " 2060\n", - " 23173\n", - " 582978\n", - " 3100047.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 459757.304011\n", - " 436835.494548\n", - " 419958.086643\n", - " 435515.915955\n", - " 425013.325154\n", - " 383317.152377\n", - " 381266.519178\n", - " 2050.633200\n", - " 0.005378\n", + " 309435.437644\n", + " 327543.125082\n", + " 336866.204386\n", + " 331980.842360\n", + " 330169.889911\n", + " 421573.506857\n", + " 423163.439788\n", + " -1589.932931\n", + " -0.003757\n", " \n", " \n", " 36\n", " 2061\n", - " 23689\n", - " 595156\n", - " 3162324.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 403898.123577\n", - " 446026.892969\n", - " 459573.706453\n", - " 436904.851847\n", - " 419966.747362\n", - " 390113.556785\n", - " 387064.014493\n", - " 3049.542292\n", - " 0.007879\n", + " 320279.427886\n", + " 330945.691553\n", + " 322432.738606\n", + " 318079.159985\n", + " 317973.894415\n", + " 422575.707068\n", + " 422364.387452\n", + " 211.319617\n", + " 0.000500\n", " \n", " \n", " 37\n", " 2062\n", - " 22794\n", - " 574103\n", - " 3036727.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 468021.236699\n", - " 450100.730558\n", - " 416050.220079\n", - " 373748.278834\n", - " 351040.543393\n", - " 372856.397814\n", - " 373879.275648\n", - " -1022.877835\n", - " -0.002736\n", + " 330832.389669\n", + " 285321.675202\n", + " 301954.830856\n", + " 310662.088357\n", + " 312810.479228\n", + " 420956.703710\n", + " 421566.843952\n", + " -610.140243\n", + " -0.001447\n", " \n", " \n", " 38\n", " 2063\n", - " 22722\n", - " 573325\n", - " 3024141.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 414958.264565\n", - " 415976.330050\n", - " 443797.927964\n", - " 453085.545667\n", - " 444035.139054\n", - " 367768.692199\n", - " 368187.001270\n", - " -418.309071\n", - " -0.001136\n", + " 435362.126119\n", + " 433776.704399\n", + " 419118.260070\n", + " 404772.957169\n", + " 405190.542219\n", + " 418934.469956\n", + " 420770.806441\n", + " -1836.336485\n", + " -0.004364\n", " \n", " \n", " 39\n", " 2064\n", - " 23581\n", - " 590848\n", - " 3149704.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 441414.054493\n", - " 435767.269524\n", - " 415051.021426\n", - " 406769.043607\n", - " 396642.228590\n", - " 378200.181200\n", - " 380644.486568\n", - " -2444.305368\n", - " -0.006421\n", + " 304940.147499\n", + " 317030.377297\n", + " 304945.762400\n", + " 319651.502857\n", + " 319575.723877\n", + " 419086.943369\n", + " 419976.272074\n", + " -889.328705\n", + " -0.002118\n", " \n", " \n", " 40\n", " 2065\n", - " 23523\n", - " 591233\n", - " 3157907.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 433793.080907\n", - " 435494.327000\n", - " 421305.379992\n", - " 408124.267918\n", - " 399546.170001\n", - " 383210.897923\n", - " 380769.053462\n", - " 2441.844461\n", - " 0.006413\n", + " 353974.887443\n", + " 329874.956467\n", + " 337015.684029\n", + " 328940.852077\n", + " 329238.343810\n", + " 418729.313756\n", + " 419183.238012\n", + " -453.924256\n", + " -0.001083\n", " \n", " \n", " 41\n", " 2066\n", - " 22993\n", - " 578310\n", - " 3065123.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 358327.837808\n", - " 382545.188235\n", - " 359818.742372\n", - " 354980.088513\n", - " 342669.140660\n", - " 373477.131153\n", - " 373664.729920\n", - " -187.598767\n", - " -0.000502\n", + " 295464.487169\n", + " 354202.699889\n", + " 365879.087584\n", + " 373323.111876\n", + " 372541.004296\n", + " 418355.425750\n", + " 418391.701423\n", + " -36.275673\n", + " -0.000087\n", " \n", " \n", " 42\n", " 2067\n", - " 23261\n", - " 583580\n", - " 3099017.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 385266.544939\n", - " 357229.405339\n", - " 389448.072900\n", - " 382553.140857\n", - " 367803.054399\n", - " 375480.781577\n", - " 376740.673312\n", - " -1259.891735\n", - " -0.003344\n", + " 297221.496710\n", + " 272255.281494\n", + " 280888.319603\n", + " 281510.797522\n", + " 281840.507716\n", + " 417412.937075\n", + " 417601.659480\n", + " -188.722404\n", + " -0.000452\n", " \n", " \n", " 43\n", " 2068\n", - " 23318\n", - " 586603\n", - " 3118001.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 444523.181015\n", - " 449728.133273\n", - " 439791.891824\n", - " 438856.705942\n", - " 426322.297655\n", - " 374245.788665\n", - " 375335.534050\n", - " -1089.745385\n", - " -0.002903\n", + " 409016.019784\n", + " 378752.521246\n", + " 360679.750486\n", + " 359521.705424\n", + " 359548.833442\n", + " 414765.010421\n", + " 416813.109359\n", + " -2048.098937\n", + " -0.004914\n", " \n", " \n", " 44\n", " 2069\n", - " 23422\n", - " 588499\n", - " 3133720.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 445720.962431\n", - " 418703.399054\n", - " 431958.526817\n", - " 430211.684701\n", - " 419976.194936\n", - " 379224.450236\n", - " 378005.108376\n", - " 1219.341861\n", - " 0.003226\n", + " 420878.539429\n", + " 445824.370857\n", + " 462306.136722\n", + " 461148.128688\n", + " 461552.424105\n", + " 415927.049193\n", + " 416026.048243\n", + " -98.999050\n", + " -0.000238\n", " \n", " \n", " 45\n", " 2070\n", - " 23609\n", - " 593756\n", - " 3146747.0\n", + " 25584\n", + " 643536\n", + " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 400991.290205\n", - " 429393.430690\n", - " 411181.980311\n", - " 405133.787228\n", - " 386202.176410\n", - " 383743.213561\n", - " 381667.545696\n", - " 2075.667865\n", - " 0.005438\n", + " 405718.142702\n", + " 364719.332490\n", + " 323443.731437\n", + " 324834.166014\n", + " 323233.055405\n", + " 412876.186407\n", + " 415240.473322\n", + " -2364.286915\n", + " -0.005694\n", " \n", " \n", "\n", "
" ] }, - "execution_count": 55, + "execution_count": 61, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 55 + "execution_count": 61 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-03T11:37:16.273771Z", - "start_time": "2025-01-03T11:37:16.179184Z" + "end_time": "2025-01-07T15:20:42.603433Z", + "start_time": "2025-01-07T15:20:42.521119Z" } }, "cell_type": "code", @@ -5102,7 +4688,7 @@ "year_range = range(2025, 2061)\n", "\n", "plt.plot(year_range, multiplied_values)\n", - "plt.xlabel(\"Change ANC cases due to weather\")\n", + "plt.ylabel(\"Change ANC cases due to weather\")\n", "plt.axhline(y=0, color='black', linestyle='--') " ], "id": "c0ed116b28287eaa", @@ -5110,10 +4696,10 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 56, + "execution_count": 62, "metadata": {}, "output_type": "execute_result" }, @@ -5122,19 +4708,19 @@ "text/plain": [ "
" ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkUAAAG1CAYAAAD3BIBFAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/OQEPoAAAACXBIWXMAAA9hAAAPYQGoP6dpAACdz0lEQVR4nO2deXxU5fX/P3f2mSQz2RMCIYAg+yKgGHcrNSpWaa11aS0u1YqgVVSqrQVrbe3Pff9S27Jo3WurFi2KIG5QQRBkX8NO9mQmM0lmfX5/zDx37iQzk1nu7Of9euWlzDxzc+/NnblnzvmczxEYYwwEQRAEQRA5jiLVO0AQBEEQBJEOUFBEEARBEAQBCooIgiAIgiAAUFBEEARBEAQBgIIigiAIgiAIABQUEQRBEARBAKCgiCAIgiAIAgAFRQRBEARBEAAoKCIIgiAIggBAQRFBEARBEASANAiKHnnkEZx66qkoKChAeXk5Zs6cid27dwes6enpwZw5c1BSUoL8/HxcccUVaGxsDFhz+PBhzJgxAwaDAeXl5bj33nvhcrkC1qxZswaTJ0+GVqvF8OHDsXTp0kQfHkEQBEEQGULKg6LPPvsMc+bMwf/+9z+sXLkSTqcTF154IWw2m7jmrrvuwn/+8x+8/fbb+Oyzz3D8+HH86Ec/Ep93u92YMWMGHA4H1q5di2XLlmHp0qVYsGCBuKa+vh4zZszA+eefj82bN+POO+/EL37xC3z00UdJPV6CIAiCINITId0GwjY3N6O8vByfffYZzjnnHJjNZpSVleG1117Dj3/8YwDArl27MHr0aKxbtw6nn346/vvf/+LSSy/F8ePHUVFRAQBYtGgRfv3rX6O5uRkajQa//vWv8cEHH2Dbtm3i77r66qvR0dGBFStW9LtfHo8Hx48fR0FBAQRBSMzBEwRBEAQhK4wxdHZ2oqqqCgpF+FyQKkn7FDFmsxkAUFxcDADYuHEjnE4npk+fLq4ZNWoUBg8eLAZF69atw/jx48WACADq6uowe/ZsbN++HaeccgrWrVsXsA2+5s477wy6H3a7HXa7Xfz3sWPHMGbMGLkOkyAIgiCIJHLkyBEMGjQo7Jq0Coo8Hg/uvPNOnHnmmRg3bhwAoKGhARqNBoWFhQFrKyoq0NDQIK6RBkT8ef5cuDUWiwXd3d3Q6/UBzz3yyCP4/e9/32cfjxw5AqPRGPtBEgRBEASRNCwWC6qrq1FQUNDv2rQKiubMmYNt27bhyy+/TPWu4P7778e8efPEf/OTajQaKSgiCIIgiAwjEulL2gRFc+fOxfLly/H5558HpLcqKyvhcDjQ0dERkC1qbGxEZWWluGb9+vUB2+PdadI1vTvWGhsbYTQa+2SJAECr1UKr1cpybARBEARBpD8p7z5jjGHu3Ln497//jdWrV2Po0KEBz0+ZMgVqtRqrVq0SH9u9ezcOHz6M2tpaAEBtbS22bt2KpqYmcc3KlSthNBpFHVBtbW3ANvgavg2CIAiCIHKblHef3XbbbXjttdfw3nvvYeTIkeLjJpNJzODMnj0bH374IZYuXQqj0Yjbb78dALB27VoA3pb8SZMmoaqqCo8++igaGhpw3XXX4Re/+AX+9Kc/AfC25I8bNw5z5szBjTfeiNWrV+OOO+7ABx98gLq6un7302KxwGQywWw2U/mMIAiCIDKEaO7fKQ+KQtX4lixZguuvvx6A17zx7rvvxuuvvw673Y66ujq8+OKLYmkMAA4dOoTZs2djzZo1yMvLw6xZs/DnP/8ZKpW/QrhmzRrcdddd2LFjBwYNGoTf/e534u/oDwqKCIIgCCLzyKigKFOgoIggCIIgMo9o7t8p1xQRBEEQBEGkAxQUEQRBEARBgIIigiAIgiAIABQUEQRBEARBAKCgiCAIgiAIAgAFRQRBEARBEAAoKCIIgiAIggBAQRGRBng8DD1Od6p3gyAIgshxKCgiUs7c1zfh1Ic/QYO5J9W7QhAEQeQwFBQRKefrA23otLvw2Z6m/hcTBEEQRIKgoIhIKW4PQ1uXAwDwzcH2FO8NQRCpYuOhNhxp60r1bhA5DgVFREpp73KAT9/beIiCIoLIRY60deGK/1uHWYvXg8ZxEqmEgiIipbRaHeL/H2ixodVqT+HeEASRCo62dwPwfgYcbKVsEZE6KCgiUkrvIIiyRQSRe3T2OMX//3JfSwr3hMh1KCgiUkqLzRHwbwqKCCL3sNpd4v9/tZeCIiJ1UFBEpBSeKVIrBQDAhoNtqdwdgiBSQGePPyhad6AVbg/piojUQEERkVLafJmi2pNKAQDbjlnIyJEgcgxp+czc7cT24+YU7g2Ry1BQRKSUFp/QevLgQpTma+Bwe7D1GH0gEkQu0SkpnwGkKyJSBwVFRErh5bPSfC2m1BQBIL8igsg1ePmsNF8LAPiKgiIiRVBQRKSUVl/5rDRfg6k1xQC8Jm4EQeQOPCi6cGwFAGDDwXYqoxMpgYIiIqXwTFFJvhZThngzRRsPtZOBG0HkEFxTNGlQISqNOjhcHsoYEymBgiIipXDzxuI8DcZVmaBVKdDe5cT+ZluK94wgiGRh9WWKCnQqnDnc23RBuiIiFVBQRKSMHqdbFFiW5mmhUSkwsboQAJXQCCKX6BSDIjXOGlECgHRFRGqgoIhIGbwdX6UQYNSrAABTSWxNEDkHL58V6FQ4k9tzHDejvZe5K0EkGgqKiJTBS2cl+RoIgte8capEV0QQRG7AM8b5OhXKjTqcXJEPxrxGjgSRTCgoIlJGi80nss7Tio9NHuwNig602NBCw2EJIuvxeJg45qNA580Yk66ISBUUFBEpo02SKeIUGjQYUZ4PgLJFBJEL2Bwu8GZTo04NADjLFxSRrohINhQUESmj1eY3bpRCJTSCyB14lkilEKBVeW9J04aVQKkQcKi1C0faulK5e0SOQUERkTJETVGeJuDxKT4Tx29oOCxBZD2dknZ8ri3M16pwiq8TlbJFRDKhoIhIGS1i+axXpsjXgUbDYQki+/F3nqkDHiddEZEKKCgiUgYvn0k1RQBQU2Kg4bAEkSNYfJmifK0q4PGzRniDorX7W+HxkMM9kRwoKCJSRqjymSAINByWIHIEqZu1lEnVhcjTKNFmc2BngyUVu0bkIBQUESlDOvesNzQcliByA6mbtRS1UoFpw8jdmkguFBQRKYExhhZb8EwRENiBRsNhCSJ74ZoiY69MESDVFZGJI5EcKCgiUoLV7oLD5QHQV1MEAGNpOCxB5ARWiZt1b7hf0fr6Vthd1HRBJB4KioiUwPVEBo0SBk3fD0PpcFhqzSeI7KUzhKYIAE6uyEdpvhY9Tg++PdyR5D0jchEKioiU0Grr62bdG3E4LJk4EkTWYgnRkg94my7OGk66IiJ5UFBEpARRZJ3XV2TNIWdrgsh+rCFa8jnkV0QkEwqKiJTAM0WlYTJFfDhsPQ2HJYisJVz5DPAHRVuOdIhZJYJIFBQUESkhkkwRDYcliOyn0867z/qWzwCgqlCPYWV58DDgf/upC41ILBQUESmBj/goDpMpAqiERhDZDs8UBes+4/AuNNIVEYmGgiIiJbSG8SiSQsNhCSK7CeVoLYV0RUSyoKCISAm8fFYaxM1aCg2HJYjsJpSjtZTTh5VAIQD7m204Ye5O1q5lJa+vP4xlaw+mejfSFgqKiJQgzj3rp3zmHQ6rpeGwBJGF9DjdcLi9Jq6hus8AwKRXY/ygQgDAV+RuHTMOlwcPvLsNC9/fjuMdFFwGg4IiIiW02voXWgNen5KpNByWILIS7mYNhA+KAJBfkQzY7C64Pd6xSdvoS2ZQKCgiko7Hw9AWQUs+h4utSVdEENlFp8SjSKkQwq6V6opoHmJsSINQCoqCQ0ERkXQ6up3wfVlBUT9CawCY4ssUbTzcDo+HPgwJIlvoFN2sw2eJAK9vmU6tQHOnHXubrInetawkICg6bknhnqQvFBQRSYeLrAsNaqiV/V+CfDhsR5cTB1row5AgsoX+3Kyl6NRKnDrE24365V4qocWCTRIUpZtGc3dDJ37/n+14Z+PRlO5HzgVFL7zwAoYMGQKdTodp06Zh/fr1qd6lnIN7FPXXjs8JHA5LuiKCyBYsEbTjSyG/oviQZoqaO+1osvSkcG8C2XrMjCVfHcS7m4+ldD9yKih68803MW/ePCxcuBCbNm3CxIkTUVdXh6amplTvWk4RqchaCg2HJYjsozPMMNhgcF3R/w60wunrWiMix2YPtDVJp2zR0fYuAMCgIn1K9yOy8DxLePLJJ3HzzTfjhhtuAAAsWrQIH3zwARYvXoz77rsvom3YbDYolco+jyuVSuh0uoB1oVAoFNDr9TGt7erqCikyFAQBBoMhprXd3d3weEJ/yOTl5cW0tqenB2534BvxeHMHPI4eGFWBjwdbyxlbrgFjTHS2ttvtcLlcQdcCgMFggCAIEa3V6/VQKLzfDxwOB5zO0POVolmr0+nEayWatU6nEw6HI+RarVYLlUoV9VqXywW7PfQMOY1GA7VaHfVat9uNnp7Q3zjVajU0Gk3Uaz0eD7q7Q7cNR7NWpVJBq/UG4YwxdHV1ybI2mvc9fUb0XWu1u8BcDmjhDHmM0u0OK9LAqHKjw9qD/+0+hsk+c1dONO/7XPyMaO2wwOPwv/827mvAuSNK0uIz4mi79/1bZdSGvd5j/YyIGJYj2O12plQq2b///e+Ax3/+85+zyy67rM/6np4eZjabxZ8jR44wACF/LrnkkoDXGwyGkGvPPffcgLWlpaUh106dOjVgbU1NTci1Y8aMCVg7ZsyYkGtramoC1k6dOjXk2tLS0oC15557bsi1BoMhYO0ll1wS9rxJ+fGPfxx2bfVd/2Q1v17Omjt72KxZs8KubWpqErd72223hV1bX18vrr3nnnvCrt22bZu4duHChWHXrl+/Xlz76KOPhl376aefimuff/75sGuXL18url2yZEnYtW+99Za49q233gq7dsmSJeLa5cuXh137/PPPi2s//fTTsGsfffRRce369evDrl24cKG4dtu2bWHX3nPPPeLa+vr6sGtvu+02cW1TU1PYtbNmzRLXWq3WsGt//OMfB1zD4dbSZ4T3R/oZ8cwne5h+WOjtAtF9RlitVnEtfUZ4yZTPiJ8sWstqfr2cPfaP8NuN5TPCbDYzAMxsNrP+yJnyWUtLC9xuNyoqKgIer6ioQENDQ5/1jzzyCEwmk/hTXV2drF0lQjC8zPuNkeagEUR20ElT7wkfPFNUXhC5rCIRCIzlhuHD8ePHMXDgQKxduxa1tbXi4/Pnz8dnn32Gr7/+OmC93W4PSA1aLBZUV1fj+PHjMBqNfbZPqfHga4OVxG5/fRM+2dGEBZeOxi++NybsWil/WLEfb2w4glvOGYa7LxhGqfEo11L5jMpn6fYZcd873+H1dfsx97xhuO384f1ut6enB4eaO/H9pz6HSiHgf7+5AHmSzjUqn3kJ9Rnx+Me78PcvDuLKqQPxz43HwBiwfsFFqCz0nuNUfUYICiXG/2E13B6Gtb8+D6YwFa9YPiMsFgtMJhPMZnPQ+7eUnNEUlZaWQqlUorGxMeDxxsZGVFZW9lmv1WrFD0YpeXl5AW/SUESyJpa10g8pOddKP1TlXCu9CXAsTiUUGh2qyor6XSvl1CHFeGPDEXxzsA1a7eigf59ghPpbBkOj0URcg07UWrVaLX6YyLlWpVKJH5RyrlUqlRFfw9GsVSgUCVkrCEJC1gKJe99n62dEp90FQaVBaZExomPU6XQYWa3DkMpiHG7rwvYmO84fZQq6Npr3fa58RjgFDRQaHQaVFeOkqh4caLZhV6NNDIpS9RlxpK0Lbg+DRqlApckART9Gnpxo3veRkjPlM41GgylTpmDVqlXiYx6PB6tWrQrIHBGJh7tZR9qSz+HO1luPmWk4LJF2uH1O7fuarNjVYCGj0QiIZBhsMKTu1kTkSH2hxlV5g8ntaWDiyEtnA4v0EQdEiSJnMkUAMG/ePMyaNQtTp07Faaedhqeffho2m03sRiOSQ4vPvLEkP7ra8eBi73DYFqsd3x0147Shxf2/iCDiZFeDBQdbutDR5UBblwMdXU602Rzef9scaO9yor3LAXO3E9JK1H0Xj8Kt556Uuh3PAKJxtJZy1vBSvL7+MPkVRYnV15Kfp1Vh/EAT3t9yHFuPpr4tP13a8YEcC4quuuoqNDc3Y8GCBWhoaMCkSZOwYsWKPuJrInE4XB7RsC2SuWdS+HDYFdsb8M2hNgqKiITCGMOf/7sLf/n8QFSv06gUcLg82Hy4IzE7lkXwzEVBBI7WUmpPKoEgALsaOtHU2YPygvCld8ILd7TO0yoxpNRbOt12PB2CIm+miIKiFDB37lzMnTs31buRs/DSmUohwBhlyhzwltBWbG/ARnK2JhKI28PwwLvb8Pr6wwCAidWFKM3ToNCgQXGe2vdfDYoMGhQZ1N7/z9OgUK/Gp7ubcfPL3+C4ObQAlPASa/msOE+DsVVGbDtmwbr9rbh80sBE7F7WYXP4y2djfeWzo+3daLc5IppDmSj8QVHkGrdEkXNBEZFaeOmsKE8TU+2493DYVNefiezD6fbg7re24P0txyEIwJ9/NB5XnTo44tcPMHmzFsc70meEQroSa/kM8OqKth2z4Iu9LRQURYhVzBSpYNKrUVNiwKHWLmw/bsFZI0pTtl/pVD7LGaE1kR60xiiy5tBwWCKR9DjduPWVjXh/y3GoFAKeu+aUqAIiABhY6P1gb7HaqSEgDG4Pg83hPT/5MQRFtcNKAJBvWTTw8hkfwMvF1qke95FO5TMKioik0urLFJVGKbLm0HBYIlFY7S7csGQDVu1qglalwF9/PhWXTqiKejuFBjX0aq+fTIOZskWhkA4njSVTNHFQIQCgvsUGC5lARgSffSYGRQO9QVEqdUUutwcNvsG06VA+o6CISCqtVl+mKEqRtRQaDkvITUeXAz/929dYd6AV+VoVlt14Gs4fVR7TtgRBQFUhL6GRrigUvHSmUSmgVfWdJ9kfRXkaMbOwLY0Gm6YrHg8TNUV5YlDkNTJM5fk7Ye7xehSpFCiL8cuynFBQRCSVFpuvHT8v9ov/1CHerjNKmxNy0NTZg6tf+h+2HOlAoUGN126ehtN9pZlYqfKV0I5RUBSSzhg7z6RMGOQr/6RBW3m60+V0i5YRvctnh1q7YO5OTbZNLJ0Vpt6jCKCgiEgycmSKJg/2ZorqW2zo6AptdU8Q/XG0vQs/WbQOuxo6UV6gxZu31GKCrywTD1Umb1B0gspnIeHls1hKZxxe/km1JiYT4HoihQDo1N5bf1GeRtTAbU9RCY2LrAemgZ4IoKCISDK8JT9ajyIpJoMahQZvC29zZ+jZOwQRjv3NVly5aB0OtnZhUJEeb99ai5GVBbJsm2eKqHwWGn/nWfTWHJwJAwsBUFAUCdLOMz7zDQDG+wLL7cdS42ydTu34AAVFRJLhQut4ymcAUKj3fpB2pCjlS2Q224+b8ZNF63DC3IPh5fn4561noKZEvhlKXFNE5bPQdPYEdkLFAr+hH2rtgrmLPgvC0bvzjCPqilKWKUqfzjOAgiIiDDa7C1/sbYbTHXradbS0yFA+AwCTwfv6DvogJKJk46E2XP3S/9Bqc2BslRFv3nI6Kk3yOiIPpExRv/iNG2MPikwGNQYXp48zczojzRRJSXUJMp08igAKiogwPLlyD677+3q8s/GoLNtjjKFVBqE1IMkUkaaIiIIv97bgZ39bj84eF04dUoTXbzk96hl8keAvn/WAMRoMG4xY3ax7M94ntv6OxNZhsUnmnknhQVF9iy3AJiFZUPmMyBh4m6Zc38C6HG70OL1Zp3gzRVxTlKqOCSLzON7RjRuXbUC3041zTi7DyzdOi2nUTCTwzFO3003ZzBDE42YtZQL32iFdUVj85bNA+4PSfC0GmHRgDNhxPLm6IqlHUTVlioh053CbN615qLVLlu3xzjOdWgGDJnpfEin+TBHdcIjI2HykAw6XByPK8/HXn0+BPs5rMBw6tVJsJqAZaMGRo/sM8OuKvjvWEe8uZTXWEJoiAOIctGQHllKPolgNfeWGgiIiKD1OtxjBH2y1ybJNqUeRtPshFrimqJ3KZ0SENPmu5+Hl+TGZBUaLtIRG9EUOTREAjPUFRUfavINNieDYQmiKgNSZOKabRxFAQRERgqPtXaLR17H2bjhc8YuteaYonnZ8DnWfEdHS5LNvKC9IzjdS7lVEYuvgyNGSDwAmvRpDSkhs3R/hMkXjUzTuI908igAKiogQSEtmHgYcaY+/hCa248uQJi3K82mKqHxGRIgYFBnl7TQLBXkVhUeOlnzOeJ/hJomtQxOq+wzwi633NVnR5Uie2DrdRNYABUVECHrriA7JUEJr9aW2S/LkyBT5WvK7KV1OREajr3yWtEwReRWFRa7yGeAXW9O4j9CE8ikCgAqjDmUFWngYsPNEZ9L2Kd08igAKiogQcJE1p75FjkwR9yiK/6ZkMpDQmoiO5iRnisirKDyddnnKZ0DqvXYyAbElP0SDwbiq5OuK0s2jCKCgiAgBzwwV+7I68mSKvDclOTVFVD4jIiXZmqIBhTT/LBxyZoq4UPhYR7dYpicCCVc+AyS6oqQGRVQ+IzIEXj47e0QpAOCgDG35PFNULEf5zNd91ml3yeq4TWQnDpdHnLtXkTRNkff3NFp66BrtBWMMVhmDogKdGsPKvGNaKFsUnHDlM8DfxbctSV5F6ehRBFBQRATB7WGisPqcEWUA5MkUtcgotDZKPkgt1IFG9EOz79pTKwUUGRJj2Nib0jwtNEoFPMyvZyK89Dg9cHm87a1ylM+A1GQ6Mgmx+yxEEMrP397GTvQ43Qnfn3T0KAIoKCKCcMLcDaebQa0UUHtSCQBvmjPeb7tyCq1VSoX4DZPa8on+4B5FZfnxe2RFikIhYIAvW0ReRYHwdnxBCK1xiRbRxJHE1kGxOcKXzwaYdCjO08DlYdjdkHixdTp6FAEUFBFBOOwrlVUXGTDApINOrYDbw8SLOBY8HiaWL+T6VlBIYmsiQrieqCxJpTMOeRUFp1NSypErSJ3ga8un8llwuNA6VPlMEISkCtbT0aMIoKCICMIhX+fZ4BIDBEHAkBJvrT4eZ2tztxNuX7pcDk0RIGnLJ1droh94UFSRJJE1h3sVUVt+IFxkLefsubFVRgiCtyzDOw0JP1zDFSpTBPg70LYnwcQxHUXWAAVFRBC4yLqm2Hux1vjcYg+2xB4U8c4zo04FjUqey44yRUSk8PJZuTHZQZE3M3WC5p8FINcwWCl5WhVOKssHQLqi3jhcHjh88od8TehzPj6pmaL08ygCKCgignC4zRv8DPZliIaUev8bz2DYFqu8pTPA34FGmiKiP5osvB0/yeUzmn8WFKuMbtZSJpCuKCi88wwA8rShNVy8fLa7oVOW0U7hOJKGHkUABUVEEHjww+cJyVE+43qiEhk8ijh+ryIqnxHhaepMrps1h0Z9BEdOjyIpZOIYHN55plUpoFKGvu0PKtLDpFfD6WbY05hYsfUxKp8RmQBjTBRa87IZ/288mSJx7lmenJkiGgpLRIaoKUqy0HogjfoIikWmYbC9mTCIB0Udsm430+GdZ/1l5rxi68Q7WzvdHrGknE4eRQAFRUQv2ruc6LS7IAj+CH6or3x2pK0Lrhjb8nn5rFjGTJFJT5oiIjIafeWzsiRnigb4us86e1yijoaQDIOVOVM0psoIheD9ezeRN5SIrR83aynjqhKfbWsw98DDkHYeRQAFRUQvuEljpVEHndpbe64o0EGrUsDlYTF/4xVHfMjUeQaQpihath834+HlO8Rv6bmCy+0Rr79kC63ztCoxeKdxH354OUfu8plBo8Lwcq/Ymkpofqz9tONLGZcEZ2tRT5RmHkUABUVEL3iJbHCxv86rUAj+DrQYS2hyDoPlkKYoOp5fvQ9/+7Ieb204kupdSSqtNgcYAxSCvOXbSKG2/L7wrJmcLfmc8QMLAZDYWkp/Iz6k8KBo5wlLwsbT8M6zdPMoAigoInpxqJeeiFPDxdYxtuX7gyI5M0WkKYoG7t2Sa+3KTZLSmTIF30oHiq7WFBRxEiW0BqS6oty6zsPh9yjq3z28ptiAAq0KDpcH+5qsCdmfdPUoAigoInpxyNeOz4MgDtcVxdqB1mJLoNCaNEURwYPHZA18TBf43LFkt+NzqAOtL9YoMhfRIu1AY4zJvv1MxBqFpkihEDCmKrFi66Np2o4PUFBE9OJwkPIZEH8HWqvoUySn0Nq7LUuP3y2bCA13/t7fbEWXw9XP6uyBd54lux2fQ15FfbGImSL5y2djBhihVAho7rSLAvtcJ5ryGZD44brpatwIUFBE9IKP+OhdPhsSR/nM4fLA7MtSyKkp4gJWxgALldDCwhgTM2qMefUCuYLoUZRkkTWHNEV9SYSjNUevUWKET2z93dEO2befiVj7GQbbm0SLrdPVowigoIiQ0OVwibqTmuLA8hl3tT7SHn1bfrsvQ6EQ/OJoOdCoFOI3H9IVhcdqd8ElyaZtO5ZLQVFq3Kw5VSYa9dGbRDlacxKd6cg0omnJB/xB0Y7jFtmz8OnsUQRQUERIOOzLEpn0apgMgcHLAKMOGpUCTjeLurWYl86K87Syt1/6vYqoAy0cvXVXuXSzSNXcMw7PFDWYe6jM6yMRA2GlcLH1dzl0nYfDJrbk9y+0BrwaUoNGiW6nGwea5RVbp7NHEUBBESEhVOcZ4BXfcZ1RtGJr0aNIRj0RhzrQIqNPUJRDYutUZ4rKfV1vTjdDi5U0Lk63B91O7006EeUzABg/qBAAsPUoia0BqbA9siBUqRAwZoBXbC13F186exQBFBQREvzjPfKCPh+rrsifKUpcUGSmDrSwdHR7/wY8s7a3sRM9vhtTtuMfBpuab6UqpQKVRhr3weGlM0B+R2vOqMoCqBQCWm0OMs2EtHwWWaYIkOiKZC61p7NHEUBBESFBbMcvDi5+GxKjgSP/diynyJpT6OtAo/JZeHimaFRlAYrzNHB5GHY3JHbgYzrg8fizM6kqnwFAFXkVifCshU6tgDrMcNJ40KmVOLmiAACZOALRd58B0qBI3vOXzh5FAAVFhATRzTpI+QwAanxi60NRl898xo0JyBSZqHwWETxoLDJoMJZ7kBzP/ptFW5cDLg+DICCl+gXyKvKTqGGwvaHhsH46oxRaA36x+vbjZnhk1MKls0cRQEERIYELrfvLFNVHXT5LoKaIhsJGBD8/hQZ1wtLi6Qg3bizJ0yQsKxEJfDBsJnoVLfmqHn/6cKds2hzRzTpBnWccv4lj9l/n/RFLpuiksjzo1ArYHG7Ux2jaG4x09igCKCgifDjdHvFi7U9TdKStO6oumkTMPeOImiLKFIWlXQyKNOIU7O05kCniIuuyFImsOZk66oMxhkf+uwsvfX4gZuPW3lgTOOJDipgpOtqR82Jr3n0WTaZIpVRg9AD5na25R1F1iC/fqYaCIgKA98Pa7WHQqhQhBalVhXqolQIcEp+JSGhJYPmMa4raSVMUFi609maKvB90u050JmzgY7rQnGKRNUcsn2WYV5HN4YbD5b1GeIAZL5325JTPRlYWQK0U0N7lFL/w5SKMMdgc0QutAYhfoOQKiqQeRZQpItKaQ5LxHqHaJJUKQYzuo/nW2JpAobWJ5p9FBD8/RQY1BhcbUKBTweH2YG9jYgY+pgvczboihSJrIHNHfUgbGPi5jJdEDoOVolUpMbLSK7bOJV+u3nQ53OCJsmjNMsfLXGrnHkValQJlaehRBFBQRPgINd6jN0N9JbRodEVtNvnnnnGKDN5tUvksPPzmZtJrIAhCzoitGy2p9Sji8KCozeZAtyNzrBCkXzaa5coUJdjNWsr4gYUActvEkeuJFAKgV0eXKRo70P85IUcJknsUDSzSQxDSz6MIoKCI8HHYJ6QbXBxcT8TheqNIO9C6HC50+W4CidQUUUt+eKSZIsCfFt+e5TeLVM894xh1KuRpvDekTCqhSb9syB0UJbp8Bkh1Rdl9nYfDKuk8izYQObmiABqlAp09LrERJx7SvR0foKCI8BHOzVrKkNLovIq4yFqjUog3BTnh3WfmbqesbaPZBrcsKPRl1sYPSuzAx3TB72ad2qBIEAQxW3Qig0poiQmKEjcMtjfjxQ603HW29o/4iP58q5UKjBrAS5Dxf1ake+cZQEER4YN/CwjlUcSJ1tWaexSV5mkSki41+oIiD/N7cRCBeDxM4lPkPV9jqxI38DGdEN2sjaktnwGZ6VUkLZ/JJbTmmYtkBEU802HuduJIW+acdzmxxuBRJIV/Vsgx7iPdPYqAFAZFBw8exE033YShQ4dCr9fjpJNOwsKFC+FwBJZBvvvuO5x99tnQ6XSorq7Go48+2mdbb7/9NkaNGgWdTofx48fjww8/DHieMYYFCxZgwIAB0Ov1mD59Ovbu3ZvQ48skGGP9ehRxeFB0qK0rosxMIkXWgNe5ltfJadRHcDrtLvA/FRemSwc+1rdkp9iaMSZmN1KdKQL8QVEmjfrgXYtAIspniQ+KNCoFRvsyHd/lqIljvEGR1MQxXqh8FoZdu3bB4/HgL3/5C7Zv346nnnoKixYtwm9+8xtxjcViwYUXXoiamhps3LgRjz32GB588EG89NJL4pq1a9fimmuuwU033YRvv/0WM2fOxMyZM7Ft2zZxzaOPPopnn30WixYtwtdff428vDzU1dWhpydz0tiJpNlqR5fDDYXQ/8VaVaiDSiHA4fKgwdL/+fN7FMkvsub4h8KSrigYPEtk0CihVXkDyEQOfEwXOrqccPgsB8rSICjKRK8i6ReNZpmG2XYmydGaM26gfJmOTMRv3BibfIFbeHx31Bx3VvkYlc9Cc9FFF2HJkiW48MILMWzYMFx22WW455578K9//Utc8+qrr8LhcGDx4sUYO3Ysrr76atxxxx148sknxTXPPPMMLrroItx7770YPXo0/vCHP2Dy5Ml4/vnnAXi/LT799NN44IEHcPnll2PChAl4+eWXcfz4cbz77rvJPuy0hA+CrSrUQ6MKf0molAqxLf9gBGLrFpsvU5SXuJuSiVytwyK6WesDb0LZ7mzNyz2FBrUYDKaSTPQqkmqKWq12WUqtyew+A0hsLWaKNLGd7zEDjDDqVDB3O/Ht4faY9yMTPIqANNMUmc1mFBcXi/9et24dzjnnHGg0/ixDXV0ddu/ejfb2dnHN9OnTA7ZTV1eHdevWAQDq6+vR0NAQsMZkMmHatGnimmDY7XZYLJaAn2wlUpE1RxwM29K/2JpnihLRjs8ppPlnYeHGllxkzRHb8rP0G7ToUZTidnxOJo76kH7R8DCg1RZ/tiiZ5TPA35afq2LrWEZ8SFEpFThvZDkA4JOdTTHvRyZ4FAFpFBTt27cPzz33HH75y1+KjzU0NKCioiJgHf93Q0ND2DXS56WvC7YmGI888ghMJpP4U11dHeORpT+HImzH50TTlu/XFCUwKPK5WlNbfnDM3f65Z1J4pmjHcUtWdu6JHkUpbsfnDJQIrTPl5ty7JC2HrijZ5bMRFfnQqLxt5XKNKskkbHFqigBg+hjv/XPVzsaYt5EJHkVAAoKi++67D4IghP3ZtWtXwGuOHTuGiy66CFdeeSVuvvlmuXcpJu6//36YzWbx58iRI6nepYQRqXEjR8wURRIUiSM+EndjKiRX67C023jnWWBgOrzcd7Owy+NBkm7wTFE66IkAoMKkhSAAdpdHNDRNd3q/p+INihhjYjnHmKRMkVqpEPVzuWjiaOUt+XGc73NPLoNKIWBvk1WUW0RLJoisgQQERXfffTd27twZ9mfYsGHi+uPHj+P888/HGWecESCgBoDKyko0NgZGpvzflZWVYddIn5e+LtiaYGi1WhiNxoCfbEUsn0U4oG9IKW/Lj7x8llihNc8UUVAUDF5WNPXKFKmVCozmYxCy0Nm6KU3crDlalVIsG2RKCc3SHWj6GW9bfpfDLXZCxnOTjhbpcNhcI97yGeDVbZ46xCtt+STGbFEmeBQBCQiKysrKMGrUqLA/XCN07NgxnHfeeZgyZQqWLFkChSJwd2pra/H555/D6fTf7FauXImRI0eiqKhIXLNq1aqA161cuRK1tbUAgKFDh6KysjJgjcViwddffy2uyXUi9Sji+Nvybf2WXVqTILSm7rPw9HazljI2i8XWPKuR6rlnUjKtLZ8H1CPKvcFzvJkiridSKoSoR07EQy53oFn5MNg4zXMvGO3VFa3aFWNQ1Jb+HkVACjVFPCAaPHgwHn/8cTQ3N6OhoSFA53PttddCo9Hgpptuwvbt2/Hmm2/imWeewbx588Q1v/rVr7BixQo88cQT2LVrFx588EF88803mDt3LgCvk+ydd96Jhx9+GO+//z62bt2Kn//856iqqsLMmTOTfdhpR2ePU0zlc61Qfwws0kOpENDj9IT95sgYS06miLtaU6YoKFxrxbVXUuT0IEk3Gn2WEemSKQICdUXpjt3lFkf0DK/IByBHUOR3s06mroRnirYdy079XDisPfFrigBg+mivrujrA22w9ET/WZsp5bPk5S97sXLlSuzbtw/79u3DoEGDAp7jIkSTyYSPP/4Yc+bMwZQpU1BaWooFCxbglltuEdeeccYZeO211/DAAw/gN7/5DUaMGIF3330X48aNE9fMnz8fNpsNt9xyCzo6OnDWWWdhxYoV0OnS58MyVfDSWUmeJuL0qlqpQHWRHgdbu1DfYkOlKfh5tHS74PJ9ABXnUfdZqmjvCi60Bvwz0Lb5OnPSWQAZLeKIjzTKFA3wvVdOZEBbPhfoCwIwzFcyjzsokqGUEwvDy/KhUytgtbtQ32rDSWX5Sf39qUSO8hnglU2cVJaH/c02fLa7GT+YWBXV6zPBzRpIYabo+uuvB2Ms6I+UCRMm4IsvvkBPTw+OHj2KX//61322deWVV2L37t2w2+3Ytm0bLrnkkoDnBUHAQw89hIaGBvT09OCTTz7BySefnNDjyxSiLZ1xIulA4x5FBVoVdAlMlZuo+ywsveeeSTm5Mh8qhYD2LieOmzND5xIJjDH/MNg0EVoD0lEf6X+uuZ7IqFOLX3zkKp8lq/OMo5KIrbPVgiIU8TpaS+HZomi70KRmvxQUEWlNtCJrjr8DLbTYOhmlM8CfATFTpigoveeeSdGqlDi5gg98zJ6bRafdhR6n1806ncpnmaQp6pBkGLlAPF5X62QOg+3NhEGFALzOzLmEzSFfUHSBLyj6dHczXD63+EjIFI8igIKinOdwm8+jKEI9EYd3oIXLFCV67hlH2pKfKf4vyaQjTPkM8Nv4Z1NQ1OT7VlqgU0Efp8BUTjJJU8SvG5NeLQ7UbYpgtE84xExRkstngF8/l2vO1jbeki/DOZ88uBBFBjXM3U5sPBS5u/XRDPEoAigoynl4pmhIlOUz3oFW3xKufMY9ihKcKfKVz1weBptPGEp4cXuYKIoMVj4DpOM+sudm4W/HT69vpVW++WdNnXbYXel9rYpWDnq16PVkc7hFjUosWJPsZi1l/CB/U4Ec40oyBX/5LP4vByqlAueP5F1okbtbZ4rIGqCgKOeJdsQHh68/1NoVMjuTrEyRTq0QZ7a1Z4gpXrKwdDvB/zwmffBM0Vgutj6ePW35osg6jUpngLfhQOu7VhvN8gxYTRRmiRYtT6MUW+hb4iihJdvNWspJZfnQq5WwOdyob7Em/fenAqfbA4fLW+Yq0MpzznkJLRq/okwRWQMUFOU0dpdbHE4Z6YgPzqAiAxQC0O10hxRfJmPuGeAV0ott+aQrCoDPPSvQqqBWBn+7jx5QAIXgFdHGWx5JF0SRdRp1ngHeazVTBsOaRSsHNQRBEM9lPGJrCx8Gm4JMkVIhBEx8zwWkWT05MkUAcM7JpVArBRxotuFAc2TBZaYYNwIUFOU0R9u7wRhg0CijDlw0KoWYCg1VQmtLUvkM8I+wIFfrQEK5WUsxaFRii3K2OFvzuWcVxvTKFAH+Elq664qk5TMAokA2HldrXspJRfkM8JeKtxzpSMnvTzb8fGtVCqhCfCmKlgKdGtOGlgAAVkU4IJbKZ0RGwGfYDC42xCR+k5bQgsHT7MVJ6DYwkat1UPydZ+ED0/FZ5mztL5+lV6YIAKpMmSG27i3Q57qieDJFqSyfAUDtMO/N/D/fnUCPM701XXJgTZAvFHe3jrSERuUzIiPgnWPR6ok4XGwdajAsHwZbmoRMES+fUaYokP46zzhjs0xszcuA6TIMVoq/LT+9S5Xm3pkiWYKi5A6D7c33RpVjYKEebTYH3t98PCX7kExsMnoUSeF+Rd8cau93kkAmeRQBFBTlNIfauMg6Oj0Rx9+WHzxTlCyhNUBeRaHwu1mHD0zHVXm1FtuzRGzdnKZCayBz2vJ7m37yrBvXa8VCojIXkaJSKvDz2hoAwOKv6rPewsPqa8eXOyiqLjZgZEUB3B6GNXvCl9AyyaMIoKAop5GWz2KBt/EH0xS53B7xhpxo80bA/8FNrtaBSMWy4RjjC4qOdXSLWrBMpikNh8FyBmSIpohfO4nIFKWqfAYAV586GHq1ErsaOvG/A20p249k4B/xIb9Xl7+EFj4oyiSPIoCCopzGnymKLSiSjvro/Y2rzfeBKgj961nkwETls6DwwDSYm7WUAp0aQ32Zv0wfDmuzu8SMRHlaCq39maJ0zlT4M0W9giJZWvJTNnYTJoMaP5o8EACw5Kv6lO1HMpBzxEdveGv+mt1NcIZxt84kkTVAQVHO4vEwce5ZTZTt+JzqYj0UgtfQrcUamF3g7fjFBg2UisR/O6ChsMHxd5/1H5iOreLO1skvodldbtFPJV54lsigUaasTBMOLrS2Odxii3q64fEwcfYZzzLyUqQsLfkp/rvccOYQAMDKnY040hZ6VFGmkyhNEQBMqi5ESZ4GnT0ubKgPnXHLJJE1QEFRztLY2QOHywOVQhBbhKNFq1KK33p7i62TNfeMU0hDYYMSbu5Zb1LlbO3xMMx49kt8/6nPwn7jjBQusk7HzjMA0GuUKPY1H6RrCa3T7gI3fTb2Kp+1WB0xOUJLA19jCstnADC8vABnjygFY8CytQdTui+JhAdFiRirolQIOH9U/yW0TPIoAigoylm4OHpgkT4u/wqxA62XrqjV5hNZ5yXnxiSdf0b4ibT7DADGic7WyQ2K2roc2NdkxaHWLuxtjN9pWGzHT8PSGSfdvYp4R5FOrYDO52RdnKeBIHhHx7TH8OXDKsmKpcK8sTc3njkUAPDmN0fiGl2SziRKaM2ZPpqP/GgMWQqm8hmREcQrsuaE8ipqSXamiMpnQWkXxbKRl88OtXYltYuvVVJ63Xki/tJdY5pnioD09yrifl+FkutGrVSg2FeGjaWExkXWBo0yKSX1/jj35DIMK81DZ48L72w6murdSQhWu/d9nKig6OwRZdAoFTjU2oX9IdytqXxGZAS83DUkxnZ8Dhfn9i6ftYmZomQFRd7fY+5yprV4NdmYIxRaA0BRnkb84NqRxNZ86SwtOYKidG7H56S7V5G5O3iGsawgdlfrVLtZ90ahEDDrjCEAgKVfHYQnC4fE2nyZokR0nwHeYKv2JK8hZrASWqZ5FAEUFOUs8XaecWpCGDj6NUVJKp/5dA8OtwfdOeBUGwlOtwedvhtRfz5FHF5CS2YHmjQo2iFDUOQvn6VxpshXPjuRpvPPeNm19xDheNryLSl2sw7GFVMGoUCrwoEWGz7b25zq3ZGdRHafccQSWhB360zzKAIoKMpZ5Cqfca+iQy1dARmaZJfPDBol1EpvSp50RV6kJbDeN7dQ8IGZyRRb9y6fxZvp4+aC6ehRxKlKcwPH3nPPOPEERX6PovTIFAHeLrifnFoNAFjy1cHU7kwCsCXBLPN7vtb8jYfa+3icZZpHEUBBUc7iH/ERX/msutgAQfB2q0jfEMkWWguCIOpmKCjywjvPjDpVxBoOcdxHispn7V1OcZhrrPDXZ0L57Hi6ls+46Wev8hk/p7G4WlvTpB2/N7Nqh0AQgM/3NGNfU/xC/3RCbMnXJO6cDyzUY/QAIzwM+HRXYAkt00TWAAVFKcfjYdjd0InNSZza3NHlEP1C4s0U6dRKUTQqLaHxb/+lScoUAVKxNbXlA/7gsCgKXRcvn+1vtqLLkZyOnNZeHlc7TsSXpUr3lnzAP+qjwdIDlww2BHJj7jXigxNfpsi7zVS34/dmcIlBnOW1dG12mTkmo3wGBHahSck0kTVAQVHKeWfTUdQ9/Tn+9OHOpP1O3ilWXqCFXhO/AI/rkg62+DvQkjn3jMN1Rf0NKMwVxLlnEZbOAO9Nr8KoBWPyiJ4jgWcVeTZr54nOmLfV4/QbIqZzpqgsXwu1UoDbw2ISLSeaRGiK0rF8xuFmju9sPJZVnx9caJ3oc87drT/f0xJgwsozRdWUKSIiZXJNEQBgy5EO2Rx9+0MukTXHPxjWmynqdrhhc3jfjMnSFAHUlt+bDrEEEt3fQPQrSpKzdbMvU3RKdSGA+MTW/GatVSlg1KffzZejUAioMKav2DqUpqg8jlEfqR4GG47aYSUYVVmAbqcbb35zONW7IxuJdLSWMmGgCWUFWljtLnxd3yo+nmnGjQAFRSlnWGkeCg1q2F0eWTpvIuGwL3gZHON4j96Ig2F9GSj+zV+jVCTESTUUXFMUi7FcNhKNcaOUsUl2tuZZxbNGlAIAdsahZxI9iozatBd2pnNbvjnEtSNmimLQfVnSYBhsKARBELNFy9YeSsuSZrQwxmB18KAoMS35HIVCwAWjeBeaX1dE5TMiagRBwJTB3mzRxkPtSfmdvHwmV6ZIOhgWCBzxkcwbE/8Az6b0dzxwbVW0A3nH8RloSRBbM8ZEofXZI8oAAPWttpj1TE0Z4FHEGZjGHWiipkgfXFPUaXeh2xGd9UU6DIMNx+WTBqLIoMaxjm58EqS9PNPocrjBGzmTkZ3jJbSVO7zu1oEeRVQ+I6KAl9A2JSsokrt85guK6ltsYIyJXWjFSTJu5BTRqI8A2kPoQvqDz0Db29iJngR7PnU53Ohxer+Vjx5QgNJ8r55pd0NsuqJMEFlz0nnUh+ho3StTVKBVQavy3jZaoiyhcU1ROoz4CIZOrcS10wYDABZnQXs+L50pBECvTmymCADOGl4KrUqBYx3d2N3YGeBRlMyGm3ihoCgNmOILir451JYUN2a5PIo4PLjq7HGho8spflgmU2QN+CfBU/eZl2jcrKUMMOlQkqeBy9cZmUh4VlGvVsKgUWH0gAIAseuKeKaoIo3nnnHS2asolNBaEATRFDPatnyuKTKmaVAEANedPgQqhYD19W1JNTBNBFZJO34yMvZ6jRJnDveWwFftbAoonaV7KVsKBUVpwMRBhVApBDRa7DiW4A/IHqdbTGnG61HE0amVGGDy3oTqW21o9WWKSpOcKeJdVpQp8tIeo9BaEASJX1FibwzNYgDt3ccxvtJdrJ1v3KOoLBMyRab4NEX7m6342xcHZNe/9DjdsPuaPkxBAmruTBxtB1pnGjpa96bSpMPF4wcAyHwzR1uCh8EG4wJfa/4nOxsz0qMIoKAoLdBrlOIwzkTrig77SmcFOlXUGYRw+AfD2iTt+EkOirimiLrPAMQutAYkuqIEd6Dxa6XUd6MdM4AHRTGWzzozqXzmDYpi6T7rdrjx87+vx8Mf7MTHO+TVv/D3j1IhBG2UiLUtP51b8qVwwfX7m49HXSJMJ/weRYkvnXEuGOXVFW0+0oHNRzsAZJbIGqCgKG1Ilq5IKrKWM6UpDoZt6Ur63DNOITlaBxBrSz7g1xUluoQgZhV9AfRoX1C064QlpgGd4jDYjCifefexo8sp6j8iZdFn+8WsMi9TyIW0dBbsM4KL2KMNitLV0bo3kwcXYWJ1IRxuD177OnPb85Mx4qM3lSYdxg00gjHg3W+PAaBMEREjXFe08XCigyLfeA+Z2vE50sGwLb4bXUmyy2fkaB0A95qJJSPIvYp2neiEM4HtyS2dgZmiYaV50KgUsDncYlYzGvzdZ+mfKSrQqcWsSTTZoiNtXVj02X7x3y1Wea93HkyHEujzTFE0ppMej789PJ3LZ5wbfdmiV/53KGn+cXJjc6RG2M7dwbt83YmUKSJiggdFO090Rv2tMRr4jWawTJ1nHO5VdLC1q09JJFlw/UOP05Pwrql0x+5yix9KvduqI6G6WI8CnQoOtwd7GxM3D4pninipVaVUYGSFV2wdra7I4fKInY+ZILQG/G350eiK/vjBTthdHvBxdrG4S4cjlHEjJ5bymdXhEtvD0718BgAXjxuA8gItmjvt+HDriVTvTkxYkzD3LBg8KOJQUETExACTHgML9XB7GLYkcA6aWD6TqfOMI3W1lvoUJZMCrX/waa7rinjnmUKI7SYkCILf2TqBJTRRaC0ZHMw70KINivi21EpBVr1cIom2A+3LvS1Ysb0BSoWAX5w9DED0rfH94Z97FiIo4kLrKH4vL52plYLY0p/OaFQKXHd6DQBgyVf1SekKlptUlM8AYGyVEZWSLyVUPiNihuuKEim2TlSmiLf3d3Q50egTuyZbUyQIgvjtNtddraUeRQpFbNqxcQO9+p7tCXS2FrOKknIXF1tH25bPPYrK8tPfzZrDuzYjCYqcbg8e/M92AMB1p9eI7c9yZ4rM/czME1vyo3C17pS4WWfK3+baaYOhUSmw5agZmw53pHp3ooYHosnsPgO8n8Pf83WhZZpHEUBBUVoxZXAhgMTpitweJooy5WrH5xg0KlT4Piz5l6pka4oAasvncF1ItG7WUsaJbfmJ60DjWUWpfcPoGDvQuMalLENKZ4A0U9R/+WzZ2oPY12RFcZ4Gd00/WczYyJ0p4pq8/spnLVZ7xGL4dHezDkZJvhaXT6wC4M0WZRrWFLTkc+rGVgIAhpfnZ0wQzKGgKI2YOqQYgLcDLZbOm/443tENp5tBo1QEpDflQhpo5WmU0CXBRbU3heRqDUCSKYqjjMSDoh3HLXAn4HoEENToc5QvKDrW0R3VyBbRuDEDRNacSEd9NHfa8cwnewEA99aNhMmgRmmBN5BstTlk9SoSu89CBNS81OnysIiHL3dmSOdZb244cygA4L/bGtJycG84/OWz5H8OnzOiFM9cPQlP/GRi0n93vFBQlEaMqiyAXq2EpceFfc3yi1t56WxQsV7U3sjJUElQlOzSGYe3n5tzvAPNHOPcMylDS/KQp1Gi2+nGgQRcjy63RwzepCl2k14tijOjKaE1SYbBZgpipqifG+6jK3ah0+7C+IEm/GRqNQCg2KCBIHgzs20ylov9c8+CB9QalUIc4RNp6a7TnhkeRb0ZU2XEtKHFcHsY/rXpWKp3Jyr8w2CTf84FQcDlkwZiVKUx6b87XigoSiNUSgUmVRcCSIyuKFEia05NqX+7yRZZc6h85qW9H11IJCgUAkb4OsH2NckfFPEbuULo66XkL6FFExRlzjBYDvcqOtHREzI7vPlIB97eeBQA8OBlY8UvNCqlQixRt3QmICgKk2XkpbtIR31kgpt1KE4fVgIgPcexhMNmT11QlMlQUJRmTEmg2PpQm8+jSGY9EWeINFOUl5pv6ybRqyi3gyK/m3V8wSm/aTdaYhtFEQ5+Iy/O0/TJXMYUFGWQmzWnwqiDQgAcbg9abH2zLh4Pw8L3tgEAfjR5oPj5wCmNoROsP0LNPZMSbVu+KLTOwBs0Pw+Z1tHKg6JMPOephIKiNCOhQVGLvINgeyMNilLVcUCu1l78btbxfTPnWZeGKDqNIqXVFtrPKpYOtEwaBstRKxXiOQ4mtv7npqPYctSMfK0K9100qs/zouhZxg40LrQOd+2URxkUWTNkxEcwMjUoSqXQOpOhoCjNmDzYGxTVt/hniMnFIZ+maEhpgspnJWlQPhPnn+W2pogHhfH69VT6WsabEpEpCjMjjwdFexutETtqZ9IwWCn+ElpgecbS48SjK3YBAO64YHjQ0SWJyBSZxUxR6PdwtK7WmVw+y9SZilQ+iw0KitIMk0GNEeX5ACCrNwZjDId9Iz4Gyzzig5OnVYkflqkqn1H3mRfu0xSqgyhSuM1CQwKCIrEdP0imaFCRHvlar6P2gWZbv9tyuT1i5imThNaAX2x9rFdQ9PTKvWixOjCsLA/XnzE06GvlzhS5PQwWX1YnrKYo1vIZZYqShjVF5o2ZDgVFaUgiSmitNgdsDjcEwTvCIVHwgI6b0iUbEwmtAfg/wOPNFPFSVEI0Rdz5PEgArVAIorP1jhP9m0e22hxgzCvaTlVAHisDg3gV7W3sxLJ1BwEAD/5gLDQhXKB5mVquTJFFcuOXVVNkT80cLjnI9KAoLwUt+ZkMBUVpiN/Zuk22bfLOswFGHbSqxL1JHpgxBvMvGik6miYbLizuyHFHa1FoHcPcMyn+oEh+TVG48hkQnYljk6R0lgi7iUTSe9QHYwwP/mc73B6G74+pwDknl4V8rdRIUQ54g0KeRgm1MvTtwV8+y/7uM2lQlAj/uETgdHvEQbaUKYoOOltpyFRfULTlqBkOlyfkt8RoOOzrPJN7vEdvxlQZMaYqdd4UYkt+hn2rk5t2mYTW3OTTanfBanfJ+gHLNXNlITytoulA45msTGrH54ijPnxeRR9tb8BX+1qhUSnwuxljwr5W1BTJVD7zt+OHD6ajFVpncvnM6PtMYcyb8QqXQUsXpEPFSVMUHZQpSkOGluahyKCGw+XBdpmGce7yfduuSZCeKF3gZoVdDjfsLneK9yY19DjdsPu+JcYbFOVpVWJLr9wltFZb+MHBYgfacUu/Azm54DeT2vE50lEf3Q43/rB8JwDgl+cM6/dLjD9TJE9mlGdY+7vxl+V7AzlLjws9zv7fZ5nckq9TK6FTe2+Vlgz5ssVLZxqVImzGj+gLna00RBAEWXVFLrcH//7W68Z67sjQqfhsoECnAh+1k2kaALngWSKVQpAls8OFy41meYMiLg4O5X4+srIACsEbPPWXkRA9ijJMZA34NUUtVjueXb0Xxzq6UWXS4bbzhvf7Wp4pau9yRNylFw7+nukvKDLqVWIGO5LSndXuHwibiWSarsjma8en0ln0UFCUpnBd0SYZhsN+ursZTZ12lORpMH10RdzbS2cUCsH/AZajYmu/caM8E8l5W35jhPqRSGCMocXGu8+CZ4p0aiWGlnozm/35FfkzRZlXPis0qKH3zQlc9Nl+AMBvZ4yBXtO/9q/IoIGCj/qwxZ8tkl474RAEQeJqHT4oYoxl5EBYKZnWwEGdZ7FDQVGaMrXGOxz2m4Pt/ZYO+uPNDYcBAFdMGSSLPindyXVdkV9PJI9XVAU3cDTLJ7a22l2iEDRYSz5nTJVvKG1/QVEGzj3jCIIgehUxBtQOK8El4ysjeq1SIYiZNjl0RZGM+OBE2oFmd3ngdHs/wzKx+wzwNyxkTqaIPIpiJS3ukHa7HZMmTYIgCNi8eXPAc9999x3OPvts6HQ6VFdX49FHH+3z+rfffhujRo2CTqfD+PHj8eGHHwY8zxjDggULMGDAAOj1ekyfPh179+5N5CHFzYRBJqgUApo67TjaHvvMnQZzD1bvagIAcZBktmMy5LartVmGuWdSKkzyt+VzDUy+VgWdOnRGhLfl99eBlsmZIsCvK1IqBCy8bExUGT45DRw7IjBu5EQaFHE9kSAA+ZrMvEkbM658xjNF1I4fLWkRFM2fPx9VVVV9HrdYLLjwwgtRU1ODjRs34rHHHsODDz6Il156SVyzdu1aXHPNNbjpppvw7bffYubMmZg5cya2bdsmrnn00Ufx7LPPYtGiRfj666+Rl5eHuro69PTI770iFzq1EmMHer8lx1NC++fGI/Aw4LQhxRju8xDKdvxDYXOzLb9dprlnnArfzU/OoKi1n3Z8TqQdaP5hsJmXKQKAUZXe4O+602uiniwup4EjH/ERSYdVeYSu1rx0lq9RQZFhdgmcTNMUdVKmKGZSHhT997//xccff4zHH3+8z3OvvvoqHA4HFi9ejLFjx+Lqq6/GHXfcgSeffFJc88wzz+Ciiy7Cvffei9GjR+MPf/gDJk+ejOeffx6AN0v09NNP44EHHsDll1+OCRMm4OWXX8bx48fx7rvvJuswY2LK4PjE1h4Pw5vfHAEAXHVqbmSJgMy15ZeLSGZXRQPXFMnpai16FOWFD4rG+oKiA83WkF1OHg8TsySZNPdMytzvjcBL103BAzNGR/1aOQ0czRFqioDoM0WZqicCJJqiDBkfROWz2ElpUNTY2Iibb74Zr7zyCgyGvq2n69atwznnnAONxv/BWVdXh927d6O9vV1cM3369IDX1dXVYd26dQCA+vp6NDQ0BKwxmUyYNm2auCYYdrsdFosl4CfZ8A60bw7GFhSt3d+KI23dKNCpcMn4AXLuWlpTmGGiSLmRa+4ZhwcaTTIaOLaEGfEhpaxAi5I8DTwM2N0QvITWanPA7WEQhNQNIo4Xk16NC8dWQhVD+7Q/UxT/DVvUFEWQKYo0KLJmsJs1hweJmdKSL5bPMrRcmUpSFhQxxnD99dfj1ltvxdSpU4OuaWhoQEVFYLcU/3dDQ0PYNdLnpa8LtiYYjzzyCEwmk/hTXZ38TMvUId6gaFeDRfxgiYbXfQLrmZMGRtTJki1wTVF7jpbPOuQWWktGfcjl6MvnnoVqx+cIgiCagYYqofF2/JI8TUxBRaZTJqemiLfkRxBQc/1Wf783k92sOZlWPrP6WvIpUxQ9sn+C3HfffRAEIezPrl278Nxzz6GzsxP333+/3LsgC/fffz/MZrP4c+TIkaTvQ4VRh4GFengYsOVIR1SvbbM58PF2b9B39Wm5UzoDqPusPYoSSCSUFWghCIDLw9AmU6DJy2eRZHa4rihUBxrXtJRlqMg6XmTVFHVF5lMk/b3N/ZRVLVlUPsuUoIiE1rEj+1V699134/rrrw+7ZtiwYVi9ejXWrVsHrTbwm+LUqVPx05/+FMuWLUNlZSUaGxsDnuf/rqysFP8bbI30ef7YgAEDAtZMmjQp5D5qtdo++5YKptQU4VhHNzYeaseZw0sjft2/Nh2F080wfqAJY31tzblCUV5u+xSZZZp7xlErFSjJ06LFakeDuaffklck8In2kWzL34EWPChqznCRdbzwcxjv/DPGGMzdkWcZxaDIagdjLGTHnLUn8z1zMs2nyJYFJctUIXumqKysDKNGjQr7o9Fo8Oyzz2LLli3YvHkzNm/eLLbRv/nmm/jjH/8IAKitrcXnn38Op9N/Ia5cuRIjR45EUVGRuGbVqlUB+7By5UrU1tYCAIYOHYrKysqANRaLBV9//bW4Jp0RdUVRiK0ZY3hjgzezlWtZIsAfDGSKKFJueNlQLk0RAFSa5O1Aa7GGH/EhZcwAb1C/80Rn0PId36eKDPQokgNpcBIP3U636CcUiaaIZ/mcbhY2g+IXWmdw+SzDmjesJLSOmZQV4AcPHoxx48aJPyeffDIA4KSTTsKgQYMAANdeey00Gg1uuukmbN++HW+++SaeeeYZzJs3T9zOr371K6xYsQJPPPEEdu3ahQcffBDffPMN5s6dC8CrSbjzzjvx8MMP4/3338fWrVvx85//HFVVVZg5c2bSjztaeFD07aH2iPUcGw+1Y1+TFXq1EpdN7Gt1kO3wD7BM+VYnN9HoQiKFGzg2yiS29pfP+g9khpXlQaNUwGp3BfXsynSPonjh57CjyykaYsYCf7+olQIMEWgQtSqlWKIN15bPNUXGDM5aZFz5zJH52blUkdaqRJPJhI8//hj19fWYMmUK7r77bixYsAC33HKLuOaMM87Aa6+9hpdeegkTJ07EP//5T7z77rsYN26cuGb+/Pm4/fbbccstt+DUU0+F1WrFihUroNOl/4foqMoCGDRKdNpd2Ntkjeg1PEt06YQBGf3tLFYKc3jMB2NMFFoXySS0BvwGjnK15bdaw4/4kKJWKjCiwuuxFUxXlMlzz+SgUK+G0uf/w8uSsSDVE0VqHlkWgZt2ZxaVzzp7XHDL1GyQSEShNXWfRU3anLEhQ4YEHWcxYcIEfPHFF2Ffe+WVV+LKK68M+bwgCHjooYfw0EMPxb2fyUalVGBSdSHW7m/FxkPtGOkzeQuFpceJ5d8dB5CbpTPAr4fotLvgdHtyakp0l0NSApGzfCa25ccfFDlcHvEbd0leZIHMmAFGbD9uwc4TFlw0LnAEhj9TlJtBkUIhoDRfg0aLHS2dDgww6WPaTjTGjZyyAi32NlnDBkX+YbBpc7uJGuk5sXQ7UdSPv1aqsfqyc1Q+i57cuVtkMH5dUVu/a9/ffBw9Tg9GlOdjss/8MdeQpukzxVdELrieSKNSiENG5YDrdeTIFPHBpSrJ8N7+CNeBJrpZZ6hxoxz4R33E/vexdEfvhO53tQ79ey1Z0JKvViqQ5yspZkIJzebLFGVydi5VUFCUAfCgaFMEYus3fN5EV51aLcuE9ExEpVSI30pzrS2/QzL3TM6/v9+rKH5NEdcTFedpIh77EGrcB2NMzFLkaqYIkMfAsSOGmXmRGDiK5bMMzhQBmaUr8jtaU0t+tFBQlAGc4sv4HGztCtt2u+2YGduOWaBRKvCjyYOStXtpSWGOiq39btbypvelBo7xIo74iKK1f4wvKDra3h1wU+rocsLh9oqLy3I4KJJjKKwo0Jc5KMqG8hmQOUNhGWMktI4DCooyAJNejZN9QtNw2SKeJbpwbAWK07zmnWjEtvwMcbXu6HIE1dRFvR2uC5FRTwT4NUVtNgfsruAzyCIlGpE1x2RQY6BvkvwuSbaI64kKDWpoVbn7rTjSkRvhEIXWUVw7kbha+7vPMrd8Bkjnn6V3UNTtdINrwUlTFD0UFGUIvIS28XDwoKjb4cZ733oF1tecNjhp+5WuZFKm6O9f1uOUP6zEC5/ui3tb7TLPPeMUGtTQqLwfF/HOQIvGuFFKMBNHrmWpyNF2fI4cmSL/3LPIg1UejIW7JrJhICyQOYOmeWZOEBCRtQIRCAVFGQIXTW8MMRz2g60n0Gl3obpYj9phJcnctbSEi0XT/VvdR9sb8PAHO8AY8OW+lri3Z+Zzz2Rys+YIgiCKreMtoYnGjVFmM8eIuiL/YNhGUWSdu6UzQJ5RH3436xjKZyGCMbeHocuRHaJfnilK9+YNUWStUeWsrjQeKCjKEKYOKQYAfHfMHLR88aavdHb1qYMjFq9mM36vovQtn207Zsadb2wGr5odaLbFvU1x7lme/KWKSpnE1qJxY5QaIFFs3dA3U5TLeiLAX4qMZ9RHRwwz88okxpHBPpf4iA8gs7vPgMwRWtvIzTouKCjKEIaUGFCcp4HD5cH244EdOPuaOrHhYDuUCgE/npLbAmuOWD5L0w+wBnMPblq2Ad1ON04b6g14mzrtov4iVjpknnsmhbe8x9uWH2umiAdFuxo64fKJq8V2/Bwvn5XLqCkyRiG0LjSooVZ6v4Txv6sU3o6vVSnE8mum4p9/lr5ftAB/uZI6z2Ijs6/SHEIQBLGE1lts/abPwfr8keVil1Cuk84DHG12F25atgGNFjtGlOfjb7OmipqQ+pb4skUdCZh7xpHLwLE1xkzR4GID8jRKOFwe8TzxICBX555x+PVj6XHFLIT3a4oiv3YEQQjrap0teiIAMPlK8pmSKcr0cmWqoKAogxBNHCW6IrvLjXc2HQMAXH1qbjpYByNdNUVuD8Ov3tiM7cctKMnTYPH1p8KoU2NYWR6A+EtoHd3Rl0AiRS4DR7H7LEI3a45CIWBULxNHrm/K9UyRSR8+YxMJ5hjMG4HwnW/+dvzMLp0BGVQ+c1D5LB4oKMogpg7xd6Dx9u1PdjShzeZAhVGL80aWpXL30op01RT9+b878cnORmhUCrz086moLjYAAE4Sg6LI5tuFgjtaR3tjiwSehWwwxx4UMcbE7rOSKFryObwDjQdF4oiPHM8UCYIgZotiEVs73R4xgIkmUwQAZbwtP2imiLtZZ/4N2h8UufpZmVqspCmKCwqKMojxA01QKwU0d9rFaeHcm+jKKdVQ5dCMr/5IR03Ra18fxl+/qAcAPH7lRDHzBwDDSr0+VAfiLJ+ZYxDLRgoPisJNRO8PS7dLnM0WS1A0ZoAJgLcDjTHmHwab40JrQNKWH8PfR5r9iEZTBEja8oOM+siGYbAcU5p+0eoNlc/ig+6iGYROrcTYKu9NYeOhdhxp68IXe71t3FdR6SwAHhS029LjA+zLvS343XvbAADzvn8yLptYFfD80NL4y2eMMTEIlNvRGvBrihrMPTEbTbb4skQFOlVMZotSr6JOuws9Tq/gOtfLZ4CkLT+GDjQeFBXoVFBG2b0arnzWmSVu1oAk+5xGX7SCYfW15JPQOjYoKMowpMNh3/rGK7A+a3ipWIYhvJh83VeWHhfcnvidouNhX1MnZr+6EW4Pww9PGYjbvze8zxquKapvscET4/522v3HGs2ohkjhmaJup1u82UULL+1Ea9zIGVlZAEHw3oC3H/OW0Ap0KujJpE5sy48lUxRLOz4nbFCUBcNgOfw9ZXO44fR1P6Yj/kxR5p/zVEBBUYYx1RcUra9vw9vfHAUAXH0aZYl6I/1wT6XZWqvVjhuWbkBnjwunDinCn68YH9RQrbrYAJVCQLfTHbOQucPmPU69WgmdWv4gQa9Rwuj7xt8Yo66o1Rb9iA8pBo1KzKp9vrcZAJXOOPFlimI3/SwXy2fZ3X0mLSums4GjPyiiLwqxQEFRhjHZFxTtabSiwdKDIoMa3x9TkeK9Sj/USoVYU0+VrqjH6cYtr2zEkbZuDC424C/XTQ1ZMlIrFRhc4s32xVpC64jBkThaKk3xGTjydvySKDvPpHC/ojW7eVBEpTPAn32LpftMnHsWQ4YxbPcZD4qyQN+iVAjicaSTVrE3JLSODwqKMowKow6DivTiv6+YPCinB2GGI5Vma4wx/Pqd77DxUDsKdCosvv7Ufof0+sXWsXWgiW7WCdATcSriNHBs5u34BbHvo3/ch8W3T5QpAuIbCst1MrEMEi6TzF3rrTXLpvIZ4D8/6awroqAoPigoykCkXUtUOgtNKjvQnlm1F+9tPg6VQsCin03B8PL8fl9zUpxeRR3i3LPE3YAqxFEfMZbPZMgU8aCIU06GpQCkmaI4NEVxZIocLg8svdrVs6l8BmSGVxF1n8UHBUUZyLSh3oGvpw4pwvDyghTvTfoiTrVOsqv1e5uP4elP9gIA/jBzHM4cXhrR67jYen+MXkX8xlaUgLlnnHiHwopzz2LUFAH+8hmHNEVe5MgUxVJ61an9WrNma+B1IbbkZ1lQlM6aIn/3WXac82RDZy0DuXLqILg8HlwwmrRE4eCi0WSWz3Yct+Def34HALjlnGG45rTBEb92WJk3mxTrqA+/LiRx5bPKOA0cRTfrGLvPAG9gVmRQi+XCXB8Gy+Hn1GtV4I5KbM/fI7F2LZYVaGHpcaGp0x7wRa0zixytgfQeH8QhoXV8UKYoA1ErFfh57RAMLNT3vziHMSW5fMYYw8L3t8Hh8uB7o8rx64tGRfV63lV1rKMbPc7o51e1J3DuGUcsn8Vo4Mi7z0riCIoEQcCYKn+2iITWXow6lTh0NdpskX/uWWwBdagsVTY5WgOS7HMaZ4pspCmKCwqKiKylMMnf6t7bfBwbDrZDr1bijz8cF7UJXkmeBkadCowBB1ujzxbFUwKJFDEoijFTxH2KYnGzljK60h8UkdDai3Q4a7S6oo44hNaAPzDtGxRlT/cZ4G/LT+egyEqaorigoIjIWkShdRLKZ1a7C3/6cCcAYO73hmOAKfosniAIYgktFrF1IueecXhLfrPVHrUpZo/E9DGe8hmAwEwRCa1FYjVwNMchtAaCZ4oYY1k1EBZIf6G1y+2B3eU1lqSgKDYoKCKyFlFTlIQPsOdX70NTpx01JQbcdNbQmLczLI7BsPF0EEVKSZ4GCgFwe5jYSRYpbb7SmUapEIW5sTJuoHfcjVGnog9/CX4Dx+i+CMSbKQoWFHU73WLgnC3ls3TXFNns/rI7lc9ig84akbX4M0WJ/QA70GzF3788AAD43YwxcblJnxRHpohnxIr68UOKB5VSgbICLRotdjRYeqLK0vCSTkm+JqirdzScXFGA314yOsCzi4itLZ8xFremKJirNS+dKQTAkCVjWPj5SdfuM6vDe841KgXUNCA8JigoIrIWXkZKZKqbMYaHlu+A081w3sgyXDC6PK7tDfOJrffH0IHW0Z34TBHg1RU1WuxRu1rzzrN49UScm88ZJst2solY2vKtkpl5serRgv1esR1fq4o7CE4X0r18Zu0hPVG8UChJZC3J0BSt3tWENbuboVYKWHDpmLg//MW2/GZrVJPo3R7Jt/0EaoqA2F2tm2UwbiTCE0umiGdStSpFzFlOMSiySoOi7HKzBjIgKBI7z7IjM5cKKCgispZCyQdYrJPnw9HjdOOh5TsAADeeNVQMaOKhpsQAQQAsPS6xfT0SOnuc4DFUrF4zkcK9ipqiDIrk8CgiwhNLpkgc8RHHdcO7z9psDnGCfLa5WQMSTVF38kcHRYLYjq/JnnOebCgoIrIW3j7rYX4TOTn5+5f1ONTahfICLW7/3ghZtqlTK0X/qWh0RdzIMF/r96pJFLwFPloDx1YZ3KyJ8MSSKZLDyqFQr4bKZ0HBf7e/8yx7btBciN7j9MDuit5LLNHQiI/4oaCIyFp0aiX0vnKA3KM+Tpi78fzqfQCA31wyWtYPIX9bfuQdaPE6EkdDrOUzqdCaSAyxZIr8XYux/10UCkEMyPjvzsbyWYFWBV4hT8cSGg2DjR8Kioisxj8UVt50958+3IVupxtTa4pw+aQqWbfNxdYHohBbJ2PuGadCLJ9FKbS2Ufks0fAsnM3hRpcjsuwof2/E2o7P6R2QZWP5TKEQYNSl7/wzMVOURec82VBQRGQ1ifAV+d+BVvxny3EIAvDgZWNl76w5KQavIn5ji+fbfqRwA8foM0Xxj/ggwpOvVUGn9n6st3RG9kXAPzMvvqCod1u+JUs7odLZq8jm8Jb08klTFDMUFBFZDc8UtcvUgeZye/Dg+9sBANeeNlg0EZSTWFyt223xme9FQ4VPVGvudkY1o00snyXQRynXEQRJGStCXZFFJiuH3pkia092uVlz0nn+GZXP4oeCIiKr4ZkTuT7AXlt/GLsaOmHSq3HPhSNl2WZvuKv14bYusZOnP7hHUSKHwXKMen82ojHCbJHHw0RHa5pqn1iiFVuLmiLZy2fZNQyWk85t+X6fImrJjxUKioishmts5Eh1t9kceOLjPQCAey48OWHO0ZVGHfRqJVwehiNtXRG9hgutk1E+EwRBbMuP1MDR3O0UDQKLKVOUUKIVW/s1RfH9XfzlM2+gnI2aIiC9h8LaKFMUNxQUEVmNic8/kyEoevzj3TB3OzF6gBHXTquJe3uhEAQBQ7nYOsISmlzf9iOlPMoONJ61KDSoafxAgok1UxSvpqhP+SwLW/KB9NYUUfksfujTichq5Oo+23bMjNfXHwYAPPiDMVAqEju2QBwM2xKZ2JprphLtZs0RM0URehWJImvKEiWcaDNFZrk1RdZe5TNtlmmK0jlT5MhOcXsyoaCIyGrED7A4vtUxxrDw/e1gDLhsYhWmDSuRa/dCEq3Y2pxETRHgN3CMVFPk9ygiPVGiKfO15UeaKZLDvNH7e72BcnOnHYyxrC2f8UxROrbkW+3exgfKFMUOBUVEVuPPFMX+Afbvb49h46F2GDRK/OaS0XLtWlj8bfmRBUX+TFGygqLoymfczbqMgqKEE7WmSAbzRunv7XF60Gl3iS7y2eaZk85Ca3K0jh8Kioisxq8piq18ZrW78Mh/dwEA5pw/XPToSTTDSn2ZogjLZ35NUXLKU9EaOHLjRnKzTjx+TVH/17zd5Ua3z1YhXk2RXqNEge9m3NxpF8tnxixryffPP6OgKBuhoIjIauL1FHlu1V40d9pRU2LAL84eKueuhWWoL1PUYnX0u+8ut0csVcSrC4mUaA0c/R5FlClKNNFkivi1JQjylLn47z7R0YMep9dOIuvKZxnhU0Qt+bFCQRGR1Yjlsy4nGB8jHyFH2rqw+Kt6AMCCS8dAq0reB02+ViXqdur7Gfch/XBOxuwzwC+0brD0RHReedaitIAyRYmGZ4q6nW4xcxAKs6TzTCFD8wAPiqQZzmzTt6Rr+YwxRpkiGaCgiMhquE7C5WHit6hI+esXB+B0M5w1vBQXjK5IxO6Fxd+WH76E1t7lN8lTJandnd/8HC5PRDeHVsoUJY08rQoGjTeA709s3SFT5xlHDIp8Wji9Wpl1FgwmSfNGtF+0Ekm30w2fFVjWBaLJJLuuVoLohU6tgEblvcyj8RVpsznw1jdHAAC3nXdSQvatPyLtQDP77AaKkqQnAgCdWil2ukVSQuOZojLKFCWF3hPrQyGXRxGHB0X7fYF8tpXOAP+5crg9YolQDhZ9th8XPLEm4o7O3vAvfYIAMSgmooeCIiKrEQRBvHlHk+5+ed1B9Dg9GD/QhNqTEt+CH4xhpZF5FSXbuJFTEYWrNWWKkktphG35/D0Rr5s1p9w3F48H8tnWeQZ4S1Pcp0zOEto7G49if7MNn+5qiun1Nt6Or1HJPqQ6l6CgiMh6CqN0te52uLFs7UEAwC/PHZayD5iTIswUtSe584xTEaGBY7fDLU7vpu6z5BCp2No/HkbeTNFxczeA7BsGC3i/aCVCV8QzRLsaOmN6vY1E1rJAQRGR9ZiidLV+e+MRtHc5MbjYgIvGViZy18LCXa3rW2zweEJrF+S+sUVKpAaOPFuhVSlIAJokxPJZP235chk3cnhQxKU2xizMFAHSUR/xOeVzuh1uWHwdpLtjDIpoxIc8UFBEZD2FUcwqcrk9+OsXBwAAvzh7aNKEy8EYVGSARqmA3eXBsY7ukOv4cSXLzZpTGaGBI/coKs3XUlo/SUSeKZJZU9TLnDMbNUWA/ENhpe+h3Y2dMQm4eaaogIKiuEh5UPTBBx9g2rRp0Ov1KCoqwsyZMwOeP3z4MGbMmAGDwYDy8nLce++9cLkCu4jWrFmDyZMnQ6vVYvjw4Vi6dGmf3/PCCy9gyJAh0Ol0mDZtGtavX5/AoyLSiWi8ilZsb8CRtm4UGdS4ckp1onctLEqFgJoSA4DwbflyTTmPlgoT1xT1kynq5CM+qHSWLCIdCitqimQKisqNgUFRtmYG5Z5/Jn0PtdkcERlv9oYyRfKQ0qDonXfewXXXXYcbbrgBW7ZswVdffYVrr71WfN7tdmPGjBlwOBxYu3Ytli1bhqVLl2LBggXimvr6esyYMQPnn38+Nm/ejDvvvBO/+MUv8NFHH4lr3nzzTcybNw8LFy7Epk2bMHHiRNTV1aGpKTZBG5FZcK1Nf6luxhj+8pk3SzTrjCHQp0EHhzgYNkxbfnuKMkUVBZEJrVtt3udLacRH0og4U9Qtrx6tyKAJGJacjZoiQH6vot5fLGIpodlo7pkspCwocrlc+NWvfoXHHnsMt956K04++WSMGTMGP/nJT8Q1H3/8MXbs2IF//OMfmDRpEi6++GL84Q9/wAsvvACHw3uDW7RoEYYOHYonnngCo0ePxty5c/HjH/8YTz31lLidJ598EjfffDNuuOEGjBkzBosWLYLBYMDixYuTftxE8jFFWD5bt78VW4+ZoVMr8PPaIUnYs/4ZKo77CJ0pMqeo+yxSV2v+rbckjzJFySLiTJHMejSlQgj4O2dr+SzRQdGuBkvU27DavfuSrdm5ZJGyoGjTpk04duwYFAoFTjnlFAwYMAAXX3wxtm3bJq5Zt24dxo8fj4oKv3FeXV0dLBYLtm/fLq6ZPn16wLbr6uqwbt06AIDD4cDGjRsD1igUCkyfPl1cEwy73Q6LxRLwQ2QmkQ6F/cvn3izRT6ZWozhNbuDDIhgM6x8Gm9x95qWSFqsdLndovxZ+Yy4toExRsigv8P9twulTOsSWfPkCamkJLVtv0HIHRQ1m73uEZ9n2NEafKbKKmaLUZ7gzmZQFRQcOeG9ADz74IB544AEsX74cRUVFOO+889DW1gYAaGhoCAiIAIj/bmhoCLvGYrGgu7sbLS0tcLvdQdfwbQTjkUcegclkEn+qq1OrLyFipzCCobA7T1jw2Z5mKATgF2cNS9au9ctJEZTP/FPOk5spKs3TQqkQwBjQHCYj0UqZoqTDM0U9Tk9YJ3ezzI7WQKDYOtuGwXLinanYG54pmjy4EECs5TPSFMmB7EHRfffdB0EQwv7s2rULHo/3m+Vvf/tbXHHFFZgyZQqWLFkCQRDw9ttvy71bUXP//ffDbDaLP0eOHEn1LhExIp1/FoqXfFmiS8YPwGCfuDkdGOYrnx0396DLEfzmxoO9ZDpaA4BCIYgZiXC6IjFTRJqipKHXKMUsTSjRrsfDJOaNMgZFkoxgtpbP5O4+40HROSPKAAB7Gq1hbTiCIc4902TnOU8Wsp+9u+++G9dff33YNcOGDcOJEycAAGPGjBEf12q1GDZsGA4fPgwAqKys7NMl1tjYKD7H/8sfk64xGo3Q6/VQKpVQKpVB1/BtBEOr1UKrpQ/xbKC/8tmxjm68v+U4AOCX56RmpEcoivI0KDKo0d7lRH2LDWOrTAHPO1we0Rgx2ZoiwGvgeMLcgwZzDxAimcozRRQUJZfSfA2sdheaO+3iHD0pnT0u0U9IzkHC0qAoGx2tgch1ipHCdXnThpVAo1Kg2+nGkfYu1JT0/buFgrrP5EH2TFFZWRlGjRoV9kej0WDKlCnQarXYvXu3+Fqn04mDBw+ipqYGAFBbW4utW7cGdImtXLkSRqNRDKZqa2uxatWqgH1YuXIlamtrAUD8XdI1Ho8Hq1atEtcQ2Q3X2oQa4Lj4y3q4PQxnDi/B+EGmPs+nGj4DLVhbPm/HF4TUlCoqjf235fPuM2rJTy79ia35taNXK6FVyadD4aM+gOzvPrPIkClijKHJl2mtKtRhRLn3/R6ts7WYKcrSQDRZpExTZDQaceutt2LhwoX4+OOPsXv3bsyePRsAcOWVVwIALrzwQowZMwbXXXcdtmzZgo8++ggPPPAA5syZI2Zxbr31Vhw4cADz58/Hrl278OKLL+Ktt97CXXfdJf6uefPm4a9//SuWLVuGnTt3Yvbs2bDZbLjhhhuSf+BE0imUDHDsdroDnjN3OfH6em9m8pY0yxJxxBloQcTWZon5nkKRfGPE/lyt3R6GNp95IwVFyaW/tny53ax7/14ge8tncmqK2ruccPgaFcoLdBhZUQAgel0Rb8nPVnF7skjp2XvsscegUqlw3XXXobu7G9OmTcPq1atRVFQEAFAqlVi+fDlmz56N2tpa5OXlYdasWXjooYfEbQwdOhQffPAB7rrrLjzzzDMYNGgQ/va3v6Gurk5cc9VVV6G5uRkLFixAQ0MDJk2ahBUrVvQRXxPZiUGjhFopwOlm6OhywiCpuf/j60PocrgxqrIA54woTeFehmZoGLG136MoNQFHRT9t+e1dDniYN5NVnKJ9zFX6zRTJ7GbNCQiKsvQGLe0+Y4zF5dTe4JsdWJKngUalwMjK2IIiKp/JQ0rPnlqtxuOPP47HH3885Jqamhp8+OGHYbdz3nnn4dtvvw27Zu7cuZg7d25M+0lkNt4Bjhq0WO3o6HKiqlAPAOhxurHkq4MAgFvPPSltR1AMC+NVxEXWct/YIoUbODaFEFpzPVGRQZPSkSm5SH+Zoo4EZYrKAzJF2V0+c3kYbA53XNkZnmXlA5bFoCjKtnybrxEjn1ry44I+pYicoDDIUNh/f3sMLVY7BhbqMWPCgFTtWr+cJPEq6q2JStXcM05/Bo48S0Ht+Mmnv0yROUEBdVWhHsPK8jCpuhA6dXbeYvRqb/YZiL+ExoMi/l4aVWkE4NUQ2l3ukK/rjbWHMkVyQGePyAnEWUW+IMLtYfirrw3/xrOGQp3GWYzBJQYoBIidROVGv5CVB3nJNm7k9Kcponb81CFmikK05Ps9iuS9dtRKBT6+8xzRgiUbkWafzV1ODPRln2OhQcwUacX/GnUqWHpc2Ndk7dNxGgqxfEYt+XGRvncCgpCR3m35K3c04kCLDSa9Glefmt7GnFqVEtXFXu+k/b3E1u0pGvHB4Sn/zh5XUB8l0biRRNZJp9R3zltClc8SeO2olIqAGWjZiEnvDT7izxR5/z78vSQIgpgtitTZ2uX2wO7yirVJaB0fFBQROYHJ9224vcvhHfz6+X4AwHWn12REulnsQGsJFFv73axTE3QU6NTI8w3O5YJRKZQpSh3+TFHwUR+JGPGRS/jF1tFPtJfSW1ME+HVFkbbl884zgMpn8UJBEZETcM2NucuJbw6149vDHdCoFJh1xpDU7liEiF5FvTJFopt1XupubBWiV1HfjITfuJEyRcmGB6IOlweWnr5ZvER1n+UKcs0/418mKiVB0clRdqBZfVlajVIBjYpu6/FAZ4/ICaSjPv7ymTdLdMXkQQHtw+mMOBi2pXdQlPobW0UYA0dRaE2ZoqSjUytFn6BgYmtLgjRFuYJoChtnUNTU2TdTNMoXFO2JOFNExo1yQUERkROYfB9gmw6345OdTRAE4Oazh6Z4ryJnaGlwr6L2FM09kxJObN1ioxEfqYQPZw3Wlu8X6VOmKBbkyBQ5XB5xNh1/HwHAyT4Dx+Pmnoi27/coonb8eKGgiMgJePfZ3iZvUFE3plIsSWUCJ/n29Uh7Nxw+QSWQOFfiaAhn4NhqpREfqSRcW346ZBkzGaMM8894lkijVKBYYlth0qsxwPe+ikRsbaPOM9mgoIjICXoHDb88d1iK9iQ2ygu0yNMo4fYwHG7zl9DSIlNUELx8xhjzC63zKFOUCsIZOIpCawqKYkKOTBHX4ZUbtX3sC6IRW4vlMxJZxw0FRUROINVNnDa0GKcMLkrh3kSPIAhiZou35fc43ehxerNGqewg4qZzvYXWXQ7//pUWUKYoFYht+b0yRT1Ot5hxpPJZbBTKEhT11RNxRkahK+ok40bZoKCIyAmkH/y/PCezskScYRJna8CftlcqhJTOmOIf6L1b8nnnmV6tDJg3RySPUJki6bVD2YXY4JkiiwxBUWWQoGhUFB1olCmSDzqDRE5QVajH2SNKYdAocf7I8lTvTkzwGWj1Pq8iUSirV6fUOZgLRJs6ewKGYzbz0hlliVKGX1MU6KWTLtdOJmPqZQgbC1yHV27sW17mYutdDZZ+h87aHF6fIhJaxw8FRUROoFQIeOWmaanejbjonSlqt6VeZA0A5T5NkdPN0GZziO33osia9EQpg2eKepfPSGQdP7JoioJ4FHGGl+dDqRBg6XGh0WIXy9TB8Hef0S09Xqh8RhAZgtiW7/MqMqd47hlHo1KIA1+luqIWMm5MOaUhWvLN5GYdN4WS8pnH09cxPBL4+yVYwKNVKcX3/K4GS9jtUPlMPigoIogMgWeK2mwOdHQ5xLlnRWlwYwtm4NhKIz5SjjRTJB31YRbHw6T+2slUeEu+h/kdpaOFv194trU3Iysi0xVZKSiSDQqKCCJDMGhUonfJ/mabpASS+kwM1xVJvYpabTQMNtXwc+90s4AyT0eaZBkzGZ1aCa1vpIY5Bq8ixpj4fglVGuMdaLv78SqyUflMNigoIogMwq8rsvrnnqVBpsjflu8PippJU5RytCqlqH2R6opIUyQP8eiKrHYXunwC6YogQmtAEhT1kyniA2EpUxQ/FBQRRAbBO9AOtPgzRakWWgP9lM8yZL5ctsI1XU0SXZGZjBtlgb/3YgmK+HulQKcKaVnBy2d7m6xwuT1B1wBAJ2WKZIOCIoLIIKSZIu5mnQ4lEH9Q5L/xcp+i0rzU718u49cV+dvyO9JgPEw2EE+mqMHsE1kH6TzjDC42QK9WwuHy4GBrV8h1Npp9JhsUFBFEBsFdretbbGl1Y6sMYuDYQpmitCBYB5o5jbKMmYwpjvlnjf3oiQBAoRBwcoX3PR9uBhp1n8kHBUUEkUEM87XoHmztEstTqZx7ximXGDgCgMvtEbvjSihTlFKCDYXlQmsqn8WHMZ5MUT+dZ5xIZqCRT5F80BkkiAyiqlAPjUoBh8uDep9fUTrc2HimqMXqgMPlEUXgCiE9ynu5jFg+C6opor9NPPCZirEERU1ipih8JvVksS0/uFcRY4wyRTJCmSKCyCCUCgFDS7zZIu4XV5QGmZgigwZqpXcMQVNnj6hfKc7TQqmgMRKppIyXz4J0n1H5LD7i0hSFGQYrZVSlEQCwp9Ea9Pkep0f8LKCgKH4oKCKIDIOLrTnpYMCnUAhiGaDRYkerjRs3pj5gy3V6j/pwuT3iVPV0uHYyGZPeG4Rwd/loaPA1JfQXFPHy2cFWG7p9LfxSeOlMEACDhoTW8UJBEUFkGNKgSKNUpM0HodSriN+Aybgx9fQWWlt6/O7LRgqK4sIUR0u+WD7rJygqzdegOE8DxoC9TX11RWLnmUZFw31lgIIigsgwuFcR4P1QTpcPQm5A12jp8bfj04iPlMMzRa1WBzwev7N1vlYFtZJuAfEQq6bI7WGib1R/mSJBEES/omBiayu148sKvSMIIsOQZorSwc2awz/cGyx+TRG5Wacenq1zeRg6up2iCD4dBPqZTqzdZ61WO9weBoUQWYmZl9D2hA2KSE8kB3QWCSLDkGaKCtOoe4gHRU0WuyiuLi1In/3LVdRKBYoMarR3OdFitaeVv1WmE6tPETc5LSvQQhVBtm5UmBlo1HkmL5QpIogMw2RQi94/6XRjkxo4iiM+KFOUFkh1RWaaeyYb/P3X2eOCm7eARUCknWeck8N4FVklmiIifigoIogMhJfQ0ikoKpdqimy+8hkJrdMCaQeamTJFsiENLDt7Is8WNUYbFPk0Rc2ddrTZAjvd+DBYKp/JAwVFBJGBnOQb95EOHkWcSslQWG4USELr9ECaKeroIuNGuVBLuj+j0RU1Rth5xsnXqlBdrAcA7O6VLfKXz0hoLQcUFBFEBvLz2iG4aGwlrpwyKNW7IsK/9docbrE8QJmi9KBUYuDIR3xQpkgeYtEV8RmBvGMzEkaGcLbm5bN8HWWK5ICCIoLIQMZUGbHouikYXl6Q6l0RydOqUOBL4XN5BWWK0gP/qA8HaYpkJhZX68YI2/GljBTF1oHO1jbqPpMVCooIgpCNCsnE73ytCjo1pfTTAd723SzVFFFQJAsxBUXm6DRFADDSN+6jd6bI5vBlikhoLQsUFBEEIRvScgCVztIH6VBYasmXl1iCogZxGGwUQZGvfLan0QrG/J1uVhJaywoFRQRByIb0m29JGonAc50ATZFo3kh/HzmINijqcbrFtdFkioaV5UGtFGC1u3C0vVt83Nrjdygn4oeCIoIgZEP6IU96ovSh3JcparM50E6aIlkpjHL+Ge8806kVMEYhjlYrFWLX6R6JiSO15MsLBUUEQciGtMW4hIKitKE4TwNB8M7c4j43VD6TBzFTFGH3Ge88qzTqop5bODKIiSPNPpMXCooIgpANaaaojDRFaYNKqUCxIfDvQUGRPERbPoul84xzstiWL8kUOWjMh5xQUEQQhGwECq0pU5ROSMuZGqUCeuoMlAU+FJb7P/VHLJ1nHD4DLbB8Rj5FckJBEUEQsiHtpqHus/SCd6AB3ht5tKUbIjiFvgycudsV0frGGDrPOLx8tr/ZCqfbA4Bmn8kNBUUEQchGab4W/F5LQuv0olQSpFLpTD54+cwSYfks2mGwUgYW6pGvVcHpZjjQbIPL7UGP0xscUflMHigoIghCNniHjEIAakoMqd4dQoI0SCXjRvmIWlNkiX7EB0cQBJxc4e1A293YCZvDLT5H3WfyQGeRIAhZWXL9qWix2jHApE/1rhASpOUzyhTJBw+KrHYXnG4P1MrwuYZGi1doHekw2N6MrDRi0+EO7G6wYEpNEQCvRkyjohyHHFBQRBCErFQXG1BdTFmidEOaKTJSpkg2pF5Dlm5n2AYDxlhc5TPAL7be3dApmXtGonm5oNCSIAgiBwjIFJGbtWyolApxEHJ/JbSOLiccLq8GqDyG8hngb8vf1dAp8Sii/IZcUFBEEASRAwRoiqh8JivGCHVFjZ3eLFFxngZaVWzZHZ4pOtrejSZfKY5E1vJBQRFBEEQOQJqixGESvYrCB0Xczbq8IPbOzKI8jfj6b4+0A6BMkZxQUEQQBJEDFOdpoPDZJdDcM3nhQWZ/bfnxeBRJ4X5Fmw55gyLKFMlHSoOiPXv24PLLL0dpaSmMRiPOOussfPrppwFrDh8+jBkzZsBgMKC8vBz33nsvXK5Ak6w1a9Zg8uTJ0Gq1GD58OJYuXdrnd73wwgsYMmQIdDodpk2bhvXr1yfy0AiCINIKpUJAcZ43w0BBkbxE2pYfb+cZZ6RPV7TlqBkABUVyktKg6NJLL4XL5cLq1auxceNGTJw4EZdeeikaGhoAAG63GzNmzIDD4cDatWuxbNkyLF26FAsWLBC3UV9fjxkzZuD888/H5s2bceedd+IXv/gFPvroI3HNm2++iXnz5mHhwoXYtGkTJk6ciLq6OjQ1NSX9mAmCIFLFqUOKoFMrMKrSmOpdySoiHQrLO8/K4w2KfJkiLtqm7jP5SFlQ1NLSgr179+K+++7DhAkTMGLECPz5z39GV1cXtm3bBgD4+OOPsWPHDvzjH//ApEmTcPHFF+MPf/gDXnjhBTgc3jkzixYtwtChQ/HEE09g9OjRmDt3Ln784x/jqaeeEn/Xk08+iZtvvhk33HADxowZg0WLFsFgMGDx4sUh989ut8NisQT8EARBZDIvXDsZG347Pe7yDRFIpJqiJl4+kyko4pCmSD5SFhSVlJRg5MiRePnll2Gz2eByufCXv/wF5eXlmDJlCgBg3bp1GD9+PCoqKsTX1dXVwWKxYPv27eKa6dOnB2y7rq4O69atAwA4HA5s3LgxYI1CocD06dPFNcF45JFHYDKZxJ/q6mrZjp0gCCIVKBQCCnRUOpMbkyGy8lmDqCmKbwTOiPICSEfXUflMPlIWFAmCgE8++QTffvstCgoKoNPp8OSTT2LFihUoKvK6dDY0NAQERADEf/MSW6g1FosF3d3daGlpgdvtDrqGbyMY999/P8xms/hz5MiRuI+ZIAiCyD4i1RQ1mL2aovKC+DJFeo0SQ0ryxH9Tpkg+ZA+K7rvvPgiCEPZn165dYIxhzpw5KC8vxxdffIH169dj5syZ+MEPfoATJ07IvVtRo9VqYTQaA34IgiAIojeRBEVOtwetNp/QWobyJRdbAxQUyYnsZ/Luu+/G9ddfH3bNsGHDsHr1aixfvhzt7e1iwPHiiy9i5cqVWLZsGe677z5UVlb26RJrbGwEAFRWVor/5Y9J1xiNRuj1eiiVSiiVyqBr+DYIgiAIIlYiEVo3d9rBGKBWCig2xO8ofnJlAVZs91Y78kloLRuyB0VlZWUoKyvrd11XVxcAr75HikKhgMfjVdTX1tbij3/8I5qamlBeXg4AWLlyJYxGI8aMGSOu+fDDDwO2sXLlStTW1gIANBoNpkyZglWrVmHmzJkAAI/Hg1WrVmHu3LmxHyhBEARBwD82JVymSOw8K9BBoRBCrouUURKxdZ6GMkVykTJNUW1tLYqKijBr1ixs2bIFe/bswb333iu22APAhRdeiDFjxuC6667Dli1b8NFHH+GBBx7AnDlzoNV6hWq33norDhw4gPnz52PXrl148cUX8dZbb+Guu+4Sf9e8efPw17/+FcuWLcPOnTsxe/Zs2Gw23HDDDSk5doIgCCJ7iKR81iQOgo1PZM2RdqDl6ygokouUncnS0lKsWLECv/3tb/G9730PTqcTY8eOxXvvvYeJEycCAJRKJZYvX47Zs2ejtrYWeXl5mDVrFh566CFxO0OHDsUHH3yAu+66C8888wwGDRqEv/3tb6irqxPXXHXVVWhubsaCBQvQ0NCASZMmYcWKFX3E1wRBEAQRLTwo6na6YXe5g8414yM+KuJsx+fUFBugUSngcHmo+0xGUnomp06dGmCyGIyampo+5bHenHfeefj222/Drpk7dy6VywiCIAjZKdCpIAgAY95sUXlB36CosdMrspYrKFIpFfjlOcOw6XA7mXHKCIWXBEEQBBEHCoUAo04Nc7cTlm5n0Jb7RrM8c8+k3H3hSNm2RXihgbAEQRAEESf96YoaZNYUEYmBgiKCIAiCiJP+gqJGi7yaIiIxUFBEEARBEHEizj8L4VXUaJFXU0QkBgqKCIIgCCJOws0/s9pdsNpdAOIfBkskFgqKCIIgCCJOwpXPeOmsQKuikRxpDgVFBEEQBBEnYYMiX+dZOYms0x4KigiCIAgiTsLNP+OdZ3K24xOJgYIigiAIgoiTwrDlMxJZZwoUFBEEQRBEnESiKaKgKP2hoIggCIIg4iSSoIg6z9IfCooIgiAIIk6M3KcoSFDUQJmijIGCIoIgCIKIk8IwPkW8+4xGfKQ/FBQRBEEQRJzw8pnD5UGP0y0+7vEwNHV6hdbUfZb+UFBEEARBEHGSr1VBqRAABGaLWm0OuDwMggCU5lOmKN2hoIggCIIg4kQQBBh1Xrdq6fwzLrIuzddCraRbbrpDfyGCIAiCkIFCgwZAYKaIOs8yCwqKCIIgCEIGjEHa8v2dZ1Q6ywQoKCIIgiAIGQjmVURu1pkFBUUEQRAEIQM8KOrocoiP8XZ8Kp9lBhQUEQRBEIQM8PlnlqDlMwqKMgEKigiCIAhCBoKXz3xBEXkUZQQUFBEEQRCEDIQLiqh8lhlQUEQQBEEQMmDqNf+sx+lGu8+ziLrPMgMKigiCIAhCBky95p81+8Z7aFUKMWAi0hsKigiCIAhCBnqXz6Qia0EQUrZfRORQUEQQBEEQMiAGRb6SWQO142ccFBQRBEEQhAxIM0WMMeo8y0AoKCIIgiAIGSj0aYpcHoYuh9sfFBWQyDpToKCIIAiCIGRAr1ZCrfRqh8zdTnHERyVlijIGCooIgiAIQgYEQZCM+nCSm3UGQkERQRAEQciEUaIraqSgKOOgoIggCIIgZKIwSFBE3WeZAwVFBEEQBCETvHx2pK0LPU4PAKCc3KwzBgqKCIIgCEImeFC0u7ETgLcjTadWpnKXiCigoIggCIIgZIIHRXt8QRGVzjILCooIgiAIQiZMBg0AYG+jFQBQTkFRRkFBEUEQBEHIBM8UdTvdAIBK0hNlFBQUEQRBEIRM8KCIQ+WzzIKCIoIgCIKQid5BEZXPMgsKigiCIAhCJvj8Mw5lijILCooIgiAIQib6lM9o7llGQUERQRAEQchE3/IZCa0zCQqKCIIgCEImpEGRUiGgNI+CokyCgiKCIAiCkAmdWgmtyntrLS/QQqEQUrxHRDRQUEQQBEEQMsKzRRUkss44KCgiCIIgCBnhQRF1nmUeFBQRBEEQhIz4M0WkJ8o0EhYU/fGPf8QZZ5wBg8GAwsLCoGsOHz6MGTNmwGAwoLy8HPfeey9cLlfAmjVr1mDy5MnQarUYPnw4li5d2mc7L7zwAoYMGQKdTodp06Zh/fr1Ac/39PRgzpw5KCkpQX5+Pq644go0NjbKdagEQRAEIcK9iiqoHT/jSFhQ5HA4cOWVV2L27NlBn3e73ZgxYwYcDgfWrl2LZcuWYenSpViwYIG4pr6+HjNmzMD555+PzZs3484778QvfvELfPTRR+KaN998E/PmzcPChQuxadMmTJw4EXV1dWhqahLX3HXXXfjPf/6Dt99+G5999hmOHz+OH/3oR4k6dIIgCCKHuWT8AAwuNuD8keWp3hUiWliCWbJkCTOZTH0e//DDD5lCoWANDQ3iY//3f//HjEYjs9vtjDHG5s+fz8aOHRvwuquuuorV1dWJ/z7ttNPYnDlzxH+73W5WVVXFHnnkEcYYYx0dHUytVrO3335bXLNz504GgK1bty7kfvf09DCz2Sz+HDlyhAFgZrM5uhNAEARBEETKMJvNEd+/U6YpWrduHcaPH4+Kigrxsbq6OlgsFmzfvl1cM3369IDX1dXVYd26dQC82aiNGzcGrFEoFJg+fbq4ZuPGjXA6nQFrRo0ahcGDB4trgvHII4/AZDKJP9XV1fEfNEEQBEEQaUvKgqKGhoaAgAiA+O+GhoawaywWC7q7u9HS0gK32x10jXQbGo2mj65JuiYY999/P8xms/hz5MiRmI6TIAiCIIjMIKqg6L777oMgCGF/du3alah9TSparRZGozHghyAIgiCI7EUVzeK7774b119/fdg1w4YNi2hblZWVfbrEeEdYZWWl+N/eXWKNjY0wGo3Q6/VQKpVQKpVB10i34XA40NHREZAtkq4hCIIgCIKIKlNUVlaGUaNGhf3RaDQRbau2thZbt24N6BJbuXIljEYjxowZI65ZtWpVwOtWrlyJ2tpaAIBGo8GUKVMC1ng8HqxatUpcM2XKFKjV6oA1u3fvxuHDh8U1BEEQBEEQUWWKouHw4cNoa2vD4cOH4Xa7sXnzZgDA8OHDkZ+fjwsvvBBjxozBddddh0cffRQNDQ144IEHMGfOHGi1XsOrW2+9Fc8//zzmz5+PG2+8EatXr8Zbb72FDz74QPw98+bNw6xZszB16lScdtppePrpp2Gz2XDDDTcAAEwmE2666SbMmzcPxcXFMBqNuP3221FbW4vTTz89UYdPEARBEESmkagWuFmzZjEAfX4+/fRTcc3BgwfZxRdfzPR6PSstLWV33303czqdAdv59NNP2aRJk5hGo2HDhg1jS5Ys6fO7nnvuOTZ48GCm0WjYaaedxv73v/8FPN/d3c1uu+02VlRUxAwGA/vhD3/ITpw4EdXxRNPSRxAEQRBEehDN/VtgjLEUxmQZg8VigclkgtlsJtE1QRAEQWQI0dy/afYZQRAEQRAEKCgiCIIgCIIAQEERQRAEQRAEAAqKCIIgCIIgAFBQRBAEQRAEAYCCIoIgCIIgCAAJNG/MNrhzgcViSfGeEARBEAQRKfy+HYkDEQVFEdLZ2QkAqK6uTvGeEARBEAQRLZ2dnTCZTGHXkHljhHg8Hhw/fhwFBQUQBEHWbVssFlRXV+PIkSM5aQyZ68cP0Dmg48/t4wfoHOT68QOJOweMMXR2dqKqqgoKRXjVEGWKIkShUGDQoEEJ/R1GozFn3wwAHT9A54COP7ePH6BzkOvHDyTmHPSXIeKQ0JogCIIgCAIUFBEEQRAEQQCgoCgt0Gq1WLhwIbRabap3JSXk+vEDdA7o+HP7+AE6B7l+/EB6nAMSWhMEQRAEQYAyRQRBEARBEAAoKCIIgiAIggBAQRFBEARBEAQACooIgiAIgiAAUFAkC4888ghOPfVUFBQUoLy8HDNnzsTu3bsD1vT09GDOnDkoKSlBfn4+rrjiCjQ2NorPb9myBddccw2qq6uh1+sxevRoPPPMMwHbWLNmDQRB6PPT0NCQlOMMhxznoLW1FRdddBGqqqqg1WpRXV2NuXPn9pk3t2bNGkyePBlarRbDhw/H0qVLk3GIYUnW8Wf7NSCltbUVgwYNgiAI6OjoCHguW68BKaGOP12vAbmOP9ixvfHGGwFr0vHvDyTvHGT7NQAAS5cuxYQJE6DT6VBeXo45c+YEPP/dd9/h7LPPhk6nQ3V1NR599FF5DoIRcVNXV8eWLFnCtm3bxjZv3swuueQSNnjwYGa1WsU1t956K6uurmarVq1i33zzDTv99NPZGWecIT7/97//nd1xxx1szZo1bP/+/eyVV15her2ePffcc+KaTz/9lAFgu3fvZidOnBB/3G53Uo83GHKcg7a2Nvbiiy+yDRs2sIMHD7JPPvmEjRw5kl1zzTXimgMHDjCDwcDmzZvHduzYwZ577jmmVCrZihUrknq8vUnW8Wf7NSDl8ssvZxdffDEDwNrb28XHs/kakBLq+NP1GpDr+AGwJUuWBBxbd3e3+Hy6/v0ZS945yPZr4IknnmBVVVXs1VdfZfv27WNbtmxh7733nvi82WxmFRUV7Kc//Snbtm0be/3115ler2d/+ctf4j4GCooSQFNTEwPAPvvsM8YYYx0dHUytVrO3335bXLNz504GgK1bty7kdm677TZ2/vnni//mbwTpB2S6Itc5eOaZZ9igQYPEf8+fP5+NHTs2YM1VV13F6urqZD6C+EjU8efKNfDiiy+yc889l61atarP8ebCNRDu+DPlGoj1+AGwf//73yG3myl/f8YSdw6y+Rpoa2tjer2effLJJyG3++KLL7KioiJmt9vFx37961+zkSNHxr3PVD5LAGazGQBQXFwMANi4cSOcTiemT58urhk1ahQGDx6MdevWhd0O34aUSZMmYcCAAfj+97+Pr776Sua9lwc5zsHx48fxr3/9C+eee6742Lp16wK2AQB1dXVhz2MqSNTxc7L5GtixYwceeughvPzyy0GHN2b7NdDf8XPS/RqI5z0wZ84clJaW4rTTTsPixYvBJHZ6mfL3BxJ3DjjZeA2sXLkSHo8Hx44dw+jRozFo0CD85Cc/wZEjR8TXrFu3Dueccw40Go34WF1dHXbv3o329va49pmCIpnxeDy48847ceaZZ2LcuHEAgIaGBmg0GhQWFgasraioCFkDXrt2Ld58803ccsst4mMDBgzAokWL8M477+Cdd95BdXU1zjvvPGzatClhxxML8Z6Da665BgaDAQMHDoTRaMTf/vY38bmGhgZUVFT02YbFYkF3d3diDihKEnn82X4N2O12XHPNNXjssccwePDgoNvO5msgkuPPhGsgnvfAQw89hLfeegsrV67EFVdcgdtuuw3PPfec+Hwm/P2BxJ6DbL4GDhw4AI/Hgz/96U94+umn8c9//hNtbW34/ve/D4fDIW4n2DXAn4sHVVyvJvowZ84cbNu2DV9++WXM29i2bRsuv/xyLFy4EBdeeKH4+MiRIzFy5Ejx32eccQb279+Pp556Cq+88kpc+y0n8Z6Dp556CgsXLsSePXtw//33Y968eXjxxRdl3svEkcjjz/Zr4P7778fo0aPxs5/9LEF7lhwSefyZcA3E8x743e9+J/7/KaecApvNhsceewx33HGHnLuYcBJ5DrL5GvB4PHA6nXj22WfF+9/rr7+OyspKfPrpp6irq0vE7opQpkhG5s6di+XLl+PTTz/FoEGDxMcrKyvhcDj6dNA0NjaisrIy4LEdO3bgggsuwC233IIHHnig39952mmnYd++fbLsvxzIcQ4qKysxatQoXHbZZfjLX/6C//u//8OJEyfE53p3KjQ2NsJoNEKv1yfmoKIg0ccfjGy6BlavXo23334bKpUKKpUKF1xwAQCgtLQUCxcuFLeTrddAJMcfjHS6BuR4D0iZNm0ajh49CrvdLm4nnf/+QOLPQTCy5RoYMGAAAGDMmDHi82VlZSgtLcXhw4fF7QS7BvhzcRG3KolgHo+HzZkzh1VVVbE9e/b0eZ6Ly/75z3+Kj+3atauPuG7btm2svLyc3XvvvRH/7unTp7Mf/vCH8R2ADMh1Dnrz2WefMQCsvr6eMeYVWY4bNy5gzTXXXJNykWWyjj8Y2XQN7Nu3j23dulX8Wbx4MQPA1q5dyxobGxlj2X0NRHL8wUiHayBR74GHH36YFRUVif9O178/Y8k7B8HIlmtg9+7dDECA0Lq1tZUpFAr20UcfMcb8QmuHwyGuuf/++2URWlNQJAOzZ89mJpOJrVmzJqA9squrS1xz6623ssGDB7PVq1ezb775htXW1rLa2lrx+a1bt7KysjL2s5/9LGAbTU1N4pqnnnqKvfvuu2zv3r1s69at7Fe/+hVTKBRhVfrJQo5z8MEHH7DFixezrVu3svr6erZ8+XI2evRoduaZZ4preDvuvffey3bu3MleeOGFtGjHTdbxZ/s10JtgXTbZfA30Jtjxp+s1IMfxv//+++yvf/0r27p1K9u7dy978cUXmcFgYAsWLBDXpOvfn7HknYNsvgYY89pRjB07ln311Vds69at7NJLL2VjxowRg6COjg5WUVHBrrvuOrZt2zb2xhtvMIPBQC356QKAoD9LliwR13R3d7PbbruNFRUVMYPBwH74wx+yEydOiM8vXLgw6DZqamrENf/v//0/dtJJJzGdTseKi4vZeeedx1avXp3EIw2NHOdg9erVrLa2lplMJqbT6diIESPYr3/96z5tp59++imbNGkS02g0bNiwYQG/I1Uk6/iz/RroTajW42y9BnoT7PjT9RqQ4/j/+9//skmTJrH8/HyWl5fHJk6cyBYtWtTHfycd//6MJe8cZPM1wJjXh+jGG29khYWFrLi4mP3whz9khw8fDlizZcsWdtZZZzGtVssGDhzI/vznP8tyDILvQAiCIAiCIHIaEloTBEEQBEGAgiKCIAiCIAgAFBQRBEEQBEEAoKCIIAiCIAgCAAVFBEEQBEEQACgoIgiCIAiCAEBBEUEQBEEQBAAKigiCIAiCIABQUEQQCUEQBLz77rup3g0ixZx33nm48847U70bGceQIUPw9NNPp3o3iByEgiKCiJKGhgbcfvvtGDZsGLRaLaqrq/GDH/wAq1atSvWuyc4vf/lLKJVKvP32232ee/DBByEIAm699daAxzdv3gxBEHDw4MGAx9955x2cd955MJlMyM/Px4QJE/DQQw+hra0tkYeQ9axZswaCIPSZPJ4JLF26FIWFhaneDYIQoaCIIKLg4MGDmDJlClavXo3HHnsMW7duxYoVK3D++edjzpw5qd49Wenq6sIbb7yB+fPnY/HixUHX6HQ6/P3vf8fevXvDbuu3v/0trrrqKpx66qn473//i23btuGJJ57Ali1b8MorryRi9wkiAIfDkepdIDIBWSaoEUSOcPHFF7OBAwcyq9Xa5znp0E4A7K9//SubOXMm0+v1bPjw4ey9994Tn3e5XOzGG29kQ4YMYTqdjp188sns6aefDtjerFmz2OWXX84ee+wxVllZyYqLi9ltt90mTopmjLHjx4+zSy65hOl0OjZkyBD26quvspqaGvbUU08F7NdNN93ESktLWUFBATv//PPZ5s2b+z3WpUuXstNPP511dHQwg8HQZyDjwoUL2cSJE9n3v/99duWVV4qPf/vttwwAq6+vZ4wx9vXXXzMAfY4v2HnrzZEjR9jVV18tDo+cMmUK+9///scYY2zfvn3ssssuY+Xl5SwvL49NnTqVrVy5MuD1L7zwAhs+fDjTarWsvLycXXHFFeJzbreb/elPfxL/BhMmTGBvv/22+HxbWxu79tprWWlpKdPpdGz48OFs8eLFIffVarWy6667juXl5bHKykr2+OOPs3PPPZf96le/EtcAYP/+978DXmcymQIGZh4+fJhdeeWVzGQysaKiInbZZZeJ57I39fX1fYZvzpo1izHGWE9PD7v99ttZWVkZ02q17Mwzz2Tr168Puf/PPfccGzt2rPjvf//73wwA+7//+z/xsQsuuID99re/Ff/97rvvslNOOYVptVo2dOhQ9uCDDzKn0yk+/8QTT7Bx48Yxg8HABg0axGbPns06OzsZY/5ht9KfhQsXMsYYq6mpYX/84x/ZDTfcwPLz81l1dXWfCej9nSf+/nn44YfZgAED2JAhQ0IeO0FwKCgiiAhpbW1lgiCwP/3pT/2uBcAGDRrEXnvtNbZ37152xx13sPz8fNba2soYY8zhcLAFCxawDRs2sAMHDrB//OMfzGAwsDfffFPcxqxZs5jRaGS33nor27lzJ/vPf/7DDAYDe+mll8Q106dPZ5MmTWL/+9//2MaNG9m5557L9Hp9QFA0ffp09oMf/IBt2LCB7dmzh919992spKRE3JdQnH322ez5559njDF2xRVXsIceeijgeR4Ubdy4kSkUCrZhwwbGWN+giB+7NJiLhM7OTjZs2DB29tlnsy+++ILt3buXvfnmm2zt2rWMMcY2b97MFi1axLZu3cr27NnDHnjgAabT6dihQ4cYY4xt2LCBKZVK9tprr7GDBw+yTZs2sWeeeUbc/sMPP8xGjRrFVqxYwfbv38+WLFnCtFotW7NmDWOMsTlz5rBJkyaxDRs2sPr6erZy5Ur2/vvvh9zf2bNns8GDB7NPPvmEfffdd+zSSy9lBQUFUQVFDoeDjR49mt14443su+++Yzt27GDXXnstGzlyJLPb7X1+p8vlYu+88w4DwHbv3s1OnDjBOjo6xPNeVVXFPvzwQ7Z9+3Y2a9YsVlRUFPLv/t133zFBEFhTUxNjjLE777yTlZaWsquuukrcN4PBIAaen3/+OTMajWzp0qVs//797OOPP2ZDhgxhDz74oLjNp556iq1evZrV19ezVatWsZEjR7LZs2czxhiz2+3s6aefZkajkZ04cYKdOHFCDJhqampYcXExe+GFF9jevXvZI488whQKBdu1a1fE52nWrFksPz+fXXfddWzbtm1s27ZtIf92BMGhoIggIoRnPP71r3/1uxYAe+CBB8R/W61WBoD997//DfmaOXPmBGQyZs2axWpqapjL5RIfu/LKK8Wb1M6dOxkAMRhhjLG9e/cyAGJQ9MUXXzCj0ch6enoCftdJJ53U55u3lD179jC1Ws2am5sZY96swdChQ5nH4xHX8KCIMcauvvpq9r3vfY8x1jcouvjii9mECRNC/q5Q/OUvf2EFBQX9Bm9Sxo4dy5577jnGGGPvvPMOMxqNzGKx9FnX09PDDAaDGGBxbrrpJnbNNdcwxhj7wQ9+wG644YaIfm9nZyfTaDTsrbfeEh9rbW1ler0+qqDolVdeYSNHjgw4z3a7nen1evbRRx8F/d084yLNuFmtVqZWq9mrr74qPuZwOFhVVRV79NFHg27H4/GwkpISMVs2adIk9sgjj7DKykrGGGNffvklU6vVzGazMca8WaPeXxBeeeUVNmDAgKDbZ4yxt99+m5WUlIj/XrJkCTOZTH3W1dTUsJ/97GcB+1ZeXi5mrSI5T7NmzWIVFRVBg0mCCAVpiggiQhhjUa2fMGGC+P95eXkwGo1oamoSH3vhhRcwZcoUlJWVIT8/Hy+99BIOHz4csI2xY8dCqVSK/x4wYIC4jd27d0OlUmHy5Mni88OHD0dRUZH47y1btsBqtaKkpAT5+fniT319Pfbv3x9y3xcvXoy6ujqUlpYCAC655BKYzWasXr066PqHH34YX3zxBT7++OM+z0V73jibN2/GKaecguLi4qDPW61W3HPPPRg9ejQKCwuRn5+PnTt3iufw+9//PmpqajBs2DBcd911ePXVV9HV1QUA2LdvH7q6uvD9738/4Ly8/PLL4nmZPXs23njjDUyaNAnz58/H2rVrQ+7r/v374XA4MG3aNPGx4uJijBw5Mqpj3rJlC/bt24eCggJxn4qLi9HT0xP27xVsf5xOJ84880zxMbVajdNOOw07d+4M+hpBEHDOOedgzZo16OjowI4dO3DbbbfBbrdj165d+Oyzz3DqqafCYDCI+/rQQw8FnL+bb74ZJ06cEM/zJ598ggsuuAADBw5EQUEBrrvuOrS2torPh0P6/hEEAZWVleK1H+l5Gj9+PDQaTcTnjSBUqd4BgsgURowYAUEQsGvXrojWq9XqgH8LggCPxwMAeOONN3DPPffgiSeeQG1tLQoKCvDYY4/h66+/jngbkWC1WjFgwACsWbOmz3Ohun7cbjeWLVuGhoYGqFSqgMcXL16MCy64oM9rTjrpJNx8882477778Pe//z3guZNPPhlffvklnE5nn+MJh16vD/v8Pffcg5UrV+Lxxx/H8OHDodfr8eMf/1gU1BYUFGDTpk1Ys2YNPv74YyxYsAAPPvggNmzYAKvVCgD44IMPMHDgwIDtarVaAMDFF1+MQ4cO4cMPP8TKlStxwQUXYM6cOXj88ccjPobeCILQJ0h0Op3i/1utVkyZMgWvvvpqn9eWlZXF/Hsj5bzzzsNLL72EL774AqeccgqMRqMYKH322Wc499xzA/b197//PX70ox/12Y5Op8PBgwdx6aWXYvbs2fjjH/+I4uJifPnll7jpppvgcDjE4CoU4a79SM9TXl5eVMdPEJQpIogIKS4uRl1dHV544QXYbLY+z0fTEv3VV1/hjDPOwG233YZTTjkFw4cPjyoTAAAjR46Ey+XCt99+Kz62b98+tLe3i/+ePHmyGNwMHz484IdngXrz4YcforOzE99++y02b94s/rz++uv417/+FfI4FyxYgD179uCNN94IePzaa6+F1WrFiy++GPR1obY3YcIEbN68OWTL/ldffYXrr78eP/zhDzF+/HhUVlb2sQFQqVSYPn06Hn30UXz33Xc4ePAgVq9ejTFjxkCr1eLw4cN9zkt1dbX4+rKyMsyaNQv/+Mc/8PTTT+Oll14Kui8nnXQS1Gp1QFDb3t6OPXv2BKwrKyvDiRMnxH/v3bs3IGsyefJk7N27F+Xl5X32y2QyBf3dPBPidrsD9kej0eCrr74SH3M6ndiwYQPGjBkTdDsAcO6552LHjh14++23cd555wHwBkqffPIJvvrqK/Exvq+7d+/us5/Dhw+HQqHAxo0b4fF48MQTT+D000/HySefjOPHj/fZd+l+R0os54kgIoGCIoKIghdeeAFutxunnXYa3nnnHezduxc7d+7Es88+i9ra2oi3M2LECHzzzTf46KOPsGfPHvzud7/Dhg0botqXUaNGYfr06bjllluwfv16fPvtt7jlllug1+shCAIAYPr06aitrcXMmTPx8ccf4+DBg1i7di1++9vf4ptvvgm63b///e+YMWMGJk6ciHHjxok/P/nJT1BYWBj02zkAVFRUYN68eXj22WcDHp82bRrmz5+Pu+++G/Pnz8e6detw6NAhrFq1CldeeSWWLVsWdHvXXHMNKisrMXPmTHz11Vc4cOAA3nnnHaxbt048h//617+wefNmbNmyBddee21AFm358uV49tlnsXnzZhw6dAgvv/wyPB4PRo4ciYKCAtxzzz246667sGzZMuzfvx+bNm3Cc889J+7PggUL8N5772Hfvn3Yvn07li9fjtGjRwfd1/z8fNx000249957sXr1amzbtg3XX389FIrAj9jvfe97eP755/Htt9/im2++wa233hqQEfnpT3+K0tJSXH755fjiiy9QX1+PNWvW4I477sDRo0eD/u6amhoIgoDly5ejubkZVqsVeXl5mD17Nu69916sWLECO3bswM0334yuri7cdNNNQbcDeAPRoqIivPbaawFB0bvvvgu73R5QjluwYAFefvll/P73v8f27duxc+dOvPHGG3jggQcAeEu5TqcTzz33HA4cOIBXXnkFixYtCvh9Q4YMgdVqxapVq9DS0hJRWS3W80QQEZFiTRNBZBzHjx9nc+bMYTU1NUyj0bCBAweyyy67jH366afiGvQjqO3p6WHXX389M5lMrLCwkM2ePZvdd999onCZMX9LsZRf/epX7Nxzzw3Yl4svvphptVpWU1PDXnvtNVZeXs4WLVokrrFYLOz2229nVVVVTK1Ws+rqavbTn/60T4s9Y4w1NDQwlUoVIBiWMnv2bHbKKacwxgKF1hyz2cxKS0sDhNacN998k51zzjmsoKCA5eXlsQkTJrCHHnoobEv+wYMH2RVXXMGMRiMzGAxs6tSp7Ouvv2aMedvRzz//fKbX61l1dTV7/vnnA1rgv/jiC3buueeyoqIiptfr2YQJEwK6+zweD3v66afZyJEjmVqtZmVlZayuro599tlnjDHG/vCHP7DRo0czvV7PiouL2eWXX84OHDgQcl87OzvZz372M2YwGFhFRQV79NFH+7TkHzt2jF144YUsLy+PjRgxgn344Yd9WvJPnDjBfv7zn7PS0lKm1WrZsGHD2M0338zMZnPI3/3QQw+xyspKJgiC2JLf3d3Nbr/9dnE7/bXkcy6//HKmUqnETjC3282KiorY6aef3mftihUr2BlnnMH0ej0zGo3stNNOC+iOfPLJJ9mAAQOYXq9ndXV17OWXX+4jCr/11ltZSUlJn5Z8aQclY4xNnDhRfD6S8xTs/UMQ/SEwFqMKkiCItOPo0aOorq4WBa4EQRBE5FBQRBAZzOrVq2G1WjF+/HicOHEC8+fPx7Fjx7Bnz56oRM0EQRAEdZ8RREbjdDrxm9/8BgcOHEBBQQHOOOMMvPrqqxQQEQRBxABligiCIAiCIEDdZwRBEARBEAAoKCIIgiAIggBAQRFBEARBEAQACooIgiAIgiAAUFBEEARBEAQBgIIigiAIgiAIABQUEQRBEARBAKCgiCAIgiAIAgDw/wFE4ptqQTx8EAAAAABJRU5ErkJggg==" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 56 + "execution_count": 62 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-03T11:37:19.075390Z", - "start_time": "2025-01-03T11:37:19.004816Z" + "end_time": "2025-01-07T15:20:45.405774Z", + "start_time": "2025-01-07T15:20:45.323523Z" } }, "cell_type": "code", @@ -5148,10 +4734,10 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 57, + "execution_count": 63, "metadata": {}, "output_type": "execute_result" }, @@ -5160,13 +4746,13 @@ "text/plain": [ "
" ], - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 57 + "execution_count": 63 }, { "metadata": {}, @@ -5177,8 +4763,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-03T11:37:21.994238Z", - "start_time": "2025-01-03T11:37:21.991947Z" + "end_time": "2025-01-07T15:20:47.197611Z", + "start_time": "2025-01-07T15:20:47.194723Z" } }, "cell_type": "code", @@ -5193,11 +4779,11 @@ "name": "stdout", "output_type": "stream", "text": [ - "Sum of values < 0: -124529.77354513475\n" + "Sum of values < 0: -94013.6540869424\n" ] } ], - "execution_count": 58 + "execution_count": 64 }, { "metadata": {}, @@ -5208,8 +4794,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-03T11:37:23.670682Z", - "start_time": "2025-01-03T11:37:23.521042Z" + "end_time": "2025-01-07T15:20:06.514950Z", + "start_time": "2025-01-07T15:20:06.202317Z" } }, "cell_type": "code", @@ -5236,31 +4822,31 @@ "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_89216/4003818095.py:7: SettingWithCopyWarning: \n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_53316/4003818095.py:7: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_89216/4003818095.py:7: SettingWithCopyWarning: \n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_53316/4003818095.py:7: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_89216/4003818095.py:7: SettingWithCopyWarning: \n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_53316/4003818095.py:7: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_89216/4003818095.py:7: SettingWithCopyWarning: \n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_53316/4003818095.py:7: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_89216/4003818095.py:7: SettingWithCopyWarning: \n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_53316/4003818095.py:7: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", @@ -5273,13 +4859,13 @@ "text/plain": [ "
" ], - "image/png": "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" + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1kAAAISCAYAAAA+6QUoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/OQEPoAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydd5gkVb3+P1XVuadnenLYHNjELsuSFhDEjBJUUEHMOSJcMeL1d81ijojpKphQkQwKBhCVIDktm/Pu7Mzs5JnO3VX1++PUqe6Z6VDd073B2+/z7LO701U11d1Vp8573vf7fhXTNE3qqKOOOuqoo4466qijjjrqqArUw30CddRRRx111FFHHXXUUUcd/0mok6w66qijjjrqqKOOOuqoo44qok6y6qijjjrqqKOOOuqoo446qog6yaqjjjrqqKOOOuqoo4466qgi6iSrjjrqqKOOOuqoo4466qijiqiTrDrqqKOOOuqoo4466qijjiqiTrLqqKOOOuqoo4466qijjjqqiDrJqqOOOuqoo4466qijjjrqqCLqJKuOOuqoo4466qijjjrqqKOKqJOsOuqoo4466qijjjrqqKOOKuKoI1k/+MEPWLhwIT6fj/Xr1/PII48U3f4Pf/gDK1aswOfzsWbNGv70pz8dojOto4466qijjjrqqKOOOv4v4qgiWb///e+54oor+MxnPsMTTzzB2rVrOfvsszl48GDe7R988EEuueQS3vnOd/Lkk0/y6le/mle/+tVs2LDhEJ95HXXUUUcdddRRRx111PF/BYppmubhPgmnWL9+PSeffDJXX301AIZhMG/ePD70oQ/xyU9+csb2F198MdFolDvvvNP+2amnnsrxxx/Pj370o0N23nXUUUcdddRRRx111FHH/x24DvcJOEUqleLxxx/nyiuvtH+mqioveclLeOihh/Lu89BDD3HFFVdM+dnZZ5/NrbfeWvD3JJNJksmk/X/DMBgZGaG1tRVFUWb3Juqoo4466qijjjrqqKOOoxamaTI5OUlPTw+qWtgUeNSQrKGhIXRdp7Ozc8rPOzs72bx5c959+vv7827f399f8PdcddVVfO5zn5v9CddRRx111FFHHXXUUUcd/5HYt28fc+fOLfj6UUOyDhWuvPLKKerX+Pg48+fPZ8uWLYRCoRnba5qGz+ez/x+NRgseW1VV/H5/RdvGYjFM0+TmrTfz/ae+z5lzzuTzz/s8r/vhg+weiXHtO89gyb03M/yjH+M+/3w2zzmPnU8Nccp5izj2+XPs4yiKQiAQYOuj/dz3my1sJ86Fj16FNzbJgl9ch3fJkinnEQwG7X/H43EMwyh4zrnbJhIJdF2vyraBQMBWEZPJJJlMpirb+v1+ewUilUqRTqersq3P50PTtLK3TafTpFKpgtt6vV5cLlfBbU3T5DO3PcddG/rpCjdw4wfPoIUJMr++mOTAFgi0weuu45t77uDOnXeypGkJP3rpjwj4ArjdbgAymcwUJReA378Z9j3M5zJv44/m6fz1oy+iJ+xH13USiUTB83W73Xg8HgB0XefKe6/kvv33cenxl/KaZa8puK1hGMTjcUfHzbftZ/92A/8Y+aH4jwoNmRZOavoqX33NccRisYLHdblceL1e+7Mstm05972jbf/4Udh0O5xxBaf9azWGCX//yFkEtML3RaExQuJ7927lVw/u5Q3r53HFy1ZgPvcc+9/3flxz5tD9u99SyCmuKArmzy9n/7VP4ulpouuGOx3f97MZI/62cYArb36W4+c38dO3nFz2GBHPxHn/397PpoObOC5wAQ8+sYpz13Tz2VcdO2PbUmPEHTvu4FuPf4vnL3g+33jRN4DajBHXb7qe7zz6HV7Y80L+57T/ybvtUyNP8ZF/fYR2fzs3nXtT0ePKMWLDP/dz/x+2MOfYJl705pVFt+XAk2SuPY+krxsu/iX84jzIJNlyzNU8+ECAlqVevtv6CVqCLdz1mrt4bOcgb/npg8xt8XPLB5439aC/fCWe4c24X/9LWPpidF1n9OGH2ffBS9EaG1l8x+0o1ngHU+/lkf5Jrv/Cg6S0JF3viPCqY1415dD57vvrHtzFD+7dAcCxcxq57u2nFNwWYMfYDt71l3cRdAW544I7UBRlxn2/f+cgt33rSXxBFyfe8wkwDBbdcjPu9vap2w5sJPajl4IvDJdODeD6084/8fXHv87p80/nOy/6DgAPbdnPO697nM5GL3deduaU7csZTz5+z5WsvVeMn+/4+hkkUwlu++6TjPRGedk7VjFnRYu9be4YccXfr+D+3fezvms9X3n+V2YcV84NJKaPJ8W2LXTff/Oxb3Lnzjt55wnv5L1r31t0W4lK5xH7R/ZzyR2XkDSSfOmML3F6z+lTtnVy33/yn5/k4f6HObXzIu59eA0vXdXBV169quA8IpqKcv4fz0dRFe5o+AT9n/0iT7Uu5KqT3sIfLz+TjpB3yvalxoiNDxzg4dt2srB1H6/wfoZ/n/AaPjL6CEuCS/jJS34CwL+2HuSKG55hRXcDv3rnqUB2PEkndX720fvIGBne+IVT8XhnTvGnzyPiw8PseMU5AAxd9zn++4kvsLJlJde85JoZ267/wp9JpHVuev/pzG8NTDmux+MpOo+IPvIIvVd8BGXOHN54/PvweD288kUPcPeuu3jPivfw+pWvh+duhrs+CXNOhEt+C8ycRzidc8x2HpGLfHODyclJli9fnpcXTNm36KtHENra2tA0jYGBgSk/HxgYoKurK+8+XV1dZW0P4gKUH+b0YzU2NpY8TyfbzGbbVelVuHe7mfRN0tXVxaARwNXgY/n8TnymSVLTaOnoYL+vhaagSc/cHrq7u2ccr6Ulid8TpEXz0RRooDGdoDMUwp9n20P13uqYHX77yF7+uieFt6mVH777VBaGUvCL10NsG/TMgbfewXOk+MuTf8EddvOFl3+BeZ3zSh94wTEw9ignekzunmhkNO1iRQXfWXdPN+6IG1fYlfeazEU4HHZ83OnbZoLgNty0ZzIMulwo6TSThpumpiaampocH7ecbWd9vWf2QkglungdPOxGBeZ1teFxOc8mmn7c+XNiuEIRMr4wXV1dDN91Nw2aRmjNmqJjIECsvYsxTcOdMWa4Aco5h7K23ZPCFWphTk/njOuj2HHTRpqbtt7ED5/+ISOJEULNId6w5u08sm0bu+OektdaPixNL8W9w03EHanp+BTTYrhDbhbNW1TwPFs6Wgg+GWREH2FYHWZ59/KSxzUTboL+JhYsmlf6/Q+kwa9CVwesOhXO+Tj8/UtE+++iKfgeAh4NV8hFc2MzjY2NGJ44rlALnZ1NeY49BAEV5iwD63NLP7eRDrebxhe/mJ4iK75G3EVTsJWkFqPftd3RGPHCdR5+/OgoAKetXlhwHzlGPBF/AnfYzar2VfT09OTdVlvopSm4F1VV6GxuxpyYoLMhhHf6sd3LaQqpwAS0hcGdXfA4Rj8G93Y3ES17/Zx67DG4QrsYNqGhuY2Qz13wvRW75uJaAr8niKJCc0sYRVHo6uxDHxujsaGV7u789/Z/v+C/ufC2C3ki8QTb9G08f+7zC/6OUufgdNsxzxjusJvlPcvtbWo1N1jVuIq3nf42fr7h51zfez0XnHABquJ8/JxITfBM6hncYTfdweejepPM62yjvb296H7Nzc1MpibRI8O0uFwEmjtxhVrAH6a7O+z49wPsccVoCrYyV3uMZr9KdPHxaBsfZ1539j5O7k7iCrWweP7McRKgKdxCJqnTFGgl3BGY8foMtLYSbW3FmJgg5AriDrtJBVN5j71w/hy2H4yQ9jbR3d1W1nsbHhoi7XaTPOZYtEAjC9uDxFxRXEEXi+cvFr/P83K4/1MQ3QjtreDylPU7pmM284hiaGpqsgl+qTKioyZd0OPxcOKJJ3LPPffYPzMMg3vuuYfTTjst7z6nnXbalO0B/vrXvxbc/mhAV1AMoH3RPoYiKZIZA1WBriYfhrXyrgYCpOJi5cXjy8+j3T6xmugxFZLWhWzEC68Q1HFkY+OBCT5z+3MAfPRlyzm5OQ7XngNDW6FxLrztjxitS/jyw1/GxOS8xedxQucJzg7eJCZGiz1iMrNvpLDCUwwhj1jxmUxNVrS/U0ymxwFYYq0SprQkg5PJYrscXhi6+J6A4cBiAEJeV1kEKx+aA2ISNx4Tn0Ni00YAvCtXlNxXbWwFwEwVVk2qjZGIUGZbgs4erKZp8pfdf+GC2y7gSw9/iZHECPND8/nui77L+oVi8WD7YIREuvBKeCG0+sX7H44Pl71vORiKDwHQ5i88YfFqXk7pFgrNv3r/5ei4kyNiLA+1+EpsCcSs9xgQ75nnXQ6tS/EkDwCQjovPL+QW9+9YXFwT4cC07ykVg/iI+HdTlkxF/vEPABrOOqvoaRiGUE1MxWTTyKbS5w0cN7cJTRWTnHXzwyW33za6DYBjmo8puI3Xum8Mw8QMiWMakTxjli8MbmsSO3FgykutvpnXT1PAbSsb2w5GSp5rPhimwfDEGAAur2pP8HzWOSejhZ0bi5oW8caVbwTg649+nbRe+3t77+ReAOaH5tf8dwG8Y/U7aHA3sHV0K3/e/eey9v373r+TMTIsDS8lGRP3Y2dj6ftHzskmB3sBMBrF4lz/RPnzqdiEGAMDyhC0LuWgS3yvHYEOe5veMXHcnrB/5gGAQEjsE590/v265wq3U8OQeLZPpCbybjevWfzOa+7bzki0sOsmHxIbxT093L0QgAWtQUYSYrxo8Vnqa8tiMQ7pSeh/pqzjH6k4akgWwBVXXMFPf/pTfvGLX7Bp0ybe//73E41Gefvb3w7AW97ylinBGJdffjl333033/zmN9m8eTOf/exneeyxx7j00ksP11uYNeQNPZIYYdfwmPhZow+PS8WIWiQrGCCVEA9Gj1/Lexy3V/zcDSQ0SbIqmzzXcXgxmUjzweufIJUxeOHydt57nAuuOwdGdkDTfHj7H6F1Cbdtv41nhp4h4ApwxYlXlD6whDVhmquKCcPeCklWo0esStaaZEUtkrXUIgiGajIUHa/p75wVxvZAJgGal0GXWD1sdkg0iiFsTbxGY+JhmNwkHnK+lfntY7lQmsTqrVEBQakU8jydkKzH+h/jTX96Ex/5x0fYM7GHFl8L/73+v7n11bdyes/pdDX6aAl60A2TrQPlX29ykjySGClomaoGBuODQHGSBXDmHGEvu7/3fkfHnRy2SFarA5IliZHfmui4vHDut/Aowj6Ttr4XuUgyZv1fXl82JsQkE08IfGKimT5wgOTWraCqBM+YZi2cBlOSLAy2jW4jbZSeJAY8Ls4/rpuuRh9nLC29sr5trDTJcnlUVE2QFyMkjqlP5rmGFAUaLTVsOsny579+lnWKz3D7QGUkazg+jJoWz26vP/v5e4MWyYoV/8zeu/a9tPha2D2xm+s3X1/ROThFUk/SHxX17/NCDhwTVUCTt4m3Hfs2AK5+8mpH15DEX/b8BYCXLXgZA5Pi/ulsnOlqmo7uoBizE8PiXlYsB8RAJSRr0iJZ6hisfg0HrfGhM5h1ExwYE/flnAIkyx8S42d8wjkJ8swRJMs7KJ6TE6kJDHOmpfPdZy7G51Z5cMcw537vXzy+Z9Tx70hY2Ql7WsTvmt8SYCQ+jWQpCsxbL/6972HHxz6ScVSRrIsvvphvfOMb/M///A/HH388Tz31FHfffbdtZ9m7dy99fX329qeffjrXX389P/nJT1i7di033ngjt956K6tXrz5cb2HWCHvD+DTx4Nx4cB8Ac5vFalqlSlZCEwO0WcTrWseRCdM0ufLmZ9k1FKWnycd3XhZG/cV5MLobmhfC2/8EzQuZSE3wnSe+A8AHjv8A7YHiFogpsEhWuy4G/EpJllwJrzXJiuliFa4roxOwvP9jqREyeuE6gMOKwS3i77ZljMTFOVaHZIljjMXTGIkEyZ27APCtWlVyX9UiWWbq0H1mw9bKaPN0hSQH20a38cF7Psjb//x2nhl6Br/Lz/vXvp8/XfgnXr/i9bhVMZYpisKqbkHqnzuQf1W2GORDP6EniGVqt/jkRMkCOGPOGQA8dfCpgqvMubCVLCcky1aysrU8LD4Lz3JhJzOsZ0mDpwGAMWsiH/ZPI1nj4nk0RcX6p1De/GvX4mpuLnoaNhdRhQV059jO0ucOfOf16/j3p15Ma0PpCbGtZIULkyxFUfAGxHNTD4nPxIgUqJEqQLKafeK9ZszMlO9raYf4DLcdrGwM7I304jbEd5r7bJfnmyiiZIEgypefcDkAP3r6R/b1Vwv0TvZiYhJ0B7OT6EOAN616Ey2+FvZO7uX27bc72mciNcGDBx4E4GULX0b/uCRZpe8fSbLSI+I+creI9yqPUQ5io2KsCahjcOyF9McESe0MzCRZBZWsRjF+SsLmBO454p51DQjSY5gG0fTMa/70pW3c9sEzWNwWpG88wcU/foif37+r5EKUEY+T2iWePxut9zK32c9IchrJApgnVPs6yTpMuPTSS9mzZw/JZJKHH36Y9evX26/dd999XHfddVO2f93rXseWLVtIJpNs2LCBc8455xCfcXWhKIqtZm0f2Q+IixWmkayERbL8+UmWHKA9JsQUyx5Rtwsedfj1w3u585k+XKrCT85tpun3r4bxvdC6FN5+F4TFCuI1T13DSGKExU2LecPKN5T3S5rEMUJJMeDvOcLtgklDTGpaDJ1Wq2ha0SKMxMqzNxwyHLSsUe3LGbWIRst0laACSKVhLJYmuW0b6DpaczOujo4Se4LSLMYY0wCzSHhMNSHfe2vDTJLVH+3n/z3w/3jtHa/ln/v/iaZoXLz8Yv504Z/4wPEfIOgOztjn2B5JsspXMQPuAH6XGFdraRmUxy5FsuaG5rKoaRG6qfPvA/8uum06pdtWIWd2QUvJknZBC96XCLXb1L1gZpXosbhUsqZ9T+OWktWUDVpyahWErJKlqWIB0Kll0CkmU5P0RcUibDElC7KWwUxAqBJ57YIAjdZ7ndg/dX/Nay8qDSey188xnYJkba1QyeqL9uHWBZmUbhQAn0MlC+BVS17FypaVRNIRrn7y6orOwwlyrYKHsv1N0B3kXWveBcAPn/4hSb20Vfy+fSIsYknTEpaEl3BwQuxTjl2QMfHc8beL+6giu+CouM4C7S3QsYKDsYPAVLtglmTlPzdbySqLZInr2DzQby/ijyfzj5vLu0Lc/qEzOPe4bjKGyefv3MgHr3+CyUThay+5dSsYBlpbG5vT4vrtbDLJGOLZIhclgBwl65GclZejF0cdyaojKx3vtR5q00kW/oDtoy+oZFkDtAuFiCou+rpd8OjCht5xvnCHqLP58pleVv/lEmHZaVsOb/ujvcq6ZWQLv90skno+econ7dV+x7AmTe5MhBCxWddkOVmJnw1SpnhQhXWDVku9UlwRhsp46BxSSCWrY4VNBKuhZElFaCyWIr4xaxV0MuFRm7PF88YhUrjzKVkTqQm+9fi3OO+W87h1+60YpsFLF7yUW191K58+9dNFycmqnsqVLMipq0nUhmSljTSjSWG3KUWyIKtmlarLilgqltun2QpHUUy3C1rwtMlrQMNleAhZ0wVbyZq+EDBuEQ1LyTKSSaL/FoSw4aziIQuAvRrustIHN4/kb81SKbaPbQeEKtDkLR5qYytZPkmyCpAiSbLG9894qcX6PHNJum0XrLAm60DkgE2yPL4syXKqZIEgsVeuF2UVN2+7mY3DGys6l1LYM7EHgPmNh6YeKxcXLb+IzkAnA7EBbthyQ8nt/7LbsgoufBnRZIbJpPgcndgFJcnSJoTyE+q0SFaZSpZpmMRjYmz2HyvswdNJViKt2+RtTnMhu6BVk1WGXVDWZKV6e+3FlPFU4cWpBq+Lqy9Zx+deeSxuTeFPz/bzyqsfYFNf/rE2sUncy74VK9g7LOYPoQbxPoLuID5XDmHsWQeqCyb7sur4UYw6yToKIeXp/phITpwzjWSZXr9dRFywJitngI5bKxd1u+DRgwlZh6UbvGVJlNdteC9E+qHjWEGwQpYSYZpc9chV9uT0tJ4KQl88QXsC1qMMMRJNFV21KoRDpWRlEMdv1o2skuWKMBQ5QsMvBqWStSJHyZo9yWqy7FyGCZENIhTFSegFgBLOJkuZE4OzPhcnsJWsoJeknuQXz/2CV9z0Cq7dcC1JPcmJnSfym3N+w7de8C0WNi0sebxje8QEeXPfJLpR/oporcMvZD2CpmiEveGS2+fWZRWz58h6rMZWnzMFYXrwhQWXR0WGs3l0Hw27hZ2qIMmSak6jIFmxRx7FjMdxdXbiXVH6upMlIG7Lvr5puLpKlpPQCwmpDGW8QnnSJwuQouYF4u+xvTNeyq3rk1jaLo7XOxYnkixfIT4QOYBHF89r9xS7oHMlC2BdxzrOXng2JiY3b7u57PNwgn2TYoJ8qEIvcuHVvLx/7fsB+N9n/zev9U1iMjWZtQoueJldSxX0aEUTICXkfMxjBfeEuwQhKlfJSg72YZhiXhY44TwSmYStJkm74IbecQwT2kNe2gvYY7N2wTKCLywlK72/l0avIFkTyeKLU4qi8NbTF3LDe0+jp8nHrqEor/7BA/zhsZnEKGHVA7P0GCYsl5XXKxS5GVZStx+614p/75vaGuFoRJ1kHYWQKyejSbHKMb0mK6NZKxzKVEtBLjRNRXOJB3DKFbT2L9wnoI4jB6Zp8smbnmHPcIyzGvv57MgnUaKD0LUG3noHNGTrre7adRePDzyOT/PxsZM+VvkvtVanl/vFoL9vpPxrxQ6+SNeWZOmKeKCGDZ0W2y44eWSSLMOAQZEsSPtKO7GpGkqWz63hc4shPqtkla7HAlC8QRRNTOSN0cLN26sF0zSt927wxMhfOf+W8/nGY99gIjXB0vBSrn7R1Vx79rUc136c42Muagvid2vE0zq7hgpPsgoh3yS5mpD1MK2+VkdR0yd2nojf5WcoPlRU5ZmQoRdOrIIAMat4PTC1ZkpRlKytPOMn1Pcs7Li3iF1wqpJlWwWf/3xHZE8SR4+VqLZ5ZHPe4vtKsXVU3GdOSJZUhjKWDdXIF3wBELYIxOieGS/lI+nNQQ9t1uS4EjXrQDRHyZpiFxTnm4w5J26vWPgKAB7uq03ty94JQTwPVejFdLxy6StZ0LiAkcQIv97464Lb3bfvPtJGmsVNi1navJSBMqyCYM3HTJNgVDxr2uYIkjVQppIVfUqoaV4thtax2FaxfJrPfnY+tW8MgOPnhQveU5XYBWXwhTExQbsu5pPFlKxcrJvfzB8vO5OzlrWTzBh87MZn+PiNT09JdU1sFs+f8TkiPbcj5CWWEcefYhWU+A8Kv6iTrKMQXQFBsmKGeEjbdkGrmZruknYCV9GHm1wJS1r9PYxEnWQdDfjlQ3v407P9HK/t4md8DjU+LCT2t9wOwexqdDQd5ZuPfROAdx/3brobyu8XZMOqy1oZEKtblYRf5CpZtUpsi2fioFor7bpp2wW9rvEjM8Z9bA9k4qB5oHmhnbBXLPyhHDQHPKimgb5DrOL7VpVOFpRQ3WLsMEcHSmw5e0RTOindwNt1K9948nP0RfvoCHTw+dM/z43n38hZ884qu65DUxVWdItrrpK6rHx2r2rCDr0IOOs349E8rO8Sk49iKYNlxbdDQSULsjW9Ht1HyDDgjx8hZjXKnRl8ka3JMk0zpx6rtFUQsjVZHpcHr+YllonZakg14CT0QsKuyXKJCaceLUCIwjlK1rQGu3KFfrrddJlVl7WtgtTLXLvgFCXLUt4SUefqxUldJ6EqKrsndtspgNWEXZN1GOyCAG7VzQeP/yAA1z13XcEao1yrIGRTATscWAVBWPmCSQVrTYqueUJ1iqb0shwfsY1CTQs0CPI8YDmVOgId9tj35N4xQJCsQghUQLLUYBDNCqaZMyn2L6Vk5aI56OHat53MR1+2DFWBGx7bzwXXPMjuoSimrpPcIhY4DrSLecT8loB9X+QNRfkPCr+ok6yjEFKeNrUxFAW6m6baBTPKTM92PsjXM5Yf1izS8bqOIwPP7B/ji3/cyPHKdn7vvwpXahzmngxvuW1qOhjw42d+zMH4QeaF5vHWY986u19srU4vmUWvLEmyDNOoWWLbaFycn9s08buDtCpiIuJ2jR2ZSlZOsiCai1HL7tMSnH3wBQjLYE9kCCWRQPH78SxY4HhfxerTZYwdrMq5FIPskeUO7gBEv5s/XvBHLjjmAjsIoRLI8IuNFdRl1bomy2myYC7OnFs6yl3aBRucJAuaZsGaLMgJSNJ9hLxNMLKT18RvBKYpWaY5RclK7dpNet8+FLeboMO+lHLhRVEUmwhVyzJomqZNspY1Lyu5vVSy0rJeuZBdsGkuKKro6xOdep8UUkKPsRIGy1WyTNOkL9qXYxecWZNVrE/WjFP3NrGqRSjb1Vaz0nraDhk5HHZBibMXns2y5mVE0hF+vuHnM16fTE3ywIEHAGEVhCzJ6nKoZLlVNwtMce+Yfh/BUJCQdd84jnEf30+sX3xegTZBdvKFXkgla10RkiWVrFgZNVkAbqtReNeEIHTl1k6rqsKlLzqGX71zPa1BD5v6Jjj/+/dzz18fxbSeP9vd4rzntwbs+0LeJ1Mw1yJZ/RsgWVn94pGCOsk6CiHtgqp7zO6RZRoGpkWy0lZaYKFkQQlpJUxrUgmr12QdyRiPizqs44zN/Nb3FbyZCMw/Dd58i92XRmLn+E5+tfFXgAi78GrOVuUKYlqvrD0j5duvvJrXDt2oVV3WgLUq36zrKJ4grZYVVtMmGYocgcEXdj3WciBbl1RNJWuJpTD4li1D0ZwTFtUjxg9zsnYxzxLD0SRgoLjHALh4+cVTi6ErhKzLqiT8otY1WZWQLDvKffCpgivzkXKUrHRM9GiDGYs0kK3p9eh+Qie/F4B3cQsLlT672TUA8VGhyAI0zrFVrMDJJ6MGZyY/5oN0BiqqwspWobhWK2FwIDbAZHoSTdFY1LSo5PY2ycLqIVnILqi57Rq06ZZBW8madv0stcIvyu3fNpYcI56J5w2+kDVkesYgk3Le2+7UnlOB6pOs3kgvhmngd/nLur6rDVVRuWzdZQBcv+l6BmNT60ulVXBR0yKWhpcC2Voqp3ZBgAWGIEZ6o1A+u5vEvv3jDhf2nruFuBEGINAirg9JsmTQ2cHJBL1jcRQFjiumZFk1WclYBj3j3G4r67JaR8X1U2h8KYXnLW3jj5edyckLm5lMZvjVr/8GgHf5cvaNic9jfktgZiPiXDTNEe4ZU4cDT1R0HkcK6iTrKIQkWYqWpNuys+aqUBnTWn0skCwo4fZaCUrWZKZuFzxyYZomH7/xaXpGn+BX3q/iN2Ow8Ex4003gDc3Y9isPf4WMkeGsuWfx/LnO7DpFMaNXVvnXiqIoNU8Y7J+UJMsQJMsKFDBd0SNbyWoXk8qRMhryOkE44LZJlrcMqyCA4rWCMyZqU5OUi9FYCsUVAUVHU7Qpq7ezga1k9U2UbVGtdU2WbEScdyW3AHoaeljStATDNHio76G820zYwRf508emQMa3ax6w+mDlwivtghkfoeXnkFr4ArxKhi+4ryPkzXm+yBSwYAe4vET+WZ5VEMCwlSxY0SKCMqqVMCjrsRY2LsSjlb63pF0wZVrkpZBdELJ1WWNTSVZuQ+JcLLN7ZZW3Qn8gInpxNSCu6dznu9uroapCgXCSMCixvlvYT//d9++qWrilVXBeaN4hjW/Ph+fPfT5r29eS0BP85JmfTHkttwGxPM9y4tsl5ujiuZa06u3kvn3jDp+TG24iJkmWRZJy7YIAT1lWwWUdIRq8hed23oALxboW4mWEX3ishMHwqHgGzeYZ3dXk4/p3n8p7nr/Yfv78Qw/zzH5B3HJJVt6aLPiPsQzWSdZRiIA7gFcVA3Vrk7iJ7fh2RSGti6+1ULKghFwJ0y2Vw6wHXxyx+PkDu5ncdA/Xeb5KgAQsfiG84QaR/DcN9+69l4f6HsKtuvnEyZ+ozglYNVmNKeHdn22MeyRVGwvAwagYuMOGRbKsiU7GlTgya7JyemRldIPxuHgoViP4AoSla8mYmJz5VpRHslSvtEqNVuVcimE4kkJxi9/TEejApTqIHneAZZ0hNFVhJJoqO+2rUE1NtSAVjrIag5MT5b5/ZpS7njGIWqvnjhoR51oF80yGp9RkeRrpe94XSJpuzlSfRduYk0qXU4+lR6LEHnsccNYfS0LWZCmqwsoWS8ka3lSVyX85yYKQVbJS1rO0oF0QsgmDDpWsYywla/9onFjKOSE6EBX3cdAiWbl2QUVR8NrhF84n1us61uHVvAzGB9k1vsvxfqUgQy8WNDq3J9cKiqLYDZhv3HYjvRFxrUZSER7szTYglhioQMnqTAsFKxoU14u0GjqyCw7vgANPErPUMEmybCXLShZ8Mif0ohgUVcHfYMW4V9Arq2FIPNsrVbLs42kqnzpnJecFxL3zsNbGRivifUFrgNGEGO8LNqrO7Zd1FKNOso5SeBEXZkNQWA6mNiK2emSVsgtag7Rhrewdqn44dZSHp/aN8cDdv+Xn7q/jV1JwzMvgkt+BJzBj23gmztce/RoAbzv2bcxrrFKyk6VkeWIDaOjsH41VFIstG3TWyi44aE0am3UdPEFaLauFruoMRmubalg2DAOGrGTBjpWMx9N278UZoQIVIux3sVjaBctVsnxWrWZkrCrnUgyjsRSqZRWUNafVgM+t2bHZz/WWtzJ7KO2ChmHyg79v585nDpTcT9ZlPdD7wIz0vchoEkzQ3KrdL6coioReAGheQbw8up+QJ8Sgey4/yLxKvPjnT0HCmojl1GNFH3wA0mk8CxbgWbiw9DlYkNe+qioc03wMmqIxmhy1V/Rng21jzuuxIJvWl06L91+wTxbkhF84U7Jagh5arUWUHQed266lkuU3xcKaZ5qaUW6MOwgL9/EdxwMUVEYrQa6SdSTg5K6TOa37NDJGhh8+9UMA7tt/HykjxcLGhVPCULJ2QecW+9aE+OzH/eIi7pJ2QSck6zmxWBHziOS9UkrW8fPDJQ/pb6ygIbFVk+UfFM/JarhNTNOkYd9OAIwl2XtvfkuwuF0QcpSsR2aEyhxNqJOsoxSKLlY9PD5xI0whWfGM9ZqzmixTtUhWPfjiiMNYLMVvfvljfqh9E5+Sxlz+Crj41+DOv8r28w0/50D0AF3BLrvrfVXQ0AmqG8XU6dHGSetmRR3ta20XHLaCL8KGAZ4gwUAnXmuAHkuOVEQMa4bxvaImRvNA8yI7WbDJ78alVWdo7khOEE5FMVQV7zHOVvEl1IDVGiJS2+bRIBoRq5aS1dPQU9VjH1thU2I5SY6kIyT16quguSTrH9sG+fqft/DxG5+xexwWwgkdJxBwiXSu6TVLucmCznpkWQQgTz0WAB6xYOfV/QTcAcZiaX6kn0+v1gORAbj3S2K7nB5ZkX/+E4BgGVZByFGyFPC5fHbtVDXCL8pXsizCYs1R9aIkK79dUE4eY5mYSD3NwTFWwmA5dVmSZOULvhDn7LwhcS5O7a5+XZadLHgYQy+m47ITRG3WHTvvYOfYzimpgvJeMU2zIrtgU0LsP+xNT9nXUU3WBotkaWJxKZ+SpRsmz+wfA2CdA5IVsBZYYhUoWe6Do2Cas1ayADIHB9FHRkBV+fYnL+SDL1zCh1+yjPaQtzTJ6lwN7gAkxmB426zP5XChTrKOUqSSYuJgaGPi74qULKuw3QojqKcLHlkwTZPfXHcNX0p9Fa+SIb38fJTX/RJc+VfY9k3u4+fPigSlj530MQLumUpXxVBVaBST3+MbxYRDdm4vB7VuSCwtCM26Ae4ASkMHLRbJMtWITWSOCMh6rNZjQHMxEpXJgtWxCgJ0HRSTneGWblRfeUESakCsmJux2iuAo9GUHXpRTSULYJVNssqbNITcITuopdpqlmmatg2xzddmN/CMpXR6x4qPw27NbU+M798/NWVwcljs68gqCFmS5c9fF6G7xTUZMBtQFZXRWIoUbn7dKuxXPPpTOPCkrWSZjXOI/kOQrHKsgpBVsmQ9yapWkXw327qstJFm57hYTS+bZCV0TMCMxTAzBchLAbtgg7sBj7WAOTNhUIyD5dRlSbugSxfHnE6yZPhFOUoWZEnWo/2PkjHKb5CcD/smrEbEhym+PR9Wt63mxfNfjGEafO2xr/FA79RUQYDRWJqU1fbDaYQ7QENM7DPgFvefY7vgwU1wcCOobmIpUUMZaPKgG7od0tER6GD7wQjRlE7Qo9nXTjHYStZEGQ2Je8TzXYklaIjP3i4IkNi0EQDP4kUEQkE+dvYKLn/JMeiGbj+r5WLWDGhumHOi+Pe+h4mMJtj55CBD+48wR0oJ1EnWUQjTNIlExQQoZYrBW5IsJRgglZBKVomaLNnM0JpI1JWsIwv33vhj3jvwOTyKztiSV+K+6DpwFZ6Af/3Rr5MyUqzvXs9LF7y0+idk98qSDYmPPJI1nhoDIKzropA/2Ear1ZBYdR1hDYlz6rGAbCPiQHWsggDhvt0A7G8t37aj+MVquxErP0myXIzUVMkSCYOyHsApFEUpaPmaLaLpqK1uqGYjf92YtcTtGCw98T5jrlWX1Tu1Lmuy3EbEsiargF1Qd1kkyxDXgqwZ7GtZD6tfKyIB7/yw6BMFJEYUMoODKIEAgZNPdnYOFnKVLMiGX8w2YXD3+G4yRoagO0hP0Nm1JeubTCNbs2xEC9wH0i440Qt6lqTkXj8z67JkjHv5SpaSthIfp9sFg5UpWStbVhLyhIikI2wc3ljWvvmQNtL2uR4pdkGJS4+/FAWFB3ofsK2CuRZSSYpagh68LudJrD4rubbfHSOlp5zbBS0Vy1jyUuLW9xZoFCqPbuqoikqbv42n9omxcc3cJjS1tEJtx7iX0yvL50NrF0mQ7ePVcZskN4sFEt/KVVN+Pp4ax0Tc703ephn72cgJvziwbYy7fvws999wdKladZJ1FGIkmiKVEBfmREasdhhWaIXqL8MuaJEwxeolVK/JOnKw695recGGT+JSDHb0nEf4DdeCVvj7/Nf+f/H3fX/Hpbi48pQra5PoZNVlLfWMAZXFuMvO9bUiWRMWyWoxDFGzFmyzGxIrrsiRFX4hlawOUSs1WuVkQYDgXtF3amfTnLL3VRvEd2XGa9PTLBcj0RSKawzA8UTYKaSStX80zniZq/yFwgtmC2kVDLqD/PnZEdJ61iK4Y7D0fXXmHFGX9ezQs1NWnMtvRFzcLph2ifvFqwtVfMz6/MIBD5z9ZfA2CSVr/6MARJ8TwTjB005D9ZR3HecGX0D1SJa0Ci4NL3U8LrrcKqpLbKsHwuLvQuEXoW6xUGlkYHJqTV3B8IsOGePuXMnqi4g+SoY1b55pF7SUrDIaEgNoqsYpXWIyWw3LYH+kn4yZwat5q5YSWi0sbV7KeYvPs///0gUvnXJN2I2IQ+W1PFHHxT07GYCB6IBNsoYiSdJ6gXoi04QNNwEQX/IaMC2rbIPbtgq2+lpxqa6cJsQFkvimoZKGxACeOeIZ3zFuEs/ESevlXUvTkdhkkawVK6b8fMRa3GnyNtlugbzICb+Ijov3EmiaZTuaQ4w6yToKsX80jpkWJGsgJh5qU2uyHNoFrZUw1SJZdbvgkYHow79kwT8/jKaYPNj4Cha/8xdFCVZKT/HVR78KwBtXvpEl4SW1OTGLZM2xemVVEuNuK1np2pCsaFpMOMNW8AWBrJKluCJHlpI1aNmgZihZ1SNZ7l3bAdjU0FX2vkpDGAAjmYJZPmxLYTiatJWs7obq2gWb/G7mNgsrznN95VlgatWQ2K7H8rVxg2UVlIX2TprUdgW7WBpeimEaPHjgQfvnNslybBcsHnyR0sQ97tXF55dbN0ioE178/6ZsH3lMEKJyotslbLugMpVk9Uf7GUuMlX08CRl64dQqKM9Bkha9SazuG5ECY5aqQthSbEadhV9IJWvfaIy4g75WE6kJJtOTqIaGaW0+3anikw2JY+Vb/nKj3GeL3NALVTnyppjvP/79uKw5z9kLz57yWiXJggD6qBi7Jv0K/bF+WgIe3JqCacLBQgt7fU/DyA5w+Ym1i0UTX8iDqip26IVMFrSbEDuox4KskhUvtyGxVZfVIfNsUrOzDCY2ifHAt3IaySpVjyUx11LDh7YSHRLnEmyq3vPxUODIuwPqKIn9o3GMTBgQqyamadqWHjUQIC3tgg4j3FXFShmMx6vaK6OO8mE8dh3+uy5DxeR219msef8vUIoQLIBfbvwleyb20OZv431r31e7k5O9sgzZK+vIswvGdGFxaDYMcAch2J4lWdokQ2Wu7NUMhjGjR9aYNYGtVny7PjkJB0Sy4DP+zpKBCtOhNoiFHDOjZBWPGmEkPo6iifdf7ZosyOmXVWH4RdWVrIQgWX4tzOb+STwulfefJRZHnNgFIatm5Ua5V2wX9Oef7CQ0cY/LBrhjssWAtLSe9A7oWQdAJuUh/pwkWeXVY0GukiX+H/KEbLvZbNQsO/Qi7JxkQZa06A3is6kkYbBQG4DWoIfmgBvTdPZ9SxWrXcsulsjgKgmvVZOVKFOthWxd1pMHn5wR0lEujsTQi1zMC83j+y/+Pl858yssb1k+5bUBK/Siq0KSNRGAvmgfqqrQEZLhFwUcQpaKxbKziSXEtZYvWTCazNgBKetKxLdL+CsIvoBswuCcCbH/RLJyy6AeiZDeK64F78qpybaOSVagBdqEnTPWLz6TYLiuZNVRY+wfjWGmGwGFlJFiJDEyRclKlmkXdMnLwDAw07Vdsa6jCB75Keqdl6Ni8kvj5Sx9+08J+YsPKP3RfrvB4hUnXkFDnoaiVYPslZWsvFdWLdMFTdMkYYjjhnWRLphbk+VxjR85StbEfkhHhc2oRaSoyeCLailZchVxwB9m0h1gMlHeCrfit9IFdQViQ1U5p3xI6wZRq8l1s7cFn6u8CY4TyLqsshMGa9SQeMj6PCei4r2efWwXJy4QE44dDsMQ7Cj3AyLK3TBMIiNl9MiCkkpWXBXnoqXFNSkXAsLyGlU1OO/b4PIRTSwH08S7YgXuzk5nvz8Hpt2MOGvfqoZlUJIsp/HtEjKtL2sXLLIwJMMvrNo0iULXj6Iodr+sbQ7qsmSN0xyfGINdbhV1WgKprWSVaRcE0aS5I9BB2kjz5MEny94/F7JH1pEUejEdZ8w5g3MXnzvj5wMVxLebmQz6hBhXJv1ZQiwtg3nDLwwDnrtF/Hv1a4hZVrjgtGTBjkAHz+wfxzChp8lHh0PyF7Aj3Mu7FtxzhFW7a0JcW7NRspJbxCKiq6sLV/NUm6NcdChJssCuy4qOiPskUFey6qg19o/GARd+NQyIifbUdEGpZBUnWbJw1pVzGZix2tdf1JEHD10Df/ooAD/NnIP73K+xak6RglAL33zsm8QzcU7oOGGK17wmsJQsr5VyNRJNMZkobxCvpZI1mZ7ERPjfw4YuarJcXloV8cB0u8YZPFJI1kHLKti6VKQokVuTVZ3gC1l0vKd57pTjO4VMIzR1JTsZrwFGo9keWdUOvZA44pQsyy54YEh81xedNJfF7SLMaDiaYjRa+rs6vuN4gm7Rb2bj8EZi40kMw0RVFeervTGr0XSBmqyYIkiWmhbnKWuymnLDWXrWwWVPEjFEElglKhbMrMmCnITB4coSBiOpiJ3KV45dELI1Thm/leQbKVIrJ2PcHTYkBjimQyyIbXNQlyXfQ7dH3B/T67Egq2RVYhdUFKVqUe5HWo+scmCTrCbnCz36xITtdY34od8q4ehqLKJk7X8UxveBJwTHvNSunfJPj28PdvKkFXrhpD+WhD+nJqscd5LHUrLax8RzdDZKVmKjZRWcVo8FlG5EnIu5FsmaFOcUrNdk1VFr7B8VRKjZ0w4IkmXmkKy0jHAvkS4oB2o3ChnVsgzWwy8OPe7/Dvz5SgCuybySDcd+jNefUnoV8JG+R7h7992oisqV62sUdpELKzxBSY4zLyAe5PvKrMuqZfCFrNvwGuA1EemCQKtF7BQtwlDkCLELynqsjuwDqNo1WfIh198uriVp9XIKxS8mCUamtiRrJJZCsZMFq28VhGz4xfbBCIl06RoYiUJ2r9lCkqxkMsicsJ/Tl7QR9LrosSZ3TixkbtXNad2nASJlUFoFg81eVAcJZED2ey0Q4T7JGACKrqJnDJtkTb9GzUAHkYfE5LxSkiX7jVZTydo+JmoSOwIdxVPM8sBWsrxi/ChYkwVlNySGHJLlQLmUSla7SyiE7jwuFRnhnqhAyYKsZXC2dVlHg5JVCNIu2Bkqg2RZVkG9wY+hKvRFhZLVWSzGXVoFV5wLbr+tZE23C3YGOu0mxOschl5ANvjC0M2ySLesyQqPpkWvrFkoWYnNFslatXLGa47tgmCHX8SS4vOsk6w6ag6hZEGXVbvQH8sqWUpuM+KSwRdWFKypkLBW02VKYR2HCP/4OvztMwB8J3MhN4bfwZcvPK4kYUobaa565CoALlp2kT0ZqSm8IfCFATi+Sazq7i0zYbCWSpYcuBvlHNrqE9biFQO57oozdKSkC9qhF9nvrdrpgtIuONS9cMrxnUIqWYauQLR2dsGRSI6SVeVkQYmuRh8tQQ+6YbKl3/m1V+uaLCMT4jUnzrVjmZdYE2+ndVlnzBFR7vfvv7/8ZMFMUlhWoaBdcMLMTrJSiUzWLuifqrbGn34aY3wcrakJ/9rjnP3+aZAr7mrOrESOa3sm9hBLl++y2Dq6FShfxYKsMpS2FmsKpgsCNC8Uf0+zCxZVsqRd0EFDYkmyWjWR1pdvAdU7i+ALyIZfbBreVHGPJN3Q2R8RPdOO1JqsYuivIPhCkizCYiGnPyKUrG5rwaRvupJl6FOsggAxi9zZJCsqSFa7v90OvShHydLcqj3/Kydh0NXdDYqCO23QFJudkpW0kgW9eZSsskhW2zJSnk7SZraP2NGEOsk6ymCapk2y5jUKktUX6cOIigeQ4QvaKU2lmxFLkgUJTVy4ZqJOsg4JTBPu/RL8/YsAfD19ET9SLuKaN51I0Fv8ewP43ebfsX1sO83eZi5dd2mtzzYLqy5rVUAMvuWGXzS4xYRlMjVZ9ZCVseQYAI0yDtsj7FetAaH46lqawWKWn0OJPCTLVrKqQLKMVIrkDhHfHpm/GKDs+HJF2gVrHHyRq2RVO1lQQlEU2zJYTl1WrdIF+yZFDZqZCfG6E+faP1/SLvsnlUeynh16loMD4jNsLLcRsaKBL7/KE9EnSatiAhidTBO1kvDC03q5Re77BwDBM89E0Zz3F8qFtAuSs8DU5m+jw9+BicmW0S1lH1OSrGXh8uqxIEtaMi4xuXMUfDFxQJBXC0WVLCthcO9IrKS6Ku2CzaqYlE4PvRDna9kF45myQ25AqH2LmxZjYvJI/yNl7w9iwTdjZHCrbjsZ72hBRjfsmt3OMtSSjEWyXM3iu+mL9mGapm05nNEra/f9ED0oFiwXvwCA2ISMJ59qF1T0MAcnk2iqwuqe8pTYbF1WGb2yPB5cVj1l+1jlNVlmOk1ym6iF9K2cpZKlqkTbRFqp262XzBo40lAnWUcZRqIp4taAvLhZSLu5SpZurd4rqoLLXfzrlRerC4WEVWxetwseApgm3PM5+OfXALgqcwk/0F/N51+5mhVdjSV3H4oPcc1T1wBw+QmXl22DmRWsuqwlXvFgKZdkSSVLN/VZp1hNh/R5N8u+JNYKdGOwA5dF6EaTIxVNQKoK08xJFhQkK60bdjBFSxXsgslt2yCTQW1qQu0QiWTlK1nW5LLGNVkj0dorWZC1DG4sI8ZdTpLHkmNkjMoUgnzoi4hJ1HHdc5nXErB/vtRWspwtBnQGO1nWvAwTkx37hYrSUHboRcsUYpOLydSkHeM+MiaeDYoCjb5pJOuf/xS/u0KrIGQj3KdbHVe0inukkka5drJgBUqWzyItadV6NhazCwbbLOXchPH99o8lSc93/bQ3eGnyuzEcJAxKJSukhIH8C6iyGTEmtpulXMy2LktaBeeG5qKplZHtw4WhSArTBE1VaA06J1lSyfK1isW8WCbGZHrSrsmaYRd84pfi71WvBJfVNFiSrJCHSCpCLCOeq71D4vUVXSH8nvI+TzthcKLc8AsZ425WrGgmd+7ETKdRGxrsxMJc2M9qnzMLZCws6j2Dbud95Y4U1EnWUQapYnU2epnXaJGsaD+G1eNKkiyPTytpOctdDYtZCkPdLlhjmCb85dNw/7cB+Kb6dn6cOZ8LT5jD606aORjlw7cf/zaRdITVrau54JgLanm2M2GRrLlKZb2y/C6/3aOk2pZBqWQ1G7KRjLgX1IYOWqyEQUOdLJtsVB3j+yEVAdUFrSK2W56TqkCjf/bBFzL0wrdyJeGgTIYr72Gr+nODL2poF4zm1mTVjmRVkjDY5Gmye/3IicFskc5kiOti8nLhcVNXectVsiAb5T54UByzWvHtIO7RpEtMEkct21OT320TIdM0GbvpJpEkpqoEz3ie4/OeDjv4Ytpja2WL+Iw2j5QXfmGaZkU9siSkkpW2gnOK2gUVJSf8Yrf947A3jKqomJj2+JTdRWG5ZRksZmGNpWP2vkFTbO/Jo2Rpmmo/0yuty5ptv6x9k6Ln24LQgor2P5zoz2lErDmtaQT00TEAPC1tNHsFaeiL9E0JvrBdG3v/DRtuFP8+8e32MWyS1ei1VayQO8SmA+KcjncY3Z4Lf6UNieeKeWX7eOUpwHZ/rBUr8s5DpTNALkKUQjQgFlqC5sGKzudwok6yjjL0jolJ7dzmAF0BsULdF+2zlay0Jh4IpayCAJor29U+aU1I63bBGsI04a6Pw0NXA3Bd+FK+H3spx3Q08MVXr3YUXPHUwae4fcftAHxq/acOfbPHab2yyo1xVxSlZnVZo0kxCW6TjXMtu6BoSCzULdGQ+DCTLGkVzE0WtCZF4YCnrAd8IdjJTitX2tau8XKDL7yHJvjiYGQC1SWuo1rZBQFWdQsla3PfJLpDNVNTNXviVC3L4F+37gTFBFPhwrVT+/RIJWvfaGkLmYS0DKbHxXsqP769OMlKa2KiNz4xNZhFj0Q48LGP0/ffnwag6ZWvnBHVXA7sCPdp13+lJGsgNsBkahJN0VjctLjs87FJlin+LmoXhJzwi2xdlqZqhL1hIH9d1vKu0iRLBimE3CHUjDiXfMEXkFWzKq3LOrnrZFRFZc/EHjuKvBzsmRDBH/Maj95kQacx6RJSydKaw3QFxZxsIDZAhxUDn8wYYuw1dDtBmHVvhjkniP3Thv19BZo8djphR6Ajpwlx+feVDL+IVdqQeGwWSpZFsqb3xwJI62n72e/ILghENTHvCJgHYLy3onM6XKiTrKMMMllwbrPfnpAMxYcwosJekrGsDU59qzLGPekWE1KpiNVRZRgG3PlheOQngMI9x3yaz/afjt+tcc0bTyDgKf196YbOlx/+MgAXHnMha9rX1Pik88AiWY0p8SDYPxpzPGGVsElWuspKlpUu2G5YZMK6pgm220qWok0e/l5ZxeqxArNXsSBnJXHlCsJ+8bAt2y5oK1lAtHYkS04iPWrATp+sBRa1BfG7NeJpnV1DzpWiaodf3PiUsL151UaC3qnW0LYGD40+F6YJu4acWQbXdqylwdWAPyGUurJrsgqEXsBUu+CktSLe5HcT3/Acu17zGibuvBM0jfYPf5juL3/J2e8tAFOmC04nWa1iorZ9dDsp3fk1LK2CCxsX4tHKt+DKGqeUbiXvFuuTBVklq1BD4iIka3MRktUbEZPKnoYeOzk4X4R77jlX0isLxNi8unU1UJmadaQ3Ii4GO749VF56nW7XZDXbJKsv0ofPrdnjef9EAh6/FvqfFfWPL/msvb9sGKxqCt6Ay1ay2gPtPNsrSE5lSpb43eUqWe451kLqrJSsrJNiOmQ9lqZoNHqdjffW9JagOgr7K6sXPFyok6yjDNIuOLfZT4uvBZfqwjAN0lExacgo4mHi8Tvz78rBOumyGo/WSVb1Yehw+4fEIIvCttO/yrs3iP4vX3z1ajtlqhRu2nYTm0Y2EXKHuGzdZTU84SKwgi880QO4NYW0bs4s7C2BWilZcvAO23ZBSbJa7YbEqit6+EnWwZkkq5rJgqZhTLULBqb2OHIK5RDVZA3FBWFv9nTU7HeAqLVY2S2uvcMVfjEeS/Pg7l0AdAbbZ7yuKEpOXZYzIuhW3ZzRehZuwwOYNDSXSbIKxLdnjAyxTIyUZReMRFJgmrx449/ZfcklpPfsxdXdzYJf/ZK2974HRZ3ddCLbjHjqz7uD3TR6GsmYGTuS3QlmYxWErJKVyoj3pUdLkF7ZkHharyybpOe5flY4UbIsRam7oZtU0mrPkscuCOCzlKxEmfd6LqRl8OH+8uuy9k0Iu2CtSVZsIsWmBw+QTjpvx1AKkmR1ldEjCyAzapGG5ma6rcRnuXDU1STG0KGDB+CeL4gdXvhpUcNnIWsV9KAoik2yvLSQSBuEfC4WtwXLfj+VNyTO1mRVki5omiYJ+/lTOFlQWmmdIDYmntlBbRT21UlWHTVElmQFUBXVTvAxYpaSpYgJlRO7IGTrslJWgpJZJ1nVhZ6BW98PT/0aFJXxc37AJY8swTDhdSfO5TUnOqvDGkuM8b0nvwfAB9d90H5w1xLpvj72f/jDTN53X/aHlpKlTBxggdXwdM9wZTHula6SFcJI3GpwqBuYKOAW1zTB9qxdUJtk8HDHuOfpkSVJVrgKoRfpvXsxYjEUrxfPokX2MccqVrJUzOhwNpmgyhhLWSu3/q6aHD8Xsi6rnKbEdkJcfPYJi7c/c4CMIn733Mb8pLKSuqzVXmE9SvsTaC6Hj/V4cSUrasW7SyUrORrhMw9fy0vu+Q2k0zS85MUsvuVmAiec4Pg8i6GQkqUoim0Z3DTsvF/WbEIvIEfJSoGJEyVrpl0QskpWvoTBZRbJ6p9IFEz/7I0KJWtOwxzSVjhOIbugz1ayKg9pyQ2/KCcB1jANuyar1nbBx+7azb2/3MyWf5dvaSwEu0dW2XbBMQC05paskiVJlmUZ7Hr065AYg87VcNI7puyfS7IgmyyYSolr4/h5Yed973Lgr9QuODerZE0myrcLpnsPYExMgNuNd8mSGa/bjYiL1IJOR9TqIxZUR2Df7JplH2rUSdZRhly7IGCvnBAXqzDSP+7YLmgpWSm3VLLq6YJVg56GW94Dz/weFA39NT/nfU8tYSiSZHlniM+/arXjQ33vye8xnhznmOZjuHj5xTU8aQEjlWL/ZZczedfdjPzvz7IvhLpE5LORYXWTeCiVW5dVOyVrDICwbggVSy6JB9psJUtxTR7emqw8yYIAo5ZdsBrJgnIV0btsGYrLZVtWym5G7M1ONsxUSoR11AARXdT39QTn1OT4uagkxr2aDYn/8Ng+VJe47tv9M5UsKD9hEKDDEJ9dxFtGOIdtF8w/2ZGLIIZb3Dvt//grp/ZvRNdcdH7608z9/vfRwmHnv68ECilZkLUMltOU2CZZ4QpJlqUKmSbomrdiu2AxJbTR52ZOWDzLN/fnvyZtJSvYTcqyC+brkwW5vbIqV7LWdqzFp/kYig+xY2yH4/0Oxg6SMlK4FFd2XlIjRKyecNEyCUQxDFTQIwum1mTJ990fFep8V5OPNcpOluyzmg+f83XQps7NYuPTemRZjYjHJsScbF0FVkGoPPjC3dUJmopbB2VkvOxWK0mrCbF36VIUz8znmbwPnNZjAUTlZ3T66+G875R1PocbdZJ1FCG3R9bcZnEDdgW70HQTJSMG34xh9b5yqmRZZCyjyQj3upJVFWRScOM7RGd31Q0X/YLv9h3LQzuHCXg0fvDGExxHsj43/Bw3bhWJRJ865VO41Nr3iRj40pdJPPsskO0DAoCqgZVquSpYWa8sWXdTbZI1nrJiYQ0dxZ2NxSbQatdkuV0Th9cuONELqUmRLNiSXeUbsWooqtEjKzf0ArI9jSSRcwrVl61NMHRqYhk0TZMk4rjzm2pPslbZJMv55KFaNVmb+iZ4Zv84mhVD3OZvy7tdJUpWKGkRQVc/Sd3h9W0HX+RXsiZTkyiGyTFWwhk67A+28fBHv07Lm97oKKinHMjWCtOVLMg2JXYafpE20uwYFwShUiXL5VZtVTDtCqJHo8WvGWkXjA5CKkuQS10/dvhFgabEskdWT0MP6aRUsgqQLKuBcqLC4AsAr+ZlXcc6oDzLoIxvnxOaU/NnlIyoz9TALtjZOPuaLEmyOkMePue+DgUT1lwEC06fsf90JUs2Ij4wLL7LcpoQ50IeL1YmyVJcLlxd4n20jum2ou0Udj1WnibEUGaPLAu2knXqa6C7smbnhwt1knUUYTSWJmY1g5TdxLuCXfhy7qF0RjygCq10TYf0dmesPll1u2AVkEnCDW+BTbeD5oGLf82/XKfy/XvFyuqXL1hjr1aXgmEaXPXwVZiYnLPoHE7qOqmWZw7A2M23MPb739v/10em2VxkryyP7JVV3jVTCyUrY2SIWEEatpIl4fLQqonVYu1wkyxZj9WyxO6RArk1WbMPvtj92L0AJBaLB6W0C04kMmWFlCguF4pbnI+ZUWoSfjGZzIBLXEdLmp1ZZ2eDZZ0hNFVhNJamb9yZal+tmqw/PCb6J3U2C0JdiGTJsWHnYMRxT7dYv/DajfoG2D2+29kJlYhwj/bt59O/Mzh265g4dus8LnvBf+Fann/yNGsUSBeErJK1dXQrulF6Yr1nfA8ZI0PAFai4LYCiKNmGxO4AZDKYxfpI+ptB9iwc22f/WF4/+eyCUDr8QvbIyg2+8BRoWO8Lzi74QsKOcj/gPPziUIZeJC2SlU4ZVTtm/3j5SpaRStmhY1oOyRqIDaAbOqdN/oUT1O3EFT+89PN5jxG3SJZ/ml3wwLAge2vnhst/M2SDL9IJnUyqPDLqkeEXY2bZtv7c0KV8kPeB0/j2VCJjk2nZrPloQp1kHUWQVsGOkBefW5Cj7mC3TbIUj4eUNeg4tQvKmizDin6v2wVniXQcfvcG2HoXuHxwyW8Z6H4B//W7pzBNuOSUebx6nfMV+zt23MHTg08TcAX4yEkfqeGJCyQ2baL/c58DIHzJ6wHQx8cx9ZxB2iJZc1TZK+vw2wXtqFkTGo1pJAtolZMf7TAHX+Spx4LcdMHZPUQSmQRsEiv4NypPAiINTmKiXMugv7bhFyORbI+sBY21J1k+t8YxFolxahm0a7IKTJKdIJUxuOVJQbLCIbEoUYhkzW3249FUkhnDbtlRCgO7xHsZCO12bvEqEuEe+df9+N/536zZY4Ii7pcD7YuIu322MlptGLImK49CtiC0AL/LTzwTt2PCi0GGXixtXjqrNhdZkiXGE72UZbB5pmWwlJJVLPwiqScZiosedT3BHtsuWDhd0Aq+mEVNFsCpPaIu69GBRx034bZJVuMhIFmWUlcueSiEeEpnwqp3K4dkyXosNA01FKLd346maOimztDoTtZt+Q4Av/G9HhrzWyhze2SljbQ9zpjpJua3BGhtKE9Zk/D4XXaLnnLVLFmX1TFO2THuic1TnRTTUW4j4qgVeuH2aY7ntUcS6iTrKEJusqBEV7ALnzVvUgMBUnFrpatMu6ChisldPV1wFkjF4Levh+1/A5cf3vB7MotexId++yTD0RQruxv5zPnHOj7cZGqSbz3+LQDet/Z9dARqm76mj4+z/0OXYSaTNJx1Fp1XXileMAz0iZwJqUWyOirslVWL4AvZrNNleHDBTJJlrZrpWpLBycN4jQ9aNSXtU0lWtdIF//XojYTiJhkVfpt5iG2j23BrKg3WynfZMe5e8YA3a0SyDkaiKFaNUi17ZOVCWgadhl8Ui+B2ins2DTAaS9MR8pJGTFoKkSyXprLIShPb7iBhMD6ZYmJQXNMHG/bYNrmSiFk24By7oJlOc/Ab32Dfu9+NNh5hdwf8+7we6zWhNDVVoVl2PkgrXr4af03VWNa8DHBWlyXrseQ+lUKGX+ghcQ0YkRLWKRl+kZMwWCz4ArJK1tb+yRl2RFmP5Xf5CXvDdvBFocmmHeE+i5osgBXNK2j0NBJNR9kwtMHRPtIuOC9U+x5Z1bYLHpwUi8s+t0pjGRN5fcyqxwqHUVQVTdXsMLK+B76BJznMDqObnyRfVvAYuXbBodgQJiYqLkw9wLoKrYIgFisCdl1WuQmD4p5vHy9PycqMjpI5IK5Zb5XsgrZVsKkysnm4USdZRxF6p9VjAXQGOrNKVsCfHYTLjHA3rD4i9WbEFSIZgesvgp33if5Mb7oJFr+A7/xtG4/sGiHo0fjBG9bZCqQTXPPUNYwkRljYuJA3rXxT7c4dEfvd+/GPk96/H/e8efR87auoHg9qSEwA7BU7mNEraySaYjLhfBCvhZIlB25PxpoA5tZkAc2BDlTTBAWG4yOObVhVR57QC8hRsmZJsp7+hyiw3tupknbBD576AZCtyyo7/GKKkjU0q3PLh50jvSiKiWK6HdtHZguZMPjcAWcrtLl2L8OszJ50w2PCPvaaE+fatsNCJAtgSYcgWTsc1GUN7BaTILU5TcoVd6Zk6WmQK9SWXTC1v5fdb3oTw1bQzcGzT+C/36KR6RHKn5oR98xs1dZCMOU9WSBJrZyEwdmGXkjI8ItMIAyAEXGaMJijZOVcP/lquha3NeBSFSaTmRnKpV2PFexBURQ7wt1dIsK90mbEEpqqZaPc+5zVZR0qu6BpmDl2weqQLGkV7Gr0lVVrmBt6IWHXZW25E4DPZt7KwZhZsLm4TbKaPHbohctsAtSK+mPlotLwC49UssbKU7KSW8TzzT13Lloof2uackmWDAYJho8+qyDUSdZRhenJgiBWf33WCqPi99uDT7npgqZUsmJ1klU2EhPw69fA7n+BJwRvvgUWPo9/bB3kB/eJvi5XveY4Frc7q8MCMUn47ebfAnDlKVfi1mqzeiwx9KMfEf3HP1G8XuZ+77toTWIiqjULSV+u2AF2ryzXZC+tFikoxzJYi+ALqWT5DOu6n6ZkaQ3thC0/kqFOMl4m2agKCiQLQnXSBQ9EDqBv2gpA90lnoqBwz957eG74uZxeWeWGX1i1mpnaKFl7J0U8tYeWqgcpFMKq7vISBmXUsG7qZVtnQEzg/rFVqL7nr221C8mLkayl7c57ZUmrYHi++K4ckay4vJ8V8IeJPPAAuy64gMTTz6CGQsz57nd57u3PI+1W8PnFCrKmi+dMreyCkr+qBa4DWZflJPxitj2yJKT9TveL8dCIlPg+mmeSLHn9pI10XlXA41LtsJPplsHcHlmmadp9oUo1I07MsiYLYH2XVZfloCmxaZrZHlk1tgumEhmRqQ9kqlSTNWC19eioMFnQFc5a32ySpSmYK8/nEfV4AA5O5Lep2yQrlCVZ6Zz49tmg4hh3q1dW+7jJeMr5mFesCbFE2UrWWNZOeTSiTrKOIkxPFgQIuUM06eLiy/hc2YjXMvtkoYrB2ShW2FvHTMTH4NcXwr5/i6Lnt9wG89fTNx7nw78XdVhvXD+fV651XnxtmiZXPXIVuqnzkvkv4fQ5MxOJqonIv/7F0PevBqDrM5+ZMkDKFbop4ReWksX4fua1iGuxHMtgg1tMKKpJsqTP269b1/M0kiV6ZckY98jhqcuaOADJCRGB37rU/nEirRO1VmRno2TdtuM2lh4Qk47Fp76McxefC8DVT15tqw/lNyS2Ukd1BaLVV7J6J8VKfVDLH2deC0i7YO9Y3BHpdKtumqyavkosgzc9sR/DhJMXNhNqsGxJmo+gu3CD0SUyxv1g6WSv/p1iErTwGGFT2je5j5Re4n3ZjYjDoGoMfOnLGJOT+NeuZdEtt9B49svs+zMQEM8XjzWfDftrpGTZwRf5X5cJgxtHNhZN+Yumo/RGBHmvll0w47MU/ckSJEvGuOfYBb2a1x7zyg2/kO9jTsMcQbCst13QLlglJQuydVlPDz5NLF18fB+MD5LQE2iKRk+wsqARp8h9b9VqRnywwvj2jK1kZUlWd0zcj30eL8rZX7abG/dPzJxbpRIZ+z0EmjzZHlnJEB5NtceqShGwwi/KjnG3lKy2CZiIjTneL7FpIwDeAqEXUIldUCpZdZJVR42RryZLURQ6FTEBSHk026vsNF3QbdVqKFbkaj1dsAzERuBXr4b9j4pkqbfeDnNPJKMbXPbbJxmJpji2p5H/d96qsg77591/5tH+R/FqXj528sdqc+4WUvt7OfDRj4FpEr74YsIXXjDldblCNyXGXZKs+ChLw+Kf5ShZ0i4YSVev75JUsoK6NaTlIVktdkPiCIOHg2TJ0IvWqcmCkvhoqlJWPUAuDNPg9q23slg4OPEft4b3r30/mqJxf+/94N0FiITScmArWbqSnZhXEYNxccJhd23rDXPR5Hczr0WMoRv7HIZflEiIKwTTNPmDZRV83Unz7BCDVn9rUeXOjnEvoWQZhmnbBZcun0PIHUI39dLhEDnx7WYqRWr3bgDmfO97eOaKVWxJshoaxGflQUwYQjUqPpd2wUKfy9LwUlyqi8nUpG2jywdpFezwd9jkuFLYwRce8X1UYheE0nV9ywuEX8imtt3Bbnsyrijg8uSfusl0QT1tzDoUYn5oPl3BLtJGmicPPll0W1mP1R3srrnrQrp1oHrBF1m7YGXx7TbJSkbo3vFPAPo6lkF4vk3c8pEsSX5cHhW3V7NJlpluYlVPI16X8/KCfJCJhfGJ8sZ9V3s7hqbiMiA54Lzhc7KEkhVLx4hnxByzbLvgUZgsCHWSddRA9MiaaRcEaEesdiQ8lpRO+XZBRbECMOokyxmiw/DLV8KBJ0Xh+FvvgJ7jAfjGX7by6O5RGrwufvCGE8qqw4qlY3z9sa8D8K4176o4ftgJjGSS3ssvRx8fx7dmDZ3//akZ22gtllUqtybL12hHFa8KiElBJSRrIjVRdqPDQpBKVoNuTdCm1WQRaJ2mZB2GhsSSZBUIvWgOuCu2zD3a/yjs6cWXFrZhz+LFzG+cz6uXvhqA/dwCwHiZdkHFbylZNbILjiSFPabV11X1YxfDsd3i+i07/KLMGPdHd4+yezhGwKNx7ppum2QVakQssbhdLBKMRFN2vV4+jPZHSSd0XF6N1p4gi8OLAUqHX+TEt6f27QPDQA0EcHVkz0uSrFCDOBcFhTafG7VAzdRsIYeCfBHuAB7Nw9KwUIA3Dxe2DG4dFZbZ2VoFAXxSyXKJ8aSkXVAqWYlx4XKwUCqhslDCoIxvn9Mwx15AdftcBccJt1ezP7/ZJgwqisKp3ULNKlWXtW9SLCQsaFwwq9/pBKkaKFnSLlh+I+IxIIdk/esbdEXEGNHvE8S8yzrmQJ6WETGL/AQaPSiKYvfIMjKNs7YKQo5dsNxeWZpGol1ck+aBfkf7GMkkyZ07gSLJgknxnPaonqJKfi7qwRd1HDJc+/ZT+NZFa5kzjWS1Ih4AUZeR7aNRpl1QwwrAqAdflEZkEH5xHvQ/C8EOeNsfoWsNAPduHuBH/xATnK+99jgWtjkbSCR+8sxPOBg7yNyGubx99durfuq5GPjiF0k89xxaOMzc734HNU93drsmK1fJgmyvLO8YUF6vLFmTlTEyJPTq2FOlktWoSz/NtPq3HLug6oowNHkYlawC9VizCRS4dfutLOkT791/7LEomrif33vce3Grbob0jWiB7WUHX6i+2gZfTGZErVJ38NAkC0oc21NeXValDYll4MV5x3UT9LpsklWsHgsg4HExJyw++2J1WbIeq2N+CFVTWRIWDa5L1mXlxLdLFcuzaNGUybtUmkP+kD1xb/PWTqXIKlmFt5HhFxtHNhbcxg69qALJkva7tCYmyiXtgt4GCFjf7dhe+8eleq1JJWvHYIRUJltnJBW77oasklXMpaIoSk74RRXqsrqd1WXJ0ItDkSw4VcmqUk1WBT2yYFrwxdB2ePBqujLie+q36quK2QVjVp2W3YjY2sfMNM0qWVBCHrdcuyCA3ikWltR+Z+N+cus20HW0cBhXZ2febUasxZ0Wv/MaXBnhXg++qKOmUBSFUxa1cOEJc2dIyGFD3MQTruxF6zxdUAzImmKRrHrwRXFM9sN158LBjdDQJQhWh3jw947FueKGpwF462kLOGdNeRPH3eO7+cXGXwDwiVM+gVer3crN2I03MvaHG0FR6PnmN3D35FfM8tZkgU2y5sleWcPOu8L7XX77eqtWXZZUsppksx3PNCUr2JZVsrTJw1OTJRsRT++RJZWsCuuxJlOT/HXPX1l6QExSfWvW2K91N3TzumWvA8Db/peiqkg+qD4rwr1GSlbMFA/wOaHa1nFMxyqbZJWXMFiOkhVJZvjTs8Jqc9FJYvKZaxcshWxdVhGSZdVjdS0W72dJk1OSZd3PgdYsyVq4cMom8t5s9IZQLXtaS4EmuNWATbKKKGWyLqtY+EW1Qi8gW5OVVqw+kqX6ZEFWzcoNvygR4z4n7CfkdZExTHYOie87baRt+9iUHlkFkgWnn3M1SJZUsjaPbLbH2HyQ9tRD0yMr+76qlS44MDk7kuUKN8NdHwcjTff8MwGh2sQzcVvJ6s+nZI1PDXUYsO2C1VKyKqvJAjC7hYXbM1D4e8+F3R9r1cqCBKrceizTNIna6Yt1JauOw4RGXUzOxq3rWtUUNJezr1auimnWpVAPviiC8V649hwY2gKNc+Dtf4J2UVid1g0+dP0TjMXSHDe3iU+dWzhdJx9M0+Qrj3yFjJHhzDlnctbcs2rxDgCIb3iO/s9/AYD2yy+j4XnPK7ity1KyMmP5lax2q1fW/tE4usNYdEVRqh7jLm0Isu4qf/CFVZN1OIIvapgseNeuu0jqSY4dFA8h/3Frprz+rjXvwqV40QJ72Zd4vKxjK7lKVnwU9NkX1EsYpkFGEQ/dxeHaNyLOhYxx3zEYLRitnItKGhL/6Zk+YimdxW1BTlwg7iOnShbAEssyuL0YybLqsToXifcjlaydYzuLH9y2CzaT3CXq9aaTLJmE1+BuwHSL50Ozq4Ykq4RdELIJg4Vi3E3TrFqPLMjWZKVNq9Yp6qCOVCYM5oRflFJCFUWZUZc1EB3AMA08qodWf6vdnsVdohSgWg2JQVynS8NLMTF5pP+RgttJu2Ct49thavCFnjZm3Y7DNE0G7OCL8iby8rmoRbfBjntA8xB6xdcJWPbSgehACSUr2yPLNE2bVDe625jfEpixfbmQSlaszD5ZAK4esUjsd5BwCtl6LO+K0smCThsRpxO63Qutbhes47ChISMG1XFZ8+8v7NmeDrkq5paXQjKJqVdndeg/CmN74bpzYGQHNM0XBKt1if3y1/+8hSf2jhHyubj6khPKLlj9+76/88CBB3Crbj5xyidqFmetj43Re/nlmKkUDS98Ia3veU/R7bN2wbGpL1gkK5jow6OpZAyTvnHnKmi1SdZYQpxfq249TKb7vf0ttpLldo0f+pqsyT7Rl2hasiDAiBW3XKmSdev2W3FlTHr6xXvKVbIA2gPtPL/zVYCozSqnDi4bfGGND3Fnq5pOMBQfAkXHNFUWNx9aJauz0Utr0INumDPqYPLBVrLKsAvekBN4Ie/nckjWUqlkFZjkpBIZhg8IBblzkaVkWSRrz8Qe0kaRiVU+JWvRoimbSLtgo6cRw3JJNM6yEL8YDLO0XXB583IUFAbjg/ZnmYuDsYNMpCbQFI3FTYtnfU6SsKSs1hBGKbsg5IRfZO2CpZQsmJkwaIdeNHSjKmo2ObhEqJUMv6iGkgWUrMsyTTPbiLjx0NoFYfbhFxPxDIm0WIArW8kasUjWc9eJH5x2KUrbUtv+3BftywZf5FOyJrM9ssaSY6QN8f+1PfOrMgeQNVmJyVTZZNQ7TxDm0LCz53pik6VkOUgWdNoTUSYLenxaSQX3SEWdZP0HIJARX+OYle/qNFkQsv02XCgYVnauWVezpmJkF1x7LozuhuaF8PY/ir8t/G3jAD/5p1g5/vpr1zK/tbwVqEQmwdce/RoAbz32rTUrHjYNg96PfZx0by/u+fPp+epXUNTiQ4DWLIMvpitZ4mGqTvTaQSyVhl9UA1LJapMTy+lKluai1SUmrYoWYfBQ12TJeqyWxeCauiIngy9aguXXu2wb3cazQ8+yZFBDzRho4bDd4yQXFyx+E6buIaXt45699zg+vh18gTX5qKJlcM/4fgDMTCMdodmv2pYDRVFyLIOlr8FS6XDTsWMwwmN7RtFUhdeckP0+nAZfQOmEwYO7J8CEUIvPXuXtDHQScAXImBm7b1Fe2CSrhdRuobjkKlmmaWaDLzwhZGeEBq2GEx0HdsGAO2CPj/ksg9IquKBxAR5t9jUcMvgirSuYOAi+gLx2QSc1fdPDL2R8u4xET5doRCxRTSULKNmUeDgxTCwTQ0FhbkPtFelUbDrJml1dlrQKNvndZYVUmaaZrclKHRDulud/FICuBqtXVrTfVrIOTiZmEB1pF/SHsvHtRibICfOq09LC1+C2zhWSZfZOC8xbCEB4tPSCpGkYJKxGxFXtkTV+dFsFoU6y/iPgTYkbN2nFsDsNvQDw5HjsdasGqG4ZzMHwDlGDNb4XWpbA2/6UfYgiGkR/5A+iDuvtz1vIy1eXn5J27YZr6Y300hno5N1r3l21U5+OoR9cQ/Rf/0Lx+UTD4cbSPTjsmqwCwReM76uoV1Y1laxEJmHHwnZaK4EzSBbQalkUDFecwcghrj2U9Vjty2e8NDKL4Itbt98KwNlxoWD4jluTdwV0Xrid1MgZAPzgqR+gG85Wf6WSZWA95KoYfrF9RJAAM91Mo6+2sc/5UE5dlj1JdliT9YfHBIF8wbL2KQ1OK1Gy9o/G81oa+63Qi87F2ftYURRbzdo+tr3wwS2yrBt+9CFxTp6F2cWdWCaGYXUHbvA0kLIuqWChJlZVgJx/llrAL2YZrGboBWQJi2kq6JoPvVSEO+S1CzpJp1zeJb5HSbJkI2KZMOs0OdhbZSXrpM6T0BSNvZN77bTDXEirYHewuyrEthSmK1mzTRjsH6/MKmjG45hJsVjn8hrwsi/az52ugJgH9EX76Ah5URRI66ZdfyuRaxfMhl5Upx4LQNNUW9kstyFx0wJxD7VMmKSSxZ/t6b17MWMxFK93hu04F+U3Ij66Qy+gTrL+I6DExYWoWwlITuPbATS3iqqJp1rMaphYj3G3MLhV1GBN9ELbMmERbMquSqcyBh+8/knG42nWzgtz5SvKq8MC2D+5n59t+BkAHz35owSmR49XCZF//IOha64BoPtzn8W3orCknwtZk2VEIhipnEHaJlm9LGgW1105SpZMGKwGyZLJgpgqLYalUOUhWS0Ba3VQMRmJjVctPt4RpJLVMfMaySpZ5T1I0nqaO3feCcCJI6Imx796Td5tmwMeUiNnYuo+to9t5+7ddzv6HbIZsWmTrOopWbvGBBFxmy01iwUvBlmX5UTJylUiSl03Gd3gpifEe3vdSVn7lGEadrqWk+CL1qCHJr8b04SdgzODZWSyYNeiqb2g7ITBYjHu1nmkRsRE3NXejtaQTeSU96VLdeHTfCQVK7mS2n1PToIvIJswuGmkCMkKV4dkuTyaXd+cdgUc2gUXir/H9tqFZk76rC3vFAtPvWNxJhLpbLKgZT2TycHuUnZBixgmq6RkNXgaWN22GsivZkmr4KEIvYCZjZZnaxccqLARsVx4VFQTZenz4Nhsj0n5nfVH+3FrKq1BMX5Otwza6YJNHnaNiu/bTDextkokCyoPv2jqWUjKBaoJY3uLLNiQtQp6ly1DKVK3WW5NVuwoj2+HOsn6j4ARE5NbXbOaRpahZEF20I5bsdf1hsTAwEZRgxXph45VIkUwNFWl+spdm3l63xiNPhdXX7IOj8OwkVx8/dGvk9STnNJ1CmcvOLtaZz8Fqf376f34J0TD4UteT9OrXuV4X7WxESxL4ZS6rFA3KCoYaZaHxPVSTox7NZUsSbJMPUiDUphkuQNtNFp1WRllgol4dSYhjlAgvh1ylKwySdY/9/+TkcQIbf42mnaKABLfmtV5t230ucDwkxoWgSrXPHUNGaP0+7cj3K3C/2qSrF5rVTyg5qg6z9wA178exopY3aoEGeO+uX+iZGiLXHlNGSmi6eJJmv/YOsjgZJLWoIcXrcg2WR5LjpExxWfupCZBUZSCdVmmaTKwSyhwsh5LQiYMFg2/sOyCKeu4BZMFPY0oikLMIgu1nOpI8lqKcBdLGKxmsqCE3ZDYHXBoF7SIdTpq3y8tfnH9RNNREpn8TpGmgJtuy1q2tX/SVo2kkpV2WJMl0wUTDpSs3Lj4YpB1WQ/1PTTjNRnffihCL2CmQjfbhMGDFfbIyjz7ZwA0r4Fy7jemSLDdDdmaLMD+XnNJlmmadpPgQKOHZwfE59jgaqXJXz1lPxt+UR7JcmkuhpvEs39ib/G00kSJJsQSMqHSuV1QktA6yarjMEKSLFO1lCyH8e0S0uMdt8IC/s8rWf3Pij5Y0UHR/+qtd0JDx5RN7t7Qz88fEKlc37zoeNsyVw7u772fe/fdi6ZoXHnKlTUJuzASCfZfdhnG+Di+tcfReeWVZe2vqCpaOAyAnpswqLnAit1e4hkDyotxD7mrR7Lk6piRCeLHIln5FMEpCYOTDB6qhEHTLEqyKk0XvGW7aDB8Qc/LSVlNIP1r8itZLk2l0eciNXI6je4weyf3cseOO0r+DkVGuMuinGj1SFa/NQEJuXLurfu/DVvvgt+8dkoz11pgUWuQgEcjkTbYNVR88ux3+e3EsFKWQRl4ccG6OVMWXqRVsNnbjFtzNokqlDA4MZQgPplGdSm0zwtNea1kQ2JDtwNMUv1Wc9ACJKvBcjdErdYIbqOWSpb4u9Q4KJWsfZP7powfaSNtR9dXlWRZdqu0K4DuhGS5vGIRCmzLYMgdwq2K4zgNv5hOslJJK12wRIx+tk9W8UWU3z6yl2M/czff+suWkupsbl3W9G1l7d+hUrJS04MvqmQX7CqHZGVS6Pd8D7DCoaY5FHKVLMgSuNyEwVQ8g26R3ECjh50jVuPpaYu5s4UMv5CErhyMtVgEbc/uotvZ8e1FQi8gO3aWG3wRbKrbBes4jMiSLEvJKsMumLt90iNJ1v/hmqwDT8J154kVyJ518JbbITh1QNg7HONjN4o6rHefuYiXrsrfeK8Y0nqarz7yVQDesPINLG1eWmKP8mGaJv2f/wLJjZvQmpuZ+538DYdLQWsp3pB4ruyVdZiCL2SyoKkHCGJdu9ObEcPUXlmHMsZ9sh8S40L5a535PY9UYBc8GDvIv3r/BcA5qRVgmrh6unG1Fa71CQc8YHo5Z/4bAPjh0z8kpRdf3bSVLMN6VFRRyRpOiglIq9e6f0wzm8g2uBl+/ybI1O47UlWFld3Owy+chBcMRZLcs0kUsOdaBaG8HlkShZSsgd1CxWqbG0JzT32MS7vg7vHd+dXKxDhYIUmpXnGuhZIFbcXZum80vXYWWzl5L1X2FfaF7Ulsrpq1d2IvaSON3+VnTsPM8JdKIe13GVcAMxbDzDhQwO2Ewd2AII5Orh+bZPWN2xN0+V6c2gXtmqwSQQe3PNlLWjf53r3b+cgfni6qaq1tX4tP8zGSGLHVQok9k4JIHopGxJAlj5KLp2cbfFFJfPu/r0EfFN+PNm9mqwBZk9Uf7cc0TbosJWYgh2TJGimP34XLrdEfFTVZx7RW79oF8M+iIXHECvFK9e4vup1tFyxShmCaZtk1WbZdMFxXsuo4jJAkC6X8mizIKllJa/XfiDufLP9HYf9j8ItXQWIM5p4Mb7kNAlMHg2RG59LfPsFkIsMJ88N8/OXOapum41ebfsXuid20+lp5/9r3V+HkZ2LsD39g/OabQVWZ861v4u4urzmyhCtskawCDYllr6zRWJqJhLPVsgaLBFVDyZLJgoruR7VqR2Y0IwZLyZINiQ8hycpNFnRPXS2Np3Q7PjgccG4RuWPHHRimwbqOdTTvEpP3QvVYEvL468Ln0u5vpy/ax03bbiq6j2qlC5oZa0ZTpeAL0zQZT4vrpsNvrdzGRyFlkQlPA+z+F9x2abaBUg2wqhyS5aAh8a1P9pIxTNbOC9sTZgk5uXYSeiFhJwxOU7IGdsp6rJnhNd3BbvwuP2kjbYcSTIEkyt4mkntmJgtCTo8s6z4dt+4bNVNDkiVrshwo+nZdVk74RW7ohVrFgI5cuyCAEXWg2MvwizJj3GXC4HMD+8mYGVyKy06idBrhbtsFi5CsRFrnqX1jgCArNz/Ryzuue7Tg+O3RPJzYeSIwtS7LNM2sknWo7IKWkiUtZNWqyepwqmRNDsA/voaeFNeYq3VmEmBnUCwcJfQEY8mxvA2Js42IPRiGyWRG3JfH91Q3XThg1WSVaxcEiHeI8cXo7Su4TWZwEH1wCBQF3/KZwU4Su8Z3kTEyeFSP4zHQDr6oK1l1HE5IkqVQmV1QDtopyw7zfzLCfe+/4ZevFr2M5p8Gb7oZfE0zNrvqT5t5Zv844YCb77/hBNxa+bfQQHSAHz39IwCuOOkKe7W4mog/+ywDX/giAO3/9V8ETzut4mPJXlmZAkqWN3qAVkuFcZowKIMv5Ir5bCBrstx6zmpXPrtgoHVqQ+JDFeNezCpoqVhuTaGhhA1IwjRNO1XwgqUXEH92A1C4HksibNkRY0mV9xwn+qP95Jmf2MmM+WA3I5aT6yopWePJcTKmGGfmSGuVnJAG2+GiX4qeYs/eAPd+sSq/Mx+OrSBhUIZXTIdpmvz+UTHhvOikmVHWg3FBKsshWVLJ2jUUnVI3li9ZUEJVVBY1CWUqb12WVY9l+sN549thak1WMqMTkU2+07NTDYrBtgs6CEFZ0TqzLmvr6FageqEXEpK0ZHzis9YdhV9YhCO3IbEDkr68U/yO7aPiXugMdqKp4vmcTjpLF3RiF3xm/zipjEFbg5efv+1kAh6N+7cPcdGPHsrbzwmylsF/9/3b/tlYcozJtLhW5oZqH99u6Iat6El1Y7bpggNW+IRju+Cuf0I6SsYliJQWnhni4NGyRGJKr6xcJWsyS7J2DkUxtTEATphTXZJl2wUraEic7hDvTekfLLhNYrOIbvcsXIgaKFw2Iev51nWuc2SXNk2zXpNVx+GHaRiYFslSzUqVLKvhosuaUP1fswvufgB+dSGkJmHhmfDGG8E3c/Lyp2f7uO7B3QB866K1zAn7K/p133z8m8QzcY5vP57zFp83mzPPi8zoKPsvvxwznabhxS+m9d3vmtXxSjUkZnx/2THu1Qy+kMW0bt1a7XL5Qc2z0JCrZLkih64hsZPQi4DHcU3eU4NPsXtiN36Xn5ctfBmJZ54BCtdjSYStYuqxWIoLj7mQnmAPQ/EhbthyQ8F9VFmTJSfXVSJZMjnNyDTQ3mAtMoxbqkt4Pix9MZz/XfH/f30DHr+uKr93OmTC4MYDEyXrUkpNkp/eP862gxG8LpXz185srlxOfLvE3OYAHpdKMmPQOyrIcCatM7RP3DfTkwUlloaFLTVvXZb1HWb0sHh2aBqeeVMnyJFU1i44Hkvb6YL6LCe0xWA6aEYskS9hsBahF5CjZAXEZ21Ey2lIPDPGvZiStaQjiKYqxE1xrch6LMgqWSXtghYpTMYzBRvQPrJLXAPrF7XwwuUd3PDe02hr8LK5f5ILrnkgb4NuGX7xWP9jdqNrGXrRGejE53Je0xRJZvjlQ7vZ6EBBzoX8DCCrbsxGydIN067NdRx8Mbpb7KuK71M+H6cj1zIoe2VNsQvmKFmP7hlA0cT93dNQm5qsciPcAcxuodK5Bwo3oXfShBiyCqi8jkohndDtHmj1dME6DhtyVSfNIlkub3lfqxy0MzbJ+j9kF9x5H/z6NSIJavEL4A03gHdmPc+e4SifuFFMZt971mJetKL8OiyAR/sf5a5dd6Gg8Kn1n6qqrQXA1HUOfPRjZA704V4wn56vXDXrQI3CNVmWB398H/MtkuW0LqsW6YJe3VpcyJMsCEypyVIPZUPig6WVrHLqsW7ZJgIvzl54Nt7JJOkDB4RV49hji+7XHJAkK41H8/C+te8D4GfP/qxgYp6tZKWsVfEqBV/IHkBmujn73mWioLyuTngznPUJ8e87r4Btf63K787Fsq4GXKrCaCxNX4EVfAmZEJevpsYwTH52vwjCOWdNd96+X5WQLE1VWNwmrmdZlzW0L4Khm/hDbkKt+SeGi5us8IuxPCRLxrfHxXE9c+eiuKeeb27wxVg8TdIaQqaHDlQTTiPcIUuydo3vstP6pF1wWfPMGpnZQJIs3SvGLGOyjF5ZOXZBJzVZXpfG4rYgqnsMyAYoAKQd98myXjcLf18P7xLXwCmLxDW9ek4Tt3zgdJa0B+kbT/DaHz3IgzumWoOXtywn7A0Ty8TYMCTUcxnfLhtEl4Jpmtz6ZC8v+sZ9/M9tz/GJm55xtJ+EVOdcXg2vlaI8m2bEw5EkumGiKtDW4HAMturs9LS4ZwqRrNyEQamS5Y4xuT2y/r1XKM4aHtvlUS0EZlGTpc0R78E7Gp3awiUHSSv0wlskWTBjZHi0/1HAOcmSKpbHp5VswH0ko06yjnJk67EU3KaYECVd5ZEkj3UBZ6xmxOb/FSVr+9/g+oshE4elL4VLfp+3lieR1vnAb55gMpnhpAXNfPRlhX3HxZAxMnz54S8DcNHyi+ymmtXE0A9+QPSBB6yGw99HC83eiuhqLkSyskrWAqtAds9weSSrGsEXUsny2SSrgGUh2E6LkU0XPCQ1WbnJgh3FlSwniKVjdo+rC5ZeQOLZZwERXFDqu26yfockducvOZ8FjQsYTY7ym02/ybuPXZOVsqwm1Vay0uEckmVNSGUENsALroS1l4Cpww1vhQNPVeX3S3hdmm3JK1WXVUjJmkikec+vHueOp8V7esP6/LUpldRkwcy6rP6dMrq9qeACigy/2Dle2C6YmrSa1+dpHirvy5AnxGg0RcpSsnKVhGpDColOFoU6Ah20+FrQTZ1to9uIpqP0RnqBGtoFrcU33QnJCueQLGvMcdKQGET4heIWY1pugIetZJWYcGqamq2zzhPjntENHt8jji9JFsC8lgA3vf90TlnYwmQiw1t//gi3PdVrv64qKqd0nQJkLYOy5s9J6MWG3nFe96OH+K/fP2XHpm/pnyStOydJ8v14/S5cXmmjrPyalFbBtgYvLqfWf8sCqifEdao1h/Nu1hWcqWRNJjLErAUr2y7Y5GFDvxj7mr3tVU8ZzqYLpsruDelv7SBhrb+ke3vzbmPHt68oPJ95bvg5IukIIU/IXiAphWwj4qNXxYKjiGSNjIzwxje+kcbGRsLhMO985zuJFIlTHRkZ4UMf+hDLly/H7/czf/58LrvsMsbHS3vvj1joMwdMSbJUvx+/IR4CE2Z579FtrYzJZsb/JyLct9wNv70EMglY9gp4/W9mhBJIfPGPG3nuwAQtQQ/ff8O6iuqwAH6/5fdsH9tO2BvmQ+s+NJuzz4vJv/+doWt+CED3Fz6Pb3l1VnSzNVn5gy+IDbOwSTwYnCpZuc2IZ9sUWAZfBGTMeL5kQQB/s12TpR0qkhU5KIJUFBVaZ07+7Ph2h0rWn3f/mXgmzoLGBazrWEf8GUGy/CXqsSBHyYpbDWhVFx9Y+wEArttwHePJmeOGbEZsJJJiEpyJQ8p5VH8hyHjqKUqWbRfMWRVXFDj/e7DoLKE2X3/RFHWgGljlsC4rnxKx/eAkr/7BA/xt0wAel8rXXnscJy/Mn5xViZIFsGRawqDdhDhPPZa9j9Ura9f4LnRj2iTUIsqpMXHfTU8WhKnpgtOVrFo18c4qWaW3VRRlimVw+5holtrubyfsC1f1vKQylJYtTiIOrv/GOaKmUE+JXouUrumTWNEVQrVI1lQly5ldELLqWyJPQ+LnDkwQS+k0+lx2A2SJcMDDL995Cueu6Satm1z+u6e45r7t9ndu12UdECTL7pFVJL59NJriv295lldefT+P7RnF79b42NnLCXg0UrrBnjJaf8jQC2/AhdtjkaxZ2AUrakRsWUB1i/C5HNgFQz43Qet8Zc2btAu6Am72TYhrpKfK8e2QbUacSRtlE9ImX5iDliM53XtgxutGNEpq926guF1QWgXXd623awxLISrtlEexVRCOIpL1xje+keeee46//vWv3Hnnnfzzn//kPe95T8HtDxw4wIEDB/jGN77Bhg0buO6667j77rt55zvfeQjPusq45X1Ceel9wv6RHXoRDODVhZI1ZpS32ixXvXSpZCX+w0nWpjtEPLSegpXniyJ7V/4b+Y6nD/Drf4sHybcuWkt3U2V1WEPxIa5+8moALjvhMpq8+WspKkVq714OfOKTADS/8Y00nX9+1Y5dsCbL1wSWIrXEIyao5dZkpY00SX12ZEdGuDfo1kwwX+gFgKrR6rYmplrk0PTJGrRqRpoX5SXxI9aDujnoLFlQBl68eumrURSF+AZBsnxrjiu5r0wXHM9Z3X75opezNLyUyfQkv9z4yxn7qBbJwjAwFeseqYKaJZt05lWymqatirs8cPGvRFPwyAD8+rV2n6dqQNZlOVWyZE3N3Rv6edXVD7BzMEp3k48/vPc0Ljqp8Ip+JcEXkO2VJUlW/66sklUIPQ09eDUvST1pKzw2pF1wxIqQzqNkSbvg9JosQzfRaxR+YZSRLgjZpsSbRjZlQy+qXI8F4JNKlmZZZyMOlCzNBU2WCmVd186VrEabZMmaLF037J5KTmqui8W4P5JjFczX+Nnn1vj+Jet41xmCfH/t7i38v9s2kNENTusWAUrPDD1DLB2z7YL5kgV1w+RXD+3mBd+4j988vBfDhPOO6+aej5zFB1+4lGMsgrd1wHn4UcqyC+YqWbOxC/aXS7L0DIyL+ykzKeZJTuyCAJ2yIbH1O2OWinYwnQZN3NPzakCy3F4Nl9XmoVzLYKOnkcGwuEbS+2fGuCe2bhXtQ9rbi7YPkcqnJOlO8J/QIwuOEpK1adMm7r77bv73f/+X9evXc8YZZ/D973+f3/3udxw4MJNdA6xevZqbbrqJ888/nyVLlvCiF72IL33pS9xxxx1kivS5SCaTTExMTPlzRGByADbeBlvvhp++EK5/PRx4MqtkBQK4rML/YeNgWYeWK2OGJvY3Yv/BJGvDzcJ2ZKTh2AvhtdeKSVwe7ByM8EnLM/7BFy7hBcs78m7nBN994rtE0hFWta7iwqUXVnycfDDicfZfdjnGxAT+44+n8xMfr+rxZXrSDLugothq1jyrV9b+0fiUFLRCCLgCdj3abOqyTNO0layQXKQrVJNFTo8i1WAoNl6zVXkbgyJ5KV89FpTXiHj3+G6eOPgEqqLyyiWvxDRNElayoBMlK+yfahcEYQG69PhLAfj1xl/PKMq3SRZgeqzPrgoka9+EmKjktwvmWRX3NcEb/yCavA5tgd+/uWo9tGTCYKkifFvJSgzzjT9v4X2/fpxoSmf9ohbu+NAZrJ0XLrhvUk/a13m5JEvaGbcfjBAdTxIZSYICHQsK20M1VStcl2XZBZMHxfkUJVnuEKOxFClkZ62smlBtyFsx38Q/H+yEweHNNavHgqwqlLYWGRylC0JWkbXsZdNJeiEs72xAsWqyOvxiop7OsWk6UbKKJQxOr8fKB1VV+PR5q/jM+atQFPj1v/fyvl8/Tou3i55gDxkjwxMHn7CVrOl2wUd2jXDe9+/n/932HOPxNCu6QvzuPady9RtOoMcKjFpmXdf5QjYKIVfJcnnE82M2zYgPltsja2I/mDqm6kUfF+NFQZIVnEqyZF3WgE2yxDi8czKO4hYkqyNY+RyjEBRFyemVVV7CYJO3KUfJmmkXTG4WVkFvERUrnonz1MGnAOf1WJDTI6uuZNUeDz30EOFwmJNOOsn+2Ute8hJUVeXhhx8usudUjI+P09jYiMtVeCXoqquuoqmpyf4zb96habBXEqFO+MC/4bjXCz/F1rvgJy/AuPPT4vVAA2pGvK+DmYGyDi0j3E1V3Ij6f6pd8Jkb4KZ3ivqO4y6GC38KBaJEE2mdD17/pD2J+vBLKn94Pz34tK1AfGr9pxzL5U5gmib9n/s8yc2b0VpbmfOdb6NU0HC4GFw5wRczSIlFspozA3g0lYxh0jde+vpRFKUq4RfRdNRuuBq2ah+KkSxfsJ2gtV2aCSaTtSvkB+CgpWTlqceCbCPiZgd2QXkNnTHnDDoCHWQOHBC9y1yuok0gJcI5wRe5eNH8F7GyZSWxTIxrN1w7dSe3GzRrEcZtTSaqEH4hJx5+pQ2vS4PkpLBVwtSarFw0zRVEyxOyemh9sCo9tKRdsHcszlis8EqvVCKi6ShX3ye+13c8bxG/ftd62hqKTwSkxdCtussubF/c1oCiiD50OzaJCXJrT7CkorE4bJGs6QmDsRFMHdKDYpKYzy6Yq2SNxdOggOmyVrRrVJcl7YI4LElZ1bIKENHtMsq9FkqWrMlKI/42ipQpTMG0hEFJ0kcTo/mbRFvw++IoagbTVIjHBRFJWaEXmktFc2BXL9QryzBMHt0tSVbppthvf94ifvjGE/C6VP626SBv+N9HOL79ZAD+svsvtsVYkqz+8QSX/fZJLvrxQ2zqm6DR5+JzrzyWOz90Bqcunvr7ZB+5rQNlkCyLNHqqZBeUqpLj+HaLMBuBuWAt1mvhcN5NZU3WUHyItJHO6ZWVxDRMm/A8NxJBcVktGQKVBWqVQqUJg42eRg5KJStPQ+LERitZsEg91pMDT4r3H+xyHJAC5MS315WsmqO/v5+OjqkM3+Vy0dLSQn9/v6NjDA0N8YUvfKGoxRDgyiuvZHx83P6zb1+eZo6HC21L4cIfwwcftcmWsedxAMx4Vr0aSOdX9wpBRrijWg+T/0Ql66nr4eb3iGYsx78JXv1DYekogM/dsZFNfRO0Bj1875J1zotip0E3dDvs4lVLXsXa9rUVHacQxn5/A+O33ioaDn/zm7i7qm83kCt1ZiqFEZ1mB7RIljrRy9xmsULpOGHQPfvwC6liaXgJmdbEpQjJmp4wWPNeWU6VrBIkK2NkuH3H7YAIvADRCw3At2wZqrf0ap/skzWdSCiKYtcI/nbzbxmMDU55TapZptta0pylkhVLx5hMi8lZ2GON6zJZ0BcGb5EAj641cNEvrB5af4B7vzCrcwFo9LntdMxialbvsAmmGDN8vijfufh4/uf8VY5qNHPrscotbPd7NLtdxLZN4rMvZhWUkHVZM5WsYVJRDQwDJRDA1TGzmeoUkmWRcsWyHNVOyRIky6mSNTc0l6A7SMpI2Svl1Q69gJyaLMOFieLMLgjZhEFrYh72hlFQMDHtRNR86ItZ9YqZRnYcFCSgnHosAF9AKllTSdbWg5OMx9MEPJqt4JbCy1d3c/271xMOuHl63xj/eDoMYAfwtPvb0RQv19y3nRd98z5uf/oAigKXnDKf+z72Qt56+sK8z89lneWTLJmW6PW77TKH2US4y+ALx3ZBWY/lFjZOJRCYovbnosXXglt1Y5gGg7HBrF1wPE4imhaLCgo83j+BWmOSVWnCYJO3iUFrqEntn6lkJSwly7eqMMmyrYJd68sa++rBF1XAJz/5SRRFKfpn8+bNpQ9UAhMTE5x77rmsWrWKz372s0W39Xq9NDY2TvlzxMEmW49gWPKrrls9VJQUfRPbyzqcHLgV1XqYOOlofzTh8evg1g8AJpz4dnjl9/P3UbJw21O9/PaRvSgKfOf1x5dXFDsNN2+/mY3DG2lwN/BfJ/5XxcfJh/gzzzDwpS8B0HHFhwme6tzvXA4Uvx/FmsTrY4UTBue3HvpeWXaPLKWBAFYqZqGaLIBA26HrlWWa2ZqsQiRL1mSVsAs+eOBBBuODNHubOWvuWUAOyTqueH8sCRl8EU3ppDJT6xjOmHMGx7cfT1JP8tNnfzrlNTv8wmWNhbGp0c7lQqpYpu6jNRAWPyxmFZyOKT20vgmPXVt8ewdY1S3DL/KTrDufOcAF1zyIkRHKwldet4hXr5uTd9t8qLQeS0ImDA7tsSZji0o/l2wlazrJio/kJAsuyDvxmRJ8YZFyzWoNUqsYd7sZscOJmKqoLG8WSa8mJpqi2e+5mpB2QRMFXfOiV6hkuVQXzT6xYFUsxj03eXNzv/i+ZWCBxyHJkjVZiWl2QVmPdeKC5rICnE5c0MJN7z+deS1+BgbEmC+bmDe6unn5d/7F1+7eQiylc8L8MLd/8AyuunBN0cUjSbJ2D8dIpJ0RJVljJuyC1UgXFM+MDqd2QWuc0l1iYaJQ6AWI61OqWX3RPrpzarKkouQJuOidSGTtgoHq2wUhG35RSU3WQSvUKjXNLmhmMiS3ilpIXxEnhSRZp/Y4twpC3S5YFXzkIx9h06ZNRf8sXryYrq4uDh6cWmeUyWQYGRmhq8TK/eTkJC9/+csJhULccsstuN3OCsyPCrQdg7HyIgD0loUApFxJ+ke2wW/fAH1POzqMjHBXLSVL/09Ssh75KdxxOWDCKe+F874NauHLfvvBCFfeLCavH3rhUs48ZuYqr1OMJcb47hNiMvjB4z9Y8QQrHzIjI+y//L8w02lCL30JLTUMdFEUJSf8onSvLKcx7rkJg5VCrgi7zBABxVKlCqULgtWQWMa4R2qbMBgdFAENigpt+VfYRx1GuMveWOctOQ+3ZXHN1mM5I1khn9tu9DoWL6xm/WHrH+z0P8jWZZmaJFmzU7LksY10mBaL+E1pROwEuT20/vgR2PqXWZ3TsQUSBjO6wVV3beLS658kntYJamFxmqHyJityUm3XBJaJpR0NKCakB8X1WqgJcS5yEwYNyWBME2JZkuVdONMqmNSTdhhNrpLlsuyJ0rpWbdjNiMuYlaxqXWX/e37jfLxa9SdkLreGZql4aXcAw2lNVvNUkgXOGhLnJm/KeiX5mduukxKQxHB68IVdj1UgAbMYlrQ3cPP7n8ea7rnoiey8a9M+D7uGorSHvHzrorXc+L7TWTO39PXZ2eil0edCN0x2Djpb2JUqqsefU5M1i+ALSbJkxHpJWKpkhjBQuB5LIrcuSy7W9k8kbQKBTwMMVJf4nmtFsgK2XbC8miy/y89os7iWjOHhKcnTqV27MJNJ1EAA9/z84/ZoYtS28pZTj2WaZt0uWA20t7ezYsWKon88Hg+nnXYaY2NjPP744/a+9957L4ZhsH594dX7iYkJXvayl+HxeLj99tvxFZB1j2aY1kWvzxc+6ZQWZ8ilkdryR/jx8x2RLRnhrimW/P6fQrIeugb+9FHx79MuhVd8FYqsksZTOh/8zRPEUjqnLW7l8lnUYQFc/dTVjCfHWRpeyutXvH5Wx8qFaDj8UTJ9fXgWLqT7qtk3HC6Fwg2Jc5Ssw9CQWCpZihHMKlmF+mQBBFtpkUqWVuMYd1mP1bwQ3DNTKU3TzKnJKrz4M5IY4b599wFZq6Cp6ySeew4A32pnJEtTFZr8MxMGJU7pPoX1XevJGBl+8sxP7J8rVq8sQ7VsmLMkWbaSlW6mJWhNigslCxbDC66EtW8QNZZ/eBsceLLiczp2jhV+0ZdVskajKd527aP8+B+i19R7z1rMSVaNbjElIh+kXbDdX9mizZL2Btp1BUU38fg0mruKXOMW5obm4lE9JPREljQnxsHUSU0U7pEl70cFhaA7aEf+SxWldkqW82bEEjJhEGpjFZSQpCXjCjhrRgzZBYPxXpFKR+Fea7nILkI0s9kiWdIu6FTJ8sl0wRwlyzTNKcmClaA95OV37zmVHm82zVRJt/Ge5y/m3o+cxYUnzHVs91QUxa7L2nbQ2Wc6JcJ9ln2ykhnddhJ0hsq0CxpiLCxFsqb0ypLBF+MJu0dWTDVRXBFQDFRFrepCbC7sXlllKlmKouBqChO1hul0TtCctAp6V6xAKbBw/Uj/I5iYLA0vLeu9pRK6TZ7rStYhwMqVK3n5y1/Ou9/9bh555BEeeOABLr30Ul7/+tfT0yO8sb29vaxYsYJHHnkEyBKsaDTKz372MyYmJujv76e/vx9dr11DxUMNmS6oW6v3GZe4iQaOfSWggCRbv3sj9OXvri4HbhUrAOM/Ifjige/Cn68U/z7jw/CyLxYlWACfuX0DWwYmaWvw8t1Ljkcr42E/HRuHN3LDlhsAEXbhUp2tQDrB4Pe+T/TBh1D8fuZ+/3toDUWUmyrBVShh0CZZvcxrFg+Rsu2C6dkrWRhBAkglq1hN1lQla7CWNVkl6rFiOba9YraaO3fcScbMsLp1tV3Yn9q1CyMaRQkE8C5d4viUwv6pvbKm49J1Imnwth23kcgI0qp6LZKlWEQxOju74BQlS5LLcuyCEooibIOLX2D10LrYXmkuFzLGfcdglERaZ0PvOOdffT/3bx/C79a4+g3ruPIVK+2JQqkY7umotEeWxNKOBrp18bjuXNToiIi4VBcLmxYCOU2JZXx7RExcPIsWztgvkhJKTYO7AVVRbbug31IdU/EaBV+U0YxYIrehey1CLyTs8AtXAN2pnb6hCzSvWASw0jRtJatIr6zsIkSY/aNxIslMthGxU7tgnuCL3cMxBieTeDS1aBJmKQQ8Lv77hdkWIVe+9Aw+dc5KQr7yXUIyxt1pwuCUCHfP7GqyDlr1WB6XaocClYRsRJwR90+hRsQS+RoSD0aSRKx6o2Fdt0Mv2nxtVZ0n5MLfKN5fucEXMLUuKzfGPRt6Ubo/VjkqFkDMUrE8flfJ5ttHOo4KkgXwm9/8hhUrVvDiF7+Yc845hzPOOIOf/CS72ppOp9myZQsxi3Q88cQTPPzwwzz77LMsXbqU7u5u+88RFWYxS8ggAt1aKVc8YtLWf+Zl8MFHYM3rAAU23wk/PlPUJk1rJiovYhUVE+Xo75P1z6/DX/9H/PusT8CLP1OSYN30+H5ueGw/qgLfe/3xdDhd2coDwzT48sNfxsTkFQtfwcldJ1d8rOmYvOcehn/8YwC6v/gFvMfUbmKRC7sh8cg0ktXYAyigJ1nkF9eNUyWrwVoYmFXwhaVkGZkgAUUqWUVI54yarFqSLFmPtTzvyyOWVdDrUvG78z9ITNPklu3CKnjBMRfYP49bVkHfqpUomvOHUJNlS5Q2xelY276WVl8rGSPDphFx/lLJMlWLZMWKR1CXQrbmJEfJsu2CZaa5ujyiz13HsaKH1m9eV1EPrY6Ql7YGD7ph8s2/bOE1P3yQ/aNxFrQGuOWDp3PecWIxL19DYieYLcla0h60SVbr/CLBINP3syyDslmvHd8ekUpW8WRByKZRBhosdaTGwRfl2AUXNS3CY6Xi1pJkySCJjDvoXMlS1ez1PC1h0ImS1egS1rEt/ZOkk2XaBfNEuD+yS/zO4+eF8bk1SEZEz8iB58Aoz3J3Ss/JuBTxO9bPyz++OcHyMsMvqtmMeCAnvt0RsU/H7cbSekJsX6wmC6baBdsavGiqgm6YDA+LZ2VfPIXqqm09FmTtguUqWTA1YTC3LiuxWTwfisW32/VYZZIsO/TiKLcKAtSGNtcALS0tXH/99QVfX7hw4ZR46Re84AW174FzBEAqWRmXmAhpXnEz9Ef7YcnJ8Jr/hed/TBCPZ2+Ep34DB54SzT1bxQM4d3VM17yQOARNWmsB04T7roJ/fFX8/4WfhrM+VnK3bQOTfPpWMWm9/MXLOH3p7CT7O3feydODT+N3+bnipCtmdaxcpPbsyTYcfvObaTr33KoduxQK1mRpbtG7aPIAc61eWaOxNBOJNI0lVjblJE6unFcCqWRl0v6sklUs+CLYPiVdcLCCh45j2EpW/uQl2a+qJegp+JB/bvg5to9tx6t5efmil9s/T1ihF36HVkEJGX5RSMlSFIU17Wu4b999PDv4LOs61qH6rCaspmxGPMvgi0h2pT6rZFkkqxy7oITsofW/LxE9tG58J7z55rIOoSgKK7sb+de2IX76r10AvGB5O9+9eB1NOavcTnsdTYckWZXWZLU2eJlnWE3jm51PPGaEX8RG0NMKurUO4lk4M1JZkqwGTwOJtE7cCiUINojfW7OarDKbEYOIxH/tstfy6MCjnNJ1Sk3OC7JBEmmX33mEOwhldni7UEAW5TQkLkDSTdO0Sdbi5nkMDwmStSxhNSL2O00XnNmMeEZ/rH99E+7/lrVDGBacnv3TtbZo+m7QHeRTp36K/ZP77fCRSrCszIbEkjR6A25cXtknq7KaLDtZ0LFV0BqjPA1kIoKglWMX1FSF9gYv/RMJxkYEyRozDby+2tZjQa5dsLyaLJiuZAmSZZomyU1WsuDKVXn36430sm9yH5qicWLniWX9zqhVsxY4yq2CcBQpWXXkh02yVDFQePxiYOyP5kTbty8XZOttf4RgBxx8Dn7yAtj8R0D03pA+al3zoiQTh+4NVAumCfd8PkuwXvI5RwQrlsrwgd88QTytc8bSNi590dJZncZkapJvPSYeXO897r32IDtbGPE4+z90GUYkgv+EE+j82EerclynkLaIGSQLbMtgIN5HmzURc2IZrEbwhVSyUil/TvCFswh3xVXDmizTzNZklVCyioVeyMCLlyx4yZT+SnayoIMmxLmw7YJF+kGtaRPE7dkh8TtUqWSZ1nnONvhiupKVjkPUCjYqxy6Yi6Y58MYbQHXBjntgaFvZh1g9J1us/6EXLeVnbz15CsECZ0pEPsxWyUpE04QzYoweLkNkXxIWC2k7x7J2QRl6obW1oYVmqmLSvhvyhBi3yLimKjQ0SLtgbUiWFFPKqckCuHL9ldz8ypvtRZtaILcmS49EnC/gFuiVVYikjyfHiWXE2Lm6U+y7pX8iW5NVppKVmKJkTSNZ+x8Vfyuq6FG35U/wl0/DT18EX10Av7oA/vkN2PNQ3sbfr1v2Oj584odnVQ+8rFO4DvaOxIilSl9XMpI+10amZwwMo/wFddkjq9Np6IUMMAkvQB8bA0ALO1eyIBuwEbFIRFQ16Wi2yF6wNvHtkI1wT0TT6Hp5pDQ3YVA2JM7094vPQNPwHpN/ziStgmva1tiuFaeQoRfB8NGvZNVJ1lGOLMkSF6PfL5j/FJIlsfB58N5/wrxTITkBv3sD/O2zKIZuq1kZlw81lTi6VEDTFA8HuSp39lVwxn852vX/3foc2w5GaA95+fbFs6vDAvjR0z9iODHMwsaFvHnVm2d1LAnTNOn7zGdIbt2K1tbGnG9Xv+FwKbhaxIN5RoQ7TAm/mCfDLxwkDFYl+MLqk5VM+nKCL4qQLF+YVusZo9bSLhgdsupfFGjLH6CSq2TlQzwT50+7/gRkAy9A9CtLWkXH/uOOy7tvIWR7ZRVe0ZxOshRZk2VYE7z4KBiVWXTSetruw2UrWeOWz9/TAP7ik5ai6Foj6rMAnru17N3fcMp8zlnTxU/fchIfednyvGNBKSUiH0zTnHXwxcHdwlI7qhrsmnS+CCZJ1o7xHWJMjw3boRfePKEXkGMXdGeTBcN+N15/bUkWdp+s2hx+NsglWWQymAmH34GdMChqDksFX8gFiFZfK8d2C0K+uX8ymy7ouE+WlRScNsikdHrH4uwfjaOpCicssO4xqbS/48/wrnvhpV+AZa8QynAqAjvuFX3orn05XDUPrj0X7v0S7Pj7jJKDStHa4LUX5raVULP0jGGHIeRGuENldVkHJclyqmSN7hZ/Ny+wFxudKlmTqUmi6agdfpG0HBRRxaSxQTwra6lkeYPZZNlEpDw1q8nbxMGw+LesyUpYKpZ38eKCPRr/faCy6HaA2JgV3+40Wv8IxlFjF6wjP2ySpYiBqqFBWHvkyskMNHbD2+6Ev/w/ePiHcP+3ofdx3J6Pk4wJJUs1DEin4RBP5CuCacJdn4BHRJ0S53wDTnm3o11veGwfNz0h6rC+f8k62kOzu6G3j27nN5t+A8AnT/kkHq06n9/ob3/LxO13gKYx51vfxN1Zu8G4EArWZMG0hMHTeXLvmKO6LNmMuBpKVibtMPhCVWn1hq1/pxmKTmKaZvXTGWU9VvOCgmmHI5aVp7kAybpn7z1E0hHmNMyZUteX2LIVM51GC4dxz51b1mnJAu/RIiTr2LZjAWH3GEmMZJUsw5r9mgbExyBYvvWtP9qPiYlpuDD1BqFk5SYLzvZ7OPYC2P43eO4WR0p2Lua1BLjmjcVtLU7S4aZjIjVB2hCfd6V2wf5dgmQd0AyUQed2tXmhebhUF/FMnP5oP9058e35Qi9gak2WXAhoCrjxWlY1GcJQbdhqRI2TUiuBHXzhFmOLEYmg+mcmhs6AVLKswIRSEe7SStvT0MMKK3lvy8AkKUvFdkqy3D4NRVUwDZNkLMOjloq1uqeRBq9L1OZJ9bhjpWgAPvdEeN5lQlI8uBH2PGD9eVC0o9hzv/gDQjHuPh66VoM7CG4fuPzib7c/+2+XX/zf7QeXT1i55c89AfAEWdYZYigyzNaByaKBHLnk3mO9PxTAFAmDHl9509l+O77daY+sHCVrVISIlQq+CLqDhDwhJlOTU8Iv9JiOglCyWtzjkKhdI2IQDb59IQ/xiRSxiVRZiX2N3kYGpylZsh6rUBNiwzR4uF8oWeu7yu/fGZ34z2hEDHWSddRDkqy0Kb7KxoYGiEF/LI+SJaG54RVfgbknwe2Xwa5/4o69Hugmo1mr1vE42pFOsgwD/ngFPH4toMD534ET3+Zo1y39k/zPbaIO64qXLuPUxZVNfiRM0+Qrj3wF3dR50bwX8bw5z5vV8STiTz3FwFVfAaDjIx8heErt6g6KQSuULgh5e2U5IlmWkjWb4AtZk2Vmglm7YLGaLCAQaMNnTJBQVZLmONGULiYe1USJeizIhk+0FEi2unXbrQC8aumrUHPSABIbLKvg6tVlk0NpTRyPF7YLNnoaWdS0iF3ju9gwtIFlsiYrmRar3IlxYRmsgGTJlXozHQYUoeLtriBZsBBWnAt3/JewRA9uKWjVrBSSJI0nx0kbadxq6VQyqWKFPKGK+zgN7BLF8X0ug/hB5yTLrbpZ2LiQ7WPb2T62ne7YMKlJMVHPF98OU0lWrpIlW33ULMLd4lhOI8APJaSSpfvEmKVPRnC1O1AlC9gFh+PDeRd3eiNiEtvT0MPSjgZURajOkYiM0Xc2TimKgjfgIhFJk4im7Xqs9fI5NySayNI4VxCsXKiqIE9dq2H9e8UXM7w9S7h2PwAT+6H3MfFnNlh+Lqvb/osHd5QOv5D1WG6fhmo1UnZ5NDJJvaJeWdngi/J6ZAkl6x/i95dQskBYBidTk1avrG5UE7DON6qYJE3xTK2lkgUQCLmJT6Qqakgsa7L0sTH0SJTkJiv0YkX+59u20W2MJEbwu/ysbV9b9rnK4IujvUcW1EnWUQ9byTI0QKc51CRIVj674HSseS10Hgu/fzOe4Qmg2w7QMBIJtKbSDQUPGwxdEMSnfg0o8KofwLo3Oto1mszwgd88TiJt8Pxl7XzgBbOrwwL4y56/8HD/w3g1Lx87ubwV9ELIDA+z//L/gnSa0Nln0/L2t1XluJWgYPAFTLULLimfZFWqZOmGznhSTD5NPUDQ5SBdEFCCbbSkxzigqiJhcDJZfZJVoh4LyOmRNfNBsn9yPw/3P4yCwquWvGrKa/FnrNCL48oLvYCsklXMLgjCMrhrfBfPDD7DCtmMOBEXxCoxboVflN9HLrcHkEtVaPS5Kk8WzAd/Myx5IWz7i1CzXvDJ2R8zB03eJjRFQzd1RhOjjiZGs63HMk2TgRwla3Qoim6Yjq3Ni5sWs31sOzvHd3JmPFfJmpksCFODLyQZbw548PprTLIqCL44VLDTBS1CYkQcjlnSLjjZB5mkrWSljTSRdGRGHZl0oPQEe/C5NRa2Bdk5GGXcajVRTpy1L+gmEUmTjKXtZEG7CbG9CORgEUJRRDP1tmOyi5hjewXhGt0taiozCfF3Og6ZOKQT1s9i1r+tn6Vj4udWewi2/JH3Ne7kFi5ly0Bx0pqbLCjh9qgWyarELig+U8dJwhZRNkPz0MfFc6eUXRAEydo6upW+aB9dTQvxm0KAMzBpafYznBD26VoqWSDDL6LEy4xxb/I2EfcqxAMu/LEM6d5e2y7oK5AsKFMFT+g8AbdWfrS/DL442ntkQZ1kHfUw4paSpauATltTMwxkPcBBdxHrFAirwLvvxf2522AUTI+4IYzxEeis7U1fMfQM3PYBeOb3omj3gh/DcRc52tU0Tf77lmfZMSj80d++aO2sV05j6Rhff/TrALxz9TuZGyrPwpX3PDMZeq/4CJmBATyLF9P9pS8d1smHSzYjHh/H1PWpseF5GhIfiuCLidQEJmJiZup+Am5pFyzRqDXYTuvwFg64XaiaqMta2FbiPikXchLTUVjJGitSk3XbjtsAEX3b09Az5bWsklU+yZLNiIvZBUGQrNt33M6GoQ1c7BO/x4gnoL0NRnZWHH4hJ5FGOkyzTFWcTbJgPhx7Qc1IlqqoNPuaGYoPMRwfLotkVVqPNX4wTjKWQXOrjHsVUhmD/aMxFrQ6u2aXhJfAHpEwaEaHsySrkJJlBV80ehoZnRDXSVPAbYcq1SzC3W5GXJPDzwrSLpjJsQs6QqBV2OnSURjbh69tKUF3kGg6ynB8eAbJkkpWd4MITFjRFWLnYJRYdGpDaGfnLL6vweE4OwajKAqcPINkFY7fLorw/Nkpz4YBB56A6y+mZWITt3g/w0f7/gco7NTI9sjKTtpFXVa67IbEpmnm2AXLU7J0V6stuzpZiM5NGDyx0UfQEM/xqAKr53l5MFP7mizIJgzGykwYlM/pkRY3c2IZkps32bVZhXpkSZJ1WvdpZZ+naZp2n6x68EUdhx2m1ScrbSVPhRqCdq2LIzULwNeIe76QdHWXWDkwf/c2GN5R3ZOtBvQ03PIei2Bp8JqfOSZYAL97dB+3PnUATVX4/hvW0dow+5WS/332fxmIDTCnYQ5vX/32WR8PYPC73yX28MMogYDVcLjKJKBMaOGw+IdhoE9Ms/dJkhUdZIHl3d4/GkcvkfgkJxgpI0VSLz+AQoZeBFwNeDBxYT1oi9VkwYxeWTVpSFyiRxZk0wXD09IFdUPn1u23AvDqpa+e8poRjZLcIZLi/GUmC0KOXbBIuiBMDb9QpJKVTIhJI1RMsqSSZaabaZHvu5JGxMWw/BzQPDC4OasoVhHl1mXNNr6937IKdiwIsbBdXNs7yqjLyg2/yAwOY2RUUFU8Ber5ZEuFqXZBjx0fXquarEqaER8qSMKSdgnrrD7p8PNXlOx1PbYbKF6XJRch5jTMAWB5p5jgSmLrLqPuSBLDLXvHrWOFsmmZg0KJoL18NboqUFVRrvCuv6I3L2auMsQPU58isu3+grskrGtxipLlrawhcSSZIWbt0+kkXCExLhIYAd0Uzy21sRHFXVqlmdKQuNFH0BTXd0w1Wdwt3lPIHSJQwuY+W1TaK6vJK4jkkPVsn/zbPQC4erqz84IcpPU0jw88DpTfHwvE+CLtn/UI9zoOO+yaLGtxwuNz0dWQvamdQnq9J9xCsTAO7oCfvBA2/6mKZztLZFJw4ztgw02guuGiX8DqCx3vvvHABJ+5/TkAPvqy5dlVvVlgz8QernvuOgA+fvLH8bkqb2IsMfHXvzL80/8FoOdLX8S7ZMmsjzlbKG43qhX3PMMy6G8Wq7VApzGCR1PJGCYHxoo3tQ64A3atUSVqlgy9CLqa8JNDlEqpt8F2Wq286JrEuEeHsySkQLIgwKi1Ot0yjWQ90v8I/dF+Qp4QL5r/oimvJTZuBMPA1dXlrCZkGpwEXwAsa16GR/UwkZpgTBHfoxHPIVnRynplZZWs5qyCZ9sFq0Sy/GFY8mLx7+duqc4xc1BuQ2K5XaV2wYGdYlGjc2EjSzqEFXZ7GXVZsiHxzrGdJAfGAHB3dxRMKLXtgu5cu2BWycokdYwyY6Cd4IhWsmSfLEVM+srqlSUtg5YSUoyk20qWFf293Aq/0K1JZzlKls+Kcd91QHyf6xflPO9kTValSla10LIY7V1/ZYNyDM1KhMBvL4CNt+XdVNpU5XUI4HKLiyVdZk2WrMcK+VwEPA6Iq6zHCrSiR8XzolTohURujHtXU66SZdJlxbfXWsUC8DeKa7hsu6BHkKwDjYKURu4XRNhXoB7rmaFniGfiNHubK2oQLuuxPP5sw+mjGUfgcFaHU5ipFKbFrlJyEPa76AoIklUwYTAPZGpR1CUe4kbzKkiOw+8uEf2nKoxsrhoySfjDW2HT7WKV+uJfw8rzHe8eSWa49PonSGUMXri8nfc+f/GsT0mGXaSNNM/reR4vnPfCWR8zuWsXfZ+8EoCWt76Vxle8YtbHrBYK1mUpiq1mqZP7mdsiVntLWQZVRaXBLa63SsIvxqyVRb/WRFDGt2veok00AQi20iKVLC3CYKTKDYmHrR5NTfOKqmrZmqypq6GP9ov+NS+c98IZpN2ux1pTvlUQsqpZPK2TSBe+p92amxWtYgK2PyVSyAxZkwUinawCZJWssCBZmZSoV4Hq2QVBWAZBkKwqt6MotyHxYFzUXFRKsqSS1bmoiaXt4n7ZcdB5hPaCxgVoikYkHWHYaq3gWVCY0Mp7MeQJ2QsB4RySBbVRs2TbkCNayVI8mCjOa7IgJ/xCKLa2khWfev1EUhGb4EqLsEwYVHXx2ZRTkyWJYd+g+M5PWWTdu8lIdmGjyCLQIUOwje/O+RZ/1U9ENVJww1vh3z+asVm2EXEeJatMu6DdiNhp6MWUZMH/z957h0ly1dffnwqdJ/Sknc1R2iStckBCMmAQIBkQSCJjsDEYmyQTDTLIBv8IwgYEGGwDBl6SCUIyFkEEIUugiLQKu9LuKqw27+TQM50rvH/culXVPR2qe3pmd1ZznkfPjma6e2pmqqvuued8z3Hi2yuoOJUgSdZAeoB4WKfbsdpnVJt4QryP57IjS6Jpu2BEqKlH2sXz7KzYdItuqUyyZD/W+cvOLwlsCgrXKngChF7AIsla0LCynlJQyHs7Xf43dVCE3Z4ssUC2L/4HOP9vxBd//1n47hVN717PGpYJP3yDKEvUo/Da/4ZNLw78dNu2+fCNO9g7kmZZZ5TPvuqMliRY3X7odv5w+A/oqs7fn/f3s14cWJkMh999NVY6Tezss1ny/vfN+hhbiSCFxP65rLkOv5B2wYjSTkwJOI8FQsly7YLp1itZo0+Kf3uqK5C2bXvpgmUzWY+NPQZ4lj0/snIeq0mS1R7Rkae+LJqthtN6RQfXgYK4jtjZ2dkFLdtyU09dJSt1WETC61Foa+Fu7qZLBeEeeVzEUbcQjSpZswm+KOZNRg+LhdjS9T4lqwG7YEgLsbpDkKqxKXHLj6yvfm5OF8Vrd4Q7mMjKCPcwmqa6ysFchF/YTZYRzweibgKogqFHg9sFwdeVVZYwWKZkyeTNzkinO0u9ujtOTNcIOfsEjcSUSzKSdjaRzl3nhDRIFSuxBOKzd3O0AmuX9fK24nv4Y+8rABtu+XvRfWl5CpUbfOFXshySVWzQLuglCwa0o/mTBSfFJkTQYDC/XbBQKLJCEccf6wgznhfXhvlQsmQhcTPpggBDZT9uvdCLZqyC4IVenAhWQVgkWQsa0ipoh6OYRZ+SlWjcLih3hIrOznkxm4dLrxMzT6E47P0/+M/neMWh84l9vxeD7HoMXvdDOOkFDT39e/ce4OaHj6CrCv/2ujOrlr82gryZ59P3iWj1N259I+s6Kyd1BYVt2xy99h/JP/EEWl8vKz7/uUB+7/mE3iVuyEYLSdZswi9kfHtYafOUrCDN8ok+ekyfXbDVM1kjjpLVU90qMZU3MBx7VJfPLmjbNrtGxRzR1p6tM56X2yFqB5qZxwIRjx2kkBjg1F7xPZ7KCQuTlc/7SFbjGy7DmWEMy0BBxTbaRaqi3FHvXNnafqRoh3edaLFl0C0kbnAmqxmSNXwghW3ZJJIR2rqirpL15NB0Q4Xx0jKYmxLXlPCGGuemL11QniNdDskIyYTB3ByQLFfJavlLzxpayCOYhh5vzC4obbDjZSSrjKRLlXd5wgu6UVWFzUsSqIhfStCeLPCIYcSC9b0JL0WvkWTBecLG/nYsVD4Xehs8/x/FJ+/6Etz4FuFiwRd8EffbBZubyRpoNL7dr2RNOSSrvSPQU3ujvSxPncSFT1zBtz54JyunxHneuyTOYHoQmCe7YJMzWbqqkwglGEqWvjErxbeni2l2DIuNwPOXNd6PBZ5d8EQIvYBFkrWgIUmW1ebFiIajWpMky+kBcXqyctPOAnnbVfCWW6FrrejGeOj7LTjyBpFy7ERrLoD1z23oqTsPT/Lxn4md7A++eBNnr2nNzt03d36Tw9OHWRJbwttOe9usX2/8u98j9bOfgaax8vOfJ7Rk/guH68G1C1YsJG6uK6vNIUWzmcnS7HYSikOyggwP+4IvZLpgS+EqWdWrAaSKFQ9rREPewmkwM8hYbgxN0djYVWrlMcbGvFSnU05p+vCSMRnjXvtmK5WsvTnxPe1sFuIOUWhCyZL25TBdgEZPItz6ZEE/pGVw540ttQzO50zWgDOPtXSdWNCt70ugKEKFlMEpQbA+KezRakrc8qvFt5uWSboolLPy4AtgTmPcvZms45Bl4S3uDT2O2Qq7YJnd1CVZZWmim3q8jaNGZlTkTFbUVjjPP4/lhl4cPyRLzp49MTwNF79XJAarupi//s4VkJ3wRbh7m4+hiDOT1aBdcKhRu6BPybJSUsmqTbLGB9Lc89On+MG19/OyR9/FlqELKeYsiGvcHS3y7BesYSgjrNhzHd8OEGsXv7fMVKGhDRoQc1nDPiVL7eggtGL5jMc9MPgAhm2wsm1l0ynLmRMovh0WI9wXNCTJMtuTAOhhFVVTPZJVq5C4DHKHzHLKMrMp305d/1Y49Sr4/b+K5vf5hlzQxRojSKlckXc4c1gv2LKEt148+zksEMPJX98hginef+77Z50KlNn+IIPXXQdA/wc/QPycc2Z9jHOBwF1ZJwWPcZdJmLNRslQ7QUQGX9RLFgRIlKYLjky0eibLIVm91UmWXCB3lYVeSBVrfXL9jHms3E6hYoXXrUPrCLaLWglBwy9Wtq8kGUmS0cTf28r5gy8aJ1lyEalZ4n3clQjDWIuTBf3Y9GJhQxx7CgZ2wLLTWvKyjaQLFq2ia2tthmQN7nNCL9aJFU40pLGyK8bBsSxPDk0HTkc9KXkSmmmTSAkCUy2+XVoFQbw3pV1QnjPSVp7Ptn4mS4aRHo8zWSBmnNKTBYp6HKsRu6A8tzMjkJ+uev7I94e0+0ts6E5QYBxTbYyASjIStRXOOh5DL3w4ybHBjkwXGJnO03v6a6CtH37457D/D/CNF5MvXA+UBl9I0tloGbG0Cy5tRslKCTucWkHJyk4XeOKPQ+y5d4Chfd6csaEXeKJrO5dcci4vu+h5/EXRJBHR+fJT86dkyXRBy7ApZI0SsloPnZFOjoSOYCXbUSemiG7eXPF9eveRuwF41vLmrIIAaXcm68QgWYtK1gKG5cS3W3FxA5YXH7+SFXTHQnq9bYdkFdJlC2Tp3W4yunlWkAPCcoEXALZt86GfPML+0QwrkjH+9ZWnt+zm/a9//FfyZp5z+s/hxWuDz4ZVgjEywuG/+zswDDouu5SuN76xJcc4Fwg6k7WmZ55mshwlCyvhswsGIFnRTnpscelTtBwj6QYWTPVgmaJHCmorWVU6snaNCZK1pXumFSO7Q85jNWcVlJB2QZkcVw2KonBq76nknXuxncv5gi+aIFlpr4gYEEpWK4uIyxFph5MvER+30DIolawgwRdSxdIVnWQk2dD3sW2bgb1O6MV6b0G3QYZfDAcPv1jfuZ4lE6BZCkpIQa/SgSjfh1Etimmp5Bwbukuy5rKQ+DhOFwSfkhVq0C4YS0LUkQEmDlRXstKVlay1HWJOOt/g7csOiydEbSorWcdD6IWDeFh3HRCPDzr3gg3Pgzf/EtqXwfAu8vvFJlOJXbDJmayBRmaybNurmehai5lyioidjS6jaPLkA0P8/CuP8K0P3snvf/g4Q/tSKKrCmlN7eOFbTuHwK27j9pP+m8meoyiqQsJxDs2nkqWHNXczPdtkV1ahX1y7681jNWsVBI9kxReDLxZxrOEqWTGHZDlESb5h82be3UWtBze1SBMndn4GyZpdqtisIL9nA0O63757P7/YMUBIE3NY5V1EzeKuw3fx2wO/RVM0Pnz+h2dF3NzC4aEhwhs2sOyf//m43cUF0LudmayJOkpWUiwKxjNFUrnaF/NWkCzbSPiCLwKQLEWhI9aD7mxAZM0U6XyLFo0TB8AsiNCFGha4MSe1ras89GJUWFtrzmM1UULsRzJgITGI8I2Cs6YpUbKKaSjWjugvx9FpYRcs5sT1qise9hYvnXOgZMGcpAxKJWI8N45l195BlySrO9bdcNLW9HiezGQBVVXoW+2V1vrnsoJibedaVjiXUbUnWvU6I5Usv1VQUxXanEXhXJIsy/n7tCKUaC4gd/6LjdoFwWcZ3F/VbirfH+Uka4WjVmZti0wh+O/9KadCI47Kyi7HbVHMwfg+8fFxpGSBmMsCeGLQd14v3QZ/9Rvo20yh6FhWJx51v6xLJatJu+CSIEpWehiKGUCk6FqpKWxgxOzitu/u5psfvJNffW0n+x4ZwbJs+la3c9ErT+YvPv1sXvLO0zn5nH6Wdoo1mT/xuWgWXTVzPpQs8NSsTIMx7jJhMHWS+Dni589UqkayIzw5IVwc5y+dDcly7ILJRSVrEccYVtZRsqLi4iStHGEt7FpTgs5luQO1qnMjKSdZsWOoZDVoF3zk0ASf+LlQBD506RbOXN1V5xnBUDSLfOq+TwHw2s2vnTEz0yiGPv95Mvfdh+oUDquJY1s4XA+eXXBi5hc7lgMKGDkS5iS9beJifmC0tpo1m+ALuYFgFOOekhXQuqnEe70Y91Z2ZckC7+71oFafn5DzUN1llo1qoRe2bbtKVuy0WZKsgMEXIEiWVLKsXA4iHe41otFrgdypz2TF37ynLdz6IuJynPwiEZgz/jQcfbglL5mMJgEwbdO1rFbDbEIvBp8WdqOelW0lszgyYbCRQuKIFmHLhDP43her+jj5PmwP+6yCsZBLysJzGXwh0wWP040m/0yWNR1cRQR8CYOekjVdnC4pYXeVrEQpyYo75LygwOODwf/mjwyJ8ydsefNujD4pftHRztamebYAG/vFeb1nsOxekFwFb76FvJoEIHzr++CRHwGeXbARJSudN1wla0Wy+nvBhZzH6lgOeoT0VJF7z/0ov93eyWN/OEIha9DWFeGsF63htdeez6uuOZfTn7/KTfMDL6J9MDPofk5WO+iqTle0NWuUemg2/ELep3e/7nzW/+xm2p733BmPkdHtW7q3NP3z2LZNRgZfLCpZizjWcJWsiFic+73KjXZlhctIlpEp26WWO9jZYMpYSyG/ZwAlazLrzGGZFi/c2s+bn722ZYfx3V3fZV9qH93Rbv72jL+d1WulfvVrxv7rGwAs++QniaxvzbzYXEJLyuCLCmqmHhEeeoDJg6zqDjaXNRslSy5wi4WYV0YcRMkCZy5LJgy2MPxCdmTVmMcCbybLr7COZEcYyg4RMsMYD3UwOey9B42jRzFHR0HXiVTpJwkKaf2qF3wBImFQKlkUi9im2XSMu9ypNwtJALqimohwh7mxCwJE2mDjC8XHLbIMhtSQa/2rF34xG5Ll9WOVzn6c1EQhMcD6MUFeRpdU372XHVn+ZMGkbyMgEp3D4AuZLnicKlkyra8YimNNNalkje+nI9xByLnPyq6srJF17YPlSlbBUdkLis2egeB9gvcdngBAwYs/Z0QmC24+7mIcZfjF4wMVfrexLvKI90GESbjxrfD7zxEKO4mPDcxkbT8wjmnZrEjGggVf+OaxAMYK7WQSS9E02HzBUi7/uzN44ycu5IJXbKB7eeX7j1tIPO2tx6RVcElsSVN9Us3ADb9otJA4ItwHE+Y0kZNOqrgR0gqrYCFnYjgW5cUI90Ucc9gOyTLCFUhWgwmDrl3Q6XAwZ9gFnZ2JY6JkBbML2rbNB294mINjWVZ2xfiXq1o3hzWUGeI/HhYFie85+z3uzk4zyO/dy9FrrgGg+81vpuPFL2rJMc41as5kQVMx7pJkpYqNlREXzIKbgpbPR710wYZIlq+QuMGdvaoIkCwIlWeypFXw/MwLue/G/dx901Pu17KOVTCy8WTUyOxuPl0uyaqvZHVFu+jr9lKirJwvxr2B3jzbtn0zWUnaIzrh7BBYhkgRa19W5xVmgTm0DNYLv5hNEfFgWbKghJzJOjyRJdvADv6yUfHYA73VFdbpgt8uOHMjIBQTzy20OPjCtm1wgy9a+tItQyThTxdscI7TZxdUFGXGXJZcfCdCiRn3lqJT/FwAdlciIBWQN0y2H56k4PxS8/K9fhzGt0tIu+Djg1MzZsmNounW1ETOf5345K0fQx8R6nQjdsF794rf+fnrA44fSHulo0bKIu5lK8M8/01bWbm5u+7GgEuyfJveUtWajyJiiWa7siTJkpsw5bBte9b9WODFt0fiekNJmsczFknWAoarZDkFwmFfh4YkWbKHoR5khDtootE+lyt9gDuLkWl4FmPWkMSuTvDFN+/cx68eHSSkKXz5dWfR2UB6Tj187oHPkTEynNZ3Gi/b8LKmX8dKpzn0rndjpdPEzz2XJe99T8uOca6hO3ZBK53GKlS4SM+CZDWqZEkVS1M0MvkQ8YaVLK+QWG2lkhWgIwt86YIVSNZqW3QajR3xFnI5p4R4tvNYIIplAdcOVg+bl3rf085lfeEXweczJ/OTZA1x3bCLSbr9VsGOFTWtlbPGyS8UNtKJ/XBke0te0g2/yNb+HUglS5KyoDANi+ED4j0hkwUluhNhl5w3YhnsGBUL7d1d1Rekrl0w1D6jIwu8CPd8i5Us/5r6eFWy/HZBO5MRqm5QlBUSl3etyQ2IZYllMzYG5aK+qNjsCUiyHjk0ScGwKDhvq1za+Xu5oRfHH8la35dAUxVSOYPBVOn12CX1CoQv+xic/RcA6GNi86kRu+C9T4vf+fnrApKsMiWrWBQna6iBOW+5HhvNjVIwxXV3PjuyJKRdMNNk8EUqX5lkHZg6wEB6gJAa4swlZzZ9fG7oRceJYRWERZK1oCFJluF0W1VSshq2CwKmFhadOH5EOsSOM8xv+IVte+mCNWayHjo4wad+KeZZ/uGyLZy+KtmyQ7h/4H5+vvfnKChcc/41TUv7tm1z9KMfpfDUU+h9faz43GdR9IXToqB2dIAmzpOKc1nzSLJk6EVnpJNM3m6cZMV76J4Tu6CjPtVTspzgi27fjVrOY3VbYmdzciiL6Rxj9pHWzGNBY0oWwGl9p5Pzz2U1YReUi8h2vQvskAi9cJMF52geSyKcgI2OWtwiy2DQQmJpJ+yL9zX0+iOHpjENi0hCp3PJzLmRDX3iPA9KsszpNPq0OJceaJ+pFEiUzmSJ86Mz5p2jczWT5c4McTyTLBl8If4ejRUSS7ug2FgoD7+Q8e0r2lbMeGoxJ+2CBCZZ9z0t7pmajNx3lazjL75dIqJrrHWSacvnsuTxR2K6OD/WXgxAaOppILhdMFc0efigsOGevy7gxoevI8suFDAscf+PJII7CpKRJFFnnSbJlWsXnEeSNVsla7IwWfHr9xwRKtbpfafPqtImc4KFXsAiyVrQkBHuhhO7LtMFoXG7oBZS3ZubqUUhX6ZkKYpHcurs3rYUhWmR1gZV7YITmQLv+N52iqbNZduW8qYL17bs2xuW4YZdXLXxKk7pab4Edvw73yH1i1+CrrPiC9ej9zW28DrWUFQVLZkEwByvcA40UUjcbPCFDL3oinSRzhvE3TLixpUspVWFxIW0KOwG6K2jZGWkkuWpBI+NCSUrnhe/E8uymRrJYVsWuUdFolZ02+xJliyWDUqy/HNZVibjI1nB7YLSDtWui3NeFBHLZME5msfy45QrxL+P/k9LLINBC4mbncmSoRdL13VWtDzLuaynAs5lFfbvA2AiDgN6tmr8/FTRI1njrl3QO0fDczSTVUKyjk+O5SlZToG62VBXlnOO5ychOz5TyarSkQVQcKxwBcVmNF1geKr+tepeh2Ql2mRasAGm4dmZ+46f+HY/3FLiGSRLnG/uRvISEQykp8TPE7SM+MEDExRMi/6OiFs1Uhf+jqypKUxnvRVqC9ixhQhzKd/4ns/4dglJsqQtLyjqKVn3DojQi9lYBf3HdaLEt8MiyVrQcJUsRZyQfpIlL9ZBC4kVRXHnsgwtglJOsuDYdGVJ1UyPVkyOs22b9//4EQ5PZFnTE+fTV57W0nSqH+35EY+PP05npJN3n/nupl8n88ADDH7mXwDo/+AHiZ91VqsOcV4RtCtrtXMDOzyexTCr7zI2bRfMTQBiZihdMJqwC/oLiacYacVMluzHinXVnR8cT5fOZI3lxtwNETXr3WDGBzMU9u3Dmp5GiUaJbNgw68P0yoiD/cxberZQcNbZQxOHIO4QhiaUrKgqntvlJ1lzrWSB6MsKJYR6dviBWb9c0Jms5klW5dALiUa7sgpP7wNgrEuQmb2Teys+zq9kTVawC4bnbCbL+/h4V7IMZyPHaqRfL5yAhLOpNnFgppKVrqVkid91wrlW1FOzDNPigX3ivtnTJYhALl0UCZtWUbwPOlbWeoljhpOXiPtB+c8o7aluR1bvyaCGCBni5zQC2gWlVfC8dT3B1gmWCZPOxlnXGsxUSmxCU+ocCoLyNZk7kzWPJKu9Rxz71FiF9V0N1FKyTMt0kwVnU0IMJ14RMSySrAUNj2TJosiZM1lDmSEMK9iuo7QMmnoUNV9hp8ONcZ9HJctvFaxwUfz675/mt7sGCWsqX37dWXREWzeHNZod5d8e+jcA3n3mu93o5kZRHBrikCwc/rM/o+vP39CyY5xv6DJhsA7J6m+PEtZUDMvm6GT1C7okWXkzXxJnXA9SyWoPd2LZ+EhWwN1Jv5LVKrtgwNALy7K94AvHLrh7VMxKrOlYQ3bSU5jGB9JkH3kEgOgpp7TEXipJVt6wyBXrL04iWgScsI2nBnc1FXwhd+pDlnjunBcRlyMUg02Xio9bYBkMUkhs27ZHsqKNkawBn5JVCRsaTBgs7BWzgrlOseEh+2zK4Z/JkudoZ7yCXfCZrGRJu+AsEgYlSZfnj6tktc1UsqRdsMtZeO6ukzD42NEU6YJJR1Snp8cpMs4Y3jxW30ZQj8+ln5swWKZkFTJlJEsLQe9GdKcfMaiS5YZeBJ3HSh12wnlC0L4MK5XylKyIVufJpXCVrOlSJWs+7YKSZGUmCxgBrv0SnWGHZOUnZ1iNd4/tJlVI0RZqm5XTRx4XLJKsRRwnkCSraJUWRYLYOdVVHcu23Bt9PciLhqlF0AoVFp3xY2AXdEMvZl4UH9g/znW3iBvHR1+6lVNXVF6QNIsvPvhFpgpTbOnewpUnX9nUa9jFIoff+17M4REiJ5/Esn/++HHbAxMEmiwkrkiynMXy9CCqVWBlt7jB14pxT4QSKIjfRyNqllSyErr4m7t2QcfKUxfxHi/CvVV2wRFJsmpbBVO5InJNKZPbpFXwlI5TXWsMwMRgxldCfOrsjxFoi+jojloQVM3SY4K87h96vKngC7mIxBAkXShZDsmaD7sg+FIG/wes4JHPleAqWTXsgulimpwpzktJyoIgO1UgNZwFBZZUUbJkIfHTI2lMq779sfCUIFmaQ7Kemniq4uNK0wWdCPfYzOCLls9k2QthJkv87EU1io3SeMKgL/yi3C7oFhGXdWSBZxdc0iWup/WULDmPde7abmLOhkouU/SSBY/D0AsJt5B4aBrLd167SpbvXKR/KyHnuh9kJqtgWGw/IO5bzwqcLCitgqtA1TBTU+54hhcWFgz+hEHbto8JyYomQujOOm96LPg9T5YRF62ie02TkKmC5yw9B12d3SagG3yxaBdcxPEAywmnMCynhNhHslRFdWXo4IXETny7FiFUrGUXnE+SVbkjazxd4F3f345h2bzktGW84fzWWo52DO/gxiduBOCa869BazL9bOiznyN7/wOoiQQrvvhF1HjzQ6HHA2oWEse7RfErQOowq7qcrqzx6iRLVVTaHGLUCMmSSlZcExf/NmdHM2gZcWm6YIaR6RYkZrpKVm1Ln0wWbI/ohHVxCZbJghsjpTuBEwMZsk6yYCvmsUBYg5MNhl9EEuL3fHhkb1PBF3IOoZgXpLg7Hpq/4AuJk14gSHjqEBy+f1YvFST4Qm5uJUKJhobB5TxWV3/cJTXlWJGMEdFVCqZVt4sOPLtge1Jcx6rZBf09WZNZaRf0KVm+maxq4RnNwPatkdXjdBNK9mShKBh6FKuRmSzwzvMyJatgFtyo//KOLPDsgst7K4dClEPOY523rtuNnc+ni8d1fLvE2p44YU0lUzA5POFdk2XwRTjuez8s2eoqWaZhlZCySnjk0AR5w6InEXbttnVRlixopiZdJcsfFhYE7px8ZoCJ/AQFS9wH5pNkKYpCh6NmpUaD3/PiehzdqfeZzJdaBlsR3S4hZ7IWgy8WcVxAKlkFU9yU/DNZ4Hl9gyYMejNZUULFCjvc8cZ3sGcNuZDzJQtals37fvwwRyZzrOtN8KkrtrVUHbJsi0/c+wkAXrbhZZyx5IymXid1yy2MfetbACz79KeIrFvXoiM8dnBnsioVEitKiWWwr11cKEfTtdWS9lDjc1lSyYqoYvGfUBqcyYq0k1R0VGehmDYnG+ocqgi3iLi2kjXuhl7MjG9fowuCJk/n8YE0+V1CrY1ta42SBdAZa4xkxdsFuR4cO0gx6ijGDQRfyJmTfE78vZZqU2DkAEVEuM8HQlHYdJn4eJaWQf9MTTWy0ew8lltCvL66Mq+qCuvduazai33btikcFL//pb3Oc6ooWfI92BHuqBx84ZA+2w5u0QqCkgXy8cmx0EIquiy/1eNY003aBctmsgbSA9jYRLWoS979kKrh6n5xbXt8cKqqemlZNn/c55GsqBOsU2oXPH5Jlq6prHeSM/2KnVT3SzYd+k8hpHhqTL2uLD/5DLxekHOjjgppTU1h6oKkNGsXHJgecFWs7mg3YW1+VRt3Lms0+FyWoiiumuXvysqbeR4cehCYPcmybXvRLriI4wtWRgw9Fw1Jskrf9NLfHVTJcmeytChhs4hdbqlxZ7LmMfhCWhN9HVlf/f1efrd7iLCu8m+vO5P2Fs5hAdz0xE08OvooiVCC95zdXI9V/qmnOHLNPwDQ85a/ouOSS1p5iMcMsivLnKhfSNwjQx2m65AsZy5LWpWCYCwvzouwIhaNsUaDLxQFLdFHV6ssg7YdvIjYiW+XJGsyP8nh6cMA9FriPdu3WvxOcmmDghVC7ewktLp1io9UJyYC2gUTbeLvrhaKPGU4YQuZsUC2u0wx4+5+pqbEz7XEFosM2peBPo+LjBZZBuUiuWgV3US+cjTbkeUlC9YuPD8p4FyWOTKClc2BYrN2iSB8Y7kxtwbBj+niTLtgp8+ipYe9FNpWhl9IoqooHNd2ai/GvYlCYp9dUJ4/E/kJDk2JYIVlbTM7ssBTslb0JYiGVHJFq2pq6xND00xkisRCGqeu6HSPN5cueh1+x2F8ux/uXNaQj2SVB18ALNmKRgEQ7+N6XVmSZAWexwKfXVBce81J30xWg0qW3y4oQy/mU8WS6OiWSlZj4RcyYdCvZD009BB5M09frI/1netndVyFrIHhFE4nFu2Cizge4M5kOeV45Wk3S+ONxbiHXJIlLiJ2tULieZ3JkiRLXBj/uG+Mf/mVsD3800tP4ZTlrZ3DmsxPcv326wF4++lvb3gXGkQnzaF3vRs7kyF+/vn0/d3ftfQYjyWkXbDiTBaUkCxJIsbqKVkOyUoVaw90+yGVLN0WC804jvUhKMkC0ZVleeEXw7MhWekRyE0CCnTXvtm48e3OAmjXmOjHWtm2Ejst3oOdS+K0dYn3YSa+hNipp7Z08enaBbPBlCw16iRqFeGRtLO7a5vg/B1qQc5jtYfbmXB+vp6ic02aL6ugxEnPF51/U0fg4L1Nv0xEi9AWEudetULiZpQsy7IZ3CfeB+UlxOUI2pWVf1p0CYXiJon2XjfBrlzNsm3bVbJCSoy8IRY8fsVVURQvYbCFc1nSLng8EyzwhV+E4k3YBT0lKxnuREHBsi13HrPSPBZ4M1nReMiXvlf5Wnmfk5539pouQprq2QWnMmBkQQt7x3GcQs5lPe5TsgrlEe4AnStRop2uZbBWwqA/cfH89Q1sepTZBa2pVNMzWVLJyhgZN3jmWJCsdicMpRElC7yEQb+SJa2C5y87f9bv3bSjYkXiOnp4Dsvp5xmLJGsBw05nMFUdZ504k2Q1WkgckelJ4iKSmy6LBz4mEe6eXXB0Os+7vv8gpmVz+RnLee15rR+Y/7cH/42J/AQbOjfw2i2vbfj5tm1z9B/+gcLevej9/QuucLgetC5xDlScyYKSriw3nryOWtJMjLucyVLtdnQMQjgLvkaKEEsSBqcYCdA/UxVSxepcJZLsasCNb3fUJFlCvKVnS4knPdkvfpZ0vJ9oC62C4BXMBg2+UKLiZwobsHNstyAqEMg6LK2CS+PLyDgLofa8c02aj2RBP/QIbP4z8XGrLINV5rIkyWqkiHh8IE0xZ6JHNLqX194wkHMl9ZSswr59AIQ7DIj3uDvO5XNZWSOLaYu/j2EIUq2rComyBc9cdGW5StZxGnoh4SUMNmEX7FwJKFDMoGcnSEaSAOwcEcE2lZIFwUsXDEc1V+XZXSX8wm+JA2+OLC/dBD0ng3Z8348kydoz6J3XFZUsRYElW1zLYDFfXZneeUQkLnbGQmxyXj8Q3CLitUCpktXoTFZUj9IVEZuUDw89DBwrkiXtgo3NIVfqynKj21sxj+WGXpw4VkFYJFkLFrZlYWWzbmcDzPQIu70MQZUs5/l5XSzupifKLuTHYibL2SW2Yt2850cPM5DKsb4vwSdf0do5LBBRpD96/EcAfPj8DxNSG7chjn3r/2PqV7+CUIgV138evacxq9DxDjf4otJMFlS2CwZUsoKSLNu2XSVLsdq8+HYIni4IDsny2wVn0ZXlzmPVtgqCv4jYSRZ05rG29mx1bzRtyQhdDsnKxPuJtSj0QkKqaJMBZ7KkkhUp2uwY2dHQhotMTuuJik2fkKYQmRL2yHlLFvRDWgYf+ynuDlUTcMMvqiQMNqNkSatg/9p21DqEwy0kHk7XDKEo7BMLxXC7AfFuNiTF3F+5kiXff7qik8uLe0EyHppxnZ2LGHcZ4a4c5yuSWdkF9Qh0OGqVL2Fwx4gItqnUkWWZlpucF4pqbF5auUcKxHXxvjKSJUlJLuecH8fxPJaEJEFPDU+7HYvuTFa87J5ckjBY/b0sFb5z13bXfV+5MPIwJTeDnOALfxlxgzNZ4G18PzwsSNZ8dmRJdPQ2Zxd0u7Icu+BkfpJHRx8FhJI1W2TkBuMJZBWERZK1YGHncmDbbmdHKKrNuHi4g5YN2gWLDslKp8qUrGPRk+V8r58/meeOx4eJhlS+8vqzSDQo1deDbdt88t5PYtkWL1r7oqYuGpk//pGhf/1XAPo/9PfEzzyzpcd4PED3lRFXXNg1YReUO2RBSVbWyLrJTLYR9+axVL2x+R5fIbE6266sgPNYMLOIWNoFt3ZvLWm87+wWC4pMvL9lyYISjRYSKzFJssTiPB0XZDtI+IVUsjpDYte2Kx5Gme9kQT/WPw8inTA9AAfuafpl6hUSj+Qan8ka3CtLiOvboNf1JlAUmMwWa4bLFBy7oCBZnpL11GRlkiWSBcWiNhmf+X6S4QP5uVCyjnO7YNSvZDVqFwRfwuA+VwmVIQhyU9QPf7hIOKK7SlYlkrV/NMPQVJ6wpnLGqqQ4Xif4wjRVDDu8IEjWyq4YsZBGwbDY78yeFdwI97L7/pKt6Io492vNZMl+rMDR7eBUTNjCHZEQGyVmKoU1C5Il/8bymnEsSFazXVmukuXYBe8fuB/LtljbsdZda84G6RMw9AIWSdaChVtE7JCs8mRB8EjWeH6cnFF/10K+hhESb8L0ZNlNRO5eF6bAmMWufyNwSNZ/bReLj4+/7FQ2L609EN4Mfrb3Zzw49CAxPcb7z3l/w88vDg5x6D3vBdOk46Uvpet1r2v5MR4PkEqWXSxipSsMX/uVLGch32olS1oFI1qEXEEj4XZkNTCPBSUka9aFxAE7sgDG0l409nRhmv0poTT47YJtyQjxrFh8ZduXE1rSWltJ0g2+CKhkRcQ1oYs4NjaPRp3fdQNKVlwVC5Xu+S4iLocehi0vER/PwjJYr5B4JNO4kjUQMPQCIBrS3JqEWpZBaReMtBsQ85SsvROldkEZ4CFCL5xkwdhMNV/apGQgQyvgzmQd93ZBR8kKxbEaVbLAN5e1f0aSYCUlq+D8jlVNQQupLsnaN5qeUSQuVazTV3USDYm/USiqub/TvJVYECRLVRVO7hcqrZzLkhHuJXZBgP5T0KWSVSVd0LRs7ttXqvAFwsQ+8W9yjRv3mp/yLHaNBl8AM8jIsbALNtuVVa5ktTK6HTy7YCK5qGQt4jiAJFlWXJz4lfzBHeEOYg4Jk2k2tSAvGpK4ZabKlKxo0vNzzFf4hfN9Ru02TlnewSvPWdnybzFdmOZzD3wOgL8+7a8b3pWxi0UOv+c9mCMjRDZuZNnH/um435FtFmo8juJYxyomDMo47mKGbk2cP5mCOWNB4IcbfFEIFnwhrYLJSJJMwSSOQ7JCDZKseG/rCokDdmSBpx51J0KuirUssYxkJEl6wtnNS0aIDAgLYibSg2nOrjy3HI0GX0glq09LArAj5FwHApAsqWSFbUFKuuMhLxq58xgoWdASy2C9QuKG7IKmQeHn/8TYEbFwD6JkQf3wC9swKBwUhFYqWZJkDWeHS5LC5CZHe7jdPS+S5fYsPLvg3ChZLXvJOYEMkjCasQuCL2HwwIyC6opKlkOy5L25ry1CdyKMZcMTg6Xfv3weC4Qy6FoGrfaSImJjfJyxb3+H9D33YOVbUMbeQrjhF4PT2Lbt2gXL585LZrKqzMjtHkgxlTNoi+hsXdbABq07j+UFhRSce4SigKY3vnwu/xsfC5LVbFdWefCFS7KWt4hkOfe+eMeikrWI4wCyiNh0SkJnXHwQb6ZGwi+k/C17IHKpspuIqgqiBfNjGSxmoSjI5ITdTk9bZE7Iy388/B+MZEdY3b6aN259Y8PPH/yXfyG7fTtqWxsrv/iFBV84XA9eIXEFkhWKQkLcONqyRwlp4u9VS81qVMmSykFXtIt0wfBmshpWsvpKlaypJtVZ04AxRxWo05EFnl2wKx72Qi+6t5BPG5iGjLCNoO55ENXMY6MyNdKYf74eGo1wV53gi15F/K12SGKbrm8XlEqWaorF38pYHmRc/7FQsgDWPUdcy9JDsP/Opl6i1kyWaZmu4hoo+OLh/2bwD78FFNp7osQ7gu3m1otxLx46BIaBooMetyDeTSKUcO8L/vALl2SFvPj2SnbBuZnJEv8uGCVLj2NNNRh8AZ6SNV6qZOmqXvE8KeQdcuHY4xVFcWeWdpclDN63T5yH560rJW/RqKPC0FGyCXT0w9cw+MlPcuAv/pLHzzufA29+MyNf+xrZHTuxzdaplM1go1SyBqcwihaWKUj4DCUr1kXI2QcwRg9XfC1pFTxnbRe61sCStyxZEKDoXC9DYaWptcjSttIN3P7E/NsFobmuLH+E+0B6gH2pfaiKyrlLz23JMWVSJ14RMSySrAULadUyY9VJFjQW4y5JlvQc5yvZweYzxt0hcpaiM0WM9hbPYYGYL/neru8B8KHzPtRwMeDkz3/O+Le/A8Dy6z5NeO3aVh/icYeahcTgWgaV1GF3Md9KkjWRnwCgK9LFdN4k7toFGyS3ZXbBpiPcJw+AVQQ9Ch31ldaxjDeTJeOb/aEX0UQILaSS27mTuDOvMT6QrvxiTaLRMmIlKq4Jnba4Oe8wnAVenc2WollkODsMgFlIArBWd56T6KubxDhn0MOw5aXi4yYtg7XSBcfz41i2haqobqJYVRgFuOMzDBY3ArB0RfDr3Aa3kLjy+ZGXyYLtplCJnLnaDZ0zwy9kT11du+BckKyFli7YtF3QUW4n9pfM6i1LLEOtkPpRrmQBFeeyjkxkOTiWRVVEfHvJMYfE3zIX3yDCN4DMgw8y/X//B5qG1teLnc+Tvutuhj/7Ofa98pU8fuGzOfSudzP+3/9N/umnawarzAW8hMEpN75dUZWKc1B6TFxDimOVN5LvfVqSzwasgjBDybJt260taGYeC0qVrJgeoz3UQNJhC9FMV5ZrFyxMuqmCp/Sc4pKv2cI/j3wiYZFkLVC4dsGIeJNWixNtpJBYzmS5JGu6Esmaxxh3h8jl9E5AIdHkha0abNvmU/d9CsM2eO6q53Lxyosben7+iSc4+tFrAej567+m/fnPb+nxHa/Qk8G7sroDhF80GnwhS1ST0STpvF/JaiBZECDRS7drF0wzMhXcOlECOY/VvUGovTVgWjaTWa+M2B/fPu2LbzfGxykePEjcsfmOD1YuH20Wrl0wUwy0gJJKVpsVQlVUhswMg5pWN/hiID2AjU1Ui5LOihv7KkWQrmOSLOiHaxn8X6FGNgiXZFVQsoYz4mfsinShqXWuWw99DyYOuCSrvyd4X5ybMFhFyXLj29uc959z/V6fdMIvfCRLzmS1hdt8Slb1maxW9mRZ1gKxC8ZL7YINkw/XLniQHh/5rtaRJUmW//7uJgwOetfLPzozR6eu6KStbDMyogoCno97/X3D138BgM6XX87Jd9zB+pv/l/5rrqHtec9DTSSwJieZ+s1vGPjYx9l76WU8+afP58iHr2Hy5psxhocb+5mbgDt7NpJmyqnWiMT0iuqRnhAOBmNi5nFZlpe4eH6ZwlcX5R1Z6QymIt4P4QqbD0EgN71BWAWP1VhBM11Z/gj3Vs9j2bZ9wgZfHN+FCYuoCisjLpxGRNxkW6JkORdySxULY6OWkjUfdkGHyKV18eZudaLgbw/8lnuP3ktYDfPBcz/Y0HPN6WmvcPiCZ9F39btbemzHMzy74ETlB/i6snraTgfmTsnalzfokUpWIx1ZAPFeuqWSpVhMGylyRdMdGg+MBuaxJrNF5LosrBd5elIkv23t2crQfm/wN7dTROO2h/MMARMtJllSYSyYFtmiSTxc+72lOjNZSr7IScmTeHz8cXZGwvTX2WxxO7ISS5mYFgv3pbazGDoWyYJ+rPsToexkRmD/H2D9cxt6ulQiKgVfBJ7HMvJwx79i2zBYFPMy/bEDgY9BKlmHJ7JkCsaMv2Ph6X2AM4+leHZvqWT57YJy1qI93M5TWUfJqpEuWMi20FLmvCcCx2sfI8i0vqIeB8PAzuVQYg2ose3LRQqqVaTb8gja8rZqRcSOcuILtqrUleXOY62dqdZEGQcS5KNi8yt9991k7r0XQiH63v52Mbd18slETj6Z7jf+ObZhkN2xg8w995C+624yDz2EcfQokzfdxORNQvWNnHwS8WddQMcLLyF+bmvsYn4s7YjSHtGZyhvsOyo2EMLlVkEHoY4kAEZq5qbfk8PTjGeKxEIa21YEm3N0UaZkWalJL769QtBYEPTGetEVHcM2jsk8lkQzXVkdTjfiZGGypIS4FShkDcyitMovKlmLOA4glSwzVD1dEBqLcXftgk4/VDFT4Q0Ym0clyyFy06q4OLbSLpg1snzmj58B4M3b3syq9uC76rZtc/TD11DYtw996VJWfPazKNqJ01BeD1q3LCSur2TNhV1QzrpIJSvW7ExWOEFIj9E524RBtyMrSLKg+D10xkI8lXoCG5slsSX0xnpLioizOx4BoGuZWERPDLSWZMXDmjsvNx7AMijLiK1cjm29Ik7+kUi47nXgyLQgWcvblrs/e4/phPAcq3ksCS00K8ugVLIyRoasUXqtdElWvA7J2v5tSB1iOraVrNWJSpE+a2fgY+hKhN0+ur0VLIOlyYJdrtIqwy+enHjSfazfLjheS8mag+ALqWRxfHOsEiULaNwyqOluOFBP3vt7VS8idpQsn4tDWumGp/Lue6q8H6vkmA1hOc5p/di2zdD11wPQ9apXEVoxM9FQ0XXiZ55J79/+LWu+82023XsPq772Nbr/6s1Etm4BRSH/xJOMf+c77H/jm8g/9dSM15gtFEVho1Szjor7woz4dgd6h3gfFqdSUKYs3rtXXJ/OWpMk3EhQRX7KG4nwdWQZsyRZmqq5c1jHIr5dopmurM6wWIdNFaYYyY4Q0SKcseSMlhyPDL2IxHX08Im1llokWQsULslyI9wrn5iNkCxJ1GwlhI2CmalhF8xWWWC3Es5FbkoVF9tWKllf3/F1BtIDLE8s582nvrmh54594xtM/eY3EAqx8gvXo3c36PVe4HBnssZbU0jcFhJEImfmKJr1F/wyXbAr0kU6b5BolmQpijOXNctC4kY6smQRcTxUUkIMpT0huR1iod2z0alhaLGSpSiKL8a9/s+sOjNZdjbrkqydkQika5MsGbizLLHMnUXrzDuzE1WSBe1isDmxlmAWlsG4HifiLLrKLYNyTqs3WoNkFXPw+88CkD3tbwCIqZNoE483dBzeXNbMBb9rF+wwvA0yPLvgUGbI3dzwB1/IkupkrELwhXOfKLbQLihtd8e7kiWDLww9Ku6RzXRlOcpId2bC/VQ1u6A7A+S7vyciOqu7BcnbPZBiZDrvBp+cW0HJiuRFIERe7Wb6tv8j9/AjKNEovX/ztkCHq8bjtF18Ef0f+ADrb7yRk++6kxXXf57o1q1g20z8+IZAr9MoJJk8Oiyuff7Qi+k772Tf615P/umnCSXFe6xoKJAqDb+4p1mroFSxYl0QFQqOOTk5qyJiCUmujgclq5GuLKlkSZy15Cz3+jdbyHnk+AlmFYRFkrVgYcueLE28WaraBX3pgvX84/4LuamF3QTDEsznTJajZE3QWrvggdQBvrnzmwB84NwPuDH3QZC+9z6GPivi3pde82Fip5/ekmNaSNC7gs9kyULiWmWpkmSBNxdSC9KelYwmmc6bxJrtyYKZXVlTzShZzk5uoI4sh2Qlwi7J2tKzBcCnZIXJ7twBQN/ZwkKWmy6Sm24t+ZChBpONKFn5PNv6JMkKYxamhOWtCiopWYmsQ7Iq2AUHP/VpHj//WRQOBLfMzQprL4Z4r9jQ2XdHQ09VFKVqIXEgu+AD34Kpo9CxguLaSwEIKzkYaZBkVUkYtNJpjEGhGor4dm8B3hHuYElMLPKkZbA0wl3aBecpwl2mCx7nQ1nuQl9RMfQYVrr5rqxY6ihxRxGrZhf0gi9K733+8Iv7nXmsTf3t7vXWRXqUqOkoWWaC4S+IWazuP38Del+A1MsK0Lu66Hjxi+l95zsBmPzpT7ELre/NlAmDQ46lTSpZtm0z+IlPkt2+ndQvfoEedcYb7AgMPuY+37b981gNboRWSBa0pqYwnfXWbEjWyV3iPiHV5GOBZrqyQmrIPV+hdVZBgIzsyDrBrIKwSLIWLNwyYlUw/3okK2Nk6i5g9ZDqDh6bWgS7Ismaz5ks8T3GbXGxbW9Soi/HZ/74GYpWkQuWXcDzVwcPqygODnL4ve8Fy6Lz8stJvuY1LTmehYbAM1lTA/TFHEtaDZKlqZpLtIJYBv0zWbNSssDpynJIVjNdWYW0t3sapCPL+T10x8NuR9aW7lKSFbWzmMMjoGm0n76Vti7xHm+1miWtnEHsgnImy85m2dC5gZgeI6OqPB0K1dxwkUrW0vgyVzELTzu/rwp2wfQ992BlMqTvuaehn6VpaDpsfZn4eBaWwbGytFUZfFGVZBUy8AexWcOfvJ+CIW7FITUL04OQnQh8DNW6sgr7xUJR64ijhW3v2u1AqlmylNgtIw4Fswu2NsJ9YaQLarqKHhZ/q6Zj3N3wi/1cuu5S1neu55SeUyo+tJCfGXwBvvCLgamK/VguRvYQUcV5kT40TH7PHtS2Nnr+6q8aP+4ytP3Jxeh9fZjj40z97rZZv145ZFT9+KTYRJMzWZk//pHCXnHOmhOThJy/h2FHYehR9/lPj6QZnsoT1lVOX5Vs7JtX6MgyU1OuklXNORQE7z7r3fzbn/4bl667tOnXmC2a7cryq1mt6scCTtjQC1gkWQsWMsLdUMRCqdpMVkyPkYwkgfqWQUXxIlJNLQr5Cn7deZ3JEt9jzBKLiESd4fwguP3g7dx+6HZ0RedD538o8M6pXShw+Oq/wxwdJbJpE0v/6R+P+13XuYLWVWcmK9ELWgSwWaZOALXtgtDYXJYkWZ3hJNmiSazZMmJwurIcu2AzM1lSxYp1lygF1SAtcx1xb3Hr2gUdkqUNiDCMyMaNqNEoyX6xezgx2OIYd7eQOIhdUNyQrVwOTdXcReGOOnNZUslq15dg2ZAgi+qkQ1ZKFzSnRPhCYe/TwX+Q2UJaBnfdDAHsqn40rWTd/w1BpjpXwxlvcK13Id2x7ow+Wfl5FVCtK8u1CvY5MdGx0vOzfC5LvvfCapyC09dWuSfLSRdsYfDFQikjBp9lMBRvzi7o68r6pwv/iZ++/KfEq4T2yPOi/P7uD7+oNY/F8G6iijjGzCGhaHX/5V+gJZONH3cZFF2n84orAJi4ofWWQTmTlUuL96T8vU/88EfuY8zJCVeRKZYpWZJ8nrEq2XiYUSUlKzXZEiWrI9zBc1Y9h5DaXEJhq9BMV5acy+qMdLK5a3PLjkXaBRPJRSVrEccJpJWv6AREyhtfJTQUfuFczA0tApVa4OezJ8v5HkOWWETM1i6YN/Nc98frAPjzrX/O+s71dZ7hYfAz/0L2oYdQ29tZ+aUvojaSKHWCwZvJqkKyFMW1DC6xxY19rM7cjyRZMuGsGizbcklWWM7qKbNQshI9rpKl6lONz2Q1EHoBnpKlRI5i2ibd0W6WxJdgmRYZpwxZH9wHQHSzuIl1OSRrvMXhF8kGurIUh2TZ+Ty2ZblzWbVIlmVbDGTENSeqiOvGpqhzzkST7qxDyXOcRWv+6b0zvjZnWPNs0dmVHYe9tzf01O5Y5UJidyarEskqpOEPnxcfP+cDoIcpuFHdzjVu5InAxyBnsvaNZDCcDQOA/NOCqIadIffyTQB5/XtqUmwUuBsclri2hTSFRIUhdHmMpmG5iWCzxUJRsgCiCS/8ormuLKlk1bfEunbBSGUla9fRFI8dFdfMyiRrDxFV/F0Llo6WTNL9pjc1fsxVkLxSkKz0nXdSPFy5DLhZ9LZF6E6ECdvinIjEdIzRUVK//rX7GHNigpBzjhp2BIY8kiXJ57MatQpCXSWr2eCL4wmz6co6b+l59aspGoAMvnjGz2QVi0U2bNjArl275up4FhEQrl3QdkhWjTd9Y+EXUsmKoFZSso7BTNaQIRaZs7UL/n+P/n8cnDpIX6yPt50ebOgXYPLmmxn/7ncBWH7ddYRXH+Po6WMMOZNlTkxgm1V2sx2S1eMkW7VKyZoqTGE5Axw6Dvl2SVaDEe4AiT4vxl2fZrjRmSx3Hqt+6AXAmLMrm1fFTXxrz1YURSGTKoAtFpnqYWdxvEbc4JNLBXlseYx7opHgi6j7se2by9oRiUC6clfWcGYYwzLQFA1MQag2RibEFytYBW3LchetMnp8XqBqsPVy8XGDlsGmlKz7viZi47vWwumvBXyL6bjze25gLmtFMkY0pFIwLQ6Oe9afwj5xjoW7nMVQGck6KSnOWamoynRBwxDH0BkLV1Tr/db0VnVlyXHhheAOkIpKUY9jTc/CLpg6VFc5LbhKVumCdm1PgrCukjcsbBvW9sTp74jOfIHhPYTttHu8PW99K1pbg32CNRBevZr4s54lAjBubK7UuxY29rcRlSQrrosI+WIRdIfoT0y6aXRFOwLDe8AU3X8yWfD89Q2GXoBPyVrrfspMpTD02QdfHC9opitLzg5evKKxTtF68GaynuEkKxQKkcsF/4MsYu4gSVbRFH/CajNZ0GBXlrQL6lG0Qg0lKzfZVIFnQ3CI3GDRsQvOQsk6On2Urz3yNQDed877SAS0luUef5yj1/4jAD1/8zba//R5TR/DiQLXamLbmKkqypNjBWvPi3NuPFPA9PXClCMoyZJFxG2hNgpFcfNtV5ssIwZnJstLFxxu1C4oFYeAJEumC6asfYB/Hkt60sMUDziL4zWCzHe5dsHWkqxOR8kKFuHuLeD8Me5PhENkpwcrPkd2ZPXH+5nMiN/x+pBDRiokC1rT0+5qu3joEFYlJX2uIC2Du28GI7iaWamQOFPMkC6Khe0MkpWfgjtF+ADP+XsRI4/XhxSWC+AGSJaqKqzvnVlK7NoF253rdPlMlqNkHU0fZSI3Qc4U9/aiIch3pXks+f3kfaJV4ReektWSl5tTlBQSN2MXTCwRdmrbgslDNR9aqBJ8oWsqJ/V517uKKhbA8B5yBw33eJOvfW3jx1sHyauuAmDixhurb7o1iU397URlr2BUY9yxCnZeLuYozYkJQhFnJos4WEUYfZJD41mOTObQVYUzVycb+6a2XVHJslKplsxkHS9opivrvWe/l88993O8bMPLWnos6cXgCw/veMc7uO666zCMOV5gL6ImrEwGGyiaYqEZRMmSQ+i1IBMGDS1CqJifmUjolFkC4ERpzxmcmPjDBbHITMxi9+hf7v8XcmaOs5acxWXrLgv0HHNqisPvejd2Nkviwgvpe9e7mv7+JxKUUAi1XZCiel1ZMSdJzrZFEW81yDb5uiRLdmRFRLIgQJviLIobLSMGZyZrFj1ZDcS3g6foDeWFAiZnm/wdWTJZz1OyxM81OZTFNFtjzwIv+CKQXVDTUMLi8XY2S3+8nz4ljKko7JqoPD8k57GWtS1zf+7VmkNGKiQLloQIWJYb3DAvWH0BtPWLzaO9/xf4aZUKiSXhimrRmZs59/6nsEF3b4Btr3I/7SpZHU5hagN2QfDNZTnhF7ZtU3DsgpGEszFaNpOVjCbd439k5BH38/m8IFddVUgWeItMedyzhezJWhhKlhNhH4o1ZxdUVe/8r2MZLOYlyZp575OWQYDzKkWU51JY40eZetRZ5ikKRbv1Nrf2S16A2tmJcfQo6bvuaulrn9zfTsRRsuz9T1A8eBC1vZ2u174OECTLVbIU5702+Kg7j3Xays66ReszkBkFZ5PEPzdq+kjWiaBkNdOV1RXt4pI1l7TUKmjbthd8kXyGK1kAf/zjH7nxxhtZvXo1L3rRi7jiiitK/lvE/MDKZLDUELZzAao1k7UsIYoOgylZjgyvRQgbBXLlnntNh6izEJhLy6BZhLxQSdx0wUhzg6J3H7mb3+z/Daqics351wS6kdu2zZEPf5jC/v3oy5ex/LP/+owqHK4HrVsmDNYmWVrqMB3OBsBYujqBaVTJ6oqKZEGAxKwi3Hvosbx0weGpBpR62/ZIVtCZrEwBFIPB3D7AF98ue0ISGuaoeF+FVguS1ZaMoIdVLMtmaqR1TgKpVASxC4KnZlm5HIqicGpUREDvSFdeKMpNneWJ5e7ffpk97HzzSqEXpX/7Y2YZ/N3HheIUAK6S5bMLjuRG3K+VXGtyk3DXl8THz/2QuJY6cAMOnM4fxvY25BSQQQjb94v3hzk6KgiAohCKTIoHVQhmkeEXDw09BAiFOJUV1/zOCh1ZEi2PcZd2wQUwk+V1ZcUxm7ELQknCYC24dsEKLo5NPpJVMaJ85HHGn4hjZ0GzxHs8H2BDpVGokQidLxPKRqs7szYtbSfinBv5O34HQOfllxNaJjaOrVQK3bktGzhq+9Bjs7MKShWrfRmEPAXfnEp5wRcnwExWM11Zc4F8xnBnO+OLShYkk0muvPJKXvSiF7F8+XI6OztL/lvE/MDKpDFkv5NSe2elESXLm8mKEjULTOUqXJTnI8bdeW1bUUmRQFUgGmrcS1I0i3zqvk8B8JpNr2FT96ZAzxv9+teZ/u2tKKEQK7/wBXcOaRECetLpyhoLUEjcJnan5DxSJQQNvnDj26NdTDskKzabCHe/kqWaTBWmyBsBbzjpYWcjQIGudYGeMp4uoEYGMG2TZCTpboBMy/h2VZAorbcXrS3hHJfiJgyOD7QuYdAlWTUURj/kXJbtWMZPSwiitCM3XPHxpUqW+B59pmMtrJQsWGY9Lcxn+AXAhe8SnVkDO+CHfx7INtgdnRl8Ieex+mJlPUT3/IdQ/3s3wqlXlnxJRnWHOrtAjwnbU50FuB/P2yQ6r25/fJh03nCtgqEVK1Ad9bfcLgieZfCh4YcAaAu3uWmTNZWsFse4e0pWS15uTuEqWXoCa7rJ96MvYbAWvJ6smff3U5aL9daKZIyVXTODmMz9DzO6q73kmPOZuXEgJa8S5/PU736HMdq6zdeNSzwlq3jfHwDoevWr0HxrTaXohICZzvnqU7Kq2ihrYWKf+NeXLAhgTZ5YSlYzXVlzgYyjYkXiOnqjKZALAA3T8W9+85tzcRyLaBBWJuMVEUf1muqMJFmDmUEs20KtYXyXOzSmFiVhFpnKG8zoJY91A3vnVslykgWtSCdWVqU9UvtnrIbv7/4+T08+TXe0m3ec+Y5Az0nffTfDn78egP6PfITYtm0Nf98THV5XVjUly1lETx6iOxniaeooWaHGlKxkJOkqWW6Ee5M9WREb2iyLaVVF0dOMThdYngyQHiktXcnVJTue1VA0LVI5g1BSpHBt6d7intMZh2RFioJolIerdPXHGTk4zfhghmB0rj6SseB2QQAl5ilZAKcmT4KRe9hpVCbGciZreWI5Tzl/+2TRIVmV7IJl1qv83nkmWcnV8PofwbdeAntvg/99J7z8P4S9qwqk3S5VSFE0i4S0UOXQi+w43P1l8fFzPySUMx/cxXRMh96TBNEbeTxQ9xrAlmXtrOmJs380w//tGeZCmSy4Zg3k7hMPis1ccMrwi50jOwGniLhGR5ZEpNVdWY5aoS4kJSsUx5pq0tLq2gWrP9+2bfe8qDQD9OyTevjIn23htJXJivfGsR//HLOgEl6SINbTTuZw2o1DbzWimzYR3baN3I4dTP7PT+n5qze35HU7Yro7k6Xnp4mdfTaRk4VrQG1vx5qaQs2Ie4ZlKVi2ijWwkwNjGVQFzlnTxOZohXksEEq70XPikCzZlTV2JE1qNOtu5M03XBfHCRh6AU1GuBuGwW9/+1v+8z//kynH4nHkyBGmm/EnL6Ip2OkMpi5JVu03fF+8D1VRMSyjZHagEuTFw9AjRIwCU5XSo+Yjxt0hcMWIuEi2NxF6MZwZ5isPfQWAvzvr79y5n1ooDgxw+H3vF4XDr3gFyVe9suHv+0xA/ULiFeLfwjQromKnarRGwmBQu2B5ETFA1JY9WU3cJMJxCCW8GHdtKvhcVoPzWHLxqkUF+ZD9WOApWWEnqU/OY0kk5yD8oivh2QVnzF5WgBpxSJZTH3FK76kots1hxZwRYQ4ibAZEItVYpkiEAvFC9ZksV8lySM282gUlVpwNr/o2KBo88kO49Z9qPrwj0oGuiGuTtAzKImJpJQTg7q9AfhL6tsDWV8x4nYK/D6l3o/hkA3NZiqLw4lPFZtovdx71Qi9WLfMeFJu54JSFxFlD/E3bQ+2ufbRSR5aE3IxrVbqgtYAi3EuCL2ZtF6w+k2Ualvt7qWRPUxSFt1y8vqJaY4yPM/a7PQD0vep5RJ33ej49d7P0bgDGT34S6HoSBMW8iYo4J3QjQ9drXu1+TQYwKWlvk8ewI+ipQ7SR4dQVnbRHmxgxqNCRBaUzWSdC8AU015XVapzIoRfQBMnav38/27Zt4/LLL+cd73gHw8PihnLdddfx/ve/v+UHKDE2NsbrX/96Ojo6SCaT/NVf/VVgUmfbNpdeeimKovA///M/c3aM8wkrk3HtgrWSBQFCasjdVZULn2rwR7hHzQLTFUnWPMS4O3bBQjgJNJcs+LkHPkfGyLCtdxuXn3R53cdbhQKHrr4ac2yMyJYtLP3HaxfEIPaxQF0lKxQT1itgfUg8ZrwGyQocfCGVrKgIvlCxCNuzSBcESPQ2F37RaEeWs3gNxQXJkvNY4DXeh0bF12SyoIQMv5hoYVeWVLIMyyZdqG+RlEqWtAu2d6xkXVFcH6QSImHbtjeT1SZmslYoTtR7KFFxwW+lxN8+cpIgrYW9e1u2WGsIJ18CL3Nmp+78Atzz71UfqiqqaxmUG1gzOrIyY95rPO/DFZWxkoCDHud8aiBhEODSUwWhum33ELm9+wAIL3Ou1dHOkhkwCTmTJRFcyZKFxK2KcF84dkFJWIp6bE7tgv5QkUaVk9Gvfx2rYBFJFmm/7KVEJMmag5ksiY4/uwwlFqOwdy/ZBx9syWtKe6NiGRSjUdpf+EL3a65lcGoCh4dRTIjf60blEOetbcIqCBWVLLtYxMpkWlJGfDyhma6sViNzAodeQBMk6+qrr+acc85hfHycmK+Q9RWveAW33nprSw/Oj9e//vU8+uij/OY3v+FnP/sZd9xxB3/9138d6LnXX3/9CbVYtotF7GKxxC5YD25XVqZ2+IUb4a5F0W2L6XSFeM/5mMlyVLKcLi6kjZKsBwYf4Gd7f4aCwjXnX1PTIikx9OlPk3v4EdSODlZ+8Qsl3UCLKIVeL/gC3LmslU6i3FwoWXF8N4dmerIAEr10yxh3fZqRqYAR3g13ZBUAE8KCfGzt9pQsmS6oDTo2rxl2QWGFHG+hkhUNqYR18b6oRYAl1Ki43ku7IPFetjkx648MP1Ly2In8hKuOLE0sZTxd9EhWcnXF1bRUBaJbt4KmYaXTGEOV573mHGe+Hv70o+LjWz4MO2+s+tDyGPcZM1l3fQkKU9C/DTa/tOJruGXEEc0j7Q0mDJ6+spPlnVHSBZPJx4XKGu5zwhEqWAVBzJR1RTzCW0KyAgVftGZg3iVZC0zJsqaaVLIkyZoegGLlCG15TuhhtSEbZXFoiPHvfR+AvtNSKEu2uMecm0MlS2tro+PSS4HWBWBIEq8bWR7c+mzUiLcQl0qWNTnpFhIXu0Va62b1YHOhF1BRyTKnprAVHdux+Z4IwRfQXFdWq+Em6y4qWQK///3v+chHPkI4XPoLWbt2LYdb3PgtsWvXLm655Ra+/vWvc/7553PRRRfxpS99iR/84AccOXKk5nMfeughPvvZz/KNb3xjTo7tWEDadUxXyaq/qxI0YTDszmSJi9n0ZAW1UO5Cz2nwhViwZB2S1UgRsWmZfOpeEXZxxclXcGrvqXWfM/nTnzL+/f8GYPlnriO8auZg/iI8SCXLGK9xDnQIy+BSRTym1kK+zVGhGlOyDC/0QlFBb5IUl8W4B+7KarQjK11AjQyCYtAeamdluyChxbzpLibUA0K9CFWxC+ami+SmW7MbrSiKG25QK15fojz4gng32/Lib7rTCU6QkPNYvbFeIlqEUb+SVSFZEDwlS+/tIbRSnDsyhvyY4OL3wblvBWy46W3w9B0VH+aGX+RKSVZvrFcUNd/7n+KBz7um6nyXTBcMldgFG1OyFEXhRacuRbVM1AFxL470Oe+JCqEXEtIyCA7Jykq74PwFXzj94gtCyXJJViiO2eyIRLzbU96rdGUV875zogGM/sd/YudyxHoKtK1PQKKXqPO3zM2hkgWeZTB1yy0z0kKbQfqA2JDSjQw/WX5uydckyTInJrwAh4S4Fm9WDzSnZFkmTBwUH5d1ZMkiYoBQeAEUugVAM11ZrcbiTFYZLMvCrFA4d+jQIdrb2ys8Y/a4++67SSaTnHPOOe7nXvCCF6CqKvfee2/V52UyGV73utfx5S9/maVLlwb6Xvl8nlQqVfLf8QZZRGw4g/717ILgFRLXSxj0ZrLEmy87VcEOMS8zWeK1pzVHyWqg6+LHj/+YPeN76Ah3cPVZV9d9fG7PHo7+4z8B0Pv2t9P+3Oc2fLjPNNSdyQKIi8ckFXEOBVKyisF6sqSS5ca3hxLNr9DiPrugNs3wVACSZRow7hCAoEpWpoAadUIverzQC7mTp4dVlCHx9fKZrFBEo61L3IRaqWZJtWI8QIy7G+Gelb/zGNucMvQdo49iyZUyvnmsxHKyBZNc0WKl4qhSFZIFwVOy1LZ2IuvEwn/eEwb9UBS49DrY8jIwC/CD18PAzhkPq6Zk9cZ6hd2wmIZlZ8CmS6t+K2kXDEc173zKjkG6MUv2pacuoz87jmaaKJEIesy5V1eIb5eQ4RcgItyD2AXDLZ7JWlhKlhfhbmWyzRXwKkpdy2CJuhkQhUOHGf/xjwGpYm0GRSGSmNt0QYnYmWcQ3rABO5sl9fNfzPr1xm79PQAFbB5VO92+PSglWZL07DWXA3BG+AidNc7fqpg6KpI9VR3al7uf9s9j6SEVVTsxSFYzXVmthmsXXCRZAi984Qu5/vrr3f9XFIXp6Wn+8R//kcsuC1by2igGBgZYsqQ0407Xdbq7uxkYqK7MvOc97+HCCy/k8svrz+NIfOpTnyqJpF91HCoakmRZUbEwDWIXXNYWTMlyy4gdlSyXqkSy5mEmyykiTiniZwxqFxzLjfHFB78IwLvOfBdd0drpQmYqxaF3vRs7lyNx0UX0vuPtszjoZw60ZAC7oKN4dthit7fWQl7OZGWNLEWr+m7rhFOA3RXtIl0wiM8mvl0i0UuPaxcMGHwxsR8sQ8RtO4pdPYynC2gOyfKHXrg7eXEFBdB6etDaZs6XeeEXcxDjHmCH21Wy8t4N+eRwkohlMVVMcyDlDfH749tHnWTBVWr10AvwlCy1o53wekGy8nuPoZIFIgXwiq/B6gtFXP/3rvJ2uh34C4kt22LM2XzqsYD7viYe9Lx/qLoJYFk2RkGcf6GoJmyvkoiONmYZPHtNF1uNCQCKS1eg5KrHt0vIGHcon8mqbxdsnZK1gEhWwrsXGXqThcTgC7/YV/HLbrJggE1UiZGvfAWKReKb+kn0F6BPqKKSGObnKF1QQlEULwDjhtlZBu1ikYl7HgAgFRfXvscHvU04l2RNTrqFxDumxNrkZA6IHsNGIQlvx4qSGUYzNeXFt58goRdwfHRlLQZflOGzn/0sd955J1u3biWXy/G6173OtQped911Db3Whz70IRRFqfnf7t27Gz1EAP73f/+X3/3udyWEMAg+/OEPMzk56f538ODB+k+aZ1hpR8mKioVYQ0pW0OALR8nKp2soWfNgF5xUxOI7qF3wi9u/yFRhik1dm3jlxtrJgLZlceTvP0TxwAFCy5ez/F8+s1g4HBCBZrKcOZA2S6jBY9PVSVYi5JGk6ULlRUvRKrpKV1eki+m86c1kNTuPBSXBF2rQ4As3WXBDzYhvP8bSRTdZcEu3L/TCUbJiulgAlc9jSXS5XVktVLIa6MpyI9yzHskKxXvYUhDP3TGyw/28v4h43FnYrdEkyaqiZE2J80Rrbye8bi1wjO2CEqEovPb7Ihlw6ih898qSa5+/kHgiP4FhC+LR88B3wMjCinNEmEYVSBULfKWzvc2FX2iqwnPjwvpzqL3P2wirMpMFpeEXETVBwdlwSMbmL8Ldswse/yRL01TXnlbU482TLLnZUFXJcuyCAZWs/N6nmXSCvZb8ibO52LcZ8MI65irC3Y/Oy18GoRC5nTvJ7drV9OtM/e42Cs7MX8FxTlQkWRMT7u/ogdEEhq0SM6fEe7VRyHmssvh2KzV5woVewLHvyrJt2w19Wgy+cLBy5UoefvhhrrnmGt7znvdw5pln8ulPf5oHH3xwhtpUD+973/vYtWtXzf/Wr1/P0qVLGRoaKnmuYRiMjY1VtQH+7ne/46mnniKZTKLrOroubgpXXnklz61hB4tEInR0dJT8d7xBKlmmtAsG2FmRvvsnJp6gYFZf7Iacm7zh7Nrkpyss6OQNex7sghNIJav+z7hzZCc3PiEG1K85/xo0tfZzRr/6NaZvuw0lHGbFF7+4WDjcAKRd0EqnsQpVzidHyYqaYvE8mq4eFa6ruku0qs1lTeYnAZHo1h5uF8EXSiuULN9MlpZmpAYZdNHgPBbAaDqLGnVCL/xK1oRTxmiKxVq5VVAiuVT8jC2NcXfUiokGgi/snM+/H+/lVCf8wk+yKilZK5B2wSpK1pT4+dX2diKOklWY766saoh1wRtuEBaikT3w369xAwv8hcTSKtgV7iT0gNMp+bxralpZ5TyWqilosnC9ybksgFMt8T552O7EkmSwhl3QT7JU25nz1VTi4erXz5BMF8y1Zvd7IaULAkRbMZcl7YJVYtxLLKQBMPJvXwLLou15zyMWcea8nPNovuyCAHp3N+3Pfz4AEzf8pOnXmfjhD1xHTZtjJatGsqSSdWS8yNO2U1sw+FgT39T5W8yIb/cpWU0kHR+vkF1ZAKljMJeVzxiYRbHDEj9BlaymzhZd13nDG94w62/e19dHX19f3cddcMEFTExM8MADD3D22WcDgkRZlsX5559f8Tkf+tCHeMtb3lLyuW3btvH5z3+el760csLTQoGVEeqS6fQCBbELru1YS3e0m7HcGI+NPsYZS86o+DgvXVBcUArpCgs6ecPOjoNlBd7JbwjODuyoKRaW9eyClm3xyXs/iY3NS9a/hLP6z6r5+Ok772T4i8JW2P/RjxA79ZQWHPQzB2p7O2gamCbm+Dhqf//MBzkkK1IQi768YZEtmsSrzNe1h9tJF9NVSZYMvegMd6KpGum8QZ+0C4ZmQbLiTdgFG+zIAhjI7kdRi4TVGKs7PKIhlayIsyAuj2+XmAslq7MRJSsqrgl+JYt4D6cdFQRtx3BlJWt0uICOQY/tLPir2AVdJaujg/A6UblcPHIEK5tF9SXZHjN0roQ3/AS++WI4eC/85C3wqm+7dsHRnEeyekwTjBysehZs+NOaLyuJSokNyVWynmz4MLvGjpIFnox0MTGyk26oSbJ6oj10hDtIFVJYVhQo0BkP1VSVWq9kLRy7IIjwi+nxvFCymg14cO2CVZSsbPDgi9zu3aR+8UsA+t7xt3DjD8UXpJI1T3ZBieRVVzF1yy1M3nwzSz7w/oaTegv795O+626Mk64EoKszAhPw+IBHaGWEu38mK2TD4fA6TjYOw9CjcPILGjvwakXEqZS78XwiKVkgLINjR9LHJGFQWgUjcR09dGL9XiWaIllPPPEEt912G0NDQ1iWVfK1a6+9tiUH5seWLVt48YtfzFvf+lb+4z/+g2KxyDvf+U5e85rXsHy5GE48fPgwz3/+8/n2t7/Neeedx9KlSyuqXKtXr2adcwNfqHCDL2QZcQC7oKIonLnkTG49cCsPDD5QnWQ5N3pLCWMDRiWSJZUs24LcRM0beNNwVLIRS1gi65UR//TJn7JjZAdxPc57z35vzccWjxzhiCwcvupKul65WDjcKBRVRUsmMUdHMcfHCdUgWWp+goiukjcsRqcLxLurk6yB9ACpQuWwGX+yIMC0P8J91jNZjpKlFpnITlM0LUK1hpubIFnD+b0Qg1WJk0sqBeSNJjQp5iVDVeyCsisrNZzFNC20FgxfNxJ84Ua450tJllSydo/vpmAWCGthN11wWdsynthXYKkyhooFWgQSlTfW3Jmstjb0ri60zk7MyUkK+/cT3by56Z+xpejfCq/5b/jOK2D3z+AX76fngrcBpUpW77Rj06ujYoFv9sZ/jWuyKwuguF8sFA+1LWFqfFCQrBp2QUVReNWmV/F/B/+PJaGTgUdrWgXB29jLt6wnyzuWhQB/+EXzSlZtu2BJd1odDH9BbBh2XHYp0SUhMS8aboeO5c7xzp+SBZC48AJCy5dTPHKEqd/8ls6XvqSh54//6EfigxVrAejricF+2DM4hW3bKIpSMV0wBBR7N8PAH5pUsmR8+9qST1tTJ14RscSx7Mo60TuyoAm74Ne+9jW2bNnCtddeyw033MBNN93k/jeXRb/f+9732Lx5M89//vO57LLLuOiii/jqV7/qfr1YLLJnzx4ymdbt8h6vcEmW7MkKEOEOcNYSoe48OFS9KNBVxRQFSw1jVvp96mFxAYe5mcuyTMhOADAUQMmazE9y/fbrAXj7GW+nL15dHRWFw3+HOTFBdOtWln70oy077GcatK4kUGMuyyFZSnac7kT9xXx7qHZXlj9ZECizC5bOZOWffponn/8Cxv/7v+v/IIleYrZNVO6m69OM1rMMSpIVsIgYYNIW80UbOjeVfN5NFxwWN/jwmrUVn9+WjKCHVSzLZmqkNTdEN8LdCTuwLZtbv72Lu34yU0FRZRmxX8lK9LDSMOlSQhiWwe6x3WSKGdfauTyxnLF0gVVusuDKisq3bdvuYlVzLNrh480yKLH22XDl1wAF7v8GPQ+JBeFEfoKhjLC195oGrLkI1v1J3ZcruFHdfiXLsQuO7wMj+KyElclgOGFQh9r6sGQ6YY3gC4Crz7qamy6/iUJRLHa6aoRegLexV8yZWNbsC6Pla8yFKWIu4I9xlzbXhiEtadkxyM+85gVNF8w+9BDTt90GqkrvO98l7KwgQi8c0ipnsoyihRGgeHy2UFSVziuvABoPwLAKBSZvvEm8zkpxDVjWl0BVRNWETH917z8TE25PVshW6FxzhnihoUcbP/CqStbUCTmTBce2K+tED72AJkjW//t//49PfOITDAwM8NBDD/Hggw+6/23fvn0ujhGA7u5uvv/97zM1NcXk5CTf+MY3aPMlcK1duxbbtmvOW9m2zctf/vI5O8b5gi1nshS5sxJMkDy7X1gtHxx6sCRu2Q89rLrt6YYe9YpHy+FaBueAZGUnAHHTHSiIC0AtkvWVh77CWG6M9Z3red2W19V86cFPfpLcjh1onZ2s+OIXS8oNF9EY9C5xDtQjWWTH6XYW87Vi3GXCYDWS5U8WBEiXBF+UpvGl77qL4uHDroWmJuK9KFDSlVXTMpif9oaqezZUf1z50xQRonOKbx4LvBuNPizmKKrZBRVVcRMGxwdakzAogy8k+R3aP8Xuu47y4G8OYJml1wgl4gRf5EqVLAU4FfE+2jGyw53Hag+30xZuYzxTKC0irgA7l4OiIHqaUwUSXi8cB8c8YbAStl4Ol34GgOTvP4uCsCw/OfQwAH2GCc/7cKAhI1fJ8pOs9qViI8s2YSz4z19wVCw1mURp76DDdlThgG4DeR7Ui7/2b+z5gzuahbQLLpShrIhDWop6HCvdJMmKdnjk98jMjc+S7rQaGPrCFwDofPnLiaxfB8OSZHnqbyiquVbM+VKzkq94BSgKmXvvdc/LIJj69W8wx8fRly7FTAhLYFtbmLU9YsN1jzOXJZUsO5/Hsh3Vz4b1pzh9WsOPi6qNoDAKkHK6XmfMZE2ekOmCcGy7suQG44nakQVNkKzx8XFeuWivOqaQZcRFRVzog0a8bureREyPkSqkeHKistdfUZSSuSw7W+WNN5cx7pK4RTpJOWvyanbBPWN7+MGeHwDwofM+REitvjiYuOl/mPjBD0FRWP6v/0J4ZbDo7UVUhltIPFaHZJkFlsXFgr1WwqDblVVHyUpGkhQMi4JpkagSfGGOinPIGBmp/4OEohBu9yUMTtUuJJYqVrzX+xnrIFMoQETcwM9aus39vG3bXvBFYQKtu9slGZXgzmW1KPxCxnTLmayDu71Nk/JQA0/J8gdfiEXiNkMskneM7HCtgssTwqo0Ol1gBbWLiE3HKoimoThxzRHH1n1cJAxWwvl/DRe9Bx1IOufOniN/BKAnuRbWXhToZSouphXFU0kbiHEv7NsHiN/d8zf3ksQhAHWULAk3vr2OXVAPaai6WLS3Yi5L2gXVBTSTBY5dcDalu5sdG50srPahUIl8lyF9z71k7r4HQiH6ZP3IsJPILNVQxH1dHvNcFxJLhJYvJ3GReA9M/OTGwM+b+IG4nydfeRV5J10wHNfZ2C+ui3sGHFtxIgFOoNloSpznPdEQvSs3ihldMw9jTwU/4MmDgC1qOdpKQ9ys1JRbRnwiBV/Ase3KOtE7sqAJpXvhOAABAABJREFUkvXKV76SX//613NxLIsICDfC3RZv9qAeYV3VOb3vdAC2D1ZXHcN+klVVyZrDGHc3EUsUzkJlJcu2bT557yexbItL1lzCBcsvqPqSuV27GPinfwKg9x3voO3ii1t+2M80eIXEVUhWOAGaWMSviArSUtMu6JCsajNZE/kJwOnIcs6LmBt8UWoXNMYbIFkAiV66gxYSNzGP9ejwXhS1gG2FOKXXU7/yaQPTEAQ0kk9VjW+XcLuyWhR+kSyzCx7ykazyHW/Fncny/W7ivQBscxIHd47sdGsiZDffeKbgKyKukizoFBFrbW3uXI7blXUsC4nr4fn/CKe/1iXo+5yEyN6tVwR+iaq2sCZi3CXJCq9dy0s2JdAUwV7sgJsBkw7Z7krUt++0MvzCDb5YGBzLTRcUwRdNKlkAz3KI0e6fz1As3ZmsKvY027YZdipqul71KkIrnE3DYed86SudY3TnstLzo2QBXmfWTTdiG/W/b/7JJ8ncfz9oGsmrrnLPrUhMZ+NScX94YlD8vv1zWSPjwp68rC0qPKdLnIqMwQYsg+481uoZJ6K/jPhEVbKORVeW2xF5AtsFA1HyLzopbAAnnXQSH/3oR7nnnnvYtm0boVDpjte73/3u1h7hImbAymSwgaIt3uyNlBWe1X8W9xy9h+1D23nN5tdUfEwoqsNkAUOLouRzWJY9c4cxNodKlnzNeA9T49VJ1i+e/gXbh7YT1aJ84JwPVH05c3JSFA7n8ySe8yf0vv1vW3/Mz0DUnclSFKH0TA+yNJQFQjXtgnWVrJynZE07JKtDlUpWqV1QKlnW1BRWLlc/3SrRS09W3Kjr2gXdeazgJOvBQZG8pxZXENK9c3laJgvqJqptVI1vl+hqcYx7l0/JKuQNjj416X6tfPFcU8lKTUCig/2p/ewaE904rpKVrm8XNFOCWKu+yoywq2Ttw7YslONxYEdR4GVfoue7z+ZJshjO4qx35bMCv0TVgAOXZAVXsvKO6hdeu5aLlovf17Qd5emBHNtW1t8tHnfen511lCxxvDrZqWKLlKyFli7ozDiFZtGTBbBkM2x4Pjx1q1CzLv20+yWpcFYbB8g++CDZhx5CiUbp/RsRvoJleqS8b2PJ46OJEJNk56UrS6L9ec9F6+7GHB5h+o47aP/T2kmb4z8U843tf/o8Qv395DPC+hiJ62zsF9f4Pf4Y985OzJERRsZS9NJDnzxv+7fC4fth6DEg4IZHlXksACuVwoyemOmCsivLyJtMj+Xdjbz5gHRxnMhKVqDV+ec///mS/29ra+P222/n9ttvL/m8oiiLJGseYGUyzq6Ks+PbAMk6e4mYy9o+uN1N6SmH3y4YMQqkCwbt0bKbrlSy5mQmS7ymHet2FYvyMuJ0Mc1n7/8sAG897a3urnk5bMviyAf/nuKhQ4RWrGDFddcdn4u1BQi925nJmqhVSCxJVgbodBdxleCSrGKVmSy/klVwzgutIMb3yoIvjDGP/Bsjo/WtoYk+eqbF4kTRphmZqhF80YSStWtUEI+YVUoy3AhbW5CmUJV5LIlki+2CcjFtWjZ7d49hGV6IQb7MVlRxJishlKzO3ASr20/hwNRBfnfgdwAsbxMka7yEZFW2C8oYbLXdI8vhlStB17GzWYzBQULLKr/Hjzm0EN2rL4IDv3E/1RvrDfz0QrXZG7crqxG7oBOesm4t0aIgzON2O7/ceZRtKzvrPl/aRpN1ZrLAU7JakTDolhEvGJLlKVnm9ODsXuyCtwuS9eB3xBxfVPydKkb7+zB9+x0AtL/gBeiyCmdiv7DJ6dEZc0WSGM7XTBaAEg7T+fKXM/aNbzDx4xtqkiwrm2Xypz8FIPmqV2NbtntuhWM6m/qlkjUzYXAqlaI33ENS1oP0nyr+bSRh0FWyZpIsM5XCTJyYwReyK2vsSJrUaHZeSVYm5QRfPNPTBZ9++ulA/+093lKgTlAIkiXe8IqqoIeCk4ZtfdvQFZ3BzKA7O1EOaT809ShRs+iqBiWYy5ks5zXNaBdyHrpcyfrPh/+T4ewwq9pX8aZT3lT1pUb/8z+Zvv12lEiElV/6ontRXsTs4c5kVVOywJ1Z6tFEUEOrlCyXfKtVZrJ8c2LmyHD145OI9wQPvnCLiIMnCz6VEjuynfr6ks+7HVkOgQyvrq1kyRtgbrpIbnr2O9LRkEbUuX7s21n6Xi5fPLtKlp9kRTvBiaPflhSkQM7OLUssw7RsUtk8yxXntTurzGQ5JEtr95QsJRRy7ZP54/ze0pMorTBohGQVq9oFfSSrSom3H7Ztl9gF5XV0nDZu2TlQtQjcD2kbrZcuCF74hSSJs8FCKyP2R7jPyi4IQsnq2wyFadj+HffT9cqI03/4AwCJi57tfVKGXvSeDGrp87wY9/lTsgCSV4muq+nbb6c4OFT1calf3oKVShFauZLEsy+kkDdl/hWRuM7a3gQhTSFdMDk8IdR0eT8PFZ1NKpnatcQJFxrcGfxAqyhZtm1jTk2dsBHu4A+/mL+5LP888mK6oA8f//jHK8akZ7NZPv7xj7fkoBZRG1Ym43VkRbWGukVieoytTrpZtbksuaNqahEiZoGpSjdRl2TN3UxWIZz0vp2vqG7v5F6+85i4GX3ovA8R0Srvgkz//g8Mf/FLACy99lqiW7dWfNwimoOWdGayqgVfgEuyuhVBssYCkKzpQuVFiz/CfdpZgLQpzuuFyoMvfErWaICNgERfMJJl2zDqDFMHVLIs2+JwRqhf/eHSNEJJssJTggjWswuGIhptXeJ8b5WaJRfUg09MAFRNIVOiFZQsVXP/xtsSK0sev7xtOROZAn32OCHFxFZ1aK+sRkklS+soDf2QCYOF4zFh0IeemBcsEVJDblJmEBSq2QW71wsCm5+E6eqLUwlzbAwrlQJFEeTUcQRM0MHekTSPD9YnA3Jmsl7wBXg2tkK2demCC03JmrVdEASzlLNZ9/6nm4jnKpwVrPLG2Bi5x4RK0/bsSiRr04znyBj3+bQLAkTWryd29tlgWUzWqPkZ/6ETePHqV6GoqksGtZCKHtIIaSrre4XS/bibMChUv2hRkC5DJl32nyL+ndhfMR6/IqooWXYmA4bhVuacaMEXcGy6svIZbx75RJ7JaphkfexjH2O6wkUlk8nwsY99rCUHtYjaECRLDKE3YhWUOKtf9GVtH6pCspwdVUOLEK1GsuRMVrbGArtZOIuDfCgJQFtEd2fCbNvmU/d+CsM2eM7K5/AnKyv30BQOHebI+98Ptk3yla8keWXwQfRFBEPd4AtwF+AdTspZELtg1eALX4S7G4iizCwjtotFzElvtsgYDhB+keil2ylWV7UaJGt6EApTYvHbHazU/ODUQQpWBtvSWZ5YW/I1SbJkEXG1+HY/Wh3j3hkLEbNgekAsVJafnAQqzWQ5wRflYTgy/CJa2k+3LLGMMZ9VUOlYDlrl65VUstS2UpJ13CcMOuiJeiSrN9bb0MZX1dkbPeIt+AKEX0gVK7R8uZhBdJSscLs4tl/uPFr3NaRdsF6EO3j3nlamCy6UMuKoL8K96TJiP057lbDgTx4QJdd4Cmclu2D6zrvAtols3uxZBaFifLtEJDG/hcR+uAEYP/kJtjWzPia3axe5hx+BUIjkFeJe7Q+9kJDhF3sGnE49R8mKFMW1sCg7wOLd0LZUfDy0O9hBVuvIcq5Npn5iBl/AsenKcq3yCR09dOL9TiUaJlnV5ngefvhhuruDdXEsYnawMhmviDhgR5YfspS4upIlZ7KiRIwCU7kKO19uuuBc2AUFycrqYpcq4bPR3HrgVu45eg8hNcTfn/v3FZ9u5fMcvvpqzMlJoqeeSv9H/qH1x7gIdF/wRVUrkkOy2mxxo2rWLpg1suRMcQPoina5FlY3XdA3k1VuXwyUMFiiZE0xUi1qXs5jJVeLRXAAyHksK7+M3rbSAI60E2EbyU+idXW5Rby1MBfhF6sMcSvoXp6ga6n4XZbbBRWnU87OZkv/3s61YJMSRVfF9SiqRemOdjOarp8sCCIiGSooWesWQMIgpUpWI1ZBqL2Ydi2DAWLcS6yC4F5He5aI2bhbdg7UfL5t20w4SlYwu+AcpAsukHFZqWSZegxzugWbHaEYnPNX4uN7voJt2T674Mx7vLQKtvmtguDFt5eFXgBE5UzWPCtZAB0veiFqWxvFAwfI3PfHGV8f/+EPxeMueQF6j3gvSTIof9cAm5zwiyccJctuF2uEeEH8DYyCj8D1O86VIKXE+WnIyLnRMpI1KTb9TCfB9kSbyYJj05WVeQaEXkADJKurq4vu7m4URWHjxo10d3e7/3V2dnLJJZfwqle9ai6PdREOrEwa01WyGn/Dn7nkTEDY7uScix9ehHuQmay5swtOaZJkiYts1sjymT+KAtC/PPUvWdVReb5j8P99gtyjj6J1drLyC9cvFg7PETRnU8UuFt1agRlwSFbcFDfFyWwRw5y5kwnQEapeRixVrJAaIq7HfRHuM8uIy5U1I8hMVqLXI1lanvFsuvJxNjGP9diYsPWYuRUzFq/uTFZhom58u4Qb496yrqwQaw3xnl+5ucuL5s5UVrKwbeyib6GWEIuiSC7F5i6xg740sRRFUcpCL6r/fOaUky5YrmQtFLugT8nyE64g8CLcK2yYNZAwWPAlCwKuI2DV8hXoqsLugSmeHqlOCDIFk6IpyE4jwRfPxHTBsG/h37IZp3PfIiovDt5L8en7ve9VRr5t22b6rjsB3B4q5wu+ZMHqSlbuGChZajxOx0v+DICJG24o+Zo5nSb1vzcDkHy1l3gsSZbfrXOy7MpySNZhS1xPk6ajZPmLsd25rADhFxMHxL/RToglS75kOdcm6wSeyToWXVlpGXpxAlsFIWC6IMD111+Pbdu8+c1v5mMf+xidnV5SUTgcZu3atVxwQfWeokW0DnYm6ylZTdgFk9EkGzo38NTkUzw49CB/uro08SfQTJZrFxwTF/dW2jycxcG0Ii6osoj4Gzu/wdH0UZYmlvKWbW+p+NSJn/yEiR//WBQOf/azXnfIIloONRZDiUaxcznM8TG0tsTMBzkkK1KcRFHEqTKeKdLXPpP4SiUrY2QwLMNVRaB0HktRFJdkRS1n583Xk2WWzWAFUrLivXRYNiHbpqgooE4zli6wpKMs+r2JZMHHRsVN3sotr06y8pOE154Z6PXcQuKWdWWFaXOUrFWbuxlzbIgzgi98Mfh2Ngth52fxdead2nsqO0d3sqJNvO+EklU7WRBwwwNmKlmCZBmDg5jT6crn2HGA7qjn4uiL9dV45EwU8zJdsJKSFbwrKy+VLOd3Jl0G0c4+LtjQw++fGOGXO4/y9udWPnelVTCsqcQC2Hfk8eZbEHwhHWQLxS6oaSqhsEqxYJHP21UdPg2hvR9OvQoe/j7Fu78JXIWiKmhlwVb5PXswh0dQYjFiZ53lfSF1WIRnqLqY5yvDsVSyAJJXvZKJH/yQqV//GnPiH1yrX+pnP8PKZAivW0f8vHPdx1dWssT14cmhaUzLZk9G4UxgiZ1hCjAKPpIl57KGgpCs2smCIMYn4MRWsmRX1nzY9+S9b1HJcvCmN72Jv/iLv+C2227jb//2b3nTm97k/vfa1752kWDNI0qDL5obwnTnsipYBuVOjaGLmazpWsEXlgH5yjM0TcNZHKRUoWwkIjoHpw7yjR3fAOAD53yAmKPk+ZF99FEGPibCV/re/a6ZVopFtBx157IckqVkx91h+mqFxG0+Nao8/MJNFowmxdedHcuIPXMmyxgtVVfNQDNZfSjgFRLr0wxVKiRusCPLtm3XLmhmV9DtK3k1TYvMlLQLThAKqmQ5dr7UcBaziirYCLpshaSlYiuwfGPSi+YuD74IhcDp+CqZy3JJ1ggvXPtCwmqYi1eKsu/xErtgdZLlKlntpXZJrbMTzbEPSTvc8YjumEeyGrUL1ozqdhMGg89keXZB5z0Z7+bSU0XgSC3LoJyXTMZDgQiDp2S1IPjCUbIWUruGG36hhLHzNdJIG8EFIgCjsEfEs1cKtnJTBc87DzXs27SR81jdG0CbqUTK4z0WShZA9JStRDZvxi4UmLxZzJ3Ztu1aBbte8+qSn7XSTNaq7jjRkEresDgwluGRlKO8FsX1o7KS9Wj9dM4aHVlmKoWNgqmI3+mJGHwhu7IApsdadC7XgbTKxxdJVime85znuAXEuVyOVCpV8t8i5ha2bTsR7s0HX4BnGawUfhHy2QUjRpGpSnbBUMxTD1o5l2Xbrl1wzBaL7kRE5zN//AwFq8D5y87nkjWXzHiaOTHB4XdfjV0o0Pbc59Lztre17pgWURV1C4kdkkV23CUYo1XmnXRVJ66Lc6rcMuhXsgDSeQMFi7BUsnwkyxwX54++XCwsgylZYiFfN2GwQSXr8PRhEeRha1j5frp8JCubEh1fim0RKk7XjW+XaEtG0MMqlmUzNTJ7e0f7pHh/5zp0wlHdjaeuZANTfXNZLpzgCzKjnLv0XO55/T28fsvrgWBFxODNZPl7siS88Iu5n8sqHj2KbTZOGiJahPaQ2GVvdiarsl3QIVkTB6FYfV7CNk2K+4XlySNZznU51s0LT+lHVeCRQ5McGq+sgE420JEFczSTtUCULICIG36RcNMxZ42l22DtxRSs6qrJ9B8qWAXBF3oxM1nQf7zzHeEuoSiKF4Dx4x9j2za5HTvI79ol+rQuv7zk8fI4I77zUVMVTloirhE7D0+yfcJJp8tMAGCZtrfx1LdJDPllx0RgUS3UULKsVApT867bJ2LwhezKAkjN01xWZlJ2ZJ3YdsGGSVYmk+Gd73wnS5YsIZFI0NXVVfLfIuYWdi4Htl0S4d4Mzu4XpcS7RneRKZbedL3gC5kuWOWi7O5gtzBhMDcJtlh0jFviYmqHDvJ/B/8PXdH58HkfnnEjti2Lwx/8IMXDhwmtWsXy6z69WDg8T9C7xA5+1a6sCiQrSIx7qli6YeNPFgRBsqL4XqeCkhXdKBYbxshI/Y4gPQzRTnpMf8Jg2XGaRRjfJz4OOJO1a0yoWHZ+KaDT7bMLTkuroDGFgk14bTCSpahKSxMGQ8Pi5xxvE++rakoWgCITBv079/I6kBZkKqR6i6LxdL5uETGAOT2zJ0siPE8Jgwd//Ct++J6b2fWF/27q+XIWq+GZrFp2wXgPRJOArzqgAopHjmAXiyjhMCFnc8Etio/30NsW4dy14r1aTc2acBa1yViwRY9LslrRk7XAyojB15UVimPOtivLjwveQdES77NQpPQ+ZmUyZB94ACjrxwJf6EVlkhV1SZbhktr5RudLX4ISDpN//HFyO3cy/gMn8OLSS2d0WLpFxPHSzYeNjmXwhgcOMayK35M66bkX3PCLUEyoeiDUrFpwlay1M75kpryOLEWhoV7ShYT57spKLwZfVMYHPvABfve73/Hv//7vRCIRvv71r/Oxj32M5cuX8+1vf3sujnERPlhOR5kb4d6kXXB523KWJpZi2AY7RnaUfE3uqBrOTFZFuyB4C+hWKllyYRBKkDIk2RN2ozOWnMGG5IYZTxn5yr+TvuP3onD4i19A880LLmJu4dkFJyo/oBLJqmIXhOoJg1LJSkaSAEznDRL4Fvo++6g5Js7HyEahAtj5PFY6ABmJ99ZWssb3C3tsKF6176kcch6rmBUzSl0Jj4DIdKWwc84HDb4A31zWLMMvbMumeFTsXB527nVyUZPPztxckXNZJUpWwpvJKocxNURUKWKjQMfKGV+XqJYuCBBe7yQMznH4xeO3P8Vk8iSe2FP9/KyFV258Jaf1nca5S8+t/2AHpmFhGWLBW3HDTFECWQZdq+CaNWKDyba967Jj7b70VBFpXY1kuR1ZQZWsaAuVrAVWRgye/a6ox7HSLSRZJ7+IQpvYWAibpZtX6fvuwy4WCa1Y4SmWEjVCL/zHiz1z3nK+oHV20v6iFwEw+o1vkPrFLwBIvubVMx4rg3ciZW4dOZd1++PDTDmpsqpZcM8dw28ZdBMG68xl1ZzJmnRJVijSWC/pQsJ8d2XJCPdFu2AZbr75Zr7yla9w5ZVXous6F198MR/5yEf45Cc/yfe+9725OMZF+CBJluns3DdrF4TqUe7+CPeoWWQqW2XRIXewszMXV03DN0cgbYqKLhbIUsXwY/qOOxj58pcBWPqxfyK6ZUvrjmURdeGSrLEq54AkWUaOJTGxkBqrFo8ObolrOcmaoWQVDGKyIyuUKBnmMJxy5NDy5agJ8T4xhoMkDPb5ZrKmGCmfyZIx2t0bAg+PuPHtueWENIU2nyXMVbLyE2jJZEObA27C4CzDL0YOT2PlTArYHFBKFzXl6YIASlTcECvPZM3cbAlPHwIgH1si1MIqcHuy2meSLC9hcO7sgrZtkxmcEN+nSWXmjae8ke9d9r2GioilVRBqDNS7JKt6wuCMZMH8lNgQADek6MXOXNYDB8YZSs1cSDVuFxTH+0wsIwbPfmfo8dbZBQFUleK6ywAIZQ54qSBA2mcVLFns27anZMnzpQyarrpzN8eiK0tCWganfnkLdi5HZNMmYmecMeNxuQrBF+ApWQCGqmNGYiiAHhK/j6I//GKJE35RK2HQtmvOZFmpKUy3iPjEswpKzGdXlm3bZCalkrVoFyzB2NgY652dxY6ODsacxdVFF13EHXfc0dqjW8QMzCRZzb/pJcl6YOiBks+7M1lOD1AuXcWj68a4t1DJ8u2+ygQ5WxU/s1QxJAqHDnH4Ax8UhcOveTXJl7+8dcexiEBwZ7ImqtgFI+0i7QpYHhbnUbXgC2hEyTI9JcvXkQVeumAu1o3au0R8LlBXVq9rF1QqFRI3EXohlSwZ3+5fGLlljPlJQgFKiP1oVVfWoV3i93pQtxiX6XKSZOXNGbYiNerYBUtmsrzgi/IB83hGFOCa7dVVLLtYdJUxrQLJcu2C+/c3NS8VBMXDRyg4wl2hqNS3l7YIktBpIRVVq3I7lgmDNbqyMg8+CEBks2MVkxtfesx9fyztjHLm6iS2Db96dKaa1UhHFpRGuM/297XQyogBojL4olWFxD4U+88DIGyMweO3uJ93Qy/KrYLpEciOA4p3vtQ45mM1lwUQP+/ckutd8tWvqvh3lwpp+UayLCSWUJ3NKd1ZCpUmDAboysqOi4J5qDg3aqZSXrJgk86hhYD57MrKZwxMw5mnWyRZpVi/fj1PO7tmmzdv5kc/+hEgFK5kmad2Ea2H7CMyQrOzC4KXMPjI8CMULe+iG/ZFuAPkq5UtxqvbhJqGXBzEukk7sr+BuAD6SZaVy3H43VdjTU4SPe00+q+5pnXHsIjA0B0lq+pMlqK4alZ/SFy8mykklumC/pmsODOTBQGMsTFGuzZz4y81Hl9xqfhcYJLltwuWHWeDoReDmUHG8+OoioaVX1qSLAhehG24MEF4TbB5LIlki+yCh3aL99t+3WQyW8SybM+eY89UdVy7YMlMlhP0YBZEhLQD27bpzB91DrhGR5Zvgaq2zQy+CK1YgRIKYefzFI8eDfyzNYLs9gco6o7qqYQwJybm5PuUwyucrbFZVifG3bYsMnffA0DiggvFJ8usghLSMviLHTNJ1riz8O5sMPjCsmyM4uxSLhdaGTF4M1nFUMytIGgVCob43YaULNzzFfG5Q4eFLVTTSDzrWaVPkCpW11oxi1TnmHPHKMYdnACMK4WapcTjdL7sZRUfVynCHWB5Z9R1BHTGQkR7xD1B08Q5VMz7zkWZMDi8B6wqGzRyzratv+LvTgRfnLjx7RLz2ZXlVpck9HmJiz+WaPiS9pd/+Zc8/PDDAHzoQx/iy1/+MtFolPe85z184AMfaPkBLqIUM2ayZmEX3JDcQEe4g6yRZc/YHvfz0i5oaFFsoFi1aHYulCw5rO3ZBQ0EyfOTrIF//mdyjz2G1tXFyus/Xxplu4h5g+YEX1SdyQKXZPU5ts+xdPWIWDf4olAWfJEXry/PgXTeIK44rxMqJVnm6CiHVzwHgKHIWgCMIDHu9WayRiTJChZ6IVWsJZE1YIdqd2QFTBaUkCQrN10kN93cgsksWhx5YgKA/SELy4apnIEWUt3h7hkx7jL4Iuu7EYfj3kxc2vs9Zwom/fYQAKGe6j+f5aTSqvE4ij7zeqZommuDmyvLYGb7dgwnLdXQYxQPHZ6T71MON7691uLNtQs+WTGKOr97N+bEBGoiQWzbqeKTPtu1HzLK/d6nRxktO78bDb4IhTVwBIjZzmUtyHRBn5JlTbfQLoiPfKt52Pd7OPqIq2LFzjhjpuI7UjtZUCKaqB5qM5/oevWraHve8+j/4AfRKmysgDcTGikj/YqicHK/eM65a7vRHTeFrjibsn4lq2udmKE1cjBW5dpRYx4LhJXZPIGLiCXKu7LmEp5V8MSex4ImSNZ73vMe3v3udwPwghe8gN27d/P973+fBx98kKuvvrrlB7iIUlhZxy6ozv5NryqqG+X+wKBnGXRv+IqKpYYoZqrZBediJkvuwPa4dsG8JRZhUsUY//GPmfzJjaCqrPjsvxJavrx1338RLsyixc47Dte0pNWdyQKXZHU7ts+xGruobSFx86ynZE1XUbKsfJ5cAUa7hRc/Yyco6omASlZfMLtgQCVLkqzesLBXV1OyIvlJwg3aBUMRjbYucQ1oVs0aeHoSo2gRaw+RiYpbgbRyeuEX5UqWE+GeK7smJGSMu3cejPni20Pd1UmWTGZTO6rPMs11wmD2ge0UnfoAU49RPHJkTr5POYo5mSxYY7Osa62w3BbTkJp5XOm77wYgft55ossMSuLb/VjVHeeU5R1YNvzmsdJY68mstAsGU7IUVWlZ+IVrF1xQM1le8IWZai3JkgpyaImTyHnPV0jfKUhWxf7HOvHtEpFjXEgsoXV2surfv0JXhcALiWrBFwDnrRPn9fO3LHFTCTVbPL6kK0tVvSCQagmDNeaxQNgFTf3En8maz64saZU/0eexoAmS5Ucul2PNmjVcccUVnHbaaa06pkXUgC2VLEWcnLOxC0LlUuJQ2LuQmFoUs5qS5c5kzZVd0OnvscQNrDPSSXbHTgb/+f8B0Hf11SQuvLB133sRJbj9B3u4/ft7+MMN1WdB6vZkgUuyOm2xmK6lZMnQgOky25lUsroiXdi27dgFZ85kmWNjDPWdha1653CqfVXDdkFVzzCWzmLKmaRcCqYdi1XPzITLSpDx7W3KWnHsidLFqyxjjDRhFwRmHeN+aLf4m63c3O32d03I3eMq4ReKnMnKlf0NK8xnjqULrHRIltJVoyPLKSKuNI8lEXbCL+YiYdCcnCT/xBMYDskytBiFeVayam6WaSHoFkS9kmUwfeddACQuuMD7pC++vRyXbRNq1i/LUgYbtQtC68IvLFfJmtXLzCvcCHc9Tvree1r62jIQJbRO3J/th28gfZcg0zP6scAXelGHZDnEMJc+tkpWPViW7b43yu2CAO95wUZ+9LYLeM25qzyS5Yw8lChZAP1O+EW1hME6SlaJXfAEnsmaz64sj2QtKlkzYJom//zP/8yKFStoa2tjr2Pf+OhHP8p//dd/tfwAF1EKK5PBRsFw2sdnYxcEL/ziwaEHvRhdVXF3bAwtAvkchlnBcz8XJMs3SzDl7OZlDEfJyukcvtopHP7TP6XnrW9p3fddRAkeu/MIu+4U8y+pGoW3cibLnJysHkrgkKx2Z7ZuPF2sOihfaSZrqjiF6XSnJaNJckVhbXPtgmHPbmKMjjHgDI1ruri8TbWvwRgNRrKSloVj7cfW0oxKQjjmdBQl+iCWrP9aeEpW2BS70X67YDFvurv/wi7YmJIFsw+/OLhLvG9XbemiMyauJ1LJilRVspyZrHIlyx9+4WBs2teR1VljJqtGsqBExAlbmgu7YPahh4Qt2lFEbVUjf6RyzHmrUZQdWZWKiP2QFtWyhEErnycje5Mu9JEsn+26HC925rLuemrETRSExu2C4Itxn21Xlu/es1DgRriHEmTvf6ClGwAu+V6yGlY9i+ywgpVOoyWTRLdunfmE4drx7RJRqWQdw+CLIPAro5XWONGQxnnrulEUxSNZprhWlyhZ4JGsekpWhblR2zCw0mkv+OIEVrJg/rqy5AZjPLlIsmbgE5/4BN/61rf4zGc+Q9g3B3Pqqafy9a9/vaUHt4iZsDIZd1cFZpcuCHBKzylEtAjj+XGeTnk3CTfGXY8SNQtM5yvcRKUVpaV2QW8HNl0Q33PamESxbCL/798pHjlCaPVqln/6U4uFw3OE4QNT3PHf3o55NlU9qMItkLRtzFSq8oMckhU3xWK6YFqVzycqz2TJ+Pa4HieiRdznVrILjh8YJdW5HmyL054nEu1S7asxA85kqUCX3FXXphiZcn72BuexhjPDjGRHUBUVKyeUAz/JklZBzcwTbovMKOIMAjfGvQmSlc8aDO0Tv2OhZInF12RGJgx6xaV+KDFxEy6ZyQIv/MKnZE1NjNCuOGSss0ZH1pQsIq6hZDl2wfy+1itZmQe2Y6khbMVbzGUOD7X8+1RCICULqoZfZB98EDufR+/rI7zBp7BWsQsCbOhrY2N/G0XT5tZdwjJo27ZnF0wEV7L8CYOzgUwpVxcQyZKExYyK83bihhta9tqSfIejOlzwdqaPint+4oLzUbSycyU74ansNZIFwadkHeOZrHqQ1x09rLqbZdUgr52qIa5JbhmxhAy/qKdkVbALyg2gZ0LwBcxfV1ZmYtEuWBXf/va3+epXv8rrX/96NN+b/fTTT2f37t0tPbhFzISVzmA4/mBVU+pegOohpIXY1rsNKLUM+hMGI0bRVZVK4LcItSryOCssTHasS9gFlSJ5M8cr/2Bh3nM/SjTKyi99Ea3G/MYimkcuXeSWr+7ANCyWndTpfs6spGQCSijkztJUtQw6C71QfoKYkyQ0ViVh0FWyip6SJePb/cmCAEnNeY2QZxd88lFhneuzB1h7mlBXptrXBJ7JAug2BdEoCb9w57GCWQWlirW+cz2prFg4+mey0r6OrGasggBdS6VdsHGSdXjPOLYtiFp7d9RVL2SMd8S1gZUpWRGHZFVVsjySZYyJxcuU1jUjZt8POc9SS8mSJMscHqlO5ptEdvt21yrofm6ohv21hXBtYXVJlhN+URbj7lrILrygNDSihl0QvM4saRlMF0yKpriGN6RkxSorno1iIZcRG4SwFJXJ//kf7EJzRdblKDkvNr+E9LB4byRWVbjfS+LdsQKite+Lx8tMVj24Kn8Ap47sF1QL4ppUrGYXHHsaCmXWasuCiQPi4wp2QRnKY0WEW6Lu+3SBY766stKLwRfVcfjwYU46aebgt2VZFIvH9xv3RICVyZQkC7YijaniXJZrF4wSMauRLOcGbhZmXryahbNIK4S7KJo2ipZh5bDNVXeKm/Cyj3+M6KbavvNFNAfbsrn1W4+RGsnR0Rvlsr85zbXvZFPV39vuXFbVQmLxdbJjLtGoRrIqlRHL0AuvI0uci5268xrS5mXbPH1IXNJWx4fpXdUOCuSjXaRTBWyrMlF04Wwa+BMGnxp2ZsPk4rbOTrHEY2OCZG3p3uIGfXT5SZbjSQ/nJ5smWVLJSg1nq5LgavDmsQRxlQW0ci4nLBdj2cpKlj1jJsu5FvjSBZk8KI4vsrTmsbhKVkd1kqW1taH3CRLcyvALq1Agu2MHxbKEytzI5Lx0ZbmKRT27YJVCYjf0wj+PBVUj3CVklPsdjw+TzhsuuQ7rKtFQ8GVBuEVK1oIsI/bNCtn9KzHHxpi67f9a8tquwhnRMSZT5Jy3VaJwx8wNTTmPVSf0AkS4ARz7dMF6kHbGSABV1VWy8mINYpTbBRO9kFgC2DBUJgRMD4j1i6JWVNvlBpAZdUjWCa5kzVdXljuTtWgXnImtW7fy+9//fsbnb7jhBs4888yWHNQiqkPYBcUboVVxomcvORuA7UMzSZapRYia+cr2rlAcpHWxFTHutu3aBTOaWGwrWprVw+KmEjvjjKqdGouYPR741X727RhF01Ve/NfbiLaFiLWJm1x2qvoOrZ6s05Xl2AXJTtQlWZVmslySFU0CnpLVrpWSrMGnU0znQ2hmnlV9RcJRna5+Z2cuvqJ+95EWgliXmzCoatP8z0NOmluTyYJbe7Yy7vys3T674LRUsgoTTc1jAbQlI+hhFcuySQ03dlOU/VirNotFuCRZk3WCL9wy4hnpgjM78/TUIfGpeO30T28mq/YufNiZy8q3kGTlHn0UO5/H6uov+XyxaLu72HOJQmAlyznvUoch7yz8JifJ7dwJlIVeQNUId4nNS9tZ2xMnb1jctmfIncfqioca2riT9yD5czSLhVhGrGqq+3eLvVjcl1plGXTTBaOaCDaxIZI0CeWegCdvLX2wTBasE3oBHjE8lj1ZQZBvRMmSJCsnNsRm2AWheimxnMfqWCmu/2UwU5MAWI4SP9ugseMd89GVZdu2S7LiHYt2wRm49tpreec738l1112HZVnceOONvPWtb+UTn/gE11577Vwc4yJ8KFeyWoHTl5yOqqgcnj7MYFp49OXN09QiRMwi0/kKF2VFaW2MeyENzvDqtCosANFIjk5HJNOX1t4RX0TzOLh7jPv+V4QK/MlrN9K3WpAd2caeqTWXJcMv6pKs8cAkK11MY1jiRiuTBbsjYsEoZ/Xa1VKSteceYX3qG36ISJ/4nkvWiPNoqn1Nw11Zamiahw9O8MRACkad4IsAM1kFs8BjI4Jkbe7ezFhm5qxLZsKx5eUnCa9tTslSVKWpuazp8RzjAxkUBZZvTAKeRWxm8EXp+16REe4zZrJmBl/EMiKhr9hWfR4LPEuO1l65L0dCJgwWWhgwkN3+IADKxlNKPm9o8xPjHtguGOty7ayS8KfvvRdsm/CGDYT6S0lirZksEGTGbxlsJvQCWqhkucEXs3qZeYd8n0Se8wIA0n/4A8XDs0+m9J8Xsh8rcZZDou75cumDA8a3g0/JOt5JlrO5E66QLFgOSbKUjCBZM+yCAEtk+EXZXFaNeSzwVHbTKSl+pihZc9mVlc8YWIZ4vy/aBSvg8ssv5+abb+a3v/0tiUSCa6+9ll27dnHzzTdzySWXzMUxLsIHK5PBcJWs1pCsRCjBpi5xgZZqlowqNfUoUaNQ2S4IFaObm4YkalqElCVuBtFojo6MeEPq3V2z/x6LmIHp8Ry/+a9HsW3YcuEytj7bUx7i7QFIVnedQmIfyeqpQ7LafEmB6aJg13ImSypZ044dpM0tI45jGhZPPCA2CJYO3ofeI46pb40TpNG+GmNkuOrP4CLR55Kspd3inL/l3oegMA2KJjqLqsCwDG564iZectNLGMoOEVbDrG47mYIhdlb9M1nT/pmsJpUsgC4Z494AyZJWwb7V7e6iSypZE27wReXSUk/Jqh980Z4X6ZR256qax2NOOz1ZdZSsiNuV1bqEwcx2cb1TVpeSZ0OPtWSxXA9SsQh0LfeXEuNZBWeoWFB3Jgs8y+Btu4cYSIm/ZyPx7fDMtguCN+NkdfQSP/98sG0mbrxp1q9bcFMnNdJ33glA28vfLFjoU7+DoV3egxsgWe7myXFuF2xoJqtMyZqRLgjVlawa81gA5qTYAHom9GTB/HRlyXnkaCKE1oA1eaGiqZ/w4osv5je/+Q1DQ0NkMhn+8Ic/8MIXvrDVx7aIChBKlkOyWqRkAZzdLyyDspTYH+FedSYLfCSrBYPivtjhtCP5h8NZOpz1o9ZdfcGwiOZgGha/+tpOslNFele18Sev2Vjy9ViHJFnVL7j1Z7I8ktVVh2SF1BAxR6mVCYMyXbArUhp8kVBkumAb+3eOkk8bRKw0XeN70LrEeblkjTPj1b46mJKV6HXtgt3t4mfetcMp6u5aA/rMnX7Ltrhl3y284qev4Nq7ruVo+ih9sT4+/SefJl8Qi7CIrrqhHwDpcWG3ixQmCc2CZLlKVgPhF+481hZP5UjGy4Iv4pUXz6o7k1VNyfJIVk9RKIt6jSJi8ClZNWayAMLrWmsXtG2brEOy7KWlRNDUo/OjZDkLwkCLN2lVdYIOMr7QixIUMuAkrVWzCwKctrKTFckYmYLJzQ+LnzVoEbFEqyLcXZK1gOyCAFEfaUledRUAEzfeWL3OIgBMw3J3+u1D+zCGh1FiMWLP/TPY/GfiQfd8RfxbSMOkQxTqxLeDN+NkFK05UypagXyNIuJyqO3toKpoprh2zejJAi9hsFzJqlNELDv8DFX2ZJ3YJGs+urJcq+AzIFkQmrQL3nbbbeTKb7KLmBdY2Qymaxds3Rtehl88OCTsM6GofyarhpIVa6GS5bO4yIW0HvKTrEUlq9W46ydPMrA3RSSu8+K/3oYeLj2npJJVK/jC7cqaqGMXLGboi4nFQzWSBTPnsmYoWc65GPOVET9+n1jQL5vYgYLtKlm9q9oAm0Kkk6mjE1W/pwtfITHaNF3xEMmsCHAon8eybZs7Dt3Bq3/2aj5w+wfYl9pHMpLkfWe/j19c8QsuWXOJqwx1J8IlC8jpUXFSR0OG+/trBo12Zdm2zUF3Hsv7vnJxXV5GPCP4IirTBauQrOw4mOI5fZaIQY/2ra15TO5MVlttkhWRdsH9B7CN2e/EF57ehzk+jhKJYHb0lnzN0OZLyQoY4Q4+JetxiocPU9i/HzSN+Lnnlj5OXkfVUEmHXDkUReFFpzgBGE8IlbdRu2C1FMpG4c5kLbCNbalk5dJF2l94CWpnJ8bRo6Tvuqvp1yz65tsKfxSvEz/vXNRwGJ71DvGFh38oQmZksmCiryahlghHNVctPJ7VrEbsgoqqonV2olniflCRZPVtBhRhZ5721TPUKSJ2lSynl/REV7Jg7ruyMjJZ8BkQegFNkKy7776bl770pSSTSS6++GI+8pGP8Nvf/pZsdm7TSBYhYM+BXRDgzCUitOSJ8SdIFVKE3eCLKBGzUHkmC1o7k5X1hrWnHJKl6RmfXXBRyWolnvjjII/cJsIJnv8XW+nsi814jDuTVSP4Qs5kVQ2+iHYKqx3QHxIX7lokqzxhUAZfSCVLhrDEbPFaeSvBvkfEwnLJITG/oPWIcyUU1ugMiWvTyNEA9gefXXAsN8rlZ6xgveIoGr55rD8O/JE3/vKNvOPWd7B7bDeJUIK3n/52fnnFL/mLU/+CqKM2u/NYvtAL27bJTIufoa2vNrGoB6lkBY1xHz+aITNZQAupLN3Q6b1OuV2wiq2oahlxrAtwSGR2HCMzSRJh32nvX1/zmIKkCwLoy5YJklcsUjx0qOZjgyC7XSiUsW3bKORLh+WN+VKy3ICDRuyCT5C+5x5AHPuMfjG/VbCOMnTpNkGyJMlJNmkXzGdnGXyxQJUsv/1OjUTcYKaJH/246deUqqAWUsncKa5nbc++SHxx9bNg+Zlidvn+b3glxAFCL0D8fuUGyvEcfiFnQSMBz0etsxPVUbKK+QrBF+E4dDvXIX8pcR0ly5RKFuL+VTcF9ATAXHdlucmCz4DQC2iCZP3mN79hYmKCW2+9lcsuu4z777+fK664gmQyyUUXXTQXx7gIH/w9Wa0kWb2xXtZ0rMHG5qGhh9ybfs0Id/DZBVtAsvx2QWchregZOheVrJZj7Eia331XxNme9eI1rDutt+LjYu1B7IJ1ZrIUxY1xX6KLOStJPiqhXMmSwRcywl2eG1FbLPSfeiqCaVh0L42RGBNWMr861N0pFoAjEwEWcPFeuh274Hh+nCvOWsY6Rahk2fa17BzZydt+8zbe/Ks389DwQ0S0CH95yl9yyxW38Ldn/G3JTBngJgv6Qy9y6SKWJY6lfWXl33tQSJKVSxfJTddfNEkVa/lJneg++6K0C6ZyRUzLrloy6ypZ5cEXmu5F9WdGSA2Kv8OkHaezq/bmSNB0QUVVCa9dC7TGMphxQi9iZ53lBgHE2h07lR6lMA9KlrQLBlOyHJI/9pSrlMywCkLd+HY/zl7dRV+7t6OcjDe28Gld8IX4d6GRLPf66Cwck1ddCcDUbbcF6+arAM9CqpK9X2wEJOTaSlHggneKj+/7Ggw8Ij4OMI8lIQuJ8+njV8mSqaaRAEoWiLks1y5YzQbpzmU5lkGzCE4CajUlS1qZDUu8P090uyDMfVeW7MiKLypZ1aHrOs9+9rO58sorecUrXsGLXvQiLMtaLCOeB4jgi9bbBQHOWiIsgw8MPuBFuOsRokbBtWjNQIVZjKbhLg563IW0raRdu6Des6hktQKFnMEtX92BkTdZsamL81+6rupj4+5MVoCerGpKFriWwW7VIVk1lKy2kCAqM5QsWUbspAuGHSVrz2NihXbS1gQKgggoca9ctq/f6YDKRasfn0Sily5HybJsi+XdFptDAzwZCvFXB37Da3/+Wu46che6ovPqTa/mF1f8gvee817XylgO+XP6lay0kywYKkwRW1M7ea8eQhGNti5xswoSfuH1Y5UuwDtj4ndk25DKFktKZqXKAKDGnOCLfIUbsC/8IjO0D4CjyhK0GmEGtmV5SladdEHwWQZbkDCYfUAsYONnn+Uqdu3OLq6hxTAOz72S5Ua4B7EhJVeDFsEu5kjfJcIQEhdeOPNxmfqhFxKqqvCiU7xkwoaVrBbPZKkLLPhCqv+TI2LDJ7ppE9HTTgPDYPKnP23qNeU5oWNgF4uEli8nvG6t94Ctl4vi4fQQ3P9N8bkGSJbXlXU8K1nBZ7LAIVmWVLKqkKzyhMHJQ2Bbooamrb/iU8zUFJaiYdnivHxm2QXnxp2WcYIvngnJgtAEyfrqV7/K6173OlasWMGFF17ILbfcwkUXXcT999/P8HCA9K5FzApWJuMm3bS6s8E/l1Ua4V5w7XszIGeyWmIXHHNf01XOrCnanPWcTLFbRPOwbZvbvrub8YEMic4wL/yrU1C16pcBSbKyNdIF3ZmsasEX4JKspFKfZPmVLMMy3AAMSbJkumDYzJIy+ziy3wAF1q1w5vi6u0t2xGX4xYTdXb9gNtFLCEg6jpNHBrfzpZ4iV6xYyo7CblRF5WUbXsbNr7iZjzzrIyyJL6n5cjIS3Z8smHY7spqPb/fDswzWLgQ3TYvDjwuStWpL6XsppKm0O1aY8UzB20G2Sxctrl2wXMmCkg2Xwug+AEb0yosXCSuTcWUMtaO2kgUQXitIVn6WCYPGyIiYaUL070nrlNzFNfQY5uQk5nSLStYrwLZt1y4Y6FquatCzgfykjjk+iRKPEzvttJmPk7brWDDl/1Inyh0gGTs26YKWJPILi2PRIUmWr6cu+UonAOPHNzRVaC3PCc0p101cdFGpwqeF4Ly3Og92zs9GlCy3K+v4VbIamcmCMiWrGskqTxh057FWg1r5HmimUpiaRwaeCUrWXHdluXbBxeCLyvibv/kbbr31Vq6++mr27dvHTTfdxNVXX83pp5++4KT+hQa7WMQuFLyZrBamC4KnZO0c2QlhcXMwtagTfFFtJmsOgi98dsFoRiywbVVB6+ys9sxFBMQjtx3iyfuHxA72X2+rWwYov55LFzHNCl53vJksK5PBylexFToLvk5bqBZTOcONNi+HS7KKU0zmRRmkguLOaolzw0Y3szye/RMAVmzsIuI8tpyM957Uh2IZFLVYfQuE00Uk57KuvuN9/Lwtjq0oFFOncv2zv8snLvoEK9uDKVAVlaxJGd8+Oav4domg4RdD+6Yo5kwiCZ3elTNVo05f+IUe0tB0cXvwh19UDb4Aj2SlR7DHReJZKly7207acZRwGDVSf2dTFhIXnt5X97G1kHlQWAUjJ5+M1tnpLupkspYZEb+f4pG5swwaRcu1yQVevPWeTHpA/J7i556DEq7w/m3ALghw/rpuN/jEbx0MAqk0GAWr6vUhCOTvYaEqWVMjOSzn5++49DKUeJzCvn2uWtoIpJKlTgmynLjo2TMfdPZfQMhT64POZIE353RcK1kNpAuCIFmq07FZrFRGDJ6SNbQbLLPuPBaI65MkWZquotXYkDxRMNddWenF4IvauPHGG3n961/PD37wA/r6+rjwwgu55ppr+PWvf00mEzxGeBGNw3LCRVpdRiyxqn0VvbFeilaRQ1lxATK0CBGj6IYNzMCcRLj3uJawWFosypVkJ0qV3aZFBMPRpya56wbRsXPhVSexbEN90hpNhNw0qmoJg2p7O2iO8jkxUfmFHJIVNaZc+9h4lbksf/CFnMfqiHSgq+J8n84bRCii2BaPZ58LwKbz+zHHxfmj9ZQuLiPLltCWFtavob11zlPH8tZreD/rszNZrh/SyR1+A/c90dhOfyUla3pY7D6H8xOE1rRSyap9/T3kzGOt3NRdsY/IC78Qx1wp/EIqWRjCylSChFSyxtCmxKzDdHQ5tWBOyY6sYAEgnl1wdkpW9gER3R47W2ws5ZwFp9zFNSOCuM5lwqA/RS4UDkqyNpIeFIuTiv1Y0JBdEEDXVL702rN43yUbOXtNY3OvIZ9lvTiL8At7gSpZbckImq5iWTZTTq+Q1pag47JLAZj4ceMBGEXnXqumJ0DTKv+dY11wxuvEx5FOaK+9meGHZxc8jpUsaRdsRMmyakS4A3SvAz0GRhbG99VNFgQxLyo3tZ8JVkGY264s27YXI9zr4eUvfzmf+9zn2L59OwMDA1xzzTUcPnyYl7zkJXQv2rnmFJZDYt0I9xZL14qiuGrWE2mRWuQpWfMQ4V5uF1QM4mnxhtS7Fs+t2SCTKvCrr+7AsmxOOmcJpz0vmBKjqAqxNnFTzlZJGFRU1VWzqs5lOSRLzY27u+bVLIN+u2B5siAIJStOjmFjPePmSrSQyoYzl2CMivOnPIVS6+ykfVrEsA88XmcYPd4NKLx1YpKXrH4B31rxEv5jcJitXaKD5sbthzCt4BYgV8nykaypI+I4o0rOLdKcDbqWOl1ZdZQsOY+1akvlhXSX25VVGuNeyHpkSol5CZQzVEvXLjhCJC3ISaF9Rc1jkj00MxLyqkAGX5jj49XTLANAlhDHzzoL27LdQXu/XRCgOIdzWUVf4WzQEl67cx2ZIfF3SlxQYR4LSqowguKik3t51/NPbtiNomkqulMoOpu5LGmrW2hKlqIqnr3KZxnscjqzUrf8CtNRa4NCKlmamSN2+unV3xsXvgsSS+CUl9dNkfTDswsen0qWaVqu5S8S0L6qJTtdu6Bl2pVVVVWDJU6X2OCjdZUs27ZL7ILPBKsgzG1XVj5tuB1wiY5FJasqRkdHufHGG/noRz/KNddcw3e/+106Ojq49NJLW318i/BBkiwjJElW6+NE5VzWo1M7AG8mq27whZEVJZizQVm6oKJl3NCLcO/sUtieybAsm1//16OkJwt0LY3zvDdsbmgx5ca415zLSgK1Conl7N64u5ivR7JShZTXkeUkC4IgWQklzx5HxVp3ei/hmI45KhaX5SmUiqqStMVxDe2rs+BRNYh3c34uz6e2vpWzM0JpWbLuVLriIQZTef7wZPDUsHFnIdMd9ytZ4jUTbVpLLNZSyUoNZ6tatgo5g4G9wk65cnNlkiXDL1ySVUHJUsJhd0Fnl9d2+IIv2rOCnJh1bJVmSiYLBiNZajyOvkzMEDVrGbSyWXKPieH32FlnU8ibrl3NDb5QxN9rLmPc3dCLBhZvmUGwTRUtahPZeHLlB2UbU7Jmi3CVTrVGYDunbVCyeTyhc4l4/00Oe/e/6OmnEzn5ZOx8nsmf/ayh15MKp2bkK1sFJbrWwvv2wMu+2NDru0rWLEnWwV1j7Lnn6KxeoxL8831Bw738M1lQYy7LtQw+VlfJsnM5KBYxdYdkPUOULJi7riypYkUTIbTQM8OZ1PBPuW3bNvr7+3nb297G4cOHeetb38qDDz7IyMgIN91001wc4yIcWBnHLjhHM1ngm8uaeBgQ6YLhWhHukXZwbFyzDr8oIVlmCclaDL1oHvf9714O7xlHj2i8+K+3NUzO4+31SZaWrNOVJYfws2Ouda4RJcuf3jedN4nbeZ7IXQzApvOXOt+7spIF0BUVJ9LIYCFA+IWYyyI9DKNPiZ+v72Redrqwvt3wQPCOJrcnyxfhLj3pbb310/SCoC0ZQQ8Ly5J/N92Po09OYpk27T1ROnpn9qGBX8kSx1epkFhRlPqFxKkjtBnib6F217ZDWtMyWTB4X1hknWMZbDL8IvvIDjAM9P5+QiuWu4tNLaS6M4imrWEp6rzYBRt5P6Z3CdKX6M+i5CYrP6jBmazZohXhF/I9uRDHujsrhF8oiuIFYNxwQ0OvJ5Vj3czRVq8WpwkLvRvhPgu74PhAmp/928P89lu7mBhq7ZiIPK5QVKsZyuSHlkyi2AaKw9aNanNZMvwigJIlFUjT2dR+JpGsuerKckMvks8MqyA0GXzx0EMPMTw8zE9+8hPe9a53cVqlhKNFtBxWJo2lqFiqOEFbHeEOsLFrI22hNiacnX9b0QhbNgXTIm9U2B1SFJ9NaBYkq5jzkpJiooxY0dKLRcSzxNOPjPDALeJm8qdv2Ez38kTDrxFzY9xrdWVJu+BElReRJGucnrbgJEvOZHVHvQVjOm+wytDJWkli2hSrtjo9XaOVZ7IAkl0KqlWkWCxdDFWEq8iMwMgT4uOek7jq7FUA/OrRASaz9XeBbdt2CYt/JiuTczqylifrvkYQKKriqlnVLIOyH2vV5q6q6lnSF3wBQQqJq5Cso6K7J21HaEv21Tx2V8kKkCwoEXZIVr7Juazsg8481llnoiiK+/NF43rJjJGpzW0hsbTXNbJ4y9zn9Cb152H0ySoPkqXu86RkOUpcITf7mawFqWRVIFkAHS99KUooRP6xXWR3PlrpqRWRPTwIQEiH6CmntO5AHcjgi2btgrZtc8cPHscyxd8saBF6UBQajG8Hh2QBat0Yd4dkHd4uIvChbkeWnRCzy60ezzieMVddWbK+JP4MiW+HJkjWO97xDk499dS5OJZF1IGVyZTEic6FXVBTNU5fcjpF1VsAq6qOZpnVLYOtmMuSKpiiQbTTtQsuFhE3j8nhLL/9prBFnfa8lZx8bu047WqQSla14Avw/j71ZrL8dsHRKiTLH3zhKlmOXdC0bLJFk5UF8ZiTkjvcxCfDsSpW6lML9/bQNi0UqKH9dSyDCYdkje71bsQ9J3Hqig429bdTMCx+/kh9m8x03qDoLETkz2yaFnlTLHI61gUfVq+HrjrhF4d2Of1YW6qrG7KIdnzGTFZZIXGsipIlgy+cfrPDdi9dido3U28mK7iqF5bhF03aBTMPyHmsswFvsRlJhMSMUdg5n/TY3CpZjRQRI4bwszuEjTvRX4CRxys/0J1tnZ9rZmuULPHvQkworkay9K4u2i+5BICJG4IHYGQPi2tObPUyFK31C/uonMlqUsl68v4hd74TYLLVSla6sdALwJ1t1dyEwWox7g5plSXEkY6q7xNXyXJIVijS+vXW8Yq56sqSG7XPlPh2aHImaxHHBnYm4w5kayHVjVhuNc5achYoNpYmLnZuV1a9uazZ2AV9VkEUhWlXyRKf1hftgg3BKJjc8tUdFLIGS9d3cOGVJzX9Wu5MVpXgCyBw8AXZCXocVWe8ASVLBl+kCwYhG3oLSQA29e1ynyfnwbQKISl6bx/tUyJWfGj/VNWfA/BI1sF7xL9t/RDtQFEUrjpbzBjd8MDB2q+BN48VD2tEQ2KxlJksgKKgWCbtJ82uiNiPZI0Y90yqwOhhMQe2clP1hXcyVpYuWGXWRo04JGvGTFYpuT1k99FTh2R56YLBlayIjHFvQsmyTZOsE98eO+tMwBcX7Szq5OaVoccwx8Zm/pwtQtGdyQq2eMvcdx9YFuG+BKGEWZlkGXkoiN/pfNkFq5HxRrCQlSzZlZUazpYUdwMkX/VK8bWf/dydqa6H3LAT3X7S2tYdpA+RWZQRF7IGf7hBqPuxdvE61SzKzUJebxoZh/BIlkwYrGIXbFviORVAqFhViL0kWXZMXJueKcEXMHddWVLJeqYUEcMiyVpQEEqWLCKeuze8nMvKa94MWMSsFePuLNxmYxcsS8RySVZa3LS0RbtgQ7jjB48zcnCaWHuIF7311FkR8liAmSxZSCznoma+SFL8mx13k/bq2QWni9OMZsV5IWey0nmDjUUNFY2kdpglSedGaNs+JasSyeqlwyFZw3VJlmNxO3if+LfHI6iXn7kcTVXYfmCCp5wAi2pw57EqhF6EC5NEnKS8VqCrhl3w0B7xe+ld1eb+LSvBi3AvDb4oZCorWTPtgqXhNELJqp0O5ipZHcFnsqRdsHDwIHah+jlZCfknn8SankaNx4luEt1CrpLl/PxycWe1iXN6riyDjdoF03fdDUDi/2fvz8Mcqe6rcfzUolJpV6/Tsy/MDjMwDGY3DgbsMY7BNo73+IuNgThesf06OHEW5/X+CybGSwiJ1ze2SWKwQzZsDCSY3TBgZpgNhtl7ZnqRWvtS2++PW7dUUmspSaVWS33P8/Awo5bU1dOlqnvuOZ9ztp5BHqBWVjuyNkeAd256BT1uBF/QmaweXJGEhmRwPAdV0a15Swr/+efDs3w59HQayV/+quF7qfE4iuZ1Mbi5RrBJm7AH2lSSwkZ4+t8PIZsoIjLiw6veSD6HiSmXSVa2/PPoBLwsg5NlS8mqGXwBlOaygIYdWQCgyURlX0gzWZ3qyirFtzOSxTAPoduUrE6EXlBsGdkCD+9BkSeLKE2UIatFJGsWErswk2VLxCqqOoqqXhZ8ITK7oGPseWwcex8/CY4DrrrhTAQH5Lbezx9uTLIcz2QV0zDt3rVJlqe04D6WIoqRpWQVVGwukpvdBt//gDNLY/VUCjB7m6qFpIgjwwilyGza5NEU9HqLC3o+F0xboY1kjYZk/N56QsLuaRCAEbfi20uLhcRBsmCX1ZT1b+YG6nVlWVbBjfWVDWoXnMnVDr4AAF4mv8BZdkEpANjszCeM4cZKFp3JCjonWeKiReD8fkDTUDzuPIQEALJmOazvnHPAiXSxSc4baqOi11ZjhASddIpkNWsXzDxBSJb/wgvIA1VJFt2sGmgpFKEVeE0lTmkjwp1+HnvRLigIvLUotScMAmay6XXXAXDWmZV94gmo5mdIXtSZjUWZkhejudj9qeMpvPA/5PN22TvXY3AxUc8TE51RspqxCwKkqoM3layadkGglDAI1O/IMq9NukSurQtpJqtTXVlZFnzBMJ+hZ7OlZMEOzGNReAUvzho+C0XBJFmNYtyteG537IIZUzHjRNtMVpU5G4bZmDyawiM/JTai869Zg+UNFtZOQElWzkG6YE27oBwFbRodFcl5VYtkeQQPfOZmwskMmX2iStb0ZA4rVXLZWi8/AnjIDVA149v5QAC8d/bCXhwehj97GoJehFLQ6ndKBSrCGobKrZbXmZbBe3eeqNuZZXVk2ZSs1LFJAIDsUV1dUFKSlc8oyKdLmyGGYZSFXtR9D6pkZVoMvrCH4AA4LYzC16BkV0+Z6YJNKFkcx5USBpu0DOZ2UqvgudZj1gyISYbpYsoYIjNznZrLKjZhF1ROnSI/K88j8Jod5MHYK4BWsfE1x/HtQCmAqdBGGTHMj1Gv9WRR1JrLAoDIW94CCAJyO3eicPBg3fdJP/pYya3SIeVE8JTmDvMZZyTL0A38708OwNANnHHuCFacOYTIaCkcQa9RHdEKqHLeTPAF4LCQGHCsZGlJkt6pmfeYhaRkdaori9kFHWJmZga33XYbPvjBD+KDH/wgbr/9diQSNeJkGVyDnslCFWl8e2c/8NtGt0Hhya6DJngh14txt5SsNoIvsqVhbWpL9HJpBMxNFDd3/fsV+YyC++/aBU3VsWrLELa/vn58tlNQkpXPKDV7mBoGX/C8ZRkcFohlrlbwBQAEPUSh0gxys6RK1vgL0+DAgfdOISxOEPXE9n1rkXFhaAi8oSNoluRO1gu/CJTb3jBcbtu5YtMoIj4PTiXzeKxOZ1a8SrJg6hT5voGAu/tbHq+A4AC5ccVtBDIxmUM6VgAvcli8Nlr3PSgZTBVUKJpuFYHOCr6gEe65Kn79QOnfPyMvaXjcWqq5niyKUsLgoaZel91JlCz/dhvJqrBH0sWdESHnQadIFlV+nOyQZ54g84HyWWdBWLaRbC7oSimGmmKO49sBd4IvLGW5NzlWXZLlWTSK4GteAwCY+dk9Nd/DMAxkHn201MvUQeVEbnIua9+TJ3HqlQREr4BL/4BcDwMRLwSRVEekXFQ7rJmsZpUsW1dWzXRBwLGSpZtKVqkna+EEXwDud2UZuoFMktoFmZJVE8888wzOOOMM3H777YjFYojFYvj617+OM844Azt37uzEMTKY0LNZaNQu2EElCwC2L9oORTD9zYIMWSvWmcmi6YLu2AUzRfJ9ogpZjBs8DyEyN/MFvQpDN/DgD/YgOZVHeFjGFddvdm2IXA54rPfKp6rflEszWfHaPVSmZXCAIyQgnq3dWUXnsigGZPLaqd3kPAkETQXDJFlUyaoVkCKOEHUqlCCL8rrhFw2ULK8o4NpzGndmVVOyMnFywwoMVO+qagcDY9QymLEeoylgY6sjDXdiw7ZrSjKn2GY3yn/nlpJVqHLztSkouUBjkkXnHprpyQLsCYPOSZZy8iTU8ZOAIMBnqx2xItwDFTNZIXMm60SnZrJMJcvBDnnmiccBAIGLLiIbFvScnK6wDFqbVV0gWW3YBY0+UbJqhUBE30Y6sxK/+EXNOcLCSy9BnZiYG7eKnxYSN/6d5TMKHr+XKHDnv3G1ZT/neK4s9MMtFNpQsvhGwRcAMLoRFpuvq2SRa5PKd570zke43ZV1bG8MumrA6xcRiDIlqyZuueUWXHPNNTh8+DDuvfde3HvvvTh06BB+//d/H5/4xCc6cIgMFHou19EiYjvOHjnbIlma4IVXrUOy3Ihwt9kFqS0xkjcXi9EQuDmaL+hVPPvLIzi8axqCyGPHTVusBaMb4HgOviB5v1pzWZbSqCjQM5mqz6EkKwxzh1A3kKyx+20nWSInIugJYup4GsXpAlQYGAmZHUFUyaIdWTVIFh8IgJNlK/zCMcniBGBg1ayn0JTBX754quasYjUlK5slN//gmPubBtFFsxMGj+81rYKbGivBosBbRCueVWqmC1oR7tWULDP8omB4wAcbVwZo6ebTBYHWEgaz5iagvHEj+ECpLy5foWTRn1vzkd9Rx5Qsayar/rXcMAxrHitw0UXkQaquViYM5krX0bkCPX5X0gV7cCYLqK9kAUDwsldDHBmBFo8j9dDDVZ+TefQxGIBV09LJRb3XinFvrGQ9+YuDyKcVDC4JYOsV5YmopZ/bvRj3yrRPpyB2QTPCvZ6SJQWAS28BznobMLyh5tM0M5RH48i9byHZBQH3u7L2PEo2q9afP2bVriwEtKRk/cmf/AlEsfQBEEURn/nMZ/DMM8+4enAM5SDBF53f5QKAiDcCn59c7Ild0EHwRVszWdTmMmSRuVCBXLh5FnpRF8f2xfD0fWSxedm71mNkRXOqgBP4GoRf8D6fZSNrFOPuKSQQNK0XNIGvEnaSFZWj4DgOB546BQB4xaMj7DFJkumX1+K1kwUBsngTh4cRShJ71dSxVO05AjlKyBVACJYwm7BuWRrB+kVBFOp0ZllKlo1k5RTyc4dX1C/pbQWV4Re6buD4fmehF9Z7mKpbIlcsSxe0K46l4IsqC0rzWnDCGGrYkQXYlSznPVmAzS546FBt5bQCObMfy2ezCgK2RV3FTJZmEviOBV/QdMEGi+niyy9Dm5wCJ8tW7DyG15P/V5Ks7NyTLHcj3F05pDlHZIR89hIT2arnIyeKiLz1rQBqB2BkHn0UOi9Z/widXNRbdsEGhcSnDyXxork4fs271s9aHDcil62gmKM9fc1tFNrtgnVnsgDgyr8E3vbduuEwesJUskDO74VHstzrysomizj0O2KtP/PVjR0O/YSmL2nhcBhHjx6d9fixY8cQatLywdAc9GwGmkDTBTv/gR8y7TKqaEa415zJctEu6BtEpqAB0BA2F+AeFt9eE+l4Hg9890UYBrDp4sXYfElnLmABJwmDzRQSmzf5WKa6l7+MZHmj0HUDB54mJGuPR0WAM3fXJLI4Vy0lq/a5Ig4Pw5+bhEc0oCo6Yidr7L7yfGnjoGIei6K8M6u6ZZD2ZA2axEUvFJAXyPFG1i2teZytgtoFqZI1dSyFQlaFJAsYXens2kzDL+KZkpJlGOU7w5xMyJNRVcmiJGsYg42KiAsFGGYiJB9uTsmSVpJ+Gz2ZtPrRGoEqWf5zy0lWKcK9XMmiG1rq5CT0gnszJxRO7YJWquB554GXTMJuKVk17IJzGnxRPSClGfRyGTFQ6hUq5jXrfKpE9G0kZTDz+OMoHi9XR/VcDtlnnrHOOXCdXdR7A40LiXXdwP/+dD9gABsuGMOSdbM3OztBstpSspykCzoEnRdVdbJMXkjpgoC7XVn7njgJXTewaHUYQ0ub21DrdTRNst7xjnfghhtuwD//8z/j2LFjOHbsGO6++2588IMfxLve9a5OHCODiblUsgBgLDoKwFSy1HplxCbJKqZJGWYrsA1spwtKWXy7d8j9Xf9+gKbq+OU/7EYupWB4eRCXvXN9x74XVbJydQqJxUYJgzaSRRfgsRoLkrBUWnQPyAM4cSCOTKIIw8PhFY8OPyjJMpWsGJ3Jqq16iiPD4GBgIEB+hgkn4RcV81h2vPmcpeA54NkjcbxSpTOL2gUpocy+ctSaqQyvGK39vVsEVbKSkzlomo5jplVw6YYB8A7tGaUYdwWihwcvkEWvXaWwlKxqM1nLXwUdHJ7Qz8Rgo44sU8UCz4P3+x0dX+kYZHiWEqLqxDKopVIoHCCqj29bdSVLrujJUjQenI/8rOrJ6mplO3BqF7T6sahVELApWZUkq7xvcC4QGfUBHJCOF5COt3b973UlS5RKwTO1Is2l5cvhv+hCwDCQuPfesq9ln3mGzGqNkY0bySt0lHCWZrJqK1kvPnICk0dTkHxizTL7cCdIVqvBF5EIeJouWM8u6BA0XZCSrIUafNFuV5ahG5ZVcPOlC0vFAlogWX/zN3+Dt771rXjf+96HVatWYdWqVbj++uvxtre9DV/96lc7cYwMJsoi3Ds8kwUAywbJB0ITZHj1XO2ZLG+kdHdsVc3Kmgtz/xDSBQ2cmEEkS2684tBwnRcuXDx+z8s49UoSXr+IHTdtgdggLrsd+GkhcaKOkkXDL2K1SBaN+o9jyCokdqZkHXiSqFj5MRkaB8iG+ToafGF+z3pKljBMzqMBkexQ1i0lDpokqA7JGg3LeA3tzNo5W82qnMlKHCCdX4JebKpo0ymCUS9ErwBdN5CczFmhF06tggAQ9dFC4iKJSq8S487TMuJqStYZr8XHVv4C39GubahkWcmCwWBLM5fNJAzmnv8doOvwLF8Oz6ISwdU0HYqpKNHdfWvGKK/Cs5RcA4sdmMsqOrALGoqC7NOkFDtwsY1kDZqFxLkYkLHNwnYhwl0OeDBqWpSP72vt+m+VEfeokgU4U3VoAMbMvffC0EoL18yjjwIApHPPB+As1r8dyA2UrGyyiCf/jWxeXHjtGiththL2wA+ntt1GaCvC3SwjVuoFXzgETRdUFPJzLTS7oFtdWScOxJGYzMEjC1i73f3NxfmOpu9skiThG9/4BuLxOJ5//nk8//zziMViuP322+Gt0k/jFmKxGN7znvcgHA4jGo3ihhtuQDo9e/e4Ek888QRe+9rXIhAIIBwO47LLLkMu52553lzByNjLiOfALhg2lQnBC5mfRKrWTBbPt9eVpSlAwawA8JGeLLuSJbCZrFl46ben8cLDZGF/xfWbrZtdp2DNZNVRskqFxI2UrJiVuFcrxt1OsgbFYRx8jvRLzYwSEiAb5mfYQ4MvTCWrxkwWQOyCABBRJgA0ULJe/Wlg23uBs95a+zkA3rZ9OYDZnVm6biCeLbcLJg6fBgD4hNr/hu2A4zlEze6aqeNpnHyZfKachF5QDNCuLPPYq4VfcF4z+KKyJ8vEeI68hz3woxqsjqwWbebeJhIGc89Rq+C2sseLtkUmXdSVZow0eJZ0rpCYkrt6NqTcrl3Qs1kIAwPwbrAN6Ut+ILKC/Nk+l9WFmSwAWL6ZfL+je1okWeaa2K1E1G7AiaoTuvJKCJEI1FOnLGIFkH4sAPCcRc7PTlvTGilZj9/7Moo5FSMrQjjzstrW5tCQDI7noCp63Q04p9AUHaqim8fYul2w4UxWAxiaBj2dhgEbyVpgdkG3urKswItXLZoTB9Z8Q9Mk6wMf+ABSqRT8fj+2bNmCLVu2wO/3I5PJ4AMf+EAnjhEA8J73vAcvvvgiHnjgAfzHf/wHHnnkEdx00011X/PEE09gx44deN3rXoenn34av/3tb/GRj3wEfI8m1ZEI97mzC9KdG1Xwwofp2nZBoL25rBxdlHOAL4p0QQUnZCySJbKZrDLExjN46J/2AQC271iJ1Vs7r/T5ncxkOSZZcQwFyfvFHZCs6MllUAoawsMyYiaX9OrULkiVLHMmq05pNVVEQ2bC4NSJNDS1xo7n6lcD134bkOunANLOrJOJPJ44WFIUUnnVIl3UgpcaJ/8uvg7y4QHTMrj38ZPQVB2BqNeyETpBxLILkt+LRTiqKlnVb7w08KMRydLMneJm57EopNUkYbBwqLFdMEtDL87dXvY4VegkWbAslfbeJ2pJdDth0NANyy5Yz4ZUsgpeOFvto3NZ9hj3LkS4A8DyTeT7Hd8Xs6x/zaDX0wUBZ0l7vNeLyJuvBQDM/OxnAAiBLx48SGyzZxAi3WnVpJpCTTH+Uhz7nzwFcCRIqV6sviDwCA2aNkkXLIPWZg7X/BrHXkZcN13QAegGkM5LVlH2QlOygPa7snLpIg4+TzZIz3y1+3PIvYCm2cYPf/jDqkpQLpfDj370I1cOqhJ79+7F/fffj3/8x3/EBRdcgEsvvRTf/OY3cffdd2O8zg7jLbfcgo997GO49dZbceaZZ2LDhg14+9vf3lHFrZMQR0ehmYP+c0GyrJQtUYYPM7XtgkB7hcTWwiAK8IJJsrIIm3ZBpmSVUMyruP+uXVALGpZuGMD516yZk+/rdzKTRYMvZhwEXzShZHkOEnK0/vwxpE0biEc3r0GSH4aul8qI65RWiyPkfaTpI/D6Reiqgdh4jbh5h5A9Aq45m3ZmHbMep6mJQa8ISSSX2cw0WXwFOljEGB0jpPOYqSgs3zjQ1MKVKlnxiljzMiXLmsmqbiGZdkiydDMiWQi2NghN7YLFBnZBQ1GQ+93vAJSXEAP20IuSfZO6BIp5taRkudyVZR/Mr6daWKEX9nksisqEQbsjYA7tggAwtiYC0Ssgl1IwdaKxw6QSll2wN/c/AZQSBht1RkWuIwEYqYf/B+rkJNKmouXbutUW395puyA53ytDOjRNx//+lJxPmy9dgrHVjasm3Ixxp518kiw2rWoKAzYlq02SRa3MWjBKHuAATwft+PMV7XZl7X/yFHTVwMiKUEdSj3sBji9pyWQSiUQChmEglUohmUxa/8XjcfzXf/0XRkc747d84oknEI1Gcd5551mPXXnlleB5Hk899VTV10xMTOCpp57C6OgoLr74YixatAivec1r8KhNoq+GQqFQ9rMlk3UsRXOM1ff8DMbwGIC5mcmiOzeaIEM2UkjWsAcBaM8umCvffa20C4p11ImFBMMw8PA/7UP8VBaBiITX3XDmnJV3WkpWWzNZNiUrUF/JCnuIuuErhqAeIQuPDReMIWMSfY9GSVYQWiIB6IR8ifVIlmkX1KYmrQt+XcugQ9CUwfttnVml+PbS4j2TIsceHO3czWagQrVatqk5RYOmCyYsu6BpK3KoZCmabineDZWslNmR1aKSRe2CyokTddP/8vv2wcjnwUcikNaUb0qU4ttL19MyJWuJqWS5bBekVkGO5yB4qt+GtXTGIoeBiy6e/YRhc16Qhl9UOALmEoLIY+l68j1p4IpTGIbR8+mCgPOkPXn9evjOPhtQVST+7d+QMa2CgUsvtRInO20XtCLcK5SsFx48jth4BnLQg4uuPcPRe1nx9S4qWc1aBQFACIfB05msXHvWRc2Mb0eYXD89ktDTVtZW0U5XlmEs7MALCsckKxqNYnBwEBzHYf369RgYGLD+Gx4exgc+8AF8+MMf7shBnjp1ahaBE0URg4ODOHXqVNXXvGImTv3VX/0VbrzxRtx///0499xzccUVV+Cll16q+hoA+PKXv4xIJGL9t3z5cvd+EBcwVxdhoLSbpgpeeFUDOe5I7eFWyy7YipJV6sgCgHSe2AUjdCZrYG6tL/MVLzx8HC8/MwGe5/D6m7bUHEbuBHxm8EU+o0Cr0S8lOE4XnLEW4LEGStba6XMBg8PoqjCii/wWyRJU8+Tw+K15LCESAeepHShhkazJKYyspCSrTviFQ2xdFsHa0SDyio7/MjuzKHm04tuLReRpR9bSzm0aRMcqSNaG5lTgqM8kv6YSZ3Vl5Uo73vVmsujPzXNApEHPjaVktTiTJQwPgw8GAV1H8ciRms/LPvssAMC/bdssy111JasUXc+NLgbgvl3QCr2okyKX/e3TgKrCs2IFpGVVrDaVSlaFI2CusdwMWDneJMmC7ZYyV5tGnQAlWbmU0rAzLPoHJAAj/q//isyTTwIAgpdeYpHvTs//WAq1TclKx/N4+j+JKnzRW86AHHQWzuNmwmCxxfh2AOAEAR6ZHLNSb7TBAei1yaAkawFaBYH2urJOvpxA/FQWosRj/asaF9P3KxyTrIcffhgPPvggDMPAz372Mzz00EPWf48++iiOHj2KP/uzP2vqm996663gOK7uf/v27Wv6hwIA3dzZvvnmm/H+978f27Ztw+23344NGzbge9/7Xs3Xffazn0UikbD+O3bsWM3nzjU0VYdmDoXOhZJl2QUFL7xFgJMPIVcrytMiWTUW2PVQMaydLqjwIA2/uTldL8xgoeDkwQQe/9nLAICL37YWi89obONwE3LQY+3k5VPVh6Udz2QVkhjwkfdqZBdcN0nU6w0XkIs0OTdU8IZ5E5UCto6s+ucJTRc0FAUjo+Tz44aSVa0zK2bFtxPSohw/joKX/M5CSztnf42OlkjWwOIAAtHmrNHRiuALb5UOJKpkVSsjpj931C9BaLBgtmayWiRZHMdZylQ9y6BVQlzRjwXY4tttSpbo4a3FvjFIzjt1YoJEbLuEUnx7Y6tgoJpVECiRrPgRUp3Rhfh2O2j4xfhLiaaCB3Tbxl0v2wUlnwhfyFSCGxCO8BveAN7vh3LkKPRkEnwkAnnLFhTNTSSpw3HhtHhbVXQrnvvRf30JakHD2JoINl202PF72RMG24WlZLW4vvGYiabtBl9QJUs37YILLfSCop2uLKpirTtv0ZysV+crHP/kr3nNawAAhw4dwooVK1yR9T/1qU/h+uuvr/ucNWvWYGxsDBMTE2WPq6qKWCyGsbGxqq9bvJhcJDZv3lz2+KZNm6qWKVN4vd55O7NVtO3OzImSZV7oNUGGpBoQ/IeQzqvwS1VOG58LSha1CxZVRItkAWYIfMt2on5BNlnEL+/aBV03sPa8UWy9fNmcHwPPc/AFPcgmi8gmi1UX78JAFEA9khW1/jgikot2veCLaG4Uo5kV4HhyoQaIldTqyAIAKQAtTkMv6i8uea8XfDgMPZnEoMngYycyUBUNoqe9z9Nbti3F1+7fh2eOxHFoKjNLySoePoKCREhWICq39b3qweMlfT3peAHLNzZP5mhIx8lEDm+/8wlsnjEwAmDX4TiSu05iLCJjRCUrYSM/26IXSzubxwIAPd1euiAAeFevRv6FF1A8XJ1kGYaB7HPPAZg9jwWUZkDsShbHcfD4BBQyKlRfGJzXC6NQgHL6NCSXnA1OioizjUhWcBHgDQOFJBA7ZItv7w7JGhjzIxD1IjNTwMmXExbpagR7UEYv2wUBQjhyKQWJyVzdGRQ+EED4jW/EzL/+KwDyO+YEYc6ULNLDRdTaQlbF+PEZHNw5CY4DXvPu9U1Z49wsJLaCaFolWUFyLIrSXoS7ZipZup+sPRa6kkW7spzeJ/MZBS/vJGv2hWwVBJogWRQrV6507ZuPjIxgZKRx0exFF12EmZkZPPvss9i+naRDPfTQQ9B1HRdccEHV16xatQpLlizB/v37yx4/cOAA3vCGN7R/8F1AMUcuwKLEOy4XbQf0Qm/wAryqCMF/BDO5IkbDVRaJdNC6nZksqmTlVURMkqVHgj1/420Hum7gV999EZlEEQNjflz+3o1d+/fwhSWLZFWDaCpJWiIBQ9PACRUXZF4gaX35BAY4Mo+TKWrIKxrkiot32BvGWbFLAADLNg9YdsVMQcMQzMW9IAGCByqNb3eQQikOD6OYTMJbmIEv5CGD+sfTjga862FRWMZl60fwP/snce/O4yialkqqZBWOHEHBSzZ+AtHO2jyXrh/A/qdP4Yxzmy/xXhyRMRz0YipdwNOHY1AKAq6EhD1HEvjKj0lK1LLUBP4BwEw8hTd/+zEsjsgYi8gYC8s4mSAEmJLLeiilC7ZOskpdWdUTBpWjR6FNTYHzeCCfddasrxcy1e1JXp+IQkaFktfgWbwYxcOHoZwYd41kKVZHVvVbsDIxgcJLLwMcB/8F51d/E44jPW7jO4llkM5kzXHoRelwOCzfNIB9T5zC0b0x5yTLZhfs9bmXyIgfp15JOgqBiP7B2yySFbyUXOvoedHpTVSO5+D1e5DPKMgminjkbmI53Xr5cgwva+7zSO2ChayKfEax5r1aQaEicKdZSGGzPLw9t6BVlG74Q0B2boLG5iNoV5Za0JCOFRwn1R54+hQ0RcfQ0gAWrV7Ym+Q9Ic5v2rQJO3bswI033oinn34ajz32GD7ykY/gne98J5aY6U8nTpzAxo0b8bRZ3MhxHP7P//k/uOOOO/Czn/0ML7/8Mv78z/8c+/btww033NDNH6dlUJ/3XEmv9t0bjyqDE3LYH3u5+pPbmsmiiwNqF9QQKZCbFGeqIwsVT9/3Ck7sj0P0Cthx85auXuwbxbgLEZOoGAYJo6gG0zIY1JMQzQUVnf+xQ+REvCp1JQBg04VmIayqo6jp8HOmkuUhF3zNsgs2Vm5oiIo2PYWRFeTiX7eUuAlQy+A9zx6fpeikD5+AwZPFRyDSWaX8snetx7v/8gIsWde8kiV7BDz06dfgX//oItzxrm14/Tnk335pwItzV0SxJCJDNefeJLWI54/N4L93n8L3HzuML//3Pvzg8cMAnClZWpszWQAg0a6sGnbB7E6iYslnnQW+ikOBLuoqF4adjnFvNFubNed05M2b64a5lM1lddkuCJQsg82EX5QrWa4f0pyimfkkecsWBC6+CMLAAIKXXw4AKDqI9XcLNOzliV8cRGIyB39EwvlvWt30+3gkwUpMbVfNKlp2wdaImhQh6aqGwdWu53AAugGkeUny6UJVslrpyqoMvFjIm+RAC0pWt/DjH/8YH/nIR3DFFVeA53lcd911uOOOO6yvK4qC/fv3I5st7SB94hOfQD6fxy233IJYLIazzz4bDzzwAM44w1lqznxD0drlmptfG89zEEWyKyTqAQB57Jp6Hm/CbNtNKcK9BSWrIvgiU1ARMec9FnJ8+6EXpvDs/WSg/7Xv3YjBxYGuHk+jGHfO47HseFo8bilbZfANAPHD4HIzGAhImEwVMJ0uYnGkvDwql1KQi6sAB6wye8Bo6IWfKllmnYFq2gUdKVkjNGFwCqMrN+Hoi9OuzGUBwJWbFiEsixhP5PHgPmKVoFH1qeMxwAN4PToEsbN7W5IsQhpr/RoRlj141SryuzvMS/jPJ6awJuLDn/zxqwAAhalpvHL/FyHpKu589zacThdxMpHHqUQOp5J5pPIq3nl+Y8VHp+mC7dgF6UzWoUMwDGPWDT230wy9qGIVBIB8jUF7eo0t5FQEO1BIXOrIqr54s/qxLq5hFaSwurJeBgJmX16X7IIAsGwD+d7Tx9PIJouOwnn6S8kySdZE4wUpx3FYftddgK6Dk8zZzTmyCwLUIpuz6h4ufdu6ljdwwyM+ZBJFJCazWLSqdeWiWtpnM/BGQ4C5Z6YWtZavtVqSbBJqZg/jQp3JAohlMDaecZwwePpwEtMnMhA8PNafX32cZyGhZ0jW4OAgfvKTn9T8+qpVq6om391666249dZbO3loc4a5TBak8Eg8VFWHqJPdjBPpGkEg1kxWexHuqqYjpxQRMaOwvUOdqQWY70hM5vDr7+8BAGy9fBnWzYN0Hn/ISSFx1CJZVVEW474Uk6lC1YTBVIxc0AMRr9VPQnvaIiIlWRVKloOAFBp+oU5NYfQc9xIGAaICvensJfjxU0dthbxkRzY9kQKWAoFQz1xyAVQPvvD4S4T4dWuj4P3Oy47taDddEAA8K1YAPA89k4E6MQnPovLrRa0SYopqM1lASclS8lqHlKzaG2aGYTQOvaCwK1k0NaKLJMsfljC8PIipY2kc2xvDhgsaL7LKlKw+IVnJKWe7/pxY/vufy41Ue9jL0g0DWHte6/fayKgfJ19OtB1+UWjTrSNGI+COajA4AUpBh7e1SxN0qmRJ5Pe5UJUsoPmurD2/IZtRa88dbcs62i9oiearqopf//rX+Pu//3ukzNK28fFxpNPNlxAyOMdc2wWB0sVFgBm5XZiq/kSqZBUSpBSzGdjSBTNFDZyQs4qI5eGFR7LUoob779qFYk7F2JowLr5ubbcPCQCZyQLqkyzRjNtXHZAsaimrZheku2ahwZLFK1M0+5c8pWRBAFBjdCar8eJSHCZzSurkFEZXkh3X+MmMpSy0C2oZpBjwS9CLRWQzxLoSHO6uGtkspKplxKWZzGox7k5h9WSFWt/55iUJnuXk37x4qHwuS43HUTRntXzbzqn6+nym+s45LSQu5FR4lnZAyaqjWBQPHYJ6+jQ4SaqaiFgGqmRNvWS7jna3V3D5puai3PvJLhgZJYvydLzQUsKdk9RJt0A3FniBw2vetb4tW1dk2LmCVw/tRLgDhGTxtJC4jYRBzZzJ0kRyrVvIJKuZrqxiTsVLz5wGwAIvKJomWUeOHMGWLVtw7bXX4sMf/jAmJ8kw9Fe/+lV8+tOfdv0AGUroCskyL/acIQKGgZlCjZkrXxSAeZHONRnjbrMLkiLijFVE7DGVh4WER+4+gKljafhCHrz+xrM6bi9zikYzWYAtxt1BITENhZhOz36/dJySrNKCntoFB0Tz+aZdkH4vwWHwBUCUrEDUC39EgmEAU8fcUbPOWR7FGSMlIjUQkKAcP4GCWa4cGAm68n3mCnQ2ophVLacAx/OWvalaIbFT0OFyoY3gCwDwri5ZBu3ImamC0hln1JxrsmayKpQsr9zZmSyljiuBWgV9288FLzdIohxcQxSsQhKYIMp3N2eygBLJOro3VrtX0QbrKVzvpwvKAY91f044VLPssFIn50DJGlpKrlPnvn4lBsba2/yxbJIt/Mx2tBvhLkSjEGghcRski16bNJ5s8i3U4Augua6sA789DbWoY2DMj8Vr57ZmZr6i6dXbxz/+cZx33nmIx+Pw+Uq2kbe85S148MEHXT04hnIU5yh5yA7JLPfTRRkeFUipNUgWL5QiupuxDOoakJ8hf/YNIl1QwQlZRDLkoYVWRLznsXHsffwkOA646oYzERzoXNx3s2g0kwU46coyf5+5OIbqKVmmXTBoI1lpc5c3IphKqRV8YSpZDuyCdCZLnSKKLFWz3LIMks6s0jzSgF9C8chhFLxRAECwyd6qboPuKOu6AbVYGiTnzGu/Xpgd4+4EhqpCN+dn25nJAuwJgxUkayexCvrrqEG10gU99uALOpN16hSMdmPLTNA+pGoBByWr4MWN30j0AgOryJ9nzELmLtoFAWDx2ggED49soojYyUzD51Mlq9cJFkB+hnZ6o+YqXRAAzrlyBd7xuVe1FHZRCargtatkFdpUsgjJMpWsNtwJVMlSObL+WchKVjNdWSzwYjaaJlm/+c1v8LnPfQ6SVD7QumrVKpxwcaePYTZohPucKlnmDq8qeOFVgIxaR6WyFtBNkKx8AjDMxZtvgJAsMWPZBRdSEfHk0RQe+SmJ0j3/mjVYvnF+/ezOlKwoAAeFxLmYFQpRrZC4ZBecrWRFLSUrAENRrCRDYagJJWuakixzLuuoO+EXAOnMkkQeUb8HA34PlKNHbR1ZvUWyRKlUzFtWSGwqLHqLSpZus5YLwfbUvVLCYLldMFunhBggdiKaQFY5O0B30ot5FeLICODxAJoGtaKvsVXUsgsaqorsU08BAAIXOyBZADC0rvzvXbYLih4BS9ZFAQDH9zZ2NZQU0k4e1dyhnd4oxUF/mlsQRB7Dy0KuLIbDpl0wmyy2Zb2myrLUYrqgEI1C0Mn9oR0lSzPHYDQztmAhk6zKrqxamDiSxOTRFHiRw4YLWeAFRdOXNV3XoWmz/6GPHz+OUJs7kgz1MdfpgvbvpZkkS0UOWaVGB4iVMNhEjDtVvbxhQJRMu2DWsgsKDuZs+gH5jIL779oFTdWxassQtr/evT46t0C7qvJpBZpWPR6X2rK0GQfBF0Fzzq+qXZAoJKEyJYuc/yGekix/afaL50sR8nVASZY2HYOhaSUl67A7ShYAjEVk3Puhi3H3TRdCFHgUjxxBwdubJIvjuLI4c+txmfwcRoszWXQRw/n94DztDUfbEwYp9EIB+d27AdRJFjRVLI7nZpGd0s9M+t48Zrm9W5bBWiFG+d27oafTECIRyJs2Onuz4QqS1WW7IABrg+jonsYbbrqpZPF9svPdKsnSNR2qWaLba/Y0OeCx5hqdhn5UwjCMkl2w5ZmsqDWT1SrZMwwDurlxp+rk87mQ0wVpVxYApGO1nQtUxTrjnBH4gp3tguwlNE2yXve61+Fv//Zvrb9zHId0Oo2//Mu/xNVXX+3msTFUoBski15cNEGGVCSLocncZPUnW11ZTShZVrIgWXyn8xUkq15HTJ/A0A08+IM9SE7lER6WccX1m+dlypYc9FjHlU9VDzcRWgi+iNUJvghWUbJCfCnCnSpmwsAAOL7x5UwYGCDT9boOLR7HyAqyMTRzOltGItrFWUsj2DhGCFzxyFEUTbtgpzuyOoFq4Re8bNoFcy2SLDqP1aaKBZTsgsr4uKWs5XfvhqEoEIaH4alRIGwlC/rEWbv59uALACXLoEvhF0oNuyC1CvovvHB2mXct0IRBii7bBYFSX9b4S3FoSv2+ImpkwDy85rWCZrqy7KDEG+jNRX274ReaokNXCeFuzy5ozmSlW7s2GYUCDIVcGxSdnJPSHPSWzVc46coq5lUc+C0LvKiGpknWbbfdhsceewybN29GPp/Hu9/9bssq+NWvfrUTx8hgomQXnMOZLK9NycqR4diJbA3LTEtKVnlHVrqgQjJS8JvrbtGBBazX8ewvj+DwrmkIIo8dN22Zt7GnPM/BFyTHVrOQuIngi0HTLlgZ4a4UNOQz5CZHrQpAiWQFKMny+EvzWA4VT04ULXVUnZqCPywhaCYYTh51T82yI3/kGIoeQiZ6TckC7DHuJWJN7YJGobWFjNWR1WboBUDOOapiFg8fBlCyCvrPPbemHapeJw/dyKIzMjRhsNhhJcvqx2oU3W6HnWR5w4DQ/evH0NIAfGEJalHHyVdqFJOboHbBPuFYiFrzSTUcHzVAlRde5OZN2FEziIySGdlWC4nphgbHtW7P4/x+CAZ5n+JMa2nXWsK0jvM8FIWcmwvZLgjYwy+qX+9ffnYCSl5DZMSHpev7f2O8GTT9SV62bBl+97vf4U//9E9xyy23YNu2bfjKV76C5557DqOjCy9uey7RzXRBVZThyZObx1SuRoy7bd7GMWzx7YBZRKyQm7Iu8G0Pxc93HNsXw9P3kVmSy9613lJW5isaxbg7n8mKY9C0FMQrSBYNvZBkoSxligZfBKwy4gBU2pHVhK3Umsua7Ez4hR1GsYjMdBrgePBCiaT2Euiucpld0NemkmV1ZLUe324dC8dBqrAM5p6tX0IMwCLylR1ZQOka2zEli5I3mytBz2aRff55AA5KiO2w2wV982OBw3Eclm8ix3KsQZS7FXzRJywrPEzIRipWqGmrrgbLqdKjqknJJtkcuaSgmx6Sf7ay7BQcx0EUyPlUTDYOXakGe38fDc/oRWXRTTTqyioLvOiTz7FbaOnTLIoi3vve97p9LAwNYF2Eu9CTpQleeAvkg1ZbyWrHLkhemy6oiBbModNIoK8TatLxPB747oswDGDTxYux+ZL5L7P7wxKmUZtkiQ3TBc1FYD6BQfPGFc8WoeuGFbCQNkmWXcUCSkqWH+aFXgpAi5Pzp5mAFHF4GIX9+20JgyG88tykq+EXFMUTpfh2f0TqyRtQtUJi3ktnsloMvjDLPvmQO5H20urVyD33HAqvHIKh6xZZqdczRX8euYqS5a2YQ3M7xr1aH1L22WcBRYFn6dKaFseq8A+Rz1Uu3vXQCzuWbxrEgadOk76sN59R83k0wr1frvWBiATRw0NVdKSm84iOOmvErded1gtoJ/ADKH3WWo1vpxA95Dwqplq0LZpWZj4SKUXqL3glq3ZX1tTxNE4fSoLnOWy8aPFcH9q8R9Nn849+9KO6X3/f+97X8sEw1IelZM1p8EWJZEkFsrA6nWlkF2xGyaq0C2qIFMwdqGj7u9zzFZqq45f/sBu5lILh5UFc9s71jV80D9Aoxp0qSno2C71QsBbjFmw77QMCuQnqBpDIKVZvVrX4dqBEsmQbySopWc4Xl6WuLDJbOLqic0pW8ciRUrJgD85jATUKiamSlW8twl1Pk39rN5QsAPDaEgaLBw9CTyTA+XyQN9YOj7BmsqooWXShSy3abitZ1RZvmcceB0BUrKYIB8cRy+Cxp+bFPBYFDb+YOJpCPq1ArqHilpSsOTu0joLjOYRHfIiNZ5CYzDVNsuayosVNtDqLRlFPWW4Goof8+ymZNudFQyFrM4SRrNpdWVTFWn32sLU+YCih6dX6xz/+8bK/K4qCbDYLSZLg9/sZyeogavn4OwlqZ1EFGVKRfIBOpE5XfzJNtWolXdBuFyyQDzI/OD+sL53A4/e8jFOvJOH1i9hx0xaIUm9cxP2h+nZBPhQCBAHQNGjxOPixiihXQSRzI4UkPIUZhGQRqbyK6UxxFskKVXSE0XRB2TBvnh4/tNhL5G2bOFdoV5ZmKlkjZox7cjKHfEZxdSZOOXq0ZzuyKCxVp0qEe6tKlkaVLBdmsgBYdsHC4UPI7iQlxL6zz66bXGgpWVWG7OnPrKk6NEWHRJWs8ZMwdN1RyEot6JpuhUHYN8xK/VhNWAUphteZJGv+KFmBqBeDSwKIjWdwbF8M685bVPV5VoR7nyhZAFF1YuOZprqy6nWn9QKokpWO5aGpetNzZW6NQ3hkAdCBYpVAJSfQafJpJFL1c7oQUasrSy1qOPD0KQAs8KIWmr5TxOPxsv/S6TT279+PSy+9FD/96U87cYwMJrbvWIntb1g5p8PzdrtgWDOVrGytdEHzBt/UTJZJyGi6YEFFxIyF9jShTvQSXvrtabzw8HEAwBXXb7ZuTr2ARjNZHMc5KCSOkv/bCont4Rc0JnaWXbBo3oR1c+EiBaGaARtiE+eKYClZ5NyTAx5rF9bt8Ivi4SMomkqWv1dJVlUli/ZktTmTFXSJZK0ylaxDh5F95hkAgP/cbXVfY+2cVyHV9lmpYl6FuGgR2TxQFKiTNa5/DlEtRU6dnkZh/35y3Bde2Pybrno1+f/Y1raOzW0s30Q2z+rNZdF0wV600taCZZ1rImmv15Usf1iCKPEwjNoBCfVQb9OjGXhks9sz1xrJosEXRrC0cceUrOpdWQd3TqCQVREalK3POkM5XBHo161bh6985SuzVC4Gd3HOlStw4bVnzGn6nMdmFwwZZJE41TDCvQklK2cuxE2ClsoXEcmbi5+R/gtSiY1n8NA/7QNASPPqrcNdPqLm4KSQWGwm/KIKySrZBctJCQ2+kDRKskrpgkIzM1lDlGSVAlysUuIj7s5lFftAyZKqzmSZJKvVmSwX0wUBQFq+DBBFGLkc0g89BADwnbu97musdMEqizre1p1VyKngRBGeRUSJUU60ZxmsliKXfYYEdXjXr3eclFmGre8AbnkRuOjDbR2b26BR7sf2xizFqhIlJWvODqvjsJL2muiMKvb4TBbHcW3NZdFNHKldkmWm1tJwmWZBgy/0YBQAwAscBE+feFlbRK2urBetwIvFfbVJ4iZcO3NEUcS4S351hvkDK8JdlBHVCbmbKdQgUZaSNQPoDosAK+yCyWICkSy56fqG+6s1vJhXcf9du6AWNCzbOIDzr1nT7UNqGo1msgBAiBIS1VRXVhWSFRosV/joTJbHUrICUGNm8EUz6YIjVUiWOZc16fJcVlkRcaQ3/eqWXTA/W8kyWpzJ0mwJXm6A83ggrVgBANAzGYDn4Tvn7LqvqTeTBdhj3M3Fr0vhF9VS5LLPmurbefWJYU1wHBBZNu+YypJ1UfAih3SsgJnT1VPn+lLJGm4+xt3qTutha1pkpPUYd2pHbjf4whMgm1lK0Xmyox1UydID5Lq90FUsoHpXVuxkBidfToDjgI0XMatgLTR9Nt93331lfzcMAydPnsS3vvUtXHLJJa4dGMP8gGVnEbwImySroGeRVbLweyoGeq1QAwPIJ5wNYVcEXySVhFVELA31lspTD4Zh4OF/2of4qSwCUS+u+sCZVppeL8GJkkXDL7T4TPUnVCFZcdM/r+sGMnHTLlihZFGSJajmCeIJQIu1EeFeRck67aKSZRSLUE6cQGEsCqA3O7IAQDJJSJmSRcuI21WyXKxokFavRvEVUofg3bChYdFxPlNbyQKIgpeZKbge414tRS5nKlm+7S2SrHkKjyRg8RkRnNg/g2N74xgYC8x6jqVk9eD1sBYiZldWcioPQzcc/WzdmLl2G+E2Ytzp56zVImIKKUiOQW1Qgl0LdANI95FrU68qi24jNCQjNp6xrKA08GLllmEEB3rz3jYXaPpsfvOb31z2d47jMDIygte+9rW47bbb3DouhnmCUrqgjCHNgKFL4PgipnJTWOFZUf5kwQN4I0AhQchTI5JlGLMi3DNKEuEMuen2UxHxCw8fx8vPTIDnObz+xrN6NoXHZwZf5NMKNE2HIMwWw62urFiNOQwbyaJhF9NpQrKyiYIV5+6PVNoFyU2YV2kqoQd6mizWmzlXKMnSEwnoxSJ4SbL6ydKxArLJoiu/H2V8HND1kpLVoySrMs4cAHjZjHBvdyYr7F6CqHfNaqQfJH/214lup6BKVi37tddHEwbdjXGvnL3R0hnk9xELsf+889p67/mI5ZsGTZIVw9bLl836uq73n10wOOAFz3PQVB3pmQJCFUmp1VA6L3pZyTLJZSt2QfPzKPnaG4eQwmTzV3VopqmEbqYL6jLZpOnVIBK3Ye/K0hQd+58kgRdnssCLumjaLqjretl/mqbh1KlT+MlPfoLFi1lGfr+BSuUGL8JvaDBUc3alZleWuYB2EuNeSAG6uXAzCVlWSyBsXp+Fgf4YpDx5MIHHf/YyAODit63F4jMiXT6i1iEHPdZiKJ9Sqj7HCr6YqWUXNH+vZcEXRL1KmX7vgLlIoTAMA5mCCgEaeI08R6MWQ4+nKUWEj0QAM3WOJgxKPhHRReTm7Fb4RfHIEaiCF5pIFh49S7Jo8EW29PvmLCWrNZJl9WQ1UJuagbS6ZL/1NQi9AIBCIyVLruzKckfJqkyRyz3/PKDr8CxbZs199RPoQPyJA/Hq5bymktWLyn4t8AKPkJnI5tQ6ZxVU97A9ra2ZrDozks1AipBriqq1Ng1Dk081iaiuvawsugl7V9Yrz08in1EQiHqx4sz+WKd1Cgt7mo+hIewXfEkHdIXsPE/lpqq/wOrKchB+QZ/j8QMe8gHOaynLLthMwex8RTZZxC/v2gVdN7D2vNGqO7m9BJ7nLDWrUSFx45msGAZN/3zMXMCnYuTmXLnzm1d06AbgR2kGSE3lre/XTPwzx3F1LYNuhV8Ujxy1kgU9stCzO9RW8EVOtaxdvDWT1SLJMmOS3VSypNWrrD/7G9juDN1oqGRJFbNorilZFUXE1jzW9sbqWy9iZHkIcsADJa/h9KHZny29D2eyANt8ksO5rGKVgupeg0WypnKWQukURbfsggPkOq4ZrZIsU8mSyO+vl0mvm7B3Zb34KLkGbrpkMfgqbhaGEhydzZ/85Ccdv+HXv/71lg+GYf6BF3gIvAFN5+DRDRiqWdxaS8myVAoHSlaFVVDXDXBKAj5z7d7MnM18hK7p+NV3dyOTKGJgzI/L37uxL7pgfGEJ2WQR2VqFxAPNzGSRBS5Vsqz49gqSRa2CflpEzAnQEuZCvQVbqTg8DPXkyQqSFcaBp0+7VkpcHnrRmyoWUFr06KoBTdEhSgI4maYLNk+yDMOAZpIsN2ey5E2b4F23DuKSxfBU9rNVoFjQqIBSdyYLsClZtpkswzBa/ixXzmT16zwWBcdzWLZpAC8/M4Fje2JYsjZa9vV+TBcEbNY5hwmD1nnWo5sxgGmTFDjoqoGMQ5skRcGl4AvvYBjAaWicB4amgROaI0nULqiJXgBZRrJM0K6sqeNpqEUd4IBNFzP3WiM4Opufe+65sr/v3LkTqqpiw4YNAIADBw5AEARs79ObxEKHRzSgFTnwOmfZBSfdiHG3kgXJojuraIioMwAATeRdtRJ1A0/9+yGc2D8D0Stgx81belbJqIQ/LGEapDOjGiy7oIOZLKpkxc3OIjpUWxnfTkMvBiXTsiYFW0oWpKinZE26pWQdPYqCFAXQu1ZBgOzkchxxdRVyKkRJsMqIWwm+0DNZS75wK10QIAXJa/79vsZPBFAwzzfBw9csAi8peCYpGhsDOA5GoQBteto6h5qFpYzJIvRiEbkXXgDQn/NYFMs3DRKStTeGCypSVQ29/4IvgOa7sqjC2cuLel7gERqSkZjIITGZa45kuRThTkgWoAkStGTSclY4BVWyVF4GkGXBFyaokqWaqY0rNg8hPNQ7HZ/dgqOz+eGHH7b+/PWvfx2hUAg//OEPMWCevPF4HO9///vx6le/ujNHydBViB4OKAK8ZkA3lazaJIvaBR0oWRbJIq9J51VECuYFLuzvadXn0AtT2Hn/EQDAa9+7EYOLZ6dq9Sr8ofox7kIzPVlmp8k0ncmK0/j26krWkKQCKsyOrOaTBSnEYXLO2UnW8PIQOA7IJIrIzBTaJkZEyVoPAAhEezPoBCD2SskvopBRUciqCES8lpLVSvCFnjaVQo/Hep+5hpP5D2rboqSIkySIo6NQT5+GMj7eMsmyAg68AvK7X4RRKEAYHIS0enVL79cLoHNZE4eTKGSVsth8K8K9h6/31UATBp12ZfVDuiBAbJKJiRwJv9jgjOAYhmGLcG8v+MLjNzeABAlqPN4UyTJ03QpT0jhybWDBFwS0K0s1NwNY4IUzNG2mvO222/DlL3/ZIlgAMDAwgC984QssXbBP4ZHIaWLoKClZ2Roky9eEklVhF0wXVESL5AKnR93b4Z5rJCZz+PX39wAAtl6+DOte1V/D7I1i3K2ZrJmZ6gWkdpIVNNMKFR3Zoop0rDrJspQsD1WyAtDirStZgrlA1mwky+MVMGCS4Yk2wy8MRSHx7aZdsFeLiCkqEwZ5nxl8UWieZNGdYiEU6trCOt+gIwuYbRcE3JnLorM3HllAbiexCvq3n9t3JMOO0KCM6CI/DAM4vr9886Xf7YKJiVzNImY7lHzv2wUBe/hFMx1hmjXD1e5Mlsdrrlc4AUpspqnX6qmUFcSicuTaIPWwsugm7F1ZvrCElVv7J/25k2iaZCWTSUxOzl5gT05OIpVyt8iTYX5AoiRLgzWTVZNkUbtgroaKYUdFR1amoCKSzwAAuIHeTOBTixruv2sXijkVY2vCuPi6td0+JNfha0CyqF0QikKKYWe9ASVZMwh4OEgiOb9imaLNLlhBsopkATIgmt9TCkClSlaLM1kAoE6WB7i4FX6hjI8DmoaijxxbZRx9r8EefgHAsgu2pGRZ81jdswPTZEE5UHtBVy263g2SRRfTkiwiS+exzu1/q/3yzeTecGxvBcnqU7tgeMgHcIRA5GoksdpRGYjSq2glYdDavOE5iFJ7QQqijRQVpmeaei2dFeVkGYpCzktmFyyB/m43XbS4an0Lw2w0/a/0lre8Be9///tx77334vjx4zh+/Djuuece3HDDDXjrW9/aiWNk6DLoRUvTeAcR7q3MZJWUrIi5M96r8e2P3H0AU8fS8IU8eP2NZ0EQ++9C1EjJ4n0+cKbSUdUyaCut5gpJyzI4MZ2zLDOz7YLk8YhgLlY8Aagxco6Jg8157gFAHB4BUG4XBEj4BQBMHG5vw6h4hFhFiyHyfXpeyTJ3l6mlp53gC7qQEULuJQs2i4ITJUuuQrJcKCS2gi8kHllz3tl/3gIgWaZl8Nie8nsDFXn6TckTPLxV0tqIcBiGYV37et2e1grJsuy7AbHt80AQeHCmB7UYa+46riUS5D3C4dLnlClZFi64Zg2271iJ7W9Y2e1D6Rk0vQK888478YY3vAHvfve7sXLlSqxcuRLvfve7sWPHDnznO9/pxDEydBl0F1vVOAQEszRYzSCrVLEDNDOTVcUuGMmT2RzJXAT3EvY8No69j58ExwFX3XAmggPdmTfpNBrNZAENColFCZBMFSMbw6DZlTVxiqhecsAz68ZG7YJRoaRkaTFC4ITBFpSskdnBFwAwQsMvjiYdWXxqoXjkKAD0RfAFUJqTmKVk5fNN/zuV4tu7Zwmmizq53kwWLSPOl1pNaVdW0QW7IGamoCcS4Px+yJs2tfx+vYKl66PgeQ7JqXzZArykZHXryDoHK8a9gXVOU3Tr36HXlaywjWQ5vTZYoRdtJgtSCBz5jBVmmiNZlsoeDvVFEInbGFoaxIVvPqNvQrzmAk1f1vx+P77zne9genoazz33HJ577jnEYjF85zvfQSDQP8P9DCXQBnZV4zHgD8HQyd+rdmU1E+FeYRdM5YuI5MgOs3+4t+aYJo+m8MhPDwAAzr9mDZZv7E0lzgn8kfpKFgCIUaddWTMWyYqZCxGaYmQHJVkhi2T5oU2bSlYLfWrV0gUBYHhpEDzPIZdSkI4Xqr3UEYpHjsAAhzzIz9LrJEuqKCSmSiUMA0ax9nlQDXQmiw92j2TlMy3OZC0hdkG1LSWLvJ9x7BUAgP+cs8GJ/b9okWQRi9YQ9fLY3tL9gc7i9JuSBdjCLxokDJYR+R5f1IeHZWKTzDuzSQKwhV648zkQeVPJSqSbep2WMOdFwxEotDS8x0kvQ3fR8t5RIBDA1q1bsXXrVkau+hwe086lch4My2JpLqtawqBdyWq0i5U1F+BmhPt0LmEVEQdGeye5Jp9RcP9du6CpOlZtGcL21/e3lE7LiPMZBZqmV32OFeNesysrSv6fi1sky5rHGphNSGi6YJA3iY8twr2ldEFzjsvI5crmxkRJwOBSM/yijbms4tEjUDwBGOYlllosexWzgi+8pd+RkWsuxl1PkYUPPw+ULG+dmSy6W1som8miStZ4y0onXVDrB/cD6N9+rGqwLIM2kgVqF+yzmSwAiAw7s87RBb3oFXr+30H0CJY92mlHWMGlImLrGMy3KSadh28AgJ4qhfKUUkD7fwOEoXPoQ4GewW1IQXLB1AQvRjwG9HoJg3Qmy9CAfKL+G1coWdO5GCJZ0zLRI3ZBQzfw4A/2IDmVR3hYxhXXb+75m2QjyEEPSQIzgHyNnUpKfBzFuJski/Zu1VWyOELEdF2CYc4DtZIuyAcC4P3EylNzLquNUmIS3x4FAPhCnp6fzfNaSpY5k+XxWCuZZueyNLqQ6aKSVWhCyVLymmXlojNZRjYLbWampe9NF2/qvt0AAP9CIllm+MWJ/XHo5gYNVbL43v6IVIWlZDUgWf0S305RUvCckRx6XZHajG+nEEVyD1ZSTV6bkqZdMBJmdkEGV9CHlzUGtyFRJUvwYlg0YCh1lCzRa5u3aRB+UTGTFc/PWEpWKwvnbuDZXx7B4V3TEEQeO27aAjngzk1iPoPnOcihRgmDUQDNkSzFfK9qBZY0+MLPkeeoBXLj42QZnEmWmoVQwzLYbimxoapQToyjIJGEzF63CgKz0wWB8rmsZjAflKw8nclykC4IlOaoeK8XgjnPp5xozTJYNDcMMDkOiCJ8Z5/d0vv0IkZXhuH1iyhk1dImhtHHdkFzJivZSMmySFZ/qCZOFTyKUhCNOz8/JUbFTLMkywy+CNlIVp8QX4bugJEshoagF35NlDEk6o1j3K25rDox7sUsoJoXQFP9ShRKJKsVC9hc49jeGJ6+j8xVXPau9RhZ0bvdXs3CShisEX5hdWXFa8zmVSFZyJKbWrXAEKpk+UHOGa1ALl3i4GDLi7PaMe4lJasVS1jh4EFAVaGEyVxhP5CsynRBAOB8rSUMWkrWPE8XFDy8pUBWTxhsLfyCLqgFrQD5zM1W59hCAM9zWGoW1FLLoE7LiPvQARAeJp+RfEax5gCrgRZe94tqEhk1Az+6ZRc0LX5Ktrl5Ud1UsoRI2Jb22B+/E4bugJEshoagFgZN8GJA0Cy74ESujRh3+jWhlDSXS09BNu9DrSTGzSXS8Tx+9d0XYRjApksWY/MlvTND5gYoyco16MqqPZNVIuKUZAk0vr2OXVA2SZaaI+SnHTJeK/xicEkAvMihkFWRnGo+ojy/axcAQFt6BgAg0OMdWUD1+STea5KsZmeyqCVnHvRkNVrUWQmDtp9bsrqymleyNEWHrpFzV1Tz8G8/r+n36HVUzmX1axkxQD439FpZbz6pXzqyKMLDzgI/KKzgC7eULBrWlXcWvEFBQ3m4YNj2O+kPdZGhO2iaZP3whz/Ef/7nf1p//8xnPoNoNIqLL74YR8xuGIb+Au3tUAUZEb6kZE1lq6QLAjaSVSdh0G4VNO+uXJIoY6rIgw+0ZgGbC2iqjl/+w27k0wqGlwdx2TvWd/uQ5hz+RnbBKCVZjeyCJMKdNwCveT+sbhc0b8K6qWSZqpfQQrIgRYlklSuygshjeCkhAE//xys1wz1qIbebzNooQ8sA9JmSZSdZvtbsglqaRrh3X8lqZO+t2pXVRiGxZRUEUbIWQj9WJSjJOv1KEsW82rdlxBROeqOsTqY+WdDTn7np4AuX0gU9fnLNVWyfNyegKjuCodIcJlOyGNpA0yTrS1/6EnymveGJJ57At7/9bXzta1/D8PAwbrnlFtcPkKH78NiUrCinlgqJaylZviaULH9pkcynyGO5gHde+/Mfv+dlnHolCa9fxI6btkCUFt5F2NegkFgYdEqyiJIV0jlwIATHF5q98M0UzZuwQW7aqqlEiG0onrW6sgDg3B0rwfEcDjx1Gv/1nV2WnccJ8rsIySqan4NApLeTBYHZwRcAwMnkPtCsXdCy5IS6Y6/VNd2yAjVWsqokDLZRSEwX07xWAAcDvm3bmn6PXkdkxIfwsAxdN3DiwEypjLjfSVYdVafv7ILmz5xLKWUbFLVgBV+4pWQFCMlSdR56wXkVh25GuOv+0gaQ2Ce/E4buoGmSdezYMaxduxYA8Itf/ALXXXcdbrrpJnz5y1/Gb37zG9cPkKH7sJOsEKc6ULLMhW+9riyqcvlLi2RvZgYAUAjPXxXrpd+exgsPHwcAXHH9ZutmstDgb0Cy6ExW1TJiYDbJMsgCKzhYnWBnqHVDIwsVLU2+LyVzrYAGX2iTs8/jM7aN4uoPbYHo4XH0xWn82+3P1e0Fo9CLReQPkL60PMi50Q9KlpvBFxot/OwSybL/DI7tgnmXlCzbPJa09gzrc7LQsHwzue4f2xMrKVn9ybFsCYO1k/b6LV1Q8onWZpmT8IuipWS5ExwlBUwrMy81lQJKr026lzgZRIkH36fkn2Fu0DTJCgaDmDZLQH/1q1/hqquuAgDIsoxck958ht4A7YnQRBlBQ4VukqyUkkJOrfI7dzKTRUMxfKVFhj9DLnBaF1PH6iE2nsFD/7QPALB9x0qs3jrc5SPqHqyZrBrBF9ZMVjIJQ62yk2kjWVGfBxGd3MjkGqoPtQuKJslSUzS+vQ0li9oFp6ufp6u2DOPaT26DHPBg4kgK9/7/nq27UAKAwr59gKJAGBhANktshv1AsmhAhKboUBWyIORkOpPVbLpgd5UsOo/lkQXwQv1bYMkuaCuLbUvJoudxYUHOY1Es31QKv7Bmsvp0MRt2ZBek52R/2AUBZzZJik6lC2pCkyTLTBfUvYGy92FgaBVNk6yrrroKH/zgB/HBD34QBw4cwNVXXw0AePHFF7Fq1Sq3j49hHsCuZAUMFdC9MHSy6KqqZtkLiWuhoiMLAPxZUgrLzcPd3WJexf137YJa0LBs4wDOv2ZNtw+pq2g4kxUh8eUwDGuYuAw2kiUKPEYFco4Jweo7mTT4QlAJydHMkkl3ZrJqKLIAxlZHcN1ntiM8LCMxmcM9X3u2bklxzgy9kLZsRc7sEAv2AcmSvAJgroEp4bCUrIJzkqUXCjBM+w7fpZmsPJ3HqpMsSFFZwgyUSJaeSlU/t+uARsELan5BzmNRLNswAI4DZk5nkTRLyOezRbwd0Bj3emSj2GfBF4CdXDbuyir1ZLmVLmgjWbXCl6qAWplVDzn2fiK9DN1B0yTr29/+Ni666CJMTk7innvuwdAQWSQ/++yzeNe73uX6ATJ0H3Q3R+c9kJQiAM6yDFady7ItoGvCsguWFslhUwltR53oBAzDwMP/bx/ip7IIRL246gNnLngLgT9Sn2RxHg94k2hVncuynyO6jiGOnGOGf/YiQ9cNZIt0cWoqWQlCyNvpU7MrWYZeO9wiusiPt/6f7RheHkQupeDnX38OR1+srn7ld79I/rDhHAAAL3B90Z3G8ZxFOOiusxXh3oSSRVUscBz4QMDdg3QIuqDz1unIopCqkCze77eU2mbVrKJ53gpaYUGVEFfC6/dgdBW5hxx9kdwLuD7NOqaKTjZRtBLrKqH0YVy4044wQzdKdkG3lCxzTlrjvY6VLPsGkE5JVh/9Phi6g6Yva9FoFN/61rfwb//2b9ixY4f1+Oc//3n82Z/9masHxzA/YN9d03JFBCTBinGvWkhsKVn17ILlRcSGYSCcIwt238ho+wftIl54+DhefnYCPM/h9TeeZVnlFjJ8ppKVzyjQa6TvidEogAYky9CBYgoRnVyKFO/sSxINvQAATiGLVM0cUG4n6l8wN4igKNASibrPDUS8eMunzsXyTQNQCxr+89svYN+TJ2c9L7+bKFn68vXW6/rFBlU5l8VbwRfObeLWPFYwCI7vzqq6kHFuTapGsoDW57IyLx0mrxcNSxFbqKApg/GT5DPN96mSJQc81rlWK22P2gX7KS7cqV1QKWhW+IlrPVkSubbogtTw2k6hU1Wa46ByZGOsn5RFhu6gpbvcb37zG7z3ve/FxRdfjBPmTeb//b//h0cffdTVg2OYH+AFHjxHFtKFqQSifql+IbGTCPcKu2CmqCBsLmTCY/Nn8XHyYAKP/+xlAMDFb1uLxWdEunxE8wNy0EMG1Q0gl67eRUJ3+9Vq4RceGfCYASfZGPzmBm+2iuhDQy9ETgen5mAYgBonN06xDbsgL0mWrVGrYxmkkGQRb/zw2Vh//iLouoEHf7AXz95/2Jop0TMZFA6Scmp1dAUAIBDtH0JeSTg4mdggjRaUrK52ZJlKlhO7oDWTlS9XIKy5rCa7sjKHSGiON9odFW8+Yfnmis9un2xGVEOjhEGr+LaPFvVOSRbdtBFEHqLHnZ+/lZksav3lw2EoBb3sfRgYWkXTJOuee+7B61//evh8PuzcuRMFU15NJBL40pe+5PoBMswPeMwNptyJCQwEPDAUh0oW3aKqRIVd8HR6BuEsee7g4hWuHXc7yCaL+OVdu6DrBtaeN4qtly/r9iHNG/A8B5nOZSVqzGWZSpF6ulbUPyFhRjYGybyppapckWjoxZCXLER0hQPMMI12yogBQKgT4171+SKPK6/fjG2vI+fok794Bb+5+wB03UB+zx5A1yGOjSGnEwLSD6EXFCW7YIWS1cRMlmbFt3evIyvflJJFFlkFl5Ss3LFTAAB5ZP7Nnc41Fq0Ol5GKPuZYDQkHtRH206Ke/szpmYIVllMNbse3A7BqVbQm0gUpyRJCIdvvo3+URYbuoGmS9YUvfAF33nkn/uEf/gEeT2kn8JJLLsHOnTtdPTiG+QN68c+fmsKAX7ISBqsqWbQnS1eAYrr6G2bL7YKn0jFEzPnY+WAX1DUdv/rubmQSRQyM+XH5ezf27WB2q7Bi3GskDHrNqofCgf3V38AkWfnYDHjTcRjTZ9+MaejFiET+rxXIucgHAuC97ZEYcXgEgHOSBZD5pIvfuhaXvn0dwAG7/vcEfvkPu5H+HenH8m05C9kE2XwKRPqIZFUUEltlxM0oWbSIuEvJgoB9JsuBktXILtjETJahKMhPEuusb8mI49f1KwSBx9L1NrLZxywrMkrDL6qHQBT70C4oBz2ERBtAcqr2NcJKFnQp9AIozWTpTShZ1C4ohMNWiXE/KYsM3UHTJGv//v247LLLZj0eiUQw00RUJkNvQfKbMzhTMxiUxfp2QckPiGZ/VK25rFylkjWNsHn/aVedcANP/fshnNg/A9ErYMfNW/rq5ucWrBj3GuEX8qZNAID8nr3V38AkWalJcnNLcwZi+dnWQ0qyhiTyNVUjVitrpqoNlBIG68wP1sDZr12O191wJniRwyvPTeKhnUEoog/ymWchPWOSrD5WsjivGXzRRE+WZcnpJslqZSarooy6ZBd0rmTl9+yBapBFm7xofoX7dAt0Lgvo35kswIGSRXuyfP2zqOc4zpFl0Nr0cFPJsuyCzoMvqMrOh8Ol30cfKYsM3UHTJGtsbAwvv/zyrMcfffRRrFmzsGOt+xlS0GxQh4ilagpGveALoP5cllooKVzm86Zjp+E11zHtJMa5gUO/m8TO+48AAF77hxsxuJjNT1RDoxh3eTMhWYUDB2AoVea2fFEAQHqa3ICTvIFYZvZ7UbvggIf8X1XJ4t6N86REsmqcxw2w7rxFuOaj50DyiZjWh7Bz26egrTkTmRnyc/QTyaJ2nkKlktVE8IWeIp97oYtdeHk6k+VAyaoW4Q60ZhfMPvMsVIH8m0ly7ydOugHalwX0b08W0Lgrq9in9jRKsuolDLqdLAiUgi+aswuSOV8hHLb9PhjJYmgPTZOsG2+8ER//+Mfx1FNPgeM4jI+P48c//jE+/elP40Mf+lAnjpFhHoAqOZrgxVh6sr6SBdQnWfQxTgC8JHggM0kWK0WRA+f3u3fgTSIxmcOvf0CUl62XL8O68xZ17VjmO3zh+iTLs2wZ+EAAhqKg8MqhKm9gKllxQsCSvI7pKiSLpgsOiOR5mkKIixuKpzhMFAUnwRe1sHTDAK69eR2kwgwygcX4718biJmJaf1EsizCQZUsK12w4Pg9tBRVsro3k1UqPm0i+CJXEXyxlChZWiIBLZ1x9H2zzz4LTSTnA7MhEUQX+REcJP8mfSxkleaTYnloankaq6EbUPuwJwuwdYRN1O7KspSsDtgFmwm+sEJ5wraZrD77fTDMPZomWbfeeive/e5344orrkA6ncZll12GD37wg7j55pvx0Y9+tBPHyDAPUCokljGcmLRmslJKCjm1yi4VncvKVSFZVnz7AGDGOBemyUB4yu/p2uyTWtRw/127UMypGFsTxsXXre3KcfQK/A1IFsfz8G7aCADI790z+wnmOZJKkkVHkjcQr6pkkRteRCRf04pkcdxOsiCFQJWsydZJFgD4p17BeTv/BoHiFDJJxbJQBiL9ky5IScksJSvXhJJFLTnzIF3QWU8Wue4V86qVIgkAQjBo9cAp443VLEPXkdu5E5qlZLHFG0AsZStMy6Dg6dOiLJBrpegVYBhAarrcXmvvzuq3Rb1lF6wRXQ+UrieSg00Pp7C6PQUJqsMId6sWJByxIvX7TVlkmHs0fVXjOA5/9md/hlgsht27d+PJJ5/E5OQk/u///b+dOD6GeQLafK6KMqKxU4DuBWeQi+JUtsoC1VKyqsy6VCki1mLkPTJ+2b2DbhKP3H0AU8fS8IU8eP2NZ0EQ+/em7wasmawawRcAIG/aDAAo7K0yl2UqWek0+XemdkGjIpGSzmRFBPJ9VDP4op2OLIpWgi+qIb97F+RCHK+JPlcW899PSpY0ayaL/GxNzWRZwRddVLLMmSxHEe7mz6xrBjSlXIGw5rIchF8UX3kF2swMNFpyymY8LWx/wypsfvUSbL5k/lR3uA2O4xAZJr/7mQpVh8a38zzXd/ccJzNZxQ4oWXQmy+AEqMnMrHtKNVCVXbArWcwuyNAmWv5ES5KEzZs3Y+PGjfj1r3+NvdUWUQx9A7qgLkoR+CdPAuDA62QxWT/GvZpdsLwjCwC4BEndyga7YxXc89g49j5+EhwHXHXDmQgOdI/s9QoazWQBgLzRVLKqhV9Qu2CGLNaTvIGipiNTLLdmUZIVNkmWlidKpzjYfgy22GSEey3kdpNkwfCWDbjm4+fg7NcuxwXXrO6rwJRSuiAhKbyv+TJiqmTNh5ksJzMgHq8AmML67Bh35+EX2WeeBQDofkIu2UB9CeFhHy5/z0ZEF3XPJj4XiIxWJxw0VMUjC32XYEtn0VJT+Zql9SX7rvszWQCgQbCsgPWg24Mv+tS+yTD3aJpkvf3tb8e3vvUtAEAul8OrXvUqvP3tb8fWrVtxzz33uH6ADPMDoUFCOvLyIKTTZOdWN8MvJnJVepAc2QVLSpbHTB0rBud+8TV5NIVHfnoAAHDBtWuwfGP30w17AY1msoBS+EV+377Zu4mUZOVJsEhBIguMWLr8/WjwRZAjsz/UneqOkkVIlhaPVw/ncIj8rlJ8uygJuPTt63De1avbPr75BEvJMueTeJkGXzQzk2UuZLrwOQeIJZgqUk4i3DmOs81l1UgYdKBkZZ8lJEuTyLneb7YwhsagSlZlCITSh0XEFMGoF4LIQ9cNpOPVrxOWXdBFJUsQePACuZ84ncsq9WSFS+XQbDOEoU00TbIeeeQRvPrVrwYA/PznP4eu65iZmcEdd9yBL3zhC64fIMP8QHiILKhy8hC4kyfAGTrUIlkoVbcL2gqJK2EpWSUlwmsOj6uhyOzndxD5jIL779oFTdWxassQzn3dyjn9/r0Mqm7mM0rNXUrvGWcAHg/0VGr2jr9vAKohIaeaC88geb9YtpxkUSUrxJObtJYlN0BXZrKiUUAQAMOAGou39B7KxATU06cBnoe8eXPbxzRfUQq+IGSUs5SsJnqyUt1VsiyrI+dcTSrNZZUrrJKVMOiEZD0DAFA5Quz6SeFkcIaaSlah/zqyKDieQ3iYrB0SE9UV705EuAMlguQ0YdDqyYqEbcEX/fc7YZhbNE2yEokEBs1Ur/vvvx/XXXcd/H4/3vjGN+Kll15y/QAZ5gdCQ1TJGoJRKGAon4Sm1FGy6qYLmotZm13QlyEXYCMyd/0xhm7gwR/sQXIqj/CwjCuu39zXMcJuQw56SCKYAeTS1VUgTpKsUuL8norwC98A0hpRkjxeAYEQuaHFMuU7nhnzhucHWcyrGXJTdiNdkBMEKwpem27NMpg3rYLeM84A38VkzE7DWxnhbs5kNRN8YSlZXZrJytuSBZ1+1mvFuIsOlSxlfBzq+EkYggDVfIt+VC0Y6qPWfJLS56pJo/CLQgci3AFANINUdIddWfYOv1LwRX/+ThjmDk2TrOXLl+OJJ55AJpPB/fffj9e97nUAgHg8Dlnu3BxLLBbDe97zHoTDYUSjUdxwww1Ip9N1X3Pq1Cn84R/+IcbGxhAIBHDuuecyS2OLoHZBTZShij6szE3DUMhCqX7whTO7YNBMlRMGRtw76AZ49pdHcHjXNASRx46btjjqzWEogec5yHQuK1Ev/MLsy9q3r/wLvgGkNPL7Dg56MRgk59h0DbugD3kYBqDRc8WlPjWhzbksSrLks85y5XjmK6idRy3q0FS9pGQVnNsFrd3iLqULFjLNL+ikGiRLctiVlX12JwDAs2kLqGOWLd4WHuh8UnIqB10vWafpgr5f538axbiXgi/cvf+WCoklaA4SBjVLZWczWQzuoWmS9YlPfALvec97sGzZMixZsgS/93u/B4DYCLds2eL28Vl4z3vegxdffBEPPPAA/uM//gOPPPIIbrrpprqved/73of9+/fjvvvuw65du/DWt74Vb3/72/Hcc8917Dj7FaIkWDM4eXkIZxRnWp/Jqgi+MAwDQXqhHVrs7oHXwLG9MTx93ysAgMvetR4jK7o3iN/LsMIv6iYMmnNZleEX/kGkTCUrFPVgKEDeK17DLugzCtCKPGCuT8SB9oMvAEAcai/GPWfOY8lbFgbJAgjhoDNZUFVH82yGpkHPEFswH+6OkmUN2TexoWLNZOWrFxJr09PQ66h51CoonXMeeYBjJGshIjgggxc56JqBdKxksbXmf/rUmtaoiLlTSlaZXTA+U/e5hq5bG0BcMAS1qJe9BwNDq2iaZP3xH/8xnnzySXzve9/Do48+Ct7sOVqzZk3HZrL27t2L+++/H//4j/+ICy64AJdeeim++c1v4u6778Z4HavG448/jo9+9KM4//zzsWbNGnzuc59DNBrFs+YQMkNzKIVfDGFFfrp+IXHdmazyCPe0kkYkS1bOwdFl7h50FaTjefzquy/CMIBNlyzu6+jgTsNv9kDlnIRfVCaQenxIGYRUh0IGBvzkvSoLiamS5TVy0PLkesNHIuA87ux80vCLVpQswzCQ37ULAODr4CbTfADPc9bObiGrWkoW4GwuS7c5D4Rgl5QsczNHbknJKp/J4sNh8AEyT6icPFnz9TnzfiNs3gqALNz6LUWOoTF4vhTjbrfOWapJny7o6Sxasopd0NANa/PCzeALABA9zguJ9UwGVGbW5YD1OCNZDO2ipQj37du34y1veQuCthvlG9/4RlxyySWuHZgdTzzxBKLRKM477zzrsSuvvBI8z+Opp56q+bqLL74Y//zP/4xYLAZd13H33Xcjn89b6ls1FAoFJJPJsv8YCMJDpYTBJRkbyaoa4W4qWWoeKFbYBCrsgvF8HGHzKcHRzipZmqrj/rt2I59WMLw8iMvesb6j36/f4STG3bthAwBAPX0aaqxc2UyDENxQUMGQGXxRWUicKZo3YT0P1SRZoktWQaA9kqWcOEFu4B6P9XP2MyTbXBbn8ZAECaCukkNB7TicLIOTulPSnM80HxddSlUsV7I4jrPUrFqWQTUeR+GllwEAwlpSZ9Cvi2mGxrBUHVsIRCnCvT+VLItYTuZmJcwWcqrlTHBfyaIzWY1JFi0i5rxeqDo5Do7n+rogm2Fu0NJZffz4cdx33304evQoisXyBdHXv/51Vw7MjlOnTmF0dLTsMVEUMTg4iFOnTtV83b/8y7/gHe94B4aGhiCKIvx+P37+859jrTmIXw1f/vKX8fnPf961Y+8nhKyEwUGMJA5adsFUMYW8mocs2mbypCAgSIBWJGqWZAsEqLALJuKnIJnrF99IZ4MvHr/nZZw+lITXL2LHTVsgSmzB0w6cxLgLwSA8K1dAOXIU+b17EbRtxqR08rkO+nKWkhWrJFl0p1fPQSuQm57gQrIgRakrq8pmQQNQFUtevx58l4jDXMLr8yCNAopZFRzHgfP5YGSzMBzMZVnJgqHuWXOtJLOm7IJmumAFyQJIjHvhwIGaCYM505ourV4NXSabkv26mGZojGrhF/0c4Q6QdQPHkVnObLKIQKRU0E4/U6LEu17ETO/tGt84+EI3i4j5cAhKoRR6wRRnhnbR9Fn94IMPYsOGDfi7v/s73HbbbXj44Yfx/e9/H9/73vfw/PPPN/Vet956K7lR1/lvX+WwfBP48z//c8zMzODXv/41nnnmGXzyk5/E29/+duwyF0bV8NnPfhaJRML679ixYy1//36DZRf0DiIaPw1oXgggC8tZahbHVZ/L0lQgbw6hmmpX8vRx8r4ih9BA5xZgL/32NF54mHyvK67fbN3wGFqHEyULAORNJNq8UGEZTKmEVIe8KQwG6tsFRS0HtUCVLPfIuNWV1cJMFi0h7vd5LIpZCYPmXJYjJYuWfXaTZLWhZFXOZAFoqGTRfiz/edutxTQbpl+4oPcce1dWsc9DFgSRtzZoK2PcrU0Pl62CgI1kNaFkCeEIC71gcBVNn9mf/exn8elPfxqf//znEQqFcM8992B0dBTvec97sGPHjqbe61Of+hSuv/76us9Zs2YNxsbGMDFRHq6gqipisRjGxsaqvu7gwYP41re+hd27d+PMM88EAJx99tn4zW9+g29/+9u48847q77O6/XC6/VW/dpChxXj7huGqBQwmE/Bw0eR1ScwmZ3E8tDy8hf4B4H0qfK5rJyti0iOAgAyEycwCCDpEzHm7cwub2w8g4f+iRD27TtWYvXW4Y58n4UGayarTvAFAMgbNyJ1//3I7y1tmhi6gbTZtRbyxC2SZbcLKpqOokqGkEU1Cy1PbnzCoDuhFwAgULvgdJX5wQYolRD39zwWRWXSHiebMe6OZrK6r2Tl6UxWE0pWrQh3oHEhce4ZQrJ827cjRXfI2eJtwcJK2pssWehL6YL9q3CGh31ITuWRmMxhybqo9bhVROx3P9nXY08XnKnteAIALUVTT0N9H6nPMLdo+lO9d+9e/PSnPyUvFkXkcjkEg0H89V//Na699lp86EMfcvxeIyMjGBlpHNl90UUXYWZmBs8++yy2b98OAHjooYeg6zouuOCCqq/JZslFjAZzUAiCAF2vXpzKUB92kgUASzJTiBtRABM15rJo+IVNyaKqlhwFBHL6ZSZPAwASsgeBDpCsYl7F/XftglrQsGzjAM6/Zo3r32OhwrGSVSX8IpsqQjcEcNAQ4KaqKlk0WRAAeDXbISWLXIOanckydB35F18EAMhnLQySRQkH3YHmZTPGPdeYZFlKVpeSBQFbuqALEe5AfSVLz+WQM88P/3nnQTlEF2/9u5hmqA+7XdAwDHAc1/d2QQCIjPpxfF+8jFwC9vh29z8THlPJ0vnGEe40WZC3FxEzksXgApq2CwYCAWsOa/HixTh48KD1takWe2YaYdOmTdixYwduvPFGPP3003jsscfwkY98BO985zuxxNxJPHHiBDZu3Iinn34aALBx40asXbsWN998M55++mkcPHgQt912Gx544AG8+c1v7shx9juoXVAVZKiCjCWZaXAa2ZWumjDoM9UGO8mqSBYEgJw5C5PweRGQ3L3YGoaBh//fPsRPZRGIenHVB84EzwqHXYOTmSygFONePHQIurkBkpomC/MAPw2+ELci3FN5FYpGNkKoVVASeXDFjJUu6OpM1jAhbHoq5Sglj6J46BD0TAaczwfvGQuDuJeCLwhZoXZBo+BAybJ2i7uTLAjY7ElN7JxbM1l5bdbXPEtrK1m5370AqCrE0VF4li61Xs9sSAsXlfNJQOm8kvqYfNPwi2RFjDu9jrgdegEAohl8oTkoI6YbQEIojCJTnBlcRNMk68ILL8Sjjz4KALj66qvxqU99Cl/84hfxgQ98ABdeeKHrB0jx4x//GBs3bsQVV1yBq6++Gpdeeinuuusu6+uKomD//v2WguXxePBf//VfGBkZwZve9CZs3boVP/rRj/DDH/4QV199dceOs58hySLkIFmc5OVBLM5MQVPqJQyaaoN9Jqsi9AIAtGliIUzJfgguE6AXHjqOl5+dAM9z2HHTWfCH+z+cYC5B/z3zGQW6VlshFkdGiC3PMFA4cAAAkDK7YkLCFJCLI+LzgP76qWWQhl4EvSKg2JUs90gWHwpZaXfqlHPLYI6GXmzaBE7s3wWSHZZ1ziQrViGxEyUrRWeyuqlkUbugu0qWOjEBvSIEivZj+c/bbioW/Z0ix9AY1eaTlAWwqKcx7pVdWfTz6HZ8O1A+k6VnMjCKtTcCtSRRuoRw2GYXZJ9ThvbR9Fn09a9/HWmz7+Tzn/880uk0/vmf/xnr1q3rSLIgxeDgIH7yk5/U/PqqVatmxYOuW7cO99xzT8eOaSEiNCgjn1aQlwexND2FYmEN4K3VlWUuhKvZBX22RfIMucClfe7ucJ88mMDj95D45IvfthZjayKuvj8DIAc94DhSMZJLK2XJUbOeu2kTMr/5DfJ798J3zjkWyQoKk0AuDp7nMOCXMJ0pYjpTxGhYtpSsgMQDuQy0ArlZCy7aBTmOgzg8DGV8HNrUJLBsqaPX5XcTK5hvgYReAFWCL7x0Jqtx8IVOd4vDXZzJsoIvmlCyakS4A4AwMEASFnM5qCdPQlq50voa7cfymRb3fu9DYnCGyEj5fBLtX+trklWjkLiV3jqn8NhIFgBoiQTEGuMpumVlDjG7IIOraFrJWrNmDbZuJaWKgUAAd955J1544QXcc889WGm7wTD0J8JWjPsQlmSmkM2R4r76M1k2daCKXVBMENKe87u3w51NFvHLu3ZB1w2sPW8UWy/vfMnxQgTPc5AdJwyac1l7yFxWOkZiv0MmyQKAgYrwCzqTNShpAAwr+EJ00S4IAIIV4+7c8mzFty+QeSxgNuFoSckKdodkGYbRol2wtpLFcVwp/MI2l2WoKrLP/w4AmccCSily/byYZmiMcEX4BbWn9bNdMGzaBQtZ1droAOzBFx0gWSZJ0r1kjVLPMqglZ6cLss8pgxtommT99re/rVoA/NRTT+GZZ55x5aAY5i+CViHxEBZnplGkJKvqTFaVCPcqdkFviizQCkF3Fs66puNX392NTKKIgTE/Ln/vRtZ30UE4j3EnZax5s5ah0i4IYFb4BSVZQ5IKQwe0ojmT5aJdEGg+/MJQFOvnWIhKVtEKvmhmJqu7SpaS12DoxO3gbcIuSC2SalGvaomlc1lFG8nK790HI5sFHwrBu26d9f2B/k6RY2iMSlVnIQRfeLyClURrV7NKwRfupwuKkllGbHZ01iNZukWyQrYZuf79fTDMHZomWR/+8IerdkedOHECH/7wh105KIb5i7BFsgbhVwuIZMiCYSI3MfvJ1ZQsyy5YiuD2p8mCWg26YwF76t8P4cT+GYheATtu3sIWNR2GP0xukDmHSlbhwAEYqmojWSUli4ZfxLPkvahdcMCjWEXE4HkIEXetn7QrS3XYlVV46SUYhQL4UAieFStcPZb5DO8sJYv2ZM3/may8mSwoiDxEj/Nbn8dXWmxVDb+oEuNO57F8524DZybclmay2OJtIcPelaUpOnSNEP9+D0Sp1hFGryMdCb6g6YIeM7DLgZLFh1m6IIO7aJpk7dmzB+eee+6sx7dt24Y9e/a4clAM8xehIVP2D5F+srEEWQyniink1YqFljWTZevGsuyChFAZhoFghlxojUj1zrNmcOh3k9h5/xEAwGv/cCMGFwfafk+G+vCHyVxOIyXLs2IFeL8fRqGAwiuvIE1nsniTZBmGZRecTlfYBUXFCr0QBgbACe7eAC2SNe2MZOXMfiz5rDOtRfRCQGUIBO81SZajmazupgsWMqUFXTPKtiCUSJnTGHc6j+Xffp71WJH17zCgRDZmJnKWVRDo//OipOCVYtxppUIngi9KPVnk/qTXiXG3erLCYVsQCducZWgfTa8OvF4vTp8+PevxkydPQlwgCVsLGTTGPe8lStSSVAoeniyMZ81lWSSr9kxWRskgZF5zxcjito4tMZnDr39A5n22Xr4M685b1Nb7MTiDFePeoJCY43l4NxLLYHr3Pms+JiRMAloRKGZmKVmZIlmYRsSiFd/uZrIghdjkTFZ+t1lCvIDmsQBb8AW1C5pKlpEvNHytZgYmdUvJsjqymigiprDIZb5xIbFhGMg+uxMASRaksIIv2OJtQSNsko1iTrVqLEQPD17o782aauEXpRnJDipZNPiirl2QWpnDrIyYwVU0/al+3eteh89+9rNI2HYFZmZm8Kd/+qe46qqrXD04hvkHGj9b5GSoghdL0lMIiUSVmspVLFDpTJaSARRT5apIF5yJjUMyHTiewdaVLLWo4f67dqGYUzG2JoyLr1vb8nsxNAdrJitRn2QBJctgbPchAOTmKnnMOZdcHAP+8pksahcMC0WoZuiF2/NYACAMkXNYc2gXzJkkS15A81hAaXZCKWjQNR0cLSPuASUrn2k9yaxejLtkKVmEZBUPHYYWi4GTJMhnlc6PIrMLMoCk3gXM+aSpY2TjYSGcExEr8MM2k9VBu6CH9mRx5L2dBF/Y7YL9bt9kmBs0TbL+5m/+BseOHcPKlStx+eWX4/LLL8fq1atx6tQp3HbbbZ04RoZ5BK9PtC6Iee8glmSm4eOjAICJbMVclhwBOPNCRclVRfBF4jSZ78t5AF+4dWvfI3cfwNSxNHwhD15/41kQxP7eFZxPoAPNuQZKFgDImwnJmjlEzpXgoFyaz8vFMRQk7xWrsAtG+II1k+V2siBgsws6ULL0fN7q+vJtWVhKlmSfT8pp4GUzwr3BTJZhGKWZrHDvKlmF3OyZLNFUstTTp2EoSmkea+tW8FKpl09hZcQMJiKjhHBMHSOfiYVgTQt3SclSDfP/NUiWXizCMEvohVCI2XoZXEXTK9GlS5fihRdewNe+9jVs3rwZ27dvxze+8Q3s2rULy5cv78QxMswzhGzhF4szU5A4skiepWRxXHlXlq5bAQf08dTp4wCApE9AUGrtQrvnsXHsffwkOA646oYzERyQW3ofhtbgNF0QgGUXTJ0mi4tQBcmiSlZl8EWQL5ZmslzsyKKg/Snq1NSsvr1K5PfuBTQNwtAQxLH25wh7CbzAW4uPQk6xKVkNSFYuB2hk8SKEupMu2M6CjhKjakqWODxMyqx1Hcrp08g9U96PRWFFuPdxVDeDM1Dr3KSpZC0E4k1/5myiaCnhVDXqRLqgNZOl8zBQW8miCjs4DnyI9WQxuIuWrvaBQAA33XST28fC0CMIDcqYOpZGXh7EkomD4LWzAVRRsgBiC8xMEgWrkAAMvfQ4gOzUKUQAJHweBFpYfEweTeGRnxJV4YJr12D5RvdVDob6oDNZTpQs77p1gCgiZ5AbbmhQBrIlkjUYrR7hHuAK1kyWMDgAtyGadkGjUICeTtclAlYJ8VlnLchqAK9fhFLQUMiqkKyZrPoki6pYEASrW2uuQZUsuYmOLApvHbsgx/PwLFmC4uHDUE6MI0tDL2zzWIZuQGU2JAYTVNWZOkFJVv8TbznggdcvopBVkZzKlRXX2xVyt0CVLAMcdF6sSbI0WkQcDILjeVsKaP//Thg6D+apYmgadiUrqObhT5GL5SwlCyjFuOdipdALKQSIZDFdmCTELClLCDZ5UctnFPz33++CpupYtWUI576OlWF3A35KstJK1R4hO3hJgnftWuRlQoYrlSxqF4xnijAMAxlzYRrg8paSJXZAyeJ9PvBBMivUKMY9v9ssIV5gVkEKeyExJ9N0wfoky+rICoW6RkzzVMlqoiOLol7wBVAKv8g9txPK8eMAz8O3bZv1dbo7DiyM+RuG+qCqjrrAim/t4ReFHNn08HiFjoR+eKTSe+q8VDNdUE+SxwXTxsyULAY3wUgWQ9MImzHu2TBZWAxMkItSVSXLbhe0kgVLSoQaI4/NyDKCTShZhm7gwR/sQWo6j/CwjCuu3wyOX3iqwnyAHPSA4wAYhGg1fP7GjVY6ZXDQW9UuqOoGknnVsgv6kIdGgy86MJMFlOaytAYx7jS+fSGVENthLyTmZWcR7tZucZfmsQCgkDFnslqyC9ZWsoBSjHvivn8n32PjBgjBUsAHnfPgeY7NizJYZINioRTfWiRrItfReSyAWJt5kawJNEGqOZNlnxU1DIPNTjK4Cna1Z2gaVox7YBQAEJkg8c3VlSw7ySoPvQAAIz4DAEh4/U2RrGd/eQSHd01DEHnsuGkL5BaG2RncAc9zkJuYy5I3byopWUN2JSsG2SMgYNo8YpmiZRf0GQWbktVZklUv/EJLp1E8RJIR7clxCwneKkpWo+ALnfbQBLuTLAjYZ7JaCb6gM1mzgy8AwLOUbDgVX3kFQHk/FgBb946wIC2mDOWoJFkLxZpmhV9MlUhWJzqyKDxSqStLm0lUnbfVEqWOLF01oOvkOUzJYnADjGQxNA1qFyx4IgCAyFQGQJ2ZLIDYBSvi2wGAmyEXuIQ36Hgm69jeGJ6+jyxmLnvXeoys6M4gPUMJNPwi54BkSRs2ouCNAphtFwRgFRLbSZbXyFnpgp2IcAcAgXZl1bEL5ne/CBgGxCWLrTmuhQZ7nDlvzlfphUYzWWZHVheVrHw7SpaNWFYDVbIo/NvPLfs7SyxjsMPr90AOlsj+wrELmjHuE9mOK1mArSuLlwBFgZ7JznqOtQEUDpXbetlnlcEFOCZZ8Xgc3/zmN5GkSSw2JBKJml9j6D9QkqXAC433YGCa/N6TxSTyasVii6pW2elZRcQAICbJRW9GCjtSstLxPH713RdhGMCmSxZj8yVL2vxpGNyAP0wWDE6ULHXxGoDjwekKJDVjI1kzAGAVEscyRcsu6ClmoSs0wr0z5EYcaqxk5V9cmCXEdlhKls0u6FjJ6lKyIFBSslpRvZ3OZFH4K5IF2TA9QyXsatZCswsmp3K2jqzOuVCshEEvqYepFn5BlSw+HLY+38ICKIdmmBs4Pou+9a1v4ZFHHkG4yk5kJBLBb37zG3zzm9909eAY5ie8ftHaect7BzCSjMEr1Ai/aGAX9CbJ4izhCTcMvtBUHffftRv5tILh5UFc9o71Lvw0DG7AHya/fyckK1sgv2e5MIPigf2zlKxBi2QVkCmasd9Jmk7Hg+/QQt2JXZDOYy20EmI7JH/zwRfWTNY8IFmdnMkCAM/KFVYlAEWRzXkwVMBOshYK+Y6Mkp85NZ1H1kyj9XbQLijS8IswucdUJVnWBhArImZwH45J1j333IM/+qM/qvn1m2++GT/72c9cOSiG+Q2O4xC2EgaHsDQ9hUEvIU6TucnyJ9uVrCp2QdksnZ2RBhr2ZD12z8s4fSgJr1/Ejpu2WFYAhu6DxrhnHcS4p2JkQe7Nx5Dfs7emXfBkIg/N9McjQ+xmYjjQsZkWkdoFpyZrPie/iyQLLrQSYjtop409+KJRhLueLqULdgO6blgEqRUlqxThXn0mSxwZAUTynMp5LIAlljHMRpmStUAW9f6wBFHiYRjA9HEzvr6DdkE6k2WEogCqkyzakyVEwuxzyuA6HJOsgwcPYt26dTW/vm7dOhw8eNCVg2KY/7DCL+QhhJQcxtQoAGAyW7FAtc9kVdgFdV1HKE0iv2c8gwjUubC99NvT2PUwKS6+4vrNswaHGbqLZmayKMmS8zHk9+2bRbKoXfBorOSfN0xbqRDtXHBCIyVLjcWgnDgBAJA3b+7Yccx3eO1KljmTZRSLMLTqBASwpwt2h2QVsyUFqpVFnVSnJwsAOEGAZ/FiALOtgkDJLrgQ+pAYnKFcyVoYi3qO4xAeJj/3xFFyTeiokmWuKYwAmR/XEjOznlNS2cNWsiAjWQxuwTHJEgQB4+PjNb8+Pj4Onmce1oWCkBnjPhMiC4ulM2RhXFvJmk2ysjOTEM1apbx3EcQaHuh0PI+H/mkfAGD7jpVYvXXYrR+DwSU0M5OVpiSrEEd+756aStYxk2T5JQGaSbLEaMTV47ZDoBHuNYIv8ruJVVBatcrqVFmIsEIgsoqlZAH11axuz2TR0AuPV4DQwqyFlS5YYyYLAIZuuhHByy9H6PWvm/U1K/higSymGRojMuq3/iw1kazb67DmsiZJ7UMngy+okqX7yfW6ql2Q9mRFwijSGeAF9Ptg6Cwc3222bduGX/ziFzW//vOf/xzbbOWLDP0NGn6RDhKSNTpNTqVZShadySokgfRp8mdT3YqfOgIAyEmAx1978Xx8XxxqQcPQsiDOv2aNWz8Cg4toZibLrmQVXzkEHeaOrpoHillLyToWIzfhgFeEliKvEQaiLh95CeIwmaNRYzEY+uxS5dxuOo+1cK2CgK0nK6eC83qtx+vNZVnpgqHukNNCG0XEQLmSVS0GGgAG/uAPsPzvvlM1pt6a9WA75AwmqKIDLCzyXelC6Wy6IFmXGHLt4AvdNi+qLLByaIbOwzHJ+shHPoLbbrsN3/rWt6DZbCGapuGb3/wmbr/9dnz4wx/uyEEyzD9Qu2DBR5SqwUmyiJmlZMkRAOYMTZz0C1F1KzVB7H8JH4+gt/acRGycRMQvWRsFzwqH5yXoTFbO0UwW6VXzSwqg6ygcPQnw5o02F8dggCzcT5mhKEGvCM1UIjrVkUXeewDgOEDTqt6M8wu8hJjCsgtmVXA8bxGtukoWnXsIdacnK5+l8e2tJZlRkmUYKIt5dooiSxdkqIAv5LFmsTrZFTXfYFfwgNKMZydA7YK6lS6YmPUcjV6bwpFSETHbDGFwCY5J1nXXXYfPfOYz+NjHPobBwUFs27YN27Ztw+DgID7xiU/gk5/8JN72trd18lgZ5hHCw4RkaR5i/4mY0v8sJYsXSnYw3bTamOpWZuIkACDpE+vGt8dOEpI1uNhf8zkM3YWfkqy0Al2brQJRGIZhKVmR5cSel99bPpc1WBFMEPAKUDNmtO5Q56yinMcDIRoFMLsryzAM5HaT0IuFWkJMUTmfxDtIGNRSpbmHbqBgkiy5RSVL9PDWBk+t8It6UJhdkKECHMfhoreuxeZLFmN4afdKuucakeFyJWsugi90iawd6gZf2Hqy2EwWg1toypz+xS9+EU8++SSuv/56LFmyBIsXL8b73/9+PPHEE/jKV77SqWNkmIegSpYBL3RORGSSLKJmKVlAWS8WAMsumJ8i9sGEz1O3iJgqWYNLAu0eNkOHIAc94DgABiFatVDIqlDNG9nAxuUAgPzevRUky1v2moBHgJojxE0cHnX/4G0ohV+Un8fq6dNkVksQIG/a1NFjmO+wkvbyGnTdKMW41+nK0k2SJXQp+KKQaa+Th+M4eOhcVo3wi3pgEe4M1XDWZUtx+R9uAreAHBo0xp1iLiLcNY+5KVxBsgxdL20AhW3pgkxxZnAJTZ9J559/Ps4///xOHAtDD0EOeiBKPNSijrw8gPA0CS2oTrKGgOmXyZ9FH2DuKhWmyXMTsremklXMq5byMbh44ez29Rp4noMckpBLFpFNFhGIeKs+j/4ufSEP/Js3YAZAft9eYIWNZC2Syl4TlQxoebIIEUYXdepHAEBi3AsvvQStImEwZ0a3e9euBe9b2MmWdmtTMWePcc/VfE1JyeoSyaJKVhu75l6fiEJGrRt+UQsKG6hnYAAABAe84HkOulnP0dHgC2oXFMn9SEuU2wX1bBYw52+FcBjF/EzZ6xgY2oXjs/vo0aOOnrdixYqWD4ahd8BxHEJDPsRPZpCXBzEYn4Q/LyCBBApawSonBlDWi2VXtfQYIWYJr68myYqfJKlyvrAEOdg57zZD+/CbJKtejHtqmpCs0KAMedMyAEBh/wEYb1pHJvdycYR9IgSeszqyBiQFWp7sSIqjSzr6Mwg1Ytzzu18EsLBLiCkEkbc2WIq2GHc9X6j6fKNYtOa1upYumG1PyQIax7jXg8KULAYGAAAv8AgNyUiYIwadnEejXZoaRz73lUoWtQpykgRelpldkMF1OD67V61aVbUE1DAM63GO46Cqzd+AGHoToUEZ8ZMZTAeXYDC+H8sSHhyQVUzlprA0uLT0RBrjDpQRLiNOdpVmvIGadsHSPBazCs53+MMeTJ+onzCYjpdIlrRyBTi/H0Y2i2LaCy8A5OLgOA4DfglTabJoHxAVqAVCsgQzAbBTsBIGK2ayrBLiBT6PReH1iVCLRRSyjZUsLZ22/sxXSd6bCxTM4JRW0wWBUsdVoQ27IJvJYmAglsHEZA7gOmsXpDNZKke+RyXJoqEXvFnJwWYnGdyG47P7ueeeq/q4YRi4++67cccddyDYpRsoQ3cQNmPcY0GiLqzPBHEAM5jMTlaQrAHbn0skS0iQxVdCCmJVjZ0ji2Sxeax5D5owWI9kUSUrOCiDEwTI69cj9/zzyE8bJskiXWpDgRLJGtRTMDRTyepguiBgm8manrYeMwwDuRdNJeushR3fTiH5PcgkiqSQuMFMFt0t5gMBcEJ3Fi8FF5UsuhBrBtQuyMqIGRhK4ReSLHZ0Hk30mjNZhmkbTCZhqCo40SRdVuopUdiZksXgNhxf8c8+++xZj/3617/GrbfeigMHDuAzn/kMPvWpT7l6cAzzG7QrK+UnYQQrk2SRPZGdKH+iXcmykSxPkux8z0iRmhHuVugFU7LmPayurDox7jS+nQanyJs3EZJ1qoDIEKxC4sFAaS5r0HyMEwHO39mESXFkdvCFcvQo9EQCnMcDef26jn7/XoEVfpFV4bHSBWsoWbQjq4sFzrSMuJ35D1pI3JaSxRZvDAxWjHsnVSygpGRpeonIacmktVlXShYk1yY6b8k2QxjcQlPpghQ7d+7EVVddhd///d/HhRdeiJdffhl/9Vd/hVCX/PYM3QElWUUvUarG4uRCNiv8omwmq0S45BRZcCekKAI1lSyyQGMka/7DHzJj3B3aBQHAayb15U+Qm101khXJkscEH1fVsuwmqJJlD76gJcTeTZvASVLV1y00WF1ZOQWcj9oFq89k6any3eJugCpZcqB1Jcsrtz+TxWxIDAxAdBEhWb5QZ+es6UyWUtSt0B27ZVBLlpIFAaZkMbiPpkjWwYMH8Y53vAPnn38+RkZGsGfPHnzrW9/C6GhnY5UZ5icoyeJEYhMdnCKL61ldWVVmsgzDgN+MVY57BqoGXxTzKtKm8sHsgvMf/jC5YTqxC9JzR95ISFbh2BQMA0BuBkA5yQpkyeye2MEUKgphiJyr9pksq4SYzWNZoNY5MpNFgy9qKFnJ7iYLAraZrDbOIU+LwReapkNTSYIZ2yFnYACWbxrAq964Cpe8bW1Hvw8lS2pRszoQy0kWubcIbCaLoUNwTLL++I//GJs3b0YikcAzzzyDn/zkJ1izZk0nj41hnoOqERIvQed4hCaItW+WkuWfnS6op1IQzdGGGXEIwSqLDzqP5Q9Lbe1AM8wNGs1kaYpufS04SKyF3vXrAEGAlspCzfKWkjVgI1m+jKmEzEG6pDhCgi+0mRkYRXKsrIR4Nrw2wsHJ5Hdp1JrJSpsdWQ5I1ou/OYGf37YT+Tpda63AFSXL6gdrjmTZZ7jY4o2BgSQMnv+mNViybqDxk9uAXckqkaxSjLtuKVlsJouhM3C8rXbnnXdClmVMTEzgAx/4QM3n7dy505UDY5j/8IclCB4emqKj4B2ALzkNX0Gor2SZf85MjAMAsl5AQaRqumCchV70FOhMVq7GTFbKtAqKEm8tdnmvF94zzkDhwAHkZzzwmCRryEayvGlCssRg9e4tNyFEIoAoAqoKNRaDODKC/J69AAAfi2+3IFl2QZuSVahOsppRsp7/9THMnM7i0AtT2HTxYleOVVU0qApRktqbyaLEsrngC0rKBJGHILTk0GdgYGgBHjP4Qi3UUrLoTFYEQIlksaoFBrfg+I7zl3/5l508DoYeBMdxCA3KmDmdxXRwKZblp7EoDkwuqjOTZf45efoY+b8PgF69jJiFXvQW/KaSlUsr0DUdfMWCMh0rzWPZZ6vkTRsJyYp7EKoykyWmU1ABCKHOlwBzPA9xaAjq6dNQJ6egJZMwsllwfj8kptxbsAdf8HQmq4aSpTmcydJU3erOmR5P131uM6AqFse1Z9ejC69mgy+YBYmBoTugSpZa1MBHogDKSZY1LxoOwdANm5LFbL0M7oCRLIa2EBoiJOtUZDmWTb2AsbiBvbOCL+wR7uTPqYkTAICkXwDAVSdZppI1wEhWT0AOesBxgGEQohWIlCtPqVgpvt0O76ZNwL/dh3zcAyhxQMmXkSw+Tc4DMTI354E4PExI1tQktPgMAMC3eXPX4sfnI7w2JYvz0nTBGnZBK12wPslKTORgmAXUdIPFDRTM2U/J315cdCnCvUmSxXbHGRi6ApouaBgAV4VkaYlST5ZStNl6mV2QwSW44l1IJpP4u7/7O5x33nluvB1DD4EGGCQCxNozFgcShQSKms0yJohAdCXAi0BkBQAgO3mSvM5HbGN1lSxmF+wJ8DwHOVg7/KIyvp1C3rQZAFCYMYlVLl5GspDOAgCEyNz08FkJg9PTyLN5rKooC77w1S8jdpouGD9VIlbTJ9xTsvJZGnrR3kyf9TM3qWRRuyDbHWdgmFuIUmmJa4SIi6aMZKXovGjY2gwBV/46BoZ20NZV/+GHH8b3vvc93HvvvYhEInjLW97i1nEx9Ajogjkrk1mrJTOlGPeyQuL3/QLIxoEgCRYoTk3CDyDhJYvpypmsYk5FOm4mCzIlq2fgD3uRSylVY9xLdsFyhUveuAEAoGQEaEUOQi6OwUBJ/TTS5ixXNNKpwy6DYHVlTSFnJgvKbB6rDGVKltWTVT3C3elMlp1kZRNF5NOKRdrbgRV60WY6pbfFdEFqF2RKFgPD3IIXePAiB101YATJ/aPMLkjTBSPhkq3XK3S8KoRh4aDpu86JEyfwgx/8AN///vcxMzODeDyOn/zkJ3j729/OTswFiLCpZGkSuYAtT4gANExmK0jW4BrANpqlxKYBADPmAq2yJ8tKFoywZMFegj/swfSJ6oXEqVh5RxaFEInAs3QplBMnkI97EMjFMTQsYTjohW4YMNJk8S4MRjt+/AAgDhGSpYyfRGHfPgCAb8uWOfnevQKvqUCTmSwyK1dbyTJ3ixuUEcdPZcv+Pj2extL17aePWfHtbV5H6ExVMd9s8AWbyWJg6BY8koCCqlYlWaUNoJKSJTGrIIOLcKyJ3nPPPbj66quxYcMGPP/887jtttswPj4OnuexZcsWRrAWKEJDZIElCOT/ozGS4jUrxr0CemwGAJDw+iEJPLxidZLFVKzeghXjnqhNsipnsgBA3myWEsc9QC4OUeDxXx+7FP/1sUuhZsh7iYNDs17XCVC7YOaxx2AoCiGBy5fPyffuFZTPZBFlUq8ZfGEuZIKNlCzTFuoht6XpE+7MZbmtZGlKqffKCZQCswsyMHQLdL7K8JllxIlShLuVLhgJlz6nrMuOwUU4JlnveMc7sG3bNpw8eRL/+q//imuvvRaSJDV+IUNfg6oSMuchXVlJBd6igYnsRN3XcTPk4paQg7NULMBGstg8Vk+BxrhXKlmGbljF0pVKFgB4N24EABRmPFZX1mhYxginABoJQxDmimSZdkHlBAlnkc86i20iVUCydUaV7IK1gi+oklWbZBm6YdkFV51Ffs8xlxIG3ZrJsi++mrEMFpldkIGha6AJg7pMZnqpkmUUizByRH0XQqGS4syULAYX4Zhk3XDDDfj2t7+NHTt24M4770Q8Hu/kcTH0CAIRCRzPQQCHmSAJv1g0A0zlpuq+TkySXesZKVS1iDjO4tt7Ev6QGeNeMZOVSytk958DAgOz+65o+AVVsii0WAwAwIs6+ODczGRRJcs6NhZ6MQtU1YEBaAINvmigZNWZyUrF81CLOniBw+qzyb+/a0qWmS7oDbS3Q83znLUAayb8gkW4MzB0DzTEQpf9AEoki16XAHJtYkXEDJ2AY5L193//9zh58iRuuukm/PSnP8XixYtx7bXXwjAM6Lpz6wRDf4HjOcgRsrA+GV0FABiLN1ayvEmyIJuRIghItePbGcnqLfjD1dMFqVUwEPFWLWSldsFCUoSeKJ07qkmyBFkHpLmLcLeDlRDPhuDhLVufAtMuWIVkGboOPU0UqXrpgtQqGBn1Y3g5eV5sPA3DMNo+1oJLShZgj3F3PpdFI9/b6ehiYGBoDZQ06R5zdrRQgJ7LWVZBPhgEJwisaoGhI2gqp9Ln8+H/+//+P/zv//4vdu3ahTPPPBOLFi3CJZdcgne/+9249957O3WcDPMYQTP8YiK4BACJca+nZBm6DjlNFuEJz8Cs+PaCPVmQ2QV7CtZMViXJmq4eekEhLloEIeAFDA6Fw8etx9VpEpAieueOZAnDI2V/l1noRVVQNUsx85Oo9cYOPZMhJTWor2TNmCRrcMyP6CI/eJ5DMa9Z14F2kDeVLLlNJQtoLca9yHbIGRi6BtqVpXIeQDTnKmdmZgXyKMwuyNABtFwGsG7dOnzpS1/CsWPH8E//9E/IZrN417ve5eaxMfQIBkbIDlHSvwgAsDhWX8nSk0kIpvg5IwzMsgvGTRUrEJFc2X1mmDvQmaxcxUxWOl49vp2C4zjIq8j5kz982npcm6ZKlgZ4/K4fbzXwAT84MzFPHBmBZ9GiOfm+vQYafqGAfEb1wmxCpJu7xZzXC95b/XcPADFzHis65ocg8oiOkd+1G31ZripZNGGwBbsg2yFnYJh70JksTdEhRKPkzzMzZUXEgD2ghn1OGdxD241rPM/jTW96E37xi1/g2LFjbhwTQ48hOkwWpHkviVte1EDJUmNk5ibjBRREZnVksRLi3oXfVLJyaQW6VrIRW0rWUHUlCwC8Z5AEv/yxmPWYFid/JkrW3JQRcxxnWQbZPFZtWNY53UzvyuVm2fuczGMBpY2VgTHymR8yP/v0WtAOaLqgt810QcDWlZVvgmSx1DIGhq5B9Jq25oIGwexa1BKJUkm6SbJKVQvsc8rgHlyttR4dHXXz7Rh6BLQrCx6ykBqLG5gpzKCozY7xBoDc1CkAQNIPGJofwYqZrNI81twsqhncgxz0gOMAGIRoUVjx7QO1SZa8bi0AoGDrS1Kn7TNZc6NkAYA4RBLuWAlxbVDSUlRLO79GhZplWXIaFhGbdkFzBnNwKfnsu6lkudG3J7VQSMxSyxgYugfLLljUypUsOpNlpp6y4AuGTsBVksWwMEHVCYkn/x9OAR7FqKlmpU6TmZuknwN0eZZdkJKsgcVzt6hmcAc8z0EOzg6/qFVEbIe82UwYnFRhaOSGp02RvrW5nMkCgNCVV4CPRBC+6qo5+569BkvVUUvx9nrFXJYTJSuXLiJvEvLoIvKZp0rWdJtKlmEY1kyWG0pWKySLDdQzMHQPYk2SRTeAKmay2OeUwUUwksXQNmghcdDgofrJDvSiGdScy8pMngQApAMiAK6OXZApWb0Iay7LRrKsjqw6dkFp3UZwgg5DBYpHjgAA1Bgh6oJXBzxzR7KGPvhBrH/yCXjXrZuz79lrkMwZp2JBBzzkz5VKllX26SBZMDjotXaRh0wlK34qA01rPb1WKWgwdGJh9LqhZMk0wt15uiC1FjIbEgPD3INeU5SCDiFi2gVnZqAnSSmxFXxBN0OYksXgIhjJYmgbgYgEgwMEcEiOnQEAWByvrWTlJoldMOUni/Gg7aJWyCrIzJjJgkzJ6klYMe5m+IVS0JDPEKUiWEfJ4oLD8EbJgjS/excAQKPpgn4OEOe2/JwVENeH11cKgeBpIXGFkqWniN2Pr1NETOexBsdKJDo0KEP0CtBVA4mJ2amFTkHnsXiRg+hp/3YntTKTxYIvGBi6BtqTpdiVrHhJyaLXJrYZwtAJtHTXmZmZwT/+4z/is5/9LGJmj83OnTtx4sQJVw+OoTfACzx0mZxKscHVAEiMey0lqzhNyFfaTxZmQW9phzl2kuxqB6JelizYo6iMcadWQcknlkpsq0GOQh4gZKyw+3cASiEpQrB2Mh1Dd2CPM+dk8vupLCTW6HB5sLGSNWAjWRzPlSyDbcxlUXIv+z2ukOZm7YKGYdiiodnijYFhrmHZBQvVZ7KEMFG32EwWQyfQ9FX/hRdewJVXXolIJILDhw/jxhtvxODgIO69914cPXoUP/rRjzpxnAzzHFzQA+QKiAcXAyDhF5O5yarP1U1inpaJzTBgu6jFxsmCiiUL9i78oXKSlY7Vj2+3wPOQRz3Ay0B+zx4Yum7F7AphX+cOmKEl0E2QYlYFL/ugAdBz5SRLr9gtrgaLZFUo10NLAjh9KNlWwqCbyYJAqVDYKcnSVB26aVdkShYDw9yDkia1qEEYjQIgJMtQyAaMUBl8wT6nDC6iaSXrk5/8JK6//nq89NJLkOWS9efqq6/GI4884urBMfQOpBBZcCW8JJVtURyYzFYnWcYM8UInZEKk7GXEpWRBRrJ6FZUzWU5CLyhkM1Ey/9Ir0GZmAHOBKobY+TDf4LWULMWyCxqFCiUrXT5cXg3xUzS+vZxk0ZnMdpSsQsa9jizAFvbhcCaLqlgA2yFnYOgGaLpgmV0wkbClC7IyYobOoWmS9dvf/hY333zzrMeXLl2KU6dOuXJQDL0H3wBZWGd4csGqp2QJM2TRlJDIDpKdZMUZyep5WDNZFSSr3jwWhXfpIMAZ0BIpFPbtAwDwkg5OZufDfINkqkOFrGqVN9dUskLVQ2yUomadH3a7IAAMLW0/YZAqWXLAJSWLzqE5nMmi8e2iVwDHsxk/Boa5hjWTVdAh2u2CFT1ZzC7I0Ak0TbK8Xi+S5g6AHQcOHMDIyIgrB1UNX/ziF3HxxRfD7/cjan5QGsEwDPzFX/wFFi9eDJ/PhyuvvBIvvfRSx45xISNsFhIrhhnjngDiydNVn+tJkkH2mNmrZU8XZEXEvQ86k5VLUbugmSzogGTx4UF4w2QBm370MQCA6NXmrIiYwTm8tvkk3ktnsiqCL6iSFa6uZM2cygIG6bDyhcqDTaiSlZzKWQugZpF3WclqdiaLFhGzxDIGhu5AtNkFeXu6YKKijJh+VlnwBYOLaJpkXXPNNfjrv/5rKKafleM4HD16FH/yJ3+C6667zvUDpCgWi/iDP/gDfOhDH3L8mq997Wu44447cOedd+Kpp55CIBDA61//euQrhrMZ2sfQCLH6CCoP+GXwAIzx2STL0HV402TRPS2Qi1tIpjviCjIJsjAfYEpWz8JfI/jCCcmCbwDeKLm2ZB4jJGuui4gZnMFbpmTRdMEKu6ClZFWfyYqfrt2J5w9L8IU8gFGyETcLaybLLSVLLoV9OAErImZg6C6qlhEnk6UOv3CYzE6qxJrOPqsMbqJpknXbbbchnU5jdHQUuVwOr3nNa7B27VqEQiF88Ytf7MQxAgA+//nP45ZbbsGWLVscPd8wDPzt3/4tPve5z+Haa6/F1q1b8aMf/Qjj4+P4xS9+0bHjXKgYMecpAiogrFhB/nw6iaJWLHuelkiAN2tvJrkoeZ6pZFEVKzjgrZ9CxzCvYc1kpRXomt6UXRC+gVLC4P79AOa+iJjBGeyqDuc17YKVM1mp+j1ZcTNNdGBRdRLd7lxWIdsZJUvJl/q36oEVnDIwdBelnizNsgtC1wGz8F4Ih8uUckayGNxE0yvZSCSCBx54AI8++iheeOEFpNNpnHvuubjyyis7cXwt49ChQzh16lTZcUUiEVxwwQV44okn8M53vrPq6wqFAgq2Qs1q1kiG2Vi6JAgdBkRw0JdtAPYdwFgcmMpNYUlwifU8LU4iudMyoKB8JouFXvQH5KAHHAcYBpBNKsjEndsF4Ru0SBaFIM9tETGDM1AlyzAA3Ud+P0blTBbtyapFsmjoRY3P/NDSAE7sj7ecMJjPuDuTZd/8KRa0hptBdHaLWZAYGLoDOpOlFnVwkgTe74eeJZs78HjAyTIU8x7FixwEkdXHMriHlq/8l156KS699FI3j8VV0BCORYsWlT2+aNGiugEdX/7yl/H5z3++o8fWjwj6PMjwQEgHMkMr4Ucp/KKMZJnlskk/YKgBiDwHr3lRowupATaP1dPgeQ5y0INcSsHU8RR03QDPc/BHHJQJ+wYgR8tJFlOy5idEjwBe5KCrBlQPUZx020yWYRiWJafWTFa1jiw7hpbOLyVL8PDWz1zMqQ1JFouFZmDoLkRbuqBhGBCiUYtkCeEwOI4rbYawLjsGl9H0GXXHHXdUfZzjOMiyjLVr1+Kyyy6DIDS+qdx666346le/Wvc5e/fuxcaNG5s9zJbx2c9+Fp/85CetvyeTSSxfvnzOvn+vguM4ZD1AqAAkA4sIyYrNjnEvTJG/J/2AofkR8IpWSShTsvoH/rCEXErB6cNECQ4MeME7SVfzDUDwGhDDItQkufEJssZmsuYpvD4RuZQCzfz9GPmSC8DI5wFzdpevUkasazpmTlOSVcsuSK4FrSpZbvdkAaWf2Un4BbULsuALBobuwLL/GYCm6BCiUSjj4wBKNmaWLMjQKTR957n99tsxOTmJbDaLgYEBAEA8Hoff70cwGMTExATWrFmDhx9+uCE5+dSnPoXrr7++7nPWrFnT7CECAMbGxgAAp0+fxuLFi63HT58+jXPOOafm67xeL7zeBqWpDFWheHmgYGBGiGIMwNiMgZMVMe6piRMAgKSfA3SZdWT1KfxhCdMnMpgwSZYjqyAA+Mg1RR7hkTadukzJmr/w+oliqYh+8AB0W6gQVbHA8+ADs0lUcioPXTMgevia5we9FmSTReTSRfiCDtRQG6iSJQfcUbIAYv1zSrLoDrmH2QUZGLoCqmQB5V1ZAMBHKuLbmeLM4DKaNp9+6Utfwqte9Sq89NJLmJ6exvT0NA4cOIALLrgA3/jGN3D06FGMjY3hlltuafheIyMj2LhxY93/JKm5myrF6tWrMTY2hgcffNB6LJlM4qmnnsJFF13U0nsy1IfuJxeopE4WVCMJYCpZbs3MTp4k/w9KAHiLZOUzCrJmsiAjWb0PGuM+cZgstJsmWTbLoOBlM1nzFTQIQhXMMmKbXVBPlZIFqVptB53Hio75a3ZISbKI8DB57+kTzatZdCbLTSVL8jlPGGTBFwwM3QXPl+as1KIOIRqxvkZL0lkRMUOn0DTJ+tznPofbb78dZ5xxhvXY2rVr8Td/8zf47Gc/i2XLluFrX/saHjPjl93C0aNH8fzzz+Po0aPQNA3PP/88nn/+eaTTJa/+xo0b8fOf/xwAsa994hOfwBe+8AXcd9992LVrF973vvdhyZIlePOb3+zqsTEQCEGyW5zLcdC8IngDyB49XPYcahfMB8nCKWBe1KiKFRzwWosYht6F3+w8oj1FoaEmSVY4az0kykzJmq+g5EXhZ0e4a8kGyYIN5rEoaMJgbLy5uSxdNyy1ya2ZLKC5QuJigdkFGRi6DdFLC4nLlSxWRMzQaTS9mj158iRUdfbNRVVVK1BiyZIlSFGriEv4i7/4C/zwhz+0/r5t2zYAwMMPP4zf+73fAwDs378fiUTCes5nPvMZZDIZ3HTTTZiZmcGll16K+++/H7LscMHH0BS8UQlADkpKgbJ4GMLhUzCOj5c9R41NQwKQD5KFVWV8Oysh7g9QJYsiOODQgktJVjAJgMSCC8wuOG9Bgx9U3iwjtkW46+YGGB+uFd9uBt3UmMeiGFoawOEXpppWsux2Prd6soBSUmAx17ggWWF2QQaGrsMjCShk1LKuLKB0bVJYCihDh9C0knX55Zfj5ptvxnPPPWc99txzz+FDH/oQXvva1wIAdu3ahdWrV7t3lAB+8IMfwDCMWf9RggWQNCv7jBfHcfjrv/5rnDp1Cvl8Hr/+9a+xfv16V4+LoYSAuZDmsiq45SRRUBgvn8nS4zMAgHyA7E7TImI2j9VfCFSQLOdKVhQAIPo1RN/yJkTO9DGSNY8hUSULRCmqqmRVCb0AgPhpZ0rWUItKFlVRPV4BguBeLLPX1g/WCLSMWGJ2QQaGrkGsUkgMAEKYWAeLTMli6BCavvN897vfxeDgILZv326FRJx33nkYHBzEd7/7XQBAMBjEbbfd5vrBMsxvRIaI8sBpAL9sHQAgcCpR9hxuhiy88kFycQtIZMFi7WozktUXqFSyHM9k8QIgR8BxwOJPfhBLXks6t+Bh6YLzEZRwKIZJsqrNZFVRsgzDcKxkDS4l14Tp8QwMo3EBMEUnkgUBwNMEyVIKVMliizcGhm6hVEisV5AsqmSx2UmGzqDpu8/Y2BgeeOAB7Nu3DwcOHAAAbNiwARs2bLCec/nll7t3hAw9g8GQFy9xBkIGB34RUQyjUwUomgKPQBZhYoIsrHL+CBBndsF+hX+WXbAJi65vAMgngFwcKJqzWVLQxaNjcAvWTJZBFif2MmKrIys0uyMrmyiimNfAcUB0tD7Jii7ygxc4KHkNqVgeYXMzpxEKppLldTFZELApWXkndkE6k8VsSAwM3QItJK6cyeJDbCaLobNo+cpP0/8YGCgGAh4keR0hTQAGVgIghcRTuSksDi6GoevwpMgiLGvO3oRkkSQLJlmyYD/BFyqRLDnoae7m5RsA4odNkmVaxFhP1rwEnWFQNPL71e0zWUmaLjibIMfMZMHwiA+Cp76hQhB4DIz5MX0ig9iJjHOSZSpZsstKVmkmy7ldkO2QMzB0Dx5qF1Qq7II0wt2ayWKfUwZ30fTdR9M0/OAHP8CDDz6IiYkJ6Lpe9vWHHnrItYNj6C0M+CUkeANLNaDgicIPEuM+kRrH4uBiaIkEeNPtk/FGARAli6pYwUEvGzztE/hCEjgOMIwmrILWiwkBJyTLDDtgM1nzElTJKqqEKJUpWenaStaMw2RBisElQUyfyGB6PI1VW4cdvSbfISWLpgs6i3BnA/UMDN2GaG7yqQUNwuJShDs/q4yYfU4Z3EXTZ9THP/5x/OAHP8Ab3/hGnHXWWVX7TxgWJgb8EpImi8oURHhEDh7VwOlDLwGLt0ObngYApGVANcjFLeAVbaEXzBLWL+B5DnKQFNW2TLIyk4BWIH9mdsF5CVq3oJi1ZvYyYqpkCVVmspzOY1EMLQ3gpd8215XVqZksqZngC2ZDYmDoOqiSNXsmK2I+zj6nDJ1B03efu+++G//yL/+Cq6++uhPHw9DDsJOsxHQewkgAgyfTSB9+CbgYUGMx8jU/oCrE8hPyiogdZvNY/Qh/WEIupSA46DC+nYKSrOSJ0mMs+GJegvZPFYvkc2/kSsEXWoqE3PBV0gVjTSpZrSQM5rNK2TG6BYtkNejJMgyjtHhjNiQGhq6BzmSpikbUK0EANM2yCzJbL0On0DTJkiQJa9eu7cSxMPQ4QrKIlHmNmpnKwT8WBU6moRw5CgDQTJKV9AP5AiFZRMkiC6fBxWwh3U/whyVMn8i0oGQNkv8njpP/cwIgNknUGOYENASiYJIsvVCAYRjgOA56qnZPVvwUTRN19pmnGzDxU1lomu4okt2ayXKxIwtwHuGuFDTAtEczuyADQ/cgWumCGjiex/DNN0M5cQKe5cutxwGmZDG4j6Yj3D/1qU/hG9/4RlNRugwLAzzPAX5ykcrE8tCWLiJfOEFKqovTpDMrGeBQKJCFd8ArIHaS7Gozu2B/YePFizG8PIjVZzubobFAlazEMfJ/KQAwW/K8hDWTldcIn9A0yztIlazKmaxCTkU2QYJunCpZoSEZHq8AXTMwY/ZrNYKVLuiykkV3uxuVEdOFG8eVdtIZGBjmHlbwhfmZHPnYR7Hkq1+xxl3oZ5UFXzC4jaa31x599FE8/PDD+O///m+ceeaZ8HjKb2D33nuvawfH0HsQQiIwYUAr6uBXrwLwLLwniYKVmSRkK+nnkM1LAIqQNQ45M1nQ6a42Q29g/avGsP5VY82/0CJZpl2QhV7MW9AyYkMHNMELUStAz+chSFLNdEGqYvkjkqUKNQLHcRhcEsDpQ0nETmQs+2A9dGomy2uzC1LVrhqs7h2vwGaXGRi6CCvCvVh9Y4QG1LDgCwa30fQZFY1G8Za3vKUTx8LQB4iGvMhwOQQMDsII6coKnia2ofwEIVmFkBeZPEml1BMk2CA0KDNLDQMBJVnZKfJ/No81byF6ePACB10zoHn8JZIVDkNLk8+9EC5XsuInm5vHohhaGsTpQ0lMj6exDosaPr9gzmTJHZrJ0jUDmqJDlKrvftOZLQ+7rjEsUGiaBoWm4nQRos+AHOFhcCrytnAeCs6rk6/z1b/OsPDg8XggCO0rm01f/b///e+3/U0Z+hdRv4QEn0VA4yCGSVfWQKwIQ1VRjE1BBKBGAsgUyQJEiZn9WCz0goGCkiwKpmTNW3AcB8knIp9WoAWiQD4OI5+HoSgwsoRM8cHqStagw2RBiqGl5DxwmjCYz5hKlsszWR6vAHAADGJ9rEWyrCJiZkFiWGAwDAOnTp3CzMxMtw8FAMBFNGx5UwSiZODQoUOzvr7pdWRudDJxEtMppjozEESjUYyNjbXlRGBbbAyuYtAvIcnrWKLxEDyjUATAowG5E8egxWIQAeiREHQzJCw7RXaNWAkxgwVGsnoKXkqyfCQOWc/lLRULAIRQefBFnCYLNvmZH2wyYbDQoXRBjuMgySKKORXFnIpApHooC4tvZ1iooARrdHQUfr+/63bZQlZBOl6AKPGIjJRv7ui6gbhEg3gCZLacYUHDMAxks1lMTEwAABYvXtzye7VEsn72s5/hX/7lX3D06FEUi8Wyr+3cubPlg2HofUQDHpwyY9y1pIDTAxyWTRmYemk3jHgCAKBHIkAa4Dkgebq1BRdDH4ORrJ4CnXnSfMQWaORz0FPmPJbfD04sv81QJSvarJJlqt3JqTyKebWuvVhTdKhFvez43ITkEwjJytcOv1CYXZBhAULTNItgDQ0NdftwAACcLqAgGhBFAbJcnnaraTo8ItmQ8fnkrhNChvkBn48kYE9MTGB0dLRl62DTkUd33HEH3v/+92PRokV47rnncP7552NoaAivvPIK3vCGN7R0EAz9gwG/hIRJslKxPOLDZJc3+cp+CDNkB9qIkEV0QBKtUlJmF2SwUEmy2EzWvAadUVJloljp+QI0K/SiXMXSFB3JSdKlNdjkTJYvJMEXlgDAKjCvBdqRBQ6OwzWagZMY9yKzCzIsQNAZLL9//ly3KXGqlopt6Ib1HEawGOyg53A7c4VNk6zvfOc7uOuuu/DNb34TkiThM5/5DB544AF87GMfQyKRaPlAGPoDgxUkKzNKdrdzrxyEmCaLKz1CdreGPCJyKXLyDjS5q83QxxBEwGsLS5BYtP98BlWKVPP3RJQsM769oiNrZiILwyDEwx+Rmv5eVM2KjdcnWVayoE8E1wH7D1XR6pEshRWcMixgzCfCwpkr3WrNQ/QxjrUsMFTAjXO46dPq6NGjuPjiiwEQOS1l2kL+8A//ED/96U/bPiCG3kbU70GSkqzpPJQlhFBxe18GZ17MjBDpTVoEsvgIDbFkQYYK+KKlP0uMgM9nUFVHNW2dei4PjdoFKzqy7PNYrdzAhpYSIjd9ov5cltWRFXB3HotCssW410KxQL4msVhoBoauwrrW6PWVLAYGt9E0yRobG0MsRnqPVqxYgSeffBIAcOjQIVZQzICBgGSRrEJWhTFGGtV9L48DAJI+QBTIwmtEJ6cfswoyzILdMshmsuY1JDNYQhOJh123z2TV6MgaWNQacR5sUsmSOzCPBdhIVp1CYqZkMTDME1h2wdlfKilZjGQxuI+mSdZrX/ta3HfffQCA97///bjllltw1VVX4R3veAfrz2LAgF+CwgE5U7byDK8DAPAaGUJP+gHBIAuvAdPmypIFGWbBTrI87PyYz6BKlmKSLCNfsJQsoY6S1QqcKll0JqvTSlahrl3QVLIYyWJg6CpKdkFjlhhQUrI6ewz/8z//Y819Vfvv8ssv7+wBMHQFTW/z3XXXXdB1smD+8Ic/jKGhITz++OO45pprcPPNN7t+gAy9hQFzVzvBG/BpHHz+5VB5QCSnDJJ+gNMDAAwEC+TixkgWwywwJatnYM1kCSS1S8/noJvBF5UzWZaS1eIM5uDiAMABuZSCbLIIf7j6XFeBdmR1SskyiVPd4Asrwp3ZBRkYuokyK6AB0nNH/2qSrk4rWRdffDFOnjw56/H77rsPf/RHf4Q//uM/7uj3Z+gOmlayeJ6HaIvkfec734k77rgDH/3oRyFJzQ8yM/QXIj4POA5W+MX/v707j4uq3v8H/jowzLCvIjMIiAuISxak3pAUcAnz5hUzNS0N09JQ+ZUrWYFLi7lcTb0WWUnd6zfL7Fo30dzAErlidqG8KppXwAUiZHOQfc7vj2EOM7KIOMPm6/l4zCM962fG05l5n/fn8/5YVjgiz7FufYm1ALFG+wPLqkwbebG7INVjEGRxTFZ7JlUXFLSVRMVyvTFZtnVBlqgRUaTLZN1lZUEdC4U57LtoM2ZNzZely2RZGnmOLJ3mjMlid0Gi9kFoIKiS/q7RbWPaIEsul0OpVBq8CgsLsXjxYixfvhyTJk0CABw7dgxDhgyBQqGASqVCdHQ0qqvr7jMhISGIiorC0qVL4ezsDKVSiRUrVhicq6ioCLNnz4arqyvs7e0xYsQIpKenS+vT09MRGhoKOzs72Nvb4+GHH8ZPP/1k0vd/v2rRI7aioiKkpqYiLy9PymrpzJgxwygNo45JZm4Ge0sLlNzSADCHrNQKuU4C3Au0N7Zia0CstoaVphTmVdplLf3BRZ2YlXPdn1ldsF2TugtC+5BNU14ujcnSz2TdLChHdZUGZjIB9l0s6x+omVzcbVDyRxluXCuFh59zg9tI1QVNlMlqXgl3XXdBZrKI2pIgCNpISxTrjcuSMlmtPCSrqKgI48ePR0hICFavXg0AuHbtGsaOHYuIiAh89tlnOH/+PF544QVYWloaBFKffvopFi5ciJMnTyIlJQUREREICgrC6NGjAQCTJk2ClZUV9u/fDwcHB8TFxWHkyJG4cOECnJ2d8cwzz8Df3x/vv/8+zM3NkZaWBgsL0zyQut/d9d3/X//6F5555hmo1WrY29sbRP+CIDDIIjhZW6C4qAIAIN40R65eUqLEGqiutESXGm0S1b6LJSwUfNJLtzEYk8VMVnsmt9YFWdr/io1UF9SNx3Lsag0z85bXS3bpZovL6flNZrIqdGOyTJXJakZ3waoKZrKI2ovaGEsag6UjjclqxcIXGo0G06ZNg0wmw86dO6Xf0du2bYOnpye2bt0KQRDg5+eH69evY9myZYiJiYGZmfa+OXDgQMTGxgIAfHx8sHXrVhw5cgSjR4/G8ePHpSSIQqHtXbB+/Xrs3bsXX331FV588UVkZ2djyZIl8PPzk45BpnHX33SLFi3C888/D7VajaKiIhQWFkovXdVBur/pVxgsL6xBnnPdj4xKeyuUVYrootHeVDgeixrEMVkdhpTJ0mj/qykvh6akdp4sveqC9zoeS0fXvfhGExUGpTFZNiauLljeeHVBaTJiPkQianNCIxUG22KerOXLlyMlJQXffPMN7PQmbD937hwCAwMNkhdBQUFQq9W4evWqtGzgwIEGx1OpVMjLywOg7QqoVqvh4uICW1tb6XX58mVcunQJALBw4ULMnj0bo0aNwpo1a6TlZHx3/Q107do1REVFtavZvKl9cbKW46o0IXEFypSOAPIBABoHW5RWVsOlhuXbqQkMsjoMXZe8Ko05RGgnI65Ra7NMBpmsHF2QdW//ni7u2sCt4HopRI3Y4BPoitYak9WM6oIW7C5I1OYEMwA1DY3Jat15snbt2oX169dj3759Lc4g3d61TxAEaeiOWq2GSqVCUlJSvf0cHR0BACtWrMC0adOwb98+7N+/H7Gxsdi1axcrhJvAXcfuYWFhHCBHTXK0tpAKX5SrqyAq3etWOjngZnk1utRob2gtLeVMnRyDrA5DF3BoRAEaMwtoyisazmT9rivffm8P6BzcrGAmE1BVUYObBeUNblNu6kyWZTNKuNd2F2QJd6K2J2Wybu8u2ErVBQEgLS0Ns2bNwpo1axAWFlZvfd++fZGSkmIQCCYnJ8POzg4eHh7NOkdAQAByc3Mhk8nQu3dvg1eXLl2k7Xx9ffHKK6/g4MGDePLJJ7Fjx457f4NUT7O+gXTzYgHAn//8ZyxZsgRnz57FAw88UC+i/stf/mLcFlKH42wtR6UAiBYChCoRVg69UCP8AnMRMHd2QmlJFVx0ExEzyKKGMMjqMCwU5hDMBIgaEdUya2jKy+rGZNnrZ7Jqgyy3e/v3NDc3g5ObDW5cU+PGNbVUbVCfycdk3aG7oEYjorpS+2SZY7KI2p4uUVWvu6DGcL2p5OfnIzw8HCEhIXj22WeRm5trsN7c3ByRkZHYtGkTFixYgPnz5yMjIwOxsbFYuHChNB7rTkaNGoXAwECEh4dj7dq18PX1xfXr17Fv3z5MmDAB/fv3x5IlS/DUU0+hR48euHr1Kk6dOoWJEyea4m3f95oVZIWHh9dbtmrVqnrLBEFATU3jfdTp/uBko60yVqkwg6KqBs6iO74eKqBbAaDp3g1VJ2tgLTKTRU3gZMQdhiAIUFjJUF5ahWqZFcTSW9DUdhc0rx1vUHazEuWlVYAAON7jmCwAcOlWG2RdL0WPB10N1omiKI3JsjRRJks3Dq26ogaaGk29Qh66LBYAyDlPFlGbqxuT1TaZrH379iErKwtZWVlQqVT11nfv3h2ZmZlISEjAkiVL8OCDD8LZ2RmzZs3C66+/3uzzCIKAhIQEvPbaa5g5cyb++OMPKJVKDB8+HG5ubjA3N8eNGzcwY8YM/P777+jSpQuefPJJrFy50phvl2o16+5/e5l2oqY41j49LrMQoADgUNEF24Zrn+Y+Z+UMmVr7A8TSUQ4LOZ/yUgOsXQDrLtrHjJYObd0augO5dV2QVV1QANR+Z5jVBlm6ohd2zpZG+X/epZstgN9RcK1+hcGqihpoarsEmSqTZWGlV8ynvAaWNrcFWbXjsczMBZhbtOKIeiJqkK6wRf1MlnaBmYlTWc899xyee+65O24XHByM1NTURtc3NNZq7969Bn+3s7PD5s2bsXnz5gaP8fnnn9+xHWQcfMRGRudsrc1k3TQX4QjAutxButIcLR1hVVYDwBx2biyeQo0wlwFzftAGWTJOct7eSZkdmRWq/7gCABAsLCDUlhAuyLm3SYhv11SFQd0cWWbmAmRy0wQ45uZmkFmYobpKg8qyaljaGAZzlZyImKhdkQpb1BuTVbuez0LIBJp9WR09ehT9+vVDSe2AZn3FxcXo378/fvjhB6M2jjomx9ogqwDap9nmpXVjJhzkDrCt0N7VOB6LmuTQDXD0bOtWUDPoxihVyaykiYjN9OZRLMrVBVnGebCizWRpj1tTbdjTQhqPZWNh0ophdeOy6he/qJLKt/M5JlF70GgJ91auLkj3l2YHWZs2bcILL7wAe72BzDoODg6YM2cONm7caNTGUcfkXDsm6w+N9seHeLPuaa6NhQOcq7U3M1cP2/o7E1GHoyvjXi2rC6LMbY0/R5aOrZMCcktzaDQiimqrFupI47GsTRvgNFXGvbJCV76dmSyi9qCu8IVhlKVLbDHIIlNodpCVnp6OMWPGNLr+sccew+nTp43SKOrYnGrHQeRUaZ8oVxbV3dTksEWX2sqCSg+7+jsTUYej311QR7+yYIEuyDJS9loQBDjXzpd147rhuKxyE1cW1NGVZq8oq1/sSZfJsuBExETtg5muhHvdIlEUpdQWuwuSKTT7svr999/rlWvXJ5PJ8McffxilUdSx6boLFgm1c2XdrIZCtAQACGU2sBIFiBA5ETFRJyG3rh9k6SoLVpZXQ11QAQBwNtKYLABw7lY7Luua4bgs3ZgsU82RpdNUJktX+IJzZBG1Dw1lsvTnzGImi0yh2UFWt27dcObMmUbX//LLLw2WpaT7j1xmBluFDOUCYK7QXmLTvZ7HCM8RsChwBADclIGVBYk6ibpMVl13QF1lweK8MgCApa0FLG2Nl11yqc1kFdxW/KK8VJvJsjRxJkvRVHdBqfAFx2QRtQcNjcky6DnIGItMoNlB1tixY/HGG2+gvLy83rqysjLExsbiiSeeMGrjqONytLYABEBhr81qTXCbjPdGvIeiXO0PLrWCdzSizkLRUCbLXhtkFeQYdzyWjouUyTLsLihlslprTFZDhS8qdIUv+CCJqD2oK+FeP5MlmAnMZJFJNPtb6PXXX8fXX38NX19fzJ8/H3369AEAnD9/Hn/7299QU1OD1157zWQNpY7FyVqOq4VlEGxlwB/AzQJtcH6z9ql2uRU7QBN1Fg2OybI1nCPL2BOP6zJZN2+Uo7K8GvLarFFFaV11QVPSna/hTJau8AUzWUTtgZTJ0usiKLLoBZlYs78B3NzccOLECbz00kt49dVX62bJFgSEhYXhb3/7G9zc3EzWUOpYnGorDGpqJ+0suaENsm79of1vlS1/fBB1FrqsTrVFXSCly2QV1pZvN+Z4LEDb/dDaQY5bxZUouF4KZU/tpNWtl8nS3tsqmyp8wTFZRO1C3ZisumV1maw2aBDdF+7qW6h79+5ISEhAYWEhfvvtN4iiCB8fHzg5OZmqfdRB6SoMVtaOybp5oxyiKKKqdgA87E37lJmIWo/UXdBCf0yWtrqgLshyNHJ3QQBwcbfBreJK3Lim1guydGOyWqe7YEWDJdxruwsyyCJqFwRddUH97oIi58hqDUlJSQgNDUVhYSEcHR3bujmtqkXxu5OTEwYPHowhQ4YwwKIGOdVWGCyt/Z1z80Y5bpVUQqzUQAMRMkd5G7aOiIxJbqV9aGJYXdAWmhoNivOMOxGxPudu9YtflJfqqguauLtgk5MR13YX5GTERO1Cg5ksXXdBMwFJSUkQBKHRV2hoaOs3ugGJiYkYO3YsXFxcYG1tjX79+mHRokW4du2a0c6RmZkJQRCQlpZmtGPeibe3d4Of+5o1a4xy/BUrVuChhx4yyrHuBpOkZBK6IKvYTDspxc0bZdIA+GIzEdYmfspMRK1HymSZW0rLzOzsUfxHGTQ1ImRyM9g5WTa2e4u5NDBXVkWrzZPVVAl3ZrKI2hMpW6WpX/jCTACGDh2KnJyceq+4uDgIgoDIyMi2aLaBuLg4jBo1CkqlEnv27MHZs2fxwQcfoLi4GBs2bGj19lRWVhr1eKtWrar3+S9YsMCo52htDLLIJJxqnyLfqJ35r7SkEvnZ2h9C+WYibBXsLkjUWegKX2gEGWrMtH82t7eTugo6KW2k7jrGpKswqJ/J0o3JsjTxPFl1Jdzrj8mq5Jgsonal4RLuddUF5XI5lEqlwauwsBCLFy/G8uXLMWnSJGm/Y8eOYciQIVAoFFCpVIiOjkZ1dd3DlpCQEERFRWHp0qVwdnaGUqnEihUrDNpTVFSE2bNnw9XVFfb29hgxYgTS09Mbbf/Vq1cRFRWFqKgofPLJJwgJCYG3tzeGDx+Ojz76CDExMdK2x48fx7Bhw2BlZQVPT09ERUWhtLTuHunt7Y23334bzz//POzs7ODl5YUPP/xQWt+jRw8AgL+/PwRBQEhICAAgIiIC4eHheOutt+Du7i4VwPv73/+OQYMGwc7ODkqlEtOmTUNeXl5z/lkM6PbXf9nYaO/xNTU1mDVrFnr06AErKyv06dMH7733nsH+SUlJGDJkCGxsbODo6IigoCBkZWUhPj4eK1euRHp6upQhi4+Pv+v2tQSDLDIJXSYrv7IKMrkZIAJZ/72hXWaugS1LGxN1GhYKc6k7jm6uLDM7O6myoKOb8bsKArUVCwWg7GYVbpVUQqMRpTFSJs9kNTUZcUXtZMTsLkgEURRxq7K61V/646+gV8Jdt7z2GXCDY7KKioowfvx4hISEYPXq1dLya9euYezYsRg8eDDS09Px/vvv4+OPP8abb75psP+nn34KGxsbnDx5EmvXrsWqVatw6NAhaf2kSZOQl5eH/fv34/Tp0wgICMDIkSNRUFDQ4Ge4e/duVFZWYunSpQ2u1411unTpEsaMGYOJEyfil19+wRdffIHjx49j/vz5Bttv2LABgwYNwn/+8x9ERkbipZdeQkZGBgAgNTUVAHD48GHk5OTg66+/ljfijTEAAEPNSURBVPY7cuQIMjIycOjQIXz33XcAgKqqKqxevRrp6enYu3cvMjMzERER0WA7W0qj0cDDwwO7d+/G2bNnERMTg+XLl+PLL78EAFRXVyM8PBzBwcH45ZdfkJKSghdffBGCIGDKlClYtGgR+vfvL2XIpkyZYtT2NYbfAGQSuiCrsKwKds6WKMy9hZzfigAAN8xF2PDHB1GnIZgJkFvJUHGrGtUyKygqS2BuZ4fC3CIAgLPKNEGWhdwcDl2sUPxHGW5cU8PVyw6o/V3VatUFGxiTxUwWUZ2yqhr0i/m+1c97dlUYrOXa+4B+ICWK2jFajVUX1Gg0mDZtGmQyGXbu3Gmw77Zt2+Dp6YmtW7dCEAT4+fnh+vXrWLZsGWJiYmBmpj3YwIEDERsbCwDw8fHB1q1bceTIEYwePRrHjx9Hamoq8vLyoFAoAADr16/H3r178dVXX+HFF1+s914uXrwIe3t7qFSqJt/zO++8g2eeeQYvv/yydO7NmzcjODgY77//Piwttd22x44dK3WBXLZsGTZu3IjExET06dMHrq6uAAAXFxcolUqD49vY2OCjjz6CXF43rv7555+X/tyzZ09s3rwZgwcPhlqthq2tbZPt1bds2TK8/vrrBsv279+PYcOGwcLCAitXrpSW9+jRAykpKfjyyy8xefJklJSUoLi4GE888QR69eoFAOjbt6+0va2tLWQyWb33Y2r8pUsm4Vj7FLnwVhXsXBxRmHsLmhrtDe2GmQa2DLKIOhWFdV2QBQBm9vYozNEOxnYycvl2fS7dbFH8RxkKrpfCvov2B4RMYQ5zmWk7auhnskRRNPghxhLuRO2LQbJKFAEI0DRSXXD58uVISUlBamoq7OzsDNadO3cOgYGBBvsEBQVBrVbj6tWr8PLyAqANsvSpVCqpC116ejrUajVcXFwMtikrK8OlS5cabP/t95jGpKen45dffsHOnTsN9tVoNLh8+bIUeOi3TxAEKJXKZnXxe+CBBwwCLAA4ffo0VqxYgfT0dBQWFkKj0aYIs7Oz0a9fvzseU2fJkiX1MmDdunWT/vy3v/0Nn3zyCbKzs1FWVobKykqpmIWzszMiIiIQFhaG0aNHY9SoUZg8efIdg1JT4y9dMgnn2nmyCksrYddDIS0Xoc1kMcgi6lykubLMrQBBgGBlhcLf68ZkmYpzNxv8L+0PbRn3Xtoy7qYu3w7UvV9RBKoqaqRCGABQqesuyMmIiWBlYY6zq8La5Lw6giDUpq9EbTdBc73ugnrPY3bt2oX169dj37598PHxafG5LSwMuysLgiAFH2q1GiqVCklJSfX2a6zEua+vL4qLi5GTk9Nk4KBWqzFnzhxERUXVW6cLAO/UvqboxkjplJaWIiwsDGFhYdi5cydcXV2RnZ2NsLCwuy6M0aVLF/Tu3bvBdbt27cLixYuxYcMGBAYGws7ODuvWrcPJkyelbXbs2IGoqCgcOHAAX3zxBV5//XUcOnQIjzzyyF21w5j4DUAmoesuWK0RobCve+pRagHUCGB3QaJORlcIolpmBTM7O9wqqUZVeQ0EMwEOXa3usHfL1VUYLG21yoIAILMwg2AmQNSIqCyrC7JqqjXQVGufkFtw7CkRBEGQuu21bTu0D0WkMVm3ZbLS0tIwa9YsrFmzBmFhDQeFffv2xZ49ewwyS8nJybCzs4OHh0ez2hEQEIDc3FzIZDJ4e3s3a5+nnnoK0dHRWLt2LTZu3FhvfVFRERwdHREQEICzZ882Gqw0hy5TVVNTv6jP7c6fP48bN25gzZo18PT0BAD89NNPLT53Y5KTkzF06FCDKo8NZf38/f3h7++PV199FYGBgfi///s/PPLII5DL5c16P8bGwhdkElZyc1haaC8vwbbu5lpU+9vHlk94iToVKZMls64dj6UteuHgamXSrntShcGcUpSX6oIs099fBEFocFyWrqsgwBLuRO3J7RUG9asL5ufnIzw8HCEhIXj22WeRm5tr8Prjjz8AAJGRkbhy5QoWLFiA8+fP45tvvkFsbCwWLlwojce6k1GjRiEwMBDh4eE4ePAgMjMzceLECbz22muNBiienp7YuHEj3nvvPcyaNQvHjh1DVlYWkpOTMWfOHKk4x7Jly3DixAnMnz8faWlpuHjxIr755pt6hS+a0rVrV1hZWeHAgQP4/fffUVxc3Oi2Xl5ekMvl2LJlC/73v//h22+/NSgUcjdu3rxZ73MvKSkBoB1b9tNPP+H777/HhQsX8MYbb+DUqVPSvpcvX8arr76KlJQUZGVl4eDBg7h48aLUPdLb2xuXL19GWloa8vPzUVFR0aI23i0GWWQyumxWld4PjXxzbTqa3QWJOhdprqzaTJYuyDLFJMT6dEFcdUUN/qidJsLSxBMR6ygaqDCoC7jMLcxgZs6vWKL2QtCrMAjoVxcE9u3bh6ysLCQkJEClUtV7DR48GIB2jFBCQgJSU1Px4IMPYu7cuZg1a1a9gg1NtkMQkJCQgOHDh2PmzJnw9fXF008/jaysLLi5uTW6X2RkJA4ePIhr165hwoQJ8PPzw+zZs2Fvb4/FixcD0I61OnbsGC5cuIBhw4bB398fMTExcHd3b3b7ZDIZNm/ejLi4OLi7u2P8+PGNbuvq6or4+Hjs3r0b/fr1w5o1a7B+/fpmn0tfTExMvc9dV01xzpw5ePLJJzFlyhT86U9/wo0bNwyyWtbW1jh//jwmTpwIX19fvPjii5g3bx7mzJkDAJg4cSLGjBmD0NBQuLq64vPPP29RG++WIBrUuKTblZSUwMHBAcXFxbC3t2/r5nQoj7/3I87llGD75Idw4UNtadD9tlU4I6tGcvQIdHM0XRciImpdx7+8iPSjV9A963s80CUHmY+/hjM/XENAWHcETuhl0nN/8VYq8q+o0dXbHnmZJeg7VIURM/reeUcjnXfcggfh1V87iP3GNTV2rU6FlZ0Fnl83zORtIGpPysvLcfnyZfTo0UOqZNdeFOSUorqyBg6uVlBYW+DGdTVqqjRwdLPm+Emqp6lrubmxAR+zkck41z5NVkPUzpUFIFfQdqVhJouoc5Fb13UXNMhkmah8uz5nd22XwT+ybwIAFK2UydL9MKswyGTVVhbkeCyidkVXnE/qLtjEPFlExsAgi0zGUTdX1q0qBE/rgwGjPZFvpr272cj5A4SoM9F1nauSWUHh64PC3NrKgm6mqyyooyt+oZv3pjXGZAF149D0x2FV1XYXtOCTcaJ2pW5M1m2FL/hLmEykw1xab731FoYOHQpra+tGS1zqq6qqwrJly/DAAw/AxsYG7u7umDFjBq5fv276xhIAwKm2wlfRrUr4PaJCz9BugABYWphBxrEKRJ2KLrCRBw6H/eyXcKtEW77X1GOyAO1cWfpaa0yWrvBFQ5ksFr0gal/qxmRpAyxpMmJmsshEOswv3crKSkyaNAkvvfRSs7a/desWfv75Z7zxxhv4+eef8fXXXyMjIwN/+ctfTNxS0nGuzWQV3NL+2FLXzh1jq2idH0BE1Hqk6oKQoSivHABg46iQlpuSrrugTqtlsizrF76oqr3PWbBLNFG7ImWyNKJ20k7dcjMGWWQaHeZbYOXKlQCA+Pj4Zm3v4OCAQ4cOGSzbunUrhgwZguzsbINJ2fRVVFQYlHbUlY+ku6ffXRAASqUgi094iTobXWBTcasaBTmtU1lQx9ZJG8zpgp3W7i6oX8KdmSyi9knKWOnNlaVd3kYNok6vw2SyjKG4uBiCIDTZ3fCdd96Bg4OD9NJNrkZ3z8mmrrsgANysDbI4ETFR56MLOCrKqlGkG4+lNP14LED748lFL5vVliXcdeOzLBhkEbUrdYUvRGj0il6wuyCZyn0TZJWXl2PZsmWYOnVqk+UWX331VRQXF0uvK1eutGIrOxfdPFkFpbdnshhkEXU2UsBxq7rV5sjS56w3LqvVM1lleoUvau9zct7niNoXM113Qb2iF4yvyITaNMiKjo6WniI09jp//vw9n6eqqgqTJ0+GKIp4//33m9xWoVDA3t7e4EUtowuydJksdTmDLKLOSpqMuEqD/KvaSYGdVK2TyQJgkMlSWLdWCffGC18wk0XUvuhnsqSiFxyPRSbUpr92Fy1ahIiIiCa36dmz5z2dQxdgZWVl4ejRowyaWpGzjW5MlmHhC3YXJOp85JYyQAAgAupC7bjW1sxkuXSrDbKEuqyaqdWVcGd3QaL2ThdQiaIozZXFroJkSm36a9fV1RWurq4mO74uwLp48SISExPh4uJisnNRfY61T5PLqzQoq6xBaUXtRMScP4ao0xHMBMgt64pPyK1ksLaXt9r5Xb3sYeukgH0Xq1Z7Oq0/Dk1HVwRDzvscUbuiPxlxXSarDRt0n0hKSkJoaCgKCwubNQVTZ9JhLq/s7GykpaUhOzsbNTU1SEtLQ1paGtRqtbSNn58f/vnPfwLQBlhPPfUUfvrpJ+zcuRM1NTXIzc1Fbm4uKisr2+pt3FdsFTLIan/sFN6qhLqiSlpORJ2PfgbJSWndqk+JLRTmeHZ1IMa/4t9q52y4hHuN1B4iaj/0S7jXjcnSLktKSmpy6EpoaGibtVtfYmIixo4dCxcXF1hbW6Nfv35YtGgRrl27ZrRzZGZmQhAEpKWlGe2YTXn66acxZswYg2UHDhyAIAhYsWKFwfIVK1Y0Wh38bsTHx7dKwNdhgqyYmBj4+/sjNjYWarUa/v7+8Pf3x08//SRtk5GRgeLiYgDAtWvX8O233+Lq1at46KGHoFKppNeJEyfa6m3cVwRBgJNel0F17Y8PGzmDLKLOSK5XcKI1x2PpmMvMYNaKYyx0kxHrxmHp/5kl3InaF8NMVu2y2l/BQ4cORU5OTr1XXFwcBEFAZGRk2zRaT1xcHEaNGgWlUok9e/bg7Nmz+OCDD1BcXIwNGza0enuMlbAIDQ1FcnIyqqvrHlYlJibC09MTSUlJBtsmJia2m4C3OTpMkBUfH1/bj9bwFRISIm0jiqI0xsvb27vB7W/fh0zLqbbLYGFpVV11QXajIeqUbs9kdXa691tTpUFNtfZXm258lgXvc0TtiuGYLMNMllwuh1KpNHgVFhZi8eLFWL58OSZNmiQd59ixYxgyZAgUCgVUKhWio6MNAoSQkBBERUVh6dKlcHZ2hlKprJeRKSoqwuzZs+Hq6gp7e3uMGDEC6enpjbb96tWriIqKQlRUFD755BOEhITA29sbw4cPx0cffYSYmBhp2+PHj2PYsGGwsrKCp6cnoqKiUFpaKq339vbG22+/jeeffx52dnbw8vLChx9+KK3v0aMHAMDf3x+CIEi/mSMiIhAeHo633noL7u7u6NOnDwDg73//OwYNGgQ7OzsolUpMmzYNeXl5zf53CQ0NhVqtNkiaJCUlITo6GidPnkR5uXZy+/Lycpw8eVIKsu70GaanpyM0NBR2dnawt7fHww8/jJ9++glJSUmYOXOmNK1TQxkzY+kwQRZ1THUTEldKhS84GTFR5yQ3CLJaP5PV2vQDKV2XQV13QWayiGqJIlBZ2vovvQmHAf3ugrhjdcGioiKMHz8eISEhWL16tbT82rVrGDt2LAYPHoz09HS8//77+Pjjj/Hmm28a7P/pp5/CxsYGJ0+exNq1a7Fq1SocOnRIWj9p0iTk5eVh//79OH36NAICAjBy5EgUFBQ02J7du3ejsrISS5cubXC9ruvbpUuXMGbMGEycOBG//PILvvjiCxw/fhzz58832H7Dhg0YNGgQ/vOf/yAyMhIvvfQSMjIyAACpqakAgMOHDyMnJwdff/21tN+RI0eQkZGBQ4cO4bvvvgOgHZ6zevVqpKenY+/evcjMzLxjUTt9vr6+cHd3R2JiIgDg5s2b+PnnnzFp0iR4e3sjJSUFAHDixAlUVFRIQdadPsNnnnkGHh4eOHXqFE6fPo3o6GhYWFhg6NCh2LRpE+zt7aWM5eLFi5vd3rvBR21kUs4NBFmsLkjUOenPT3U/ZLLMzARYKMxRVVGDirJqWNnJ60q482ESkVbVLeBt99Y/7/LrgLzuYY9BCXfRcJk+jUaDadOmQSaTYefOnQZjS7dt2wZPT09s3boVgiDAz88P169fx7JlyxATEwMzM23uYuDAgYiNjQUA+Pj4YOvWrThy5AhGjx6N48ePIzU1FXl5eVAoFACA9evXY+/evfjqq6/w4osv1mvTxYsXYW9vD5VK1eRbfuedd/DMM8/g5Zdfls69efNmBAcH4/3334elpSUAYOzYsVIXyGXLlmHjxo1ITExEnz59pIJ0Li4uUCqVBse3sbHBRx99BLm8rqjR888/L/25Z8+e2Lx5MwYPHgy1Wg1bW1s0R2hoKJKSkvDqq6/ixx9/hK+vL1xdXTF8+HCpcEZSUhJ69OiB7t27N+szzM7OxpIlS+Dn5yd9FjoODg4QBKHe+zM2ZrLIpJxsGuguyCCLqFPSdZ8zl5nBvotVG7emddSVca+BKIpSd0FWFyRqX6RgSWw6k7V8+XKkpKTgm2++gZ2dncG6c+fOITAw0CDwCgoKglqtxtWrV6VlAwcONNhPpVJJXejS09OhVqvh4uICW1tb6XX58mVcunSpwbaLotisQkLp6emIj483OG5YWBg0Gg0uX77cYPt0wUZzuvg98MADBgEWAJw+fRrjxo2Dl5cX7OzsEBwcDEBbsK65QkJCkJycjKqqKiQlJUldFIODg6VxWbpgS/c+7/QZLly4ELNnz8aoUaOwZs2aRj9bU+K3AJmUU4PdBXnZEXVGusIXjm5WrVqAoi3JrWQoLapARVk1qqs00hNyzpNFVMvCWptVaovz6qtNKzQ0Jktn165dWL9+Pfbt22eQ+bjrU1sYToguCAI0Gu24TbVaDZVKVa+oA4BGK975+vqiuLgYOTk5TWaz1Go15syZg6ioqHrr9KvyNdW+ptjYGHYDLy0tRVhYGMLCwrBz5064uroiOzsbYWFhd1UYIzQ0FKWlpTh16hQSExOxZMkSANog6/nnn0dBQQFOnjyJOXPmSO/zTp/hihUrMG3aNOzbtw/79+9HbGwsdu3ahQkTJjS7XfeKv3bJpPSDrFJ2FyTq1Gxq58Vydm9eF5HOQDf2qrKsWpqIGAAs5AyyiABo++TJ236Mpn5ApampP09WWloaZs2ahTVr1iAsLKzBY/Tt2xd79uwxyCwlJyfDzs4OHh4ezWpHQEAAcnNzIZPJ4O3t3ax9nnrqKURHR2Pt2rXYuHFjvfVFRUVwdHREQEAAzp49i969ezfruA3RZapqamrusCVw/vx53LhxA2vWrIGnpycAGBSwaK5evXrB09MT3377LdLS0qRsWLdu3dCtWzds2LABlZWVUiaruZ+hr68vfH198corr2Dq1KnYsWMHJkyYALlc3qz3d6/YXZBMSjchceGtKmayiDo53yFKPBLeE3/6S8+2bkqr0XWRrCyvRlXtPc5CYd5qEyITUfPoJ62kIKt2YX5+PsLDwxESEoJnn31WmldV9/rjjz8AAJGRkbhy5QoWLFiA8+fP45tvvkFsbCwWLlwojce6k1GjRiEwMBDh4eE4ePAgMjMzceLECbz22muNBiienp7YuHEj3nvvPcyaNQvHjh1DVlYWkpOTMWfOHKk4x7Jly3DixAnMnz8faWlpuHjxIr755pt6hS+a0rVrV1hZWeHAgQP4/fffpamRGuLl5QW5XI4tW7bgf//7H7799luDQiF3IzQ0FNu2bUPv3r3h5uYmLQ8ODsaWLVukAhnAnT/DsrIyzJ8/H0lJSdLndOrUKfTt2xeAtsKiWq3GkSNHkJ+fj1u3brWozXfCIItMyrl2nqz8mxUor9KmohlkEXVOcisZHh7jDQfX+2M8FlA3JquyrLqu6AW7ChK1O7py3QCguW1M1r59+5CVlYWEhASDeVV1r8GDBwPQZlYSEhKQmpqKBx98EHPnzsWsWbPw+uuv31U7EhISMHz4cMycORO+vr54+umnkZWVZRBc3C4yMhIHDx7EtWvXMGHCBPj5+WH27Nmwt7eXquMNHDgQx44dw4ULFzBs2DD4+/sjJiZGCk6aQyaTYfPmzYiLi4O7uzvGjx/f6Laurq6Ij4/H7t270a9fP6xZswbr169v9rn0hYaG4ubNm/WmWQoODsbNmzcN5se602dobm6OGzduYMaMGfD19cXkyZPx+OOPY+XKlQC086LNnTsXU6ZMgaurK9auXduiNt+JIIq31bgkAyUlJXBwcEBxcTHs7e3bujkdzumsQkx8/wTsLWUoqR0QfuHNxyGXMb4noo4v8e/ncDY5B3/6Sw+4+zjhnxt+hqObNZ5Z+UhbN42o1ZWXl+Py5cvo0aOHVMmuPfnjyk2p6AUAOLpZs0gNNaipa7m5sQF/6ZJJ6SYj1gVYcpkZAywi6jR0mayKshpUltd1FySi9uf2Qhfs1kumxF+7ZFK67oI67CpIRJ2J3GBMFufIImrPhNt+9TanLDpRSzHIIpOyt7SA/oMiBllE1Jnoj8nSVReUc0wWUbtUP5PVRg2h+wIvLzIpMzMBjtZ12SyWbyeizkQ3nkNb+KK2uyDHeBC1S7cnrsyYySITYpBFJqcr4w4AtuxGQ0SdiFTCvaymrrsgM1lE7VK97oGMsciEGGSRyTnpZbLYXZCIOhO5Ve1kxOV1JdzlfJhE1C7pdw8UzASOySKTYpBFJufE7oJE1EkZjslid0Gi9kw/qGKARabGIItMzsmguyB/fBBR52E4JouFL4jaM4Mgi7+AycR4iZHJOdmwuyARdU5SJquC82QRtXcG3QWZySITY5BFJsfugkTUWekKX0AEbhVXAqjLbhFR+2LYXbANG9KBCIKAvXv3tnUzOiQGWWRy7C5IRJ2VuYUZzGTaX2vqwnIArC5I1G7pBVaC3iSeSUlJEASh0VdoaGgbNNaQIAiwtLREVlaWwfLw8HBERETc8/FXrFiBhx566J6PQ3UYZJHJ6c+TZcsnvETUyeiyWWU3qwBwTBZRe6UfWOlntYYOHYqcnJx6r7i4OAiCgMjIyLZobj2CICAmJsaoxxRFEdXV1UY95p1UVla26vnaCoMsMjlnG3YXJKLO6/bugRa8zxFJRFHErapbrf4SRbFeWwSDTFbdn+VyOZRKpcGrsLAQixcvxvLlyzFp0iRp22PHjmHIkCFQKBRQqVSIjo42CFJCQkIQFRWFpUuXwtnZGUqlEitWrDBoR1FREWbPng1XV1fY29tjxIgRSE9Pv+NnOX/+fPzjH//AmTNnGt2moqICUVFR6Nq1KywtLfHoo4/i1KlT0npd1m7//v14+OGHoVAo8I9//AMrV65Eenq6lL2Lj4+X9snPz8eECRNgbW0NHx8ffPvttwbnPHPmDB5//HHY2trCzc0N06dPR35+vsFnMn/+fLz88svo0qULwsLCpHYcOXIEgwYNgrW1NYYOHYqMjIw7fg4dBb8JyOScOBkxEXViuuIXOuwuSFSnrLoMf/q/P7X6eU9OOwlrC2uDZc0t4V5UVITx48cjJCQEq1evlpZfu3YNY8eORUREBD777DOcP38eL7zwAiwtLQ0CqU8//RQLFy7EyZMnkZKSgoiICAQFBWH06NEAgEmTJsHKygr79++Hg4MD4uLiMHLkSFy4cAHOzs6NtisoKAgXLlxAdHQ0vvvuuwa3Wbp0Kfbs2YNPP/0U3bt3x9q1axEWFobffvvN4NjR0dFYv349evbsCUtLSyxatAgHDhzA4cOHAQAODg7StitXrsTatWuxbt06bNmyBc888wyysrLg7OyMoqIijBgxArNnz8bGjRtRVlaGZcuWYfLkyTh69KjBZ/LSSy8hOTkZAJCTkwMAeO2117Bhwwa4urpi7ty5eP7556VtOjpmssjkDKsLWjSxJRFRx6ObkFj6O7tFE7VL+nGVmVnDQZZGo8G0adMgk8mwc+dOg2Bs27Zt8PT0xNatW+Hn54fw8HCsXLkSGzZsgEajkbYbOHAgYmNj4ePjgxkzZmDQoEE4cuQIAOD48eNITU3F7t27MWjQIPj4+GD9+vVwdHTEV199dcf38M477+DAgQP48ccf660rLS3F+++/j3Xr1uHxxx9Hv379sH37dlhZWeHjjz822HbVqlUYPXo0evXqhW7dusHW1hYymUzK5FlZWUnbRkREYOrUqejduzfefvttqNVqpKamAgC2bt0Kf39/vP322/Dz84O/vz8++eQTJCYm4sKFC9IxfHx8sHbtWvTp0wd9+vSRlr/11lsIDg5Gv379EB0djRMnTqC8vPyOn0NHwG8CMjlHq7rAyoaZLCLqZOp1F2Qmi0hiJbPCyWkn2+S8tzMck9XwfsuXL0dKSgpSU1NhZ2dnsO7cuXMIDAw0CLyCgoKgVqtx9epVeHl5AdAGWfpUKhXy8vIAAOnp6VCr1XBxcTHYpqysDJcuXbrj++rXrx9mzJiB6OjoehmfS5cuoaqqCkFBQdIyCwsLDBkyBOfOnTPYdtCgQXc8l47++7GxsYG9vb3B+0lMTIStrW29/S5dugRfX18AwMMPP3zHY6tUKgBAXl6e9Fl2ZAyyyORk5mbwcLJCTnE53Owt27o5RERGpdDrLigIgMyCnUSIdARBqNdtr60YTkZcP8ratWsX1q9fj3379sHHx6fF57GwMOy1IwiClOlSq9VQqVRISkqqt5+jo2Ozjr9y5Ur4+vreU2l1GxubZm97p/czbtw4vPvuu/X20wVNTZ1P/9i6fx/9rGBHxiCLWsWnzw9BYWklutgq2ropRERGZaEXZFlYyjjJKVE7ZVD44rb/T9PS0jBr1iysWbMGYWFhDe7ft29f7NmzB6IoSvsnJyfDzs4OHh4ezWpDQEAAcnNzIZPJ4O3t3aL34enpifnz52P58uXo1auXtLxXr16Qy+VITk5G9+7dAQBVVVU4deoUXn755SaPKZfLUVNTc9dtCQgIwJ49e+Dt7Q2ZjGGFPj5uo1bRy9UWg7wbH8xJRNRR6WeyWL6dqP0yzGTVLc/Pz0d4eDhCQkLw7LPPIjc31+D1xx9/AAAiIyNx5coVLFiwAOfPn8c333yD2NhYLFy4EGZmzftJPWrUKAQGBiI8PBwHDx5EZmYmTpw4gddeew0//fRTs9/Lq6++iuvXr0uFKgBttuill17CkiVLcODAAZw9exYvvPACbt26hVmzZjV5PG9vb1y+fBlpaWnIz89HRUVFs9oxb948FBQUYOrUqTh16hQuXbqE77//HjNnzmxR0NaZMMgiIiK6B/pjsiw47pSo3dIPrPQDrn379iErKwsJCQlQqVT1XoMHDwYAdOvWDQkJCUhNTcWDDz6IuXPnYtasWXj99deb3wZBQEJCAoYPH46ZM2fC19cXTz/9NLKysuDm5tbs4zg7O2PZsmX1ikSsWbMGEydOxPTp0xEQEIDffvsN33//PZycnJo83sSJEzFmzBiEhobC1dUVn3/+ebPa4e7ujuTkZNTU1OCxxx7DAw88gJdffhmOjo7NDjw7K0FsaCIBkpSUlMDBwQHFxcWwt7dv6+YQEVE7898fryFpp3Zul67e9pgU3fwB5USdSXl5OS5fvowePXrA0rL9jcHWaETkX7kJAHBS2vChCDWqqWu5ubHB/R1iEhER3SM5uwsSdQiGY7Larh10f2CQRUREdA/0gyw+GSdqvwRBgLnMDBAEmJkzyiLTYhkQIiKie2BY+IJfq0TtmaObNUSNCDNz5hnItPhtQEREdA/0Jx/mRMRE7Zu5jMEVtQ5eaURERPeAJdyJiOh2DLKIiIjugeGYLHYQISIiBllERET3xEJuDtSOoWd3QSIiAhhkERER3RPBTJAKXrC7IBERAQyyiIiI7pncShtcsbsgEREBDLKIiIjumZWtHABgacMgi4g6l4iICISHh7d1MzocBllERET3KHBCL/g/5gV3H8e2bgoR3aWkpCQIgtDoKzQ0tK2biGPHjmHEiBFwdnaGtbU1fHx88Nxzz6GystJo58jMzIQgCEhLS7vnY8XHxzf4WVpaWt57Q2sJgoC9e/ca7XjGxkduRERE98izrzM8+zq3dTOIqAWGDh2KnJycesu//fZbzJ07F5GRkW3Qqjpnz57FmDFjsGDBAmzevBlWVla4ePEi9uzZg5qamjZtW1Ps7e2RkZFhsEwQhDZqTetjJouIiIiITEIURWhu3Wr1lyiKzW6jXC6HUqk0eBUWFmLx4sVYvnw5Jk2aJG177NgxDBkyBAqFAiqVCtHR0aiurpbWh4SEICoqCkuXLoWzszOUSiVWrFhhcL6ioiLMnj0brq6usLe3x4gRI5Cent5o+w4ePAilUom1a9diwIAB6NWrF8aMGYPt27fDyspK2m7Pnj3o378/FAoFvL29sWHDBoPjNJT5cXR0RHx8PACgR48eAAB/f38IgoCQkBCDbdevXw+VSgUXFxfMmzcPVVVVTX6ugiDU+1zd3Nyk9QcOHMCjjz4KR0dHuLi44IknnsClS5ek9ZWVlZg/fz5UKhUsLS3RvXt3vPPOOwAAb29vAMCECRMgCIL09/aEmSwiIiIiMgmxrAwZAQ+3+nn7/HwagrV1i/YtKirC+PHjERISgtWrV0vLr127hrFjxyIiIgKfffYZzp8/jxdeeAGWlpYGgdSnn36KhQsX4uTJk0hJSUFERASCgoIwevRoAMCkSZNgZWWF/fv3w8HBAXFxcRg5ciQuXLgAZ+f6GXGlUomcnBz88MMPGD58eINtPn36NCZPnowVK1ZgypQpOHHiBCIjI+Hi4oKIiIhmve/U1FQMGTIEhw8fRv/+/SGXy6V1iYmJUKlUSExMxG+//YYpU6bgoYcewgsvvNCsYzektLQUCxcuxMCBA6FWqxETE4MJEyYgLS0NZmZm2Lx5M7799lt8+eWX8PLywpUrV3DlyhUAwKlTp9C1a1fs2LEDY8aMgbl5+6vsyiCLiIiIiAiARqPBtGnTIJPJsHPnToPubdu2bYOnpye2bt0KQRDg5+eH69evY9myZYiJiYGZmbaD2MCBAxEbGwsA8PHxwdatW3HkyBGMHj0ax48fR2pqKvLy8qBQKABoM0R79+7FV199hRdffLFemyZNmoTvv/8ewcHBUCqVeOSRRzBy5EjMmDED9vb2AIC//vWvGDlyJN544w0AgK+vL86ePYt169Y1O8hydXUFALi4uECpVBqsc3JywtatW2Fubg4/Pz/8+c9/xpEjR5oMsoqLi2Fra2uwbNiwYdi/fz8AYOLEiQbrPvnkE7i6uuLs2bMYMGAAsrOz4ePjg0cffRSCIKB79+712uro6Fivre0FgywiIiIiMgnBygp9fj7dJudtieXLlyMlJQWpqamws7MzWHfu3DkEBgYaBF5BQUFQq9W4evUqvLy8AGiDLH0qlQp5eXkAgPT0dKjVari4uBhsU1ZWZtBVTp+5uTl27NiBN998E0ePHsXJkyfx9ttv491330VqaipUKhXOnTuH8ePHG+wXFBSETZs2oaam5p4zPf379zc4hkqlwq+//trkPnZ2dvj5558Nlul3b7x48SJiYmJw8uRJ5OfnQ6PRAACys7MxYMAAREREYPTo0ejTpw/GjBmDJ554Ao899tg9vY/WxCCLiIiIiExCEIQWd9trbbt27cL69euxb98++Pj4tPg4FhYWBn8XBEEKINRqNVQqFZKSkurt5+jo2ORxu3XrhunTp2P69OlYvXo1fH198cEHH2DlypXNapcgCPXGqt1pXJVOU++pMWZmZujdu3ej68eNG4fu3btj+/btcHd3h0ajwYABA6SKiQEBAbh8+TL279+Pw4cPY/LkyRg1ahS++uqrZrW5rTHIIiIiIqL7WlpaGmbNmoU1a9YgLCyswW369u2LPXv2QBRFKZuVnJwMOzs7eHh4NOs8AQEByM3NhUwmu6diDU5OTlCpVCgtLZXalpycbLBNcnIyfH19pQyUq6urQRXFixcv4tatW9LfdWOwWqNi4Y0bN5CRkYHt27dj2LBhAIDjx4/X287e3h5TpkzBlClT8NRTT2HMmDEoKCiAs7MzLCws2nV1RQZZRERERHTfys/PR3h4OEJCQvDss88iNzfXYL25uTlcXV0RGRmJTZs2YcGCBZg/fz4yMjIQGxuLhQsXSuOx7mTUqFEIDAxEeHg41q5dC19fX1y/fh379u3DhAkTMGjQoHr7xMXFIS0tDRMmTECvXr1QXl6Ozz77DP/973+xZcsWAMCiRYswePBgrF69GlOmTEFKSgq2bt2Kbdu2SccZMWIEtm7disDAQNTU1GDZsmUGGaquXbvCysoKBw4cgIeHBywtLeHg4NCSjxSAtrLk7Z+l7jxOTk5wcXHBhx9+CJVKhezsbERHRxts99e//hUqlQr+/v4wMzPD7t27oVQqpYyft7c3jhw5gqCgICgUCjg5ObW4rabAEu5EREREdN/at28fsrKykJCQAJVKVe81ePBgANruegkJCUhNTcWDDz6IuXPnYtasWXj99debfS5BEJCQkIDhw4dj5syZ8PX1xdNPP42srCyD8ub6hgwZArVajblz56J///4IDg7Gv//9b+zduxfBwcEAtBmyL7/8Ert27cKAAQMQExODVatWGRS92LBhAzw9PTFs2DBMmzYNixcvhrVeV06ZTIbNmzcjLi4O7u7u9cZ43a2SkpIGP8+8vDyYmZlh165dOH36NAYMGIBXXnkF69atM9jfzs4Oa9euxaBBgzB48GBkZmYiISFBCmg3bNiAQ4cOwdPTE/7+/vfUVlMQxLuZSOA+VFJSAgcHBxQXF0sVXIiIiIjIUHl5OS5fvowePXrA0tKyrZtD1GJNXcvNjQ06TCbrrbfewtChQ2FtbX3HgYENmTt3LgRBwKZNm4zeNiIiIiIiIp0OE2RVVlZi0qRJeOmll+5633/+85/497//DXd3dxO0jIiIiIiIqE6HKXyhK08ZHx9/V/tdu3YNCxYswPfff48///nPJmgZERERERFRnQ4TZLWERqPB9OnTsWTJEvTv379Z+1RUVKCiokL6e0lJiamaR0REREREnVCH6S7YEu+++y5kMhmioqKavc8777wDBwcH6eXp6WnCFhIRERERUWfTpkFWdHS0dibwJl7nz59v0bFPnz6N9957D/Hx8dKEcc3x6quvori4WHpduXKlRecnIiIiIqL7U5t2F1y0aJFB/f6G9OzZs0XH/vHHH5GXlwcvLy9pWU1NDRYtWoRNmzYhMzOzwf0UCgUUCkWLzklERERERNSmQZarqytcXV1Ncuzp06dj1KhRBsvCwsIwffp0zJw50yTnJCIiIiIi6jCFL7Kzs1FQUIDs7GzU1NQgLS0NANC7d2/Y2toCAPz8/PDOO+9gwoQJcHFxgYuLi8ExLCwsoFQq0adPn9ZuPhERERER3Sc6TJAVExODTz/9VPq7v78/ACAxMREhISEAgIyMDBQXF7dF84iIiIiIOp2IiAgUFRVh7969bd2UDqXDVBeMj4+HKIr1XroACwBEUWxyjFdmZiZefvllk7eViIiIiDqGpKSkJouwhYaGtnUTcezYMYwYMQLOzs6wtraGj48PnnvuOVRWVhrtHJmZmRAEQeot1lLnz5+HIAj497//bbD8kUcegaWlJcrLy6Vl5eXlsLS0xMcff3xP5wQAb29vbNq06Z6PYywdJsgiIiIiIjK2oUOHIicnp94rLi4OgiAgMjKyTdt39uxZjBkzBoMGDcIPP/yAX3/9FVu2bIFcLkdNTU2btq0hfn5+UCqVSEpKkpbdvHkTP//8M1xdXQ2Cr5SUFFRUVGDEiBFt0FLTYpBFRERERCYhiiKqKmpa/SWKYrPbKJfLoVQqDV6FhYVYvHgxli9fjkmTJknbHjt2DEOGDIFCoYBKpUJ0dDSqq6ul9SEhIYiKisLSpUvh7OwMpVKJFStWGJyvqKgIs2fPhqurK+zt7TFixAikp6c32r6DBw9CqVRi7dq1GDBgAHr16oUxY8Zg+/btsLKykrbbs2cP+vfvD4VCAW9vb2zYsMHgOIIg1Ovy5+joiPj4eABAjx49AGiH5AiCYNBbDADWr18PlUoFFxcXzJs3D1VVVY22OTQ01CDIOn78OHx9fTFu3DiD5UlJSejevbt07m+++QYBAQGwtLREz549sXLlSunzFUURK1asgJeXFxQKBdzd3aW5cENCQpCVlYVXXnlFykC2tQ4zJouIiIiIOpbqSg0+/H/HWv28L74XDAuFeYv2LSoqwvjx4xESEoLVq1dLy69du4axY8ciIiICn332Gc6fP48XXngBlpaWBoHUp59+ioULF+LkyZNISUlBREQEgoKCMHr0aADApEmTYGVlhf3798PBwQFxcXEYOXIkLly4AGdn53rtUSqVyMnJwQ8//IDhw4c32ObTp09j8uTJWLFiBaZMmYITJ04gMjISLi4ud5wuSSc1NRVDhgzB4cOH0b9/f8jlcmldYmIiVCoVEhMT8dtvv2HKlCl46KGH8MILLzR4rNDQULzyyiuorq6GTCaTaigMGzYM27Ztkz6vxMREqTvmjz/+iBkzZmDz5s0YNmwYLl26hBdffBEAEBsbiz179mDjxo3YtWsX+vfvj9zcXCk4/frrr/Hggw/ixRdfbLRNrY2ZLCIiIiIiABqNBtOmTYNMJsPOnTsNMiLbtm2Dp6cntm7dCj8/P4SHh2PlypXYsGEDNBqNtN3AgQMRGxsLHx8fzJgxA4MGDcKRI0cAaDM6qamp2L17NwYNGgQfHx+sX78ejo6O+Oqrrxps06RJkzB16lQEBwdDpVJhwoQJ2Lp1K0pKSqRt/vrXv2LkyJF444034Ovri4iICMyfPx/r1q1r9nvXTavk4uICpVJpEPA5OTlJ7/uJJ57An//8Z+k9NSQ0NBSlpaU4deoUAG3GKjg4GMOHD8fJkydRXl6OsrIypKamSkHWypUrER0djeeeew49e/bE6NGjsXr1asTFxQHQVhpXKpUYNWoUvLy8MGTIECmgcnZ2hrm5Oezs7KRsZFtjJouIiIiITEImN8OL7wW3yXlbYvny5UhJSUFqairs7OwM1p07dw6BgYEGgVdQUBDUajWuXr0KLy8vANogS59KpUJeXh4AID09HWq1ut40Q2VlZbh06VKDbTI3N8eOHTvw5ptv4ujRozh58iTefvttvPvuu0hNTYVKpcK5c+cwfvx4g/2CgoKwadMm1NTUwNy8ZVk9nf79+xscQ6VS4ddff210+969e8PDwwNJSUno378//vOf/yA4OBhdu3aFl5cXUlJSIIoiKioqpCArPT0dycnJeOutt6Tj1NTUoLy8HLdu3cKkSZOwadMm9OzZE2PGjMHYsWMxbtw4yGTtM5xpn60iIiIiog5PEIQWd9trbbt27cL69euxb98++Pj4tPg4FhYWBn8XBEHKdKnVaqhUKoNxSTqOjo5NHrdbt26YPn06pk+fjtWrV8PX1xcffPABVq5c2ax2CYJQb6xaU+Oq9DX1nhoTEhKCxMREDBw4ED4+PujatSsAIDg4GImJiRBFEb1794anpycA7WezcuVKPPnkk/WOZWlpCU9PT2RkZODw4cM4dOgQIiMjsW7dOhw7dqxe+9oDBllEREREdF9LS0vDrFmzsGbNGoSFhTW4Td++fbFnzx6Ioihls5KTk2FnZwcPD49mnScgIAC5ubmQyWTw9vZucXudnJygUqlQWloqtS05Odlgm+TkZPj6+koZKFdXV+Tk5EjrL168iFu3bkl/143BMlbFwtDQUERFRaFfv34GRTSGDx+O7du3QxRFg/L4AQEByMjIQO/evRs9ppWVFcaNG4dx48Zh3rx58PPzw6+//oqAgIB2V22RQRYRERER3bfy8/MRHh6OkJAQPPvss8jNzTVYb25uDldXV0RGRmLTpk1YsGAB5s+fj4yMDMTGxmLhwoUwM2te98RRo0YhMDAQ4eHhWLt2LXx9fXH9+nXs27cPEyZMwKBBg+rtExcXh7S0NEyYMAG9evVCeXk5PvvsM/z3v//Fli1bAACLFi3C4MGDsXr1akyZMgUpKSnYunUrtm3bJh1nxIgR2Lp1KwIDA1FTU4Nly5YZZIC6du0KKysrHDhwAB4eHrC0tISDg0NLPlIAdeOyPvnkE2zfvl1aHhwcjNmzZwOAQXn8mJgYPPHEE/Dy8sJTTz0FMzMzpKen48yZM3jzzTcRHx+Pmpoa/OlPf4K1tTX+8Y9/wMrKCt27dwegnSfrhx9+wNNPPw2FQoEuXbq0uO3GwMIXRERERHTf2rdvH7KyspCQkACVSlXvNXjwYADa7noJCQlITU3Fgw8+iLlz52LWrFl4/fXXm30uQRCQkJCA4cOHY+bMmfD19cXTTz+NrKwsuLm5NbjPkCFDoFarMXfuXPTv3x/BwcH497//jb179yI4WDveLSAgAF9++SV27dqFAQMGICYmBqtWrTKoLLhhwwZ4enpi2LBhmDZtGhYvXgxra2tpvUwmw+bNmxEXFwd3d/d6Y7zuVo8ePdC9e3fcvHlTaicAeHl5wd3dHZWVlQYZrrCwMHz33Xc4ePAgBg8ejEceeQQbN26UgihHR0ds374dQUFBGDhwIA4fPox//etf0vi2VatWITMzE7169ZKKeLQlQbybiQTuQyUlJXBwcEBxcTHs7e3bujlERERE7VJ5eTkuX76MHj16wNLSsq2bQ9RiTV3LzY0NmMkiIiIiIiIyIgZZRERERERERsQgi4iIiIiIyIgYZBERERERERkRgywiIiIiMhrWVKOOzhjXMIMsIiIiIrpnujmX9Ce4JeqIdNew/jxid4uTERMRERHRPTM3N4ejoyPy8vIAANbW1hAEoY1bRdR8oiji1q1byMvLg6OjI8zNzVt8LAZZRERERGQUSqUSAKRAi6gjcnR0lK7llmKQRURERERGIQgCVCoVunbtiqqqqrZuDtFds7CwuKcMlg6DLCIiIiIyKnNzc6P8UCXqqFj4goiIiIiIyIgYZBERERERERkRgywiIiIiIiIj4pisO9BNRlZSUtLGLSEiIiIiorakiwnuNGExg6w7uHnzJgDA09OzjVtCRERERETtwc2bN+Hg4NDoekG8Uxh2n9NoNLh+/Trs7Ow4oV4HVVJSAk9PT1y5cgX29vZt3Ry6D/Cao9bGa45aE683am3t6ZoTRRE3b96Eu7s7zMwaH3nFTNYdmJmZwcPDo62bQUZgb2/f5v9j0v2F1xy1Nl5z1Jp4vVFray/XXFMZLB0WviAiIiIiIjIiBllERERERERGxCCLOj2FQoHY2FgoFIq2bgrdJ3jNUWvjNUetidcbtbaOeM2x8AUREREREZERMZNFRERERERkRAyyiIiIiIiIjIhBFhERERERkRExyCIiIiIiIjIiBlnUIbzzzjsYPHgw7Ozs0LVrV4SHhyMjI8Ngm/LycsybNw8uLi6wtbXFxIkT8fvvv0vrb9y4gTFjxsDd3R0KhQKenp6YP38+SkpKDI6TlJSEgIAAKBQK9O7dG/Hx8a3xFqkdMcb1pu/GjRvw8PCAIAgoKioyWMfrjQDjXXOCINR77dq1y2AbXnMEGPc+Fx8fj4EDB8LS0hJdu3bFvHnzDNb/8ssvGDZsGCwtLeHp6Ym1a9ea9L1R+2OM6y0+Pr7Be5wgCMjLy5O2azf3OJGoAwgLCxN37NghnjlzRkxLSxPHjh0renl5iWq1Wtpm7ty5oqenp3jkyBHxp59+Eh955BFx6NCh0vqCggJx27Zt4qlTp8TMzEzx8OHDYp8+fcSpU6dK2/zvf/8Tra2txYULF4pnz54Vt2zZIpqbm4sHDhxo1fdLbcsY15u+8ePHi48//rgIQCwsLJSW83ojHWNdcwDEHTt2iDk5OdKrrKxMWs9rjnSMdc1t2LBBdHd3F3fu3Cn+9ttvYnp6uvjNN99I64uLi0U3NzfxmWeeEc+cOSN+/vnnopWVlRgXF9dq75XanjGut1u3bhnc23JycsSwsDAxODhY2qY93eMYZFGHlJeXJwIQjx07JoqiKBYVFYkWFhbi7t27pW3OnTsnAhBTUlIaPc57770nenh4SH9funSp2L9/f4NtpkyZIoaFhRn5HVBHci/X27Zt28Tg4GDxyJEj9YIsXm/UmJZecwDEf/7zn40el9ccNaYl11xBQYFoZWUlHj58uNHjbtu2TXRychIrKiqkZcuWLRP79OljondCHYExfsfl5eWJFhYW4meffSYta0/3OHYXpA6puLgYAODs7AwAOH36NKqqqjBq1ChpGz8/P3h5eSElJaXBY1y/fh1ff/01goODpWUpKSkGxwCAsLCwRo9B94eWXm9nz57FqlWr8Nlnn8HMrP7tltcbNeZe7nHz5s1Dly5dMGTIEHzyyScQ9abD5DVHjWnJNXfo0CFoNBpcu3YNffv2hYeHByZPnowrV65I+6SkpGD48OGQy+XSsrCwMGRkZKCwsLA13hq1Q8b4HffZZ5/B2toaTz31lLSsPd3jGGRRh6PRaPDyyy8jKCgIAwYMAADk5uZCLpfD0dHRYFs3Nzfk5uYaLJs6dSqsra3RrVs32Nvb46OPPpLW5ebmws3Nrd4xSkpKUFZWZpo3RO1aS6+3iooKTJ06FevWrYOXl1eDx+b1Rg25l3vcqlWr8OWXX+LQoUOYOHEiIiMjsWXLFmk9rzlqSEuvuf/973/QaDR4++23sWnTJnz11VcoKCjA6NGjUVlZKR2noWtOt47uP/f6O07n448/xrRp02BlZSUta0/3OFmrno3ICObNm4czZ87g+PHjLdp/48aNiI2NxYULF/Dqq69i4cKF2LZtm5FbSZ1FS6+3V199FX379sWzzz5ropZRZ3Uv97g33nhD+rO/vz9KS0uxbt06REVFGbOJ1Mm09JrTaDSoqqrC5s2b8dhjjwEAPv/8cyiVSiQmJiIsLMwUzaUO7l5/xwHajNW5c+fw97//3YgtMy5msqhDmT9/Pr777jskJibCw8NDWq5UKlFZWVmvctvvv/8OpVJpsEypVMLPzw9/+ctfEBcXh/fffx85OTnSutsrJ/3++++wt7c3eFJC94d7ud6OHj2K3bt3QyaTQSaTYeTIkQCALl26IDY2VjoOrzfSZ4x7nL4//elPuHr1KioqKqTj8JojffdyzalUKgBAv379pPWurq7o0qULsrOzpeM0dM3p1tH9xVj3uI8++ggPPfQQHn74YYPl7ekexyCLOgRRFDF//nz885//xNGjR9GjRw+D9Q8//DAsLCxw5MgRaVlGRgays7MRGBjY6HE1Gg0ASD9AAgMDDY4BaPucN3UM6nyMcb3t2bMH6enpSEtLQ1pamtQt9ccff5TKG/N6Ix1T3ePS0tLg5OQEhUIBgNcc1THGNRcUFCQt1ykoKEB+fj66d+8OQHvN/fDDD6iqqpK2OXToEPr06QMnJyeTvT9qX4x5j1Or1fjyyy8xa9aseudpV/e4Vi+1QdQCL730kujg4CAmJSUZlO68deuWtM3cuXNFLy8v8ejRo+JPP/0kBgYGioGBgdL6ffv2iZ988on466+/ipcvXxa/++47sW/fvmJQUJC0ja7055IlS8Rz586Jf/vb31je+D5kjOvtdomJiY2WcOf1Rsa45r799ltx+/bt4q+//ipevHhR3LZtm2htbS3GxMRI2/CaIx1j3efGjx8v9u/fX0xOThZ//fVX8YknnhD79esnVlZWiqKorRrn5uYmTp8+XTxz5oy4a9cu0dramiXc7zPG/F796KOPREtLS4PvU532dI9jkEUdAoAGXzt27JC2KSsrEyMjI0UnJyfR2tpanDBhgpiTkyOtP3r0qBgYGCg6ODiIlpaWoo+Pj7hs2bJ6/5MmJiaKDz30kCiXy8WePXsanIPuD8a43m7XUJClW87rjYxxze3fv1986KGHRFtbW9HGxkZ88MEHxQ8++ECsqakxOBevORJF493niouLxeeff150dHQUnZ2dxQkTJojZ2dkG26Snp4uPPvqoqFAoxG7duolr1qxpjbdI7Ygxv1cDAwPFadOmNXqu9nKPE0RRr7YrERERERER3ROOySIiIiIiIjIiBllERERERERGxCCLiIiIiIjIiBhkERERERERGRGDLCIiIiIiIiNikEVERERERGREDLKIiIiIiIiMiEEWERERERGRETHIIiIiIiIiMiIGWUREdF8RRRGjRo1CWFhYvXXbtm2Do6Mjrl692gYtIyKizoJBFhER3VcEQcCOHTtw8uRJxMXFScsvX76MpUuXYsuWLfDw8DDqOauqqox6PCIiat8YZBER0X3H09MT7733HhYvXozLly9DFEXMmjULjz32GPz9/fH444/D1tYWbm5umD59OvLz86V9Dxw4gEcffRSOjo5wcXHBE088gUuXLknrMzMzIQgCvvjiCwQHB8PS0hI7d+5si7dJRERtRBBFUWzrRhAREbWF8PBwFBcX48knn8Tq1avx3//+F/3798fs2bMxY8YMlJWVYdmyZaiursbRo0cBAHv27IEgCBg4cCDUajViYmKQmZmJtLQ0mJmZITMzEz169IC3tzc2bNgAf39/WFpaQqVStfG7JSKi1sIgi4iI7lt5eXno378/CgoKsGfPHpw5cwY//vgjvv/+e2mbq1evwtPTExkZGfD19a13jPz8fLi6uuLXX3/FgAEDpCBr06ZN+H//7/+15tshIqJ2gt0FiYjovtW1a1fMmTMHffv2RXh4ONLT05GYmAhbW1vp5efnBwBSl8CLFy9i6tSp6NmzJ+zt7eHt7Q0AyM7ONjj2oEGDWvW9EBFR+yFr6wYQERG1JZlMBplM+3WoVqsxbtw4vPvuu/W203X3GzduHLp3747t27fD3d0dGo0GAwYMQGVlpcH2NjY2pm88ERG1SwyyiIiIagUEBGDPnj3w9vaWAi99N27cQEZGBrZv345hw4YBAI4fP97azSQionaO3QWJiIhqzZs3DwUFBZg6dSpOnTqFS5cu4fvvv8fMmTNRU1MDJycnuLi44MMPP8Rvv/2Go0ePYuHChW3dbCIiamcYZBEREdVyd3dHcnIyampq8Nhjj+GBBx7Ayy+/DEdHR5iZmcHMzAy7du3C6dOnMWDAALzyyitYt25dWzebiIjaGVYXJCIiIiIiMiJmsoiIiIiIiIyIQRYREREREZERMcgiIiIiIiIyIgZZRERERERERsQgi4iIiIiIyIgYZBERERERERkRgywiIiIiIiIjYpBFRERERERkRAyyiIiIiIiIjIhBFhERERERkRExyCIiIiIiIjKi/w/XqhnvspUxYgAAAABJRU5ErkJggg==" }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 59 + "execution_count": 54 }, { "metadata": { From ac9d1d1e7d5d8c538eed70db4896e1ec7a6be518 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 7 Jan 2025 15:34:32 +0000 Subject: [PATCH 156/291] Removed the scaling Was having issues with years being dropped when scaled --- ...al_realtionship_reporting_precipitation.py | 259 +++++++++++------- 1 file changed, 165 insertions(+), 94 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index edd34fec2a..4ab54cc6ed 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -19,9 +19,10 @@ use_all_weather = True min_year_for_analysis = 2012 absolute_min_year = 2011 -mask_threshold = 0 +mask_threshold = -np.inf # accounts for scaling use_percentile_mask_threshold = False use_residuals = False +from sklearn.preprocessing import StandardScaler poisson=False if use_residuals: @@ -33,6 +34,7 @@ covid_months = range((2020 - min_year_for_analysis)* 12 + 4, (2020 - min_year_for_analysis)* 12 + 4 + 20) # Bingling's paper: disruption between April 2020 and Dec 2021, a period of 20 months cyclone_freddy_months_phalombe = range((2023 - min_year_for_analysis)* 12 + 4, (2020 - min_year_for_analysis)* 12 + 4 + 14) # From news report and DHIS2, see disruption from April 2023 - June 2024, 14 months + cyclone_freddy_months_thumbwe = range((2023 - min_year_for_analysis)* 12 + 3, (2020 - min_year_for_analysis)* 12 + 3 + 12) # From news report and DHIS2, see disruption from March 2023 - March 2024, 12 months model_filename = ( @@ -302,14 +304,44 @@ def repeat_info(info, num_facilities, year_range, historical): altitude, np.array(minimum_distance) ]) -coefficient_names = ["year", "month", resid_encoded.columns, zone_encoded.columns, owner_encoded.columns, ftype_encoded.columns, facility_encoded.columns, "altitude", "minimum_distance"] +# Continuous columns that need to be standardized (weather_data, lag variables, altitude, minimum_distance) +# X_continuous = np.column_stack([ +# year_flattened, +# month_flattened, +# altitude, +# np.array(minimum_distance) +# ]) +# X_categorical = np.column_stack([ +# resid_encoded, +# zone_encoded, +# owner_encoded, +# ftype_encoded, +# facility_encoded, +# ]) +# scaler = StandardScaler() +# X_continuous_scaled = scaler.fit_transform(X_continuous) +# X_weather_standardized = np.column_stack([X_continuous_scaled, X_categorical]) +# X_weather_standardized = np.column_stack([X_continuous, X_categorical]) + +coefficient_names = ["year", "month"] + list(resid_encoded.columns) + list(zone_encoded.columns) + \ + list(owner_encoded.columns) + list(ftype_encoded.columns) + \ + list(facility_encoded.columns) + ["altitude", "minimum_distance"] coefficient_names = pd.Series(coefficient_names) results, y_pred, mask_ANC_data = build_model(X , y, poisson = poisson, log_y=log_y, X_mask_mm=mask_threshold) coefficients = results.params coefficients_df = pd.DataFrame(coefficients, columns=['coefficients']) +continuous_coefficients = coefficients[:len(X[0])] +categorical_coefficients = coefficients[len(X[0]):] +#means = scaler.mean_ +#scales = scaler.scale_ +#rescaled_continuous_coefficients = continuous_coefficients * scales +#rescaled_coefficients = np.concatenate([rescaled_continuous_coefficients, categorical_coefficients]) +#rescaled_coefficients_df = pd.DataFrame(rescaled_coefficients, columns=['rescaled coefficients']) p_values = results.pvalues p_values_df = pd.DataFrame(p_values, columns=['p_values']) +#results_df = pd.concat([coefficient_names, coefficients_df, p_values_df, rescaled_coefficients_df], axis=1) results_df = pd.concat([coefficient_names, coefficients_df, p_values_df], axis=1) + results_df.to_csv('/Users/rem76/Desktop/Climate_change_health/Data/results_of_model_historical.csv') if use_residuals: if log_y: @@ -391,32 +423,8 @@ def repeat_info(info, num_facilities, year_range, historical): ########################## STEP 2 - USE THESE IN PREDICTIONS ########################## ############################################################################################## -if use_residuals: - X_weather = np.column_stack([ - weather_data[mask_ANC_data], - np.array(year_flattened)[mask_ANC_data], - np.array(month_flattened)[mask_ANC_data], - resid_encoded[mask_ANC_data], - zone_encoded[mask_ANC_data], - owner_encoded[mask_ANC_data], - ftype_encoded[mask_ANC_data], - lag_1_month[mask_ANC_data], - lag_2_month[mask_ANC_data], - lag_3_month[mask_ANC_data], - lag_4_month[mask_ANC_data], - lag_1_5_day[mask_ANC_data], - lag_2_5_day[mask_ANC_data], - lag_3_5_day[mask_ANC_data], - lag_4_5_day[mask_ANC_data], - facility_encoded[mask_ANC_data], - np.array(altitude)[mask_ANC_data], - np.array(minimum_distance)[mask_ANC_data], - #np.array(above_below_X)[mask_ANC_data], - ]) - results_of_weather_model, y_pred_weather, mask_all_data = build_model(X_weather, y_weather, poisson=False, log_y=False, # residuals are already logged - X_mask_mm=mask_threshold) -else: - X_weather = np.column_stack([ + +X_weather = np.column_stack([ weather_data, np.array(year_flattened), np.array(month_flattened), @@ -435,25 +443,69 @@ def repeat_info(info, num_facilities, year_range, historical): facility_encoded, np.array(altitude), np.array(minimum_distance), - #above_below_X + #np.array(above_below_X)[mask_ANC_data], ]) + # Continuous columns that need to be standardized (weather_data, lag variables, altitude, minimum_distance) +# X_continuous = np.column_stack([ +# weather_data, +# np.array(year_flattened), +# np.array(month_flattened), +# lag_1_month, +# lag_2_month, +# lag_3_month, +# lag_4_month, +# lag_1_5_day, +# lag_2_5_day, +# lag_3_5_day, +# lag_4_5_day, +# np.array(altitude), +# np.array(minimum_distance),] +# ) +# X_categorical = np.column_stack([ +# resid_encoded, +# zone_encoded, +# owner_encoded, +# ftype_encoded, +# facility_encoded, +# #np.array(above_below_X)[mask_ANC_data], +# ]) +# +# scaler = StandardScaler() +# #X_continuous_scaled = scaler.fit_transform(X_continuous) +# #X_weather_standardized = np.column_stack([X_continuous_scaled, X_categorical]) +# X_weather_standardized = np.column_stack([X_continuous, X_categorical]) - results_of_weather_model, y_pred_weather, mask_all_data = build_model(X_weather, y, poisson = poisson, log_y=log_y, +results_of_weather_model, y_pred_weather, mask_all_data = build_model(X_weather, y, poisson = poisson, log_y=log_y, X_mask_mm=mask_threshold) -coefficient_names_weather = ["precip_monthly_total", "precip_5_day_max", "year", "month", resid_encoded.columns, zone_encoded.columns, owner_encoded.columns, ftype_encoded.columns, "lag_1_month","lag_2_month","lag_3_month", "lag_4_month", "lag_1_5_day", "lag_2_5_day","lag_3_5_day", "lag_4_5_day",facility_encoded.columns, "altitude", "minimum_distance"] + +coefficient_names_weather = ["precip_monthly_total", "precip_5_day_max", "year", "month"] + \ + list(resid_encoded.columns) + list(zone_encoded.columns) + \ + list(owner_encoded.columns) + list(ftype_encoded.columns) + \ + ["lag_1_month", "lag_2_month", "lag_3_month", "lag_4_month"] + \ + ["lag_1_5_day", "lag_2_5_day", "lag_3_5_day", "lag_4_5_day"] + \ + list(facility_encoded.columns) + ["altitude", "minimum_distance"] coefficient_names_weather = pd.Series(coefficient_names_weather) coefficients_weather = results_of_weather_model.params coefficients_weather_df = pd.DataFrame(coefficients_weather, columns=['coefficients']) +#rescale coefficients +continuous_coefficients = coefficients_weather[:len(X_weather[0])] +categorical_coefficients = coefficients_weather[len(X_weather[0]):] +#means = scaler.mean_ +#scales = scaler.scale_ +#rescaled_continuous_coefficients = continuous_coefficients * scales +#rescaled_coefficients_weather = np.concatenate([rescaled_continuous_coefficients, categorical_coefficients]) +rescaled_coefficients_weather = np.concatenate([continuous_coefficients, categorical_coefficients]) + +rescaled_coefficients_df = pd.DataFrame(rescaled_coefficients_weather, columns=['rescaled coefficients']) + p_values_weather = results_of_weather_model.pvalues p_values_weather_df = pd.DataFrame(p_values_weather, columns=['p_values']) -results_weather_df = pd.concat([coefficient_names_weather, coefficients_weather_df, p_values_weather_df], axis=1) +results_weather_df = pd.concat([coefficient_names_weather, coefficients_weather_df, p_values_weather_df, rescaled_coefficients_df], axis=1) results_weather_df.to_csv('/Users/rem76/Desktop/Climate_change_health/Data/results_of_weather_model_historical.csv') print("All predictors", results_of_weather_model.summary()) # - X_filtered = X_weather[mask_all_data] - # # Effect size # if use_residuals: # y_mean = np.mean(y_weather[mask_all_data]) @@ -477,53 +529,34 @@ def repeat_info(info, num_facilities, year_range, historical): fig, axs = plt.subplots(1, 2, figsize=(10, 6)) -if use_residuals: - if log_y: - axs[0].scatter(X_filtered[:, 0], y_weather[mask_all_data], color='red', alpha=0.5, label = 'Residuals') - axs[0].scatter(X_filtered[:, 0], np.exp(y_pred_weather), label='Expected change in ANC visits', color="blue", alpha = 0.5) - axs[0].hlines(y = 0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color = 'black', linestyle = '--') - axs[0].set_ylabel('Expcetd change in ANC visits') - - axs[1].scatter(X_filtered[:, 0], np.exp(y_pred_weather[mask_all_data] - y_pred), color='red', alpha=0.5, label = 'Residuals') - axs[1].hlines(y = 0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color = 'black', linestyle = '--') - axs[1].set_ylabel('Difference between weather and non-weather model') - else: - axs[0].scatter(X_filtered[:, 0], y_weather[mask_all_data], color='red', alpha=0.5, label = 'Residuals') - axs[0].hlines(y = 0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color = 'black', linestyle = '--') - axs[0].scatter(X_filtered[:, 0], y_pred, label='Expected change in ANC visits') - axs[0].hlines(y=0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color='black', linestyle='--') - axs[0].set_ylabel('Expcetd change in ANC visits') - axs[1].scatter(X_filtered[:, 0], y_pred_weather[mask_all_data] - y_pred[X_weather[:,0]> mask_threshold], color='red', alpha=0.5, label = 'Residuals') - axs[1].hlines(y = 0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color = 'black', linestyle = '--') - axs[1].set_ylabel('Difference between weather and non-weather model') +indices_ANC_data = np.where(mask_ANC_data)[0] +indices_all_data = np.where(mask_all_data)[0] +common_indices = np.intersect1d(indices_ANC_data, indices_all_data) +matched_y_pred = y_pred[np.isin(indices_ANC_data, common_indices)] +matched_y_pred_weather = y_pred_weather[np.isin(indices_all_data, common_indices)] +monthly_weather_predictions = X_filtered[:, 0][np.isin(indices_all_data, common_indices)] -else: - indices_ANC_data = np.where(mask_ANC_data)[0] - indices_all_data = np.where(mask_all_data)[0] - common_indices = np.intersect1d(indices_ANC_data, indices_all_data) - matched_y_pred = y_pred[np.isin(indices_ANC_data, common_indices)] - matched_y_pred_weather = y_pred_weather[np.isin(indices_all_data, common_indices)] - if log_y: +if log_y: axs[0].scatter(X_filtered[:, 0], y[mask_all_data], color='red', alpha=0.5, label = 'Non weather model') axs[0].hlines(y = 0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color = 'black', linestyle = '--') axs[0].scatter(X_filtered[:, 0], np.exp(y_pred_weather), label='Weather model', color="blue", alpha = 0.5) axs[0].hlines(y=0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color='black', linestyle='--') axs[0].set_ylabel('ANC visits') - axs[1].scatter(X_filtered[:, 0], np.exp(matched_y_pred_weather) - np.exp(matched_y_pred), color='red', alpha=0.5, label = 'Residuals') + axs[1].scatter(monthly_weather_predictions, np.exp(matched_y_pred_weather) - np.exp(matched_y_pred), color='red', alpha=0.5, label = 'Residuals') axs[1].hlines(y = 0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color = 'black', linestyle = '--') axs[1].set_ylabel('Difference between weather and non-weather model') - else: +else: axs[0].scatter(X_filtered[:, 0], y[mask_all_data], color='red', alpha=0.5, label = 'Non weather model') axs[0].hlines(y = 0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color = 'black', linestyle = '--') axs[0].scatter(X_filtered[:, 0], y_pred, label='Weather model') axs[0].hlines(y=0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color='black', linestyle='--') axs[0].set_ylabel('ANC visits') - axs[1].scatter(X_filtered[:, 0], matched_y_pred_weather- matched_y_pred, color='red', alpha=0.5, label = 'Residuals') + axs[1].scatter(monthly_weather_predictions, matched_y_pred_weather- matched_y_pred, color='red', alpha=0.5, label = 'Residuals') axs[1].hlines(y = 0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color = 'black', linestyle = '--') axs[1].set_ylabel('Difference between weather and non-weather model') axs[0].set_xlabel('Monthly precipitation (mm)') @@ -532,7 +565,7 @@ def repeat_info(info, num_facilities, year_range, historical): axs[0].legend(loc='upper left', borderaxespad=0.) -#plt.show() +plt.show() ############### ADD IN CMIP DATA ########################### @@ -545,13 +578,12 @@ def get_weather_data(ssp_scenario, model_type): f"{data_path}Precipitation_data/Downscaled_CMIP6_data_CIL/{ssp_scenario}/{model_type}_model_monthly_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{ssp_scenario}.csv", dtype={'column_name': 'float64'} ) - weather_data_prediction_monthly_df = weather_data_prediction_monthly_original.drop(columns=zero_sum_columns) weather_data_prediction_five_day_cumulative_df = weather_data_prediction_five_day_cumulative_original.drop( columns=zero_sum_columns) return weather_data_prediction_five_day_cumulative_df, weather_data_prediction_monthly_df -model_types = ['lowest']#, 'median', 'highest'] +model_types = ['lowest', 'highest']#, 'median', 'highest'] # Configuration and constants min_year_for_analysis = 2025 absolute_min_year = 2025 @@ -566,7 +598,8 @@ def get_weather_data(ssp_scenario, model_type): for model_type in model_types: if use_all_weather: weather_data_prediction_five_day_cumulative_df, weather_data_prediction_monthly_df = get_weather_data(ssp_scenario, - model_type) + model_type) + lag_1_month_prediction = weather_data_prediction_monthly_df.shift(1).values lag_2_month_prediction = weather_data_prediction_monthly_df.shift(2).values lag_3_month_prediction = weather_data_prediction_monthly_df.shift(3).values @@ -599,6 +632,8 @@ def get_weather_data(ssp_scenario, model_type): weather_data_prediction_monthly_flattened = weather_data_prediction_monthly.values.flatten() weather_data_prediction_five_day_cumulative_flattened = weather_data_prediction_five_day_cumulative.values.flatten() weather_data_prediction_flatten = np.vstack((weather_data_prediction_monthly_flattened, weather_data_prediction_five_day_cumulative_flattened)).T + print(weather_data_prediction_flatten.dtype) + num_facilities = len(weather_data_prediction_monthly.columns) else: if five_day: @@ -646,7 +681,6 @@ def get_weather_data(ssp_scenario, model_type): altitude_prediction = list(altitude_prediction) minimum_distance_prediction = np.nan_to_num(minimum_distance_prediction, nan=np.nan, posinf=np.nan, neginf=np.nan) # just in case - print(lag_4_month_prediction) # Weather data X_basis_weather = np.column_stack([ @@ -670,6 +704,34 @@ def get_weather_data(ssp_scenario, model_type): minimum_distance_prediction, #above_below_X_prediction ]) + # X_continuous_weather = np.column_stack([ + # weather_data_prediction_flatten, + # np.array(year_flattened_prediction), + # np.array(month_flattened_prediction), + # lag_1_month_prediction, + # lag_2_month_prediction, + # lag_3_month_prediction, + # lag_4_month_prediction, + # lag_1_5_day_prediction, + # lag_2_5_day_prediction, + # lag_3_5_day_prediction, + # lag_4_5_day_prediction, + # altitude_prediction, + # minimum_distance_prediction + # ]) + # + # X_categorical_weather = np.column_stack([ + # resid_encoded_prediction, + # zone_encoded_prediction, + # owner_encoded_prediction, + # ftype_encoded_prediction, + # facility_encoded_prediction + # ]) + # + # #scaler_weather = StandardScaler() + # #X_continuous_weather_scaled = scaler_weather.fit_transform(X_continuous_weather) + # #X_weather_standardized = np.column_stack([X_continuous_weather_scaled, X_categorical_weather]) + # X_weather_standardized = np.column_stack([X_continuous_weather, X_categorical_weather]) X_basis_weather_filtered = X_basis_weather[X_basis_weather[:, 0] > mask_threshold] # format output @@ -689,19 +751,39 @@ def get_weather_data(ssp_scenario, model_type): if use_residuals: predictions = results_of_weather_model.predict(X_basis_weather_filtered) else: - X_bases_ANC = np.column_stack([ - year_flattened_prediction, - month_flattened_prediction, + # X_continuous_ANC = np.column_stack([ + # np.array(year_flattened_prediction), + # np.array(month_flattened_prediction), + # altitude_prediction, + # minimum_distance_prediction + # ]) + # + # X_categorical_ANC = np.column_stack([ + # resid_encoded_prediction, + # zone_encoded_prediction, + # owner_encoded_prediction, + # ftype_encoded_prediction, + # facility_encoded_prediction + # ]) + + #scaler_ANC = StandardScaler() + #X_continuous_ANC_scaled = scaler_ANC.fit_transform(X_continuous_ANC) + + #X_bases_ANC_standardized = np.column_stack([X_continuous_ANC_scaled, X_categorical_ANC]) + #X_bases_ANC_standardized = np.column_stack([X_continuous_ANC, X_categorical_ANC]) + X_basis_ANC = np.column_stack([ + np.array(year_flattened_prediction), + np.array(month_flattened_prediction), resid_encoded_prediction, zone_encoded_prediction, owner_encoded_prediction, ftype_encoded_prediction, facility_encoded_prediction, altitude_prediction, - minimum_distance_prediction + minimum_distance_prediction, + # above_below_X_prediction ]) - - y_pred_ANC = results.predict(X_bases_ANC) + y_pred_ANC = results.predict(X_basis_ANC) if log_y: predictions = np.exp(predictions_weather) - np.exp(y_pred_ANC[X_basis_weather[:, 0] > mask_threshold]) data_weather_predictions['y_pred_no_weather'] = np.exp(y_pred_ANC[X_basis_weather[:, 0] > mask_threshold]) @@ -710,7 +792,7 @@ def get_weather_data(ssp_scenario, model_type): predictions = predictions_weather - y_pred_ANC[X_basis_weather[:, 0] > mask_threshold] data_weather_predictions['y_pred_no_weather'] = y_pred_ANC[X_basis_weather[:, 0] > mask_threshold] - + print(predictions) data_weather_predictions['difference_in_expectation'] = predictions data_weather_predictions['weather'] = X_basis_weather[X_basis_weather[:, 0] > mask_threshold, 0] data_weather_predictions_grouped = data_weather_predictions.groupby('Year_Month').mean().reset_index() @@ -725,23 +807,6 @@ def get_weather_data(ssp_scenario, model_type): axs[0].set_xticklabels(xticks, rotation=45, ha='right') axs[0].set_ylabel('Difference Predicted ANC visits due to rainfall') axs[0].legend(loc='upper left') - # - # # if log_y: - # # - # # axs[1].scatter(X_basis_weather_filtered[:, 0], np.exp(data_weather_predictions['y_pred_weather']), color='#9AC4F8', - # # alpha=0.3, label='Predictions of weather model') - # # axs[1].scatter(X_basis_weather_filtered[:, 0], np.exp(data_weather_predictions['y_pred_no_weather']), color='#9AC4F8', - # # alpha=1, label='Predictions of no weather model') - # # else: - # # axs[1].scatter(X_basis_weather_filtered[:, 0], data_weather_predictions['y_pred_weather'], color='#9AC4F8', alpha=0.7, - # # label='Predictions of weather model') - # # - # # axs[1].scatter(X_basis_weather_filtered[:, 0], data_weather_predictions['y_pred_no_weather'], color='#9AC4F8', alpha=1, - # # label='Predictions of no weather model') - # # axs[1].set_xlabel('Precipitation (mm)') - # # axs[1].set_ylabel('Frequency') - # # axs[1].legend() - #plt.tight_layout() plt.show() fig, axs = plt.subplots(1, 2, figsize=(14, 6)) @@ -754,10 +819,16 @@ def get_weather_data(ssp_scenario, model_type): plt.tight_layout() plt.show() + print(X_basis_weather[:, 0].min()) + print(X_basis_weather[:, 0].max()) ## Save predictions - + print(len(year_flattened_prediction)) + print(year_flattened_prediction) + print(len(year_flattened_prediction[X_basis_weather[:, 0] > mask_threshold])) + print(year_flattened_prediction) # Format output: Add all relevant X variables + print(year_flattened_prediction[X_basis_weather[:, 0] > mask_threshold]) full_data_weather_predictions = pd.DataFrame({ 'Year': year_flattened_prediction[X_basis_weather[:, 0] > mask_threshold], 'Month': np.array(month_flattened_prediction)[X_basis_weather[:, 0] > mask_threshold], @@ -777,7 +848,7 @@ def get_weather_data(ssp_scenario, model_type): 'Difference_in_Expectation': predictions, }) - # Save the results + #Save the results full_data_weather_predictions.to_csv(f"{data_path}weather_predictions_with_X_{ssp_scenario}_{model_type}.csv", index=False) X_basis_weather_filtered = pd.DataFrame(X_basis_weather_filtered) From fd5c98bae74b5b6d231e54edd596bc8cde3d1ce3 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 7 Jan 2025 16:13:07 +0000 Subject: [PATCH 157/291] Rename --- ...IP6_downscaling.py => CIL_CMIP6_downscaling_accessing_data.py} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename src/scripts/climate_change/{CIL_CMIP6_downscaling.py => CIL_CMIP6_downscaling_accessing_data.py} (100%) diff --git a/src/scripts/climate_change/CIL_CMIP6_downscaling.py b/src/scripts/climate_change/CIL_CMIP6_downscaling_accessing_data.py similarity index 100% rename from src/scripts/climate_change/CIL_CMIP6_downscaling.py rename to src/scripts/climate_change/CIL_CMIP6_downscaling_accessing_data.py From 1d398eea2274aee0e140f123022bdaa7d817499a Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 7 Jan 2025 16:33:07 +0000 Subject: [PATCH 158/291] Run kdball --- .../CIL_CMIP6_downscaling.ipynb | 11 +- .../climate_change/CIL_CMIP6_downscaling.py | 293 ++++++++++++++++++ 2 files changed, 294 insertions(+), 10 deletions(-) create mode 100644 src/scripts/climate_change/CIL_CMIP6_downscaling.py diff --git a/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb b/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb index 361eb7c09f..3a4a9f5094 100644 --- a/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb +++ b/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb @@ -660,8 +660,7 @@ "base_dir = \"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/\"\n", "nc_file_directory = os.path.join(base_dir, 'nc_files')\n", "# NB these are daily \n", - "scenarios = [\"ssp245\"]#, \"ssp585\"] \n", - "#scenarios = [\"ssp585\"] \n", + "scenarios = [\"ssp245\", \"ssp585\"] \n", "\n", "data_by_model_and_grid = {}\n", "for scenario in scenarios:\n", @@ -812,14 +811,6 @@ ], "execution_count": null }, - { - "metadata": {}, - "cell_type": "code", - "source": "data_all_models", - "id": "40563902df7b9233", - "outputs": [], - "execution_count": null - }, { "metadata": { "ExecuteTime": { diff --git a/src/scripts/climate_change/CIL_CMIP6_downscaling.py b/src/scripts/climate_change/CIL_CMIP6_downscaling.py new file mode 100644 index 0000000000..af66a51ae3 --- /dev/null +++ b/src/scripts/climate_change/CIL_CMIP6_downscaling.py @@ -0,0 +1,293 @@ +#!/usr/bin/env python +# coding: utf-8 + +# From https://planetarycomputer.microsoft.com/dataset/cil-gdpcir-cc0#Ensemble-example + +# In[1]: + + +import planetary_computer +import pystac_client + +import xarray as xr +import numpy as np +import pandas as pd +from dask.diagnostics import ProgressBar +from tqdm.auto import tqdm + +import os +import re +import glob +import shutil +import zipfile +from pathlib import Path + +import difflib +from scipy.spatial import KDTree + +import matplotlib.pyplot as plt +import geopandas as gpd +import regionmask +import cartopy.crs as ccrs + +from netCDF4 import Dataset + +from carbonplan import styles # noqa: F401 +import intake +import cmip6_downscaling + + +# Load and organise data + +# In[52]: + + +import xarray as xr +import pandas as pd +from pystac_client import Client +from planetary_computer import sign_inplace +from tqdm import tqdm + + + +ANC = True +Inpatient = False +multiplier = 1 # no need for multiplier +years = range(2025, 2071) # final date is 1st Jan 2100 +month_lengths = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] * len(years) +window_size = 5 + +if ANC: + reporting_data = pd.read_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_ANC_by_smaller_facility_lm.csv") +elif Inpatient: + reporting_data = pd.read_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_Inpatient_by_smaller_facility_lm.csv") +general_facilities = gpd.read_file("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_districts.shp") + +facilities_with_lat_long = pd.read_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_lat_long_region.csv") + + +# In[3]: + + +def unzip_all_in_directory(directory): + """ + Unzips all .zip files in the specified directory, extracting each into a separate folder. + + Parameters: + directory (str): The path to the folder containing the .zip files. + """ + for filename in os.listdir(directory): + if filename.endswith('.zip'): + file_path = os.path.join(directory, filename) + extract_dir = os.path.join(directory, filename[:-4]) + os.makedirs(extract_dir, exist_ok=True) + + try: + with zipfile.ZipFile(file_path, 'r') as zip_ref: + zip_ref.extractall(extract_dir) + except zipfile.BadZipFile: + print(f"Skipped {filename}: not a valid zip file.") + +def get_facility_lat_long(reporting_facility, facilities_df, cutoff=0.90, n_matches=3): + """ + Function to find the closest matching facility name and return its latitude and longitude. + + Parameters: + - reporting_facility: The facility name for which latitude and longitude are needed. + - facilities_df : DataFrame containing facility names ('Fname') and their corresponding latitudes ('A109__Latitude') and longitudes ('A109__Longitude'). + - cutoff: The minimum similarity score for a match. Default is 0.90. + - n_matches: The maximum number of matches to consider. Default is 3. + + Returns: match_name, lat_for_facility, long_for_facility + + """ + matching_facility_name = difflib.get_close_matches(reporting_facility, facilities_df['Fname'], n=n_matches, + cutoff=cutoff) + + if matching_facility_name: + match_name = matching_facility_name[0] # Access the string directly + lat_for_facility = facilities_df.loc[facilities_df['Fname'] == match_name, "A109__Latitude"].iloc[0] + long_for_facility = facilities_df.loc[facilities_df['Fname'] == match_name, "A109__Longitude"].iloc[0] + return match_name, lat_for_facility, long_for_facility + else: + return np.nan, np.nan, np.nan + +def extract_nc_files_from_unzipped_folders(directory): + """ + Searches for .nc files in the specified directory and all its subfolders, + and copies them to the output directory, maintaining the folder structure. + + Parameters: + directory (str): The path to the folder containing the unzipped folders. + """ + output_directory = os.path.join(directory, 'nc_files') + if not os.path.exists(output_directory): + os.makedirs(output_directory) + + for root, _, files in os.walk(directory): + # Skip the output directory to prevent recursive copying + if root == output_directory: + continue + + for filename in files: + if filename.endswith('.nc'): + source_file_path = os.path.join(root, filename) + destination_file_path = os.path.join(output_directory, filename) + + # Only copy if the file does not already exist in the output directory + if not os.path.exists(destination_file_path): + shutil.copy2(source_file_path, output_directory) + + +# In[ ]: + + +base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/" +nc_file_directory = os.path.join(base_dir, 'nc_files') +# NB these are daily +scenarios = ["ssp245", "ssp585"] + +data_by_model_and_grid = {} +for scenario in scenarios: + print(scenario) + scenario_directory = os.path.join(base_dir, scenario) + + grid_centroids = {} + cumulative_sum_by_models = {} + file_path_downscaled = f"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/" + output_file = f"CIL_combined_{scenario}_2025_2070.nc" + file_pattern = os.path.join(file_path_downscaled, "CIL_subset_ssp245_*.nc") + data_all_models = xr.open_mfdataset(file_pattern, combine='nested', concat_dim="time") + data_all_models.compute() + + data_all_models.to_netcdf(output_file) + #data_all_models = xr.open_dataset(file_path_downscaled) + + ## Get models of interest - min, med, max + # Assuming 'pr' is the variable representing precipitation in the dataset + pr_aggregated = data_all_models.mean(dim=["lat", "lon", "time"], skipna=True) # Work with the 'pr' DataArray + + # Find the model with the lowest value + min_model_object = pr_aggregated['pr'].idxmin(dim="model") + min_model = min_model_object.values.item() + # Find the model with the median value + sorted_models = pr_aggregated.sortby("model") + n_models = len(pr_aggregated.model) + median_index = n_models // 2 + median_model_object = sorted_models["model"][median_index] + print(median_model_object) + median_model = median_model_object.values.item() + print(median_model) + # Find the model with the highest value + max_model_object = pr_aggregated['pr'].idxmax(dim="model") + max_model = max_model_object.values.item() + + models_of_interest = [min_model, median_model, max_model] + #models_of_interest = [median_model] + + print("Models of interest", models_of_interest) + # see which facilities have reporting data and data on latitude and longitude + weather_df_lowest_window = pd.DataFrame() + weather_df_median_window = pd.DataFrame() + weather_df_highest_window = pd.DataFrame() + + weather_df_lowest_monthly = pd.DataFrame() + weather_df_median_monthly = pd.DataFrame() + weather_df_highest_monthly = pd.DataFrame() + for model in models_of_interest: + data_per_model = data_all_models.sel(model=model) + pr_data = data_per_model.variables['pr'][:] # in kg m-2 s-1 = mm s-1 x 86400 to get to day + lat_data = data_per_model.variables['lat'][:] + lon_data = data_per_model.variables['lon'][:] + lon_grid, lat_grid = np.meshgrid(lon_data, lat_data) + centroids = np.column_stack((lat_grid.ravel(), lon_grid.ravel())) + + # Store centroids + grid_centroids[model] = centroids + grid_dictionary = {} + grid = 0 + for i in lat_data: + for j in lon_data: + precip_data_for_grid = data_per_model.sel(lat=i, lon=j, method="nearest") # across all time points + grid_dictionary[grid] = precip_data_for_grid.pr.data + grid += 1 + data_by_model_and_grid[model] = grid_dictionary + + for reporting_facility in reporting_data.columns: + print(reporting_facility) + grid_precipitation_for_facility = {} + match_name, lat_for_facility, long_for_facility = get_facility_lat_long(reporting_facility, facilities_with_lat_long) + if not np.isnan(long_for_facility) and not np.isnan(lat_for_facility): + facility_location = np.array([lat_for_facility, long_for_facility]) + kd_trees_by_model = {} + + # Loop over each model of interest + for model in models_of_interest: + centroids = grid_centroids[model] + kd_tree = KDTree(centroids) + distance, closest_grid_index = kd_tree.query(facility_location) + grid_precipitation_for_facility[model] = data_by_model_and_grid[model][closest_grid_index] + + cumulative_sum_monthly = [] + cumulative_sum_window = [] + + begin_day = 0 + # Calculate monthly cumulative sums + for month_idx, month_length in enumerate(month_lengths): + days_for_grid_monthly = grid_precipitation_for_facility[model][begin_day:begin_day + month_length] + cumulative_sums_monthly = [ + sum(days_for_grid_monthly) + ] + max_cumulative_sums_monthly = max(cumulative_sums_monthly) + cumulative_sum_monthly.append(max_cumulative_sums_monthly) + begin_day += month_length + + begin_day = 0 + # Calculate windowed cumulative sums + for month_idx, month_length in enumerate(month_lengths): + days_for_grid_window = grid_precipitation_for_facility[model][begin_day:begin_day + month_length] + + cumulative_sums_window = [ + sum(days_for_grid_window[day:day + window_size]) + for day in range(month_length - window_size + 1) + ] + + max_cumulative_sums_window = max(cumulative_sums_window) + cumulative_sum_window.append(max_cumulative_sums_window) + begin_day += month_length + + # Assign the calculated data to the correct dataframe based on the model + if model == min_model: + weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly + weather_df_lowest_window[reporting_facility] = cumulative_sum_window + elif model == median_model: + weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly + weather_df_median_window[reporting_facility] = cumulative_sum_window + elif model == max_model: + weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly + weather_df_highest_window[reporting_facility] = cumulative_sum_window + + if ANC: + weather_df_lowest_window.to_csv(Path(scenario_directory) / f"lowest_model_daily_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{scenario}.csv", index=False) + weather_df_median_window.to_csv(Path(scenario_directory) / f"median_model_daily_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{scenario}.csv", index=False) + weather_df_highest_window.to_csv(Path(scenario_directory) / f"highest_model_daily_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{scenario}.csv", index=False) + + weather_df_lowest_monthly.to_csv(Path(scenario_directory) / f"lowest_model_monthly_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{scenario}.csv", index=False) + weather_df_median_monthly.to_csv(Path(scenario_directory) / f"median_model_monthly_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{scenario}.csv", index=False) + weather_df_highest_monthly.to_csv(Path(scenario_directory) / f"highest_model_monthly_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{scenario}.csv", index=False) + + +# In[27]: + + +data_all_models.mean(dim=["lat", "lon", "time"], skipna=True) + + +# In[ ]: + + + + From ffa6846b3d2e7ca3bf807d704967b093e41bbca3 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 8 Jan 2025 19:00:48 +0000 Subject: [PATCH 159/291] Have quicker processing of downscaled data NB - some years are missing --- .../CIL_CMIP6_downscaling.ipynb | 20048 +++++++++++++++- 1 file changed, 19569 insertions(+), 479 deletions(-) diff --git a/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb b/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb index 3a4a9f5094..d5702c348f 100644 --- a/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb +++ b/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb @@ -9,8 +9,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-07T09:41:20.078055Z", - "start_time": "2025-01-07T09:41:18.319974Z" + "end_time": "2025-01-08T16:28:56.441662Z", + "start_time": "2025-01-08T16:28:54.657651Z" } }, "cell_type": "code", @@ -58,8 +58,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-07T09:12:15.018110Z", - "start_time": "2025-01-07T08:36:55.986715Z" + "end_time": "2025-01-08T16:01:01.661499Z", + "start_time": "2025-01-08T16:00:57.685170Z" } }, "cell_type": "code", @@ -141,350 +141,7 @@ "name": "stderr", "output_type": "stream", "text": [ - " 36%|███▋ | 8/22 [00:37<01:31, 6.57s/it]Task exception was never retrieved\n", - "future: exception=SocketTimeoutError('Timeout on reading data from socket')>\n", - "Traceback (most recent call last):\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 77, in process_chunk\n", - " chunk_data, _ = await self._download_chunk(chunk_start, chunk_end - 1)\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 141, in _download_chunk\n", - " chunk_data = await process_content(response, offset[0], offset[1], self.encryption_options)\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 49, in process_content\n", - " await data.response.read()\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/core/rest/_aiohttp.py\", line 215, in read\n", - " self._content = await self._internal_response.read()\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/client_reqrep.py\", line 1214, in read\n", - " self._body = await self.content.read()\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 415, in read\n", - " block = await self.readany()\n", - " ^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 437, in readany\n", - " await self._wait(\"readany\")\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 344, in _wait\n", - " await waiter\n", - "aiohttp.client_exceptions.SocketTimeoutError: Timeout on reading data from socket\n", - "Task exception was never retrieved\n", - "future: exception=SocketTimeoutError('Timeout on reading data from socket')>\n", - "Traceback (most recent call last):\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 77, in process_chunk\n", - " chunk_data, _ = await self._download_chunk(chunk_start, chunk_end - 1)\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 141, in _download_chunk\n", - " chunk_data = await process_content(response, offset[0], offset[1], self.encryption_options)\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 49, in process_content\n", - " await data.response.read()\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/core/rest/_aiohttp.py\", line 215, in read\n", - " self._content = await self._internal_response.read()\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/client_reqrep.py\", line 1214, in read\n", - " self._body = await self.content.read()\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 415, in read\n", - " block = await self.readany()\n", - " ^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 437, in readany\n", - " await self._wait(\"readany\")\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 344, in _wait\n", - " await waiter\n", - "aiohttp.client_exceptions.SocketTimeoutError: Timeout on reading data from socket\n", - "Task exception was never retrieved\n", - "future: exception=SocketTimeoutError('Timeout on reading data from socket')>\n", - "Traceback (most recent call last):\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 77, in process_chunk\n", - " chunk_data, _ = await self._download_chunk(chunk_start, chunk_end - 1)\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 141, in _download_chunk\n", - " chunk_data = await process_content(response, offset[0], offset[1], self.encryption_options)\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 49, in process_content\n", - " await data.response.read()\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/core/rest/_aiohttp.py\", line 215, in read\n", - " self._content = await self._internal_response.read()\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/client_reqrep.py\", line 1214, in read\n", - " self._body = await self.content.read()\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 415, in read\n", - " block = await self.readany()\n", - " ^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 437, in readany\n", - " await self._wait(\"readany\")\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 344, in _wait\n", - " await waiter\n", - "aiohttp.client_exceptions.SocketTimeoutError: Timeout on reading data from socket\n", - "Task exception was never retrieved\n", - "future: exception=SocketTimeoutError('Timeout on reading data from socket')>\n", - "Traceback (most recent call last):\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 77, in process_chunk\n", - " chunk_data, _ = await self._download_chunk(chunk_start, chunk_end - 1)\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 141, in _download_chunk\n", - " chunk_data = await process_content(response, offset[0], offset[1], self.encryption_options)\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 49, in process_content\n", - " await data.response.read()\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/core/rest/_aiohttp.py\", line 215, in read\n", - " self._content = await self._internal_response.read()\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/client_reqrep.py\", line 1214, in read\n", - " self._body = await self.content.read()\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 415, in read\n", - " block = await self.readany()\n", - " ^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 437, in readany\n", - " await self._wait(\"readany\")\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 344, in _wait\n", - " await waiter\n", - "aiohttp.client_exceptions.SocketTimeoutError: Timeout on reading data from socket\n", - "Task exception was never retrieved\n", - "future: exception=SocketTimeoutError('Timeout on reading data from socket')>\n", - "Traceback (most recent call last):\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 77, in process_chunk\n", - " chunk_data, _ = await self._download_chunk(chunk_start, chunk_end - 1)\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 141, in _download_chunk\n", - " chunk_data = await process_content(response, offset[0], offset[1], self.encryption_options)\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 49, in process_content\n", - " await data.response.read()\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/core/rest/_aiohttp.py\", line 215, in read\n", - " self._content = await self._internal_response.read()\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/client_reqrep.py\", line 1214, in read\n", - " self._body = await self.content.read()\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 415, in read\n", - " block = await self.readany()\n", - " ^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 437, in readany\n", - " await self._wait(\"readany\")\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 344, in _wait\n", - " await waiter\n", - "aiohttp.client_exceptions.SocketTimeoutError: Timeout on reading data from socket\n", - "Task exception was never retrieved\n", - "future: exception=SocketTimeoutError('Timeout on reading data from socket')>\n", - "Traceback (most recent call last):\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 77, in process_chunk\n", - " chunk_data, _ = await self._download_chunk(chunk_start, chunk_end - 1)\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 141, in _download_chunk\n", - " chunk_data = await process_content(response, offset[0], offset[1], self.encryption_options)\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 49, in process_content\n", - " await data.response.read()\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/core/rest/_aiohttp.py\", line 215, in read\n", - " self._content = await self._internal_response.read()\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/client_reqrep.py\", line 1214, in read\n", - " self._body = await self.content.read()\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 415, in read\n", - " block = await self.readany()\n", - " ^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 437, in readany\n", - " await self._wait(\"readany\")\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 344, in _wait\n", - " await waiter\n", - "aiohttp.client_exceptions.SocketTimeoutError: Timeout on reading data from socket\n", - "Task exception was never retrieved\n", - "future: exception=SocketTimeoutError('Timeout on reading data from socket')>\n", - "Traceback (most recent call last):\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 77, in process_chunk\n", - " chunk_data, _ = await self._download_chunk(chunk_start, chunk_end - 1)\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 141, in _download_chunk\n", - " chunk_data = await process_content(response, offset[0], offset[1], self.encryption_options)\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 49, in process_content\n", - " await data.response.read()\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/core/rest/_aiohttp.py\", line 215, in read\n", - " self._content = await self._internal_response.read()\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/client_reqrep.py\", line 1214, in read\n", - " self._body = await self.content.read()\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 415, in read\n", - " block = await self.readany()\n", - " ^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 437, in readany\n", - " await self._wait(\"readany\")\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 344, in _wait\n", - " await waiter\n", - "aiohttp.client_exceptions.SocketTimeoutError: Timeout on reading data from socket\n", - "Task exception was never retrieved\n", - "future: exception=SocketTimeoutError('Timeout on reading data from socket')>\n", - "Traceback (most recent call last):\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 77, in process_chunk\n", - " chunk_data, _ = await self._download_chunk(chunk_start, chunk_end - 1)\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 141, in _download_chunk\n", - " chunk_data = await process_content(response, offset[0], offset[1], self.encryption_options)\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 49, in process_content\n", - " await data.response.read()\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/core/rest/_aiohttp.py\", line 215, in read\n", - " self._content = await self._internal_response.read()\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/client_reqrep.py\", line 1214, in read\n", - " self._body = await self.content.read()\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 415, in read\n", - " block = await self.readany()\n", - " ^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 437, in readany\n", - " await self._wait(\"readany\")\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 344, in _wait\n", - " await waiter\n", - "aiohttp.client_exceptions.SocketTimeoutError: Timeout on reading data from socket\n", - "Task exception was never retrieved\n", - "future: exception=SocketTimeoutError('Timeout on reading data from socket')>\n", - "Traceback (most recent call last):\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 77, in process_chunk\n", - " chunk_data, _ = await self._download_chunk(chunk_start, chunk_end - 1)\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 141, in _download_chunk\n", - " chunk_data = await process_content(response, offset[0], offset[1], self.encryption_options)\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 49, in process_content\n", - " await data.response.read()\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/core/rest/_aiohttp.py\", line 215, in read\n", - " self._content = await self._internal_response.read()\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/client_reqrep.py\", line 1214, in read\n", - " self._body = await self.content.read()\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 415, in read\n", - " block = await self.readany()\n", - " ^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 437, in readany\n", - " await self._wait(\"readany\")\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 344, in _wait\n", - " await waiter\n", - "aiohttp.client_exceptions.SocketTimeoutError: Timeout on reading data from socket\n", - "Task exception was never retrieved\n", - "future: exception=SocketTimeoutError('Timeout on reading data from socket')>\n", - "Traceback (most recent call last):\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 77, in process_chunk\n", - " chunk_data, _ = await self._download_chunk(chunk_start, chunk_end - 1)\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 141, in _download_chunk\n", - " chunk_data = await process_content(response, offset[0], offset[1], self.encryption_options)\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 49, in process_content\n", - " await data.response.read()\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/core/rest/_aiohttp.py\", line 215, in read\n", - " self._content = await self._internal_response.read()\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/client_reqrep.py\", line 1214, in read\n", - " self._body = await self.content.read()\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 415, in read\n", - " block = await self.readany()\n", - " ^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 437, in readany\n", - " await self._wait(\"readany\")\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 344, in _wait\n", - " await waiter\n", - "aiohttp.client_exceptions.SocketTimeoutError: Timeout on reading data from socket\n", - "Task exception was never retrieved\n", - "future: exception=SocketTimeoutError('Timeout on reading data from socket')>\n", - "Traceback (most recent call last):\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 77, in process_chunk\n", - " chunk_data, _ = await self._download_chunk(chunk_start, chunk_end - 1)\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 141, in _download_chunk\n", - " chunk_data = await process_content(response, offset[0], offset[1], self.encryption_options)\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 49, in process_content\n", - " await data.response.read()\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/core/rest/_aiohttp.py\", line 215, in read\n", - " self._content = await self._internal_response.read()\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/client_reqrep.py\", line 1214, in read\n", - " self._body = await self.content.read()\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 415, in read\n", - " block = await self.readany()\n", - " ^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 437, in readany\n", - " await self._wait(\"readany\")\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 344, in _wait\n", - " await waiter\n", - "aiohttp.client_exceptions.SocketTimeoutError: Timeout on reading data from socket\n", - "Task exception was never retrieved\n", - "future: exception=SocketTimeoutError('Timeout on reading data from socket')>\n", - "Traceback (most recent call last):\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 77, in process_chunk\n", - " chunk_data, _ = await self._download_chunk(chunk_start, chunk_end - 1)\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 141, in _download_chunk\n", - " chunk_data = await process_content(response, offset[0], offset[1], self.encryption_options)\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 49, in process_content\n", - " await data.response.read()\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/core/rest/_aiohttp.py\", line 215, in read\n", - " self._content = await self._internal_response.read()\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/client_reqrep.py\", line 1214, in read\n", - " self._body = await self.content.read()\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 415, in read\n", - " block = await self.readany()\n", - " ^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 437, in readany\n", - " await self._wait(\"readany\")\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 344, in _wait\n", - " await waiter\n", - "aiohttp.client_exceptions.SocketTimeoutError: Timeout on reading data from socket\n", - "Task exception was never retrieved\n", - "future: exception=SocketTimeoutError('Timeout on reading data from socket')>\n", - "Traceback (most recent call last):\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 77, in process_chunk\n", - " chunk_data, _ = await self._download_chunk(chunk_start, chunk_end - 1)\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 141, in _download_chunk\n", - " chunk_data = await process_content(response, offset[0], offset[1], self.encryption_options)\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/storage/blob/aio/_download_async.py\", line 49, in process_content\n", - " await data.response.read()\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/azure/core/rest/_aiohttp.py\", line 215, in read\n", - " self._content = await self._internal_response.read()\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/client_reqrep.py\", line 1214, in read\n", - " self._body = await self.content.read()\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 415, in read\n", - " block = await self.readany()\n", - " ^^^^^^^^^^^^^^^^^^^^\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 437, in readany\n", - " await self._wait(\"readany\")\n", - " File \"/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/aiohttp/streams.py\", line 344, in _wait\n", - " await waiter\n", - "aiohttp.client_exceptions.SocketTimeoutError: Timeout on reading data from socket\n", - "100%|██████████| 22/22 [02:45<00:00, 7.53s/it]\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_24684/2600312277.py:43: FutureWarning: 'Y' is deprecated and will be removed in a future version, please use 'YE' instead.\n", - " time_range = pd.date_range(\"2061-01-01\", \"2071-01-01\", freq=\"Y\")\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Saved yearly data for 2061 to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL//CIL_subset_ssp585_2061.nc\n", - "Saved yearly data for 2062 to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL//CIL_subset_ssp585_2062.nc\n", - "Saved yearly data for 2063 to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL//CIL_subset_ssp585_2063.nc\n", - "Saved yearly data for 2064 to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL//CIL_subset_ssp585_2064.nc\n", - "Saved yearly data for 2065 to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL//CIL_subset_ssp585_2065.nc\n", - "Saved yearly data for 2066 to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL//CIL_subset_ssp585_2066.nc\n", - "Saved yearly data for 2067 to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL//CIL_subset_ssp585_2067.nc\n", - "Saved yearly data for 2068 to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL//CIL_subset_ssp585_2068.nc\n", - "Saved yearly data for 2069 to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL//CIL_subset_ssp585_2069.nc\n", - "Saved yearly data for 2070 to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL//CIL_subset_ssp585_2070.nc\n" + " 0%| | 0/22 [00:01 62\u001B[0m \u001B[43mcombined_dataset\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mto_netcdf\u001B[49m\u001B[43m(\u001B[49m\u001B[43mcombined_output\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 63\u001B[0m \u001B[38;5;28mprint\u001B[39m(\u001B[38;5;124mf\u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mSaved combined dataset to \u001B[39m\u001B[38;5;132;01m{\u001B[39;00mcombined_output\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m\"\u001B[39m)\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/core/dataset.py:2372\u001B[0m, in \u001B[0;36mDataset.to_netcdf\u001B[0;34m(self, path, mode, format, group, engine, encoding, unlimited_dims, compute, invalid_netcdf, auto_complex)\u001B[0m\n\u001B[1;32m 2369\u001B[0m encoding \u001B[38;5;241m=\u001B[39m {}\n\u001B[1;32m 2370\u001B[0m \u001B[38;5;28;01mfrom\u001B[39;00m \u001B[38;5;21;01mxarray\u001B[39;00m\u001B[38;5;21;01m.\u001B[39;00m\u001B[38;5;21;01mbackends\u001B[39;00m\u001B[38;5;21;01m.\u001B[39;00m\u001B[38;5;21;01mapi\u001B[39;00m \u001B[38;5;28;01mimport\u001B[39;00m to_netcdf\n\u001B[0;32m-> 2372\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[43mto_netcdf\u001B[49m\u001B[43m(\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;66;43;03m# type: ignore[return-value] # mypy cannot resolve the overloads:(\u001B[39;49;00m\n\u001B[1;32m 2373\u001B[0m \u001B[43m \u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[43m,\u001B[49m\n\u001B[1;32m 2374\u001B[0m \u001B[43m \u001B[49m\u001B[43mpath\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 2375\u001B[0m \u001B[43m \u001B[49m\u001B[43mmode\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mmode\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 2376\u001B[0m \u001B[43m \u001B[49m\u001B[38;5;28;43mformat\u001B[39;49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43mformat\u001B[39;49m\u001B[43m,\u001B[49m\n\u001B[1;32m 2377\u001B[0m \u001B[43m \u001B[49m\u001B[43mgroup\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mgroup\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 2378\u001B[0m \u001B[43m \u001B[49m\u001B[43mengine\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mengine\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 2379\u001B[0m \u001B[43m \u001B[49m\u001B[43mencoding\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mencoding\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 2380\u001B[0m \u001B[43m \u001B[49m\u001B[43munlimited_dims\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43munlimited_dims\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 2381\u001B[0m \u001B[43m \u001B[49m\u001B[43mcompute\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mcompute\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 2382\u001B[0m \u001B[43m \u001B[49m\u001B[43mmultifile\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43;01mFalse\u001B[39;49;00m\u001B[43m,\u001B[49m\n\u001B[1;32m 2383\u001B[0m \u001B[43m \u001B[49m\u001B[43minvalid_netcdf\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43minvalid_netcdf\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 2384\u001B[0m \u001B[43m \u001B[49m\u001B[43mauto_complex\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mauto_complex\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 2385\u001B[0m \u001B[43m\u001B[49m\u001B[43m)\u001B[49m\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/backends/api.py:1882\u001B[0m, in \u001B[0;36mto_netcdf\u001B[0;34m(dataset, path_or_file, mode, format, group, engine, encoding, unlimited_dims, compute, multifile, invalid_netcdf, auto_complex)\u001B[0m\n\u001B[1;32m 1879\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m multifile:\n\u001B[1;32m 1880\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m writer, store\n\u001B[0;32m-> 1882\u001B[0m writes \u001B[38;5;241m=\u001B[39m \u001B[43mwriter\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43msync\u001B[49m\u001B[43m(\u001B[49m\u001B[43mcompute\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mcompute\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 1884\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(target, BytesIO):\n\u001B[1;32m 1885\u001B[0m store\u001B[38;5;241m.\u001B[39msync()\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/backends/common.py:351\u001B[0m, in \u001B[0;36mArrayWriter.sync\u001B[0;34m(self, compute, chunkmanager_store_kwargs)\u001B[0m\n\u001B[1;32m 348\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m chunkmanager_store_kwargs \u001B[38;5;129;01mis\u001B[39;00m \u001B[38;5;28;01mNone\u001B[39;00m:\n\u001B[1;32m 349\u001B[0m chunkmanager_store_kwargs \u001B[38;5;241m=\u001B[39m {}\n\u001B[0;32m--> 351\u001B[0m delayed_store \u001B[38;5;241m=\u001B[39m \u001B[43mchunkmanager\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mstore\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m 352\u001B[0m \u001B[43m \u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43msources\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 353\u001B[0m \u001B[43m \u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mtargets\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 354\u001B[0m \u001B[43m \u001B[49m\u001B[43mlock\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mlock\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 355\u001B[0m \u001B[43m \u001B[49m\u001B[43mcompute\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mcompute\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 356\u001B[0m \u001B[43m \u001B[49m\u001B[43mflush\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43;01mTrue\u001B[39;49;00m\u001B[43m,\u001B[49m\n\u001B[1;32m 357\u001B[0m \u001B[43m \u001B[49m\u001B[43mregions\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mregions\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 358\u001B[0m \u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mchunkmanager_store_kwargs\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 359\u001B[0m \u001B[43m\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 360\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39msources \u001B[38;5;241m=\u001B[39m []\n\u001B[1;32m 361\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mtargets \u001B[38;5;241m=\u001B[39m []\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/namedarray/daskmanager.py:247\u001B[0m, in \u001B[0;36mDaskManager.store\u001B[0;34m(self, sources, targets, **kwargs)\u001B[0m\n\u001B[1;32m 239\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21mstore\u001B[39m(\n\u001B[1;32m 240\u001B[0m \u001B[38;5;28mself\u001B[39m,\n\u001B[1;32m 241\u001B[0m sources: Any \u001B[38;5;241m|\u001B[39m Sequence[Any],\n\u001B[1;32m 242\u001B[0m targets: Any,\n\u001B[1;32m 243\u001B[0m \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39mkwargs: Any,\n\u001B[1;32m 244\u001B[0m ) \u001B[38;5;241m-\u001B[39m\u001B[38;5;241m>\u001B[39m Any:\n\u001B[1;32m 245\u001B[0m \u001B[38;5;28;01mfrom\u001B[39;00m \u001B[38;5;21;01mdask\u001B[39;00m\u001B[38;5;21;01m.\u001B[39;00m\u001B[38;5;21;01marray\u001B[39;00m \u001B[38;5;28;01mimport\u001B[39;00m store\n\u001B[0;32m--> 247\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[43mstore\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m 248\u001B[0m \u001B[43m \u001B[49m\u001B[43msources\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43msources\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 249\u001B[0m \u001B[43m \u001B[49m\u001B[43mtargets\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mtargets\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 250\u001B[0m \u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mkwargs\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 251\u001B[0m \u001B[43m \u001B[49m\u001B[43m)\u001B[49m\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/dask/array/core.py:1245\u001B[0m, in \u001B[0;36mstore\u001B[0;34m(***failed resolving arguments***)\u001B[0m\n\u001B[1;32m 1243\u001B[0m \u001B[38;5;28;01melif\u001B[39;00m compute:\n\u001B[1;32m 1244\u001B[0m store_dsk \u001B[38;5;241m=\u001B[39m HighLevelGraph(layers, dependencies)\n\u001B[0;32m-> 1245\u001B[0m \u001B[43mcompute_as_if_collection\u001B[49m\u001B[43m(\u001B[49m\u001B[43mArray\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mstore_dsk\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mmap_keys\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mkwargs\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 1246\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28;01mNone\u001B[39;00m\n\u001B[1;32m 1248\u001B[0m \u001B[38;5;28;01melse\u001B[39;00m:\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/dask/base.py:397\u001B[0m, in \u001B[0;36mcompute_as_if_collection\u001B[0;34m(cls, dsk, keys, scheduler, get, **kwargs)\u001B[0m\n\u001B[1;32m 395\u001B[0m schedule \u001B[38;5;241m=\u001B[39m get_scheduler(scheduler\u001B[38;5;241m=\u001B[39mscheduler, \u001B[38;5;28mcls\u001B[39m\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mcls\u001B[39m, get\u001B[38;5;241m=\u001B[39mget)\n\u001B[1;32m 396\u001B[0m dsk2 \u001B[38;5;241m=\u001B[39m optimization_function(\u001B[38;5;28mcls\u001B[39m)(dsk, keys, \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39mkwargs)\n\u001B[0;32m--> 397\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[43mschedule\u001B[49m\u001B[43m(\u001B[49m\u001B[43mdsk2\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mkeys\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mkwargs\u001B[49m\u001B[43m)\u001B[49m\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/dask/threaded.py:91\u001B[0m, in \u001B[0;36mget\u001B[0;34m(dsk, keys, cache, num_workers, pool, **kwargs)\u001B[0m\n\u001B[1;32m 88\u001B[0m \u001B[38;5;28;01melif\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(pool, multiprocessing\u001B[38;5;241m.\u001B[39mpool\u001B[38;5;241m.\u001B[39mPool):\n\u001B[1;32m 89\u001B[0m pool \u001B[38;5;241m=\u001B[39m MultiprocessingPoolExecutor(pool)\n\u001B[0;32m---> 91\u001B[0m results \u001B[38;5;241m=\u001B[39m \u001B[43mget_async\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m 92\u001B[0m \u001B[43m \u001B[49m\u001B[43mpool\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43msubmit\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 93\u001B[0m \u001B[43m \u001B[49m\u001B[43mpool\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_max_workers\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 94\u001B[0m \u001B[43m \u001B[49m\u001B[43mdsk\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 95\u001B[0m \u001B[43m \u001B[49m\u001B[43mkeys\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 96\u001B[0m \u001B[43m \u001B[49m\u001B[43mcache\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mcache\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 97\u001B[0m \u001B[43m \u001B[49m\u001B[43mget_id\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43m_thread_get_id\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 98\u001B[0m \u001B[43m \u001B[49m\u001B[43mpack_exception\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mpack_exception\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 99\u001B[0m \u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mkwargs\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 100\u001B[0m \u001B[43m\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 102\u001B[0m \u001B[38;5;66;03m# Cleanup pools associated to dead threads\u001B[39;00m\n\u001B[1;32m 103\u001B[0m \u001B[38;5;28;01mwith\u001B[39;00m pools_lock:\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/dask/local.py:505\u001B[0m, in \u001B[0;36mget_async\u001B[0;34m(submit, num_workers, dsk, result, cache, get_id, rerun_exceptions_locally, pack_exception, raise_exception, callbacks, dumps, loads, chunksize, **kwargs)\u001B[0m\n\u001B[1;32m 503\u001B[0m \u001B[38;5;28;01mwhile\u001B[39;00m state[\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mwaiting\u001B[39m\u001B[38;5;124m\"\u001B[39m] \u001B[38;5;129;01mor\u001B[39;00m state[\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mready\u001B[39m\u001B[38;5;124m\"\u001B[39m] \u001B[38;5;129;01mor\u001B[39;00m state[\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mrunning\u001B[39m\u001B[38;5;124m\"\u001B[39m]:\n\u001B[1;32m 504\u001B[0m fire_tasks(chunksize)\n\u001B[0;32m--> 505\u001B[0m \u001B[38;5;28;01mfor\u001B[39;00m key, res_info, failed \u001B[38;5;129;01min\u001B[39;00m \u001B[43mqueue_get\u001B[49m\u001B[43m(\u001B[49m\u001B[43mqueue\u001B[49m\u001B[43m)\u001B[49m\u001B[38;5;241m.\u001B[39mresult():\n\u001B[1;32m 506\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m failed:\n\u001B[1;32m 507\u001B[0m exc, tb \u001B[38;5;241m=\u001B[39m loads(res_info)\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/dask/local.py:140\u001B[0m, in \u001B[0;36mqueue_get\u001B[0;34m(q)\u001B[0m\n\u001B[1;32m 139\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21mqueue_get\u001B[39m(q):\n\u001B[0;32m--> 140\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[43mq\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mget\u001B[49m\u001B[43m(\u001B[49m\u001B[43m)\u001B[49m\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/queue.py:171\u001B[0m, in \u001B[0;36mQueue.get\u001B[0;34m(self, block, timeout)\u001B[0m\n\u001B[1;32m 169\u001B[0m \u001B[38;5;28;01melif\u001B[39;00m timeout \u001B[38;5;129;01mis\u001B[39;00m \u001B[38;5;28;01mNone\u001B[39;00m:\n\u001B[1;32m 170\u001B[0m \u001B[38;5;28;01mwhile\u001B[39;00m \u001B[38;5;129;01mnot\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_qsize():\n\u001B[0;32m--> 171\u001B[0m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mnot_empty\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mwait\u001B[49m\u001B[43m(\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 172\u001B[0m \u001B[38;5;28;01melif\u001B[39;00m timeout \u001B[38;5;241m<\u001B[39m \u001B[38;5;241m0\u001B[39m:\n\u001B[1;32m 173\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m \u001B[38;5;167;01mValueError\u001B[39;00m(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mtimeout\u001B[39m\u001B[38;5;124m'\u001B[39m\u001B[38;5;124m must be a non-negative number\u001B[39m\u001B[38;5;124m\"\u001B[39m)\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/threading.py:327\u001B[0m, in \u001B[0;36mCondition.wait\u001B[0;34m(self, timeout)\u001B[0m\n\u001B[1;32m 325\u001B[0m \u001B[38;5;28;01mtry\u001B[39;00m: \u001B[38;5;66;03m# restore state no matter what (e.g., KeyboardInterrupt)\u001B[39;00m\n\u001B[1;32m 326\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m timeout \u001B[38;5;129;01mis\u001B[39;00m \u001B[38;5;28;01mNone\u001B[39;00m:\n\u001B[0;32m--> 327\u001B[0m \u001B[43mwaiter\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43macquire\u001B[49m\u001B[43m(\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 328\u001B[0m gotit \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;01mTrue\u001B[39;00m\n\u001B[1;32m 329\u001B[0m \u001B[38;5;28;01melse\u001B[39;00m:\n", + "Cell \u001B[0;32mIn[4], line 30\u001B[0m\n\u001B[1;32m 27\u001B[0m \u001B[38;5;28;01mfor\u001B[39;00m item \u001B[38;5;129;01min\u001B[39;00m tqdm(ensemble):\n\u001B[1;32m 28\u001B[0m asset \u001B[38;5;241m=\u001B[39m item\u001B[38;5;241m.\u001B[39massets[variable_id]\n\u001B[1;32m 29\u001B[0m datasets_by_model\u001B[38;5;241m.\u001B[39mappend(\n\u001B[0;32m---> 30\u001B[0m \u001B[43mxr\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mopen_dataset\u001B[49m\u001B[43m(\u001B[49m\u001B[43masset\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mhref\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43masset\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mextra_fields\u001B[49m\u001B[43m[\u001B[49m\u001B[38;5;124;43m\"\u001B[39;49m\u001B[38;5;124;43mxarray:open_kwargs\u001B[39;49m\u001B[38;5;124;43m\"\u001B[39;49m\u001B[43m]\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 31\u001B[0m )\n\u001B[1;32m 33\u001B[0m \u001B[38;5;66;03m# Combine datasets by model\u001B[39;00m\n\u001B[1;32m 34\u001B[0m all_datasets \u001B[38;5;241m=\u001B[39m xr\u001B[38;5;241m.\u001B[39mconcat(\n\u001B[1;32m 35\u001B[0m datasets_by_model,\n\u001B[1;32m 36\u001B[0m dim\u001B[38;5;241m=\u001B[39mpd\u001B[38;5;241m.\u001B[39mIndex([ds\u001B[38;5;241m.\u001B[39mattrs[\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124msource_id\u001B[39m\u001B[38;5;124m\"\u001B[39m] \u001B[38;5;28;01mfor\u001B[39;00m ds \u001B[38;5;129;01min\u001B[39;00m datasets_by_model], name\u001B[38;5;241m=\u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mmodel\u001B[39m\u001B[38;5;124m\"\u001B[39m),\n\u001B[1;32m 37\u001B[0m combine_attrs\u001B[38;5;241m=\u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mdrop_conflicts\u001B[39m\u001B[38;5;124m\"\u001B[39m,\n\u001B[1;32m 38\u001B[0m )\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/backends/api.py:670\u001B[0m, in \u001B[0;36mopen_dataset\u001B[0;34m(filename_or_obj, engine, chunks, cache, decode_cf, mask_and_scale, decode_times, decode_timedelta, use_cftime, concat_characters, decode_coords, drop_variables, inline_array, chunked_array_type, from_array_kwargs, backend_kwargs, **kwargs)\u001B[0m\n\u001B[1;32m 658\u001B[0m decoders \u001B[38;5;241m=\u001B[39m _resolve_decoders_kwargs(\n\u001B[1;32m 659\u001B[0m decode_cf,\n\u001B[1;32m 660\u001B[0m open_backend_dataset_parameters\u001B[38;5;241m=\u001B[39mbackend\u001B[38;5;241m.\u001B[39mopen_dataset_parameters,\n\u001B[0;32m (...)\u001B[0m\n\u001B[1;32m 666\u001B[0m decode_coords\u001B[38;5;241m=\u001B[39mdecode_coords,\n\u001B[1;32m 667\u001B[0m )\n\u001B[1;32m 669\u001B[0m overwrite_encoded_chunks \u001B[38;5;241m=\u001B[39m kwargs\u001B[38;5;241m.\u001B[39mpop(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124moverwrite_encoded_chunks\u001B[39m\u001B[38;5;124m\"\u001B[39m, \u001B[38;5;28;01mNone\u001B[39;00m)\n\u001B[0;32m--> 670\u001B[0m backend_ds \u001B[38;5;241m=\u001B[39m \u001B[43mbackend\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mopen_dataset\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m 671\u001B[0m \u001B[43m \u001B[49m\u001B[43mfilename_or_obj\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 672\u001B[0m \u001B[43m \u001B[49m\u001B[43mdrop_variables\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mdrop_variables\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 673\u001B[0m \u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mdecoders\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 674\u001B[0m \u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mkwargs\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 675\u001B[0m \u001B[43m\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 676\u001B[0m ds \u001B[38;5;241m=\u001B[39m _dataset_from_backend_dataset(\n\u001B[1;32m 677\u001B[0m backend_ds,\n\u001B[1;32m 678\u001B[0m filename_or_obj,\n\u001B[0;32m (...)\u001B[0m\n\u001B[1;32m 688\u001B[0m \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39mkwargs,\n\u001B[1;32m 689\u001B[0m )\n\u001B[1;32m 690\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m ds\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/backends/zarr.py:1524\u001B[0m, in \u001B[0;36mZarrBackendEntrypoint.open_dataset\u001B[0;34m(self, filename_or_obj, mask_and_scale, decode_times, concat_characters, decode_coords, drop_variables, use_cftime, decode_timedelta, group, mode, synchronizer, consolidated, chunk_store, storage_options, zarr_version, zarr_format, store, engine, use_zarr_fill_value_as_mask)\u001B[0m\n\u001B[1;32m 1522\u001B[0m store_entrypoint \u001B[38;5;241m=\u001B[39m StoreBackendEntrypoint()\n\u001B[1;32m 1523\u001B[0m \u001B[38;5;28;01mwith\u001B[39;00m close_on_error(store):\n\u001B[0;32m-> 1524\u001B[0m ds \u001B[38;5;241m=\u001B[39m \u001B[43mstore_entrypoint\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mopen_dataset\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m 1525\u001B[0m \u001B[43m \u001B[49m\u001B[43mstore\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 1526\u001B[0m \u001B[43m \u001B[49m\u001B[43mmask_and_scale\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mmask_and_scale\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 1527\u001B[0m \u001B[43m \u001B[49m\u001B[43mdecode_times\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mdecode_times\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 1528\u001B[0m \u001B[43m \u001B[49m\u001B[43mconcat_characters\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mconcat_characters\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 1529\u001B[0m \u001B[43m \u001B[49m\u001B[43mdecode_coords\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mdecode_coords\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 1530\u001B[0m \u001B[43m \u001B[49m\u001B[43mdrop_variables\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mdrop_variables\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 1531\u001B[0m \u001B[43m \u001B[49m\u001B[43muse_cftime\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43muse_cftime\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 1532\u001B[0m \u001B[43m \u001B[49m\u001B[43mdecode_timedelta\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mdecode_timedelta\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 1533\u001B[0m \u001B[43m \u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 1534\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m ds\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/backends/store.py:59\u001B[0m, in \u001B[0;36mStoreBackendEntrypoint.open_dataset\u001B[0;34m(self, filename_or_obj, mask_and_scale, decode_times, concat_characters, decode_coords, drop_variables, use_cftime, decode_timedelta)\u001B[0m\n\u001B[1;32m 45\u001B[0m encoding \u001B[38;5;241m=\u001B[39m filename_or_obj\u001B[38;5;241m.\u001B[39mget_encoding()\n\u001B[1;32m 47\u001B[0m \u001B[38;5;28mvars\u001B[39m, attrs, coord_names \u001B[38;5;241m=\u001B[39m conventions\u001B[38;5;241m.\u001B[39mdecode_cf_variables(\n\u001B[1;32m 48\u001B[0m \u001B[38;5;28mvars\u001B[39m,\n\u001B[1;32m 49\u001B[0m attrs,\n\u001B[0;32m (...)\u001B[0m\n\u001B[1;32m 56\u001B[0m decode_timedelta\u001B[38;5;241m=\u001B[39mdecode_timedelta,\n\u001B[1;32m 57\u001B[0m )\n\u001B[0;32m---> 59\u001B[0m ds \u001B[38;5;241m=\u001B[39m \u001B[43mDataset\u001B[49m\u001B[43m(\u001B[49m\u001B[38;5;28;43mvars\u001B[39;49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mattrs\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mattrs\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 60\u001B[0m ds \u001B[38;5;241m=\u001B[39m ds\u001B[38;5;241m.\u001B[39mset_coords(coord_names\u001B[38;5;241m.\u001B[39mintersection(\u001B[38;5;28mvars\u001B[39m))\n\u001B[1;32m 61\u001B[0m ds\u001B[38;5;241m.\u001B[39mset_close(filename_or_obj\u001B[38;5;241m.\u001B[39mclose)\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/core/dataset.py:746\u001B[0m, in \u001B[0;36mDataset.__init__\u001B[0;34m(self, data_vars, coords, attrs)\u001B[0m\n\u001B[1;32m 743\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(coords, Dataset):\n\u001B[1;32m 744\u001B[0m coords \u001B[38;5;241m=\u001B[39m coords\u001B[38;5;241m.\u001B[39m_variables\n\u001B[0;32m--> 746\u001B[0m variables, coord_names, dims, indexes, _ \u001B[38;5;241m=\u001B[39m \u001B[43mmerge_data_and_coords\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m 747\u001B[0m \u001B[43m \u001B[49m\u001B[43mdata_vars\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mcoords\u001B[49m\n\u001B[1;32m 748\u001B[0m \u001B[43m\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 750\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_attrs \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mdict\u001B[39m(attrs) \u001B[38;5;28;01mif\u001B[39;00m attrs \u001B[38;5;28;01melse\u001B[39;00m \u001B[38;5;28;01mNone\u001B[39;00m\n\u001B[1;32m 751\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_close \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;01mNone\u001B[39;00m\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/core/dataset.py:459\u001B[0m, in \u001B[0;36mmerge_data_and_coords\u001B[0;34m(data_vars, coords)\u001B[0m\n\u001B[1;32m 455\u001B[0m coords \u001B[38;5;241m=\u001B[39m create_coords_with_default_indexes(coords, data_vars)\n\u001B[1;32m 457\u001B[0m \u001B[38;5;66;03m# exclude coords from alignment (all variables in a Coordinates object should\u001B[39;00m\n\u001B[1;32m 458\u001B[0m \u001B[38;5;66;03m# already be aligned together) and use coordinates' indexes to align data_vars\u001B[39;00m\n\u001B[0;32m--> 459\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[43mmerge_core\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m 460\u001B[0m \u001B[43m \u001B[49m\u001B[43m[\u001B[49m\u001B[43mdata_vars\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mcoords\u001B[49m\u001B[43m]\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 461\u001B[0m \u001B[43m \u001B[49m\u001B[43mcompat\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;124;43m\"\u001B[39;49m\u001B[38;5;124;43mbroadcast_equals\u001B[39;49m\u001B[38;5;124;43m\"\u001B[39;49m\u001B[43m,\u001B[49m\n\u001B[1;32m 462\u001B[0m \u001B[43m \u001B[49m\u001B[43mjoin\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;124;43m\"\u001B[39;49m\u001B[38;5;124;43mouter\u001B[39;49m\u001B[38;5;124;43m\"\u001B[39;49m\u001B[43m,\u001B[49m\n\u001B[1;32m 463\u001B[0m \u001B[43m \u001B[49m\u001B[43mexplicit_coords\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43mtuple\u001B[39;49m\u001B[43m(\u001B[49m\u001B[43mcoords\u001B[49m\u001B[43m)\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 464\u001B[0m \u001B[43m \u001B[49m\u001B[43mindexes\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mcoords\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mxindexes\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 465\u001B[0m \u001B[43m \u001B[49m\u001B[43mpriority_arg\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;241;43m1\u001B[39;49m\u001B[43m,\u001B[49m\n\u001B[1;32m 466\u001B[0m \u001B[43m \u001B[49m\u001B[43mskip_align_args\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43m[\u001B[49m\u001B[38;5;241;43m1\u001B[39;49m\u001B[43m]\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 467\u001B[0m \u001B[43m\u001B[49m\u001B[43m)\u001B[49m\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/core/merge.py:699\u001B[0m, in \u001B[0;36mmerge_core\u001B[0;34m(objects, compat, join, combine_attrs, priority_arg, explicit_coords, indexes, fill_value, skip_align_args)\u001B[0m\n\u001B[1;32m 696\u001B[0m \u001B[38;5;28;01mfor\u001B[39;00m pos, obj \u001B[38;5;129;01min\u001B[39;00m skip_align_objs:\n\u001B[1;32m 697\u001B[0m aligned\u001B[38;5;241m.\u001B[39minsert(pos, obj)\n\u001B[0;32m--> 699\u001B[0m collected \u001B[38;5;241m=\u001B[39m \u001B[43mcollect_variables_and_indexes\u001B[49m\u001B[43m(\u001B[49m\u001B[43maligned\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mindexes\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mindexes\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 700\u001B[0m prioritized \u001B[38;5;241m=\u001B[39m _get_priority_vars_and_indexes(aligned, priority_arg, compat\u001B[38;5;241m=\u001B[39mcompat)\n\u001B[1;32m 701\u001B[0m variables, out_indexes \u001B[38;5;241m=\u001B[39m merge_collected(\n\u001B[1;32m 702\u001B[0m collected, prioritized, compat\u001B[38;5;241m=\u001B[39mcompat, combine_attrs\u001B[38;5;241m=\u001B[39mcombine_attrs\n\u001B[1;32m 703\u001B[0m )\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/core/merge.py:362\u001B[0m, in \u001B[0;36mcollect_variables_and_indexes\u001B[0;34m(list_of_mappings, indexes)\u001B[0m\n\u001B[1;32m 360\u001B[0m append(name, variable, indexes[name])\n\u001B[1;32m 361\u001B[0m \u001B[38;5;28;01melif\u001B[39;00m variable\u001B[38;5;241m.\u001B[39mdims \u001B[38;5;241m==\u001B[39m (name,):\n\u001B[0;32m--> 362\u001B[0m idx, idx_vars \u001B[38;5;241m=\u001B[39m \u001B[43mcreate_default_index_implicit\u001B[49m\u001B[43m(\u001B[49m\u001B[43mvariable\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 363\u001B[0m append_all(idx_vars, {k: idx \u001B[38;5;28;01mfor\u001B[39;00m k \u001B[38;5;129;01min\u001B[39;00m idx_vars})\n\u001B[1;32m 364\u001B[0m \u001B[38;5;28;01melse\u001B[39;00m:\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/core/indexes.py:1425\u001B[0m, in \u001B[0;36mcreate_default_index_implicit\u001B[0;34m(dim_variable, all_variables)\u001B[0m\n\u001B[1;32m 1423\u001B[0m \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[1;32m 1424\u001B[0m dim_var \u001B[38;5;241m=\u001B[39m {name: dim_variable}\n\u001B[0;32m-> 1425\u001B[0m index \u001B[38;5;241m=\u001B[39m \u001B[43mPandasIndex\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mfrom_variables\u001B[49m\u001B[43m(\u001B[49m\u001B[43mdim_var\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43moptions\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43m{\u001B[49m\u001B[43m}\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 1426\u001B[0m index_vars \u001B[38;5;241m=\u001B[39m index\u001B[38;5;241m.\u001B[39mcreate_variables(dim_var)\n\u001B[1;32m 1428\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m index, index_vars\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/core/indexes.py:654\u001B[0m, in \u001B[0;36mPandasIndex.from_variables\u001B[0;34m(cls, variables, options)\u001B[0m\n\u001B[1;32m 651\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m level \u001B[38;5;129;01mis\u001B[39;00m \u001B[38;5;129;01mnot\u001B[39;00m \u001B[38;5;28;01mNone\u001B[39;00m:\n\u001B[1;32m 652\u001B[0m data \u001B[38;5;241m=\u001B[39m var\u001B[38;5;241m.\u001B[39m_data\u001B[38;5;241m.\u001B[39marray\u001B[38;5;241m.\u001B[39mget_level_values(level)\n\u001B[0;32m--> 654\u001B[0m obj \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43mcls\u001B[39;49m\u001B[43m(\u001B[49m\u001B[43mdata\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mdim\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mcoord_dtype\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mvar\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mdtype\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 655\u001B[0m \u001B[38;5;28;01massert\u001B[39;00m \u001B[38;5;129;01mnot\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(obj\u001B[38;5;241m.\u001B[39mindex, pd\u001B[38;5;241m.\u001B[39mMultiIndex)\n\u001B[1;32m 656\u001B[0m \u001B[38;5;66;03m# Rename safely\u001B[39;00m\n\u001B[1;32m 657\u001B[0m \u001B[38;5;66;03m# make a shallow copy: cheap and because the index name may be updated\u001B[39;00m\n\u001B[1;32m 658\u001B[0m \u001B[38;5;66;03m# here or in other constructors (cannot use pd.Index.rename as this\u001B[39;00m\n\u001B[1;32m 659\u001B[0m \u001B[38;5;66;03m# constructor is also called from PandasMultiIndex)\u001B[39;00m\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/core/indexes.py:589\u001B[0m, in \u001B[0;36mPandasIndex.__init__\u001B[0;34m(self, array, dim, coord_dtype, fastpath)\u001B[0m\n\u001B[1;32m 587\u001B[0m index \u001B[38;5;241m=\u001B[39m array\n\u001B[1;32m 588\u001B[0m \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[0;32m--> 589\u001B[0m index \u001B[38;5;241m=\u001B[39m \u001B[43msafe_cast_to_index\u001B[49m\u001B[43m(\u001B[49m\u001B[43marray\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 591\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m index\u001B[38;5;241m.\u001B[39mname \u001B[38;5;129;01mis\u001B[39;00m \u001B[38;5;28;01mNone\u001B[39;00m:\n\u001B[1;32m 592\u001B[0m \u001B[38;5;66;03m# make a shallow copy: cheap and because the index name may be updated\u001B[39;00m\n\u001B[1;32m 593\u001B[0m \u001B[38;5;66;03m# here or in other constructors (cannot use pd.Index.rename as this\u001B[39;00m\n\u001B[1;32m 594\u001B[0m \u001B[38;5;66;03m# constructor is also called from PandasMultiIndex)\u001B[39;00m\n\u001B[1;32m 595\u001B[0m index \u001B[38;5;241m=\u001B[39m index\u001B[38;5;241m.\u001B[39mcopy()\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/core/indexes.py:469\u001B[0m, in \u001B[0;36msafe_cast_to_index\u001B[0;34m(array)\u001B[0m\n\u001B[1;32m 459\u001B[0m emit_user_level_warning(\n\u001B[1;32m 460\u001B[0m (\n\u001B[1;32m 461\u001B[0m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124m`pandas.Index` does not support the `float16` dtype.\u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[0;32m (...)\u001B[0m\n\u001B[1;32m 465\u001B[0m category\u001B[38;5;241m=\u001B[39m\u001B[38;5;167;01mDeprecationWarning\u001B[39;00m,\n\u001B[1;32m 466\u001B[0m )\n\u001B[1;32m 467\u001B[0m kwargs[\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mdtype\u001B[39m\u001B[38;5;124m\"\u001B[39m] \u001B[38;5;241m=\u001B[39m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mfloat64\u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[0;32m--> 469\u001B[0m index \u001B[38;5;241m=\u001B[39m pd\u001B[38;5;241m.\u001B[39mIndex(\u001B[43mnp\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43masarray\u001B[49m\u001B[43m(\u001B[49m\u001B[43marray\u001B[49m\u001B[43m)\u001B[49m, \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39mkwargs)\n\u001B[1;32m 471\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m _maybe_cast_to_cftimeindex(index)\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/core/indexing.py:516\u001B[0m, in \u001B[0;36mExplicitlyIndexed.__array__\u001B[0;34m(self, dtype, copy)\u001B[0m\n\u001B[1;32m 514\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m np\u001B[38;5;241m.\u001B[39masarray(\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mget_duck_array(), dtype\u001B[38;5;241m=\u001B[39mdtype, copy\u001B[38;5;241m=\u001B[39mcopy)\n\u001B[1;32m 515\u001B[0m \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[0;32m--> 516\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m np\u001B[38;5;241m.\u001B[39masarray(\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mget_duck_array\u001B[49m\u001B[43m(\u001B[49m\u001B[43m)\u001B[49m, dtype\u001B[38;5;241m=\u001B[39mdtype)\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/coding/variables.py:81\u001B[0m, in \u001B[0;36m_ElementwiseFunctionArray.get_duck_array\u001B[0;34m(self)\u001B[0m\n\u001B[1;32m 80\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21mget_duck_array\u001B[39m(\u001B[38;5;28mself\u001B[39m):\n\u001B[0;32m---> 81\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mfunc(\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43marray\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mget_duck_array\u001B[49m\u001B[43m(\u001B[49m\u001B[43m)\u001B[49m)\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/core/indexing.py:657\u001B[0m, in \u001B[0;36mLazilyIndexedArray.get_duck_array\u001B[0;34m(self)\u001B[0m\n\u001B[1;32m 653\u001B[0m array \u001B[38;5;241m=\u001B[39m apply_indexer(\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39marray, \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mkey)\n\u001B[1;32m 654\u001B[0m \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[1;32m 655\u001B[0m \u001B[38;5;66;03m# If the array is not an ExplicitlyIndexedNDArrayMixin,\u001B[39;00m\n\u001B[1;32m 656\u001B[0m \u001B[38;5;66;03m# it may wrap a BackendArray so use its __getitem__\u001B[39;00m\n\u001B[0;32m--> 657\u001B[0m array \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43marray\u001B[49m\u001B[43m[\u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mkey\u001B[49m\u001B[43m]\u001B[49m\n\u001B[1;32m 659\u001B[0m \u001B[38;5;66;03m# self.array[self.key] is now a numpy array when\u001B[39;00m\n\u001B[1;32m 660\u001B[0m \u001B[38;5;66;03m# self.array is a BackendArray subclass\u001B[39;00m\n\u001B[1;32m 661\u001B[0m \u001B[38;5;66;03m# and self.key is BasicIndexer((slice(None, None, None),))\u001B[39;00m\n\u001B[1;32m 662\u001B[0m \u001B[38;5;66;03m# so we need the explicit check for ExplicitlyIndexed\u001B[39;00m\n\u001B[1;32m 663\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(array, ExplicitlyIndexed):\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/backends/zarr.py:226\u001B[0m, in \u001B[0;36mZarrArrayWrapper.__getitem__\u001B[0;34m(self, key)\u001B[0m\n\u001B[1;32m 224\u001B[0m \u001B[38;5;28;01melif\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(key, indexing\u001B[38;5;241m.\u001B[39mOuterIndexer):\n\u001B[1;32m 225\u001B[0m method \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_oindex\n\u001B[0;32m--> 226\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[43mindexing\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mexplicit_indexing_adapter\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m 227\u001B[0m \u001B[43m \u001B[49m\u001B[43mkey\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43marray\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mshape\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mindexing\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mIndexingSupport\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mVECTORIZED\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mmethod\u001B[49m\n\u001B[1;32m 228\u001B[0m \u001B[43m\u001B[49m\u001B[43m)\u001B[49m\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/core/indexing.py:1018\u001B[0m, in \u001B[0;36mexplicit_indexing_adapter\u001B[0;34m(key, shape, indexing_support, raw_indexing_method)\u001B[0m\n\u001B[1;32m 996\u001B[0m \u001B[38;5;250m\u001B[39m\u001B[38;5;124;03m\"\"\"Support explicit indexing by delegating to a raw indexing method.\u001B[39;00m\n\u001B[1;32m 997\u001B[0m \n\u001B[1;32m 998\u001B[0m \u001B[38;5;124;03mOuter and/or vectorized indexers are supported by indexing a second time\u001B[39;00m\n\u001B[0;32m (...)\u001B[0m\n\u001B[1;32m 1015\u001B[0m \u001B[38;5;124;03mIndexing result, in the form of a duck numpy-array.\u001B[39;00m\n\u001B[1;32m 1016\u001B[0m \u001B[38;5;124;03m\"\"\"\u001B[39;00m\n\u001B[1;32m 1017\u001B[0m raw_key, numpy_indices \u001B[38;5;241m=\u001B[39m decompose_indexer(key, shape, indexing_support)\n\u001B[0;32m-> 1018\u001B[0m result \u001B[38;5;241m=\u001B[39m \u001B[43mraw_indexing_method\u001B[49m\u001B[43m(\u001B[49m\u001B[43mraw_key\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mtuple\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 1019\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m numpy_indices\u001B[38;5;241m.\u001B[39mtuple:\n\u001B[1;32m 1020\u001B[0m \u001B[38;5;66;03m# index the loaded np.ndarray\u001B[39;00m\n\u001B[1;32m 1021\u001B[0m indexable \u001B[38;5;241m=\u001B[39m NumpyIndexingAdapter(result)\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/xarray/backends/zarr.py:216\u001B[0m, in \u001B[0;36mZarrArrayWrapper._getitem\u001B[0;34m(self, key)\u001B[0m\n\u001B[1;32m 215\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21m_getitem\u001B[39m(\u001B[38;5;28mself\u001B[39m, key):\n\u001B[0;32m--> 216\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_array\u001B[49m\u001B[43m[\u001B[49m\u001B[43mkey\u001B[49m\u001B[43m]\u001B[49m\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/zarr/core.py:797\u001B[0m, in \u001B[0;36mArray.__getitem__\u001B[0;34m(self, selection)\u001B[0m\n\u001B[1;32m 795\u001B[0m result \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mget_orthogonal_selection(pure_selection, fields\u001B[38;5;241m=\u001B[39mfields)\n\u001B[1;32m 796\u001B[0m \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[0;32m--> 797\u001B[0m result \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mget_basic_selection\u001B[49m\u001B[43m(\u001B[49m\u001B[43mpure_selection\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mfields\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mfields\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 798\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m result\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/zarr/core.py:923\u001B[0m, in \u001B[0;36mArray.get_basic_selection\u001B[0;34m(self, selection, out, fields)\u001B[0m\n\u001B[1;32m 921\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_get_basic_selection_zd(selection\u001B[38;5;241m=\u001B[39mselection, out\u001B[38;5;241m=\u001B[39mout, fields\u001B[38;5;241m=\u001B[39mfields)\n\u001B[1;32m 922\u001B[0m \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[0;32m--> 923\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_get_basic_selection_nd\u001B[49m\u001B[43m(\u001B[49m\u001B[43mselection\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mselection\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mout\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mout\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mfields\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mfields\u001B[49m\u001B[43m)\u001B[49m\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/zarr/core.py:965\u001B[0m, in \u001B[0;36mArray._get_basic_selection_nd\u001B[0;34m(self, selection, out, fields)\u001B[0m\n\u001B[1;32m 959\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21m_get_basic_selection_nd\u001B[39m(\u001B[38;5;28mself\u001B[39m, selection, out\u001B[38;5;241m=\u001B[39m\u001B[38;5;28;01mNone\u001B[39;00m, fields\u001B[38;5;241m=\u001B[39m\u001B[38;5;28;01mNone\u001B[39;00m):\n\u001B[1;32m 960\u001B[0m \u001B[38;5;66;03m# implementation of basic selection for array with at least one dimension\u001B[39;00m\n\u001B[1;32m 961\u001B[0m \n\u001B[1;32m 962\u001B[0m \u001B[38;5;66;03m# setup indexer\u001B[39;00m\n\u001B[1;32m 963\u001B[0m indexer \u001B[38;5;241m=\u001B[39m BasicIndexer(selection, \u001B[38;5;28mself\u001B[39m)\n\u001B[0;32m--> 965\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_get_selection\u001B[49m\u001B[43m(\u001B[49m\u001B[43mindexer\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mindexer\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mout\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mout\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mfields\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mfields\u001B[49m\u001B[43m)\u001B[49m\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/zarr/core.py:1340\u001B[0m, in \u001B[0;36mArray._get_selection\u001B[0;34m(self, indexer, out, fields)\u001B[0m\n\u001B[1;32m 1337\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m math\u001B[38;5;241m.\u001B[39mprod(out_shape) \u001B[38;5;241m>\u001B[39m \u001B[38;5;241m0\u001B[39m:\n\u001B[1;32m 1338\u001B[0m \u001B[38;5;66;03m# allow storage to get multiple items at once\u001B[39;00m\n\u001B[1;32m 1339\u001B[0m lchunk_coords, lchunk_selection, lout_selection \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mzip\u001B[39m(\u001B[38;5;241m*\u001B[39mindexer)\n\u001B[0;32m-> 1340\u001B[0m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_chunk_getitems\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m 1341\u001B[0m \u001B[43m \u001B[49m\u001B[43mlchunk_coords\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 1342\u001B[0m \u001B[43m \u001B[49m\u001B[43mlchunk_selection\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 1343\u001B[0m \u001B[43m \u001B[49m\u001B[43mout\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 1344\u001B[0m \u001B[43m \u001B[49m\u001B[43mlout_selection\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 1345\u001B[0m \u001B[43m \u001B[49m\u001B[43mdrop_axes\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mindexer\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mdrop_axes\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 1346\u001B[0m \u001B[43m \u001B[49m\u001B[43mfields\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mfields\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 1347\u001B[0m \u001B[43m \u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 1348\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m out\u001B[38;5;241m.\u001B[39mshape:\n\u001B[1;32m 1349\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m out\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/zarr/core.py:2181\u001B[0m, in \u001B[0;36mArray._chunk_getitems\u001B[0;34m(self, lchunk_coords, lchunk_selection, out, lout_selection, drop_axes, fields)\u001B[0m\n\u001B[1;32m 2179\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;129;01mnot\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_meta_array, np\u001B[38;5;241m.\u001B[39mndarray):\n\u001B[1;32m 2180\u001B[0m contexts \u001B[38;5;241m=\u001B[39m ConstantMap(ckeys, constant\u001B[38;5;241m=\u001B[39mContext(meta_array\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_meta_array))\n\u001B[0;32m-> 2181\u001B[0m cdatas \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mchunk_store\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mgetitems\u001B[49m\u001B[43m(\u001B[49m\u001B[43mckeys\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mcontexts\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mcontexts\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 2183\u001B[0m \u001B[38;5;28;01mfor\u001B[39;00m ckey, chunk_select, out_select \u001B[38;5;129;01min\u001B[39;00m \u001B[38;5;28mzip\u001B[39m(ckeys, lchunk_selection, lout_selection):\n\u001B[1;32m 2184\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m ckey \u001B[38;5;129;01min\u001B[39;00m cdatas:\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/zarr/storage.py:1426\u001B[0m, in \u001B[0;36mFSStore.getitems\u001B[0;34m(self, keys, contexts)\u001B[0m\n\u001B[1;32m 1422\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21mgetitems\u001B[39m(\n\u001B[1;32m 1423\u001B[0m \u001B[38;5;28mself\u001B[39m, keys: Sequence[\u001B[38;5;28mstr\u001B[39m], \u001B[38;5;241m*\u001B[39m, contexts: Mapping[\u001B[38;5;28mstr\u001B[39m, Context]\n\u001B[1;32m 1424\u001B[0m ) \u001B[38;5;241m-\u001B[39m\u001B[38;5;241m>\u001B[39m Mapping[\u001B[38;5;28mstr\u001B[39m, Any]:\n\u001B[1;32m 1425\u001B[0m keys_transformed \u001B[38;5;241m=\u001B[39m {\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_normalize_key(key): key \u001B[38;5;28;01mfor\u001B[39;00m key \u001B[38;5;129;01min\u001B[39;00m keys}\n\u001B[0;32m-> 1426\u001B[0m results_transformed \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mmap\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mgetitems\u001B[49m\u001B[43m(\u001B[49m\u001B[38;5;28;43mlist\u001B[39;49m\u001B[43m(\u001B[49m\u001B[43mkeys_transformed\u001B[49m\u001B[43m)\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mon_error\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;124;43m\"\u001B[39;49m\u001B[38;5;124;43mreturn\u001B[39;49m\u001B[38;5;124;43m\"\u001B[39;49m\u001B[43m)\u001B[49m\n\u001B[1;32m 1427\u001B[0m results \u001B[38;5;241m=\u001B[39m {}\n\u001B[1;32m 1428\u001B[0m \u001B[38;5;28;01mfor\u001B[39;00m k, v \u001B[38;5;129;01min\u001B[39;00m results_transformed\u001B[38;5;241m.\u001B[39mitems():\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/fsspec/mapping.py:105\u001B[0m, in \u001B[0;36mFSMap.getitems\u001B[0;34m(self, keys, on_error)\u001B[0m\n\u001B[1;32m 103\u001B[0m oe \u001B[38;5;241m=\u001B[39m on_error \u001B[38;5;28;01mif\u001B[39;00m on_error \u001B[38;5;241m==\u001B[39m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mraise\u001B[39m\u001B[38;5;124m\"\u001B[39m \u001B[38;5;28;01melse\u001B[39;00m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mreturn\u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[1;32m 104\u001B[0m \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[0;32m--> 105\u001B[0m out \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mfs\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mcat\u001B[49m\u001B[43m(\u001B[49m\u001B[43mkeys2\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mon_error\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43moe\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 106\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(out, \u001B[38;5;28mbytes\u001B[39m):\n\u001B[1;32m 107\u001B[0m out \u001B[38;5;241m=\u001B[39m {keys2[\u001B[38;5;241m0\u001B[39m]: out}\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/adlfs/spec.py:1506\u001B[0m, in \u001B[0;36mAzureBlobFileSystem.cat\u001B[0;34m(self, path, recursive, on_error, **kwargs)\u001B[0m\n\u001B[1;32m 1504\u001B[0m \u001B[38;5;28;01mfor\u001B[39;00m path \u001B[38;5;129;01min\u001B[39;00m paths:\n\u001B[1;32m 1505\u001B[0m \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[0;32m-> 1506\u001B[0m out[path] \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mcat_file\u001B[49m\u001B[43m(\u001B[49m\u001B[43mpath\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mkwargs\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 1507\u001B[0m \u001B[38;5;28;01mexcept\u001B[39;00m \u001B[38;5;167;01mException\u001B[39;00m \u001B[38;5;28;01mas\u001B[39;00m e:\n\u001B[1;32m 1508\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m on_error \u001B[38;5;241m==\u001B[39m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mraise\u001B[39m\u001B[38;5;124m\"\u001B[39m:\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/fsspec/asyn.py:118\u001B[0m, in \u001B[0;36msync_wrapper..wrapper\u001B[0;34m(*args, **kwargs)\u001B[0m\n\u001B[1;32m 115\u001B[0m \u001B[38;5;129m@functools\u001B[39m\u001B[38;5;241m.\u001B[39mwraps(func)\n\u001B[1;32m 116\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21mwrapper\u001B[39m(\u001B[38;5;241m*\u001B[39margs, \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39mkwargs):\n\u001B[1;32m 117\u001B[0m \u001B[38;5;28mself\u001B[39m \u001B[38;5;241m=\u001B[39m obj \u001B[38;5;129;01mor\u001B[39;00m args[\u001B[38;5;241m0\u001B[39m]\n\u001B[0;32m--> 118\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[43msync\u001B[49m\u001B[43m(\u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mloop\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mfunc\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43margs\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mkwargs\u001B[49m\u001B[43m)\u001B[49m\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/fsspec/asyn.py:91\u001B[0m, in \u001B[0;36msync\u001B[0;34m(loop, func, timeout, *args, **kwargs)\u001B[0m\n\u001B[1;32m 88\u001B[0m asyncio\u001B[38;5;241m.\u001B[39mrun_coroutine_threadsafe(_runner(event, coro, result, timeout), loop)\n\u001B[1;32m 89\u001B[0m \u001B[38;5;28;01mwhile\u001B[39;00m \u001B[38;5;28;01mTrue\u001B[39;00m:\n\u001B[1;32m 90\u001B[0m \u001B[38;5;66;03m# this loops allows thread to get interrupted\u001B[39;00m\n\u001B[0;32m---> 91\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[43mevent\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mwait\u001B[49m\u001B[43m(\u001B[49m\u001B[38;5;241;43m1\u001B[39;49m\u001B[43m)\u001B[49m:\n\u001B[1;32m 92\u001B[0m \u001B[38;5;28;01mbreak\u001B[39;00m\n\u001B[1;32m 93\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m timeout \u001B[38;5;129;01mis\u001B[39;00m \u001B[38;5;129;01mnot\u001B[39;00m \u001B[38;5;28;01mNone\u001B[39;00m:\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/threading.py:629\u001B[0m, in \u001B[0;36mEvent.wait\u001B[0;34m(self, timeout)\u001B[0m\n\u001B[1;32m 627\u001B[0m signaled \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_flag\n\u001B[1;32m 628\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;129;01mnot\u001B[39;00m signaled:\n\u001B[0;32m--> 629\u001B[0m signaled \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_cond\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mwait\u001B[49m\u001B[43m(\u001B[49m\u001B[43mtimeout\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 630\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m signaled\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/threading.py:331\u001B[0m, in \u001B[0;36mCondition.wait\u001B[0;34m(self, timeout)\u001B[0m\n\u001B[1;32m 329\u001B[0m \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[1;32m 330\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m timeout \u001B[38;5;241m>\u001B[39m \u001B[38;5;241m0\u001B[39m:\n\u001B[0;32m--> 331\u001B[0m gotit \u001B[38;5;241m=\u001B[39m \u001B[43mwaiter\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43macquire\u001B[49m\u001B[43m(\u001B[49m\u001B[38;5;28;43;01mTrue\u001B[39;49;00m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mtimeout\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 332\u001B[0m \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[1;32m 333\u001B[0m gotit \u001B[38;5;241m=\u001B[39m waiter\u001B[38;5;241m.\u001B[39macquire(\u001B[38;5;28;01mFalse\u001B[39;00m)\n", "\u001B[0;31mKeyboardInterrupt\u001B[0m: " ] } ], - "execution_count": 52 + "execution_count": 4 }, { "metadata": {}, @@ -527,8 +202,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-07T09:41:43.642027Z", - "start_time": "2025-01-07T09:41:43.455377Z" + "end_time": "2025-01-08T16:47:24.877431Z", + "start_time": "2025-01-08T16:47:24.641918Z" } }, "cell_type": "code", @@ -557,18 +232,18 @@ "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_51565/4112377517.py:16: DtypeWarning: Columns (58,59,105,127,136,142,149,150,258,285,296,319,344,345,360,393,394,427,428,437,449,450,452,453,461,462,478,479,489,490,492,493,494,497,498,499,500,501,502,503,572,580,585,586,587,588,591,592,593,594,607,608,609,610,619,620,621,622,626,634,872,887,967,978,1066,1510) have mixed types. Specify dtype option on import or set low_memory=False.\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/4112377517.py:16: DtypeWarning: Columns (58,59,105,127,136,142,149,150,258,285,296,319,344,345,360,393,394,427,428,437,449,450,452,453,461,462,478,479,489,490,492,493,494,497,498,499,500,501,502,503,572,580,585,586,587,588,591,592,593,594,607,608,609,610,619,620,621,622,626,634,872,887,967,978,1066,1510) have mixed types. Specify dtype option on import or set low_memory=False.\n", " facilities_with_lat_long = pd.read_csv(\n" ] } ], - "execution_count": 2 + "execution_count": 5 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-07T09:41:45.213570Z", - "start_time": "2025-01-07T09:41:45.207554Z" + "end_time": "2025-01-08T16:47:26.312607Z", + "start_time": "2025-01-08T16:47:26.305093Z" } }, "cell_type": "code", @@ -644,152 +319,137 @@ ], "id": "a9a92aa8bbb6b45a", "outputs": [], - "execution_count": 3 + "execution_count": 6 }, { "metadata": { - "jupyter": { - "is_executing": true - }, "ExecuteTime": { - "start_time": "2025-01-07T10:13:26.237514Z" + "end_time": "2025-01-08T17:04:51.283175Z", + "start_time": "2025-01-08T16:47:27.076767Z" } }, "cell_type": "code", "source": [ "base_dir = \"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/\"\n", - "nc_file_directory = os.path.join(base_dir, 'nc_files')\n", - "# NB these are daily \n", - "scenarios = [\"ssp245\", \"ssp585\"] \n", + "scenarios = [\"ssp245\", \"ssp585\"]\n", + "window_size = 5\n", "\n", "data_by_model_and_grid = {}\n", + "\n", + "def calculate_cumulative_metrics(precip_data, window_size):\n", + " \"\"\"\n", + " Calculate monthly totals and 5-day maximums for precipitation data.\n", + " \"\"\"\n", + " # Monthly total\n", + " monthly_total = np.sum(precip_data)\n", + "\n", + " # 5-day maximum using rolling window\n", + " if len(precip_data) >= window_size:\n", + " rolling_sums = np.cumsum(precip_data)\n", + " rolling_sums[window_size:] -= rolling_sums[:-window_size]\n", + " max_5_day = np.max(rolling_sums[window_size - 1:])\n", + " else:\n", + " max_5_day = np.sum(precip_data) # Handle case where data is shorter than window size\n", + "\n", + " return monthly_total, max_5_day\n", "for scenario in scenarios:\n", - " print(scenario)\n", + " print(f\"Processing scenario: {scenario}\")\n", " scenario_directory = os.path.join(base_dir, scenario)\n", - "\n", - " grid_centroids = {}\n", - " cumulative_sum_by_models = {}\n", " file_path_downscaled = f\"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/\"\n", " output_file = f\"CIL_combined_{scenario}_2025_2070.nc\"\n", " file_pattern = os.path.join(file_path_downscaled, \"CIL_subset_ssp245_*.nc\")\n", " data_all_models = xr.open_mfdataset(file_pattern, combine='nested', concat_dim=\"time\")\n", " data_all_models.compute()\n", + " files = sorted(Path(file_path_downscaled).glob(f\"CIL_subset_{scenario}_*.nc\"))\n", "\n", - " data_all_models.to_netcdf(output_file)\n", - " #data_all_models = xr.open_dataset(file_path_downscaled)\n", - " \n", - " ## Get models of interest - min, med, max\n", - " # Assuming 'pr' is the variable representing precipitation in the dataset\n", - " pr_aggregated = data_all_models.mean(dim=[\"lat\", \"lon\", \"time\"], skipna=True) # Work with the 'pr' DataArray \n", - "\n", - " # Find the model with the lowest value\n", + " pr_aggregated = data_all_models.mean(dim=[\"lat\", \"lon\", \"time\"], skipna=True)\n", " min_model_object = pr_aggregated['pr'].idxmin(dim=\"model\")\n", " min_model = min_model_object.values.item()\n", - " # Find the model with the median value\n", " sorted_models = pr_aggregated.sortby(\"model\")\n", " n_models = len(pr_aggregated.model)\n", " median_index = n_models // 2\n", " median_model_object = sorted_models[\"model\"][median_index]\n", - " print(median_model_object)\n", " median_model = median_model_object.values.item()\n", - " print(median_model)\n", - " # Find the model with the highest value\n", " max_model_object = pr_aggregated['pr'].idxmax(dim=\"model\")\n", " max_model = max_model_object.values.item()\n", "\n", " models_of_interest = [min_model, median_model, max_model]\n", - " #models_of_interest = [median_model]\n", - "\n", " print(\"Models of interest\", models_of_interest)\n", - " # see which facilities have reporting data and data on latitude and longitude\n", - " weather_df_lowest_window = pd.DataFrame()\n", - " weather_df_median_window = pd.DataFrame()\n", - " weather_df_highest_window = pd.DataFrame()\n", "\n", - " weather_df_lowest_monthly = pd.DataFrame()\n", - " weather_df_median_monthly = pd.DataFrame()\n", - " weather_df_highest_monthly = pd.DataFrame()\n", - " for model in models_of_interest:\n", - " data_per_model = data_all_models.sel(model=model)\n", - " pr_data = data_per_model.variables['pr'][:] # in kg m-2 s-1 = mm s-1 x 86400 to get to day\n", - " lat_data = data_per_model.variables['lat'][:]\n", - " lon_data = data_per_model.variables['lon'][:]\n", - " lon_grid, lat_grid = np.meshgrid(lon_data, lat_data)\n", - " centroids = np.column_stack((lat_grid.ravel(), lon_grid.ravel()))\n", + " # Initialize cumulative storage for models of interest\n", + " cumulative_weather_dfs = {\n", + " model: {\"monthly\": pd.DataFrame(), \"window\": pd.DataFrame()}\n", + " for model in models_of_interest\n", + " }\n", "\n", - " # Store centroids\n", - " grid_centroids[model] = centroids\n", - " grid_dictionary = {}\n", - " grid = 0\n", - " for i in lat_data:\n", - " for j in lon_data:\n", - " precip_data_for_grid = data_per_model.sel(lat=i, lon=j, method=\"nearest\") # across all time points\n", - " grid_dictionary[grid] = precip_data_for_grid.pr.data\n", - " grid += 1\n", - " data_by_model_and_grid[model] = grid_dictionary\n", + " for file_path in files:\n", + " print(f\"Processing file: {file_path.name}\")\n", + " data_all_models = xr.open_dataset(file_path)\n", "\n", - " for reporting_facility in reporting_data.columns:\n", - " print(reporting_facility)\n", - " grid_precipitation_for_facility = {}\n", - " match_name, lat_for_facility, long_for_facility = get_facility_lat_long(reporting_facility, facilities_with_lat_long)\n", - " if not np.isnan(long_for_facility) and not np.isnan(lat_for_facility):\n", - " facility_location = np.array([lat_for_facility, long_for_facility])\n", - " kd_trees_by_model = {}\n", + " for model in models_of_interest:\n", + " if model not in data_all_models[\"model\"].values:\n", + " print(f\"Model {model} not found in file {file_path.name}, skipping.\")\n", + " continue\n", "\n", - " # Loop over each model of interest\n", - " for model in models_of_interest:\n", - " centroids = grid_centroids[model]\n", - " kd_tree = KDTree(centroids)\n", - " distance, closest_grid_index = kd_tree.query(facility_location)\n", - " grid_precipitation_for_facility[model] = data_by_model_and_grid[model][closest_grid_index]\n", + " print(f\"Processing model: {model}\")\n", + " data_per_model = data_all_models.sel(model=model)\n", "\n", - " cumulative_sum_monthly = []\n", - " cumulative_sum_window = []\n", + " # Prepare grid data structure\n", + " lat_data = data_per_model.variables['lat'][:]\n", + " lon_data = data_per_model.variables['lon'][:]\n", + " lon_grid, lat_grid = np.meshgrid(lon_data, lat_data)\n", + " centroids = np.column_stack((lat_grid.ravel(), lon_grid.ravel()))\n", "\n", - " begin_day = 0\n", - " # Calculate monthly cumulative sums\n", - " for month_idx, month_length in enumerate(month_lengths):\n", - " days_for_grid_monthly = grid_precipitation_for_facility[model][begin_day:begin_day + month_length]\n", - " cumulative_sums_monthly = [\n", - " sum(days_for_grid_monthly)\n", - " ]\n", - " max_cumulative_sums_monthly = max(cumulative_sums_monthly)\n", - " cumulative_sum_monthly.append(max_cumulative_sums_monthly)\n", - " begin_day += month_length\n", + " grid_precip_map = {}\n", "\n", - " begin_day = 0\n", - " # Calculate windowed cumulative sums\n", - " for month_idx, month_length in enumerate(month_lengths):\n", - " days_for_grid_window = grid_precipitation_for_facility[model][begin_day:begin_day + month_length]\n", + " for year in np.unique(data_per_model['time.year']):\n", + " for month in range(1, 13): # 1 to 12 for each month\n", + " print(f\"Processing year {year}, month {month}\")\n", "\n", - " cumulative_sums_window = [\n", - " sum(days_for_grid_window[day:day + window_size])\n", - " for day in range(month_length - window_size + 1)\n", - " ]\n", + " # Extract precipitation data for this month of this year\n", + " month_data = data_per_model.sel(\n", + " time=data_per_model.time.dt.year == year\n", + " ).sel(time=data_per_model.time.dt.month == month)\n", "\n", - " max_cumulative_sums_window = max(cumulative_sums_window)\n", - " cumulative_sum_window.append(max_cumulative_sums_window)\n", - " begin_day += month_length\n", + " # Skip if no data\n", + " if month_data.time.size == 0:\n", + " continue\n", "\n", - " # Assign the calculated data to the correct dataframe based on the model\n", - " if model == min_model:\n", - " weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly\n", - " weather_df_lowest_window[reporting_facility] = cumulative_sum_window\n", - " elif model == median_model:\n", - " weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly\n", - " weather_df_median_window[reporting_facility] = cumulative_sum_window\n", - " elif model == max_model:\n", - " weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly\n", - " weather_df_highest_window[reporting_facility] = cumulative_sum_window\n", + " # Get daily precipitation values for grids\n", + " for grid, (i, j) in enumerate(np.ndindex(len(lat_data), len(lon_data))):\n", + " precip_data_for_grid = month_data.isel(lat=i, lon=j).pr.values\n", "\n", - " if ANC:\n", - " weather_df_lowest_window.to_csv(Path(scenario_directory) / f\"lowest_model_daily_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{scenario}.csv\", index=False)\n", - " weather_df_median_window.to_csv(Path(scenario_directory) / f\"median_model_daily_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{scenario}.csv\", index=False)\n", - " weather_df_highest_window.to_csv(Path(scenario_directory) / f\"highest_model_daily_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{scenario}.csv\", index=False)\n", + " if grid not in grid_precip_map:\n", + " grid_precip_map[grid] = {\"monthly\": {}, \"window\": {}}\n", "\n", - " weather_df_lowest_monthly.to_csv(Path(scenario_directory) / f\"lowest_model_monthly_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{scenario}.csv\", index=False)\n", - " weather_df_median_monthly.to_csv(Path(scenario_directory) / f\"median_model_monthly_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{scenario}.csv\", index=False)\n", - " weather_df_highest_monthly.to_csv(Path(scenario_directory) / f\"highest_model_monthly_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{scenario}.csv\", index=False)\n" + " # Calculate metrics\n", + " monthly, window = calculate_cumulative_metrics(precip_data_for_grid, window_size)\n", + "\n", + " grid_precip_map[grid][\"monthly\"][(year, month)] = monthly\n", + " grid_precip_map[grid][\"window\"][(year, month)] = window\n", + "\n", + " # Map facilities to grids and assign metrics\n", + " kd_tree = KDTree(centroids)\n", + "\n", + " for reporting_facility in reporting_data.columns:\n", + " match_name, lat, lon = get_facility_lat_long(reporting_facility, facilities_with_lat_long)\n", + " if not np.isnan(lat) and not np.isnan(lon):\n", + " facility_location = np.array([[lat, lon]])\n", + " dist, closest_grid_index = kd_tree.query(facility_location)\n", + " closest_grid_index = closest_grid_index[0]\n", + "\n", + " for (year, month), metrics in grid_precip_map[closest_grid_index][\"monthly\"].items():\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + " for (year, month), metrics in grid_precip_map[closest_grid_index][\"window\"].items():\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "\n", + " # Save cumulative results\n", + " for model, weather_dfs in cumulative_weather_dfs.items():\n", + " for metric_type, df in weather_dfs.items():\n", + " output_file = Path(scenario_directory) / f\"{model}_{metric_type}_prediction_weather_by_facility.csv\"\n", + " df.to_csv(output_file, index=True)\n", + " print(f\"Saved {metric_type} data to {output_file}\")\n", + "\n" ], "id": "8a6e7f822720bd39", "outputs": [ @@ -797,19 +457,19449 @@ "name": "stdout", "output_type": "stream", "text": [ - "ssp245\n", - " Size: 64B\n", - "array('GFDL-CM4', dtype=' Date: Wed, 8 Jan 2025 21:46:33 +0000 Subject: [PATCH 160/291] Changed naming --- .../CIL_CMIP6_downscaling.ipynb | 10054 +--------------- 1 file changed, 640 insertions(+), 9414 deletions(-) diff --git a/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb b/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb index d5702c348f..22a4f5b906 100644 --- a/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb +++ b/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb @@ -49,6 +49,630 @@ "outputs": [], "execution_count": 1 }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-08T19:08:50.482403Z", + "start_time": "2025-01-08T19:08:46.931480Z" + } + }, + "cell_type": "code", + "source": [ + "catalog = pystac_client.Client.open(\n", + " \"https://planetarycomputer.microsoft.com/api/stac/v1/\",\n", + " modifier=planetary_computer.sign_inplace,\n", + ")\n", + "collection = catalog.get_collection(\"cil-gdpcir-cc-by\")\n", + "item = collection.get_item(\"cil-gdpcir-NUIST-NESM3-ssp585-r1i1p1f1-day\")\n", + "item.assets\n", + "search = catalog.search(\n", + " collections=[\"cil-gdpcir-cc-by\"],\n", + " query={\"cmip6:source_id\": {\"eq\": \"GFDL-CM4\"}, \"cmip6:experiment_id\": {\"eq\": \"ssp245\"}},\n", + ")\n", + "items = search.get_all_items()\n", + "len(items)\n", + "\n", + "asset = item.assets[\"pr\"]\n", + "item = items[0]\n", + "item\n", + "ds = xr.open_dataset(asset.href, **asset.extra_fields[\"xarray:open_kwargs\"])\n", + "ds" + ], + "id": "7b534ded8a9cd532", + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/pystac_client/item_search.py:903: FutureWarning: get_all_items() is deprecated, use item_collection() instead.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "text/plain": [ + " Size: 260GB\n", + "Dimensions: (lat: 720, lon: 1440, time: 31390)\n", + "Coordinates:\n", + " * lat (lat) float64 6kB -89.88 -89.62 -89.38 -89.12 ... 89.38 89.62 89.88\n", + " * lon (lon) float64 12kB -179.9 -179.6 -179.4 ... 179.4 179.6 179.9\n", + " * time (time) object 251kB 2015-01-01 12:00:00 ... 2100-12-31 12:00:00\n", + "Data variables:\n", + " pr (time, lat, lon) float64 260GB dask.array\n", + "Attributes: (12/47)\n", + " Conventions: CF-1.7 CMIP-6.2\n", + " activity_id: ScenarioMIP\n", + " contact: climatesci@rhg.com\n", + " creation_date: 2019-08-11T09:53:50Z\n", + " data_specs_version: 01.00.30\n", + " dc6_bias_correction_method: Quantile Delta Method (QDM)\n", + " ... ...\n", + " sub_experiment_id: none\n", + " table_id: day\n", + " tracking_id: hdl:21.14100/ed432434-922e-4cea-8400-c32159...\n", + " variable_id: pr\n", + " variant_label: r1i1p1f1\n", + " version_id: v20190811" + ], + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 260GB\n",
+       "Dimensions:  (lat: 720, lon: 1440, time: 31390)\n",
+       "Coordinates:\n",
+       "  * lat      (lat) float64 6kB -89.88 -89.62 -89.38 -89.12 ... 89.38 89.62 89.88\n",
+       "  * lon      (lon) float64 12kB -179.9 -179.6 -179.4 ... 179.4 179.6 179.9\n",
+       "  * time     (time) object 251kB 2015-01-01 12:00:00 ... 2100-12-31 12:00:00\n",
+       "Data variables:\n",
+       "    pr       (time, lat, lon) float64 260GB dask.array<chunksize=(365, 360, 360), meta=np.ndarray>\n",
+       "Attributes: (12/47)\n",
+       "    Conventions:                  CF-1.7 CMIP-6.2\n",
+       "    activity_id:                  ScenarioMIP\n",
+       "    contact:                      climatesci@rhg.com\n",
+       "    creation_date:                2019-08-11T09:53:50Z\n",
+       "    data_specs_version:           01.00.30\n",
+       "    dc6_bias_correction_method:   Quantile Delta Method (QDM)\n",
+       "    ...                           ...\n",
+       "    sub_experiment_id:            none\n",
+       "    table_id:                     day\n",
+       "    tracking_id:                  hdl:21.14100/ed432434-922e-4cea-8400-c32159...\n",
+       "    variable_id:                  pr\n",
+       "    variant_label:                r1i1p1f1\n",
+       "    version_id:                   v20190811
" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 10 + }, { "metadata": {}, "cell_type": "markdown", @@ -323,9 +947,11 @@ }, { "metadata": { + "jupyter": { + "is_executing": true + }, "ExecuteTime": { - "end_time": "2025-01-08T17:04:51.283175Z", - "start_time": "2025-01-08T16:47:27.076767Z" + "start_time": "2025-01-08T21:35:55.872116Z" } }, "cell_type": "code", @@ -442,13 +1068,20 @@ " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", " for (year, month), metrics in grid_precip_map[closest_grid_index][\"window\"].items():\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + " model_categories = {\n", + " min_model: \"lowest\",\n", + " median_model: \"median\",\n", + " max_model: \"highest\"\n", + "}\n", "\n", - " # Save cumulative results\n", + "# Save cumulative results\n", " for model, weather_dfs in cumulative_weather_dfs.items():\n", + " category = model_categories[model] # Get the category for the model\n", " for metric_type, df in weather_dfs.items():\n", - " output_file = Path(scenario_directory) / f\"{model}_{metric_type}_prediction_weather_by_facility.csv\"\n", + " # Use the category in the output file name\n", + " output_file = Path(scenario_directory) / f\"{category}_{metric_type}_prediction_weather_by_facility.csv\"\n", " df.to_csv(output_file, index=True)\n", - " print(f\"Saved {metric_type} data to {output_file}\")\n", + " print(f\"Saved {metric_type} data for {category} model to {output_file}\")\n", "\n" ], "id": "8a6e7f822720bd39", @@ -457,9418 +1090,11 @@ "name": "stdout", "output_type": "stream", "text": [ - "Processing scenario: ssp245\n", - "Models of interest ['HadGEM3-GC31-LL', 'GFDL-CM4', 'INM-CM5-0']\n", - "Processing file: CIL_subset_ssp245_2025.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2025, month 1\n", - "Processing year 2025, month 2\n", - "Processing year 2025, month 3\n", - "Processing year 2025, month 4\n", - "Processing year 2025, month 5\n", - "Processing year 2025, month 6\n", - "Processing year 2025, month 7\n", - "Processing year 2025, month 8\n", - "Processing year 2025, month 9\n", - "Processing year 2025, month 10\n", - "Processing year 2025, month 11\n", - "Processing year 2025, month 12\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Processing model: GFDL-CM4\n", - "Processing year 2025, month 1\n", - "Processing year 2025, month 2\n", - "Processing year 2025, month 3\n", - "Processing year 2025, month 4\n", - "Processing year 2025, month 5\n", - "Processing year 2025, month 6\n", - "Processing year 2025, month 7\n", - "Processing year 2025, month 8\n", - "Processing year 2025, month 9\n", - "Processing year 2025, month 10\n", - "Processing year 2025, month 11\n", - "Processing year 2025, month 12\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Processing model: INM-CM5-0\n", - "Processing year 2025, month 1\n", - "Processing year 2025, month 2\n", - "Processing year 2025, month 3\n", - "Processing year 2025, month 4\n", - "Processing year 2025, month 5\n", - "Processing year 2025, month 6\n", - "Processing year 2025, month 7\n", - "Processing year 2025, month 8\n", - "Processing year 2025, month 9\n", - "Processing year 2025, month 10\n", - "Processing year 2025, month 11\n", - "Processing year 2025, month 12\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Processing file: CIL_subset_ssp245_2026.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2026, month 1\n", - "Processing year 2026, month 2\n", - "Processing year 2026, month 3\n", - "Processing year 2026, month 4\n", - "Processing year 2026, month 5\n", - "Processing year 2026, month 6\n", - "Processing year 2026, month 7\n", - "Processing year 2026, month 8\n", - "Processing year 2026, month 9\n", - "Processing year 2026, month 10\n", - "Processing year 2026, month 11\n", - "Processing year 2026, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2026, month 1\n", - "Processing year 2026, month 2\n", - "Processing year 2026, month 3\n", - "Processing year 2026, month 4\n", - "Processing year 2026, month 5\n", - "Processing year 2026, month 6\n", - "Processing year 2026, month 7\n", - "Processing year 2026, month 8\n", - "Processing year 2026, month 9\n", - "Processing year 2026, month 10\n", - "Processing year 2026, month 11\n", - "Processing year 2026, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2026, month 1\n", - "Processing year 2026, month 2\n", - "Processing year 2026, month 3\n", - "Processing year 2026, month 4\n", - "Processing year 2026, month 5\n", - "Processing year 2026, month 6\n", - "Processing year 2026, month 7\n", - "Processing year 2026, month 8\n", - "Processing year 2026, month 9\n", - "Processing year 2026, month 10\n", - "Processing year 2026, month 11\n", - "Processing year 2026, month 12\n", - "Processing file: CIL_subset_ssp245_2027.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2027, month 1\n", - "Processing year 2027, month 2\n", - "Processing year 2027, month 3\n", - "Processing year 2027, month 4\n", - "Processing year 2027, month 5\n", - "Processing year 2027, month 6\n", - "Processing year 2027, month 7\n", - "Processing year 2027, month 8\n", - "Processing year 2027, month 9\n", - "Processing year 2027, month 10\n", - "Processing year 2027, month 11\n", - "Processing year 2027, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2027, month 1\n", - "Processing year 2027, month 2\n", - "Processing year 2027, month 3\n", - "Processing year 2027, month 4\n", - "Processing year 2027, month 5\n", - "Processing year 2027, month 6\n", - "Processing year 2027, month 7\n", - "Processing year 2027, month 8\n", - "Processing year 2027, month 9\n", - "Processing year 2027, month 10\n", - "Processing year 2027, month 11\n", - "Processing year 2027, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2027, month 1\n", - "Processing year 2027, month 2\n", - "Processing year 2027, month 3\n", - "Processing year 2027, month 4\n", - "Processing year 2027, month 5\n", - "Processing year 2027, month 6\n", - "Processing year 2027, month 7\n", - "Processing year 2027, month 8\n", - "Processing year 2027, month 9\n", - "Processing year 2027, month 10\n", - "Processing year 2027, month 11\n", - "Processing year 2027, month 12\n", - "Processing file: CIL_subset_ssp245_2028.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2028, month 1\n", - "Processing year 2028, month 2\n", - "Processing year 2028, month 3\n", - "Processing year 2028, month 4\n", - "Processing year 2028, month 5\n", - "Processing year 2028, month 6\n", - "Processing year 2028, month 7\n", - "Processing year 2028, month 8\n", - "Processing year 2028, month 9\n", - "Processing year 2028, month 10\n", - "Processing year 2028, month 11\n", - "Processing year 2028, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2028, month 1\n", - "Processing year 2028, month 2\n", - "Processing year 2028, month 3\n", - "Processing year 2028, month 4\n", - "Processing year 2028, month 5\n", - "Processing year 2028, month 6\n", - "Processing year 2028, month 7\n", - "Processing year 2028, month 8\n", - "Processing year 2028, month 9\n", - "Processing year 2028, month 10\n", - "Processing year 2028, month 11\n", - "Processing year 2028, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2028, month 1\n", - "Processing year 2028, month 2\n", - "Processing year 2028, month 3\n", - "Processing year 2028, month 4\n", - "Processing year 2028, month 5\n", - "Processing year 2028, month 6\n", - "Processing year 2028, month 7\n", - "Processing year 2028, month 8\n", - "Processing year 2028, month 9\n", - "Processing year 2028, month 10\n", - "Processing year 2028, month 11\n", - "Processing year 2028, month 12\n", - "Processing file: CIL_subset_ssp245_2029.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2029, month 1\n", - "Processing year 2029, month 2\n", - "Processing year 2029, month 3\n", - "Processing year 2029, month 4\n", - "Processing year 2029, month 5\n", - "Processing year 2029, month 6\n", - "Processing year 2029, month 7\n", - "Processing year 2029, month 8\n", - "Processing year 2029, month 9\n", - "Processing year 2029, month 10\n", - "Processing year 2029, month 11\n", - "Processing year 2029, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2029, month 1\n", - "Processing year 2029, month 2\n", - "Processing year 2029, month 3\n", - "Processing year 2029, month 4\n", - "Processing year 2029, month 5\n", - "Processing year 2029, month 6\n", - "Processing year 2029, month 7\n", - "Processing year 2029, month 8\n", - "Processing year 2029, month 9\n", - "Processing year 2029, month 10\n", - "Processing year 2029, month 11\n", - "Processing year 2029, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2029, month 1\n", - "Processing year 2029, month 2\n", - "Processing year 2029, month 3\n", - "Processing year 2029, month 4\n", - "Processing year 2029, month 5\n", - "Processing year 2029, month 6\n", - "Processing year 2029, month 7\n", - "Processing year 2029, month 8\n", - "Processing year 2029, month 9\n", - "Processing year 2029, month 10\n", - "Processing year 2029, month 11\n", - "Processing year 2029, month 12\n", - "Processing file: CIL_subset_ssp245_2030.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2030, month 1\n", - "Processing year 2030, month 2\n", - "Processing year 2030, month 3\n", - "Processing year 2030, month 4\n", - "Processing year 2030, month 5\n", - "Processing year 2030, month 6\n", - "Processing year 2030, month 7\n", - "Processing year 2030, month 8\n", - "Processing year 2030, month 9\n", - "Processing year 2030, month 10\n", - "Processing year 2030, month 11\n", - "Processing year 2030, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2030, month 1\n", - "Processing year 2030, month 2\n", - "Processing year 2030, month 3\n", - "Processing year 2030, month 4\n", - "Processing year 2030, month 5\n", - "Processing year 2030, month 6\n", - "Processing year 2030, month 7\n", - "Processing year 2030, month 8\n", - "Processing year 2030, month 9\n", - "Processing year 2030, month 10\n", - "Processing year 2030, month 11\n", - "Processing year 2030, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2030, month 1\n", - "Processing year 2030, month 2\n", - "Processing year 2030, month 3\n", - "Processing year 2030, month 4\n", - "Processing year 2030, month 5\n", - "Processing year 2030, month 6\n", - "Processing year 2030, month 7\n", - "Processing year 2030, month 8\n", - "Processing year 2030, month 9\n", - "Processing year 2030, month 10\n", - "Processing year 2030, month 11\n", - "Processing year 2030, month 12\n", - "Processing file: CIL_subset_ssp245_2031.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2031, month 1\n", - "Processing year 2031, month 2\n", - "Processing year 2031, month 3\n", - "Processing year 2031, month 4\n", - "Processing year 2031, month 5\n", - "Processing year 2031, month 6\n", - "Processing year 2031, month 7\n", - "Processing year 2031, month 8\n", - "Processing year 2031, month 9\n", - "Processing year 2031, month 10\n", - "Processing year 2031, month 11\n", - "Processing year 2031, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2031, month 1\n", - "Processing year 2031, month 2\n", - "Processing year 2031, month 3\n", - "Processing year 2031, month 4\n", - "Processing year 2031, month 5\n", - "Processing year 2031, month 6\n", - "Processing year 2031, month 7\n", - "Processing year 2031, month 8\n", - "Processing year 2031, month 9\n", - "Processing year 2031, month 10\n", - "Processing year 2031, month 11\n", - "Processing year 2031, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2031, month 1\n", - "Processing year 2031, month 2\n", - "Processing year 2031, month 3\n", - "Processing year 2031, month 4\n", - "Processing year 2031, month 5\n", - "Processing year 2031, month 6\n", - "Processing year 2031, month 7\n", - "Processing year 2031, month 8\n", - "Processing year 2031, month 9\n", - "Processing year 2031, month 10\n", - "Processing year 2031, month 11\n", - "Processing year 2031, month 12\n", - "Processing file: CIL_subset_ssp245_2032.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2032, month 1\n", - "Processing year 2032, month 2\n", - "Processing year 2032, month 3\n", - "Processing year 2032, month 4\n", - "Processing year 2032, month 5\n", - "Processing year 2032, month 6\n", - "Processing year 2032, month 7\n", - "Processing year 2032, month 8\n", - "Processing year 2032, month 9\n", - "Processing year 2032, month 10\n", - "Processing year 2032, month 11\n", - "Processing year 2032, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2032, month 1\n", - "Processing year 2032, month 2\n", - "Processing year 2032, month 3\n", - "Processing year 2032, month 4\n", - "Processing year 2032, month 5\n", - "Processing year 2032, month 6\n", - "Processing year 2032, month 7\n", - "Processing year 2032, month 8\n", - "Processing year 2032, month 9\n", - "Processing year 2032, month 10\n", - "Processing year 2032, month 11\n", - "Processing year 2032, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2032, month 1\n", - "Processing year 2032, month 2\n", - "Processing year 2032, month 3\n", - "Processing year 2032, month 4\n", - "Processing year 2032, month 5\n", - "Processing year 2032, month 6\n", - "Processing year 2032, month 7\n", - "Processing year 2032, month 8\n", - "Processing year 2032, month 9\n", - "Processing year 2032, month 10\n", - "Processing year 2032, month 11\n", - "Processing year 2032, month 12\n", - "Processing file: CIL_subset_ssp245_2033.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2033, month 1\n", - "Processing year 2033, month 2\n", - "Processing year 2033, month 3\n", - "Processing year 2033, month 4\n", - "Processing year 2033, month 5\n", - "Processing year 2033, month 6\n", - "Processing year 2033, month 7\n", - "Processing year 2033, month 8\n", - "Processing year 2033, month 9\n", - "Processing year 2033, month 10\n", - "Processing year 2033, month 11\n", - "Processing year 2033, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2033, month 1\n", - "Processing year 2033, month 2\n", - "Processing year 2033, month 3\n", - "Processing year 2033, month 4\n", - "Processing year 2033, month 5\n", - "Processing year 2033, month 6\n", - "Processing year 2033, month 7\n", - "Processing year 2033, month 8\n", - "Processing year 2033, month 9\n", - "Processing year 2033, month 10\n", - "Processing year 2033, month 11\n", - "Processing year 2033, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2033, month 1\n", - "Processing year 2033, month 2\n", - "Processing year 2033, month 3\n", - "Processing year 2033, month 4\n", - "Processing year 2033, month 5\n", - "Processing year 2033, month 6\n", - "Processing year 2033, month 7\n", - "Processing year 2033, month 8\n", - "Processing year 2033, month 9\n", - "Processing year 2033, month 10\n", - "Processing year 2033, month 11\n", - "Processing year 2033, month 12\n", - "Processing file: CIL_subset_ssp245_2034.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2034, month 1\n", - "Processing year 2034, month 2\n", - "Processing year 2034, month 3\n", - "Processing year 2034, month 4\n", - "Processing year 2034, month 5\n", - "Processing year 2034, month 6\n", - "Processing year 2034, month 7\n", - "Processing year 2034, month 8\n", - "Processing year 2034, month 9\n", - "Processing year 2034, month 10\n", - "Processing year 2034, month 11\n", - "Processing year 2034, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2034, month 1\n", - "Processing year 2034, month 2\n", - "Processing year 2034, month 3\n", - "Processing year 2034, month 4\n", - "Processing year 2034, month 5\n", - "Processing year 2034, month 6\n", - "Processing year 2034, month 7\n", - "Processing year 2034, month 8\n", - "Processing year 2034, month 9\n", - "Processing year 2034, month 10\n", - "Processing year 2034, month 11\n", - "Processing year 2034, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2034, month 1\n", - "Processing year 2034, month 2\n", - "Processing year 2034, month 3\n", - "Processing year 2034, month 4\n", - "Processing year 2034, month 5\n", - "Processing year 2034, month 6\n", - "Processing year 2034, month 7\n", - "Processing year 2034, month 8\n", - "Processing year 2034, month 9\n", - "Processing year 2034, month 10\n", - "Processing year 2034, month 11\n", - "Processing year 2034, month 12\n", - "Processing file: CIL_subset_ssp245_2035.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2035, month 1\n", - "Processing year 2035, month 2\n", - "Processing year 2035, month 3\n", - "Processing year 2035, month 4\n", - "Processing year 2035, month 5\n", - "Processing year 2035, month 6\n", - "Processing year 2035, month 7\n", - "Processing year 2035, month 8\n", - "Processing year 2035, month 9\n", - "Processing year 2035, month 10\n", - "Processing year 2035, month 11\n", - "Processing year 2035, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2035, month 1\n", - "Processing year 2035, month 2\n", - "Processing year 2035, month 3\n", - "Processing year 2035, month 4\n", - "Processing year 2035, month 5\n", - "Processing year 2035, month 6\n", - "Processing year 2035, month 7\n", - "Processing year 2035, month 8\n", - "Processing year 2035, month 9\n", - "Processing year 2035, month 10\n", - "Processing year 2035, month 11\n", - "Processing year 2035, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2035, month 1\n", - "Processing year 2035, month 2\n", - "Processing year 2035, month 3\n", - "Processing year 2035, month 4\n", - "Processing year 2035, month 5\n", - "Processing year 2035, month 6\n", - "Processing year 2035, month 7\n", - "Processing year 2035, month 8\n", - "Processing year 2035, month 9\n", - "Processing year 2035, month 10\n", - "Processing year 2035, month 11\n", - "Processing year 2035, month 12\n", - "Processing file: CIL_subset_ssp245_2036.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2036, month 1\n", - "Processing year 2036, month 2\n", - "Processing year 2036, month 3\n", - "Processing year 2036, month 4\n", - "Processing year 2036, month 5\n", - "Processing year 2036, month 6\n", - "Processing year 2036, month 7\n", - "Processing year 2036, month 8\n", - "Processing year 2036, month 9\n", - "Processing year 2036, month 10\n", - "Processing year 2036, month 11\n", - "Processing year 2036, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2036, month 1\n", - "Processing year 2036, month 2\n", - "Processing year 2036, month 3\n", - "Processing year 2036, month 4\n", - "Processing year 2036, month 5\n", - "Processing year 2036, month 6\n", - "Processing year 2036, month 7\n", - "Processing year 2036, month 8\n", - "Processing year 2036, month 9\n", - "Processing year 2036, month 10\n", - "Processing year 2036, month 11\n", - "Processing year 2036, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2036, month 1\n", - "Processing year 2036, month 2\n", - "Processing year 2036, month 3\n", - "Processing year 2036, month 4\n", - "Processing year 2036, month 5\n", - "Processing year 2036, month 6\n", - "Processing year 2036, month 7\n", - "Processing year 2036, month 8\n", - "Processing year 2036, month 9\n", - "Processing year 2036, month 10\n", - "Processing year 2036, month 11\n", - "Processing year 2036, month 12\n", - "Processing file: CIL_subset_ssp245_2037.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2037, month 1\n", - "Processing year 2037, month 2\n", - "Processing year 2037, month 3\n", - "Processing year 2037, month 4\n", - "Processing year 2037, month 5\n", - "Processing year 2037, month 6\n", - "Processing year 2037, month 7\n", - "Processing year 2037, month 8\n", - "Processing year 2037, month 9\n", - "Processing year 2037, month 10\n", - "Processing year 2037, month 11\n", - "Processing year 2037, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2037, month 1\n", - "Processing year 2037, month 2\n", - "Processing year 2037, month 3\n", - "Processing year 2037, month 4\n", - "Processing year 2037, month 5\n", - "Processing year 2037, month 6\n", - "Processing year 2037, month 7\n", - "Processing year 2037, month 8\n", - "Processing year 2037, month 9\n", - "Processing year 2037, month 10\n", - "Processing year 2037, month 11\n", - "Processing year 2037, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2037, month 1\n", - "Processing year 2037, month 2\n", - "Processing year 2037, month 3\n", - "Processing year 2037, month 4\n", - "Processing year 2037, month 5\n", - "Processing year 2037, month 6\n", - "Processing year 2037, month 7\n", - "Processing year 2037, month 8\n", - "Processing year 2037, month 9\n", - "Processing year 2037, month 10\n", - "Processing year 2037, month 11\n", - "Processing year 2037, month 12\n", - "Processing file: CIL_subset_ssp245_2038.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2038, month 1\n", - "Processing year 2038, month 2\n", - "Processing year 2038, month 3\n", - "Processing year 2038, month 4\n", - "Processing year 2038, month 5\n", - "Processing year 2038, month 6\n", - "Processing year 2038, month 7\n", - "Processing year 2038, month 8\n", - "Processing year 2038, month 9\n", - "Processing year 2038, month 10\n", - "Processing year 2038, month 11\n", - "Processing year 2038, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2038, month 1\n", - "Processing year 2038, month 2\n", - "Processing year 2038, month 3\n", - "Processing year 2038, month 4\n", - "Processing year 2038, month 5\n", - "Processing year 2038, month 6\n", - "Processing year 2038, month 7\n", - "Processing year 2038, month 8\n", - "Processing year 2038, month 9\n", - "Processing year 2038, month 10\n", - "Processing year 2038, month 11\n", - "Processing year 2038, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2038, month 1\n", - "Processing year 2038, month 2\n", - "Processing year 2038, month 3\n", - "Processing year 2038, month 4\n", - "Processing year 2038, month 5\n", - "Processing year 2038, month 6\n", - "Processing year 2038, month 7\n", - "Processing year 2038, month 8\n", - "Processing year 2038, month 9\n", - "Processing year 2038, month 10\n", - "Processing year 2038, month 11\n", - "Processing year 2038, month 12\n", - "Processing file: CIL_subset_ssp245_2039.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2039, month 1\n", - "Processing year 2039, month 2\n", - "Processing year 2039, month 3\n", - "Processing year 2039, month 4\n", - "Processing year 2039, month 5\n", - "Processing year 2039, month 6\n", - "Processing year 2039, month 7\n", - "Processing year 2039, month 8\n", - "Processing year 2039, month 9\n", - "Processing year 2039, month 10\n", - "Processing year 2039, month 11\n", - "Processing year 2039, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2039, month 1\n", - "Processing year 2039, month 2\n", - "Processing year 2039, month 3\n", - "Processing year 2039, month 4\n", - "Processing year 2039, month 5\n", - "Processing year 2039, month 6\n", - "Processing year 2039, month 7\n", - "Processing year 2039, month 8\n", - "Processing year 2039, month 9\n", - "Processing year 2039, month 10\n", - "Processing year 2039, month 11\n", - "Processing year 2039, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2039, month 1\n", - "Processing year 2039, month 2\n", - "Processing year 2039, month 3\n", - "Processing year 2039, month 4\n", - "Processing year 2039, month 5\n", - "Processing year 2039, month 6\n", - "Processing year 2039, month 7\n", - "Processing year 2039, month 8\n", - "Processing year 2039, month 9\n", - "Processing year 2039, month 10\n", - "Processing year 2039, month 11\n", - "Processing year 2039, month 12\n", - "Processing file: CIL_subset_ssp245_2040.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2040, month 1\n", - "Processing year 2040, month 2\n", - "Processing year 2040, month 3\n", - "Processing year 2040, month 4\n", - "Processing year 2040, month 5\n", - "Processing year 2040, month 6\n", - "Processing year 2040, month 7\n", - "Processing year 2040, month 8\n", - "Processing year 2040, month 9\n", - "Processing year 2040, month 10\n", - "Processing year 2040, month 11\n", - "Processing year 2040, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2040, month 1\n", - "Processing year 2040, month 2\n", - "Processing year 2040, month 3\n", - "Processing year 2040, month 4\n", - "Processing year 2040, month 5\n", - "Processing year 2040, month 6\n", - "Processing year 2040, month 7\n", - "Processing year 2040, month 8\n", - "Processing year 2040, month 9\n", - "Processing year 2040, month 10\n", - "Processing year 2040, month 11\n", - "Processing year 2040, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2040, month 1\n", - "Processing year 2040, month 2\n", - "Processing year 2040, month 3\n", - "Processing year 2040, month 4\n", - "Processing year 2040, month 5\n", - "Processing year 2040, month 6\n", - "Processing year 2040, month 7\n", - "Processing year 2040, month 8\n", - "Processing year 2040, month 9\n", - "Processing year 2040, month 10\n", - "Processing year 2040, month 11\n", - "Processing year 2040, month 12\n", - "Processing file: CIL_subset_ssp245_2041.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2041, month 1\n", - "Processing year 2041, month 2\n", - "Processing year 2041, month 3\n", - "Processing year 2041, month 4\n", - "Processing year 2041, month 5\n", - "Processing year 2041, month 6\n", - "Processing year 2041, month 7\n", - "Processing year 2041, month 8\n", - "Processing year 2041, month 9\n", - "Processing year 2041, month 10\n", - "Processing year 2041, month 11\n", - "Processing year 2041, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2041, month 1\n", - "Processing year 2041, month 2\n", - "Processing year 2041, month 3\n", - "Processing year 2041, month 4\n", - "Processing year 2041, month 5\n", - "Processing year 2041, month 6\n", - "Processing year 2041, month 7\n", - "Processing year 2041, month 8\n", - "Processing year 2041, month 9\n", - "Processing year 2041, month 10\n", - "Processing year 2041, month 11\n", - "Processing year 2041, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2041, month 1\n", - "Processing year 2041, month 2\n", - "Processing year 2041, month 3\n", - "Processing year 2041, month 4\n", - "Processing year 2041, month 5\n", - "Processing year 2041, month 6\n", - "Processing year 2041, month 7\n", - "Processing year 2041, month 8\n", - "Processing year 2041, month 9\n", - "Processing year 2041, month 10\n", - "Processing year 2041, month 11\n", - "Processing year 2041, month 12\n", - "Processing file: CIL_subset_ssp245_2042.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2042, month 1\n", - "Processing year 2042, month 2\n", - "Processing year 2042, month 3\n", - "Processing year 2042, month 4\n", - "Processing year 2042, month 5\n", - "Processing year 2042, month 6\n", - "Processing year 2042, month 7\n", - "Processing year 2042, month 8\n", - "Processing year 2042, month 9\n", - "Processing year 2042, month 10\n", - "Processing year 2042, month 11\n", - "Processing year 2042, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2042, month 1\n", - "Processing year 2042, month 2\n", - "Processing year 2042, month 3\n", - "Processing year 2042, month 4\n", - "Processing year 2042, month 5\n", - "Processing year 2042, month 6\n", - "Processing year 2042, month 7\n", - "Processing year 2042, month 8\n", - "Processing year 2042, month 9\n", - "Processing year 2042, month 10\n", - "Processing year 2042, month 11\n", - "Processing year 2042, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2042, month 1\n", - "Processing year 2042, month 2\n", - "Processing year 2042, month 3\n", - "Processing year 2042, month 4\n", - "Processing year 2042, month 5\n", - "Processing year 2042, month 6\n", - "Processing year 2042, month 7\n", - "Processing year 2042, month 8\n", - "Processing year 2042, month 9\n", - "Processing year 2042, month 10\n", - "Processing year 2042, month 11\n", - "Processing year 2042, month 12\n", - "Processing file: CIL_subset_ssp245_2043.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2043, month 1\n", - "Processing year 2043, month 2\n", - "Processing year 2043, month 3\n", - "Processing year 2043, month 4\n", - "Processing year 2043, month 5\n", - "Processing year 2043, month 6\n", - "Processing year 2043, month 7\n", - "Processing year 2043, month 8\n", - "Processing year 2043, month 9\n", - "Processing year 2043, month 10\n", - "Processing year 2043, month 11\n", - "Processing year 2043, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2043, month 1\n", - "Processing year 2043, month 2\n", - "Processing year 2043, month 3\n", - "Processing year 2043, month 4\n", - "Processing year 2043, month 5\n", - "Processing year 2043, month 6\n", - "Processing year 2043, month 7\n", - "Processing year 2043, month 8\n", - "Processing year 2043, month 9\n", - "Processing year 2043, month 10\n", - "Processing year 2043, month 11\n", - "Processing year 2043, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2043, month 1\n", - "Processing year 2043, month 2\n", - "Processing year 2043, month 3\n", - "Processing year 2043, month 4\n", - "Processing year 2043, month 5\n", - "Processing year 2043, month 6\n", - "Processing year 2043, month 7\n", - "Processing year 2043, month 8\n", - "Processing year 2043, month 9\n", - "Processing year 2043, month 10\n", - "Processing year 2043, month 11\n", - "Processing year 2043, month 12\n", - "Processing file: CIL_subset_ssp245_2044.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2044, month 1\n", - "Processing year 2044, month 2\n", - "Processing year 2044, month 3\n", - "Processing year 2044, month 4\n", - "Processing year 2044, month 5\n", - "Processing year 2044, month 6\n", - "Processing year 2044, month 7\n", - "Processing year 2044, month 8\n", - "Processing year 2044, month 9\n", - "Processing year 2044, month 10\n", - "Processing year 2044, month 11\n", - "Processing year 2044, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2044, month 1\n", - "Processing year 2044, month 2\n", - "Processing year 2044, month 3\n", - "Processing year 2044, month 4\n", - "Processing year 2044, month 5\n", - "Processing year 2044, month 6\n", - "Processing year 2044, month 7\n", - "Processing year 2044, month 8\n", - "Processing year 2044, month 9\n", - "Processing year 2044, month 10\n", - "Processing year 2044, month 11\n", - "Processing year 2044, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2044, month 1\n", - "Processing year 2044, month 2\n", - "Processing year 2044, month 3\n", - "Processing year 2044, month 4\n", - "Processing year 2044, month 5\n", - "Processing year 2044, month 6\n", - "Processing year 2044, month 7\n", - "Processing year 2044, month 8\n", - "Processing year 2044, month 9\n", - "Processing year 2044, month 10\n", - "Processing year 2044, month 11\n", - "Processing year 2044, month 12\n", - "Processing file: CIL_subset_ssp245_2045.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2045, month 1\n", - "Processing year 2045, month 2\n", - "Processing year 2045, month 3\n", - "Processing year 2045, month 4\n", - "Processing year 2045, month 5\n", - "Processing year 2045, month 6\n", - "Processing year 2045, month 7\n", - "Processing year 2045, month 8\n", - "Processing year 2045, month 9\n", - "Processing year 2045, month 10\n", - "Processing year 2045, month 11\n", - "Processing year 2045, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2045, month 1\n", - "Processing year 2045, month 2\n", - "Processing year 2045, month 3\n", - "Processing year 2045, month 4\n", - "Processing year 2045, month 5\n", - "Processing year 2045, month 6\n", - "Processing year 2045, month 7\n", - "Processing year 2045, month 8\n", - "Processing year 2045, month 9\n", - "Processing year 2045, month 10\n", - "Processing year 2045, month 11\n", - "Processing year 2045, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2045, month 1\n", - "Processing year 2045, month 2\n", - "Processing year 2045, month 3\n", - "Processing year 2045, month 4\n", - "Processing year 2045, month 5\n", - "Processing year 2045, month 6\n", - "Processing year 2045, month 7\n", - "Processing year 2045, month 8\n", - "Processing year 2045, month 9\n", - "Processing year 2045, month 10\n", - "Processing year 2045, month 11\n", - "Processing year 2045, month 12\n", - "Processing file: CIL_subset_ssp245_2046.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2046, month 1\n", - "Processing year 2046, month 2\n", - "Processing year 2046, month 3\n", - "Processing year 2046, month 4\n", - "Processing year 2046, month 5\n", - "Processing year 2046, month 6\n", - "Processing year 2046, month 7\n", - "Processing year 2046, month 8\n", - "Processing year 2046, month 9\n", - "Processing year 2046, month 10\n", - "Processing year 2046, month 11\n", - "Processing year 2046, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2046, month 1\n", - "Processing year 2046, month 2\n", - "Processing year 2046, month 3\n", - "Processing year 2046, month 4\n", - "Processing year 2046, month 5\n", - "Processing year 2046, month 6\n", - "Processing year 2046, month 7\n", - "Processing year 2046, month 8\n", - "Processing year 2046, month 9\n", - "Processing year 2046, month 10\n", - "Processing year 2046, month 11\n", - "Processing year 2046, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2046, month 1\n", - "Processing year 2046, month 2\n", - "Processing year 2046, month 3\n", - "Processing year 2046, month 4\n", - "Processing year 2046, month 5\n", - "Processing year 2046, month 6\n", - "Processing year 2046, month 7\n", - "Processing year 2046, month 8\n", - "Processing year 2046, month 9\n", - "Processing year 2046, month 10\n", - "Processing year 2046, month 11\n", - "Processing year 2046, month 12\n", - "Processing file: CIL_subset_ssp245_2047.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2047, month 1\n", - "Processing year 2047, month 2\n", - "Processing year 2047, month 3\n", - "Processing year 2047, month 4\n", - "Processing year 2047, month 5\n", - "Processing year 2047, month 6\n", - "Processing year 2047, month 7\n", - "Processing year 2047, month 8\n", - "Processing year 2047, month 9\n", - "Processing year 2047, month 10\n", - "Processing year 2047, month 11\n", - "Processing year 2047, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2047, month 1\n", - "Processing year 2047, month 2\n", - "Processing year 2047, month 3\n", - "Processing year 2047, month 4\n", - "Processing year 2047, month 5\n", - "Processing year 2047, month 6\n", - "Processing year 2047, month 7\n", - "Processing year 2047, month 8\n", - "Processing year 2047, month 9\n", - "Processing year 2047, month 10\n", - "Processing year 2047, month 11\n", - "Processing year 2047, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2047, month 1\n", - "Processing year 2047, month 2\n", - "Processing year 2047, month 3\n", - "Processing year 2047, month 4\n", - "Processing year 2047, month 5\n", - "Processing year 2047, month 6\n", - "Processing year 2047, month 7\n", - "Processing year 2047, month 8\n", - "Processing year 2047, month 9\n", - "Processing year 2047, month 10\n", - "Processing year 2047, month 11\n", - "Processing year 2047, month 12\n", - "Processing file: CIL_subset_ssp245_2048.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2048, month 1\n", - "Processing year 2048, month 2\n", - "Processing year 2048, month 3\n", - "Processing year 2048, month 4\n", - "Processing year 2048, month 5\n", - "Processing year 2048, month 6\n", - "Processing year 2048, month 7\n", - "Processing year 2048, month 8\n", - "Processing year 2048, month 9\n", - "Processing year 2048, month 10\n", - "Processing year 2048, month 11\n", - "Processing year 2048, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2048, month 1\n", - "Processing year 2048, month 2\n", - "Processing year 2048, month 3\n", - "Processing year 2048, month 4\n", - "Processing year 2048, month 5\n", - "Processing year 2048, month 6\n", - "Processing year 2048, month 7\n", - "Processing year 2048, month 8\n", - "Processing year 2048, month 9\n", - "Processing year 2048, month 10\n", - "Processing year 2048, month 11\n", - "Processing year 2048, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2048, month 1\n", - "Processing year 2048, month 2\n", - "Processing year 2048, month 3\n", - "Processing year 2048, month 4\n", - "Processing year 2048, month 5\n", - "Processing year 2048, month 6\n", - "Processing year 2048, month 7\n", - "Processing year 2048, month 8\n", - "Processing year 2048, month 9\n", - "Processing year 2048, month 10\n", - "Processing year 2048, month 11\n", - "Processing year 2048, month 12\n", - "Processing file: CIL_subset_ssp245_2049.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2049, month 1\n", - "Processing year 2049, month 2\n", - "Processing year 2049, month 3\n", - "Processing year 2049, month 4\n", - "Processing year 2049, month 5\n", - "Processing year 2049, month 6\n", - "Processing year 2049, month 7\n", - "Processing year 2049, month 8\n", - "Processing year 2049, month 9\n", - "Processing year 2049, month 10\n", - "Processing year 2049, month 11\n", - "Processing year 2049, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2049, month 1\n", - "Processing year 2049, month 2\n", - "Processing year 2049, month 3\n", - "Processing year 2049, month 4\n", - "Processing year 2049, month 5\n", - "Processing year 2049, month 6\n", - "Processing year 2049, month 7\n", - "Processing year 2049, month 8\n", - "Processing year 2049, month 9\n", - "Processing year 2049, month 10\n", - "Processing year 2049, month 11\n", - "Processing year 2049, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2049, month 1\n", - "Processing year 2049, month 2\n", - "Processing year 2049, month 3\n", - "Processing year 2049, month 4\n", - "Processing year 2049, month 5\n", - "Processing year 2049, month 6\n", - "Processing year 2049, month 7\n", - "Processing year 2049, month 8\n", - "Processing year 2049, month 9\n", - "Processing year 2049, month 10\n", - "Processing year 2049, month 11\n", - "Processing year 2049, month 12\n", - "Processing file: CIL_subset_ssp245_2050.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2050, month 1\n", - "Processing year 2050, month 2\n", - "Processing year 2050, month 3\n", - "Processing year 2050, month 4\n", - "Processing year 2050, month 5\n", - "Processing year 2050, month 6\n", - "Processing year 2050, month 7\n", - "Processing year 2050, month 8\n", - "Processing year 2050, month 9\n", - "Processing year 2050, month 10\n", - "Processing year 2050, month 11\n", - "Processing year 2050, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2050, month 1\n", - "Processing year 2050, month 2\n", - "Processing year 2050, month 3\n", - "Processing year 2050, month 4\n", - "Processing year 2050, month 5\n", - "Processing year 2050, month 6\n", - "Processing year 2050, month 7\n", - "Processing year 2050, month 8\n", - "Processing year 2050, month 9\n", - "Processing year 2050, month 10\n", - "Processing year 2050, month 11\n", - "Processing year 2050, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2050, month 1\n", - "Processing year 2050, month 2\n", - "Processing year 2050, month 3\n", - "Processing year 2050, month 4\n", - "Processing year 2050, month 5\n", - "Processing year 2050, month 6\n", - "Processing year 2050, month 7\n", - "Processing year 2050, month 8\n", - "Processing year 2050, month 9\n", - "Processing year 2050, month 10\n", - "Processing year 2050, month 11\n", - "Processing year 2050, month 12\n", - "Processing file: CIL_subset_ssp245_2051.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2051, month 1\n", - "Processing year 2051, month 2\n", - "Processing year 2051, month 3\n", - "Processing year 2051, month 4\n", - "Processing year 2051, month 5\n", - "Processing year 2051, month 6\n", - "Processing year 2051, month 7\n", - "Processing year 2051, month 8\n", - "Processing year 2051, month 9\n", - "Processing year 2051, month 10\n", - "Processing year 2051, month 11\n", - "Processing year 2051, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2051, month 1\n", - "Processing year 2051, month 2\n", - "Processing year 2051, month 3\n", - "Processing year 2051, month 4\n", - "Processing year 2051, month 5\n", - "Processing year 2051, month 6\n", - "Processing year 2051, month 7\n", - "Processing year 2051, month 8\n", - "Processing year 2051, month 9\n", - "Processing year 2051, month 10\n", - "Processing year 2051, month 11\n", - "Processing year 2051, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2051, month 1\n", - "Processing year 2051, month 2\n", - "Processing year 2051, month 3\n", - "Processing year 2051, month 4\n", - "Processing year 2051, month 5\n", - "Processing year 2051, month 6\n", - "Processing year 2051, month 7\n", - "Processing year 2051, month 8\n", - "Processing year 2051, month 9\n", - "Processing year 2051, month 10\n", - "Processing year 2051, month 11\n", - "Processing year 2051, month 12\n", - "Processing file: CIL_subset_ssp245_2052.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2052, month 1\n", - "Processing year 2052, month 2\n", - "Processing year 2052, month 3\n", - "Processing year 2052, month 4\n", - "Processing year 2052, month 5\n", - "Processing year 2052, month 6\n", - "Processing year 2052, month 7\n", - "Processing year 2052, month 8\n", - "Processing year 2052, month 9\n", - "Processing year 2052, month 10\n", - "Processing year 2052, month 11\n", - "Processing year 2052, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2052, month 1\n", - "Processing year 2052, month 2\n", - "Processing year 2052, month 3\n", - "Processing year 2052, month 4\n", - "Processing year 2052, month 5\n", - "Processing year 2052, month 6\n", - "Processing year 2052, month 7\n", - "Processing year 2052, month 8\n", - "Processing year 2052, month 9\n", - "Processing year 2052, month 10\n", - "Processing year 2052, month 11\n", - "Processing year 2052, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2052, month 1\n", - "Processing year 2052, month 2\n", - "Processing year 2052, month 3\n", - "Processing year 2052, month 4\n", - "Processing year 2052, month 5\n", - "Processing year 2052, month 6\n", - "Processing year 2052, month 7\n", - "Processing year 2052, month 8\n", - "Processing year 2052, month 9\n", - "Processing year 2052, month 10\n", - "Processing year 2052, month 11\n", - "Processing year 2052, month 12\n", - "Processing file: CIL_subset_ssp245_2053.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2053, month 1\n", - "Processing year 2053, month 2\n", - "Processing year 2053, month 3\n", - "Processing year 2053, month 4\n", - "Processing year 2053, month 5\n", - "Processing year 2053, month 6\n", - "Processing year 2053, month 7\n", - "Processing year 2053, month 8\n", - "Processing year 2053, month 9\n", - "Processing year 2053, month 10\n", - "Processing year 2053, month 11\n", - "Processing year 2053, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2053, month 1\n", - "Processing year 2053, month 2\n", - "Processing year 2053, month 3\n", - "Processing year 2053, month 4\n", - "Processing year 2053, month 5\n", - "Processing year 2053, month 6\n", - "Processing year 2053, month 7\n", - "Processing year 2053, month 8\n", - "Processing year 2053, month 9\n", - "Processing year 2053, month 10\n", - "Processing year 2053, month 11\n", - "Processing year 2053, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2053, month 1\n", - "Processing year 2053, month 2\n", - "Processing year 2053, month 3\n", - "Processing year 2053, month 4\n", - "Processing year 2053, month 5\n", - "Processing year 2053, month 6\n", - "Processing year 2053, month 7\n", - "Processing year 2053, month 8\n", - "Processing year 2053, month 9\n", - "Processing year 2053, month 10\n", - "Processing year 2053, month 11\n", - "Processing year 2053, month 12\n", - "Processing file: CIL_subset_ssp245_2054.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2054, month 1\n", - "Processing year 2054, month 2\n", - "Processing year 2054, month 3\n", - "Processing year 2054, month 4\n", - "Processing year 2054, month 5\n", - "Processing year 2054, month 6\n", - "Processing year 2054, month 7\n", - "Processing year 2054, month 8\n", - "Processing year 2054, month 9\n", - "Processing year 2054, month 10\n", - "Processing year 2054, month 11\n", - "Processing year 2054, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2054, month 1\n", - "Processing year 2054, month 2\n", - "Processing year 2054, month 3\n", - "Processing year 2054, month 4\n", - "Processing year 2054, month 5\n", - "Processing year 2054, month 6\n", - "Processing year 2054, month 7\n", - "Processing year 2054, month 8\n", - "Processing year 2054, month 9\n", - "Processing year 2054, month 10\n", - "Processing year 2054, month 11\n", - "Processing year 2054, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2054, month 1\n", - "Processing year 2054, month 2\n", - "Processing year 2054, month 3\n", - "Processing year 2054, month 4\n", - "Processing year 2054, month 5\n", - "Processing year 2054, month 6\n", - "Processing year 2054, month 7\n", - "Processing year 2054, month 8\n", - "Processing year 2054, month 9\n", - "Processing year 2054, month 10\n", - "Processing year 2054, month 11\n", - "Processing year 2054, month 12\n", - "Processing file: CIL_subset_ssp245_2055.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2055, month 1\n", - "Processing year 2055, month 2\n", - "Processing year 2055, month 3\n", - "Processing year 2055, month 4\n", - "Processing year 2055, month 5\n", - "Processing year 2055, month 6\n", - "Processing year 2055, month 7\n", - "Processing year 2055, month 8\n", - "Processing year 2055, month 9\n", - "Processing year 2055, month 10\n", - "Processing year 2055, month 11\n", - "Processing year 2055, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2055, month 1\n", - "Processing year 2055, month 2\n", - "Processing year 2055, month 3\n", - "Processing year 2055, month 4\n", - "Processing year 2055, month 5\n", - "Processing year 2055, month 6\n", - "Processing year 2055, month 7\n", - "Processing year 2055, month 8\n", - "Processing year 2055, month 9\n", - "Processing year 2055, month 10\n", - "Processing year 2055, month 11\n", - "Processing year 2055, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2055, month 1\n", - "Processing year 2055, month 2\n", - "Processing year 2055, month 3\n", - "Processing year 2055, month 4\n", - "Processing year 2055, month 5\n", - "Processing year 2055, month 6\n", - "Processing year 2055, month 7\n", - "Processing year 2055, month 8\n", - "Processing year 2055, month 9\n", - "Processing year 2055, month 10\n", - "Processing year 2055, month 11\n", - "Processing year 2055, month 12\n", - "Processing file: CIL_subset_ssp245_2056.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2056, month 1\n", - "Processing year 2056, month 2\n", - "Processing year 2056, month 3\n", - "Processing year 2056, month 4\n", - "Processing year 2056, month 5\n", - "Processing year 2056, month 6\n", - "Processing year 2056, month 7\n", - "Processing year 2056, month 8\n", - "Processing year 2056, month 9\n", - "Processing year 2056, month 10\n", - "Processing year 2056, month 11\n", - "Processing year 2056, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2056, month 1\n", - "Processing year 2056, month 2\n", - "Processing year 2056, month 3\n", - "Processing year 2056, month 4\n", - "Processing year 2056, month 5\n", - "Processing year 2056, month 6\n", - "Processing year 2056, month 7\n", - "Processing year 2056, month 8\n", - "Processing year 2056, month 9\n", - "Processing year 2056, month 10\n", - "Processing year 2056, month 11\n", - "Processing year 2056, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2056, month 1\n", - "Processing year 2056, month 2\n", - "Processing year 2056, month 3\n", - "Processing year 2056, month 4\n", - "Processing year 2056, month 5\n", - "Processing year 2056, month 6\n", - "Processing year 2056, month 7\n", - "Processing year 2056, month 8\n", - "Processing year 2056, month 9\n", - "Processing year 2056, month 10\n", - "Processing year 2056, month 11\n", - "Processing year 2056, month 12\n", - "Processing file: CIL_subset_ssp245_2057.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2057, month 1\n", - "Processing year 2057, month 2\n", - "Processing year 2057, month 3\n", - "Processing year 2057, month 4\n", - "Processing year 2057, month 5\n", - "Processing year 2057, month 6\n", - "Processing year 2057, month 7\n", - "Processing year 2057, month 8\n", - "Processing year 2057, month 9\n", - "Processing year 2057, month 10\n", - "Processing year 2057, month 11\n", - "Processing year 2057, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2057, month 1\n", - "Processing year 2057, month 2\n", - "Processing year 2057, month 3\n", - "Processing year 2057, month 4\n", - "Processing year 2057, month 5\n", - "Processing year 2057, month 6\n", - "Processing year 2057, month 7\n", - "Processing year 2057, month 8\n", - "Processing year 2057, month 9\n", - "Processing year 2057, month 10\n", - "Processing year 2057, month 11\n", - "Processing year 2057, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2057, month 1\n", - "Processing year 2057, month 2\n", - "Processing year 2057, month 3\n", - "Processing year 2057, month 4\n", - "Processing year 2057, month 5\n", - "Processing year 2057, month 6\n", - "Processing year 2057, month 7\n", - "Processing year 2057, month 8\n", - "Processing year 2057, month 9\n", - "Processing year 2057, month 10\n", - "Processing year 2057, month 11\n", - "Processing year 2057, month 12\n", - "Processing file: CIL_subset_ssp245_2058.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2058, month 1\n", - "Processing year 2058, month 2\n", - "Processing year 2058, month 3\n", - "Processing year 2058, month 4\n", - "Processing year 2058, month 5\n", - "Processing year 2058, month 6\n", - "Processing year 2058, month 7\n", - "Processing year 2058, month 8\n", - "Processing year 2058, month 9\n", - "Processing year 2058, month 10\n", - "Processing year 2058, month 11\n", - "Processing year 2058, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2058, month 1\n", - "Processing year 2058, month 2\n", - "Processing year 2058, month 3\n", - "Processing year 2058, month 4\n", - "Processing year 2058, month 5\n", - "Processing year 2058, month 6\n", - "Processing year 2058, month 7\n", - "Processing year 2058, month 8\n", - "Processing year 2058, month 9\n", - "Processing year 2058, month 10\n", - "Processing year 2058, month 11\n", - "Processing year 2058, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2058, month 1\n", - "Processing year 2058, month 2\n", - "Processing year 2058, month 3\n", - "Processing year 2058, month 4\n", - "Processing year 2058, month 5\n", - "Processing year 2058, month 6\n", - "Processing year 2058, month 7\n", - "Processing year 2058, month 8\n", - "Processing year 2058, month 9\n", - "Processing year 2058, month 10\n", - "Processing year 2058, month 11\n", - "Processing year 2058, month 12\n", - "Processing file: CIL_subset_ssp245_2059.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2059, month 1\n", - "Processing year 2059, month 2\n", - "Processing year 2059, month 3\n", - "Processing year 2059, month 4\n", - "Processing year 2059, month 5\n", - "Processing year 2059, month 6\n", - "Processing year 2059, month 7\n", - "Processing year 2059, month 8\n", - "Processing year 2059, month 9\n", - "Processing year 2059, month 10\n", - "Processing year 2059, month 11\n", - "Processing year 2059, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2059, month 1\n", - "Processing year 2059, month 2\n", - "Processing year 2059, month 3\n", - "Processing year 2059, month 4\n", - "Processing year 2059, month 5\n", - "Processing year 2059, month 6\n", - "Processing year 2059, month 7\n", - "Processing year 2059, month 8\n", - "Processing year 2059, month 9\n", - "Processing year 2059, month 10\n", - "Processing year 2059, month 11\n", - "Processing year 2059, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2059, month 1\n", - "Processing year 2059, month 2\n", - "Processing year 2059, month 3\n", - "Processing year 2059, month 4\n", - "Processing year 2059, month 5\n", - "Processing year 2059, month 6\n", - "Processing year 2059, month 7\n", - "Processing year 2059, month 8\n", - "Processing year 2059, month 9\n", - "Processing year 2059, month 10\n", - "Processing year 2059, month 11\n", - "Processing year 2059, month 12\n", - "Processing file: CIL_subset_ssp245_2060.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2060, month 1\n", - "Processing year 2060, month 2\n", - "Processing year 2060, month 3\n", - "Processing year 2060, month 4\n", - "Processing year 2060, month 5\n", - "Processing year 2060, month 6\n", - "Processing year 2060, month 7\n", - "Processing year 2060, month 8\n", - "Processing year 2060, month 9\n", - "Processing year 2060, month 10\n", - "Processing year 2060, month 11\n", - "Processing year 2060, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2060, month 1\n", - "Processing year 2060, month 2\n", - "Processing year 2060, month 3\n", - "Processing year 2060, month 4\n", - "Processing year 2060, month 5\n", - "Processing year 2060, month 6\n", - "Processing year 2060, month 7\n", - "Processing year 2060, month 8\n", - "Processing year 2060, month 9\n", - "Processing year 2060, month 10\n", - "Processing year 2060, month 11\n", - "Processing year 2060, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2060, month 1\n", - "Processing year 2060, month 2\n", - "Processing year 2060, month 3\n", - "Processing year 2060, month 4\n", - "Processing year 2060, month 5\n", - "Processing year 2060, month 6\n", - "Processing year 2060, month 7\n", - "Processing year 2060, month 8\n", - "Processing year 2060, month 9\n", - "Processing year 2060, month 10\n", - "Processing year 2060, month 11\n", - "Processing year 2060, month 12\n", - "Processing file: CIL_subset_ssp245_2061.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2061, month 1\n", - "Processing year 2061, month 2\n", - "Processing year 2061, month 3\n", - "Processing year 2061, month 4\n", - "Processing year 2061, month 5\n", - "Processing year 2061, month 6\n", - "Processing year 2061, month 7\n", - "Processing year 2061, month 8\n", - "Processing year 2061, month 9\n", - "Processing year 2061, month 10\n", - "Processing year 2061, month 11\n", - "Processing year 2061, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2061, month 1\n", - "Processing year 2061, month 2\n", - "Processing year 2061, month 3\n", - "Processing year 2061, month 4\n", - "Processing year 2061, month 5\n", - "Processing year 2061, month 6\n", - "Processing year 2061, month 7\n", - "Processing year 2061, month 8\n", - "Processing year 2061, month 9\n", - "Processing year 2061, month 10\n", - "Processing year 2061, month 11\n", - "Processing year 2061, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2061, month 1\n", - "Processing year 2061, month 2\n", - "Processing year 2061, month 3\n", - "Processing year 2061, month 4\n", - "Processing year 2061, month 5\n", - "Processing year 2061, month 6\n", - "Processing year 2061, month 7\n", - "Processing year 2061, month 8\n", - "Processing year 2061, month 9\n", - "Processing year 2061, month 10\n", - "Processing year 2061, month 11\n", - "Processing year 2061, month 12\n", - "Processing file: CIL_subset_ssp245_2062.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2062, month 1\n", - "Processing year 2062, month 2\n", - "Processing year 2062, month 3\n", - "Processing year 2062, month 4\n", - "Processing year 2062, month 5\n", - "Processing year 2062, month 6\n", - "Processing year 2062, month 7\n", - "Processing year 2062, month 8\n", - "Processing year 2062, month 9\n", - "Processing year 2062, month 10\n", - "Processing year 2062, month 11\n", - "Processing year 2062, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2062, month 1\n", - "Processing year 2062, month 2\n", - "Processing year 2062, month 3\n", - "Processing year 2062, month 4\n", - "Processing year 2062, month 5\n", - "Processing year 2062, month 6\n", - "Processing year 2062, month 7\n", - "Processing year 2062, month 8\n", - "Processing year 2062, month 9\n", - "Processing year 2062, month 10\n", - "Processing year 2062, month 11\n", - "Processing year 2062, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2062, month 1\n", - "Processing year 2062, month 2\n", - "Processing year 2062, month 3\n", - "Processing year 2062, month 4\n", - "Processing year 2062, month 5\n", - "Processing year 2062, month 6\n", - "Processing year 2062, month 7\n", - "Processing year 2062, month 8\n", - "Processing year 2062, month 9\n", - "Processing year 2062, month 10\n", - "Processing year 2062, month 11\n", - "Processing year 2062, month 12\n", - "Processing file: CIL_subset_ssp245_2063.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2063, month 1\n", - "Processing year 2063, month 2\n", - "Processing year 2063, month 3\n", - "Processing year 2063, month 4\n", - "Processing year 2063, month 5\n", - "Processing year 2063, month 6\n", - "Processing year 2063, month 7\n", - "Processing year 2063, month 8\n", - "Processing year 2063, month 9\n", - "Processing year 2063, month 10\n", - "Processing year 2063, month 11\n", - "Processing year 2063, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2063, month 1\n", - "Processing year 2063, month 2\n", - "Processing year 2063, month 3\n", - "Processing year 2063, month 4\n", - "Processing year 2063, month 5\n", - "Processing year 2063, month 6\n", - "Processing year 2063, month 7\n", - "Processing year 2063, month 8\n", - "Processing year 2063, month 9\n", - "Processing year 2063, month 10\n", - "Processing year 2063, month 11\n", - "Processing year 2063, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2063, month 1\n", - "Processing year 2063, month 2\n", - "Processing year 2063, month 3\n", - "Processing year 2063, month 4\n", - "Processing year 2063, month 5\n", - "Processing year 2063, month 6\n", - "Processing year 2063, month 7\n", - "Processing year 2063, month 8\n", - "Processing year 2063, month 9\n", - "Processing year 2063, month 10\n", - "Processing year 2063, month 11\n", - "Processing year 2063, month 12\n", - "Processing file: CIL_subset_ssp245_2064.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2064, month 1\n", - "Processing year 2064, month 2\n", - "Processing year 2064, month 3\n", - "Processing year 2064, month 4\n", - "Processing year 2064, month 5\n", - "Processing year 2064, month 6\n", - "Processing year 2064, month 7\n", - "Processing year 2064, month 8\n", - "Processing year 2064, month 9\n", - "Processing year 2064, month 10\n", - "Processing year 2064, month 11\n", - "Processing year 2064, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2064, month 1\n", - "Processing year 2064, month 2\n", - "Processing year 2064, month 3\n", - "Processing year 2064, month 4\n", - "Processing year 2064, month 5\n", - "Processing year 2064, month 6\n", - "Processing year 2064, month 7\n", - "Processing year 2064, month 8\n", - "Processing year 2064, month 9\n", - "Processing year 2064, month 10\n", - "Processing year 2064, month 11\n", - "Processing year 2064, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2064, month 1\n", - "Processing year 2064, month 2\n", - "Processing year 2064, month 3\n", - "Processing year 2064, month 4\n", - "Processing year 2064, month 5\n", - "Processing year 2064, month 6\n", - "Processing year 2064, month 7\n", - "Processing year 2064, month 8\n", - "Processing year 2064, month 9\n", - "Processing year 2064, month 10\n", - "Processing year 2064, month 11\n", - "Processing year 2064, month 12\n", - "Processing file: CIL_subset_ssp245_2065.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2065, month 1\n", - "Processing year 2065, month 2\n", - "Processing year 2065, month 3\n", - "Processing year 2065, month 4\n", - "Processing year 2065, month 5\n", - "Processing year 2065, month 6\n", - "Processing year 2065, month 7\n", - "Processing year 2065, month 8\n", - "Processing year 2065, month 9\n", - "Processing year 2065, month 10\n", - "Processing year 2065, month 11\n", - "Processing year 2065, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2065, month 1\n", - "Processing year 2065, month 2\n", - "Processing year 2065, month 3\n", - "Processing year 2065, month 4\n", - "Processing year 2065, month 5\n", - "Processing year 2065, month 6\n", - "Processing year 2065, month 7\n", - "Processing year 2065, month 8\n", - "Processing year 2065, month 9\n", - "Processing year 2065, month 10\n", - "Processing year 2065, month 11\n", - "Processing year 2065, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2065, month 1\n", - "Processing year 2065, month 2\n", - "Processing year 2065, month 3\n", - "Processing year 2065, month 4\n", - "Processing year 2065, month 5\n", - "Processing year 2065, month 6\n", - "Processing year 2065, month 7\n", - "Processing year 2065, month 8\n", - "Processing year 2065, month 9\n", - "Processing year 2065, month 10\n", - "Processing year 2065, month 11\n", - "Processing year 2065, month 12\n", - "Processing file: CIL_subset_ssp245_2066.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2066, month 1\n", - "Processing year 2066, month 2\n", - "Processing year 2066, month 3\n", - "Processing year 2066, month 4\n", - "Processing year 2066, month 5\n", - "Processing year 2066, month 6\n", - "Processing year 2066, month 7\n", - "Processing year 2066, month 8\n", - "Processing year 2066, month 9\n", - "Processing year 2066, month 10\n", - "Processing year 2066, month 11\n", - "Processing year 2066, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2066, month 1\n", - "Processing year 2066, month 2\n", - "Processing year 2066, month 3\n", - "Processing year 2066, month 4\n", - "Processing year 2066, month 5\n", - "Processing year 2066, month 6\n", - "Processing year 2066, month 7\n", - "Processing year 2066, month 8\n", - "Processing year 2066, month 9\n", - "Processing year 2066, month 10\n", - "Processing year 2066, month 11\n", - "Processing year 2066, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2066, month 1\n", - "Processing year 2066, month 2\n", - "Processing year 2066, month 3\n", - "Processing year 2066, month 4\n", - "Processing year 2066, month 5\n", - "Processing year 2066, month 6\n", - "Processing year 2066, month 7\n", - "Processing year 2066, month 8\n", - "Processing year 2066, month 9\n", - "Processing year 2066, month 10\n", - "Processing year 2066, month 11\n", - "Processing year 2066, month 12\n", - "Processing file: CIL_subset_ssp245_2067.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2067, month 1\n", - "Processing year 2067, month 2\n", - "Processing year 2067, month 3\n", - "Processing year 2067, month 4\n", - "Processing year 2067, month 5\n", - "Processing year 2067, month 6\n", - "Processing year 2067, month 7\n", - "Processing year 2067, month 8\n", - "Processing year 2067, month 9\n", - "Processing year 2067, month 10\n", - "Processing year 2067, month 11\n", - "Processing year 2067, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2067, month 1\n", - "Processing year 2067, month 2\n", - "Processing year 2067, month 3\n", - "Processing year 2067, month 4\n", - "Processing year 2067, month 5\n", - "Processing year 2067, month 6\n", - "Processing year 2067, month 7\n", - "Processing year 2067, month 8\n", - "Processing year 2067, month 9\n", - "Processing year 2067, month 10\n", - "Processing year 2067, month 11\n", - "Processing year 2067, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2067, month 1\n", - "Processing year 2067, month 2\n", - "Processing year 2067, month 3\n", - "Processing year 2067, month 4\n", - "Processing year 2067, month 5\n", - "Processing year 2067, month 6\n", - "Processing year 2067, month 7\n", - "Processing year 2067, month 8\n", - "Processing year 2067, month 9\n", - "Processing year 2067, month 10\n", - "Processing year 2067, month 11\n", - "Processing year 2067, month 12\n", - "Processing file: CIL_subset_ssp245_2068.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2068, month 1\n", - "Processing year 2068, month 2\n", - "Processing year 2068, month 3\n", - "Processing year 2068, month 4\n", - "Processing year 2068, month 5\n", - "Processing year 2068, month 6\n", - "Processing year 2068, month 7\n", - "Processing year 2068, month 8\n", - "Processing year 2068, month 9\n", - "Processing year 2068, month 10\n", - "Processing year 2068, month 11\n", - "Processing year 2068, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2068, month 1\n", - "Processing year 2068, month 2\n", - "Processing year 2068, month 3\n", - "Processing year 2068, month 4\n", - "Processing year 2068, month 5\n", - "Processing year 2068, month 6\n", - "Processing year 2068, month 7\n", - "Processing year 2068, month 8\n", - "Processing year 2068, month 9\n", - "Processing year 2068, month 10\n", - "Processing year 2068, month 11\n", - "Processing year 2068, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2068, month 1\n", - "Processing year 2068, month 2\n", - "Processing year 2068, month 3\n", - "Processing year 2068, month 4\n", - "Processing year 2068, month 5\n", - "Processing year 2068, month 6\n", - "Processing year 2068, month 7\n", - "Processing year 2068, month 8\n", - "Processing year 2068, month 9\n", - "Processing year 2068, month 10\n", - "Processing year 2068, month 11\n", - "Processing year 2068, month 12\n", - "Processing file: CIL_subset_ssp245_2069.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2069, month 1\n", - "Processing year 2069, month 2\n", - "Processing year 2069, month 3\n", - "Processing year 2069, month 4\n", - "Processing year 2069, month 5\n", - "Processing year 2069, month 6\n", - "Processing year 2069, month 7\n", - "Processing year 2069, month 8\n", - "Processing year 2069, month 9\n", - "Processing year 2069, month 10\n", - "Processing year 2069, month 11\n", - "Processing year 2069, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2069, month 1\n", - "Processing year 2069, month 2\n", - "Processing year 2069, month 3\n", - "Processing year 2069, month 4\n", - "Processing year 2069, month 5\n", - "Processing year 2069, month 6\n", - "Processing year 2069, month 7\n", - "Processing year 2069, month 8\n", - "Processing year 2069, month 9\n", - "Processing year 2069, month 10\n", - "Processing year 2069, month 11\n", - "Processing year 2069, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2069, month 1\n", - "Processing year 2069, month 2\n", - "Processing year 2069, month 3\n", - "Processing year 2069, month 4\n", - "Processing year 2069, month 5\n", - "Processing year 2069, month 6\n", - "Processing year 2069, month 7\n", - "Processing year 2069, month 8\n", - "Processing year 2069, month 9\n", - "Processing year 2069, month 10\n", - "Processing year 2069, month 11\n", - "Processing year 2069, month 12\n", - "Processing file: CIL_subset_ssp245_2070.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2070, month 1\n", - "Processing year 2070, month 2\n", - "Processing year 2070, month 3\n", - "Processing year 2070, month 4\n", - "Processing year 2070, month 5\n", - "Processing year 2070, month 6\n", - "Processing year 2070, month 7\n", - "Processing year 2070, month 8\n", - "Processing year 2070, month 9\n", - "Processing year 2070, month 10\n", - "Processing year 2070, month 11\n", - "Processing year 2070, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2070, month 1\n", - "Processing year 2070, month 2\n", - "Processing year 2070, month 3\n", - "Processing year 2070, month 4\n", - "Processing year 2070, month 5\n", - "Processing year 2070, month 6\n", - "Processing year 2070, month 7\n", - "Processing year 2070, month 8\n", - "Processing year 2070, month 9\n", - "Processing year 2070, month 10\n", - "Processing year 2070, month 11\n", - "Processing year 2070, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2070, month 1\n", - "Processing year 2070, month 2\n", - "Processing year 2070, month 3\n", - "Processing year 2070, month 4\n", - "Processing year 2070, month 5\n", - "Processing year 2070, month 6\n", - "Processing year 2070, month 7\n", - "Processing year 2070, month 8\n", - "Processing year 2070, month 9\n", - "Processing year 2070, month 10\n", - "Processing year 2070, month 11\n", - "Processing year 2070, month 12\n", - "Saved monthly data to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp245/HadGEM3-GC31-LL_monthly_prediction_weather_by_facility.csv\n", - "Saved window data to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp245/HadGEM3-GC31-LL_window_prediction_weather_by_facility.csv\n", - "Saved monthly data to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp245/GFDL-CM4_monthly_prediction_weather_by_facility.csv\n", - "Saved window data to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp245/GFDL-CM4_window_prediction_weather_by_facility.csv\n", - "Saved monthly data to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp245/INM-CM5-0_monthly_prediction_weather_by_facility.csv\n", - "Saved window data to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp245/INM-CM5-0_window_prediction_weather_by_facility.csv\n", - "Processing scenario: ssp585\n", - "Models of interest ['HadGEM3-GC31-LL', 'GFDL-CM4', 'INM-CM5-0']\n", - "Processing file: CIL_subset_ssp585_2025.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2025, month 1\n", - "Processing year 2025, month 2\n", - "Processing year 2025, month 3\n", - "Processing year 2025, month 4\n", - "Processing year 2025, month 5\n", - "Processing year 2025, month 6\n", - "Processing year 2025, month 7\n", - "Processing year 2025, month 8\n", - "Processing year 2025, month 9\n", - "Processing year 2025, month 10\n", - "Processing year 2025, month 11\n", - "Processing year 2025, month 12\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Processing model: GFDL-CM4\n", - "Processing year 2025, month 1\n", - "Processing year 2025, month 2\n", - "Processing year 2025, month 3\n", - "Processing year 2025, month 4\n", - "Processing year 2025, month 5\n", - "Processing year 2025, month 6\n", - "Processing year 2025, month 7\n", - "Processing year 2025, month 8\n", - "Processing year 2025, month 9\n", - "Processing year 2025, month 10\n", - "Processing year 2025, month 11\n", - "Processing year 2025, month 12\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Processing model: INM-CM5-0\n", - "Processing year 2025, month 1\n", - "Processing year 2025, month 2\n", - "Processing year 2025, month 3\n", - "Processing year 2025, month 4\n", - "Processing year 2025, month 5\n", - "Processing year 2025, month 6\n", - "Processing year 2025, month 7\n", - "Processing year 2025, month 8\n", - "Processing year 2025, month 9\n", - "Processing year 2025, month 10\n", - "Processing year 2025, month 11\n", - "Processing year 2025, month 12\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/3528993389.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Processing file: CIL_subset_ssp585_2026.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2026, month 1\n", - "Processing year 2026, month 2\n", - "Processing year 2026, month 3\n", - "Processing year 2026, month 4\n", - "Processing year 2026, month 5\n", - "Processing year 2026, month 6\n", - "Processing year 2026, month 7\n", - "Processing year 2026, month 8\n", - "Processing year 2026, month 9\n", - "Processing year 2026, month 10\n", - "Processing year 2026, month 11\n", - "Processing year 2026, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2026, month 1\n", - "Processing year 2026, month 2\n", - "Processing year 2026, month 3\n", - "Processing year 2026, month 4\n", - "Processing year 2026, month 5\n", - "Processing year 2026, month 6\n", - "Processing year 2026, month 7\n", - "Processing year 2026, month 8\n", - "Processing year 2026, month 9\n", - "Processing year 2026, month 10\n", - "Processing year 2026, month 11\n", - "Processing year 2026, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2026, month 1\n", - "Processing year 2026, month 2\n", - "Processing year 2026, month 3\n", - "Processing year 2026, month 4\n", - "Processing year 2026, month 5\n", - "Processing year 2026, month 6\n", - "Processing year 2026, month 7\n", - "Processing year 2026, month 8\n", - "Processing year 2026, month 9\n", - "Processing year 2026, month 10\n", - "Processing year 2026, month 11\n", - "Processing year 2026, month 12\n", - "Processing file: CIL_subset_ssp585_2027.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2027, month 1\n", - "Processing year 2027, month 2\n", - "Processing year 2027, month 3\n", - "Processing year 2027, month 4\n", - "Processing year 2027, month 5\n", - "Processing year 2027, month 6\n", - "Processing year 2027, month 7\n", - "Processing year 2027, month 8\n", - "Processing year 2027, month 9\n", - "Processing year 2027, month 10\n", - "Processing year 2027, month 11\n", - "Processing year 2027, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2027, month 1\n", - "Processing year 2027, month 2\n", - "Processing year 2027, month 3\n", - "Processing year 2027, month 4\n", - "Processing year 2027, month 5\n", - "Processing year 2027, month 6\n", - "Processing year 2027, month 7\n", - "Processing year 2027, month 8\n", - "Processing year 2027, month 9\n", - "Processing year 2027, month 10\n", - "Processing year 2027, month 11\n", - "Processing year 2027, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2027, month 1\n", - "Processing year 2027, month 2\n", - "Processing year 2027, month 3\n", - "Processing year 2027, month 4\n", - "Processing year 2027, month 5\n", - "Processing year 2027, month 6\n", - "Processing year 2027, month 7\n", - "Processing year 2027, month 8\n", - "Processing year 2027, month 9\n", - "Processing year 2027, month 10\n", - "Processing year 2027, month 11\n", - "Processing year 2027, month 12\n", - "Processing file: CIL_subset_ssp585_2028.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2028, month 1\n", - "Processing year 2028, month 2\n", - "Processing year 2028, month 3\n", - "Processing year 2028, month 4\n", - "Processing year 2028, month 5\n", - "Processing year 2028, month 6\n", - "Processing year 2028, month 7\n", - "Processing year 2028, month 8\n", - "Processing year 2028, month 9\n", - "Processing year 2028, month 10\n", - "Processing year 2028, month 11\n", - "Processing year 2028, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2028, month 1\n", - "Processing year 2028, month 2\n", - "Processing year 2028, month 3\n", - "Processing year 2028, month 4\n", - "Processing year 2028, month 5\n", - "Processing year 2028, month 6\n", - "Processing year 2028, month 7\n", - "Processing year 2028, month 8\n", - "Processing year 2028, month 9\n", - "Processing year 2028, month 10\n", - "Processing year 2028, month 11\n", - "Processing year 2028, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2028, month 1\n", - "Processing year 2028, month 2\n", - "Processing year 2028, month 3\n", - "Processing year 2028, month 4\n", - "Processing year 2028, month 5\n", - "Processing year 2028, month 6\n", - "Processing year 2028, month 7\n", - "Processing year 2028, month 8\n", - "Processing year 2028, month 9\n", - "Processing year 2028, month 10\n", - "Processing year 2028, month 11\n", - "Processing year 2028, month 12\n", - "Processing file: CIL_subset_ssp585_2029.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2029, month 1\n", - "Processing year 2029, month 2\n", - "Processing year 2029, month 3\n", - "Processing year 2029, month 4\n", - "Processing year 2029, month 5\n", - "Processing year 2029, month 6\n", - "Processing year 2029, month 7\n", - "Processing year 2029, month 8\n", - "Processing year 2029, month 9\n", - "Processing year 2029, month 10\n", - "Processing year 2029, month 11\n", - "Processing year 2029, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2029, month 1\n", - "Processing year 2029, month 2\n", - "Processing year 2029, month 3\n", - "Processing year 2029, month 4\n", - "Processing year 2029, month 5\n", - "Processing year 2029, month 6\n", - "Processing year 2029, month 7\n", - "Processing year 2029, month 8\n", - "Processing year 2029, month 9\n", - "Processing year 2029, month 10\n", - "Processing year 2029, month 11\n", - "Processing year 2029, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2029, month 1\n", - "Processing year 2029, month 2\n", - "Processing year 2029, month 3\n", - "Processing year 2029, month 4\n", - "Processing year 2029, month 5\n", - "Processing year 2029, month 6\n", - "Processing year 2029, month 7\n", - "Processing year 2029, month 8\n", - "Processing year 2029, month 9\n", - "Processing year 2029, month 10\n", - "Processing year 2029, month 11\n", - "Processing year 2029, month 12\n", - "Processing file: CIL_subset_ssp585_2030.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2030, month 1\n", - "Processing year 2030, month 2\n", - "Processing year 2030, month 3\n", - "Processing year 2030, month 4\n", - "Processing year 2030, month 5\n", - "Processing year 2030, month 6\n", - "Processing year 2030, month 7\n", - "Processing year 2030, month 8\n", - "Processing year 2030, month 9\n", - "Processing year 2030, month 10\n", - "Processing year 2030, month 11\n", - "Processing year 2030, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2030, month 1\n", - "Processing year 2030, month 2\n", - "Processing year 2030, month 3\n", - "Processing year 2030, month 4\n", - "Processing year 2030, month 5\n", - "Processing year 2030, month 6\n", - "Processing year 2030, month 7\n", - "Processing year 2030, month 8\n", - "Processing year 2030, month 9\n", - "Processing year 2030, month 10\n", - "Processing year 2030, month 11\n", - "Processing year 2030, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2030, month 1\n", - "Processing year 2030, month 2\n", - "Processing year 2030, month 3\n", - "Processing year 2030, month 4\n", - "Processing year 2030, month 5\n", - "Processing year 2030, month 6\n", - "Processing year 2030, month 7\n", - "Processing year 2030, month 8\n", - "Processing year 2030, month 9\n", - "Processing year 2030, month 10\n", - "Processing year 2030, month 11\n", - "Processing year 2030, month 12\n", - "Processing file: CIL_subset_ssp585_2031.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2031, month 1\n", - "Processing year 2031, month 2\n", - "Processing year 2031, month 3\n", - "Processing year 2031, month 4\n", - "Processing year 2031, month 5\n", - "Processing year 2031, month 6\n", - "Processing year 2031, month 7\n", - "Processing year 2031, month 8\n", - "Processing year 2031, month 9\n", - "Processing year 2031, month 10\n", - "Processing year 2031, month 11\n", - "Processing year 2031, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2031, month 1\n", - "Processing year 2031, month 2\n", - "Processing year 2031, month 3\n", - "Processing year 2031, month 4\n", - "Processing year 2031, month 5\n", - "Processing year 2031, month 6\n", - "Processing year 2031, month 7\n", - "Processing year 2031, month 8\n", - "Processing year 2031, month 9\n", - "Processing year 2031, month 10\n", - "Processing year 2031, month 11\n", - "Processing year 2031, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2031, month 1\n", - "Processing year 2031, month 2\n", - "Processing year 2031, month 3\n", - "Processing year 2031, month 4\n", - "Processing year 2031, month 5\n", - "Processing year 2031, month 6\n", - "Processing year 2031, month 7\n", - "Processing year 2031, month 8\n", - "Processing year 2031, month 9\n", - "Processing year 2031, month 10\n", - "Processing year 2031, month 11\n", - "Processing year 2031, month 12\n", - "Processing file: CIL_subset_ssp585_2032.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2032, month 1\n", - "Processing year 2032, month 2\n", - "Processing year 2032, month 3\n", - "Processing year 2032, month 4\n", - "Processing year 2032, month 5\n", - "Processing year 2032, month 6\n", - "Processing year 2032, month 7\n", - "Processing year 2032, month 8\n", - "Processing year 2032, month 9\n", - "Processing year 2032, month 10\n", - "Processing year 2032, month 11\n", - "Processing year 2032, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2032, month 1\n", - "Processing year 2032, month 2\n", - "Processing year 2032, month 3\n", - "Processing year 2032, month 4\n", - "Processing year 2032, month 5\n", - "Processing year 2032, month 6\n", - "Processing year 2032, month 7\n", - "Processing year 2032, month 8\n", - "Processing year 2032, month 9\n", - "Processing year 2032, month 10\n", - "Processing year 2032, month 11\n", - "Processing year 2032, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2032, month 1\n", - "Processing year 2032, month 2\n", - "Processing year 2032, month 3\n", - "Processing year 2032, month 4\n", - "Processing year 2032, month 5\n", - "Processing year 2032, month 6\n", - "Processing year 2032, month 7\n", - "Processing year 2032, month 8\n", - "Processing year 2032, month 9\n", - "Processing year 2032, month 10\n", - "Processing year 2032, month 11\n", - "Processing year 2032, month 12\n", - "Processing file: CIL_subset_ssp585_2033.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2033, month 1\n", - "Processing year 2033, month 2\n", - "Processing year 2033, month 3\n", - "Processing year 2033, month 4\n", - "Processing year 2033, month 5\n", - "Processing year 2033, month 6\n", - "Processing year 2033, month 7\n", - "Processing year 2033, month 8\n", - "Processing year 2033, month 9\n", - "Processing year 2033, month 10\n", - "Processing year 2033, month 11\n", - "Processing year 2033, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2033, month 1\n", - "Processing year 2033, month 2\n", - "Processing year 2033, month 3\n", - "Processing year 2033, month 4\n", - "Processing year 2033, month 5\n", - "Processing year 2033, month 6\n", - "Processing year 2033, month 7\n", - "Processing year 2033, month 8\n", - "Processing year 2033, month 9\n", - "Processing year 2033, month 10\n", - "Processing year 2033, month 11\n", - "Processing year 2033, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2033, month 1\n", - "Processing year 2033, month 2\n", - "Processing year 2033, month 3\n", - "Processing year 2033, month 4\n", - "Processing year 2033, month 5\n", - "Processing year 2033, month 6\n", - "Processing year 2033, month 7\n", - "Processing year 2033, month 8\n", - "Processing year 2033, month 9\n", - "Processing year 2033, month 10\n", - "Processing year 2033, month 11\n", - "Processing year 2033, month 12\n", - "Processing file: CIL_subset_ssp585_2034.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2034, month 1\n", - "Processing year 2034, month 2\n", - "Processing year 2034, month 3\n", - "Processing year 2034, month 4\n", - "Processing year 2034, month 5\n", - "Processing year 2034, month 6\n", - "Processing year 2034, month 7\n", - "Processing year 2034, month 8\n", - "Processing year 2034, month 9\n", - "Processing year 2034, month 10\n", - "Processing year 2034, month 11\n", - "Processing year 2034, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2034, month 1\n", - "Processing year 2034, month 2\n", - "Processing year 2034, month 3\n", - "Processing year 2034, month 4\n", - "Processing year 2034, month 5\n", - "Processing year 2034, month 6\n", - "Processing year 2034, month 7\n", - "Processing year 2034, month 8\n", - "Processing year 2034, month 9\n", - "Processing year 2034, month 10\n", - "Processing year 2034, month 11\n", - "Processing year 2034, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2034, month 1\n", - "Processing year 2034, month 2\n", - "Processing year 2034, month 3\n", - "Processing year 2034, month 4\n", - "Processing year 2034, month 5\n", - "Processing year 2034, month 6\n", - "Processing year 2034, month 7\n", - "Processing year 2034, month 8\n", - "Processing year 2034, month 9\n", - "Processing year 2034, month 10\n", - "Processing year 2034, month 11\n", - "Processing year 2034, month 12\n", - "Processing file: CIL_subset_ssp585_2035.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2035, month 1\n", - "Processing year 2035, month 2\n", - "Processing year 2035, month 3\n", - "Processing year 2035, month 4\n", - "Processing year 2035, month 5\n", - "Processing year 2035, month 6\n", - "Processing year 2035, month 7\n", - "Processing year 2035, month 8\n", - "Processing year 2035, month 9\n", - "Processing year 2035, month 10\n", - "Processing year 2035, month 11\n", - "Processing year 2035, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2035, month 1\n", - "Processing year 2035, month 2\n", - "Processing year 2035, month 3\n", - "Processing year 2035, month 4\n", - "Processing year 2035, month 5\n", - "Processing year 2035, month 6\n", - "Processing year 2035, month 7\n", - "Processing year 2035, month 8\n", - "Processing year 2035, month 9\n", - "Processing year 2035, month 10\n", - "Processing year 2035, month 11\n", - "Processing year 2035, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2035, month 1\n", - "Processing year 2035, month 2\n", - "Processing year 2035, month 3\n", - "Processing year 2035, month 4\n", - "Processing year 2035, month 5\n", - "Processing year 2035, month 6\n", - "Processing year 2035, month 7\n", - "Processing year 2035, month 8\n", - "Processing year 2035, month 9\n", - "Processing year 2035, month 10\n", - "Processing year 2035, month 11\n", - "Processing year 2035, month 12\n", - "Processing file: CIL_subset_ssp585_2036.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2036, month 1\n", - "Processing year 2036, month 2\n", - "Processing year 2036, month 3\n", - "Processing year 2036, month 4\n", - "Processing year 2036, month 5\n", - "Processing year 2036, month 6\n", - "Processing year 2036, month 7\n", - "Processing year 2036, month 8\n", - "Processing year 2036, month 9\n", - "Processing year 2036, month 10\n", - "Processing year 2036, month 11\n", - "Processing year 2036, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2036, month 1\n", - "Processing year 2036, month 2\n", - "Processing year 2036, month 3\n", - "Processing year 2036, month 4\n", - "Processing year 2036, month 5\n", - "Processing year 2036, month 6\n", - "Processing year 2036, month 7\n", - "Processing year 2036, month 8\n", - "Processing year 2036, month 9\n", - "Processing year 2036, month 10\n", - "Processing year 2036, month 11\n", - "Processing year 2036, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2036, month 1\n", - "Processing year 2036, month 2\n", - "Processing year 2036, month 3\n", - "Processing year 2036, month 4\n", - "Processing year 2036, month 5\n", - "Processing year 2036, month 6\n", - "Processing year 2036, month 7\n", - "Processing year 2036, month 8\n", - "Processing year 2036, month 9\n", - "Processing year 2036, month 10\n", - "Processing year 2036, month 11\n", - "Processing year 2036, month 12\n", - "Processing file: CIL_subset_ssp585_2037.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2037, month 1\n", - "Processing year 2037, month 2\n", - "Processing year 2037, month 3\n", - "Processing year 2037, month 4\n", - "Processing year 2037, month 5\n", - "Processing year 2037, month 6\n", - "Processing year 2037, month 7\n", - "Processing year 2037, month 8\n", - "Processing year 2037, month 9\n", - "Processing year 2037, month 10\n", - "Processing year 2037, month 11\n", - "Processing year 2037, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2037, month 1\n", - "Processing year 2037, month 2\n", - "Processing year 2037, month 3\n", - "Processing year 2037, month 4\n", - "Processing year 2037, month 5\n", - "Processing year 2037, month 6\n", - "Processing year 2037, month 7\n", - "Processing year 2037, month 8\n", - "Processing year 2037, month 9\n", - "Processing year 2037, month 10\n", - "Processing year 2037, month 11\n", - "Processing year 2037, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2037, month 1\n", - "Processing year 2037, month 2\n", - "Processing year 2037, month 3\n", - "Processing year 2037, month 4\n", - "Processing year 2037, month 5\n", - "Processing year 2037, month 6\n", - "Processing year 2037, month 7\n", - "Processing year 2037, month 8\n", - "Processing year 2037, month 9\n", - "Processing year 2037, month 10\n", - "Processing year 2037, month 11\n", - "Processing year 2037, month 12\n", - "Processing file: CIL_subset_ssp585_2038.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2038, month 1\n", - "Processing year 2038, month 2\n", - "Processing year 2038, month 3\n", - "Processing year 2038, month 4\n", - "Processing year 2038, month 5\n", - "Processing year 2038, month 6\n", - "Processing year 2038, month 7\n", - "Processing year 2038, month 8\n", - "Processing year 2038, month 9\n", - "Processing year 2038, month 10\n", - "Processing year 2038, month 11\n", - "Processing year 2038, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2038, month 1\n", - "Processing year 2038, month 2\n", - "Processing year 2038, month 3\n", - "Processing year 2038, month 4\n", - "Processing year 2038, month 5\n", - "Processing year 2038, month 6\n", - "Processing year 2038, month 7\n", - "Processing year 2038, month 8\n", - "Processing year 2038, month 9\n", - "Processing year 2038, month 10\n", - "Processing year 2038, month 11\n", - "Processing year 2038, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2038, month 1\n", - "Processing year 2038, month 2\n", - "Processing year 2038, month 3\n", - "Processing year 2038, month 4\n", - "Processing year 2038, month 5\n", - "Processing year 2038, month 6\n", - "Processing year 2038, month 7\n", - "Processing year 2038, month 8\n", - "Processing year 2038, month 9\n", - "Processing year 2038, month 10\n", - "Processing year 2038, month 11\n", - "Processing year 2038, month 12\n", - "Processing file: CIL_subset_ssp585_2039.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2039, month 1\n", - "Processing year 2039, month 2\n", - "Processing year 2039, month 3\n", - "Processing year 2039, month 4\n", - "Processing year 2039, month 5\n", - "Processing year 2039, month 6\n", - "Processing year 2039, month 7\n", - "Processing year 2039, month 8\n", - "Processing year 2039, month 9\n", - "Processing year 2039, month 10\n", - "Processing year 2039, month 11\n", - "Processing year 2039, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2039, month 1\n", - "Processing year 2039, month 2\n", - "Processing year 2039, month 3\n", - "Processing year 2039, month 4\n", - "Processing year 2039, month 5\n", - "Processing year 2039, month 6\n", - "Processing year 2039, month 7\n", - "Processing year 2039, month 8\n", - "Processing year 2039, month 9\n", - "Processing year 2039, month 10\n", - "Processing year 2039, month 11\n", - "Processing year 2039, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2039, month 1\n", - "Processing year 2039, month 2\n", - "Processing year 2039, month 3\n", - "Processing year 2039, month 4\n", - "Processing year 2039, month 5\n", - "Processing year 2039, month 6\n", - "Processing year 2039, month 7\n", - "Processing year 2039, month 8\n", - "Processing year 2039, month 9\n", - "Processing year 2039, month 10\n", - "Processing year 2039, month 11\n", - "Processing year 2039, month 12\n", - "Processing file: CIL_subset_ssp585_2040.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2040, month 1\n", - "Processing year 2040, month 2\n", - "Processing year 2040, month 3\n", - "Processing year 2040, month 4\n", - "Processing year 2040, month 5\n", - "Processing year 2040, month 6\n", - "Processing year 2040, month 7\n", - "Processing year 2040, month 8\n", - "Processing year 2040, month 9\n", - "Processing year 2040, month 10\n", - "Processing year 2040, month 11\n", - "Processing year 2040, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2040, month 1\n", - "Processing year 2040, month 2\n", - "Processing year 2040, month 3\n", - "Processing year 2040, month 4\n", - "Processing year 2040, month 5\n", - "Processing year 2040, month 6\n", - "Processing year 2040, month 7\n", - "Processing year 2040, month 8\n", - "Processing year 2040, month 9\n", - "Processing year 2040, month 10\n", - "Processing year 2040, month 11\n", - "Processing year 2040, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2040, month 1\n", - "Processing year 2040, month 2\n", - "Processing year 2040, month 3\n", - "Processing year 2040, month 4\n", - "Processing year 2040, month 5\n", - "Processing year 2040, month 6\n", - "Processing year 2040, month 7\n", - "Processing year 2040, month 8\n", - "Processing year 2040, month 9\n", - "Processing year 2040, month 10\n", - "Processing year 2040, month 11\n", - "Processing year 2040, month 12\n", - "Processing file: CIL_subset_ssp585_2041.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2041, month 1\n", - "Processing year 2041, month 2\n", - "Processing year 2041, month 3\n", - "Processing year 2041, month 4\n", - "Processing year 2041, month 5\n", - "Processing year 2041, month 6\n", - "Processing year 2041, month 7\n", - "Processing year 2041, month 8\n", - "Processing year 2041, month 9\n", - "Processing year 2041, month 10\n", - "Processing year 2041, month 11\n", - "Processing year 2041, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2041, month 1\n", - "Processing year 2041, month 2\n", - "Processing year 2041, month 3\n", - "Processing year 2041, month 4\n", - "Processing year 2041, month 5\n", - "Processing year 2041, month 6\n", - "Processing year 2041, month 7\n", - "Processing year 2041, month 8\n", - "Processing year 2041, month 9\n", - "Processing year 2041, month 10\n", - "Processing year 2041, month 11\n", - "Processing year 2041, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2041, month 1\n", - "Processing year 2041, month 2\n", - "Processing year 2041, month 3\n", - "Processing year 2041, month 4\n", - "Processing year 2041, month 5\n", - "Processing year 2041, month 6\n", - "Processing year 2041, month 7\n", - "Processing year 2041, month 8\n", - "Processing year 2041, month 9\n", - "Processing year 2041, month 10\n", - "Processing year 2041, month 11\n", - "Processing year 2041, month 12\n", - "Processing file: CIL_subset_ssp585_2042.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2042, month 1\n", - "Processing year 2042, month 2\n", - "Processing year 2042, month 3\n", - "Processing year 2042, month 4\n", - "Processing year 2042, month 5\n", - "Processing year 2042, month 6\n", - "Processing year 2042, month 7\n", - "Processing year 2042, month 8\n", - "Processing year 2042, month 9\n", - "Processing year 2042, month 10\n", - "Processing year 2042, month 11\n", - "Processing year 2042, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2042, month 1\n", - "Processing year 2042, month 2\n", - "Processing year 2042, month 3\n", - "Processing year 2042, month 4\n", - "Processing year 2042, month 5\n", - "Processing year 2042, month 6\n", - "Processing year 2042, month 7\n", - "Processing year 2042, month 8\n", - "Processing year 2042, month 9\n", - "Processing year 2042, month 10\n", - "Processing year 2042, month 11\n", - "Processing year 2042, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2042, month 1\n", - "Processing year 2042, month 2\n", - "Processing year 2042, month 3\n", - "Processing year 2042, month 4\n", - "Processing year 2042, month 5\n", - "Processing year 2042, month 6\n", - "Processing year 2042, month 7\n", - "Processing year 2042, month 8\n", - "Processing year 2042, month 9\n", - "Processing year 2042, month 10\n", - "Processing year 2042, month 11\n", - "Processing year 2042, month 12\n", - "Processing file: CIL_subset_ssp585_2043.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2043, month 1\n", - "Processing year 2043, month 2\n", - "Processing year 2043, month 3\n", - "Processing year 2043, month 4\n", - "Processing year 2043, month 5\n", - "Processing year 2043, month 6\n", - "Processing year 2043, month 7\n", - "Processing year 2043, month 8\n", - "Processing year 2043, month 9\n", - "Processing year 2043, month 10\n", - "Processing year 2043, month 11\n", - "Processing year 2043, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2043, month 1\n", - "Processing year 2043, month 2\n", - "Processing year 2043, month 3\n", - "Processing year 2043, month 4\n", - "Processing year 2043, month 5\n", - "Processing year 2043, month 6\n", - "Processing year 2043, month 7\n", - "Processing year 2043, month 8\n", - "Processing year 2043, month 9\n", - "Processing year 2043, month 10\n", - "Processing year 2043, month 11\n", - "Processing year 2043, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2043, month 1\n", - "Processing year 2043, month 2\n", - "Processing year 2043, month 3\n", - "Processing year 2043, month 4\n", - "Processing year 2043, month 5\n", - "Processing year 2043, month 6\n", - "Processing year 2043, month 7\n", - "Processing year 2043, month 8\n", - "Processing year 2043, month 9\n", - "Processing year 2043, month 10\n", - "Processing year 2043, month 11\n", - "Processing year 2043, month 12\n", - "Processing file: CIL_subset_ssp585_2044.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2044, month 1\n", - "Processing year 2044, month 2\n", - "Processing year 2044, month 3\n", - "Processing year 2044, month 4\n", - "Processing year 2044, month 5\n", - "Processing year 2044, month 6\n", - "Processing year 2044, month 7\n", - "Processing year 2044, month 8\n", - "Processing year 2044, month 9\n", - "Processing year 2044, month 10\n", - "Processing year 2044, month 11\n", - "Processing year 2044, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2044, month 1\n", - "Processing year 2044, month 2\n", - "Processing year 2044, month 3\n", - "Processing year 2044, month 4\n", - "Processing year 2044, month 5\n", - "Processing year 2044, month 6\n", - "Processing year 2044, month 7\n", - "Processing year 2044, month 8\n", - "Processing year 2044, month 9\n", - "Processing year 2044, month 10\n", - "Processing year 2044, month 11\n", - "Processing year 2044, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2044, month 1\n", - "Processing year 2044, month 2\n", - "Processing year 2044, month 3\n", - "Processing year 2044, month 4\n", - "Processing year 2044, month 5\n", - "Processing year 2044, month 6\n", - "Processing year 2044, month 7\n", - "Processing year 2044, month 8\n", - "Processing year 2044, month 9\n", - "Processing year 2044, month 10\n", - "Processing year 2044, month 11\n", - "Processing year 2044, month 12\n", - "Processing file: CIL_subset_ssp585_2045.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2045, month 1\n", - "Processing year 2045, month 2\n", - "Processing year 2045, month 3\n", - "Processing year 2045, month 4\n", - "Processing year 2045, month 5\n", - "Processing year 2045, month 6\n", - "Processing year 2045, month 7\n", - "Processing year 2045, month 8\n", - "Processing year 2045, month 9\n", - "Processing year 2045, month 10\n", - "Processing year 2045, month 11\n", - "Processing year 2045, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2045, month 1\n", - "Processing year 2045, month 2\n", - "Processing year 2045, month 3\n", - "Processing year 2045, month 4\n", - "Processing year 2045, month 5\n", - "Processing year 2045, month 6\n", - "Processing year 2045, month 7\n", - "Processing year 2045, month 8\n", - "Processing year 2045, month 9\n", - "Processing year 2045, month 10\n", - "Processing year 2045, month 11\n", - "Processing year 2045, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2045, month 1\n", - "Processing year 2045, month 2\n", - "Processing year 2045, month 3\n", - "Processing year 2045, month 4\n", - "Processing year 2045, month 5\n", - "Processing year 2045, month 6\n", - "Processing year 2045, month 7\n", - "Processing year 2045, month 8\n", - "Processing year 2045, month 9\n", - "Processing year 2045, month 10\n", - "Processing year 2045, month 11\n", - "Processing year 2045, month 12\n", - "Processing file: CIL_subset_ssp585_2046.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2046, month 1\n", - "Processing year 2046, month 2\n", - "Processing year 2046, month 3\n", - "Processing year 2046, month 4\n", - "Processing year 2046, month 5\n", - "Processing year 2046, month 6\n", - "Processing year 2046, month 7\n", - "Processing year 2046, month 8\n", - "Processing year 2046, month 9\n", - "Processing year 2046, month 10\n", - "Processing year 2046, month 11\n", - "Processing year 2046, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2046, month 1\n", - "Processing year 2046, month 2\n", - "Processing year 2046, month 3\n", - "Processing year 2046, month 4\n", - "Processing year 2046, month 5\n", - "Processing year 2046, month 6\n", - "Processing year 2046, month 7\n", - "Processing year 2046, month 8\n", - "Processing year 2046, month 9\n", - "Processing year 2046, month 10\n", - "Processing year 2046, month 11\n", - "Processing year 2046, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2046, month 1\n", - "Processing year 2046, month 2\n", - "Processing year 2046, month 3\n", - "Processing year 2046, month 4\n", - "Processing year 2046, month 5\n", - "Processing year 2046, month 6\n", - "Processing year 2046, month 7\n", - "Processing year 2046, month 8\n", - "Processing year 2046, month 9\n", - "Processing year 2046, month 10\n", - "Processing year 2046, month 11\n", - "Processing year 2046, month 12\n", - "Processing file: CIL_subset_ssp585_2047.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2047, month 1\n", - "Processing year 2047, month 2\n", - "Processing year 2047, month 3\n", - "Processing year 2047, month 4\n", - "Processing year 2047, month 5\n", - "Processing year 2047, month 6\n", - "Processing year 2047, month 7\n", - "Processing year 2047, month 8\n", - "Processing year 2047, month 9\n", - "Processing year 2047, month 10\n", - "Processing year 2047, month 11\n", - "Processing year 2047, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2047, month 1\n", - "Processing year 2047, month 2\n", - "Processing year 2047, month 3\n", - "Processing year 2047, month 4\n", - "Processing year 2047, month 5\n", - "Processing year 2047, month 6\n", - "Processing year 2047, month 7\n", - "Processing year 2047, month 8\n", - "Processing year 2047, month 9\n", - "Processing year 2047, month 10\n", - "Processing year 2047, month 11\n", - "Processing year 2047, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2047, month 1\n", - "Processing year 2047, month 2\n", - "Processing year 2047, month 3\n", - "Processing year 2047, month 4\n", - "Processing year 2047, month 5\n", - "Processing year 2047, month 6\n", - "Processing year 2047, month 7\n", - "Processing year 2047, month 8\n", - "Processing year 2047, month 9\n", - "Processing year 2047, month 10\n", - "Processing year 2047, month 11\n", - "Processing year 2047, month 12\n", - "Processing file: CIL_subset_ssp585_2048.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2048, month 1\n", - "Processing year 2048, month 2\n", - "Processing year 2048, month 3\n", - "Processing year 2048, month 4\n", - "Processing year 2048, month 5\n", - "Processing year 2048, month 6\n", - "Processing year 2048, month 7\n", - "Processing year 2048, month 8\n", - "Processing year 2048, month 9\n", - "Processing year 2048, month 10\n", - "Processing year 2048, month 11\n", - "Processing year 2048, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2048, month 1\n", - "Processing year 2048, month 2\n", - "Processing year 2048, month 3\n", - "Processing year 2048, month 4\n", - "Processing year 2048, month 5\n", - "Processing year 2048, month 6\n", - "Processing year 2048, month 7\n", - "Processing year 2048, month 8\n", - "Processing year 2048, month 9\n", - "Processing year 2048, month 10\n", - "Processing year 2048, month 11\n", - "Processing year 2048, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2048, month 1\n", - "Processing year 2048, month 2\n", - "Processing year 2048, month 3\n", - "Processing year 2048, month 4\n", - "Processing year 2048, month 5\n", - "Processing year 2048, month 6\n", - "Processing year 2048, month 7\n", - "Processing year 2048, month 8\n", - "Processing year 2048, month 9\n", - "Processing year 2048, month 10\n", - "Processing year 2048, month 11\n", - "Processing year 2048, month 12\n", - "Processing file: CIL_subset_ssp585_2049.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2049, month 1\n", - "Processing year 2049, month 2\n", - "Processing year 2049, month 3\n", - "Processing year 2049, month 4\n", - "Processing year 2049, month 5\n", - "Processing year 2049, month 6\n", - "Processing year 2049, month 7\n", - "Processing year 2049, month 8\n", - "Processing year 2049, month 9\n", - "Processing year 2049, month 10\n", - "Processing year 2049, month 11\n", - "Processing year 2049, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2049, month 1\n", - "Processing year 2049, month 2\n", - "Processing year 2049, month 3\n", - "Processing year 2049, month 4\n", - "Processing year 2049, month 5\n", - "Processing year 2049, month 6\n", - "Processing year 2049, month 7\n", - "Processing year 2049, month 8\n", - "Processing year 2049, month 9\n", - "Processing year 2049, month 10\n", - "Processing year 2049, month 11\n", - "Processing year 2049, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2049, month 1\n", - "Processing year 2049, month 2\n", - "Processing year 2049, month 3\n", - "Processing year 2049, month 4\n", - "Processing year 2049, month 5\n", - "Processing year 2049, month 6\n", - "Processing year 2049, month 7\n", - "Processing year 2049, month 8\n", - "Processing year 2049, month 9\n", - "Processing year 2049, month 10\n", - "Processing year 2049, month 11\n", - "Processing year 2049, month 12\n", - "Processing file: CIL_subset_ssp585_2050.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2050, month 1\n", - "Processing year 2050, month 2\n", - "Processing year 2050, month 3\n", - "Processing year 2050, month 4\n", - "Processing year 2050, month 5\n", - "Processing year 2050, month 6\n", - "Processing year 2050, month 7\n", - "Processing year 2050, month 8\n", - "Processing year 2050, month 9\n", - "Processing year 2050, month 10\n", - "Processing year 2050, month 11\n", - "Processing year 2050, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2050, month 1\n", - "Processing year 2050, month 2\n", - "Processing year 2050, month 3\n", - "Processing year 2050, month 4\n", - "Processing year 2050, month 5\n", - "Processing year 2050, month 6\n", - "Processing year 2050, month 7\n", - "Processing year 2050, month 8\n", - "Processing year 2050, month 9\n", - "Processing year 2050, month 10\n", - "Processing year 2050, month 11\n", - "Processing year 2050, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2050, month 1\n", - "Processing year 2050, month 2\n", - "Processing year 2050, month 3\n", - "Processing year 2050, month 4\n", - "Processing year 2050, month 5\n", - "Processing year 2050, month 6\n", - "Processing year 2050, month 7\n", - "Processing year 2050, month 8\n", - "Processing year 2050, month 9\n", - "Processing year 2050, month 10\n", - "Processing year 2050, month 11\n", - "Processing year 2050, month 12\n", - "Processing file: CIL_subset_ssp585_2051.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2051, month 1\n", - "Processing year 2051, month 2\n", - "Processing year 2051, month 3\n", - "Processing year 2051, month 4\n", - "Processing year 2051, month 5\n", - "Processing year 2051, month 6\n", - "Processing year 2051, month 7\n", - "Processing year 2051, month 8\n", - "Processing year 2051, month 9\n", - "Processing year 2051, month 10\n", - "Processing year 2051, month 11\n", - "Processing year 2051, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2051, month 1\n", - "Processing year 2051, month 2\n", - "Processing year 2051, month 3\n", - "Processing year 2051, month 4\n", - "Processing year 2051, month 5\n", - "Processing year 2051, month 6\n", - "Processing year 2051, month 7\n", - "Processing year 2051, month 8\n", - "Processing year 2051, month 9\n", - "Processing year 2051, month 10\n", - "Processing year 2051, month 11\n", - "Processing year 2051, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2051, month 1\n", - "Processing year 2051, month 2\n", - "Processing year 2051, month 3\n", - "Processing year 2051, month 4\n", - "Processing year 2051, month 5\n", - "Processing year 2051, month 6\n", - "Processing year 2051, month 7\n", - "Processing year 2051, month 8\n", - "Processing year 2051, month 9\n", - "Processing year 2051, month 10\n", - "Processing year 2051, month 11\n", - "Processing year 2051, month 12\n", - "Processing file: CIL_subset_ssp585_2052.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2052, month 1\n", - "Processing year 2052, month 2\n", - "Processing year 2052, month 3\n", - "Processing year 2052, month 4\n", - "Processing year 2052, month 5\n", - "Processing year 2052, month 6\n", - "Processing year 2052, month 7\n", - "Processing year 2052, month 8\n", - "Processing year 2052, month 9\n", - "Processing year 2052, month 10\n", - "Processing year 2052, month 11\n", - "Processing year 2052, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2052, month 1\n", - "Processing year 2052, month 2\n", - "Processing year 2052, month 3\n", - "Processing year 2052, month 4\n", - "Processing year 2052, month 5\n", - "Processing year 2052, month 6\n", - "Processing year 2052, month 7\n", - "Processing year 2052, month 8\n", - "Processing year 2052, month 9\n", - "Processing year 2052, month 10\n", - "Processing year 2052, month 11\n", - "Processing year 2052, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2052, month 1\n", - "Processing year 2052, month 2\n", - "Processing year 2052, month 3\n", - "Processing year 2052, month 4\n", - "Processing year 2052, month 5\n", - "Processing year 2052, month 6\n", - "Processing year 2052, month 7\n", - "Processing year 2052, month 8\n", - "Processing year 2052, month 9\n", - "Processing year 2052, month 10\n", - "Processing year 2052, month 11\n", - "Processing year 2052, month 12\n", - "Processing file: CIL_subset_ssp585_2053.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2053, month 1\n", - "Processing year 2053, month 2\n", - "Processing year 2053, month 3\n", - "Processing year 2053, month 4\n", - "Processing year 2053, month 5\n", - "Processing year 2053, month 6\n", - "Processing year 2053, month 7\n", - "Processing year 2053, month 8\n", - "Processing year 2053, month 9\n", - "Processing year 2053, month 10\n", - "Processing year 2053, month 11\n", - "Processing year 2053, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2053, month 1\n", - "Processing year 2053, month 2\n", - "Processing year 2053, month 3\n", - "Processing year 2053, month 4\n", - "Processing year 2053, month 5\n", - "Processing year 2053, month 6\n", - "Processing year 2053, month 7\n", - "Processing year 2053, month 8\n", - "Processing year 2053, month 9\n", - "Processing year 2053, month 10\n", - "Processing year 2053, month 11\n", - "Processing year 2053, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2053, month 1\n", - "Processing year 2053, month 2\n", - "Processing year 2053, month 3\n", - "Processing year 2053, month 4\n", - "Processing year 2053, month 5\n", - "Processing year 2053, month 6\n", - "Processing year 2053, month 7\n", - "Processing year 2053, month 8\n", - "Processing year 2053, month 9\n", - "Processing year 2053, month 10\n", - "Processing year 2053, month 11\n", - "Processing year 2053, month 12\n", - "Processing file: CIL_subset_ssp585_2054.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2054, month 1\n", - "Processing year 2054, month 2\n", - "Processing year 2054, month 3\n", - "Processing year 2054, month 4\n", - "Processing year 2054, month 5\n", - "Processing year 2054, month 6\n", - "Processing year 2054, month 7\n", - "Processing year 2054, month 8\n", - "Processing year 2054, month 9\n", - "Processing year 2054, month 10\n", - "Processing year 2054, month 11\n", - "Processing year 2054, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2054, month 1\n", - "Processing year 2054, month 2\n", - "Processing year 2054, month 3\n", - "Processing year 2054, month 4\n", - "Processing year 2054, month 5\n", - "Processing year 2054, month 6\n", - "Processing year 2054, month 7\n", - "Processing year 2054, month 8\n", - "Processing year 2054, month 9\n", - "Processing year 2054, month 10\n", - "Processing year 2054, month 11\n", - "Processing year 2054, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2054, month 1\n", - "Processing year 2054, month 2\n", - "Processing year 2054, month 3\n", - "Processing year 2054, month 4\n", - "Processing year 2054, month 5\n", - "Processing year 2054, month 6\n", - "Processing year 2054, month 7\n", - "Processing year 2054, month 8\n", - "Processing year 2054, month 9\n", - "Processing year 2054, month 10\n", - "Processing year 2054, month 11\n", - "Processing year 2054, month 12\n", - "Processing file: CIL_subset_ssp585_2055.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2055, month 1\n", - "Processing year 2055, month 2\n", - "Processing year 2055, month 3\n", - "Processing year 2055, month 4\n", - "Processing year 2055, month 5\n", - "Processing year 2055, month 6\n", - "Processing year 2055, month 7\n", - "Processing year 2055, month 8\n", - "Processing year 2055, month 9\n", - "Processing year 2055, month 10\n", - "Processing year 2055, month 11\n", - "Processing year 2055, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2055, month 1\n", - "Processing year 2055, month 2\n", - "Processing year 2055, month 3\n", - "Processing year 2055, month 4\n", - "Processing year 2055, month 5\n", - "Processing year 2055, month 6\n", - "Processing year 2055, month 7\n", - "Processing year 2055, month 8\n", - "Processing year 2055, month 9\n", - "Processing year 2055, month 10\n", - "Processing year 2055, month 11\n", - "Processing year 2055, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2055, month 1\n", - "Processing year 2055, month 2\n", - "Processing year 2055, month 3\n", - "Processing year 2055, month 4\n", - "Processing year 2055, month 5\n", - "Processing year 2055, month 6\n", - "Processing year 2055, month 7\n", - "Processing year 2055, month 8\n", - "Processing year 2055, month 9\n", - "Processing year 2055, month 10\n", - "Processing year 2055, month 11\n", - "Processing year 2055, month 12\n", - "Processing file: CIL_subset_ssp585_2056.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2056, month 1\n", - "Processing year 2056, month 2\n", - "Processing year 2056, month 3\n", - "Processing year 2056, month 4\n", - "Processing year 2056, month 5\n", - "Processing year 2056, month 6\n", - "Processing year 2056, month 7\n", - "Processing year 2056, month 8\n", - "Processing year 2056, month 9\n", - "Processing year 2056, month 10\n", - "Processing year 2056, month 11\n", - "Processing year 2056, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2056, month 1\n", - "Processing year 2056, month 2\n", - "Processing year 2056, month 3\n", - "Processing year 2056, month 4\n", - "Processing year 2056, month 5\n", - "Processing year 2056, month 6\n", - "Processing year 2056, month 7\n", - "Processing year 2056, month 8\n", - "Processing year 2056, month 9\n", - "Processing year 2056, month 10\n", - "Processing year 2056, month 11\n", - "Processing year 2056, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2056, month 1\n", - "Processing year 2056, month 2\n", - "Processing year 2056, month 3\n", - "Processing year 2056, month 4\n", - "Processing year 2056, month 5\n", - "Processing year 2056, month 6\n", - "Processing year 2056, month 7\n", - "Processing year 2056, month 8\n", - "Processing year 2056, month 9\n", - "Processing year 2056, month 10\n", - "Processing year 2056, month 11\n", - "Processing year 2056, month 12\n", - "Processing file: CIL_subset_ssp585_2057.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2057, month 1\n", - "Processing year 2057, month 2\n", - "Processing year 2057, month 3\n", - "Processing year 2057, month 4\n", - "Processing year 2057, month 5\n", - "Processing year 2057, month 6\n", - "Processing year 2057, month 7\n", - "Processing year 2057, month 8\n", - "Processing year 2057, month 9\n", - "Processing year 2057, month 10\n", - "Processing year 2057, month 11\n", - "Processing year 2057, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2057, month 1\n", - "Processing year 2057, month 2\n", - "Processing year 2057, month 3\n", - "Processing year 2057, month 4\n", - "Processing year 2057, month 5\n", - "Processing year 2057, month 6\n", - "Processing year 2057, month 7\n", - "Processing year 2057, month 8\n", - "Processing year 2057, month 9\n", - "Processing year 2057, month 10\n", - "Processing year 2057, month 11\n", - "Processing year 2057, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2057, month 1\n", - "Processing year 2057, month 2\n", - "Processing year 2057, month 3\n", - "Processing year 2057, month 4\n", - "Processing year 2057, month 5\n", - "Processing year 2057, month 6\n", - "Processing year 2057, month 7\n", - "Processing year 2057, month 8\n", - "Processing year 2057, month 9\n", - "Processing year 2057, month 10\n", - "Processing year 2057, month 11\n", - "Processing year 2057, month 12\n", - "Processing file: CIL_subset_ssp585_2058.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2058, month 1\n", - "Processing year 2058, month 2\n", - "Processing year 2058, month 3\n", - "Processing year 2058, month 4\n", - "Processing year 2058, month 5\n", - "Processing year 2058, month 6\n", - "Processing year 2058, month 7\n", - "Processing year 2058, month 8\n", - "Processing year 2058, month 9\n", - "Processing year 2058, month 10\n", - "Processing year 2058, month 11\n", - "Processing year 2058, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2058, month 1\n", - "Processing year 2058, month 2\n", - "Processing year 2058, month 3\n", - "Processing year 2058, month 4\n", - "Processing year 2058, month 5\n", - "Processing year 2058, month 6\n", - "Processing year 2058, month 7\n", - "Processing year 2058, month 8\n", - "Processing year 2058, month 9\n", - "Processing year 2058, month 10\n", - "Processing year 2058, month 11\n", - "Processing year 2058, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2058, month 1\n", - "Processing year 2058, month 2\n", - "Processing year 2058, month 3\n", - "Processing year 2058, month 4\n", - "Processing year 2058, month 5\n", - "Processing year 2058, month 6\n", - "Processing year 2058, month 7\n", - "Processing year 2058, month 8\n", - "Processing year 2058, month 9\n", - "Processing year 2058, month 10\n", - "Processing year 2058, month 11\n", - "Processing year 2058, month 12\n", - "Processing file: CIL_subset_ssp585_2059.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2059, month 1\n", - "Processing year 2059, month 2\n", - "Processing year 2059, month 3\n", - "Processing year 2059, month 4\n", - "Processing year 2059, month 5\n", - "Processing year 2059, month 6\n", - "Processing year 2059, month 7\n", - "Processing year 2059, month 8\n", - "Processing year 2059, month 9\n", - "Processing year 2059, month 10\n", - "Processing year 2059, month 11\n", - "Processing year 2059, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2059, month 1\n", - "Processing year 2059, month 2\n", - "Processing year 2059, month 3\n", - "Processing year 2059, month 4\n", - "Processing year 2059, month 5\n", - "Processing year 2059, month 6\n", - "Processing year 2059, month 7\n", - "Processing year 2059, month 8\n", - "Processing year 2059, month 9\n", - "Processing year 2059, month 10\n", - "Processing year 2059, month 11\n", - "Processing year 2059, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2059, month 1\n", - "Processing year 2059, month 2\n", - "Processing year 2059, month 3\n", - "Processing year 2059, month 4\n", - "Processing year 2059, month 5\n", - "Processing year 2059, month 6\n", - "Processing year 2059, month 7\n", - "Processing year 2059, month 8\n", - "Processing year 2059, month 9\n", - "Processing year 2059, month 10\n", - "Processing year 2059, month 11\n", - "Processing year 2059, month 12\n", - "Processing file: CIL_subset_ssp585_2060.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2060, month 1\n", - "Processing year 2060, month 2\n", - "Processing year 2060, month 3\n", - "Processing year 2060, month 4\n", - "Processing year 2060, month 5\n", - "Processing year 2060, month 6\n", - "Processing year 2060, month 7\n", - "Processing year 2060, month 8\n", - "Processing year 2060, month 9\n", - "Processing year 2060, month 10\n", - "Processing year 2060, month 11\n", - "Processing year 2060, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2060, month 1\n", - "Processing year 2060, month 2\n", - "Processing year 2060, month 3\n", - "Processing year 2060, month 4\n", - "Processing year 2060, month 5\n", - "Processing year 2060, month 6\n", - "Processing year 2060, month 7\n", - "Processing year 2060, month 8\n", - "Processing year 2060, month 9\n", - "Processing year 2060, month 10\n", - "Processing year 2060, month 11\n", - "Processing year 2060, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2060, month 1\n", - "Processing year 2060, month 2\n", - "Processing year 2060, month 3\n", - "Processing year 2060, month 4\n", - "Processing year 2060, month 5\n", - "Processing year 2060, month 6\n", - "Processing year 2060, month 7\n", - "Processing year 2060, month 8\n", - "Processing year 2060, month 9\n", - "Processing year 2060, month 10\n", - "Processing year 2060, month 11\n", - "Processing year 2060, month 12\n", - "Processing file: CIL_subset_ssp585_2061.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2061, month 1\n", - "Processing year 2061, month 2\n", - "Processing year 2061, month 3\n", - "Processing year 2061, month 4\n", - "Processing year 2061, month 5\n", - "Processing year 2061, month 6\n", - "Processing year 2061, month 7\n", - "Processing year 2061, month 8\n", - "Processing year 2061, month 9\n", - "Processing year 2061, month 10\n", - "Processing year 2061, month 11\n", - "Processing year 2061, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2061, month 1\n", - "Processing year 2061, month 2\n", - "Processing year 2061, month 3\n", - "Processing year 2061, month 4\n", - "Processing year 2061, month 5\n", - "Processing year 2061, month 6\n", - "Processing year 2061, month 7\n", - "Processing year 2061, month 8\n", - "Processing year 2061, month 9\n", - "Processing year 2061, month 10\n", - "Processing year 2061, month 11\n", - "Processing year 2061, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2061, month 1\n", - "Processing year 2061, month 2\n", - "Processing year 2061, month 3\n", - "Processing year 2061, month 4\n", - "Processing year 2061, month 5\n", - "Processing year 2061, month 6\n", - "Processing year 2061, month 7\n", - "Processing year 2061, month 8\n", - "Processing year 2061, month 9\n", - "Processing year 2061, month 10\n", - "Processing year 2061, month 11\n", - "Processing year 2061, month 12\n", - "Processing file: CIL_subset_ssp585_2062.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2062, month 1\n", - "Processing year 2062, month 2\n", - "Processing year 2062, month 3\n", - "Processing year 2062, month 4\n", - "Processing year 2062, month 5\n", - "Processing year 2062, month 6\n", - "Processing year 2062, month 7\n", - "Processing year 2062, month 8\n", - "Processing year 2062, month 9\n", - "Processing year 2062, month 10\n", - "Processing year 2062, month 11\n", - "Processing year 2062, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2062, month 1\n", - "Processing year 2062, month 2\n", - "Processing year 2062, month 3\n", - "Processing year 2062, month 4\n", - "Processing year 2062, month 5\n", - "Processing year 2062, month 6\n", - "Processing year 2062, month 7\n", - "Processing year 2062, month 8\n", - "Processing year 2062, month 9\n", - "Processing year 2062, month 10\n", - "Processing year 2062, month 11\n", - "Processing year 2062, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2062, month 1\n", - "Processing year 2062, month 2\n", - "Processing year 2062, month 3\n", - "Processing year 2062, month 4\n", - "Processing year 2062, month 5\n", - "Processing year 2062, month 6\n", - "Processing year 2062, month 7\n", - "Processing year 2062, month 8\n", - "Processing year 2062, month 9\n", - "Processing year 2062, month 10\n", - "Processing year 2062, month 11\n", - "Processing year 2062, month 12\n", - "Processing file: CIL_subset_ssp585_2063.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2063, month 1\n", - "Processing year 2063, month 2\n", - "Processing year 2063, month 3\n", - "Processing year 2063, month 4\n", - "Processing year 2063, month 5\n", - "Processing year 2063, month 6\n", - "Processing year 2063, month 7\n", - "Processing year 2063, month 8\n", - "Processing year 2063, month 9\n", - "Processing year 2063, month 10\n", - "Processing year 2063, month 11\n", - "Processing year 2063, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2063, month 1\n", - "Processing year 2063, month 2\n", - "Processing year 2063, month 3\n", - "Processing year 2063, month 4\n", - "Processing year 2063, month 5\n", - "Processing year 2063, month 6\n", - "Processing year 2063, month 7\n", - "Processing year 2063, month 8\n", - "Processing year 2063, month 9\n", - "Processing year 2063, month 10\n", - "Processing year 2063, month 11\n", - "Processing year 2063, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2063, month 1\n", - "Processing year 2063, month 2\n", - "Processing year 2063, month 3\n", - "Processing year 2063, month 4\n", - "Processing year 2063, month 5\n", - "Processing year 2063, month 6\n", - "Processing year 2063, month 7\n", - "Processing year 2063, month 8\n", - "Processing year 2063, month 9\n", - "Processing year 2063, month 10\n", - "Processing year 2063, month 11\n", - "Processing year 2063, month 12\n", - "Processing file: CIL_subset_ssp585_2064.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2064, month 1\n", - "Processing year 2064, month 2\n", - "Processing year 2064, month 3\n", - "Processing year 2064, month 4\n", - "Processing year 2064, month 5\n", - "Processing year 2064, month 6\n", - "Processing year 2064, month 7\n", - "Processing year 2064, month 8\n", - "Processing year 2064, month 9\n", - "Processing year 2064, month 10\n", - "Processing year 2064, month 11\n", - "Processing year 2064, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2064, month 1\n", - "Processing year 2064, month 2\n", - "Processing year 2064, month 3\n", - "Processing year 2064, month 4\n", - "Processing year 2064, month 5\n", - "Processing year 2064, month 6\n", - "Processing year 2064, month 7\n", - "Processing year 2064, month 8\n", - "Processing year 2064, month 9\n", - "Processing year 2064, month 10\n", - "Processing year 2064, month 11\n", - "Processing year 2064, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2064, month 1\n", - "Processing year 2064, month 2\n", - "Processing year 2064, month 3\n", - "Processing year 2064, month 4\n", - "Processing year 2064, month 5\n", - "Processing year 2064, month 6\n", - "Processing year 2064, month 7\n", - "Processing year 2064, month 8\n", - "Processing year 2064, month 9\n", - "Processing year 2064, month 10\n", - "Processing year 2064, month 11\n", - "Processing year 2064, month 12\n", - "Processing file: CIL_subset_ssp585_2065.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2065, month 1\n", - "Processing year 2065, month 2\n", - "Processing year 2065, month 3\n", - "Processing year 2065, month 4\n", - "Processing year 2065, month 5\n", - "Processing year 2065, month 6\n", - "Processing year 2065, month 7\n", - "Processing year 2065, month 8\n", - "Processing year 2065, month 9\n", - "Processing year 2065, month 10\n", - "Processing year 2065, month 11\n", - "Processing year 2065, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2065, month 1\n", - "Processing year 2065, month 2\n", - "Processing year 2065, month 3\n", - "Processing year 2065, month 4\n", - "Processing year 2065, month 5\n", - "Processing year 2065, month 6\n", - "Processing year 2065, month 7\n", - "Processing year 2065, month 8\n", - "Processing year 2065, month 9\n", - "Processing year 2065, month 10\n", - "Processing year 2065, month 11\n", - "Processing year 2065, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2065, month 1\n", - "Processing year 2065, month 2\n", - "Processing year 2065, month 3\n", - "Processing year 2065, month 4\n", - "Processing year 2065, month 5\n", - "Processing year 2065, month 6\n", - "Processing year 2065, month 7\n", - "Processing year 2065, month 8\n", - "Processing year 2065, month 9\n", - "Processing year 2065, month 10\n", - "Processing year 2065, month 11\n", - "Processing year 2065, month 12\n", - "Processing file: CIL_subset_ssp585_2066.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2066, month 1\n", - "Processing year 2066, month 2\n", - "Processing year 2066, month 3\n", - "Processing year 2066, month 4\n", - "Processing year 2066, month 5\n", - "Processing year 2066, month 6\n", - "Processing year 2066, month 7\n", - "Processing year 2066, month 8\n", - "Processing year 2066, month 9\n", - "Processing year 2066, month 10\n", - "Processing year 2066, month 11\n", - "Processing year 2066, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2066, month 1\n", - "Processing year 2066, month 2\n", - "Processing year 2066, month 3\n", - "Processing year 2066, month 4\n", - "Processing year 2066, month 5\n", - "Processing year 2066, month 6\n", - "Processing year 2066, month 7\n", - "Processing year 2066, month 8\n", - "Processing year 2066, month 9\n", - "Processing year 2066, month 10\n", - "Processing year 2066, month 11\n", - "Processing year 2066, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2066, month 1\n", - "Processing year 2066, month 2\n", - "Processing year 2066, month 3\n", - "Processing year 2066, month 4\n", - "Processing year 2066, month 5\n", - "Processing year 2066, month 6\n", - "Processing year 2066, month 7\n", - "Processing year 2066, month 8\n", - "Processing year 2066, month 9\n", - "Processing year 2066, month 10\n", - "Processing year 2066, month 11\n", - "Processing year 2066, month 12\n", - "Processing file: CIL_subset_ssp585_2067.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2067, month 1\n", - "Processing year 2067, month 2\n", - "Processing year 2067, month 3\n", - "Processing year 2067, month 4\n", - "Processing year 2067, month 5\n", - "Processing year 2067, month 6\n", - "Processing year 2067, month 7\n", - "Processing year 2067, month 8\n", - "Processing year 2067, month 9\n", - "Processing year 2067, month 10\n", - "Processing year 2067, month 11\n", - "Processing year 2067, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2067, month 1\n", - "Processing year 2067, month 2\n", - "Processing year 2067, month 3\n", - "Processing year 2067, month 4\n", - "Processing year 2067, month 5\n", - "Processing year 2067, month 6\n", - "Processing year 2067, month 7\n", - "Processing year 2067, month 8\n", - "Processing year 2067, month 9\n", - "Processing year 2067, month 10\n", - "Processing year 2067, month 11\n", - "Processing year 2067, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2067, month 1\n", - "Processing year 2067, month 2\n", - "Processing year 2067, month 3\n", - "Processing year 2067, month 4\n", - "Processing year 2067, month 5\n", - "Processing year 2067, month 6\n", - "Processing year 2067, month 7\n", - "Processing year 2067, month 8\n", - "Processing year 2067, month 9\n", - "Processing year 2067, month 10\n", - "Processing year 2067, month 11\n", - "Processing year 2067, month 12\n", - "Processing file: CIL_subset_ssp585_2068.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2068, month 1\n", - "Processing year 2068, month 2\n", - "Processing year 2068, month 3\n", - "Processing year 2068, month 4\n", - "Processing year 2068, month 5\n", - "Processing year 2068, month 6\n", - "Processing year 2068, month 7\n", - "Processing year 2068, month 8\n", - "Processing year 2068, month 9\n", - "Processing year 2068, month 10\n", - "Processing year 2068, month 11\n", - "Processing year 2068, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2068, month 1\n", - "Processing year 2068, month 2\n", - "Processing year 2068, month 3\n", - "Processing year 2068, month 4\n", - "Processing year 2068, month 5\n", - "Processing year 2068, month 6\n", - "Processing year 2068, month 7\n", - "Processing year 2068, month 8\n", - "Processing year 2068, month 9\n", - "Processing year 2068, month 10\n", - "Processing year 2068, month 11\n", - "Processing year 2068, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2068, month 1\n", - "Processing year 2068, month 2\n", - "Processing year 2068, month 3\n", - "Processing year 2068, month 4\n", - "Processing year 2068, month 5\n", - "Processing year 2068, month 6\n", - "Processing year 2068, month 7\n", - "Processing year 2068, month 8\n", - "Processing year 2068, month 9\n", - "Processing year 2068, month 10\n", - "Processing year 2068, month 11\n", - "Processing year 2068, month 12\n", - "Processing file: CIL_subset_ssp585_2069.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2069, month 1\n", - "Processing year 2069, month 2\n", - "Processing year 2069, month 3\n", - "Processing year 2069, month 4\n", - "Processing year 2069, month 5\n", - "Processing year 2069, month 6\n", - "Processing year 2069, month 7\n", - "Processing year 2069, month 8\n", - "Processing year 2069, month 9\n", - "Processing year 2069, month 10\n", - "Processing year 2069, month 11\n", - "Processing year 2069, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2069, month 1\n", - "Processing year 2069, month 2\n", - "Processing year 2069, month 3\n", - "Processing year 2069, month 4\n", - "Processing year 2069, month 5\n", - "Processing year 2069, month 6\n", - "Processing year 2069, month 7\n", - "Processing year 2069, month 8\n", - "Processing year 2069, month 9\n", - "Processing year 2069, month 10\n", - "Processing year 2069, month 11\n", - "Processing year 2069, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2069, month 1\n", - "Processing year 2069, month 2\n", - "Processing year 2069, month 3\n", - "Processing year 2069, month 4\n", - "Processing year 2069, month 5\n", - "Processing year 2069, month 6\n", - "Processing year 2069, month 7\n", - "Processing year 2069, month 8\n", - "Processing year 2069, month 9\n", - "Processing year 2069, month 10\n", - "Processing year 2069, month 11\n", - "Processing year 2069, month 12\n", - "Processing file: CIL_subset_ssp585_2070.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2070, month 1\n", - "Processing year 2070, month 2\n", - "Processing year 2070, month 3\n", - "Processing year 2070, month 4\n", - "Processing year 2070, month 5\n", - "Processing year 2070, month 6\n", - "Processing year 2070, month 7\n", - "Processing year 2070, month 8\n", - "Processing year 2070, month 9\n", - "Processing year 2070, month 10\n", - "Processing year 2070, month 11\n", - "Processing year 2070, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2070, month 1\n", - "Processing year 2070, month 2\n", - "Processing year 2070, month 3\n", - "Processing year 2070, month 4\n", - "Processing year 2070, month 5\n", - "Processing year 2070, month 6\n", - "Processing year 2070, month 7\n", - "Processing year 2070, month 8\n", - "Processing year 2070, month 9\n", - "Processing year 2070, month 10\n", - "Processing year 2070, month 11\n", - "Processing year 2070, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2070, month 1\n", - "Processing year 2070, month 2\n", - "Processing year 2070, month 3\n", - "Processing year 2070, month 4\n", - "Processing year 2070, month 5\n", - "Processing year 2070, month 6\n", - "Processing year 2070, month 7\n", - "Processing year 2070, month 8\n", - "Processing year 2070, month 9\n", - "Processing year 2070, month 10\n", - "Processing year 2070, month 11\n", - "Processing year 2070, month 12\n", - "Saved monthly data to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/HadGEM3-GC31-LL_monthly_prediction_weather_by_facility.csv\n", - "Saved window data to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/HadGEM3-GC31-LL_window_prediction_weather_by_facility.csv\n", - "Saved monthly data to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/GFDL-CM4_monthly_prediction_weather_by_facility.csv\n", - "Saved window data to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/GFDL-CM4_window_prediction_weather_by_facility.csv\n", - "Saved monthly data to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/INM-CM5-0_monthly_prediction_weather_by_facility.csv\n", - "Saved window data to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/INM-CM5-0_window_prediction_weather_by_facility.csv\n" + "Processing scenario: ssp245\n" ] } ], - "execution_count": 7 + "execution_count": null }, { "metadata": { From 75777bc346c6549a40c2a070e55c6c21589bcc29 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 9 Jan 2025 08:47:10 +0000 Subject: [PATCH 161/291] Changed data to access the files where data was missing --- .../CIL_CMIP6_downscaling_accessing_data.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/src/scripts/climate_change/CIL_CMIP6_downscaling_accessing_data.py b/src/scripts/climate_change/CIL_CMIP6_downscaling_accessing_data.py index ef2706ba18..a581d99fce 100644 --- a/src/scripts/climate_change/CIL_CMIP6_downscaling_accessing_data.py +++ b/src/scripts/climate_change/CIL_CMIP6_downscaling_accessing_data.py @@ -38,7 +38,7 @@ ) # Get the collections -scenarios = ["ssp245"] # Change as needed +scenarios = ["ssp245"]#, "ssp585"] # Change as needed variable_id = "pr" # Precipitation variable for scenario in scenarios: @@ -67,12 +67,14 @@ # Define the spatial and temporal bounds lon_bounds = slice(32.67161823, 35.91841716) lat_bounds = slice(-17.12627881, -9.36366167) - time_range = pd.date_range("2065-01-01", "2071-01-01", freq="Y") + #years_for_retrieval = ['2034', '2037', '2040', '2043', '2045', '2046', '2055', '2060', '2062', '2063', + #'2064'] #'2032', '2026', '2029', + years_for_retrieval = ['2062', '2063','2064'] # Process each year output_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/" yearly_files = [] - for year in time_range.year: + for year in years_for_retrieval: yearly_subset = all_datasets.pr.sel( lon=lon_bounds, lat=lat_bounds, From c545685735c0a74df3e72636e81ba75be52072b2 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 9 Jan 2025 09:22:09 +0000 Subject: [PATCH 162/291] Changed data to access the files where data was missing Dropped first column which has index of months/years --- .../CIL_CMIP6_downscaling_accessing_data.py | 4 ++-- ...historical_realtionship_reporting_precipitation.py | 11 +++++++++-- 2 files changed, 11 insertions(+), 4 deletions(-) diff --git a/src/scripts/climate_change/CIL_CMIP6_downscaling_accessing_data.py b/src/scripts/climate_change/CIL_CMIP6_downscaling_accessing_data.py index a581d99fce..35d502295c 100644 --- a/src/scripts/climate_change/CIL_CMIP6_downscaling_accessing_data.py +++ b/src/scripts/climate_change/CIL_CMIP6_downscaling_accessing_data.py @@ -38,7 +38,7 @@ ) # Get the collections -scenarios = ["ssp245"]#, "ssp585"] # Change as needed +scenarios = ["ssp585"]#, "ssp585"] # Change as needed variable_id = "pr" # Precipitation variable for scenario in scenarios: @@ -70,7 +70,7 @@ #years_for_retrieval = ['2034', '2037', '2040', '2043', '2045', '2046', '2055', '2060', '2062', '2063', #'2064'] #'2032', '2026', '2029', - years_for_retrieval = ['2062', '2063','2064'] + years_for_retrieval = ['2033', '2036','2037', '2041', '2047', '2048', '2050', '2054', '2060'] # Process each year output_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/" yearly_files = [] diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 4ab54cc6ed..9bbb1c95cd 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -571,13 +571,20 @@ def repeat_info(info, num_facilities, year_range, historical): ############### ADD IN CMIP DATA ########################### def get_weather_data(ssp_scenario, model_type): weather_data_prediction_five_day_cumulative_original = pd.read_csv( - f"{data_path}Precipitation_data/Downscaled_CMIP6_data_CIL/{ssp_scenario}/{model_type}_model_daily_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{ssp_scenario}.csv", + f"{data_path}Precipitation_data/Downscaled_CMIP6_data_CIL/{ssp_scenario}/{model_type}_window_prediction_weather_by_facility.csv", dtype={'column_name': 'float64'} ) + weather_data_prediction_five_day_cumulative_original = weather_data_prediction_five_day_cumulative_original.drop( + weather_data_prediction_five_day_cumulative_original.columns[0], axis=1 + ) # first column are date/months + print(weather_data_prediction_five_day_cumulative_original) weather_data_prediction_monthly_original = pd.read_csv( - f"{data_path}Precipitation_data/Downscaled_CMIP6_data_CIL/{ssp_scenario}/{model_type}_model_monthly_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{ssp_scenario}.csv", + f"{data_path}Precipitation_data/Downscaled_CMIP6_data_CIL/{ssp_scenario}/{model_type}_monthly_prediction_weather_by_facility.csv", dtype={'column_name': 'float64'} ) + weather_data_prediction_monthly_original = weather_data_prediction_monthly_original.drop( + weather_data_prediction_monthly_original.columns[0], axis=1 + ) # first column are date/months weather_data_prediction_monthly_df = weather_data_prediction_monthly_original.drop(columns=zero_sum_columns) weather_data_prediction_five_day_cumulative_df = weather_data_prediction_five_day_cumulative_original.drop( columns=zero_sum_columns) From 572a54aa0b4f279b136d71772724f5714534397f Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 9 Jan 2025 09:24:01 +0000 Subject: [PATCH 163/291] Undid hash out --- .../process_CMIP6_data_KDBall.py | 110 +++++++++--------- 1 file changed, 55 insertions(+), 55 deletions(-) diff --git a/src/scripts/climate_change/process_CMIP6_data_KDBall.py b/src/scripts/climate_change/process_CMIP6_data_KDBall.py index 5e237919fb..fa713905d5 100644 --- a/src/scripts/climate_change/process_CMIP6_data_KDBall.py +++ b/src/scripts/climate_change/process_CMIP6_data_KDBall.py @@ -143,7 +143,7 @@ def extract_nc_files_from_unzipped_folders(directory): for j in range(len(lat_data)): precip_data_for_grid = pr_data[:,j,i] # across all time points precip_data_for_grid = precip_data_for_grid * multiplier # to get from per second to per day - grid_dictionary[grid] = precip_data_for_grid.data.values + grid_dictionary[grid] = precip_data_for_grid.data grid += 1 data_by_model_and_grid[model] = grid_dictionary data_by_model_and_grid = pd.DataFrame.from_dict(data_by_model_and_grid) @@ -158,60 +158,60 @@ def extract_nc_files_from_unzipped_folders(directory): data_by_model_and_grid_same_length = data_by_model_and_grid_same_length.dropna(axis=0) data_by_model_and_grid_same_length.to_csv(Path(scenario_directory)/"data_by_model_and_grid_modal_resolution.csv", index = True) - # # Now loop over facilities to locate each one in a grid cell for each model - # facilities_with_location = [] - # # see which facilities have reporting data and data on latitude and longitude - # median_precipitation_by_facility = {} - # percentiles_25_by_facility = {} - # percentiles_75_by_facility = {} - # cumulative_sum_window = {} - # for reporting_facility in reporting_data.columns: - # grid_precipitation_for_facility = {} - # match_name, lat_for_facility, long_for_facility = get_facility_lat_long(reporting_facility, facilities_with_lat_long) - # if not np.isnan(long_for_facility) and not np.isnan(lat_for_facility): - # facility_location = np.array([lat_for_facility, long_for_facility]) - # kd_trees_by_model = {} - # for model in grid_centroids.keys(): - # if model in data_by_model_and_grid_same_length.columns: - # centroids = grid_centroids[model] - # kd_tree = KDTree(centroids) - # distance, closest_grid_index = kd_tree.query(facility_location) - # grid_precipitation_for_facility[model] = data_by_model_and_grid_same_length[model][closest_grid_index].data - # first_model = next(iter(grid_precipitation_for_facility)) - # median_all_timepoints_for_facility = [] - # p25_all_timepoints_for_facility = [] - # p75_all_timepoints_for_facility = [] - # - # for t in range(len(grid_precipitation_for_facility[first_model])): #all should be the same length - # per_time_point_by_model = [] - # for precip_data in grid_precipitation_for_facility.values(): - # if len(precip_data) == len(grid_precipitation_for_facility[first_model]): # ensure same time resolution - # per_time_point_by_model.append(precip_data[t]) - # p25_all_timepoints_for_facility.append(np.percentile(per_time_point_by_model, 25)) - # p75_all_timepoints_for_facility.append(np.percentile(per_time_point_by_model, 75)) - # median_all_timepoints_for_facility.append(np.median(per_time_point_by_model)) - # cumulative_sum_window[reporting_facility] = [] - # begin_day = 0 - # for month_idx, month_length in enumerate(month_lengths): - # if monthly_cumulative: - # window_size = month_length - # days_for_grid = median_all_timepoints_for_facility[begin_day:begin_day + month_length] - # cumulative_sums = [ - # sum(days_for_grid[day:day + window_size]) - # for day in range(month_length - window_size + 1) - # ] - # max_cumulative_sums = max(cumulative_sums) - # cumulative_sum_window[reporting_facility].append(max_cumulative_sums) - # begin_day += month_length - # median_precipitation_by_facility[reporting_facility] = median_all_timepoints_for_facility - # percentiles_25_by_facility[reporting_facility] = p25_all_timepoints_for_facility - # percentiles_75_by_facility[reporting_facility] = p75_all_timepoints_for_facility - # - # weather_df_median = pd.DataFrame.from_dict(median_precipitation_by_facility, orient='index').T - # weather_df_p25 = pd.DataFrame.from_dict(percentiles_25_by_facility, orient='index').T - # weather_df_p75 = pd.DataFrame.from_dict(percentiles_75_by_facility, orient='index').T - # df_cumulative_sum = pd.DataFrame.from_dict(cumulative_sum_window, orient='index').T - # df_cumulative_sum.astype(float) + # Now loop over facilities to locate each one in a grid cell for each model + facilities_with_location = [] + # see which facilities have reporting data and data on latitude and longitude + median_precipitation_by_facility = {} + percentiles_25_by_facility = {} + percentiles_75_by_facility = {} + cumulative_sum_window = {} + for reporting_facility in reporting_data.columns: + grid_precipitation_for_facility = {} + match_name, lat_for_facility, long_for_facility = get_facility_lat_long(reporting_facility, facilities_with_lat_long) + if not np.isnan(long_for_facility) and not np.isnan(lat_for_facility): + facility_location = np.array([lat_for_facility, long_for_facility]) + kd_trees_by_model = {} + for model in grid_centroids.keys(): + if model in data_by_model_and_grid_same_length.columns: + centroids = grid_centroids[model] + kd_tree = KDTree(centroids) + distance, closest_grid_index = kd_tree.query(facility_location) + grid_precipitation_for_facility[model] = data_by_model_and_grid_same_length[model][closest_grid_index].data + first_model = next(iter(grid_precipitation_for_facility)) + median_all_timepoints_for_facility = [] + p25_all_timepoints_for_facility = [] + p75_all_timepoints_for_facility = [] + + for t in range(len(grid_precipitation_for_facility[first_model])): #all should be the same length + per_time_point_by_model = [] + for precip_data in grid_precipitation_for_facility.values(): + if len(precip_data) == len(grid_precipitation_for_facility[first_model]): # ensure same time resolution + per_time_point_by_model.append(precip_data[t]) + p25_all_timepoints_for_facility.append(np.percentile(per_time_point_by_model, 25)) + p75_all_timepoints_for_facility.append(np.percentile(per_time_point_by_model, 75)) + median_all_timepoints_for_facility.append(np.median(per_time_point_by_model)) + cumulative_sum_window[reporting_facility] = [] + begin_day = 0 + for month_idx, month_length in enumerate(month_lengths): + if monthly_cumulative: + window_size = month_length + days_for_grid = median_all_timepoints_for_facility[begin_day:begin_day + month_length] + cumulative_sums = [ + sum(days_for_grid[day:day + window_size]) + for day in range(month_length - window_size + 1) + ] + max_cumulative_sums = max(cumulative_sums) + cumulative_sum_window[reporting_facility].append(max_cumulative_sums) + begin_day += month_length + median_precipitation_by_facility[reporting_facility] = median_all_timepoints_for_facility + percentiles_25_by_facility[reporting_facility] = p25_all_timepoints_for_facility + percentiles_75_by_facility[reporting_facility] = p75_all_timepoints_for_facility + + weather_df_median = pd.DataFrame.from_dict(median_precipitation_by_facility, orient='index').T + weather_df_p25 = pd.DataFrame.from_dict(percentiles_25_by_facility, orient='index').T + weather_df_p75 = pd.DataFrame.from_dict(percentiles_75_by_facility, orient='index').T + df_cumulative_sum = pd.DataFrame.from_dict(cumulative_sum_window, orient='index').T + df_cumulative_sum.astype(float) # if ANC: # weather_df_median.to_csv(Path(scenario_directory) / "median_daily_prediction_weather_by_facility_KDBall.csv", index=False) # weather_df_p25.to_csv(Path(scenario_directory) / "p25_daily_prediction_weather_by_facility_KDBall.csv", index=False) From 26b613fe47ca20110df268c53ae01648f14db855 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 9 Jan 2025 09:46:48 +0000 Subject: [PATCH 164/291] Large files --- .../~$ResourceFile_Lifestyle_Enhanced.xlsx | 3 + ...al_realtionship_reporting_precipitation.py | 2 +- .../longterm_projections_draws.json | 161 ------------------ 3 files changed, 4 insertions(+), 162 deletions(-) create mode 100644 resources/~$ResourceFile_Lifestyle_Enhanced.xlsx delete mode 100644 src/scripts/longterm_projections/longterm_projections_draws.json diff --git a/resources/~$ResourceFile_Lifestyle_Enhanced.xlsx b/resources/~$ResourceFile_Lifestyle_Enhanced.xlsx new file mode 100644 index 0000000000..b72f063477 --- /dev/null +++ b/resources/~$ResourceFile_Lifestyle_Enhanced.xlsx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:eb9b50e17e6e2718a696c1bb16f9d6f13de0af9e037a590c0451a9681b6c36e3 +size 165 diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 9bbb1c95cd..4ac4d968e8 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -590,7 +590,7 @@ def get_weather_data(ssp_scenario, model_type): columns=zero_sum_columns) return weather_data_prediction_five_day_cumulative_df, weather_data_prediction_monthly_df -model_types = ['lowest', 'highest']#, 'median', 'highest'] +model_types = ['lowest', 'median' 'highest'] # Configuration and constants min_year_for_analysis = 2025 absolute_min_year = 2025 diff --git a/src/scripts/longterm_projections/longterm_projections_draws.json b/src/scripts/longterm_projections/longterm_projections_draws.json deleted file mode 100644 index 6c09fc27aa..0000000000 --- a/src/scripts/longterm_projections/longterm_projections_draws.json +++ /dev/null @@ -1,161 +0,0 @@ -{ - "scenario_script_path": "src/scripts/longterm_projections/longterm_projections.py", - "scenario_seed": 0, - "arguments": [], - "runs_per_draw": 10, - "draws": [ - { - "draw_number": 0, - "parameters": { - "SymptomManager": { - "spurious_symptoms": true - }, - "HealthSystem": { - "Service_Availability": [ - "*" - ], - "use_funded_or_actual_staffing": "actual", - "mode_appt_constraints": 1, - "cons_availability": "default", - "beds_availability": "default", - "equip_availability": "all" - } - }, - "draw_name": "0" - }, - { - "draw_number": 1, - "parameters": { - "SymptomManager": { - "spurious_symptoms": true - }, - "HealthSystem": { - "Service_Availability": [ - "*" - ], - "use_funded_or_actual_staffing": "funded_plus", - "mode_appt_constraints": 1, - "cons_availability": "default", - "beds_availability": "all", - "equip_availability": "default", - "cons_availability_postSwitch": "all", - "year_cons_availability_switch": 2020, - "equip_availability_postSwitch": "all", - "year_equip_availability_switch": 2020 - }, - "ImprovedHealthSystemAndCareSeekingScenarioSwitcher": { - "max_healthsystem_function": [ - false, - true - ], - "max_healthcare_seeking": [ - false, - true - ], - "year_of_switch": 2020 - }, - "Malaria": { - "type_of_scaleup": "max", - "scaleup_start_year": 2020 - }, - "Tb": { - "type_of_scaleup": "max", - "scaleup_start_year": 2020 - }, - "Hiv": { - "type_of_scaleup": "max", - "scaleup_start_year": 2020 - } - }, - "draw_name": "1" - }, - { - "draw_number": 2, - "parameters": { - "SymptomManager": { - "spurious_symptoms": true - }, - "HealthSystem": { - "Service_Availability": [ - "*" - ], - "use_funded_or_actual_staffing": "actual", - "mode_appt_constraints": 1, - "cons_availability": "default", - "beds_availability": "default", - "equip_availability": "all" - }, - "Malaria": { - "type_of_scaleup": "target", - "scaleup_start_year": 2020 - }, - "Tb": { - "type_of_scaleup": "target", - "scaleup_start_year": 2020 - }, - "Hiv": { - "type_of_scaleup": "target", - "scaleup_start_year": 2020 - } - }, - "draw_name": "2" - }, - { - "draw_number": 3, - "parameters": { - "SymptomManager": { - "spurious_symptoms": true - }, - "HealthSystem": { - "Service_Availability": [ - "*" - ], - "use_funded_or_actual_staffing": "actual", - "mode_appt_constraints": 1, - "cons_availability": "default", - "beds_availability": "default", - "equip_availability": "all" - }, - "Lifestyle": { - "r_urban": 0.00075, - "r_higher_bmi": 0.00075, - "r_high_salt_urban": 0.0045000000000000005, - "r_high_sugar": 0.00015000000000000001, - "r_low_ex": 0.0015, - "r_tob": 0.0002666666666666667, - "r_ex_alc": 0.0045000000000000005, - "r_non_wood_burn_stove": 0.0015, - "r_clean_drinking_water": 0.0015, - "r_improved_sanitation": 0.0015, - "r_access_handwashing": 0.0015 - } - }, - "draw_name": "3" - }, - { - "draw_number": 4, - "parameters": { - "SymptomManager": { - "spurious_symptoms": true - }, - "HealthSystem": { - "Service_Availability": [ - "*" - ], - "use_funded_or_actual_staffing": "actual", - "mode_appt_constraints": 1, - "cons_availability": "default", - "beds_availability": "default", - "equip_availability": "all" - }, - "Lifestyle": { - "r_tob": 0.0006000000000000001, - "r_ex_alc": 0.0045000000000000005 - } - }, - "draw_name": "4" - } - ], - "commit": "fc3328e0ad4ca56c6ce39a4af283331468c3fe98", - "github": "https://github.com/UCL/TLOmodel/tree/fc3328e0ad4ca56c6ce39a4af283331468c3fe98" -} \ No newline at end of file From 4591b075da167587c918433920eaeb682db33036 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 9 Jan 2025 09:47:37 +0000 Subject: [PATCH 165/291] Stops saving large files --- .../CIL_CMIP6_downscaling.ipynb | 3250 ++++++++++++++++- 1 file changed, 3247 insertions(+), 3 deletions(-) diff --git a/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb b/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb index 22a4f5b906..213edfd4ca 100644 --- a/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb +++ b/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb @@ -749,7 +749,7 @@ " # Combine all yearly files into one NetCDF file\n", " combined_output = f\"{output_dir}/CIL_subsetted_all_model_{scenario}.nc\"\n", " combined_dataset = xr.open_mfdataset(yearly_files, combine=\"by_coords\")\n", - " combined_dataset.to_netcdf(combined_output)\n", + " #combined_dataset.to_netcdf(combined_output)\n", " print(f\"Saved combined dataset to {combined_output}\")" ], "id": "fc5f8a6d54c1a89d", @@ -951,7 +951,7 @@ "is_executing": true }, "ExecuteTime": { - "start_time": "2025-01-08T21:35:55.872116Z" + "start_time": "2025-01-09T09:21:44.738971Z" } }, "cell_type": "code", @@ -1090,7 +1090,3251 @@ "name": "stdout", "output_type": "stream", "text": [ - "Processing scenario: ssp245\n" + "Processing scenario: ssp245\n", + "Models of interest ['HadGEM3-GC31-LL', 'GFDL-CM4', 'INM-CM5-0']\n", + "Processing file: CIL_subset_ssp245_2025.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2025, month 1\n", + "Processing year 2025, month 2\n", + "Processing year 2025, month 3\n", + "Processing year 2025, month 4\n", + "Processing year 2025, month 5\n", + "Processing year 2025, month 6\n", + "Processing year 2025, month 7\n", + "Processing year 2025, month 8\n", + "Processing year 2025, month 9\n", + "Processing year 2025, month 10\n", + "Processing year 2025, month 11\n", + "Processing year 2025, month 12\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing model: GFDL-CM4\n", + "Processing year 2025, month 1\n", + "Processing year 2025, month 2\n", + "Processing year 2025, month 3\n", + "Processing year 2025, month 4\n", + "Processing year 2025, month 5\n", + "Processing year 2025, month 6\n", + "Processing year 2025, month 7\n", + "Processing year 2025, month 8\n", + "Processing year 2025, month 9\n", + "Processing year 2025, month 10\n", + "Processing year 2025, month 11\n", + "Processing year 2025, month 12\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing model: INM-CM5-0\n", + "Processing year 2025, month 1\n", + "Processing year 2025, month 2\n", + "Processing year 2025, month 3\n", + "Processing year 2025, month 4\n", + "Processing year 2025, month 5\n", + "Processing year 2025, month 6\n", + "Processing year 2025, month 7\n", + "Processing year 2025, month 8\n", + "Processing year 2025, month 9\n", + "Processing year 2025, month 10\n", + "Processing year 2025, month 11\n", + "Processing year 2025, month 12\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing file: CIL_subset_ssp245_2026.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2026, month 1\n", + "Processing year 2026, month 2\n", + "Processing year 2026, month 3\n", + "Processing year 2026, month 4\n", + "Processing year 2026, month 5\n", + "Processing year 2026, month 6\n", + "Processing year 2026, month 7\n", + "Processing year 2026, month 8\n", + "Processing year 2026, month 9\n", + "Processing year 2026, month 10\n", + "Processing year 2026, month 11\n", + "Processing year 2026, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2026, month 1\n", + "Processing year 2026, month 2\n", + "Processing year 2026, month 3\n", + "Processing year 2026, month 4\n", + "Processing year 2026, month 5\n", + "Processing year 2026, month 6\n", + "Processing year 2026, month 7\n", + "Processing year 2026, month 8\n", + "Processing year 2026, month 9\n", + "Processing year 2026, month 10\n", + "Processing year 2026, month 11\n", + "Processing year 2026, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2026, month 1\n", + "Processing year 2026, month 2\n", + "Processing year 2026, month 3\n", + "Processing year 2026, month 4\n", + "Processing year 2026, month 5\n", + "Processing year 2026, month 6\n", + "Processing year 2026, month 7\n", + "Processing year 2026, month 8\n", + "Processing year 2026, month 9\n", + "Processing year 2026, month 10\n", + "Processing year 2026, month 11\n", + "Processing year 2026, month 12\n", + "Processing file: CIL_subset_ssp245_2027.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2027, month 1\n", + "Processing year 2027, month 2\n", + "Processing year 2027, month 3\n", + "Processing year 2027, month 4\n", + "Processing year 2027, month 5\n", + "Processing year 2027, month 6\n", + "Processing year 2027, month 7\n", + "Processing year 2027, month 8\n", + "Processing year 2027, month 9\n", + "Processing year 2027, month 10\n", + "Processing year 2027, month 11\n", + "Processing year 2027, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2027, month 1\n", + "Processing year 2027, month 2\n", + "Processing year 2027, month 3\n", + "Processing year 2027, month 4\n", + "Processing year 2027, month 5\n", + "Processing year 2027, month 6\n", + "Processing year 2027, month 7\n", + "Processing year 2027, month 8\n", + "Processing year 2027, month 9\n", + "Processing year 2027, month 10\n", + "Processing year 2027, month 11\n", + "Processing year 2027, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2027, month 1\n", + "Processing year 2027, month 2\n", + "Processing year 2027, month 3\n", + "Processing year 2027, month 4\n", + "Processing year 2027, month 5\n", + "Processing year 2027, month 6\n", + "Processing year 2027, month 7\n", + "Processing year 2027, month 8\n", + "Processing year 2027, month 9\n", + "Processing year 2027, month 10\n", + "Processing year 2027, month 11\n", + "Processing year 2027, month 12\n", + "Processing file: CIL_subset_ssp245_2028.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2028, month 1\n", + "Processing year 2028, month 2\n", + "Processing year 2028, month 3\n", + "Processing year 2028, month 4\n", + "Processing year 2028, month 5\n", + "Processing year 2028, month 6\n", + "Processing year 2028, month 7\n", + "Processing year 2028, month 8\n", + "Processing year 2028, month 9\n", + "Processing year 2028, month 10\n", + "Processing year 2028, month 11\n", + "Processing year 2028, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2028, month 1\n", + "Processing year 2028, month 2\n", + "Processing year 2028, month 3\n", + "Processing year 2028, month 4\n", + "Processing year 2028, month 5\n", + "Processing year 2028, month 6\n", + "Processing year 2028, month 7\n", + "Processing year 2028, month 8\n", + "Processing year 2028, month 9\n", + "Processing year 2028, month 10\n", + "Processing year 2028, month 11\n", + "Processing year 2028, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2028, month 1\n", + "Processing year 2028, month 2\n", + "Processing year 2028, month 3\n", + "Processing year 2028, month 4\n", + "Processing year 2028, month 5\n", + "Processing year 2028, month 6\n", + "Processing year 2028, month 7\n", + "Processing year 2028, month 8\n", + "Processing year 2028, month 9\n", + "Processing year 2028, month 10\n", + "Processing year 2028, month 11\n", + "Processing year 2028, month 12\n", + "Processing file: CIL_subset_ssp245_2029.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2029, month 1\n", + "Processing year 2029, month 2\n", + "Processing year 2029, month 3\n", + "Processing year 2029, month 4\n", + "Processing year 2029, month 5\n", + "Processing year 2029, month 6\n", + "Processing year 2029, month 7\n", + "Processing year 2029, month 8\n", + "Processing year 2029, month 9\n", + "Processing year 2029, month 10\n", + "Processing year 2029, month 11\n", + "Processing year 2029, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2029, month 1\n", + "Processing year 2029, month 2\n", + "Processing year 2029, month 3\n", + "Processing year 2029, month 4\n", + "Processing year 2029, month 5\n", + "Processing year 2029, month 6\n", + "Processing year 2029, month 7\n", + "Processing year 2029, month 8\n", + "Processing year 2029, month 9\n", + "Processing year 2029, month 10\n", + "Processing year 2029, month 11\n", + "Processing year 2029, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2029, month 1\n", + "Processing year 2029, month 2\n", + "Processing year 2029, month 3\n", + "Processing year 2029, month 4\n", + "Processing year 2029, month 5\n", + "Processing year 2029, month 6\n", + "Processing year 2029, month 7\n", + "Processing year 2029, month 8\n", + "Processing year 2029, month 9\n", + "Processing year 2029, month 10\n", + "Processing year 2029, month 11\n", + "Processing year 2029, month 12\n", + "Processing file: CIL_subset_ssp245_2030.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2030, month 1\n", + "Processing year 2030, month 2\n", + "Processing year 2030, month 3\n", + "Processing year 2030, month 4\n", + "Processing year 2030, month 5\n", + "Processing year 2030, month 6\n", + "Processing year 2030, month 7\n", + "Processing year 2030, month 8\n", + "Processing year 2030, month 9\n", + "Processing year 2030, month 10\n", + "Processing year 2030, month 11\n", + "Processing year 2030, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2030, month 1\n", + "Processing year 2030, month 2\n", + "Processing year 2030, month 3\n", + "Processing year 2030, month 4\n", + "Processing year 2030, month 5\n", + "Processing year 2030, month 6\n", + "Processing year 2030, month 7\n", + "Processing year 2030, month 8\n", + "Processing year 2030, month 9\n", + "Processing year 2030, month 10\n", + "Processing year 2030, month 11\n", + "Processing year 2030, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2030, month 1\n", + "Processing year 2030, month 2\n", + "Processing year 2030, month 3\n", + "Processing year 2030, month 4\n", + "Processing year 2030, month 5\n", + "Processing year 2030, month 6\n", + "Processing year 2030, month 7\n", + "Processing year 2030, month 8\n", + "Processing year 2030, month 9\n", + "Processing year 2030, month 10\n", + "Processing year 2030, month 11\n", + "Processing year 2030, month 12\n", + "Processing file: CIL_subset_ssp245_2031.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2031, month 1\n", + "Processing year 2031, month 2\n", + "Processing year 2031, month 3\n", + "Processing year 2031, month 4\n", + "Processing year 2031, month 5\n", + "Processing year 2031, month 6\n", + "Processing year 2031, month 7\n", + "Processing year 2031, month 8\n", + "Processing year 2031, month 9\n", + "Processing year 2031, month 10\n", + "Processing year 2031, month 11\n", + "Processing year 2031, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2031, month 1\n", + "Processing year 2031, month 2\n", + "Processing year 2031, month 3\n", + "Processing year 2031, month 4\n", + "Processing year 2031, month 5\n", + "Processing year 2031, month 6\n", + "Processing year 2031, month 7\n", + "Processing year 2031, month 8\n", + "Processing year 2031, month 9\n", + "Processing year 2031, month 10\n", + "Processing year 2031, month 11\n", + "Processing year 2031, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2031, month 1\n", + "Processing year 2031, month 2\n", + "Processing year 2031, month 3\n", + "Processing year 2031, month 4\n", + "Processing year 2031, month 5\n", + "Processing year 2031, month 6\n", + "Processing year 2031, month 7\n", + "Processing year 2031, month 8\n", + "Processing year 2031, month 9\n", + "Processing year 2031, month 10\n", + "Processing year 2031, month 11\n", + "Processing year 2031, month 12\n", + "Processing file: CIL_subset_ssp245_2032.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2032, month 1\n", + "Processing year 2032, month 2\n", + "Processing year 2032, month 3\n", + "Processing year 2032, month 4\n", + "Processing year 2032, month 5\n", + "Processing year 2032, month 6\n", + "Processing year 2032, month 7\n", + "Processing year 2032, month 8\n", + "Processing year 2032, month 9\n", + "Processing year 2032, month 10\n", + "Processing year 2032, month 11\n", + "Processing year 2032, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2032, month 1\n", + "Processing year 2032, month 2\n", + "Processing year 2032, month 3\n", + "Processing year 2032, month 4\n", + "Processing year 2032, month 5\n", + "Processing year 2032, month 6\n", + "Processing year 2032, month 7\n", + "Processing year 2032, month 8\n", + "Processing year 2032, month 9\n", + "Processing year 2032, month 10\n", + "Processing year 2032, month 11\n", + "Processing year 2032, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2032, month 1\n", + "Processing year 2032, month 2\n", + "Processing year 2032, month 3\n", + "Processing year 2032, month 4\n", + "Processing year 2032, month 5\n", + "Processing year 2032, month 6\n", + "Processing year 2032, month 7\n", + "Processing year 2032, month 8\n", + "Processing year 2032, month 9\n", + "Processing year 2032, month 10\n", + "Processing year 2032, month 11\n", + "Processing year 2032, month 12\n", + "Processing file: CIL_subset_ssp245_2033.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2033, month 1\n", + "Processing year 2033, month 2\n", + "Processing year 2033, month 3\n", + "Processing year 2033, month 4\n", + "Processing year 2033, month 5\n", + "Processing year 2033, month 6\n", + "Processing year 2033, month 7\n", + "Processing year 2033, month 8\n", + "Processing year 2033, month 9\n", + "Processing year 2033, month 10\n", + "Processing year 2033, month 11\n", + "Processing year 2033, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2033, month 1\n", + "Processing year 2033, month 2\n", + "Processing year 2033, month 3\n", + "Processing year 2033, month 4\n", + "Processing year 2033, month 5\n", + "Processing year 2033, month 6\n", + "Processing year 2033, month 7\n", + "Processing year 2033, month 8\n", + "Processing year 2033, month 9\n", + "Processing year 2033, month 10\n", + "Processing year 2033, month 11\n", + "Processing year 2033, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2033, month 1\n", + "Processing year 2033, month 2\n", + "Processing year 2033, month 3\n", + "Processing year 2033, month 4\n", + "Processing year 2033, month 5\n", + "Processing year 2033, month 6\n", + "Processing year 2033, month 7\n", + "Processing year 2033, month 8\n", + "Processing year 2033, month 9\n", + "Processing year 2033, month 10\n", + "Processing year 2033, month 11\n", + "Processing year 2033, month 12\n", + "Processing file: CIL_subset_ssp245_2034.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2034, month 1\n", + "Processing year 2034, month 2\n", + "Processing year 2034, month 3\n", + "Processing year 2034, month 4\n", + "Processing year 2034, month 5\n", + "Processing year 2034, month 6\n", + "Processing year 2034, month 7\n", + "Processing year 2034, month 8\n", + "Processing year 2034, month 9\n", + "Processing year 2034, month 10\n", + "Processing year 2034, month 11\n", + "Processing year 2034, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2034, month 1\n", + "Processing year 2034, month 2\n", + "Processing year 2034, month 3\n", + "Processing year 2034, month 4\n", + "Processing year 2034, month 5\n", + "Processing year 2034, month 6\n", + "Processing year 2034, month 7\n", + "Processing year 2034, month 8\n", + "Processing year 2034, month 9\n", + "Processing year 2034, month 10\n", + "Processing year 2034, month 11\n", + "Processing year 2034, month 12\n" ] } ], From 20171b8c461b8e79b08ac264359dd7fa3caac880 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 9 Jan 2025 09:49:54 +0000 Subject: [PATCH 166/291] Added district --- .../reporting_and_monthly_weather_data_small_facilities.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py b/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py index 5528bcf36a..ab0eb2a5da 100644 --- a/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py +++ b/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py @@ -158,7 +158,7 @@ facilities_with_lat_long["Fname"].isin(facilities_with_location) ] -additional_rows = ["Zonename", "Resid", "A105", "A109__Altitude", "Ftype", 'A109__Latitude', 'A109__Longitude'] +additional_rows = ["Zonename", "Resid", "Dist", "A105", "A109__Altitude", "Ftype", 'A109__Latitude', 'A109__Longitude'] expanded_facility_info = included_facilities_with_lat_long[["Fname"] + additional_rows] expanded_facility_info.columns = ["Fname"] + additional_rows From d5f2e307d274e048e897ccedc7e611cb5ea71efc Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 9 Jan 2025 10:59:27 +0000 Subject: [PATCH 167/291] Found Blantyre was mispelled as "Blanytyre" "Nkhatabay" as "Nkhatabay" --- .../reporting_and_monthly_weather_data_small_facilities.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py b/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py index ab0eb2a5da..7d2ae146ff 100644 --- a/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py +++ b/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py @@ -160,6 +160,8 @@ additional_rows = ["Zonename", "Resid", "Dist", "A105", "A109__Altitude", "Ftype", 'A109__Latitude', 'A109__Longitude'] expanded_facility_info = included_facilities_with_lat_long[["Fname"] + additional_rows] +expanded_facility_info['Dist'] = expanded_facility_info['Dist'].replace("Blanytyre", "Blantyre") +expanded_facility_info['Dist'] = expanded_facility_info['Dist'].replace("Nkhatabay", "Nkhata Bay") expanded_facility_info.columns = ["Fname"] + additional_rows expanded_facility_info.set_index("Fname", inplace=True) From 48422c777986d2b7581cbcbc0e36ce6128d0dca3 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 9 Jan 2025 11:01:22 +0000 Subject: [PATCH 168/291] Added district Also allowed for 2024 in analysis, so can get lag years --- ...al_realtionship_reporting_precipitation.py | 69 +++++++++---------- 1 file changed, 32 insertions(+), 37 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 4ac4d968e8..cbf5437e8f 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -266,6 +266,8 @@ def repeat_info(info, num_facilities, year_range, historical): zone_info_each_month = repeat_info(expanded_facility_info["Zonename"], num_facilities, year_range, historical = True) zone_encoded = pd.get_dummies(zone_info_each_month, drop_first=True) +dist_info_each_month = repeat_info(expanded_facility_info["Dist"], num_facilities, year_range, historical = True) +dist_encoded = pd.get_dummies(dist_info_each_month, drop_first=True) resid_info_each_month = repeat_info(expanded_facility_info['Resid'], num_facilities, year_range, historical = True) resid_encoded = pd.get_dummies(resid_info_each_month, drop_first=True) owner_info_each_month = repeat_info(expanded_facility_info['A105'], num_facilities, year_range, historical = True) @@ -298,6 +300,7 @@ def repeat_info(info, num_facilities, year_range, historical): month_flattened, resid_encoded, zone_encoded, + dist_encoded, owner_encoded, ftype_encoded, facility_encoded, @@ -425,26 +428,27 @@ def repeat_info(info, num_facilities, year_range, historical): X_weather = np.column_stack([ - weather_data, - np.array(year_flattened), - np.array(month_flattened), - resid_encoded, - zone_encoded, - owner_encoded, - ftype_encoded, - lag_1_month, - lag_2_month, - lag_3_month, - lag_4_month, - lag_1_5_day, - lag_2_5_day, - lag_3_5_day, - lag_4_5_day, - facility_encoded, - np.array(altitude), - np.array(minimum_distance), - #np.array(above_below_X)[mask_ANC_data], - ]) + weather_data, + np.array(year_flattened), + np.array(month_flattened), + resid_encoded, + zone_encoded, + dist_encoded, + owner_encoded, + ftype_encoded, + lag_1_month, + lag_2_month, + lag_3_month, + lag_4_month, + lag_1_5_day, + lag_2_5_day, + lag_3_5_day, + lag_4_5_day, + facility_encoded, + np.array(altitude), + np.array(minimum_distance), + #np.array(above_below_X)[mask_ANC_data], +]) # Continuous columns that need to be standardized (weather_data, lag variables, altitude, minimum_distance) # X_continuous = np.column_stack([ # weather_data, @@ -577,7 +581,6 @@ def get_weather_data(ssp_scenario, model_type): weather_data_prediction_five_day_cumulative_original = weather_data_prediction_five_day_cumulative_original.drop( weather_data_prediction_five_day_cumulative_original.columns[0], axis=1 ) # first column are date/months - print(weather_data_prediction_five_day_cumulative_original) weather_data_prediction_monthly_original = pd.read_csv( f"{data_path}Precipitation_data/Downscaled_CMIP6_data_CIL/{ssp_scenario}/{model_type}_monthly_prediction_weather_by_facility.csv", dtype={'column_name': 'float64'} @@ -590,10 +593,10 @@ def get_weather_data(ssp_scenario, model_type): columns=zero_sum_columns) return weather_data_prediction_five_day_cumulative_df, weather_data_prediction_monthly_df -model_types = ['lowest', 'median' 'highest'] +model_types = ['lowest', 'median', 'highest'] # Configuration and constants min_year_for_analysis = 2025 -absolute_min_year = 2025 +absolute_min_year = 2024 max_year_for_analysis = 2071 data_path = "/Users/rem76/Desktop/Climate_change_health/Data/" @@ -603,6 +606,7 @@ def get_weather_data(ssp_scenario, model_type): # Load and preprocess weather data for ssp_scenario in ssp_scenarios: for model_type in model_types: + print(ssp_scenario, model_type) if use_all_weather: weather_data_prediction_five_day_cumulative_df, weather_data_prediction_monthly_df = get_weather_data(ssp_scenario, model_type) @@ -639,8 +643,6 @@ def get_weather_data(ssp_scenario, model_type): weather_data_prediction_monthly_flattened = weather_data_prediction_monthly.values.flatten() weather_data_prediction_five_day_cumulative_flattened = weather_data_prediction_five_day_cumulative.values.flatten() weather_data_prediction_flatten = np.vstack((weather_data_prediction_monthly_flattened, weather_data_prediction_five_day_cumulative_flattened)).T - print(weather_data_prediction_flatten.dtype) - num_facilities = len(weather_data_prediction_monthly.columns) else: if five_day: @@ -668,9 +670,9 @@ def get_weather_data(ssp_scenario, model_type): # Load and preprocess facility information zone_info_prediction = repeat_info(expanded_facility_info["Zonename"], num_facilities, year_range_prediction, historical = False) zone_encoded_prediction = pd.get_dummies(zone_info_prediction, drop_first=True) - + dist_info_prediction = repeat_info(expanded_facility_info["Dist"], num_facilities, year_range_prediction, historical=False) + dist_encoded_prediction = pd.get_dummies(dist_info_prediction, drop_first=True) resid_info_prediction = repeat_info(expanded_facility_info['Resid'], num_facilities, year_range_prediction, historical = False) - resid_encoded_prediction = pd.get_dummies(resid_info_prediction, drop_first=True) owner_info_prediction = repeat_info(expanded_facility_info['A105'], num_facilities, year_range_prediction, historical = False) owner_encoded_prediction = pd.get_dummies(owner_info_prediction, drop_first=True) @@ -696,6 +698,7 @@ def get_weather_data(ssp_scenario, model_type): np.array(month_flattened_prediction), resid_encoded_prediction, zone_encoded_prediction, + dist_encoded_prediction, owner_encoded_prediction, ftype_encoded_prediction, lag_1_month_prediction, @@ -783,6 +786,7 @@ def get_weather_data(ssp_scenario, model_type): np.array(month_flattened_prediction), resid_encoded_prediction, zone_encoded_prediction, + dist_encoded_prediction, owner_encoded_prediction, ftype_encoded_prediction, facility_encoded_prediction, @@ -799,7 +803,6 @@ def get_weather_data(ssp_scenario, model_type): predictions = predictions_weather - y_pred_ANC[X_basis_weather[:, 0] > mask_threshold] data_weather_predictions['y_pred_no_weather'] = y_pred_ANC[X_basis_weather[:, 0] > mask_threshold] - print(predictions) data_weather_predictions['difference_in_expectation'] = predictions data_weather_predictions['weather'] = X_basis_weather[X_basis_weather[:, 0] > mask_threshold, 0] data_weather_predictions_grouped = data_weather_predictions.groupby('Year_Month').mean().reset_index() @@ -826,22 +829,14 @@ def get_weather_data(ssp_scenario, model_type): plt.tight_layout() plt.show() - print(X_basis_weather[:, 0].min()) - print(X_basis_weather[:, 0].max()) - - ## Save predictions - print(len(year_flattened_prediction)) - print(year_flattened_prediction) - print(len(year_flattened_prediction[X_basis_weather[:, 0] > mask_threshold])) - print(year_flattened_prediction) # Format output: Add all relevant X variables - print(year_flattened_prediction[X_basis_weather[:, 0] > mask_threshold]) full_data_weather_predictions = pd.DataFrame({ 'Year': year_flattened_prediction[X_basis_weather[:, 0] > mask_threshold], 'Month': np.array(month_flattened_prediction)[X_basis_weather[:, 0] > mask_threshold], 'Facility_ID': facility_flattened_prediction[X_basis_weather[:, 0] > mask_threshold], 'Altitude': np.array(altitude_prediction)[X_basis_weather[:, 0] > mask_threshold], 'Zone': np.array(zone_info_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'District':np.array(dist_info_prediction)[X_basis_weather[:, 0] > mask_threshold], 'Resid': np.array(resid_info_prediction)[X_basis_weather[:, 0] > mask_threshold], 'Owner': np.array(owner_info_prediction)[X_basis_weather[:, 0] > mask_threshold], 'Facility_Type': np.array(ftype_info_prediction)[X_basis_weather[:, 0] > mask_threshold], From ae2222941b8b94b2c4af2d585b7f4e88c4bb7071 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 9 Jan 2025 11:14:41 +0000 Subject: [PATCH 169/291] "Contents are identical" --- .../CIL_CMIP6_downscaling.ipynb | 6331 ++++++++++++++++- 1 file changed, 6286 insertions(+), 45 deletions(-) diff --git a/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb b/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb index 213edfd4ca..a402bcc90e 100644 --- a/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb +++ b/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb @@ -947,11 +947,9 @@ }, { "metadata": { - "jupyter": { - "is_executing": true - }, "ExecuteTime": { - "start_time": "2025-01-09T09:21:44.738971Z" + "end_time": "2025-01-09T11:06:05.311500Z", + "start_time": "2025-01-09T10:47:08.857112Z" } }, "cell_type": "code", @@ -1092,20 +1090,20 @@ "text": [ "Processing scenario: ssp245\n", "Models of interest ['HadGEM3-GC31-LL', 'GFDL-CM4', 'INM-CM5-0']\n", - "Processing file: CIL_subset_ssp245_2025.nc\n", + "Processing file: CIL_subset_ssp245_2024.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2025, month 1\n", - "Processing year 2025, month 2\n", - "Processing year 2025, month 3\n", - "Processing year 2025, month 4\n", - "Processing year 2025, month 5\n", - "Processing year 2025, month 6\n", - "Processing year 2025, month 7\n", - "Processing year 2025, month 8\n", - "Processing year 2025, month 9\n", - "Processing year 2025, month 10\n", - "Processing year 2025, month 11\n", - "Processing year 2025, month 12\n" + "Processing year 2024, month 1\n", + "Processing year 2024, month 2\n", + "Processing year 2024, month 3\n", + "Processing year 2024, month 4\n", + "Processing year 2024, month 5\n", + "Processing year 2024, month 6\n", + "Processing year 2024, month 7\n", + "Processing year 2024, month 8\n", + "Processing year 2024, month 9\n", + "Processing year 2024, month 10\n", + "Processing year 2024, month 11\n", + "Processing year 2024, month 12\n" ] }, { @@ -2059,18 +2057,18 @@ "output_type": "stream", "text": [ "Processing model: GFDL-CM4\n", - "Processing year 2025, month 1\n", - "Processing year 2025, month 2\n", - "Processing year 2025, month 3\n", - "Processing year 2025, month 4\n", - "Processing year 2025, month 5\n", - "Processing year 2025, month 6\n", - "Processing year 2025, month 7\n", - "Processing year 2025, month 8\n", - "Processing year 2025, month 9\n", - "Processing year 2025, month 10\n", - "Processing year 2025, month 11\n", - "Processing year 2025, month 12\n" + "Processing year 2024, month 1\n", + "Processing year 2024, month 2\n", + "Processing year 2024, month 3\n", + "Processing year 2024, month 4\n", + "Processing year 2024, month 5\n", + "Processing year 2024, month 6\n", + "Processing year 2024, month 7\n", + "Processing year 2024, month 8\n", + "Processing year 2024, month 9\n", + "Processing year 2024, month 10\n", + "Processing year 2024, month 11\n", + "Processing year 2024, month 12\n" ] }, { @@ -3024,18 +3022,18 @@ "output_type": "stream", "text": [ "Processing model: INM-CM5-0\n", - "Processing year 2025, month 1\n", - "Processing year 2025, month 2\n", - "Processing year 2025, month 3\n", - "Processing year 2025, month 4\n", - "Processing year 2025, month 5\n", - "Processing year 2025, month 6\n", - "Processing year 2025, month 7\n", - "Processing year 2025, month 8\n", - "Processing year 2025, month 9\n", - "Processing year 2025, month 10\n", - "Processing year 2025, month 11\n", - "Processing year 2025, month 12\n" + "Processing year 2024, month 1\n", + "Processing year 2024, month 2\n", + "Processing year 2024, month 3\n", + "Processing year 2024, month 4\n", + "Processing year 2024, month 5\n", + "Processing year 2024, month 6\n", + "Processing year 2024, month 7\n", + "Processing year 2024, month 8\n", + "Processing year 2024, month 9\n", + "Processing year 2024, month 10\n", + "Processing year 2024, month 11\n", + "Processing year 2024, month 12\n" ] }, { @@ -3988,6 +3986,46 @@ "name": "stdout", "output_type": "stream", "text": [ + "Processing file: CIL_subset_ssp245_2025.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2025, month 1\n", + "Processing year 2025, month 2\n", + "Processing year 2025, month 3\n", + "Processing year 2025, month 4\n", + "Processing year 2025, month 5\n", + "Processing year 2025, month 6\n", + "Processing year 2025, month 7\n", + "Processing year 2025, month 8\n", + "Processing year 2025, month 9\n", + "Processing year 2025, month 10\n", + "Processing year 2025, month 11\n", + "Processing year 2025, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2025, month 1\n", + "Processing year 2025, month 2\n", + "Processing year 2025, month 3\n", + "Processing year 2025, month 4\n", + "Processing year 2025, month 5\n", + "Processing year 2025, month 6\n", + "Processing year 2025, month 7\n", + "Processing year 2025, month 8\n", + "Processing year 2025, month 9\n", + "Processing year 2025, month 10\n", + "Processing year 2025, month 11\n", + "Processing year 2025, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2025, month 1\n", + "Processing year 2025, month 2\n", + "Processing year 2025, month 3\n", + "Processing year 2025, month 4\n", + "Processing year 2025, month 5\n", + "Processing year 2025, month 6\n", + "Processing year 2025, month 7\n", + "Processing year 2025, month 8\n", + "Processing year 2025, month 9\n", + "Processing year 2025, month 10\n", + "Processing year 2025, month 11\n", + "Processing year 2025, month 12\n", "Processing file: CIL_subset_ssp245_2026.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2026, month 1\n", @@ -4334,11 +4372,6214 @@ "Processing year 2034, month 9\n", "Processing year 2034, month 10\n", "Processing year 2034, month 11\n", - "Processing year 2034, month 12\n" + "Processing year 2034, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2034, month 1\n", + "Processing year 2034, month 2\n", + "Processing year 2034, month 3\n", + "Processing year 2034, month 4\n", + "Processing year 2034, month 5\n", + "Processing year 2034, month 6\n", + "Processing year 2034, month 7\n", + "Processing year 2034, month 8\n", + "Processing year 2034, month 9\n", + "Processing year 2034, month 10\n", + "Processing year 2034, month 11\n", + "Processing year 2034, month 12\n", + "Processing file: CIL_subset_ssp245_2035.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2035, month 1\n", + "Processing year 2035, month 2\n", + "Processing year 2035, month 3\n", + "Processing year 2035, month 4\n", + "Processing year 2035, month 5\n", + "Processing year 2035, month 6\n", + "Processing year 2035, month 7\n", + "Processing year 2035, month 8\n", + "Processing year 2035, month 9\n", + "Processing year 2035, month 10\n", + "Processing year 2035, month 11\n", + "Processing year 2035, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2035, month 1\n", + "Processing year 2035, month 2\n", + "Processing year 2035, month 3\n", + "Processing year 2035, month 4\n", + "Processing year 2035, month 5\n", + "Processing year 2035, month 6\n", + "Processing year 2035, month 7\n", + "Processing year 2035, month 8\n", + "Processing year 2035, month 9\n", + "Processing year 2035, month 10\n", + "Processing year 2035, month 11\n", + "Processing year 2035, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2035, month 1\n", + "Processing year 2035, month 2\n", + "Processing year 2035, month 3\n", + "Processing year 2035, month 4\n", + "Processing year 2035, month 5\n", + "Processing year 2035, month 6\n", + "Processing year 2035, month 7\n", + "Processing year 2035, month 8\n", + "Processing year 2035, month 9\n", + "Processing year 2035, month 10\n", + "Processing year 2035, month 11\n", + "Processing year 2035, month 12\n", + "Processing file: CIL_subset_ssp245_2036.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2036, month 1\n", + "Processing year 2036, month 2\n", + "Processing year 2036, month 3\n", + "Processing year 2036, month 4\n", + "Processing year 2036, month 5\n", + "Processing year 2036, month 6\n", + "Processing year 2036, month 7\n", + "Processing year 2036, month 8\n", + "Processing year 2036, month 9\n", + "Processing year 2036, month 10\n", + "Processing year 2036, month 11\n", + "Processing year 2036, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2036, month 1\n", + "Processing year 2036, month 2\n", + "Processing year 2036, month 3\n", + "Processing year 2036, month 4\n", + "Processing year 2036, month 5\n", + "Processing year 2036, month 6\n", + "Processing year 2036, month 7\n", + "Processing year 2036, month 8\n", + "Processing year 2036, month 9\n", + "Processing year 2036, month 10\n", + "Processing year 2036, month 11\n", + "Processing year 2036, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2036, month 1\n", + "Processing year 2036, month 2\n", + "Processing year 2036, month 3\n", + "Processing year 2036, month 4\n", + "Processing year 2036, month 5\n", + "Processing year 2036, month 6\n", + "Processing year 2036, month 7\n", + "Processing year 2036, month 8\n", + "Processing year 2036, month 9\n", + "Processing year 2036, month 10\n", + "Processing year 2036, month 11\n", + "Processing year 2036, month 12\n", + "Processing file: CIL_subset_ssp245_2037.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2037, month 1\n", + "Processing year 2037, month 2\n", + "Processing year 2037, month 3\n", + "Processing year 2037, month 4\n", + "Processing year 2037, month 5\n", + "Processing year 2037, month 6\n", + "Processing year 2037, month 7\n", + "Processing year 2037, month 8\n", + "Processing year 2037, month 9\n", + "Processing year 2037, month 10\n", + "Processing year 2037, month 11\n", + "Processing year 2037, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2037, month 1\n", + "Processing year 2037, month 2\n", + "Processing year 2037, month 3\n", + "Processing year 2037, month 4\n", + "Processing year 2037, month 5\n", + "Processing year 2037, month 6\n", + "Processing year 2037, month 7\n", + "Processing year 2037, month 8\n", + "Processing year 2037, month 9\n", + "Processing year 2037, month 10\n", + "Processing year 2037, month 11\n", + "Processing year 2037, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2037, month 1\n", + "Processing year 2037, month 2\n", + "Processing year 2037, month 3\n", + "Processing year 2037, month 4\n", + "Processing year 2037, month 5\n", + "Processing year 2037, month 6\n", + "Processing year 2037, month 7\n", + "Processing year 2037, month 8\n", + "Processing year 2037, month 9\n", + "Processing year 2037, month 10\n", + "Processing year 2037, month 11\n", + "Processing year 2037, month 12\n", + "Processing file: CIL_subset_ssp245_2038.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2038, month 1\n", + "Processing year 2038, month 2\n", + "Processing year 2038, month 3\n", + "Processing year 2038, month 4\n", + "Processing year 2038, month 5\n", + "Processing year 2038, month 6\n", + "Processing year 2038, month 7\n", + "Processing year 2038, month 8\n", + "Processing year 2038, month 9\n", + "Processing year 2038, month 10\n", + "Processing year 2038, month 11\n", + "Processing year 2038, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2038, month 1\n", + "Processing year 2038, month 2\n", + "Processing year 2038, month 3\n", + "Processing year 2038, month 4\n", + "Processing year 2038, month 5\n", + "Processing year 2038, month 6\n", + "Processing year 2038, month 7\n", + "Processing year 2038, month 8\n", + "Processing year 2038, month 9\n", + "Processing year 2038, month 10\n", + "Processing year 2038, month 11\n", + "Processing year 2038, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2038, month 1\n", + "Processing year 2038, month 2\n", + "Processing year 2038, month 3\n", + "Processing year 2038, month 4\n", + "Processing year 2038, month 5\n", + "Processing year 2038, month 6\n", + "Processing year 2038, month 7\n", + "Processing year 2038, month 8\n", + "Processing year 2038, month 9\n", + "Processing year 2038, month 10\n", + "Processing year 2038, month 11\n", + "Processing year 2038, month 12\n", + "Processing file: CIL_subset_ssp245_2039.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2039, month 1\n", + "Processing year 2039, month 2\n", + "Processing year 2039, month 3\n", + "Processing year 2039, month 4\n", + "Processing year 2039, month 5\n", + "Processing year 2039, month 6\n", + "Processing year 2039, month 7\n", + "Processing year 2039, month 8\n", + "Processing year 2039, month 9\n", + "Processing year 2039, month 10\n", + "Processing year 2039, month 11\n", + "Processing year 2039, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2039, month 1\n", + "Processing year 2039, month 2\n", + "Processing year 2039, month 3\n", + "Processing year 2039, month 4\n", + "Processing year 2039, month 5\n", + "Processing year 2039, month 6\n", + "Processing year 2039, month 7\n", + "Processing year 2039, month 8\n", + "Processing year 2039, month 9\n", + "Processing year 2039, month 10\n", + "Processing year 2039, month 11\n", + "Processing year 2039, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2039, month 1\n", + "Processing year 2039, month 2\n", + "Processing year 2039, month 3\n", + "Processing year 2039, month 4\n", + "Processing year 2039, month 5\n", + "Processing year 2039, month 6\n", + "Processing year 2039, month 7\n", + "Processing year 2039, month 8\n", + "Processing year 2039, month 9\n", + "Processing year 2039, month 10\n", + "Processing year 2039, month 11\n", + "Processing year 2039, month 12\n", + "Processing file: CIL_subset_ssp245_2040.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2040, month 1\n", + "Processing year 2040, month 2\n", + "Processing year 2040, month 3\n", + "Processing year 2040, month 4\n", + "Processing year 2040, month 5\n", + "Processing year 2040, month 6\n", + "Processing year 2040, month 7\n", + "Processing year 2040, month 8\n", + "Processing year 2040, month 9\n", + "Processing year 2040, month 10\n", + "Processing year 2040, month 11\n", + "Processing year 2040, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2040, month 1\n", + "Processing year 2040, month 2\n", + "Processing year 2040, month 3\n", + "Processing year 2040, month 4\n", + "Processing year 2040, month 5\n", + "Processing year 2040, month 6\n", + "Processing year 2040, month 7\n", + "Processing year 2040, month 8\n", + "Processing year 2040, month 9\n", + "Processing year 2040, month 10\n", + "Processing year 2040, month 11\n", + "Processing year 2040, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2040, month 1\n", + "Processing year 2040, month 2\n", + "Processing year 2040, month 3\n", + "Processing year 2040, month 4\n", + "Processing year 2040, month 5\n", + "Processing year 2040, month 6\n", + "Processing year 2040, month 7\n", + "Processing year 2040, month 8\n", + "Processing year 2040, month 9\n", + "Processing year 2040, month 10\n", + "Processing year 2040, month 11\n", + "Processing year 2040, month 12\n", + "Processing file: CIL_subset_ssp245_2041.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2041, month 1\n", + "Processing year 2041, month 2\n", + "Processing year 2041, month 3\n", + "Processing year 2041, month 4\n", + "Processing year 2041, month 5\n", + "Processing year 2041, month 6\n", + "Processing year 2041, month 7\n", + "Processing year 2041, month 8\n", + "Processing year 2041, month 9\n", + "Processing year 2041, month 10\n", + "Processing year 2041, month 11\n", + "Processing year 2041, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2041, month 1\n", + "Processing year 2041, month 2\n", + "Processing year 2041, month 3\n", + "Processing year 2041, month 4\n", + "Processing year 2041, month 5\n", + "Processing year 2041, month 6\n", + "Processing year 2041, month 7\n", + "Processing year 2041, month 8\n", + "Processing year 2041, month 9\n", + "Processing year 2041, month 10\n", + "Processing year 2041, month 11\n", + "Processing year 2041, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2041, month 1\n", + "Processing year 2041, month 2\n", + "Processing year 2041, month 3\n", + "Processing year 2041, month 4\n", + "Processing year 2041, month 5\n", + "Processing year 2041, month 6\n", + "Processing year 2041, month 7\n", + "Processing year 2041, month 8\n", + "Processing year 2041, month 9\n", + "Processing year 2041, month 10\n", + "Processing year 2041, month 11\n", + "Processing year 2041, month 12\n", + "Processing file: CIL_subset_ssp245_2042.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2042, month 1\n", + "Processing year 2042, month 2\n", + "Processing year 2042, month 3\n", + "Processing year 2042, month 4\n", + "Processing year 2042, month 5\n", + "Processing year 2042, month 6\n", + "Processing year 2042, month 7\n", + "Processing year 2042, month 8\n", + "Processing year 2042, month 9\n", + "Processing year 2042, month 10\n", + "Processing year 2042, month 11\n", + "Processing year 2042, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2042, month 1\n", + "Processing year 2042, month 2\n", + "Processing year 2042, month 3\n", + "Processing year 2042, month 4\n", + "Processing year 2042, month 5\n", + "Processing year 2042, month 6\n", + "Processing year 2042, month 7\n", + "Processing year 2042, month 8\n", + "Processing year 2042, month 9\n", + "Processing year 2042, month 10\n", + "Processing year 2042, month 11\n", + "Processing year 2042, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2042, month 1\n", + "Processing year 2042, month 2\n", + "Processing year 2042, month 3\n", + "Processing year 2042, month 4\n", + "Processing year 2042, month 5\n", + "Processing year 2042, month 6\n", + "Processing year 2042, month 7\n", + "Processing year 2042, month 8\n", + "Processing year 2042, month 9\n", + "Processing year 2042, month 10\n", + "Processing year 2042, month 11\n", + "Processing year 2042, month 12\n", + "Processing file: CIL_subset_ssp245_2043.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2043, month 1\n", + "Processing year 2043, month 2\n", + "Processing year 2043, month 3\n", + "Processing year 2043, month 4\n", + "Processing year 2043, month 5\n", + "Processing year 2043, month 6\n", + "Processing year 2043, month 7\n", + "Processing year 2043, month 8\n", + "Processing year 2043, month 9\n", + "Processing year 2043, month 10\n", + "Processing year 2043, month 11\n", + "Processing year 2043, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2043, month 1\n", + "Processing year 2043, month 2\n", + "Processing year 2043, month 3\n", + "Processing year 2043, month 4\n", + "Processing year 2043, month 5\n", + "Processing year 2043, month 6\n", + "Processing year 2043, month 7\n", + "Processing year 2043, month 8\n", + "Processing year 2043, month 9\n", + "Processing year 2043, month 10\n", + "Processing year 2043, month 11\n", + "Processing year 2043, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2043, month 1\n", + "Processing year 2043, month 2\n", + "Processing year 2043, month 3\n", + "Processing year 2043, month 4\n", + "Processing year 2043, month 5\n", + "Processing year 2043, month 6\n", + "Processing year 2043, month 7\n", + "Processing year 2043, month 8\n", + "Processing year 2043, month 9\n", + "Processing year 2043, month 10\n", + "Processing year 2043, month 11\n", + "Processing year 2043, month 12\n", + "Processing file: CIL_subset_ssp245_2044.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2044, month 1\n", + "Processing year 2044, month 2\n", + "Processing year 2044, month 3\n", + "Processing year 2044, month 4\n", + "Processing year 2044, month 5\n", + "Processing year 2044, month 6\n", + "Processing year 2044, month 7\n", + "Processing year 2044, month 8\n", + "Processing year 2044, month 9\n", + "Processing year 2044, month 10\n", + "Processing year 2044, month 11\n", + "Processing year 2044, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2044, month 1\n", + "Processing year 2044, month 2\n", + "Processing year 2044, month 3\n", + "Processing year 2044, month 4\n", + "Processing year 2044, month 5\n", + "Processing year 2044, month 6\n", + "Processing year 2044, month 7\n", + "Processing year 2044, month 8\n", + "Processing year 2044, month 9\n", + "Processing year 2044, month 10\n", + "Processing year 2044, month 11\n", + "Processing year 2044, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2044, month 1\n", + "Processing year 2044, month 2\n", + "Processing year 2044, month 3\n", + "Processing year 2044, month 4\n", + "Processing year 2044, month 5\n", + "Processing year 2044, month 6\n", + "Processing year 2044, month 7\n", + "Processing year 2044, month 8\n", + "Processing year 2044, month 9\n", + "Processing year 2044, month 10\n", + "Processing year 2044, month 11\n", + "Processing year 2044, month 12\n", + "Processing file: CIL_subset_ssp245_2045.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2045, month 1\n", + "Processing year 2045, month 2\n", + "Processing year 2045, month 3\n", + "Processing year 2045, month 4\n", + "Processing year 2045, month 5\n", + "Processing year 2045, month 6\n", + "Processing year 2045, month 7\n", + "Processing year 2045, month 8\n", + "Processing year 2045, month 9\n", + "Processing year 2045, month 10\n", + "Processing year 2045, month 11\n", + "Processing year 2045, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2045, month 1\n", + "Processing year 2045, month 2\n", + "Processing year 2045, month 3\n", + "Processing year 2045, month 4\n", + "Processing year 2045, month 5\n", + "Processing year 2045, month 6\n", + "Processing year 2045, month 7\n", + "Processing year 2045, month 8\n", + "Processing year 2045, month 9\n", + "Processing year 2045, month 10\n", + "Processing year 2045, month 11\n", + "Processing year 2045, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2045, month 1\n", + "Processing year 2045, month 2\n", + "Processing year 2045, month 3\n", + "Processing year 2045, month 4\n", + "Processing year 2045, month 5\n", + "Processing year 2045, month 6\n", + "Processing year 2045, month 7\n", + "Processing year 2045, month 8\n", + "Processing year 2045, month 9\n", + "Processing year 2045, month 10\n", + "Processing year 2045, month 11\n", + "Processing year 2045, month 12\n", + "Processing file: CIL_subset_ssp245_2046.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2046, month 1\n", + "Processing year 2046, month 2\n", + "Processing year 2046, month 3\n", + "Processing year 2046, month 4\n", + "Processing year 2046, month 5\n", + "Processing year 2046, month 6\n", + "Processing year 2046, month 7\n", + "Processing year 2046, month 8\n", + "Processing year 2046, month 9\n", + "Processing year 2046, month 10\n", + "Processing year 2046, month 11\n", + "Processing year 2046, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2046, month 1\n", + "Processing year 2046, month 2\n", + "Processing year 2046, month 3\n", + "Processing year 2046, month 4\n", + "Processing year 2046, month 5\n", + "Processing year 2046, month 6\n", + "Processing year 2046, month 7\n", + "Processing year 2046, month 8\n", + "Processing year 2046, month 9\n", + "Processing year 2046, month 10\n", + "Processing year 2046, month 11\n", + "Processing year 2046, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2046, month 1\n", + "Processing year 2046, month 2\n", + "Processing year 2046, month 3\n", + "Processing year 2046, month 4\n", + "Processing year 2046, month 5\n", + "Processing year 2046, month 6\n", + "Processing year 2046, month 7\n", + "Processing year 2046, month 8\n", + "Processing year 2046, month 9\n", + "Processing year 2046, month 10\n", + "Processing year 2046, month 11\n", + "Processing year 2046, month 12\n", + "Processing file: CIL_subset_ssp245_2047.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2047, month 1\n", + "Processing year 2047, month 2\n", + "Processing year 2047, month 3\n", + "Processing year 2047, month 4\n", + "Processing year 2047, month 5\n", + "Processing year 2047, month 6\n", + "Processing year 2047, month 7\n", + "Processing year 2047, month 8\n", + "Processing year 2047, month 9\n", + "Processing year 2047, month 10\n", + "Processing year 2047, month 11\n", + "Processing year 2047, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2047, month 1\n", + "Processing year 2047, month 2\n", + "Processing year 2047, month 3\n", + "Processing year 2047, month 4\n", + "Processing year 2047, month 5\n", + "Processing year 2047, month 6\n", + "Processing year 2047, month 7\n", + "Processing year 2047, month 8\n", + "Processing year 2047, month 9\n", + "Processing year 2047, month 10\n", + "Processing year 2047, month 11\n", + "Processing year 2047, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2047, month 1\n", + "Processing year 2047, month 2\n", + "Processing year 2047, month 3\n", + "Processing year 2047, month 4\n", + "Processing year 2047, month 5\n", + "Processing year 2047, month 6\n", + "Processing year 2047, month 7\n", + "Processing year 2047, month 8\n", + "Processing year 2047, month 9\n", + "Processing year 2047, month 10\n", + "Processing year 2047, month 11\n", + "Processing year 2047, month 12\n", + "Processing file: CIL_subset_ssp245_2048.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2048, month 1\n", + "Processing year 2048, month 2\n", + "Processing year 2048, month 3\n", + "Processing year 2048, month 4\n", + "Processing year 2048, month 5\n", + "Processing year 2048, month 6\n", + "Processing year 2048, month 7\n", + "Processing year 2048, month 8\n", + "Processing year 2048, month 9\n", + "Processing year 2048, month 10\n", + "Processing year 2048, month 11\n", + "Processing year 2048, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2048, month 1\n", + "Processing year 2048, month 2\n", + "Processing year 2048, month 3\n", + "Processing year 2048, month 4\n", + "Processing year 2048, month 5\n", + "Processing year 2048, month 6\n", + "Processing year 2048, month 7\n", + "Processing year 2048, month 8\n", + "Processing year 2048, month 9\n", + "Processing year 2048, month 10\n", + "Processing year 2048, month 11\n", + "Processing year 2048, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2048, month 1\n", + "Processing year 2048, month 2\n", + "Processing year 2048, month 3\n", + "Processing year 2048, month 4\n", + "Processing year 2048, month 5\n", + "Processing year 2048, month 6\n", + "Processing year 2048, month 7\n", + "Processing year 2048, month 8\n", + "Processing year 2048, month 9\n", + "Processing year 2048, month 10\n", + "Processing year 2048, month 11\n", + "Processing year 2048, month 12\n", + "Processing file: CIL_subset_ssp245_2049.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2049, month 1\n", + "Processing year 2049, month 2\n", + "Processing year 2049, month 3\n", + "Processing year 2049, month 4\n", + "Processing year 2049, month 5\n", + "Processing year 2049, month 6\n", + "Processing year 2049, month 7\n", + "Processing year 2049, month 8\n", + "Processing year 2049, month 9\n", + "Processing year 2049, month 10\n", + "Processing year 2049, month 11\n", + "Processing year 2049, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2049, month 1\n", + "Processing year 2049, month 2\n", + "Processing year 2049, month 3\n", + "Processing year 2049, month 4\n", + "Processing year 2049, month 5\n", + "Processing year 2049, month 6\n", + "Processing year 2049, month 7\n", + "Processing year 2049, month 8\n", + "Processing year 2049, month 9\n", + "Processing year 2049, month 10\n", + "Processing year 2049, month 11\n", + "Processing year 2049, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2049, month 1\n", + "Processing year 2049, month 2\n", + "Processing year 2049, month 3\n", + "Processing year 2049, month 4\n", + "Processing year 2049, month 5\n", + "Processing year 2049, month 6\n", + "Processing year 2049, month 7\n", + "Processing year 2049, month 8\n", + "Processing year 2049, month 9\n", + "Processing year 2049, month 10\n", + "Processing year 2049, month 11\n", + "Processing year 2049, month 12\n", + "Processing file: CIL_subset_ssp245_2050.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2050, month 1\n", + "Processing year 2050, month 2\n", + "Processing year 2050, month 3\n", + "Processing year 2050, month 4\n", + "Processing year 2050, month 5\n", + "Processing year 2050, month 6\n", + "Processing year 2050, month 7\n", + "Processing year 2050, month 8\n", + "Processing year 2050, month 9\n", + "Processing year 2050, month 10\n", + "Processing year 2050, month 11\n", + "Processing year 2050, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2050, month 1\n", + "Processing year 2050, month 2\n", + "Processing year 2050, month 3\n", + "Processing year 2050, month 4\n", + "Processing year 2050, month 5\n", + "Processing year 2050, month 6\n", + "Processing year 2050, month 7\n", + "Processing year 2050, month 8\n", + "Processing year 2050, month 9\n", + "Processing year 2050, month 10\n", + "Processing year 2050, month 11\n", + "Processing year 2050, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2050, month 1\n", + "Processing year 2050, month 2\n", + "Processing year 2050, month 3\n", + "Processing year 2050, month 4\n", + "Processing year 2050, month 5\n", + "Processing year 2050, month 6\n", + "Processing year 2050, month 7\n", + "Processing year 2050, month 8\n", + "Processing year 2050, month 9\n", + "Processing year 2050, month 10\n", + "Processing year 2050, month 11\n", + "Processing year 2050, month 12\n", + "Processing file: CIL_subset_ssp245_2051.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2051, month 1\n", + "Processing year 2051, month 2\n", + "Processing year 2051, month 3\n", + "Processing year 2051, month 4\n", + "Processing year 2051, month 5\n", + "Processing year 2051, month 6\n", + "Processing year 2051, month 7\n", + "Processing year 2051, month 8\n", + "Processing year 2051, month 9\n", + "Processing year 2051, month 10\n", + "Processing year 2051, month 11\n", + "Processing year 2051, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2051, month 1\n", + "Processing year 2051, month 2\n", + "Processing year 2051, month 3\n", + "Processing year 2051, month 4\n", + "Processing year 2051, month 5\n", + "Processing year 2051, month 6\n", + "Processing year 2051, month 7\n", + "Processing year 2051, month 8\n", + "Processing year 2051, month 9\n", + "Processing year 2051, month 10\n", + "Processing year 2051, month 11\n", + "Processing year 2051, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2051, month 1\n", + "Processing year 2051, month 2\n", + "Processing year 2051, month 3\n", + "Processing year 2051, month 4\n", + "Processing year 2051, month 5\n", + "Processing year 2051, month 6\n", + "Processing year 2051, month 7\n", + "Processing year 2051, month 8\n", + "Processing year 2051, month 9\n", + "Processing year 2051, month 10\n", + "Processing year 2051, month 11\n", + "Processing year 2051, month 12\n", + "Processing file: CIL_subset_ssp245_2052.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2052, month 1\n", + "Processing year 2052, month 2\n", + "Processing year 2052, month 3\n", + "Processing year 2052, month 4\n", + "Processing year 2052, month 5\n", + "Processing year 2052, month 6\n", + "Processing year 2052, month 7\n", + "Processing year 2052, month 8\n", + "Processing year 2052, month 9\n", + "Processing year 2052, month 10\n", + "Processing year 2052, month 11\n", + "Processing year 2052, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2052, month 1\n", + "Processing year 2052, month 2\n", + "Processing year 2052, month 3\n", + "Processing year 2052, month 4\n", + "Processing year 2052, month 5\n", + "Processing year 2052, month 6\n", + "Processing year 2052, month 7\n", + "Processing year 2052, month 8\n", + "Processing year 2052, month 9\n", + "Processing year 2052, month 10\n", + "Processing year 2052, month 11\n", + "Processing year 2052, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2052, month 1\n", + "Processing year 2052, month 2\n", + "Processing year 2052, month 3\n", + "Processing year 2052, month 4\n", + "Processing year 2052, month 5\n", + "Processing year 2052, month 6\n", + "Processing year 2052, month 7\n", + "Processing year 2052, month 8\n", + "Processing year 2052, month 9\n", + "Processing year 2052, month 10\n", + "Processing year 2052, month 11\n", + "Processing year 2052, month 12\n", + "Processing file: CIL_subset_ssp245_2053.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2053, month 1\n", + "Processing year 2053, month 2\n", + "Processing year 2053, month 3\n", + "Processing year 2053, month 4\n", + "Processing year 2053, month 5\n", + "Processing year 2053, month 6\n", + "Processing year 2053, month 7\n", + "Processing year 2053, month 8\n", + "Processing year 2053, month 9\n", + "Processing year 2053, month 10\n", + "Processing year 2053, month 11\n", + "Processing year 2053, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2053, month 1\n", + "Processing year 2053, month 2\n", + "Processing year 2053, month 3\n", + "Processing year 2053, month 4\n", + "Processing year 2053, month 5\n", + "Processing year 2053, month 6\n", + "Processing year 2053, month 7\n", + "Processing year 2053, month 8\n", + "Processing year 2053, month 9\n", + "Processing year 2053, month 10\n", + "Processing year 2053, month 11\n", + "Processing year 2053, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2053, month 1\n", + "Processing year 2053, month 2\n", + "Processing year 2053, month 3\n", + "Processing year 2053, month 4\n", + "Processing year 2053, month 5\n", + "Processing year 2053, month 6\n", + "Processing year 2053, month 7\n", + "Processing year 2053, month 8\n", + "Processing year 2053, month 9\n", + "Processing year 2053, month 10\n", + "Processing year 2053, month 11\n", + "Processing year 2053, month 12\n", + "Processing file: CIL_subset_ssp245_2054.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2054, month 1\n", + "Processing year 2054, month 2\n", + "Processing year 2054, month 3\n", + "Processing year 2054, month 4\n", + "Processing year 2054, month 5\n", + "Processing year 2054, month 6\n", + "Processing year 2054, month 7\n", + "Processing year 2054, month 8\n", + "Processing year 2054, month 9\n", + "Processing year 2054, month 10\n", + "Processing year 2054, month 11\n", + "Processing year 2054, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2054, month 1\n", + "Processing year 2054, month 2\n", + "Processing year 2054, month 3\n", + "Processing year 2054, month 4\n", + "Processing year 2054, month 5\n", + "Processing year 2054, month 6\n", + "Processing year 2054, month 7\n", + "Processing year 2054, month 8\n", + "Processing year 2054, month 9\n", + "Processing year 2054, month 10\n", + "Processing year 2054, month 11\n", + "Processing year 2054, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2054, month 1\n", + "Processing year 2054, month 2\n", + "Processing year 2054, month 3\n", + "Processing year 2054, month 4\n", + "Processing year 2054, month 5\n", + "Processing year 2054, month 6\n", + "Processing year 2054, month 7\n", + "Processing year 2054, month 8\n", + "Processing year 2054, month 9\n", + "Processing year 2054, month 10\n", + "Processing year 2054, month 11\n", + "Processing year 2054, month 12\n", + "Processing file: CIL_subset_ssp245_2055.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2055, month 1\n", + "Processing year 2055, month 2\n", + "Processing year 2055, month 3\n", + "Processing year 2055, month 4\n", + "Processing year 2055, month 5\n", + "Processing year 2055, month 6\n", + "Processing year 2055, month 7\n", + "Processing year 2055, month 8\n", + "Processing year 2055, month 9\n", + "Processing year 2055, month 10\n", + "Processing year 2055, month 11\n", + "Processing year 2055, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2055, month 1\n", + "Processing year 2055, month 2\n", + "Processing year 2055, month 3\n", + "Processing year 2055, month 4\n", + "Processing year 2055, month 5\n", + "Processing year 2055, month 6\n", + "Processing year 2055, month 7\n", + "Processing year 2055, month 8\n", + "Processing year 2055, month 9\n", + "Processing year 2055, month 10\n", + "Processing year 2055, month 11\n", + "Processing year 2055, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2055, month 1\n", + "Processing year 2055, month 2\n", + "Processing year 2055, month 3\n", + "Processing year 2055, month 4\n", + "Processing year 2055, month 5\n", + "Processing year 2055, month 6\n", + "Processing year 2055, month 7\n", + "Processing year 2055, month 8\n", + "Processing year 2055, month 9\n", + "Processing year 2055, month 10\n", + "Processing year 2055, month 11\n", + "Processing year 2055, month 12\n", + "Processing file: CIL_subset_ssp245_2056.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2056, month 1\n", + "Processing year 2056, month 2\n", + "Processing year 2056, month 3\n", + "Processing year 2056, month 4\n", + "Processing year 2056, month 5\n", + "Processing year 2056, month 6\n", + "Processing year 2056, month 7\n", + "Processing year 2056, month 8\n", + "Processing year 2056, month 9\n", + "Processing year 2056, month 10\n", + "Processing year 2056, month 11\n", + "Processing year 2056, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2056, month 1\n", + "Processing year 2056, month 2\n", + "Processing year 2056, month 3\n", + "Processing year 2056, month 4\n", + "Processing year 2056, month 5\n", + "Processing year 2056, month 6\n", + "Processing year 2056, month 7\n", + "Processing year 2056, month 8\n", + "Processing year 2056, month 9\n", + "Processing year 2056, month 10\n", + "Processing year 2056, month 11\n", + "Processing year 2056, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2056, month 1\n", + "Processing year 2056, month 2\n", + "Processing year 2056, month 3\n", + "Processing year 2056, month 4\n", + "Processing year 2056, month 5\n", + "Processing year 2056, month 6\n", + "Processing year 2056, month 7\n", + "Processing year 2056, month 8\n", + "Processing year 2056, month 9\n", + "Processing year 2056, month 10\n", + "Processing year 2056, month 11\n", + "Processing year 2056, month 12\n", + "Processing file: CIL_subset_ssp245_2057.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2057, month 1\n", + "Processing year 2057, month 2\n", + "Processing year 2057, month 3\n", + "Processing year 2057, month 4\n", + "Processing year 2057, month 5\n", + "Processing year 2057, month 6\n", + "Processing year 2057, month 7\n", + "Processing year 2057, month 8\n", + "Processing year 2057, month 9\n", + "Processing year 2057, month 10\n", + "Processing year 2057, month 11\n", + "Processing year 2057, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2057, month 1\n", + "Processing year 2057, month 2\n", + "Processing year 2057, month 3\n", + "Processing year 2057, month 4\n", + "Processing year 2057, month 5\n", + "Processing year 2057, month 6\n", + "Processing year 2057, month 7\n", + "Processing year 2057, month 8\n", + "Processing year 2057, month 9\n", + "Processing year 2057, month 10\n", + "Processing year 2057, month 11\n", + "Processing year 2057, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2057, month 1\n", + "Processing year 2057, month 2\n", + "Processing year 2057, month 3\n", + "Processing year 2057, month 4\n", + "Processing year 2057, month 5\n", + "Processing year 2057, month 6\n", + "Processing year 2057, month 7\n", + "Processing year 2057, month 8\n", + "Processing year 2057, month 9\n", + "Processing year 2057, month 10\n", + "Processing year 2057, month 11\n", + "Processing year 2057, month 12\n", + "Processing file: CIL_subset_ssp245_2058.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2058, month 1\n", + "Processing year 2058, month 2\n", + "Processing year 2058, month 3\n", + "Processing year 2058, month 4\n", + "Processing year 2058, month 5\n", + "Processing year 2058, month 6\n", + "Processing year 2058, month 7\n", + "Processing year 2058, month 8\n", + "Processing year 2058, month 9\n", + "Processing year 2058, month 10\n", + "Processing year 2058, month 11\n", + "Processing year 2058, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2058, month 1\n", + "Processing year 2058, month 2\n", + "Processing year 2058, month 3\n", + "Processing year 2058, month 4\n", + "Processing year 2058, month 5\n", + "Processing year 2058, month 6\n", + "Processing year 2058, month 7\n", + "Processing year 2058, month 8\n", + "Processing year 2058, month 9\n", + "Processing year 2058, month 10\n", + "Processing year 2058, month 11\n", + "Processing year 2058, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2058, month 1\n", + "Processing year 2058, month 2\n", + "Processing year 2058, month 3\n", + "Processing year 2058, month 4\n", + "Processing year 2058, month 5\n", + "Processing year 2058, month 6\n", + "Processing year 2058, month 7\n", + "Processing year 2058, month 8\n", + "Processing year 2058, month 9\n", + "Processing year 2058, month 10\n", + "Processing year 2058, month 11\n", + "Processing year 2058, month 12\n", + "Processing file: CIL_subset_ssp245_2059.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2059, month 1\n", + "Processing year 2059, month 2\n", + "Processing year 2059, month 3\n", + "Processing year 2059, month 4\n", + "Processing year 2059, month 5\n", + "Processing year 2059, month 6\n", + "Processing year 2059, month 7\n", + "Processing year 2059, month 8\n", + "Processing year 2059, month 9\n", + "Processing year 2059, month 10\n", + "Processing year 2059, month 11\n", + "Processing year 2059, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2059, month 1\n", + "Processing year 2059, month 2\n", + "Processing year 2059, month 3\n", + "Processing year 2059, month 4\n", + "Processing year 2059, month 5\n", + "Processing year 2059, month 6\n", + "Processing year 2059, month 7\n", + "Processing year 2059, month 8\n", + "Processing year 2059, month 9\n", + "Processing year 2059, month 10\n", + "Processing year 2059, month 11\n", + "Processing year 2059, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2059, month 1\n", + "Processing year 2059, month 2\n", + "Processing year 2059, month 3\n", + "Processing year 2059, month 4\n", + "Processing year 2059, month 5\n", + "Processing year 2059, month 6\n", + "Processing year 2059, month 7\n", + "Processing year 2059, month 8\n", + "Processing year 2059, month 9\n", + "Processing year 2059, month 10\n", + "Processing year 2059, month 11\n", + "Processing year 2059, month 12\n", + "Processing file: CIL_subset_ssp245_2060.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2060, month 1\n", + "Processing year 2060, month 2\n", + "Processing year 2060, month 3\n", + "Processing year 2060, month 4\n", + "Processing year 2060, month 5\n", + "Processing year 2060, month 6\n", + "Processing year 2060, month 7\n", + "Processing year 2060, month 8\n", + "Processing year 2060, month 9\n", + "Processing year 2060, month 10\n", + "Processing year 2060, month 11\n", + "Processing year 2060, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2060, month 1\n", + "Processing year 2060, month 2\n", + "Processing year 2060, month 3\n", + "Processing year 2060, month 4\n", + "Processing year 2060, month 5\n", + "Processing year 2060, month 6\n", + "Processing year 2060, month 7\n", + "Processing year 2060, month 8\n", + "Processing year 2060, month 9\n", + "Processing year 2060, month 10\n", + "Processing year 2060, month 11\n", + "Processing year 2060, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2060, month 1\n", + "Processing year 2060, month 2\n", + "Processing year 2060, month 3\n", + "Processing year 2060, month 4\n", + "Processing year 2060, month 5\n", + "Processing year 2060, month 6\n", + "Processing year 2060, month 7\n", + "Processing year 2060, month 8\n", + "Processing year 2060, month 9\n", + "Processing year 2060, month 10\n", + "Processing year 2060, month 11\n", + "Processing year 2060, month 12\n", + "Processing file: CIL_subset_ssp245_2061.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2061, month 1\n", + "Processing year 2061, month 2\n", + "Processing year 2061, month 3\n", + "Processing year 2061, month 4\n", + "Processing year 2061, month 5\n", + "Processing year 2061, month 6\n", + "Processing year 2061, month 7\n", + "Processing year 2061, month 8\n", + "Processing year 2061, month 9\n", + "Processing year 2061, month 10\n", + "Processing year 2061, month 11\n", + "Processing year 2061, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2061, month 1\n", + "Processing year 2061, month 2\n", + "Processing year 2061, month 3\n", + "Processing year 2061, month 4\n", + "Processing year 2061, month 5\n", + "Processing year 2061, month 6\n", + "Processing year 2061, month 7\n", + "Processing year 2061, month 8\n", + "Processing year 2061, month 9\n", + "Processing year 2061, month 10\n", + "Processing year 2061, month 11\n", + "Processing year 2061, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2061, month 1\n", + "Processing year 2061, month 2\n", + "Processing year 2061, month 3\n", + "Processing year 2061, month 4\n", + "Processing year 2061, month 5\n", + "Processing year 2061, month 6\n", + "Processing year 2061, month 7\n", + "Processing year 2061, month 8\n", + "Processing year 2061, month 9\n", + "Processing year 2061, month 10\n", + "Processing year 2061, month 11\n", + "Processing year 2061, month 12\n", + "Processing file: CIL_subset_ssp245_2062.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2062, month 1\n", + "Processing year 2062, month 2\n", + "Processing year 2062, month 3\n", + "Processing year 2062, month 4\n", + "Processing year 2062, month 5\n", + "Processing year 2062, month 6\n", + "Processing year 2062, month 7\n", + "Processing year 2062, month 8\n", + "Processing year 2062, month 9\n", + "Processing year 2062, month 10\n", + "Processing year 2062, month 11\n", + "Processing year 2062, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2062, month 1\n", + "Processing year 2062, month 2\n", + "Processing year 2062, month 3\n", + "Processing year 2062, month 4\n", + "Processing year 2062, month 5\n", + "Processing year 2062, month 6\n", + "Processing year 2062, month 7\n", + "Processing year 2062, month 8\n", + "Processing year 2062, month 9\n", + "Processing year 2062, month 10\n", + "Processing year 2062, month 11\n", + "Processing year 2062, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2062, month 1\n", + "Processing year 2062, month 2\n", + "Processing year 2062, month 3\n", + "Processing year 2062, month 4\n", + "Processing year 2062, month 5\n", + "Processing year 2062, month 6\n", + "Processing year 2062, month 7\n", + "Processing year 2062, month 8\n", + "Processing year 2062, month 9\n", + "Processing year 2062, month 10\n", + "Processing year 2062, month 11\n", + "Processing year 2062, month 12\n", + "Processing file: CIL_subset_ssp245_2063.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2063, month 1\n", + "Processing year 2063, month 2\n", + "Processing year 2063, month 3\n", + "Processing year 2063, month 4\n", + "Processing year 2063, month 5\n", + "Processing year 2063, month 6\n", + "Processing year 2063, month 7\n", + "Processing year 2063, month 8\n", + "Processing year 2063, month 9\n", + "Processing year 2063, month 10\n", + "Processing year 2063, month 11\n", + "Processing year 2063, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2063, month 1\n", + "Processing year 2063, month 2\n", + "Processing year 2063, month 3\n", + "Processing year 2063, month 4\n", + "Processing year 2063, month 5\n", + "Processing year 2063, month 6\n", + "Processing year 2063, month 7\n", + "Processing year 2063, month 8\n", + "Processing year 2063, month 9\n", + "Processing year 2063, month 10\n", + "Processing year 2063, month 11\n", + "Processing year 2063, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2063, month 1\n", + "Processing year 2063, month 2\n", + "Processing year 2063, month 3\n", + "Processing year 2063, month 4\n", + "Processing year 2063, month 5\n", + "Processing year 2063, month 6\n", + "Processing year 2063, month 7\n", + "Processing year 2063, month 8\n", + "Processing year 2063, month 9\n", + "Processing year 2063, month 10\n", + "Processing year 2063, month 11\n", + "Processing year 2063, month 12\n", + "Processing file: CIL_subset_ssp245_2064.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2064, month 1\n", + "Processing year 2064, month 2\n", + "Processing year 2064, month 3\n", + "Processing year 2064, month 4\n", + "Processing year 2064, month 5\n", + "Processing year 2064, month 6\n", + "Processing year 2064, month 7\n", + "Processing year 2064, month 8\n", + "Processing year 2064, month 9\n", + "Processing year 2064, month 10\n", + "Processing year 2064, month 11\n", + "Processing year 2064, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2064, month 1\n", + "Processing year 2064, month 2\n", + "Processing year 2064, month 3\n", + "Processing year 2064, month 4\n", + "Processing year 2064, month 5\n", + "Processing year 2064, month 6\n", + "Processing year 2064, month 7\n", + "Processing year 2064, month 8\n", + "Processing year 2064, month 9\n", + "Processing year 2064, month 10\n", + "Processing year 2064, month 11\n", + "Processing year 2064, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2064, month 1\n", + "Processing year 2064, month 2\n", + "Processing year 2064, month 3\n", + "Processing year 2064, month 4\n", + "Processing year 2064, month 5\n", + "Processing year 2064, month 6\n", + "Processing year 2064, month 7\n", + "Processing year 2064, month 8\n", + "Processing year 2064, month 9\n", + "Processing year 2064, month 10\n", + "Processing year 2064, month 11\n", + "Processing year 2064, month 12\n", + "Processing file: CIL_subset_ssp245_2065.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2065, month 1\n", + "Processing year 2065, month 2\n", + "Processing year 2065, month 3\n", + "Processing year 2065, month 4\n", + "Processing year 2065, month 5\n", + "Processing year 2065, month 6\n", + "Processing year 2065, month 7\n", + "Processing year 2065, month 8\n", + "Processing year 2065, month 9\n", + "Processing year 2065, month 10\n", + "Processing year 2065, month 11\n", + "Processing year 2065, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2065, month 1\n", + "Processing year 2065, month 2\n", + "Processing year 2065, month 3\n", + "Processing year 2065, month 4\n", + "Processing year 2065, month 5\n", + "Processing year 2065, month 6\n", + "Processing year 2065, month 7\n", + "Processing year 2065, month 8\n", + "Processing year 2065, month 9\n", + "Processing year 2065, month 10\n", + "Processing year 2065, month 11\n", + "Processing year 2065, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2065, month 1\n", + "Processing year 2065, month 2\n", + "Processing year 2065, month 3\n", + "Processing year 2065, month 4\n", + "Processing year 2065, month 5\n", + "Processing year 2065, month 6\n", + "Processing year 2065, month 7\n", + "Processing year 2065, month 8\n", + "Processing year 2065, month 9\n", + "Processing year 2065, month 10\n", + "Processing year 2065, month 11\n", + "Processing year 2065, month 12\n", + "Processing file: CIL_subset_ssp245_2066.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2066, month 1\n", + "Processing year 2066, month 2\n", + "Processing year 2066, month 3\n", + "Processing year 2066, month 4\n", + "Processing year 2066, month 5\n", + "Processing year 2066, month 6\n", + "Processing year 2066, month 7\n", + "Processing year 2066, month 8\n", + "Processing year 2066, month 9\n", + "Processing year 2066, month 10\n", + "Processing year 2066, month 11\n", + "Processing year 2066, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2066, month 1\n", + "Processing year 2066, month 2\n", + "Processing year 2066, month 3\n", + "Processing year 2066, month 4\n", + "Processing year 2066, month 5\n", + "Processing year 2066, month 6\n", + "Processing year 2066, month 7\n", + "Processing year 2066, month 8\n", + "Processing year 2066, month 9\n", + "Processing year 2066, month 10\n", + "Processing year 2066, month 11\n", + "Processing year 2066, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2066, month 1\n", + "Processing year 2066, month 2\n", + "Processing year 2066, month 3\n", + "Processing year 2066, month 4\n", + "Processing year 2066, month 5\n", + "Processing year 2066, month 6\n", + "Processing year 2066, month 7\n", + "Processing year 2066, month 8\n", + "Processing year 2066, month 9\n", + "Processing year 2066, month 10\n", + "Processing year 2066, month 11\n", + "Processing year 2066, month 12\n", + "Processing file: CIL_subset_ssp245_2067.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2067, month 1\n", + "Processing year 2067, month 2\n", + "Processing year 2067, month 3\n", + "Processing year 2067, month 4\n", + "Processing year 2067, month 5\n", + "Processing year 2067, month 6\n", + "Processing year 2067, month 7\n", + "Processing year 2067, month 8\n", + "Processing year 2067, month 9\n", + "Processing year 2067, month 10\n", + "Processing year 2067, month 11\n", + "Processing year 2067, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2067, month 1\n", + "Processing year 2067, month 2\n", + "Processing year 2067, month 3\n", + "Processing year 2067, month 4\n", + "Processing year 2067, month 5\n", + "Processing year 2067, month 6\n", + "Processing year 2067, month 7\n", + "Processing year 2067, month 8\n", + "Processing year 2067, month 9\n", + "Processing year 2067, month 10\n", + "Processing year 2067, month 11\n", + "Processing year 2067, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2067, month 1\n", + "Processing year 2067, month 2\n", + "Processing year 2067, month 3\n", + "Processing year 2067, month 4\n", + "Processing year 2067, month 5\n", + "Processing year 2067, month 6\n", + "Processing year 2067, month 7\n", + "Processing year 2067, month 8\n", + "Processing year 2067, month 9\n", + "Processing year 2067, month 10\n", + "Processing year 2067, month 11\n", + "Processing year 2067, month 12\n", + "Processing file: CIL_subset_ssp245_2068.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2068, month 1\n", + "Processing year 2068, month 2\n", + "Processing year 2068, month 3\n", + "Processing year 2068, month 4\n", + "Processing year 2068, month 5\n", + "Processing year 2068, month 6\n", + "Processing year 2068, month 7\n", + "Processing year 2068, month 8\n", + "Processing year 2068, month 9\n", + "Processing year 2068, month 10\n", + "Processing year 2068, month 11\n", + "Processing year 2068, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2068, month 1\n", + "Processing year 2068, month 2\n", + "Processing year 2068, month 3\n", + "Processing year 2068, month 4\n", + "Processing year 2068, month 5\n", + "Processing year 2068, month 6\n", + "Processing year 2068, month 7\n", + "Processing year 2068, month 8\n", + "Processing year 2068, month 9\n", + "Processing year 2068, month 10\n", + "Processing year 2068, month 11\n", + "Processing year 2068, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2068, month 1\n", + "Processing year 2068, month 2\n", + "Processing year 2068, month 3\n", + "Processing year 2068, month 4\n", + "Processing year 2068, month 5\n", + "Processing year 2068, month 6\n", + "Processing year 2068, month 7\n", + "Processing year 2068, month 8\n", + "Processing year 2068, month 9\n", + "Processing year 2068, month 10\n", + "Processing year 2068, month 11\n", + "Processing year 2068, month 12\n", + "Processing file: CIL_subset_ssp245_2069.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2069, month 1\n", + "Processing year 2069, month 2\n", + "Processing year 2069, month 3\n", + "Processing year 2069, month 4\n", + "Processing year 2069, month 5\n", + "Processing year 2069, month 6\n", + "Processing year 2069, month 7\n", + "Processing year 2069, month 8\n", + "Processing year 2069, month 9\n", + "Processing year 2069, month 10\n", + "Processing year 2069, month 11\n", + "Processing year 2069, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2069, month 1\n", + "Processing year 2069, month 2\n", + "Processing year 2069, month 3\n", + "Processing year 2069, month 4\n", + "Processing year 2069, month 5\n", + "Processing year 2069, month 6\n", + "Processing year 2069, month 7\n", + "Processing year 2069, month 8\n", + "Processing year 2069, month 9\n", + "Processing year 2069, month 10\n", + "Processing year 2069, month 11\n", + "Processing year 2069, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2069, month 1\n", + "Processing year 2069, month 2\n", + "Processing year 2069, month 3\n", + "Processing year 2069, month 4\n", + "Processing year 2069, month 5\n", + "Processing year 2069, month 6\n", + "Processing year 2069, month 7\n", + "Processing year 2069, month 8\n", + "Processing year 2069, month 9\n", + "Processing year 2069, month 10\n", + "Processing year 2069, month 11\n", + "Processing year 2069, month 12\n", + "Processing file: CIL_subset_ssp245_2070.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2070, month 1\n", + "Processing year 2070, month 2\n", + "Processing year 2070, month 3\n", + "Processing year 2070, month 4\n", + "Processing year 2070, month 5\n", + "Processing year 2070, month 6\n", + "Processing year 2070, month 7\n", + "Processing year 2070, month 8\n", + "Processing year 2070, month 9\n", + "Processing year 2070, month 10\n", + "Processing year 2070, month 11\n", + "Processing year 2070, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2070, month 1\n", + "Processing year 2070, month 2\n", + "Processing year 2070, month 3\n", + "Processing year 2070, month 4\n", + "Processing year 2070, month 5\n", + "Processing year 2070, month 6\n", + "Processing year 2070, month 7\n", + "Processing year 2070, month 8\n", + "Processing year 2070, month 9\n", + "Processing year 2070, month 10\n", + "Processing year 2070, month 11\n", + "Processing year 2070, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2070, month 1\n", + "Processing year 2070, month 2\n", + "Processing year 2070, month 3\n", + "Processing year 2070, month 4\n", + "Processing year 2070, month 5\n", + "Processing year 2070, month 6\n", + "Processing year 2070, month 7\n", + "Processing year 2070, month 8\n", + "Processing year 2070, month 9\n", + "Processing year 2070, month 10\n", + "Processing year 2070, month 11\n", + "Processing year 2070, month 12\n", + "Saved monthly data for lowest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp245/lowest_monthly_prediction_weather_by_facility.csv\n", + "Saved window data for lowest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp245/lowest_window_prediction_weather_by_facility.csv\n", + "Saved monthly data for median model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp245/median_monthly_prediction_weather_by_facility.csv\n", + "Saved window data for median model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp245/median_window_prediction_weather_by_facility.csv\n", + "Saved monthly data for highest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp245/highest_monthly_prediction_weather_by_facility.csv\n", + "Saved window data for highest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp245/highest_window_prediction_weather_by_facility.csv\n", + "Processing scenario: ssp585\n", + "Models of interest ['HadGEM3-GC31-LL', 'GFDL-CM4', 'INM-CM5-0']\n", + "Processing file: CIL_subset_ssp585_2024.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2024, month 1\n", + "Processing year 2024, month 2\n", + "Processing year 2024, month 3\n", + "Processing year 2024, month 4\n", + "Processing year 2024, month 5\n", + "Processing year 2024, month 6\n", + "Processing year 2024, month 7\n", + "Processing year 2024, month 8\n", + "Processing year 2024, month 9\n", + "Processing year 2024, month 10\n", + "Processing year 2024, month 11\n", + "Processing year 2024, month 12\n" ] - } - ], - "execution_count": null + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing model: GFDL-CM4\n", + "Processing year 2024, month 1\n", + "Processing year 2024, month 2\n", + "Processing year 2024, month 3\n", + "Processing year 2024, month 4\n", + "Processing year 2024, month 5\n", + "Processing year 2024, month 6\n", + "Processing year 2024, month 7\n", + "Processing year 2024, month 8\n", + "Processing year 2024, month 9\n", + "Processing year 2024, month 10\n", + "Processing year 2024, month 11\n", + "Processing year 2024, month 12\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing model: INM-CM5-0\n", + "Processing year 2024, month 1\n", + "Processing year 2024, month 2\n", + "Processing year 2024, month 3\n", + "Processing year 2024, month 4\n", + "Processing year 2024, month 5\n", + "Processing year 2024, month 6\n", + "Processing year 2024, month 7\n", + "Processing year 2024, month 8\n", + "Processing year 2024, month 9\n", + "Processing year 2024, month 10\n", + "Processing year 2024, month 11\n", + "Processing year 2024, month 12\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing file: CIL_subset_ssp585_2025.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2025, month 1\n", + "Processing year 2025, month 2\n", + "Processing year 2025, month 3\n", + "Processing year 2025, month 4\n", + "Processing year 2025, month 5\n", + "Processing year 2025, month 6\n", + "Processing year 2025, month 7\n", + "Processing year 2025, month 8\n", + "Processing year 2025, month 9\n", + "Processing year 2025, month 10\n", + "Processing year 2025, month 11\n", + "Processing year 2025, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2025, month 1\n", + "Processing year 2025, month 2\n", + "Processing year 2025, month 3\n", + "Processing year 2025, month 4\n", + "Processing year 2025, month 5\n", + "Processing year 2025, month 6\n", + "Processing year 2025, month 7\n", + "Processing year 2025, month 8\n", + "Processing year 2025, month 9\n", + "Processing year 2025, month 10\n", + "Processing year 2025, month 11\n", + "Processing year 2025, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2025, month 1\n", + "Processing year 2025, month 2\n", + "Processing year 2025, month 3\n", + "Processing year 2025, month 4\n", + "Processing year 2025, month 5\n", + "Processing year 2025, month 6\n", + "Processing year 2025, month 7\n", + "Processing year 2025, month 8\n", + "Processing year 2025, month 9\n", + "Processing year 2025, month 10\n", + "Processing year 2025, month 11\n", + "Processing year 2025, month 12\n", + "Processing file: CIL_subset_ssp585_2026.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2026, month 1\n", + "Processing year 2026, month 2\n", + "Processing year 2026, month 3\n", + "Processing year 2026, month 4\n", + "Processing year 2026, month 5\n", + "Processing year 2026, month 6\n", + "Processing year 2026, month 7\n", + "Processing year 2026, month 8\n", + "Processing year 2026, month 9\n", + "Processing year 2026, month 10\n", + "Processing year 2026, month 11\n", + "Processing year 2026, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2026, month 1\n", + "Processing year 2026, month 2\n", + "Processing year 2026, month 3\n", + "Processing year 2026, month 4\n", + "Processing year 2026, month 5\n", + "Processing year 2026, month 6\n", + "Processing year 2026, month 7\n", + "Processing year 2026, month 8\n", + "Processing year 2026, month 9\n", + "Processing year 2026, month 10\n", + "Processing year 2026, month 11\n", + "Processing year 2026, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2026, month 1\n", + "Processing year 2026, month 2\n", + "Processing year 2026, month 3\n", + "Processing year 2026, month 4\n", + "Processing year 2026, month 5\n", + "Processing year 2026, month 6\n", + "Processing year 2026, month 7\n", + "Processing year 2026, month 8\n", + "Processing year 2026, month 9\n", + "Processing year 2026, month 10\n", + "Processing year 2026, month 11\n", + "Processing year 2026, month 12\n", + "Processing file: CIL_subset_ssp585_2027.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2027, month 1\n", + "Processing year 2027, month 2\n", + "Processing year 2027, month 3\n", + "Processing year 2027, month 4\n", + "Processing year 2027, month 5\n", + "Processing year 2027, month 6\n", + "Processing year 2027, month 7\n", + "Processing year 2027, month 8\n", + "Processing year 2027, month 9\n", + "Processing year 2027, month 10\n", + "Processing year 2027, month 11\n", + "Processing year 2027, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2027, month 1\n", + "Processing year 2027, month 2\n", + "Processing year 2027, month 3\n", + "Processing year 2027, month 4\n", + "Processing year 2027, month 5\n", + "Processing year 2027, month 6\n", + "Processing year 2027, month 7\n", + "Processing year 2027, month 8\n", + "Processing year 2027, month 9\n", + "Processing year 2027, month 10\n", + "Processing year 2027, month 11\n", + "Processing year 2027, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2027, month 1\n", + "Processing year 2027, month 2\n", + "Processing year 2027, month 3\n", + "Processing year 2027, month 4\n", + "Processing year 2027, month 5\n", + "Processing year 2027, month 6\n", + "Processing year 2027, month 7\n", + "Processing year 2027, month 8\n", + "Processing year 2027, month 9\n", + "Processing year 2027, month 10\n", + "Processing year 2027, month 11\n", + "Processing year 2027, month 12\n", + "Processing file: CIL_subset_ssp585_2028.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2028, month 1\n", + "Processing year 2028, month 2\n", + "Processing year 2028, month 3\n", + "Processing year 2028, month 4\n", + "Processing year 2028, month 5\n", + "Processing year 2028, month 6\n", + "Processing year 2028, month 7\n", + "Processing year 2028, month 8\n", + "Processing year 2028, month 9\n", + "Processing year 2028, month 10\n", + "Processing year 2028, month 11\n", + "Processing year 2028, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2028, month 1\n", + "Processing year 2028, month 2\n", + "Processing year 2028, month 3\n", + "Processing year 2028, month 4\n", + "Processing year 2028, month 5\n", + "Processing year 2028, month 6\n", + "Processing year 2028, month 7\n", + "Processing year 2028, month 8\n", + "Processing year 2028, month 9\n", + "Processing year 2028, month 10\n", + "Processing year 2028, month 11\n", + "Processing year 2028, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2028, month 1\n", + "Processing year 2028, month 2\n", + "Processing year 2028, month 3\n", + "Processing year 2028, month 4\n", + "Processing year 2028, month 5\n", + "Processing year 2028, month 6\n", + "Processing year 2028, month 7\n", + "Processing year 2028, month 8\n", + "Processing year 2028, month 9\n", + "Processing year 2028, month 10\n", + "Processing year 2028, month 11\n", + "Processing year 2028, month 12\n", + "Processing file: CIL_subset_ssp585_2029.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2029, month 1\n", + "Processing year 2029, month 2\n", + "Processing year 2029, month 3\n", + "Processing year 2029, month 4\n", + "Processing year 2029, month 5\n", + "Processing year 2029, month 6\n", + "Processing year 2029, month 7\n", + "Processing year 2029, month 8\n", + "Processing year 2029, month 9\n", + "Processing year 2029, month 10\n", + "Processing year 2029, month 11\n", + "Processing year 2029, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2029, month 1\n", + "Processing year 2029, month 2\n", + "Processing year 2029, month 3\n", + "Processing year 2029, month 4\n", + "Processing year 2029, month 5\n", + "Processing year 2029, month 6\n", + "Processing year 2029, month 7\n", + "Processing year 2029, month 8\n", + "Processing year 2029, month 9\n", + "Processing year 2029, month 10\n", + "Processing year 2029, month 11\n", + "Processing year 2029, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2029, month 1\n", + "Processing year 2029, month 2\n", + "Processing year 2029, month 3\n", + "Processing year 2029, month 4\n", + "Processing year 2029, month 5\n", + "Processing year 2029, month 6\n", + "Processing year 2029, month 7\n", + "Processing year 2029, month 8\n", + "Processing year 2029, month 9\n", + "Processing year 2029, month 10\n", + "Processing year 2029, month 11\n", + "Processing year 2029, month 12\n", + "Processing file: CIL_subset_ssp585_2030.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2030, month 1\n", + "Processing year 2030, month 2\n", + "Processing year 2030, month 3\n", + "Processing year 2030, month 4\n", + "Processing year 2030, month 5\n", + "Processing year 2030, month 6\n", + "Processing year 2030, month 7\n", + "Processing year 2030, month 8\n", + "Processing year 2030, month 9\n", + "Processing year 2030, month 10\n", + "Processing year 2030, month 11\n", + "Processing year 2030, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2030, month 1\n", + "Processing year 2030, month 2\n", + "Processing year 2030, month 3\n", + "Processing year 2030, month 4\n", + "Processing year 2030, month 5\n", + "Processing year 2030, month 6\n", + "Processing year 2030, month 7\n", + "Processing year 2030, month 8\n", + "Processing year 2030, month 9\n", + "Processing year 2030, month 10\n", + "Processing year 2030, month 11\n", + "Processing year 2030, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2030, month 1\n", + "Processing year 2030, month 2\n", + "Processing year 2030, month 3\n", + "Processing year 2030, month 4\n", + "Processing year 2030, month 5\n", + "Processing year 2030, month 6\n", + "Processing year 2030, month 7\n", + "Processing year 2030, month 8\n", + "Processing year 2030, month 9\n", + "Processing year 2030, month 10\n", + "Processing year 2030, month 11\n", + "Processing year 2030, month 12\n", + "Processing file: CIL_subset_ssp585_2031.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2031, month 1\n", + "Processing year 2031, month 2\n", + "Processing year 2031, month 3\n", + "Processing year 2031, month 4\n", + "Processing year 2031, month 5\n", + "Processing year 2031, month 6\n", + "Processing year 2031, month 7\n", + "Processing year 2031, month 8\n", + "Processing year 2031, month 9\n", + "Processing year 2031, month 10\n", + "Processing year 2031, month 11\n", + "Processing year 2031, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2031, month 1\n", + "Processing year 2031, month 2\n", + "Processing year 2031, month 3\n", + "Processing year 2031, month 4\n", + "Processing year 2031, month 5\n", + "Processing year 2031, month 6\n", + "Processing year 2031, month 7\n", + "Processing year 2031, month 8\n", + "Processing year 2031, month 9\n", + "Processing year 2031, month 10\n", + "Processing year 2031, month 11\n", + "Processing year 2031, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2031, month 1\n", + "Processing year 2031, month 2\n", + "Processing year 2031, month 3\n", + "Processing year 2031, month 4\n", + "Processing year 2031, month 5\n", + "Processing year 2031, month 6\n", + "Processing year 2031, month 7\n", + "Processing year 2031, month 8\n", + "Processing year 2031, month 9\n", + "Processing year 2031, month 10\n", + "Processing year 2031, month 11\n", + "Processing year 2031, month 12\n", + "Processing file: CIL_subset_ssp585_2032.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2032, month 1\n", + "Processing year 2032, month 2\n", + "Processing year 2032, month 3\n", + "Processing year 2032, month 4\n", + "Processing year 2032, month 5\n", + "Processing year 2032, month 6\n", + "Processing year 2032, month 7\n", + "Processing year 2032, month 8\n", + "Processing year 2032, month 9\n", + "Processing year 2032, month 10\n", + "Processing year 2032, month 11\n", + "Processing year 2032, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2032, month 1\n", + "Processing year 2032, month 2\n", + "Processing year 2032, month 3\n", + "Processing year 2032, month 4\n", + "Processing year 2032, month 5\n", + "Processing year 2032, month 6\n", + "Processing year 2032, month 7\n", + "Processing year 2032, month 8\n", + "Processing year 2032, month 9\n", + "Processing year 2032, month 10\n", + "Processing year 2032, month 11\n", + "Processing year 2032, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2032, month 1\n", + "Processing year 2032, month 2\n", + "Processing year 2032, month 3\n", + "Processing year 2032, month 4\n", + "Processing year 2032, month 5\n", + "Processing year 2032, month 6\n", + "Processing year 2032, month 7\n", + "Processing year 2032, month 8\n", + "Processing year 2032, month 9\n", + "Processing year 2032, month 10\n", + "Processing year 2032, month 11\n", + "Processing year 2032, month 12\n", + "Processing file: CIL_subset_ssp585_2033.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2033, month 1\n", + "Processing year 2033, month 2\n", + "Processing year 2033, month 3\n", + "Processing year 2033, month 4\n", + "Processing year 2033, month 5\n", + "Processing year 2033, month 6\n", + "Processing year 2033, month 7\n", + "Processing year 2033, month 8\n", + "Processing year 2033, month 9\n", + "Processing year 2033, month 10\n", + "Processing year 2033, month 11\n", + "Processing year 2033, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2033, month 1\n", + "Processing year 2033, month 2\n", + "Processing year 2033, month 3\n", + "Processing year 2033, month 4\n", + "Processing year 2033, month 5\n", + "Processing year 2033, month 6\n", + "Processing year 2033, month 7\n", + "Processing year 2033, month 8\n", + "Processing year 2033, month 9\n", + "Processing year 2033, month 10\n", + "Processing year 2033, month 11\n", + "Processing year 2033, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2033, month 1\n", + "Processing year 2033, month 2\n", + "Processing year 2033, month 3\n", + "Processing year 2033, month 4\n", + "Processing year 2033, month 5\n", + "Processing year 2033, month 6\n", + "Processing year 2033, month 7\n", + "Processing year 2033, month 8\n", + "Processing year 2033, month 9\n", + "Processing year 2033, month 10\n", + "Processing year 2033, month 11\n", + "Processing year 2033, month 12\n", + "Processing file: CIL_subset_ssp585_2034.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2034, month 1\n", + "Processing year 2034, month 2\n", + "Processing year 2034, month 3\n", + "Processing year 2034, month 4\n", + "Processing year 2034, month 5\n", + "Processing year 2034, month 6\n", + "Processing year 2034, month 7\n", + "Processing year 2034, month 8\n", + "Processing year 2034, month 9\n", + "Processing year 2034, month 10\n", + "Processing year 2034, month 11\n", + "Processing year 2034, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2034, month 1\n", + "Processing year 2034, month 2\n", + "Processing year 2034, month 3\n", + "Processing year 2034, month 4\n", + "Processing year 2034, month 5\n", + "Processing year 2034, month 6\n", + "Processing year 2034, month 7\n", + "Processing year 2034, month 8\n", + "Processing year 2034, month 9\n", + "Processing year 2034, month 10\n", + "Processing year 2034, month 11\n", + "Processing year 2034, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2034, month 1\n", + "Processing year 2034, month 2\n", + "Processing year 2034, month 3\n", + "Processing year 2034, month 4\n", + "Processing year 2034, month 5\n", + "Processing year 2034, month 6\n", + "Processing year 2034, month 7\n", + "Processing year 2034, month 8\n", + "Processing year 2034, month 9\n", + "Processing year 2034, month 10\n", + "Processing year 2034, month 11\n", + "Processing year 2034, month 12\n", + "Processing file: CIL_subset_ssp585_2035.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2035, month 1\n", + "Processing year 2035, month 2\n", + "Processing year 2035, month 3\n", + "Processing year 2035, month 4\n", + "Processing year 2035, month 5\n", + "Processing year 2035, month 6\n", + "Processing year 2035, month 7\n", + "Processing year 2035, month 8\n", + "Processing year 2035, month 9\n", + "Processing year 2035, month 10\n", + "Processing year 2035, month 11\n", + "Processing year 2035, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2035, month 1\n", + "Processing year 2035, month 2\n", + "Processing year 2035, month 3\n", + "Processing year 2035, month 4\n", + "Processing year 2035, month 5\n", + "Processing year 2035, month 6\n", + "Processing year 2035, month 7\n", + "Processing year 2035, month 8\n", + "Processing year 2035, month 9\n", + "Processing year 2035, month 10\n", + "Processing year 2035, month 11\n", + "Processing year 2035, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2035, month 1\n", + "Processing year 2035, month 2\n", + "Processing year 2035, month 3\n", + "Processing year 2035, month 4\n", + "Processing year 2035, month 5\n", + "Processing year 2035, month 6\n", + "Processing year 2035, month 7\n", + "Processing year 2035, month 8\n", + "Processing year 2035, month 9\n", + "Processing year 2035, month 10\n", + "Processing year 2035, month 11\n", + "Processing year 2035, month 12\n", + "Processing file: CIL_subset_ssp585_2036.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2036, month 1\n", + "Processing year 2036, month 2\n", + "Processing year 2036, month 3\n", + "Processing year 2036, month 4\n", + "Processing year 2036, month 5\n", + "Processing year 2036, month 6\n", + "Processing year 2036, month 7\n", + "Processing year 2036, month 8\n", + "Processing year 2036, month 9\n", + "Processing year 2036, month 10\n", + "Processing year 2036, month 11\n", + "Processing year 2036, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2036, month 1\n", + "Processing year 2036, month 2\n", + "Processing year 2036, month 3\n", + "Processing year 2036, month 4\n", + "Processing year 2036, month 5\n", + "Processing year 2036, month 6\n", + "Processing year 2036, month 7\n", + "Processing year 2036, month 8\n", + "Processing year 2036, month 9\n", + "Processing year 2036, month 10\n", + "Processing year 2036, month 11\n", + "Processing year 2036, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2036, month 1\n", + "Processing year 2036, month 2\n", + "Processing year 2036, month 3\n", + "Processing year 2036, month 4\n", + "Processing year 2036, month 5\n", + "Processing year 2036, month 6\n", + "Processing year 2036, month 7\n", + "Processing year 2036, month 8\n", + "Processing year 2036, month 9\n", + "Processing year 2036, month 10\n", + "Processing year 2036, month 11\n", + "Processing year 2036, month 12\n", + "Processing file: CIL_subset_ssp585_2037.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2037, month 1\n", + "Processing year 2037, month 2\n", + "Processing year 2037, month 3\n", + "Processing year 2037, month 4\n", + "Processing year 2037, month 5\n", + "Processing year 2037, month 6\n", + "Processing year 2037, month 7\n", + "Processing year 2037, month 8\n", + "Processing year 2037, month 9\n", + "Processing year 2037, month 10\n", + "Processing year 2037, month 11\n", + "Processing year 2037, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2037, month 1\n", + "Processing year 2037, month 2\n", + "Processing year 2037, month 3\n", + "Processing year 2037, month 4\n", + "Processing year 2037, month 5\n", + "Processing year 2037, month 6\n", + "Processing year 2037, month 7\n", + "Processing year 2037, month 8\n", + "Processing year 2037, month 9\n", + "Processing year 2037, month 10\n", + "Processing year 2037, month 11\n", + "Processing year 2037, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2037, month 1\n", + "Processing year 2037, month 2\n", + "Processing year 2037, month 3\n", + "Processing year 2037, month 4\n", + "Processing year 2037, month 5\n", + "Processing year 2037, month 6\n", + "Processing year 2037, month 7\n", + "Processing year 2037, month 8\n", + "Processing year 2037, month 9\n", + "Processing year 2037, month 10\n", + "Processing year 2037, month 11\n", + "Processing year 2037, month 12\n", + "Processing file: CIL_subset_ssp585_2038.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2038, month 1\n", + "Processing year 2038, month 2\n", + "Processing year 2038, month 3\n", + "Processing year 2038, month 4\n", + "Processing year 2038, month 5\n", + "Processing year 2038, month 6\n", + "Processing year 2038, month 7\n", + "Processing year 2038, month 8\n", + "Processing year 2038, month 9\n", + "Processing year 2038, month 10\n", + "Processing year 2038, month 11\n", + "Processing year 2038, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2038, month 1\n", + "Processing year 2038, month 2\n", + "Processing year 2038, month 3\n", + "Processing year 2038, month 4\n", + "Processing year 2038, month 5\n", + "Processing year 2038, month 6\n", + "Processing year 2038, month 7\n", + "Processing year 2038, month 8\n", + "Processing year 2038, month 9\n", + "Processing year 2038, month 10\n", + "Processing year 2038, month 11\n", + "Processing year 2038, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2038, month 1\n", + "Processing year 2038, month 2\n", + "Processing year 2038, month 3\n", + "Processing year 2038, month 4\n", + "Processing year 2038, month 5\n", + "Processing year 2038, month 6\n", + "Processing year 2038, month 7\n", + "Processing year 2038, month 8\n", + "Processing year 2038, month 9\n", + "Processing year 2038, month 10\n", + "Processing year 2038, month 11\n", + "Processing year 2038, month 12\n", + "Processing file: CIL_subset_ssp585_2039.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2039, month 1\n", + "Processing year 2039, month 2\n", + "Processing year 2039, month 3\n", + "Processing year 2039, month 4\n", + "Processing year 2039, month 5\n", + "Processing year 2039, month 6\n", + "Processing year 2039, month 7\n", + "Processing year 2039, month 8\n", + "Processing year 2039, month 9\n", + "Processing year 2039, month 10\n", + "Processing year 2039, month 11\n", + "Processing year 2039, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2039, month 1\n", + "Processing year 2039, month 2\n", + "Processing year 2039, month 3\n", + "Processing year 2039, month 4\n", + "Processing year 2039, month 5\n", + "Processing year 2039, month 6\n", + "Processing year 2039, month 7\n", + "Processing year 2039, month 8\n", + "Processing year 2039, month 9\n", + "Processing year 2039, month 10\n", + "Processing year 2039, month 11\n", + "Processing year 2039, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2039, month 1\n", + "Processing year 2039, month 2\n", + "Processing year 2039, month 3\n", + "Processing year 2039, month 4\n", + "Processing year 2039, month 5\n", + "Processing year 2039, month 6\n", + "Processing year 2039, month 7\n", + "Processing year 2039, month 8\n", + "Processing year 2039, month 9\n", + "Processing year 2039, month 10\n", + "Processing year 2039, month 11\n", + "Processing year 2039, month 12\n", + "Processing file: CIL_subset_ssp585_2040.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2040, month 1\n", + "Processing year 2040, month 2\n", + "Processing year 2040, month 3\n", + "Processing year 2040, month 4\n", + "Processing year 2040, month 5\n", + "Processing year 2040, month 6\n", + "Processing year 2040, month 7\n", + "Processing year 2040, month 8\n", + "Processing year 2040, month 9\n", + "Processing year 2040, month 10\n", + "Processing year 2040, month 11\n", + "Processing year 2040, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2040, month 1\n", + "Processing year 2040, month 2\n", + "Processing year 2040, month 3\n", + "Processing year 2040, month 4\n", + "Processing year 2040, month 5\n", + "Processing year 2040, month 6\n", + "Processing year 2040, month 7\n", + "Processing year 2040, month 8\n", + "Processing year 2040, month 9\n", + "Processing year 2040, month 10\n", + "Processing year 2040, month 11\n", + "Processing year 2040, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2040, month 1\n", + "Processing year 2040, month 2\n", + "Processing year 2040, month 3\n", + "Processing year 2040, month 4\n", + "Processing year 2040, month 5\n", + "Processing year 2040, month 6\n", + "Processing year 2040, month 7\n", + "Processing year 2040, month 8\n", + "Processing year 2040, month 9\n", + "Processing year 2040, month 10\n", + "Processing year 2040, month 11\n", + "Processing year 2040, month 12\n", + "Processing file: CIL_subset_ssp585_2041.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2041, month 1\n", + "Processing year 2041, month 2\n", + "Processing year 2041, month 3\n", + "Processing year 2041, month 4\n", + "Processing year 2041, month 5\n", + "Processing year 2041, month 6\n", + "Processing year 2041, month 7\n", + "Processing year 2041, month 8\n", + "Processing year 2041, month 9\n", + "Processing year 2041, month 10\n", + "Processing year 2041, month 11\n", + "Processing year 2041, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2041, month 1\n", + "Processing year 2041, month 2\n", + "Processing year 2041, month 3\n", + "Processing year 2041, month 4\n", + "Processing year 2041, month 5\n", + "Processing year 2041, month 6\n", + "Processing year 2041, month 7\n", + "Processing year 2041, month 8\n", + "Processing year 2041, month 9\n", + "Processing year 2041, month 10\n", + "Processing year 2041, month 11\n", + "Processing year 2041, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2041, month 1\n", + "Processing year 2041, month 2\n", + "Processing year 2041, month 3\n", + "Processing year 2041, month 4\n", + "Processing year 2041, month 5\n", + "Processing year 2041, month 6\n", + "Processing year 2041, month 7\n", + "Processing year 2041, month 8\n", + "Processing year 2041, month 9\n", + "Processing year 2041, month 10\n", + "Processing year 2041, month 11\n", + "Processing year 2041, month 12\n", + "Processing file: CIL_subset_ssp585_2042.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2042, month 1\n", + "Processing year 2042, month 2\n", + "Processing year 2042, month 3\n", + "Processing year 2042, month 4\n", + "Processing year 2042, month 5\n", + "Processing year 2042, month 6\n", + "Processing year 2042, month 7\n", + "Processing year 2042, month 8\n", + "Processing year 2042, month 9\n", + "Processing year 2042, month 10\n", + "Processing year 2042, month 11\n", + "Processing year 2042, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2042, month 1\n", + "Processing year 2042, month 2\n", + "Processing year 2042, month 3\n", + "Processing year 2042, month 4\n", + "Processing year 2042, month 5\n", + "Processing year 2042, month 6\n", + "Processing year 2042, month 7\n", + "Processing year 2042, month 8\n", + "Processing year 2042, month 9\n", + "Processing year 2042, month 10\n", + "Processing year 2042, month 11\n", + "Processing year 2042, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2042, month 1\n", + "Processing year 2042, month 2\n", + "Processing year 2042, month 3\n", + "Processing year 2042, month 4\n", + "Processing year 2042, month 5\n", + "Processing year 2042, month 6\n", + "Processing year 2042, month 7\n", + "Processing year 2042, month 8\n", + "Processing year 2042, month 9\n", + "Processing year 2042, month 10\n", + "Processing year 2042, month 11\n", + "Processing year 2042, month 12\n", + "Processing file: CIL_subset_ssp585_2043.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2043, month 1\n", + "Processing year 2043, month 2\n", + "Processing year 2043, month 3\n", + "Processing year 2043, month 4\n", + "Processing year 2043, month 5\n", + "Processing year 2043, month 6\n", + "Processing year 2043, month 7\n", + "Processing year 2043, month 8\n", + "Processing year 2043, month 9\n", + "Processing year 2043, month 10\n", + "Processing year 2043, month 11\n", + "Processing year 2043, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2043, month 1\n", + "Processing year 2043, month 2\n", + "Processing year 2043, month 3\n", + "Processing year 2043, month 4\n", + "Processing year 2043, month 5\n", + "Processing year 2043, month 6\n", + "Processing year 2043, month 7\n", + "Processing year 2043, month 8\n", + "Processing year 2043, month 9\n", + "Processing year 2043, month 10\n", + "Processing year 2043, month 11\n", + "Processing year 2043, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2043, month 1\n", + "Processing year 2043, month 2\n", + "Processing year 2043, month 3\n", + "Processing year 2043, month 4\n", + "Processing year 2043, month 5\n", + "Processing year 2043, month 6\n", + "Processing year 2043, month 7\n", + "Processing year 2043, month 8\n", + "Processing year 2043, month 9\n", + "Processing year 2043, month 10\n", + "Processing year 2043, month 11\n", + "Processing year 2043, month 12\n", + "Processing file: CIL_subset_ssp585_2044.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2044, month 1\n", + "Processing year 2044, month 2\n", + "Processing year 2044, month 3\n", + "Processing year 2044, month 4\n", + "Processing year 2044, month 5\n", + "Processing year 2044, month 6\n", + "Processing year 2044, month 7\n", + "Processing year 2044, month 8\n", + "Processing year 2044, month 9\n", + "Processing year 2044, month 10\n", + "Processing year 2044, month 11\n", + "Processing year 2044, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2044, month 1\n", + "Processing year 2044, month 2\n", + "Processing year 2044, month 3\n", + "Processing year 2044, month 4\n", + "Processing year 2044, month 5\n", + "Processing year 2044, month 6\n", + "Processing year 2044, month 7\n", + "Processing year 2044, month 8\n", + "Processing year 2044, month 9\n", + "Processing year 2044, month 10\n", + "Processing year 2044, month 11\n", + "Processing year 2044, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2044, month 1\n", + "Processing year 2044, month 2\n", + "Processing year 2044, month 3\n", + "Processing year 2044, month 4\n", + "Processing year 2044, month 5\n", + "Processing year 2044, month 6\n", + "Processing year 2044, month 7\n", + "Processing year 2044, month 8\n", + "Processing year 2044, month 9\n", + "Processing year 2044, month 10\n", + "Processing year 2044, month 11\n", + "Processing year 2044, month 12\n", + "Processing file: CIL_subset_ssp585_2045.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2045, month 1\n", + "Processing year 2045, month 2\n", + "Processing year 2045, month 3\n", + "Processing year 2045, month 4\n", + "Processing year 2045, month 5\n", + "Processing year 2045, month 6\n", + "Processing year 2045, month 7\n", + "Processing year 2045, month 8\n", + "Processing year 2045, month 9\n", + "Processing year 2045, month 10\n", + "Processing year 2045, month 11\n", + "Processing year 2045, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2045, month 1\n", + "Processing year 2045, month 2\n", + "Processing year 2045, month 3\n", + "Processing year 2045, month 4\n", + "Processing year 2045, month 5\n", + "Processing year 2045, month 6\n", + "Processing year 2045, month 7\n", + "Processing year 2045, month 8\n", + "Processing year 2045, month 9\n", + "Processing year 2045, month 10\n", + "Processing year 2045, month 11\n", + "Processing year 2045, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2045, month 1\n", + "Processing year 2045, month 2\n", + "Processing year 2045, month 3\n", + "Processing year 2045, month 4\n", + "Processing year 2045, month 5\n", + "Processing year 2045, month 6\n", + "Processing year 2045, month 7\n", + "Processing year 2045, month 8\n", + "Processing year 2045, month 9\n", + "Processing year 2045, month 10\n", + "Processing year 2045, month 11\n", + "Processing year 2045, month 12\n", + "Processing file: CIL_subset_ssp585_2046.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2046, month 1\n", + "Processing year 2046, month 2\n", + "Processing year 2046, month 3\n", + "Processing year 2046, month 4\n", + "Processing year 2046, month 5\n", + "Processing year 2046, month 6\n", + "Processing year 2046, month 7\n", + "Processing year 2046, month 8\n", + "Processing year 2046, month 9\n", + "Processing year 2046, month 10\n", + "Processing year 2046, month 11\n", + "Processing year 2046, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2046, month 1\n", + "Processing year 2046, month 2\n", + "Processing year 2046, month 3\n", + "Processing year 2046, month 4\n", + "Processing year 2046, month 5\n", + "Processing year 2046, month 6\n", + "Processing year 2046, month 7\n", + "Processing year 2046, month 8\n", + "Processing year 2046, month 9\n", + "Processing year 2046, month 10\n", + "Processing year 2046, month 11\n", + "Processing year 2046, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2046, month 1\n", + "Processing year 2046, month 2\n", + "Processing year 2046, month 3\n", + "Processing year 2046, month 4\n", + "Processing year 2046, month 5\n", + "Processing year 2046, month 6\n", + "Processing year 2046, month 7\n", + "Processing year 2046, month 8\n", + "Processing year 2046, month 9\n", + "Processing year 2046, month 10\n", + "Processing year 2046, month 11\n", + "Processing year 2046, month 12\n", + "Processing file: CIL_subset_ssp585_2047.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2047, month 1\n", + "Processing year 2047, month 2\n", + "Processing year 2047, month 3\n", + "Processing year 2047, month 4\n", + "Processing year 2047, month 5\n", + "Processing year 2047, month 6\n", + "Processing year 2047, month 7\n", + "Processing year 2047, month 8\n", + "Processing year 2047, month 9\n", + "Processing year 2047, month 10\n", + "Processing year 2047, month 11\n", + "Processing year 2047, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2047, month 1\n", + "Processing year 2047, month 2\n", + "Processing year 2047, month 3\n", + "Processing year 2047, month 4\n", + "Processing year 2047, month 5\n", + "Processing year 2047, month 6\n", + "Processing year 2047, month 7\n", + "Processing year 2047, month 8\n", + "Processing year 2047, month 9\n", + "Processing year 2047, month 10\n", + "Processing year 2047, month 11\n", + "Processing year 2047, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2047, month 1\n", + "Processing year 2047, month 2\n", + "Processing year 2047, month 3\n", + "Processing year 2047, month 4\n", + "Processing year 2047, month 5\n", + "Processing year 2047, month 6\n", + "Processing year 2047, month 7\n", + "Processing year 2047, month 8\n", + "Processing year 2047, month 9\n", + "Processing year 2047, month 10\n", + "Processing year 2047, month 11\n", + "Processing year 2047, month 12\n", + "Processing file: CIL_subset_ssp585_2048.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2048, month 1\n", + "Processing year 2048, month 2\n", + "Processing year 2048, month 3\n", + "Processing year 2048, month 4\n", + "Processing year 2048, month 5\n", + "Processing year 2048, month 6\n", + "Processing year 2048, month 7\n", + "Processing year 2048, month 8\n", + "Processing year 2048, month 9\n", + "Processing year 2048, month 10\n", + "Processing year 2048, month 11\n", + "Processing year 2048, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2048, month 1\n", + "Processing year 2048, month 2\n", + "Processing year 2048, month 3\n", + "Processing year 2048, month 4\n", + "Processing year 2048, month 5\n", + "Processing year 2048, month 6\n", + "Processing year 2048, month 7\n", + "Processing year 2048, month 8\n", + "Processing year 2048, month 9\n", + "Processing year 2048, month 10\n", + "Processing year 2048, month 11\n", + "Processing year 2048, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2048, month 1\n", + "Processing year 2048, month 2\n", + "Processing year 2048, month 3\n", + "Processing year 2048, month 4\n", + "Processing year 2048, month 5\n", + "Processing year 2048, month 6\n", + "Processing year 2048, month 7\n", + "Processing year 2048, month 8\n", + "Processing year 2048, month 9\n", + "Processing year 2048, month 10\n", + "Processing year 2048, month 11\n", + "Processing year 2048, month 12\n", + "Processing file: CIL_subset_ssp585_2049.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2049, month 1\n", + "Processing year 2049, month 2\n", + "Processing year 2049, month 3\n", + "Processing year 2049, month 4\n", + "Processing year 2049, month 5\n", + "Processing year 2049, month 6\n", + "Processing year 2049, month 7\n", + "Processing year 2049, month 8\n", + "Processing year 2049, month 9\n", + "Processing year 2049, month 10\n", + "Processing year 2049, month 11\n", + "Processing year 2049, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2049, month 1\n", + "Processing year 2049, month 2\n", + "Processing year 2049, month 3\n", + "Processing year 2049, month 4\n", + "Processing year 2049, month 5\n", + "Processing year 2049, month 6\n", + "Processing year 2049, month 7\n", + "Processing year 2049, month 8\n", + "Processing year 2049, month 9\n", + "Processing year 2049, month 10\n", + "Processing year 2049, month 11\n", + "Processing year 2049, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2049, month 1\n", + "Processing year 2049, month 2\n", + "Processing year 2049, month 3\n", + "Processing year 2049, month 4\n", + "Processing year 2049, month 5\n", + "Processing year 2049, month 6\n", + "Processing year 2049, month 7\n", + "Processing year 2049, month 8\n", + "Processing year 2049, month 9\n", + "Processing year 2049, month 10\n", + "Processing year 2049, month 11\n", + "Processing year 2049, month 12\n", + "Processing file: CIL_subset_ssp585_2050.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2050, month 1\n", + "Processing year 2050, month 2\n", + "Processing year 2050, month 3\n", + "Processing year 2050, month 4\n", + "Processing year 2050, month 5\n", + "Processing year 2050, month 6\n", + "Processing year 2050, month 7\n", + "Processing year 2050, month 8\n", + "Processing year 2050, month 9\n", + "Processing year 2050, month 10\n", + "Processing year 2050, month 11\n", + "Processing year 2050, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2050, month 1\n", + "Processing year 2050, month 2\n", + "Processing year 2050, month 3\n", + "Processing year 2050, month 4\n", + "Processing year 2050, month 5\n", + "Processing year 2050, month 6\n", + "Processing year 2050, month 7\n", + "Processing year 2050, month 8\n", + "Processing year 2050, month 9\n", + "Processing year 2050, month 10\n", + "Processing year 2050, month 11\n", + "Processing year 2050, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2050, month 1\n", + "Processing year 2050, month 2\n", + "Processing year 2050, month 3\n", + "Processing year 2050, month 4\n", + "Processing year 2050, month 5\n", + "Processing year 2050, month 6\n", + "Processing year 2050, month 7\n", + "Processing year 2050, month 8\n", + "Processing year 2050, month 9\n", + "Processing year 2050, month 10\n", + "Processing year 2050, month 11\n", + "Processing year 2050, month 12\n", + "Processing file: CIL_subset_ssp585_2051.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2051, month 1\n", + "Processing year 2051, month 2\n", + "Processing year 2051, month 3\n", + "Processing year 2051, month 4\n", + "Processing year 2051, month 5\n", + "Processing year 2051, month 6\n", + "Processing year 2051, month 7\n", + "Processing year 2051, month 8\n", + "Processing year 2051, month 9\n", + "Processing year 2051, month 10\n", + "Processing year 2051, month 11\n", + "Processing year 2051, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2051, month 1\n", + "Processing year 2051, month 2\n", + "Processing year 2051, month 3\n", + "Processing year 2051, month 4\n", + "Processing year 2051, month 5\n", + "Processing year 2051, month 6\n", + "Processing year 2051, month 7\n", + "Processing year 2051, month 8\n", + "Processing year 2051, month 9\n", + "Processing year 2051, month 10\n", + "Processing year 2051, month 11\n", + "Processing year 2051, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2051, month 1\n", + "Processing year 2051, month 2\n", + "Processing year 2051, month 3\n", + "Processing year 2051, month 4\n", + "Processing year 2051, month 5\n", + "Processing year 2051, month 6\n", + "Processing year 2051, month 7\n", + "Processing year 2051, month 8\n", + "Processing year 2051, month 9\n", + "Processing year 2051, month 10\n", + "Processing year 2051, month 11\n", + "Processing year 2051, month 12\n", + "Processing file: CIL_subset_ssp585_2052.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2052, month 1\n", + "Processing year 2052, month 2\n", + "Processing year 2052, month 3\n", + "Processing year 2052, month 4\n", + "Processing year 2052, month 5\n", + "Processing year 2052, month 6\n", + "Processing year 2052, month 7\n", + "Processing year 2052, month 8\n", + "Processing year 2052, month 9\n", + "Processing year 2052, month 10\n", + "Processing year 2052, month 11\n", + "Processing year 2052, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2052, month 1\n", + "Processing year 2052, month 2\n", + "Processing year 2052, month 3\n", + "Processing year 2052, month 4\n", + "Processing year 2052, month 5\n", + "Processing year 2052, month 6\n", + "Processing year 2052, month 7\n", + "Processing year 2052, month 8\n", + "Processing year 2052, month 9\n", + "Processing year 2052, month 10\n", + "Processing year 2052, month 11\n", + "Processing year 2052, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2052, month 1\n", + "Processing year 2052, month 2\n", + "Processing year 2052, month 3\n", + "Processing year 2052, month 4\n", + "Processing year 2052, month 5\n", + "Processing year 2052, month 6\n", + "Processing year 2052, month 7\n", + "Processing year 2052, month 8\n", + "Processing year 2052, month 9\n", + "Processing year 2052, month 10\n", + "Processing year 2052, month 11\n", + "Processing year 2052, month 12\n", + "Processing file: CIL_subset_ssp585_2053.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2053, month 1\n", + "Processing year 2053, month 2\n", + "Processing year 2053, month 3\n", + "Processing year 2053, month 4\n", + "Processing year 2053, month 5\n", + "Processing year 2053, month 6\n", + "Processing year 2053, month 7\n", + "Processing year 2053, month 8\n", + "Processing year 2053, month 9\n", + "Processing year 2053, month 10\n", + "Processing year 2053, month 11\n", + "Processing year 2053, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2053, month 1\n", + "Processing year 2053, month 2\n", + "Processing year 2053, month 3\n", + "Processing year 2053, month 4\n", + "Processing year 2053, month 5\n", + "Processing year 2053, month 6\n", + "Processing year 2053, month 7\n", + "Processing year 2053, month 8\n", + "Processing year 2053, month 9\n", + "Processing year 2053, month 10\n", + "Processing year 2053, month 11\n", + "Processing year 2053, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2053, month 1\n", + "Processing year 2053, month 2\n", + "Processing year 2053, month 3\n", + "Processing year 2053, month 4\n", + "Processing year 2053, month 5\n", + "Processing year 2053, month 6\n", + "Processing year 2053, month 7\n", + "Processing year 2053, month 8\n", + "Processing year 2053, month 9\n", + "Processing year 2053, month 10\n", + "Processing year 2053, month 11\n", + "Processing year 2053, month 12\n", + "Processing file: CIL_subset_ssp585_2054.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2054, month 1\n", + "Processing year 2054, month 2\n", + "Processing year 2054, month 3\n", + "Processing year 2054, month 4\n", + "Processing year 2054, month 5\n", + "Processing year 2054, month 6\n", + "Processing year 2054, month 7\n", + "Processing year 2054, month 8\n", + "Processing year 2054, month 9\n", + "Processing year 2054, month 10\n", + "Processing year 2054, month 11\n", + "Processing year 2054, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2054, month 1\n", + "Processing year 2054, month 2\n", + "Processing year 2054, month 3\n", + "Processing year 2054, month 4\n", + "Processing year 2054, month 5\n", + "Processing year 2054, month 6\n", + "Processing year 2054, month 7\n", + "Processing year 2054, month 8\n", + "Processing year 2054, month 9\n", + "Processing year 2054, month 10\n", + "Processing year 2054, month 11\n", + "Processing year 2054, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2054, month 1\n", + "Processing year 2054, month 2\n", + "Processing year 2054, month 3\n", + "Processing year 2054, month 4\n", + "Processing year 2054, month 5\n", + "Processing year 2054, month 6\n", + "Processing year 2054, month 7\n", + "Processing year 2054, month 8\n", + "Processing year 2054, month 9\n", + "Processing year 2054, month 10\n", + "Processing year 2054, month 11\n", + "Processing year 2054, month 12\n", + "Processing file: CIL_subset_ssp585_2055.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2055, month 1\n", + "Processing year 2055, month 2\n", + "Processing year 2055, month 3\n", + "Processing year 2055, month 4\n", + "Processing year 2055, month 5\n", + "Processing year 2055, month 6\n", + "Processing year 2055, month 7\n", + "Processing year 2055, month 8\n", + "Processing year 2055, month 9\n", + "Processing year 2055, month 10\n", + "Processing year 2055, month 11\n", + "Processing year 2055, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2055, month 1\n", + "Processing year 2055, month 2\n", + "Processing year 2055, month 3\n", + "Processing year 2055, month 4\n", + "Processing year 2055, month 5\n", + "Processing year 2055, month 6\n", + "Processing year 2055, month 7\n", + "Processing year 2055, month 8\n", + "Processing year 2055, month 9\n", + "Processing year 2055, month 10\n", + "Processing year 2055, month 11\n", + "Processing year 2055, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2055, month 1\n", + "Processing year 2055, month 2\n", + "Processing year 2055, month 3\n", + "Processing year 2055, month 4\n", + "Processing year 2055, month 5\n", + "Processing year 2055, month 6\n", + "Processing year 2055, month 7\n", + "Processing year 2055, month 8\n", + "Processing year 2055, month 9\n", + "Processing year 2055, month 10\n", + "Processing year 2055, month 11\n", + "Processing year 2055, month 12\n", + "Processing file: CIL_subset_ssp585_2056.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2056, month 1\n", + "Processing year 2056, month 2\n", + "Processing year 2056, month 3\n", + "Processing year 2056, month 4\n", + "Processing year 2056, month 5\n", + "Processing year 2056, month 6\n", + "Processing year 2056, month 7\n", + "Processing year 2056, month 8\n", + "Processing year 2056, month 9\n", + "Processing year 2056, month 10\n", + "Processing year 2056, month 11\n", + "Processing year 2056, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2056, month 1\n", + "Processing year 2056, month 2\n", + "Processing year 2056, month 3\n", + "Processing year 2056, month 4\n", + "Processing year 2056, month 5\n", + "Processing year 2056, month 6\n", + "Processing year 2056, month 7\n", + "Processing year 2056, month 8\n", + "Processing year 2056, month 9\n", + "Processing year 2056, month 10\n", + "Processing year 2056, month 11\n", + "Processing year 2056, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2056, month 1\n", + "Processing year 2056, month 2\n", + "Processing year 2056, month 3\n", + "Processing year 2056, month 4\n", + "Processing year 2056, month 5\n", + "Processing year 2056, month 6\n", + "Processing year 2056, month 7\n", + "Processing year 2056, month 8\n", + "Processing year 2056, month 9\n", + "Processing year 2056, month 10\n", + "Processing year 2056, month 11\n", + "Processing year 2056, month 12\n", + "Processing file: CIL_subset_ssp585_2057.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2057, month 1\n", + "Processing year 2057, month 2\n", + "Processing year 2057, month 3\n", + "Processing year 2057, month 4\n", + "Processing year 2057, month 5\n", + "Processing year 2057, month 6\n", + "Processing year 2057, month 7\n", + "Processing year 2057, month 8\n", + "Processing year 2057, month 9\n", + "Processing year 2057, month 10\n", + "Processing year 2057, month 11\n", + "Processing year 2057, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2057, month 1\n", + "Processing year 2057, month 2\n", + "Processing year 2057, month 3\n", + "Processing year 2057, month 4\n", + "Processing year 2057, month 5\n", + "Processing year 2057, month 6\n", + "Processing year 2057, month 7\n", + "Processing year 2057, month 8\n", + "Processing year 2057, month 9\n", + "Processing year 2057, month 10\n", + "Processing year 2057, month 11\n", + "Processing year 2057, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2057, month 1\n", + "Processing year 2057, month 2\n", + "Processing year 2057, month 3\n", + "Processing year 2057, month 4\n", + "Processing year 2057, month 5\n", + "Processing year 2057, month 6\n", + "Processing year 2057, month 7\n", + "Processing year 2057, month 8\n", + "Processing year 2057, month 9\n", + "Processing year 2057, month 10\n", + "Processing year 2057, month 11\n", + "Processing year 2057, month 12\n", + "Processing file: CIL_subset_ssp585_2058.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2058, month 1\n", + "Processing year 2058, month 2\n", + "Processing year 2058, month 3\n", + "Processing year 2058, month 4\n", + "Processing year 2058, month 5\n", + "Processing year 2058, month 6\n", + "Processing year 2058, month 7\n", + "Processing year 2058, month 8\n", + "Processing year 2058, month 9\n", + "Processing year 2058, month 10\n", + "Processing year 2058, month 11\n", + "Processing year 2058, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2058, month 1\n", + "Processing year 2058, month 2\n", + "Processing year 2058, month 3\n", + "Processing year 2058, month 4\n", + "Processing year 2058, month 5\n", + "Processing year 2058, month 6\n", + "Processing year 2058, month 7\n", + "Processing year 2058, month 8\n", + "Processing year 2058, month 9\n", + "Processing year 2058, month 10\n", + "Processing year 2058, month 11\n", + "Processing year 2058, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2058, month 1\n", + "Processing year 2058, month 2\n", + "Processing year 2058, month 3\n", + "Processing year 2058, month 4\n", + "Processing year 2058, month 5\n", + "Processing year 2058, month 6\n", + "Processing year 2058, month 7\n", + "Processing year 2058, month 8\n", + "Processing year 2058, month 9\n", + "Processing year 2058, month 10\n", + "Processing year 2058, month 11\n", + "Processing year 2058, month 12\n", + "Processing file: CIL_subset_ssp585_2059.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2059, month 1\n", + "Processing year 2059, month 2\n", + "Processing year 2059, month 3\n", + "Processing year 2059, month 4\n", + "Processing year 2059, month 5\n", + "Processing year 2059, month 6\n", + "Processing year 2059, month 7\n", + "Processing year 2059, month 8\n", + "Processing year 2059, month 9\n", + "Processing year 2059, month 10\n", + "Processing year 2059, month 11\n", + "Processing year 2059, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2059, month 1\n", + "Processing year 2059, month 2\n", + "Processing year 2059, month 3\n", + "Processing year 2059, month 4\n", + "Processing year 2059, month 5\n", + "Processing year 2059, month 6\n", + "Processing year 2059, month 7\n", + "Processing year 2059, month 8\n", + "Processing year 2059, month 9\n", + "Processing year 2059, month 10\n", + "Processing year 2059, month 11\n", + "Processing year 2059, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2059, month 1\n", + "Processing year 2059, month 2\n", + "Processing year 2059, month 3\n", + "Processing year 2059, month 4\n", + "Processing year 2059, month 5\n", + "Processing year 2059, month 6\n", + "Processing year 2059, month 7\n", + "Processing year 2059, month 8\n", + "Processing year 2059, month 9\n", + "Processing year 2059, month 10\n", + "Processing year 2059, month 11\n", + "Processing year 2059, month 12\n", + "Processing file: CIL_subset_ssp585_2060.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2060, month 1\n", + "Processing year 2060, month 2\n", + "Processing year 2060, month 3\n", + "Processing year 2060, month 4\n", + "Processing year 2060, month 5\n", + "Processing year 2060, month 6\n", + "Processing year 2060, month 7\n", + "Processing year 2060, month 8\n", + "Processing year 2060, month 9\n", + "Processing year 2060, month 10\n", + "Processing year 2060, month 11\n", + "Processing year 2060, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2060, month 1\n", + "Processing year 2060, month 2\n", + "Processing year 2060, month 3\n", + "Processing year 2060, month 4\n", + "Processing year 2060, month 5\n", + "Processing year 2060, month 6\n", + "Processing year 2060, month 7\n", + "Processing year 2060, month 8\n", + "Processing year 2060, month 9\n", + "Processing year 2060, month 10\n", + "Processing year 2060, month 11\n", + "Processing year 2060, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2060, month 1\n", + "Processing year 2060, month 2\n", + "Processing year 2060, month 3\n", + "Processing year 2060, month 4\n", + "Processing year 2060, month 5\n", + "Processing year 2060, month 6\n", + "Processing year 2060, month 7\n", + "Processing year 2060, month 8\n", + "Processing year 2060, month 9\n", + "Processing year 2060, month 10\n", + "Processing year 2060, month 11\n", + "Processing year 2060, month 12\n", + "Processing file: CIL_subset_ssp585_2061.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2061, month 1\n", + "Processing year 2061, month 2\n", + "Processing year 2061, month 3\n", + "Processing year 2061, month 4\n", + "Processing year 2061, month 5\n", + "Processing year 2061, month 6\n", + "Processing year 2061, month 7\n", + "Processing year 2061, month 8\n", + "Processing year 2061, month 9\n", + "Processing year 2061, month 10\n", + "Processing year 2061, month 11\n", + "Processing year 2061, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2061, month 1\n", + "Processing year 2061, month 2\n", + "Processing year 2061, month 3\n", + "Processing year 2061, month 4\n", + "Processing year 2061, month 5\n", + "Processing year 2061, month 6\n", + "Processing year 2061, month 7\n", + "Processing year 2061, month 8\n", + "Processing year 2061, month 9\n", + "Processing year 2061, month 10\n", + "Processing year 2061, month 11\n", + "Processing year 2061, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2061, month 1\n", + "Processing year 2061, month 2\n", + "Processing year 2061, month 3\n", + "Processing year 2061, month 4\n", + "Processing year 2061, month 5\n", + "Processing year 2061, month 6\n", + "Processing year 2061, month 7\n", + "Processing year 2061, month 8\n", + "Processing year 2061, month 9\n", + "Processing year 2061, month 10\n", + "Processing year 2061, month 11\n", + "Processing year 2061, month 12\n", + "Processing file: CIL_subset_ssp585_2062.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2062, month 1\n", + "Processing year 2062, month 2\n", + "Processing year 2062, month 3\n", + "Processing year 2062, month 4\n", + "Processing year 2062, month 5\n", + "Processing year 2062, month 6\n", + "Processing year 2062, month 7\n", + "Processing year 2062, month 8\n", + "Processing year 2062, month 9\n", + "Processing year 2062, month 10\n", + "Processing year 2062, month 11\n", + "Processing year 2062, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2062, month 1\n", + "Processing year 2062, month 2\n", + "Processing year 2062, month 3\n", + "Processing year 2062, month 4\n", + "Processing year 2062, month 5\n", + "Processing year 2062, month 6\n", + "Processing year 2062, month 7\n", + "Processing year 2062, month 8\n", + "Processing year 2062, month 9\n", + "Processing year 2062, month 10\n", + "Processing year 2062, month 11\n", + "Processing year 2062, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2062, month 1\n", + "Processing year 2062, month 2\n", + "Processing year 2062, month 3\n", + "Processing year 2062, month 4\n", + "Processing year 2062, month 5\n", + "Processing year 2062, month 6\n", + "Processing year 2062, month 7\n", + "Processing year 2062, month 8\n", + "Processing year 2062, month 9\n", + "Processing year 2062, month 10\n", + "Processing year 2062, month 11\n", + "Processing year 2062, month 12\n", + "Processing file: CIL_subset_ssp585_2063.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2063, month 1\n", + "Processing year 2063, month 2\n", + "Processing year 2063, month 3\n", + "Processing year 2063, month 4\n", + "Processing year 2063, month 5\n", + "Processing year 2063, month 6\n", + "Processing year 2063, month 7\n", + "Processing year 2063, month 8\n", + "Processing year 2063, month 9\n", + "Processing year 2063, month 10\n", + "Processing year 2063, month 11\n", + "Processing year 2063, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2063, month 1\n", + "Processing year 2063, month 2\n", + "Processing year 2063, month 3\n", + "Processing year 2063, month 4\n", + "Processing year 2063, month 5\n", + "Processing year 2063, month 6\n", + "Processing year 2063, month 7\n", + "Processing year 2063, month 8\n", + "Processing year 2063, month 9\n", + "Processing year 2063, month 10\n", + "Processing year 2063, month 11\n", + "Processing year 2063, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2063, month 1\n", + "Processing year 2063, month 2\n", + "Processing year 2063, month 3\n", + "Processing year 2063, month 4\n", + "Processing year 2063, month 5\n", + "Processing year 2063, month 6\n", + "Processing year 2063, month 7\n", + "Processing year 2063, month 8\n", + "Processing year 2063, month 9\n", + "Processing year 2063, month 10\n", + "Processing year 2063, month 11\n", + "Processing year 2063, month 12\n", + "Processing file: CIL_subset_ssp585_2064.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2064, month 1\n", + "Processing year 2064, month 2\n", + "Processing year 2064, month 3\n", + "Processing year 2064, month 4\n", + "Processing year 2064, month 5\n", + "Processing year 2064, month 6\n", + "Processing year 2064, month 7\n", + "Processing year 2064, month 8\n", + "Processing year 2064, month 9\n", + "Processing year 2064, month 10\n", + "Processing year 2064, month 11\n", + "Processing year 2064, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2064, month 1\n", + "Processing year 2064, month 2\n", + "Processing year 2064, month 3\n", + "Processing year 2064, month 4\n", + "Processing year 2064, month 5\n", + "Processing year 2064, month 6\n", + "Processing year 2064, month 7\n", + "Processing year 2064, month 8\n", + "Processing year 2064, month 9\n", + "Processing year 2064, month 10\n", + "Processing year 2064, month 11\n", + "Processing year 2064, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2064, month 1\n", + "Processing year 2064, month 2\n", + "Processing year 2064, month 3\n", + "Processing year 2064, month 4\n", + "Processing year 2064, month 5\n", + "Processing year 2064, month 6\n", + "Processing year 2064, month 7\n", + "Processing year 2064, month 8\n", + "Processing year 2064, month 9\n", + "Processing year 2064, month 10\n", + "Processing year 2064, month 11\n", + "Processing year 2064, month 12\n", + "Processing file: CIL_subset_ssp585_2065.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2065, month 1\n", + "Processing year 2065, month 2\n", + "Processing year 2065, month 3\n", + "Processing year 2065, month 4\n", + "Processing year 2065, month 5\n", + "Processing year 2065, month 6\n", + "Processing year 2065, month 7\n", + "Processing year 2065, month 8\n", + "Processing year 2065, month 9\n", + "Processing year 2065, month 10\n", + "Processing year 2065, month 11\n", + "Processing year 2065, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2065, month 1\n", + "Processing year 2065, month 2\n", + "Processing year 2065, month 3\n", + "Processing year 2065, month 4\n", + "Processing year 2065, month 5\n", + "Processing year 2065, month 6\n", + "Processing year 2065, month 7\n", + "Processing year 2065, month 8\n", + "Processing year 2065, month 9\n", + "Processing year 2065, month 10\n", + "Processing year 2065, month 11\n", + "Processing year 2065, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2065, month 1\n", + "Processing year 2065, month 2\n", + "Processing year 2065, month 3\n", + "Processing year 2065, month 4\n", + "Processing year 2065, month 5\n", + "Processing year 2065, month 6\n", + "Processing year 2065, month 7\n", + "Processing year 2065, month 8\n", + "Processing year 2065, month 9\n", + "Processing year 2065, month 10\n", + "Processing year 2065, month 11\n", + "Processing year 2065, month 12\n", + "Processing file: CIL_subset_ssp585_2066.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2066, month 1\n", + "Processing year 2066, month 2\n", + "Processing year 2066, month 3\n", + "Processing year 2066, month 4\n", + "Processing year 2066, month 5\n", + "Processing year 2066, month 6\n", + "Processing year 2066, month 7\n", + "Processing year 2066, month 8\n", + "Processing year 2066, month 9\n", + "Processing year 2066, month 10\n", + "Processing year 2066, month 11\n", + "Processing year 2066, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2066, month 1\n", + "Processing year 2066, month 2\n", + "Processing year 2066, month 3\n", + "Processing year 2066, month 4\n", + "Processing year 2066, month 5\n", + "Processing year 2066, month 6\n", + "Processing year 2066, month 7\n", + "Processing year 2066, month 8\n", + "Processing year 2066, month 9\n", + "Processing year 2066, month 10\n", + "Processing year 2066, month 11\n", + "Processing year 2066, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2066, month 1\n", + "Processing year 2066, month 2\n", + "Processing year 2066, month 3\n", + "Processing year 2066, month 4\n", + "Processing year 2066, month 5\n", + "Processing year 2066, month 6\n", + "Processing year 2066, month 7\n", + "Processing year 2066, month 8\n", + "Processing year 2066, month 9\n", + "Processing year 2066, month 10\n", + "Processing year 2066, month 11\n", + "Processing year 2066, month 12\n", + "Processing file: CIL_subset_ssp585_2067.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2067, month 1\n", + "Processing year 2067, month 2\n", + "Processing year 2067, month 3\n", + "Processing year 2067, month 4\n", + "Processing year 2067, month 5\n", + "Processing year 2067, month 6\n", + "Processing year 2067, month 7\n", + "Processing year 2067, month 8\n", + "Processing year 2067, month 9\n", + "Processing year 2067, month 10\n", + "Processing year 2067, month 11\n", + "Processing year 2067, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2067, month 1\n", + "Processing year 2067, month 2\n", + "Processing year 2067, month 3\n", + "Processing year 2067, month 4\n", + "Processing year 2067, month 5\n", + "Processing year 2067, month 6\n", + "Processing year 2067, month 7\n", + "Processing year 2067, month 8\n", + "Processing year 2067, month 9\n", + "Processing year 2067, month 10\n", + "Processing year 2067, month 11\n", + "Processing year 2067, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2067, month 1\n", + "Processing year 2067, month 2\n", + "Processing year 2067, month 3\n", + "Processing year 2067, month 4\n", + "Processing year 2067, month 5\n", + "Processing year 2067, month 6\n", + "Processing year 2067, month 7\n", + "Processing year 2067, month 8\n", + "Processing year 2067, month 9\n", + "Processing year 2067, month 10\n", + "Processing year 2067, month 11\n", + "Processing year 2067, month 12\n", + "Processing file: CIL_subset_ssp585_2068.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2068, month 1\n", + "Processing year 2068, month 2\n", + "Processing year 2068, month 3\n", + "Processing year 2068, month 4\n", + "Processing year 2068, month 5\n", + "Processing year 2068, month 6\n", + "Processing year 2068, month 7\n", + "Processing year 2068, month 8\n", + "Processing year 2068, month 9\n", + "Processing year 2068, month 10\n", + "Processing year 2068, month 11\n", + "Processing year 2068, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2068, month 1\n", + "Processing year 2068, month 2\n", + "Processing year 2068, month 3\n", + "Processing year 2068, month 4\n", + "Processing year 2068, month 5\n", + "Processing year 2068, month 6\n", + "Processing year 2068, month 7\n", + "Processing year 2068, month 8\n", + "Processing year 2068, month 9\n", + "Processing year 2068, month 10\n", + "Processing year 2068, month 11\n", + "Processing year 2068, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2068, month 1\n", + "Processing year 2068, month 2\n", + "Processing year 2068, month 3\n", + "Processing year 2068, month 4\n", + "Processing year 2068, month 5\n", + "Processing year 2068, month 6\n", + "Processing year 2068, month 7\n", + "Processing year 2068, month 8\n", + "Processing year 2068, month 9\n", + "Processing year 2068, month 10\n", + "Processing year 2068, month 11\n", + "Processing year 2068, month 12\n", + "Processing file: CIL_subset_ssp585_2069.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2069, month 1\n", + "Processing year 2069, month 2\n", + "Processing year 2069, month 3\n", + "Processing year 2069, month 4\n", + "Processing year 2069, month 5\n", + "Processing year 2069, month 6\n", + "Processing year 2069, month 7\n", + "Processing year 2069, month 8\n", + "Processing year 2069, month 9\n", + "Processing year 2069, month 10\n", + "Processing year 2069, month 11\n", + "Processing year 2069, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2069, month 1\n", + "Processing year 2069, month 2\n", + "Processing year 2069, month 3\n", + "Processing year 2069, month 4\n", + "Processing year 2069, month 5\n", + "Processing year 2069, month 6\n", + "Processing year 2069, month 7\n", + "Processing year 2069, month 8\n", + "Processing year 2069, month 9\n", + "Processing year 2069, month 10\n", + "Processing year 2069, month 11\n", + "Processing year 2069, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2069, month 1\n", + "Processing year 2069, month 2\n", + "Processing year 2069, month 3\n", + "Processing year 2069, month 4\n", + "Processing year 2069, month 5\n", + "Processing year 2069, month 6\n", + "Processing year 2069, month 7\n", + "Processing year 2069, month 8\n", + "Processing year 2069, month 9\n", + "Processing year 2069, month 10\n", + "Processing year 2069, month 11\n", + "Processing year 2069, month 12\n", + "Processing file: CIL_subset_ssp585_2070.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2070, month 1\n", + "Processing year 2070, month 2\n", + "Processing year 2070, month 3\n", + "Processing year 2070, month 4\n", + "Processing year 2070, month 5\n", + "Processing year 2070, month 6\n", + "Processing year 2070, month 7\n", + "Processing year 2070, month 8\n", + "Processing year 2070, month 9\n", + "Processing year 2070, month 10\n", + "Processing year 2070, month 11\n", + "Processing year 2070, month 12\n", + "Processing model: GFDL-CM4\n", + "Processing year 2070, month 1\n", + "Processing year 2070, month 2\n", + "Processing year 2070, month 3\n", + "Processing year 2070, month 4\n", + "Processing year 2070, month 5\n", + "Processing year 2070, month 6\n", + "Processing year 2070, month 7\n", + "Processing year 2070, month 8\n", + "Processing year 2070, month 9\n", + "Processing year 2070, month 10\n", + "Processing year 2070, month 11\n", + "Processing year 2070, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2070, month 1\n", + "Processing year 2070, month 2\n", + "Processing year 2070, month 3\n", + "Processing year 2070, month 4\n", + "Processing year 2070, month 5\n", + "Processing year 2070, month 6\n", + "Processing year 2070, month 7\n", + "Processing year 2070, month 8\n", + "Processing year 2070, month 9\n", + "Processing year 2070, month 10\n", + "Processing year 2070, month 11\n", + "Processing year 2070, month 12\n", + "Saved monthly data for lowest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/lowest_monthly_prediction_weather_by_facility.csv\n", + "Saved window data for lowest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/lowest_window_prediction_weather_by_facility.csv\n", + "Saved monthly data for median model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/median_monthly_prediction_weather_by_facility.csv\n", + "Saved window data for median model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/median_window_prediction_weather_by_facility.csv\n", + "Saved monthly data for highest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/highest_monthly_prediction_weather_by_facility.csv\n", + "Saved window data for highest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/highest_window_prediction_weather_by_facility.csv\n" + ] + } + ], + "execution_count": 14 }, { "metadata": { From a65f0995f3682bbfd93fdb4a723767b9386d0814 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 9 Jan 2025 11:50:29 +0000 Subject: [PATCH 170/291] Added map showing projected decrease (%) by district of ANC cases (for ssp245 lowest) --- src/scripts/climate_change/cohort_model.ipynb | 2708 +++++++++++------ 1 file changed, 1843 insertions(+), 865 deletions(-) diff --git a/src/scripts/climate_change/cohort_model.ipynb b/src/scripts/climate_change/cohort_model.ipynb index f76d06bf20..5508640b5a 100644 --- a/src/scripts/climate_change/cohort_model.ipynb +++ b/src/scripts/climate_change/cohort_model.ipynb @@ -6,8 +6,8 @@ "metadata": { "collapsed": true, "ExecuteTime": { - "end_time": "2025-01-07T10:26:36.875228Z", - "start_time": "2025-01-07T10:26:35.806549Z" + "end_time": "2025-01-09T11:44:41.243549Z", + "start_time": "2025-01-09T11:44:40.438524Z" } }, "source": [ @@ -198,8 +198,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-07T15:20:29.960Z", - "start_time": "2025-01-07T15:20:29.953891Z" + "end_time": "2025-01-09T11:44:42.287386Z", + "start_time": "2025-01-09T11:44:42.285045Z" } }, "cell_type": "code", @@ -209,26 +209,26 @@ ], "id": "bbff583692196586", "outputs": [], - "execution_count": 55 + "execution_count": 2 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-07T15:20:30.644229Z", - "start_time": "2025-01-07T15:20:30.416235Z" + "end_time": "2025-01-09T11:44:43.001534Z", + "start_time": "2025-01-09T11:44:42.828177Z" } }, "cell_type": "code", "source": "predictions_from_cmip = pd.read_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv')", "id": "3be0a4515f3e890e", "outputs": [], - "execution_count": 56 + "execution_count": 3 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-07T15:20:31.088305Z", - "start_time": "2025-01-07T15:20:30.927992Z" + "end_time": "2025-01-09T11:44:43.466150Z", + "start_time": "2025-01-09T11:44:43.286795Z" } }, "cell_type": "code", @@ -337,6 +337,54 @@ "44 Central WestSouth EastNorthernSouth EastNorthe... \n", "45 Central WestSouth EastNorthernSouth EastNorthe... \n", "\n", + " District \\\n", + "0 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "1 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "2 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "3 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "4 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "5 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "6 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "7 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "8 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "9 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "10 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "11 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "12 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "13 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "14 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "15 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "16 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "17 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "18 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "19 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "20 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "21 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "22 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "23 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "24 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "25 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "26 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "27 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "28 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "29 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "30 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "31 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "32 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "33 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "34 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "35 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "36 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "37 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "38 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "39 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "40 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "41 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "42 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "43 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "44 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "45 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "\n", " Resid \\\n", "0 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", "1 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", @@ -482,7 +530,7 @@ "45 ClinicDistrict HospitalRural/Community Hospita... 405718.142702 \n", "\n", " Lag_1_Precipitation Lag_2_Precipitation Lag_3_Precipitation \\\n", - "0 298710.995438 260619.466056 255428.892934 \n", + "0 390008.338639 385074.053901 383551.519335 \n", "1 324216.805408 351108.236956 352944.118983 \n", "2 351903.960266 349493.164255 344770.234996 \n", "3 379492.789825 375543.857029 381029.229862 \n", @@ -530,100 +578,100 @@ "45 364719.332490 323443.731437 324834.166014 \n", "\n", " Lag_4_Precipitation Predicted_Weather_Model Predicted_No_Weather_Model \\\n", - "0 253508.982217 301084.510508 452103.379475 \n", - "1 353891.586301 448829.801850 451249.680342 \n", - "2 345157.532117 450130.102782 450397.593235 \n", - "3 379415.048009 446465.064103 449547.115109 \n", - "4 382864.345741 446875.456426 448698.242927 \n", - "5 289345.079079 445094.075488 447850.973656 \n", - "6 455034.373344 443152.899063 447005.304268 \n", - "7 314871.921748 445109.242713 446161.231744 \n", - "8 356543.998012 444390.632491 445318.753068 \n", - "9 391937.348081 443363.169753 444477.865230 \n", - "10 329650.101725 441484.287781 443638.565226 \n", - "11 379596.718666 443252.418520 442800.850059 \n", - "12 389558.939179 440302.572113 441964.716734 \n", - "13 377682.655534 441220.746519 441130.162266 \n", - "14 409745.578729 442599.508715 440297.183673 \n", - "15 341977.330400 437729.663871 439465.777979 \n", - "16 335789.435760 435203.049238 438635.942214 \n", - "17 296296.047432 436957.723991 437807.673415 \n", - "18 278184.608227 434305.862192 436980.968621 \n", - "19 387661.416146 434323.547929 436155.824879 \n", - "20 340516.424995 434015.417381 435332.239243 \n", - "21 502277.800794 434856.288139 434510.208770 \n", - "22 445805.292269 435279.971776 433689.730522 \n", - "23 313923.715557 430636.491081 432870.801570 \n", - "24 330244.876504 430911.874972 432053.418987 \n", - "25 438231.552425 428660.978812 431237.579854 \n", - "26 393957.931607 430121.833314 430423.281257 \n", - "27 336884.175544 427569.904956 429610.520285 \n", - "28 365595.615071 427736.660883 428799.294036 \n", - "29 337541.046047 425208.288593 427989.599612 \n", - "30 331449.273326 426741.194309 427181.434120 \n", - "31 269433.014822 425551.827998 426374.794674 \n", - "32 445524.032754 424893.403624 425569.678390 \n", - "33 291038.100935 423223.667713 424766.082395 \n", - "34 305678.254498 422131.112511 423964.003816 \n", - "35 330169.889911 421573.506857 423163.439788 \n", - "36 317973.894415 422575.707068 422364.387452 \n", - "37 312810.479228 420956.703710 421566.843952 \n", - "38 405190.542219 418934.469956 420770.806441 \n", - "39 319575.723877 419086.943369 419976.272074 \n", - "40 329238.343810 418729.313756 419183.238012 \n", - "41 372541.004296 418355.425750 418391.701423 \n", - "42 281840.507716 417412.937075 417601.659480 \n", - "43 359548.833442 414765.010421 416813.109359 \n", - "44 461552.424105 415927.049193 416026.048243 \n", - "45 323233.055405 412876.186407 415240.473322 \n", + "0 382881.752808 453186.019359 452178.159027 \n", + "1 353891.586301 448903.391472 451324.318689 \n", + "2 345157.532117 450203.526071 450472.090644 \n", + "3 379415.048009 446538.199648 449621.471846 \n", + "4 382864.345741 446948.806790 448772.459257 \n", + "5 289345.079079 445167.350051 447925.049844 \n", + "6 455034.373344 443225.944431 447079.240580 \n", + "7 314871.921748 445182.353097 446235.028444 \n", + "8 356543.998012 444463.766354 445392.410418 \n", + "9 391937.348081 443436.073774 444551.383494 \n", + "10 329650.101725 441556.996446 443711.944667 \n", + "11 379596.718666 443325.455792 442874.090938 \n", + "12 389558.939179 440375.155656 442037.819314 \n", + "13 377682.655534 441294.684850 441203.126808 \n", + "14 409745.578729 442671.748454 440370.010437 \n", + "15 341977.330400 437801.561953 439538.467226 \n", + "16 335789.435760 435274.468592 438708.494203 \n", + "17 296296.047432 437029.478846 437880.088405 \n", + "18 278184.608227 434377.435798 437053.246871 \n", + "19 387661.416146 434394.568891 436227.966648 \n", + "20 340516.424995 434086.915088 435404.244787 \n", + "21 502277.800794 434927.534834 434582.078347 \n", + "22 445805.292269 435351.610440 433761.464389 \n", + "23 313923.715557 430707.116763 432942.399983 \n", + "24 330244.876504 430982.665089 432124.882203 \n", + "25 438231.552425 428731.420008 431308.908127 \n", + "26 393957.931607 430192.671905 430494.474841 \n", + "27 336884.175544 427640.316088 429681.579436 \n", + "28 365595.615071 427806.610028 428870.219007 \n", + "29 337541.046047 425278.010843 428060.390657 \n", + "30 331449.273326 426811.173251 427252.091491 \n", + "31 269433.014822 425621.733459 426445.318624 \n", + "32 445524.032754 424963.149920 425640.069171 \n", + "33 291038.100935 423293.012832 424836.340258 \n", + "34 305678.254498 422200.602069 424034.129012 \n", + "35 330169.889911 421642.817151 423233.432568 \n", + "36 317973.894415 422645.018611 422434.248066 \n", + "37 312810.479228 421026.188284 421636.572650 \n", + "38 405190.542219 419003.352104 420840.403471 \n", + "39 319575.723877 419156.256610 420045.737685 \n", + "40 329238.343810 418797.992003 419252.572452 \n", + "41 372541.004296 418424.138509 418460.904941 \n", + "42 281840.507716 417481.752292 417670.732321 \n", + "43 359548.833442 414833.508183 416882.051771 \n", + "44 461552.424105 415995.972386 416094.860473 \n", + "45 323233.055405 412944.024703 415309.155615 \n", "\n", " Difference_in_Expectation \n", - "0 -317.566395 \n", - "1 -2419.878492 \n", - "2 -267.490453 \n", - "3 -3082.051006 \n", - "4 -1822.786501 \n", - "5 -2756.898168 \n", - "6 -3852.405205 \n", - "7 -1051.989032 \n", - "8 -928.120577 \n", - "9 -1114.695477 \n", - "10 -2154.277446 \n", - "11 451.568461 \n", - "12 -1662.144621 \n", - "13 90.584253 \n", - "14 2302.325042 \n", - "15 -1736.114108 \n", - "16 -3432.892977 \n", - "17 -849.949424 \n", - "18 -2675.106429 \n", - "19 -1832.276951 \n", - "20 -1316.821862 \n", - "21 346.079370 \n", - "22 1590.241254 \n", - "23 -2234.310489 \n", - "24 -1141.544015 \n", - "25 -2576.601042 \n", - "26 -301.447942 \n", - "27 -2040.615329 \n", - "28 -1062.633153 \n", - "29 -2781.311019 \n", - "30 -440.239811 \n", - "31 -822.966676 \n", - "32 -676.274766 \n", - "33 -1542.414682 \n", - "34 -1832.891305 \n", - "35 -1589.932931 \n", - "36 211.319617 \n", - "37 -610.140243 \n", - "38 -1836.336485 \n", - "39 -889.328705 \n", - "40 -453.924256 \n", - "41 -36.275673 \n", - "42 -188.722404 \n", - "43 -2048.098937 \n", - "44 -98.999050 \n", - "45 -2364.286915 " + "0 1007.860332 \n", + "1 -2420.927217 \n", + "2 -268.564573 \n", + "3 -3083.272198 \n", + "4 -1823.652467 \n", + "5 -2757.699793 \n", + "6 -3853.296150 \n", + "7 -1052.675347 \n", + "8 -928.644064 \n", + "9 -1115.309720 \n", + "10 -2154.948222 \n", + "11 451.364853 \n", + "12 -1662.663659 \n", + "13 91.558042 \n", + "14 2301.738017 \n", + "15 -1736.905273 \n", + "16 -3434.025611 \n", + "17 -850.609558 \n", + "18 -2675.811073 \n", + "19 -1833.397757 \n", + "20 -1317.329699 \n", + "21 345.456487 \n", + "22 1590.146050 \n", + "23 -2235.283220 \n", + "24 -1142.217114 \n", + "25 -2577.488119 \n", + "26 -301.802936 \n", + "27 -2041.263348 \n", + "28 -1063.608979 \n", + "29 -2782.379814 \n", + "30 -440.918241 \n", + "31 -823.585164 \n", + "32 -676.919251 \n", + "33 -1543.327426 \n", + "34 -1833.526943 \n", + "35 -1590.615417 \n", + "36 210.770545 \n", + "37 -610.384366 \n", + "38 -1837.051367 \n", + "39 -889.481075 \n", + "40 -454.580449 \n", + "41 -36.766432 \n", + "42 -188.980029 \n", + "43 -2048.543588 \n", + "44 -98.888087 \n", + "45 -2365.130912 " ], "text/html": [ "
\n", @@ -649,6 +697,7 @@ " Facility_ID\n", " Altitude\n", " Zone\n", + " District\n", " Resid\n", " Owner\n", " Facility_Type\n", @@ -670,17 +719,18 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", " 370655.578345\n", - " 298710.995438\n", - " 260619.466056\n", - " 255428.892934\n", - " 253508.982217\n", - " 301084.510508\n", - " 452103.379475\n", - " -317.566395\n", + " 390008.338639\n", + " 385074.053901\n", + " 383551.519335\n", + " 382881.752808\n", + " 453186.019359\n", + " 452178.159027\n", + " 1007.860332\n", " \n", " \n", " 1\n", @@ -689,6 +739,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -697,9 +748,9 @@ " 351108.236956\n", " 352944.118983\n", " 353891.586301\n", - " 448829.801850\n", - " 451249.680342\n", - " -2419.878492\n", + " 448903.391472\n", + " 451324.318689\n", + " -2420.927217\n", " \n", " \n", " 2\n", @@ -708,6 +759,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -716,9 +768,9 @@ " 349493.164255\n", " 344770.234996\n", " 345157.532117\n", - " 450130.102782\n", - " 450397.593235\n", - " -267.490453\n", + " 450203.526071\n", + " 450472.090644\n", + " -268.564573\n", " \n", " \n", " 3\n", @@ -727,6 +779,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -735,9 +788,9 @@ " 375543.857029\n", " 381029.229862\n", " 379415.048009\n", - " 446465.064103\n", - " 449547.115109\n", - " -3082.051006\n", + " 446538.199648\n", + " 449621.471846\n", + " -3083.272198\n", " \n", " \n", " 4\n", @@ -746,6 +799,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -754,9 +808,9 @@ " 385373.062799\n", " 381129.073629\n", " 382864.345741\n", - " 446875.456426\n", - " 448698.242927\n", - " -1822.786501\n", + " 446948.806790\n", + " 448772.459257\n", + " -1823.652467\n", " \n", " \n", " 5\n", @@ -765,6 +819,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -773,9 +828,9 @@ " 285932.285061\n", " 289579.937651\n", " 289345.079079\n", - " 445094.075488\n", - " 447850.973656\n", - " -2756.898168\n", + " 445167.350051\n", + " 447925.049844\n", + " -2757.699793\n", " \n", " \n", " 6\n", @@ -784,6 +839,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -792,9 +848,9 @@ " 455288.388297\n", " 455102.702313\n", " 455034.373344\n", - " 443152.899063\n", - " 447005.304268\n", - " -3852.405205\n", + " 443225.944431\n", + " 447079.240580\n", + " -3853.296150\n", " \n", " \n", " 7\n", @@ -803,6 +859,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -811,9 +868,9 @@ " 324314.368396\n", " 316195.532608\n", " 314871.921748\n", - " 445109.242713\n", - " 446161.231744\n", - " -1051.989032\n", + " 445182.353097\n", + " 446235.028444\n", + " -1052.675347\n", " \n", " \n", " 8\n", @@ -822,6 +879,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -830,9 +888,9 @@ " 345593.426372\n", " 354934.926046\n", " 356543.998012\n", - " 444390.632491\n", - " 445318.753068\n", - " -928.120577\n", + " 444463.766354\n", + " 445392.410418\n", + " -928.644064\n", " \n", " \n", " 9\n", @@ -841,6 +899,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -849,9 +908,9 @@ " 400410.349670\n", " 392246.728746\n", " 391937.348081\n", - " 443363.169753\n", - " 444477.865230\n", - " -1114.695477\n", + " 443436.073774\n", + " 444551.383494\n", + " -1115.309720\n", " \n", " \n", " 10\n", @@ -860,6 +919,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -868,9 +928,9 @@ " 327819.997189\n", " 330789.556355\n", " 329650.101725\n", - " 441484.287781\n", - " 443638.565226\n", - " -2154.277446\n", + " 441556.996446\n", + " 443711.944667\n", + " -2154.948222\n", " \n", " \n", " 11\n", @@ -879,6 +939,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -887,9 +948,9 @@ " 408894.912655\n", " 378604.565588\n", " 379596.718666\n", - " 443252.418520\n", - " 442800.850059\n", - " 451.568461\n", + " 443325.455792\n", + " 442874.090938\n", + " 451.364853\n", " \n", " \n", " 12\n", @@ -898,6 +959,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -906,9 +968,9 @@ " 360367.235995\n", " 389923.203199\n", " 389558.939179\n", - " 440302.572113\n", - " 441964.716734\n", - " -1662.144621\n", + " 440375.155656\n", + " 442037.819314\n", + " -1662.663659\n", " \n", " \n", " 13\n", @@ -917,6 +979,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -925,9 +988,9 @@ " 381170.945543\n", " 378471.104964\n", " 377682.655534\n", - " 441220.746519\n", - " 441130.162266\n", - " 90.584253\n", + " 441294.684850\n", + " 441203.126808\n", + " 91.558042\n", " \n", " \n", " 14\n", @@ -936,6 +999,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -944,9 +1008,9 @@ " 401617.097706\n", " 408341.613660\n", " 409745.578729\n", - " 442599.508715\n", - " 440297.183673\n", - " 2302.325042\n", + " 442671.748454\n", + " 440370.010437\n", + " 2301.738017\n", " \n", " \n", " 15\n", @@ -955,6 +1019,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -963,9 +1028,9 @@ " 340683.245254\n", " 342518.356804\n", " 341977.330400\n", - " 437729.663871\n", - " 439465.777979\n", - " -1736.114108\n", + " 437801.561953\n", + " 439538.467226\n", + " -1736.905273\n", " \n", " \n", " 16\n", @@ -974,6 +1039,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -982,9 +1048,9 @@ " 335947.246630\n", " 335248.047067\n", " 335789.435760\n", - " 435203.049238\n", - " 438635.942214\n", - " -3432.892977\n", + " 435274.468592\n", + " 438708.494203\n", + " -3434.025611\n", " \n", " \n", " 17\n", @@ -993,6 +1059,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -1001,9 +1068,9 @@ " 302510.901036\n", " 300226.263604\n", " 296296.047432\n", - " 436957.723991\n", - " 437807.673415\n", - " -849.949424\n", + " 437029.478846\n", + " 437880.088405\n", + " -850.609558\n", " \n", " \n", " 18\n", @@ -1012,6 +1079,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -1020,9 +1088,9 @@ " 271260.885375\n", " 274124.334082\n", " 278184.608227\n", - " 434305.862192\n", - " 436980.968621\n", - " -2675.106429\n", + " 434377.435798\n", + " 437053.246871\n", + " -2675.811073\n", " \n", " \n", " 19\n", @@ -1031,6 +1099,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -1039,9 +1108,9 @@ " 387974.439450\n", " 387736.897200\n", " 387661.416146\n", - " 434323.547929\n", - " 436155.824879\n", - " -1832.276951\n", + " 434394.568891\n", + " 436227.966648\n", + " -1833.397757\n", " \n", " \n", " 20\n", @@ -1050,6 +1119,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -1058,9 +1128,9 @@ " 362046.586240\n", " 342819.132014\n", " 340516.424995\n", - " 434015.417381\n", - " 435332.239243\n", - " -1316.821862\n", + " 434086.915088\n", + " 435404.244787\n", + " -1317.329699\n", " \n", " \n", " 21\n", @@ -1069,6 +1139,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -1077,9 +1148,9 @@ " 480685.090489\n", " 500151.794189\n", " 502277.800794\n", - " 434856.288139\n", - " 434510.208770\n", - " 346.079370\n", + " 434927.534834\n", + " 434582.078347\n", + " 345.456487\n", " \n", " \n", " 22\n", @@ -1088,6 +1159,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -1096,9 +1168,9 @@ " 449504.867423\n", " 447116.625283\n", " 445805.292269\n", - " 435279.971776\n", - " 433689.730522\n", - " 1590.241254\n", + " 435351.610440\n", + " 433761.464389\n", + " 1590.146050\n", " \n", " \n", " 23\n", @@ -1107,6 +1179,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -1115,9 +1188,9 @@ " 310749.912224\n", " 313141.518581\n", " 313923.715557\n", - " 430636.491081\n", - " 432870.801570\n", - " -2234.310489\n", + " 430707.116763\n", + " 432942.399983\n", + " -2235.283220\n", " \n", " \n", " 24\n", @@ -1126,6 +1199,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -1134,9 +1208,9 @@ " 336295.941280\n", " 330700.546457\n", " 330244.876504\n", - " 430911.874972\n", - " 432053.418987\n", - " -1141.544015\n", + " 430982.665089\n", + " 432124.882203\n", + " -1142.217114\n", " \n", " \n", " 25\n", @@ -1145,6 +1219,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -1153,9 +1228,9 @@ " 435891.016355\n", " 437939.836711\n", " 438231.552425\n", - " 428660.978812\n", - " 431237.579854\n", - " -2576.601042\n", + " 428731.420008\n", + " 431308.908127\n", + " -2577.488119\n", " \n", " \n", " 26\n", @@ -1164,6 +1239,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -1172,9 +1248,9 @@ " 392209.231985\n", " 393915.875687\n", " 393957.931607\n", - " 430121.833314\n", - " 430423.281257\n", - " -301.447942\n", + " 430192.671905\n", + " 430494.474841\n", + " -301.802936\n", " \n", " \n", " 27\n", @@ -1183,6 +1259,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -1191,9 +1268,9 @@ " 335224.704315\n", " 335946.670289\n", " 336884.175544\n", - " 427569.904956\n", - " 429610.520285\n", - " -2040.615329\n", + " 427640.316088\n", + " 429681.579436\n", + " -2041.263348\n", " \n", " \n", " 28\n", @@ -1202,6 +1279,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -1210,9 +1288,9 @@ " 376450.353321\n", " 368811.709372\n", " 365595.615071\n", - " 427736.660883\n", - " 428799.294036\n", - " -1062.633153\n", + " 427806.610028\n", + " 428870.219007\n", + " -1063.608979\n", " \n", " \n", " 29\n", @@ -1221,6 +1299,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -1229,9 +1308,9 @@ " 325974.066284\n", " 334512.344383\n", " 337541.046047\n", - " 425208.288593\n", - " 427989.599612\n", - " -2781.311019\n", + " 425278.010843\n", + " 428060.390657\n", + " -2782.379814\n", " \n", " \n", " 30\n", @@ -1240,6 +1319,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -1248,9 +1328,9 @@ " 333207.967531\n", " 331162.787180\n", " 331449.273326\n", - " 426741.194309\n", - " 427181.434120\n", - " -440.239811\n", + " 426811.173251\n", + " 427252.091491\n", + " -440.918241\n", " \n", " \n", " 31\n", @@ -1259,6 +1339,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -1267,9 +1348,9 @@ " 267520.943494\n", " 269888.025290\n", " 269433.014822\n", - " 425551.827998\n", - " 426374.794674\n", - " -822.966676\n", + " 425621.733459\n", + " 426445.318624\n", + " -823.585164\n", " \n", " \n", " 32\n", @@ -1278,6 +1359,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -1286,9 +1368,9 @@ " 448849.771066\n", " 446651.780946\n", " 445524.032754\n", - " 424893.403624\n", - " 425569.678390\n", - " -676.274766\n", + " 424963.149920\n", + " 425640.069171\n", + " -676.919251\n", " \n", " \n", " 33\n", @@ -1297,6 +1379,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -1305,9 +1388,9 @@ " 291501.477315\n", " 289945.485496\n", " 291038.100935\n", - " 423223.667713\n", - " 424766.082395\n", - " -1542.414682\n", + " 423293.012832\n", + " 424836.340258\n", + " -1543.327426\n", " \n", " \n", " 34\n", @@ -1316,6 +1399,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -1324,9 +1408,9 @@ " 302154.611762\n", " 306083.376401\n", " 305678.254498\n", - " 422131.112511\n", - " 423964.003816\n", - " -1832.891305\n", + " 422200.602069\n", + " 424034.129012\n", + " -1833.526943\n", " \n", " \n", " 35\n", @@ -1335,6 +1419,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -1343,9 +1428,9 @@ " 336866.204386\n", " 331980.842360\n", " 330169.889911\n", - " 421573.506857\n", - " 423163.439788\n", - " -1589.932931\n", + " 421642.817151\n", + " 423233.432568\n", + " -1590.615417\n", " \n", " \n", " 36\n", @@ -1354,6 +1439,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -1362,9 +1448,9 @@ " 322432.738606\n", " 318079.159985\n", " 317973.894415\n", - " 422575.707068\n", - " 422364.387452\n", - " 211.319617\n", + " 422645.018611\n", + " 422434.248066\n", + " 210.770545\n", " \n", " \n", " 37\n", @@ -1373,6 +1459,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -1381,9 +1468,9 @@ " 301954.830856\n", " 310662.088357\n", " 312810.479228\n", - " 420956.703710\n", - " 421566.843952\n", - " -610.140243\n", + " 421026.188284\n", + " 421636.572650\n", + " -610.384366\n", " \n", " \n", " 38\n", @@ -1392,6 +1479,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -1400,9 +1488,9 @@ " 419118.260070\n", " 404772.957169\n", " 405190.542219\n", - " 418934.469956\n", - " 420770.806441\n", - " -1836.336485\n", + " 419003.352104\n", + " 420840.403471\n", + " -1837.051367\n", " \n", " \n", " 39\n", @@ -1411,6 +1499,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -1419,9 +1508,9 @@ " 304945.762400\n", " 319651.502857\n", " 319575.723877\n", - " 419086.943369\n", - " 419976.272074\n", - " -889.328705\n", + " 419156.256610\n", + " 420045.737685\n", + " -889.481075\n", " \n", " \n", " 40\n", @@ -1430,6 +1519,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -1438,9 +1528,9 @@ " 337015.684029\n", " 328940.852077\n", " 329238.343810\n", - " 418729.313756\n", - " 419183.238012\n", - " -453.924256\n", + " 418797.992003\n", + " 419252.572452\n", + " -454.580449\n", " \n", " \n", " 41\n", @@ -1449,6 +1539,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -1457,9 +1548,9 @@ " 365879.087584\n", " 373323.111876\n", " 372541.004296\n", - " 418355.425750\n", - " 418391.701423\n", - " -36.275673\n", + " 418424.138509\n", + " 418460.904941\n", + " -36.766432\n", " \n", " \n", " 42\n", @@ -1468,6 +1559,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -1476,9 +1568,9 @@ " 280888.319603\n", " 281510.797522\n", " 281840.507716\n", - " 417412.937075\n", - " 417601.659480\n", - " -188.722404\n", + " 417481.752292\n", + " 417670.732321\n", + " -188.980029\n", " \n", " \n", " 43\n", @@ -1487,6 +1579,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -1495,9 +1588,9 @@ " 360679.750486\n", " 359521.705424\n", " 359548.833442\n", - " 414765.010421\n", - " 416813.109359\n", - " -2048.098937\n", + " 414833.508183\n", + " 416882.051771\n", + " -2048.543588\n", " \n", " \n", " 44\n", @@ -1506,6 +1599,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -1514,9 +1608,9 @@ " 462306.136722\n", " 461148.128688\n", " 461552.424105\n", - " 415927.049193\n", - " 416026.048243\n", - " -98.999050\n", + " 415995.972386\n", + " 416094.860473\n", + " -98.888087\n", " \n", " \n", " 45\n", @@ -1525,6 +1619,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -1533,27 +1628,27 @@ " 323443.731437\n", " 324834.166014\n", " 323233.055405\n", - " 412876.186407\n", - " 415240.473322\n", - " -2364.286915\n", + " 412944.024703\n", + " 415309.155615\n", + " -2365.130912\n", " \n", " \n", "\n", "
" ] }, - "execution_count": 57, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 57 + "execution_count": 4 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-07T15:20:32.501456Z", - "start_time": "2025-01-07T15:20:32.475207Z" + "end_time": "2025-01-09T11:44:43.904823Z", + "start_time": "2025-01-09T11:44:43.875882Z" } }, "cell_type": "code", @@ -1662,6 +1757,54 @@ "44 Central WestSouth EastNorthernSouth EastNorthe... \n", "45 Central WestSouth EastNorthernSouth EastNorthe... \n", "\n", + " District \\\n", + "0 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "1 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "2 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "3 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "4 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "5 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "6 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "7 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "8 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "9 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "10 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "11 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "12 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "13 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "14 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "15 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "16 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "17 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "18 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "19 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "20 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "21 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "22 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "23 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "24 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "25 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "26 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "27 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "28 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "29 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "30 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "31 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "32 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "33 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "34 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "35 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "36 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "37 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "38 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "39 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "40 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "41 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "42 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "43 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "44 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "45 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "\n", " Resid \\\n", "0 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", "1 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", @@ -1807,7 +1950,7 @@ "45 ClinicDistrict HospitalRural/Community Hospita... 405718.142702 \n", "\n", " Lag_1_Precipitation Lag_2_Precipitation Lag_3_Precipitation \\\n", - "0 298710.995438 260619.466056 255428.892934 \n", + "0 390008.338639 385074.053901 383551.519335 \n", "1 324216.805408 351108.236956 352944.118983 \n", "2 351903.960266 349493.164255 344770.234996 \n", "3 379492.789825 375543.857029 381029.229862 \n", @@ -1855,100 +1998,100 @@ "45 364719.332490 323443.731437 324834.166014 \n", "\n", " Lag_4_Precipitation Predicted_Weather_Model Predicted_No_Weather_Model \\\n", - "0 253508.982217 301084.510508 452103.379475 \n", - "1 353891.586301 448829.801850 451249.680342 \n", - "2 345157.532117 450130.102782 450397.593235 \n", - "3 379415.048009 446465.064103 449547.115109 \n", - "4 382864.345741 446875.456426 448698.242927 \n", - "5 289345.079079 445094.075488 447850.973656 \n", - "6 455034.373344 443152.899063 447005.304268 \n", - "7 314871.921748 445109.242713 446161.231744 \n", - "8 356543.998012 444390.632491 445318.753068 \n", - "9 391937.348081 443363.169753 444477.865230 \n", - "10 329650.101725 441484.287781 443638.565226 \n", - "11 379596.718666 443252.418520 442800.850059 \n", - "12 389558.939179 440302.572113 441964.716734 \n", - "13 377682.655534 441220.746519 441130.162266 \n", - "14 409745.578729 442599.508715 440297.183673 \n", - "15 341977.330400 437729.663871 439465.777979 \n", - "16 335789.435760 435203.049238 438635.942214 \n", - "17 296296.047432 436957.723991 437807.673415 \n", - "18 278184.608227 434305.862192 436980.968621 \n", - "19 387661.416146 434323.547929 436155.824879 \n", - "20 340516.424995 434015.417381 435332.239243 \n", - "21 502277.800794 434856.288139 434510.208770 \n", - "22 445805.292269 435279.971776 433689.730522 \n", - "23 313923.715557 430636.491081 432870.801570 \n", - "24 330244.876504 430911.874972 432053.418987 \n", - "25 438231.552425 428660.978812 431237.579854 \n", - "26 393957.931607 430121.833314 430423.281257 \n", - "27 336884.175544 427569.904956 429610.520285 \n", - "28 365595.615071 427736.660883 428799.294036 \n", - "29 337541.046047 425208.288593 427989.599612 \n", - "30 331449.273326 426741.194309 427181.434120 \n", - "31 269433.014822 425551.827998 426374.794674 \n", - "32 445524.032754 424893.403624 425569.678390 \n", - "33 291038.100935 423223.667713 424766.082395 \n", - "34 305678.254498 422131.112511 423964.003816 \n", - "35 330169.889911 421573.506857 423163.439788 \n", - "36 317973.894415 422575.707068 422364.387452 \n", - "37 312810.479228 420956.703710 421566.843952 \n", - "38 405190.542219 418934.469956 420770.806441 \n", - "39 319575.723877 419086.943369 419976.272074 \n", - "40 329238.343810 418729.313756 419183.238012 \n", - "41 372541.004296 418355.425750 418391.701423 \n", - "42 281840.507716 417412.937075 417601.659480 \n", - "43 359548.833442 414765.010421 416813.109359 \n", - "44 461552.424105 415927.049193 416026.048243 \n", - "45 323233.055405 412876.186407 415240.473322 \n", + "0 382881.752808 453186.019359 452178.159027 \n", + "1 353891.586301 448903.391472 451324.318689 \n", + "2 345157.532117 450203.526071 450472.090644 \n", + "3 379415.048009 446538.199648 449621.471846 \n", + "4 382864.345741 446948.806790 448772.459257 \n", + "5 289345.079079 445167.350051 447925.049844 \n", + "6 455034.373344 443225.944431 447079.240580 \n", + "7 314871.921748 445182.353097 446235.028444 \n", + "8 356543.998012 444463.766354 445392.410418 \n", + "9 391937.348081 443436.073774 444551.383494 \n", + "10 329650.101725 441556.996446 443711.944667 \n", + "11 379596.718666 443325.455792 442874.090938 \n", + "12 389558.939179 440375.155656 442037.819314 \n", + "13 377682.655534 441294.684850 441203.126808 \n", + "14 409745.578729 442671.748454 440370.010437 \n", + "15 341977.330400 437801.561953 439538.467226 \n", + "16 335789.435760 435274.468592 438708.494203 \n", + "17 296296.047432 437029.478846 437880.088405 \n", + "18 278184.608227 434377.435798 437053.246871 \n", + "19 387661.416146 434394.568891 436227.966648 \n", + "20 340516.424995 434086.915088 435404.244787 \n", + "21 502277.800794 434927.534834 434582.078347 \n", + "22 445805.292269 435351.610440 433761.464389 \n", + "23 313923.715557 430707.116763 432942.399983 \n", + "24 330244.876504 430982.665089 432124.882203 \n", + "25 438231.552425 428731.420008 431308.908127 \n", + "26 393957.931607 430192.671905 430494.474841 \n", + "27 336884.175544 427640.316088 429681.579436 \n", + "28 365595.615071 427806.610028 428870.219007 \n", + "29 337541.046047 425278.010843 428060.390657 \n", + "30 331449.273326 426811.173251 427252.091491 \n", + "31 269433.014822 425621.733459 426445.318624 \n", + "32 445524.032754 424963.149920 425640.069171 \n", + "33 291038.100935 423293.012832 424836.340258 \n", + "34 305678.254498 422200.602069 424034.129012 \n", + "35 330169.889911 421642.817151 423233.432568 \n", + "36 317973.894415 422645.018611 422434.248066 \n", + "37 312810.479228 421026.188284 421636.572650 \n", + "38 405190.542219 419003.352104 420840.403471 \n", + "39 319575.723877 419156.256610 420045.737685 \n", + "40 329238.343810 418797.992003 419252.572452 \n", + "41 372541.004296 418424.138509 418460.904941 \n", + "42 281840.507716 417481.752292 417670.732321 \n", + "43 359548.833442 414833.508183 416882.051771 \n", + "44 461552.424105 415995.972386 416094.860473 \n", + "45 323233.055405 412944.024703 415309.155615 \n", "\n", " Difference_in_Expectation Percentage_Difference \n", - "0 -317.566395 -0.000702 \n", - "1 -2419.878492 -0.005363 \n", - "2 -267.490453 -0.000594 \n", - "3 -3082.051006 -0.006856 \n", - "4 -1822.786501 -0.004062 \n", - "5 -2756.898168 -0.006156 \n", - "6 -3852.405205 -0.008618 \n", - "7 -1051.989032 -0.002358 \n", - "8 -928.120577 -0.002084 \n", - "9 -1114.695477 -0.002508 \n", - "10 -2154.277446 -0.004856 \n", - "11 451.568461 0.001020 \n", - "12 -1662.144621 -0.003761 \n", - "13 90.584253 0.000205 \n", - "14 2302.325042 0.005229 \n", - "15 -1736.114108 -0.003951 \n", - "16 -3432.892977 -0.007826 \n", - "17 -849.949424 -0.001941 \n", - "18 -2675.106429 -0.006122 \n", - "19 -1832.276951 -0.004201 \n", - "20 -1316.821862 -0.003025 \n", - "21 346.079370 0.000796 \n", - "22 1590.241254 0.003667 \n", - "23 -2234.310489 -0.005162 \n", - "24 -1141.544015 -0.002642 \n", - "25 -2576.601042 -0.005975 \n", - "26 -301.447942 -0.000700 \n", - "27 -2040.615329 -0.004750 \n", - "28 -1062.633153 -0.002478 \n", - "29 -2781.311019 -0.006499 \n", - "30 -440.239811 -0.001031 \n", - "31 -822.966676 -0.001930 \n", - "32 -676.274766 -0.001589 \n", - "33 -1542.414682 -0.003631 \n", - "34 -1832.891305 -0.004323 \n", - "35 -1589.932931 -0.003757 \n", - "36 211.319617 0.000500 \n", - "37 -610.140243 -0.001447 \n", - "38 -1836.336485 -0.004364 \n", - "39 -889.328705 -0.002118 \n", - "40 -453.924256 -0.001083 \n", - "41 -36.275673 -0.000087 \n", - "42 -188.722404 -0.000452 \n", - "43 -2048.098937 -0.004914 \n", - "44 -98.999050 -0.000238 \n", - "45 -2364.286915 -0.005694 " + "0 1007.860332 0.002229 \n", + "1 -2420.927217 -0.005364 \n", + "2 -268.564573 -0.000596 \n", + "3 -3083.272198 -0.006857 \n", + "4 -1823.652467 -0.004064 \n", + "5 -2757.699793 -0.006157 \n", + "6 -3853.296150 -0.008619 \n", + "7 -1052.675347 -0.002359 \n", + "8 -928.644064 -0.002085 \n", + "9 -1115.309720 -0.002509 \n", + "10 -2154.948222 -0.004857 \n", + "11 451.364853 0.001019 \n", + "12 -1662.663659 -0.003761 \n", + "13 91.558042 0.000208 \n", + "14 2301.738017 0.005227 \n", + "15 -1736.905273 -0.003952 \n", + "16 -3434.025611 -0.007828 \n", + "17 -850.609558 -0.001943 \n", + "18 -2675.811073 -0.006122 \n", + "19 -1833.397757 -0.004203 \n", + "20 -1317.329699 -0.003026 \n", + "21 345.456487 0.000795 \n", + "22 1590.146050 0.003666 \n", + "23 -2235.283220 -0.005163 \n", + "24 -1142.217114 -0.002643 \n", + "25 -2577.488119 -0.005976 \n", + "26 -301.802936 -0.000701 \n", + "27 -2041.263348 -0.004751 \n", + "28 -1063.608979 -0.002480 \n", + "29 -2782.379814 -0.006500 \n", + "30 -440.918241 -0.001032 \n", + "31 -823.585164 -0.001931 \n", + "32 -676.919251 -0.001590 \n", + "33 -1543.327426 -0.003633 \n", + "34 -1833.526943 -0.004324 \n", + "35 -1590.615417 -0.003758 \n", + "36 210.770545 0.000499 \n", + "37 -610.384366 -0.001448 \n", + "38 -1837.051367 -0.004365 \n", + "39 -889.481075 -0.002118 \n", + "40 -454.580449 -0.001084 \n", + "41 -36.766432 -0.000088 \n", + "42 -188.980029 -0.000452 \n", + "43 -2048.543588 -0.004914 \n", + "44 -98.888087 -0.000238 \n", + "45 -2365.130912 -0.005695 " ], "text/html": [ "
\n", @@ -1974,6 +2117,7 @@ " Facility_ID\n", " Altitude\n", " Zone\n", + " District\n", " Resid\n", " Owner\n", " Facility_Type\n", @@ -1996,18 +2140,19 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", " 370655.578345\n", - " 298710.995438\n", - " 260619.466056\n", - " 255428.892934\n", - " 253508.982217\n", - " 301084.510508\n", - " 452103.379475\n", - " -317.566395\n", - " -0.000702\n", + " 390008.338639\n", + " 385074.053901\n", + " 383551.519335\n", + " 382881.752808\n", + " 453186.019359\n", + " 452178.159027\n", + " 1007.860332\n", + " 0.002229\n", " \n", " \n", " 1\n", @@ -2016,6 +2161,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2024,10 +2170,10 @@ " 351108.236956\n", " 352944.118983\n", " 353891.586301\n", - " 448829.801850\n", - " 451249.680342\n", - " -2419.878492\n", - " -0.005363\n", + " 448903.391472\n", + " 451324.318689\n", + " -2420.927217\n", + " -0.005364\n", " \n", " \n", " 2\n", @@ -2036,6 +2182,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2044,10 +2191,10 @@ " 349493.164255\n", " 344770.234996\n", " 345157.532117\n", - " 450130.102782\n", - " 450397.593235\n", - " -267.490453\n", - " -0.000594\n", + " 450203.526071\n", + " 450472.090644\n", + " -268.564573\n", + " -0.000596\n", " \n", " \n", " 3\n", @@ -2056,6 +2203,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2064,10 +2212,10 @@ " 375543.857029\n", " 381029.229862\n", " 379415.048009\n", - " 446465.064103\n", - " 449547.115109\n", - " -3082.051006\n", - " -0.006856\n", + " 446538.199648\n", + " 449621.471846\n", + " -3083.272198\n", + " -0.006857\n", " \n", " \n", " 4\n", @@ -2076,6 +2224,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2084,10 +2233,10 @@ " 385373.062799\n", " 381129.073629\n", " 382864.345741\n", - " 446875.456426\n", - " 448698.242927\n", - " -1822.786501\n", - " -0.004062\n", + " 446948.806790\n", + " 448772.459257\n", + " -1823.652467\n", + " -0.004064\n", " \n", " \n", " 5\n", @@ -2096,6 +2245,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2104,10 +2254,10 @@ " 285932.285061\n", " 289579.937651\n", " 289345.079079\n", - " 445094.075488\n", - " 447850.973656\n", - " -2756.898168\n", - " -0.006156\n", + " 445167.350051\n", + " 447925.049844\n", + " -2757.699793\n", + " -0.006157\n", " \n", " \n", " 6\n", @@ -2116,6 +2266,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2124,10 +2275,10 @@ " 455288.388297\n", " 455102.702313\n", " 455034.373344\n", - " 443152.899063\n", - " 447005.304268\n", - " -3852.405205\n", - " -0.008618\n", + " 443225.944431\n", + " 447079.240580\n", + " -3853.296150\n", + " -0.008619\n", " \n", " \n", " 7\n", @@ -2136,6 +2287,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2144,10 +2296,10 @@ " 324314.368396\n", " 316195.532608\n", " 314871.921748\n", - " 445109.242713\n", - " 446161.231744\n", - " -1051.989032\n", - " -0.002358\n", + " 445182.353097\n", + " 446235.028444\n", + " -1052.675347\n", + " -0.002359\n", " \n", " \n", " 8\n", @@ -2156,6 +2308,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2164,10 +2317,10 @@ " 345593.426372\n", " 354934.926046\n", " 356543.998012\n", - " 444390.632491\n", - " 445318.753068\n", - " -928.120577\n", - " -0.002084\n", + " 444463.766354\n", + " 445392.410418\n", + " -928.644064\n", + " -0.002085\n", " \n", " \n", " 9\n", @@ -2176,6 +2329,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2184,10 +2338,10 @@ " 400410.349670\n", " 392246.728746\n", " 391937.348081\n", - " 443363.169753\n", - " 444477.865230\n", - " -1114.695477\n", - " -0.002508\n", + " 443436.073774\n", + " 444551.383494\n", + " -1115.309720\n", + " -0.002509\n", " \n", " \n", " 10\n", @@ -2196,6 +2350,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2204,10 +2359,10 @@ " 327819.997189\n", " 330789.556355\n", " 329650.101725\n", - " 441484.287781\n", - " 443638.565226\n", - " -2154.277446\n", - " -0.004856\n", + " 441556.996446\n", + " 443711.944667\n", + " -2154.948222\n", + " -0.004857\n", " \n", " \n", " 11\n", @@ -2216,6 +2371,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2224,10 +2380,10 @@ " 408894.912655\n", " 378604.565588\n", " 379596.718666\n", - " 443252.418520\n", - " 442800.850059\n", - " 451.568461\n", - " 0.001020\n", + " 443325.455792\n", + " 442874.090938\n", + " 451.364853\n", + " 0.001019\n", " \n", " \n", " 12\n", @@ -2236,6 +2392,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2244,9 +2401,9 @@ " 360367.235995\n", " 389923.203199\n", " 389558.939179\n", - " 440302.572113\n", - " 441964.716734\n", - " -1662.144621\n", + " 440375.155656\n", + " 442037.819314\n", + " -1662.663659\n", " -0.003761\n", " \n", " \n", @@ -2256,6 +2413,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2264,10 +2422,10 @@ " 381170.945543\n", " 378471.104964\n", " 377682.655534\n", - " 441220.746519\n", - " 441130.162266\n", - " 90.584253\n", - " 0.000205\n", + " 441294.684850\n", + " 441203.126808\n", + " 91.558042\n", + " 0.000208\n", " \n", " \n", " 14\n", @@ -2276,6 +2434,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2284,10 +2443,10 @@ " 401617.097706\n", " 408341.613660\n", " 409745.578729\n", - " 442599.508715\n", - " 440297.183673\n", - " 2302.325042\n", - " 0.005229\n", + " 442671.748454\n", + " 440370.010437\n", + " 2301.738017\n", + " 0.005227\n", " \n", " \n", " 15\n", @@ -2296,6 +2455,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2304,10 +2464,10 @@ " 340683.245254\n", " 342518.356804\n", " 341977.330400\n", - " 437729.663871\n", - " 439465.777979\n", - " -1736.114108\n", - " -0.003951\n", + " 437801.561953\n", + " 439538.467226\n", + " -1736.905273\n", + " -0.003952\n", " \n", " \n", " 16\n", @@ -2316,6 +2476,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2324,10 +2485,10 @@ " 335947.246630\n", " 335248.047067\n", " 335789.435760\n", - " 435203.049238\n", - " 438635.942214\n", - " -3432.892977\n", - " -0.007826\n", + " 435274.468592\n", + " 438708.494203\n", + " -3434.025611\n", + " -0.007828\n", " \n", " \n", " 17\n", @@ -2336,6 +2497,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2344,10 +2506,10 @@ " 302510.901036\n", " 300226.263604\n", " 296296.047432\n", - " 436957.723991\n", - " 437807.673415\n", - " -849.949424\n", - " -0.001941\n", + " 437029.478846\n", + " 437880.088405\n", + " -850.609558\n", + " -0.001943\n", " \n", " \n", " 18\n", @@ -2356,6 +2518,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2364,9 +2527,9 @@ " 271260.885375\n", " 274124.334082\n", " 278184.608227\n", - " 434305.862192\n", - " 436980.968621\n", - " -2675.106429\n", + " 434377.435798\n", + " 437053.246871\n", + " -2675.811073\n", " -0.006122\n", " \n", " \n", @@ -2376,6 +2539,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2384,10 +2548,10 @@ " 387974.439450\n", " 387736.897200\n", " 387661.416146\n", - " 434323.547929\n", - " 436155.824879\n", - " -1832.276951\n", - " -0.004201\n", + " 434394.568891\n", + " 436227.966648\n", + " -1833.397757\n", + " -0.004203\n", " \n", " \n", " 20\n", @@ -2396,6 +2560,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2404,10 +2569,10 @@ " 362046.586240\n", " 342819.132014\n", " 340516.424995\n", - " 434015.417381\n", - " 435332.239243\n", - " -1316.821862\n", - " -0.003025\n", + " 434086.915088\n", + " 435404.244787\n", + " -1317.329699\n", + " -0.003026\n", " \n", " \n", " 21\n", @@ -2416,6 +2581,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2424,10 +2590,10 @@ " 480685.090489\n", " 500151.794189\n", " 502277.800794\n", - " 434856.288139\n", - " 434510.208770\n", - " 346.079370\n", - " 0.000796\n", + " 434927.534834\n", + " 434582.078347\n", + " 345.456487\n", + " 0.000795\n", " \n", " \n", " 22\n", @@ -2436,6 +2602,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2444,10 +2611,10 @@ " 449504.867423\n", " 447116.625283\n", " 445805.292269\n", - " 435279.971776\n", - " 433689.730522\n", - " 1590.241254\n", - " 0.003667\n", + " 435351.610440\n", + " 433761.464389\n", + " 1590.146050\n", + " 0.003666\n", " \n", " \n", " 23\n", @@ -2456,6 +2623,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2464,10 +2632,10 @@ " 310749.912224\n", " 313141.518581\n", " 313923.715557\n", - " 430636.491081\n", - " 432870.801570\n", - " -2234.310489\n", - " -0.005162\n", + " 430707.116763\n", + " 432942.399983\n", + " -2235.283220\n", + " -0.005163\n", " \n", " \n", " 24\n", @@ -2476,6 +2644,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2484,10 +2653,10 @@ " 336295.941280\n", " 330700.546457\n", " 330244.876504\n", - " 430911.874972\n", - " 432053.418987\n", - " -1141.544015\n", - " -0.002642\n", + " 430982.665089\n", + " 432124.882203\n", + " -1142.217114\n", + " -0.002643\n", " \n", " \n", " 25\n", @@ -2496,6 +2665,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2504,10 +2674,10 @@ " 435891.016355\n", " 437939.836711\n", " 438231.552425\n", - " 428660.978812\n", - " 431237.579854\n", - " -2576.601042\n", - " -0.005975\n", + " 428731.420008\n", + " 431308.908127\n", + " -2577.488119\n", + " -0.005976\n", " \n", " \n", " 26\n", @@ -2516,6 +2686,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2524,10 +2695,10 @@ " 392209.231985\n", " 393915.875687\n", " 393957.931607\n", - " 430121.833314\n", - " 430423.281257\n", - " -301.447942\n", - " -0.000700\n", + " 430192.671905\n", + " 430494.474841\n", + " -301.802936\n", + " -0.000701\n", " \n", " \n", " 27\n", @@ -2536,6 +2707,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2544,10 +2716,10 @@ " 335224.704315\n", " 335946.670289\n", " 336884.175544\n", - " 427569.904956\n", - " 429610.520285\n", - " -2040.615329\n", - " -0.004750\n", + " 427640.316088\n", + " 429681.579436\n", + " -2041.263348\n", + " -0.004751\n", " \n", " \n", " 28\n", @@ -2556,6 +2728,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2564,10 +2737,10 @@ " 376450.353321\n", " 368811.709372\n", " 365595.615071\n", - " 427736.660883\n", - " 428799.294036\n", - " -1062.633153\n", - " -0.002478\n", + " 427806.610028\n", + " 428870.219007\n", + " -1063.608979\n", + " -0.002480\n", " \n", " \n", " 29\n", @@ -2576,6 +2749,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2584,10 +2758,10 @@ " 325974.066284\n", " 334512.344383\n", " 337541.046047\n", - " 425208.288593\n", - " 427989.599612\n", - " -2781.311019\n", - " -0.006499\n", + " 425278.010843\n", + " 428060.390657\n", + " -2782.379814\n", + " -0.006500\n", " \n", " \n", " 30\n", @@ -2596,6 +2770,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2604,10 +2779,10 @@ " 333207.967531\n", " 331162.787180\n", " 331449.273326\n", - " 426741.194309\n", - " 427181.434120\n", - " -440.239811\n", - " -0.001031\n", + " 426811.173251\n", + " 427252.091491\n", + " -440.918241\n", + " -0.001032\n", " \n", " \n", " 31\n", @@ -2616,6 +2791,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2624,10 +2800,10 @@ " 267520.943494\n", " 269888.025290\n", " 269433.014822\n", - " 425551.827998\n", - " 426374.794674\n", - " -822.966676\n", - " -0.001930\n", + " 425621.733459\n", + " 426445.318624\n", + " -823.585164\n", + " -0.001931\n", " \n", " \n", " 32\n", @@ -2636,6 +2812,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2644,10 +2821,10 @@ " 448849.771066\n", " 446651.780946\n", " 445524.032754\n", - " 424893.403624\n", - " 425569.678390\n", - " -676.274766\n", - " -0.001589\n", + " 424963.149920\n", + " 425640.069171\n", + " -676.919251\n", + " -0.001590\n", " \n", " \n", " 33\n", @@ -2656,6 +2833,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2664,10 +2842,10 @@ " 291501.477315\n", " 289945.485496\n", " 291038.100935\n", - " 423223.667713\n", - " 424766.082395\n", - " -1542.414682\n", - " -0.003631\n", + " 423293.012832\n", + " 424836.340258\n", + " -1543.327426\n", + " -0.003633\n", " \n", " \n", " 34\n", @@ -2676,6 +2854,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2684,10 +2863,10 @@ " 302154.611762\n", " 306083.376401\n", " 305678.254498\n", - " 422131.112511\n", - " 423964.003816\n", - " -1832.891305\n", - " -0.004323\n", + " 422200.602069\n", + " 424034.129012\n", + " -1833.526943\n", + " -0.004324\n", " \n", " \n", " 35\n", @@ -2696,6 +2875,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2704,10 +2884,10 @@ " 336866.204386\n", " 331980.842360\n", " 330169.889911\n", - " 421573.506857\n", - " 423163.439788\n", - " -1589.932931\n", - " -0.003757\n", + " 421642.817151\n", + " 423233.432568\n", + " -1590.615417\n", + " -0.003758\n", " \n", " \n", " 36\n", @@ -2716,6 +2896,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2724,10 +2905,10 @@ " 322432.738606\n", " 318079.159985\n", " 317973.894415\n", - " 422575.707068\n", - " 422364.387452\n", - " 211.319617\n", - " 0.000500\n", + " 422645.018611\n", + " 422434.248066\n", + " 210.770545\n", + " 0.000499\n", " \n", " \n", " 37\n", @@ -2736,6 +2917,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2744,10 +2926,10 @@ " 301954.830856\n", " 310662.088357\n", " 312810.479228\n", - " 420956.703710\n", - " 421566.843952\n", - " -610.140243\n", - " -0.001447\n", + " 421026.188284\n", + " 421636.572650\n", + " -610.384366\n", + " -0.001448\n", " \n", " \n", " 38\n", @@ -2756,6 +2938,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2764,10 +2947,10 @@ " 419118.260070\n", " 404772.957169\n", " 405190.542219\n", - " 418934.469956\n", - " 420770.806441\n", - " -1836.336485\n", - " -0.004364\n", + " 419003.352104\n", + " 420840.403471\n", + " -1837.051367\n", + " -0.004365\n", " \n", " \n", " 39\n", @@ -2776,6 +2959,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2784,9 +2968,9 @@ " 304945.762400\n", " 319651.502857\n", " 319575.723877\n", - " 419086.943369\n", - " 419976.272074\n", - " -889.328705\n", + " 419156.256610\n", + " 420045.737685\n", + " -889.481075\n", " -0.002118\n", " \n", " \n", @@ -2796,6 +2980,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2804,10 +2989,10 @@ " 337015.684029\n", " 328940.852077\n", " 329238.343810\n", - " 418729.313756\n", - " 419183.238012\n", - " -453.924256\n", - " -0.001083\n", + " 418797.992003\n", + " 419252.572452\n", + " -454.580449\n", + " -0.001084\n", " \n", " \n", " 41\n", @@ -2816,6 +3001,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2824,10 +3010,10 @@ " 365879.087584\n", " 373323.111876\n", " 372541.004296\n", - " 418355.425750\n", - " 418391.701423\n", - " -36.275673\n", - " -0.000087\n", + " 418424.138509\n", + " 418460.904941\n", + " -36.766432\n", + " -0.000088\n", " \n", " \n", " 42\n", @@ -2836,6 +3022,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2844,9 +3031,9 @@ " 280888.319603\n", " 281510.797522\n", " 281840.507716\n", - " 417412.937075\n", - " 417601.659480\n", - " -188.722404\n", + " 417481.752292\n", + " 417670.732321\n", + " -188.980029\n", " -0.000452\n", " \n", " \n", @@ -2856,6 +3043,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2864,9 +3052,9 @@ " 360679.750486\n", " 359521.705424\n", " 359548.833442\n", - " 414765.010421\n", - " 416813.109359\n", - " -2048.098937\n", + " 414833.508183\n", + " 416882.051771\n", + " -2048.543588\n", " -0.004914\n", " \n", " \n", @@ -2876,6 +3064,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2884,9 +3073,9 @@ " 462306.136722\n", " 461148.128688\n", " 461552.424105\n", - " 415927.049193\n", - " 416026.048243\n", - " -98.999050\n", + " 415995.972386\n", + " 416094.860473\n", + " -98.888087\n", " -0.000238\n", " \n", " \n", @@ -2896,6 +3085,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -2904,28 +3094,28 @@ " 323443.731437\n", " 324834.166014\n", " 323233.055405\n", - " 412876.186407\n", - " 415240.473322\n", - " -2364.286915\n", - " -0.005694\n", + " 412944.024703\n", + " 415309.155615\n", + " -2365.130912\n", + " -0.005695\n", " \n", " \n", "\n", "
" ] }, - "execution_count": 58, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 58 + "execution_count": 5 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-07T15:20:35.922798Z", - "start_time": "2025-01-07T15:20:33.592575Z" + "end_time": "2025-01-09T11:44:47.118081Z", + "start_time": "2025-01-09T11:44:44.949435Z" } }, "cell_type": "code", @@ -2939,19 +3129,19 @@ "data": { "text/plain": [ " 0 1 2 3 4 5 6 7 8 9 \\\n", - "0 278.839565 104.469566 2025.0 1.0 1.0 1.0 0.0 0.0 0.0 1.0 \n", - "1 314.940604 105.141358 2025.0 2.0 1.0 0.0 0.0 1.0 0.0 1.0 \n", + "0 278.839565 104.469566 2025.0 1.0 1.0 1.0 0.0 0.0 0.0 0.0 \n", + "1 314.940604 105.141358 2025.0 2.0 1.0 0.0 0.0 1.0 0.0 0.0 \n", "2 243.284699 75.971366 2025.0 3.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", "3 376.344881 171.678366 2025.0 4.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", "4 310.515664 76.252856 2025.0 5.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", "... ... ... ... ... ... ... ... ... ... ... \n", - "181051 328.073671 113.592252 2070.0 8.0 0.0 0.0 1.0 0.0 0.0 1.0 \n", + "181051 328.073671 113.592252 2070.0 8.0 0.0 0.0 1.0 0.0 0.0 0.0 \n", "181052 272.709461 99.514648 2070.0 9.0 0.0 0.0 0.0 1.0 0.0 0.0 \n", "181053 272.709461 99.514648 2070.0 10.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", - "181054 272.737490 79.155316 2070.0 11.0 0.0 0.0 1.0 0.0 0.0 1.0 \n", - "181055 175.643851 76.903689 2070.0 12.0 0.0 0.0 0.0 0.0 0.0 1.0 \n", + "181054 272.737490 79.155316 2070.0 11.0 0.0 0.0 1.0 0.0 0.0 0.0 \n", + "181055 175.643851 76.903689 2070.0 12.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", "\n", - " ... 344 345 346 347 348 349 350 351 352 353 \n", + " ... 371 372 373 374 375 376 377 378 379 380 \n", "0 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 1099.0 0.084097 \n", "1 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 632.0 0.089463 \n", "2 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 873.0 NaN \n", @@ -2964,7 +3154,7 @@ "181054 ... 0.0 0.0 0.0 0.0 0.0 0.0 1.0 0.0 1149.0 0.233156 \n", "181055 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 1.0 873.0 0.098121 \n", "\n", - "[181056 rows x 354 columns]" + "[181056 rows x 381 columns]" ], "text/html": [ "
\n", @@ -2996,16 +3186,16 @@ " 8\n", " 9\n", " ...\n", - " 344\n", - " 345\n", - " 346\n", - " 347\n", - " 348\n", - " 349\n", - " 350\n", - " 351\n", - " 352\n", - " 353\n", + " 371\n", + " 372\n", + " 373\n", + " 374\n", + " 375\n", + " 376\n", + " 377\n", + " 378\n", + " 379\n", + " 380\n", " \n", " \n", " \n", @@ -3020,7 +3210,7 @@ " 0.0\n", " 0.0\n", " 0.0\n", - " 1.0\n", + " 0.0\n", " ...\n", " 0.0\n", " 0.0\n", @@ -3044,7 +3234,7 @@ " 0.0\n", " 1.0\n", " 0.0\n", - " 1.0\n", + " 0.0\n", " ...\n", " 0.0\n", " 0.0\n", @@ -3164,7 +3354,7 @@ " 1.0\n", " 0.0\n", " 0.0\n", - " 1.0\n", + " 0.0\n", " ...\n", " 0.0\n", " 0.0\n", @@ -3236,7 +3426,7 @@ " 1.0\n", " 0.0\n", " 0.0\n", - " 1.0\n", + " 0.0\n", " ...\n", " 0.0\n", " 0.0\n", @@ -3260,7 +3450,7 @@ " 0.0\n", " 0.0\n", " 0.0\n", - " 1.0\n", + " 0.0\n", " ...\n", " 0.0\n", " 0.0\n", @@ -3275,22 +3465,22 @@ " \n", " \n", "\n", - "

181056 rows × 354 columns

\n", + "

181056 rows × 381 columns

\n", "
" ] }, - "execution_count": 59, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 59 + "execution_count": 6 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-07T15:20:39.426328Z", - "start_time": "2025-01-07T15:20:39.421298Z" + "end_time": "2025-01-09T11:44:47.122067Z", + "start_time": "2025-01-09T11:44:47.119725Z" } }, "cell_type": "code", @@ -3305,13 +3495,13 @@ ], "id": "fd6b107fed0933cb", "outputs": [], - "execution_count": 60 + "execution_count": 7 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-07T15:20:40.500895Z", - "start_time": "2025-01-07T15:20:40.462242Z" + "end_time": "2025-01-09T11:44:47.146371Z", + "start_time": "2025-01-09T11:44:47.122652Z" } }, "cell_type": "code", @@ -3417,6 +3607,54 @@ "44 Central WestSouth EastNorthernSouth EastNorthe... \n", "45 Central WestSouth EastNorthernSouth EastNorthe... \n", "\n", + " District \\\n", + "0 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "1 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "2 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "3 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "4 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "5 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "6 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "7 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "8 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "9 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "10 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "11 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "12 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "13 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "14 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "15 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "16 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "17 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "18 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "19 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "20 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "21 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "22 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "23 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "24 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "25 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "26 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "27 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "28 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "29 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "30 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "31 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "32 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "33 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "34 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "35 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "36 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "37 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "38 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "39 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "40 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "41 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "42 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "43 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "44 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "45 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", + "\n", " Resid \\\n", "0 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", "1 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", @@ -3562,7 +3800,7 @@ "45 ClinicDistrict HospitalRural/Community Hospita... 405718.142702 \n", "\n", " Lag_1_Precipitation Lag_2_Precipitation Lag_3_Precipitation \\\n", - "0 298710.995438 260619.466056 255428.892934 \n", + "0 390008.338639 385074.053901 383551.519335 \n", "1 324216.805408 351108.236956 352944.118983 \n", "2 351903.960266 349493.164255 344770.234996 \n", "3 379492.789825 375543.857029 381029.229862 \n", @@ -3610,100 +3848,100 @@ "45 364719.332490 323443.731437 324834.166014 \n", "\n", " Lag_4_Precipitation Predicted_Weather_Model Predicted_No_Weather_Model \\\n", - "0 253508.982217 301084.510508 452103.379475 \n", - "1 353891.586301 448829.801850 451249.680342 \n", - "2 345157.532117 450130.102782 450397.593235 \n", - "3 379415.048009 446465.064103 449547.115109 \n", - "4 382864.345741 446875.456426 448698.242927 \n", - "5 289345.079079 445094.075488 447850.973656 \n", - "6 455034.373344 443152.899063 447005.304268 \n", - "7 314871.921748 445109.242713 446161.231744 \n", - "8 356543.998012 444390.632491 445318.753068 \n", - "9 391937.348081 443363.169753 444477.865230 \n", - "10 329650.101725 441484.287781 443638.565226 \n", - "11 379596.718666 443252.418520 442800.850059 \n", - "12 389558.939179 440302.572113 441964.716734 \n", - "13 377682.655534 441220.746519 441130.162266 \n", - "14 409745.578729 442599.508715 440297.183673 \n", - "15 341977.330400 437729.663871 439465.777979 \n", - "16 335789.435760 435203.049238 438635.942214 \n", - "17 296296.047432 436957.723991 437807.673415 \n", - "18 278184.608227 434305.862192 436980.968621 \n", - "19 387661.416146 434323.547929 436155.824879 \n", - "20 340516.424995 434015.417381 435332.239243 \n", - "21 502277.800794 434856.288139 434510.208770 \n", - "22 445805.292269 435279.971776 433689.730522 \n", - "23 313923.715557 430636.491081 432870.801570 \n", - "24 330244.876504 430911.874972 432053.418987 \n", - "25 438231.552425 428660.978812 431237.579854 \n", - "26 393957.931607 430121.833314 430423.281257 \n", - "27 336884.175544 427569.904956 429610.520285 \n", - "28 365595.615071 427736.660883 428799.294036 \n", - "29 337541.046047 425208.288593 427989.599612 \n", - "30 331449.273326 426741.194309 427181.434120 \n", - "31 269433.014822 425551.827998 426374.794674 \n", - "32 445524.032754 424893.403624 425569.678390 \n", - "33 291038.100935 423223.667713 424766.082395 \n", - "34 305678.254498 422131.112511 423964.003816 \n", - "35 330169.889911 421573.506857 423163.439788 \n", - "36 317973.894415 422575.707068 422364.387452 \n", - "37 312810.479228 420956.703710 421566.843952 \n", - "38 405190.542219 418934.469956 420770.806441 \n", - "39 319575.723877 419086.943369 419976.272074 \n", - "40 329238.343810 418729.313756 419183.238012 \n", - "41 372541.004296 418355.425750 418391.701423 \n", - "42 281840.507716 417412.937075 417601.659480 \n", - "43 359548.833442 414765.010421 416813.109359 \n", - "44 461552.424105 415927.049193 416026.048243 \n", - "45 323233.055405 412876.186407 415240.473322 \n", + "0 382881.752808 453186.019359 452178.159027 \n", + "1 353891.586301 448903.391472 451324.318689 \n", + "2 345157.532117 450203.526071 450472.090644 \n", + "3 379415.048009 446538.199648 449621.471846 \n", + "4 382864.345741 446948.806790 448772.459257 \n", + "5 289345.079079 445167.350051 447925.049844 \n", + "6 455034.373344 443225.944431 447079.240580 \n", + "7 314871.921748 445182.353097 446235.028444 \n", + "8 356543.998012 444463.766354 445392.410418 \n", + "9 391937.348081 443436.073774 444551.383494 \n", + "10 329650.101725 441556.996446 443711.944667 \n", + "11 379596.718666 443325.455792 442874.090938 \n", + "12 389558.939179 440375.155656 442037.819314 \n", + "13 377682.655534 441294.684850 441203.126808 \n", + "14 409745.578729 442671.748454 440370.010437 \n", + "15 341977.330400 437801.561953 439538.467226 \n", + "16 335789.435760 435274.468592 438708.494203 \n", + "17 296296.047432 437029.478846 437880.088405 \n", + "18 278184.608227 434377.435798 437053.246871 \n", + "19 387661.416146 434394.568891 436227.966648 \n", + "20 340516.424995 434086.915088 435404.244787 \n", + "21 502277.800794 434927.534834 434582.078347 \n", + "22 445805.292269 435351.610440 433761.464389 \n", + "23 313923.715557 430707.116763 432942.399983 \n", + "24 330244.876504 430982.665089 432124.882203 \n", + "25 438231.552425 428731.420008 431308.908127 \n", + "26 393957.931607 430192.671905 430494.474841 \n", + "27 336884.175544 427640.316088 429681.579436 \n", + "28 365595.615071 427806.610028 428870.219007 \n", + "29 337541.046047 425278.010843 428060.390657 \n", + "30 331449.273326 426811.173251 427252.091491 \n", + "31 269433.014822 425621.733459 426445.318624 \n", + "32 445524.032754 424963.149920 425640.069171 \n", + "33 291038.100935 423293.012832 424836.340258 \n", + "34 305678.254498 422200.602069 424034.129012 \n", + "35 330169.889911 421642.817151 423233.432568 \n", + "36 317973.894415 422645.018611 422434.248066 \n", + "37 312810.479228 421026.188284 421636.572650 \n", + "38 405190.542219 419003.352104 420840.403471 \n", + "39 319575.723877 419156.256610 420045.737685 \n", + "40 329238.343810 418797.992003 419252.572452 \n", + "41 372541.004296 418424.138509 418460.904941 \n", + "42 281840.507716 417481.752292 417670.732321 \n", + "43 359548.833442 414833.508183 416882.051771 \n", + "44 461552.424105 415995.972386 416094.860473 \n", + "45 323233.055405 412944.024703 415309.155615 \n", "\n", " Difference_in_Expectation Percentage_Difference \n", - "0 -317.566395 -0.000702 \n", - "1 -2419.878492 -0.005363 \n", - "2 -267.490453 -0.000594 \n", - "3 -3082.051006 -0.006856 \n", - "4 -1822.786501 -0.004062 \n", - "5 -2756.898168 -0.006156 \n", - "6 -3852.405205 -0.008618 \n", - "7 -1051.989032 -0.002358 \n", - "8 -928.120577 -0.002084 \n", - "9 -1114.695477 -0.002508 \n", - "10 -2154.277446 -0.004856 \n", - "11 451.568461 0.001020 \n", - "12 -1662.144621 -0.003761 \n", - "13 90.584253 0.000205 \n", - "14 2302.325042 0.005229 \n", - "15 -1736.114108 -0.003951 \n", - "16 -3432.892977 -0.007826 \n", - "17 -849.949424 -0.001941 \n", - "18 -2675.106429 -0.006122 \n", - "19 -1832.276951 -0.004201 \n", - "20 -1316.821862 -0.003025 \n", - "21 346.079370 0.000796 \n", - "22 1590.241254 0.003667 \n", - "23 -2234.310489 -0.005162 \n", - "24 -1141.544015 -0.002642 \n", - "25 -2576.601042 -0.005975 \n", - "26 -301.447942 -0.000700 \n", - "27 -2040.615329 -0.004750 \n", - "28 -1062.633153 -0.002478 \n", - "29 -2781.311019 -0.006499 \n", - "30 -440.239811 -0.001031 \n", - "31 -822.966676 -0.001930 \n", - "32 -676.274766 -0.001589 \n", - "33 -1542.414682 -0.003631 \n", - "34 -1832.891305 -0.004323 \n", - "35 -1589.932931 -0.003757 \n", - "36 211.319617 0.000500 \n", - "37 -610.140243 -0.001447 \n", - "38 -1836.336485 -0.004364 \n", - "39 -889.328705 -0.002118 \n", - "40 -453.924256 -0.001083 \n", - "41 -36.275673 -0.000087 \n", - "42 -188.722404 -0.000452 \n", - "43 -2048.098937 -0.004914 \n", - "44 -98.999050 -0.000238 \n", - "45 -2364.286915 -0.005694 " + "0 1007.860332 0.002229 \n", + "1 -2420.927217 -0.005364 \n", + "2 -268.564573 -0.000596 \n", + "3 -3083.272198 -0.006857 \n", + "4 -1823.652467 -0.004064 \n", + "5 -2757.699793 -0.006157 \n", + "6 -3853.296150 -0.008619 \n", + "7 -1052.675347 -0.002359 \n", + "8 -928.644064 -0.002085 \n", + "9 -1115.309720 -0.002509 \n", + "10 -2154.948222 -0.004857 \n", + "11 451.364853 0.001019 \n", + "12 -1662.663659 -0.003761 \n", + "13 91.558042 0.000208 \n", + "14 2301.738017 0.005227 \n", + "15 -1736.905273 -0.003952 \n", + "16 -3434.025611 -0.007828 \n", + "17 -850.609558 -0.001943 \n", + "18 -2675.811073 -0.006122 \n", + "19 -1833.397757 -0.004203 \n", + "20 -1317.329699 -0.003026 \n", + "21 345.456487 0.000795 \n", + "22 1590.146050 0.003666 \n", + "23 -2235.283220 -0.005163 \n", + "24 -1142.217114 -0.002643 \n", + "25 -2577.488119 -0.005976 \n", + "26 -301.802936 -0.000701 \n", + "27 -2041.263348 -0.004751 \n", + "28 -1063.608979 -0.002480 \n", + "29 -2782.379814 -0.006500 \n", + "30 -440.918241 -0.001032 \n", + "31 -823.585164 -0.001931 \n", + "32 -676.919251 -0.001590 \n", + "33 -1543.327426 -0.003633 \n", + "34 -1833.526943 -0.004324 \n", + "35 -1590.615417 -0.003758 \n", + "36 210.770545 0.000499 \n", + "37 -610.384366 -0.001448 \n", + "38 -1837.051367 -0.004365 \n", + "39 -889.481075 -0.002118 \n", + "40 -454.580449 -0.001084 \n", + "41 -36.766432 -0.000088 \n", + "42 -188.980029 -0.000452 \n", + "43 -2048.543588 -0.004914 \n", + "44 -98.888087 -0.000238 \n", + "45 -2365.130912 -0.005695 " ], "text/html": [ "
\n", @@ -3729,6 +3967,7 @@ " Facility_ID\n", " Altitude\n", " Zone\n", + " District\n", " Resid\n", " Owner\n", " Facility_Type\n", @@ -3751,18 +3990,19 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", " 370655.578345\n", - " 298710.995438\n", - " 260619.466056\n", - " 255428.892934\n", - " 253508.982217\n", - " 301084.510508\n", - " 452103.379475\n", - " -317.566395\n", - " -0.000702\n", + " 390008.338639\n", + " 385074.053901\n", + " 383551.519335\n", + " 382881.752808\n", + " 453186.019359\n", + " 452178.159027\n", + " 1007.860332\n", + " 0.002229\n", " \n", " \n", " 1\n", @@ -3771,6 +4011,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -3779,10 +4020,10 @@ " 351108.236956\n", " 352944.118983\n", " 353891.586301\n", - " 448829.801850\n", - " 451249.680342\n", - " -2419.878492\n", - " -0.005363\n", + " 448903.391472\n", + " 451324.318689\n", + " -2420.927217\n", + " -0.005364\n", " \n", " \n", " 2\n", @@ -3791,6 +4032,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -3799,10 +4041,10 @@ " 349493.164255\n", " 344770.234996\n", " 345157.532117\n", - " 450130.102782\n", - " 450397.593235\n", - " -267.490453\n", - " -0.000594\n", + " 450203.526071\n", + " 450472.090644\n", + " -268.564573\n", + " -0.000596\n", " \n", " \n", " 3\n", @@ -3811,6 +4053,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -3819,10 +4062,10 @@ " 375543.857029\n", " 381029.229862\n", " 379415.048009\n", - " 446465.064103\n", - " 449547.115109\n", - " -3082.051006\n", - " -0.006856\n", + " 446538.199648\n", + " 449621.471846\n", + " -3083.272198\n", + " -0.006857\n", " \n", " \n", " 4\n", @@ -3831,6 +4074,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -3839,10 +4083,10 @@ " 385373.062799\n", " 381129.073629\n", " 382864.345741\n", - " 446875.456426\n", - " 448698.242927\n", - " -1822.786501\n", - " -0.004062\n", + " 446948.806790\n", + " 448772.459257\n", + " -1823.652467\n", + " -0.004064\n", " \n", " \n", " 5\n", @@ -3851,6 +4095,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -3859,10 +4104,10 @@ " 285932.285061\n", " 289579.937651\n", " 289345.079079\n", - " 445094.075488\n", - " 447850.973656\n", - " -2756.898168\n", - " -0.006156\n", + " 445167.350051\n", + " 447925.049844\n", + " -2757.699793\n", + " -0.006157\n", " \n", " \n", " 6\n", @@ -3871,6 +4116,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -3879,10 +4125,10 @@ " 455288.388297\n", " 455102.702313\n", " 455034.373344\n", - " 443152.899063\n", - " 447005.304268\n", - " -3852.405205\n", - " -0.008618\n", + " 443225.944431\n", + " 447079.240580\n", + " -3853.296150\n", + " -0.008619\n", " \n", " \n", " 7\n", @@ -3891,6 +4137,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -3899,10 +4146,10 @@ " 324314.368396\n", " 316195.532608\n", " 314871.921748\n", - " 445109.242713\n", - " 446161.231744\n", - " -1051.989032\n", - " -0.002358\n", + " 445182.353097\n", + " 446235.028444\n", + " -1052.675347\n", + " -0.002359\n", " \n", " \n", " 8\n", @@ -3911,6 +4158,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -3919,10 +4167,10 @@ " 345593.426372\n", " 354934.926046\n", " 356543.998012\n", - " 444390.632491\n", - " 445318.753068\n", - " -928.120577\n", - " -0.002084\n", + " 444463.766354\n", + " 445392.410418\n", + " -928.644064\n", + " -0.002085\n", " \n", " \n", " 9\n", @@ -3931,6 +4179,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -3939,10 +4188,10 @@ " 400410.349670\n", " 392246.728746\n", " 391937.348081\n", - " 443363.169753\n", - " 444477.865230\n", - " -1114.695477\n", - " -0.002508\n", + " 443436.073774\n", + " 444551.383494\n", + " -1115.309720\n", + " -0.002509\n", " \n", " \n", " 10\n", @@ -3951,6 +4200,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -3959,10 +4209,10 @@ " 327819.997189\n", " 330789.556355\n", " 329650.101725\n", - " 441484.287781\n", - " 443638.565226\n", - " -2154.277446\n", - " -0.004856\n", + " 441556.996446\n", + " 443711.944667\n", + " -2154.948222\n", + " -0.004857\n", " \n", " \n", " 11\n", @@ -3971,6 +4221,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -3979,10 +4230,10 @@ " 408894.912655\n", " 378604.565588\n", " 379596.718666\n", - " 443252.418520\n", - " 442800.850059\n", - " 451.568461\n", - " 0.001020\n", + " 443325.455792\n", + " 442874.090938\n", + " 451.364853\n", + " 0.001019\n", " \n", " \n", " 12\n", @@ -3991,6 +4242,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -3999,9 +4251,9 @@ " 360367.235995\n", " 389923.203199\n", " 389558.939179\n", - " 440302.572113\n", - " 441964.716734\n", - " -1662.144621\n", + " 440375.155656\n", + " 442037.819314\n", + " -1662.663659\n", " -0.003761\n", " \n", " \n", @@ -4011,6 +4263,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -4019,10 +4272,10 @@ " 381170.945543\n", " 378471.104964\n", " 377682.655534\n", - " 441220.746519\n", - " 441130.162266\n", - " 90.584253\n", - " 0.000205\n", + " 441294.684850\n", + " 441203.126808\n", + " 91.558042\n", + " 0.000208\n", " \n", " \n", " 14\n", @@ -4031,6 +4284,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -4039,10 +4293,10 @@ " 401617.097706\n", " 408341.613660\n", " 409745.578729\n", - " 442599.508715\n", - " 440297.183673\n", - " 2302.325042\n", - " 0.005229\n", + " 442671.748454\n", + " 440370.010437\n", + " 2301.738017\n", + " 0.005227\n", " \n", " \n", " 15\n", @@ -4051,6 +4305,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -4059,10 +4314,10 @@ " 340683.245254\n", " 342518.356804\n", " 341977.330400\n", - " 437729.663871\n", - " 439465.777979\n", - " -1736.114108\n", - " -0.003951\n", + " 437801.561953\n", + " 439538.467226\n", + " -1736.905273\n", + " -0.003952\n", " \n", " \n", " 16\n", @@ -4071,6 +4326,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -4079,10 +4335,10 @@ " 335947.246630\n", " 335248.047067\n", " 335789.435760\n", - " 435203.049238\n", - " 438635.942214\n", - " -3432.892977\n", - " -0.007826\n", + " 435274.468592\n", + " 438708.494203\n", + " -3434.025611\n", + " -0.007828\n", " \n", " \n", " 17\n", @@ -4091,6 +4347,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -4099,10 +4356,10 @@ " 302510.901036\n", " 300226.263604\n", " 296296.047432\n", - " 436957.723991\n", - " 437807.673415\n", - " -849.949424\n", - " -0.001941\n", + " 437029.478846\n", + " 437880.088405\n", + " -850.609558\n", + " -0.001943\n", " \n", " \n", " 18\n", @@ -4111,6 +4368,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -4119,9 +4377,9 @@ " 271260.885375\n", " 274124.334082\n", " 278184.608227\n", - " 434305.862192\n", - " 436980.968621\n", - " -2675.106429\n", + " 434377.435798\n", + " 437053.246871\n", + " -2675.811073\n", " -0.006122\n", " \n", " \n", @@ -4131,6 +4389,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -4139,10 +4398,10 @@ " 387974.439450\n", " 387736.897200\n", " 387661.416146\n", - " 434323.547929\n", - " 436155.824879\n", - " -1832.276951\n", - " -0.004201\n", + " 434394.568891\n", + " 436227.966648\n", + " -1833.397757\n", + " -0.004203\n", " \n", " \n", " 20\n", @@ -4151,6 +4410,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -4159,10 +4419,10 @@ " 362046.586240\n", " 342819.132014\n", " 340516.424995\n", - " 434015.417381\n", - " 435332.239243\n", - " -1316.821862\n", - " -0.003025\n", + " 434086.915088\n", + " 435404.244787\n", + " -1317.329699\n", + " -0.003026\n", " \n", " \n", " 21\n", @@ -4171,6 +4431,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -4179,10 +4440,10 @@ " 480685.090489\n", " 500151.794189\n", " 502277.800794\n", - " 434856.288139\n", - " 434510.208770\n", - " 346.079370\n", - " 0.000796\n", + " 434927.534834\n", + " 434582.078347\n", + " 345.456487\n", + " 0.000795\n", " \n", " \n", " 22\n", @@ -4191,6 +4452,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -4199,10 +4461,10 @@ " 449504.867423\n", " 447116.625283\n", " 445805.292269\n", - " 435279.971776\n", - " 433689.730522\n", - " 1590.241254\n", - " 0.003667\n", + " 435351.610440\n", + " 433761.464389\n", + " 1590.146050\n", + " 0.003666\n", " \n", " \n", " 23\n", @@ -4211,6 +4473,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -4219,10 +4482,10 @@ " 310749.912224\n", " 313141.518581\n", " 313923.715557\n", - " 430636.491081\n", - " 432870.801570\n", - " -2234.310489\n", - " -0.005162\n", + " 430707.116763\n", + " 432942.399983\n", + " -2235.283220\n", + " -0.005163\n", " \n", " \n", " 24\n", @@ -4231,6 +4494,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -4239,10 +4503,10 @@ " 336295.941280\n", " 330700.546457\n", " 330244.876504\n", - " 430911.874972\n", - " 432053.418987\n", - " -1141.544015\n", - " -0.002642\n", + " 430982.665089\n", + " 432124.882203\n", + " -1142.217114\n", + " -0.002643\n", " \n", " \n", " 25\n", @@ -4251,6 +4515,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -4259,10 +4524,10 @@ " 435891.016355\n", " 437939.836711\n", " 438231.552425\n", - " 428660.978812\n", - " 431237.579854\n", - " -2576.601042\n", - " -0.005975\n", + " 428731.420008\n", + " 431308.908127\n", + " -2577.488119\n", + " -0.005976\n", " \n", " \n", " 26\n", @@ -4271,6 +4536,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -4279,10 +4545,10 @@ " 392209.231985\n", " 393915.875687\n", " 393957.931607\n", - " 430121.833314\n", - " 430423.281257\n", - " -301.447942\n", - " -0.000700\n", + " 430192.671905\n", + " 430494.474841\n", + " -301.802936\n", + " -0.000701\n", " \n", " \n", " 27\n", @@ -4291,6 +4557,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -4299,10 +4566,10 @@ " 335224.704315\n", " 335946.670289\n", " 336884.175544\n", - " 427569.904956\n", - " 429610.520285\n", - " -2040.615329\n", - " -0.004750\n", + " 427640.316088\n", + " 429681.579436\n", + " -2041.263348\n", + " -0.004751\n", " \n", " \n", " 28\n", @@ -4311,6 +4578,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -4319,10 +4587,10 @@ " 376450.353321\n", " 368811.709372\n", " 365595.615071\n", - " 427736.660883\n", - " 428799.294036\n", - " -1062.633153\n", - " -0.002478\n", + " 427806.610028\n", + " 428870.219007\n", + " -1063.608979\n", + " -0.002480\n", " \n", " \n", " 29\n", @@ -4331,6 +4599,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -4339,10 +4608,10 @@ " 325974.066284\n", " 334512.344383\n", " 337541.046047\n", - " 425208.288593\n", - " 427989.599612\n", - " -2781.311019\n", - " -0.006499\n", + " 425278.010843\n", + " 428060.390657\n", + " -2782.379814\n", + " -0.006500\n", " \n", " \n", " 30\n", @@ -4351,6 +4620,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -4359,10 +4629,10 @@ " 333207.967531\n", " 331162.787180\n", " 331449.273326\n", - " 426741.194309\n", - " 427181.434120\n", - " -440.239811\n", - " -0.001031\n", + " 426811.173251\n", + " 427252.091491\n", + " -440.918241\n", + " -0.001032\n", " \n", " \n", " 31\n", @@ -4371,6 +4641,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -4379,10 +4650,10 @@ " 267520.943494\n", " 269888.025290\n", " 269433.014822\n", - " 425551.827998\n", - " 426374.794674\n", - " -822.966676\n", - " -0.001930\n", + " 425621.733459\n", + " 426445.318624\n", + " -823.585164\n", + " -0.001931\n", " \n", " \n", " 32\n", @@ -4391,6 +4662,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -4399,10 +4671,10 @@ " 448849.771066\n", " 446651.780946\n", " 445524.032754\n", - " 424893.403624\n", - " 425569.678390\n", - " -676.274766\n", - " -0.001589\n", + " 424963.149920\n", + " 425640.069171\n", + " -676.919251\n", + " -0.001590\n", " \n", " \n", " 33\n", @@ -4411,6 +4683,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -4419,10 +4692,10 @@ " 291501.477315\n", " 289945.485496\n", " 291038.100935\n", - " 423223.667713\n", - " 424766.082395\n", - " -1542.414682\n", - " -0.003631\n", + " 423293.012832\n", + " 424836.340258\n", + " -1543.327426\n", + " -0.003633\n", " \n", " \n", " 34\n", @@ -4431,6 +4704,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -4439,10 +4713,10 @@ " 302154.611762\n", " 306083.376401\n", " 305678.254498\n", - " 422131.112511\n", - " 423964.003816\n", - " -1832.891305\n", - " -0.004323\n", + " 422200.602069\n", + " 424034.129012\n", + " -1833.526943\n", + " -0.004324\n", " \n", " \n", " 35\n", @@ -4451,6 +4725,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -4459,10 +4734,10 @@ " 336866.204386\n", " 331980.842360\n", " 330169.889911\n", - " 421573.506857\n", - " 423163.439788\n", - " -1589.932931\n", - " -0.003757\n", + " 421642.817151\n", + " 423233.432568\n", + " -1590.615417\n", + " -0.003758\n", " \n", " \n", " 36\n", @@ -4471,6 +4746,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -4479,10 +4755,10 @@ " 322432.738606\n", " 318079.159985\n", " 317973.894415\n", - " 422575.707068\n", - " 422364.387452\n", - " 211.319617\n", - " 0.000500\n", + " 422645.018611\n", + " 422434.248066\n", + " 210.770545\n", + " 0.000499\n", " \n", " \n", " 37\n", @@ -4491,6 +4767,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -4499,10 +4776,10 @@ " 301954.830856\n", " 310662.088357\n", " 312810.479228\n", - " 420956.703710\n", - " 421566.843952\n", - " -610.140243\n", - " -0.001447\n", + " 421026.188284\n", + " 421636.572650\n", + " -610.384366\n", + " -0.001448\n", " \n", " \n", " 38\n", @@ -4511,6 +4788,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -4519,10 +4797,10 @@ " 419118.260070\n", " 404772.957169\n", " 405190.542219\n", - " 418934.469956\n", - " 420770.806441\n", - " -1836.336485\n", - " -0.004364\n", + " 419003.352104\n", + " 420840.403471\n", + " -1837.051367\n", + " -0.004365\n", " \n", " \n", " 39\n", @@ -4531,6 +4809,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -4539,9 +4818,9 @@ " 304945.762400\n", " 319651.502857\n", " 319575.723877\n", - " 419086.943369\n", - " 419976.272074\n", - " -889.328705\n", + " 419156.256610\n", + " 420045.737685\n", + " -889.481075\n", " -0.002118\n", " \n", " \n", @@ -4551,6 +4830,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -4559,10 +4839,10 @@ " 337015.684029\n", " 328940.852077\n", " 329238.343810\n", - " 418729.313756\n", - " 419183.238012\n", - " -453.924256\n", - " -0.001083\n", + " 418797.992003\n", + " 419252.572452\n", + " -454.580449\n", + " -0.001084\n", " \n", " \n", " 41\n", @@ -4571,6 +4851,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -4579,10 +4860,10 @@ " 365879.087584\n", " 373323.111876\n", " 372541.004296\n", - " 418355.425750\n", - " 418391.701423\n", - " -36.275673\n", - " -0.000087\n", + " 418424.138509\n", + " 418460.904941\n", + " -36.766432\n", + " -0.000088\n", " \n", " \n", " 42\n", @@ -4591,6 +4872,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -4599,9 +4881,9 @@ " 280888.319603\n", " 281510.797522\n", " 281840.507716\n", - " 417412.937075\n", - " 417601.659480\n", - " -188.722404\n", + " 417481.752292\n", + " 417670.732321\n", + " -188.980029\n", " -0.000452\n", " \n", " \n", @@ -4611,6 +4893,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -4619,9 +4902,9 @@ " 360679.750486\n", " 359521.705424\n", " 359548.833442\n", - " 414765.010421\n", - " 416813.109359\n", - " -2048.098937\n", + " 414833.508183\n", + " 416882.051771\n", + " -2048.543588\n", " -0.004914\n", " \n", " \n", @@ -4631,6 +4914,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -4639,9 +4923,9 @@ " 462306.136722\n", " 461148.128688\n", " 461552.424105\n", - " 415927.049193\n", - " 416026.048243\n", - " -98.999050\n", + " 415995.972386\n", + " 416094.860473\n", + " -98.888087\n", " -0.000238\n", " \n", " \n", @@ -4651,6 +4935,7 @@ " 643536\n", " 3435564.0\n", " Central WestSouth EastNorthernSouth EastNorthe...\n", + " LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...\n", " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", @@ -4659,28 +4944,28 @@ " 323443.731437\n", " 324834.166014\n", " 323233.055405\n", - " 412876.186407\n", - " 415240.473322\n", - " -2364.286915\n", - " -0.005694\n", + " 412944.024703\n", + " 415309.155615\n", + " -2365.130912\n", + " -0.005695\n", " \n", " \n", "\n", "
" ] }, - "execution_count": 61, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 61 + "execution_count": 8 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-07T15:20:42.603433Z", - "start_time": "2025-01-07T15:20:42.521119Z" + "end_time": "2025-01-09T11:44:47.692803Z", + "start_time": "2025-01-09T11:44:47.597022Z" } }, "cell_type": "code", @@ -4696,10 +4981,10 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 62, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, @@ -4708,19 +4993,19 @@ "text/plain": [ "
" ], - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 62 + "execution_count": 9 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-07T15:20:45.405774Z", - "start_time": "2025-01-07T15:20:45.323523Z" + "end_time": "2025-01-09T11:44:50.894208Z", + "start_time": "2025-01-09T11:44:50.806926Z" } }, "cell_type": "code", @@ -4734,10 +5019,10 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 63, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" }, @@ -4746,13 +5031,13 @@ "text/plain": [ "
" ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi8AAAGwCAYAAABhDIVPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/OQEPoAAAACXBIWXMAAA9hAAAPYQGoP6dpAACUZElEQVR4nO2deZhT9fX/3zd7ZsnsKzPDyCIDIrsiKII/saitoq2tCypailZFa91prVj9+rVVW3fFDal+oWrrWrVYRHABCsgmy7DvzL5PZsn6+f2RfG6SmSST5d4kNzmv55nngeTm5t7k5t73Ped9zhEYYwwEQRAEQRAKQRXvDSAIgiAIgggHEi8EQRAEQSgKEi8EQRAEQSgKEi8EQRAEQSgKEi8EQRAEQSgKEi8EQRAEQSgKEi8EQRAEQSgKTbw3QGqcTidqamqQmZkJQRDivTkEQRAEQYQAYwydnZ0oLS2FShU8tpJ04qWmpgbl5eXx3gyCIAiCICLg+PHjKCsrC7pM0omXzMxMAK6dN5lMcd4agiAIgiBCoaOjA+Xl5eJ1PBhJJ154qshkMpF4IQiCIAiFEYrlgwy7BEEQBEEoChIvBEEQBEEoChIvBEEQBEEoChIvBEEQBEEoChIvBEEQBEEoChIvBEEQBEEoChIvBEEQBEEoChIvBEEQBEEoChIvBEEQBEEoChIvBEEQBEEoChIvBEEQBEEoChIvBEEQBEEoChIvBJGiMMbQY3XEezMIgiDChsQLQaQoD360E+Mf/Q+ONHXFe1MIgiDCgsQLQaQo3x1oQq/NiV01HfHeFIIgiLAg8UIQKQhjDHXtvQCAzl5bnLeGIAgiPEi8EEQK0t5jg8XuBAB09trjvDUEQRDhQeKFIFKQuo5e8d8UeSEIQmmQeCGIFISnjACggyIvBEEoDBIvBJGC1HtFXswWEi8EQSgLEi8EkYLUtVvEf1PaiCAIpUHihSBSEF/PC0VeCIJQFiReCCIFqSfxQhCEgiHxQhApiLdhl9JGBEEoDRIvBJGCkGGXIAglQ+KFIFIMi92B5i6r+H8qlSYIQmmQeCGIFKOhw+Lzf6vdCYudpksTBKEcSLwQRIrBU0aDso3iY2TaJQhCSZB4IYgUg5dJl2YbkKHXACDxQhCEsiDxQhApBq80KjJ5xIuZxAtBEAqCxAtBpBg8bVRsMiDTwCMvVC5NEIRyIPFCEClGnduwW5zlES9UcUQQhJIg8UIQKUa9V9oo06AFQJEXgiCUBYkXgkgxajt6APhGXsiwSxCEkiDxQhApBGMM9Txt5OV5oS67BEEoCRIvBJFCtHbbYLU7AQCFJj2ljQiCUCQkXggiheBl0rnpOug1amRSnxeCIBQIiReCSCF4mXSRyQAA5HkhCEKRkHghiBSiTuzxogcAMW3UQWkjgiAUBIkXgkgheNqoOMs38kKGXYIglERMxMuLL76IyspKGAwGTJ48GRs3bgzpde+88w4EQcBll10m7wYSRIrQN22UQWkjgiAUiOzi5d1338Vdd92FRYsWYcuWLRg7dixmzZqFhoaGoK87cuQI7rnnHkybNk3uTSSIlKHOazQAAJio2oggCAUiu3j561//ivnz5+PGG2/EqFGjsHjxYqSlpWHJkiUBX+NwODBnzhz88Y9/xJAhQ+TeRIJIGcShjFlk2CUIQrnIKl6sVis2b96MmTNnet5QpcLMmTOxfv36gK975JFHUFhYiHnz5g34HhaLBR0dHT5/BEH4p75P5IUbdrutDtgdzrhtF0EQRDjIKl6amprgcDhQVFTk83hRURHq6ur8vua7777DG2+8gddeey2k93j88ceRlZUl/pWXl0e93QSRjPTaHGjtdqWHStyRlwx3nxcA6LI44rJdBEEQ4ZJQ1UadnZ247rrr8NprryE/Pz+k1yxcuBDt7e3i3/Hjx2XeSoJQJg3usQB6jQpZRlfERadRQa9xnQaoXJogCKWgGXiRyMnPz4darUZ9fb3P4/X19SguLu63/MGDB3HkyBFccskl4mNOpyuUrdFosHfvXgwdOtTnNXq9Hnq9XoatJ4jkQjTrZhkgCIL4eKZBC4vZQr4XgiAUg6yRF51Oh4kTJ2LVqlXiY06nE6tWrcKUKVP6LV9VVYUdO3Zg27Zt4t+ll16K8847D9u2baOUEEFEQV2fMmmOSTTtUuSFIAhlIGvkBQDuuusuzJ07F5MmTcKZZ56JZ555Bl1dXbjxxhsBANdffz0GDRqExx9/HAaDAaNHj/Z5fXZ2NgD0e5wgiPCob/c163Ko4oggCKUhu3i58sor0djYiIceegh1dXUYN24cVqxYIZp4jx07BpUqoaw3BJGUeKeNvBEnS1so8kIQhDKQXbwAwIIFC7BgwQK/z61Zsyboa5cuXSr9BhFEChIobcQrjswUeUkY7A4nGs0WlGQZ470pBJGQUMiDIFKEgdJGHSReEoaHPtmFKY9/he+PtMR7UwgiISHxQhApgidt5FudJ6aNSLwkDN/ubwQA7K3vjPOWEERiQuKFIFIAp5P1G8rIyaRqo4Sis9eG4y09AICOHhKUBOEPEi8EkQK0dFthczAAQGEmVRslMnvqPNEWEpQE4R8SLwSRAvCBjPkZOug0vj97Ll7MFhIvicDuGs98NhKUBOEfEi8EkQIEShkB3p4XustPBKprPeKFRjYQhH9IvBBEClDX4b/SCKC0UaLhLV7oOyEI/5B4IYgUgJdJF2UFi7zQhTLe2B1OH89LRw9FXgjCHyReCCIFCCXyQimK+HOkuQsWu1P8PwlKgvAPiReCSAHqOiwAAogXvcewyxiL6XYRvuyudUVdDFrXqZl8SAThHxIvBJECiN11g6SNGAO6rI6YbhfhC680mjg4BwB1PSaIQJB4IYgUINBQRsB1l69RCQDoTj/ecLPu5FPyALiiYQ4nRcMIoi8kXggiyem1OdDuNn76K5UWBIEqjhIELl7OPCVXfIwGZhJEf0i8EESSwxvUGbVqmAz+B8lTr5f402S2oKHTAkEAxpRlQe9uJkhGaoLoD4kXgkhyvFNGgiD4XSZDT5GXeMOjLpV56UjTaWAyUgk7QQSCxAtBJDme7rr6gMtQ2ij+cPEyqsQEgErYCSIYJF4IIsnhaSN/ZdIcalQXf3il0ciSTAD0nRBEMEi8EESSw9NG/rrrckxi5IXu8uNFtbvHy0h35IV/J9RllyD6Q+KFIJKc+iDddTmUNoovvTYHDjSaAQCjSrl4IRM1QQSCxAtBJDmhpI0yDJ4uu0TsOdBghsPJkJ2mFb8nk5EEJUEEgsQLQSQ59e7RAMHSRtxfQebQ+LDbbdYdWWwSK8LoOyGIwJB4IYgkxulklDZSANysy1NGgGfmFH0nBNEfEi8EkcQ0dVlgdzIIAlCQGaxUmvwV8YSXSXOzLgDq80IQQSDxQhBJTH27K2WUn6GHVh34506Rl/jBGPMSL5ni49TnhSACQ+KFIJKYuhBSRoCnLJcMu7HnZFsPOnrt0KoFDC/0iBeT6Hmh74Qg+kLihSCSGLHHywDiJUNPKYp4wfu7DC3IgE7jOSWL0TDq80IQ/SDxQhBJTD0vk84K7HcBvNNGNjDGZN8uwoM4FsDLrAt4VxuRoCSIvpB4IYgkhkdeSrKMQZfj4sXmYLDYnbJvF+FBrDQq8RUvnj4vFHkhiL6QeCGIJKY+xLRRuk4DPnCaDKKxpbquf6UR4Im8WOxOWOyOmG8XQSQyJF4IIokJpbsuAKhUAjLcfUXMlKaIGWaLHUebuwH4ES96j6AkLxJB+ELihSCSGLHaaADPC0BN0eLBHrffpdhkQG66zuc5lUpAho6GMxKEP0i8EESS0m21i0JkoLQR4N2ojsRLrPDX38Ub6r9DEP4h8UIQSQpPGaXr1KIwCYZ3xRERG3a7y6T7VhpxqMsuQfiHxAtBJClij5cgAxm9obv82LPbz1gAb6jLLkH4h8QLQSQpoQxk9EZMG1GX3ZjgcDLsDVBpxKGZUwThHxIvBJGk1LnnGoUqXjIobRRTDjd1odfmhFGrRmVeut9l+NiGjh4SlAThDYkXgkhS6iltlNBws+6I4kyoVYLfZSjyQhD+IfFCEElKqD1eOCa6UMaU6gH8LoCnyy6NCCAIX2IiXl588UVUVlbCYDBg8uTJ2LhxY8BlX3vtNUybNg05OTnIycnBzJkzgy5PEIR/Qh3KyKHIS2zZHWCmkTee+UYkKAnCG9nFy7vvvou77roLixYtwpYtWzB27FjMmjULDQ0Nfpdfs2YNrr76aqxevRrr169HeXk5fvSjH+HkyZNybypBJBWiYZfSRgmJOJAxQI8XgL4TggiE7OLlr3/9K+bPn48bb7wRo0aNwuLFi5GWloYlS5b4XX7ZsmW49dZbMW7cOFRVVeH111+H0+nEqlWr/C5vsVjQ0dHh80cQqY7DydDQGaZhV0/VRrGi2WxBfYcFggCMKA6SNuKRF+qwSxA+yCperFYrNm/ejJkzZ3reUKXCzJkzsX79+pDW0d3dDZvNhtzcXL/PP/7448jKyhL/ysvLJdl2glAyTWYLHE4GlQDkZ+gGfgGoSV0sqXY3pxucmybOlPIHRV4Iwj+yipempiY4HA4UFRX5PF5UVIS6urqQ1nH//fejtLTURwB5s3DhQrS3t4t/x48fj3q7CULpcLNuQaYeGnVoP3O6UMaOUMy6gFeHXQsJSoLwJrDkTwD+9Kc/4Z133sGaNWtgMPgPfev1euj1Aw+dI4hUwjOQ0Rjya6jaKHZ4/C4DiBfq80IQfpE18pKfnw+1Wo36+nqfx+vr61FcXBz0tU899RT+9Kc/4T//+Q/GjBkj52YSRNLh6a4burDnkZdemxM2h1OW7SJcDDQWgOPd54UxJvt2EYRSkFW86HQ6TJw40cdsy823U6ZMCfi6J554Ao8++ihWrFiBSZMmybmJBJGUhNvjBQDSvbwXZkodyYbF7sCBBjMAYGSQMmnAEw1zMqDL6pB92whCKchebXTXXXfhtddew9/+9jdUV1fjlltuQVdXF2688UYAwPXXX4+FCxeKy//5z3/GH/7wByxZsgSVlZWoq6tDXV0dzGaz3JtKEElDuEMZAUCrVsGoVQMg34ucHGgww+5kyDJqUTrA92PQqqBxd9+ldB5BeJDd83LllVeisbERDz30EOrq6jBu3DisWLFCNPEeO3YMKpVHQ7388suwWq244oorfNazaNEiPPzww3JvLkEkBeEOZeRkGjTosTmoKZqM7K7hKaNMCIL/sQAcQRBgMmrR0mVFZ68dJVmx2EKCSHxiYthdsGABFixY4Pe5NWvW+Pz/yJEj8m8QQSQ5kaSNAJd4aei0UORFRniZ9EB+F06mQYOWLiv1eiEIL2i2EUEkIfUdrgZ14aSNABoEGAtCrTTiUAk7QfSHxAtBJBlmix1md5fcSCIvfB2E9DDGQq404phovhFB9IPEC0EkGTxllKnX+FQQhQLd5ctLbXsv2nts0KgEDC/KCOk1/DuhydIE4YHEC0EkGfURVBpxMvWUNpITbtYdVpgBvUYd0muoeSBB9IfEC0EkGZGadQGKvMhNqGMBvMkUhzPSd0IQHBIvBJFkiD1eIhIv3F9BF0o5qK4Lz6wL0MBMgvAHiReCSDLEHi9Z4c/8yiDDrqx4eryELl74cEYSlAThgcQLQSQZ0qSN6C5farosdhxt6QbgalAXKvSdEER/SLwQRJJRH0XayESeF9nYU9cJxoAikx55GaFHxTyGXfpOCIJD4oUgkow6MW0UueeF7vKlJ9z+LhwuKKnDLkF4IPFCEEmE3eFEY6eruy5VGyUWkVQaAd6Ckr4TguCQeCGIJKLJbIWTARqVEFZqgsMvlGa6UEpOuGMBOCYjb1JHkReC4JB4IYgkora9BwBQmKmHWhV8YrE/Mtwdec1WO5xOJum2pTIOJ8OeMAcycrig7LY6YHc4Jd82glAiJF4IIomIprsu4EkbMeYSMIQ0HG3uQo/NAYNWhVPy08N6Lf9OACphJwgOiReCSCKiKZMGAINWDZ3adVogj4V0VLujLiOKTWFHxLRqFYxa1ygB6rJLEC5IvBCEjOw40Y4pj6/C+5tPxOT96jpcZt1IyqQ51FdEenbXtgMARoXR38Ubz3BG+k4IAiDxQhCy8vW+BtS29+KzHbUxeb/6KMqkOfxCSaZd6eCRl3DNuhxPl10SLwQBkHghCFlpMlsBALXudI7cRJs2AjwjAihtJB2RlklzqISdIHwh8UIQMsJ7rtS5q4DkJpruupxMPd3lS0lrl1UUr1WRRl6o1wtB+EDihSBkpNHsEi+t3Tb0WB2yvhdjLKruuhy6y5cWHnUZnJcmlqKHSyZ12SUIH0i8EISMNLnFC+Bp2y8XnRY7ut0CKZq0EXV0lRZxLEBxZFEXgL4TgugLiReCkJGmTo94qW2TN3VU705NmAwaGHXqiNcjGnYtdJcvBXvrXGbdqggrjQDqsksQfSHxQhAyYbE70OF1pyy3aVeKlBFAaSOpOdrcDQAYUpAR8TpMNDCTIHwg8UIQMtHsrjTi1Mps2uWVRtGYdQESL1JzpLkLADA4Ny3idZjoOyEIH0i8EIRMePtdAPkjL2KPl6jFC93lS0W31Y4Gd+qwMi+8sQDe8O+E0kYE4YLEC0HIRGNnbMWL1GmjDrrLj5pjLa6UUZZRi6w0bcTroWgYQfhC4oUgZIJHXvisINnFS3v0owEAz10+ddiNHu53qcyLPGUEeHXYpVJpggBA4oUgZIN31+VVJnI3qpMqbcR7kXRStVHUHOV+lyhSRgBFXgiiLyReCEImeNro9EFZAORvVCdV2ojModJxxB15GRxt5MWrzwtjLOrtIgilQ+KFIGSCp41OyU9HurvvilyN6mwOp/h+0Xte6EIpFcdE8SJN5MXqcMJid0a9XQShdEi8EIRMcDFRkKkXBYVcjeoaOy1gDNCqBeSm6aJaF79QOpwMPTZ5RxokO2KZdJSRl3SdBoLg+jdVHBEEiReCkA3ueSnI0KM02whAPtMuj+gUZhqgUglRrStNpwZfBaWOIsdqd6LGLVajFS8qlYBMPZ9vRN8JQZB4IQiZ4JGX/Ey9aKKVq1Edb1AXbcoIAARB8Jh2SbxEzInWbjiZSwwWZOijXh/13yEIDyReCEIGrHYn2rpdF5n8DD1K5I68tEtTacShC2X0HHX3eKnITYMgRBcNAzzl0iQoCYLEC0HIQnOXK+qiVgnINmpR4o6I1MkkXniZdLQ9XjhUmhs9R5tcfpdoOut642keSIKSIEi8EIQMNHW6/C556TqoVIKYzqmR2fNSnBV9egLwLc0lIkOqMmkOlbAThAcSLwQhA6Lfxe11KM1ypY3kalR3otW13kHZ0lwoPZEXusuPFD4aINoyaQ4XlNRllyBiJF5efPFFVFZWwmAwYPLkydi4cWPQ5f/xj3+gqqoKBoMBp59+Oj7//PNYbCZBSEajV5k04DHSytWoznOhlEa8ZLjFi9lCd/mRIlWZNIdSeQThQXbx8u677+Kuu+7CokWLsGXLFowdOxazZs1CQ0OD3+XXrVuHq6++GvPmzcPWrVtx2WWX4bLLLsPOnTvl3lSCkIy+kReTQSNbo7puq13s5lueK+2FkoYzRobDyXCiRZoyaQ6ZqAnCg0buN/jrX/+K+fPn48YbbwQALF68GJ999hmWLFmCBx54oN/yzz77LC688ELce++9AIBHH30UK1euxAsvvIDFixeH/L5dXV1Qq9X9Hler1TAYDD7LBUKlUsFoNEa0bHd3d8DupIIgIC0tLaJle3p64HQG7rCZnp4e0bK9vb1wOAJHBMJZNi3NU11hsVhgtwe+AIazrNFohErl0ttWqxU2W+CTeDjLGgwG8VgJZ1mbzQar1ep3uZrGNjCnA/mZroZxdrsdBQaGTnMvDtU0odDou7xer4dGoxGXtVgsfVcpotPpoNVqxWX3nmiC09qLLKMWGqcVXV1Wv8s6HA709gYWTlqtFjqda3vTtSo4rb1obmv3e9x7L+t0OtHTEzgdFs6yGo0Ger1L8DHG0N3dLcmy4fzupThHnGztRm9PN7RqASaNE11dXVGfI/Swur+TTp9tonOEByWdIwDf3304y4Z7jgh12XDOEeEsG845ImSYjFgsFqZWq9mHH37o8/j111/PLr30Ur+vKS8vZ08//bTPYw899BAbM2aM3+V7e3tZe3u7+Hf8+HEGIODfxRdf7PP6tLS0gMtOnz7dZ9n8/PyAy06aNMln2cGDBwdcdtSoUT7Ljho1KuCygwcP9ll20qRJAZfNz8/3WXb69OkBl01LS/NZ9uKLLw76uXlzxRVXBF3WbDaLy86dOzfosg0NDeKyt956a9BlDx8+LC57zz33BF12586d4rKLFi0KuuzGjRvFZZ944omgy65evVpc9oUXXgi6bMEVi9hr3xxkjDH25ptvBl32vffeE9f73nvvBV32zTffFJf99NNPgy77wgsviMuuXr066LJPPPGEuOx9L78fdNlFixaJy+7cuTPosvfcc4+47OHDh4Mue+utt4rLNjQ0BF127ty54rJmsznosldccYXPMRxsWTpHuP7oHOH5k+sc8emnn4rLKu0csXHjxqDLRnKOaG9vZwBYe3s7GwhZ00ZNTU1wOBwoKiryebyoqAh1dXV+X1NXVxfW8o8//jiysrLEv/Lycmk2niAkIF+C5mTxIE0ne1CWIAgiYgTG5Ju8VlNTg0GDBmHdunWYMmWK+Ph9992Hr7/+Ghs2bOj3Gp1Oh7/97W+4+uqrxcdeeukl/PGPf0R9fX2/5S0Wi09IrKOjA+Xl5aipqYHJZOq3PKWN/C9LIWFpQ8KXPPctDrZasWz+VJwzPB82mw1P/XsnXl5zCFeeUYaHLx3ts3w0IeE/vL8FyzYcx/xzT8FdF4wIuGw4Yd73vz+G3y7fhClDc7HkhjODLktpo/7niKe+2IM3vjuCa8+qwO9/PMrvsuGeI77d14D5b23GqUUZ+HjBOQGXpXOEMs4RAKWN+i7b0dGBrKwstLe3+71+eyPr7VV+fj7UanU/0VFfX4/i4mK/rykuLg5reb1eL57AvElPT/f5MQUilGUiWdb7ZCLlst4nPymX9T5ZS7lsoO8n2mV1Ol3IOVK5ltVqteKPvi+tNhUElVr0vGi1WlQW50Glq0GLRRX0WNJoNOJJaiA0Gg3qugGVzoBhpflB16tWq0M+hrPT9VDpDOhh2gFfo1IF359IlxUEQZZlAfl+93zZ2i7Xd3LqoMDfSbjniMLcrJC+EzpHuEj0c0Q0y4Z7jgh12XDOEeEsG87vPlRkTRvpdDpMnDgRq1atEh9zOp1YtWqVTyTGmylTpvgsDwArV64MuDxBJBo2hxOt7tEA3jNt5GpUd8yrDb1UZFKTuqjwlElLd8Lm4wGowy5BxKDa6K677sLcuXMxadIknHnmmXjmmWfQ1dUlVh9df/31GDRoEB5//HEAwG9+8xtMnz4df/nLX/DjH/8Y77zzDr7//nu8+uqrcm8qQUhCi7vaR60SkJPmuUOTo1Gd08lw3N2gTlrxQk3qIoUxJnnfHcDznZgtdjidLOrp4QShZGQXL1deeSUaGxvx0EMPoa6uDuPGjcOKFStEU+6xY8fEvCMATJ06FcuXL8eDDz6I3/3udxg+fDg++ugjjB49OtBbEERCwXuu5LpHA3D6Nqoz6vqX8odLfWcvrHYnNCpBnJ8kBdTnJXIazRZ0Wx1QCUBZjnTihXfYZQwwW+3i/wkiFYlJScGCBQuwYMECv8+tWbOm32M///nP8fOf/1zmrSIIeejboI7DG9V1WR2o6+jFKfnRpxSOuefnDMoxQqOWLgvM00ZWuxMWuwN6TfRCK1Xg30lpthE6jXTfiUGrhk6tgtXhRGcviRcitaHZRgQhMTzykp/ha+oTBM+AxlqJUkdHZfC7AECG3nNfY6boS1hIPZDRG0rnEYQLEi8EITFNZpfnpcBPj5cSt++ltk0a0+5xmcSLWiWI4wzItBseR2Uw63JE024PfSdEakPihSAkRkwbZfoTL67Ii1TzjeSoNOJQxVFkHHVHXiop8kIQskHihSAkhosX/5EXd7l0mzRpI3nFC10oI4FHXipyZYi8GKhcmiAAEi8EITmeyEv/RlYl2bxcWqLIi/suv0LOu3wLRV7CgfuQKvPlFJT0nRCpDYkXgpCYpk6X58XfXCMpG9WZLXY0u3vKlMsQecmgtFHYtHfb0OZuUChvNIy+EyK1IfGSYNS19+K6NzZg5e7+c5wIZRCoVBqQtlEdN+vmpGllKZultFH4HG1xpYwKM/WyDLcU00Y99J0QqQ2Njk0wvthVh2/3NwEALhhVNMDSRKJhdzjR0j1w5EWKRnVy+l0AV18agO7yw0HOMmnAY6Km5oFEqkORlxCx2p040NCJrcdaZX2fGvcdebM58HRRInFp6bKCMUAluDrs9sVk0CDNLViirTjy+F2kN4YC3tVGdJcfKkeb5CuTBgCTkXc+VtZ3UtPWAzN5pwgJIfESInvrOjHzr9/g5rc3y/o+3MjZ3BV4hDmRuDSaPaMB1H5mzwiCp41/tI3qPJGX0CcDh0Om3jNLhwgN0awrc+RFSdGwho5ezHhyDa57Y0O8N4VIIki8hEhJtuuC02i2wGp3yvY+vHlZs9kKxphs70PIA29Q5y9lxJGqUZ3caaMMmm8UNmKZtGzRMOX5kPbVm2F1OPHDiXbYHfKdO4nUgsRLiOSl66DTqMAYUC9RgzF/1Ha47sbtTkZdNBVIk3s0QIGfBnUcqRrVcfEiR6URoMy7/HgjZ4M6QJmGXX6+dDgZaiVqEUAQJF5CxDvcL1WDsb44ncyn/weljpRHsEojjhTHkcPJcKKVm0PpLj8R6Lba0eAWr4NlaFAHKLNUur7Tc07jFXIEES0kXsLA41WQ5+6hucsKm4P5/J9QFh7x0t+syynOir5RXV1HL2wOBq1aQLHJEPF6gqHEC2U84ZGw7DQtstLkmficZVReh92GDs9N2DESL4REkHgJg1J3d9QaiSYC96WvgbPZTJEXpRGS5yU7+kZ1vNKoLCfNrzFYCniKgqZKh8aRJnckTKY0HuARlL02J2wK8Y94p9mPt5J4IaSBxEsYlEo8EbgvfSM6FHlRHo2doaeNomlUd6yFz8+R70KZoae0UTjIOU2aw78TQDkRMZ5KA4BjLfLc+BGpB4mXMBDvmGXyvNS29Y28kHhRGsEmSnN4tVFrtw29NkdE7yN3pRHgucvvsjrgcFLl20DIXSYNABq1CunuPkFKMe36RF6SIG1kdzhFvxkRP0i8hAGPvEgxl8YftX2qTyhtpDxC8bx4N6qL1D/F72DlFS8e3waljgZG7jJpjpKqwBhjPp6XZBAvz3y5H+f8eTXe3XQs3puS0pB4CQMeeYm2uVggeDpqkNtb00RpI0XhcDK0uL+zYKXSUjSqk7tMGgB0GhX0GtcpQkkG0Xghd5k0R0lddtu6bbB6eXOau6zoUnjTw63HXV3W//fzPeLvnYg9JF7CgIf729xzaaSGV5+cVmoCALRQ2khRtHRZ4WSAIAC5aYEjL0D0jeqOif4KeS+U/C6fuuwGx2p3iunkihh9J0rwInG/S06aVqyUUrppl/va2ntseOo/e+O8NakLiZcwMBk0omFOjoojvs7Rg7IAUJ8XpcFTRrlpOmjUwX9axVE0quvotaG123XhkjPyAlC5dKicaO2GkwFpOjUKgpi1pSBTQZ2Pud+lyGQQU5y8Uk6peBuQ/77xGHaebI/j1qQuJF7CwCfcL3HFkdPJxB/66EGuyAsZdpVFKA3qOKVRNKrjvoG8dJ1P9YkcUKO60OApo4rcNAiCPKXrHCV12eXntEKTAeXuGVzHW5VbcWSxO9DmvnE499QCMAYs+mQXjXKJAyRewqSE93qRuOKoqcsCm4NBJQAjS1zipbXbSlUeCkIsk84MnjIComtUx+9c5Y66ABR5CZUj7jRepcxmXUBZ3wmPUhRm6sXjVcmmXf4b16lV+PPPTkeaTo3NR1vx4daTcd6y1IPES5iId8wSp434RawgUy+GnZ0MaOum6ItSCCfy4jF/RyBeWvhYgBiIF71y/BXxhEdeYvGdmBTUZbdBTBvpUZ6jfPHS4DW7rCTLiAX/bxgAl3mXfiOxhcRLmEg1EbgvNe71lWQZoVGrkONuL06N6pRDKN11OdFUG8WixwtHSf6KeBKLBnUcJUVe6t1l0j6eFyWLlw7fwavzzjkFp+Sno8lswXOr9sdz01IOEi9h4mntLnXkxbU+flHLc18Am6jXi2JoCqG7LieaRnWxKJPmZLgvlFRtFJxYNKjjKKnaiA9lLMz0iJfjrd2K9Yg0ivvj+o3rNWo89JNRAIA31x7BgYbOuG1bqkHiJUx4DxaphzPy9fGLWm66yzdBfQSUQ6PZ964sGNE0qott5EU5F8p44XAyMRUid5k04Dp2AKCjJ/EFZYMYedGjNNsIQXDNZWpU6E1ZY2f/3/h5VYU4v6oQdifDH/+1W7HCTGmQeAmTEq8qESkPUo94ca2fd2iliiPl4EkbDWzYFQRBLJcOJ3Vkdzhx0l2tERN/hYJSFPGitr0HNgeDTq0Sbz7khFcbdVoSW1AyxtDQ6ak20mlUYpdypfpePAZk30nuf/jJKOjUKny7vwlf7KqPx6alHCRewoSfnLqtDknvfPgFjKel8tJdyp5GBCiHcAy7QGSDPmvbe2F3ui6URX1OoHKgJH9FvOBm3bJco2wTvr0RO+wmeOSltdsGm8N1g8eLEMpyuHhRZrm0KF5Mvr/xyvx0zD/3FADA/3y2O+KZZUTokHgJE6NOLZpppfS99I288LQRGXaVgcPJRKEZStoIiKxRHb9jLcs1QhWDCyWljQYmlmXSgHK+E97jJS9dB517zITSTbsNfTwv3tx23jCUZBlworUHi78+GOtNSzlIvESAWHEkkXjxblDH101pI2XR2u0aDQB4hOdARNKojhtDB8fA7wJAbIJHkZfAHGuOnQcJ8I2GJbK/wrtBHUfpvV64h6dv2ggA0nQa/O7ikQCAl9ccjGof7Q4n3lx7GH/69x44qdeXX0i8RECp2KhOGtOud4M6ruh5tRGNCFAGPGWUk6aFdoDRAJxIGtXF0qwLUNooFDyRl9h8J9zzYncy9CRwesJzofdEKZQceXE4mfg775s24vxkTAnOGpILi92Jxz6rjuh9dp5sx+wX1+KP/9qNxV8fxPpDzRFvczJD4iUCSiWeLs09D4WZBnEmTh6ljRRFU2foPV44kTSqi2WZNKCcFEU8ERvU5ccmbZSmU4vemkQWlTzFUuR1oefH7QkFjgho7rKIg1fzAkRXBUHAw5eeBrVKwIpddfhuf1PI6++1OfD4v6sx+8W12FXTIT6+9kDo60glSLxEAE/tSBV54Rcv7oEAgDxKGymKpjD9LkBkjepinaIwefV5SeQURbxgjHk6HsfoOxEEwdM8MIHnG3k3qOPw+UY17T2w2p1x2a5I4WXSeenBB69WFZtw3VmDAQCLPtkZ0n6uO9iEWc98g1e+PgSHk+HHY0rwwEVV7uco8uIPEi8RwCMvUs034hcvvl7AU23U3mNT3I88FQm30ggASkzhN6rzjAaIrTnUyYAua+KmKOJFo9mCbqsDKgEoy4mNeAGU0fnYn+elIEMPg1YFxoCTEs+HkxvPaICBq/x+e8GpyEvX4WBjF/627kjA5dq7bXjg/R9wzWsbcLS5G0UmPV67fhJevGYCZo8rBQD8cKJNEaMgYg2JlwjwGHalibxwz0OxydMjIsuoFUPDrTTfKOFpjEC8mIzhNapr77ah3X2nze9g5cagVUHjPg7NCXyhjBc8ZVSabRQramKBEmZO1Xf297wIgqDYGUeNfjw8gcgyanHfhSMAAM+u2i/OePLm3ztqMfPpr/HOpuMAgGvPqsDKu6bjglFFAFzXmSH56XAyYMOhFql2I2kg8RIBPNxf194riRO8xn3h8o68qFQCctIodaQURM9LCBOlOeE2qjve6jrZ52fokabTRLCV4SMIgjgiIJEvlPHiSFNsy6Q5Yq+XBBaUjeJQRt9IhVJNu8HKpP3x84nlGFuWBbPFjj+t2CM+Xt/Ri5vf/h63LNuCxk4LhuSn472bp+B/LjtdNGNzpgzNA+BKKxG+kHiJgOIsAwQBsDqckhhq+Vwjb88L4FUuTRVHCU8kkRcgvEZ1R0W/S2yiLhwlpCjixbEYjgXwJtGN1E4nE9MsRX0qc8q9ZhwpiUAN6gKhUrnMuwDwwZaT+P5IC/6+8Rhm/vVrfLGrHhqVgAXnDcPnv5mGM0/J9buOs4flAwDWHSDfS19kFS8tLS2YM2cOTCYTsrOzMW/ePJjN5qDL33777RgxYgSMRiMqKipwxx13oL29Xc7NDButWiWqbykqjrwnSntDpl3lwIcyFoQpXsJpVBdrvwsnHimKXpsDDgX0tzjSHLuBjN7wO/RE7bLb0m2F3ckgCP0FvVJ7vQTr8RKI8RU5+PnEMgDANa9vwMIPdqCz146xZVn41+3n4J5ZI2DQqgO+/qwhrsjL3vpO0TBMuJBVvMyZMwe7du3CypUr8emnn+Kbb77BTTfdFHD5mpoa1NTU4KmnnsLOnTuxdOlSrFixAvPmzZNzMyPCU3EUnXjxbVDn+6PI5SMCqFw64YnEsAt4GtWFIoJjXSbNiXWvly6LHef8eTWufGV9TN4vGo65e7zEXFAmeCrPu7tu375H5QodERBu2ohz34VVyNRrYLU7YdSq8eCPR+KDW8/GyBLTgK/NTddhlHs56vfii2yJ8+rqaqxYsQKbNm3CpEmTAADPP/88Lr74Yjz11FMoLS3t95rRo0fj/fffF/8/dOhQPPbYY7j22mtht9uh0fTfXIvFAovFo0g7Ojr6LSMHpdkGbDsefbl0k9kCu9O3QR1H7PVC840SGqeTiQIzHM8L4GlUF0ra6HiMG9RxeIrCbImNeDnU2IUmswVNZgt6bY6gd6bxhkdeYjEk05tEH5gZaIAh4EmxKc3zEs7UeG8KMvVYfN1ErNxdj3nnnBL2zcfUoXnYXduB9QebcOnY/tfNVEW2yMv69euRnZ0tChcAmDlzJlQqFTZs2BDyetrb22EymfwKFwB4/PHHkZWVJf6Vl5dHve2hINWIAF5l4t2gjkMjApRBW49NTHHwEvdQ8fR6CcHz0uK6y4+9eIntXX6Tl1hP5GZmbd1Wsfor1t+JyehOGyVo5KVBNOv2/z3waqP2Hk/1XKLDGIsobcQ5e1g+Hr70tIiiptz3spZ8Lz7IJl7q6upQWFjo85hGo0Fubi7q6upCWkdTUxMeffTRoKmmhQsXor29Xfw7fvx4VNsdKvyiUxNluXTfadLe0IiA0Gjo7MWTX+zBq98cjItPgl9ss9O0YZfLloTYrdnmcIpRvljf5cc6bdToI14S9+6cG6gLM2NX/cVJ9LEN/hrUcdL1GjGqrBTfS0evHRZ3v61QDbtSccYpudCoBBxr6VbM5xULwhYvDzzwAARBCPq3Z8+egVc0AB0dHfjxj3+MUaNG4eGHHw64nF6vh8lk8vmLBYOyebhfmshLX78LQJOlB6K1y4rH/12N6U+swYurD+J/P9+DG5duQluM++Jws264fhcg9EZ1tW29cDgZ9BpV2KbgaIn1hdI78nI8gSMvsZ4m7U2maNhNzMiFvwZ13ijNtNvo9rtkGjQxT2Nm6DUYW54NAFhP3XZFwr5duPvuu3HDDTcEXWbIkCEoLi5GQ0ODz+N2ux0tLS0oLi4O+vrOzk5ceOGFyMzMxIcffgitVht0+XhQwsVL1JEX/5VGAKWNAtHRa8Pr3x7Gku8Oiz6M0YNMONBgxjf7GnHpC2vxynUTQzLESYGnTDo8vwvgaVTXbXWgtr0XpwSYj8NTRuW5aVC5m8bFCvFCGau0UafneE/kyIs4qiHGkTDAU22UqJGXBj8N6rwpz03DtuNtiimX9jdkMpZMHZqHzUdbsfZgE35xRmysEYlO2OKloKAABQUFAy43ZcoUtLW1YfPmzZg4cSIA4KuvvoLT6cTkyZMDvq6jowOzZs2CXq/HJ598AoMh/PxiLOBVIvUdvbA7nEFnXQQjWOSF+yfIsOuiy2LH0nVH8Oo3h8Rc+agSE+7+0an4f1WFqK7txM3/9z2OtXTjpy+twxNXjMElMTC4NUYReeGN6g41dqG2vSegeIn1NGlveOQlVh12fTwvCVyREq8yaSDxq40aAjSo4/BeRUox7QYzIMeCqUPz8fxXB7DuYDMYYxCE2N7AJCKyeV5GjhyJCy+8EPPnz8fGjRuxdu1aLFiwAFdddZVYaXTy5ElUVVVh48aNAFzC5Uc/+hG6urrwxhtvoKOjA3V1dairq4PDkVhzVfIz9NCqBTiZpw12JPC0k7/IS677Tr7L6gh59k0y0mtz4PVvD+HcJ1bjyS/2or3HhmGFGXhpzgR8evs5OH9kEQRBwKhSEz657RxMG56PHpsDt/99Kx7/vBp2h7yzoZrM4U+U9sa7Y3Mg4ileMvTxSxsldOSlJT5l0oC3YTcxIy8ez0uAyIs4IiBxxak3Ypl0jP0unAmDs6HXqNDYacGBhsC90lIJWV1my5Ytw4IFC3D++edDpVLhZz/7GZ577jnxeZvNhr1796K723WC2rJli1iJNGzYMJ91HT58GJWVlXJublioVAKKTAacaO1BbVuP6IEJF38TpTmZeg10apXYyTfS91AqVrsT735/HC98tV88GQ7OS8OdM4fj0rGDxNlP3uSk6/DmDWfgyf/sxStfH8Ir3xzCrpoOPH/1eOQEGGMfLZFMlPYmlFlZ8SqTBrxSFJbYVxsltuclPmXSgFc0zGKHw8n8/hbihcPJxFRq4MiL0jwvkTWhlAq9Ro0zKnPx3YEmrDvYjOFFmXHZjkRCVvGSm5uL5cuXB3y+srISjHmqQ2bMmOHz/0SnNMuIE609EVccObwa1JX6qTYSBAF5GTrUtvei2WxJGfFidzjxwdaTeG7VfrFUdlC2EXecPww/nVDWr+lVXzRqFRZeNBKnD8rCvf/4Ad8daMIlL3yHV6+bhFGl0vtgRPESZeQlWMWRZzRAPFMUMao28opktnRZ0WWxI10f22qegei22sXtHJwbD8Ou5/Mw99qRlZY4vsDmLgsc7u66eQFuGLhh90RrD5xOFnMfV7iEOxpADqYOy8N3B5qw9kAT5k6tjNt2JAo02ygKuOCItOKo2atBXaALn1hxlEKm3euXbMR9//wBJ1p7UJCpxyOzT8NX90zHlWdUDChcvPnJmFJ8eNtUVOSm4URrD3768lp8vO2k5NsrdtcNs0Edp2SARnWMMdEcGp+7/NiZQ20OJ1q7XREePs06EXu9cDGZnaaNi3DQa9TQu8vyE63XCze35mfoA3oBS7IMUKsEWB1O1HdGV/QQC6Lp8SIVU4e6+r3891CzIkZnyA2JlyjgFUeRjgjgEZsiU/8GdRxPr5fUEC9WuxPr3OWA9104At/cex6un1IJvSay8sSqYhM+WXA2zj21AL02J37zzjY89tluSX0w4kTpqCMv/k/i7T02dLqrqspyktuw2+I+zlUCxNB4IvpejsZpLIA3sRSV4cD9IYH8LoArOsojyVyYJzKRjgaQktGlJmQaNOjotWNXTWLN+4sHJF6ioDTKRnWBpkl7k59iIwJauz0Xr1+fOxRGXfQ9FbLTXD6YW2cMBQC89u1hXL9ko3ihjAbXaIDIq42AgRvVcbNuYaZeks8jXDLc4sXqcMpuHOepmNx0PQYnsC+CR14GxyGNxzEZ+bTvxIq8iGbdAaIU5e6KIyl9TU6ZIhKJkDbSqFWYfIprUCN12yXxEhXRjgjgHVNL/VQaccTJ0ikSeeHpsdx0vaR5cLVKwH0XVuGlOROQplNj3cFmXPL8d1HfwbT32GBzuEcDRNDnBRi4UV08/S4AkKHTgFdmyn2X3+TVM4df3BIxbRTPMmlOokZePA3qgl/o+fEsVbn05qMtGPGHf+ON7w5Lsj5Or80hfsYFcUwbAcDZw1ziZd3BprhuRyJA4iUKxDvmCIcz1nUErjTiiJOlU8Tz4oliyFMZdPHpJfjw1rMxOC8NJ9t68Jt3tkW1Pn6xNRk0Eae2TEYNjO6unf7KpcUy6ThdKFUqARm62PQV4WXnBZl6MUWWiI3MeJl0RRzTRnw4Y6J12Q21Jwr/fk9IJF4+2loDm4Phy931kqyPw/0ueo1K/MzjBfe9bDrSAos9ddtnACReooJHTJq7rBGF02vEHi+Bf+SeyEtqpI08kRd5xAsAjCjOxAe3TIVKAA40mMU7xUgQu+tGkQsXBEEUwjV+onjxLJPmxKriyBN50Sd25KUp/pEXT5fdBBMvAzSo40gdedl0pEXS9XEaza79KcjUx7053KlFGcjP0KPX5sTWY21x3ZZ4Q+IlCrLTtEHvmAeiLshoAE6qjQjgF688mfsp5GXoMaLYVTa95WhrxOsRIwVRbm+wRnXxThsBnhQFH8cgF545UTpP5CXBPC8Wu0NMFcfXsBu9oHQ4meSVKwM1qONIKV7ae2zYW98JwJXGt9qlM+THezSAN4IgYOpQnjpKbd8LiZco8LljjqDiSBwN4KfHC4enjaQwlyoBvp+B+kNIycTB2QCAzdGIl87oIy9A8EZ18eyuy8mIUTt678hLWY7rM+notYvjIBKBE609cDIgTaeWLb0ZCp4uu5F/Nle/9l+c+8RqdEkoSkXPy4CGXdfx3NBpidoIvuVYK3iLMCeLvALUH/EeDdAXUbwcSG3fC4mXKOGpo3Arjrwb1AVNG7kv4k1mi6Ia+EUKjzDFRrzkAHCd+CIl2gZ1nECN6qx2p/hYvDwvgOcuX+529N6elzSdRjwOEqlc2rtMOp5phMwoxzbUtfdi4+EWnGzrwe7aDkm2yeFk4m9ioMhLTppWHD0R7ff7vTtlxJEydRTv0QB9OXuYy/ey7XibpKJTaZB4iRLxohOm0m9yN6hTq4Sgip57Xix2J7qsyW/Q4t4eudNGADCxIhcAsPNkR8R3fk1RTJT2JlCjupo2112+QauKW2tyIHaVLd6RFwAoE8ulE8f3kghl0oC3oIws8rLteJv4b6nm5TSbLXAyV6uDgX7DgiCI0bVov99NR1w3ILxAUUqTdyKljQBXxKosxwi7k2FjH9GWSpB4iRKxUV2YkReeHijM1AedS5Km0yDN3dsjFXq98JLwSMuOw6E814j8DD2sDmfEJdPRTJT2JlCjuqNeKaO43uXHKG3U9/PkF7fEiry4xUt+fMULTxtFKii3n2gT/y2VeOF+l4IBzmscKXwvVrsT291C7JzhBVGvry+JljYCgLPdVUfrU9j3QuIlSgYN0GAsELUhVBpxxBEBKeB7aRYnNMsvXgRBiNr3Eu1EaU5xgLRRIvhdgNh02bU7nGhxNynkoxb49OFEqjgS00ZxmGnkDY+GRZrK2y5D5KU+xEojTrkEjQh31rTDYnciJ02L6acWRL2+vnDxUpAgaSPANecIANamsO+FxEuUDDSXJhC1IVQaccQRASlQccSjS9yoLDfc9xK5eJHGsMu9U30b1XnKpON8oYzSXxEKLd1WMAYIApCb5hIviRx5iWeZNODp89IZgZnZ6WTYccITbZRKvHiiFKH9HqSIvHC/y6TKXDGVJ2XkJd4Tpf0xxW3a3V3bgdYUuKn1B4mXKCmNsNqI32GHEnlJlREBvTaH6OuJRdoIACZUcPHSFrYhmjEmWaQoUKO6Y2KZdHwnioueF4t8aSM+Iyo3TSfO+ipPMM+Lw8lEP8XgfOVGXg41daHTYodW7UrtnGzrQY8EnjpPd91QIy/RjwjgfpczKnNEU7tU85LsDqfow0sUwy7gSmENL8wAY65BjakIiZco4ZGTTos9LD8Aj7wE667LSZW0Ed8/nVol3unLzehBWdCqBTSZLWFfIDt67LC6BzxGmzYK1KjuaJy763Ji0aSur1kX8I28JEK1XU1bD2wOBp1aheIQL9ByEY1hl6eMxpVnI8c9FftgY/TRF3EoY4j+kAqvtFEk3y9jzCfywtOMHb12tHdHL7Sbu1zRQJUA5MUoGhwqvOpobYqOCiDxEiXpeo0Yvg00FdgffNnSbEobcTwpI13MzKkGrRqjB2UBADYfC8+5z7vrZho0MGijH5jYt1EdYyxx0kZR+itCwZOC80Sx+OThLqsDrRJcjKKFp4zKc40hGVLlhBt2rXZn2K3iuVl3bFk2hhVmAJBGvITaoI7DGxGaLfaIvt+DjV1o7bZBr1FhdGkWjDq1KH6lqDjilUb5GaEZkGPJlBRvVkfiRQK4AAkndVQXRuQlP0VGBIg9XmLc+GtiRWS+F6l6vHD6Nqpr7baJHW15BCJexKLayF/kxaBVi/6JRPC9HG3x9HiJNxle0clwI2I88jK23CNepPC9hDqUkeP9/UZist181HXDMa48GzqN63LGU6xS+F4SrceLN2cNyYNKAA41dkXU4V3pkHiRAC5eQo28OJxMHMoYbKI0R0wbJXvkRSyTju2JQmxWd7QtrNf5u9hGQ99GdbyqpdhkkCSyEw38QilntVGgyq1E8r2s2FkHAKgqzozzlrgmpfP0ajjDGS12h9iUblx5NoYWSCdeIikrjsa0y/0ukypzJFlfXxKxTJqTZdTidHfUOBWnTJN4kYBwG9U1mS1wuBvUFYTgyhfTRsnueeFzjWLQXdebCW7xsqeuI6zZPWJPkkxptlcsl3ZXriVKmTTgPQRQRvHCqzr6/CYSpeKourYD3+5vgkoArj6zIq7bwonEi1Rd2wmbgyE3XYeyHCOGSpQ2sjucXt11Q7/Yi+I0gu/X2+/CkVS8JFiDur5Mcfd7WXsg9VJHJF4kgEdeToZYLs3TS0UhNnLKS5Fqo+YYzjXypshkQFmOEU7m2/tiIKSOvJT2SRsdTxCzLuC5SPbYHLA5pBt6501jgM+TmzCl7JoaCa99ewgAcNHpJeIFN954vEihR17ElFFZFgRBwDB35OVwUxfsUXy3TWaXuVWtEsL6DUfa66WhsxdHmrshCJ6qwWjW5w/vidKJyNnDuO+lKSEM7bGExIsEBJpLE4hw/C6A52Te0mVN6gPU43mJ/Ykikn4vvLRXKvHCjweeUkykyAsfzAjIlzpq9Joo7Y0n8hK/tFFdey8+2VYDALhp2pC4bUdfTMbwIy/efhfAZYo2atWwOVhU0QrudynI0EMVhrm1PMIRAZvdKaMRRZnIcpuXAWnFS6JHXiYNzoVOrUJtu0vIpRIkXiQg2ERgf9SI06RDM2HmpLt+mHYnQ0dP8g7i8sw1iv2k3gkRmHZFw65EJzYeeWnpsqLX5hArWxJBvGjVKrEPjVypo4E9L/E7OS9ddwR2J8OZp+SKF/1EwDNzKvTIyzZeaeTeD5VKwJAClwE5Gt8L94eEWmnEiTTN8/1R3t8l1+dxvr4TrT1wOKO72RO76yag5wUAjDo1xldkA0i9brskXiTAu1FdKJGROt6gLsS8sF6jFsP2TUlccRTLidJ98Z4w7QzxhCd12qhvozp+sU6cFIX7Ll+GRnUOJ0NLl38x6D0iIB6RR7PFjmUbjgIA5idQ1AXwdNkN9aamvceGQ40uI/jYsmzxcW7aPeh+LhLCbVDH4WnRk209YaWtPH6XHJ/Hi0wG6NQq2J0s7LEtfeHRwESsNuJMTdE5RyReJICH+y12Z0i9CsKNvACeC2QyVxyJht04pI2qijNh1KrR2WvHgRCNi00Sz2HyblR3pLkLte6LweAE8LwAntSRHJGX1m4ruGbM7SNeS7INUAmu31djHHxf7206js5eO4bkp+P8qsKYv38wwo288JEA5blGn89ZinLpBnGuUXi/36JMl9hwOFnI0etuqx07a1wVU5P6RF7UKs+06mjSYIwxj3hJ0LQR4Ot7CfXGKxkg8SIBeo2nMVIovV7qxLlGod+h5Ca5aZcxFjfDLgBo1CqMc4fRQ0kdMcYCGkyjgR8Tm4+2gjEgTaeOy+fhj0wZK454FCsnTQut2ve0pFWrxNRsrH0vdocTb3x3GAAwb9opYXk5YoGny25o34l3czpvRPESRcVRvegPCS/yovISG6GmBrcda4PDyVCaZRAbGXrDo5Unoiivb+u2iR20E9WwCwBjyrKRplOjtduGPXWd8d6cmEHiRSLCmXEUzkRpTl6SjwjosjpgsbtOFPHwvADhmXY7eu2w2qU/sRWbXCfiDYdcIfGK3LSYdRseCJOMjeoGMj8PCvPiJhUrdtXhZFsPctN1+NmEspi+dyjwLruhVhtt8xoL4I3YZbfBHHFqThwNEEGKpSzMcmlPf5dcv8+XS9CojvtdstO00Gvi22cpGDqNCmee4vocUqnfC4kXifBUHAUPezqcDPXuH0UoE6U5yT4igEeUjFo10nSxmWvUF2/fy0DwSEGGXprRABwugvlFJlH8LoC8840G8g95+15iBWMMr33jKo++7qzBcW8U6I9wv5O+lUacwXlpUKsEmC12MYISLmLkJYKZT+F2xf3e3Vn3jD5+F8/6ou/1kojTpANxttjvhcQLESZciNQMYBBr7AyvQR3HE3lJzrSRp7tu/FIk3LV/qLELLQNEuJoClPVGC/dP8XD14EQSL3rXXX44jfxCxTPXyP9vIh6N6jYebsH2E+3Qa1S4bsrgmL1vOPDmgaF02K1r70VDpwVqlYDTSk0+z+k1avGCH2mzunCHMnoj9vIJIc1jdzix5WjwyIsU4iWRRwP0hc852ni4RbY+TIkGiReJ4HfMtQM0quPu91Ab1HHyMpI7bRTPHi+c7DSdGD7fOkD0JVBZb7T0HReRCA3qOBlRTDEeiMYB5kSV58Y+8vLaty6vy08nlEn+PUtFOJEXHs07tSjTb3QzmjEBNodT/E1EkjYKR2zsqetEl9WBTIMGpxb5H9MgRXl9Io8G6MuoEhOy07Tosjrwg9vXlOyQeJEIz3yj4CfX2ggqjQDvtFGSRl7iNBqgLxPc0ZeBfC9S93jh9G1cmDJpI+55CTBqIVxDZ7QcbDTjy+p6AMCvpp0Sk/eMhHA67HKz7rjyLL/PR1NxxH8PGpWAnLTwf8PhiA1eIj2hIifgDSBfX3OXFV0RRgoTvUGdNyqVgClD3FVHKTIqgMSLRIhpowEjL+F11+XkJ/lwxnhWGnkTqmlX6h4vnL4m7kRoUMeJRbVRQM9LrqcXSCzKQXmF0cyRhWJEIhHJCqPDrmcsQLbf56MRL/VeF/pIKrLCERubxOZ0/v0ugCudlp3mOl4jHSvB00aJXGnkzdRhbt9Liph2SbxIBE8b1XX0Bu3qyCuNSsMUL7nutNFAXgylkghpI8AjXrafaAuaO5ZLvGQZtWKjOkHwRBwSgUwZq40GMkcWmwzQqATYHAz1naH1AomUZrMF728+ASDxmtL1xbvPS7AqIaeT4Qd3j5dAHYKHurvsRuJ5ibRBHSfLqBVb/AcTG4wxv8MY/SGmoiJsmy+mjSLcp1gz1e172XK0LaSqV6VD4kUiCjMNUKsEOJyexkb+4I3HisOoNAKAvHT3fKNua9QtrxMRcTRAnCMvQ/IzkGXUotfmRHVtR8DlGgdIc0SKIAhi9KXEZEioEk1eKi3HbKOBxKBaJYipWbl9L2//9ygsdifGlmWJJaiJCjfsOpmr3UAgDjWZYbbYYdSqMbzQfySJT5du6LSE7WuKtEGdN7y8OZhp90RrD+o7LNCqhYARJM/6ojPtKqFBnTdD8tMxrjwbVocTty7bIrZySFZIvEiEWiWgyH2QB6s4ijTykpOmhSAAjLm6kSYbnshLfMWLSiWE5HuRo0Edh3fZTSS/CwBk6OVJGzmdngaFwcRgLHwvvTYH3lrvGgXwq2lDEqbHTiAMWhU07jRNsIjYtuOuqMvpg7KgUfs/7ZsMWlF8hJs6irRBnTehmHZ5ifToQVkw6oIL+4ooTbtKEy+CIOD5q8fDZNBg2/E2/O/n1bK919ZjregJIpZjAYkXCRFNu0F8L+FOlOZo1Cpku8Oqyeh78ZRKx/9EEYrvxVMqLf328kZ1iTIWgCNX2qitxyZGE3mE0R+x6PXy/pYTaOmyYlC2EReNLpbtfaRCEARPl90g8408/V38m3U5kfpeomlQx/GUSwcWG7w5Xd9hjP4QxUsEx0u31S62BFCK5wVw3fD89RfjALiGif5re43k77HpSAuufu2/uH7JBllSyKFC4kVCSgaoOPJuUFcaZrUR4FVxlIS9XhKl2ggAJrjFy9ZjbX6fZ4x5qo1kEC/ThudDoxJw7qkFkq87GuSqNuKfZZZRC50m8ClJ7siL08nwhrs8+pfnnBIwQpFo8C67wS4k2/tMkg7EsAJPp91wiKZBHSeUiiPud+E3GEHXlxN52ohXGhm1amTo49M0M1JmjirCLTOGAgAeeP+HqOZV9WXnyXb88s1N6LU5kabTxDWtrYxfp0LgqaCTAcxSvEGdRiVEdMeel6QVR04nE43I8U4bAa5qDLVKwMm2Hr9C1Gyxi6MMpPa8AMBl4wdh1yOz8JMxpZKvOxq4OdRstUta8RNqw7/yMFvIh8uqPQ041NSFTIMGV55RLst7yMFAorLX5hD9WwP5RLjvJVzTbr3oeZEvbdTWbcW+etd2TQpBvHinjcI9Xhu8pkkneurQH3dfcCrOGpKLLqsDty7bjG5r9DccBxvNmLtkIzotdpxZmYvF104MerMhN7K+c0tLC+bMmQOTyYTs7GzMmzcPZnNoPwrGGC666CIIgoCPPvpIzs2UDHFEQIC0EffCFJkMYTWo4+Qnaa+Xjl4b7O6TS9+JwvEgXa/ByBJX86stR9v6Pc+bcaXr5BtlkEhGXQ6/SDIGdElwMuSE6h/ydNmVJ2302reuUQDXTK5Q1N22aYBeL9W1HbA5GPLSdQNWrw2LsFFdgwT+EG9x6q9yiqdxhxSkh5ReLsl2nWcjmUYudtdVUMrIG41aheeuHo+CTD321Zvx+w93RjyzCnDdkF/3+gY0d1kxepAJr98waUDPkdzIKl7mzJmDXbt2YeXKlfj000/xzTff4Kabbgrptc8884ziFO9AaaNI/S4cfmFPtnJp7nfJNMQ3DOnNhIrAvpeBWtknK3qNClo1N4dKJ164GBzIW8AvbrXtvbBL3AJ9+/E2bDzcAo1KwI1TE7cpnT8GmiztPc9ooHMq97wca+lGry00Q6bV7hTPSdFEXgZlGyEIQK/Nv9j4nvd3GRxaBZhWrRJbWISbOmqQwIAcbwozDXjh6vFQqwR8uPUklm88FtF6GjstuPb1Dahp78XQgnT87cYzRcEcT2QTL9XV1VixYgVef/11TJ48Geeccw6ef/55vPPOO6ipCW4i2rZtG/7yl79gyZIlcm2eLJSK840CRF4imCbtDU+pNCWbeOGVRgkQdeGIpl0/YwLkNOsmMoIgiCet9hBm6YRKqD1zCjL00GlUcDjZgANQw4VHXS4dWxrxzUW8yBxgvtF23t9lgJQR4BKQmQYNnAw40twV0vtzoaFVC8hJi/yiptOoUOIWP/7KpT39XQZOGXEi7fXCI0lKMuv6Y/KQPNw3awQA4I+f7A57dEB7tw3XL9mIw01dGJRtxP/9anJCFFUAMoqX9evXIzs7G5MmTRIfmzlzJlQqFTZs2BDwdd3d3bjmmmvw4osvorh4YLe/xWJBR0eHz1+84Cq/yWzxW2PPIy+Ri5fkTBuJZt0E+VEAnsjLrpPt/e5APWmOxBFbsYKXcUuZumkK8UKhUgkoc0c3pfS9HG/pxuc7agG4yqOVhmmAzsehVhoBLoE6VDTthiZexAZ1mYaoo+WBTLu9Nge2u8u9Q6k0EteXE5lPqtHL86J0bjp3CC4YVQSrw4lb/m8L2kJstdFttePGpRtRXduB/Aw9lv1qsthJPhGQTbzU1dWhsLDQ5zGNRoPc3FzU1dUFfN1vf/tbTJ06FbNnzw7pfR5//HFkZWWJf+Xl8TPa5abroNeowJjnB+2NONcowgNASsPu4aYuPPrpbrR3x6/UjZMoowG8KcsxojBTD7tXZ1JOqkZeAGBwrqsL69EQ78pDIRwxOEgG38uStYfhZMA5w/Ixqs+0ZSUQrIS9vceGQ02u7yqUyAsQfrl0g9hdN/rfQyDxsvNkO6wOJ/IzdGG1EIi0UZ04GiAJfuOCIOCpn49FRW4aTrb14O73tg9oYLbYHbj57c3YcqwNWUYt/u9XZ6IyPz1GWxwaYYuXBx54AIIgBP3bs2dPRBvzySef4KuvvsIzzzwT8msWLlyI9vZ28e/48eMRvbcUeHdH9VdxxL0wEUdeJPS8/HXlPrzx3WEs/uZg1OuKlkRpUOeNIAgB+700yjRRWgnwKdeRdi31RzijFsTp0hK9f3u3De9ucp0z5p+rvKgL4CmV9ud52eEW3oPz0pAT4s2BKF5CrDjiKZYiCfwhgSqOeH+XSYNzw4ruRNqorlFhowEGIsuoxUtzJkCnUWHVnga8/HXg877d4cQdf9+Kb/c3IU2nxps3noGq4sQT9WFb6u+++27ccMMNQZcZMmQIiouL0dDQ4PO43W5HS0tLwHTQV199hYMHDyI7O9vn8Z/97GeYNm0a1qxZ0+81er0een3iXERKsow40tzt17Qb6URpDk+rNEmQNtp50nVSW3cw/hNIPaMBEud7BFy+l3/vrOsnXlLVsAsAg90Xg6MRzovxhzhROgTxInXF0fKNx9BtdWBEUSbOHZ4vyTpjTbDIi9jfJcSoCxB+xVG9BKMBOHxEQF/xEonfBQita68/pKieSjRGD8rCI5eehgc+2IG//GcvxldkY+pQ32Pe6WS4//0d+GJXPXRqFV67fpKYQk80whYvBQUFKCgYuHnWlClT0NbWhs2bN2PixIkAXOLE6XRi8uTJfl/zwAMP4Fe/+pXPY6effjqefvppXHLJJeFualzgnoC+06XtDqf4g4g28tLRa4fV7oy4xt5sseOwO5S882Q7OnttoukvHiRi5AXwblbXCsaYeMcnZ4O6REfqyAtjTBSvoYjBSD0M/rDanVi6ztWU7lfTTlFcdSPHJHbY7S9etrn9LmPKBva7cHjk5VCjGQ4nG7CtgxQN6jhcbHiLU6eTicb5cPwu3uur77Cg1+aAQTtwNaN39VQyiRcAuPKMcnx/tBX/3HwCd/x9Kz67Y5pYIcYYwyOf7sb7W05ArRLwwjXjcfawxBX0snleRo4ciQsvvBDz58/Hxo0bsXbtWixYsABXXXUVSktdzbdOnjyJqqoqbNy4EQBQXFyM0aNH+/wBQEVFBU45RRnli7ziqG/kpdEcXYM6wBX64yeSaOYb7fEaOOhwMnx/JHAb/FggRl4STAycVmqCTqNCc5fVJ9IgihcZGtQlOoPzXHnvE63dkgwIbe+xwebgowEG/jyljLys3F2P+g4LCjP1uHRcYjUEDIdAhl3GmChexg3QWdebshwjdGoVLHZnSNOJpWhQx+FpwZr2HrHo4WCjGW3dNhi16rA9SdlpWrFnT6jHDP99a1QCctKS6zcuCAIenT0aVcWZaDJbsWD5FtjcbQee/nI/lq47AgB46udj8KPTEns8hqx9XpYtW4aqqiqcf/75uPjii3HOOefg1VdfFZ+32WzYu3cvurvlG7QWawLNN+Ipo0gb1AGuagve6yWa1NGuGt+KrPWH4ps6SsRSacDVKO70Qa47Vp46YoyFleZINopNBujUKtgcLKQL20Dw4zjToAnprphf3Oo6emGxRzcYbvVeV1p79rjShOkvFAmZAcRLXUcvGjstUKsEnFYaeuRFo1bhFLc5M5TUkZQDDAsy9DBoXUUP/PjifpfxFdnQhjmyQRCEkMYOeONdJq2K8FydyBh1arx87URk6DXYdKQVT32xF69/ewjPrdoPAHhk9mm4fHxZnLdyYGQVL7m5uVi+fDk6OzvR3t6OJUuWICPDM469srISjDHMmDEj4DoYY7jsssvk3ExJ4WmjvoZdLmYiTRlxpKg42lXj8rtUulMA6+Pse2lOoNEAfenb76XL6kCPu3Q6FcWLWiWgLIAvIRIa3UIw1BRcXroORq0ajAUfgDoQjDF8u78RADD91MIBlk5sPE3qfNNGvER6RFFm2N1Qw6k4kjLyIghCv5lEHr9LeCkjTkWYx6vSpklHwin56XjyijEAgFe+OYT/+cw1gfreWSNw/ZTKOG5Z6NBsI4nxpI36Rl5cYibaBlj8Ah/NcMbd7rTRjWe7UnG7atolbToWDg4nE1NgiWbYBTz9Xra4Iy+8TNqoVSNdQS3kpaTSnToKtYlZMMI1PwuC4BnQGIXvZW99J+o7LDBoVWGbQBMNXm3UbXX4dB7e5u6LMtAwRn8MDVG8WOwOtLrbLUhh2AX6z7DadNQtXkKYZ+SPcE27Ypl0EosXALjo9BLMO8djx7j53CG41T3QUQmQeJEYHnlp77H5DMPiYiaSadLe8At8pJEXm8OJfXWuE9L/qyrEkPx0OBmw8XBLVNsVKa3dVvCRG9F055SLCYOzAbgudh29Nq+LbeJFiWJFpF1L/RGJ+VkK38s3+1xRl8mn5IWUrkpkeOQF8E0dbRf9LqGnjDhDC9xpowHKpXkbfZ1GhSyjNL9fb7FR39GL4y09UAmutFG06wsFvk8FCh4NECoPXFSFm84dgoUXVeGBi6oUZVon8SIxJoPHIOZdcSTONYoytOqJvEQmXvbXm2F1OJFp0KAsx4izhuYBiF/qiIuwnDQtNGHms2NBYaYBFblpYAzYdqwtrJ4kyQpvEiZFuXRTBN2Kw/Uw+OPb/U0AgHNPHbhyMtHRqlUwugUYFy8OJ8OOk5FHXrzTRsEG+nkPMJTqwidG1lq6xWKCkSWmiCsiyyL0vCRz2oijVavwu4tH4ubpQxUlXAASL7IgTpf2qjjiE6X5CIFI8XheIksb8ZTRqBITBEHAlCFu8RIn026iVhp5492sjjeoS8UyaY4oXiTwvERifo428tJjdWCDO9I4/dTELQUNh76+l0ONZpgtdqTp1BhemBn2+oYWZEAQXBHkYDdKPEohhd+F42ks14NNbr9LuCXS/tfnf1p1Xxq5IEuC0QDJDIkXGfBXceSZKB1l2sh9ko+0yy436/Lqg7Pc4qW6tgOtcRj4mKiVRt7wfi9bjrV6RgOkwF1ZICrcIwKONXeFdDEIRmMEDf+i7fWy4XAzrHYnSrIM4hwfpdNXvPAS6dGDsiKqbjRo1aJIDOZ7kbJBHce7l9D3RyNrTucNn1bdZXWEdN70RF6SP22kZEi8yEBpn4oju8Mp/shLJao2aorQ88LLpHm/hIJMPYa7Q8QbDsc++uIZypi44mWi27S77VibeGJL5bRRea7nYhBp+pITSRquLKd/I7Nw+GafO2U0vEBxofJAcNMuTxvxzrrh9HfpSyiddutluNBzcdreYxPPV5MGRx55MWjVYro+FN8LjyalQtpIyZB4kYGSPo3qGs0WOJmr6VG06ZFoqo0YY6h2nwxO82r2NCWOvhfPUMbEPVGMKM5Euk6NTosd6w+6LnwFCSy25EavUaPEfTGI1vfiGXIZjufF9ftq7LT0m/gdCrxEOhn8LhzuB+FddvkE5nDGAvRFnC4dxLRbL+FQRk66XiPepDHmShNGW6UZ6oBGp5OJgprSRokNiRcZ8HheXD9sbtyNpkEdh1/kWyKIvBxv6UGnxQ6dWiUa8gDE1feSyD1eOGqVgHHuSocj7ot1KkdeAO/QfuTl0owxMYIYzueZZQy/ayqnpq0H+xvMUAmuKdLJgkmcb2RHr82Bare3bWwElUacUHq9NEo4lNEbbrIFovO7cMpDjNa1dlthd/KOz6n9G090SLzIAPe88A6R3O8SbYM6wHOR77I60GMN766T+11OLc7w6VQ52S1e9tWbJRn6GA5i2iiBPS+AJ3XESWXPCwAMdvteoom8dPTaYXX3JQmnp0Y0vV541GVseTayErA0P1K8u+zuru2A3cmQn6HDoChaM3DxcjAkz4u04qXCS7xI0Ycn1PJ+nhbOTddFPDuOiA307ciAd+SFMSamjyKdJu1Nhl4j/qjCTR3xSqPTSnzvxnLTdagqdlUk/DfG0RfPUMbEFgMT+jTIoshL9L1euFDO0Ic2GsCbSH0v3O8ybXjypIwAr+GMvTb84Dbrji3LjsrTw8VLTXsvuix2v8vUi9VG0v4eynM850opIi8VeaF12U2lMmmlQ+JFBnjkpdvqQEePXUwfSRF5EQQh4hEB3Px22qD+w83i5Xtp6Ur8aiMAGN8n8pLs3TcHQopy6SavGTLhwn0vJ8J4f4eT4bsDLvGSLCXSHI9h14btJyLv7+JNdppO9CL587302hxiZ26pK3N4pCTLqBWNw1Ksb0Dx0pEa3XWTARIvMmDQqsUBiifbejyRFwnEC+BJHYVbLs3TRqNK+ouXs+Lke2lSQLUR4DqJnlrkOokatCqkhzkrJtmQIm3k8buE/91HEnn54UQb2ntsyDRoojKyJiJiqXSPXeysG614AYAhQUy73O+i16hgMko7KuPsYfnI0GtwxcQySYYjcsNubXuPOEXZH1QmrRxIvMiEd6M6KSMvgMdIFo4/pclsQX2HBYIAVPkTL6fkQRCAQ41dYh5bbqx2JzrcpZ1KMMfxZnX5GdJ1E1UqPG3UZLYETCkMRDTdissj8LzwlNE5w/ITsptzNJjcnpeTbT041OQyUY8ti9ysywlm2vX2u0j9eyjPTcOOh3+EB388UpL18WnVTq9p1f4QhzJSpVHCk1y/4ASCl0vXtPd6TZSO3vMCeHXZDSPystudMqrMSxcrNbzJStOKEZlY+V545EitEiSbiyInE929JqQ2JyqRLKMW2W7Da6TTpaMRL5FEXr5xm3WTze8CeCIvO70mxmenRR/NDNbrRS6/C0cQBMlEkb9p1f5IhYnSyQKJF5ngjepOtHaL8z/imTbq25zOH7xkOlbihRuOc9N1koSG5eYnY0pw49mVuOdHI+K9KQnB4DyeOoqsXLoxioZ/ZW7PS0uXNaTIT3uPTew6e26S+V0AT7URb3gsRcoICC3yUqgQMR+K7yVVJkonAyReZIKbdrcfbxMb1ElVocIrc8JJG4mVRsHES4xNu0oYDeCNQavGoktOEz+nVGdwbnQDGqOZ0G0yaMVoXSjRl/UHm+BwMgwpSBejNslEX8+JVJ6eoW7xcrS5u59XRGmVOaE0qiPPi3Ig8SITPMrCO10WmQySRRdyI6g2CmbW5ZxxSi5UgqsRm/dQSbnwDGVUhnghfIm24qgxggZ13vCKo1CmBX/tNRIgGek7cVmqyEtplgFpOjXsTtZPpDbI1ONFLioGmC7NGKPRAAqCxItM8MhLj7t9ebTTpL3JD3NEQJfFjsNuEx8fyOgPk0GL0we5no9F9MUTeaEThRIJtfFXIJqinBNVls19L8HfnzGGb/bxkQDJlzICPH1eAFeUN1iENRwEQRDHBPRNHdV3Sj+UUU7KvaZV+8NssYvnazLsJj4kXmSir78l2mnS3oQ7ImBPXScYc91NDJTLPSuGqSNuOM5VSNqI8EX0vEQwIsA1GsDd5yXayMsAaaNDTV042dYDnVoltgRINtJ1GnBv64jizLCb/gVD7LTbp1xaNOwqJMUykOeFp4wy9Bqk6aQt/Sakh8SLTLjKBz3/j3aatDc8zdLUZQXjDr0g7OYpoxDuxmI556hZrDYh8aJEeNqopq03aO8Mf5gtdljsrtdE4nkBPBVHA6WNvnVHXSZV5iTtRUmlEsQqQqlSRpxApl05hjLKCRe77T02tHfb+j1PKSNlQeJFJrRqlc+PINqpqN7wyIvV7oQ5hEqLXX4mSQfijMpcaFQCTrT2hOQliAaljAYg/FOY6eqd4XAynAyzTT9vUJeuU0csKMQuuwO89zf73X6XJJoi7Q/e62WcxA34hha4ImzekZceqwOd7h5NSqk2StNpxBSlv/5AjTwSSOJFEZB4kZFSr1lGUvV4AQCjTo00d4fXUMqlPZVGAzetStdrMMbd3Eru6EuzQkYDEP4RBEEMxYdr2vVUGkV+oRAjL0E8Lxa7Q0yBJqtZlzNlaB5MBo3kIs17QCOP9PKSYqNWjUw/faMSlYrcwDOOaDSAsiDxIiOlWd7iRdq7EzF1NIDvxeZwYk9dJ4DglUbe8FLg/8rse6FqI+VT4R4TcCzMXi/RmnUBiJOlO3vt4oydvmw+0ooemwP5GXpx+Giy8uQVY/D9gxdIGuUFXN4mjUpAl9Uhdgv3blCnpG7T5UEqjhqpTFpRkHiREW/BUiJhtREA5LpTR80D9Ho52GiG1e5Ehl7jM2Y+GFOGuCoy1h9qDslTEylUbaR8xHLpMCuOmiTwO6XpNGLULlCKU0wZDc9XRCPEaBAEQZw4LyVatUr8nrnvRfS7KOxCH8y020CjARQFiRcZKXGnjbRqAfkSX6Dz00PrssvHAowqMYV88p44OAdatYDa9t6oBu8Fo8fqQLfVVZZIkRflEmmvl2i663pTlht8TICnRDq5U0Zy07dcWqkX+mCN6ngqjAy7yoDEi4zwCiMpG9Rx8sReL8HFSyhjAfpi1Kkxzl2xIJfvhaeMdGqV31lLhDKItNdLtA3qODx15K/XS2OnRfR7nTM8Ofu7xIq+5dJKa1DHCdaozlNtpKx9SlVIvMjI5CF5GFqQjp9NKJN83aGOCNgVRpm0N2LJtEy+F0+lkU5ROXPCF97r5VhLd1gpRikMuwDEYXv+Ii/fugcxnlZqkmw0R6rSt1zaM1FaWZ8rFy8n23rgcPoer0qNJqUqJF5kJDddh1V3z8BvLzhV8nXnhTAigDEmpo3C7bgpNquTyffC012UMlI2g7KNUKsE9NgcYiooFDwN6qL7/nnkxd+d9LcpUiIdC/pGXuoVGqUoMhmgVQuwORjq3AIMcFWlcdM3pY2UAYkXhRLKZOkTrT3o6LVDqxYwvDC8SosJFTnQaVRo7LTgYGNkU4ODwS9euWTWVTQ6jUocfRGO78Vj2I0y8hLA8+J0MjHykuwl0rGAe16azFa0dVs9/hCFRSnUKkEssfdOdXLhrVOrxIGfRGJD4kWh8AqdYGkj7ncZXpgZdhWCQavGhIpsAPL4XrhXJ596vCiewe5y6SNNoYvcpk5pPS/HW33TVrtrO9BktiJNp8bEwTlRvQfh6v/EqycPNppFf4jSPC+A/3JpnjIqyFRW6XcqQ+JFoYiTpYNEXrhZMVy/C4eXTMvR74WXeFPaSPlU5AWfGdOXLq8BeNE2BBvkrujrtjrQ6tXy/Rt31GXKkDxZyodTEZ46+uFEOzrdnb2VKF78NarjYowa1CkH+lUrFH7H2tplhdPp35PCZxpFOmFWbFYng+9F7K5LRkrFMzg3vF4vPFpo1KqRHmWlmUGrFj0K3nfS3+4jv4vU8NTROvfNTLpOrchKQX+9XhqpTFpxkHhRKDzyYncydPT67y7qMesOPBbAH2PLs2DQqtDcZcX+PkPZooUbjWmitPIJt9eLp9JImu++r++ly2LH90dbAJB4kRIeefmvO42slJlGfSn3M1aCKo2UB4kXhaLTqJBpcN31+BsR0NplRY27lffIksjaous1akwanAtA+pJp3ueFJkorn3BHBDRK5HfhePteANfF1eZgKM81ojIvtK7SxMDwyIs4kFGhUQq/nheFVk+lMiReFAw/+fsbEcDNuoPz0pBpiNw9z1NHUouXFhoNkDRwz0trty1gFNAbqSqNOJ5eL66LkdhVd3gBmS8lhEdeOEr0uwCe47XJbEWX27vDJ0orVZClIiReFExekBEBu2uj87twznI3q/vv4eaA3ppwYYyhqYvSRslChl4jRtBC6bQr1WgAjqfXiyttxOcZTaMSaUnJz9D5lBErrUEdx2TQIjvNtR88WsdLv8mwqxxIvCgYcbK0H/Gyy2umUTSMKctCmk6Ntm6bOJ06WswWO6x2JwCqNkoWKsIw7UrVoI7j8bx043hLNw43dUGtEjB1WJ4k6ydcCILgE31Rcoql71gLShspDxIvCibYZOldUZp1OVq1CpMq3b4Xifq9cLNumk6NNJ3yqhWI/vAxAUdbBva9SDUagOOZb9SDr90powkV2TBFkS4l/DOswEu8KDTyAnhSjcdauuFwMvGYVPI+pRqyiZeWlhbMmTMHJpMJ2dnZmDdvHszmgStW1q9fj//3//4f0tPTYTKZcO6556Knx//E2FQnP0CX3R6rA4fcbbyjTRsB0s85aqbRAElHOAMamyQaysgpyTJCJQAWuxMfbDkBgLrqysXQwnTx30r1vAC+FWrNXRY4GSAInlQ8kfjIJl7mzJmDXbt2YeXKlfj000/xzTff4Kabbgr6mvXr1+PCCy/Ej370I2zcuBGbNm3CggULoFJRgMgfgeYb7anrgJO5xI0UOVxu2t1wuLnfMLNIaKbRAEmHWC4dRtpIKvGi06hQ7L6QbjnWBgCYRiXSsuCdNlKyePHu9cJTRnnpemjUdK1RCrLE7Kurq7FixQps2rQJkyZNAgA8//zzuPjii/HUU0+htLTU7+t++9vf4o477sADDzwgPjZixIig72WxWGCxeNImHR0dEuyBMsgNMFla9LuUZklSbTG61IQMvQadvXbsrunA6WXRpaJoNEDyMTiMLrtNndJ3My3LTRNbA2SnaXH6oOiOUcI/wwo8bReUXJnjLV64gVzJ+5OKyCIz169fj+zsbFG4AMDMmTOhUqmwYcMGv69paGjAhg0bUFhYiKlTp6KoqAjTp0/Hd999F/S9Hn/8cWRlZYl/5eXlku5LIpMfYEQAHwsgRcoIADRqFc48hftemqJeH02UTj6456WmvQcWuyPgcj1WB7qsruel7PHDfS8AcM6wfKhVVCItB+W5RsyZXIGbzx0SdXfkeFLh1eulvkOZQyZTHVnES11dHQoLC30e02g0yM3NRV1dnd/XHDp0CADw8MMPY/78+VixYgUmTJiA888/H/v37w/4XgsXLkR7e7v4d/z4cel2JMHhrfX7el6kqjTyRkrfC02UTj7y0nVI16nBWP8Jz97w716vUUnaWp4bMAHqqisngiDgsctPx8KLR8Z7U6KiJNsg+qT4zV4BjSpRFGGJlwceeACCIAT927NnT0Qb4nS6Smdvvvlm3HjjjRg/fjyefvppjBgxAkuWLAn4Or1eD5PJ5POXKvAeKa3dVtgdrs/P7nBij8SRF8Dje9l0pFV8r0hpFg2bFHlJFgRBQAWvOArSabfRy+8iZQM5bsAEgGnD8yVbL5GcaNUqlLqHen5/pBUARV6URli3PnfffTduuOGGoMsMGTIExcXFaGho8HncbrejpaUFxcXFfl9XUlICABg1apTP4yNHjsSxY8fC2cyUISdNC0EAGHN1Ny3I1ONwUxcsdifSdGpU5qUPvJIQGVligsmgQUevHTtOtmN8RU7E6+KjAShtlFwMzk1DdW1HUNMu97tIVSbN4UJ9bHk2SrKMAyxNEK7U0YnWHuypc93sUY8XZRGWeCkoKEBBwcAh2SlTpqCtrQ2bN2/GxIkTAQBfffUVnE4nJk+e7Pc1lZWVKC0txd69e30e37dvHy666KJwNjNl0KhVyEnToaXLipYuKwoy9WLKaGSJCSoJ8/5qlYAzT8nFl9UN2Hy0NTrxQqMBkpJQKo4aJW5QxxlZYsL7t0z18b4QRDAqctOw7mAzeAElGXaVhSyel5EjR+LCCy/E/PnzsXHjRqxduxYLFizAVVddJVYanTx5ElVVVdi4cSMAV9j53nvvxXPPPYd//vOfOHDgAP7whz9gz549mDdvnhybmRR4yqVdF4VdNdKMBfAHFyxbj7dFtZ5mGg2QlFSEUHHUJPFQRm8mDs5RdPkuEVu8U40ApY2Uhmx28WXLlmHBggU4//zzoVKp8LOf/QzPPfec+LzNZsPevXvR3e050d15553o7e3Fb3/7W7S0tGDs2LFYuXIlhg4dKtdmKh4uAPiIAG4+k9KsyxlXng0A2ObupREJTicTDcZyXMCI+DE4d2DPi9Q9XggiUvqJF0obKQrZxEtubi6WL18e8PnKykow1r/h2QMPPODT54UIDr8ItJgtYIxJNhbAH2PKsiAIwMm2HjR09kb0Y+/otYmN7ijyklzwtNHx1h44ncxv2tIjXui7J+JLRR/xQkMZlQW1E1Q43PTa3GVFTXsv2rpt0KgEDC/KGOCV4ZNp0GK4u8NmpNEX3ho+06CBTkOHXzJRkmWARiXAaneizt07oy9SzzUiiEjxFi+ZBg0MWnUct4YIF7p6KBwxbWS2Yrc76jKsMEO2H6KYOorQ99JMaYOkRaNWiYbZQKZdLl6ppwYRb3LStGKvITLrKg8SLwqHN6prNltEs+4oGcy6nHHlLtNupOJF7K5LKaOkhPd6ORZgurRcpdIEES6CIIi+F/K7KA8SLwqHjwho6bLK6nfh8MjL9uNtEQ1pbKJKo6RmcG7gculemwOdFjsAirwRiUG5O1JIlUbKg8SLwhEjL12etJEclUacU4sykKZTo8vqwIEGc9iv52mjPLp4JSVirxc/5dLc76JTq2AyKHcuDpE88CnZ3uMlCGVAZxCFwyMYJ9t6YLW72vbLmTbSqFU4fVAWNhxuwbbjrRhRnDnwi7yg0QDJDR/QeMxP5KXJ67uXcjQAQUTKr6YNQV6GHpePHxTvTSHChCIvCoeLAC5cynONyDJqZX3PcRXZACLzvZDnJbnxdNnt73khvwuRaOSm6zDvnFMoja1ASLwoHJNBC41XPw05U0ac8W7fy9YIyqXFidKUNkpKePlpR68dbd2+084bqdKMIAiJIPGicFQqATledw1ymnU5vOJoX30nutwGzFDhowHy6U4nKTFo1Shymx/7mnbFyAulDAmCiBISL0lAno94kT/yUpxlQEmWAU4G/HCiPazXimkjuvtOWviYgCN9Ukc0GoAgCKkg8ZIEeF8M5DTrehNJszq7w4nWbiqVTnbEAY19Iy9mmmlFEIQ0kHhJArgQyE3XoThGU3U94qU15Ne0dtvAGCAIru6WRHIi9nrpUy7NPS80Q4YgiGgh8ZIE8PlGp5WaYlaCGknkpbnLdfHKSdNBo6ZDL1kJHHmhtBFBENJAV5AkYEyZy6Q7bXh+zN7z9LIsqFUC6jssqG3vCek1LWYqk04FeK+Xo31GBHDDbkEmff8EQUQHNalLAi4fX4azhuTFLGUEAGk6DUYUZWJ3bQe2HmtDyenGAV9DowFSA542qu+woNfmgEGrhsXuQEcvjQYgCEIaKPKSJJRkGWPetTTcZnU0UTo1yE7TItPd/v+Y2/fCOytr1YLsTRQJgkh+SLwQESP6XkJsVucpk6bISzIjCIJXp12XeOF+l7x0PY0GIAgiaki8EBHDO+3uONkOu8M54PK8VJbSRskP7/XCxwQ0iqMB6LsnCCJ6SLwQETO0IAOZeg16bA7sre8ccHmaKJ068MgLTxtRpRFBEFJC4oWIGJVKwNgw5hzRaIDUoX/aiBrUEQQhHSReiKgIp99LC1UbpQwV7rQRj7yIaSMSLwRBSACJFyIqwhEvTZQ2Shl45OVEazccTiZ+99RdlyAIKSDxQkQFL5c+2GhGR68t4HIWuwOdYp8PirwkO8UmA3QaFWwOhpq2Hi/PC333BEFED4kXIiryM/QoyzGCMeCH44EnTLd2uYSNRiXAZKA+H8mOSiWgPMfVuPBoc7foeSmgqBtBEBJA4oWImvEVOQCArccCD2nkd9456TqoVNTnIxXwHhMgRl4obUQQhASQeCGiJhTfC680orlGqUOFe0zAwYYutHW7Im9k2CUIQgpIvBBR4y1eGGN+l2npomqTVIObdrced0Xk1CoB2TQagCAICSDxQkTNaaUmaNUCmrusONHqf8J0M3XXTTm4eNl50uWFyqOUIUEQEkHihYgag1aNkSUmAMDWAKkjbtikuUapA+/1YnO4onEUdSMIQipIvBCSMH6AIY00UTr1KM81wnsGI5l1CYKQChIvhCTwfi/c39CXFjLsphx6jRolJoP4f+rxQhCEVJB4ISRhXLmrXHpXTQes9v4TpptoNEBKUuH2vQDUXZcgCOkg8UJIQmVeGrLTtLDanaiu7ej3PE2UTk0q3b1eAGpQRxCEdJB4ISRBEASMLcsG4L/fC08bUeogtfCOvJDfiSAIqSDxQkjGeLfvpa946bba0W11AKC0UaoxONcTeSHxQhCEVJB4ISSDN6vrOyaA93jRaVTI0GtivVlEHBnsHXnJJOFKEIQ0kHghJIOLlyPN3Wh1p4kAz2iA/HQdBIGalKUSPoZdirwQBCERsomXlpYWzJkzByaTCdnZ2Zg3bx7MZnPQ19TV1eG6665DcXEx0tPTMWHCBLz//vtybSIhMdlpOpyS70oTbDvRJj7ORwOQWTf1MBm0uO/CEbjj/OH0/RMEIRmyiZc5c+Zg165dWLlyJT799FN88803uOmmm4K+5vrrr8fevXvxySefYMeOHfjpT3+KX/ziF9i6datcm0lIzDg/zeqaaDRASnPrjGG464JT470ZBEEkEbKIl+rqaqxYsQKvv/46Jk+ejHPOOQfPP/883nnnHdTU1AR83bp163D77bfjzDPPxJAhQ/Dggw8iOzsbmzdvlmMzCRnwZ9ptptEABEEQhITIIl7Wr1+P7OxsTJo0SXxs5syZUKlU2LBhQ8DXTZ06Fe+++y5aWlrgdDrxzjvvoLe3FzNmzAj4GovFgo6ODp8/In74mzBNE6UJgiAIKZFFvNTV1aGwsNDnMY1Gg9zcXNTV1QV83XvvvQebzYa8vDzo9XrcfPPN+PDDDzFs2LCAr3n88ceRlZUl/pWXl0u2H0T4VBWboNOo0N5jw+GmLgA0UZogCIKQlrDEywMPPABBEIL+7dmzJ+KN+cMf/oC2tjZ8+eWX+P7773HXXXfhF7/4BXbs2BHwNQsXLkR7e7v4d/z48Yjfn4genUaF0aWuCdM8ddREc40IgiAICQmr6cbdd9+NG264IegyQ4YMQXFxMRoaGnwet9vtaGlpQXFxsd/XHTx4EC+88AJ27tyJ0047DQAwduxYfPvtt3jxxRexePFiv6/T6/XQ6ykdkUiMK8/BlmNt2Ha8DT+dUEYTpQmCIAhJCUu8FBQUoKCgYMDlpkyZgra2NmzevBkTJ04EAHz11VdwOp2YPHmy39d0d3cDAFQq32CQWq2G09l/0B+RuIyvyAbWeiIvLTSUkSAIgpAQWTwvI0eOxIUXXoj58+dj48aNWLt2LRYsWICrrroKpaWlAICTJ0+iqqoKGzduBABUVVVh2LBhuPnmm7Fx40YcPHgQf/nLX7By5UpcdtllcmwmIRPctLu7pgO9NgdVGxEEQRCSIlufl2XLlqGqqgrnn38+Lr74Ypxzzjl49dVXxedtNhv27t0rRly0Wi0+//xzFBQU4JJLLsGYMWPw1ltv4W9/+xsuvvhiuTaTkIGyHCPyM3SwOxn+e6gZVocrcpaXTmkjgiAIInpkGzSTm5uL5cuXB3y+srJSLKXlDB8+nDrqJgGCIGBceTa+rG7AqmqX9yldp4ZRp47zlhEEQRDJAM02ImSBp45WVdcDAHIpZUQQBEFIBIkXQhbGV+QAAGraewFQyoggCIKQDhIvhCyMKcuC9wDpfIq8EARBEBJB4oWQhUyDFsMKMsT/U5k0QRAEIRUkXgjZ4L4XAMijBnUEQRCERJB4IWRjnHvCNECjAQiCIAjpIPFCyMb48hzx3zQagCAIgpAKEi+EbJxalAGj1tXbhTwvBEEQhFSQeCFkQ6NW4fqpgzGiKBNjvfwvBEEQBBENAuvb5lbhdHR0ICsrC+3t7TCZTPHeHIIgCIIgQiCc6zdFXgiCIAiCUBQkXgiCIAiCUBQkXgiCIAiCUBQkXgiCIAiCUBQkXgiCIAiCUBQkXgiCIAiCUBQkXgiCIAiCUBQkXgiCIAiCUBQkXgiCIAiCUBQkXgiCIAiCUBQkXgiCIAiCUBQkXgiCIAiCUBQkXgiCIAiCUBQkXgiCIAiCUBSaeG+A1DDGALhGaxMEQRAEoQz4dZtfx4ORdOKls7MTAFBeXh7nLSEIgiAIIlw6OzuRlZUVdBmBhSJxFITT6URNTQ0yMzMhCIKk6+7o6EB5eTmOHz8Ok8kk6bqVQKrvP0CfQarvP0CfAe1/au8/IN9nwBhDZ2cnSktLoVIFd7UkXeRFpVKhrKxM1vcwmUwpe9ACtP8AfQapvv8AfQa0/6m9/4A8n8FAERcOGXYJgiAIglAUJF4IgiAIglAUJF7CQK/XY9GiRdDr9fHelLiQ6vsP0GeQ6vsP0GdA+5/a+w8kxmeQdIZdgiAIgiCSG4q8EARBEAShKEi8EARBEAShKEi8EARBEAShKEi8EARBEAShKFJKvDz++OM444wzkJmZicLCQlx22WXYu3evzzK9vb247bbbkJeXh4yMDPzsZz9DfX29+Pz27dtx9dVXo7y8HEajESNHjsSzzz7rs441a9ZAEIR+f3V1dTHZz2BI8Rk0NzfjwgsvRGlpKfR6PcrLy7FgwYJ+86TWrFmDCRMmQK/XY9iwYVi6dGksdjEosdr/ZD8GvGlubkZZWRkEQUBbW5vPc8l6DHgTaP8T9RiQav/97ds777zjs0wifv9A7D6DZD8GAGDp0qUYM2YMDAYDCgsLcdttt/k8/8MPP2DatGkwGAwoLy/HE088Ic1OsBRi1qxZ7M0332Q7d+5k27ZtYxdffDGrqKhgZrNZXObXv/41Ky8vZ6tWrWLff/89O+uss9jUqVPF59944w12xx13sDVr1rCDBw+yt99+mxmNRvb888+Ly6xevZoBYHv37mW1tbXin8PhiOn++kOKz6ClpYW99NJLbNOmTezIkSPsyy+/ZCNGjGBXX321uMyhQ4dYWloau+uuu9ju3bvZ888/z9RqNVuxYkVM97cvsdr/ZD8GvJk9eza76KKLGADW2toqPp7Mx4A3gfY/UY8BqfYfAHvzzTd99q2np0d8PlG/f8Zi9xkk+zHwl7/8hZWWlrJly5axAwcOsO3bt7OPP/5YfL69vZ0VFRWxOXPmsJ07d7K///3vzGg0sldeeSXqfUgp8dKXhoYGBoB9/fXXjDHG2tramFarZf/4xz/EZaqrqxkAtn79+oDrufXWW9l5550n/p8fsN4nskRFqs/g2WefZWVlZeL/77vvPnbaaaf5LHPllVeyWbNmSbwH0SHX/qfKMfDSSy+x6dOns1WrVvXb31Q4BoLtv1KOgUj3HwD78MMPA65XKd8/Y/J9Bsl8DLS0tDCj0ci+/PLLgOt96aWXWE5ODrNYLOJj999/PxsxYkTU25xSaaO+tLe3AwByc3MBAJs3b4bNZsPMmTPFZaqqqlBRUYH169cHXQ9fhzfjxo1DSUkJLrjgAqxdu1birZcGKT6DmpoafPDBB5g+fbr42Pr1633WAQCzZs0K+jnGA7n2n5PMx8Du3bvxyCOP4K233vI7RC3Zj4GB9p+T6MdANL+B2267Dfn5+TjzzDOxZMkSMK+2YUr5/gH5PgNOMh4DK1euhNPpxMmTJzFy5EiUlZXhF7/4BY4fPy6+Zv369Tj33HOh0+nEx2bNmoW9e/eitbU1qm1OWfHidDpx55134uyzz8bo0aMBAHV1ddDpdMjOzvZZtqioKGCOct26dXj33Xdx0003iY+VlJRg8eLFeP/99/H++++jvLwcM2bMwJYtW2Tbn0iI9jO4+uqrkZaWhkGDBsFkMuH1118Xn6urq0NRUVG/dXR0dKCnp0eeHQoTOfc/2Y8Bi8WCq6++Gk8++SQqKir8rjuZj4FQ9l8Jx0A0v4FHHnkE7733HlauXImf/exnuPXWW/H888+Lzyvh+wfk/QyS+Rg4dOgQnE4n/vd//xfPPPMM/vnPf6KlpQUXXHABrFaruB5/xwB/LhqSbqp0qNx2223YuXMnvvvuu4jXsXPnTsyePRuLFi3Cj370I/HxESNGYMSIEeL/p06dioMHD+Lpp5/G22+/HdV2S0m0n8HTTz+NRYsWYd++fVi4cCHuuusuvPTSSxJvpXzIuf/JfgwsXLgQI0eOxLXXXivTlsUGOfdfCcdANL+BP/zhD+K/x48fj66uLjz55JO44447pNxE2ZHzM0jmY8DpdMJms+G5554Tr39///vfUVxcjNWrV2PWrFlybK5ISkZeFixYgE8//RSrV69GWVmZ+HhxcTGsVmu/ion6+noUFxf7PLZ7926cf/75uOmmm/Dggw8O+J5nnnkmDhw4IMn2S4EUn0FxcTGqqqpw6aWX4pVXXsHLL7+M2tpa8bm+zvT6+nqYTCYYjUZ5dioM5N5/fyTTMfDVV1/hH//4BzQaDTQaDc4//3wAQH5+PhYtWiSuJ1mPgVD23x+JdAxI8RvwZvLkyThx4gQsFou4nkT+/gH5PwN/JMsxUFJSAgAYNWqU+HxBQQHy8/Nx7NgxcT3+jgH+XFRE7ZpREE6nk912222stLSU7du3r9/z3KT0z3/+U3xsz549/UxaO3fuZIWFhezee+8N+b1nzpzJLr/88uh2QAKk+gz68vXXXzMA7PDhw4wxl1lv9OjRPstcffXVcTfrxWr//ZFMx8CBAwfYjh07xL8lS5YwAGzdunWsvr6eMZbcx0Ao+++PRDgG5PoN/M///A/LyckR/5+o3z9jsfsM/JEsx8DevXsZAB/DbnNzM1OpVOyLL75gjHkMu1arVVxm4cKFkhh2U0q83HLLLSwrK4utWbPGp2ytu7tbXObXv/41q6ioYF999RX7/vvv2ZQpU9iUKVPE53fs2MEKCgrYtdde67OOhoYGcZmnn36affTRR2z//v1sx44d7De/+Q1TqVRBXdmxQorP4LPPPmNLlixhO3bsYIcPH2affvopGzlyJDv77LPFZXiZ5L333suqq6vZiy++mBBlkrHa/2Q/Bvrir6oimY+Bvvjb/0Q9BqTY/08++YS99tprbMeOHWz//v3spZdeYmlpaeyhhx4Sl0nU75+x2H0GyXwMMOZqE3DaaaextWvXsh07drCf/OQnbNSoUaJYaWtrY0VFRey6665jO3fuZO+88w5LS0ujUulwAeD378033xSX6enpYbfeeivLyclhaWlp7PLLL2e1tbXi84sWLfK7jsGDB4vL/PnPf2ZDhw5lBoOB5ebmshkzZrCvvvoqhnsaGCk+g6+++opNmTKFZWVlMYPBwIYPH87uv//+fuWAq1evZuPGjWM6nY4NGTLE5z3iRaz2P9mPgb4EKglN1mOgL/72P1GPASn2/9///jcbN24cy8jIYOnp6Wzs2LFs8eLF/fqXJOL3z1jsPoNkPgYYc/Vx+eUvf8mys7NZbm4uu/zyy9mxY8d8ltm+fTs755xzmF6vZ4MGDWJ/+tOfJNkHwb0jBEEQBEEQiiAlDbsEQRAEQSgXEi8EQRAEQSgKEi8EQRAEQSgKEi8EQRAEQSgKEi8EQRAEQSgKEi8EQRAEQSgKEi8EQRAEQSgKEi8EQRAEQSgKEi8EEUeWLl3ab+y8knj44Ycxbty4eG8GAeDIkSMQBAHbtm2L96YoijVr1kAQhH5DCInEhsQL4cMNN9wAQRAgCAJ0Oh2GDRuGRx55BHa7Pd6bNiCCIOCjjz6K92b4sHr1alx88cXIy8tDWloaRo0ahbvvvhsnT56M96ZJwj333INVq1ZJsq6enh7k5uYiPz/f71TeyspKCIKA//73vz6P33nnnZgxY4bPYx0dHfj973+PqqoqGAwGFBcXY+bMmfjggw9ATcWj44YbbsBll10W782IiBkzZuDOO++M92YQEkDihejHhRdeiNraWuzfvx933303Hn74YTz55JMRrcvhcMDpdEq8hcrglVdewcyZM1FcXIz3338fu3fvxuLFi9He3o6//OUv8d48ScjIyEBeXp4k63r//fdx2mmnoaqqKqAINRgMuP/++4Oup62tDVOnTsVbb72FhQsXYsuWLfjmm29w5ZVX4r777kN7e7sk20sQwbDZbPHehORGkglJRNIwd+5cNnv2bJ/HLrjgAnbWWWcxxhjr7e1ld999NystLWVpaWnszDPPZKtXrxaXffPNN1lWVhb7+OOP2ciRI5larWaHDx9mvb297L777mNlZWVMp9OxoUOHstdff1183Y4dO9iFF17I0tPTWWFhIbv22mtZY2Oj+Pz06dPZ7bffzu69916Wk5PDioqK2KJFi8TnBw8e7HdQ5oEDB9ill17KCgsLWXp6Ops0aRJbuXKlz/7V1NSwiy++mBkMBlZZWcmWLVvGBg8ezJ5++mlxmdbWVjZv3jyWn5/PMjMz2Xnnnce2bdsW8HM8fvw40+l07M477/T7PB/gxz+vFStWsKqqKpaens5mzZrFampqxGU3btzIZs6cyfLy8pjJZGLnnnsu27x5s8/6ALDXXnuNXXbZZcxoNLJhw4axjz/+2GeZjz/+mA0bNozp9Xo2Y8YMtnTp0n7DBL/99lt2zjnnMIPBwMrKytjtt9/OzGZzwP1ctGgRGzt2rPh/fvw8+eSTrLi4mOXm5rJbb71VnDIbjBkzZrDFixezl19+mV1wwQX9nh88eDC74447mE6nY5999pn4+G9+8xs2ffp08f+33HILS09PZydPnuy3js7OTmaz2QJuwyeffMImTZrE9Ho9y8vLY5dddpn43FtvvcUmTpzIMjIyWFFREbv66qtZfX29+HxLSwu75pprWH5+PjMYDGzYsGFsyZIl4vPHjh1jP//5z1lWVhbLyclhl156KTt8+LD4/OrVq9kZZ5zB0tLSWFZWFps6dSo7cuRIwG3dsGEDGzduHNPr9WzixInsgw8+YADY1q1bGWOeY8ubDz/8kPU97X/00Uds/PjxTK/Xs1NOOYU9/PDDAT8jf4Np+e//hx9+YOedd544hHD+/Pmss7Mz4PZPnDiRPfnkk+L/Z8+ezTQajfia48ePMwBs//79jLGBzz1NTU3sqquuYqWlpcxoNLLRo0ez5cuXi8/PnTu337YfPnxYHKr55ZdfsokTJzKj0cimTJnC9uzZE9bnBIC99NJL7JJLLmFpaWk+5ydCeki8ED74Ey+XXnopmzBhAmOMsV/96lds6tSp7JtvvmEHDhxgTz75JNPr9Wzfvn2MMdcJU6vVsqlTp7K1a9eyPXv2sK6uLvaLX/yClZeXsw8++IAdPHiQffnll+ydd95hjLku5AUFBWzhwoWsurqabdmyhV1wwQXsvPPOE7dh+vTpzGQysYcffpjt27eP/e1vf2OCILD//Oc/jDHGGhoaxKmotbW1rKGhgTHG2LZt29jixYvZjh072L59+9iDDz7IDAYDO3r0qLjumTNnsnHjxrH//ve/bPPmzWz69OnMaDT6iJeZM2eySy65hG3atInt27eP3X333SwvL481Nzf7/Rz/+te/MgA+IsQf/POaOXMm27RpE9u8eTMbOXIku+aaa8RlVq1axd5++21WXV3Ndu/ezebNm8eKiopYR0eHuAwAVlZWxpYvX87279/P7rjjDpaRkSFu36FDh5hWq2X33HMP27NnD/v73//OBg0a5CNeDhw4wNLT09nTTz/N9u3bx9auXcvGjx/PbrjhhoDb70+8mEwm9utf/5pVV1ezf/3rXywtLY29+uqrQT+HAwcOML1ez1paWlhzczMzGAz9LtxcUN5xxx1szJgx4vReb/HicDhYTk4Ou+mmm4K+nz8+/fRTplar2UMPPcR2797Ntm3bxv73f/9XfP6NN95gn3/+OTt48CBbv349mzJlCrvooovE52+77TY2btw4tmnTJnb48GG2cuVK9sknnzDGGLNarWzkyJHsl7/8Jfvhhx/Y7t272TXXXMNGjBjBLBYLs9lsLCsri91zzz3swIEDbPfu3Wzp0qU+x6k3nZ2drKCggF1zzTVs586d7F//+hcbMmRI2OLlm2++YSaTiS1dupQdPHiQ/ec//2GVlZXs4YcfDvi+v/jFL9iFF17IamtrWW1tLbNYLMxsNrOSkhL205/+lO3YsYOtWrWKnXLKKWzu3LkBP++77rqL/fjHP2aMMeZ0Ollubi7Lz89n//73vxljjP3f//0fGzRokLj8QOeeEydOsCeffJJt3bqVHTx4kD333HNMrVazDRs2MMYYa2trY1OmTGHz588Xt91ut4viZfLkyWzNmjVs165dbNq0aWzq1KlhfU4AWGFhIVuyZAk7ePBgwO+OkAYSL4QP3uLF6XSylStXMr1ez+655x529OhRplar+93Rnn/++WzhwoWMMdcJE4BPVGLv3r0MQL+IB+fRRx9lP/rRj3we43dde/fuZYy5xMs555zjs8wZZ5zB7r//fvH/ANiHH3444D6edtpp7Pnnn2eMMVZdXc0AsE2bNonP79+/nwEQxcu3337LTCYT6+3t9VnP0KFD2SuvvOL3PW655RZmMpkG3Bb+eR04cEB87MUXX2RFRUUBX+NwOFhmZib717/+JT4GgD344IPi/81mMwMgXgjuv/9+Nnr0aJ/1/P73v/cRL/Pmzet30f/222+ZSqViPT09frfFn3gZPHgws9vt4mM///nP2ZVXXhlwfxhj7He/+51PlGP27Nn97ly5eGloaGCZmZnsrbfeYoz5ipf6+noGgP31r38N+n7+mDJlCpszZ07Iy2/atIkBECMFl1xyCbvxxhv9Lvv222+zESNGMKfTKT5msViY0WhkX3zxBWtubmYA2Jo1a0J671deeYXl5eX5fC8vv/xy2OLl/PPP9xFofFtLSkoCvre/G5xXX32V5eTk+ETpPvvsM6ZSqVhdXZ3f9XzyyScsKyuL2e12tm3bNlZcXMx+85vfiL/pX/3qV6KID+Xc448f//jH7O677xb/P336dPab3/zGZxnvyIv3tgMQP99QPicAASOthPSQ54Xox6effoqMjAwYDAZcdNFFuPLKK/Hwww9jx44dcDgcOPXUU5GRkSH+ff311zh48KD4ep1OhzFjxoj/37ZtG9RqNaZPn+73/bZv347Vq1f7rLOqqgoAfNbrvU4AKCkpQUNDQ9B9MZvNuOeeezBy5EhkZ2cjIyMD1dXVOHbsGABg79690Gg0mDBhgviaYcOGIScnx2f7zGYz8vLyfLbx8OHDPtvnDWMMgiAE3TZOWloahg4dGnC/6uvrMX/+fAwfPhxZWVkwmUwwm83iPnC8P5/09HSYTCZxPXv37sUZZ5zhs/yZZ57p8//t27dj6dKlPvs4a9YsOJ1OHD58OKR9AYDTTjsNarU64P70xeFw4G9/+xuuvfZa8bFrr70WS5cu9euXKigowD333IOHHnoIVqvV5zkWhRl327ZtOP/88wM+v3nzZlxyySWoqKhAZmameDzz7+GWW27BO++8g3HjxuG+++7DunXrxNdu374dBw4cQGZmpvjZ5ubmore3FwcPHkRubi5uuOEGzJo1C5dccgmeffZZ1NbWBtyW6upqjBkzBgaDQXxsypQpYe/z9u3b8cgjj/h85/Pnz0dtbS26u7tDXk91dTXGjh2L9PR08bGzzz4bTqcTe/fu9fuaadOmobOzE1u3bsXXX3+N6dOnY8aMGVizZg0A4OuvvxaN2KGcexwOBx599FGcfvrpyM3NRUZGBr744ot+v5NAeP9+SkpKAEA8bkP9nCZNmhTaB0ZEjSbeG0AkHueddx5efvll6HQ6lJaWQqNxHSZmsxlqtRqbN2/2uTgBLuMmx2g0+ly4jUZj0Pczm8245JJL8Oc//7nfc/wkAgBardbnOUEQBjQD33PPPVi5ciWeeuopDBs2DEajEVdccUW/i95A21dSUiKeVL0JVOZ86qmnor29HbW1tT774A9/++V9EZ47dy6am5vx7LPPYvDgwdDr9ZgyZUq/fYjk8/HGbDbj5ptvxh133NHvuYqKipDXE+52fPHFFzh58iSuvPJKn8cdDgdWrVqFCy64oN9r7rrrLrz00kt46aWXfB4vKChAdnY29uzZE/L2coIdp11dXZg1axZmzZqFZcuWoaCgAMeOHcOsWbPE7+Giiy7C0aNH8fnnn2PlypU4//zzcdttt+Gpp56C2WzGxIkTsWzZsn7rLigoAAC8+eabuOOOO7BixQq8++67ePDBB7Fy5UqcddZZYe8LAKhUqn5irq+J1Gw2449//CN++tOf9nu9tzCSg+zsbIwdOxZr1qzB+vXrccEFF+Dcc8/FlVdeiX379mH//v2iQAzl3PPkk0/i2WefxTPPPIPTTz8d6enpuPPOO0P+rXsft/z8xY/bUD8nb/FGyAuJF6If6enpGDZsWL/Hx48fD4fDgYaGBkybNi3k9Z1++ulwOp34+uuvMXPmzH7PT5gwAe+//z4qKytFoRQJWq0WDofD57G1a9fihhtuwOWXXw7AdRI6cuSI+PyIESNgt9uxdetWTJw4EQBw4MABtLa2+mxfXV0dNBoNKisrQ9qWK664Ag888ACeeOIJPP300/2eb2trC7m/y9q1a/HSSy/h4osvBgAcP34cTU1NIb2WM2LECHz++ec+j23atMnn/xMmTMDu3bv9fvdy8sYbb+Cqq67C73//e5/HH3vsMbzxxht+xUtGRgb+8Ic/4OGHH8all14qPq5SqXDVVVfh7bffxqJFi1BaWurzOrPZDIPB4Pc4GzNmDFatWoUbb7yx33N79uxBc3Mz/vSnP6G8vBwA8P333/dbrqCgAHPnzsXcuXMxbdo03HvvvXjqqacwYcIEvPvuuygsLITJZAr4WYwfPx7jx4/HwoULMWXKFCxfvtyveBk5ciTefvtt9Pb2ihfPviXkBQUF6OzsRFdXl3hR7dsDZsKECdi7d29Y37lOp+v3Oxs5ciSWLl3q815r166FSqXCiBEjAq5r+vTpWL16NTZu3IjHHnsMubm5GDlyJB577DGUlJTg1FNPFT+Xgc49a9euxezZs8UIntPpxL59+zBq1Kig2x4KkXxOhLxQ2ogImVNPPRVz5szB9ddfjw8++ACHDx/Gxo0b8fjjj+Ozzz4L+LrKykrMnTsXv/zlL/HRRx/h8OHDWLNmDd577z0AwG233YaWlhZcffXV2LRpEw4ePIgvvvgCN954Y1gnmsrKSqxatQp1dXWi+Bg+fDg++OADbNu2Ddu3b8c111zjEwWoqqrCzJkzcdNNN2Hjxo3YunUrbrrpJp/o0cyZMzFlyhRcdtll+M9//oMjR45g3bp1+P3vf+/3AgYA5eXlePrpp/Hss89i3rx5+Prrr3H06FGsXbsWN998Mx599NGQ92v48OF4++23UV1djQ0bNmDOnDkDRrP6cvPNN2PPnj24//77sW/fPrz33ntYunQpAM9d5v33349169ZhwYIF2LZtG/bv34+PP/4YCxYsCOu9wqGxsRH/+te/MHfuXIwePdrn7/rrr8dHH32ElpYWv6+96aabkJWVheXLl/s8/thjj6G8vByTJ0/GW2+9hd27d2P//v1YsmQJxo8fD7PZ7Hd9ixYtwt///ncsWrQI1dXV2LFjhxgNrKiogE6nw/PPP49Dhw7hk08+6fcdPvTQQ/j4449x4MAB7Nq1C59++ilGjhwJAJgzZw7y8/Mxe/ZsfPvtt+Jv4I477sCJEydw+PBhLFy4EOvXr8fRo0fxn//8B/v37xdf35drrrkGgiBg/vz52L17Nz7//HM89dRTPstMnjwZaWlp+N3vfoeDBw9i+fLl4nfuvc1vvfUW/vjHP2LXrl2orq7GO++8gwcffND/FwbX7+yHH37A3r170dTUBJvNhjlz5sBgMGDu3LnYuXMnVq9ejdtvvx3XXXcdioqKAq5rxowZ+OKLL6DRaMRU8YwZM7Bs2TKfNHMo557hw4dj5cqVWLduHaqrq3HzzTejvr6+37Zv2LABR44cQVNTU8iRyUg+J0Jm4mu5IRINf2Y8b6xWK3vooYdYZWUl02q1rKSkhF1++eXshx9+YIz5NwkyxlhPTw/77W9/y0pKSphOp+tXRrpv3z52+eWXs+zsbGY0GllVVRW78847RYOjP6Pd7NmzfaoZPvnkEzZs2DCm0WjEUunDhw+z8847jxmNRlZeXs5eeOGFfuuqqalhF110EdPr9Wzw4MFs+fLlrLCwkC1evFhcpqOjg91+++2stLSUabVaVl5ezubMmcOOHTsW9PNcuXIlmzVrFsvJyWEGg4FVVVWxe+65R6xCCsVUuWXLFjZp0iRmMBjY8OHD2T/+8Y9+pdzwY1bOyspib775pvj/vqXS3ODpbfrcuHEju+CCC1hGRgZLT09nY8aMYY899ljA/QtUKu1N31Jmb5566imWnZ3tt5TaYrGw7Oxs9uyzzzLGWL99Zoyx5cuXMwD91t/W1sYeeOABNnz4cKbT6VhRURGbOXMm+/DDD31Ms315//332bhx45hOp2P5+fnspz/9qc97VVZWMr1ez6ZMmcI++eQTH4Pso48+ykaOHMmMRiPLzc1ls2fPZocOHRJfX1tby66//nqWn5/P9Ho9GzJkCJs/fz5rb29ndXV17LLLLhN/H4MHD2YPPfSQWFHlj/Xr17OxY8cynU7Hxo0bx95//32f7WHMdSwNGzaMGY1G9pOf/IS9+uqr/UqlV6xYwaZOncqMRiMzmUzszDPPDFod1tDQIB4jiKJUmjHGmpubmSAIPoZufvx7//4YG/jc09zczGbPns0yMjJYYWEhe/DBB9n111/vczzu3buXnXXWWcxoNPYrlfZuGbB161bx+VA/J3+/QUI+BMao3SRBeHPixAmUl5fjyy+/DGrgVDqPPfYYFi9ejOPHj8d7UwiCIMKCPC9EyvPVV1/BbDbj9NNPR21tLe677z5UVlbi3HPPjfemScpLL72EM844A3l5eVi7di2efPJJWVNCBEEQckHihUh5bDYbfve73+HQoUPIzMzE1KlTsWzZsn5VM0pn//79+J//+R+0tLSgoqICd999NxYuXBjvzSIIgggbShsRBEEQBKEoqNqIIAiCIAhFQeKFIAiCIAhFQeKFIAiCIAhFQeKFIAiCIAhFQeKFIAiCIAhFQeKFIAiCIAhFQeKFIAiCIAhFQeKFIAiCIAhF8f8BVIgugQ17kpYAAAAASUVORK5CYII=" + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi8AAAGwCAYAAABhDIVPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/OQEPoAAAACXBIWXMAAA9hAAAPYQGoP6dpAACV00lEQVR4nO2deZhT9fX/3zd7ZsnsKwyMLDIgsguCC/gVC9oqWls3VLQUrYpLFRdaK1a/fm1daq0bbkj1J0Vb16pFEcEFKCCLsgz7MsDs+2SWrJ/fH8nnJplJMlnuTXKT83qeeR5Ibm5ucm/ufd9z3uccgTHGQBAEQRAEoRBU8d4AgiAIgiCIcCDxQhAEQRCEoiDxQhAEQRCEoiDxQhAEQRCEoiDxQhAEQRCEoiDxQhAEQRCEoiDxQhAEQRCEotDEewOkxul0orq6GpmZmRAEId6bQxAEQRBECDDG0NHRgdLSUqhUwWMrSSdeqqurUVZWFu/NIAiCIAgiAo4fP46BAwcGXSbpxEtmZiYA14c3mUxx3hqCIAiCIEKhvb0dZWVl4nU8GEknXniqyGQykXghCIIgCIURiuWDDLsEQRAEQSgKEi8EQRAEQSgKEi8EQRAEQSgKEi8EQRAEQSgKEi8EQRAEQSgKEi8EQRAEQSgKEi8EQRAEQSgKEi8EQRAEQSgKEi8EQRAEQSgKEi8EQRAEQSgKEi8EQRAEQSgKEi8EQRAEQSgKEi8EkaIwxtBtdcR7MwiCIMKGxAtBpCgPfrgL4x/9AkcbO+O9KQRBEGFB4oUgUpTvDjaix+bE7ur2eG8KQRBEWJB4IYgUhDGG2rYeAEBHjy3OW0MQBBEeJF4IIgVp67bBYncCADp67HHeGoIgiPAg8UIQKUhte4/4b4q8EAShNEi8EEQKwlNGANBOkReCIBQGiReCSEHqvCIvZguJF4IglAWJF4JIQWrbLOK/KW1EEITSIPFCECmIr+eFIi8EQSgLEi8EkYLUkXghCELBkHghiBTE27BLaSOCIJQGiReCSEHIsEsQhJIh8UIQKYbF7kBTp1X8P5VKEwShNEi8EESKUd9u8fm/1e6ExU7TpQmCUA4kXggixeApowHZRvExMu0SBKEkSLwQRIpR4zbrlmYbkKHXACDxQhCEsiDxQhApBo+8FJkMyDS4xIuZxAtBEAqCxAtBpBi8TLrY5B15oXJpgiCUA4kXgkgxeHfd4ixP5IUqjgiCUBIkXggixfBNG2kBUOSFIAhlQeKFIFIMf5EXMuwSBKEkSLwQRArBGEOdu89LsVfkhbrsEgShJEi8EEQK0dJlg9XuBAAUmvRekRdKGxEEoRxIvBBECsErjXLTddBr1MikPi8EQSgQEi8EkUJ4m3UBkOeFIAhFQuKFIFIIbtYtyeLixeV5aae0EUEQCoLEC0GkEDxt1DvyQoZdgiCUREzEywsvvIDy8nIYDAZMmTIFmzdvDul1K1euhCAIuPTSS+XdQIJIEXjaqNgtXjIobUQQhAKRXby88847uPvuu7FkyRJs27YNY8eOxaxZs1BfXx/0dUePHsWiRYtwzjnnyL2JBJEyeHq86AEAJmpSRxCEApFdvPzlL3/BggULcOONN2LUqFFYunQp0tLSsGzZsoCvcTgcmDt3Lv74xz9iyJAhcm8iQaQMgdJGFHkhCEJJyCperFYrtm7dipkzZ3reUKXCzJkzsXHjxoCve+SRR1BYWIj58+f3+x4WiwXt7e0+fwRB+Me7uy7gMex2WR2wO5xx2y6CIIhwkFW8NDY2wuFwoKioyOfxoqIi1NbW+n3Nd999h9dffx2vvvpqSO/x+OOPIysrS/wrKyuLersJIhnpsTnQ2uVKD4meF3efFwDotDjisl0EQRDhklDVRh0dHbjuuuvw6quvIj8/P6TXLF68GG1tbeLf8ePHZd5KglAm3Kyr16iQZXRFXHQaFfQa12mAyqUJglAKmv4XiZz8/Hyo1WrU1dX5PF5XV4fi4uI+yx86dAhHjx7FxRdfLD7mdLpC2RqNBvv27cPQoUN9XqPX66HX62XYeoJILrjfpTjLAEEQxMczDVpYzBbyvRAEoRhkjbzodDpMnDgRa9asER9zOp1Ys2YNpk6d2mf5iooK7Ny5Ezt27BD/LrnkEpx33nnYsWMHpYQIIgpqe3XX5ZhovhFBEApD1sgLANx9992YN28eJk2ahMmTJ+Ovf/0rOjs7ceONNwIArr/+egwYMACPP/44DAYDRo8e7fP67OxsAOjzOEEQ4dG7xwuHKo4IglAasouXK6+8Eg0NDXjooYdQW1uLcePGYdWqVaKJt6qqCipVQllvCCIpqW2zAPBUGnF4xRF12SUIQinILl4AYOHChVi4cKHf59atWxf0tcuXL5d+gwgiBQkUecnQU9oo0bDanaht68GgvLR4bwpBJCQU8iCIFKF3jxcOTxu1U9ooYXjoo10498m12HykOd6bQhAJCYkXgkgRenfX5WSKIwJIvCQK3x1sBADsr+uI85YQRGJC4oUgUgCnk6G+I3jkhdJGiUF7jw0nWroBkKAkiECQeCGIFKC5ywqbg0EQgMJM375IVG2UWOyt8URbSFAShH9IvBBECsBTRnnpemjVvj97Ll6o2igx2FPdJv6buh4ThH9IvBBECuDprtu3G7XH80IXykSg0ifyQoKSIPxB4oUgUoDaAGXSAKWNEo3K2nbx3+3dJCgJwh8kXggiBagLMBoAoGqjRMLucGJvLUVeCKI/SLwQRAogpo2CRF7IXxF/jjR2wmp3iv8n8UIQ/iHxQhApgDiUMcuPeNF7DLuMsZhuF+HLnhpXyihNpwZAgpIgAkHihSBSgECjAQBP2ogxoNPqiOl2Eb5w8TJxcA4AirwQRCBIvBBECsDTRiV+Ii8GrQoalQCAKo7iDa80mlyeC8AVDXM4KRpGEL0h8UIQSU631SHOLfKXNhIEgSqOEoRKd+RlypA88TEz7ROC6AOJF4JIcrjfJU2nFv0tvaFeL/GnocOChg4LBAEYPcAEg9Z1eibfC0H0hcQLQSQ53pVGgiD4XYYiL/GHR11OyUtHmk4jCkoSLwTRFxIvBJHkBOvxwsnQk3iJN1y8jCw1ASBBSRDBIPFCEEmO2F3Xj9+FQ43q4g+vNBpV4hIvJtonBBEQEi8EkeTwtFGwyItJvMunFEW8ECMvJZkAvJoH0ogAgugDiReCSHI8PV76DmXkUIoivvTYHDjU0AkAGFWSBQAwGclETRCBIPFCEElOTVvoaSOzhcRLPDhQZ4bDyZCTpkWRW2SaxLENtE8IojckXggiyQnJsEvzjeKKJ2VkEivCqHydIAJD4oUgkhiHk6G+wwKgv8gLpY3iSW+zLuDtQ6J9QhC9IfFCEElMk9kCh5NBJQAFGcE8L3SXH0/2eEVeONTnhSACQ+KFIJIYXiadn6GHRh34506Rl/jBGPNJG3FMRtonBBEIEi8EkcQEG8joDU9RkGE39pxo6UZHjx1atYBhhRni45l6d+SFSqUJog8kXggiiQnFrAsAGXpqiBYveNRlWGEmdBrPKZmiYQQRGBIvBJHEhNJdF/C+UNrAGJN9uwgPlTUdAHzNuoCnzwuVShNEX0i8EEQSU9vmqjTqL/LCxYvNwWCxO2XfLsLDnpo2AJ7OupxMKl8niICQeCGIJMbTXTe4eEnXacAHTtPFMrYEirzwaiOr3YkemyPm20UQiQyJF4JIYkJNG6lUgjhZ2kxpipjR0WNDVXMXAN9KIwDI1HsEJfleCMIXEi8EkcTUhTCUkZOpJ4NorNlb64q6lGQZkJOu83lOpRKQoaOBmQThDxIvBJGkdFrs6HCXPvcXeQG8G9WReIkV/vq7eOMZzkj7hCC8IfFCEEkKTxll6DViSigY3hVHRGyo9DMWwBsy7RKEf0i8EESSUiumjAKPBfCG+orEnj3VwSMvtE8Iwj/9344RAIC2Lhu+PtAAh9OJy8YPjPfmEES/cPESSsoI8EobUZfdmOBwMuyrc3leepdJc0wG6rJLEP4g8RIi9R09uOMf25GTpiXxQiiC2hC763IyKG0UU440dqLH5kSaTo3Beel+l6HIC0H4h9JGIZKV5roDauu2wemkDqRE4sN7vPQ314hDF8rYwidJjyjOhFol+F3GY9glQUkQ3pB4CZEs90nEySisTigDMW0UYuTFZKALZSzpr9II8Dbs0jmHILyJiXh54YUXUF5eDoPBgClTpmDz5s0Bl3311VdxzjnnICcnBzk5OZg5c2bQ5WOFXqOGUasG4PK/EESiE+pQRg5FXmJLf5VGgMeHRNVGBOGL7OLlnXfewd13340lS5Zg27ZtGDt2LGbNmoX6+nq/y69btw5XX3011q5di40bN6KsrAw/+clPcPLkSbk3tV+y3amj1m5rnLeEIPon1O66HC5ezBRZjAn9VRoB3oZd2icE4Y3s4uUvf/kLFixYgBtvvBGjRo3C0qVLkZaWhmXLlvld/u2338att96KcePGoaKiAq+99hqcTifWrFnjd3mLxYL29nafP7ngqaNWirwQCY7d4URDh2soY6hpoww9TTGOFU1mC+o7LBAEoKLYf6URQL13CCIQsooXq9WKrVu3YubMmZ43VKkwc+ZMbNy4MaR1dHV1wWazITc31+/zjz/+OLKyssS/srIySbbdH57IC51IiMSm0WyFkwFqlYC8jHD7vNDxLTd8GGN5XjrSgzQQpA67BOEfWcVLY2MjHA4HioqKfB4vKipCbW1tSOu4//77UVpa6iOAvFm8eDHa2trEv+PHj0e93YHINrpmj7R1UdqISGx4yqgwUx+wkqU35HmJHXtq2gAE7u/CoQ67BOGfhO7z8qc//QkrV67EunXrYDD4D33r9Xro9aHdWUaLGHmhtBGR4NSGMZCRQ9VGsYNHXkYWB/a7AICJBCVB+EXWyEt+fj7UajXq6up8Hq+rq0NxcXHQ1z711FP405/+hC+++AJjxoyRczNDxrvXC0EkMrzSKFS/C+C5y++xOWFzOGXZLsKFWGlU2p948QhKxqi/FEFwZBUvOp0OEydO9DHbcvPt1KlTA77uiSeewKOPPopVq1Zh0qRJcm5iWPC0EXleiEQn3EojAD7eCzPd6cuGxe7AwXozgOCVRoCnVNrJgE6rQ/ZtIwilIHu10d13341XX30Vf//731FZWYlbbrkFnZ2duPHGGwEA119/PRYvXiwu/+c//xl/+MMfsGzZMpSXl6O2tha1tbUwm81yb2q/UNqIUAp1EaSNtGqV2MuI0hTycaDODLuTIcuo7bf7sUGrglbt8ixROo8gPMjuebnyyivR0NCAhx56CLW1tRg3bhxWrVolmnirqqqgUnk01EsvvQSr1Ypf/OIXPutZsmQJHn74Ybk3Nyi8VLqN+rwQCU6NOJQxPD9YpkGDbpuDDKIy4t2cThCCm6kFQUCmQYvmTivau+0oyYrFFhJE4hMTw+7ChQuxcOFCv8+tW7fO5/9Hjx6Vf4MiJJv6vBAKweN5MYb1ukyDBvUdFoq8yMieEMYCeJNp0KC500qRF4LwgmYbhUEW9XkhFABjLCLPC+DxWNCFUj48M42Cl0lzTDQigCD6QOIlDLLTeJ8Xcv4TiUuHxY4ut7kznGojgEYEyA1jTCyT7q/SiEP9dwiiLyRewoCnjawOJ7pt5PwnEhNu1jUZNDDq1GG9li6U8lLd1oO2bhs0KgHDCjNCeo0n8kL7hCA4JF7CIE2nFp3/5HshEpVIU0YAkKmntJGcVLqHMQ4rzIBeE5qwFLvsUrqaIERIvISBIAjI4iMC6ERCJCiRdNflUORFXrwrjULF40OifUIQHBIvYUK9XohEJ5LuupxMSlHISriVRgBgMtJ8I4LoDYmXMMmmXi9EghNV2ogMu7JSGYF4ocgLQfSFxEuYUOSFSHRq2ywAIksbZYhpIzq+pcZsseNYcxeA0MukAe9UHu0TguCQeAkTk5F6vRCJTTRpI5piLB/7atvBGFBk0iMvI/TOx2K1EZ1zCEKExEuYiMMZKfJCJCjRpY2o2kgu9rj7u4STMgJIUBKEP0i8hAlPG5HnhUhEbA4nGs2Rp42o2kg+Iqk0AjzRXjLsEoQHEi9hQp4XIpFp6LCAMUCrFpCXrgv79TzyYibxIjl7qsM36wIkKAnCHyRewiSLhjMSCQxPGRVmGqBSBZ9Y7I8MvbvayGqH00kjMKTC4WTYVxtZ2ogLyi6rA3aHU/JtIwglQuIlTPh8IzLsEokIb1AXid8F8NzlM+YSMIQ0HGvqRLfNAYNWhVPy08N6Ld8nAEVfCIJD4iVMeJ8Xcv4ToRLLIZ6ieInA7wIABq0aOrXrtEAXSungzelGFJugDjMiplWrYNS6RgnQPiEIFyRewsTjeSHDLtE/O463YtL/fol3txyPyfvxMulIzLoc6isiPR6zbuj9XbyhLrsE4QuJlzDhpdKdVgesdso/E8H5dn8DmjqtWLW7Nibv5ymTDr2PSG/ELrt0ly8Zle4y6XArjTiesQ0kXggCIPESNpkGDQR31JeGMxL9wcuWq1u7Y/J+0Qxl5GRQdYvkRFppxKGKI4LwhcRLmKhUgtjxknq9EP3RaHYdIzwiIjfRdNflZOrpLl9KWjqt4v6viFC8UJddgvCFxEsEUK8XIlQa3JGX1i4buq0OWd+LMRZVd10O3eVLC/e7DM5LE0vRw4X2CUH4QuIlArKp1wsRIjxtBAA1bfKmjtq77eixuXxY0Rl2aYqxlPBKo5HFkUVdAOqySxC9IfESAVnU64UIkYYOj3jhfhS54FGX7DQtDO7S2kgQDbsWOr6lgDenq4iw0gigyAtB9IbESwR4Ii/keSEC02Nz+FxsqmMkXqLxuwB0oZSaY01dAIAhBRkRr8NEAzMJwgcSLxHgGc5IJxIiME2dvuK2Vua0UV2U3XU5JF6k5WhTJwBgcG5axOvgk6Xbu2mfEARA4iUieOSFxAsRjEavlBGgpMgL3eVLRZfVjnr3cVCeF95YAG/EfUKpPIIAQOIlIkTPCxl2iSB4m3WB2HleojHrAp7ISztFXqKmqtmVMspO0yLLHbGNBLHDLkVeCAIAiZeIED0vFHkhgsDFi07j+pnJ3ahOurSR6/imDrvRw/0u0aSMAIqGEURvSLxEgOh5IcMuEQTeoI53VZW7UV1NlEMZObwXCaUooucY97tEkTICyIdEEL0h8RIBWRR5IUKAl0mPGZAFQP5GdVIMZQQ85lC6UEbPUR55yYsu8mLymm0UyynlBJGokHiJAOqwS4QC765bnp8uRjPkalRnsTvE6iap0kYdPXa6UEZJlShepIm82BwMFhoISxAkXiIhyz1Zur3HBoeTTu6Ef3i1UX6GThQUcpl269s9/pqcKIyhgOdC6XAydNvkHWmQ7Ihl0lFGXtJ1GqjcA2Gpyy5BkHiJCJ42YowMdERguGG3IEOPErd4katc2pMy0kPgY88jJE2nFi+UZNqNHKvdKZq0oxUvKpUgRu+o4oggSLxEhE6jQrrO1X6dUkdEILhhNz/TI17kalQnVY8XABAErwsliZeIOdHSBSdzicGCDH3U66OKI4LwQOIlQrLdvV6oUR3hD6vdKR4bBRl6FGcZAcgXeeHpqGjNuhy6UEbPMXePl0G5aVFHwwDv4YwkKAmCxEuEUMUREYymTlfKSKMSkGXUolRmz0udhJEXgEpzpeBYo8vvEk1nXW88+4TOOQRB4iVCPBVH1OuF6Etjh+u4yMvQQaUSRMNujVyRF7dhN9pKI47Jq+KIiAypyqQ5tE8IwgOJlwih4YxEMBrMLpGS7/Y6lGa70kZylUofd6coBuZIc6Gku/zo4aMBoi2T5niGM9I+IYiYiJcXXngB5eXlMBgMmDJlCjZv3hx0+X/+85+oqKiAwWDA6aefjs8++ywWmxkWvFyaDLuEP3jkhYsXHhGRq1FdlZe/Qgoy3BdKs4Xu8iNFqjJpDqXyCMKD7OLlnXfewd13340lS5Zg27ZtGDt2LGbNmoX6+nq/y2/YsAFXX3015s+fj+3bt+PSSy/FpZdeil27dsm9qWEhel5IvBB+4A3quHjJ1GvECjWpoy8dPTY0uxvUleUaJVknDWeMDoeT4USzNGXSHI9hl845BKGR+w3+8pe/YMGCBbjxxhsBAEuXLsWnn36KZcuW4YEHHuiz/LPPPovZs2fj3nvvBQA8+uijWL16NZ5//nksXbo05Pft7OyEWq3u87harYbBYPBZLhAqlQpGo9HvskbBBqe1Bw0tbejs7OyzbFdXV8DupIIgIC0tLaJlu7u74XQG7rCZnp4e0bI9PT1wOAJHBMJZNi3NU11hsVhgtwe+AIazrNFohErl0ttWqxU2W+CTeDjLGgwG8VgJZ1mbzQar1b/nqbqxBczpQH6mK0Jnt9tRaAQOmXtwpKYJRWm+1Sd6vR4ajUZc1mKx9FknR6fTQavVisvuO9EIp7UHOelaqBxWdHZa/S7rcDjQ0xPYc6PVaqHTubY3XauC09qDptY2v78R72WdTie6uwMLsnCW1Wg00Otdgo8xhq6uLkmWDed3L8U54mRLF3q6u6BTq2DSOCU5R+iYFU5rD5pbO3y2ic4RHpR0jgB8f/fhLBvuOSLUZcM5R4SzbDjniJBhMmKxWJharWYffPCBz+PXX389u+SSS/y+pqysjD3zzDM+jz300ENszJgxfpfv6elhbW1t4t/x48cZgIB/F110kc/r09LSAi47ffp0n2Xz8/MDLjtp0iSfZQcPHhxw2VGjRvksO2rUqIDLDh482GfZSZMmBVw2Pz/fZ9np06cHXDYtLc1n2Ysuuijo9+bNL37xi6DLms1mcdl58+YFXba+vl5c9tZbbw267JEjR8RlFy1aFHTZXbt2icsuWbIk6LKbN28Wl33iiSeCLrt27Vpx2eeffz7osgW/WMJe/eYQY4yxN954I+iy7777rrjed999N+iyb7zxhrjsJ598EnTZ559/Xlx27dq1QZd94oknxGXve+m9oMsuWbJEXHbXrl1Bl120aJG47JEjR4Iue+utt4rL1tfXB1123rx54rJmsznosr/4xS98juFgy9I5wvVH5wjPn1zniE8++URcVmnniM2bNwddNpJzRFtbGwPA2traWH/ImjZqbGyEw+FAUVGRz+NFRUWora31+5ra2tqwln/88ceRlZUl/pWVlUmz8QQhAQWZ0TcniwdpOtmDsgRBEBEjMCbf5LXq6moMGDAAGzZswNSpU8XH77vvPnz99dfYtGlTn9fodDr8/e9/x9VXXy0+9uKLL+KPf/wj6urq+ixvsVh8QmLt7e0oKytDdXU1TCZTn+WlShttOtyEG97YgiH5afj0znMpbeQFhYSBi//2LQ61WLHipmk4a1g+bDYbnvrPbry07hCuOGMg/njJaJ/lowkJ/+5fW7Fy8wn8ZvoQ3Dnz1IDLhhPmfX9rFe56ewumDs3FshsmB12W0kZ9zxFPfb4Xr393FNeeOQi//+kov8uGe474dn89Fry5FacWZeCjhWcHXJbOEco4RwCUNuq9bHt7O7KystDW1ub3+u2NrLdX+fn5UKvVfURHXV0diouL/b6muLg4rOX1er14AvMmPT3d58cUiFCW8bdsSb4DKp0BZqfW7zq8Tyb9Ec6y3ic/KZf1PllLuWyg/RPtsjqdLuQcqVzLarVa8UffmxabCoJKLRp2tVotyotzodKdRLNFFfS402g04kmqPzQaDWq7BKh0BgwrzQ+6XrVaHfLxnpWmh0pnQDfzf3x7o1IF/zyRLisIgizLApH/7kNdtqYTUOkMOHVA4H0S7jmiKC87pH1C5wgXiX6OiGbZcM8RoS4bzjkinGXD+d2HiqxpI51Oh4kTJ2LNmjXiY06nE2vWrPGJxHgzdepUn+UBYPXq1QGXjxeePi/WgHdPRGpiczjR4q5Cy8/wnORKZGpUx3u8lElUJg14jwegaqNI8JRJS3fC9lSAUbURQcie2L777rsxb948TJo0CZMnT8Zf//pXdHZ2itVH119/PQYMGIDHH38cAHDnnXdi+vTpePrpp/HTn/4UK1euxPfff49XXnlF7k0Ni2x3nxebg6HL6kC6njwChIsm90BGtUpATpq3eJG+UZ3DyXCiRdpOrgA1qYsGxphXgzrp94nZYofTyaBSRT8viSCUiuxX3CuvvBINDQ146KGHUFtbi3HjxmHVqlWiKbeqqkrMOwLAtGnTsGLFCjz44IP43e9+h+HDh+PDDz/E6NGjA71FXDBoVdBpVLDanWjttpF4IUQa3T1ectN1PheYkmzfRnVGXd9S/nCpaeuGzcGgU6skG8oIUJ+XaGgwW9BldUAlSNfxGPCMB2AMMFvt4v8JIhWJyRV34cKFWLhwod/n1q1b1+exX/7yl/jlL38p81ZFhyAIyDZqUd9hQWuXFQOypWkORiif3g3qOLxRXafVgZq2bgwpyIj6varEsQBGqCW8E+dpI6vdCYvdAb0meqGVKhxzzzQqzTZCp5EuM2/QqqFTq2B1ONHRQ+KFSG1otlEU8C67bdRll/CiscMlXnqXSQuCgBK3yJVqurQcfhcAyPCKJJop+hIWXLxINU3aG5OR5hsRBEDiJSrEydJ0IiG8aDTzuUZ9KxK4abdaIvEih7cCcPl1+DgDMu2GxzG3WXeQxPsEICM1QXBIvEQBDWck/ME9LwUZfUs6i92+lFqJTLv8Ll+qgYze0IUyMjyRFzn2CRmpCQIg8RIVnshL4MZCROrR0OHf8wJATBtJVS4tV9oIoAtlpIiRl1wZ0kYGGs5IEACJl6jIJs8L4QceeeFDGb2RutcLTxvJE3lxixcLRV7C4Zh7n5TnyykoaZ8QqQ2JlyjwNKoj8UJ4aAxQbQRIK17ae2xiMzw5xEsGpY3CprXLKqaR5dgnYuSFzjlEikPiJQqy0qT3vNS39+DGNzbjq7195zgRysBj2PUnXqRrVFfl9lbkZ+hk6TNEaaPw4X6Xwky9LMMtKfJCEC6os1oU8LSRlJ6XVbtrsXZfA+xOhv+pKOr/BURCYXc40dIVRLxI2KhOTr8LAJjoQhk2YspIhjJpwGOipuaBRKpDkZcoEA27EkZeqltd6QTeYp5QFs2dVjAGqARXh93e8EZ1QPTRFzn9LoB3tRFFXkLlWKN8ZdKAV58Xhe2T481dlF4nJIXESxTw+UZS/ij5Ba2pM/AIcyJxaRBHA+j9drwVBAHFWbxcOjrfi9jjRS7xovfM0iFCwxN5kVtQKmef1LX34H+eXofrl22O96YQSQSJlyjgHXaljLxwI6frDp6mVSuNYA3qOKUSlUtXyZw2yqD5RmHjaVAnT9qIp/KUZNjdX9cBm4Nh18k22B3OeG8OkSSQeImCLHfaqNvmQI/NIck6eeTF5mB00VAgDQFGA3jDG9UpJ21Ex2GoyNmgDlBmKq+u3fWbcDiZZC0CCILESxRk6jXgmQEp7oScToa6Nk+6qMlMqSOlEaxMmiNFozq7w4mTLS7xI5e/gqqNwqPLake9W7wOlqFBHaDMaqP6Ds9xzgU3QUQLiZcoUKkET+pIAvHS1GmF1Sus2tRJpl2l0Sh21w2cNpKi10tNWw/sTgadRoWiTEPE6wmGEi+U8YRHXbLTtGJUVmr4+UZJht36ds9N2HESL4REkHiJkuw06Uy7vQ2cVHGkPEKJvBRLIF5Ev0uOESo/xmAp4A3RaKp0aHDxMlgmvwvgEZQ9NiesdmX4R+raKfJCSA+JlyiR0rRb3csDQRVHyoMbdoN5XkolaFQnt98FADL0lDYKB27Wlav6C/DsE0A5+8VbvBxvkWYgKUGQeIkST6+X6KMkFHlRPuFEXnijukiIhXjhd/mdVgccTqp86w+5y6QBQKNWiX2ClJLOq/NKGyVD5MXucOJEi/I/h9Ih8RIl4nBGCdJGvSMvzeR5URyhiBeTwdOorrY9stSR3GXSgKeyBaDUUSjIXSbNUVIVGGNMrMADksPz8tcvD+DsP6/Fys1V8d6UlIbES5RkSzjfiEdeSt135o1UbaQoHE4mCk5/E6U53o3qalojC6NXxcBfodOooNe4ThFKMojGi6ON8kdeAGV12W3tsvkUITR3WhXf9HD78RYAwOP/2Us3mHGExEuUZEk436jGPRrgtAFZAChtpDSaOi1wMkAQgNy0wOIFiL5RXSzSRoDnLl/pFxy5sdgdoodJrtJ1jpJ6vdS5y6Rz03Viil3p0RceSWrrtuHJz/fFeWtSFxIvUSKlYbem3XXyG13qFi9k2FUUjR0usZmbpoNGHfynFU2jurYum5imLMs1hv36cKBy6dA40dINJwPSdGoUBEkZSkGm2GU38fcJ97sUZupRluMSdUoXL/VeabCVW6qw80RbHLcmdSHxEiX8biJaz4vTycS00egBJgDkeVEaofhdONH0ejnuNgvmZ+iRppN3MDw1qgsN7zSeIMhTus4xGZTT66Xe7ekqNBnEKKGSTbsWu0O8UT331AIwBiz5eBecZGiPOSReokSqydJNnVbYHAyCAIws8YgXqvJQDqJ4CeJ34UTTZdfTT0Te9ARAkZdQORqDMmmOkvYJj1IUZepFc/kJBZdL85SRTq3Cny8/HWk6NbZVteKD7SfjvGWpB4mXKMlyT5aO1vPC0weFmXoUunuEOJk0JdhEbODiJZS0QTSN6mLldwGATL1y/BXxRBSU+fLvE5OCuuzyHi9FJoOY4lRy5KXea3ZZSZYRC/9nGACXeZd+I7GFxEuUiGmjKCMv/CJWnGWERq0S10upI+XgmSjdv3iJplFdLMqkOeJdPhl2g+JpUCdvmTSgrMhLnZg20otiW8meFz7qgDehnH/2KTglPx2NZgv+tuZAPDct5SDxEiXZ4l2QPaoUDy+Z5WXSeemuiE4jVRwpBnGuUZDuupxoGtUdj2HkJUNBF8p4Ivc0aW94tZEUw2DlhkcqCjMNomG3qrkLjCkzHd7grp7i0XG9Ro2HLh4FAHhj/VEcrO+I27alGiReooRXGwHRnUxq2nnkxS1e3HfvVHGkHBrCMOxG06juWLP7Lj+GF0oKiQfG4WSiiVruMmnAdewAyhCUPFJRZNKjNNsIlQBY7E6fxnVKgm93ocnzGz9vRCFmjiyE3cnw8Md7FCvMlAaJlyjRqFXIdM8biWayNO/xwtMJfCox9XpRDg0hTJTmRNqozuZwotp9rMQi8qKkC2W8qG7ths3BoFOrUJIlb+k64Kk26rAktqB0OhnqOzyeF53G8/0cV2h7fdHzkuE7yf0PPxsFnUaF7w424vPdtfHYtJSDxIsEZEkw36i2zTfykutOGzWR50UxhON5ASCeyMMx7da09sDhZNBrVLL3EwGU5a+IFx4PkhFqmSZ8eyN22E3wPi8tXa4KSsDjEVG6abfeT+QFcJXI33TOEADAo59URjyzjAgdEi8SIJZLRxF54XONSrO558WdNqIRAYrANRrA18zXH55eL6FHXrzNuqoYXCjFDrskXgIilknLPNOIo5RUHr/Q56XroHU3bfQ0qlNmuXR9L8+LN7eeNxSlWQacbO3G0q8PxXrTUg4SLxKQ7S6XjrTiyOlkoiu/mNJGiqSly+oZDZDef9oIiKxRHfe7xCJlBHh1c03wC2U8qYph3x3Ae5/YE9pfUefVoI6j9EZ19e0eA3Jv0nQa/O6nIwEAS78+FFVVlc3hxLLvjuDx/1RSA7wAkHiRAM+IgMiERmOnBTYHg0rwKPpcd+SFSqWVAe/xkpPmucvsj0ga1cWyxwsAZOgpbdQfsWxQB3g8Lw4nQ7ctcdMT3mZdDjc0K7Fc2uFk4u+8d9qI89PTSzB1SB4sdif+99M9Eb3PrpNtmPP8ejzyyR68/PVhbDjUFPE2JzMkXiQgK8q0Efe7FGTqxQtfnjvy0kjVRoqAzzUKxazLiaRRXSzLpAHlpCjiiadBXWzSRmk6teitSWRRKTao84pSDFTwfCPvwat5AaKrgiDg4UtOg1ol4PPddfj2QEPI6++2OvD4Z5WY88J67KlpFx/fcKgx6m1PRki8SEB2lMMZefWId6UCpY2URThzjTg8bVQbgeclVuKFVxuZLYmdoogXjDGPeInRPhEEwWs4Y+KKSn/mVn7c1rT3wGJP3KiRPxpED48+6ODVEcWZuH7qYADAwx/vhtXu7HfdGw42Yvaz3+Dlbw7D4WT42ZgSPHBhBQBgPUVe/ELiRQK4YTfSEwm/ePGLGeBJG7V122Bz9H/wE/HFUyYdjnhxidWWEBvVeV8oY9FPBPBEXpwM6KQKij40dFjQbXNAJXiiCrHA2/eSqPjzvORn6GDUqsGY56ZNKXiPBuiPu2aeirx0HQ41dOLvG44GXK6ty4b7/vUDrnltE441daEky4DXrp+E56+ZgEvGlgIAdp5oJc+ZH0i8SEC2ON8osgOMpw28Iy/ZRi14MUkL+V4SnkgiLyaDBmlhNKpr67aJaYKyGF0oDVoVNO4DkSqO+nLMHQkbkGOEThO70ymfOZXIF7U6r6GMHEEQFFsu3SCadfv/jWcZtbh/tity8uyaA+J0bQ5jDJ/trMH5f/ka735/AgBw/dTB+OK352LmqCIAQGm2Eafkp8PJgE2Hm6X8KEkBiRcJiLbPi0e8eO5QVCpBjL7QiIDEpyGMidIcQRA8FUchNKrjJ/vCTD2MbtEjN4IgeI0ISNwLZbw42hi7mUbe8F4viex5qfcayuhNmUJ9L8HKpP3xi4kDMbYsG2aLHX9atVd8vLatBze/tRW3vr0NjWYLhhak41+/mYpH5owWI52cqUPzAJDvxR8kXiRA9LxEHHlxp42yfX/kou+FTLsJT7gN6jjhNKqLtd+Fo4QURbzg+yRWZdKcRDdSO53Mbyt9wDNQVHniJXilUW9UKgF/vOQ0AMD7207i+6PNWLGpChf85Wt8sacOGpWAO/5nGD694xxMKs/1u46zhuYDADYcJN9Lb2QVL83NzZg7dy5MJhOys7Mxf/58mM3moMvffvvtGDFiBIxGIwYNGoQ77rgDbW1tcm5m1GSnRdfnxV/kBfD0C6Fy6cSnMYx8uDfhNKoT/S6xFi/62F8ou60O2BXg9Toa4x4vHJM4nDExBWVzlxV2J4Mg9BX0onhR2IiAYD1eAjGuLBtXTBoIALjmtU343Qc70WGxY2xZNj6542zc/ZMRMGgDR1HPHOISNfvqOhQ7D0ouZBUvc+fOxe7du7F69Wp88skn+Oabb3DTTTcFXL66uhrV1dV46qmnsGvXLixfvhyrVq3C/Pnz5dzMqPHusBtuRYZ3g7rec1H4cEZKGyU+3PMSbsv+cBrViWXSMb/Lj22KotNixzlPfIWrXvlvTN4vGo7FuLsuJzPBU3n8nJaXru/T90ipjerCTRtx7ptdgUyDBla7E0atGg/9bBTev2UaKopN/b42L0OPkSWu5TYepuiLNxq5VlxZWYlVq1Zhy5YtmDRpEgDgueeew0UXXYSnnnoKpaWlfV4zevRovPfee+L/hw4disceewzXXnst7HY7NJq+m2uxWGCxeBRpe3t7n2XkhjepczgZzBZ7n7xlMBrNfRvUcXgvARoRkNg4nUycQRVu2oh3VK5N6LSRe0SAJTbi5XBDJxrNVjSareixOYLemcabY3GLvCR252N/Deo4g8S0kbJGBHBfW7jR1fwMPV6+biK+3FOPG88qFyNPoXLW0DxU1rRjw8FGsQKJkDHysnHjRmRnZ4vCBQBmzpwJlUqFTZs2hbyetrY2mEwmv8IFAB5//HFkZWWJf2VlZVFve7gYtGro3ZUG4fZ64XfchZmGPr0D8ihtpAhauqxwuFt454XRpA7w+JyqE1q8xPYuv9FLrJ9oSdwLXGuXFW1un1us94nJyFN5iZk2Esuk/VzoB+a4BHtbty3iVHusYYxFlDbiTBuaj4cuHhW2cAGAacO4aZciL97IJl5qa2tRWFjo85hGo0Fubi5qa0MbGd7Y2IhHH300aKpp8eLFaGtrE/+OHz8e1XZHCk8dtYVp2uVeh+Ksvj8IShuFRn17D/70n714cd3BuPgk+P7JTtOGPBqAE2qjOqvdiWp3RVL8xEtsLpQNPuIlcVMLPOpSZNIjTSdbENsviT7tm5tbe1caAUC6XiMWIyjF99LeY4fF3WwuVMOuVEw+JQ9qlYCq5i7FmZzlJGzx8sADD0AQhKB/e/fu7X9F/dDe3o6f/vSnGDVqFB5++OGAy+n1ephMJp+/eCAOZwxbvLjuUEqz/YkXqjYKRpPZgv/7rBLnPLEWS78+hCdW7cMNb2yJeV+cSHq8cEJtVFfd2g0nc/VdCTdsHS2xvlB6R16OJ3DkxTPTKLZ+F8DbsJuYkQt/Deq8UdqYgAa33yXToIl5GjNDr8HYgVkAgI0UfREJ+3bhnnvuwQ033BB0mSFDhqC4uBj19fU+j9vtdjQ3N6O4uDjo6zs6OjB79mxkZmbigw8+gFYbuockXnh6vUQmXopNxj7P0YgA/7R12/Dat4ex7LsjYtfXsQOzsL/OjO8ONuLi57/Dy9dNxGmlWTHZHo94CS9lBHga1XVZHaht78EpAebjeKeMBEGIfGMjgHteYuWv4HOiAGVEXmLtdwG8S6UTM/JSF8TzAriO4x3HWxVj2q0Po0GdHJw1LB/bqlqx/lAjrjgj9taIRCRs8VJQUICCgoJ+l5s6dSpaW1uxdetWTJw4EQDw1Vdfwel0YsqUKQFf197ejlmzZkGv1+Pjjz+GwRB+fjEeeHq9hCc0gkVeaLK0L2aLHcvXH8Er3xwWe46MHmDCPT8ZgRmnFmBfXQduenMrqpq7cPlLG/Dny8dgzrgBsm9XJKMBOLxR3aGGTtS0dockXmINj7zEqsOuj+clgU2d8RUviV1t5KnM8X/+5l12lZI2Enu8ROB3kYKpQ/Pw3FcHseFQExhjMb+BSURk87yMHDkSs2fPxoIFC7B582asX78eCxcuxFVXXSVWGp08eRIVFRXYvHkzAJdw+clPfoLOzk68/vrraG9vR21tLWpra+FwJPZclexIIy+twTwvrjt5s8WOHltif3456bE58Oo3h3HuE2vx1Bf70d5jx6lFGVh67UT8e+HZOG9EIQRBQEWxCR8vPAvnnlqAHpsTd67cgf/9ZI/sPhjueYk0nRNKozouXiIx/EVLhj5+aaPEjrzEp0wa8Bh2E7VxYLBqI8C7XDpxxak3ohiLsd+FM2FQDvQaFRo6LDhYH7hXWiohq8vs7bffxsKFC3H++edDpVLh8ssvx9/+9jfxeZvNhn379qGry3WC2rZtm1iJNGzYMJ91HTlyBOXl5XJublSIjeoi9Lz07vECAJl6DXRqFawOJ5o6rRiQ3XeZZMZid+DdLcfx3FcHxTufU/LTcdfM4fjZmFKoVX3vPrLTdHjjhjPw9Bf78OK6Q3jtuyPYU9OO56+ZIDb9k5poPC+AR7gGm29UFacGdYDHX9FhiX21USJ7Xo7Fqbsu4BUNs9jhcDK/v4V44XAy0XTtz7ALeET4CYWkjXh0Ndw+TlJh0KoxqTwH6w82YcOhJgwvyozLdiQSsoqX3NxcrFixIuDz5eXlPk3dZsyYEXaTt0SB93oJZ76Rw6dBXd8fuSAIyE3Xoba9B83m1BEvdocT7287iWfXHMBJd2RqQLYRd84cjp+PHxB0HD0AqFUC7ptdgdEDsrDonz9gw6EmXPycywczeoD0PphIG9RxSt37vjrIfKN4taEH4lBt5NVJtLnTik6LHen62Fbz9EenxS5uZzwMu3yfAK50HvfcJQJNnRY4nK7eVXkBbhj4fKMTLd0JJ778Ee5oADmYNjQf6w82Yf3BRsybVh637UgUaLaRRESSNmoyW2B3+m9Qx+Gpo8YUqji67vXNuO+9H3GytRtFJj0evXQ01i6agSsmlfUrXLy56PQSfHDrWRicl4aTrd24/KUN+HD7Scm3V/S8hDGU0Zv+GtUxxjzddePieYmdOdTmcKLF/Rvi06wTsdcLF5M5adq4CAe9xtNbKtEa1fGUUV6GPuDvtSTLAI1KgNXhFG/gEploerxIxVnDXHOO/nu4SewrlcqQeJEIXiodznDG6iAN6ji810uqVBxZ7U6xDfYDF1bg63vPw3VnDoZOE9mhOqI4Ex/fdjZmjCiAxe7EXe/swCP/ltYHE23aqL9GdS1dNnS4u9vyEtNYEkvDLjenqwSIofFELKflfpdBcfC7cBK14oj7QwL5XQBAo1ah1B1JTsT925tIRwNIyehSEzL1GrT32LG7OrHn/cUCEi8SwdNG4XSMrA0wTdqbVBsR0OJOu6lVAm46Z4gkPRWy0rR4fd4ZWHiey0e1bP0RXPv6Jkm+U6eTicIyYvHST6M6fpdfZNLHpVV+hlu8WB1O2Y3jPIqVm67HYO6LSEDTLh/IWB6HNB7HZEzMEQFimXQ/UQo5ZhzJZTtIhLSRRq3ClCGubrvraco0iRep8AxnDD1CUt0a2O/CSbURATyKkZOmg0rCPLhaJWDRrBFYeu0EpOvU+O/hZlz83HfYdTK6O5i2bhvsEY4G4JSYgjeqE/0ucfBWAECGTgNemSn3Xb53zxxPOW3ipY3EMuk4pPE4iRp56a9BHUfq/butqgUj/rAKb6w/Isn6OD02h/gdF8QxbQQA04byUQGNcd2ORIDEi0SIkZcw0ka1AaZJe5NqIwKaxQGH8lQGzR5dgg9vOwun5Kejuq0Hd67cHtX6+MU2y6iFXhNZVMRkdDWqA/xXHB2PY5k0AKhUAjJ0sekr4l12PjAncSMv8SyT5ojDGROsy25/Deo4ZeKARmn27wfbTsJqd+KL3XWSrI/D/S56jUr8zuMF971sOdoMiz1122cAJF4kg0deemyhh9Z5dUnQyEuKjQjgKRi5ypoBl5fivVumQSUAhxo6ozIMNkTRXZcjCIJYLl3jp+JI9FfE9S4/NhVH3v4h8c48AXuBxLNBHUcsYU+wtFFDPw3qOGUSjwjYcrQZgLRpKABoMLs+T0GmPu7N4U4tykB+hg49Nid2VLXGdVviDYkXicjQa8Ryv1CjL7VBerxwUjVtlCdzP4XcdB0qil1zsLYda4l4PY1R+l04pUEa1YnddfPiVyrPUxRmi8zipcMrbZSgkReL3YFqtz8pnpEXKQSlw8kkr1wJNfIipeelvceGfXUdAFzDbm0SGvLjPRrAG0EQMHWoK/qyPsXnHJF4kQhBEDwjAkI07YpzjYJGXlKr2oiLtED9IaRk4uAcAMDWaMSLWCYd3YktWKM6HnkYFCfPC+Ax7cqfNvJEXgbkuMRae4897OaPcnKipRuMAek6tWzpzVDwdNmN/Lu5+tX/4twn1qJTQlHKI5mBGtRxuHip77BEbQTfdqwF3KvrZMF7JoVLvEcD9Ib7XjamuO+FxIuEeIYz9i80vBvU+ZtrxOEX8UazRbEN/MLBU7kj/0VhwuBsAMDWqsjFS0OUDeo4gRrVWe1O8S4/EdJGcrej9/a8pOk04nGQSNEX7zLpeKYRMqMc21Db1oPNR5pxsrUbu6vbJdkmh5OJArS/ypzsNK04eiLa/fv9Ud/fsJSpo3iPBujNWe7Iy/aqVklFp9Ig8SIhnuGM/d8JNXo1qAt24eOeF4vdiS4/lSjJBvf28KGUcjJxUC4AYNfJtojv/LzTHNEQqFHdiZYuMAYYtfG9y49VZUvvIZcDRF9E4vhejjbGv0wa8BaUkUVedhxvFf99qEGaeTlNZgucDO7uusF/w4IgiKbdaMUG97vwAkVJxUsCpY0AYFBeGgbmGGF3MvFzpyIkXiREnG8UQtqIp4yKTIEb1AFAmk4Do7u3Ryqkjpp42igGF+qyXCPyM/SwOVjEJdPRNqjjcNN270Z13tOk43qXH4e0EQCUuVNHiRR58XiQ4iteeNooUkH5w4lW8d9SDfvjfpeCTH1ILf/5/o1GnFrtTlGI8WocaSMviZU2ArxLplPX90LiRUI8kZf+RUawadK9SaURAbFMGwmCgIk8dRSh70Uqwy5vVNi7Ud3xBLlQxqLLrt3hRLM75cpHLQz0moGTKBx1p43K42jWBTzRsEhTeT94RV6kEy+h+V04Uph2d1W3wWJ3IidNixkjCgEAJySM1IlDGRMkbQR4RNr6g6nreyHxIiGmMAy7PPJSGqTSiOPpspsCkRdz7NJGgMe0uy1C34s4lDHKkHKgRnVVcZxp5E20/opQaO6ygjFAEIBcdxSTl0snVOQlARrUAZ4+Lx0RmJmdToYfT3iijZKJlxDLpDlS9Hr53p06mTg4V5auvfVxnijtj6nuTrt7atrRkiKVqL0h8SIhni67oYiXcCIvrh9Nc5JHXnpsDnS6L9yxSBsB3hVHrWEbohnzGg0QpXgJ1KguYcQL97xY5EsbNXa4e/yk6cRU6sAE87zYHU4cdwupwfnKjbwcbjTDbLFDq3aldk62dqPLGr0w5WmjUM2tUogNbtY9ozxHcvFidzhFH16iGHYBV/fi4YUZYMw1qDEVIfEiIdlhdNmtEXu8hCBexIqj5FbY3O+iU6vEO325Oa00Czq1Co1mS9gXyPZuO6zufhLRlnb7NKrzSh3xZmjxFy/yR178+Ye8PS+JUG1X09YDm4NBp1GhJMTUiFxEY9j94bgr6jKuLBs57puuww2dUW8Tb1DX31wjTlmuJy0Yyf5ljOF7d8p3UnmuGKlr67aFNWcuEE2drmhgKAbkWJPqvhcSLxISiWE3WIM6Tqr0emkSG9TpYmZONWjVGD3A1axua1V4zn3eeTPToJFkYKLYqM4984oxFvfRAJxo/RWhIIqXTI8Q5JOHO60OtEhwMYoWLibLcoySzt6KBJ6mttqdYbeK52bdsQOzMawwA4A0FUehNqjjDHSLU7PFHtH+PdzYieZOK/QaFUYPMLnL613vfVyCVCOvNMrPCM2AHEumcd9LivZ7IfEiIVlhDGcUu+sG6fHC8XTZTe60USxGA/hjwqDImtU1uNMcUuXCezeqa+60otPqgCB4TvLxwmPYlTFt5CfyYtCqxQthIvheEsWsC0DskQKEHxHjZt2xZR7xIoXvJVzDrvf+jSTVw/0uY8uyxdlig8SxEhKIlwTr8eLNmafkQSW4Ima9WyykAiReJCTUDrsOJ/Mayhh6tVFTkhuzPGXSsT1RePtewkGqMmlOSa9GdfxkXmwySBLZiYbYpI38V24lku/lP7tqAAAVJZlx3hLXpHSeXg1nOKPF7sCeGldTunFl2RhaIKV4Cd/AHs2Moy1efhdxfRL6XhKxTJqTlabF6AFZAFJzyjSJFwkJNW3UaLbA4WRQq4SQfhSpMlmap43yYx15cYuXfbXtYfUx8ZfmiIaSXo3qqhIkZQQAmXr5m9Txhn+9L3yJ0utld3Ub1h9sglol4OrJg+K6LZxIRGVlTQdsDobcdB0G5hgxVKK0kbe5NdTICxCdaZdHXiaV50qyvt40iOIl8SIvADDN3W03FX0vJF4khEdeOiz2oIPB+J11YYiNnDyl0kmeNuqMT9qoyGTAwBwjnMxjZAwF2SIvXLwkiFkX8Fwku20OSYfeedMQ4PsUIy9xFi+vfXsEAHDR6SXiNsUbjxcpdNEtpowGZkEQBAxzR16ONHbCHsW+bTS7zK1qlRCWgX2gaNoNb/82dFhwtKkLguBJ/QJSR148E6UTEdG0e7AxIQztsYTEi4RwAx0QPIxbG0alEeBJGzV3WpP6AI3VRGl/RDKksVFiz0vvRnX85BvvfiKAZzAjIF+juoYAoxY8vV7ilzaqaevGv3+oBgAsOOeUuG1Hb0zG8CMv3n4XABiQbYRRq4bNwaK64HO/S2GmPiwzc6SRkq3HXFGXEUWZyPI69w6SoHcMJ9FGA/TmjPJcaNUCqtt6cLQp/p6wWELiRULUKkFsHBWs10t1GJVGgCcSYXcytHcn7yCu5hiOBuhNJM3qPGkjicSLV6O6HpsjYdrQA4BWrRLHVJhlGgbXv+clfifn5RuOwu5kmHJKLsYMzI7bdvTGM3Mq9MjLDl5p5BYvKpWAIQUuA3I0vhdv8RIOkY4I4H6XSV5+F8AjXk62dsPhjO5mT2xQl4CeFwAw6tQY7446pZrvhcSLxHgmSweLvLh+pKFGXvQatRi2T+YRAbzaKNqeKZHAw87bqlrgDPGEJ3XayGT0zLGqaetJKM8LEP0gwGA4nEyspuvreYmuF0i0mC12rNhUBQBYcM6QmL9/MPjNUqg3NW3dNrGfy1gvESZWHEXhexHNrWH2v+Hi/GRrd1hpK+53OcPL7wK40sBatQCbg/k0fIwE0fOSgNVGHD5lesPB1PK9kHiRmGyj68IbLG3EIy+hdNfleMqlk9e02xTHtFFFcSbSdGp09NhDPoEHSnNEiiAIYuroaFOneOJNBM8L4EkdyWHabemygmvG3p6nkmwDVIJrsnpDHHxf72w5jo4eO4YUpON/Kgpj/v7BCDfystM9EqAs1+jzPfOKo0P1kTeqqxfLpMP7/RZlGqBTq+BwMrH/VX90We3YVe2qmJrUS7yoVYIYrauKIpXCGEt4wy4ATBvm8r1sPNwU8o1XMkDiRWKyQ+j1wj0vvAFXKHga1SVn5IUx5imVjkPkRaNWYZw7jB6K74UxJtlQRm94NO77o81gDEjXqePyffjDc6GUXrzwKFZOmhbaXlPWtWqVmGKNte/F7nBi2Xcuo+6vzx4S98Z0vfFEw0LbJ97N6byRIvIiNqgLM8WiUgliH6NQU4M7qlrhcDKUZhkwwM95VIqZSa1dNrGDdqIadgHXvkzTqdHcacXe2o54b07MIPEiMVkh9HoJZ6I0J9lHBHRaHbDY3a324+B5AcJrVtfeY5flxMYv0puPuELiZblpMes23B/iIEAZ0kbc/BxICA4I8+ImFf/ZVYuTrd3IS9fh5xMGxPS9Q4EXCYSaytvhNutyoc4Ru+zWmyNOzdVF0dAt3Aohj98l1+/zvFFdNAZkHuXLTtOKDfASEZ1GJabOUsn3QuJFYrL78bw4nAx17lBkKBOlOWKjuiQVLzyiZNSqkaaLzVyj3oim3RDEC48UZOilGQ3A4ZEXXrKdKCkjQN5Gdf35h7x9L7GCMYZXvz0MALhu6uC4Nwr0R7j7pHelEWdwXhrUKgFmi12MoISLWJkTwcwnXlEWajn898d4f5ccv89L0euFf55EmiYdiLOGpd6cIxIvEsM9L4GGMzZ0eBrUhXPHzoeCJeuIAB5RilfUBQDGD8oG4JmXEoxADdWihUdeeFQnocSLu1GdHNVG/VVuDYxDo7rNR5rx44k26DUqXHfm4Ji9bziYeJ+XEDrs1rb1oL7DArVKwGmlJp/n9Bq1eKxF2qyuPsyhjN54xEb/4tTucIo3GJMG+4+8lEnQGyiRRwP0hjer23S4SbY+TIkGiReJ8URe/F/8+MTgohAb1HH4Rb0xSQ27zXEaDeBNdppODJ/3F33x+F2kFVu9K9AGJ0CZNCdDxmojHqIPdJfr8TDELvLyqrsp3eUTB8b1uAxGOJEXnjI6tSjTb3QzmjEBNodT/E2Ea9gFwhsRsLe2A51WBzL1Gowo9j+mQQrPSyKPBujNqBITstO06LQ68OOJ0BttKhkSLxIjel4C3AnVRFBpBHgqMJLVsCtWGsXZnDqR+1766fcidZk0p/dxkShl0oDMaSPueQkwaiHWkZdDDWZ8WVkHAJh/duI0petNOB12uVl3XFmW3+ejGdDIq3K0agE5aeH/hsMRG7xEesLgnIA3gLz8utFsRWeEkcJEb1DnjUolYOoQT7fdVIDEi8Tw+UaBPC814jTp8KYE84tkspZKx7PSyJtQfS9yiZfePqiEShvFoNoooOdFwsZjofC6u8Jo5shCMSKRiGSF0WHXMxYg2+/z0YgXsZlbRnjddTl8/zZ19i82thzrO4yxNyaDVoyCR5o6SvTRAL0RRwWkiO+FxIvE8B9MIM8LrzQqCdPUlvyG3finjQDPkMYfTrQGzR17erxIu73ejeoEwVNlkwhkylht1NARPG1UbDJAo3I1HuMXFbloMlvw3tYTABKvKV1vvPu8BKsScjqZmE7obdblRFMuLXbXjcCsC7gi1jxqHUxsMMb8DmP0h+ijibDXS6RN9+LFtGEu38vWqhbRnpDMkHiRGE+pdADPS3tkkRfRsNtljcmdZ6zh02il9pCEy5D8dGSnadFjc6Kypj3gclJPlOZ4N6orzTImVIkmL5WWY7ZRf5EXtUoQ+yLJ7Xt567/HYLE7MWZgFiafEvwCGW+4oHQyV7uBQBxuNMNsscOoVWN4of9IEh8R0NBhCXjzFYhIG9R5E4rYONHSjbp2C7RqIWAEieMx7UZ2vDQqoEGdN0Py0zF2YBasdidue3sbrPbkNu6SeJEYPlm6rdvmt9uhGHkJ0/OS447oMBZYGCkZHnmJ9UTp3qhUAsaH0KyuQYYGdRx+bPDy0UQhQy9P2sjp9DQoDCYGY+F76bE58ObGYwBcUZdE6bETCKNWDY07TRMsIrbDXXp/+oAsaNT+T/smg1YUH+FWHIkN6qKIUnjKpQOLDV4iPXpAFoy64MI+WtNuvUwVhXIhCAKeu3oCMg0abKtqxZ/+s1e299pW1YIua3zn7JF4kRjeNMrJALOfnRvuRGmORq0SBUxTEvpemhKg2ogTyoTpRpnSRoCnXDqR/C6AfGmj1m6bGE3kEUZ/eCpS5Iu8vL/tJJo7rRiQbcSFo4tlex+pEATB02U3yHwjT38X/2ZdTqS+F7GsOIoLfShiQ2xONziw34UTTa+XLqtdbAmglMgL4DIq/+WKcQCAZeuP4NMfayR/jy1Hm3HNq//F9a9vliWFHCokXiTGoFWLnoW2XqZd7wZ1oU6U9oZf2BuTsOIoUaqNAI/vJZBp1zUaQL6Q8jnD86FTqzD91ESboyNPtRH/LrOMWug0gU9JckdenE6G175zNaW78azygBGKRIPfMAW7kPzQa5J0IIYVeDrthkNdFA3qOKGUS4fqdwGiEy+80sioVSNDH5+mmZFywagi/Gb6UADAff/6IeK+Pf7YdbINv3pjC3psTmQYNHFNayvj16kwAnXZjbRBHcdTLp1ckRenk3n1eYm/eBk7MBtqlYDqth5Ut/a9yzdb7OIoAzkiL3PGDcCuP87CT8eUSL7uaODmULPVLukAuMYQB1yKd+YyiZev9tbjcEMnMg0aXDV5kCzvIQf9icoem0P0b/XnExnKxwSEnTbinpfIxUt/YqO1y4r9da7tCifycry5K+yRB/Ve06QTPXXoj0U/ORVTTslFp9WBW/7fVklSPAfrzbh+2WZ0WOyYXJ6Ll+ZODHqzITeyvnNzczPmzp0Lk8mE7OxszJ8/H2ZzaD8KxhguvPBCCIKADz/8UM7NlBxPrxdfkVEdYYM6Dj+5J1u5dHuPDXb3xTDenhcASNdrMLLE1fxqm59+L7wZV7pO3W/ePVLieVIIBL9IMgZ0Spjvbgix7NwTeZEnbcRHAVwzeZCi7rZ55+NAvV4qa9phczDkpevE7zAQwyJsVMcv9tEYdr3FqT+xwdO4QwrSQ0ov+0wj7wgvWi1FGiyeaNQqPHfNeBRk6rG/zowHP9gV8cwqwBXtvO71TWjutOL0AVl4/YZJsp37QkXWM+TcuXOxe/durF69Gp988gm++eYb3HTTTSG99q9//asiFS8QOPJS0xpZpRGH+wGSrVEd97tkxjkM6c3EIEMaxTJphZ7YIkWvUUGr5uZQ6cQLF4P9RSP5xa2mrQd2iVug/3iiFZuONEOjEnDDWeWSrltuTMbgk6W95xn1d07lnpeq5i702AJXL3ljtTvFG6poutEOyDZCEIAem1MUtN5wv8sZAUYC9EarVokVauGmjjwN6pRRJu2PwkwDnrt6PNQqAe9vP4l/bD4e0XrqO3pw7WubUNPWg2GFGfj7ryaLUdh4Ipt4qaysxKpVq/Daa69hypQpOPvss/Hcc89h5cqVqK6uDvraHTt24Omnn8ayZcvk2jxZ4fONenfZ5bX34XbX5fCoRLKNCBB7vCRA1IUj+l6qWvs8J1eDukRHEARxlk64pbTBCPX7LMjQQ6dRweFkYrNHqeCjAC4eWxqRHy2eZPYz30js79JPyghwCchMgwZOBhxt6gzp/bnQcHXXjfyiptOoxCaN/nwvW/sZxuiPSH0v4rgKhd+gnDkkD/fOGgEAePjj3dgZ5uiAti4brn99M442dWFgjhH/b/6UhIiOAzKKl40bNyI7OxuTJk0SH5s5cyZUKhU2bdoU8HVdXV245ppr8MILL6C4uH+3v8ViQXt7u89fvBEb1fUqaeYn3NIIxYuYNkoyz4to1k0gMcArjnafbOtzB+q52CbGjziW8B40UqZuQh1yqVIJGMh7vUjoeznR0oXPdrqqMn59TuKOAgiEqZ/OxzvcZt0x/VQaAS6BGm7FkdigLtMQdbScp7V6V5T12BzipPUzQjDrciIVL+JEaYWLFwC4+dwhuGBUEawOJ255e2ufQpJAdFrsuGH5Zuyt7UBBph7/b/6UiG+85UA28VJbW4vCQt9qCY1Gg9zcXNTW1gZ83W9/+1tMmzYNc+bMCel9Hn/8cWRlZYl/ZWVlUW23FGQFSBvVinONIkwbuS/uTRJMlj7S2In//WRPyAeynCTKaABvBmQbUZiph92rMylHzjLpRGdwrquR2bEQ78pDIRwxOEAG38sb64/C4WQ4a1geTivt/wKfaAQrYW/rtuFwg2tfhRJ5ATwDGg/Vh7aPpWhQxwkkNnadbIPV4UR+hi6sYaVlkYoXhXtevBEEAU/9ciwG5abhREs37n53R7+G+x6bAze99T22V7Uiy6jFW/Mnozw/PUZbHBphi5cHHngAgiAE/du7N7LmOB9//DG++uor/PWvfw35NYsXL0ZbW5v4d/x4ZHk9KQk0nJEbdiONvORJWG30l9X78dp3R/DyN4eiXle0JMpoAG8EQQjY76UhRI9GMsIH3kVSfhqIUA27gOdidEKi92/rtmHl5ioAwK8TfBRAIMQ+L34iLzxNMCg3LeRwf7hjAuok9IcE6vXi6e+SG1Z0x3O8hCd2GxQ2GqA/soxavDh3AnQaFdbsrcdLXwc+79sdTtz+j+1Yf7AJ6To1/v6ryagoNsVwa0MjbEv9PffcgxtuuCHoMkOGDEFxcTHq6+t9Hrfb7Whubg6YDvrqq69w6NAhZGdn+zx++eWX45xzzsG6dev6vEav10OvT6yLCPe89PYF1EY4UZrDy4il6POy66TrpJYIQ7x4JCmRIi+AK3X0n121fcRLqnpeAGCw+2JwLMJ5Mf4QJ0qH8H1KXXG0cnMVOq0ODC/MwIxTCyRZZ6wJ1ucl1P4u3oRbccSjFHJGXjz9XUL3uwRbX3/UK2w0QCiMHpCFRy45DQ+8vxNPf7EP4wdlY9rQfJ9lnE6G+/71I1bvqYNOo8Kr8yZhXBjHTiwJW7wUFBSgoKD/H/nUqVPR2tqKrVu3YuLEiQBc4sTpdGLKlCl+X/PAAw/g17/+tc9jp59+Op555hlcfPHF4W5q3PB4XjwnE7vDKeaGS6OsNmrvscNqd0ZcTmu22HGk0RUS3nmyDWaLPa6loZ7IS2KJF49ptwWMMfGOL5XFi9SRF8aYZ65VCBcKz7ya6N/fanfijfVHAShjFEAgTGKH3b7iZYc4STr0dBiPvBxuMIt9qYIhRYM6Dh8R4C1OnU6G78VJ0uHNmuLipba9Bz02Bwza/qsZfaunkus3fuUZZfj+WAv+tfUE7vjHdnx6xzlibx7GGP747914f/tJqFUCXrhmQh9xk0jI5nkZOXIkZs+ejQULFmDz5s1Yv349Fi5ciKuuugqlpaUAgJMnT6KiogKbN28GABQXF2P06NE+fwAwaNAgnHKKcox02X76vDSYLXAyQKMSIr7oZRm14omkJYr5Rnu9Bg46nAxbjjRHvC4pECMvCSYGTis1QadRobnTiqNekYZGsRIhscRWLBic58p7n2jpkmRAaFu3DTYHHw3Q//cpZeRlTWUdatt7kJ+hx5zxpVGvL14EMuwyxkTxEs7d88AcI3RqFSx2p98mjb2RokEdh6d5qtu6xcGChxrMaOu2wahVY1RpeOmLnDSteGMW6jHDf98alYCctOT6jQuCgEfnjEZFcSYazVYsXLENNnfbgae/2I+/bzwGQQCe/uVYXDCqKM5bGxxZ+7y8/fbbqKiowPnnn4+LLroIZ599Nl555RXxeZvNhn379qGrS75Ba/HAn2G3utXzA4+kQR3gqrbgP6ZoUke7q30rsjYejm/qKBFLpQFAr1FjzADXHStPHTHGPH1eEkxsxYJikwE6tQo2BwvpwtYf/DjONGhCuisu87qTtthD60MSiK/2utLal44rTZj+QpGQGUC81Lb3oKHDArVKCMuIrFGrcIrbnBlK6sjTEyX630NBhh4GrQqMASfdxxf3u4wflA1tmCMbBEEIe0Cj9+9bFeG5OpEx6tR46dqJyNRrsOVoC578fB9e/voQnl97EADwyCWn4dLxA+K8lf0jq3jJzc3FihUr0NHRgba2NixbtgwZGZ5x7OXl5WCMYcaMGQHXwRjDpZdeKudmSk52mqfPC+9qGK3fhSNFl909bvFS7k4BbIyz76UpgUYD9Ka3abfT6kCPTb7RAImOWiVgYG5kjb/80eD2uxSE+F3mpetg1KrBmKfpYyQwxvDNgQYAwLkK9bpwPIZd37QRb043oigz7G6o4ZRLezwv0UdeBEHoM+MonHlG/ijLCa+83ns0QLJySn46nvzlGADAK98cxuPuCdT3zR6B66aWx3HLQifxepAnATxtZLU7xQsdb1AX7jTp3vALfDQVR7trXGbdG89ypeJ2V7dJ2nQsHBxOJqbAgk0Ujhfc97LdPSaAl0kbtWqkK6iFvJRIadoN1z8kCIKnF0gUvpf9dWbUtVug16gw+ZTILoqJAjfsdlkdPp2Hd7j7ooRj1uUMDVG8WOwOtLgjzFIYdoG+Jtst7uZ0Z4Rp1u2zvhCP12Qqkw7G7NElWODV1+g304fi1hnD4rhF4UHiRQbSdGqxjTr3vfAGdVGLl/ToJkvbHE7sr3WdkM4bUYgh+elwMmBznHwvLV1WMAYIAqLqzikXE9xjAvbVdaC9x+a52Kag34XDfS/HmqPv9dIYQSdTKXwv3+x3RV2mDMkLKV2VyPDIC+CbOvpB9LuE37sm1HJpnjLSaVRii4ho8Z5xVNvWg+PN3VAJwPhBEYqXME3mngZ1yVEmHYz7Zlfg5ulD8PuLRuL+2SPivTlhQeJFBgRBQBYfEeC+K/FEXqJrPc57NUSaNjpYb4bV4USmQYOyXCPOHJoHIH6pIx5ByjZqoQkznx0LCjL1GJSbBsaAHVWtnottCqaMOLxJ2LFGKSMvoYvBcD0M/hBTRsMTt5oiVLRqFYxuAcbFi8PJsPNkFJGXAo/nJdhAP+8ohVTVWt7793t31GVkiSniishwG9UlY5l0ILRqFRZfOBILzlVetV3iXS2ShN7DGaWKvORHmTbiZt1RJSYIgoCpQ9ziJU6m3UQcDdAbb98Lb1CXin4XjiheJPC8hNPjhRNt5KXH5hAjjdMV7nfh9Pa9HG4ww2yxI02nxvDCzLDXN7QgA4LgqgZrCnKjxKMUUvhdOGVeIwK+PxpZibQ3g7zEUCiTlRu4IEtiz0syQOJFJngIlXtJop0ozYl2RMDuatfdGC85PNMtXipr2tESh4GPiTgaoDfe/V4aU3SitDeD3CMCqpo6Q7oYBEPsrhvG9xltr5dNR5phsTtRbDKI6RGl01u8/ODurDt6QFZE1Y0GrVoUicF8L3USjgbgeKd5vo9gGGNvBrjPuZ1Wjz8nGGJ33RRIGykZEi8ykS2KFyvsDqcYXo028iJOlo4w8sIrjXjpZEGmHsPdJ/BNR2IfffFEXhJXvEwcxE27reLJOpUjL2W5RgiC62IQ7K48FCJp+DdQrEaJLPLC/S7nnpqvuFB5IDxddl1pox8i6O/Sm1A67dbJcKHn4rSt2yZGiicNjjzyYtCqUeyODIWSOqoPcVAoEV9IvMiEd6+X+o7oG9RxoimVZoxhTw0XL55mT1Pj6HvxRF4S90QxojgT6To1zBa7OE6hIIHFltzoNWqUuC8G0VYceYZchuN5cd1JN5otfSZ+h4JHvCRHygjw9HrhXXbFsQAhDmP0hzigMYhpV5woLWHkJV2vESOxjLn2d7QtJkIdE+B0Mq/IS+KekwgSL7LB5xu1dttEv0s0Deo4/CLfFEG10fHmbnT02KFTq3zC5fH0vSRyjxeOWiWIlQ785JfKkRfAO7QfecURY0yMIIbzfWYZvbumhieeatq6caDeDJUAnD1M+WZdjkmcLG1Hj82BSvdNytgIKo04ofR64Rf6IolTLNxkCwBnRBF16b2+/kzeLV1W2N2do1P9N57okHiRCW/DrlQ9XgAg132RdzVLC++uc4+7v8upxRk+nSqnuMXL/jqzJEMfw0FMGyWw5wXw+F44qex5AYDBbt9LNJGX9h47rO6+JOGE6H17vYSXOvp2fyMAYMzAbLGZZDLg3WW3sqYdNgdDXrpO9HtEAhcvh0LyvMgnXiZG4XfhhNrrhaeMctN1Ec+OI2ID7R2ZEIczdlsl664LAJl6DXRu4RGu34Dnj08r8b0by03XoaLYVZHw3xhHXzxDGRNbDEzsLV4SfHvlRoy8RCFeuFDO0Ic2GsAb7ns5EWbF09dJVCLtjcnLsMv9LmPLsqPy9PC0UXVbDzotdr/L1InVRtL+HgblekRXNJVGHJ5q7M/knUpl0kqHxItM8Gqj1i6bONco0mnS3giC4NVlN7woiVgm7We4Ga86irXvpVkB1UZAX+Njqpv5pCiXjsTvwvE3fbg/HE6G7w64Ii/J5HcBvA27NrHSKBq/CwDkpOvE36U/30uPzSFWU0oxUdobbtrNMmpF43A0hOp5qXdHklL9960ESLzIhDjfqMuG2nbXCbZYoh94pCMCPJVGfcULN+3GOvLSqIA+L4DrJHpqkeskatCqkB7mrJhkQ4q0Efe7RHKhGBhBufSPJ1rR1m1DpkETVRVOIpLp5XnxRF4i97tw+JgAf+KF93jRa1Ri5EcqzhqWD5NBg19OHCjJcEQuXqpbu8Upyv7gpftUJp34kHiRiWyvPi+eyIs0P4jcCEYENJktqG3vgSAAFSV+Ii+n5EEQgEMNneLdh9xY7U60u0s7Ez3yAnhSR/kZ0nUTVSo8bdRotgRMKfRHJGXSnLIIGtV96466nDU0PyG7OUcDFy8nWrpxuNFloo428gIEN+16D2SU+vdQlpuGHx+ehd//dKQk6yvI1EOvUcHJEHQaumc0QGLfTBEkXmTDY9j1eF6iHQ3AyY9gRMBucZJ0ut8221lpWoxyi5pYVR3x7VerBMnmosjJRHfVg1QRNCWTZdSKx3ik06WjES8Dc0KrHvEmGUukOSa3YXeXuwnl4Lw05EhwQxCs14tcfhdvpBJFgiCElDqiMmnlQOJFJvjFuNPqkKxBHUdMG4UhXnh/F39+Fw4vmY5V6oh3Cc5N10kSGpabn40pwfyzT8GiWcoaYCYX0U6Xjkq8uD0vLV02mEOI/LT32LDdnU45J8nMuoCn2og3PJYi6gIEj7x4erwoQ8x7yqWDRF5oNIBiIPEiE5kGLfhNg1QN6jiRpI28ZxoFItbN6sRKIwWkjABXp84//GyUaG5Odfh06Uh7vTSIoxbC3/8mg1a8QQil18uGg41wOBmG5Kf7lOEmCyajbzQ1kmGM/uCel2NNXX28InVeQxmVQCiRl3oaDaAYSLzIhFoliKFcwJUXliq6kBdBl9097nCyP7Mu54xTcqESgKNNXWJvGjnhkZdEblBHBEasOIow8hLtkEux4iiEMQFf70/OKiNOpsE37TpOArMuAJRmGZCmU8PuZH32c4MMQxnlpL9GdYwx0fOiFEGWypB4kRHuCQCkM+sC4U+W7rLaRRMfn2nkD5NBi9MHuJ6PRfTFE3mhE4USCbX8NBCeUunI9v/A7NAqjhhjPvOMkpFMr2oftUoI+jsPB0EQxH4vvVNHdaJhVxm/3/6OV7PFjm53409KGyU+JF5kJNvLhFoskVkX8KSNQu3zUlnTAcZcDvr+XPRnxjB1pITRAERgeNroaFP4aSPXaAB3ZUe0kZd+Ko6ONHbiZGs3dGpV0qb8MnQaMU1dUZwZdtO/YAwLUC4tGnYVkmLpT7zwNGaGXoM0nbSl34T0kHiRkSyv9uOlEpl1AY9HpLHTCsYdekHwN4wxELGcc6SU0QCEf3jaqLq1J2jvDH+YLXZY7K7XROJ5AUKvOOJRl0nlOUl7UVKpBLGKUCq/C2dogUuk9om8yDCUUU74SIm2bpvYXM8bmiatLEi8yIhv5EVC8eKOVFjtTnRa+59vFIrfhXNGeS40KgEnWrrDKkONBKWMBiD8U5iph0GrgsPJcDLMGUO8QV2aTh2xoAg18vKNu7/LOcOT0+/C4R67cRJVGnH8RV66rQ50uHs0KaXaKF2vEVPu/s5tJF6UBYkXGfH2vEjV4wUA0nQapLk7vIaSOvJUGvWfB0/XazBmoNv3InP0pUkhowEI/3j3zgh3TICYMoriQhFKl12L3SGmQJPV78KZMiQXmXoNzpH4c3oPaOSRXl5SbNSqkemnb1SiEsy0y5tzkllXGZB4kRHvyItUPV44uTx11I9p1+5wYm9tB4DQIi+AZ87Rf2X2vVC1kfIZ5B4TUBWm7yVasy7gSQN09Nj9pgEAYOuxFnTbHMjP0GNkcWjHv1J5+pdj8f0fZkp6owS4vE0alYBOqwM17oab3g3qlNRtOpjvpYHKpBUFiRcZ8fa8lEhYbQR4Ui39lUsfauiE1e5Ehl4j/nD7Q+z3crgpJE9NpFC1kfKJtFza06AucuGaptOIUbtAKc5veIn08HxFNEKMBkEQoNdIP3NLq1aJ+5n7XkS/i8Iu9MHEi9jjRSEenlSHxIuM8CZaWrWAfIkv0HxEQH9po91uv8vIksyQT96TBudCqxZQ09YT1eC9YHRbHehy+3Uo8qJcIp0uHW2PF85A98UokO8lmUcCxJLe5dJKvdDzadX+xQuljZQEiRcZ4WkjKRvUcXjaqL8RAZ5J0qH3fTDq1OLUXbl8LzxlpFOr/M5aIpSBeCcbceQlSvEiDmj0nwbglXZnJ+FIgFjS27TL/SFKaVDHKQsidiltpCxIvMjIhME5GJKfjp+PHyD5unnaqL9GdaGMBfCHWDItk+/FU2mkU1TOnPDFMyKgK6wUo2c0QHTihd9J+7sYfXvAFXU5rdQk2WiOVKX3jKO6dmU1qOPwaegnWrrgcPoer1RtpCxIvMhIbroOXy2agbt/Iv0gP7HLbmfgtBFjTEwbBRvI6I8zZfa9kFk3ORiQbYRKALptDlGQhIKnQV10+5+XS/vzvHx7ILlHAsSS3pGXunZlRimKTQZo1QJsDoZatwADXFVprV0u0zeljZQBiReFkhfCiICTrd1o77FDqxZwalFmWOufMCgHOo0KDR0WHGqIbPBeMMismxzoNCqUZrsERDi+F+nSRv4jL04nEyMv5yZ5f5dYMMTteWk0W9HaZVXs9GW1ShCPGe9UJxfeOrXKp8UFkbiQeFEooUyW5imjYYWZ0GnC29UGrRoTBmUDkMf3Qj1ekodIKo4aO6Qx7Ja5PS/HW3zTVntq2tFotiJNp8bEwTlRvQfhapnP2z0cajCLAwyV5nkBPD4p72idd8qI0tjKgMSLQuEX/WCl0rurQx8L4I+pQ1wmRzn6vYijAShtpHhE30uIvV46vQbgRet54VGfLqsDLV2eXi/fuKMuU4fkhS3cCf/w1NGPJ9rQYXF111WieOEmc+/mhlyMkd9FOdCvWqHke/V5cTr9e1L2RCte3L6X/8rge/EMZaSThdIZHGaXXR4tNGrVSNdF15fEoFWLplHvO2kqkZYeXi69wX0zk6ZTK7JS0F+vlwYqk1YcJF4USk66Ky9rdzK09/jvLspnGoVbacQZW5YFg1aFpk4rDvQayhYt3POSS2kjxRNu2kj0u2RKU2nW2/fSabFj67EWACRepIRHXv7rTiMrMeoCBBIvyuxbk8qQeFEoeo0amQbXXY+/Xi8tnVZUu1t5j4ww8qLXqDFpcC4A6UumebVRNB1WicSAjwg4FmLaqEEivwvH2/cCuC6uNgdDWa4R5XmhdZUm+odHXsSBjAqNUvibbyR6XjKUKchSERIvCiY/SK8X3pxrUG6aOG02EsRRARKLl2aqNkoaeO+Mli5bwCigN1JVGnHEAY3ui5GYMhpeQOZLCeGRF45SIy9cvDSareh0e3eU2jE4lSHxomByg4wI4P1dIvW7cMQhjUeaAnprwoUxhsZOT5M6Qtlk6DViBC2UTrtSixfe64Wnjb5x93c5h0qkJSU/QyeOPAGU16COk2XUip+DHzM0GkB5kHhRMLziqNFP2ihasy5nzMAspOnUaO2yidOpo8VsscNqdwKgyEuywH0EofhepGpQxxEjLy1dON7chSONnVCrBEwblifJ+gkXgiD4RF+U1qDOm96+l3qFNt1LZUi8KBhxsrSftJE4FiBK8aJVqzCp3O17kajfC09zpenUMEZZbUIkBrxc+lhz/74XqUYDcPiIgJMt3VjnThlNGJQdVbqU8M/QgnTx30pOsXiLF4eTiYJayZ8p1ZBNvDQ3N2Pu3LkwmUzIzs7G/PnzYTb3X7GyceNG/M///A/S09NhMplw7rnnorvb/8TYVCfQiIBuq0Ns4x3OQMZASD3nqIlSRklHOAMaGyWaKM0pyTZAJQAWuxPvbzsBgLrqyoV35EWpnhfA17Tb3GmFkwGCQE0zlYRs4mXu3LnYvXs3Vq9ejU8++QTffPMNbrrppqCv2bhxI2bPno2f/OQn2Lx5M7Zs2YKFCxdCpaIAkT88nhffyMu+ug44mUvcSJHD5abdTUea+gwziwTu0cmllFHSEE65tNSeF61ahZIsl+9le1UrACqRlovkES+u46WquUv0u+Sl66BR07VGKcjSYaiyshKrVq3Cli1bMGnSJADAc889h4suughPPfUUSktL/b7ut7/9Le644w488MAD4mMjRgQfamixWGCxeCIP7e3tEnwCZSBOlu4VeeFm3ZElJkmqLUaXmpCh16Cjx4491e04fWB00Rweecmnu5ykgYuXqhAa1TV2SF8mPyDHiJOtrghtTpoWowdEH3Ek+jKswDMjTcnm1kFekRfPaADlirFURBaZuXHjRmRnZ4vCBQBmzpwJlUqFTZs2+X1NfX09Nm3ahMLCQkybNg1FRUWYPn06vvvuu6Dv9fjjjyMrK0v8Kysrk/SzJDL5ASIvnrEA0pzANWoVJp/CfS+NUa+vmdJGSQfv9VLd1g2L3RFwuW6rA51W1/NStmLnvhcAOGtYPtQqKpGWg7JcI66ZMggLzjkF6Qrsrsvx9rzUt1OlkRKRRbzU1taisLDQ5zGNRoPc3FzU1tb6fc3hw4cBAA8//DAWLFiAVatWYcKECTj//PNx4MCBgO+1ePFitLW1iX/Hjx+X7oMkOLmi58VXvEhVaeSNlL6XRkobJR35GTqk6dRgrO+EZ2/4vtdrVJK2lufD9gBKGcmJIAj4v8tOx+9/OiremxIVpdlG0SfFb/ZIvCiLsMTLAw88AEEQgv7t3bs3og1xOl2lszfffDNuvPFGjB8/Hs888wxGjBiBZcuWBXydXq+HyWTy+UsVeJlxS5dV9KI4nAx7a6WpNPKG+162HG2B3eGMal1NomGTIi/JgiAIIZl2G7z8LlI2kOMGTIDMukT/aNUqcajn90ddoySo0khZhHXrc8899+CGG24IusyQIUNQXFyM+vp6n8ftdjuam5tRXFzs93UlJSUAgFGjfBX9yJEjUVVVFc5mpgw5aVoIAsCYS8DkZ+hxuMGMHpsTaTo1yvPS+19JiIwsMcFk0KC9x46dJ9swflBOxOviHh1KGyUXg/PSsLe2I+iYgEaJy6Q5p5WaIAjA2IHZKM4i7wLRP2U5aTjR0i3e7FGPF2URlngpKChAQUH/dzVTp05Fa2srtm7diokTJwIAvvrqKzidTkyZMsXva8rLy1FaWop9+/b5PL5//35ceOGF4WxmyqBRq5Bt1KKly4Yms0u88LEAFcWZkub91SoBk0/JxZeV9dh6rCU68UKjAZKScrHXS+DICy+TlqpBHWdkiQnv3zINA7KN/S9MEHD5XjYebgIvoKS0kbKQxfMycuRIzJ49GwsWLMDmzZuxfv16LFy4EFdddZVYaXTy5ElUVFRg8+bNAFxh53vvvRd/+9vf8K9//QsHDx7EH/7wB+zduxfz58+XYzOTArHiyB2Ol9qs6w0XLNuPt0a1Hu7RoYnSyQWfcRQsbSR1mbQ34wfloFDB5btEbBnUa2inlAZyQn5ks4u//fbbWLhwIc4//3yoVCpcfvnl+Nvf/iY+b7PZsG/fPnR1eU50d911F3p6evDb3/4Wzc3NGDt2LFavXo2hQ4fKtZmKJy9dh4PwCAKpZhr5Y1xZNgBgh7uXRiQ4nUysNpLjAkbEj8G5/UdexO66tO+JOOPtkwIobaQ0ZBMvubm5WLFiRcDny8vLwVjfhmcPPPCAT58XIjj5XpEXxphYaSSlWZczZmAWBAE42dqN+o6eiH7s7T020VxMkZfkwrvXi9PJoPKTtvREXmjfE/FlUG/xQoZdRUHtBBWO2GW304qath60dNmgVgk4tSizn1eGT6ZBi+HuDpuRRl+45yHToIFOQ4dfMlGSZYBGJcBqd6LW3TujN6J4oRA9EWfKvMrrMw0aGLQ0Z01J0NVD4eR59XrhUZfhhRmy/RDF1FGEvpcmGT0PRHzRqFViv5VAYwKknmtEEJGSm65DunswLJl1lQeJF4XjbdgVJ0mXyNfrZlyZy7QbsXjh3XUpZZSUDHJXHFUFmC7dSJ4XIkEQBEH0vZDfRXmQeFE4eV4jArhZVw6/C4dHXn443hrRkEaaKJ3cDM4NPKCxx+ZAh8UOgCo7iMSA+17I76I8SLwonDwvzwvv8SJHmTTn1KIMpOnU6LQ6cLDeHPbraaJ0ciNOl/ZTccT9Ljq1CiaDcufiEMnDULeHz3u8BKEM6AyicHja6GRrN6x2V9t+OdNGGrUKpw/IwqYjzdhxvAUjisMzBtNogOQm2IiARq99L+VoAIKIlF+ffQpy03S4bMKAeG8KESYUeVE4XARw4TIwx4isNK2s7zluUDaAyHwvzeR5SWoG8y67fkYEyDUagCAiJS9DjwXnDiEPlgIh8aJwTAatzxgAOaMunPFu38v2CMqlxYnSdLJISnjkpb3HjtYu32nncnbXJQgitSDxonBUKsGn2ZucfhcOrzjaX9eBTrcBM1S4YTefIi9JiVGnFstOe5t2qUEdQRBSQeIlCcjzES/yR16KswwoyTLAyYAfT7SF9VoxbUR330lLINMujQYgCEIqSLwkAd5lx3KWSXsTSbM6u8OJli4aypjscN9LVS/fCzWoIwhCKki8JAF57rLjnDQtSrJi02zJI15aQn5NS5cNjAGC4NpWIjkJ1OulgUYDEAQhESRekgAeeTmtNCtmJaiRRF6aOl0Xr5w0HTRqOvSSlUEB0kbkeSEIQiroCpIEjHabdM8enh+z9zx9YBbUKgF17RbUtHWH9JpmM5VJpwKetFEv8eL2vNAcGYIgooWa1CUBP58wAJNPycWA7Nh1iUzTaTCiKBN7atqxvaoVJaf3/96NneR3SQV42qi2vQc9NgcMWjUsdgfae1yVaeR5IQgiWijykgTwAWMqVWy7lobbrI4mSqcG2WlaZLrb/1e5U0e8s7JWLSDLSH4ngiCig8QLETGi7yXEZnXNNJQxJRAEwVMu7U4dcb9LXrqeRgMQBBE1JF6IiOGddneebIPd4ex3eV4qS2mj5Gdwru+YANGsm0n7niCI6CHxQkTM0IIMZOo16LY5sK+uo9/ledqIGtQlP7ziiKeNGjuoxwtBENJB4oWIGJVKwNgw5hzRaIDUoXevlwbyOxEEISEkXoioCKffC40GSB16R15oNABBEFJC4oWIinDEizhRmiIvSQ/v9XKipQsOJ6MGdQRBSAqJFyIqeLn0oQYz2ntsAZez2B3oEPt80AUs2Sk2GaBTq2BzMFS3dovipYAa1BEEIQEkXoioyM/QY2COEYwBPx4PPGG6pdMlbDQqASYD9flIdtQqAQNzXY0Lq5q7xEqzAkobEQQhASReiKgZPygHALC9KvCQRn7nnZOui3kzPSI+eJt2G2koI0EQEkLihYiaUHwvvNKI5hqlDtz3cqjBjNYuV+SNDLsEQUgBiRciarzFC2PM7zI0GiD14F12eUROrRKQTaMBCIKQABIvRNScVmqCVi2gqdOKEy3+J0w301DGlIOLl10n2wG4om6UMiQIQgpIvBBRY9CqMbLEBADYHiB1xA2bNNcodRjkHhFgdY+OoKgbQRBSQeKFkITx/QxppLRR6lGWa4T3DEYy6xIEIRUkXghJ4P1eth/3X3HUTIbdlEOvUaPEZBD/T/19CIKQChIvhCSMK3OVS++ubofV3nfCdCN5XlISPiYAoB4vBEFIB4kXQhLK89KQnaaF1e5EZU17n+dponRqMtjtewEoZUgQhHSQeCEkQRAEjB2YDcB/vxeeNqLUQWrhE3khzwtBEBJB4oWQjPFu30tv8dJltaPL6gBAaaNUY7CXeKHIC0EQUkHihZAM3qyu95iAJneZtE6jQoZeE+vNIuKIT9ook4QrQRDSQOKFkAwuXo42daHFnSYCPKMB8tN1EARqUpZKkGGXIAg5kE28NDc3Y+7cuTCZTMjOzsb8+fNhNpuDvqa2thbXXXcdiouLkZ6ejgkTJuC9996TaxMJiclO0+GUfNed9o4TreLjzZ1k1k1Vsoxa3HPBqbjtvKG0/wmCkAzZxMvcuXOxe/durF69Gp988gm++eYb3HTTTUFfc/3112Pfvn34+OOPsXPnTvz85z/HFVdcge3bt8u1mYTEjPPTrI531yW/S2py+/nDce+sinhvBkEQSYQs4qWyshKrVq3Ca6+9hilTpuDss8/Gc889h5UrV6K6ujrg6zZs2IDbb78dkydPxpAhQ/Dggw8iOzsbW7dulWMzCRnwZ9ptotEABEEQhITIIl42btyI7OxsTJo0SXxs5syZUKlU2LRpU8DXTZs2De+88w6am5vhdDqxcuVK9PT0YMaMGQFfY7FY0N7e7vNHxA9/E6Z52oiqTQiCIAgpkEW81NbWorCw0OcxjUaD3Nxc1NbWBnzdu+++C5vNhry8POj1etx888344IMPMGzYsICvefzxx5GVlSX+lZWVSfY5iPCpKDZBp1GhrduGI42dADyRF0obEQRBEFIQlnh54IEHIAhC0L+9e/dGvDF/+MMf0Nraii+//BLff/897r77blxxxRXYuXNnwNcsXrwYbW1t4t/x48cjfn8ienQaFUaXuiZM89RRI801IgiCICQkrKYb99xzD2644YagywwZMgTFxcWor6/3edxut6O5uRnFxcV+X3fo0CE8//zz2LVrF0477TQAwNixY/Htt9/ihRdewNKlS/2+Tq/XQ6+ndEQiMa4sB9uqWrHjeCt+PmEgTZQmCIIgJCUs8VJQUICCgoJ+l5s6dSpaW1uxdetWTJw4EQDw1Vdfwel0YsqUKX5f09XVBQBQqXyDQWq1Gk5n30F/ROIyflA2sN4TeWmmoYwEQRCEhMjieRk5ciRmz56NBQsWYPPmzVi/fj0WLlyIq666CqWlpQCAkydPoqKiAps3bwYAVFRUYNiwYbj55puxefNmHDp0CE8//TRWr16NSy+9VI7NJGSCm3b3VLejx+agaiOCIAhCUmTr8/L222+joqIC559/Pi666CKcffbZeOWVV8TnbTYb9u3bJ0ZctFotPvvsMxQUFODiiy/GmDFj8Oabb+Lvf/87LrroIrk2k5CBgTlG5GfoYHcy/PdwE6wOV+QsL53SRgRBEET0yDZoJjc3FytWrAj4fHl5uVhKyxk+fDh11E0CBEHAuLJsfFlZjzWVLu9Tuk4No04d5y0jCIIgkgGabUTIAk8dramsAwDkUsqIIAiCkAgSL4QsjB+UAwCobusBQCkjgiAIQjpIvBCyMGZgFrwHSOdT5IUgCIKQCBIvhCxkGrQYVpAh/p/KpAmCIAipIPFCyAb3vQBAHjWoIwiCICSCxAshG+PcE6YBGg1AEARBSAeJF0I2xpfliP+m0QAEQRCEVJB4IWTj1KIMGLWu3i7keSEIgiCkgsQLIRsatQrXTxuMEUWZGOvlfyEIgiCIaBBY7za3Cqe9vR1ZWVloa2uDyWSK9+YQBEEQBBEC4Vy/KfJCEARBEISiIPFCEARBEISiIPFCEARBEISiIPFCEARBEISiIPFCEARBEISiIPFCEARBEISiIPFCEARBEISiIPFCEARBEISiIPFCEARBEISiIPFCEARBEISiIPFCEARBEISiIPFCEARBEISiIPFCEARBEISiIPFCEARBEISi0MR7A6SGMQbANVqbIAiCIAhlwK/b/DoejKQTLx0dHQCAsrKyOG8JQRAEQRDh0tHRgaysrKDLCCwUiaMgnE4nqqurkZmZCUEQJF13e3s7ysrKcPz4cZhMJknXrQRS/fMD9B2k+ucH6Dugz5/anx+Q7ztgjKGjowOlpaVQqYK7WpIu8qJSqTBw4EBZ38NkMqXsQQvQ5wfoO0j1zw/Qd0CfP7U/PyDPd9BfxIVDhl2CIAiCIBQFiReCIAiCIBQFiZcw0Ov1WLJkCfR6fbw3JS6k+ucH6DtI9c8P0HdAnz+1Pz+QGN9B0hl2CYIgCIJIbijyQhAEQRCEoiDxQhAEQRCEoiDxQhAEQRCEoiDxQhAEQRCEokgp8fL444/jjDPOQGZmJgoLC3HppZdi3759Psv09PTgtttuQ15eHjIyMnD55Zejrq5OfP6HH37A1VdfjbKyMhiNRowcORLPPvuszzrWrVsHQRD6/NXW1sbkcwZDiu+gqakJs2fPRmlpKfR6PcrKyrBw4cI+86TWrVuHCRMmQK/XY9iwYVi+fHksPmJQYvX5k/0Y8KapqQkDBw6EIAhobW31eS5ZjwFvAn3+RD0GpPr8/j7bypUrfZZJxP0PxO47SPZjAACWL1+OMWPGwGAwoLCwELfddpvP8z/++CPOOeccGAwGlJWV4YknnpDmQ7AUYtasWeyNN95gu3btYjt27GAXXXQRGzRoEDObzeIyv/nNb1hZWRlbs2YN+/7779mZZ57Jpk2bJj7/+uuvszvuuIOtW7eOHTp0iL311lvMaDSy5557Tlxm7dq1DADbt28fq6mpEf8cDkdMP68/pPgOmpub2Ysvvsi2bNnCjh49yr788ks2YsQIdvXVV4vLHD58mKWlpbG7776b7dmzhz333HNMrVazVatWxfTz9iZWnz/ZjwFv5syZwy688EIGgLW0tIiPJ/Mx4E2gz5+ox4BUnx8Ae+ONN3w+W3d3t/h8ou5/xmL3HST7MfD000+z0tJS9vbbb7ODBw+yH374gX300Ufi821tbayoqIjNnTuX7dq1i/3jH/9gRqORvfzyy1F/hpQSL72pr69nANjXX3/NGGOstbWVabVa9s9//lNcprKykgFgGzduDLieW2+9lZ133nni//kB630iS1Sk+g6effZZNnDgQPH/9913HzvttNN8lrnyyivZrFmzJP4E0SHX50+VY+DFF19k06dPZ2vWrOnzeVPhGAj2+ZVyDET6+QGwDz74IOB6lbL/GZPvO0jmY6C5uZkZjUb25ZdfBlzviy++yHJycpjFYhEfu//++9mIESOi3uaUShv1pq2tDQCQm5sLANi6dStsNhtmzpwpLlNRUYFBgwZh48aNQdfD1+HNuHHjUFJSggsuuADr16+XeOulQYrvoLq6Gu+//z6mT58uPrZx40afdQDArFmzgn6P8UCuz89J5mNgz549eOSRR/Dmm2/6HaKW7MdAf5+fk+jHQDS/gdtuuw35+fmYPHkyli1bBubVNkwp+x+Q7zvgJOMxsHr1ajidTpw8eRIjR47EwIEDccUVV+D48ePiazZu3Ihzzz0XOp1OfGzWrFnYt28fWlpaotrmlBUvTqcTd911F8466yyMHj0aAFBbWwudTofs7GyfZYuKigLmKDds2IB33nkHN910k/hYSUkJli5divfeew/vvfceysrKMGPGDGzbtk22zxMJ0X4HV199NdLS0jBgwACYTCa89tpr4nO1tbUoKirqs4729nZ0d3fL84HCRM7Pn+zHgMViwdVXX40nn3wSgwYN8rvuZD4GQvn8SjgGovkNPPLII3j33XexevVqXH755bj11lvx3HPPic8rYf8D8n4HyXwMHD58GE6nE//3f/+Hv/71r/jXv/6F5uZmXHDBBbBareJ6/B0D/LloSLqp0qFy2223YdeuXfjuu+8iXseuXbswZ84cLFmyBD/5yU/Ex0eMGIERI0aI/582bRoOHTqEZ555Bm+99VZU2y0l0X4HzzzzDJYsWYL9+/dj8eLFuPvuu/Hiiy9KvJXyIefnT/ZjYPHixRg5ciSuvfZambYsNsj5+ZVwDETzG/jDH/4g/nv8+PHo7OzEk08+iTvuuEPKTZQdOb+DZD4GnE4nbDYb/va3v4nXv3/84x8oLi7G2rVrMWvWLDk2VyQlIy8LFy7EJ598grVr12LgwIHi48XFxbBarX0qJurq6lBcXOzz2J49e3D++efjpptuwoMPPtjve06ePBkHDx6UZPulQIrvoLi4GBUVFbjkkkvw8ssv46WXXkJNTY34XG9nel1dHUwmE4xGozwfKgzk/vz+SKZj4KuvvsI///lPaDQaaDQanH/++QCA/Px8LFmyRFxPsh4DoXx+fyTSMSDFb8CbKVOm4MSJE7BYLOJ6Enn/A/J/B/5IlmOgpKQEADBq1Cjx+YKCAuTn56Oqqkpcj79jgD8XFVG7ZhSE0+lkt912GystLWX79+/v8zw3Kf3rX/8SH9u7d28fk9auXbtYYWEhu/fee0N+75kzZ7LLLrssug8gAVJ9B735+uuvGQB25MgRxpjLrDd69GifZa6++uq4m/Vi9fn9kUzHwMGDB9nOnTvFv2XLljEAbMOGDayuro4xltzHQCif3x+JcAzI9Rv43//9X5aTkyP+P1H3P2Ox+w78kSzHwL59+xgAH8NuU1MTU6lU7PPPP2eMeQy7VqtVXGbx4sWSGHZTSrzccsstLCsri61bt86nbK2rq0tc5je/+Q0bNGgQ++qrr9j333/Ppk6dyqZOnSo+v3PnTlZQUMCuvfZan3XU19eLyzzzzDPsww8/ZAcOHGA7d+5kd955J1OpVEFd2bFCiu/g008/ZcuWLWM7d+5kR44cYZ988gkbOXIkO+uss8RleJnkvffeyyorK9kLL7yQEGWSsfr8yX4M9MZfVUUyHwO98ff5E/UYkOLzf/zxx+zVV19lO3fuZAcOHGAvvvgiS0tLYw899JC4TKLuf8Zi9x0k8zHAmKtNwGmnncbWr1/Pdu7cyX72s5+xUaNGiWKltbWVFRUVseuuu47t2rWLrVy5kqWlpVGpdLgA8Pv3xhtviMt0d3ezW2+9leXk5LC0tDR22WWXsZqaGvH5JUuW+F3H4MGDxWX+/Oc/s6FDhzKDwcByc3PZjBkz2FdffRXDTxoYKb6Dr776ik2dOpVlZWUxg8HAhg8fzu6///4+5YBr165l48aNYzqdjg0ZMsTnPeJFrD5/sh8DvQlUEpqsx0Bv/H3+RD0GpPj8//nPf9i4ceNYRkYGS09PZ2PHjmVLly7t078kEfc/Y7H7DpL5GGDM1cflV7/6FcvOzma5ubnssssuY1VVVT7L/PDDD+zss89mer2eDRgwgP3pT3+S5DMI7g9CEARBEAShCFLSsEsQBEEQhHIh8UIQBEEQhKIg8UIQBEEQhKIg8UIQBEEQhKIg8UIQBEEQhKIg8UIQBEEQhKIg8UIQBEEQhKIg8UIQBEEQhKIg8UIQcWT58uV9xs4riYcffhjjxo2L92YQAI4ePQpBELBjx454b4qiWLduHQRB6DOEkEhsSLwQPtxwww0QBAGCIECn02HYsGF45JFHYLfb471p/SIIAj788MN4b4YPa9euxUUXXYS8vDykpaVh1KhRuOeee3Dy5Ml4b5okLFq0CGvWrJFkXd3d3cjNzUV+fr7fqbzl5eUQBAH//e9/fR6/6667MGPGDJ/H2tvb8fvf/x4VFRUwGAwoLi7GzJkz8f7774OaikfHDTfcgEsvvTTemxERM2bMwF133RXvzSAkgMQL0YfZs2ejpqYGBw4cwD333IOHH34YTz75ZETrcjgccDqdEm+hMnj55Zcxc+ZMFBcX47333sOePXuwdOlStLW14emnn4735klCRkYG8vLyJFnXe++9h9NOOw0VFRUBRajBYMD9998fdD2tra2YNm0a3nzzTSxevBjbtm3DN998gyuvvBL33Xcf2traJNleggiGzWaL9yYkN5JMSCKShnnz5rE5c+b4PHbBBRewM888kzHGWE9PD7vnnntYaWkpS0tLY5MnT2Zr164Vl33jjTdYVlYW++ijj9jIkSOZWq1mR44cYT09Pey+++5jAwcOZDqdjg0dOpS99tpr4ut27tzJZs+ezdLT01lhYSG79tprWUNDg/j89OnT2e23387uvfdelpOTw4qKitiSJUvE5wcPHux3UObBgwfZJZdcwgoLC1l6ejqbNGkSW716tc/nq66uZhdddBEzGAysvLycvf3222zw4MHsmWeeEZdpaWlh8+fPZ/n5+SwzM5Odd955bMeOHQG/x+PHjzOdTsfuuusuv8/zAX78+1q1ahWrqKhg6enpbNasWay6ulpcdvPmzWzmzJksLy+PmUwmdu6557KtW7f6rA8Ae/XVV9mll17KjEYjGzZsGPvoo498lvnoo4/YsGHDmF6vZzNmzGDLly/vM0zw22+/ZWeffTYzGAxs4MCB7Pbbb2dmszng51yyZAkbO3as+H9+/Dz55JOsuLiY5ebmsltvvVWcMhuMGTNmsKVLl7KXXnqJXXDBBX2eHzx4MLvjjjuYTqdjn376qfj4nXfeyaZPny7+/5ZbbmHp6ens5MmTfdbR0dHBbDZbwG34+OOP2aRJk5her2d5eXns0ksvFZ9788032cSJE1lGRgYrKipiV199NaurqxOfb25uZtdccw3Lz89nBoOBDRs2jC1btkx8vqqqiv3yl79kWVlZLCcnh11yySXsyJEj4vNr165lZ5xxBktLS2NZWVls2rRp7OjRowG3ddOmTWzcuHFMr9eziRMnsvfff58BYNu3b2eMeY4tbz744APW+7T/4YcfsvHjxzO9Xs9OOeUU9vDDDwf8jvwNpuW//x9//JGdd9554hDCBQsWsI6OjoDbP3HiRPbkk0+K/58zZw7TaDTia44fP84AsAMHDjDG+j/3NDY2squuuoqVlpYyo9HIRo8ezVasWCE+P2/evD7bfuTIEXGo5pdffskmTpzIjEYjmzp1Ktu7d29Y3xMA9uKLL7KLL76YpaWl+ZyfCOkh8UL44E+8XHLJJWzChAmMMcZ+/etfs2nTprFvvvmGHTx4kD355JNMr9ez/fv3M8ZcJ0ytVsumTZvG1q9fz/bu3cs6OzvZFVdcwcrKytj777/PDh06xL788ku2cuVKxpjrQl5QUMAWL17MKisr2bZt29gFF1zAzjvvPHEbpk+fzkwmE3v44YfZ/v372d///ncmCAL74osvGGOM1dfXi1NRa2pqWH19PWOMsR07drClS5eynTt3sv3797MHH3yQGQwGduzYMXHdM2fOZOPGjWP//e9/2datW9n06dOZ0Wj0ES8zZ85kF198MduyZQvbv38/u+eee1heXh5ramry+z3+5S9/YQB8RIg/+Pc1c+ZMtmXLFrZ161Y2cuRIds0114jLrFmzhr311lussrKS7dmzh82fP58VFRWx9vZ2cRkAbODAgWzFihXswIED7I477mAZGRni9h0+fJhptVq2aNEitnfvXvaPf/yDDRgwwEe8HDx4kKWnp7NnnnmG7d+/n61fv56NHz+e3XDDDQG33594MZlM7De/+Q2rrKxk//73v1laWhp75ZVXgn4PBw8eZHq9njU3N7OmpiZmMBj6XLi5oLzjjjvYmDFjxOm93uLF4XCwnJwcdtNNNwV9P3988sknTK1Ws4ceeojt2bOH7dixg/3f//2f+Pzrr7/OPvvsM3bo0CG2ceNGNnXqVHbhhReKz992221s3LhxbMuWLezIkSNs9erV7OOPP2aMMWa1WtnIkSPZr371K/bjjz+yPXv2sGuuuYaNGDGCWSwWZrPZWFZWFlu0aBE7ePAg27NnD1u+fLnPcepNR0cHKygoYNdccw3btWsX+/e//82GDBkStnj55ptvmMlkYsuXL2eHDh1iX3zxBSsvL2cPP/xwwPe94oor2OzZs1lNTQ2rqalhFouFmc1mVlJSwn7+85+znTt3sjVr1rBTTjmFzZs3L+D3fffdd7Of/vSnjDHGnE4ny83NZfn5+ew///kPY4yx//f//h8bMGCAuHx/554TJ06wJ598km3fvp0dOnSI/e1vf2NqtZpt2rSJMcZYa2srmzp1KluwYIG47Xa7XRQvU6ZMYevWrWO7d+9m55xzDps2bVpY3xMAVlhYyJYtW8YOHToUcN8R0kDihfDBW7w4nU62evVqptfr2aJFi9ixY8eYWq3uc0d7/vnns8WLFzPGXCdMAD5RiX379jEAfSIenEcffZT95Cc/8XmM33Xt27ePMeYSL2effbbPMmeccQa7//77xf8DYB988EG/n/G0005jzz33HGOMscrKSgaAbdmyRXz+wIEDDIAoXr799ltmMplYT0+Pz3qGDh3KXn75Zb/vccsttzCTydTvtvDv6+DBg+JjL7zwAisqKgr4GofDwTIzM9m///1v8TEA7MEHHxT/bzabGQDxQnD//fez0aNH+6zn97//vY94mT9/fp+L/rfffstUKhXr7u72uy3+xMvgwYOZ3W4XH/vlL3/JrrzyyoCfhzHGfve73/lEOebMmdPnzpWLl/r6epaZmcnefPNNxpiveKmrq2MA2F/+8peg7+ePqVOnsrlz54a8/JYtWxgAMVJw8cUXsxtvvNHvsm+99RYbMWIEczqd4mMWi4UZjUb2+eefs6amJgaArVu3LqT3fvnll1leXp7PfnnppZfCFi/nn3++j0Dj21pSUhLwvf3d4LzyyissJyfHJ0r36aefMpVKxWpra/2u5+OPP2ZZWVnMbrezHTt2sOLiYnbnnXeKv+lf//rXoogP5dzjj5/+9KfsnnvuEf8/ffp0duedd/os4x158d52AOL3G8r3BCBgpJWQHvK8EH345JNPkJGRAYPBgAsvvBBXXnklHn74YezcuRMOhwOnnnoqMjIyxL+vv/4ahw4dEl+v0+kwZswY8f87duyAWq3G9OnT/b7fDz/8gLVr1/qss6KiAgB81uu9TgAoKSlBfX190M9iNpuxaNEijBw5EtnZ2cjIyEBlZSWqqqoAAPv27YNGo8GECRPE1wwbNgw5OTk+22c2m5GXl+ezjUeOHPHZPm8YYxAEIei2cdLS0jB06NCAn6uurg4LFizA8OHDkZWVBZPJBLPZLH4Gjvf3k56eDpPJJK5n3759OOOMM3yWnzx5ss//f/jhByxfvtznM86aNQtOpxNHjhwJ6bMAwGmnnQa1Wh3w8/TG4XDg73//O6699lrxsWuvvRbLly/365cqKCjAokWL8NBDD8Fqtfo8x6Iw4+7YsQPnn39+wOe3bt2Kiy++GIMGDUJmZqZ4PPP9cMstt2DlypUYN24c7rvvPmzYsEF87Q8//ICDBw8iMzNT/G5zc3PR09ODQ4cOITc3FzfccANmzZqFiy++GM8++yxqamoCbktlZSXGjBkDg8EgPjZ16tSwP/MPP/yARx55xGefL1iwADU1Nejq6gp5PZWVlRg7dizS09PFx8466yw4nU7s27fP72vOOeccdHR0YPv27fj6668xffp0zJgxA+vWrQMAfP3116IRO5Rzj8PhwKOPPorTTz8dubm5yMjIwOeff97ndxII799PSUkJAIjHbajf06RJk0L7woio0cR7A4jE47zzzsNLL70EnU6H0tJSaDSuw8RsNkOtVmPr1q0+FyfAZdzkGI1Gnwu30WgM+n5msxkXX3wx/vznP/d5jp9EAECr1fo8JwhCv2bgRYsWYfXq1XjqqacwbNgwGI1G/OIXv+hz0etv+0pKSsSTqjeBypxPPfVUtLW1oaamxucz+MPf5/K+CM+bNw9NTU149tlnMXjwYOj1ekydOrXPZ4jk+/HGbDbj5ptvxh133NHnuUGDBoW8nnC34/PPP8fJkydx5ZVX+jzucDiwZs0aXHDBBX1ec/fdd+PFF1/Eiy++6PN4QUEBsrOzsXfv3pC3lxPsOO3s7MSsWbMwa9YsvP322ygoKEBVVRVmzZol7ocLL7wQx44dw2effYbVq1fj/PPPx2233YannnoKZrMZEydOxNtvv91n3QUFBQCAN954A3fccQdWrVqFd955Bw8++CBWr16NM888M+zPAgAqlaqPmOttIjWbzfjjH/+In//8531e7y2M5CA7Oxtjx47FunXrsHHjRlxwwQU499xzceWVV2L//v04cOCAKBBDOfc8+eSTePbZZ/HXv/4Vp59+OtLT03HXXXeF/Fv3Pm75+Ysft6F+T97ijZAXEi9EH9LT0zFs2LA+j48fPx4OhwP19fU455xzQl7f6aefDqfTia+//hozZ87s8/yECRPw3nvvoby8XBRKkaDVauFwOHweW79+PW644QZcdtllAFwnoaNHj4rPjxgxAna7Hdu3b8fEiRMBAAcPHkRLS4vP9tXW1kKj0aC8vDykbfnFL36BBx54AE888QSeeeaZPs+3traG3N9l/fr1ePHFF3HRRRcBAI4fP47GxsaQXssZMWIEPvvsM5/HtmzZ4vP/CRMmYM+ePX73vZy8/vrruOqqq/D73//e5/HHHnsMr7/+ul/xkpGRgT/84Q94+OGHcckll4iPq1QqXHXVVXjrrbewZMkSlJaW+rzObDbDYDD4Pc7GjBmDNWvW4MYbb+zz3N69e9HU1IQ//elPKCsrAwB8//33fZYrKCjAvHnzMG/ePJxzzjm499578dRTT2HChAl45513UFhYCJPJFPC7GD9+PMaPH4/Fixdj6tSpWLFihV/xMnLkSLz11lvo6ekRL569S8gLCgrQ0dGBzs5O8aLauwfMhAkTsG/fvrD2uU6n6/M7GzlyJJYvX+7zXuvXr4dKpcKIESMCrmv69OlYu3YtNm/ejMceewy5ubkYOXIkHnvsMZSUlODUU08Vv5f+zj3r16/HnDlzxAie0+nE/v37MWrUqKDbHgqRfE+EvFDaiAiZU089FXPnzsX111+P999/H0eOHMHmzZvx+OOP49NPPw34uvLycsybNw+/+tWv8OGHH+LIkSNYt24d3n33XQDAbbfdhubmZlx99dXYsmULDh06hM8//xw33nhjWCea8vJyrFmzBrW1taL4GD58ON5//33s2LEDP/zwA6655hqfKEBFRQVmzpyJm266CZs3b8b27dtx0003+USPZs6cialTp+LSSy/FF198gaNHj2LDhg34/e9/7/cCBgBlZWV45pln8Oyzz2L+/Pn4+uuvcezYMaxfvx4333wzHn300ZA/1/Dhw/HWW2+hsrISmzZtwty5c/uNZvXm5ptvxt69e3H//fdj//79ePfdd7F8+XIAnrvM+++/Hxs2bMDChQuxY8cOHDhwAB999BEWLlwY1nuFQ0NDA/79739j3rx5GD16tM/f9ddfjw8//BDNzc1+X3vTTTchKysLK1as8Hn8scceQ1lZGaZMmYI333wTe/bswYEDB7Bs2TKMHz8eZrPZ7/qWLFmCf/zjH1iyZAkqKyuxc+dOMRo4aNAg6HQ6PPfcczh8+DA+/vjjPvvwoYcewkcffYSDBw9i9+7d+OSTTzBy5EgAwNy5c5Gfn485c+bg22+/FX8Dd9xxB06cOIEjR45g8eLF2LhxI44dO4YvvvgCBw4cEF/fm2uuuQaCIGDBggXYs2cPPvvsMzz11FM+y0yZMgVpaWn43e9+h0OHDmHFihXiPvfe5jfffBN//OMfsXv3blRWVmLlypV48MEH/e8wuH5nP/74I/bt24fGxkbYbDbMnTsXBoMB8+bNw65du7B27VrcfvvtuO6661BUVBRwXTNmzMDnn38OjUYjpopnzJiBt99+2yfNHMq5Z/jw4Vi9ejU2bNiAyspK3Hzzzairq+uz7Zs2bcLRo0fR2NgYcmQyku+JkJn4Wm6IRMOfGc8bq9XKHnroIVZeXs60Wi0rKSlhl112Gfvxxx8ZY/5Ngowx1t3dzX7729+ykpISptPp+pSR7t+/n1122WUsOzubGY1GVlFRwe666y7R4OjPaDdnzhyfaoaPP/6YDRs2jGk0GrFU+siRI+y8885jRqORlZWVseeff77Puqqrq9mFF17I9Ho9Gzx4MFuxYgUrLCxkS5cuFZdpb29nt99+OystLWVarZaVlZWxuXPnsqqqqqDf5+rVq9msWbNYTk4OMxgMrKKigi1atEisQgrFVLlt2zY2adIkZjAY2PDhw9k///nPPqXc8GNWzsrKYm+88Yb4/96l0tzg6W363Lx5M7vgggtYRkYGS09PZ2PGjGGPPfZYwM8XqFTam96lzN489dRTLDs7228ptcViYdnZ2ezZZ59ljLE+n5kxxlasWMEA9Fl/a2sre+CBB9jw4cOZTqdjRUVFbObMmeyDDz7wMc325r333mPjxo1jOp2O5efns5///Oc+71VeXs70ej2bOnUq+/jjj30Mso8++igbOXIkMxqNLDc3l82ZM4cdPnxYfH1NTQ27/vrrWX5+PtPr9WzIkCFswYIFrK2tjdXW1rJLL71U/H0MHjyYPfTQQ2JFlT82btzIxo4dy3Q6HRs3bhx77733fLaHMdexNGzYMGY0GtnPfvYz9sorr/QplV61ahWbNm0aMxqNzGQyscmTJwetDquvrxePEURRKs0YY01NTUwQBB9DNz/+vX9/jPV/7mlqamJz5sxhGRkZrLCwkD344IPs+uuv9zke9+3bx84880xmNBr7lEp7twzYvn27+Hyo35O/3yAhHwJj1G6SILw5ceIEysrK8OWXXwY1cCqdxx57DEuXLsXx48fjvSkEQRBhQZ4XIuX56quvYDabcfrpp6Ompgb33XcfysvLce6558Z70yTlxRdfxBlnnIG8vDysX78eTz75pKwpIYIgCLkg8UKkPDabDb/73e9w+PBhZGZmYtq0aXj77bf7VM0onQMHDuB///d/0dzcjEGDBuGee+7B4sWL471ZBEEQYUNpI4IgCIIgFAVVGxEEQRAEoShIvBAEQRAEoShIvBAEQRAEoShIvBAEQRAEoShIvBAEQRAEoShIvBAEQRAEoShIvBAEQRAEoShIvBAEQRAEoSj+PxzDA2kIMqlaAAAAAElFTkSuQmCC" }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 63 + "execution_count": 10 }, { "metadata": {}, @@ -4763,8 +5048,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-07T15:20:47.197611Z", - "start_time": "2025-01-07T15:20:47.194723Z" + "end_time": "2025-01-09T11:44:50.898667Z", + "start_time": "2025-01-09T11:44:50.896052Z" } }, "cell_type": "code", @@ -4779,11 +5064,11 @@ "name": "stdout", "output_type": "stream", "text": [ - "Sum of values < 0: -94013.6540869424\n" + "Sum of values < 0: -93565.2828118447\n" ] } ], - "execution_count": 64 + "execution_count": 11 }, { "metadata": {}, @@ -4794,8 +5079,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-07T15:20:06.514950Z", - "start_time": "2025-01-07T15:20:06.202317Z" + "end_time": "2025-01-09T11:44:53.427516Z", + "start_time": "2025-01-09T11:44:53.229300Z" } }, "cell_type": "code", @@ -4822,31 +5107,31 @@ "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_53316/4003818095.py:7: SettingWithCopyWarning: \n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/4003818095.py:7: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_53316/4003818095.py:7: SettingWithCopyWarning: \n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/4003818095.py:7: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_53316/4003818095.py:7: SettingWithCopyWarning: \n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/4003818095.py:7: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_53316/4003818095.py:7: SettingWithCopyWarning: \n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/4003818095.py:7: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_53316/4003818095.py:7: SettingWithCopyWarning: \n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/4003818095.py:7: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", @@ -4859,26 +5144,719 @@ "text/plain": [ "
" ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1kAAAISCAYAAAA+6QUoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/OQEPoAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydd5gkVb3+P1XVuadnenLYHNjELsuSFhDEjBJUUEHMOSJcMeL1d81ijojpKphQkQwKBhCVIDktm/Pu7Mzs5JnO3VX1++PUqe6Z6VDd073B2+/z7LO701U11d1Vp8573vf7fhXTNE3qqKOOOuqoo4466qijjjrqqArUw30CddRRRx111FFHHXXUUUcd/0mok6w66qijjjrqqKOOOuqoo44qok6y6qijjjrqqKOOOuqoo446qog6yaqjjjrqqKOOOuqoo4466qgi6iSrjjrqqKOOOuqoo4466qijiqiTrDrqqKOOOuqoo4466qijjiqiTrLqqKOOOuqoo4466qijjjqqiDrJqqOOOuqoo4466qijjjrqqCLqJKuOOuqoo4466qijjjrqqKOKqJOsOuqoo4466qijjjrqqKOOKuKoI1k/+MEPWLhwIT6fj/Xr1/PII48U3f4Pf/gDK1aswOfzsWbNGv70pz8dojOto4466qijjjrqqKOOOv4v4qgiWb///e+54oor+MxnPsMTTzzB2rVrOfvsszl48GDe7R988EEuueQS3vnOd/Lkk0/y6le/mle/+tVs2LDhEJ95HXXUUUcdddRRRx111PF/BYppmubhPgmnWL9+PSeffDJXX301AIZhMG/ePD70oQ/xyU9+csb2F198MdFolDvvvNP+2amnnsrxxx/Pj370o0N23nXUUUcdddRRRx111FHH/x24DvcJOEUqleLxxx/nyiuvtH+mqioveclLeOihh/Lu89BDD3HFFVdM+dnZZ5/NrbfeWvD3JJNJksmk/X/DMBgZGaG1tRVFUWb3Juqoo4466qijjjrqqKOOoxamaTI5OUlPTw+qWtgUeNSQrKGhIXRdp7Ozc8rPOzs72bx5c959+vv7827f399f8PdcddVVfO5zn5v9CddRRx111FFHHXXUUUcd/5HYt28fc+fOLfj6UUOyDhWuvPLKKerX+Pg48+fPZ8uWLYRCoRnba5qGz+ez/x+NRgseW1VV/H5/RdvGYjFM0+TmrTfz/ae+z5lzzuTzz/s8r/vhg+weiXHtO89gyb03M/yjH+M+/3w2zzmPnU8Nccp5izj2+XPs4yiKQiAQYOuj/dz3my1sJ86Fj16FNzbJgl9ch3fJkinnEQwG7X/H43EMwyh4zrnbJhIJdF2vyraBQMBWEZPJJJlMpirb+v1+ewUilUqRTqersq3P50PTtLK3TafTpFKpgtt6vV5cLlfBbU3T5DO3PcddG/rpCjdw4wfPoIUJMr++mOTAFgi0weuu45t77uDOnXeypGkJP3rpjwj4ArjdbgAymcwUJReA378Z9j3M5zJv44/m6fz1oy+iJ+xH13USiUTB83W73Xg8HgB0XefKe6/kvv33cenxl/KaZa8puK1hGMTjcUfHzbftZ/92A/8Y+aH4jwoNmRZOavoqX33NccRisYLHdblceL1e+7Mstm05972jbf/4Udh0O5xxBaf9azWGCX//yFkEtML3RaExQuJ7927lVw/u5Q3r53HFy1ZgPvcc+9/3flxz5tD9u99SyCmuKArmzy9n/7VP4ulpouuGOx3f97MZI/62cYArb36W4+c38dO3nFz2GBHPxHn/397PpoObOC5wAQ8+sYpz13Tz2VcdO2PbUmPEHTvu4FuPf4vnL3g+33jRN4DajBHXb7qe7zz6HV7Y80L+57T/ybvtUyNP8ZF/fYR2fzs3nXtT0ePKMWLDP/dz/x+2MOfYJl705pVFt+XAk2SuPY+krxsu/iX84jzIJNlyzNU8+ECAlqVevtv6CVqCLdz1mrt4bOcgb/npg8xt8XPLB5439aC/fCWe4c24X/9LWPpidF1n9OGH2ffBS9EaG1l8x+0o1ngHU+/lkf5Jrv/Cg6S0JF3viPCqY1415dD57vvrHtzFD+7dAcCxcxq57u2nFNwWYMfYDt71l3cRdAW544I7UBRlxn2/f+cgt33rSXxBFyfe8wkwDBbdcjPu9vap2w5sJPajl4IvDJdODeD6084/8fXHv87p80/nOy/6DgAPbdnPO697nM5GL3deduaU7csZTz5+z5WsvVeMn+/4+hkkUwlu++6TjPRGedk7VjFnRYu9be4YccXfr+D+3fezvms9X3n+V2YcV84NJKaPJ8W2LXTff/Oxb3Lnzjt55wnv5L1r31t0W4lK5xH7R/ZzyR2XkDSSfOmML3F6z+lTtnVy33/yn5/k4f6HObXzIu59eA0vXdXBV169quA8IpqKcv4fz0dRFe5o+AT9n/0iT7Uu5KqT3sIfLz+TjpB3yvalxoiNDxzg4dt2srB1H6/wfoZ/n/AaPjL6CEuCS/jJS34CwL+2HuSKG55hRXcDv3rnqUB2PEkndX720fvIGBne+IVT8XhnTvGnzyPiw8PseMU5AAxd9zn++4kvsLJlJde85JoZ267/wp9JpHVuev/pzG8NTDmux+MpOo+IPvIIvVd8BGXOHN54/PvweD288kUPcPeuu3jPivfw+pWvh+duhrs+CXNOhEt+C8ycRzidc8x2HpGLfHODyclJli9fnpcXTNm36KtHENra2tA0jYGBgSk/HxgYoKurK+8+XV1dZW0P4gKUH+b0YzU2NpY8TyfbzGbbVelVuHe7mfRN0tXVxaARwNXgY/n8TnymSVLTaOnoYL+vhaagSc/cHrq7u2ccr6Ulid8TpEXz0RRooDGdoDMUwp9n20P13uqYHX77yF7+uieFt6mVH777VBaGUvCL10NsG/TMgbfewXOk+MuTf8EddvOFl3+BeZ3zSh94wTEw9ignekzunmhkNO1iRQXfWXdPN+6IG1fYlfeazEU4HHZ83OnbZoLgNty0ZzIMulwo6TSThpumpiaampocH7ecbWd9vWf2QkglungdPOxGBeZ1teFxOc8mmn7c+XNiuEIRMr4wXV1dDN91Nw2aRmjNmqJjIECsvYsxTcOdMWa4Aco5h7K23ZPCFWphTk/njOuj2HHTRpqbtt7ED5/+ISOJEULNId6w5u08sm0bu+OektdaPixNL8W9w03EHanp+BTTYrhDbhbNW1TwPFs6Wgg+GWREH2FYHWZ59/KSxzUTboL+JhYsmlf6/Q+kwa9CVwesOhXO+Tj8/UtE+++iKfgeAh4NV8hFc2MzjY2NGJ44rlALnZ1NeY49BAEV5iwD63NLP7eRDrebxhe/mJ4iK75G3EVTsJWkFqPftd3RGPHCdR5+/OgoAKetXlhwHzlGPBF/AnfYzar2VfT09OTdVlvopSm4F1VV6GxuxpyYoLMhhHf6sd3LaQqpwAS0hcGdXfA4Rj8G93Y3ES17/Zx67DG4QrsYNqGhuY2Qz13wvRW75uJaAr8niKJCc0sYRVHo6uxDHxujsaGV7u789/Z/v+C/ufC2C3ki8QTb9G08f+7zC/6OUufgdNsxzxjusJvlPcvtbWo1N1jVuIq3nf42fr7h51zfez0XnHABquJ8/JxITfBM6hncYTfdweejepPM62yjvb296H7Nzc1MpibRI8O0uFwEmjtxhVrAH6a7O+z49wPsccVoCrYyV3uMZr9KdPHxaBsfZ1539j5O7k7iCrWweP7McRKgKdxCJqnTFGgl3BGY8foMtLYSbW3FmJgg5AriDrtJBVN5j71w/hy2H4yQ9jbR3d1W1nsbHhoi7XaTPOZYtEAjC9uDxFxRXEEXi+cvFr/P83K4/1MQ3QjtreDylPU7pmM284hiaGpqsgl+qTKioyZd0OPxcOKJJ3LPPffYPzMMg3vuuYfTTjst7z6nnXbalO0B/vrXvxbc/mhAV1AMoH3RPoYiKZIZA1WBriYfhrXyrgYCpOJi5cXjy8+j3T6xmugxFZLWhWzEC68Q1HFkY+OBCT5z+3MAfPRlyzm5OQ7XngNDW6FxLrztjxitS/jyw1/GxOS8xedxQucJzg7eJCZGiz1iMrNvpLDCUwwhj1jxmUxNVrS/U0ymxwFYYq0SprQkg5PJYrscXhi6+J6A4cBiAEJeV1kEKx+aA2ISNx4Tn0Ni00YAvCtXlNxXbWwFwEwVVk2qjZGIUGZbgs4erKZp8pfdf+GC2y7gSw9/iZHECPND8/nui77L+oVi8WD7YIREuvBKeCG0+sX7H44Pl71vORiKDwHQ5i88YfFqXk7pFgrNv3r/5ei4kyNiLA+1+EpsCcSs9xgQ75nnXQ6tS/EkDwCQjovPL+QW9+9YXFwT4cC07ykVg/iI+HdTlkxF/vEPABrOOqvoaRiGUE1MxWTTyKbS5w0cN7cJTRWTnHXzwyW33za6DYBjmo8puI3Xum8Mw8QMiWMakTxjli8MbmsSO3FgykutvpnXT1PAbSsb2w5GSp5rPhimwfDEGAAur2pP8HzWOSejhZ0bi5oW8caVbwTg649+nbRe+3t77+ReAOaH5tf8dwG8Y/U7aHA3sHV0K3/e/eey9v373r+TMTIsDS8lGRP3Y2dj6ftHzskmB3sBMBrF4lz/RPnzqdiEGAMDyhC0LuWgS3yvHYEOe5veMXHcnrB/5gGAQEjsE590/v265wq3U8OQeLZPpCbybjevWfzOa+7bzki0sOsmHxIbxT093L0QgAWtQUYSYrxo8Vnqa8tiMQ7pSeh/pqzjH6k4akgWwBVXXMFPf/pTfvGLX7Bp0ybe//73E41Gefvb3w7AW97ylinBGJdffjl333033/zmN9m8eTOf/exneeyxx7j00ksP11uYNeQNPZIYYdfwmPhZow+PS8WIWiQrGCCVEA9Gj1/Lexy3V/zcDSQ0SbIqmzzXcXgxmUjzweufIJUxeOHydt57nAuuOwdGdkDTfHj7H6F1Cbdtv41nhp4h4ApwxYlXlD6whDVhmquKCcPeCklWo0esStaaZEUtkrXUIgiGajIUHa/p75wVxvZAJgGal0GXWD1sdkg0iiFsTbxGY+JhmNwkHnK+lfntY7lQmsTqrVEBQakU8jydkKzH+h/jTX96Ex/5x0fYM7GHFl8L/73+v7n11bdyes/pdDX6aAl60A2TrQPlX29ykjySGClomaoGBuODQHGSBXDmHGEvu7/3fkfHnRy2SFarA5IliZHfmui4vHDut/Aowj6Ttr4XuUgyZv1fXl82JsQkE08IfGKimT5wgOTWraCqBM+YZi2cBlOSLAy2jW4jbZSeJAY8Ls4/rpuuRh9nLC29sr5trDTJcnlUVE2QFyMkjqlP5rmGFAUaLTVsOsny579+lnWKz3D7QGUkazg+jJoWz26vP/v5e4MWyYoV/8zeu/a9tPha2D2xm+s3X1/ROThFUk/SHxX17/NCDhwTVUCTt4m3Hfs2AK5+8mpH15DEX/b8BYCXLXgZA5Pi/ulsnOlqmo7uoBizE8PiXlYsB8RAJSRr0iJZ6hisfg0HrfGhM5h1ExwYE/flnAIkyx8S42d8wjkJ8swRJMs7KJ6TE6kJDHOmpfPdZy7G51Z5cMcw537vXzy+Z9Tx70hY2Ql7WsTvmt8SYCQ+jWQpCsxbL/6972HHxz6ScVSRrIsvvphvfOMb/M///A/HH388Tz31FHfffbdtZ9m7dy99fX329qeffjrXX389P/nJT1i7di033ngjt956K6tXrz5cb2HWCHvD+DTx4Nx4cB8Ac5vFalqlSlZCEwO0WcTrWseRCdM0ufLmZ9k1FKWnycd3XhZG/cV5MLobmhfC2/8EzQuZSE3wnSe+A8AHjv8A7YHiFogpsEhWuy4G/EpJllwJrzXJiuliFa4roxOwvP9jqREyeuE6gMOKwS3i77ZljMTFOVaHZIljjMXTGIkEyZ27APCtWlVyX9UiWWbq0H1mw9bKaPN0hSQH20a38cF7Psjb//x2nhl6Br/Lz/vXvp8/XfgnXr/i9bhVMZYpisKqbkHqnzuQf1W2GORDP6EniGVqt/jkRMkCOGPOGQA8dfCpgqvMubCVLCcky1aysrU8LD4Lz3JhJzOsZ0mDpwGAMWsiH/ZPI1nj4nk0RcX6p1De/GvX4mpuLnoaNhdRhQV059jO0ucOfOf16/j3p15Ma0PpCbGtZIULkyxFUfAGxHNTD4nPxIgUqJEqQLKafeK9ZszMlO9raYf4DLcdrGwM7I304jbEd5r7bJfnmyiiZIEgypefcDkAP3r6R/b1Vwv0TvZiYhJ0B7OT6EOAN616Ey2+FvZO7uX27bc72mciNcGDBx4E4GULX0b/uCRZpe8fSbLSI+I+creI9yqPUQ5io2KsCahjcOyF9McESe0MzCRZBZWsRjF+SsLmBO454p51DQjSY5gG0fTMa/70pW3c9sEzWNwWpG88wcU/foif37+r5EKUEY+T2iWePxut9zK32c9IchrJApgnVPs6yTpMuPTSS9mzZw/JZJKHH36Y9evX26/dd999XHfddVO2f93rXseWLVtIJpNs2LCBc8455xCfcXWhKIqtZm0f2Q+IixWmkayERbL8+UmWHKA9JsQUyx5Rtwsedfj1w3u585k+XKrCT85tpun3r4bxvdC6FN5+F4TFCuI1T13DSGKExU2LecPKN5T3S5rEMUJJMeDvOcLtgklDTGpaDJ1Wq2ha0SKMxMqzNxwyHLSsUe3LGbWIRst0laACSKVhLJYmuW0b6DpaczOujo4Se4LSLMYY0wCzSHhMNSHfe2vDTJLVH+3n/z3w/3jtHa/ln/v/iaZoXLz8Yv504Z/4wPEfIOgOztjn2B5JsspXMQPuAH6XGFdraRmUxy5FsuaG5rKoaRG6qfPvA/8uum06pdtWIWd2QUvJknZBC96XCLXb1L1gZpXosbhUsqZ9T+OWktWUDVpyahWErJKlqWIB0Kll0CkmU5P0RcUibDElC7KWwUxAqBJ57YIAjdZ7ndg/dX/Nay8qDSey188xnYJkba1QyeqL9uHWBZmUbhQAn0MlC+BVS17FypaVRNIRrn7y6orOwwlyrYKHsv1N0B3kXWveBcAPn/4hSb20Vfy+fSIsYknTEpaEl3BwQuxTjl2QMfHc8beL+6giu+CouM4C7S3QsYKDsYPAVLtglmTlPzdbySqLZInr2DzQby/ijyfzj5vLu0Lc/qEzOPe4bjKGyefv3MgHr3+CyUThay+5dSsYBlpbG5vT4vrtbDLJGOLZIhclgBwl65GclZejF0cdyaojKx3vtR5q00kW/oDtoy+oZFkDtAuFiCou+rpd8OjCht5xvnCHqLP58pleVv/lEmHZaVsOb/ujvcq6ZWQLv90skno+econ7dV+x7AmTe5MhBCxWddkOVmJnw1SpnhQhXWDVku9UlwRhsp46BxSSCWrY4VNBKuhZElFaCyWIr4xaxV0MuFRm7PF88YhUrjzKVkTqQm+9fi3OO+W87h1+60YpsFLF7yUW191K58+9dNFycmqnsqVLMipq0nUhmSljTSjSWG3KUWyIKtmlarLilgqltun2QpHUUy3C1rwtMlrQMNleAhZ0wVbyZq+EDBuEQ1LyTKSSaL/FoSw4aziIQuAvRrustIHN4/kb81SKbaPbQeEKtDkLR5qYytZPkmyCpAiSbLG9894qcX6PHNJum0XrLAm60DkgE2yPL4syXKqZIEgsVeuF2UVN2+7mY3DGys6l1LYM7EHgPmNh6YeKxcXLb+IzkAnA7EBbthyQ8nt/7LbsgoufBnRZIbJpPgcndgFJcnSJoTyE+q0SFaZSpZpmMRjYmz2HyvswdNJViKt2+RtTnMhu6BVk1WGXVDWZKV6e+3FlPFU4cWpBq+Lqy9Zx+deeSxuTeFPz/bzyqsfYFNf/rE2sUncy74VK9g7LOYPoQbxPoLuID5XDmHsWQeqCyb7sur4UYw6yToKIeXp/phITpwzjWSZXr9dRFywJitngI5bKxd1u+DRgwlZh6UbvGVJlNdteC9E+qHjWEGwQpYSYZpc9chV9uT0tJ4KQl88QXsC1qMMMRJNFV21KoRDpWRlEMdv1o2skuWKMBQ5QsMvBqWStSJHyZo9yWqy7FyGCZENIhTFSegFgBLOJkuZE4OzPhcnsJWsoJeknuQXz/2CV9z0Cq7dcC1JPcmJnSfym3N+w7de8C0WNi0sebxje8QEeXPfJLpR/oporcMvZD2CpmiEveGS2+fWZRWz58h6rMZWnzMFYXrwhQWXR0WGs3l0Hw27hZ2qIMmSak6jIFmxRx7FjMdxdXbiXVH6upMlIG7Lvr5puLpKlpPQCwmpDGW8QnnSJwuQouYF4u+xvTNeyq3rk1jaLo7XOxYnkixfIT4QOYBHF89r9xS7oHMlC2BdxzrOXng2JiY3b7u57PNwgn2TYoJ8qEIvcuHVvLx/7fsB+N9n/zev9U1iMjWZtQoueJldSxX0aEUTICXkfMxjBfeEuwQhKlfJSg72YZhiXhY44TwSmYStJkm74IbecQwT2kNe2gvYY7N2wTKCLywlK72/l0avIFkTyeKLU4qi8NbTF3LDe0+jp8nHrqEor/7BA/zhsZnEKGHVA7P0GCYsl5XXKxS5GVZStx+614p/75vaGuFoRJ1kHYWQKyejSbHKMb0mK6NZKxzKVEtBLjRNRXOJB3DKFbT2L9wnoI4jB6Zp8smbnmHPcIyzGvv57MgnUaKD0LUG3noHNGTrre7adRePDzyOT/PxsZM+VvkvtVanl/vFoL9vpPxrxQ6+SNeWZOmKeKCGDZ0W2y44eWSSLMOAQZEsSPtKO7GpGkqWz63hc4shPqtkla7HAlC8QRRNTOSN0cLN26sF0zSt927wxMhfOf+W8/nGY99gIjXB0vBSrn7R1Vx79rUc136c42Muagvid2vE0zq7hgpPsgoh3yS5mpD1MK2+VkdR0yd2nojf5WcoPlRU5ZmQoRdOrIIAMat4PTC1ZkpRlKytPOMn1Pcs7Li3iF1wqpJlWwWf/3xHZE8SR4+VqLZ5ZHPe4vtKsXVU3GdOSJZUhjKWDdXIF3wBELYIxOieGS/lI+nNQQ9t1uS4EjXrQDRHyZpiFxTnm4w5J26vWPgKAB7uq03ty94JQTwPVejFdLxy6StZ0LiAkcQIv97464Lb3bfvPtJGmsVNi1navJSBMqyCYM3HTJNgVDxr2uYIkjVQppIVfUqoaV4thtax2FaxfJrPfnY+tW8MgOPnhQveU5XYBWXwhTExQbsu5pPFlKxcrJvfzB8vO5OzlrWTzBh87MZn+PiNT09JdU1sFs+f8TkiPbcj5CWWEcefYhWU+A8Kv6iTrKMQXQFBsmKGeEjbdkGrmZruknYCV9GHm1wJS1r9PYxEnWQdDfjlQ3v407P9HK/t4md8DjU+LCT2t9wOwexqdDQd5ZuPfROAdx/3brobyu8XZMOqy1oZEKtblYRf5CpZtUpsi2fioFor7bpp2wW9rvEjM8Z9bA9k4qB5oHmhnbBXLPyhHDQHPKimgb5DrOL7VpVOFpRQ3WLsMEcHSmw5e0RTOindwNt1K9948nP0RfvoCHTw+dM/z43n38hZ884qu65DUxVWdItrrpK6rHx2r2rCDr0IOOs349E8rO8Sk49iKYNlxbdDQSULsjW9Ht1HyDDgjx8hZjXKnRl8ka3JMk0zpx6rtFUQsjVZHpcHr+YllonZakg14CT0QsKuyXKJCaceLUCIwjlK1rQGu3KFfrrddJlVl7WtgtTLXLvgFCXLUt4SUefqxUldJ6EqKrsndtspgNWEXZN1GOyCAG7VzQeP/yAA1z13XcEao1yrIGRTATscWAVBWPmCSQVrTYqueUJ1iqb0shwfsY1CTQs0CPI8YDmVOgId9tj35N4xQJCsQghUQLLUYBDNCqaZMyn2L6Vk5aI56OHat53MR1+2DFWBGx7bzwXXPMjuoSimrpPcIhY4DrSLecT8loB9X+QNRfkPCr+ok6yjEFKeNrUxFAW6m6baBTPKTM92PsjXM5Yf1izS8bqOIwPP7B/ji3/cyPHKdn7vvwpXahzmngxvuW1qOhjw42d+zMH4QeaF5vHWY986u19srU4vmUWvLEmyDNOoWWLbaFycn9s08buDtCpiIuJ2jR2ZSlZOsiCai1HL7tMSnH3wBQjLYE9kCCWRQPH78SxY4HhfxerTZYwdrMq5FIPskeUO7gBEv5s/XvBHLjjmAjsIoRLI8IuNFdRl1bomy2myYC7OnFs6yl3aBRucJAuaZsGaLMgJSNJ9hLxNMLKT18RvBKYpWaY5RclK7dpNet8+FLeboMO+lHLhRVEUmwhVyzJomqZNspY1Lyu5vVSy0rJeuZBdsGkuKKro6xOdep8UUkKPsRIGy1WyTNOkL9qXYxecWZNVrE/WjFP3NrGqRSjb1Vaz0nraDhk5HHZBibMXns2y5mVE0hF+vuHnM16fTE3ywIEHAGEVhCzJ6nKoZLlVNwtMce+Yfh/BUJCQdd84jnEf30+sX3xegTZBdvKFXkgla10RkiWVrFgZNVkAbqtReNeEIHTl1k6rqsKlLzqGX71zPa1BD5v6Jjj/+/dzz18fxbSeP9vd4rzntwbs+0LeJ1Mw1yJZ/RsgWVn94pGCOsk6CiHtgqp7zO6RZRoGpkWy0lZaYKFkQQlpJUxrUgmr12QdyRiPizqs44zN/Nb3FbyZCMw/Dd58i92XRmLn+E5+tfFXgAi78GrOVuUKYlqvrD0j5duvvJrXDt2oVV3WgLUq36zrKJ4grZYVVtMmGYocgcEXdj3WciBbl1RNJWuJpTD4li1D0ZwTFtUjxg9zsnYxzxLD0SRgoLjHALh4+cVTi6ErhKzLqiT8otY1WZWQLDvKffCpgivzkXKUrHRM9GiDGYs0kK3p9eh+Qie/F4B3cQsLlT672TUA8VGhyAI0zrFVrMDJJ6MGZyY/5oN0BiqqwspWobhWK2FwIDbAZHoSTdFY1LSo5PY2ycLqIVnILqi57Rq06ZZBW8madv0stcIvyu3fNpYcI56J5w2+kDVkesYgk3Le2+7UnlOB6pOs3kgvhmngd/nLur6rDVVRuWzdZQBcv+l6BmNT60ulVXBR0yKWhpcC2Voqp3ZBgAWGIEZ6o1A+u5vEvv3jDhf2nruFuBEGINAirg9JsmTQ2cHJBL1jcRQFjiumZFk1WclYBj3j3G4r67JaR8X1U2h8KYXnLW3jj5edyckLm5lMZvjVr/8GgHf5cvaNic9jfktgZiPiXDTNEe4ZU4cDT1R0HkcK6iTrKIQkWYqWpNuys+aqUBnTWn0skCwo4fZaCUrWZKZuFzxyYZomH7/xaXpGn+BX3q/iN2Ow8Ex4003gDc3Y9isPf4WMkeGsuWfx/LnO7DpFMaNXVvnXiqIoNU8Y7J+UJMsQJMsKFDBd0SNbyWoXk8qRMhryOkE44LZJlrcMqyCA4rWCMyZqU5OUi9FYCsUVAUVHU7Qpq7ezga1k9U2UbVGtdU2WbEScdyW3AHoaeljStATDNHio76G820zYwRf508emQMa3ax6w+mDlwivtghkfoeXnkFr4ArxKhi+4ryPkzXm+yBSwYAe4vET+WZ5VEMCwlSxY0SKCMqqVMCjrsRY2LsSjlb63pF0wZVrkpZBdELJ1WWNTSVZuQ+JcLLN7ZZW3Qn8gInpxNSCu6dznu9uroapCgXCSMCixvlvYT//d9++qWrilVXBeaN4hjW/Ph+fPfT5r29eS0BP85JmfTHkttwGxPM9y4tsl5ujiuZa06u3kvn3jDp+TG24iJkmWRZJy7YIAT1lWwWUdIRq8hed23oALxboW4mWEX3ishMHwqHgGzeYZ3dXk4/p3n8p7nr/Yfv78Qw/zzH5B3HJJVt6aLPiPsQzWSdZRiIA7gFcVA3Vrk7iJ7fh2RSGti6+1ULKghFwJ0y2Vw6wHXxyx+PkDu5ncdA/Xeb5KgAQsfiG84QaR/DcN9+69l4f6HsKtuvnEyZ+ozglYNVmNKeHdn22MeyRVGwvAwagYuMOGRbKsiU7GlTgya7JyemRldIPxuHgoViP4AoSla8mYmJz5VpRHslSvtEqNVuVcimE4kkJxi9/TEejApTqIHneAZZ0hNFVhJJoqO+2rUE1NtSAVjrIag5MT5b5/ZpS7njGIWqvnjhoR51oF80yGp9RkeRrpe94XSJpuzlSfRduYk0qXU4+lR6LEHnsccNYfS0LWZCmqwsoWS8ka3lSVyX85yYKQVbJS1rO0oF0QsgmDDpWsYywla/9onFjKOSE6EBX3cdAiWbl2QUVR8NrhF84n1us61uHVvAzGB9k1vsvxfqUgQy8WNDq3J9cKiqLYDZhv3HYjvRFxrUZSER7szTYglhioQMnqTAsFKxoU14u0GjqyCw7vgANPErPUMEmybCXLShZ8Mif0ohgUVcHfYMW4V9Arq2FIPNsrVbLs42kqnzpnJecFxL3zsNbGRivifUFrgNGEGO8LNqrO7Zd1FKNOso5SeBEXZkNQWA6mNiK2emSVsgtag7Rhrewdqn44dZSHp/aN8cDdv+Xn7q/jV1JwzMvgkt+BJzBj23gmztce/RoAbzv2bcxrrFKyk6VkeWIDaOjsH41VFIstG3TWyi44aE0am3UdPEFaLauFruoMRmubalg2DAOGrGTBjpWMx9N278UZoQIVIux3sVjaBctVsnxWrWZkrCrnUgyjsRSqZRWUNafVgM+t2bHZz/WWtzJ7KO2ChmHyg79v585nDpTcT9ZlPdD7wIz0vchoEkzQ3KrdL6coioReAGheQbw8up+QJ8Sgey4/yLxKvPjnT0HCmojl1GNFH3wA0mk8CxbgWbiw9DlYkNe+qioc03wMmqIxmhy1V/Rng21jzuuxIJvWl06L91+wTxbkhF84U7Jagh5arUWUHQed266lkuU3xcKaZ5qaUW6MOwgL9/EdxwMUVEYrQa6SdSTg5K6TOa37NDJGhh8+9UMA7tt/HykjxcLGhVPCULJ2QecW+9aE+OzH/eIi7pJ2QSck6zmxWBHziOS9UkrW8fPDJQ/pb6ygIbFVk+UfFM/JarhNTNOkYd9OAIwl2XtvfkuwuF0QcpSsR2aEyhxNqJOsoxSKLlY9PD5xI0whWfGM9ZqzmixTtUhWPfjiiMNYLMVvfvljfqh9E5+Sxlz+Crj41+DOv8r28w0/50D0AF3BLrvrfVXQ0AmqG8XU6dHGSetmRR3ta20XHLaCL8KGAZ4gwUAnXmuAHkuOVEQMa4bxvaImRvNA8yI7WbDJ78alVWdo7khOEE5FMVQV7zHOVvEl1IDVGiJS2+bRIBoRq5aS1dPQU9VjH1thU2I5SY6kIyT16quguSTrH9sG+fqft/DxG5+xexwWwgkdJxBwiXSu6TVLucmCznpkWQQgTz0WAB6xYOfV/QTcAcZiaX6kn0+v1gORAbj3S2K7nB5ZkX/+E4BgGVZByFGyFPC5fHbtVDXCL8pXsizCYs1R9aIkK79dUE4eY5mYSD3NwTFWwmA5dVmSZOULvhDn7LwhcS5O7a5+XZadLHgYQy+m47ITRG3WHTvvYOfYzimpgvJeMU2zIrtgU0LsP+xNT9nXUU3WBotkaWJxKZ+SpRsmz+wfA2CdA5IVsBZYYhUoWe6Do2Cas1ayADIHB9FHRkBV+fYnL+SDL1zCh1+yjPaQtzTJ6lwN7gAkxmB426zP5XChTrKOUqSSYuJgaGPi74qULKuw3QojqKcLHlkwTZPfXHcNX0p9Fa+SIb38fJTX/RJc+VfY9k3u4+fPigSlj530MQLumUpXxVBVaBST3+MbxYRDdm4vB7VuSCwtCM26Ae4ASkMHLRbJMtWITWSOCMh6rNZjQHMxEpXJgtWxCgJ0HRSTneGWblRfeUESakCsmJux2iuAo9GUHXpRTSULYJVNssqbNITcITuopdpqlmmatg2xzddmN/CMpXR6x4qPw27NbU+M798/NWVwcljs68gqCFmS5c9fF6G7xTUZMBtQFZXRWIoUbn7dKuxXPPpTOPCkrWSZjXOI/kOQrHKsgpBVsmQ9yapWkXw327qstJFm57hYTS+bZCV0TMCMxTAzBchLAbtgg7sBj7WAOTNhUIyD5dRlSbugSxfHnE6yZPhFOUoWZEnWo/2PkjHKb5CcD/smrEbEhym+PR9Wt63mxfNfjGEafO2xr/FA79RUQYDRWJqU1fbDaYQ7QENM7DPgFvefY7vgwU1wcCOobmIpUUMZaPKgG7od0tER6GD7wQjRlE7Qo9nXTjHYStZEGQ2Je8TzXYklaIjP3i4IkNi0EQDP4kUEQkE+dvYKLn/JMeiGbj+r5WLWDGhumHOi+Pe+h4mMJtj55CBD+48wR0oJ1EnWUQjTNIlExQQoZYrBW5IsJRgglZBKVomaLNnM0JpI1JWsIwv33vhj3jvwOTyKztiSV+K+6DpwFZ6Af/3Rr5MyUqzvXs9LF7y0+idk98qSDYmPPJI1nhoDIKzropA/2Ear1ZBYdR1hDYlz6rGAbCPiQHWsggDhvt0A7G8t37aj+MVquxErP0myXIzUVMkSCYOyHsApFEUpaPmaLaLpqK1uqGYjf92YtcTtGCw98T5jrlWX1Tu1Lmuy3EbEsiargF1Qd1kkyxDXgqwZ7GtZD6tfKyIB7/yw6BMFJEYUMoODKIEAgZNPdnYOFnKVLMiGX8w2YXD3+G4yRoagO0hP0Nm1JeubTCNbs2xEC9wH0i440Qt6lqTkXj8z67JkjHv5SpaSthIfp9sFg5UpWStbVhLyhIikI2wc3ljWvvmQNtL2uR4pdkGJS4+/FAWFB3ofsK2CuRZSSYpagh68LudJrD4rubbfHSOlp5zbBS0Vy1jyUuLW9xZoFCqPbuqoikqbv42n9omxcc3cJjS1tEJtx7iX0yvL50NrF0mQ7ePVcZskN4sFEt/KVVN+Pp4ax0Tc703ephn72cgJvziwbYy7fvws999wdKladZJ1FGIkmiKVEBfmREasdhhWaIXqL8MuaJEwxeolVK/JOnKw695recGGT+JSDHb0nEf4DdeCVvj7/Nf+f/H3fX/Hpbi48pQra5PoZNVlLfWMAZXFuMvO9bUiWRMWyWoxDFGzFmyzGxIrrsiRFX4hlawOUSs1WuVkQYDgXtF3amfTnLL3VRvEd2XGa9PTLBcj0RSKawzA8UTYKaSStX80zniZq/yFwgtmC2kVDLqD/PnZEdJ61iK4Y7D0fXXmHFGX9ezQs1NWnMtvRFzcLph2ifvFqwtVfMz6/MIBD5z9ZfA2CSVr/6MARJ8TwTjB005D9ZR3HecGX0D1SJa0Ci4NL3U8LrrcKqpLbKsHwuLvQuEXoW6xUGlkYHJqTV3B8IsOGePuXMnqi4g+SoY1b55pF7SUrDIaEgNoqsYpXWIyWw3LYH+kn4yZwat5q5YSWi0sbV7KeYvPs///0gUvnXJN2I2IQ+W1PFHHxT07GYCB6IBNsoYiSdJ6gXoi04QNNwEQX/IaMC2rbIPbtgq2+lpxqa6cJsQFkvimoZKGxACeOeIZ3zFuEs/ESevlXUvTkdhkkawVK6b8fMRa3GnyNtlugbzICb+Ijov3EmiaZTuaQ4w6yToKsX80jpkWJGsgJh5qU2uyHNoFrZUw1SJZdbvgkYHow79kwT8/jKaYPNj4Cha/8xdFCVZKT/HVR78KwBtXvpEl4SW1OTGLZM2xemVVEuNuK1np2pCsaFpMOMNW8AWBrJKluCJHlpI1aNmgZihZ1SNZ7l3bAdjU0FX2vkpDGAAjmYJZPmxLYTiatJWs7obq2gWb/G7mNgsrznN95VlgatWQ2K7H8rVxg2UVlIX2TprUdgW7WBpeimEaPHjgQfvnNslybBcsHnyR0sQ97tXF55dbN0ioE178/6ZsH3lMEKJyotslbLugMpVk9Uf7GUuMlX08CRl64dQqKM9Bkha9SazuG5ECY5aqQthSbEadhV9IJWvfaIy4g75WE6kJJtOTqIaGaW0+3anikw2JY+Vb/nKj3GeL3NALVTnyppjvP/79uKw5z9kLz57yWiXJggD6qBi7Jv0K/bF+WgIe3JqCacLBQgt7fU/DyA5w+Ym1i0UTX8iDqip26IVMFrSbEDuox4KskhUvtyGxVZfVIfNsUrOzDCY2ifHAt3IaySpVjyUx11LDh7YSHRLnEmyq3vPxUODIuwPqKIn9o3GMTBgQqyamadqWHjUQIC3tgg4j3FXFShmMx6vaK6OO8mE8dh3+uy5DxeR219msef8vUIoQLIBfbvwleyb20OZv431r31e7k5O9sgzZK+vIswvGdGFxaDYMcAch2J4lWdokQ2Wu7NUMhjGjR9aYNYGtVny7PjkJB0Sy4DP+zpKBCtOhNoiFHDOjZBWPGmEkPo6iifdf7ZosyOmXVWH4RdWVrIQgWX4tzOb+STwulfefJRZHnNgFIatm5Ua5V2wX9Oef7CQ0cY/LBrhjssWAtLSe9A7oWQdAJuUh/pwkWeXVY0GukiX+H/KEbLvZbNQsO/Qi7JxkQZa06A3is6kkYbBQG4DWoIfmgBvTdPZ9SxWrXcsulsjgKgmvVZOVKFOthWxd1pMHn5wR0lEujsTQi1zMC83j+y/+Pl858yssb1k+5bUBK/Siq0KSNRGAvmgfqqrQEZLhFwUcQpaKxbKziSXEtZYvWTCazNgBKetKxLdL+CsIvoBswuCcCbH/RLJyy6AeiZDeK64F78qpybaOSVagBdqEnTPWLz6TYLiuZNVRY+wfjWGmGwGFlJFiJDEyRclKlmkXdMnLwDAw07Vdsa6jCB75Keqdl6Ni8kvj5Sx9+08J+YsPKP3RfrvB4hUnXkFDnoaiVYPslZWsvFdWLdMFTdMkYYjjhnWRLphbk+VxjR85StbEfkhHhc2oRaSoyeCLailZchVxwB9m0h1gMlHeCrfit9IFdQViQ1U5p3xI6wZRq8l1s7cFn6u8CY4TyLqsshMGa9SQeMj6PCei4r2efWwXJy4QE44dDsMQ7Cj3AyLK3TBMIiNl9MiCkkpWXBXnoqXFNSkXAsLyGlU1OO/b4PIRTSwH08S7YgXuzk5nvz8Hpt2MOGvfqoZlUJIsp/HtEjKtL2sXLLIwJMMvrNo0iULXj6Iodr+sbQ7qsmSN0xyfGINdbhV1WgKprWSVaRcE0aS5I9BB2kjz5MEny94/F7JH1pEUejEdZ8w5g3MXnzvj5wMVxLebmQz6hBhXJv1ZQiwtg3nDLwwDnrtF/Hv1a4hZVrjgtGTBjkAHz+wfxzChp8lHh0PyF7Aj3Mu7FtxzhFW7a0JcW7NRspJbxCKiq6sLV/NUm6NcdChJssCuy4qOiPskUFey6qg19o/GARd+NQyIifbUdEGpZBUnWbJw1pVzGZix2tdf1JEHD10Df/ooAD/NnIP73K+xak6RglAL33zsm8QzcU7oOGGK17wmsJQsr5VyNRJNMZkobxCvpZI1mZ7ERPjfw4YuarJcXloV8cB0u8YZPFJI1kHLKti6VKQokVuTVZ3gC1l0vKd57pTjO4VMIzR1JTsZrwFGo9keWdUOvZA44pQsyy54YEh81xedNJfF7SLMaDiaYjRa+rs6vuN4gm7Rb2bj8EZi40kMw0RVFeervTGr0XSBmqyYIkiWmhbnKWuymnLDWXrWwWVPEjFEElglKhbMrMmCnITB4coSBiOpiJ3KV45dELI1Thm/leQbKVIrJ2PcHTYkBjimQyyIbXNQlyXfQ7dH3B/T67Egq2RVYhdUFKVqUe5HWo+scmCTrCbnCz36xITtdY34od8q4ehqLKJk7X8UxveBJwTHvNSunfJPj28PdvKkFXrhpD+WhD+nJqscd5LHUrLax8RzdDZKVmKjZRWcVo8FlG5EnIu5FsmaFOcUrNdk1VFr7B8VRKjZ0w4IkmXmkKy0jHAvkS4oB2o3ChnVsgzWwy8OPe7/Dvz5SgCuybySDcd+jNefUnoV8JG+R7h7992oisqV62sUdpELKzxBSY4zLyAe5PvKrMuqZfCFrNvwGuA1EemCQKtF7BQtwlDkCLELynqsjuwDqNo1WfIh198uriVp9XIKxS8mCUamtiRrJJZCsZMFq28VhGz4xfbBCIl06RoYiUJ2r9lCkqxkMsicsJ/Tl7QR9LrosSZ3TixkbtXNad2nASJlUFoFg81eVAcJZED2ey0Q4T7JGACKrqJnDJtkTb9GzUAHkYfE5LxSkiX7jVZTydo+JmoSOwIdxVPM8sBWsrxi/ChYkwVlNySGHJLlQLmUSla7SyiE7jwuFRnhnqhAyYKsZXC2dVlHg5JVCNIu2Bkqg2RZVkG9wY+hKvRFhZLVWSzGXVoFV5wLbr+tZE23C3YGOu0mxOschl5ANvjC0M2ySLesyQqPpkWvrFkoWYnNFslatXLGa47tgmCHX8SS4vOsk6w6ag6hZEGXVbvQH8sqWUpuM+KSwRdWFKypkLBW02VKYR2HCP/4OvztMwB8J3MhN4bfwZcvPK4kYUobaa565CoALlp2kT0ZqSm8IfCFATi+Sazq7i0zYbCWSpYcuBvlHNrqE9biFQO57oozdKSkC9qhF9nvrdrpgtIuONS9cMrxnUIqWYauQLR2dsGRSI6SVeVkQYmuRh8tQQ+6YbKl3/m1V+uaLCMT4jUnzrVjmZdYE2+ndVlnzBFR7vfvv7/8ZMFMUlhWoaBdcMLMTrJSiUzWLuifqrbGn34aY3wcrakJ/9rjnP3+aZAr7mrOrESOa3sm9hBLl++y2Dq6FShfxYKsMpS2FmsKpgsCNC8Uf0+zCxZVsqRd0EFDYkmyWjWR1pdvAdU7i+ALyIZfbBreVHGPJN3Q2R8RPdOO1JqsYuivIPhCkizCYiGnPyKUrG5rwaRvupJl6FOsggAxi9zZJCsqSFa7v90OvShHydLcqj3/Kydh0NXdDYqCO23QFJudkpW0kgW9eZSsskhW2zJSnk7SZraP2NGEOsk6ymCapk2y5jUKktUX6cOIigeQ4QvaKU2lmxFLkgUJTVy4ZqJOsg4JTBPu/RL8/YsAfD19ET9SLuKaN51I0Fv8ewP43ebfsX1sO83eZi5dd2mtzzYLqy5rVUAMvuWGXzS4xYRlMjVZ9ZCVseQYAI0yDtsj7FetAaH46lqawWKWn0OJPCTLVrKqQLKMVIrkDhHfHpm/GKDs+HJF2gVrHHyRq2RVO1lQQlEU2zJYTl1WrdIF+yZFDZqZCfG6E+faP1/SLvsnlUeynh16loMD4jNsLLcRsaKBL7/KE9EnSatiAhidTBO1kvDC03q5Re77BwDBM89E0Zz3F8qFtAuSs8DU5m+jw9+BicmW0S1lH1OSrGXh8uqxIEtaMi4xuXMUfDFxQJBXC0WVLCthcO9IrKS6Ku2CzaqYlE4PvRDna9kF45myQ25AqH2LmxZjYvJI/yNl7w9iwTdjZHCrbjsZ72hBRjfsmt3OMtSSjEWyXM3iu+mL9mGapm05nNEra/f9ED0oFiwXvwCA2ISMJ59qF1T0MAcnk2iqwuqe8pTYbF1WGb2yPB5cVj1l+1jlNVlmOk1ym6iF9K2cpZKlqkTbRFqp262XzBo40lAnWUcZRqIp4taAvLhZSLu5SpZurd4rqoLLXfzrlRerC4WEVWxetwseApgm3PM5+OfXALgqcwk/0F/N51+5mhVdjSV3H4oPcc1T1wBw+QmXl22DmRWsuqwlXvFgKZdkSSVLN/VZp1hNh/R5N8u+JNYKdGOwA5dF6EaTIxVNQKoK08xJFhQkK60bdjBFSxXsgslt2yCTQW1qQu0QiWTlK1nW5LLGNVkj0dorWZC1DG4sI8ZdTpLHkmNkjMoUgnzoi4hJ1HHdc5nXErB/vtRWspwtBnQGO1nWvAwTkx37hYrSUHboRcsUYpOLydSkHeM+MiaeDYoCjb5pJOuf/xS/u0KrIGQj3KdbHVe0inukkka5drJgBUqWzyItadV6NhazCwbbLOXchPH99o8lSc93/bQ3eGnyuzEcJAxKJSukhIH8C6iyGTEmtpulXMy2LktaBeeG5qKplZHtw4WhSArTBE1VaA06J1lSyfK1isW8WCbGZHrSrsmaYRd84pfi71WvBJfVNFiSrJCHSCpCLCOeq71D4vUVXSH8nvI+TzthcKLc8AsZ425WrGgmd+7ETKdRGxrsxMJc2M9qnzMLZCws6j2Dbud95Y4U1EnWUQapYnU2epnXaJGsaD+G1eNKkiyPTytpOctdDYtZCkPdLlhjmCb85dNw/7cB+Kb6dn6cOZ8LT5jD606aORjlw7cf/zaRdITVrau54JgLanm2M2GRrLlKZb2y/C6/3aOk2pZBqWQ1G7KRjLgX1IYOWqyEQUOdLJtsVB3j+yEVAdUFrSK2W56TqkCjf/bBFzL0wrdyJeGgTIYr72Gr+nODL2poF4zm1mTVjmRVkjDY5Gmye/3IicFskc5kiOti8nLhcVNXectVsiAb5T54UByzWvHtIO7RpEtMEkct21OT320TIdM0GbvpJpEkpqoEz3ie4/OeDjv4Ytpja2WL+Iw2j5QXfmGaZkU9siSkkpW2gnOK2gUVJSf8Yrf947A3jKqomJj2+JTdRWG5ZRksZmGNpWP2vkFTbO/Jo2Rpmmo/0yuty5ptv6x9k6Ln24LQgor2P5zoz2lErDmtaQT00TEAPC1tNHsFaeiL9E0JvrBdG3v/DRtuFP8+8e32MWyS1ei1VayQO8SmA+KcjncY3Z4Lf6UNieeKeWX7eOUpwHZ/rBUr8s5DpTNALkKUQjQgFlqC5sGKzudwok6yjjL0jolJ7dzmAF0BsULdF+2zlay0Jh4IpayCAJor29U+aU1I63bBGsI04a6Pw0NXA3Bd+FK+H3spx3Q08MVXr3YUXPHUwae4fcftAHxq/acOfbPHab2yyo1xVxSlZnVZo0kxCW6TjXMtu6BoSCzULdGQ+DCTLGkVzE0WtCZF4YCnrAd8IdjJTitX2tau8XKDL7yHJvjiYGQC1SWuo1rZBQFWdQsla3PfJLpDNVNTNXviVC3L4F+37gTFBFPhwrVT+/RIJWvfaGkLmYS0DKbHxXsqP769OMlKa2KiNz4xNZhFj0Q48LGP0/ffnwag6ZWvnBHVXA7sCPdp13+lJGsgNsBkahJN0VjctLjs87FJlin+LmoXhJzwi2xdlqZqhL1hIH9d1vKu0iRLBimE3CHUjDiXfMEXkFWzKq3LOrnrZFRFZc/EHjuKvBzsmRDBH/Maj95kQacx6RJSydKaw3QFxZxsIDZAhxUDn8wYYuw1dDtBmHVvhjkniP3Thv19BZo8djphR6Ajpwlx+feVDL+IVdqQeGwWSpZFsqb3xwJI62n72e/ILghENTHvCJgHYLy3onM6XKiTrKMMMllwbrPfnpAMxYcwosJekrGsDU59qzLGPekWE1KpiNVRZRgG3PlheOQngMI9x3yaz/afjt+tcc0bTyDgKf196YbOlx/+MgAXHnMha9rX1Pik88AiWY0p8SDYPxpzPGGVsElWuspKlpUu2G5YZMK6pgm220qWok0e/l5ZxeqxArNXsSBnJXHlCsJ+8bAt2y5oK1lAtHYkS04iPWrATp+sBRa1BfG7NeJpnV1DzpWiaodf3PiUsL151UaC3qnW0LYGD40+F6YJu4acWQbXdqylwdWAPyGUurJrsgqEXsBUu+CktSLe5HcT3/Acu17zGibuvBM0jfYPf5juL3/J2e8tAFOmC04nWa1iorZ9dDsp3fk1LK2CCxsX4tHKt+DKGqeUbiXvFuuTBVklq1BD4iIka3MRktUbEZPKnoYeOzk4X4R77jlX0isLxNi8unU1UJmadaQ3Ii4GO749VF56nW7XZDXbJKsv0ofPrdnjef9EAh6/FvqfFfWPL/msvb9sGKxqCt6Ay1ay2gPtPNsrSE5lSpb43eUqWe451kLqrJSsrJNiOmQ9lqZoNHqdjffW9JagOgr7K6sXPFyok6yjDNIuOLfZT4uvBZfqwjAN0lExacgo4mHi8Tvz78rBOumyGo/WSVb1Yehw+4fEIIvCttO/yrs3iP4vX3z1ajtlqhRu2nYTm0Y2EXKHuGzdZTU84SKwgi880QO4NYW0bs4s7C2BWilZcvAO23ZBSbJa7YbEqit6+EnWwZkkq5rJgqZhTLULBqb2OHIK5RDVZA3FBWFv9nTU7HeAqLVY2S2uvcMVfjEeS/Pg7l0AdAbbZ7yuKEpOXZYzIuhW3ZzRehZuwwOYNDSXSbIKxLdnjAyxTIyUZReMRFJgmrx449/ZfcklpPfsxdXdzYJf/ZK2974HRZ3ddCLbjHjqz7uD3TR6GsmYGTuS3QlmYxWErJKVyoj3pUdLkF7ZkHharyybpOe5flY4UbIsRam7oZtU0mrPkscuCOCzlKxEmfd6LqRl8OH+8uuy9k0Iu2CtSVZsIsWmBw+QTjpvx1AKkmR1ldEjCyAzapGG5ma6rcRnuXDU1STG0KGDB+CeL4gdXvhpUcNnIWsV9KAoik2yvLSQSBuEfC4WtwXLfj+VNyTO1mRVki5omiYJ+/lTOFlQWmmdIDYmntlBbRT21UlWHTVElmQFUBXVTvAxYpaSpYgJlRO7IGTrslJWgpJZJ1nVhZ6BW98PT/0aFJXxc37AJY8swTDhdSfO5TUnOqvDGkuM8b0nvwfAB9d90H5w1xLpvj72f/jDTN53X/aHlpKlTBxggdXwdM9wZTHula6SFcJI3GpwqBuYKOAW1zTB9qxdUJtk8HDHuOfpkSVJVrgKoRfpvXsxYjEUrxfPokX2MccqVrJUzOhwNpmgyhhLWSu3/q6aHD8Xsi6rnKbEdkJcfPYJi7c/c4CMIn733Mb8pLKSuqzVXmE9SvsTaC6Hj/V4cSUrasW7SyUrORrhMw9fy0vu+Q2k0zS85MUsvuVmAiec4Pg8i6GQkqUoim0Z3DTsvF/WbEIvIEfJSoGJEyVrpl0QskpWvoTBZRbJ6p9IFEz/7I0KJWtOwxzSVjhOIbugz1ayKg9pyQ2/KCcB1jANuyar1nbBx+7azb2/3MyWf5dvaSwEu0dW2XbBMQC05paskiVJlmUZ7Hr065AYg87VcNI7puyfS7IgmyyYSolr4/h5Yed973Lgr9QuODerZE0myrcLpnsPYExMgNuNd8mSGa/bjYiL1IJOR9TqIxZUR2Df7JplH2rUSdZRhly7IGCvnBAXqzDSP+7YLmgpWSm3VLLq6YJVg56GW94Dz/weFA39NT/nfU8tYSiSZHlniM+/arXjQ33vye8xnhznmOZjuHj5xTU8aQEjlWL/ZZczedfdjPzvz7IvhLpE5LORYXWTeCiVW5dVOyVrDICwbggVSy6JB9psJUtxTR7emqw8yYIAo5ZdsBrJgnIV0btsGYrLZVtWym5G7M1ONsxUSoR11AARXdT39QTn1OT4uagkxr2aDYn/8Ng+VJe47tv9M5UsKD9hEKDDEJ9dxFtGOIdtF8w/2ZGLIIZb3Dvt//grp/ZvRNdcdH7608z9/vfRwmHnv68ECilZkLUMltOU2CZZ4QpJlqUKmSbomrdiu2AxJbTR52ZOWDzLN/fnvyZtJSvYTcqyC+brkwW5vbIqV7LWdqzFp/kYig+xY2yH4/0Oxg6SMlK4FFd2XlIjRKyecNEyCUQxDFTQIwum1mTJ990fFep8V5OPNcpOluyzmg+f83XQps7NYuPTemRZjYjHJsScbF0FVkGoPPjC3dUJmopbB2VkvOxWK0mrCbF36VIUz8znmbwPnNZjAUTlZ3T66+G875R1PocbdZJ1FCG3R9bcZnEDdgW70HQTJSMG34xh9b5yqmRZZCyjyQj3upJVFWRScOM7RGd31Q0X/YLv9h3LQzuHCXg0fvDGExxHsj43/Bw3bhWJRJ865VO41Nr3iRj40pdJPPsskO0DAoCqgZVquSpYWa8sWXdTbZI1nrJiYQ0dxZ2NxSbQatdkuV0Th9cuONELqUmRLNiSXeUbsWooqtEjKzf0ArI9jSSRcwrVl61NMHRqYhk0TZMk4rjzm2pPslbZJMv55KFaNVmb+iZ4Zv84mhVD3OZvy7tdJUpWKGkRQVc/Sd3h9W0HX+RXsiZTkyiGyTFWwhk67A+28fBHv07Lm97oKKinHMjWCtOVLMg2JXYafpE20uwYFwShUiXL5VZtVTDtCqJHo8WvGWkXjA5CKkuQS10/dvhFgabEskdWT0MP6aRUsgqQLKuBcqLC4AsAr+ZlXcc6oDzLoIxvnxOaU/NnlIyoz9TALtjZOPuaLEmyOkMePue+DgUT1lwEC06fsf90JUs2Ij4wLL7LcpoQ50IeL1YmyVJcLlxd4n20jum2ou0Udj1WnibEUGaPLAu2knXqa6C7smbnhwt1knUUYTSWJmY1g5TdxLuCXfhy7qF0RjygCq10TYf0dmesPll1u2AVkEnCDW+BTbeD5oGLf82/XKfy/XvFyuqXL1hjr1aXgmEaXPXwVZiYnLPoHE7qOqmWZw7A2M23MPb739v/10em2VxkryyP7JVV3jVTCyUrY2SIWEEatpIl4fLQqonVYu1wkyxZj9WyxO6RArk1WbMPvtj92L0AJBaLB6W0C04kMmWFlCguF4pbnI+ZUWoSfjGZzIBLXEdLmp1ZZ2eDZZ0hNFVhNJamb9yZal+tmqw/PCb6J3U2C0JdiGTJsWHnYMRxT7dYv/DajfoG2D2+29kJlYhwj/bt59O/Mzh265g4dus8LnvBf+Fann/yNGsUSBeErJK1dXQrulF6Yr1nfA8ZI0PAFai4LYCiKNmGxO4AZDKYxfpI+ptB9iwc22f/WF4/+eyCUDr8QvbIyg2+8BRoWO8Lzi74QsKOcj/gPPziUIZeJC2SlU4ZVTtm/3j5SpaRStmhY1oOyRqIDaAbOqdN/oUT1O3EFT+89PN5jxG3SJZ/ml3wwLAge2vnhst/M2SDL9IJnUyqPDLqkeEXY2bZtv7c0KV8kPeB0/j2VCJjk2nZrPloQp1kHUWQVsGOkBefW5Cj7mC3TbIUj4eUNeg4tQvKmizDin6v2wVniXQcfvcG2HoXuHxwyW8Z6H4B//W7pzBNuOSUebx6nfMV+zt23MHTg08TcAX4yEkfqeGJCyQ2baL/c58DIHzJ6wHQx8cx9ZxB2iJZc1TZK+vw2wXtqFkTGo1pJAtolZMf7TAHX+Spx4LcdMHZPUQSmQRsEiv4NypPAiINTmKiXMugv7bhFyORbI+sBY21J1k+t8YxFolxahm0a7IKTJKdIJUxuOVJQbLCIbEoUYhkzW3249FUkhnDbtlRCgO7xHsZCO12bvEqEuEe+df9+N/536zZY4Ii7pcD7YuIu322MlptGLImK49CtiC0AL/LTzwTt2PCi0GGXixtXjqrNhdZkiXGE72UZbB5pmWwlJJVLPwiqScZiosedT3BHtsuWDhd0Aq+mEVNFsCpPaIu69GBRx034bZJVuMhIFmWUlcueSiEeEpnwqp3K4dkyXosNA01FKLd346maOimztDoTtZt+Q4Av/G9HhrzWyhze2SljbQ9zpjpJua3BGhtKE9Zk/D4XXaLnnLVLFmX1TFO2THuic1TnRTTUW4j4qgVeuH2aY7ntUcS6iTrKEJusqBEV7ALnzVvUgMBUnFrpatMu6ChisldPV1wFkjF4Levh+1/A5cf3vB7MotexId++yTD0RQruxv5zPnHOj7cZGqSbz3+LQDet/Z9dARqm76mj4+z/0OXYSaTNJx1Fp1XXileMAz0iZwJqUWyOirslVWL4AvZrNNleHDBTJJlrZrpWpLBycN4jQ9aNSXtU0lWtdIF//XojYTiJhkVfpt5iG2j23BrKg3WynfZMe5e8YA3a0SyDkaiKFaNUi17ZOVCWgadhl8Ui+B2ins2DTAaS9MR8pJGTFoKkSyXprLIShPb7iBhMD6ZYmJQXNMHG/bYNrmSiFk24By7oJlOc/Ab32Dfu9+NNh5hdwf8+7we6zWhNDVVoVl2PkgrXr4af03VWNa8DHBWlyXrseQ+lUKGX+ghcQ0YkRLWKRl+kZMwWCz4ArJK1tb+yRl2RFmP5Xf5CXvDdvBFocmmHeE+i5osgBXNK2j0NBJNR9kwtMHRPtIuOC9U+x5Z1bYLHpwUi8s+t0pjGRN5fcyqxwqHUVQVTdXsMLK+B76BJznMDqObnyRfVvAYuXbBodgQJiYqLkw9wLoKrYIgFisCdl1WuQmD4p5vHy9PycqMjpI5IK5Zb5XsgrZVsKkysnm4USdZRxF6p9VjAXQGOrNKVsCfHYTLjHA3rD4i9WbEFSIZgesvgp33if5Mb7oJFr+A7/xtG4/sGiHo0fjBG9bZCqQTXPPUNYwkRljYuJA3rXxT7c4dEfvd+/GPk96/H/e8efR87auoHg9qSEwA7BU7mNEraySaYjLhfBCvhZIlB25PxpoA5tZkAc2BDlTTBAWG4yOObVhVR57QC8hRsmZJsp7+hyiw3tupknbBD576AZCtyyo7/GKKkjU0q3PLh50jvSiKiWK6HdtHZguZMPjcAWcrtLl2L8OszJ50w2PCPvaaE+fatsNCJAtgSYcgWTsc1GUN7BaTILU5TcoVd6Zk6WmQK9SWXTC1v5fdb3oTw1bQzcGzT+C/36KR6RHKn5oR98xs1dZCMOU9WSBJrZyEwdmGXkjI8ItMIAyAEXGaMJijZOVcP/lquha3NeBSFSaTmRnKpV2PFexBURQ7wt1dIsK90mbEEpqqZaPc+5zVZR0qu6BpmDl2weqQLGkV7Gr0lVVrmBt6IWHXZW25E4DPZt7KwZhZsLm4TbKaPHbohctsAtSK+mPlotLwC49UssbKU7KSW8TzzT13Lloof2uackmWDAYJho8+qyDUSdZRhenJgiBWf33WCqPi99uDT7npgqZUsmJ1klU2EhPw69fA7n+BJwRvvgUWPo9/bB3kB/eJvi5XveY4Frc7q8MCMUn47ebfAnDlKVfi1mqzeiwx9KMfEf3HP1G8XuZ+77toTWIiqjULSV+u2AF2ryzXZC+tFikoxzJYi+ALqWT5DOu6n6ZkaQ3thC0/kqFOMl4m2agKCiQLQnXSBQ9EDqBv2gpA90lnoqBwz957eG74uZxeWeWGX1i1mpnaKFl7J0U8tYeWqgcpFMKq7vISBmXUsG7qZVtnQEzg/rFVqL7nr221C8mLkayl7c57ZUmrYHi++K4ckay4vJ8V8IeJPPAAuy64gMTTz6CGQsz57nd57u3PI+1W8PnFCrKmi+dMreyCkr+qBa4DWZflJPxitj2yJKT9TveL8dCIlPg+mmeSLHn9pI10XlXA41LtsJPplsHcHlmmadp9oUo1I07MsiYLYH2XVZfloCmxaZrZHlk1tgumEhmRqQ9kqlSTNWC19eioMFnQFc5a32ySpSmYK8/nEfV4AA5O5Lep2yQrlCVZ6Zz49tmg4hh3q1dW+7jJeMr5mFesCbFE2UrWWNZOeTSiTrKOIkxPFgQIuUM06eLiy/hc2YjXMvtkoYrB2ShW2FvHTMTH4NcXwr5/i6Lnt9wG89fTNx7nw78XdVhvXD+fV651XnxtmiZXPXIVuqnzkvkv4fQ5MxOJqonIv/7F0PevBqDrM5+ZMkDKFbop4ReWksX4fua1iGuxHMtgg1tMKKpJsqTP269b1/M0kiV6ZckY98jhqcuaOADJCRGB37rU/nEirRO1VmRno2TdtuM2lh4Qk47Fp76McxefC8DVT15tqw/lNyS2Ukd1BaLVV7J6J8VKfVDLH2deC0i7YO9Y3BHpdKtumqyavkosgzc9sR/DhJMXNhNqsGxJmo+gu3CD0SUyxv1g6WSv/p1iErTwGGFT2je5j5Re4n3ZjYjDoGoMfOnLGJOT+NeuZdEtt9B49svs+zMQEM8XjzWfDftrpGTZwRf5X5cJgxtHNhZN+Yumo/RGBHmvll0w47MU/ckSJEvGuOfYBb2a1x7zyg2/kO9jTsMcQbCst13QLlglJQuydVlPDz5NLF18fB+MD5LQE2iKRk+wsqARp8h9b9VqRnywwvj2jK1kZUlWd0zcj30eL8rZX7abG/dPzJxbpRIZ+z0EmjzZHlnJEB5NtceqShGwwi/KjnG3lKy2CZiIjTneL7FpIwDeAqEXUIldUCpZdZJVR42RryZLURQ6FTEBSHk026vsNF3QbdVqKFbkaj1dsAzERuBXr4b9j4pkqbfeDnNPJKMbXPbbJxmJpji2p5H/d96qsg77591/5tH+R/FqXj528sdqc+4WUvt7OfDRj4FpEr74YsIXXjDldblCNyXGXZKs+ChLw+Kf5ShZ0i4YSVev75JUsoK6NaTlIVktdkPiCIOHg2TJ0IvWqcmCkvhoqlJWPUAuDNPg9q23slg4OPEft4b3r30/mqJxf+/94N0FiITScmArWbqSnZhXEYNxccJhd23rDXPR5Hczr0WMoRv7HIZflEiIKwTTNPmDZRV83Unz7BCDVn9rUeXOjnEvoWQZhmnbBZcun0PIHUI39dLhEDnx7WYqRWr3bgDmfO97eOaKVWxJshoaxGflQUwYQjUqPpd2wUKfy9LwUlyqi8nUpG2jywdpFezwd9jkuFLYwRce8X1UYheE0nV9ywuEX8imtt3Bbnsyrijg8uSfusl0QT1tzDoUYn5oPl3BLtJGmicPPll0W1mP1R3srrnrQrp1oHrBF1m7YGXx7TbJSkbo3vFPAPo6lkF4vk3c8pEsSX5cHhW3V7NJlpluYlVPI16X8/KCfJCJhfGJ8sZ9V3s7hqbiMiA54Lzhc7KEkhVLx4hnxByzbLvgUZgsCHWSddRA9MiaaRcEaEesdiQ8lpRO+XZBRbECMOokyxmiw/DLV8KBJ0Xh+FvvgJ7jAfjGX7by6O5RGrwufvCGE8qqw4qlY3z9sa8D8K4176o4ftgJjGSS3ssvRx8fx7dmDZ3//akZ22gtllUqtybL12hHFa8KiElBJSRrIjVRdqPDQpBKVoNuTdCm1WQRaJ2mZB2GhsSSZBUIvWgOuCu2zD3a/yjs6cWXFrZhz+LFzG+cz6uXvhqA/dwCwHiZdkHFbylZNbILjiSFPabV11X1YxfDsd3i+i07/KLMGPdHd4+yezhGwKNx7ppum2QVakQssbhdLBKMRFN2vV4+jPZHSSd0XF6N1p4gi8OLAUqHX+TEt6f27QPDQA0EcHVkz0uSrFCDOBcFhTafG7VAzdRsIYeCfBHuAB7Nw9KwUIA3Dxe2DG4dFZbZ2VoFAXxSyXKJ8aSkXVAqWYlx4XKwUCqhslDCoIxvn9Mwx15AdftcBccJt1ezP7/ZJgwqisKp3ULNKlWXtW9SLCQsaFwwq9/pBKkaKFnSLlh+I+IxIIdk/esbdEXEGNHvE8S8yzrmQJ6WETGL/AQaPSiKYvfIMjKNs7YKQo5dsNxeWZpGol1ck+aBfkf7GMkkyZ07gSLJgknxnPaonqJKfi7qwRd1HDJc+/ZT+NZFa5kzjWS1Ih4AUZeR7aNRpl1QwwrAqAdflEZkEH5xHvQ/C8EOeNsfoWsNAPduHuBH/xATnK+99jgWtjkbSCR+8sxPOBg7yNyGubx99durfuq5GPjiF0k89xxaOMzc734HNU93drsmK1fJgmyvLO8YUF6vLFmTlTEyJPTq2FOlktWoSz/NtPq3HLug6oowNHkYlawC9VizCRS4dfutLOkT791/7LEomrif33vce3Grbob0jWiB7WUHX6i+2gZfTGZErVJ38NAkC0oc21NeXValDYll4MV5x3UT9LpsklWsHgsg4HExJyw++2J1WbIeq2N+CFVTWRIWDa5L1mXlxLdLFcuzaNGUybtUmkP+kD1xb/PWTqXIKlmFt5HhFxtHNhbcxg69qALJkva7tCYmyiXtgt4GCFjf7dhe+8eleq1JJWvHYIRUJltnJBW77oasklXMpaIoSk74RRXqsrqd1WXJ0ItDkSw4VcmqUk1WBT2yYFrwxdB2ePBqujLie+q36quK2QVjVp2W3YjY2sfMNM0qWVBCHrdcuyCA3ikWltR+Z+N+cus20HW0cBhXZ2febUasxZ0Wv/MaXBnhXg++qKOmUBSFUxa1cOEJc2dIyGFD3MQTruxF6zxdUAzImmKRrHrwRXFM9sN158LBjdDQJQhWh3jw947FueKGpwF462kLOGdNeRPH3eO7+cXGXwDwiVM+gVer3crN2I03MvaHG0FR6PnmN3D35FfM8tZkgU2y5sleWcPOu8L7XX77eqtWXZZUsppksx3PNCUr2JZVsrTJw1OTJRsRT++RJZWsCuuxJlOT/HXPX1l6QExSfWvW2K91N3TzumWvA8Db/peiqkg+qD4rwr1GSlbMFA/wOaHa1nFMxyqbZJWXMFiOkhVJZvjTs8Jqc9FJYvKZaxcshWxdVhGSZdVjdS0W72dJk1OSZd3PgdYsyVq4cMom8t5s9IZQLXtaS4EmuNWATbKKKGWyLqtY+EW1Qi8gW5OVVqw+kqX6ZEFWzcoNvygR4z4n7CfkdZExTHYOie87baRt+9iUHlkFkgWnn3M1SJZUsjaPbLbH2HyQ9tRD0yMr+76qlS44MDk7kuUKN8NdHwcjTff8MwGh2sQzcVvJ6s+nZI1PDXUYsO2C1VKyKqvJAjC7hYXbM1D4e8+F3R9r1cqCBKrceizTNIna6Yt1JauOw4RGXUzOxq3rWtUUNJezr1auimnWpVAPviiC8V649hwY2gKNc+Dtf4J2UVid1g0+dP0TjMXSHDe3iU+dWzhdJx9M0+Qrj3yFjJHhzDlnctbcs2rxDgCIb3iO/s9/AYD2yy+j4XnPK7ity1KyMmP5lax2q1fW/tE4usNYdEVRqh7jLm0Isu4qf/CFVZN1OIIvapgseNeuu0jqSY4dFA8h/3Frprz+rjXvwqV40QJ72Zd4vKxjK7lKVnwU9NkX1EsYpkFGEQ/dxeHaNyLOhYxx3zEYLRitnItKGhL/6Zk+YimdxW1BTlwg7iOnShbAEssyuL0YybLqsToXifcjlaydYzuLH9y2CzaT3CXq9aaTLJmE1+BuwHSL50Ozq4Ykq4RdELIJg4Vi3E3TrFqPLMjWZKVNq9Yp6qCOVCYM5oRflFJCFUWZUZc1EB3AMA08qodWf6vdnsVdohSgWg2JQVynS8NLMTF5pP+RgttJu2Ct49thavCFnjZm3Y7DNE0G7OCL8iby8rmoRbfBjntA8xB6xdcJWPbSgehACSUr2yPLNE2bVDe625jfEpixfbmQSlaszD5ZAK4esUjsd5BwCtl6LO+K0smCThsRpxO63Qutbhes47ChISMG1XFZ8+8v7NmeDrkq5paXQjKJqVdndeg/CmN74bpzYGQHNM0XBKt1if3y1/+8hSf2jhHyubj6khPKLlj9+76/88CBB3Crbj5xyidqFmetj43Re/nlmKkUDS98Ia3veU/R7bN2wbGpL1gkK5jow6OpZAyTvnHnKmi1SdZYQpxfq249TKb7vf0ttpLldo0f+pqsyT7Rl2hasiDAiBW3XKmSdev2W3FlTHr6xXvKVbIA2gPtPL/zVYCozSqnDi4bfGGND3Fnq5pOMBQfAkXHNFUWNx9aJauz0Utr0INumDPqYPLBVrLKsAvekBN4Ie/nckjWUqlkFZjkpBIZhg8IBblzkaVkWSRrz8Qe0kaRiVU+JWvRoimbSLtgo6cRw3JJNM6yEL8YDLO0XXB583IUFAbjg/ZnmYuDsYNMpCbQFI3FTYtnfU6SsKSs1hBGKbsg5IRfZO2CpZQsmJkwaIdeNHSjKmo2ObhEqJUMv6iGkgWUrMsyTTPbiLjx0NoFYfbhFxPxDIm0WIArW8kasUjWc9eJH5x2KUrbUtv+3BftywZf5FOyJrM9ssaSY6QN8f+1PfOrMgeQNVmJyVTZZNQ7TxDm0LCz53pik6VkOUgWdNoTUSYLenxaSQX3SEWdZP0HIJARX+OYle/qNFkQsv02XCgYVnauWVezpmJkF1x7LozuhuaF8PY/ir8t/G3jAD/5p1g5/vpr1zK/tbwVqEQmwdce/RoAbz32rTUrHjYNg96PfZx0by/u+fPp+epXUNTiQ4DWLIMvpitZ4mGqTvTaQSyVhl9UA1LJapMTy+lKluai1SUmrYoWYfBQ12TJeqyWxeCauiIngy9aguXXu2wb3cazQ8+yZFBDzRho4bDd4yQXFyx+E6buIaXt45699zg+vh18gTX5qKJlcM/4fgDMTCMdodmv2pYDRVFyLIOlr8FS6XDTsWMwwmN7RtFUhdeckP0+nAZfQOmEwYO7J8CEUIvPXuXtDHQScAXImBm7b1Fe2CSrhdRuobjkKlmmaWaDLzwhZGeEBq2GEx0HdsGAO2CPj/ksg9IquKBxAR5t9jUcMvgirSuYOAi+gLx2QSc1fdPDL2R8u4xET5doRCxRTSULKNmUeDgxTCwTQ0FhbkPtFelUbDrJml1dlrQKNvndZYVUmaaZrclKHRDulud/FICuBqtXVrTfVrIOTiZmEB1pF/SHsvHtRibICfOq09LC1+C2zhWSZfZOC8xbCEB4tPSCpGkYJKxGxFXtkTV+dFsFoU6y/iPgTYkbN2nFsDsNvQDw5HjsdasGqG4ZzMHwDlGDNb4XWpbA2/6UfYgiGkR/5A+iDuvtz1vIy1eXn5J27YZr6Y300hno5N1r3l21U5+OoR9cQ/Rf/0Lx+UTD4cbSPTjsmqwCwReM76uoV1Y1laxEJmHHwnZaK4EzSBbQalkUDFecwcghrj2U9Vjty2e8NDKL4Itbt98KwNlxoWD4jluTdwV0Xrid1MgZAPzgqR+gG85Wf6WSZWA95KoYfrF9RJAAM91Mo6+2sc/5UE5dlj1JdliT9YfHBIF8wbL2KQ1OK1Gy9o/G81oa+63Qi87F2ftYURRbzdo+tr3wwS2yrBt+9CFxTp6F2cWdWCaGYXUHbvA0kLIuqWChJlZVgJx/llrAL2YZrGboBWQJi2kq6JoPvVSEO+S1CzpJp1zeJb5HSbJkI2KZMOs0OdhbZSXrpM6T0BSNvZN77bTDXEirYHewuyrEthSmK1mzTRjsH6/MKmjG45hJsVjn8hrwsi/az52ugJgH9EX76Ah5URRI66ZdfyuRaxfMhl5Upx4LQNNUW9kstyFx0wJxD7VMmKSSxZ/t6b17MWMxFK93hu04F+U3Ij66Qy+gTrL+I6DExYWoWwlITuPbATS3iqqJp1rMaphYj3G3MLhV1GBN9ELbMmERbMquSqcyBh+8/knG42nWzgtz5SvKq8MC2D+5n59t+BkAHz35owSmR49XCZF//IOha64BoPtzn8W3orCknwtZk2VEIhipnEHaJlm9LGgW1105SpZMGKwGyZLJgpgqLYalUOUhWS0Ba3VQMRmJjVctPt4RpJLVMfMaySpZ5T1I0nqaO3feCcCJI6Imx796Td5tmwMeUiNnYuo+to9t5+7ddzv6HbIZsWmTrOopWbvGBBFxmy01iwUvBlmX5UTJylUiSl03Gd3gpifEe3vdSVn7lGEadrqWk+CL1qCHJr8b04SdgzODZWSyYNeiqb2g7ITBYjHu1nmkRsRE3NXejtaQTeSU96VLdeHTfCQVK7mS2n1PToIvIJswuGmkCMkKV4dkuTyaXd+cdgUc2gUXir/H9tqFZk76rC3vFAtPvWNxJhLpbLKgZT2TycHuUnZBixgmq6RkNXgaWN22GsivZkmr4KEIvYCZjZZnaxccqLARsVx4VFQTZenz4Nhsj0n5nfVH+3FrKq1BMX5Otwza6YJNHnaNiu/bTDextkokCyoPv2jqWUjKBaoJY3uLLNiQtQp6ly1DKVK3WW5NVuwoj2+HOsn6j4ARE5NbXbOaRpahZEF20I5bsdf1hsTAwEZRgxXph45VIkUwNFWl+spdm3l63xiNPhdXX7IOj8OwkVx8/dGvk9STnNJ1CmcvOLtaZz8Fqf376f34J0TD4UteT9OrXuV4X7WxESxL4ZS6rFA3KCoYaZaHxPVSTox7NZUsSbJMPUiDUphkuQNtNFp1WRllgol4dSYhjlAgvh1ylKwySdY/9/+TkcQIbf42mnaKABLfmtV5t230ucDwkxoWgSrXPHUNGaP0+7cj3K3C/2qSrF5rVTyg5qg6z9wA178exopY3aoEGeO+uX+iZGiLXHlNGSmi6eJJmv/YOsjgZJLWoIcXrcg2WR5LjpExxWfupCZBUZSCdVmmaTKwSyhwsh5LQiYMFg2/sOyCKeu4BZMFPY0oikLMIgu1nOpI8lqKcBdLGKxmsqCE3ZDYHXBoF7SIdTpq3y8tfnH9RNNREpn8TpGmgJtuy1q2tX/SVo2kkpV2WJMl0wUTDpSs3Lj4YpB1WQ/1PTTjNRnffihCL2CmQjfbhMGDFfbIyjz7ZwA0r4Fy7jemSLDdDdmaLMD+XnNJlmmadpPgQKOHZwfE59jgaqXJXz1lPxt+UR7JcmkuhpvEs39ib/G00kSJJsQSMqHSuV1QktA6yarjMEKSLFO1lCyH8e0S0uMdt8IC/s8rWf3Pij5Y0UHR/+qtd0JDx5RN7t7Qz88fEKlc37zoeNsyVw7u772fe/fdi6ZoXHnKlTUJuzASCfZfdhnG+Di+tcfReeWVZe2vqCpaOAyAnpswqLnAit1e4hkDyotxD7mrR7Lk6piRCeLHIln5FMEpCYOTDB6qhEHTLEqyKk0XvGW7aDB8Qc/LSVlNIP1r8itZLk2l0eciNXI6je4weyf3cseOO0r+DkVGuMuinGj1SFa/NQEJuXLurfu/DVvvgt+8dkoz11pgUWuQgEcjkTbYNVR88ux3+e3EsFKWQRl4ccG6OVMWXqRVsNnbjFtzNokqlDA4MZQgPplGdSm0zwtNea1kQ2JDtwNMUv1Wc9ACJKvBcjdErdYIbqOWSpb4u9Q4KJWsfZP7powfaSNtR9dXlWRZdqu0K4DuhGS5vGIRCmzLYMgdwq2K4zgNv5hOslJJK12wRIx+tk9W8UWU3z6yl2M/czff+suWkupsbl3W9G1l7d+hUrJS04MvqmQX7CqHZGVS6Pd8D7DCoaY5FHKVLMgSuNyEwVQ8g26R3ECjh50jVuPpaYu5s4UMv5CErhyMtVgEbc/uotvZ8e1FQi8gO3aWG3wRbKrbBes4jMiSLEvJKsMumLt90iNJ1v/hmqwDT8J154kVyJ518JbbITh1QNg7HONjN4o6rHefuYiXrsrfeK8Y0nqarz7yVQDesPINLG1eWmKP8mGaJv2f/wLJjZvQmpuZ+538DYdLQWsp3pB4ruyVdZiCL2SyoKkHCGJdu9ObEcPUXlmHMsZ9sh8S40L5a535PY9UYBc8GDvIv3r/BcA5qRVgmrh6unG1Fa71CQc8YHo5Z/4bAPjh0z8kpRdf3bSVLMN6VFRRyRpOiglIq9e6f0wzm8g2uBl+/ybI1O47UlWFld3Owy+chBcMRZLcs0kUsOdaBaG8HlkShZSsgd1CxWqbG0JzT32MS7vg7vHd+dXKxDhYIUmpXnGuhZIFbcXZum80vXYWWzl5L1X2FfaF7Ulsrpq1d2IvaSON3+VnTsPM8JdKIe13GVcAMxbDzDhQwO2Ewd2AII5Orh+bZPWN2xN0+V6c2gXtmqwSQQe3PNlLWjf53r3b+cgfni6qaq1tX4tP8zGSGLHVQok9k4JIHopGxJAlj5KLp2cbfFFJfPu/r0EfFN+PNm9mqwBZk9Uf7cc0TbosJWYgh2TJGimP34XLrdEfFTVZx7RW79oF8M+iIXHECvFK9e4vup1tFyxShmCaZtk1WbZdMFxXsuo4jJAkC6X8mizIKllJa/XfiDufLP9HYf9j8ItXQWIM5p4Mb7kNAlMHg2RG59LfPsFkIsMJ88N8/OXOapum41ebfsXuid20+lp5/9r3V+HkZ2LsD39g/OabQVWZ861v4u4urzmyhCtskawCDYllr6zRWJqJhLPVsgaLBFVDyZLJgoruR7VqR2Y0IwZLyZINiQ8hycpNFnRPXS2Np3Q7PjgccG4RuWPHHRimwbqOdTTvEpP3QvVYEvL468Ln0u5vpy/ax03bbiq6j2qlC5oZa0ZTpeAL0zQZT4vrpsNvrdzGRyFlkQlPA+z+F9x2abaBUg2wqhyS5aAh8a1P9pIxTNbOC9sTZgk5uXYSeiFhJwxOU7IGdsp6rJnhNd3BbvwuP2kjbYcSTIEkyt4mkntmJgtCTo8s6z4dt+4bNVNDkiVrshwo+nZdVk74RW7ohVrFgI5cuyCAEXWg2MvwizJj3GXC4HMD+8mYGVyKy06idBrhbtsFi5CsRFrnqX1jgCArNz/Ryzuue7Tg+O3RPJzYeSIwtS7LNM2sknWo7IKWkiUtZNWqyepwqmRNDsA/voaeFNeYq3VmEmBnUCwcJfQEY8mxvA2Js42IPRiGyWRG3JfH91Q3XThg1WSVaxcEiHeI8cXo7Su4TWZwEH1wCBQF3/KZwU4Su8Z3kTEyeFSP4zHQDr6oK1l1HE5IkqVQmV1QDtopyw7zfzLCfe+/4ZevFr2M5p8Gb7oZfE0zNrvqT5t5Zv844YCb77/hBNxa+bfQQHSAHz39IwCuOOkKe7W4mog/+ywDX/giAO3/9V8ETzut4mPJXlmZAkqWN3qAVkuFcZowKIMv5Ir5bCBrstx6zmpXPrtgoHVqQ+JDFeNezCpoqVhuTaGhhA1IwjRNO1XwgqUXEH92A1C4HksibNkRY0mV9xwn+qP95Jmf2MmM+WA3I5aT6yopWePJcTKmGGfmSGuVnJAG2+GiX4qeYs/eAPd+sSq/Mx+OrSBhUIZXTIdpmvz+UTHhvOikmVHWg3FBKsshWVLJ2jUUnVI3li9ZUEJVVBY1CWUqb12WVY9l+sN549thak1WMqMTkU2+07NTDYrBtgs6CEFZ0TqzLmvr6FageqEXEpK0ZHzis9YdhV9YhCO3IbEDkr68U/yO7aPiXugMdqKp4vmcTjpLF3RiF3xm/zipjEFbg5efv+1kAh6N+7cPcdGPHsrbzwmylsF/9/3b/tlYcozJtLhW5oZqH99u6Iat6El1Y7bpggNW+IRju+Cuf0I6SsYliJQWnhni4NGyRGJKr6xcJWsyS7J2DkUxtTEATphTXZJl2wUraEic7hDvTekfLLhNYrOIbvcsXIgaKFw2Iev51nWuc2SXNk2zXpNVx+GHaRiYFslSzUqVLKvhosuaUP1fswvufgB+dSGkJmHhmfDGG8E3c/Lyp2f7uO7B3QB866K1zAn7K/p133z8m8QzcY5vP57zFp83mzPPi8zoKPsvvxwznabhxS+m9d3vmtXxSjUkZnx/2THu1Qy+kMW0bt1a7XL5Qc2z0JCrZLkih64hsZPQi4DHcU3eU4NPsXtiN36Xn5ctfBmJZ54BCtdjSYStYuqxWIoLj7mQnmAPQ/EhbthyQ8F9VFmTJSfXVSJZMjnNyDTQ3mAtMoxbqkt4Pix9MZz/XfH/f30DHr+uKr93OmTC4MYDEyXrUkpNkp/eP862gxG8LpXz185srlxOfLvE3OYAHpdKMmPQOyrIcCatM7RP3DfTkwUlloaFLTVvXZb1HWb0sHh2aBqeeVMnyJFU1i44Hkvb6YL6LCe0xWA6aEYskS9hsBahF5CjZAXEZ21Ey2lIPDPGvZiStaQjiKYqxE1xrch6LMgqWSXtghYpTMYzBRvQPrJLXAPrF7XwwuUd3PDe02hr8LK5f5ILrnkgb4NuGX7xWP9jdqNrGXrRGejE53Je0xRJZvjlQ7vZ6EBBzoX8DCCrbsxGydIN067NdRx8Mbpb7KuK71M+H6cj1zIoe2VNsQvmKFmP7hlA0cT93dNQm5qsciPcAcxuodK5Bwo3oXfShBiyCqi8jkohndDtHmj1dME6DhtyVSfNIlkub3lfqxy0MzbJ+j9kF9x5H/z6NSIJavEL4A03gHdmPc+e4SifuFFMZt971mJetKL8OiyAR/sf5a5dd6Gg8Kn1n6qqrQXA1HUOfPRjZA704V4wn56vXDXrQI3CNVmWB398H/MtkuW0LqsW6YJe3VpcyJMsCEypyVIPZUPig6WVrHLqsW7ZJgIvzl54Nt7JJOkDB4RV49hji+7XHJAkK41H8/C+te8D4GfP/qxgYp6tZKWsVfEqBV/IHkBmujn73mWioLyuTngznPUJ8e87r4Btf63K787Fsq4GXKrCaCxNX4EVfAmZEJevpsYwTH52vwjCOWdNd96+X5WQLE1VWNwmrmdZlzW0L4Khm/hDbkKt+SeGi5us8IuxPCRLxrfHxXE9c+eiuKeeb27wxVg8TdIaQqaHDlQTTiPcIUuydo3vstP6pF1wWfPMGpnZQJIs3SvGLGOyjF5ZOXZBJzVZXpfG4rYgqnsMyAYoAKQd98myXjcLf18P7xLXwCmLxDW9ek4Tt3zgdJa0B+kbT/DaHz3IgzumWoOXtywn7A0Ty8TYMCTUcxnfLhtEl4Jpmtz6ZC8v+sZ9/M9tz/GJm55xtJ+EVOdcXg2vlaI8m2bEw5EkumGiKtDW4HAMturs9LS4ZwqRrNyEQamS5Y4xuT2y/r1XKM4aHtvlUS0EZlGTpc0R78E7Gp3awiUHSSv0wlskWTBjZHi0/1HAOcmSKpbHp5VswH0ko06yjnJk67EU3KaYECVd5ZEkj3UBZ6xmxOb/FSVr+9/g+oshE4elL4VLfp+3lieR1vnAb55gMpnhpAXNfPRlhX3HxZAxMnz54S8DcNHyi+ymmtXE0A9+QPSBB6yGw99HC83eiuhqLkSyskrWAqtAds9weSSrGsEXUsny2SSrgGUh2E6LkU0XPCQ1WbnJgh3FlSwniKVjdo+rC5ZeQOLZZwERXFDqu26yfockducvOZ8FjQsYTY7ym02/ybuPXZOVsqwm1Vay0uEckmVNSGUENsALroS1l4Cpww1vhQNPVeX3S3hdmm3JK1WXVUjJmkikec+vHueOp8V7esP6/LUpldRkwcy6rP6dMrq9qeACigy/2Dle2C6YmrSa1+dpHirvy5AnxGg0RcpSsnKVhGpDColOFoU6Ah20+FrQTZ1to9uIpqP0RnqBGtoFrcU33QnJCueQLGvMcdKQGET4heIWY1pugIetZJWYcGqamq2zzhPjntENHt8jji9JFsC8lgA3vf90TlnYwmQiw1t//gi3PdVrv64qKqd0nQJkLYOy5s9J6MWG3nFe96OH+K/fP2XHpm/pnyStOydJ8v14/S5cXmmjrPyalFbBtgYvLqfWf8sCqifEdao1h/Nu1hWcqWRNJjLErAUr2y7Y5GFDvxj7mr3tVU8ZzqYLpsruDelv7SBhrb+ke3vzbmPHt68oPJ95bvg5IukIIU/IXiAphWwj4qNXxYKjiGSNjIzwxje+kcbGRsLhMO985zuJFIlTHRkZ4UMf+hDLly/H7/czf/58LrvsMsbHS3vvj1joMwdMSbJUvx+/IR4CE2Z579FtrYzJZsb/JyLct9wNv70EMglY9gp4/W9mhBJIfPGPG3nuwAQtQQ/ff8O6iuqwAH6/5fdsH9tO2BvmQ+s+NJuzz4vJv/+doWt+CED3Fz6Pb3l1VnSzNVn5gy+IDbOwSTwYnCpZuc2IZ9sUWAZfBGTMeL5kQQB/s12TpR0qkhU5KIJUFBVaZ07+7Ph2h0rWn3f/mXgmzoLGBazrWEf8GUGy/CXqsSBHyYpbDWhVFx9Y+wEArttwHePJmeOGbEZsJJJiEpyJQ8p5VH8hyHjqKUqWbRfMWRVXFDj/e7DoLKE2X3/RFHWgGljlsC4rnxKx/eAkr/7BA/xt0wAel8rXXnscJy/Mn5xViZIFsGRawqDdhDhPPZa9j9Ura9f4LnRj2iTUIsqpMXHfTU8WhKnpgtOVrFo18c4qWaW3VRRlimVw+5holtrubyfsC1f1vKQylJYtTiIOrv/GOaKmUE+JXouUrumTWNEVQrVI1lQly5ldELLqWyJPQ+LnDkwQS+k0+lx2A2SJcMDDL995Cueu6Satm1z+u6e45r7t9ndu12UdECTL7pFVJL59NJriv295lldefT+P7RnF79b42NnLCXg0UrrBnjJaf8jQC2/AhdtjkaxZ2AUrakRsWUB1i/C5HNgFQz43Qet8Zc2btAu6Am72TYhrpKfK8e2QbUacSRtlE9ImX5iDliM53XtgxutGNEpq926guF1QWgXXd623awxLISrtlEexVRCOIpL1xje+keeee46//vWv3Hnnnfzzn//kPe95T8HtDxw4wIEDB/jGN77Bhg0buO6667j77rt55zvfeQjPusq45X1Ceel9wv6RHXoRDODVhZI1ZpS32ixXvXSpZCX+w0nWpjtEPLSegpXniyJ7V/4b+Y6nD/Drf4sHybcuWkt3U2V1WEPxIa5+8moALjvhMpq8+WspKkVq714OfOKTADS/8Y00nX9+1Y5dsCbL1wSWIrXEIyao5dZkpY00SX12ZEdGuDfo1kwwX+gFgKrR6rYmplrk0PTJGrRqRpoX5SXxI9aDujnoLFlQBl68eumrURSF+AZBsnxrjiu5r0wXHM9Z3X75opezNLyUyfQkv9z4yxn7qBbJwjAwFeseqYKaJZt05lWymqatirs8cPGvRFPwyAD8+rV2n6dqQNZlOVWyZE3N3Rv6edXVD7BzMEp3k48/vPc0Ljqp8Ip+JcEXkO2VJUlW/66sklUIPQ09eDUvST1pKzw2pF1wxIqQzqNkSbvg9JosQzfRaxR+YZSRLgjZpsSbRjZlQy+qXI8F4JNKlmZZZyMOlCzNBU2WCmVd186VrEabZMmaLF037J5KTmqui8W4P5JjFczX+Nnn1vj+Jet41xmCfH/t7i38v9s2kNENTusWAUrPDD1DLB2z7YL5kgV1w+RXD+3mBd+4j988vBfDhPOO6+aej5zFB1+4lGMsgrd1wHn4UcqyC+YqWbOxC/aXS7L0DIyL+ykzKeZJTuyCAJ2yIbH1O2OWinYwnQZN3NPzakCy3F4Nl9XmoVzLYKOnkcGwuEbS+2fGuCe2bhXtQ9rbi7YPkcqnJOlO8J/QIwuOEpK1adMm7r77bv73f/+X9evXc8YZZ/D973+f3/3udxw4MJNdA6xevZqbbrqJ888/nyVLlvCiF72IL33pS9xxxx1kivS5SCaTTExMTPlzRGByADbeBlvvhp++EK5/PRx4MqtkBQK4rML/YeNgWYeWK2OGJvY3Yv/BJGvDzcJ2ZKTh2AvhtdeKSVwe7ByM8EnLM/7BFy7hBcs78m7nBN994rtE0hFWta7iwqUXVnycfDDicfZfdjnGxAT+44+n8xMfr+rxZXrSDLugothq1jyrV9b+0fiUFLRCCLgCdj3abOqyTNO0layQXKQrVJNFTo8i1WAoNl6zVXkbgyJ5KV89FpTXiHj3+G6eOPgEqqLyyiWvxDRNElayoBMlK+yfahcEYQG69PhLAfj1xl/PKMq3SRZgeqzPrgoka9+EmKjktwvmWRX3NcEb/yCavA5tgd+/uWo9tGTCYKkifFvJSgzzjT9v4X2/fpxoSmf9ohbu+NAZrJ0XLrhvUk/a13m5JEvaGbcfjBAdTxIZSYICHQsK20M1VStcl2XZBZMHxfkUJVnuEKOxFClkZ62smlBtyFsx38Q/H+yEweHNNavHgqwqlLYWGRylC0JWkbXsZdNJeiEs72xAsWqyOvxiop7OsWk6UbKKJQxOr8fKB1VV+PR5q/jM+atQFPj1v/fyvl8/Tou3i55gDxkjwxMHn7CVrOl2wUd2jXDe9+/n/932HOPxNCu6QvzuPady9RtOoMcKjFpmXdf5QjYKIVfJcnnE82M2zYgPltsja2I/mDqm6kUfF+NFQZIVnEqyZF3WgE2yxDi8czKO4hYkqyNY+RyjEBRFyemVVV7CYJO3KUfJmmkXTG4WVkFvERUrnonz1MGnAOf1WJDTI6uuZNUeDz30EOFwmJNOOsn+2Ute8hJUVeXhhx8usudUjI+P09jYiMtVeCXoqquuoqmpyf4zb96habBXEqFO+MC/4bjXCz/F1rvgJy/AuPPT4vVAA2pGvK+DmYGyDi0j3E1V3Ij6f6pd8Jkb4KZ3ivqO4y6GC38KBaJEE2mdD17/pD2J+vBLKn94Pz34tK1AfGr9pxzL5U5gmib9n/s8yc2b0VpbmfOdb6NU0HC4GFw5wRczSIlFspozA3g0lYxh0jde+vpRFKUq4RfRdNRuuBq2ah+KkSxfsJ2gtV2aCSaTtSvkB+CgpWTlqceCbCPiZgd2QXkNnTHnDDoCHWQOHBC9y1yuok0gJcI5wRe5eNH8F7GyZSWxTIxrN1w7dSe3GzRrEcZtTSaqEH4hJx5+pQ2vS4PkpLBVwtSarFw0zRVEyxOyemh9sCo9tKRdsHcszlis8EqvVCKi6ShX3ye+13c8bxG/ftd62hqKTwSkxdCtussubF/c1oCiiD50OzaJCXJrT7CkorE4bJGs6QmDsRFMHdKDYpKYzy6Yq2SNxdOggOmyVrRrVJcl7YI4LElZ1bIKENHtMsq9FkqWrMlKI/42ipQpTMG0hEFJ0kcTo/mbRFvw++IoagbTVIjHBRFJWaEXmktFc2BXL9QryzBMHt0tSVbppthvf94ifvjGE/C6VP626SBv+N9HOL79ZAD+svsvtsVYkqz+8QSX/fZJLvrxQ2zqm6DR5+JzrzyWOz90Bqcunvr7ZB+5rQNlkCyLNHqqZBeUqpLj+HaLMBuBuWAt1mvhcN5NZU3WUHyItJHO6ZWVxDRMm/A8NxJBcVktGQKVBWqVQqUJg42eRg5KJStPQ+LERitZsEg91pMDT4r3H+xyHJAC5MS315WsmqO/v5+OjqkM3+Vy0dLSQn9/v6NjDA0N8YUvfKGoxRDgyiuvZHx83P6zb1+eZo6HC21L4cIfwwcftcmWsedxAMx4Vr0aSOdX9wpBRrijWg+T/0Ql66nr4eb3iGYsx78JXv1DYekogM/dsZFNfRO0Bj1875J1zotip0E3dDvs4lVLXsXa9rUVHacQxn5/A+O33ioaDn/zm7i7qm83kCt1ZiqFEZ1mB7RIljrRy9xmsULpOGHQPfvwC6liaXgJmdbEpQjJmp4wWPNeWU6VrBIkK2NkuH3H7YAIvADRCw3At2wZqrf0ap/skzWdSCiKYtcI/nbzbxmMDU55TapZptta0pylkhVLx5hMi8lZ2GON6zJZ0BcGb5EAj641cNEvrB5af4B7vzCrcwFo9LntdMxialbvsAmmGDN8vijfufh4/uf8VY5qNHPrscotbPd7NLtdxLZN4rMvZhWUkHVZM5WsYVJRDQwDJRDA1TGzmeoUkmWRcsWyHNVOyRIky6mSNTc0l6A7SMpI2Svl1Q69gJyaLMOFieLMLgjZhEFrYh72hlFQMDHtRNR86ItZ9YqZRnYcFCSgnHosAF9AKllTSdbWg5OMx9MEPJqt4JbCy1d3c/271xMOuHl63xj/eDoMYAfwtPvb0RQv19y3nRd98z5uf/oAigKXnDKf+z72Qt56+sK8z89lneWTLJmW6PW77TKH2US4y+ALx3ZBWY/lFjZOJRCYovbnosXXglt1Y5gGg7HBrF1wPE4imhaLCgo83j+BWmOSVWnCYJO3iUFrqEntn6lkJSwly7eqMMmyrYJd68sa++rBF1XAJz/5SRRFKfpn8+bNpQ9UAhMTE5x77rmsWrWKz372s0W39Xq9NDY2TvlzxMEmW49gWPKrrls9VJQUfRPbyzqcHLgV1XqYOOlofzTh8evg1g8AJpz4dnjl9/P3UbJw21O9/PaRvSgKfOf1x5dXFDsNN2+/mY3DG2lwN/BfJ/5XxcfJh/gzzzDwpS8B0HHFhwme6tzvXA4Uvx/FmsTrY4UTBue3HvpeWXaPLKWBAFYqZqGaLIBA26HrlWWa2ZqsQiRL1mSVsAs+eOBBBuODNHubOWvuWUAOyTqueH8sCRl8EU3ppDJT6xjOmHMGx7cfT1JP8tNnfzrlNTv8wmWNhbGp0c7lQqpYpu6jNRAWPyxmFZyOKT20vgmPXVt8ewdY1S3DL/KTrDufOcAF1zyIkRHKwldet4hXr5uTd9t8qLQeS0ImDA7tsSZji0o/l2wlazrJio/kJAsuyDvxmRJ8YZFyzWoNUqsYd7sZscOJmKqoLG8WSa8mJpqi2e+5mpB2QRMFXfOiV6hkuVQXzT6xYFUsxj03eXNzv/i+ZWCBxyHJkjVZiWl2QVmPdeKC5rICnE5c0MJN7z+deS1+BgbEmC+bmDe6unn5d/7F1+7eQiylc8L8MLd/8AyuunBN0cUjSbJ2D8dIpJ0RJVljJuyC1UgXFM+MDqd2QWuc0l1iYaJQ6AWI61OqWX3RPrpzarKkouQJuOidSGTtgoHq2wUhG35RSU3WQSvUKjXNLmhmMiS3ilpIXxEnhSRZp/Y4twpC3S5YFXzkIx9h06ZNRf8sXryYrq4uDh6cWmeUyWQYGRmhq8TK/eTkJC9/+csJhULccsstuN3OCsyPCrQdg7HyIgD0loUApFxJ+ke2wW/fAH1POzqMjHBXLSVL/09Ssh75KdxxOWDCKe+F874NauHLfvvBCFfeLCavH3rhUs48ZuYqr1OMJcb47hNiMvjB4z9Y8QQrHzIjI+y//L8w02lCL30JLTUMdFEUJSf8onSvLKcx7rkJg5VCrgi7zBABxVKlCqULgtWQWMa4R2qbMBgdFAENigpt+VfYRx1GuMveWOctOQ+3ZXHN1mM5I1khn9tu9DoWL6xm/WHrH+z0P8jWZZmaJFmzU7LksY10mBaL+E1pROwEuT20/vgR2PqXWZ3TsQUSBjO6wVV3beLS658kntYJamFxmqHyJityUm3XBJaJpR0NKCakB8X1WqgJcS5yEwYNyWBME2JZkuVdONMqmNSTdhhNrpLlsuyJ0rpWbdjNiMuYlaxqXWX/e37jfLxa9SdkLreGZql4aXcAw2lNVvNUkgXOGhLnJm/KeiX5mduukxKQxHB68IVdj1UgAbMYlrQ3cPP7n8ea7rnoiey8a9M+D7uGorSHvHzrorXc+L7TWTO39PXZ2eil0edCN0x2Djpb2JUqqsefU5M1i+ALSbJkxHpJWKpkhjBQuB5LIrcuSy7W9k8kbQKBTwMMVJf4nmtFsgK2XbC8miy/y89os7iWjOHhKcnTqV27MJNJ1EAA9/z84/ZoYtS28pZTj2WaZt0uWA20t7ezYsWKon88Hg+nnXYaY2NjPP744/a+9957L4ZhsH594dX7iYkJXvayl+HxeLj99tvxFZB1j2aY1kWvzxc+6ZQWZ8ilkdryR/jx8x2RLRnhrimW/P6fQrIeugb+9FHx79MuhVd8FYqsksZTOh/8zRPEUjqnLW7l8lnUYQFc/dTVjCfHWRpeyutXvH5Wx8qFaDj8UTJ9fXgWLqT7qtk3HC6Fwg2Jc5Ssw9CQWCpZihHMKlmF+mQBBFtpkUqWVuMYd1mP1bwQ3DNTKU3TzKnJKrz4M5IY4b599wFZq6Cp6ySeew4A32pnJEtTFZr8MxMGJU7pPoX1XevJGBl+8sxP7J8rVq8sQ7VsmLMkWbaSlW6mJWhNigslCxbDC66EtW8QNZZ/eBsceLLiczp2jhV+0ZdVskajKd527aP8+B+i19R7z1rMSVaNbjElIh+kXbDdX9mizZL2Btp1BUU38fg0mruKXOMW5obm4lE9JPREljQnxsHUSU0U7pEl70cFhaA7aEf+SxWldkqW82bEEjJhEGpjFZSQpCXjCjhrRgzZBYPxXpFKR+Fea7nILkI0s9kiWdIu6FTJ8sl0wRwlyzTNKcmClaA95OV37zmVHm82zVRJt/Ge5y/m3o+cxYUnzHVs91QUxa7L2nbQ2Wc6JcJ9ln2ykhnddhJ0hsq0CxpiLCxFsqb0ypLBF+MJu0dWTDVRXBFQDFRFrepCbC7sXlllKlmKouBqChO1hul0TtCctAp6V6xAKbBw/Uj/I5iYLA0vLeu9pRK6TZ7rStYhwMqVK3n5y1/Ou9/9bh555BEeeOABLr30Ul7/+tfT0yO8sb29vaxYsYJHHnkEyBKsaDTKz372MyYmJujv76e/vx9dr11DxUMNmS6oW6v3GZe4iQaOfSWggCRbv3sj9OXvri4HbhUrAOM/Ifjige/Cn68U/z7jw/CyLxYlWACfuX0DWwYmaWvw8t1Ljkcr42E/HRuHN3LDlhsAEXbhUp2tQDrB4Pe+T/TBh1D8fuZ+/3toDUWUmyrBVShh0CZZvcxrFg+Rsu2C6dkrWRhBAkglq1hN1lQla7CWNVkl6rFiOba9YraaO3fcScbMsLp1tV3Yn9q1CyMaRQkE8C5d4viUwv6pvbKm49J1Imnwth23kcgI0qp6LZKlWEQxOju74BQlS5LLcuyCEooibIOLX2D10LrYXmkuFzLGfcdglERaZ0PvOOdffT/3bx/C79a4+g3ruPIVK+2JQqkY7umotEeWxNKOBrp18bjuXNToiIi4VBcLmxYCOU2JZXx7RExcPIsWztgvkhJKTYO7AVVRbbug31IdU/EaBV+U0YxYIrehey1CLyTs8AtXAN2pnb6hCzSvWASw0jRtJatIr6zsIkSY/aNxIslMthGxU7tgnuCL3cMxBieTeDS1aBJmKQQ8Lv77hdkWIVe+9Aw+dc5KQr7yXUIyxt1pwuCUCHfP7GqyDlr1WB6XaocClYRsRJwR90+hRsQS+RoSD0aSRKx6o2Fdt0Mv2nxtVZ0n5MLfKN5fucEXMLUuKzfGPRt6Ubo/VjkqFkDMUrE8flfJ5ttHOo4KkgXwm9/8hhUrVvDiF7+Yc845hzPOOIOf/CS72ppOp9myZQsxi3Q88cQTPPzwwzz77LMsXbqU7u5u+88RFWYxS8ggAt1aKVc8YtLWf+Zl8MFHYM3rAAU23wk/PlPUJk1rJiovYhUVE+Xo75P1z6/DX/9H/PusT8CLP1OSYN30+H5ueGw/qgLfe/3xdDhd2coDwzT48sNfxsTkFQtfwcldJ1d8rOmYvOcehn/8YwC6v/gFvMfUbmKRC7sh8cg0ktXYAyigJ1nkF9eNUyWrwVoYmFXwhaVkGZkgAUUqWUVI54yarFqSLFmPtTzvyyOWVdDrUvG78z9ITNPklu3CKnjBMRfYP49bVkHfqpUomvOHUJNlS5Q2xelY276WVl8rGSPDphFx/lLJMlWLZMWKR1CXQrbmJEfJsu2CZaa5ujyiz13HsaKH1m9eV1EPrY6Ql7YGD7ph8s2/bOE1P3yQ/aNxFrQGuOWDp3PecWIxL19DYieYLcla0h60SVbr/CLBINP3syyDslmvHd8ekUpW8WRByKZRBhosdaTGwRfl2AUXNS3CY6Xi1pJkySCJjDvoXMlS1ez1PC1h0ImS1egS1rEt/ZOkk2XaBfNEuD+yS/zO4+eF8bk1SEZEz8iB58Aoz3J3Ss/JuBTxO9bPyz++OcHyMsMvqtmMeCAnvt0RsU/H7cbSekJsX6wmC6baBdsavGiqgm6YDA+LZ2VfPIXqqm09FmTtguUqWTA1YTC3LiuxWTwfisW32/VYZZIsO/TiKLcKAtSGNtcALS0tXH/99QVfX7hw4ZR46Re84AW174FzBEAqWRmXmAhpXnEz9Ef7YcnJ8Jr/hed/TBCPZ2+Ep34DB54SzT1bxQM4d3VM17yQOARNWmsB04T7roJ/fFX8/4WfhrM+VnK3bQOTfPpWMWm9/MXLOH3p7CT7O3feydODT+N3+bnipCtmdaxcpPbsyTYcfvObaTr33KoduxQK1mRpbtG7aPIAc61eWaOxNBOJNI0lVjblJE6unFcCqWRl0v6sklUs+CLYPiVdcLCCh45j2EpW/uQl2a+qJegp+JB/bvg5to9tx6t5efmil9s/T1ihF36HVkEJGX5RSMlSFIU17Wu4b999PDv4LOs61qH6rCaspmxGPMvgi0h2pT6rZFkkqxy7oITsofW/LxE9tG58J7z55rIOoSgKK7sb+de2IX76r10AvGB5O9+9eB1NOavcTnsdTYckWZXWZLU2eJlnWE3jm51PPGaEX8RG0NMKurUO4lk4M1JZkqwGTwOJtE7cCiUINojfW7OarDKbEYOIxH/tstfy6MCjnNJ1Sk3OC7JBEmmX33mEOwhldni7UEAW5TQkLkDSTdO0Sdbi5nkMDwmStSxhNSL2O00XnNmMeEZ/rH99E+7/lrVDGBacnv3TtbZo+m7QHeRTp36K/ZP77fCRSrCszIbEkjR6A25cXtknq7KaLDtZ0LFV0BqjPA1kIoKglWMX1FSF9gYv/RMJxkYEyRozDby+2tZjQa5dsLyaLJiuZAmSZZomyU1WsuDKVXn36430sm9yH5qicWLniWX9zqhVsxY4yq2CcBQpWXXkh02yVDFQePxiYOyP5kTbty8XZOttf4RgBxx8Dn7yAtj8R0D03pA+al3zoiQTh+4NVAumCfd8PkuwXvI5RwQrlsrwgd88QTytc8bSNi590dJZncZkapJvPSYeXO897r32IDtbGPE4+z90GUYkgv+EE+j82EerclynkLaIGSQLbMtgIN5HmzURc2IZrEbwhVSyUil/TvCFswh3xVXDmizTzNZklVCyioVeyMCLlyx4yZT+SnayoIMmxLmw7YJF+kGtaRPE7dkh8TtUqWSZ1nnONvhiupKVjkPUCjYqxy6Yi6Y58MYbQHXBjntgaFvZh1g9J1us/6EXLeVnbz15CsECZ0pEPsxWyUpE04QzYoweLkNkXxIWC2k7x7J2QRl6obW1oYVmqmLSvhvyhBi3yLimKjQ0SLtgbUiWFFPKqckCuHL9ldz8ypvtRZtaILcmS49EnC/gFuiVVYikjyfHiWXE2Lm6U+y7pX8iW5NVppKVmKJkTSNZ+x8Vfyuq6FG35U/wl0/DT18EX10Av7oA/vkN2PNQ3sbfr1v2Oj584odnVQ+8rFO4DvaOxIilSl9XMpI+10amZwwMo/wFddkjq9Np6IUMMAkvQB8bA0ALO1eyIBuwEbFIRFQ16Wi2yF6wNvHtkI1wT0TT6Hp5pDQ3YVA2JM7094vPQNPwHpN/ziStgmva1tiuFaeQoRfB8NGvZNVJ1lGOLMkSF6PfL5j/FJIlsfB58N5/wrxTITkBv3sD/O2zKIZuq1kZlw81lTi6VEDTFA8HuSp39lVwxn852vX/3foc2w5GaA95+fbFs6vDAvjR0z9iODHMwsaFvHnVm2d1LAnTNOn7zGdIbt2K1tbGnG9Xv+FwKbhaxIN5RoQ7TAm/mCfDLxwkDFYl+MLqk5VM+nKCL4qQLF+YVusZo9bSLhgdsupfFGjLH6CSq2TlQzwT50+7/gRkAy9A9CtLWkXH/uOOy7tvIWR7ZRVe0ZxOshRZk2VYE7z4KBiVWXTSetruw2UrWeOWz9/TAP7ik5ai6Foj6rMAnru17N3fcMp8zlnTxU/fchIfednyvGNBKSUiH0zTnHXwxcHdwlI7qhrsmnS+CCZJ1o7xHWJMjw3boRfePKEXkGMXdGeTBcN+N15/bUkWdp+s2hx+NsglWWQymAmH34GdMChqDksFX8gFiFZfK8d2C0K+uX8ymy7ouE+WlRScNsikdHrH4uwfjaOpCicssO4xqbS/48/wrnvhpV+AZa8QynAqAjvuFX3orn05XDUPrj0X7v0S7Pj7jJKDStHa4LUX5raVULP0jGGHIeRGuENldVkHJclyqmSN7hZ/Ny+wFxudKlmTqUmi6agdfpG0HBRRxaSxQTwra6lkeYPZZNlEpDw1q8nbxMGw+LesyUpYKpZ38eKCPRr/faCy6HaA2JgV3+40Wv8IxlFjF6wjP2ySpYiBqqFBWHvkyskMNHbD2+6Ev/w/ePiHcP+3ofdx3J6Pk4wJJUs1DEin4RBP5CuCacJdn4BHRJ0S53wDTnm3o11veGwfNz0h6rC+f8k62kOzu6G3j27nN5t+A8AnT/kkHq06n9/ob3/LxO13gKYx51vfxN1Zu8G4EArWZMG0hMHTeXLvmKO6LNmMuBpKVibtMPhCVWn1hq1/pxmKTmKaZvXTGWU9VvOCgmmHI5aVp7kAybpn7z1E0hHmNMyZUteX2LIVM51GC4dxz51b1mnJAu/RIiTr2LZjAWH3GEmMZJUsw5r9mgbExyBYvvWtP9qPiYlpuDD1BqFk5SYLzvZ7OPYC2P43eO4WR0p2Lua1BLjmjcVtLU7S4aZjIjVB2hCfd6V2wf5dgmQd0AyUQed2tXmhebhUF/FMnP5oP9058e35Qi9gak2WXAhoCrjxWlY1GcJQbdhqRI2TUiuBHXzhFmOLEYmg+mcmhs6AVLKswIRSEe7SStvT0MMKK3lvy8AkKUvFdkqy3D4NRVUwDZNkLMOjloq1uqeRBq9L1OZJ9bhjpWgAPvdEeN5lQlI8uBH2PGD9eVC0o9hzv/gDQjHuPh66VoM7CG4fuPzib7c/+2+XX/zf7QeXT1i55c89AfAEWdYZYigyzNaByaKBHLnk3mO9PxTAFAmDHl9509l+O77daY+sHCVrVISIlQq+CLqDhDwhJlOTU8Iv9JiOglCyWtzjkKhdI2IQDb59IQ/xiRSxiVRZiX2N3kYGpylZsh6rUBNiwzR4uF8oWeu7yu/fGZ34z2hEDHWSddRDkqy0Kb7KxoYGiEF/LI+SJaG54RVfgbknwe2Xwa5/4o69Hugmo1mr1vE42pFOsgwD/ngFPH4toMD534ET3+Zo1y39k/zPbaIO64qXLuPUxZVNfiRM0+Qrj3wF3dR50bwX8bw5z5vV8STiTz3FwFVfAaDjIx8heErt6g6KQSuULgh5e2U5IlmWkjWb4AtZk2Vmglm7YLGaLCAQaMNnTJBQVZLmONGULiYe1USJeizIhk+0FEi2unXbrQC8aumrUHPSABIbLKvg6tVlk0NpTRyPF7YLNnoaWdS0iF3ju9gwtIFlsiYrmRar3IlxYRmsgGTJlXozHQYUoeLtriBZsBBWnAt3/JewRA9uKWjVrBSSJI0nx0kbadxq6VQyqWKFPKGK+zgN7BLF8X0ug/hB5yTLrbpZ2LiQ7WPb2T62ne7YMKlJMVHPF98OU0lWrpIlW33ULMLd4lhOI8APJaSSpfvEmKVPRnC1O1AlC9gFh+PDeRd3eiNiEtvT0MPSjgZURajOkYiM0Xc2TimKgjfgIhFJk4im7Xqs9fI5NySayNI4VxCsXKiqIE9dq2H9e8UXM7w9S7h2PwAT+6H3MfFnNlh+Lqvb/osHd5QOv5D1WG6fhmo1UnZ5NDJJvaJeWdngi/J6ZAkl6x/i95dQskBYBidTk1avrG5UE7DON6qYJE3xTK2lkgUQCLmJT6Qqakgsa7L0sTH0SJTkJiv0YkX+59u20W2MJEbwu/ysbV9b9rnK4IujvUcW1EnWUQ9byTI0QKc51CRIVj674HSseS10Hgu/fzOe4Qmg2w7QMBIJtKbSDQUPGwxdEMSnfg0o8KofwLo3Oto1mszwgd88TiJt8Pxl7XzgBbOrwwL4y56/8HD/w3g1Lx87ubwV9ELIDA+z//L/gnSa0Nln0/L2t1XluJWgYPAFTLULLimfZFWqZOmGznhSTD5NPUDQ5SBdEFCCbbSkxzigqiJhcDJZfZJVoh4LyOmRNfNBsn9yPw/3P4yCwquWvGrKa/FnrNCL48oLvYCsklXMLgjCMrhrfBfPDD7DCtmMOBEXxCoxboVflN9HLrcHkEtVaPS5Kk8WzAd/Myx5IWz7i1CzXvDJ2R8zB03eJjRFQzd1RhOjjiZGs63HMk2TgRwla3Qoim6Yjq3Ni5sWs31sOzvHd3JmPFfJmpksCFODLyQZbw548PprTLIqCL44VLDTBS1CYkQcjlnSLjjZB5mkrWSljTSRdGRGHZl0oPQEe/C5NRa2Bdk5GGXcajVRTpy1L+gmEUmTjKXtZEG7CbG9CORgEUJRRDP1tmOyi5hjewXhGt0taiozCfF3Og6ZOKQT1s9i1r+tn6Vj4udWewi2/JH3Ne7kFi5ly0Bx0pqbLCjh9qgWyarELig+U8dJwhZRNkPz0MfFc6eUXRAEydo6upW+aB9dTQvxm0KAMzBpafYznBD26VoqWSDDL6LEy4xxb/I2EfcqxAMu/LEM6d5e2y7oK5AsKFMFT+g8AbdWfrS/DL442ntkQZ1kHfUw4paSpauATltTMwxkPcBBdxHrFAirwLvvxf2522AUTI+4IYzxEeis7U1fMfQM3PYBeOb3omj3gh/DcRc52tU0Tf77lmfZMSj80d++aO2sV05j6Rhff/TrALxz9TuZGyrPwpX3PDMZeq/4CJmBATyLF9P9pS8d1smHSzYjHh/H1PWpseF5GhIfiuCLidQEJmJiZup+Am5pFyzRqDXYTuvwFg64XaiaqMta2FbiPikXchLTUVjJGitSk3XbjtsAEX3b09Az5bWsklU+yZLNiIvZBUGQrNt33M6GoQ1c7BO/x4gnoL0NRnZWHH4hJ5FGOkyzTFWcTbJgPhx7Qc1IlqqoNPuaGYoPMRwfLotkVVqPNX4wTjKWQXOrjHsVUhmD/aMxFrQ6u2aXhJfAHpEwaEaHsySrkJJlBV80ehoZnRDXSVPAbYcq1SzC3W5GXJPDzwrSLpjJsQs6QqBV2OnSURjbh69tKUF3kGg6ynB8eAbJkkpWd4MITFjRFWLnYJRYdGpDaGfnLL6vweE4OwajKAqcPINkFY7fLorw/Nkpz4YBB56A6y+mZWITt3g/w0f7/gco7NTI9sjKTtpFXVa67IbEpmnm2AXLU7J0V6stuzpZiM5NGDyx0UfQEM/xqAKr53l5MFP7mizIJgzGykwYlM/pkRY3c2IZkps32bVZhXpkSZJ1WvdpZZ+naZp2n6x68EUdhx2m1ScrbSVPhRqCdq2LIzULwNeIe76QdHWXWDkwf/c2GN5R3ZOtBvQ03PIei2Bp8JqfOSZYAL97dB+3PnUATVX4/hvW0dow+5WS/332fxmIDTCnYQ5vX/32WR8PYPC73yX28MMogYDVcLjKJKBMaOGw+IdhoE9Ms/dJkhUdZIHl3d4/GkcvkfgkJxgpI0VSLz+AQoZeBFwNeDBxYT1oi9VkwYxeWTVpSFyiRxZk0wXD09IFdUPn1u23AvDqpa+e8poRjZLcIZLi/GUmC0KOXbBIuiBMDb9QpJKVTIhJI1RMsqSSZaabaZHvu5JGxMWw/BzQPDC4OasoVhHl1mXNNr6937IKdiwIsbBdXNs7yqjLyg2/yAwOY2RUUFU8Ber5ZEuFqXZBjx0fXquarEqaER8qSMKSdgnrrD7p8PNXlOx1PbYbKF6XJRch5jTMAWB5p5jgSmLrLqPuSBLDLXvHrWOFsmmZg0KJoL18NboqUFVRrvCuv6I3L2auMsQPU58isu3+grskrGtxipLlrawhcSSZIWbt0+kkXCExLhIYAd0Uzy21sRHFXVqlmdKQuNFH0BTXd0w1Wdwt3lPIHSJQwuY+W1TaK6vJK4jkkPVsn/zbPQC4erqz84IcpPU0jw88DpTfHwvE+CLtn/UI9zoOO+yaLGtxwuNz0dWQvamdQnq9J9xCsTAO7oCfvBA2/6mKZztLZFJw4ztgw02guuGiX8DqCx3vvvHABJ+5/TkAPvqy5dlVvVlgz8QernvuOgA+fvLH8bkqb2IsMfHXvzL80/8FoOdLX8S7ZMmsjzlbKG43qhX3PMMy6G8Wq7VApzGCR1PJGCYHxoo3tQ64A3atUSVqlgy9CLqa8JNDlEqpt8F2Wq286JrEuEeHsySkQLIgwKi1Ot0yjWQ90v8I/dF+Qp4QL5r/oimvJTZuBMPA1dXlrCZkGpwEXwAsa16GR/UwkZpgTBHfoxHPIVnRynplZZWs5qyCZ9sFq0Sy/GFY8mLx7+duqc4xc1BuQ2K5XaV2wYGdYlGjc2EjSzqEFXZ7GXVZsiHxzrGdJAfGAHB3dxRMKLXtgu5cu2BWycokdYwyY6Cd4IhWsmSfLEVM+srqlSUtg5YSUoyk20qWFf293Aq/0K1JZzlKls+Kcd91QHyf6xflPO9kTValSla10LIY7V1/ZYNyDM1KhMBvL4CNt+XdVNpU5XUI4HKLiyVdZk2WrMcK+VwEPA6Iq6zHCrSiR8XzolTohURujHtXU66SZdJlxbfXWsUC8DeKa7hsu6BHkKwDjYKURu4XRNhXoB7rmaFniGfiNHubK2oQLuuxPP5sw+mjGUfgcFaHU5ipFKbFrlJyEPa76AoIklUwYTAPZGpR1CUe4kbzKkiOw+8uEf2nKoxsrhoySfjDW2HT7WKV+uJfw8rzHe8eSWa49PonSGUMXri8nfc+f/GsT0mGXaSNNM/reR4vnPfCWR8zuWsXfZ+8EoCWt76Vxle8YtbHrBYK1mUpiq1mqZP7mdsiVntLWQZVRaXBLa63SsIvxqyVRb/WRFDGt2veok00AQi20iKVLC3CYKTKDYmHrR5NTfOKqmrZmqypq6GP9ov+NS+c98IZpN2ux1pTvlUQsqpZPK2TSBe+p92amxWtYgK2PyVSyAxZkwUinawCZJWssCBZmZSoV4Hq2QVBWAZBkKwqt6MotyHxYFzUXFRKsqSS1bmoiaXt4n7ZcdB5hPaCxgVoikYkHWHYaq3gWVCY0Mp7MeQJ2QsB4RySBbVRs2TbkCNayVI8mCjOa7IgJ/xCKLa2khWfev1EUhGb4EqLsEwYVHXx2ZRTkyWJYd+g+M5PWWTdu8lIdmGjyCLQIUOwje/O+RZ/1U9ENVJww1vh3z+asVm2EXEeJatMu6DdiNhp6MWUZMH/z957h0ly1dffnwqdJ/Sknc1R2iStckBCMmAQIBkQSCJjsDEYmyQTDTLIBv8IwgYEGGwDBl6SCUIyFkEEIUugiLQKu9LuKqw27+TQM50rvH/culXVPR2qe3pmd1ZznkfPjma6e2pmqqvuued8z3Hi2yuoOJUgSdZAeoB4WKfbsdpnVJt4QryP57IjS6Jpu2BEqKlH2sXz7KzYdItuqUyyZD/W+cvOLwlsCgrXKngChF7AIsla0LCynlJQyHs7Xf43dVCE3Z4ssUC2L/4HOP9vxBd//1n47hVN717PGpYJP3yDKEvUo/Da/4ZNLw78dNu2+fCNO9g7kmZZZ5TPvuqMliRY3X7odv5w+A/oqs7fn/f3s14cWJkMh999NVY6Tezss1ny/vfN+hhbiSCFxP65rLkOv5B2wYjSTkwJOI8FQsly7YLp1itZo0+Kf3uqK5C2bXvpgmUzWY+NPQZ4lj0/snIeq0mS1R7Rkae+LJqthtN6RQfXgYK4jtjZ2dkFLdtyU09dJSt1WETC61Foa+Fu7qZLBeEeeVzEUbcQjSpZswm+KOZNRg+LhdjS9T4lqwG7YEgLsbpDkKqxKXHLj6yvfm5OF8Vrd4Q7mMjKCPcwmqa6ysFchF/YTZYRzweibgKogqFHg9sFwdeVVZYwWKZkyeTNzkinO0u9ujtOTNcIOfsEjcSUSzKSdjaRzl3nhDRIFSuxBOKzd3O0AmuX9fK24nv4Y+8rABtu+XvRfWl5CpUbfOFXshySVWzQLuglCwa0o/mTBSfFJkTQYDC/XbBQKLJCEccf6wgznhfXhvlQsmQhcTPpggBDZT9uvdCLZqyC4IVenAhWQVgkWQsa0ipoh6OYRZ+SlWjcLih3hIrOznkxm4dLrxMzT6E47P0/+M/neMWh84l9vxeD7HoMXvdDOOkFDT39e/ce4OaHj6CrCv/2ujOrlr82gryZ59P3iWj1N259I+s6Kyd1BYVt2xy99h/JP/EEWl8vKz7/uUB+7/mE3iVuyEYLSdZswi9kfHtYafOUrCDN8ok+ekyfXbDVM1kjjpLVU90qMZU3MBx7VJfPLmjbNrtGxRzR1p6tM56X2yFqB5qZxwIRjx2kkBjg1F7xPZ7KCQuTlc/7SFbjGy7DmWEMy0BBxTbaRaqi3FHvXNnafqRoh3edaLFl0C0kbnAmqxmSNXwghW3ZJJIR2rqirpL15NB0Q4Xx0jKYmxLXlPCGGuemL11QniNdDskIyYTB3ByQLFfJavlLzxpayCOYhh5vzC4obbDjZSSrjKRLlXd5wgu6UVWFzUsSqIhfStCeLPCIYcSC9b0JL0WvkWTBecLG/nYsVD4Xehs8/x/FJ+/6Etz4FuFiwRd8EffbBZubyRpoNL7dr2RNOSSrvSPQU3ujvSxPncSFT1zBtz54JyunxHneuyTOYHoQmCe7YJMzWbqqkwglGEqWvjErxbeni2l2DIuNwPOXNd6PBZ5d8EQIvYBFkrWgIUmW1ebFiIajWpMky+kBcXqyctPOAnnbVfCWW6FrrejGeOj7LTjyBpFy7ERrLoD1z23oqTsPT/Lxn4md7A++eBNnr2nNzt03d36Tw9OHWRJbwttOe9usX2/8u98j9bOfgaax8vOfJ7Rk/guH68G1C1YsJG6uK6vNIUWzmcnS7HYSikOyggwP+4IvZLpgS+EqWdWrAaSKFQ9rREPewmkwM8hYbgxN0djYVWrlMcbGvFSnU05p+vCSMRnjXvtmK5WsvTnxPe1sFuIOUWhCyZL25TBdgEZPItz6ZEE/pGVw540ttQzO50zWgDOPtXSdWNCt70ugKEKFlMEpQbA+KezRakrc8qvFt5uWSboolLPy4AtgTmPcvZms45Bl4S3uDT2O2Qq7YJnd1CVZZWmim3q8jaNGZlTkTFbUVjjPP4/lhl4cPyRLzp49MTwNF79XJAarupi//s4VkJ3wRbh7m4+hiDOT1aBdcKhRu6BPybJSUsmqTbLGB9Lc89On+MG19/OyR9/FlqELKeYsiGvcHS3y7BesYSgjrNhzHd8OEGsXv7fMVKGhDRoQc1nDPiVL7eggtGL5jMc9MPgAhm2wsm1l0ynLmRMovh0WI9wXNCTJMtuTAOhhFVVTPZJVq5C4DHKHzHLKMrMp305d/1Y49Sr4/b+K5vf5hlzQxRojSKlckXc4c1gv2LKEt148+zksEMPJX98hginef+77Z50KlNn+IIPXXQdA/wc/QPycc2Z9jHOBwF1ZJwWPcZdJmLNRslQ7QUQGX9RLFgRIlKYLjky0eibLIVm91UmWXCB3lYVeSBVrfXL9jHms3E6hYoXXrUPrCLaLWglBwy9Wtq8kGUmS0cTf28r5gy8aJ1lyEalZ4n3clQjDWIuTBf3Y9GJhQxx7CgZ2wLLTWvKyjaQLFq2ia2tthmQN7nNCL9aJFU40pLGyK8bBsSxPDk0HTkc9KXkSmmmTSAkCUy2+XVoFQbw3pV1QnjPSVp7Ptn4mS4aRHo8zWSBmnNKTBYp6HKsRu6A8tzMjkJ+uev7I94e0+0ts6E5QYBxTbYyASjIStRXOOh5DL3w4ybHBjkwXGJnO03v6a6CtH37457D/D/CNF5MvXA+UBl9I0tloGbG0Cy5tRslKCTucWkHJyk4XeOKPQ+y5d4Chfd6csaEXeKJrO5dcci4vu+h5/EXRJBHR+fJT86dkyXRBy7ApZI0SsloPnZFOjoSOYCXbUSemiG7eXPF9eveRuwF41vLmrIIAaXcm68QgWYtK1gKG5cS3W3FxA5YXH7+SFXTHQnq9bYdkFdJlC2Tp3W4yunlWkAPCcoEXALZt86GfPML+0QwrkjH+9ZWnt+zm/a9//FfyZp5z+s/hxWuDz4ZVgjEywuG/+zswDDouu5SuN76xJcc4Fwg6k7WmZ55mshwlCyvhswsGIFnRTnpscelTtBwj6QYWTPVgmaJHCmorWVU6snaNCZK1pXumFSO7Q85jNWcVlJB2QZkcVw2KonBq76nknXuxncv5gi+aIFlpr4gYEEpWK4uIyxFph5MvER+30DIolawgwRdSxdIVnWQk2dD3sW2bgb1O6MV6b0G3QYZfDAcPv1jfuZ4lE6BZCkpIQa/SgSjfh1Etimmp5Bwbukuy5rKQ+DhOFwSfkhVq0C4YS0LUkQEmDlRXstKVlay1HWJOOt/g7csOiydEbSorWcdD6IWDeFh3HRCPDzr3gg3Pgzf/EtqXwfAu8vvFJlOJXbDJmayBRmaybNurmehai5lyioidjS6jaPLkA0P8/CuP8K0P3snvf/g4Q/tSKKrCmlN7eOFbTuHwK27j9pP+m8meoyiqQsJxDs2nkqWHNXczPdtkV1ahX1y7681jNWsVBI9kxReDLxZxrOEqWTGHZDlESb5h82be3UWtBze1SBMndn4GyZpdqtisIL9nA0O63757P7/YMUBIE3NY5V1EzeKuw3fx2wO/RVM0Pnz+h2dF3NzC4aEhwhs2sOyf//m43cUF0LudmayJOkpWUiwKxjNFUrnaF/NWkCzbSPiCLwKQLEWhI9aD7mxAZM0U6XyLFo0TB8AsiNCFGha4MSe1ras89GJUWFtrzmM1UULsRzJgITGI8I2Cs6YpUbKKaSjWjugvx9FpYRcs5sT1qise9hYvnXOgZMGcpAxKJWI8N45l195BlySrO9bdcNLW9HiezGQBVVXoW+2V1vrnsoJibedaVjiXUbUnWvU6I5Usv1VQUxXanEXhXJIsy/n7tCKUaC4gd/6LjdoFwWcZ3F/VbirfH+Uka4WjVmZti0wh+O/9KadCI47Kyi7HbVHMwfg+8fFxpGSBmMsCeGLQd14v3QZ/9Rvo20yh6FhWJx51v6xLJatJu+CSIEpWehiKGUCk6FqpKWxgxOzitu/u5psfvJNffW0n+x4ZwbJs+la3c9ErT+YvPv1sXvLO0zn5nH6Wdoo1mT/xuWgWXTVzPpQs8NSsTIMx7jJhMHWS+Dni589UqkayIzw5IVwc5y+dDcly7ILJRSVrEccYVtZRsqLi4iStHGEt7FpTgs5luQO1qnMjKSdZsWOoZDVoF3zk0ASf+LlQBD506RbOXN1V5xnBUDSLfOq+TwHw2s2vnTEz0yiGPv95Mvfdh+oUDquJY1s4XA+eXXBi5hc7lgMKGDkS5iS9beJifmC0tpo1m+ALuYFgFOOekhXQuqnEe70Y91Z2ZckC7+71oFafn5DzUN1llo1qoRe2bbtKVuy0WZKsgMEXIEiWVLKsXA4iHe41otFrgdypz2TF37ynLdz6IuJynPwiEZgz/jQcfbglL5mMJgEwbdO1rFbDbEIvBp8WdqOelW0lszgyYbCRQuKIFmHLhDP43her+jj5PmwP+6yCsZBLysJzGXwh0wWP040m/0yWNR1cRQR8CYOekjVdnC4pYXeVrEQpyYo75LygwOODwf/mjwyJ8ydsefNujD4pftHRztamebYAG/vFeb1nsOxekFwFb76FvJoEIHzr++CRHwGeXbARJSudN1wla0Wy+nvBhZzH6lgOeoT0VJF7z/0ov93eyWN/OEIha9DWFeGsF63htdeez6uuOZfTn7/KTfMDL6J9MDPofk5WO+iqTle0NWuUemg2/ELep3e/7nzW/+xm2p733BmPkdHtW7q3NP3z2LZNRgZfLCpZizjWcJWsiFic+73KjXZlhctIlpEp26WWO9jZYMpYSyG/ZwAlazLrzGGZFi/c2s+bn722ZYfx3V3fZV9qH93Rbv72jL+d1WulfvVrxv7rGwAs++QniaxvzbzYXEJLyuCLCmqmHhEeeoDJg6zqDjaXNRslSy5wi4WYV0YcRMkCZy5LJgy2MPxCdmTVmMcCbybLr7COZEcYyg4RMsMYD3UwOey9B42jRzFHR0HXiVTpJwkKaf2qF3wBImFQKlkUi9im2XSMu9ypNwtJALqimohwh7mxCwJE2mDjC8XHLbIMhtSQa/2rF34xG5Ll9WOVzn6c1EQhMcD6MUFeRpdU372XHVn+ZMGkbyMgEp3D4AuZLnicKlkyra8YimNNNalkje+nI9xByLnPyq6srJF17YPlSlbBUdkLis2egeB9gvcdngBAwYs/Z0QmC24+7mIcZfjF4wMVfrexLvKI90GESbjxrfD7zxEKO4mPDcxkbT8wjmnZrEjGggVf+OaxAMYK7WQSS9E02HzBUi7/uzN44ycu5IJXbKB7eeX7j1tIPO2tx6RVcElsSVN9Us3ADb9otJA4ItwHE+Y0kZNOqrgR0gqrYCFnYjgW5cUI90Ucc9gOyTLCFUhWgwmDrl3Q6XAwZ9gFnZ2JY6JkBbML2rbNB294mINjWVZ2xfiXq1o3hzWUGeI/HhYFie85+z3uzk4zyO/dy9FrrgGg+81vpuPFL2rJMc41as5kQVMx7pJkpYqNlREXzIKbgpbPR710wYZIlq+QuMGdvaoIkCwIlWeypFXw/MwLue/G/dx901Pu17KOVTCy8WTUyOxuPl0uyaqvZHVFu+jr9lKirJwvxr2B3jzbtn0zWUnaIzrh7BBYhkgRa19W5xVmgTm0DNYLv5hNEfFgWbKghJzJOjyRJdvADv6yUfHYA73VFdbpgt8uOHMjIBQTzy20OPjCtm1wgy9a+tItQyThTxdscI7TZxdUFGXGXJZcfCdCiRn3lqJT/FwAdlciIBWQN0y2H56k4PxS8/K9fhzGt0tIu+Djg1MzZsmNounW1ETOf5345K0fQx8R6nQjdsF794rf+fnrA44fSHulo0bKIu5lK8M8/01bWbm5u+7GgEuyfJveUtWajyJiiWa7siTJkpsw5bBte9b9WODFt0fiekNJmsczFknWAoarZDkFwmFfh4YkWbKHoR5khDtootE+lyt9gDuLkWl4FmPWkMSuTvDFN+/cx68eHSSkKXz5dWfR2UB6Tj187oHPkTEynNZ3Gi/b8LKmX8dKpzn0rndjpdPEzz2XJe99T8uOca6hO3ZBK53GKlS4SM+CZDWqZEkVS1M0MvkQ8YaVLK+QWG2lkhWgIwt86YIVSNZqW3QajR3xFnI5p4R4tvNYIIplAdcOVg+bl3rf085lfeEXweczJ/OTZA1x3bCLSbr9VsGOFTWtlbPGyS8UNtKJ/XBke0te0g2/yNb+HUglS5KyoDANi+ED4j0hkwUluhNhl5w3YhnsGBUL7d1d1Rekrl0w1D6jIwu8CPd8i5Us/5r6eFWy/HZBO5MRqm5QlBUSl3etyQ2IZYllMzYG5aK+qNjsCUiyHjk0ScGwKDhvq1za+Xu5oRfHH8la35dAUxVSOYPBVOn12CX1CoQv+xic/RcA6GNi86kRu+C9T4vf+fnrApKsMiWrWBQna6iBOW+5HhvNjVIwxXV3PjuyJKRdMNNk8EUqX5lkHZg6wEB6gJAa4swlZzZ9fG7oRceJYRWERZK1oCFJluF0W1VSshq2CwKmFhadOH5EOsSOM8xv+IVte+mCNWayHjo4wad+KeZZ/uGyLZy+KtmyQ7h/4H5+vvfnKChcc/41TUv7tm1z9KMfpfDUU+h9faz43GdR9IXToqB2dIAmzpOKc1nzSLJk6EVnpJNM3m6cZMV76J4Tu6CjPtVTspzgi27fjVrOY3VbYmdzciiL6Rxj9pHWzGNBY0oWwGl9p5Pzz2U1YReUi8h2vQvskAi9cJMF52geSyKcgI2OWtwiy2DQQmJpJ+yL9zX0+iOHpjENi0hCp3PJzLmRDX3iPA9KsszpNPq0OJceaJ+pFEiUzmSJ86Mz5p2jczWT5c4McTyTLBl8If4ejRUSS7ug2FgoD7+Q8e0r2lbMeGoxJ+2CBCZZ9z0t7pmajNx3lazjL75dIqJrrHWSacvnsuTxR2K6OD/WXgxAaOppILhdMFc0efigsOGevy7gxoevI8suFDAscf+PJII7CpKRJFFnnSbJlWsXnEeSNVsla7IwWfHr9xwRKtbpfafPqtImc4KFXsAiyVrQkBHuhhO7LtMFoXG7oBZS3ZubqUUhX6ZkKYpHcurs3rYUhWmR1gZV7YITmQLv+N52iqbNZduW8qYL17bs2xuW4YZdXLXxKk7pab4Edvw73yH1i1+CrrPiC9ej9zW28DrWUFQVLZkEwByvcA40UUjcbPCFDL3oinSRzhvE3TLixpUspVWFxIW0KOwG6K2jZGWkkuWpBI+NCSUrnhe/E8uymRrJYVsWuUdFolZ02+xJliyWDUqy/HNZVibjI1nB7YLSDtWui3NeFBHLZME5msfy45QrxL+P/k9LLINBC4mbncmSoRdL13VWtDzLuaynAs5lFfbvA2AiDgN6tmr8/FTRI1njrl3QO0fDczSTVUKyjk+O5SlZToG62VBXlnOO5ychOz5TyarSkQVQcKxwBcVmNF1geKr+tepeh2Ql2mRasAGm4dmZ+46f+HY/3FLiGSRLnG/uRvISEQykp8TPE7SM+MEDExRMi/6OiFs1Uhf+jqypKUxnvRVqC9ixhQhzKd/4ns/4dglJsqQtLyjqKVn3DojQi9lYBf3HdaLEt8MiyVrQcJUsRZyQfpIlL9ZBC4kVRXHnsgwtglJOsuDYdGVJ1UyPVkyOs22b9//4EQ5PZFnTE+fTV57W0nSqH+35EY+PP05npJN3n/nupl8n88ADDH7mXwDo/+AHiZ91VqsOcV4RtCtrtXMDOzyexTCr7zI2bRfMTQBiZihdMJqwC/oLiacYacVMluzHinXVnR8cT5fOZI3lxtwNETXr3WDGBzMU9u3Dmp5GiUaJbNgw68P0yoiD/cxberZQcNbZQxOHIO4QhiaUrKgqntvlJ1lzrWSB6MsKJYR6dviBWb9c0Jms5klW5dALiUa7sgpP7wNgrEuQmb2Teys+zq9kTVawC4bnbCbL+/h4V7IMZyPHaqRfL5yAhLOpNnFgppKVrqVkid91wrlW1FOzDNPigX3ivtnTJYhALl0UCZtWUbwPOlbWeoljhpOXiPtB+c8o7aluR1bvyaCGCBni5zQC2gWlVfC8dT3B1gmWCZPOxlnXGsxUSmxCU+ocCoLyNZk7kzWPJKu9Rxz71FiF9V0N1FKyTMt0kwVnU0IMJ14RMSySrAUNj2TJosiZM1lDmSEMK9iuo7QMmnoUNV9hp8ONcZ9HJctvFaxwUfz675/mt7sGCWsqX37dWXREWzeHNZod5d8e+jcA3n3mu93o5kZRHBrikCwc/rM/o+vP39CyY5xv6DJhsA7J6m+PEtZUDMvm6GT1C7okWXkzXxJnXA9SyWoPd2LZ+EhWwN1Jv5LVKrtgwNALy7K94AvHLrh7VMxKrOlYQ3bSU5jGB9JkH3kEgOgpp7TEXipJVt6wyBXrL04iWgScsI2nBnc1FXwhd+pDlnjunBcRlyMUg02Xio9bYBkMUkhs27ZHsqKNkawBn5JVCRsaTBgs7BWzgrlOseEh+2zK4Z/JkudoZ7yCXfCZrGRJu+AsEgYlSZfnj6tktc1UsqRdsMtZeO6ukzD42NEU6YJJR1Snp8cpMs4Y3jxW30ZQj8+ln5swWKZkFTJlJEsLQe9GdKcfMaiS5YZeBJ3HSh12wnlC0L4MK5XylKyIVufJpXCVrOlSJWs+7YKSZGUmCxgBrv0SnWGHZOUnZ1iNd4/tJlVI0RZqm5XTRx4XLJKsRRwnkCSraJUWRYLYOdVVHcu23Bt9PciLhqlF0AoVFp3xY2AXdEMvZl4UH9g/znW3iBvHR1+6lVNXVF6QNIsvPvhFpgpTbOnewpUnX9nUa9jFIoff+17M4REiJ5/Esn/++HHbAxMEmiwkrkiynMXy9CCqVWBlt7jB14pxT4QSKIjfRyNqllSyErr4m7t2QcfKUxfxHi/CvVV2wRFJsmpbBVO5InJNKZPbpFXwlI5TXWsMwMRgxldCfOrsjxFoi+jojloQVM3SY4K87h96vKngC7mIxBAkXShZDsmaD7sg+FIG/wes4JHPleAqWTXsgulimpwpzktJyoIgO1UgNZwFBZZUUbJkIfHTI2lMq779sfCUIFmaQ7Kemniq4uNK0wWdCPfYzOCLls9k2QthJkv87EU1io3SeMKgL/yi3C7oFhGXdWSBZxdc0iWup/WULDmPde7abmLOhkouU/SSBY/D0AsJt5B4aBrLd167SpbvXKR/KyHnuh9kJqtgWGw/IO5bzwqcLCitgqtA1TBTU+54hhcWFgz+hEHbto8JyYomQujOOm96LPg9T5YRF62ie02TkKmC5yw9B12d3SagG3yxaBdcxPEAywmnMCynhNhHslRFdWXo4IXETny7FiFUrGUXnE+SVbkjazxd4F3f345h2bzktGW84fzWWo52DO/gxiduBOCa869BazL9bOiznyN7/wOoiQQrvvhF1HjzQ6HHA2oWEse7RfErQOowq7qcrqzx6iRLVVTaHGLUCMmSSlZcExf/NmdHM2gZcWm6YIaR6RYkZrpKVm1Ln0wWbI/ohHVxCZbJghsjpTuBEwMZsk6yYCvmsUBYg5MNhl9EEuL3fHhkb1PBF3IOoZgXpLg7Hpq/4AuJk14gSHjqEBy+f1YvFST4Qm5uJUKJhobB5TxWV3/cJTXlWJGMEdFVCqZVt4sOPLtge1Jcx6rZBf09WZNZaRf0KVm+maxq4RnNwPatkdXjdBNK9mShKBh6FKuRmSzwzvMyJatgFtyo//KOLPDsgst7K4dClEPOY523rtuNnc+ni8d1fLvE2p44YU0lUzA5POFdk2XwRTjuez8s2eoqWaZhlZCySnjk0AR5w6InEXbttnVRlixopiZdJcsfFhYE7px8ZoCJ/AQFS9wH5pNkKYpCh6NmpUaD3/PiehzdqfeZzJdaBlsR3S4hZ7IWgy8WcVxAKlkFU9yU/DNZ4Hl9gyYMejNZUULFCjvc8cZ3sGcNuZDzJQtals37fvwwRyZzrOtN8KkrtrVUHbJsi0/c+wkAXrbhZZyx5IymXid1yy2MfetbACz79KeIrFvXoiM8dnBnsioVEitKiWWwr11cKEfTtdWS9lDjc1lSyYqoYvGfUBqcyYq0k1R0VGehmDYnG+ocqgi3iLi2kjXuhl7MjG9fowuCJk/n8YE0+V1CrY1ta42SBdAZa4xkxdsFuR4cO0gx6ijGDQRfyJmTfE78vZZqU2DkAEVEuM8HQlHYdJn4eJaWQf9MTTWy0ew8lltCvL66Mq+qCuvduazai33btikcFL//pb3Oc6ooWfI92BHuqBx84ZA+2w5u0QqCkgXy8cmx0EIquiy/1eNY003aBctmsgbSA9jYRLWoS979kKrh6n5xbXt8cKqqemlZNn/c55GsqBOsU2oXPH5Jlq6prHeSM/2KnVT3SzYd+k8hpHhqTL2uLD/5DLxekHOjjgppTU1h6oKkNGsXHJgecFWs7mg3YW1+VRt3Lms0+FyWoiiumuXvysqbeR4cehCYPcmybXvRLriI4wtWRgw9Fw1Jskrf9NLfHVTJcmeytChhs4hdbqlxZ7LmMfhCWhN9HVlf/f1efrd7iLCu8m+vO5P2Fs5hAdz0xE08OvooiVCC95zdXI9V/qmnOHLNPwDQ85a/ouOSS1p5iMcMsivLnKhfSNwjQx2m65AsZy5LWpWCYCwvzouwIhaNsUaDLxQFLdFHV6ssg7YdvIjYiW+XJGsyP8nh6cMA9FriPdu3WvxOcmmDghVC7ewktLp1io9UJyYC2gUTbeLvrhaKPGU4YQuZsUC2u0wx4+5+pqbEz7XEFosM2peBPo+LjBZZBuUiuWgV3US+cjTbkeUlC9YuPD8p4FyWOTKClc2BYrN2iSB8Y7kxtwbBj+niTLtgp8+ipYe9FNpWhl9IoqooHNd2ai/GvYlCYp9dUJ4/E/kJDk2JYIVlbTM7ssBTslb0JYiGVHJFq2pq6xND00xkisRCGqeu6HSPN5cueh1+x2F8ux/uXNaQj2SVB18ALNmKRgEQ7+N6XVmSZAWexwKfXVBce81J30xWg0qW3y4oQy/mU8WS6OiWSlZj4RcyYdCvZD009BB5M09frI/1netndVyFrIHhFE4nFu2Cizge4M5kOeV45Wk3S+ONxbiHXJIlLiJ2tULieZ3JkiRLXBj/uG+Mf/mVsD3800tP4ZTlrZ3DmsxPcv326wF4++lvb3gXGkQnzaF3vRs7kyF+/vn0/d3ftfQYjyWkXbDiTBaUkCxJIsbqKVkOyUoVaw90+yGVLN0WC804jvUhKMkC0ZVleeEXw7MhWekRyE0CCnTXvtm48e3OAmjXmOjHWtm2Ejst3oOdS+K0dYn3YSa+hNipp7Z08enaBbPBlCw16iRqFeGRtLO7a5vg/B1qQc5jtYfbmXB+vp6ic02aL6ugxEnPF51/U0fg4L1Nv0xEi9AWEudetULiZpQsy7IZ3CfeB+UlxOUI2pWVf1p0CYXiJon2XjfBrlzNsm3bVbJCSoy8IRY8fsVVURQvYbCFc1nSLng8EyzwhV+E4k3YBT0lKxnuREHBsi13HrPSPBZ4M1nReMiXvlf5Wnmfk5539pouQprq2QWnMmBkQQt7x3GcQs5lPe5TsgrlEe4AnStRop2uZbBWwqA/cfH89Q1sepTZBa2pVNMzWVLJyhgZN3jmWJCsdicMpRElC7yEQb+SJa2C5y87f9bv3bSjYkXiOnp4Dsvp5xmLJGsBw05nMFUdZ504k2Q1WkgckelJ4iKSmy6LBz4mEe6eXXB0Os+7vv8gpmVz+RnLee15rR+Y/7cH/42J/AQbOjfw2i2vbfj5tm1z9B/+gcLevej9/QuucLgetC5xDlScyYKSriw3nryOWtJMjLucyVLtdnQMQjgLvkaKEEsSBqcYCdA/UxVSxepcJZLsasCNb3fUJFlCvKVnS4knPdkvfpZ0vJ9oC62C4BXMBg2+UKLiZwobsHNstyAqEMg6LK2CS+PLyDgLofa8c02aj2RBP/QIbP4z8XGrLINV5rIkyWqkiHh8IE0xZ6JHNLqX194wkHMl9ZSswr59AIQ7DIj3uDvO5XNZWSOLaYu/j2EIUq2rComyBc9cdGW5StZxGnoh4SUMNmEX7FwJKFDMoGcnSEaSAOwcEcE2lZIFwUsXDEc1V+XZXSX8wm+JA2+OLC/dBD0ng3Z8348kydoz6J3XFZUsRYElW1zLYDFfXZneeUQkLnbGQmxyXj8Q3CLitUCpktXoTFZUj9IVEZuUDw89DBwrkiXtgo3NIVfqynKj21sxj+WGXpw4VkFYJFkLFrZlYWWzbmcDzPQIu70MQZUs5/l5XSzupifKLuTHYibL2SW2Yt2850cPM5DKsb4vwSdf0do5LBBRpD96/EcAfPj8DxNSG7chjn3r/2PqV7+CUIgV138evacxq9DxDjf4otJMFlS2CwZUsoKSLNu2XSVLsdq8+HYIni4IDsny2wVn0ZXlzmPVtgqCv4jYSRZ05rG29mx1bzRtyQhdDsnKxPuJtSj0QkKqaJMBZ7KkkhUp2uwY2dHQhotMTuuJik2fkKYQmRL2yHlLFvRDWgYf+ynuDlUTcMMvqiQMNqNkSatg/9p21DqEwy0kHk7XDKEo7BMLxXC7AfFuNiTF3F+5kiXff7qik8uLe0EyHppxnZ2LGHcZ4a4c5yuSWdkF9Qh0OGqVL2Fwx4gItqnUkWWZlpucF4pqbF5auUcKxHXxvjKSJUlJLuecH8fxPJaEJEFPDU+7HYvuTFa87J5ckjBY/b0sFb5z13bXfV+5MPIwJTeDnOALfxlxgzNZ4G18PzwsSNZ8dmRJdPQ2Zxd0u7Icu+BkfpJHRx8FhJI1W2TkBuMJZBWERZK1YGHncmDbbmdHKKrNuHi4g5YN2gWLDslKp8qUrGPRk+V8r58/meeOx4eJhlS+8vqzSDQo1deDbdt88t5PYtkWL1r7oqYuGpk//pGhf/1XAPo/9PfEzzyzpcd4PED3lRFXXNg1YReUO2RBSVbWyLrJTLYR9+axVL2x+R5fIbE6266sgPNYMLOIWNoFt3ZvLWm87+wWC4pMvL9lyYISjRYSKzFJssTiPB0XZDtI+IVUsjpDYte2Kx5Gme9kQT/WPw8inTA9AAfuafpl6hUSj+Qan8ka3CtLiOvboNf1JlAUmMwWa4bLFBy7oCBZnpL11GRlkiWSBcWiNhmf+X6S4QP5uVCyjnO7YNSvZDVqFwRfwuA+VwmVIQhyU9QPf7hIOKK7SlYlkrV/NMPQVJ6wpnLGqqQ4Xif4wjRVDDu8IEjWyq4YsZBGwbDY78yeFdwI97L7/pKt6Io492vNZMl+rMDR7eBUTNjCHZEQGyVmKoU1C5Il/8bymnEsSFazXVmukuXYBe8fuB/LtljbsdZda84G6RMw9AIWSdaChVtE7JCs8mRB8EjWeH6cnFF/10K+hhESb8L0ZNlNRO5eF6bAmMWufyNwSNZ/bReLj4+/7FQ2L609EN4Mfrb3Zzw49CAxPcb7z3l/w88vDg5x6D3vBdOk46Uvpet1r2v5MR4PkEqWXSxipSsMX/uVLGch32olS1oFI1qEXEEj4XZkNTCPBSUka9aFxAE7sgDG0l409nRhmv0poTT47YJtyQjxrFh8ZduXE1rSWltJ0g2+CKhkRcQ1oYs4NjaPRp3fdQNKVlwVC5Xu+S4iLocehi0vER/PwjJYr5B4JNO4kjUQMPQCIBrS3JqEWpZBaReMtBsQ85SsvROldkEZ4CFCL5xkwdhMNV/apGQgQyvgzmQd93ZBR8kKxbEaVbLAN5e1f0aSYCUlq+D8jlVNQQupLsnaN5qeUSQuVazTV3USDYm/USiqub/TvJVYECRLVRVO7hcqrZzLkhHuJXZBgP5T0KWSVSVd0LRs7ttXqvAFwsQ+8W9yjRv3mp/yLHaNBl8AM8jIsbALNtuVVa5ktTK6HTy7YCK5qGQt4jiAJFlWXJz4lfzBHeEOYg4Jk2k2tSAvGpK4ZabKlKxo0vNzzFf4hfN9Ru02TlnewSvPWdnybzFdmOZzD3wOgL8+7a8b3pWxi0UOv+c9mCMjRDZuZNnH/um435FtFmo8juJYxyomDMo47mKGbk2cP5mCOWNB4IcbfFEIFnwhrYLJSJJMwSSOQ7JCDZKseG/rCokDdmSBpx51J0KuirUssYxkJEl6wtnNS0aIDAgLYibSg2nOrjy3HI0GX0glq09LArAj5FwHApAsqWSFbUFKuuMhLxq58xgoWdASy2C9QuKG7IKmQeHn/8TYEbFwD6JkQf3wC9swKBwUhFYqWZJkDWeHS5LC5CZHe7jdPS+S5fYsPLvg3ChZLXvJOYEMkjCasQuCL2HwwIyC6opKlkOy5L25ry1CdyKMZcMTg6Xfv3weC4Qy6FoGrfaSImJjfJyxb3+H9D33YOVbUMbeQrjhF4PT2Lbt2gXL585LZrKqzMjtHkgxlTNoi+hsXdbABq07j+UFhRSce4SigKY3vnwu/xsfC5LVbFdWefCFS7KWt4hkOfe+eMeikrWI4wCyiNh0SkJnXHwQb6ZGwi+k/C17IHKpspuIqgqiBfNjGSxmoSjI5ITdTk9bZE7Iy388/B+MZEdY3b6aN259Y8PPH/yXfyG7fTtqWxsrv/iFBV84XA9eIXEFkhWKQkLcONqyRwlp4u9VS81qVMmSykFXtIt0wfBmshpWsvpKlaypJtVZ04AxRxWo05EFnl2wKx72Qi+6t5BPG5iGjLCNoO55ENXMY6MyNdKYf74eGo1wV53gi15F/K12SGKbrm8XlEqWaorF38pYHmRc/7FQsgDWPUdcy9JDsP/Opl6i1kyWaZmu4hoo+OLh/2bwD78FFNp7osQ7gu3m1otxLx46BIaBooMetyDeTSKUcO8L/vALl2SFvPj2SnbBuZnJEv8uGCVLj2NNNRh8AZ6SNV6qZOmqXvE8KeQdcuHY4xVFcWeWdpclDN63T5yH560rJW/RqKPC0FGyCXT0w9cw+MlPcuAv/pLHzzufA29+MyNf+xrZHTuxzdaplM1go1SyBqcwihaWKUj4DCUr1kXI2QcwRg9XfC1pFTxnbRe61sCStyxZEKDoXC9DYaWptcjSttIN3P7E/NsFobmuLH+E+0B6gH2pfaiKyrlLz23JMWVSJ14RMSySrAULadUyY9VJFjQW4y5JlvQc5yvZweYzxt0hcpaiM0WM9hbPYYGYL/neru8B8KHzPtRwMeDkz3/O+Le/A8Dy6z5NeO3aVh/icYeahcTgWgaV1GF3Md9KkjWRnwCgK9LFdN4k7toFGyS3ZXbBpiPcJw+AVQQ9Ch31ldaxjDeTJeOb/aEX0UQILaSS27mTuDOvMT6QrvxiTaLRMmIlKq4Jnba4Oe8wnAVenc2WollkODsMgFlIArBWd56T6KubxDhn0MOw5aXi4yYtg7XSBcfz41i2haqobqJYVRgFuOMzDBY3ArB0RfDr3Aa3kLjy+ZGXyYLtplCJnLnaDZ0zwy9kT11du+BckKyFli7YtF3QUW4n9pfM6i1LLEOtkPpRrmQBFeeyjkxkOTiWRVVEfHvJMYfE3zIX3yDCN4DMgw8y/X//B5qG1teLnc+Tvutuhj/7Ofa98pU8fuGzOfSudzP+3/9N/umnawarzAW8hMEpN75dUZWKc1B6TFxDimOVN5LvfVqSzwasgjBDybJt260taGYeC0qVrJgeoz3UQNJhC9FMV5ZrFyxMuqmCp/Sc4pKv2cI/j3wiYZFkLVC4dsGIeJNWixNtpJBYzmS5JGu6Esmaxxh3h8jl9E5AIdHkha0abNvmU/d9CsM2eO6q53Lxyosben7+iSc4+tFrAej567+m/fnPb+nxHa/Qk8G7sroDhF80GnwhS1ST0STpvF/JaiBZECDRS7drF0wzMhXcOlECOY/VvUGovTVgWjaTWa+M2B/fPu2LbzfGxykePEjcsfmOD1YuH20Wrl0wUwy0gJJKVpsVQlVUhswMg5pWN/hiID2AjU1Ui5LOihv7KkWQrmOSLOiHaxn8X6FGNgiXZFVQsoYz4mfsinShqXWuWw99DyYOuCSrvyd4X5ybMFhFyXLj29uc959z/V6fdMIvfCRLzmS1hdt8Slb1maxW9mRZ1gKxC8ZL7YINkw/XLniQHh/5rtaRJUmW//7uJgwOetfLPzozR6eu6KStbDMyogoCno97/X3D138BgM6XX87Jd9zB+pv/l/5rrqHtec9DTSSwJieZ+s1vGPjYx9l76WU8+afP58iHr2Hy5psxhocb+5mbgDt7NpJmyqnWiMT0iuqRnhAOBmNi5nFZlpe4eH6ZwlcX5R1Z6QymIt4P4QqbD0EgN71BWAWP1VhBM11Z/gj3Vs9j2bZ9wgZfHN+FCYuoCisjLpxGRNxkW6JkORdySxULY6OWkjUfdkGHyKV18eZudaLgbw/8lnuP3ktYDfPBcz/Y0HPN6WmvcPiCZ9F39btbemzHMzy74ETlB/i6snraTgfmTsnalzfokUpWIx1ZAPFeuqWSpVhMGylyRdMdGg+MBuaxJrNF5LosrBd5elIkv23t2crQfm/wN7dTROO2h/MMARMtJllSYSyYFtmiSTxc+72lOjNZSr7IScmTeHz8cXZGwvTX2WxxO7ISS5mYFgv3pbazGDoWyYJ+rPsToexkRmD/H2D9cxt6ulQiKgVfBJ7HMvJwx79i2zBYFPMy/bEDgY9BKlmHJ7JkCsaMv2Ph6X2AM4+leHZvqWT57YJy1qI93M5TWUfJqpEuWMi20FLmvCcCx2sfI8i0vqIeB8PAzuVQYg2ose3LRQqqVaTb8gja8rZqRcSOcuILtqrUleXOY62dqdZEGQcS5KNi8yt9991k7r0XQiH63v52Mbd18slETj6Z7jf+ObZhkN2xg8w995C+624yDz2EcfQokzfdxORNQvWNnHwS8WddQMcLLyF+bmvsYn4s7YjSHtGZyhvsOyo2EMLlVkEHoY4kAEZq5qbfk8PTjGeKxEIa21YEm3N0UaZkWalJL769QtBYEPTGetEVHcM2jsk8lkQzXVkdTjfiZGGypIS4FShkDcyitMovKlmLOA4glSwzVD1dEBqLcXftgk4/VDFT4Q0Ym0clyyFy06q4OLbSLpg1snzmj58B4M3b3syq9uC76rZtc/TD11DYtw996VJWfPazKNqJ01BeD1q3LCSur2TNhV1QzrpIJSvW7ExWOEFIj9E524RBtyMrSLKg+D10xkI8lXoCG5slsSX0xnpLioizOx4BoGuZWERPDLSWZMXDmjsvNx7AMijLiK1cjm29Ik7+kUi47nXgyLQgWcvblrs/e4/phPAcq3ksCS00K8ugVLIyRoasUXqtdElWvA7J2v5tSB1iOraVrNWJSpE+a2fgY+hKhN0+ur0VLIOlyYJdrtIqwy+enHjSfazfLjheS8mag+ALqWRxfHOsEiULaNwyqOluOFBP3vt7VS8idpQsn4tDWumGp/Lue6q8H6vkmA1hOc5p/di2zdD11wPQ9apXEVoxM9FQ0XXiZ55J79/+LWu+82023XsPq772Nbr/6s1Etm4BRSH/xJOMf+c77H/jm8g/9dSM15gtFEVho1Szjor7woz4dgd6h3gfFqdSUKYs3rtXXJ/OWpMk3EhQRX7KG4nwdWQZsyRZmqq5c1jHIr5dopmurM6wWIdNFaYYyY4Q0SKcseSMlhyPDL2IxHX08Im1llokWQsULslyI9wrn5iNkCxJ1GwlhI2CmalhF8xWWWC3Es5FbkoVF9tWKllf3/F1BtIDLE8s582nvrmh54594xtM/eY3EAqx8gvXo3c36PVe4HBnssZbU0jcFhJEImfmKJr1F/wyXbAr0kU6b5BolmQpijOXNctC4kY6smQRcTxUUkIMpT0huR1iod2z0alhaLGSpSiKL8a9/s+sOjNZdjbrkqydkQika5MsGbizLLHMnUXrzDuzE1WSBe1isDmxlmAWlsG4HifiLLrKLYNyTqs3WoNkFXPw+88CkD3tbwCIqZNoE483dBzeXNbMBb9rF+wwvA0yPLvgUGbI3dzwB1/IkupkrELwhXOfKLbQLihtd8e7kiWDLww9Ku6RzXRlOcpId2bC/VQ1u6A7A+S7vyciOqu7BcnbPZBiZDrvBp+cW0HJiuRFIERe7Wb6tv8j9/AjKNEovX/ztkCHq8bjtF18Ef0f+ADrb7yRk++6kxXXf57o1q1g20z8+IZAr9MoJJk8Oiyuff7Qi+k772Tf615P/umnCSXFe6xoKJAqDb+4p1mroFSxYl0QFQqOOTk5qyJiCUmujgclq5GuLKlkSZy15Cz3+jdbyHnk+AlmFYRFkrVgYcueLE28WaraBX3pgvX84/4LuamF3QTDEsznTJajZE3QWrvggdQBvrnzmwB84NwPuDH3QZC+9z6GPivi3pde82Fip5/ekmNaSNC7gs9kyULiWmWpkmSBNxdSC9KelYwmmc6bxJrtyYKZXVlTzShZzk5uoI4sh2Qlwi7J2tKzBcCnZIXJ7twBQN/ZwkKWmy6Sm24t+ZChBpONKFn5PNv6JMkKYxamhOWtCiopWYmsQ7Iq2AUHP/VpHj//WRQOBLfMzQprL4Z4r9jQ2XdHQ09VFKVqIXEgu+AD34Kpo9CxguLaSwEIKzkYaZBkVUkYtNJpjEGhGor4dm8B3hHuYElMLPKkZbA0wl3aBecpwl2mCx7nQ1nuQl9RMfQYVrr5rqxY6ihxRxGrZhf0gi9K733+8Iv7nXmsTf3t7vXWRXqUqOkoWWaC4S+IWazuP38Del+A1MsK0Lu66Hjxi+l95zsBmPzpT7ELre/NlAmDQ46lTSpZtm0z+IlPkt2+ndQvfoEedcYb7AgMPuY+37b981gNboRWSBa0pqYwnfXWbEjWyV3iPiHV5GOBZrqyQmrIPV+hdVZBgIzsyDrBrIKwSLIWLNwyYlUw/3okK2Nk6i5g9ZDqDh6bWgS7Ismaz5ks8T3GbXGxbW9Soi/HZ/74GYpWkQuWXcDzVwcPqygODnL4ve8Fy6Lz8stJvuY1LTmehYbAM1lTA/TFHEtaDZKlqZpLtIJYBv0zWbNSssDpynJIVjNdWYW0t3sapCPL+T10x8NuR9aW7lKSFbWzmMMjoGm0n76Vti7xHm+1miWtnEHsgnImy85m2dC5gZgeI6OqPB0K1dxwkUrW0vgyVzELTzu/rwp2wfQ992BlMqTvuaehn6VpaDpsfZn4eBaWwbGytFUZfFGVZBUy8AexWcOfvJ+CIW7FITUL04OQnQh8DNW6sgr7xUJR64ijhW3v2u1AqlmylNgtIw4Fswu2NsJ9YaQLarqKHhZ/q6Zj3N3wi/1cuu5S1neu55SeUyo+tJCfGXwBvvCLgamK/VguRvYQUcV5kT40TH7PHtS2Nnr+6q8aP+4ytP3Jxeh9fZjj40z97rZZv145ZFT9+KTYRJMzWZk//pHCXnHOmhOThJy/h2FHYehR9/lPj6QZnsoT1lVOX5Vs7JtX6MgyU1OuklXNORQE7z7r3fzbn/4bl667tOnXmC2a7cryq1mt6scCTtjQC1gkWQsWMsLdUMRCqdpMVkyPkYwkgfqWQUXxIlJNLQr5Cn7deZ3JEt9jzBKLiESd4fwguP3g7dx+6HZ0RedD538o8M6pXShw+Oq/wxwdJbJpE0v/6R+P+13XuYLWVWcmK9ELWgSwWaZOALXtgtDYXJYkWZ3hJNmiSazZMmJwurIcu2AzM1lSxYp1lygF1SAtcx1xb3Hr2gUdkqUNiDCMyMaNqNEoyX6xezgx2OIYd7eQOIhdUNyQrVwOTdXcReGOOnNZUslq15dg2ZAgi+qkQ1ZKFzSnRPhCYe/TwX+Q2UJaBnfdDAHsqn40rWTd/w1BpjpXwxlvcK13Id2x7ow+Wfl5FVCtK8u1CvY5MdGx0vOzfC5LvvfCapyC09dWuSfLSRdsYfDFQikjBp9lMBRvzi7o68r6pwv/iZ++/KfEq4T2yPOi/P7uD7+oNY/F8G6iijjGzCGhaHX/5V+gJZONH3cZFF2n84orAJi4ofWWQTmTlUuL96T8vU/88EfuY8zJCVeRKZYpWZJ8nrEq2XiYUSUlKzXZEiWrI9zBc1Y9h5DaXEJhq9BMV5acy+qMdLK5a3PLjkXaBRPJRSVrEccJpJWv6AREyhtfJTQUfuFczA0tApVa4OezJ8v5HkOWWETM1i6YN/Nc98frAPjzrX/O+s71dZ7hYfAz/0L2oYdQ29tZ+aUvojaSKHWCwZvJqkKyFMW1DC6xxY19rM7cjyRZMuGsGizbcklWWM7qKbNQshI9rpKl6lONz2Q1EHoBnpKlRI5i2ibd0W6WxJdgmRYZpwxZH9wHQHSzuIl1OSRrvMXhF8kGurIUh2TZ+Ty2ZblzWbVIlmVbDGTENSeqiOvGpqhzzkST7qxDyXOcRWv+6b0zvjZnWPNs0dmVHYe9tzf01O5Y5UJidyarEskqpOEPnxcfP+cDoIcpuFHdzjVu5InAxyBnsvaNZDCcDQOA/NOCqIadIffyTQB5/XtqUmwUuBsclri2hTSFRIUhdHmMpmG5iWCzxUJRsgCiCS/8ormuLKlk1bfEunbBSGUla9fRFI8dFdfMyiRrDxFV/F0Llo6WTNL9pjc1fsxVkLxSkKz0nXdSPFy5DLhZ9LZF6E6ECdvinIjEdIzRUVK//rX7GHNigpBzjhp2BIY8kiXJ57MatQpCXSWr2eCL4wmz6co6b+l59aspGoAMvnjGz2QVi0U2bNjArl275up4FhEQrl3QdkhWjTd9Y+EXUsmKoFZSso7BTNaQIRaZs7UL/n+P/n8cnDpIX6yPt50ebOgXYPLmmxn/7ncBWH7ddYRXH+Po6WMMOZNlTkxgm1V2sx2S1eMkW7VKyZoqTGE5Axw6Dvl2SVaDEe4AiT4vxl2fZrjRmSx3Hqt+6AXAmLMrm1fFTXxrz1YURSGTKoAtFpnqYWdxvEbc4JNLBXlseYx7opHgi6j7se2by9oRiUC6clfWcGYYwzLQFA1MQag2RibEFytYBW3LchetMnp8XqBqsPVy8XGDlsGmlKz7viZi47vWwumvBXyL6bjze25gLmtFMkY0pFIwLQ6Oe9afwj5xjoW7nMVQGck6KSnOWamoynRBwxDH0BkLV1Tr/db0VnVlyXHhheAOkIpKUY9jTc/CLpg6VFc5LbhKVumCdm1PgrCukjcsbBvW9sTp74jOfIHhPYTttHu8PW99K1pbg32CNRBevZr4s54lAjBubK7UuxY29rcRlSQrrosI+WIRdIfoT0y6aXRFOwLDe8AU3X8yWfD89Q2GXoBPyVrrfspMpTD02QdfHC9opitLzg5evKKxTtF68GaynuEkKxQKkcsF/4MsYu4gSVbRFH/CajNZ0GBXlrQL6lG0Qg0lKzfZVIFnQ3CI3GDRsQvOQsk6On2Urz3yNQDed877SAS0luUef5yj1/4jAD1/8zba//R5TR/DiQLXamLbmKkqypNjBWvPi3NuPFPA9PXClCMoyZJFxG2hNgpFcfNtV5ssIwZnJstLFxxu1C4oFYeAJEumC6asfYB/Hkt60sMUDziL4zWCzHe5dsHWkqxOR8kKFuHuLeD8Me5PhENkpwcrPkd2ZPXH+5nMiN/x+pBDRiokC1rT0+5qu3joEFYlJX2uIC2Du28GI7iaWamQOFPMkC6Khe0MkpWfgjtF+ADP+XsRI4/XhxSWC+AGSJaqKqzvnVlK7NoF253rdPlMlqNkHU0fZSI3Qc4U9/aiIch3pXks+f3kfaJV4ReektWSl5tTlBQSN2MXTCwRdmrbgslDNR9aqBJ8oWsqJ/V517uKKhbA8B5yBw33eJOvfW3jx1sHyauuAmDixhurb7o1iU397URlr2BUY9yxCnZeLuYozYkJQhFnJos4WEUYfZJD41mOTObQVYUzVycb+6a2XVHJslKplsxkHS9opivrvWe/l88993O8bMPLWnos6cXgCw/veMc7uO666zCMOV5gL6ImrEwGGyiaYqEZRMmSQ+i1IBMGDS1CqJifmUjolFkC4ERpzxmcmPjDBbHITMxi9+hf7v8XcmaOs5acxWXrLgv0HHNqisPvejd2Nkviwgvpe9e7mv7+JxKUUAi1XZCiel1ZMSdJzrZFEW81yDb5uiRLdmRFRLIgQJviLIobLSMGZyZrFj1ZDcS3g6foDeWFAiZnm/wdWTJZz1OyxM81OZTFNFtjzwIv+CKQXVDTUMLi8XY2S3+8nz4ljKko7JqoPD8k57GWtS1zf+7VmkNGKiQLloQIWJYb3DAvWH0BtPWLzaO9/xf4aZUKiSXhimrRmZs59/6nsEF3b4Btr3I/7SpZHU5hagN2QfDNZTnhF7ZtU3DsgpGEszFaNpOVjCbd439k5BH38/m8IFddVUgWeItMedyzhezJWhhKlhNhH4o1ZxdUVe/8r2MZLOYlyZp575OWQYDzKkWU51JY40eZetRZ5ikKRbv1Nrf2S16A2tmJcfQo6bvuaulrn9zfTsRRsuz9T1A8eBC1vZ2u174OECTLVbIU5702+Kg7j3Xays66ReszkBkFZ5PEPzdq+kjWiaBkNdOV1RXt4pI1l7TUKmjbthd8kXyGK1kAf/zjH7nxxhtZvXo1L3rRi7jiiitK/lvE/MDKZLDUELZzAao1k7UsIYoOgylZjgyvRQgbBXLlnntNh6izEJhLy6BZhLxQSdx0wUhzg6J3H7mb3+z/Daqics351wS6kdu2zZEPf5jC/v3oy5ex/LP/+owqHK4HrVsmDNYmWVrqMB3OBsBYujqBaVTJ6oqKZEGAxKwi3Hvosbx0weGpBpR62/ZIVtCZrEwBFIPB3D7AF98ue0ISGuaoeF+FVguS1ZaMoIdVLMtmaqR1TgKpVASxC4KnZlm5HIqicGpUREDvSFdeKMpNneWJ5e7ffpk97HzzSqEXpX/7Y2YZ/N3HheIUAK6S5bMLjuRG3K+VXGtyk3DXl8THz/2QuJY6cAMOnM4fxvY25BSQQQjb94v3hzk6KgiAohCKTIoHVQhmkeEXDw09BAiFOJUV1/zOCh1ZEi2PcZd2wQUwk+V1ZcUxm7ELQknCYC24dsEKLo5NPpJVMaJ85HHGn4hjZ0GzxHs8H2BDpVGokQidLxPKRqs7szYtbSfinBv5O34HQOfllxNaJjaOrVQK3bktGzhq+9Bjs7MKShWrfRmEPAXfnEp5wRcnwExWM11Zc4F8xnBnO+OLShYkk0muvPJKXvSiF7F8+XI6OztL/lvE/MDKpDFkv5NSe2elESXLm8mKEjULTOUqXJTnI8bdeW1bUUmRQFUgGmrcS1I0i3zqvk8B8JpNr2FT96ZAzxv9+teZ/u2tKKEQK7/wBXcOaRECetLpyhoLUEjcJnan5DxSJQQNvnDj26NdTDskKzabCHe/kqWaTBWmyBsBbzjpYWcjQIGudYGeMp4uoEYGMG2TZCTpboBMy/h2VZAorbcXrS3hHJfiJgyOD7QuYdAlWTUURj/kXJbtWMZPSwiitCM3XPHxpUqW+B59pmMtrJQsWGY9Lcxn+AXAhe8SnVkDO+CHfx7INtgdnRl8Ieex+mJlPUT3/IdQ/3s3wqlXlnxJRnWHOrtAjwnbU50FuB/P2yQ6r25/fJh03nCtgqEVK1Ad9bfcLgieZfCh4YcAaAu3uWmTNZWsFse4e0pWS15uTuEqWXoCa7rJ96MvYbAWvJ6smff3U5aL9daKZIyVXTODmMz9DzO6q73kmPOZuXEgJa8S5/PU736HMdq6zdeNSzwlq3jfHwDoevWr0HxrTaXohICZzvnqU7Kq2ihrYWKf+NeXLAhgTZ5YSlYzXVlzgYyjYkXiOnqjKZALAA3T8W9+85tzcRyLaBBWJuMVEUf1muqMJFmDmUEs20KtYXyXOzSmFiVhFpnKG8zoJY91A3vnVslykgWtSCdWVqU9UvtnrIbv7/4+T08+TXe0m3ec+Y5Az0nffTfDn78egP6PfITYtm0Nf98THV5XVjUly1lETx6iOxniaeooWaHGlKxkJOkqWW6Ee5M9WREb2iyLaVVF0dOMThdYngyQHiktXcnVJTue1VA0LVI5g1BSpHBt6d7intMZh2RFioJolIerdPXHGTk4zfhghmB0rj6SseB2QQAl5ilZAKcmT4KRe9hpVCbGciZreWI5Tzl/+2TRIVmV7IJl1qv83nkmWcnV8PofwbdeAntvg/99J7z8P4S9qwqk3S5VSFE0i4S0UOXQi+w43P1l8fFzPySUMx/cxXRMh96TBNEbeTxQ9xrAlmXtrOmJs380w//tGeZCmSy4Zg3k7hMPis1ccMrwi50jOwGniLhGR5ZEpNVdWY5aoS4kJSsUx5pq0tLq2gWrP9+2bfe8qDQD9OyTevjIn23htJXJivfGsR//HLOgEl6SINbTTuZw2o1DbzWimzYR3baN3I4dTP7PT+n5qze35HU7Yro7k6Xnp4mdfTaRk4VrQG1vx5qaQs2Ie4ZlKVi2ijWwkwNjGVQFzlnTxOZohXksEEq70XPikCzZlTV2JE1qNOtu5M03XBfHCRh6AU1GuBuGwW9/+1v+8z//kynH4nHkyBGmm/EnL6Ip2OkMpi5JVu03fF+8D1VRMSyjZHagEuTFw9AjRIwCU5XSo+Yjxt0hcMWIuEi2NxF6MZwZ5isPfQWAvzvr79y5n1ooDgxw+H3vF4XDr3gFyVe9suHv+0xA/ULiFeLfwjQromKnarRGwmBQu2B5ETFA1JY9WU3cJMJxCCW8GHdtKvhcVoPzWHLxqkUF+ZD9WOApWWEnqU/OY0kk5yD8oivh2QVnzF5WgBpxSJZTH3FK76kots1hxZwRYQ4ibAZEItVYpkiEAvFC9ZksV8lySM282gUlVpwNr/o2KBo88kO49Z9qPrwj0oGuiGuTtAzKImJpJQTg7q9AfhL6tsDWV8x4nYK/D6l3o/hkA3NZiqLw4lPFZtovdx71Qi9WLfMeFJu54JSFxFlD/E3bQ+2ufbRSR5aE3IxrVbqgtYAi3EuCL2ZtF6w+k2Ualvt7qWRPUxSFt1y8vqJaY4yPM/a7PQD0vep5RJ33ej49d7P0bgDGT34S6HoSBMW8iYo4J3QjQ9drXu1+TQYwKWlvk8ewI+ipQ7SR4dQVnbRHmxgxqNCRBaUzWSdC8AU015XVapzIoRfQBMnav38/27Zt4/LLL+cd73gHw8PihnLdddfx/ve/v+UHKDE2NsbrX/96Ojo6SCaT/NVf/VVgUmfbNpdeeimKovA///M/c3aM8wkrk3HtgrWSBQFCasjdVZULn2rwR7hHzQLTFUnWPMS4O3bBQjgJNJcs+LkHPkfGyLCtdxuXn3R53cdbhQKHrr4ac2yMyJYtLP3HaxfEIPaxQF0lKxQT1itgfUg8ZrwGyQocfCGVrKgIvlCxCNuzSBcESPQ2F37RaEeWs3gNxQXJkvNY4DXeh0bF12SyoIQMv5hoYVeWVLIMyyZdqG+RlEqWtAu2d6xkXVFcH6QSImHbtjeT1SZmslYoTtR7KFFxwW+lxN8+cpIgrYW9e1u2WGsIJ18CL3Nmp+78Atzz71UfqiqqaxmUG1gzOrIyY95rPO/DFZWxkoCDHud8aiBhEODSUwWhum33ELm9+wAIL3Ou1dHOkhkwCTmTJRFcyZKFxK2KcF84dkFJWIp6bE7tgv5QkUaVk9Gvfx2rYBFJFmm/7KVEJMmag5ksiY4/uwwlFqOwdy/ZBx9syWtKe6NiGRSjUdpf+EL3a65lcGoCh4dRTIjf60blEOetbcIqCBWVLLtYxMpkWlJGfDyhma6sViNzAodeQBMk6+qrr+acc85hfHycmK+Q9RWveAW33nprSw/Oj9e//vU8+uij/OY3v+FnP/sZd9xxB3/9138d6LnXX3/9CbVYtotF7GKxxC5YD25XVqZ2+IUb4a5F0W2L6XSFeM/5mMlyVLKcLi6kjZKsBwYf4Gd7f4aCwjXnX1PTIikx9OlPk3v4EdSODlZ+8Qsl3UCLKIVeL/gC3LmslU6i3FwoWXF8N4dmerIAEr10yxh3fZqRqYAR3g13ZBUAE8KCfGzt9pQsmS6oDTo2rxl2QWGFHG+hkhUNqYR18b6oRYAl1Ki43ku7IPFetjkx648MP1Ly2In8hKuOLE0sZTxd9EhWcnXF1bRUBaJbt4KmYaXTGEOV573mHGe+Hv70o+LjWz4MO2+s+tDyGPcZM1l3fQkKU9C/DTa/tOJruGXEEc0j7Q0mDJ6+spPlnVHSBZPJx4XKGu5zwhEqWAVBzJR1RTzCW0KyAgVftGZg3iVZC0zJsqaaVLIkyZoegGLlCG15TuhhtSEbZXFoiPHvfR+AvtNSKEu2uMecm0MlS2tro+PSS4HWBWBIEq8bWR7c+mzUiLcQl0qWNTnpFhIXu0Va62b1YHOhF1BRyTKnprAVHdux+Z4IwRfQXFdWq+Em6y4qWQK///3v+chHPkI4XPoLWbt2LYdb3PgtsWvXLm655Ra+/vWvc/7553PRRRfxpS99iR/84AccOXKk5nMfeughPvvZz/KNb3xjTo7tWEDadUxXyaq/qxI0YTDszmSJi9n0ZAW1UO5Cz2nwhViwZB2S1UgRsWmZfOpeEXZxxclXcGrvqXWfM/nTnzL+/f8GYPlnriO8auZg/iI8SCXLGK9xDnQIy+BSRTym1kK+zVGhGlOyDC/0QlFBb5IUl8W4B+7KarQjK11AjQyCYtAeamdluyChxbzpLibUA0K9CFWxC+ami+SmW7MbrSiKG25QK15fojz4gng32/Lib7rTCU6QkPNYvbFeIlqEUb+SVSFZEDwlS+/tIbRSnDsyhvyY4OL3wblvBWy46W3w9B0VH+aGX+RKSVZvrFcUNd/7n+KBz7um6nyXTBcMldgFG1OyFEXhRacuRbVM1AFxL470Oe+JCqEXEtIyCA7Jykq74PwFXzj94gtCyXJJViiO2eyIRLzbU96rdGUV875zogGM/sd/YudyxHoKtK1PQKKXqPO3zM2hkgWeZTB1yy0z0kKbQfqA2JDSjQw/WX5uydckyTInJrwAh4S4Fm9WDzSnZFkmTBwUH5d1ZMkiYoBQeAEUugVAM11ZrcbiTFYZLMvCrFA4d+jQIdrb2ys8Y/a4++67SSaTnHPOOe7nXvCCF6CqKvfee2/V52UyGV73utfx5S9/maVLlwb6Xvl8nlQqVfLf8QZZRGw4g/717ILgFRLXSxj0ZrLEmy87VcEOMS8zWeK1pzVHyWqg6+LHj/+YPeN76Ah3cPVZV9d9fG7PHo7+4z8B0Pv2t9P+3Oc2fLjPNNSdyQKIi8ckFXEOBVKyisF6sqSS5ca3hxLNr9DiPrugNs3wVACSZRow7hCAoEpWpoAadUIverzQC7mTp4dVlCHx9fKZrFBEo61L3IRaqWZJtWI8QIy7G+Gelb/zGNucMvQdo49iyZUyvnmsxHKyBZNc0WKl4qhSFZIFwVOy1LZ2IuvEwn/eEwb9UBS49DrY8jIwC/CD18PAzhkPq6Zk9cZ6hd2wmIZlZ8CmS6t+K2kXDEc173zKjkG6MUv2pacuoz87jmaaKJEIesy5V1eIb5eQ4RcgItyD2AXDLZ7JWlhKlhfhbmWyzRXwKkpdy2CJuhkQhUOHGf/xjwGpYm0GRSGSmNt0QYnYmWcQ3rABO5sl9fNfzPr1xm79PQAFbB5VO92+PSglWZL07DWXA3BG+AidNc7fqpg6KpI9VR3al7uf9s9j6SEVVTsxSFYzXVmthmsXXCRZAi984Qu5/vrr3f9XFIXp6Wn+8R//kcsuC1by2igGBgZYsqQ0407Xdbq7uxkYqK7MvOc97+HCCy/k8svrz+NIfOpTnyqJpF91HCoakmRZUbEwDWIXXNYWTMlyy4gdlSyXqkSy5mEmyykiTiniZwxqFxzLjfHFB78IwLvOfBdd0drpQmYqxaF3vRs7lyNx0UX0vuPtszjoZw60ZAC7oKN4dthit7fWQl7OZGWNLEWr+m7rhFOA3RXtIl0wiM8mvl0i0UuPaxcMGHwxsR8sQ8RtO4pdPYynC2gOyfKHXrg7eXEFBdB6etDaZs6XeeEXcxDjHmCH21Wy8t4N+eRwkohlMVVMcyDlDfH749tHnWTBVWr10AvwlCy1o53wekGy8nuPoZIFIgXwiq/B6gtFXP/3rvJ2uh34C4kt22LM2XzqsYD7viYe9Lx/qLoJYFk2RkGcf6GoJmyvkoiONmYZPHtNF1uNCQCKS1eg5KrHt0vIGHcon8mqbxdsnZK1gEhWwrsXGXqThcTgC7/YV/HLbrJggE1UiZGvfAWKReKb+kn0F6BPqKKSGObnKF1QQlEULwDjhtlZBu1ikYl7HgAgFRfXvscHvU04l2RNTrqFxDumxNrkZA6IHsNGIQlvx4qSGUYzNeXFt58goRdwfHRlLQZflOGzn/0sd955J1u3biWXy/G6173OtQped911Db3Whz70IRRFqfnf7t27Gz1EAP73f/+X3/3udyWEMAg+/OEPMzk56f538ODB+k+aZ1hpR8mKioVYQ0pW0OALR8nKp2soWfNgF5xUxOI7qF3wi9u/yFRhik1dm3jlxtrJgLZlceTvP0TxwAFCy5ez/F8+s1g4HBCBZrKcOZA2S6jBY9PVSVYi5JGk6ULlRUvRKrpKV1eki+m86c1kNTuPBSXBF2rQ4As3WXBDzYhvP8bSRTdZcEu3L/TCUbJiulgAlc9jSXS5XVktVLIa6MpyI9yzHskKxXvYUhDP3TGyw/28v4h43FnYrdEkyaqiZE2J80Rrbye8bi1wjO2CEqEovPb7Ihlw6ih898qSa5+/kHgiP4FhC+LR88B3wMjCinNEmEYVSBULfKWzvc2FX2iqwnPjwvpzqL3P2wirMpMFpeEXETVBwdlwSMbmL8Ldswse/yRL01TXnlbU482TLLnZUFXJcuyCAZWs/N6nmXSCvZb8ibO52LcZ8MI65irC3Y/Oy18GoRC5nTvJ7drV9OtM/e42Cs7MX8FxTlQkWRMT7u/ogdEEhq0SM6fEe7VRyHmssvh2KzV5woVewLHvyrJt2w19Wgy+cLBy5UoefvhhrrnmGt7znvdw5pln8ulPf5oHH3xwhtpUD+973/vYtWtXzf/Wr1/P0qVLGRoaKnmuYRiMjY1VtQH+7ne/46mnniKZTKLrOroubgpXXnklz61hB4tEInR0dJT8d7xBKlmmtAsG2FmRvvsnJp6gYFZf7Iacm7zh7Nrkpyss6OQNex7sghNIJav+z7hzZCc3PiEG1K85/xo0tfZzRr/6NaZvuw0lHGbFF7+4WDjcAKRd0EqnsQpVzidHyYqaYvE8mq4eFa6ruku0qs1lTeYnAZHo1h5uF8EXSiuULN9MlpZmpAYZdNHgPBbAaDqLGnVCL/xK1oRTxmiKxVq5VVAiuVT8jC2NcXfUiokGgi/snM+/H+/lVCf8wk+yKilZK5B2wSpK1pT4+dX2diKOklWY766saoh1wRtuEBaikT3w369xAwv8hcTSKtgV7iT0gNMp+bxralpZ5TyWqilosnC9ybksgFMt8T552O7EkmSwhl3QT7JU25nz1VTi4erXz5BMF8y1Zvd7IaULAkRbMZcl7YJVYtxLLKQBMPJvXwLLou15zyMWcea8nPNovuyCAHp3N+3Pfz4AEzf8pOnXmfjhD1xHTZtjJatGsqSSdWS8yNO2U1sw+FgT39T5W8yIb/cpWU0kHR+vkF1ZAKljMJeVzxiYRbHDEj9BlaymzhZd13nDG94w62/e19dHX19f3cddcMEFTExM8MADD3D22WcDgkRZlsX5559f8Tkf+tCHeMtb3lLyuW3btvH5z3+el760csLTQoGVEeqS6fQCBbELru1YS3e0m7HcGI+NPsYZS86o+DgvXVBcUArpCgs6ecPOjoNlBd7JbwjODuyoKRaW9eyClm3xyXs/iY3NS9a/hLP6z6r5+Ok772T4i8JW2P/RjxA79ZQWHPQzB2p7O2gamCbm+Dhqf//MBzkkK1IQi768YZEtmsSrzNe1h9tJF9NVSZYMvegMd6KpGum8QZ+0C4ZmQbLiTdgFG+zIAhjI7kdRi4TVGKs7PKIhlayIsyAuj2+XmAslq7MRJSsqrgl+JYt4D6cdFQRtx3BlJWt0uICOQY/tLPir2AVdJaujg/A6UblcPHIEK5tF9SXZHjN0roQ3/AS++WI4eC/85C3wqm+7dsHRnEeyekwTjBysehZs+NOaLyuJSokNyVWynmz4MLvGjpIFnox0MTGyk26oSbJ6oj10hDtIFVJYVhQo0BkP1VSVWq9kLRy7IIjwi+nxvFCymg14cO2CVZSsbPDgi9zu3aR+8UsA+t7xt3DjD8UXpJI1T3ZBieRVVzF1yy1M3nwzSz7w/oaTegv795O+626Mk64EoKszAhPw+IBHaGWEu38mK2TD4fA6TjYOw9CjcPILGjvwakXEqZS78XwiKVkgLINjR9LHJGFQWgUjcR09dGL9XiWaIllPPPEEt912G0NDQ1iWVfK1a6+9tiUH5seWLVt48YtfzFvf+lb+4z/+g2KxyDvf+U5e85rXsHy5GE48fPgwz3/+8/n2t7/Neeedx9KlSyuqXKtXr2adcwNfqHCDL2QZcQC7oKIonLnkTG49cCsPDD5QnWQ5N3pLCWMDRiWSJZUs24LcRM0beNNwVLIRS1gi65UR//TJn7JjZAdxPc57z35vzccWjxzhiCwcvupKul65WDjcKBRVRUsmMUdHMcfHCdUgWWp+goiukjcsRqcLxLurk6yB9ACpQuWwGX+yIMC0P8J91jNZjpKlFpnITlM0LUK1hpubIFnD+b0Qg1WJk0sqBeSNJjQp5iVDVeyCsisrNZzFNC20FgxfNxJ84Ua450tJllSydo/vpmAWCGthN11wWdsynthXYKkyhooFWgQSlTfW3Jmstjb0ri60zk7MyUkK+/cT3by56Z+xpejfCq/5b/jOK2D3z+AX76fngrcBpUpW77Rj06ujYoFv9sZ/jWuyKwuguF8sFA+1LWFqfFCQrBp2QUVReNWmV/F/B/+PJaGTgUdrWgXB29jLt6wnyzuWhQB/+EXzSlZtu2BJd1odDH9BbBh2XHYp0SUhMS8aboeO5c7xzp+SBZC48AJCy5dTPHKEqd/8ls6XvqSh54//6EfigxVrAejricF+2DM4hW3bKIpSMV0wBBR7N8PAH5pUsmR8+9qST1tTJ14RscSx7Mo60TuyoAm74Ne+9jW2bNnCtddeyw033MBNN93k/jeXRb/f+9732Lx5M89//vO57LLLuOiii/jqV7/qfr1YLLJnzx4ymdbt8h6vcEmW7MkKEOEOcNYSoe48OFS9KNBVxRQFSw1jVvp96mFxAYe5mcuyTMhOADAUQMmazE9y/fbrAXj7GW+nL15dHRWFw3+HOTFBdOtWln70oy077GcatK4kUGMuyyFZSnac7kT9xXx7qHZXlj9ZECizC5bOZOWffponn/8Cxv/7v+v/IIleYrZNVO6m69OM1rMMSpIVsIgYYNIW80UbOjeVfN5NFxwWN/jwmrUVn9+WjKCHVSzLZmqkNTdEN8LdCTuwLZtbv72Lu34yU0FRZRmxX8lK9LDSMOlSQhiWwe6x3WSKGdfauTyxnLF0gVVusuDKisq3bdvuYlVzLNrh480yKLH22XDl1wAF7v8GPQ+JBeFEfoKhjLC195oGrLkI1v1J3ZcruFHdfiXLsQuO7wMj+KyElclgOGFQh9r6sGQ6YY3gC4Crz7qamy6/iUJRLHa6aoRegLexV8yZWNbsC6Pla8yFKWIu4I9xlzbXhiEtadkxyM+85gVNF8w+9BDTt90GqkrvO98l7KwgQi8c0ipnsoyihRGgeHy2UFSVziuvABoPwLAKBSZvvEm8zkpxDVjWl0BVRNWETH917z8TE25PVshW6FxzhnihoUcbP/CqStbUCTmTBce2K+tED72AJkjW//t//49PfOITDAwM8NBDD/Hggw+6/23fvn0ujhGA7u5uvv/97zM1NcXk5CTf+MY3aPMlcK1duxbbtmvOW9m2zctf/vI5O8b5gi1nshS5sxJMkDy7X1gtHxx6sCRu2Q89rLrt6YYe9YpHy+FaBueAZGUnAHHTHSiIC0AtkvWVh77CWG6M9Z3red2W19V86cFPfpLcjh1onZ2s+OIXS8oNF9EY9C5xDtQjWWTH6XYW87Vi3GXCYDWS5U8WBEiXBF+UpvGl77qL4uHDroWmJuK9KFDSlVXTMpif9oaqezZUf1z50xQRonOKbx4LvBuNPizmKKrZBRVVcRMGxwdakzAogy8k+R3aP8Xuu47y4G8OYJml1wgl4gRf5EqVLAU4FfE+2jGyw53Hag+30xZuYzxTKC0irgA7l4OiIHqaUwUSXi8cB8c8YbAStl4Ol34GgOTvP4uCsCw/OfQwAH2GCc/7cKAhI1fJ8pOs9qViI8s2YSz4z19wVCw1mURp76DDdlThgG4DeR7Ui7/2b+z5gzuahbQLLpShrIhDWop6HCvdJMmKdnjk98jMjc+S7rQaGPrCFwDofPnLiaxfB8OSZHnqbyiquVbM+VKzkq94BSgKmXvvdc/LIJj69W8wx8fRly7FTAhLYFtbmLU9YsN1jzOXJZUsO5/Hsh3Vz4b1pzh9WsOPi6qNoDAKkHK6XmfMZE2ekOmCcGy7suQG44nakQVNkKzx8XFeuWivOqaQZcRFRVzog0a8bureREyPkSqkeHKistdfUZSSuSw7W+WNN5cx7pK4RTpJOWvyanbBPWN7+MGeHwDwofM+REitvjiYuOl/mPjBD0FRWP6v/0J4ZbDo7UVUhltIPFaHZJkFlsXFgr1WwqDblVVHyUpGkhQMi4JpkagSfGGOinPIGBmp/4OEohBu9yUMTtUuJJYqVrzX+xnrIFMoQETcwM9aus39vG3bXvBFYQKtu9slGZXgzmW1KPxCxnTLmayDu71Nk/JQA0/J8gdfiEXiNkMskneM7HCtgssTwqo0Ol1gBbWLiE3HKoimoThxzRHH1n1cJAxWwvl/DRe9Bx1IOufOniN/BKAnuRbWXhToZSouphXFU0kbiHEv7NsHiN/d8zf3ksQhAHWULAk3vr2OXVAPaai6WLS3Yi5L2gXVBTSTBY5dcDalu5sdG50srPahUIl8lyF9z71k7r4HQiH6ZP3IsJPILNVQxH1dHvNcFxJLhJYvJ3GReA9M/OTGwM+b+IG4nydfeRV5J10wHNfZ2C+ui3sGHFtxIgFOoNloSpznPdEQvSs3ihldMw9jTwU/4MmDgC1qOdpKQ9ys1JRbRnwiBV/Ase3KOtE7sqAJpXvhOAABAABJREFUkvXKV76SX//613NxLIsICDfC3RZv9qAeYV3VOb3vdAC2D1ZXHcN+klVVyZrDGHc3EUsUzkJlJcu2bT557yexbItL1lzCBcsvqPqSuV27GPinfwKg9x3voO3ii1t+2M80eIXEVUhWOAGaWMSviArSUtMu6JCsajNZE/kJwOnIcs6LmBt8UWoXNMYbIFkAiV66gxYSNzGP9ejwXhS1gG2FOKXXU7/yaQPTEAQ0kk9VjW+XcLuyWhR+kSyzCx7ykazyHW/Fncny/W7ivQBscxIHd47sdGsiZDffeKbgKyKukizoFBFrbW3uXI7blXUsC4nr4fn/CKe/1iXo+5yEyN6tVwR+iaq2sCZi3CXJCq9dy0s2JdAUwV7sgJsBkw7Z7krUt++0MvzCDb5YGBzLTRcUwRdNKlkAz3KI0e6fz1As3ZmsKvY027YZdipqul71KkIrnE3DYed86SudY3TnstLzo2QBXmfWTTdiG/W/b/7JJ8ncfz9oGsmrrnLPrUhMZ+NScX94YlD8vv1zWSPjwp68rC0qPKdLnIqMwQYsg+481uoZJ6K/jPhEVbKORVeW2xF5AtsFA1HyLzopbAAnnXQSH/3oR7nnnnvYtm0boVDpjte73/3u1h7hImbAymSwgaIt3uyNlBWe1X8W9xy9h+1D23nN5tdUfEwoqsNkAUOLouRzWJY9c4cxNodKlnzNeA9T49VJ1i+e/gXbh7YT1aJ84JwPVH05c3JSFA7n8ySe8yf0vv1vW3/Mz0DUnclSFKH0TA+yNJQFQjXtgnWVrJynZE07JKtDlUpWqV1QKlnW1BRWLlc/3SrRS09W3Kjr2gXdeazgJOvBQZG8pxZXENK9c3laJgvqJqptVI1vl+hqcYx7l0/JKuQNjj416X6tfPFcU8lKTUCig/2p/ewaE904rpKVrm8XNFOCWKu+yoywq2Ttw7YslONxYEdR4GVfoue7z+ZJshjO4qx35bMCv0TVgAOXZAVXsvKO6hdeu5aLlovf17Qd5emBHNtW1t8tHnfen511lCxxvDrZqWKLlKyFli7ozDiFZtGTBbBkM2x4Pjx1q1CzLv20+yWpcFYbB8g++CDZhx5CiUbp/RsRvoJleqS8b2PJ46OJEJNk56UrS6L9ec9F6+7GHB5h+o47aP/T2kmb4z8U843tf/o8Qv395DPC+hiJ62zsF9f4Pf4Y985OzJERRsZS9NJDnzxv+7fC4fth6DEg4IZHlXksACuVwoyemOmCsivLyJtMj+Xdjbz5gHRxnMhKVqDV+ec///mS/29ra+P222/n9ttvL/m8oiiLJGseYGUyzq6Ks+PbAMk6e4mYy9o+uN1N6SmH3y4YMQqkCwbt0bKbrlSy5mQmS7ymHet2FYvyMuJ0Mc1n7/8sAG897a3urnk5bMviyAf/nuKhQ4RWrGDFddcdn4u1BQi925nJmqhVSCxJVgbodBdxleCSrGKVmSy/klVwzgutIMb3yoIvjDGP/Bsjo/WtoYk+eqbF4kTRphmZqhF80YSStWtUEI+YVUoy3AhbW5CmUJV5LIlki+2CcjFtWjZ7d49hGV6IQb7MVlRxJishlKzO3ASr20/hwNRBfnfgdwAsbxMka7yEZFW2C8oYbLXdI8vhlStB17GzWYzBQULLKr/Hjzm0EN2rL4IDv3E/1RvrDfz0QrXZG7crqxG7oBOesm4t0aIgzON2O7/ceZRtKzvrPl/aRpN1ZrLAU7JakTDolhEvGJLlKVnm9ODsXuyCtwuS9eB3xBxfVPydKkb7+zB9+x0AtL/gBeiyCmdiv7DJ6dEZc0WSGM7XTBaAEg7T+fKXM/aNbzDx4xtqkiwrm2Xypz8FIPmqV2NbtntuhWM6m/qlkjUzYXAqlaI33ENS1oP0nyr+bSRh0FWyZpIsM5XCTJyYwReyK2vsSJrUaHZeSVYm5QRfPNPTBZ9++ulA/+093lKgTlAIkiXe8IqqoIeCk4ZtfdvQFZ3BzKA7O1EOaT809ShRs+iqBiWYy5ks5zXNaBdyHrpcyfrPh/+T4ewwq9pX8aZT3lT1pUb/8z+Zvv12lEiElV/6ontRXsTs4c5kVVOywJ1Z6tFEUEOrlCyXfKtVZrJ8c2LmyHD145OI9wQPvnCLiIMnCz6VEjuynfr6ks+7HVkOgQyvrq1kyRtgbrpIbnr2O9LRkEbUuX7s21n6Xi5fPLtKlp9kRTvBiaPflhSkQM7OLUssw7RsUtk8yxXntTurzGQ5JEtr95QsJRRy7ZP54/ze0pMorTBohGQVq9oFfSSrSom3H7Ztl9gF5XV0nDZu2TlQtQjcD2kbrZcuCF74hSSJs8FCKyP2R7jPyi4IQsnq2wyFadj+HffT9cqI03/4AwCJi57tfVKGXvSeDGrp87wY9/lTsgCSV4muq+nbb6c4OFT1calf3oKVShFauZLEsy+kkDdl/hWRuM7a3gQhTSFdMDk8IdR0eT8PFZ1NKpnatcQJFxrcGfxAqyhZtm1jTk2dsBHu4A+/mL+5LP888mK6oA8f//jHK8akZ7NZPv7xj7fkoBZRG1Ym43VkRbWGukVieoytTrpZtbksuaNqahEiZoGpSjdRl2TN3UxWIZz0vp2vqG7v5F6+85i4GX3ovA8R0Srvgkz//g8Mf/FLACy99lqiW7dWfNwimoOWdGayqgVfgEuyuhVBssYCkKzpQuVFiz/CfdpZgLQpzuuFyoMvfErWaICNgERfMJJl2zDqDFMHVLIs2+JwRqhf/eHSNEJJssJTggjWswuGIhptXeJ8b5WaJRfUg09MAFRNIVOiFZQsVXP/xtsSK0sev7xtOROZAn32OCHFxFZ1aK+sRkklS+soDf2QCYOF4zFh0IeemBcsEVJDblJmEBSq2QW71wsCm5+E6eqLUwlzbAwrlQJFEeTUcQRM0MHekTSPD9YnA3Jmsl7wBXg2tkK2demCC03JmrVdEASzlLNZ9/6nm4jnKpwVrPLG2Bi5x4RK0/bsSiRr04znyBj3+bQLAkTWryd29tlgWUzWqPkZ/6ETePHqV6GoqksGtZCKHtIIaSrre4XS/bibMChUv2hRkC5DJl32nyL+ndhfMR6/IqooWXYmA4bhVuacaMEXcGy6svIZbx75RJ7JaphkfexjH2O6wkUlk8nwsY99rCUHtYjaECRLDKE3YhWUOKtf9GVtH6pCspwdVUOLEK1GsuRMVrbGArtZOIuDfCgJQFtEd2fCbNvmU/d+CsM2eM7K5/AnKyv30BQOHebI+98Ptk3yla8keWXwQfRFBEPd4AtwF+AdTspZELtg1eALX4S7G4iizCwjtotFzElvtsgYDhB+keil2ylWV7UaJGt6EApTYvHbHazU/ODUQQpWBtvSWZ5YW/I1SbJkEXG1+HY/Wh3j3hkLEbNgekAsVJafnAQqzWQ5wRflYTgy/CJa2k+3LLGMMZ9VUOlYDlrl65VUstS2UpJ13CcMOuiJeiSrN9bb0MZX1dkbPeIt+AKEX0gVK7R8uZhBdJSscLs4tl/uPFr3NaRdsF6EO3j3nlamCy6UMuKoL8K96TJiP057lbDgTx4QJdd4Cmclu2D6zrvAtols3uxZBaFifLtEJDG/hcR+uAEYP/kJtjWzPia3axe5hx+BUIjkFeJe7Q+9kJDhF3sGnE49R8mKFMW1sCg7wOLd0LZUfDy0O9hBVuvIcq5Npn5iBl/AsenKcq3yCR09dOL9TiUaJlnV5ngefvhhuruDdXEsYnawMhmviDhgR5YfspS4upIlZ7KiRIwCU7kKO19uuuBc2AUFycrqYpcq4bPR3HrgVu45eg8hNcTfn/v3FZ9u5fMcvvpqzMlJoqeeSv9H/qH1x7gIdF/wRVUrkkOy2mxxo2rWLpg1suRMcQPoina5FlY3XdA3k1VuXwyUMFiiZE0xUi1qXs5jJVeLRXAAyHksK7+M3rbSAI60E2EbyU+idXW5Rby1MBfhF6sMcSvoXp6ga6n4XZbbBRWnU87OZkv/3s61YJMSRVfF9SiqRemOdjOarp8sCCIiGSooWesWQMIgpUpWI1ZBqL2Ydi2DAWLcS6yC4F5He5aI2bhbdg7UfL5t20w4SlYwu+AcpAsukHFZqWSZegxzugWbHaEYnPNX4uN7voJt2T674Mx7vLQKtvmtguDFt5eFXgBE5UzWPCtZAB0veiFqWxvFAwfI3PfHGV8f/+EPxeMueQF6j3gvSTIof9cAm5zwiyccJctuF2uEeEH8DYyCj8D1O86VIKXE+WnIyLnRMpI1KTb9TCfB9kSbyYJj05WVeQaEXkADJKurq4vu7m4URWHjxo10d3e7/3V2dnLJJZfwqle9ai6PdREOrEwa01WyGn/Dn7nkTEDY7uScix9ehHuQmay5swtOaZJkiYts1sjymT+KAtC/PPUvWdVReb5j8P99gtyjj6J1drLyC9cvFg7PETRnU8UuFt1agRlwSFbcFDfFyWwRw5y5kwnQEapeRixVrJAaIq7HfRHuM8uIy5U1I8hMVqLXI1lanvFsuvJxNjGP9diYsPWYuRUzFq/uTFZhom58u4Qb496yrqwQaw3xnl+5ucuL5s5UVrKwbeyib6GWEIuiSC7F5i6xg740sRRFUcpCL6r/fOaUky5YrmQtFLugT8nyE64g8CLcK2yYNZAwWPAlCwKuI2DV8hXoqsLugSmeHqlOCDIFk6IpyE4jwRfPxHTBsG/h37IZp3PfIiovDt5L8en7ve9VRr5t22b6rjsB3B4q5wu+ZMHqSlbuGChZajxOx0v+DICJG24o+Zo5nSb1vzcDkHy1l3gsSZbfrXOy7MpySNZhS1xPk6ajZPmLsd25rADhFxMHxL/RToglS75kOdcm6wSeyToWXVlpGXpxAlsFIWC6IMD111+Pbdu8+c1v5mMf+xidnV5SUTgcZu3atVxwQfWeokW0DnYm6ylZTdgFk9EkGzo38NTkUzw49CB/uro08SfQTJZrFxwTF/dW2jycxcG0Ii6osoj4Gzu/wdH0UZYmlvKWbW+p+NSJn/yEiR//WBQOf/azXnfIIloONRZDiUaxcznM8TG0tsTMBzkkK1KcRFHEqTKeKdLXPpP4SiUrY2QwLMNVRaB0HktRFJdkRS1n583Xk2WWzWAFUrLivXRYNiHbpqgooE4zli6wpKMs+r2JZMHHRsVN3sotr06y8pOE154Z6PXcQuKWdWWFaXOUrFWbuxlzbIgzgi98Mfh2Ngth52fxdead2nsqO0d3sqJNvO+EklU7WRBwwwNmKlmCZBmDg5jT6crn2HGA7qjn4uiL9dV45EwU8zJdsJKSFbwrKy+VLOd3Jl0G0c4+LtjQw++fGOGXO4/y9udWPnelVTCsqcQC2Hfk8eZbEHwhHWQLxS6oaSqhsEqxYJHP21UdPg2hvR9OvQoe/j7Fu78JXIWiKmhlwVb5PXswh0dQYjFiZ53lfSF1WIRnqLqY5yvDsVSyAJJXvZKJH/yQqV//GnPiH1yrX+pnP8PKZAivW0f8vHPdx1dWssT14cmhaUzLZk9G4UxgiZ1hCjAKPpIl57KGgpCs2smCIMYn4MRWsmRX1nzY9+S9b1HJcvCmN72Jv/iLv+C2227jb//2b3nTm97k/vfa1752kWDNI0qDL5obwnTnsipYBuVOjaGLmazpWsEXlgH5yjM0TcNZHKRUoWwkIjoHpw7yjR3fAOAD53yAmKPk+ZF99FEGPibCV/re/a6ZVopFtBx157IckqVkx91h+mqFxG0+Nao8/MJNFowmxdedHcuIPXMmyxgtVVfNQDNZfSjgFRLr0wxVKiRusCPLtm3XLmhmV9DtK3k1TYvMlLQLThAKqmQ5dr7UcBaziirYCLpshaSlYiuwfGPSi+YuD74IhcDp+CqZy3JJ1ggvXPtCwmqYi1eKsu/xErtgdZLlKlntpXZJrbMTzbEPSTvc8YjumEeyGrUL1ozqdhMGg89keXZB5z0Z7+bSU0XgSC3LoJyXTMZDgQiDp2S1IPjCUbIWUruGG36hhLHzNdJIG8EFIgCjsEfEs1cKtnJTBc87DzXs27SR81jdG0CbqUTK4z0WShZA9JStRDZvxi4UmLxZzJ3Ztu1aBbte8+qSn7XSTNaq7jjRkEresDgwluGRlKO8FsX1o7KS9Wj9dM4aHVlmKoWNgqmI3+mJGHwhu7IApsdadC7XgbTKxxdJVime85znuAXEuVyOVCpV8t8i5ha2bTsR7s0HX4BnGawUfhHy2QUjRpGpSnbBUMxTD1o5l2Xbrl1wzBaL7kRE5zN//AwFq8D5y87nkjWXzHiaOTHB4XdfjV0o0Pbc59Lztre17pgWURV1C4kdkkV23CUYo1XmnXRVJ66Lc6rcMuhXsgDSeQMFi7BUsnwkyxwX54++XCwsgylZYiFfN2GwQSXr8PRhEeRha1j5frp8JCubEh1fim0RKk7XjW+XaEtG0MMqlmUzNTJ7e0f7pHh/5zp0wlHdjaeuZANTfXNZLpzgCzKjnLv0XO55/T28fsvrgWBFxODNZPl7siS88Iu5n8sqHj2KbTZOGiJahPaQ2GVvdiarsl3QIVkTB6FYfV7CNk2K+4XlySNZznU51s0LT+lHVeCRQ5McGq+sgE420JEFczSTtUCULICIG36RcNMxZ42l22DtxRSs6qrJ9B8qWAXBF3oxM1nQf7zzHeEuoSiKF4Dx4x9j2za5HTvI79ol+rQuv7zk8fI4I77zUVMVTloirhE7D0+yfcJJp8tMAGCZtrfx1LdJDPllx0RgUS3UULKsVApT867bJ2LwhezKAkjN01xWZlJ2ZJ3YdsGGSVYmk+Gd73wnS5YsIZFI0NXVVfLfIuYWdi4Htl0S4d4Mzu4XpcS7RneRKZbedL3gC5kuWOWi7O5gtzBhMDcJtlh0jFviYmqHDvJ/B/8PXdH58HkfnnEjti2Lwx/8IMXDhwmtWsXy6z69WDg8T9C7xA5+1a6sCiQrSIx7qli6YeNPFgRBsqL4XqeCkhXdKBYbxshI/Y4gPQzRTnpMf8Jg2XGaRRjfJz4OOJO1a0yoWHZ+KaDT7bMLTkuroDGFgk14bTCSpahKSxMGQ8Pi5xxvE++rakoWgCITBv079/I6kBZkKqR6i6LxdL5uETGAOT2zJ0siPE8Jgwd//Ct++J6b2fWF/27q+XIWq+GZrFp2wXgPRJOArzqgAopHjmAXiyjhMCFnc8Etio/30NsW4dy14r1aTc2acBa1yViwRY9LslrRk7XAyojB15UVimPOtivLjwveQdES77NQpPQ+ZmUyZB94ACjrxwJf6EVlkhV1SZbhktr5RudLX4ISDpN//HFyO3cy/gMn8OLSS2d0WLpFxPHSzYeNjmXwhgcOMayK35M66bkX3PCLUEyoeiDUrFpwlay1M75kpryOLEWhoV7ShYT57spKLwZfVMYHPvABfve73/Hv//7vRCIRvv71r/Oxj32M5cuX8+1vf3sujnERPlhOR5kb4d6kXXB523KWJpZi2AY7RnaUfE3uqBrOTFZFuyB4C+hWKllyYRBKkDIk2RN2ozOWnMGG5IYZTxn5yr+TvuP3onD4i19A880LLmJu4dkFJyo/oBLJqmIXhOoJg1LJSkaSAEznDRL4Fvo++6g5Js7HyEahAtj5PFY6ABmJ99ZWssb3C3tsKF6176kcch6rmBUzSl0Jj4DIdKWwc84HDb4A31zWLMMvbMumeFTsXB527nVyUZPPztxckXNZJUpWwpvJKocxNURUKWKjQMfKGV+XqJYuCBBe7yQMznH4xeO3P8Vk8iSe2FP9/KyFV258Jaf1nca5S8+t/2AHpmFhGWLBW3HDTFECWQZdq+CaNWKDyba967Jj7b70VBFpXY1kuR1ZQZWsaAuVrAVWRgye/a6ox7HSLSRZJ7+IQpvYWAibpZtX6fvuwy4WCa1Y4SmWEjVCL/zHiz1z3nK+oHV20v6iFwEw+o1vkPrFLwBIvubVMx4rg3ciZW4dOZd1++PDTDmpsqpZcM8dw28ZdBMG68xl1ZzJmnRJVijSWC/pQsJ8d2XJCPdFu2AZbr75Zr7yla9w5ZVXous6F198MR/5yEf45Cc/yfe+9725OMZF+CBJluns3DdrF4TqUe7+CPeoWWQqW2XRIXewszMXV03DN0cgbYqKLhbIUsXwY/qOOxj58pcBWPqxfyK6ZUvrjmURdeGSrLEq54AkWUaOJTGxkBqrFo8ObolrOcmaoWQVDGKyIyuUKBnmMJxy5NDy5agJ8T4xhoMkDPb5ZrKmGCmfyZIx2t0bAg+PuPHtueWENIU2nyXMVbLyE2jJZEObA27C4CzDL0YOT2PlTArYHFBKFzXl6YIASlTcECvPZM3cbAlPHwIgH1si1MIqcHuy2meSLC9hcO7sgrZtkxmcEN+nSWXmjae8ke9d9r2GioilVRBqDNS7JKt6wuCMZMH8lNgQADek6MXOXNYDB8YZSs1cSDVuFxTH+0wsIwbPfmfo8dbZBQFUleK6ywAIZQ54qSBA2mcVLFns27anZMnzpQyarrpzN8eiK0tCWganfnkLdi5HZNMmYmecMeNxuQrBF+ApWQCGqmNGYiiAHhK/j6I//GKJE35RK2HQtmvOZFmpKUy3iPjEswpKzGdXlm3bZCalkrVoFyzB2NgY652dxY6ODsacxdVFF13EHXfc0dqjW8QMzCRZzb/pJcl6YOiBks+7M1lOD1AuXcWj68a4t1DJ8u2+ygQ5WxU/s1QxJAqHDnH4Ax8UhcOveTXJl7+8dcexiEBwZ7ImqtgFI+0i7QpYHhbnUbXgC2hEyTI9JcvXkQVeumAu1o3au0R8LlBXVq9rF1QqFRI3EXohlSwZ3+5fGLlljPlJQgFKiP1oVVfWoV3i93pQtxiX6XKSZOXNGbYiNerYBUtmsrzgi/IB83hGFOCa7dVVLLtYdJUxrQLJcu2C+/c3NS8VBMXDRyg4wl2hqNS3l7YIktBpIRVVq3I7lgmDNbqyMg8+CEBks2MVkxtfesx9fyztjHLm6iS2Db96dKaa1UhHFpRGuM/297XQyogBojL4olWFxD4U+88DIGyMweO3uJ93Qy/KrYLpEciOA4p3vtQ45mM1lwUQP+/ckutd8tWvqvh3lwpp+UayLCSWUJ3NKd1ZCpUmDAboysqOi4J5qDg3aqZSXrJgk86hhYD57MrKZwxMw5mnWyRZpVi/fj1PO7tmmzdv5kc/+hEgFK5kmad2Ea2H7CMyQrOzC4KXMPjI8CMULe+iG/ZFuAPkq5UtxqvbhJqGXBzEukk7sr+BuAD6SZaVy3H43VdjTU4SPe00+q+5pnXHsIjA0B0lq+pMlqK4alZ/SFy8mykklumC/pmsODOTBQGMsTFGuzZz4y81Hl9xqfhcYJLltwuWHWeDoReDmUHG8+OoioaVX1qSLAhehG24MEF4TbB5LIlki+yCh3aL99t+3WQyW8SybM+eY89UdVy7YMlMlhP0YBZEhLQD27bpzB91DrhGR5Zvgaq2zQy+CK1YgRIKYefzFI8eDfyzNYLs9gco6o7qqYQwJybm5PuUwyucrbFZVifG3bYsMnffA0DiggvFJ8usghLSMviLHTNJ1riz8O5sMPjCsmyM4uxSLhdaGTF4M1nFUMytIGgVCob43YaULNzzFfG5Q4eFLVTTSDzrWaVPkCpW11oxi1TnmHPHKMYdnACMK4WapcTjdL7sZRUfVynCHWB5Z9R1BHTGQkR7xD1B08Q5VMz7zkWZMDi8B6wqGzRyzratv+LvTgRfnLjx7RLz2ZXlVpck9HmJiz+WaPiS9pd/+Zc8/PDDAHzoQx/iy1/+MtFolPe85z184AMfaPkBLqIUM2ayZmEX3JDcQEe4g6yRZc/YHvfz0i5oaFFsoFi1aHYulCw5rO3ZBQ0EyfOTrIF//mdyjz2G1tXFyus/Xxplu4h5g+YEX1SdyQKXZPU5ts+xdPWIWDf4olAWfJEXry/PgXTeIK44rxMqJVnm6CiHVzwHgKHIWgCMIDHu9WayRiTJChZ6IVWsJZE1YIdqd2QFTBaUkCQrN10kN93cgsksWhx5YgKA/SELy4apnIEWUt3h7hkx7jL4Iuu7EYfj3kxc2vs9Zwom/fYQAKGe6j+f5aTSqvE4ij7zeqZommuDmyvLYGb7dgwnLdXQYxQPHZ6T71MON7691uLNtQs+WTGKOr97N+bEBGoiQWzbqeKTPtu1HzLK/d6nRxktO78bDb4IhTVwBIjZzmUtyHRBn5JlTbfQLoiPfKt52Pd7OPqIq2LFzjhjpuI7UjtZUCKaqB5qM5/oevWraHve8+j/4AfRKmysgDcTGikj/YqicHK/eM65a7vRHTeFrjibsn4lq2udmKE1cjBW5dpRYx4LhJXZPIGLiCXKu7LmEp5V8MSex4ImSNZ73vMe3v3udwPwghe8gN27d/P973+fBx98kKuvvrrlB7iIUlhZxy6ozv5NryqqG+X+wKBnGXRv+IqKpYYoZqrZBediJkvuwPa4dsG8JRZhUsUY//GPmfzJjaCqrPjsvxJavrx1338RLsyixc47Dte0pNWdyQKXZHU7ts+xGruobSFx86ynZE1XUbKsfJ5cAUa7hRc/Yyco6omASlZfMLtgQCVLkqzesLBXV1OyIvlJwg3aBUMRjbYucQ1oVs0aeHoSo2gRaw+RiYpbgbRyeuEX5UqWE+GeK7smJGSMu3cejPni20Pd1UmWTGZTO6rPMs11wmD2ge0UnfoAU49RPHJkTr5POYo5mSxYY7Osa62w3BbTkJp5XOm77wYgft55ossMSuLb/VjVHeeU5R1YNvzmsdJY68mstAsGU7IUVWlZ+IVrF1xQM1le8IWZai3JkgpyaImTyHnPV0jfKUhWxf7HOvHtEpFjXEgsoXV2surfv0JXhcALiWrBFwDnrRPn9fO3LHFTCTVbPL6kK0tVvSCQagmDNeaxQNgFTf3En8maz64saZU/0eexoAmS5Ucul2PNmjVcccUVnHbaaa06pkXUgC2VLEWcnLOxC0LlUuJQ2LuQmFoUs5qS5c5kzZVd0OnvscQNrDPSSXbHTgb/+f8B0Hf11SQuvLB133sRJbj9B3u4/ft7+MMN1WdB6vZkgUuyOm2xmK6lZMnQgOky25lUsroiXdi27dgFZ85kmWNjDPWdha1653CqfVXDdkFVzzCWzmLKmaRcCqYdi1XPzITLSpDx7W3KWnHsidLFqyxjjDRhFwRmHeN+aLf4m63c3O32d03I3eMq4ReKnMnKlf0NK8xnjqULrHRIltJVoyPLKSKuNI8lEXbCL+YiYdCcnCT/xBMYDskytBiFeVayam6WaSHoFkS9kmUwfeddACQuuMD7pC++vRyXbRNq1i/LUgYbtQtC68IvLFfJmtXLzCvcCHc9Tvree1r62jIQJbRO3J/th28gfZcg0zP6scAXelGHZDnEMJc+tkpWPViW7b43yu2CAO95wUZ+9LYLeM25qzyS5Yw8lChZAP1O+EW1hME6SlaJXfAEnsmaz64sj2QtKlkzYJom//zP/8yKFStoa2tjr2Pf+OhHP8p//dd/tfwAF1EKK5PBRsFw2sdnYxcEL/ziwaEHvRhdVXF3bAwtAvkchlnBcz8XJMs3SzDl7OZlDEfJyukcvtopHP7TP6XnrW9p3fddRAkeu/MIu+4U8y+pGoW3cibLnJysHkrgkKx2Z7ZuPF2sOihfaSZrqjiF6XSnJaNJckVhbXPtgmHPbmKMjjHgDI1ruri8TbWvwRgNRrKSloVj7cfW0oxKQjjmdBQl+iCWrP9aeEpW2BS70X67YDFvurv/wi7YmJIFsw+/OLhLvG9XbemiMyauJ1LJilRVspyZrHIlyx9+4WBs2teR1VljJqtGsqBExAlbmgu7YPahh4Qt2lFEbVUjf6RyzHmrUZQdWZWKiP2QFtWyhEErnycje5Mu9JEsn+26HC925rLuemrETRSExu2C4Itxn21Xlu/es1DgRriHEmTvf6ClGwAu+V6yGlY9i+ywgpVOoyWTRLdunfmE4drx7RJRqWQdw+CLIPAro5XWONGQxnnrulEUxSNZprhWlyhZ4JGsekpWhblR2zCw0mkv+OIEVrJg/rqy5AZjPLlIsmbgE5/4BN/61rf4zGc+Q9g3B3Pqqafy9a9/vaUHt4iZsDIZd1cFZpcuCHBKzylEtAjj+XGeTnk3CTfGXY8SNQtM5yvcRKUVpaV2QW8HNl0Q33PamESxbCL/798pHjlCaPVqln/6U4uFw3OE4QNT3PHf3o55NlU9qMItkLRtzFSq8oMckhU3xWK6YFqVzycqz2TJ+Pa4HieiRdznVrILjh8YJdW5HmyL054nEu1S7asxA85kqUCX3FXXphiZcn72BuexhjPDjGRHUBUVKyeUAz/JklZBzcwTbovMKOIMAjfGvQmSlc8aDO0Tv2OhZInF12RGJgx6xaV+KDFxEy6ZyQIv/MKnZE1NjNCuOGSss0ZH1pQsIq6hZDl2wfy+1itZmQe2Y6khbMVbzGUOD7X8+1RCICULqoZfZB98EDufR+/rI7zBp7BWsQsCbOhrY2N/G0XT5tZdwjJo27ZnF0wEV7L8CYOzgUwpVxcQyZKExYyK83bihhta9tqSfIejOlzwdqaPint+4oLzUbSycyU74ansNZIFwadkHeOZrHqQ1x09rLqbZdUgr52qIa5JbhmxhAy/qKdkVbALyg2gZ0LwBcxfV1ZmYtEuWBXf/va3+epXv8rrX/96NN+b/fTTT2f37t0tPbhFzISVzmA4/mBVU+pegOohpIXY1rsNKLUM+hMGI0bRVZVK4LcItSryOCssTHasS9gFlSJ5M8cr/2Bh3nM/SjTKyi99Ea3G/MYimkcuXeSWr+7ANCyWndTpfs6spGQCSijkztJUtQw6C71QfoKYkyQ0ViVh0FWyip6SJePb/cmCAEnNeY2QZxd88lFhneuzB1h7mlBXptrXBJ7JAug2BdEoCb9w57GCWQWlirW+cz2prFg4+mey0r6OrGasggBdS6VdsHGSdXjPOLYtiFp7d9RVL2SMd8S1gZUpWRGHZFVVsjySZYyJxcuU1jUjZt8POc9SS8mSJMscHqlO5ptEdvt21yrofm6ohv21hXBtYXVJlhN+URbj7lrILrygNDSihl0QvM4saRlMF0yKpriGN6RkxSorno1iIZcRG4SwFJXJ//kf7EJzRdblKDkvNr+E9LB4byRWVbjfS+LdsQKite+Lx8tMVj24Kn8Ap47sF1QL4ppUrGYXHHsaCmXWasuCiQPi4wp2QRnKY0WEW6Lu+3SBY766stKLwRfVcfjwYU46aebgt2VZFIvH9xv3RICVyZQkC7YijaniXJZrF4wSMauRLOcGbhZmXryahbNIK4S7KJo2ipZh5bDNVXeKm/Cyj3+M6KbavvNFNAfbsrn1W4+RGsnR0Rvlsr85zbXvZFPV39vuXFbVQmLxdbJjLtGoRrIqlRHL0AuvI0uci5268xrS5mXbPH1IXNJWx4fpXdUOCuSjXaRTBWyrMlF04Wwa+BMGnxp2ZsPk4rbOTrHEY2OCZG3p3uIGfXT5SZbjSQ/nJ5smWVLJSg1nq5LgavDmsQRxlQW0ci4nLBdj2cpKlj1jJsu5FvjSBZk8KI4vsrTmsbhKVkd1kqW1taH3CRLcyvALq1Agu2MHxbKEytzI5Lx0ZbmKRT27YJVCYjf0wj+PBVUj3CVklPsdjw+TzhsuuQ7rKtFQ8GVBuEVK1oIsI/bNCtn9KzHHxpi67f9a8tquwhnRMSZT5Jy3VaJwx8wNTTmPVSf0AkS4ARz7dMF6kHbGSABV1VWy8mINYpTbBRO9kFgC2DBUJgRMD4j1i6JWVNvlBpAZdUjWCa5kzVdXljuTtWgXnImtW7fy+9//fsbnb7jhBs4888yWHNQiqkPYBcUboVVxomcvORuA7UMzSZapRYia+cr2rlAcpHWxFTHutu3aBTOaWGwrWprVw+KmEjvjjKqdGouYPR741X727RhF01Ve/NfbiLaFiLWJm1x2qvoOrZ6s05Xl2AXJTtQlWZVmslySFU0CnpLVrpWSrMGnU0znQ2hmnlV9RcJRna5+Z2cuvqJ+95EWgliXmzCoatP8z0NOmluTyYJbe7Yy7vys3T674LRUsgoTTc1jAbQlI+hhFcuySQ03dlOU/VirNotFuCRZk3WCL9wy4hnpgjM78/TUIfGpeO30T28mq/YufNiZy8q3kGTlHn0UO5/H6uov+XyxaLu72HOJQmAlyznvUoch7yz8JifJ7dwJlIVeQNUId4nNS9tZ2xMnb1jctmfIncfqioca2riT9yD5czSLhVhGrGqq+3eLvVjcl1plGXTTBaOaCDaxIZI0CeWegCdvLX2wTBasE3oBHjE8lj1ZQZBvRMmSJCsnNsRm2AWheimxnMfqWCmu/2UwU5MAWI4SP9ugseMd89GVZdu2S7LiHYt2wRm49tpreec738l1112HZVnceOONvPWtb+UTn/gE11577Vwc4yJ8KFeyWoHTl5yOqqgcnj7MYFp49OXN09QiRMwi0/kKF2VFaW2MeyENzvDqtCosANFIjk5HJNOX1t4RX0TzOLh7jPv+V4QK/MlrN9K3WpAd2caeqTWXJcMv6pKs8cAkK11MY1jiRiuTBbsjYsEoZ/Xa1VKSteceYX3qG36ISJ/4nkvWiPNoqn1Nw11Zamiahw9O8MRACkad4IsAM1kFs8BjI4Jkbe7ezFhm5qxLZsKx5eUnCa9tTslSVKWpuazp8RzjAxkUBZZvTAKeRWxm8EXp+16REe4zZrJmBl/EMiKhr9hWfR4LPEuO1l65L0dCJgwWWhgwkN3+IADKxlNKPm9o8xPjHtguGOty7ayS8KfvvRdsm/CGDYT6S0lirZksEGTGbxlsJvQCWqhkucEXs3qZeYd8n0Se8wIA0n/4A8XDs0+m9J8Xsh8rcZZDou75cumDA8a3g0/JOt5JlrO5E66QLFgOSbKUjCBZM+yCAEtk+EXZXFaNeSzwVHbTKSl+pihZc9mVlc8YWIZ4vy/aBSvg8ssv5+abb+a3v/0tiUSCa6+9ll27dnHzzTdzySWXzMUxLsIHK5PBcJWs1pCsRCjBpi5xgZZqlowqNfUoUaNQ2S4IFaObm4YkalqElCVuBtFojo6MeEPq3V2z/x6LmIHp8Ry/+a9HsW3YcuEytj7bUx7i7QFIVnedQmIfyeqpQ7LafEmB6aJg13ImSypZ044dpM0tI45jGhZPPCA2CJYO3ofeI46pb40TpNG+GmNkuOrP4CLR55Kspd3inL/l3oegMA2KJjqLqsCwDG564iZectNLGMoOEVbDrG47mYIhdlb9M1nT/pmsJpUsgC4Z494AyZJWwb7V7e6iSypZE27wReXSUk/Jqh980Z4X6ZR256qax2NOOz1ZdZSsiNuV1bqEwcx2cb1TVpeSZ0OPtWSxXA9SsQh0LfeXEuNZBWeoWFB3Jgs8y+Btu4cYSIm/ZyPx7fDMtguCN+NkdfQSP/98sG0mbrxp1q9bcFMnNdJ33glA28vfLFjoU7+DoV3egxsgWe7myXFuF2xoJqtMyZqRLgjVlawa81gA5qTYAHom9GTB/HRlyXnkaCKE1oA1eaGiqZ/w4osv5je/+Q1DQ0NkMhn+8Ic/8MIXvrDVx7aIChBKlkOyWqRkAZzdLyyDspTYH+FedSYLfCSrBYPivtjhtCP5h8NZOpz1o9ZdfcGwiOZgGha/+tpOslNFele18Sev2Vjy9ViHJFnVL7j1Z7I8ktVVh2SF1BAxR6mVCYMyXbArUhp8kVBkumAb+3eOkk8bRKw0XeN70LrEeblkjTPj1b46mJKV6HXtgt3t4mfetcMp6u5aA/rMnX7Ltrhl3y284qev4Nq7ruVo+ih9sT4+/SefJl8Qi7CIrrqhHwDpcWG3ixQmCc2CZLlKVgPhF+481hZP5UjGy4Iv4pUXz6o7k1VNyfJIVk9RKIt6jSJi8ClZNWayAMLrWmsXtG2brEOy7KWlRNDUo/OjZDkLwkCLN2lVdYIOMr7QixIUMuAkrVWzCwKctrKTFckYmYLJzQ+LnzVoEbFEqyLcXZK1gOyCAFEfaUledRUAEzfeWL3OIgBMw3J3+u1D+zCGh1FiMWLP/TPY/GfiQfd8RfxbSMOkQxTqxLeDN+NkFK05UypagXyNIuJyqO3toKpoprh2zejJAi9hsFzJqlNELDv8DFX2ZJ3YJGs+urJcq+AzIFkQmrQL3nbbbeTKb7KLmBdY2Qymaxds3Rtehl88OCTsM6GofyarhpIVa6GS5bO4yIW0HvKTrEUlq9W46ydPMrA3RSSu8+K/3oYeLj2npJJVK/jC7cqaqGMXLGboi4nFQzWSBTPnsmYoWc65GPOVET9+n1jQL5vYgYLtKlm9q9oAm0Kkk6mjE1W/pwtfITHaNF3xEMmsCHAon8eybZs7Dt3Bq3/2aj5w+wfYl9pHMpLkfWe/j19c8QsuWXOJqwx1J8IlC8jpUXFSR0OG+/trBo12Zdm2zUF3Hsv7vnJxXV5GPCP4IirTBauQrOw4mOI5fZaIQY/2ra15TO5MVlttkhWRdsH9B7CN2e/EF57ehzk+jhKJYHb0lnzN0OZLyQoY4Q4+JetxiocPU9i/HzSN+Lnnlj5OXkfVUEmHXDkUReFFpzgBGE8IlbdRu2C1FMpG4c5kLbCNbalk5dJF2l94CWpnJ8bRo6Tvuqvp1yz65tsKfxSvEz/vXNRwGJ71DvGFh38oQmZksmCiryahlghHNVctPJ7VrEbsgoqqonV2olniflCRZPVtBhRhZ5721TPUKSJ2lSynl/REV7Jg7ruyMjJZ8BkQegFNkKy7776bl770pSSTSS6++GI+8pGP8Nvf/pZsdm7TSBYhYM+BXRDgzCUitOSJ8SdIFVKE3eCLKBGzUHkmC1o7k5X1hrWnHJKl6RmfXXBRyWolnvjjII/cJsIJnv8XW+nsi814jDuTVSP4Qs5kVQ2+iHYKqx3QHxIX7lokqzxhUAZfSCVLhrDEbPFaeSvBvkfEwnLJITG/oPWIcyUU1ugMiWvTyNEA9gefXXAsN8rlZ6xgveIoGr55rD8O/JE3/vKNvOPWd7B7bDeJUIK3n/52fnnFL/mLU/+CqKM2u/NYvtAL27bJTIufoa2vNrGoB6lkBY1xHz+aITNZQAupLN3Q6b1OuV2wiq2oahlxrAtwSGR2HCMzSRJh32nvX1/zmIKkCwLoy5YJklcsUjx0qOZjgyC7XSiUsW3bKORLh+WN+VKy3ICDRuyCT5C+5x5AHPuMfjG/VbCOMnTpNkGyJMlJNmkXzGdnGXyxQJUsv/1OjUTcYKaJH/246deUqqAWUsncKa5nbc++SHxx9bNg+Zlidvn+b3glxAFCL0D8fuUGyvEcfiFnQSMBz0etsxPVUbKK+QrBF+E4dDvXIX8pcR0ly5RKFuL+VTcF9ATAXHdlucmCz4DQC2iCZP3mN79hYmKCW2+9lcsuu4z777+fK664gmQyyUUXXTQXx7gIH/w9Wa0kWb2xXtZ0rMHG5qGhh9ybfs0Id/DZBVtAsvx2QWchregZOheVrJZj7Eia331XxNme9eI1rDutt+LjYu1B7IJ1ZrIUxY1xX6KLOStJPiqhXMmSwRcywl2eG1FbLPSfeiqCaVh0L42RGBNWMr861N0pFoAjEwEWcPFeuh274Hh+nCvOWsY6Rahk2fa17BzZydt+8zbe/Ks389DwQ0S0CH95yl9yyxW38Ldn/G3JTBngJgv6Qy9y6SKWJY6lfWXl33tQSJKVSxfJTddfNEkVa/lJneg++6K0C6ZyRUzLrloy6ypZ5cEXmu5F9WdGSA2Kv8OkHaezq/bmSNB0QUVVCa9dC7TGMphxQi9iZ53lBgHE2h07lR6lMA9KlrQLBlOyHJI/9pSrlMywCkLd+HY/zl7dRV+7t6OcjDe28Gld8IX4d6GRLPf66Cwck1ddCcDUbbcF6+arAM9CqpK9X2wEJOTaSlHggneKj+/7Ggw8Ij4OMI8lIQuJ8+njV8mSqaaRAEoWiLks1y5YzQbpzmU5lkGzCE4CajUlS1qZDUu8P090uyDMfVeW7MiKLypZ1aHrOs9+9rO58sorecUrXsGLXvQiLMtaLCOeB4jgi9bbBQHOWiIsgw8MPuBFuOsRokbBtWjNQIVZjKbhLg563IW0raRdu6Des6hktQKFnMEtX92BkTdZsamL81+6rupj4+5MVoCerGpKFriWwW7VIVk1lKy2kCAqM5QsWUbspAuGHSVrz2NihXbS1gQKgggoca9ctq/f6YDKRasfn0Sily5HybJsi+XdFptDAzwZCvFXB37Da3/+Wu46che6ovPqTa/mF1f8gvee817XylgO+XP6lay0kywYKkwRW1M7ea8eQhGNti5xswoSfuH1Y5UuwDtj4ndk25DKFktKZqXKAKDGnOCLfIUbsC/8IjO0D4CjyhK0GmEGtmV5SladdEHwWQZbkDCYfUAsYONnn+Uqdu3OLq6hxTAOz72S5Ua4B7EhJVeDFsEu5kjfJcIQEhdeOPNxmfqhFxKqqvCiU7xkwoaVrBbPZKkLLPhCqv+TI2LDJ7ppE9HTTgPDYPKnP23qNeU5oWNgF4uEli8nvG6t94Ctl4vi4fQQ3P9N8bkGSJbXlXU8K1nBZ7LAIVmWVLKqkKzyhMHJQ2Bbooamrb/iU8zUFJaiYdnivHxm2QXnxp2WcYIvngnJgtAEyfrqV7/K6173OlasWMGFF17ILbfcwkUXXcT999/P8HCA9K5FzApWJuMm3bS6s8E/l1Ua4V5w7XszIGeyWmIXHHNf01XOrCnanPWcTLFbRPOwbZvbvrub8YEMic4wL/yrU1C16pcBSbKyNdIF3ZmsasEX4JKspFKfZPmVLMMy3AAMSbJkumDYzJIy+ziy3wAF1q1w5vi6u0t2xGX4xYTdXb9gNtFLCEg6jpNHBrfzpZ4iV6xYyo7CblRF5WUbXsbNr7iZjzzrIyyJL6n5cjIS3Z8smHY7spqPb/fDswzWLgQ3TYvDjwuStWpL6XsppKm0O1aY8UzB20G2Sxctrl2wXMmCkg2Xwug+AEb0yosXCSuTcWUMtaO2kgUQXitIVn6WCYPGyIiYaUL070nrlNzFNfQY5uQk5nSLStYrwLZt1y4Y6FquatCzgfykjjk+iRKPEzvttJmPk7brWDDl/1Inyh0gGTs26YKWJPILi2PRIUmWr6cu+UonAOPHNzRVaC3PCc0p101cdFGpwqeF4Ly3Og92zs9GlCy3K+v4VbIamcmCMiWrGskqTxh057FWg1r5HmimUpiaRwaeCUrWXHdluXbBxeCLyvibv/kbbr31Vq6++mr27dvHTTfdxNVXX83pp5++4KT+hQa7WMQuFLyZrBamC4KnZO0c2QlhcXMwtagTfFFtJmsOgi98dsFoRiywbVVB6+ys9sxFBMQjtx3iyfuHxA72X2+rWwYov55LFzHNCl53vJksK5PBylexFToLvk5bqBZTOcONNi+HS7KKU0zmRRmkguLOaolzw0Y3szye/RMAVmzsIuI8tpyM957Uh2IZFLVYfQuE00Uk57KuvuN9/Lwtjq0oFFOncv2zv8snLvoEK9uDKVAVlaxJGd8+Oav4domg4RdD+6Yo5kwiCZ3elTNVo05f+IUe0tB0cXvwh19UDb4Aj2SlR7DHReJZKly7207acZRwGDVSf2dTFhIXnt5X97G1kHlQWAUjJ5+M1tnpLupkspYZEb+f4pG5swwaRcu1yQVevPWeTHpA/J7i556DEq7w/m3ALghw/rpuN/jEbx0MAqk0GAWr6vUhCOTvYaEqWVMjOSzn5++49DKUeJzCvn2uWtoIpJKlTgmynLjo2TMfdPZfQMhT64POZIE353RcK1kNpAuCIFmq07FZrFRGDJ6SNbQbLLPuPBaI65MkWZquotXYkDxRMNddWenF4IvauPHGG3n961/PD37wA/r6+rjwwgu55ppr+PWvf00mEzxGeBGNw3LCRVpdRiyxqn0VvbFeilaRQ1lxATK0CBGj6IYNzMCcRLj3uJawWFosypVkJ0qV3aZFBMPRpya56wbRsXPhVSexbEN90hpNhNw0qmoJg2p7O2iO8jkxUfmFHJIVNaZc+9h4lbksf/CFnMfqiHSgq+J8n84bRCii2BaPZ58LwKbz+zHHxfmj9ZQuLiPLltCWFtavob11zlPH8tZreD/rszNZrh/SyR1+A/c90dhOfyUla3pY7D6H8xOE1rRSyap9/T3kzGOt3NRdsY/IC78Qx1wp/EIqWRjCylSChFSyxtCmxKzDdHQ5tWBOyY6sYAEgnl1wdkpW9gER3R47W2ws5ZwFp9zFNSOCuM5lwqA/RS4UDkqyNpIeFIuTiv1Y0JBdEEDXVL702rN43yUbOXtNY3OvIZ9lvTiL8At7gSpZbckImq5iWTZTTq+Q1pag47JLAZj4ceMBGEXnXqumJ0DTKv+dY11wxuvEx5FOaK+9meGHZxc8jpUsaRdsRMmyakS4A3SvAz0GRhbG99VNFgQxLyo3tZ8JVkGY264s27YXI9zr4eUvfzmf+9zn2L59OwMDA1xzzTUcPnyYl7zkJXQv2rnmFJZDYt0I9xZL14qiuGrWE2mRWuQpWfMQ4V5uF1QM4mnxhtS7Fs+t2SCTKvCrr+7AsmxOOmcJpz0vmBKjqAqxNnFTzlZJGFRU1VWzqs5lOSRLzY27u+bVLIN+u2B5siAIJStOjmFjPePmSrSQyoYzl2CMivOnPIVS6+ykfVrEsA88XmcYPd4NKLx1YpKXrH4B31rxEv5jcJitXaKD5sbthzCt4BYgV8nykaypI+I4o0rOLdKcDbqWOl1ZdZQsOY+1akvlhXSX25VVGuNeyHpkSol5CZQzVEvXLjhCJC3ISaF9Rc1jkj00MxLyqkAGX5jj49XTLANAlhDHzzoL27LdQXu/XRCgOIdzWUVf4WzQEl67cx2ZIfF3SlxQYR4LSqowguKik3t51/NPbtiNomkqulMoOpu5LGmrW2hKlqIqnr3KZxnscjqzUrf8CtNRa4NCKlmamSN2+unV3xsXvgsSS+CUl9dNkfTDswsen0qWaVqu5S8S0L6qJTtdu6Bl2pVVVVWDJU6X2OCjdZUs27ZL7ILPBKsgzG1XVj5tuB1wiY5FJasqRkdHufHGG/noRz/KNddcw3e/+106Ojq49NJLW318i/BBkiwjJElW6+NE5VzWo1M7AG8mq27whZEVJZizQVm6oKJl3NCLcO/sUtieybAsm1//16OkJwt0LY3zvDdsbmgx5ca415zLSgK1Conl7N64u5ivR7JShZTXkeUkC4IgWQklzx5HxVp3ei/hmI45KhaX5SmUiqqStMVxDe2rs+BRNYh3c34uz6e2vpWzM0JpWbLuVLriIQZTef7wZPDUsHFnIdMd9ytZ4jUTbVpLLNZSyUoNZ6tatgo5g4G9wk65cnNlkiXDL1ySVUHJUsJhd0Fnl9d2+IIv2rOCnJh1bJVmSiYLBiNZajyOvkzMEDVrGbSyWXKPieH32FlnU8ibrl3NDb5QxN9rLmPc3dCLBhZvmUGwTRUtahPZeHLlB2UbU7Jmi3CVTrVGYDunbVCyeTyhc4l4/00Oe/e/6OmnEzn5ZOx8nsmf/ayh15MKp2bkK1sFJbrWwvv2wMu+2NDru0rWLEnWwV1j7Lnn6KxeoxL8831Bw738M1lQYy7LtQw+VlfJsnM5KBYxdYdkPUOULJi7riypYkUTIbTQM8OZ1PBPuW3bNvr7+3nb297G4cOHeetb38qDDz7IyMgIN91001wc4yIcWBnHLjhHM1ngm8uaeBgQ6YLhWhHukXZwbFyzDr8oIVlmCclaDL1oHvf9714O7xlHj2i8+K+3NUzO4+31SZaWrNOVJYfws2Ouda4RJcuf3jedN4nbeZ7IXQzApvOXOt+7spIF0BUVJ9LIYCFA+IWYyyI9DKNPiZ+v72Redrqwvt3wQPCOJrcnyxfhLj3pbb310/SCoC0ZQQ8Ly5J/N92Po09OYpk27T1ROnpn9qGBX8kSx1epkFhRlPqFxKkjtBnib6F217ZDWtMyWTB4X1hknWMZbDL8IvvIDjAM9P5+QiuWu4tNLaS6M4imrWEp6rzYBRt5P6Z3CdKX6M+i5CYrP6jBmazZohXhF/I9uRDHujsrhF8oiuIFYNxwQ0OvJ5Vj3czRVq8WpwkLvRvhPgu74PhAmp/928P89lu7mBhq7ZiIPK5QVKsZyuSHlkyi2AaKw9aNanNZMvwigJIlFUjT2dR+JpGsuerKckMvks8MqyA0GXzx0EMPMTw8zE9+8hPe9a53cVqlhKNFtBxWJo2lqFiqOEFbHeEOsLFrI22hNiacnX9b0QhbNgXTIm9U2B1SFJ9NaBYkq5jzkpJiooxY0dKLRcSzxNOPjPDALeJm8qdv2Ez38kTDrxFzY9xrdWVJu+BElReRJGucnrbgJEvOZHVHvQVjOm+wytDJWkli2hSrtjo9XaOVZ7IAkl0KqlWkWCxdDFWEq8iMwMgT4uOek7jq7FUA/OrRASaz9XeBbdt2CYt/JiuTczqylifrvkYQKKriqlnVLIOyH2vV5q6q6lnSF3wBQQqJq5Cso6K7J21HaEv21Tx2V8kKkCwoEXZIVr7Juazsg8481llnoiiK+/NF43rJjJGpzW0hsbTXNbJ4y9zn9Cb152H0ySoPkqXu86RkOUpcITf7mawFqWRVIFkAHS99KUooRP6xXWR3PlrpqRWRPTwIQEiH6CmntO5AHcjgi2btgrZtc8cPHscyxd8saBF6UBQajG8Hh2QBat0Yd4dkHd4uIvChbkeWnRCzy60ezzieMVddWbK+JP4MiW+HJkjWO97xDk499dS5OJZF1IGVyZTEic6FXVBTNU5fcjpF1VsAq6qOZpnVLYOtmMuSKpiiQbTTtQsuFhE3j8nhLL/9prBFnfa8lZx8bu047WqQSla14Avw/j71ZrL8dsHRKiTLH3zhKlmOXdC0bLJFk5UF8ZiTkjvcxCfDsSpW6lML9/bQNi0UqKH9dSyDCYdkje71bsQ9J3Hqig429bdTMCx+/kh9m8x03qDoLETkz2yaFnlTLHI61gUfVq+HrjrhF4d2Of1YW6qrG7KIdnzGTFZZIXGsipIlgy+cfrPDdi9dido3U28mK7iqF5bhF03aBTMPyHmsswFvsRlJhMSMUdg5n/TY3CpZjRQRI4bwszuEjTvRX4CRxys/0J1tnZ9rZmuULPHvQkworkay9K4u2i+5BICJG4IHYGQPi2tObPUyFK31C/uonMlqUsl68v4hd74TYLLVSla6sdALwJ1t1dyEwWox7g5plSXEkY6q7xNXyXJIVijS+vXW8Yq56sqSG7XPlPh2aHImaxHHBnYm4w5kayHVjVhuNc5achYoNpYmLnZuV1a9uazZ2AV9VkEUhWlXyRKf1hftgg3BKJjc8tUdFLIGS9d3cOGVJzX9Wu5MVpXgCyBw8AXZCXocVWe8ASVLBl+kCwYhG3oLSQA29e1ynyfnwbQKISl6bx/tUyJWfGj/VNWfA/BI1sF7xL9t/RDtQFEUrjpbzBjd8MDB2q+BN48VD2tEQ2KxlJksgKKgWCbtJ82uiNiPZI0Y90yqwOhhMQe2clP1hXcyVpYuWGXWRo04JGvGTFYpuT1k99FTh2R56YLBlayIjHFvQsmyTZOsE98eO+tMwBcX7Szq5OaVoccwx8Zm/pwtQtGdyQq2eMvcdx9YFuG+BKGEWZlkGXkoiN/pfNkFq5HxRrCQlSzZlZUazpYUdwMkX/VK8bWf/dydqa6H3LAT3X7S2tYdpA+RWZQRF7IGf7hBqPuxdvE61SzKzUJebxoZh/BIlkwYrGIXbFviORVAqFhViL0kWXZMXJueKcEXMHddWVLJeqYUEcMiyVpQEEqWLCKeuze8nMvKa94MWMSsFePuLNxmYxcsS8RySVZa3LS0RbtgQ7jjB48zcnCaWHuIF7311FkR8liAmSxZSCznoma+SFL8mx13k/bq2QWni9OMZsV5IWey0nmDjUUNFY2kdpglSedGaNs+JasSyeqlwyFZw3VJlmNxO3if+LfHI6iXn7kcTVXYfmCCp5wAi2pw57EqhF6EC5NEnKS8VqCrhl3w0B7xe+ld1eb+LSvBi3AvDb4oZCorWTPtgqXhNELJqp0O5ipZHcFnsqRdsHDwIHah+jlZCfknn8SankaNx4luEt1CrpLl/PxycWe1iXN6riyDjdoF03fdDUDi/2fvz8Mcqe6rcfzUolJpV6/Tsy/MDjMwDGY3DgbsMY7BNo73+IuNgThesf06OHEW5/X+CybGSwiJ1ze2SWKwQzZsDCSY3TBgZpgNhtl7ZnqRWvtS2++PW7dUUmspSaVWS33P8/Awo5bU1dOlqnvuOZ9ztp5BHqBWVjuyNkeAd256BT1uBF/QmaweXJGEhmRwPAdV0a15Swr/+efDs3w59HQayV/+quF7qfE4iuZ1Mbi5RrBJm7AH2lSSwkZ4+t8PIZsoIjLiw6veSD6HiSmXSVa2/PPoBLwsg5NlS8mqGXwBlOaygIYdWQCgyURlX0gzWZ3qyirFtzOSxTAPoduUrE6EXlBsGdkCD+9BkSeLKE2UIatFJGsWErswk2VLxCqqOoqqXhZ8ITK7oGPseWwcex8/CY4DrrrhTAQH5Lbezx9uTLIcz2QV0zDt3rVJlqe04D6WIoqRpWQVVGwukpvdBt//gDNLY/VUCjB7m6qFpIgjwwilyGza5NEU9HqLC3o+F0xboY1kjYZk/N56QsLuaRCAEbfi20uLhcRBsmCX1ZT1b+YG6nVlWVbBjfWVDWoXnMnVDr4AAF4mv8BZdkEpANjszCeM4cZKFp3JCjonWeKiReD8fkDTUDzuPIQEALJmOazvnHPAiXSxSc4baqOi11ZjhASddIpkNWsXzDxBSJb/wgvIA1VJFt2sGmgpFKEVeE0lTmkjwp1+HnvRLigIvLUotScMAmay6XXXAXDWmZV94gmo5mdIXtSZjUWZkhejudj9qeMpvPA/5PN22TvXY3AxUc8TE51RspqxCwKkqoM3layadkGglDAI1O/IMq9NukSurQtpJqtTXVlZFnzBMJ+hZ7OlZMEOzGNReAUvzho+C0XBJFmNYtyteG537IIZUzHjRNtMVpU5G4bZmDyawiM/JTai869Zg+UNFtZOQElWzkG6YE27oBwFbRodFcl5VYtkeQQPfOZmwskMmX2iStb0ZA4rVXLZWi8/AnjIDVA149v5QAC8d/bCXhwehj97GoJehFLQ6ndKBSrCGobKrZbXmZbBe3eeqNuZZXVk2ZSs1LFJAIDsUV1dUFKSlc8oyKdLmyGGYZSFXtR9D6pkZVoMvrCH4AA4LYzC16BkV0+Z6YJNKFkcx5USBpu0DOZ2UqvgudZj1gyISYbpYsoYIjNznZrLKjZhF1ROnSI/K88j8Jod5MHYK4BWsfE1x/HtQCmAqdBGGTHMj1Gv9WRR1JrLAoDIW94CCAJyO3eicPBg3fdJP/pYya3SIeVE8JTmDvMZZyTL0A38708OwNANnHHuCFacOYTIaCkcQa9RHdEKqHLeTPAF4LCQGHCsZGlJkt6pmfeYhaRkdaori9kFHWJmZga33XYbPvjBD+KDH/wgbr/9diQSNeJkGVyDnslCFWl8e2c/8NtGt0Hhya6DJngh14txt5SsNoIvsqVhbWpL9HJpBMxNFDd3/fsV+YyC++/aBU3VsWrLELa/vn58tlNQkpXPKDV7mBoGX/C8ZRkcFohlrlbwBQAEPUSh0gxys6RK1vgL0+DAgfdOISxOEPXE9n1rkXFhaAi8oSNoluRO1gu/CJTb3jBcbtu5YtMoIj4PTiXzeKxOZ1a8SrJg6hT5voGAu/tbHq+A4AC5ccVtBDIxmUM6VgAvcli8Nlr3PSgZTBVUKJpuFYHOCr6gEe65Kn79QOnfPyMvaXjcWqq5niyKUsLgoaZel91JlCz/dhvJqrBH0sWdESHnQadIFlV+nOyQZ54g84HyWWdBWLaRbC7oSimGmmKO49sBd4IvLGW5NzlWXZLlWTSK4GteAwCY+dk9Nd/DMAxkHn201MvUQeVEbnIua9+TJ3HqlQREr4BL/4BcDwMRLwSRVEekXFQ7rJmsZpUsW1dWzXRBwLGSpZtKVqkna+EEXwDud2UZuoFMktoFmZJVE8888wzOOOMM3H777YjFYojFYvj617+OM844Azt37uzEMTKY0LNZaNQu2EElCwC2L9oORTD9zYIMWSvWmcmi6YLu2AUzRfJ9ogpZjBs8DyEyN/MFvQpDN/DgD/YgOZVHeFjGFddvdm2IXA54rPfKp6rflEszWfHaPVSmZXCAIyQgnq3dWUXnsigGZPLaqd3kPAkETQXDJFlUyaoVkCKOEHUqlCCL8rrhFw2ULK8o4NpzGndmVVOyMnFywwoMVO+qagcDY9QymLEeoylgY6sjDXdiw7ZrSjKn2GY3yn/nlpJVqHLztSkouUBjkkXnHprpyQLsCYPOSZZy8iTU8ZOAIMBnqx2xItwDFTNZIXMm60SnZrJMJcvBDnnmiccBAIGLLiIbFvScnK6wDFqbVV0gWW3YBY0+UbJqhUBE30Y6sxK/+EXNOcLCSy9BnZiYG7eKnxYSN/6d5TMKHr+XKHDnv3G1ZT/neK4s9MMtFNpQsvhGwRcAMLoRFpuvq2SRa5PKd570zke43ZV1bG8MumrA6xcRiDIlqyZuueUWXHPNNTh8+DDuvfde3HvvvTh06BB+//d/H5/4xCc6cIgMFHou19EiYjvOHjnbIlma4IVXrUOy3Ihwt9kFqS0xkjcXi9EQuDmaL+hVPPvLIzi8axqCyGPHTVusBaMb4HgOviB5v1pzWZbSqCjQM5mqz6EkKwxzh1A3kKyx+20nWSInIugJYup4GsXpAlQYGAmZHUFUyaIdWTVIFh8IgJNlK/zCMcniBGBg1ayn0JTBX754quasYjUlK5slN//gmPubBtFFsxMGj+81rYKbGivBosBbRCueVWqmC1oR7tWULDP8omB4wAcbVwZo6ebTBYHWEgaz5iagvHEj+ECpLy5foWTRn1vzkd9Rx5Qsayar/rXcMAxrHitw0UXkQaquViYM5krX0bkCPX5X0gV7cCYLqK9kAUDwsldDHBmBFo8j9dDDVZ+TefQxGIBV09LJRb3XinFvrGQ9+YuDyKcVDC4JYOsV5YmopZ/bvRj3yrRPpyB2QTPCvZ6SJQWAS28BznobMLyh5tM0M5RH48i9byHZBQH3u7L2PEo2q9afP2bVriwEtKRk/cmf/AlEsfQBEEURn/nMZ/DMM8+4enAM5SDBF53f5QKAiDcCn59c7Ild0EHwRVszWdTmMmSRuVCBXLh5FnpRF8f2xfD0fWSxedm71mNkRXOqgBP4GoRf8D6fZSNrFOPuKSQQNK0XNIGvEnaSFZWj4DgOB546BQB4xaMj7DFJkumX1+K1kwUBsngTh4cRShJ71dSxVO05AjlKyBVACJYwm7BuWRrB+kVBFOp0ZllKlo1k5RTyc4dX1C/pbQWV4Re6buD4fmehF9Z7mKpbIlcsSxe0K46l4IsqC0rzWnDCGGrYkQXYlSznPVmAzS546FBt5bQCObMfy2ezCgK2RV3FTJZmEviOBV/QdMEGi+niyy9Dm5wCJ8tW7DyG15P/V5Ks7NyTLHcj3F05pDlHZIR89hIT2arnIyeKiLz1rQBqB2BkHn0UOi9Z/widXNRbdsEGhcSnDyXxork4fs271s9aHDcil62gmKM9fc1tFNrtgnVnsgDgyr8E3vbduuEwesJUskDO74VHstzrysomizj0O2KtP/PVjR0O/YSmL2nhcBhHjx6d9fixY8cQatLywdAc9GwGmkDTBTv/gR8y7TKqaEa415zJctEu6BtEpqAB0BA2F+AeFt9eE+l4Hg9890UYBrDp4sXYfElnLmABJwmDzRQSmzf5WKa6l7+MZHmj0HUDB54mJGuPR0WAM3fXJLI4Vy0lq/a5Ig4Pw5+bhEc0oCo6Yidr7L7yfGnjoGIei6K8M6u6ZZD2ZA2axEUvFJAXyPFG1i2teZytgtoFqZI1dSyFQlaFJAsYXens2kzDL+KZkpJlGOU7w5xMyJNRVcmiJGsYg42KiAsFGGYiJB9uTsmSVpJ+Gz2ZtPrRGoEqWf5zy0lWKcK9XMmiG1rq5CT0gnszJxRO7YJWquB554GXTMJuKVk17IJzGnxRPSClGfRyGTFQ6hUq5jXrfKpE9G0kZTDz+OMoHi9XR/VcDtlnnrHOOXCdXdR7A40LiXXdwP/+dD9gABsuGMOSdbM3OztBstpSspykCzoEnRdVdbJMXkjpgoC7XVn7njgJXTewaHUYQ0ub21DrdTRNst7xjnfghhtuwD//8z/j2LFjOHbsGO6++2588IMfxLve9a5OHCODiblUsgBgLDoKwFSy1HplxCbJKqZJGWYrsA1spwtKWXy7d8j9Xf9+gKbq+OU/7EYupWB4eRCXvXN9x74XVbJydQqJxUYJgzaSRRfgsRoLkrBUWnQPyAM4cSCOTKIIw8PhFY8OPyjJMpWsGJ3Jqq16iiPD4GBgIEB+hgkn4RcV81h2vPmcpeA54NkjcbxSpTOL2gUpocy+ctSaqQyvGK39vVsEVbKSkzlomo5jplVw6YYB8A7tGaUYdwWihwcvkEWvXaWwlKxqM1nLXwUdHJ7Qz8Rgo44sU8UCz4P3+x0dX+kYZHiWEqLqxDKopVIoHCCqj29bdSVLrujJUjQenI/8rOrJ6mplO3BqF7T6sahVELApWZUkq7xvcC4QGfUBHJCOF5COt3b973UlS5RKwTO1Is2l5cvhv+hCwDCQuPfesq9ln3mGzGqNkY0bySt0lHCWZrJqK1kvPnICk0dTkHxizTL7cCdIVqvBF5EIeJouWM8u6BA0XZCSrIUafNFuV5ahG5ZVcPOlC0vFAlogWX/zN3+Dt771rXjf+96HVatWYdWqVbj++uvxtre9DV/96lc7cYwMJsoi3Ds8kwUAywbJB0ITZHj1XO2ZLG+kdHdsVc3Kmgtz/xDSBQ2cmEEkS2684tBwnRcuXDx+z8s49UoSXr+IHTdtgdggLrsd+GkhcaKOkkXDL2K1SBaN+o9jyCokdqZkHXiSqFj5MRkaB8iG+ToafGF+z3pKljBMzqMBkexQ1i0lDpokqA7JGg3LeA3tzNo5W82qnMlKHCCdX4JebKpo0ymCUS9ErwBdN5CczFmhF06tggAQ9dFC4iKJSq8S487TMuJqStYZr8XHVv4C39GubahkWcmCwWBLM5fNJAzmnv8doOvwLF8Oz6ISwdU0HYqpKNHdfWvGKK/Cs5RcA4sdmMsqOrALGoqC7NOkFDtwsY1kDZqFxLkYkLHNwnYhwl0OeDBqWpSP72vt+m+VEfeokgU4U3VoAMbMvffC0EoL18yjjwIApHPPB+As1r8dyA2UrGyyiCf/jWxeXHjtGiththL2wA+ntt1GaCvC3SwjVuoFXzgETRdUFPJzLTS7oFtdWScOxJGYzMEjC1i73f3NxfmOpu9skiThG9/4BuLxOJ5//nk8//zziMViuP322+Gt0k/jFmKxGN7znvcgHA4jGo3ihhtuQDo9e/e4Ek888QRe+9rXIhAIIBwO47LLLkMu52553lzByNjLiOfALhg2lQnBC5mfRKrWTBbPt9eVpSlAwawA8JGeLLuSJbCZrFl46ben8cLDZGF/xfWbrZtdp2DNZNVRskqFxI2UrJiVuFcrxt1OsgbFYRx8jvRLzYwSEiAb5mfYQ4MvTCWrxkwWQOyCABBRJgA0ULJe/Wlg23uBs95a+zkA3rZ9OYDZnVm6biCeLbcLJg6fBgD4hNr/hu2A4zlEze6aqeNpnHyZfKachF5QDNCuLPPYq4VfcF4z+KKyJ8vEeI68hz3woxqsjqwWbebeJhIGc89Rq+C2sseLtkUmXdSVZow0eJZ0rpCYkrt6NqTcrl3Qs1kIAwPwbrAN6Ut+ILKC/Nk+l9WFmSwAWL6ZfL+je1okWeaa2K1E1G7AiaoTuvJKCJEI1FOnLGIFkH4sAPCcRc7PTlvTGilZj9/7Moo5FSMrQjjzstrW5tCQDI7noCp63Q04p9AUHaqim8fYul2w4UxWAxiaBj2dhgEbyVpgdkG3urKswItXLZoTB9Z8Q9Mk6wMf+ABSqRT8fj+2bNmCLVu2wO/3I5PJ4AMf+EAnjhEA8J73vAcvvvgiHnjgAfzHf/wHHnnkEdx00011X/PEE09gx44deN3rXoenn34av/3tb/GRj3wEfI8m1ZEI97mzC9KdG1Xwwofp2nZBoL25rBxdlHOAL4p0QQUnZCySJbKZrDLExjN46J/2AQC271iJ1Vs7r/T5ncxkOSZZcQwFyfvFHZCs6MllUAoawsMyYiaX9OrULkiVLHMmq05pNVVEQ2bC4NSJNDS1xo7n6lcD134bkOunANLOrJOJPJ44WFIUUnnVIl3UgpcaJ/8uvg7y4QHTMrj38ZPQVB2BqNeyETpBxLILkt+LRTiqKlnVb7w08KMRydLMneJm57EopNUkYbBwqLFdMEtDL87dXvY4VegkWbAslfbeJ2pJdDth0NANyy5Yz4ZUsgpeOFvto3NZ9hj3LkS4A8DyTeT7Hd8Xs6x/zaDX0wUBZ0l7vNeLyJuvBQDM/OxnAAiBLx48SGyzZxAi3WnVpJpCTTH+Uhz7nzwFcCRIqV6sviDwCA2aNkkXLIPWZg7X/BrHXkZcN13QAegGkM5LVlH2QlOygPa7snLpIg4+TzZIz3y1+3PIvYCm2cYPf/jDqkpQLpfDj370I1cOqhJ79+7F/fffj3/8x3/EBRdcgEsvvRTf/OY3cffdd2O8zg7jLbfcgo997GO49dZbceaZZ2LDhg14+9vf3lHFrZMQR0ehmYP+c0GyrJQtUYYPM7XtgkB7hcTWwiAK8IJJsrIIm3ZBpmSVUMyruP+uXVALGpZuGMD516yZk+/rdzKTRYMvZhwEXzShZHkOEnK0/vwxpE0biEc3r0GSH4aul8qI65RWiyPkfaTpI/D6Reiqgdh4jbh5h5A9Aq45m3ZmHbMep6mJQa8ISSSX2cw0WXwFOljEGB0jpPOYqSgs3zjQ1MKVKlnxiljzMiXLmsmqbiGZdkiydDMiWQi2NghN7YLFBnZBQ1GQ+93vAJSXEAP20IuSfZO6BIp5taRkudyVZR/Mr6daWKEX9nksisqEQbsjYA7tggAwtiYC0Ssgl1IwdaKxw6QSll2wN/c/AZQSBht1RkWuIwEYqYf/B+rkJNKmouXbutUW395puyA53ytDOjRNx//+lJxPmy9dgrHVjasm3Ixxp518kiw2rWoKAzYlq02SRa3MWjBKHuAATwft+PMV7XZl7X/yFHTVwMiKUEdSj3sBji9pyWQSiUQChmEglUohmUxa/8XjcfzXf/0XRkc747d84oknEI1Gcd5551mPXXnlleB5Hk899VTV10xMTOCpp57C6OgoLr74YixatAivec1r8KhNoq+GQqFQ9rMlk3UsRXOM1ff8DMbwGIC5mcmiOzeaIEM2UkjWsAcBaM8umCvffa20C4p11ImFBMMw8PA/7UP8VBaBiITX3XDmnJV3WkpWWzNZNiUrUF/JCnuIuuErhqAeIQuPDReMIWMSfY9GSVYQWiIB6IR8ifVIlmkX1KYmrQt+XcugQ9CUwfttnVml+PbS4j2TIsceHO3czWagQrVatqk5RYOmCyYsu6BpK3KoZCmabineDZWslNmR1aKSRe2CyokTddP/8vv2wcjnwUcikNaUb0qU4ttL19MyJWuJqWS5bBekVkGO5yB4qt+GtXTGIoeBiy6e/YRhc16Qhl9UOALmEoLIY+l68j1p4IpTGIbR8+mCgPOkPXn9evjOPhtQVST+7d+QMa2CgUsvtRInO20XtCLcK5SsFx48jth4BnLQg4uuPcPRe1nx9S4qWc1aBQFACIfB05msXHvWRc2Mb0eYXD89ktDTVtZW0U5XlmEs7MALCsckKxqNYnBwEBzHYf369RgYGLD+Gx4exgc+8AF8+MMf7shBnjp1ahaBE0URg4ODOHXqVNXXvGImTv3VX/0VbrzxRtx///0499xzccUVV+Cll16q+hoA+PKXv4xIJGL9t3z5cvd+EBcwVxdhoLSbpgpeeFUDOe5I7eFWyy7YipJV6sgCgHSe2AUjdCZrYG6tL/MVLzx8HC8/MwGe5/D6m7bUHEbuBHxm8EU+o0Cr0S8lOE4XnLEW4LEGStba6XMBg8PoqjCii/wWyRJU8+Tw+K15LCESAeepHShhkazJKYyspCSrTviFQ2xdFsHa0SDyio7/MjuzKHm04tuLReRpR9bSzm0aRMcqSNaG5lTgqM8kv6YSZ3Vl5Uo73vVmsujPzXNApEHPjaVktTiTJQwPgw8GAV1H8ciRms/LPvssAMC/bdssy111JasUXc+NLgbgvl3QCr2okyKX/e3TgKrCs2IFpGVVrDaVSlaFI2CusdwMWDneJMmC7ZYyV5tGnQAlWbmU0rAzLPoHJAAj/q//isyTTwIAgpdeYpHvTs//WAq1TclKx/N4+j+JKnzRW86AHHQWzuNmwmCxxfh2AOAEAR6ZHLNSb7TBAei1yaAkawFaBYH2urJOvpxA/FQWosRj/asaF9P3KxyTrIcffhgPPvggDMPAz372Mzz00EPWf48++iiOHj2KP/uzP2vqm996663gOK7uf/v27Wv6hwIA3dzZvvnmm/H+978f27Ztw+23344NGzbge9/7Xs3Xffazn0UikbD+O3bsWM3nzjU0VYdmDoXOhZJl2QUFL7xFgJMPIVcrytMiWTUW2PVQMaydLqjwIA2/uTldL8xgoeDkwQQe/9nLAICL37YWi89obONwE3LQY+3k5VPVh6Udz2QVkhjwkfdqZBdcN0nU6w0XkIs0OTdU8IZ5E5UCto6s+ucJTRc0FAUjo+Tz44aSVa0zK2bFtxPSohw/joKX/M5CSztnf42OlkjWwOIAAtHmrNHRiuALb5UOJKpkVSsjpj931C9BaLBgtmayWiRZHMdZylQ9y6BVQlzRjwXY4tttSpbo4a3FvjFIzjt1YoJEbLuEUnx7Y6tgoJpVECiRrPgRUp3Rhfh2O2j4xfhLiaaCB3Tbxl0v2wUlnwhfyFSCGxCO8BveAN7vh3LkKPRkEnwkAnnLFhTNTSSpw3HhtHhbVXQrnvvRf30JakHD2JoINl202PF72RMG24WlZLW4vvGYiabtBl9QJUs37YILLfSCop2uLKpirTtv0ZysV+crHP/kr3nNawAAhw4dwooVK1yR9T/1qU/h+uuvr/ucNWvWYGxsDBMTE2WPq6qKWCyGsbGxqq9bvJhcJDZv3lz2+KZNm6qWKVN4vd55O7NVtO3OzImSZV7oNUGGpBoQ/IeQzqvwS1VOG58LSha1CxZVRItkAWYIfMt2on5BNlnEL+/aBV03sPa8UWy9fNmcHwPPc/AFPcgmi8gmi1UX78JAFEA9khW1/jgikot2veCLaG4Uo5kV4HhyoQaIldTqyAIAKQAtTkMv6i8uea8XfDgMPZnEoMngYycyUBUNoqe9z9Nbti3F1+7fh2eOxHFoKjNLySoePoKCREhWICq39b3qweMlfT3peAHLNzZP5mhIx8lEDm+/8wlsnjEwAmDX4TiSu05iLCJjRCUrYSM/26IXSzubxwIAPd1euiAAeFevRv6FF1A8XJ1kGYaB7HPPAZg9jwWUZkDsShbHcfD4BBQyKlRfGJzXC6NQgHL6NCSXnA1OioizjUhWcBHgDQOFJBA7ZItv7w7JGhjzIxD1IjNTwMmXExbpagR7UEYv2wUBQjhyKQWJyVzdGRQ+EED4jW/EzL/+KwDyO+YEYc6ULNLDRdTaQlbF+PEZHNw5CY4DXvPu9U1Z49wsJLaCaFolWUFyLIrSXoS7ZipZup+sPRa6kkW7spzeJ/MZBS/vJGv2hWwVBJogWRQrV6507ZuPjIxgZKRx0exFF12EmZkZPPvss9i+naRDPfTQQ9B1HRdccEHV16xatQpLlizB/v37yx4/cOAA3vCGN7R/8F1AMUcuwKLEOy4XbQf0Qm/wAryqCMF/BDO5IkbDVRaJdNC6nZksqmTlVURMkqVHgj1/420Hum7gV999EZlEEQNjflz+3o1d+/fwhSWLZFWDaCpJWiIBQ9PACRUXZF4gaX35BAY4Mo+TKWrIKxrkiot32BvGWbFLAADLNg9YdsVMQcMQzMW9IAGCByqNb3eQQikOD6OYTMJbmIEv5CGD+sfTjga862FRWMZl60fwP/snce/O4yialkqqZBWOHEHBSzZ+AtHO2jyXrh/A/qdP4Yxzmy/xXhyRMRz0YipdwNOHY1AKAq6EhD1HEvjKj0lK1LLUBP4BwEw8hTd/+zEsjsgYi8gYC8s4mSAEmJLLeiilC7ZOskpdWdUTBpWjR6FNTYHzeCCfddasrxcy1e1JXp+IQkaFktfgWbwYxcOHoZwYd41kKVZHVvVbsDIxgcJLLwMcB/8F51d/E44jPW7jO4llkM5kzXHoRelwOCzfNIB9T5zC0b0x5yTLZhfs9bmXyIgfp15JOgqBiP7B2yySFbyUXOvoedHpTVSO5+D1e5DPKMgminjkbmI53Xr5cgwva+7zSO2ChayKfEax5r1aQaEicKdZSGGzPLw9t6BVlG74Q0B2boLG5iNoV5Za0JCOFRwn1R54+hQ0RcfQ0gAWrV7Ym+Q9Ic5v2rQJO3bswI033oinn34ajz32GD7ykY/gne98J5aY6U8nTpzAxo0b8bRZ3MhxHP7P//k/uOOOO/Czn/0ML7/8Mv78z/8c+/btww033NDNH6dlUJ/3XEmv9t0bjyqDE3LYH3u5+pPbmsmiiwNqF9QQKZCbFGeqIwsVT9/3Ck7sj0P0Cthx85auXuwbxbgLEZOoGAYJo6gG0zIY1JMQzQUVnf+xQ+REvCp1JQBg04VmIayqo6jp8HOmkuUhF3zNsgs2Vm5oiIo2PYWRFeTiX7eUuAlQy+A9zx6fpeikD5+AwZPFRyDSWaX8snetx7v/8gIsWde8kiV7BDz06dfgX//oItzxrm14/Tnk335pwItzV0SxJCJDNefeJLWI54/N4L93n8L3HzuML//3Pvzg8cMAnClZWpszWQAg0a6sGnbB7E6iYslnnQW+ikOBLuoqF4adjnFvNFubNed05M2b64a5lM1lddkuCJQsg82EX5QrWa4f0pyimfkkecsWBC6+CMLAAIKXXw4AKDqI9XcLNOzliV8cRGIyB39EwvlvWt30+3gkwUpMbVfNKlp2wdaImhQh6aqGwdWu53AAugGkeUny6UJVslrpyqoMvFjIm+RAC0pWt/DjH/8YH/nIR3DFFVeA53lcd911uOOOO6yvK4qC/fv3I5st7SB94hOfQD6fxy233IJYLIazzz4bDzzwAM44w1lqznxD0drlmptfG89zEEWyKyTqAQB57Jp6Hm/CbNtNKcK9BSWrIvgiU1ARMec9FnJ8+6EXpvDs/WSg/7Xv3YjBxYGuHk+jGHfO47HseFo8bilbZfANAPHD4HIzGAhImEwVMJ0uYnGkvDwql1KQi6sAB6wye8Bo6IWfKllmnYFq2gUdKVkjNGFwCqMrN+Hoi9OuzGUBwJWbFiEsixhP5PHgPmKVoFH1qeMxwAN4PToEsbN7W5IsQhpr/RoRlj141SryuzvMS/jPJ6awJuLDn/zxqwAAhalpvHL/FyHpKu589zacThdxMpHHqUQOp5J5pPIq3nl+Y8VHp+mC7dgF6UzWoUMwDGPWDT230wy9qGIVBIB8jUF7eo0t5FQEO1BIXOrIqr54s/qxLq5hFaSwurJeBgJmX16X7IIAsGwD+d7Tx9PIJouOwnn6S8kySdZE4wUpx3FYftddgK6Dk8zZzTmyCwLUIpuz6h4ufdu6ljdwwyM+ZBJFJCazWLSqdeWiWtpnM/BGQ4C5Z6YWtZavtVqSbBJqZg/jQp3JAohlMDaecZwwePpwEtMnMhA8PNafX32cZyGhZ0jW4OAgfvKTn9T8+qpVq6om391666249dZbO3loc4a5TBak8Eg8VFWHqJPdjBPpGkEg1kxWexHuqqYjpxQRMaOwvUOdqQWY70hM5vDr7+8BAGy9fBnWzYN0Hn/ISSFx1CJZVVEW474Uk6lC1YTBVIxc0AMRr9VPQnvaIiIlWRVKloOAFBp+oU5NYfQc9xIGAaICvensJfjxU0dthbxkRzY9kQKWAoFQz1xyAVQPvvD4S4T4dWuj4P3Oy47taDddEAA8K1YAPA89k4E6MQnPovLrRa0SYopqM1lASclS8lqHlKzaG2aGYTQOvaCwK1k0NaKLJMsfljC8PIipY2kc2xvDhgsaL7LKlKw+IVnJKWe7/pxY/vufy41Ue9jL0g0DWHte6/fayKgfJ19OtB1+UWjTrSNGI+COajA4AUpBh7e1SxN0qmRJ5Pe5UJUsoPmurD2/IZtRa88dbcs62i9oiearqopf//rX+Pu//3ukzNK28fFxpNPNlxAyOMdc2wWB0sVFgBm5XZiq/kSqZBUSpBSzGdjSBTNFDZyQs4qI5eGFR7LUoob779qFYk7F2JowLr5ubbcPCQCZyQLqkyzRjNtXHZAsaimrZheku2ahwZLFK1M0+5c8pWRBAFBjdCar8eJSHCZzSurkFEZXkh3X+MmMpSy0C2oZpBjwS9CLRWQzxLoSHO6uGtkspKplxKWZzGox7k5h9WSFWt/55iUJnuXk37x4qHwuS43HUTRntXzbzqn6+nym+s45LSQu5FR4lnZAyaqjWBQPHYJ6+jQ4SaqaiFgGqmRNvWS7jna3V3D5puai3PvJLhgZJYvydLzQUsKdk9RJt0A3FniBw2vetb4tW1dk2LmCVw/tRLgDhGTxtJC4jYRBzZzJ0kRyrVvIJKuZrqxiTsVLz5wGwAIvKJomWUeOHMGWLVtw7bXX4sMf/jAmJ8kw9Fe/+lV8+tOfdv0AGUroCskyL/acIQKGgZlCjZkrXxSAeZHONRnjbrMLkiLijFVE7DGVh4WER+4+gKljafhCHrz+xrM6bi9zikYzWYAtxt1BITENhZhOz36/dJySrNKCntoFB0Tz+aZdkH4vwWHwBUCUrEDUC39EgmEAU8fcUbPOWR7FGSMlIjUQkKAcP4GCWa4cGAm68n3mCnQ2ophVLacAx/OWvalaIbFT0OFyoY3gCwDwri5ZBu3ImamC0hln1JxrsmayKpQsr9zZmSyljiuBWgV9288FLzdIohxcQxSsQhKYIMp3N2eygBLJOro3VrtX0QbrKVzvpwvKAY91f044VLPssFIn50DJGlpKrlPnvn4lBsba2/yxbJIt/Mx2tBvhLkSjEGghcRski16bNJ5s8i3U4Augua6sA789DbWoY2DMj8Vr57ZmZr6i6dXbxz/+cZx33nmIx+Pw+Uq2kbe85S148MEHXT04hnIU5yh5yA7JLPfTRRkeFUipNUgWL5QiupuxDOoakJ8hf/YNIl1QwQlZRDLkoYVWRLznsXHsffwkOA646oYzERzoXNx3s2g0kwU46coyf5+5OIbqKVmmXTBoI1lpc5c3IphKqRV8YSpZDuyCdCZLnSKKLFWz3LIMks6s0jzSgF9C8chhFLxRAECwyd6qboPuKOu6AbVYGiTnzGu/Xpgd4+4EhqpCN+dn25nJAuwJgxUkayexCvrrqEG10gU99uALOpN16hSMdmPLTNA+pGoBByWr4MWN30j0AgOryJ9nzELmLtoFAWDx2ggED49soojYyUzD51Mlq9cJFkB+hnZ6o+YqXRAAzrlyBd7xuVe1FHZRCargtatkFdpUsgjJMpWsNtwJVMlSObL+WchKVjNdWSzwYjaaJlm/+c1v8LnPfQ6SVD7QumrVKpxwcaePYTZohPucKlnmDq8qeOFVgIxaR6WyFtBNkKx8AjDMxZtvgJAsMWPZBRdSEfHk0RQe+SmJ0j3/mjVYvnF+/ezOlKwoAAeFxLmYFQpRrZC4ZBecrWRFLSUrAENRrCRDYagJJWuakixzLuuoO+EXAOnMkkQeUb8HA34PlKNHbR1ZvUWyRKlUzFtWSGwqLHqLSpZus5YLwfbUvVLCYLldMFunhBggdiKaQFY5O0B30ot5FeLICODxAJoGtaKvsVXUsgsaqorsU08BAAIXOyBZADC0rvzvXbYLih4BS9ZFAQDH9zZ2NZQU0k4e1dyhnd4oxUF/mlsQRB7Dy0KuLIbDpl0wmyy2Zb2myrLUYrqgEI1C0Mn9oR0lSzPHYDQztmAhk6zKrqxamDiSxOTRFHiRw4YLWeAFRdOXNV3XoWmz/6GPHz+OUJs7kgz1MdfpgvbvpZkkS0UOWaVGB4iVMNhEjDtVvbxhQJRMu2DWsgsKDuZs+gH5jIL779oFTdWxassQtr/evT46t0C7qvJpBZpWPR6X2rK0GQfBF0Fzzq+qXZAoJKEyJYuc/yGekix/afaL50sR8nVASZY2HYOhaSUl67A7ShYAjEVk3Puhi3H3TRdCFHgUjxxBwdubJIvjuLI4c+txmfwcRoszWXQRw/n94DztDUfbEwYp9EIB+d27AdRJFjRVLI7nZpGd0s9M+t48Zrm9W5bBWiFG+d27oafTECIRyJs2Onuz4QqS1WW7IABrg+jonsYbbrqpZPF9svPdKsnSNR2qWaLba/Y0OeCx5hqdhn5UwjCMkl2w5ZmsqDWT1SrZMwwDurlxp+rk87mQ0wVpVxYApGO1nQtUxTrjnBH4gp3tguwlNE2yXve61+Fv//Zvrb9zHId0Oo2//Mu/xNVXX+3msTFUoBski15cNEGGVCSLocncZPUnW11ZTShZVrIgWXyn8xUkq15HTJ/A0A08+IM9SE7lER6WccX1m+dlypYc9FjHlU9VDzcRWgi+iNUJvghWUbJCfCnCnSpmwsAAOL7x5UwYGCDT9boOLR7HyAqyMTRzOltGItrFWUsj2DhGCFzxyFEUTbtgpzuyOoFq4Re8bNoFcy2SLDqP1aaKBZTsgsr4uKWs5XfvhqEoEIaH4alRIGwlC/rEWbv59uALACXLoEvhF0oNuyC1CvovvHB2mXct0IRBii7bBYFSX9b4S3FoSv2+ImpkwDy85rWCZrqy7KDEG+jNRX274ReaokNXCeFuzy5ozmSlW7s2GYUCDIVcGxSdnJPSHPSWzVc46coq5lUc+C0LvKiGpknWbbfdhsceewybN29GPp/Hu9/9bssq+NWvfrUTx8hgomQXnMOZLK9NycqR4diJbA3LTEtKVnlHVrqgQjJS8JvrbtGBBazX8ewvj+DwrmkIIo8dN22Zt7GnPM/BFyTHVrOQuIngi0HTLlgZ4a4UNOQz5CZHrQpAiWQFKMny+EvzWA4VT04ULXVUnZqCPywhaCYYTh51T82yI3/kGIoeQiZ6TckC7DHuJWJN7YJGobWFjNWR1WboBUDOOapiFg8fBlCyCvrPPbemHapeJw/dyKIzMjRhsNhhJcvqx2oU3W6HnWR5w4DQ/evH0NIAfGEJalHHyVdqFJOboHbBPuFYiFrzSTUcHzVAlRde5OZN2FEziIySGdlWC4nphgbHtW7P4/x+CAZ5n+JMa2nXWsK0jvM8FIWcmwvZLgjYwy+qX+9ffnYCSl5DZMSHpev7f2O8GTT9SV62bBl+97vf4U//9E9xyy23YNu2bfjKV76C5557DqOjCy9uey7RzXRBVZThyZObx1SuRoy7bd7GMWzx7YBZRKyQm7Iu8G0Pxc93HNsXw9P3kVmSy9613lJW5isaxbg7n8mKY9C0FMQrSBYNvZBkoSxligZfBKwy4gBU2pHVhK3Umsua7Ez4hR1GsYjMdBrgePBCiaT2Euiucpld0NemkmV1ZLUe324dC8dBqrAM5p6tX0IMwCLylR1ZQOka2zEli5I3mytBz2aRff55AA5KiO2w2wV982OBw3Eclm8ix3KsQZS7FXzRJywrPEzIRipWqGmrrgbLqdKjqknJJtkcuaSgmx6Sf7ay7BQcx0EUyPlUTDYOXakGe38fDc/oRWXRTTTqyioLvOiTz7FbaOnTLIoi3vve97p9LAwNYF2Eu9CTpQleeAvkg1ZbyWrHLkhemy6oiBbModNIoK8TatLxPB747oswDGDTxYux+ZL5L7P7wxKmUZtkiQ3TBc1FYD6BQfPGFc8WoeuGFbCQNkmWXcUCSkqWH+aFXgpAi5Pzp5mAFHF4GIX9+20JgyG88tykq+EXFMUTpfh2f0TqyRtQtUJi3ktnsloMvjDLPvmQO5H20urVyD33HAqvHIKh6xZZqdczRX8euYqS5a2YQ3M7xr1aH1L22WcBRYFn6dKaFseq8A+Rz1Uu3vXQCzuWbxrEgadOk76sN59R83k0wr1frvWBiATRw0NVdKSm84iOOmvErded1gtoJ/ADKH3WWo1vpxA95Dwqplq0LZpWZj4SKUXqL3glq3ZX1tTxNE4fSoLnOWy8aPFcH9q8R9Nn849+9KO6X3/f+97X8sEw1IelZM1p8EWJZEkFsrA6nWlkF2xGyaq0C2qIFMwdqGj7u9zzFZqq45f/sBu5lILh5UFc9s71jV80D9Aoxp0qSno2C71QsBbjFmw77QMCuQnqBpDIKVZvVrX4dqBEsmQbySopWc4Xl6WuLDJbOLqic0pW8ciRUrJgD85jATUKiamSlW8twl1Pk39rN5QsAPDaEgaLBw9CTyTA+XyQN9YOj7BmsqooWXShSy3abitZ1RZvmcceB0BUrKYIB8cRy+Cxp+bFPBYFDb+YOJpCPq1ArqHilpSsOTu0joLjOYRHfIiNZ5CYzDVNsuayosVNtDqLRlFPWW4Goof8+ymZNudFQyFrM4SRrNpdWVTFWn32sLU+YCih6dX6xz/+8bK/K4qCbDYLSZLg9/sZyeogavn4OwlqZ1EFGVKRfIBOpE5XfzJNtWolXdBuFyyQDzI/OD+sL53A4/e8jFOvJOH1i9hx0xaIUm9cxP2h+nZBPhQCBAHQNGjxOPixiihXQSRzI4UkPIUZhGQRqbyK6UxxFskKVXSE0XRB2TBvnh4/tNhL5G2bOFdoV5ZmKlkjZox7cjKHfEZxdSZOOXq0ZzuyKCxVp0qEe6tKlkaVLBdmsgBYdsHC4UPI7iQlxL6zz66bXGgpWVWG7OnPrKk6NEWHRJWs8ZMwdN1RyEot6JpuhUHYN8xK/VhNWAUphteZJGv+KFmBqBeDSwKIjWdwbF8M685bVPV5VoR7nyhZAFF1YuOZprqy6nWn9QKokpWO5aGpetNzZW6NQ3hkAdCBYpVAJSfQafJpJFL1c7oQUasrSy1qOPD0KQAs8KIWmr5TxOPxsv/S6TT279+PSy+9FD/96U87cYwMJrbvWIntb1g5p8PzdrtgWDOVrGytdEHzBt/UTJZJyGi6YEFFxIyF9jShTvQSXvrtabzw8HEAwBXXb7ZuTr2ARjNZHMc5KCSOkv/bCont4Rc0JnaWXbBo3oR1c+EiBaGaARtiE+eKYClZ5NyTAx5rF9bt8Ivi4SMomkqWv1dJVlUli/ZktTmTFXSJZK0ylaxDh5F95hkAgP/cbXVfY+2cVyHV9lmpYl6FuGgR2TxQFKiTNa5/DlEtRU6dnkZh/35y3Bde2Pybrno1+f/Y1raOzW0s30Q2z+rNZdF0wV600taCZZ1rImmv15Usf1iCKPEwjNoBCfVQb9OjGXhks9sz1xrJosEXRrC0cceUrOpdWQd3TqCQVREalK3POkM5XBHo161bh6985SuzVC4Gd3HOlStw4bVnzGn6nMdmFwwZZJE41TDCvQklK2cuxE2ClsoXEcmbi5+R/gtSiY1n8NA/7QNASPPqrcNdPqLm4KSQWGwm/KIKySrZBctJCQ2+kDRKskrpgkIzM1lDlGSVAlysUuIj7s5lFftAyZKqzmSZJKvVmSwX0wUBQFq+DBBFGLkc0g89BADwnbu97musdMEqizre1p1VyKngRBGeRUSJUU60ZxmsliKXfYYEdXjXr3eclFmGre8AbnkRuOjDbR2b26BR7sf2xizFqhIlJWvODqvjsJL2muiMKvb4TBbHcW3NZdFNHKldkmWm1tJwmWZBgy/0YBQAwAscBE+feFlbRK2urBetwIvFfbVJ4iZcO3NEUcS4S351hvkDK8JdlBHVCbmbKdQgUZaSNQPoDosAK+yCyWICkSy56fqG+6s1vJhXcf9du6AWNCzbOIDzr1nT7UNqGo1msgBAiBIS1VRXVhWSFRosV/joTJbHUrICUGNm8EUz6YIjVUiWOZc16fJcVlkRcaQ3/eqWXTA/W8kyWpzJ0mwJXm6A83ggrVgBANAzGYDn4Tvn7LqvqTeTBdhj3M3Fr0vhF9VS5LLPmurbefWJYU1wHBBZNu+YypJ1UfAih3SsgJnT1VPn+lLJGm4+xt3qTutha1pkpPUYd2pHbjf4whMgm1lK0Xmyox1UydID5Lq90FUsoHpXVuxkBidfToDjgI0XMatgLTR9Nt93331lfzcMAydPnsS3vvUtXHLJJa4dGMP8gGVnEbwImySroGeRVbLweyoGeq1QAwPIJ5wNYVcEXySVhFVELA31lspTD4Zh4OF/2of4qSwCUS+u+sCZVppeL8GJkkXDL7T4TPUnVCFZcdM/r+sGMnHTLlihZFGSJajmCeIJQIu1EeFeRck67aKSZRSLUE6cQGEsCqA3O7IAQDJJSJmSRcuI21WyXKxokFavRvEVUofg3bChYdFxPlNbyQKIgpeZKbge414tRS5nKlm+7S2SrHkKjyRg8RkRnNg/g2N74xgYC8x6jqVk9eD1sBYiZldWcioPQzcc/WzdmLl2G+E2Ytzp56zVImIKKUiOQW1Qgl0LdANI95FrU68qi24jNCQjNp6xrKA08GLllmEEB3rz3jYXaPpsfvOb31z2d47jMDIygte+9rW47bbb3DouhnmCUrqgjCHNgKFL4PgipnJTWOFZUf5kwQN4I0AhQchTI5JlGLMi3DNKEuEMuen2UxHxCw8fx8vPTIDnObz+xrN6NoXHZwZf5NMKNE2HIMwWw62urFiNOQwbyaJhF9NpQrKyiYIV5+6PVNoFyU2YV2kqoQd6mizWmzlXKMnSEwnoxSJ4SbL6ydKxArLJoiu/H2V8HND1kpLVoySrMs4cAHjZjHBvdyYr7F6CqHfNaqQfJH/214lup6BKVi37tddHEwbdjXGvnL3R0hnk9xELsf+889p67/mI5ZsGTZIVw9bLl836uq73n10wOOAFz3PQVB3pmQJCFUmp1VA6L3pZyTLJZSt2QfPzKPnaG4eQwmTzV3VopqmEbqYL6jLZpOnVIBK3Ye/K0hQd+58kgRdnssCLumjaLqjretl/mqbh1KlT+MlPfoLFi1lGfr+BSuUGL8JvaDBUc3alZleWuYB2EuNeSAG6uXAzCVlWSyBsXp+Fgf4YpDx5MIHHf/YyAODit63F4jMiXT6i1iEHPdZiKJ9Sqj7HCr6YqWUXNH+vZcEXRL1KmX7vgLlIoTAMA5mCCgEaeI08R6MWQ4+nKUWEj0QAM3WOJgxKPhHRReTm7Fb4RfHIEaiCF5pIFh49S7Jo8EW29PvmLCWrNZJl9WQ1UJuagbS6ZL/1NQi9AIBCIyVLruzKckfJqkyRyz3/PKDr8CxbZs199RPoQPyJA/Hq5bymktWLyn4t8AKPkJnI5tQ6ZxVU97A9ra2ZrDozks1AipBriqq1Ng1Dk081iaiuvawsugl7V9Yrz08in1EQiHqx4sz+WKd1Cgt7mo+hIewXfEkHdIXsPE/lpqq/wOrKchB+QZ/j8QMe8gHOaynLLthMwex8RTZZxC/v2gVdN7D2vNGqO7m9BJ7nLDWrUSFx45msGAZN/3zMXMCnYuTmXLnzm1d06AbgR2kGSE3lre/XTPwzx3F1LYNuhV8Ujxy1kgU9stCzO9RW8EVOtaxdvDWT1SLJMmOS3VSypNWrrD/7G9juDN1oqGRJFbNorilZFUXE1jzW9sbqWy9iZHkIcsADJa/h9KHZny29D2eyANt8ksO5rGKVgupeg0WypnKWQukURbfsggPkOq4ZrZIsU8mSyO+vl0mvm7B3Zb34KLkGbrpkMfgqbhaGEhydzZ/85Ccdv+HXv/71lg+GYf6BF3gIvAFN5+DRDRiqWdxaS8myVAoHSlaFVVDXDXBKAj5z7d7MnM18hK7p+NV3dyOTKGJgzI/L37uxL7pgfGEJ2WQR2VqFxAPNzGSRBS5Vsqz49gqSRa2CflpEzAnQEuZCvQVbqTg8DPXkyQqSFcaBp0+7VkpcHnrRmyoWUFr06KoBTdEhSgI4maYLNk+yDMOAZpIsN2ey5E2b4F23DuKSxfBU9rNVoFjQqIBSdyYLsClZtpkswzBa/ixXzmT16zwWBcdzWLZpAC8/M4Fje2JYsjZa9vV+TBcEbNY5hwmD1nnWo5sxgGmTFDjoqoGMQ5skRcGl4AvvYBjAaWicB4amgROaI0nULqiJXgBZRrJM0K6sqeNpqEUd4IBNFzP3WiM4Opufe+65sr/v3LkTqqpiw4YNAIADBw5AEARs79ObxEKHRzSgFTnwOmfZBSfdiHG3kgXJojuraIioMwAATeRdtRJ1A0/9+yGc2D8D0Stgx81belbJqIQ/LGEapDOjGiy7oIOZLKpkxc3OIjpUWxnfTkMvBiXTsiYFW0oWpKinZE26pWQdPYqCFAXQu1ZBgOzkchxxdRVyKkRJsMqIWwm+0DNZS75wK10QIAXJa/79vsZPBFAwzzfBw9csAi8peCYpGhsDOA5GoQBteto6h5qFpYzJIvRiEbkXXgDQn/NYFMs3DRKStTeGCypSVQ29/4IvgOa7sqjC2cuLel7gERqSkZjIITGZa45kuRThTkgWoAkStGTSclY4BVWyVF4GkGXBFyaokqWaqY0rNg8hPNQ7HZ/dgqOz+eGHH7b+/PWvfx2hUAg//OEPMWCevPF4HO9///vx6le/ujNHydBViB4OKAK8ZkA3lazaJIvaBR0oWRbJIq9J51VECuYFLuzvadXn0AtT2Hn/EQDAa9+7EYOLZ6dq9Sr8ofox7kIzPVlmp8k0ncmK0/j26krWkKQCKsyOrOaTBSnEYXLO2UnW8PIQOA7IJIrIzBTaJkZEyVoPAAhEezPoBCD2SskvopBRUciqCES8lpLVSvCFnjaVQo/Hep+5hpP5D2rboqSIkySIo6NQT5+GMj7eMsmyAg68AvK7X4RRKEAYHIS0enVL79cLoHNZE4eTKGSVsth8K8K9h6/31UATBp12ZfVDuiBAbJKJiRwJv9jgjOAYhmGLcG8v+MLjNzeABAlqPN4UyTJ03QpT0jhybWDBFwS0K0s1NwNY4IUzNG2mvO222/DlL3/ZIlgAMDAwgC984QssXbBP4ZHIaWLoKClZ2Roky9eEklVhF0wXVESL5AKnR93b4Z5rJCZz+PX39wAAtl6+DOte1V/D7I1i3K2ZrJmZ6gWkdpIVNNMKFR3Zoop0rDrJspQsD1WyAtDirStZgrlA1mwky+MVMGCS4Yk2wy8MRSHx7aZdsFeLiCkqEwZ5nxl8UWieZNGdYiEU6trCOt+gIwuYbRcE3JnLorM3HllAbiexCvq3n9t3JMOO0KCM6CI/DAM4vr9886Xf7YKJiVzNImY7lHzv2wUBe/hFMx1hmjXD1e5Mlsdrrlc4AUpspqnX6qmUFcSicuTaIPWwsugm7F1ZvrCElVv7J/25k2iaZCWTSUxOzl5gT05OIpVyt8iTYX5AoiRLgzWTVZNkUbtgroaKYUdFR1amoCKSzwAAuIHeTOBTixruv2sXijkVY2vCuPi6td0+JNfha0CyqF0QikKKYWe9ASVZMwh4OEgiOb9imaLNLlhBsopkATIgmt9TCkClSlaLM1kAoE6WB7i4FX6hjI8DmoaijxxbZRx9r8EefgHAsgu2pGRZ81jdswPTZEE5UHtBVy263g2SRRfTkiwiS+exzu1/q/3yzeTecGxvBcnqU7tgeMgHcIRA5GoksdpRGYjSq2glYdDavOE5iFJ7QQqijRQVpmeaei2dFeVkGYpCzktmFyyB/m43XbS4an0Lw2w0/a/0lre8Be9///tx77334vjx4zh+/Djuuece3HDDDXjrW9/aiWNk6DLoRUvTeAcR7q3MZJWUrIi5M96r8e2P3H0AU8fS8IU8eP2NZ0EQ++9C1EjJ4n0+cKbSUdUyaCut5gpJyzI4MZ2zLDOz7YLk8YhgLlY8Aagxco6Jg8157gFAHB4BUG4XBEj4BQBMHG5vw6h4hFhFiyHyfXpeyTJ3l6mlp53gC7qQEULuJQs2i4ITJUuuQrJcKCS2gi8kHllz3tl/3gIgWaZl8Nie8nsDFXn6TckTPLxV0tqIcBiGYV37et2e1grJsuy7AbHt80AQeHCmB7UYa+46riUS5D3C4dLnlClZFi64Zg2271iJ7W9Y2e1D6Rk0vQK888478YY3vAHvfve7sXLlSqxcuRLvfve7sWPHDnznO9/pxDEydBl0F1vVOAQEszRYzSCrVLEDNDOTVcUuGMmT2RzJXAT3EvY8No69j58ExwFX3XAmggPdmTfpNBrNZAENColFCZBMFSMbw6DZlTVxiqhecsAz68ZG7YJRoaRkaTFC4ITBFpSskdnBFwAwQsMvjiYdWXxqoXjkKAD0RfAFUJqTmKVk5fNN/zuV4tu7Zwmmizq53kwWLSPOl1pNaVdW0QW7IGamoCcS4Px+yJs2tfx+vYKl66PgeQ7JqXzZArykZHXryDoHK8a9gXVOU3Tr36HXlaywjWQ5vTZYoRdtJgtSCBz5jBVmmiNZlsoeDvVFEInbGFoaxIVvPqNvQrzmAk1f1vx+P77zne9genoazz33HJ577jnEYjF85zvfQSDQP8P9DCXQBnZV4zHgD8HQyd+rdmU1E+FeYRdM5YuI5MgOs3+4t+aYJo+m8MhPDwAAzr9mDZZv7E0lzgn8kfpKFgCIUaddWTMWyYqZCxGaYmQHJVkhi2T5oU2bSlYLfWrV0gUBYHhpEDzPIZdSkI4Xqr3UEYpHjsAAhzzIz9LrJEuqKCSmSiUMA0ax9nlQDXQmiw92j2TlMy3OZC0hdkG1LSWLvJ9x7BUAgP+cs8GJ/b9okWQRi9YQ9fLY3tL9gc7i9JuSBdjCLxokDJYR+R5f1IeHZWKTzDuzSQKwhV648zkQeVPJSqSbep2WMOdFwxEotDS8x0kvQ3fR8t5RIBDA1q1bsXXrVkau+hwe086lch4My2JpLqtawqBdyWq0i5U1F+BmhPt0LmEVEQdGeye5Jp9RcP9du6CpOlZtGcL21/e3lE7LiPMZBZqmV32OFeNesysrSv6fi1sky5rHGphNSGi6YJA3iY8twr2ldEFzjsvI5crmxkRJwOBSM/yijbms4tEjUDwBGOYlllosexWzgi+8pd+RkWsuxl1PkYUPPw+ULG+dmSy6W1som8miStZ4y0onXVDrB/cD6N9+rGqwLIM2kgVqF+yzmSwAiAw7s87RBb3oFXr+30H0CJY92mlHWMGlImLrGMy3KSadh28AgJ4qhfKUUkD7fwOEoXPoQ4GewW1IQXLB1AQvRjwG9HoJg3Qmy9CAfKL+G1coWdO5GCJZ0zLRI3ZBQzfw4A/2IDmVR3hYxhXXb+75m2QjyEEPSQIzgHyNnUpKfBzFuJski/Zu1VWyOELEdF2CYc4DtZIuyAcC4P3EylNzLquNUmIS3x4FAPhCnp6fzfNaSpY5k+XxWCuZZueyNLqQ6aKSVWhCyVLymmXlojNZRjYLbWampe9NF2/qvt0AAP9CIllm+MWJ/XHo5gYNVbL43v6IVIWlZDUgWf0S305RUvCckRx6XZHajG+nEEVyD1ZSTV6bkqZdMBJmdkEGV9CHlzUGtyFRJUvwYlg0YCh1lCzRa5u3aRB+UTGTFc/PWEpWKwvnbuDZXx7B4V3TEEQeO27aAjngzk1iPoPnOcihRgmDUQDNkSzFfK9qBZY0+MLPkeeoBXLj42QZnEmWmoVQwzLYbimxoapQToyjIJGEzF63CgKz0wWB8rmsZjAflKw8nclykC4IlOaoeK8XgjnPp5xozTJYNDcMMDkOiCJ8Z5/d0vv0IkZXhuH1iyhk1dImhtHHdkFzJivZSMmySFZ/qCZOFTyKUhCNOz8/JUbFTLMkywy+CNlIVp8QX4bugJEshoagF35NlDEk6o1j3K25rDox7sUsoJoXQFP9ShRKJKsVC9hc49jeGJ6+j8xVXPau9RhZ0bvdXs3CShisEX5hdWXFa8zmVSFZyJKbWrXAEKpk+UHOGa1ALl3i4GDLi7PaMe4lJasVS1jh4EFAVaGEyVxhP5CsynRBAOB8rSUMWkrWPE8XFDy8pUBWTxhsLfyCLqgFrQD5zM1W59hCAM9zWGoW1FLLoE7LiPvQARAeJp+RfEax5gCrgRZe94tqEhk1Az+6ZRc0LX5Ktrl5Ud1UsoRI2Jb22B+/E4bugJEshoagFgZN8GJA0Cy74ESujRh3+jWhlDSXS09BNu9DrSTGzSXS8Tx+9d0XYRjApksWY/MlvTND5gYoyco16MqqPZNVIuKUZAk0vr2OXVA2SZaaI+SnHTJeK/xicEkAvMihkFWRnGo+ojy/axcAQFt6BgAg0OMdWUD1+STea5KsZmeyqCVnHvRkNVrUWQmDtp9bsrqymleyNEWHrpFzV1Tz8G8/r+n36HVUzmX1axkxQD439FpZbz6pXzqyKMLDzgI/KKzgC7eULBrWlXcWvEFBQ3m4YNj2O+kPdZGhO2iaZP3whz/Ef/7nf1p//8xnPoNoNIqLL74YR8xuGIb+Au3tUAUZEb6kZE1lq6QLAjaSVSdh0G4VNO+uXJIoY6rIgw+0ZgGbC2iqjl/+w27k0wqGlwdx2TvWd/uQ5hz+RnbBKCVZjeyCJMKdNwCveT+sbhc0b8K6qWSZqpfQQrIgRYlklSuygshjeCkhAE//xys1wz1qIbebzNooQ8sA9JmSZSdZvtbsglqaRrh3X8lqZO+t2pXVRiGxZRUEUbIWQj9WJSjJOv1KEsW82rdlxBROeqOsTqY+WdDTn7np4AuX0gU9fnLNVWyfNyegKjuCodIcJlOyGNpA0yTrS1/6EnymveGJJ57At7/9bXzta1/D8PAwbrnlFtcPkKH78NiUrCinlgqJaylZviaULH9pkcynyGO5gHde+/Mfv+dlnHolCa9fxI6btkCUFt5F2NegkFgYdEqyiJIV0jlwIATHF5q98M0UzZuwQW7aqqlEiG0onrW6sgDg3B0rwfEcDjx1Gv/1nV2WnccJ8rsIySqan4NApLeTBYHZwRcAwMnkPtCsXdCy5IS6Y6/VNd2yAjVWsqokDLZRSEwX07xWAAcDvm3bmn6PXkdkxIfwsAxdN3DiwEypjLjfSVYdVafv7ILmz5xLKWUbFLVgBV+4pWQFCMlSdR56wXkVh25GuOv+0gaQ2Ce/E4buoGmSdezYMaxduxYA8Itf/ALXXXcdbrrpJnz5y1/Gb37zG9cPkKH7sJOsEKc6ULLMhW+9riyqcvlLi2RvZgYAUAjPXxXrpd+exgsPHwcAXHH9ZutmstDgb0Cy6ExW1TJiYDbJMsgCKzhYnWBnqHVDIwsVLU2+LyVzrYAGX2iTs8/jM7aN4uoPbYHo4XH0xWn82+3P1e0Fo9CLReQPkL60PMi50Q9KlpvBFxot/OwSybL/DI7tgnmXlCzbPJa09gzrc7LQsHwzue4f2xMrKVn9ybFsCYO1k/b6LV1Q8onWZpmT8IuipWS5ExwlBUwrMy81lQJKr026lzgZRIkH36fkn2Fu0DTJCgaDmDZLQH/1q1/hqquuAgDIsoxck958ht4A7YnQRBlBQ4VukqyUkkJOrfI7dzKTRUMxfKVFhj9DLnBaF1PH6iE2nsFD/7QPALB9x0qs3jrc5SPqHqyZrBrBF9ZMVjIJQ62yk2kjWVGfBxGd3MjkGqoPtQuKJslSUzS+vQ0li9oFp6ufp6u2DOPaT26DHPBg4kgK9/7/nq27UAKAwr59gKJAGBhANktshv1AsmhAhKboUBWyIORkOpPVbLpgd5UsOo/lkQXwQv1bYMkuaCuLbUvJoudxYUHOY1Es31QKv7Bmsvp0MRt2ZBek52R/2AUBZzZJik6lC2pCkyTLTBfUvYGy92FgaBVNk6yrrroKH/zgB/HBD34QBw4cwNVXXw0AePHFF7Fq1Sq3j49hHsCuZAUMFdC9MHSy6KqqZtkLiWuhoiMLAPxZUgrLzcPd3WJexf137YJa0LBs4wDOv2ZNtw+pq2g4kxUh8eUwDGuYuAw2kiUKPEYFco4Jweo7mTT4QlAJydHMkkl3ZrJqKLIAxlZHcN1ntiM8LCMxmcM9X3u2bklxzgy9kLZsRc7sEAv2AcmSvAJgroEp4bCUrIJzkqUXCjBM+w7fpZmsPJ3HqpMsSFFZwgyUSJaeSlU/t+uARsELan5BzmNRLNswAI4DZk5nkTRLyOezRbwd0Bj3emSj2GfBF4CdXDbuyir1ZLmVLmgjWbXCl6qAWplVDzn2fiK9DN1B0yTr29/+Ni666CJMTk7innvuwdAQWSQ/++yzeNe73uX6ATJ0H3Q3R+c9kJQiAM6yDFady7ItoGvCsguWFslhUwltR53oBAzDwMP/bx/ip7IIRL246gNnLngLgT9Sn2RxHg94k2hVncuynyO6jiGOnGOGf/YiQ9cNZIt0cWoqWQlCyNvpU7MrWYZeO9wiusiPt/6f7RheHkQupeDnX38OR1+srn7ld79I/rDhHAAAL3B90Z3G8ZxFOOiusxXh3oSSRVUscBz4QMDdg3QIuqDz1unIopCqkCze77eU2mbVrKJ53gpaYUGVEFfC6/dgdBW5hxx9kdwLuD7NOqaKTjZRtBLrKqH0YVy4044wQzdKdkG3lCxzTlrjvY6VLPsGkE5JVh/9Phi6g6Yva9FoFN/61rfwb//2b9ixY4f1+Oc//3n82Z/9masHxzA/YN9d03JFBCTBinGvWkhsKVn17ILlRcSGYSCcIwt238ho+wftIl54+DhefnYCPM/h9TeeZVnlFjJ8ppKVzyjQa6TvidEogAYky9CBYgoRnVyKFO/sSxINvQAATiGLVM0cUG4n6l8wN4igKNASibrPDUS8eMunzsXyTQNQCxr+89svYN+TJ2c9L7+bKFn68vXW6/rFBlU5l8VbwRfObeLWPFYwCI7vzqq6kHFuTapGsoDW57IyLx0mrxcNSxFbqKApg/GT5DPN96mSJQc81rlWK22P2gX7KS7cqV1QKWhW+IlrPVkSubbogtTw2k6hU1Wa46ByZGOsn5RFhu6gpbvcb37zG7z3ve/FxRdfjBPmTeb//b//h0cffdTVg2OYH+AFHjxHFtKFqQSifql+IbGTCPcKu2CmqCBsLmTCY/Nn8XHyYAKP/+xlAMDFb1uLxWdEunxE8wNy0EMG1Q0gl67eRUJ3+9Vq4RceGfCYASfZGPzmBm+2iuhDQy9ETgen5mAYgBonN06xDbsgL0mWrVGrYxmkkGQRb/zw2Vh//iLouoEHf7AXz95/2Jop0TMZFA6Scmp1dAUAIBDtH0JeSTg4mdggjRaUrK52ZJlKlhO7oDWTlS9XIKy5rCa7sjKHSGiON9odFW8+Yfnmis9un2xGVEOjhEGr+LaPFvVOSRbdtBFEHqLHnZ+/lZksav3lw2EoBb3sfRgYWkXTJOuee+7B61//evh8PuzcuRMFU15NJBL40pe+5PoBMswPeMwNptyJCQwEPDAUh0oW3aKqRIVd8HR6BuEsee7g4hWuHXc7yCaL+OVdu6DrBtaeN4qtly/r9iHNG/A8B5nOZSVqzGWZSpF6ulbUPyFhRjYGybyppapckWjoxZCXLER0hQPMMI12yogBQKgT4171+SKPK6/fjG2vI+fok794Bb+5+wB03UB+zx5A1yGOjSGnEwLSD6EXFCW7YIWS1cRMlmbFt3evIyvflJJFFlkFl5Ss3LFTAAB5ZP7Nnc41Fq0Ol5GKPuZYDQkHtRH206Ke/szpmYIVllMNbse3A7BqVbQm0gUpyRJCIdvvo3+URYbuoGmS9YUvfAF33nkn/uEf/gEeT2kn8JJLLsHOnTtdPTiG+QN68c+fmsKAX7ISBqsqWbQnS1eAYrr6G2bL7YKn0jFEzPnY+WAX1DUdv/rubmQSRQyM+XH5ezf27WB2q7Bi3GskDHrNqofCgf3V38AkWfnYDHjTcRjTZ9+MaejFiET+rxXIucgHAuC97ZEYcXgEgHOSBZD5pIvfuhaXvn0dwAG7/vcEfvkPu5H+HenH8m05C9kE2XwKRPqIZFUUEltlxM0oWbSIuEvJgoB9JsuBktXILtjETJahKMhPEuusb8mI49f1KwSBx9L1NrLZxywrMkrDL6qHQBT70C4oBz2ERBtAcqr2NcJKFnQp9AIozWTpTShZ1C4ohMNWiXE/KYsM3UHTJGv//v247LLLZj0eiUQw00RUJkNvQfKbMzhTMxiUxfp2QckPiGZ/VK25rFylkjWNsHn/aVedcANP/fshnNg/A9ErYMfNW/rq5ucWrBj3GuEX8qZNAID8nr3V38AkWalJcnNLcwZi+dnWQ0qyhiTyNVUjVitrpqoNlBIG68wP1sDZr12O191wJniRwyvPTeKhnUEoog/ymWchPWOSrD5WsjivGXzRRE+WZcnpJslqZSarooy6ZBd0rmTl9+yBapBFm7xofoX7dAt0Lgvo35kswIGSRXuyfP2zqOc4zpFl0Nr0cFPJsuyCzoMvqMrOh8Ol30cfKYsM3UHTJGtsbAwvv/zyrMcfffRRrFmzsGOt+xlS0GxQh4ilagpGveALoP5cllooKVzm86Zjp+E11zHtJMa5gUO/m8TO+48AAF77hxsxuJjNT1RDoxh3eTMhWYUDB2AoVea2fFEAQHqa3ICTvIFYZvZ7UbvggIf8X1XJ4t6N86REsmqcxw2w7rxFuOaj50DyiZjWh7Bz26egrTkTmRnyc/QTyaJ2nkKlktVE8IWeIp97oYtdeHk6k+VAyaoW4Q60ZhfMPvMsVIH8m0ly7ydOugHalwX0b08W0Lgrq9in9jRKsuolDLqdLAiUgi+aswuSOV8hHLb9PhjJYmgPTZOsG2+8ER//+Mfx1FNPgeM4jI+P48c//jE+/elP40Mf+lAnjpFhHoAqOZrgxVh6sr6SBdQnWfQxTgC8JHggM0kWK0WRA+f3u3fgTSIxmcOvf0CUl62XL8O68xZ17VjmO3zh+iTLs2wZ+EAAhqKg8MqhKm9gKllxQsCSvI7pKiSLpgsOiOR5mkKIixuKpzhMFAUnwRe1sHTDAK69eR2kwgwygcX4718biJmJaf1EsizCQZUsK12w4Pg9tBRVsro3k1UqPm0i+CJXEXyxlChZWiIBLZ1x9H2zzz4LTSTnA7MhEUQX+REcJP8mfSxkleaTYnloankaq6EbUPuwJwuwdYRN1O7KspSsDtgFmwm+sEJ5wraZrD77fTDMPZomWbfeeive/e5344orrkA6ncZll12GD37wg7j55pvx0Y9+tBPHyDAPUCokljGcmLRmslJKCjm1yi4VncvKVSFZVnz7AGDGOBemyUB4yu/p2uyTWtRw/127UMypGFsTxsXXre3KcfQK/A1IFsfz8G7aCADI790z+wnmOZJKkkVHkjcQr6pkkRteRCRf04pkcdxOsiCFQJWsydZJFgD4p17BeTv/BoHiFDJJxbJQBiL9ky5IScksJSvXhJJFLTnzIF3QWU8Wue4V86qVIgkAQjBo9cAp443VLEPXkdu5E5qlZLHFG0AsZStMy6Dg6dOiLJBrpegVYBhAarrcXmvvzuq3Rb1lF6wRXQ+UrieSg00Pp7C6PQUJqsMId6sWJByxIvX7TVlkmHs0fVXjOA5/9md/hlgsht27d+PJJ5/E5OQk/u///b+dOD6GeQLafK6KMqKxU4DuBWeQi+JUtsoC1VKyqsy6VCki1mLkPTJ+2b2DbhKP3H0AU8fS8IU8eP2NZ0EQ+/em7wasmawawRcAIG/aDAAo7K0yl2UqWek0+XemdkGjIpGSzmRFBPJ9VDP4op2OLIpWgi+qIb97F+RCHK+JPlcW899PSpY0ayaL/GxNzWRZwRddVLLMmSxHEe7mz6xrBjSlXIGw5rIchF8UX3kF2swMNFpyymY8LWx/wypsfvUSbL5k/lR3uA2O4xAZJr/7mQpVh8a38zzXd/ccJzNZxQ4oWXQmy+AEqMnMrHtKNVCVXbArWcwuyNAmWv5ES5KEzZs3Y+PGjfj1r3+NvdUWUQx9A7qgLkoR+CdPAuDA62QxWT/GvZpdsLwjCwC4BEndyga7YxXc89g49j5+EhwHXHXDmQgOdI/s9QoazWQBgLzRVLKqhV9Qu2CGLNaTvIGipiNTLLdmUZIVNkmWlidKpzjYfgy22GSEey3kdpNkwfCWDbjm4+fg7NcuxwXXrO6rwJRSuiAhKbyv+TJiqmTNh5ksJzMgHq8AmML67Bh35+EX2WeeBQDofkIu2UB9CeFhHy5/z0ZEF3XPJj4XiIxWJxw0VMUjC32XYEtn0VJT+Zql9SX7rvszWQCgQbCsgPWg24Mv+tS+yTD3aJpkvf3tb8e3vvUtAEAul8OrXvUqvP3tb8fWrVtxzz33uH6ADPMDoUFCOvLyIKTTZOdWN8MvJnJVepAc2QVLSpbHTB0rBud+8TV5NIVHfnoAAHDBtWuwfGP30w17AY1msoBS+EV+377Zu4mUZOVJsEhBIguMWLr8/WjwRZAjsz/UneqOkkVIlhaPVw/ncIj8rlJ8uygJuPTt63De1avbPr75BEvJMueTeJkGXzQzk2UuZLrwOQeIJZgqUk4i3DmOs81l1UgYdKBkZZ8lJEuTyLneb7YwhsagSlZlCITSh0XEFMGoF4LIQ9cNpOPVrxOWXdBFJUsQePACuZ84ncsq9WSFS+XQbDOEoU00TbIeeeQRvPrVrwYA/PznP4eu65iZmcEdd9yBL3zhC64fIMP8QHiILKhy8hC4kyfAGTrUIlkoVbcL2gqJK2EpWSUlwmsOj6uhyOzndxD5jIL779oFTdWxassQzn3dyjn9/r0Mqm7mM0rNXUrvGWcAHg/0VGr2jr9vAKohIaeaC88geb9YtpxkUSUrxJObtJYlN0BXZrKiUUAQAMOAGou39B7KxATU06cBnoe8eXPbxzRfUQq+IGSUs5SsJnqyUt1VsiyrI+dcTSrNZZUrrJKVMOiEZD0DAFA5Quz6SeFkcIaaSlah/zqyKDieQ3iYrB0SE9UV705EuAMlguQ0YdDqyYqEbcEX/fc7YZhbNE2yEokEBs1Ur/vvvx/XXXcd/H4/3vjGN+Kll15y/QAZ5gdCQ1TJGoJRKGAon4Sm1FGy6qYLmotZm13QlyEXYCMyd/0xhm7gwR/sQXIqj/CwjCuu39zXMcJuQw56SCKYAeTS1VUgTpKsUuL8norwC98A0hpRkjxeAYEQuaHFMuU7nhnzhucHWcyrGXJTdiNdkBMEKwpem27NMpg3rYLeM84A38VkzE7DWxnhbs5kNRN8YSlZXZrJytuSBZ1+1mvFuIsOlSxlfBzq+EkYggDVfIt+VC0Y6qPWfJLS56pJo/CLQgci3AFANINUdIddWfYOv1LwRX/+ThjmDk2TrOXLl+OJJ55AJpPB/fffj9e97nUAgHg8Dlnu3BxLLBbDe97zHoTDYUSjUdxwww1Ip9N1X3Pq1Cn84R/+IcbGxhAIBHDuuecyS2OLoHZBTZShij6szE3DUMhCqX7whTO7YNBMlRMGRtw76AZ49pdHcHjXNASRx46btjjqzWEogec5yHQuK1Ev/MLsy9q3r/wLvgGkNPL7Dg56MRgk59h0DbugD3kYBqDRc8WlPjWhzbksSrLks85y5XjmK6idRy3q0FS9pGQVnNsFrd3iLqULFjLNL+ikGiRLctiVlX12JwDAs2kLqGOWLd4WHuh8UnIqB10vWafpgr5f538axbiXgi/cvf+WCoklaA4SBjVLZWczWQzuoWmS9YlPfALvec97sGzZMixZsgS/93u/B4DYCLds2eL28Vl4z3vegxdffBEPPPAA/uM//gOPPPIIbrrpprqved/73of9+/fjvvvuw65du/DWt74Vb3/72/Hcc8917Dj7FaIkWDM4eXkIZxRnWp/Jqgi+MAwDQXqhHVrs7oHXwLG9MTx93ysAgMvetR4jK7o3iN/LsMIv6iYMmnNZleEX/kGkTCUrFPVgKEDeK17DLugzCtCKPGCuT8SB9oMvAEAcai/GPWfOY8lbFgbJAgjhoDNZUFVH82yGpkHPEFswH+6OkmUN2TexoWLNZOWrFxJr09PQ66h51CoonXMeeYBjJGshIjgggxc56JqBdKxksbXmf/rUmtaoiLlTSlaZXTA+U/e5hq5bG0BcMAS1qJe9BwNDq2iaZP3xH/8xnnzySXzve9/Do48+Ct7sOVqzZk3HZrL27t2L+++/H//4j/+ICy64AJdeeim++c1v4u6778Z4HavG448/jo9+9KM4//zzsWbNGnzuc59DNBrFs+YQMkNzKIVfDGFFfrp+IXHdmazyCPe0kkYkS1bOwdFl7h50FaTjefzquy/CMIBNlyzu6+jgTsNv9kDlnIRfVCaQenxIGYRUh0IGBvzkvSoLiamS5TVy0PLkesNHIuA87ux80vCLVpQswzCQ37ULAODr4CbTfADPc9bObiGrWkoW4GwuS7c5D4Rgl5QsczNHbknJKp/J4sNh8AEyT6icPFnz9TnzfiNs3gqALNz6LUWOoTF4vhTjbrfOWapJny7o6Sxasopd0NANa/PCzeALABA9zguJ9UwGVGbW5YD1OCNZDO2ipQj37du34y1veQuCthvlG9/4RlxyySWuHZgdTzzxBKLRKM477zzrsSuvvBI8z+Opp56q+bqLL74Y//zP/4xYLAZd13H33Xcjn89b6ls1FAoFJJPJsv8YCMJDpYTBJRkbyaoa4W4qWWoeKFbYBCrsgvF8HGHzKcHRzipZmqrj/rt2I59WMLw8iMvesb6j36/f4STG3bthAwBAPX0aaqxc2UyDENxQUMGQGXxRWUicKZo3YT0P1SRZoktWQaA9kqWcOEFu4B6P9XP2MyTbXBbn8ZAECaCukkNB7TicLIOTulPSnM80HxddSlUsV7I4jrPUrFqWQTUeR+GllwEAwlpSZ9Cvi2mGxrBUHVsIRCnCvT+VLItYTuZmJcwWcqrlTHBfyaIzWY1JFi0i5rxeqDo5Do7n+rogm2Fu0NJZffz4cdx33304evQoisXyBdHXv/51Vw7MjlOnTmF0dLTsMVEUMTg4iFOnTtV83b/8y7/gHe94B4aGhiCKIvx+P37+859jrTmIXw1f/vKX8fnPf961Y+8nhKyEwUGMJA5adsFUMYW8mocs2mbypCAgSIBWJGqWZAsEqLALJuKnIJnrF99IZ4MvHr/nZZw+lITXL2LHTVsgSmzB0w6cxLgLwSA8K1dAOXIU+b17EbRtxqR08rkO+nKWkhWrJFl0p1fPQSuQm57gQrIgRakrq8pmQQNQFUtevx58l4jDXMLr8yCNAopZFRzHgfP5YGSzMBzMZVnJgqHuWXOtJLOm7IJmumAFyQJIjHvhwIGaCYM505ourV4NXSabkv26mGZojGrhF/0c4Q6QdQPHkVnObLKIQKRU0E4/U6LEu17ETO/tGt84+EI3i4j5cAhKoRR6wRRnhnbR9Fn94IMPYsOGDfi7v/s73HbbbXj44Yfx/e9/H9/73vfw/PPPN/Vet956K7lR1/lvX+WwfBP48z//c8zMzODXv/41nnnmGXzyk5/E29/+duwyF0bV8NnPfhaJRML679ixYy1//36DZRf0DiIaPw1oXgggC8tZahbHVZ/L0lQgbw6hmmpX8vRx8r4ih9BA5xZgL/32NF54mHyvK67fbN3wGFqHEyULAORNJNq8UGEZTKmEVIe8KQwG6tsFRS0HtUCVLPfIuNWV1cJMFi0h7vd5LIpZCYPmXJYjJYuWfXaTZLWhZFXOZAFoqGTRfiz/edutxTQbpl+4oPcce1dWsc9DFgSRtzZoK2PcrU0Pl62CgI1kNaFkCeEIC71gcBVNn9mf/exn8elPfxqf//znEQqFcM8992B0dBTvec97sGPHjqbe61Of+hSuv/76us9Zs2YNxsbGMDFRHq6gqipisRjGxsaqvu7gwYP41re+hd27d+PMM88EAJx99tn4zW9+g29/+9u48847q77O6/XC6/VW/dpChxXj7huGqBQwmE/Bw0eR1ScwmZ3E8tDy8hf4B4H0qfK5rJyti0iOAgAyEycwCCDpEzHm7cwub2w8g4f+iRD27TtWYvXW4Y58n4UGayarTvAFAMgbNyJ1//3I7y1tmhi6gbTZtRbyxC2SZbcLKpqOokqGkEU1Cy1PbnzCoDuhFwAgULvgdJX5wQYolRD39zwWRWXSHiebMe6OZrK6r2Tl6UxWE0pWrQh3oHEhce4ZQrJ827cjRXfI2eJtwcJK2pssWehL6YL9q3CGh31ITuWRmMxhybqo9bhVROx3P9nXY08XnKnteAIALUVTT0N9H6nPMLdo+lO9d+9e/PSnPyUvFkXkcjkEg0H89V//Na699lp86EMfcvxeIyMjGBlpHNl90UUXYWZmBs8++yy2b98OAHjooYeg6zouuOCCqq/JZslFjAZzUAiCAF2vXpzKUB92kgUASzJTiBtRABM15rJo+IVNyaKqlhwFBHL6ZSZPAwASsgeBDpCsYl7F/XftglrQsGzjAM6/Zo3r32OhwrGSVSX8IpsqQjcEcNAQ4KaqKlk0WRAAeDXbISWLXIOanckydB35F18EAMhnLQySRQkH3YHmZTPGPdeYZFlKVpeSBQFbuqALEe5AfSVLz+WQM88P/3nnQTlEF2/9u5hmqA+7XdAwDHAc1/d2QQCIjPpxfF+8jFwC9vh29z8THlPJ0vnGEe40WZC3FxEzksXgApq2CwYCAWsOa/HixTh48KD1takWe2YaYdOmTdixYwduvPFGPP3003jsscfwkY98BO985zuxxNxJPHHiBDZu3Iinn34aALBx40asXbsWN998M55++mkcPHgQt912Gx544AG8+c1v7shx9juoXVAVZKiCjCWZaXAa2ZWumjDoM9UGO8mqSBYEgJw5C5PweRGQ3L3YGoaBh//fPsRPZRGIenHVB84EzwqHXYOTmSygFONePHQIurkBkpomC/MAPw2+ELci3FN5FYpGNkKoVVASeXDFjJUu6OpM1jAhbHoq5Sglj6J46BD0TAaczwfvGQuDuJeCLwhZoXZBo+BAybJ2i7uTLAjY7ElN7JxbM1l5bdbXPEtrK1m5370AqCrE0VF4li61Xs9sSAsXlfNJQOm8kvqYfNPwi2RFjDu9jrgdegEAohl8oTkoI6YbQEIojCJTnBlcRNMk68ILL8Sjjz4KALj66qvxqU99Cl/84hfxgQ98ABdeeKHrB0jx4x//GBs3bsQVV1yBq6++Gpdeeinuuusu6+uKomD//v2WguXxePBf//VfGBkZwZve9CZs3boVP/rRj/DDH/4QV199dceOs58hySLkIFmc5OVBLM5MQVPqJQyaaoN9Jqsi9AIAtGliIUzJfgguE6AXHjqOl5+dAM9z2HHTWfCH+z+cYC5B/z3zGQW6VlshFkdGiC3PMFA4cAAAkDK7YkLCFJCLI+LzgP76qWWQhl4EvSKg2JUs90gWHwpZaXfqlHPLYI6GXmzaBE7s3wWSHZZ1ziQrViGxEyUrRWeyuqlkUbugu0qWOjEBvSIEivZj+c/bbioW/Z0ix9AY1eaTlAWwqKcx7pVdWfTz6HZ8O1A+k6VnMjCKtTcCtSRRuoRw2GYXZJ9ThvbR9Fn09a9/HWmz7+Tzn/880uk0/vmf/xnr1q3rSLIgxeDgIH7yk5/U/PqqVatmxYOuW7cO99xzT8eOaSEiNCgjn1aQlwexND2FYmEN4K3VlWUuhKvZBX22RfIMucClfe7ucJ88mMDj95D45IvfthZjayKuvj8DIAc94DhSMZJLK2XJUbOeu2kTMr/5DfJ798J3zjkWyQoKk0AuDp7nMOCXMJ0pYjpTxGhYtpSsgMQDuQy0ArlZCy7aBTmOgzg8DGV8HNrUJLBsqaPX5XcTK5hvgYReAFWCL7x0Jqtx8IVOd4vDXZzJsoIvmlCyakS4A4AwMEASFnM5qCdPQlq50voa7cfymRb3fu9DYnCGyEj5fBLtX+trklWjkLiV3jqn8NhIFgBoiQTEGuMpumVlDjG7IIOraFrJWrNmDbZuJaWKgUAAd955J1544QXcc889WGm7wTD0J8JWjPsQlmSmkM2R4r76M1k2daCKXVBMENKe87u3w51NFvHLu3ZB1w2sPW8UWy/vfMnxQgTPc5AdJwyac1l7yFxWOkZiv0MmyQKAgYrwCzqTNShpAAwr+EJ00S4IAIIV4+7c8mzFty+QeSxgNuFoSckKdodkGYbRol2wtpLFcVwp/MI2l2WoKrLP/w4AmccCSily/byYZmiMcEX4BbWn9bNdMGzaBQtZ1droAOzBFx0gWSZJ0r1kjVLPMqglZ6cLss8pgxtommT99re/rVoA/NRTT+GZZ55x5aAY5i+CViHxEBZnplGkJKvqTFaVCPcqdkFviizQCkF3Fs66puNX392NTKKIgTE/Ln/vRtZ30UE4j3EnZax5s5ah0i4IYFb4BSVZQ5IKQwe0ojmT5aJdEGg+/MJQFOvnWIhKVtEKvmhmJqu7SpaS12DoxO3gbcIuSC2SalGvaomlc1lFG8nK790HI5sFHwrBu26d9f2B/k6RY2iMSlVnIQRfeLyClURrV7NKwRfupwuKkllGbHZ01iNZukWyQrYZuf79fTDMHZomWR/+8IerdkedOHECH/7wh105KIb5i7BFsgbhVwuIZMiCYSI3MfvJ1ZQsyy5YiuD2p8mCWg26YwF76t8P4cT+GYheATtu3sIWNR2GP0xukDmHSlbhwAEYqmojWSUli4ZfxLPkvahdcMCjWEXE4HkIEXetn7QrS3XYlVV46SUYhQL4UAieFStcPZb5DO8sJYv2ZM3/may8mSwoiDxEj/Nbn8dXWmxVDb+oEuNO57F8524DZybclmay2OJtIcPelaUpOnSNEP9+D0Sp1hFGryMdCb6g6YIeM7DLgZLFh1m6IIO7aJpk7dmzB+eee+6sx7dt24Y9e/a4clAM8xehIVP2D5F+srEEWQyniink1YqFljWTZevGsuyChFAZhoFghlxojUj1zrNmcOh3k9h5/xEAwGv/cCMGFwfafk+G+vCHyVxOIyXLs2IFeL8fRqGAwiuvIE1nsniTZBmGZRecTlfYBUXFCr0QBgbACe7eAC2SNe2MZOXMfiz5rDOtRfRCQGUIBO81SZajmazupgsWMqUFXTPKtiCUSJnTGHc6j+Xffp71WJH17zCgRDZmJnKWVRDo//OipOCVYtxppUIngi9KPVnk/qTXiXG3erLCYVsQCducZWgfTa8OvF4vTp8+PevxkydPQlwgCVsLGTTGPe8lStSSVAoeniyMZ81lWSSr9kxWRskgZF5zxcjito4tMZnDr39A5n22Xr4M685b1Nb7MTiDFePeoJCY43l4NxLLYHr3Pms+JiRMAloRKGZmKVmZIlmYRsSiFd/uZrIghdjkTFZ+t1lCvIDmsQBb8AW1C5pKlpEvNHytZgYmdUvJsjqymigiprDIZb5xIbFhGMg+uxMASRaksIIv2OJtQSNsko1iTrVqLEQPD17o782aauEXpRnJDipZNPiirl2QWpnDrIyYwVU0/al+3eteh89+9rNI2HYFZmZm8Kd/+qe46qqrXD04hvkHGj9b5GSoghdL0lMIiUSVmspVLFDpTJaSARRT5apIF5yJjUMyHTiewdaVLLWo4f67dqGYUzG2JoyLr1vb8nsxNAdrJitRn2QBJctgbPchAOTmKnnMOZdcHAP+8pksahcMC0WoZuiF2/NYACAMkXNYc2gXzJkkS15A81hAaXZCKWjQNR0cLSPuASUrn2k9yaxejLtkKVmEZBUPHYYWi4GTJMhnlc6PIrMLMoCk3gXM+aSpY2TjYSGcExEr8MM2k9VBu6CH9mRx5L2dBF/Y7YL9bt9kmBs0TbL+5m/+BseOHcPKlStx+eWX4/LLL8fq1atx6tQp3HbbbZ04RoZ5BK9PtC6Iee8glmSm4eOjAICJbMVclhwBOPNCRclVRfBF4jSZ78t5AF+4dWvfI3cfwNSxNHwhD15/41kQxP7eFZxPoAPNuQZKFgDImwnJmjlEzpXgoFyaz8vFMRQk7xWrsAtG+II1k+V2siBgsws6ULL0fN7q+vJtWVhKlmSfT8pp4GUzwr3BTJZhGKWZrHDvKlmF3OyZLNFUstTTp2EoSmkea+tW8FKpl09hZcQMJiKjhHBMHSOfiYVgTQt3SclSDfP/NUiWXizCMEvohVCI2XoZXEXTK9GlS5fihRdewNe+9jVs3rwZ27dvxze+8Q3s2rULy5cv78QxMswzhGzhF4szU5A4skiepWRxXHlXlq5bAQf08dTp4wCApE9AUGrtQrvnsXHsffwkOA646oYzERyQW3ofhtbgNF0QgGUXTJ0mi4tQBcmiSlZl8EWQL5ZmslzsyKKg/Snq1NSsvr1K5PfuBTQNwtAQxLH25wh7CbzAW4uPQk6xKVkNSFYuB2hk8SKEupMu2M6CjhKjakqWODxMyqx1Hcrp08g9U96PRWFFuPdxVDeDM1Dr3KSpZC0E4k1/5myiaCnhVDXqRLqgNZOl8zBQW8miCjs4DnyI9WQxuIuWrvaBQAA33XST28fC0CMIDcqYOpZGXh7EkomD4LWzAVRRsgBiC8xMEgWrkAAMvfQ4gOzUKUQAJHweBFpYfEweTeGRnxJV4YJr12D5RvdVDob6oDNZTpQs77p1gCgiZ5AbbmhQBrIlkjUYrR7hHuAK1kyWMDgAtyGadkGjUICeTtclAlYJ8VlnLchqAK9fhFLQUMiqkKyZrPoki6pYEASrW2uuQZUsuYmOLApvHbsgx/PwLFmC4uHDUE6MI0tDL2zzWIZuQGU2JAYTVNWZOkFJVv8TbznggdcvopBVkZzKlRXX2xVyt0CVLAMcdF6sSbI0WkQcDILjeVsKaP//Thg6D+apYmgadiUrqObhT5GL5SwlCyjFuOdipdALKQSIZDFdmCTELClLCDZ5UctnFPz33++CpupYtWUI576OlWF3A35KstJK1R4hO3hJgnftWuRlQoYrlSxqF4xnijAMAxlzYRrg8paSJXZAyeJ9PvBBMivUKMY9v9ssIV5gVkEKeyExJ9N0wfoky+rICoW6RkzzVMlqoiOLol7wBVAKv8g9txPK8eMAz8O3bZv1dbo7DiyM+RuG+qCqjrrAim/t4ReFHNn08HiFjoR+eKTSe+q8VDNdUE+SxwXTxsyULAY3wUgWQ9MImzHu2TBZWAxMkItSVSXLbhe0kgVLSoQaI4/NyDKCTShZhm7gwR/sQWo6j/CwjCuu3wyOX3iqwnyAHPSA4wAYhGg1fP7GjVY6ZXDQW9UuqOoGknnVsgv6kIdGgy86MJMFlOaytAYx7jS+fSGVENthLyTmZWcR7tZucZfmsQCgkDFnslqyC9ZWsoBSjHvivn8n32PjBgjBUsAHnfPgeY7NizJYZINioRTfWiRrItfReSyAWJt5kawJNEGqOZNlnxU1DIPNTjK4Cna1Z2gaVox7YBQAEJkg8c3VlSw7ySoPvQAAIz4DAEh4/U2RrGd/eQSHd01DEHnsuGkL5BaG2RncAc9zkJuYy5I3byopWUN2JSsG2SMgYNo8YpmiZRf0GQWbktVZklUv/EJLp1E8RJIR7clxCwneKkpWo+ALnfbQBLuTLAjYZ7JaCb6gM1mzgy8AwLOUbDgVX3kFQHk/FgBb946wIC2mDOWoJFkLxZpmhV9MlUhWJzqyKDxSqStLm0lUnbfVEqWOLF01oOvkOUzJYnADjGQxNA1qFyx4IgCAyFQGQJ2ZLIDYBSvi2wGAmyEXuIQ36Hgm69jeGJ6+jyxmLnvXeoys6M4gPUMJNPwi54BkSRs2ouCNAphtFwRgFRLbSZbXyFnpgp2IcAcAgXZl1bEL5ne/CBgGxCWLrTmuhQZ7nDlvzlfphUYzWWZHVheVrHw7SpaNWFYDVbIo/NvPLfs7SyxjsMPr90AOlsj+wrELmjHuE9mOK1mArSuLlwBFgZ7JznqOtQEUDpXbetlnlcEFOCZZ8Xgc3/zmN5GkSSw2JBKJml9j6D9QkqXAC433YGCa/N6TxSTyasVii6pW2elZRcQAICbJRW9GCjtSstLxPH713RdhGMCmSxZj8yVL2vxpGNyAP0wWDE6ULHXxGoDjwekKJDVjI1kzAGAVEscyRcsu6ClmoSs0wr0z5EYcaqxk5V9cmCXEdlhKls0u6FjJ6lKyIFBSslpRvZ3OZFH4K5IF2TA9QyXsatZCswsmp3K2jqzOuVCshEEvqYepFn5BlSw+HLY+38ICKIdmmBs4Pou+9a1v4ZFHHkG4yk5kJBLBb37zG3zzm9909eAY5ie8ftHaect7BzCSjMEr1Ai/aGAX9CbJ4izhCTcMvtBUHffftRv5tILh5UFc9o71Lvw0DG7AHya/fyckK1sgv2e5MIPigf2zlKxBi2QVkCmasd9Jmk7Hg+/QQt2JXZDOYy20EmI7JH/zwRfWTNY8IFmdnMkCAM/KFVYlAEWRzXkwVMBOshYK+Y6Mkp85NZ1H1kyj9XbQLijS8IswucdUJVnWBhArImZwH45J1j333IM/+qM/qvn1m2++GT/72c9cOSiG+Q2O4xC2EgaHsDQ9hUEvIU6TucnyJ9uVrCp2QdksnZ2RBhr2ZD12z8s4fSgJr1/Ejpu2WFYAhu6DxrhnHcS4p2JkQe7Nx5Dfs7emXfBkIg/N9McjQ+xmYjjQsZkWkdoFpyZrPie/iyQLLrQSYjtop409+KJRhLueLqULdgO6blgEqRUlqxThXn0mSxwZAUTynMp5LIAlljHMRpmStUAW9f6wBFHiYRjA9HEzvr6DdkE6k2WEogCqkyzakyVEwuxzyuA6HJOsgwcPYt26dTW/vm7dOhw8eNCVg2KY/7DCL+QhhJQcxtQoAGAyW7FAtc9kVdgFdV1HKE0iv2c8gwjUubC99NvT2PUwKS6+4vrNswaHGbqLZmayKMmS8zHk9+2bRbKoXfBorOSfN0xbqRDtXHBCIyVLjcWgnDgBAJA3b+7Yccx3eO1KljmTZRSLMLTqBASwpwt2h2QVsyUFqpVFnVSnJwsAOEGAZ/FiALOtgkDJLrgQ+pAYnKFcyVoYi3qO4xAeJj/3xFFyTeiokmWuKYwAmR/XEjOznlNS2cNWsiAjWQxuwTHJEgQB4+PjNb8+Pj4Onmce1oWCkBnjPhMiC4ulM2RhXFvJmk2ysjOTEM1apbx3EcQaHuh0PI+H/mkfAGD7jpVYvXXYrR+DwSU0M5OVpiSrEEd+756aStYxk2T5JQGaSbLEaMTV47ZDoBHuNYIv8ruJVVBatcrqVFmIsEIgsoqlZAH11axuz2TR0AuPV4DQwqyFlS5YYyYLAIZuuhHByy9H6PWvm/U1K/higSymGRojMuq3/iw1kazb67DmsiZJ7UMngy+okqX7yfW6ql2Q9mRFwijSGeAF9Ptg6Cwc3222bduGX/ziFzW//vOf/xzbbOWLDP0NGn6RDhKSNTpNTqVZShadySokgfRp8mdT3YqfOgIAyEmAx1978Xx8XxxqQcPQsiDOv2aNWz8Cg4toZibLrmQVXzkEHeaOrpoHillLyToWIzfhgFeEliKvEQaiLh95CeIwmaNRYzEY+uxS5dxuOo+1cK2CgK0nK6eC83qtx+vNZVnpgqHukNNCG0XEQLmSVS0GGgAG/uAPsPzvvlM1pt6a9WA75AwmqKIDLCzyXelC6Wy6IFmXGHLt4AvdNi+qLLByaIbOwzHJ+shHPoLbbrsN3/rWt6DZbCGapuGb3/wmbr/9dnz4wx/uyEEyzD9Qu2DBR5SqwUmyiJmlZMkRAOYMTZz0C1F1KzVB7H8JH4+gt/acRGycRMQvWRsFzwqH5yXoTFbO0UwW6VXzSwqg6ygcPQnw5o02F8dggCzcT5mhKEGvCM1UIjrVkUXeewDgOEDTqt6M8wu8hJjCsgtmVXA8bxGtukoWnXsIdacnK5+l8e2tJZlRkmUYKIt5dooiSxdkqIAv5LFmsTrZFTXfYFfwgNKMZydA7YK6lS6YmPUcjV6bwpFSETHbDGFwCY5J1nXXXYfPfOYz+NjHPobBwUFs27YN27Ztw+DgID7xiU/gk5/8JN72trd18lgZ5hHCw4RkaR5i/4mY0v8sJYsXSnYw3bTamOpWZuIkACDpE+vGt8dOEpI1uNhf8zkM3YWfkqy0Al2brQJRGIZhKVmR5cSel99bPpc1WBFMEPAKUDNmtO5Q56yinMcDIRoFMLsryzAM5HaT0IuFWkJMUTmfxDtIGNRSpbmHbqBgkiy5RSVL9PDWBk+t8It6UJhdkKECHMfhoreuxeZLFmN4afdKuucakeFyJWsugi90iawd6gZf2Hqy2EwWg1toypz+xS9+EU8++SSuv/56LFmyBIsXL8b73/9+PPHEE/jKV77SqWNkmIegSpYBL3RORGSSLKJmKVlAWS8WAMsumJ8i9sGEz1O3iJgqWYNLAu0eNkOHIAc94DgABiFatVDIqlDNG9nAxuUAgPzevRUky1v2moBHgJojxE0cHnX/4G0ohV+Un8fq6dNkVksQIG/a1NFjmO+wkvbyGnTdKMW41+nK0k2SJXQp+KKQaa+Th+M4eOhcVo3wi3pgEe4M1XDWZUtx+R9uAreAHBo0xp1iLiLcNY+5KVxBsgxdL20AhW3pgkxxZnAJTZ9J559/Ps4///xOHAtDD0EOeiBKPNSijrw8gPA0CS2oTrKGgOmXyZ9FH2DuKhWmyXMTsremklXMq5byMbh44ez29Rp4noMckpBLFpFNFhGIeKs+j/4ufSEP/Js3YAZAft9eYIWNZC2Syl4TlQxoebIIEUYXdepHAEBi3AsvvQStImEwZ0a3e9euBe9b2MmWdmtTMWePcc/VfE1JyeoSyaJKVhu75l6fiEJGrRt+UQsKG6hnYAAABAe84HkOulnP0dHgC2oXFMn9SEuU2wX1bBYw52+FcBjF/EzZ6xgY2oXjs/vo0aOOnrdixYqWD4ahd8BxHEJDPsRPZpCXBzEYn4Q/LyCBBApawSonBlDWi2VXtfQYIWYJr68myYqfJKlyvrAEOdg57zZD+/CbJKtejHtqmpCs0KAMedMyAEBh/wEYb1pHJvdycYR9IgSeszqyBiQFWp7sSIqjSzr6Mwg1Ytzzu18EsLBLiCkEkbc2WIq2GHc9X6j6fKNYtOa1upYumG1PyQIax7jXg8KULAYGAAAv8AgNyUiYIwadnEejXZoaRz73lUoWtQpykgRelpldkMF1OD67V61aVbUE1DAM63GO46Cqzd+AGHoToUEZ8ZMZTAeXYDC+H8sSHhyQVUzlprA0uLT0RBrjDpQRLiNOdpVmvIGadsHSPBazCs53+MMeTJ+onzCYjpdIlrRyBTi/H0Y2i2LaCy8A5OLgOA4DfglTabJoHxAVqAVCsgQzAbBTsBIGK2ayrBLiBT6PReH1iVCLRRSyjZUsLZ22/sxXSd6bCxTM4JRW0wWBUsdVoQ27IJvJYmAglsHEZA7gOmsXpDNZKke+RyXJoqEXvFnJwWYnGdyG47P7ueeeq/q4YRi4++67cccddyDYpRsoQ3cQNmPcY0GiLqzPBHEAM5jMTlaQrAHbn0skS0iQxVdCCmJVjZ0ji2Sxeax5D5owWI9kUSUrOCiDEwTI69cj9/zzyE8bJskiXWpDgRLJGtRTMDRTyepguiBgm8manrYeMwwDuRdNJeushR3fTiH5PcgkiqSQuMFMFt0t5gMBcEJ3Fi8FF5UsuhBrBtQuyMqIGRhK4ReSLHZ0Hk30mjNZhmkbTCZhqCo40SRdVuopUdiZksXgNhxf8c8+++xZj/3617/GrbfeigMHDuAzn/kMPvWpT7l6cAzzG7QrK+UnYQQrk2SRPZGdKH+iXcmykSxPkux8z0iRmhHuVugFU7LmPayurDox7jS+nQanyJs3EZJ1qoDIEKxC4sFAaS5r0HyMEwHO39mESXFkdvCFcvQo9EQCnMcDef26jn7/XoEVfpFV4bHSBWsoWbQjq4sFzrSMuJ35D1pI3JaSxRZvDAxWjHsnVSygpGRpeonIacmktVlXShYk1yY6b8k2QxjcQlPpghQ7d+7EVVddhd///d/HhRdeiJdffhl/9Vd/hVCX/PYM3QElWUUvUarG4uRCNiv8omwmq0S45BRZcCekKAI1lSyyQGMka/7DHzJj3B3aBQHAayb15U+Qm101khXJkscEH1fVsuwmqJJlD76gJcTeTZvASVLV1y00WF1ZOQWcj9oFq89k6any3eJugCpZcqB1Jcsrtz+TxWxIDAxAdBEhWb5QZ+es6UyWUtSt0B27ZVBLlpIFAaZkMbiPpkjWwYMH8Y53vAPnn38+RkZGsGfPHnzrW9/C6GhnY5UZ5icoyeJEYhMdnCKL61ldWVVmsgzDgN+MVY57BqoGXxTzKtKm8sHsgvMf/jC5YTqxC9JzR95ISFbh2BQMA0BuBkA5yQpkyeye2MEUKgphiJyr9pksq4SYzWNZoNY5MpNFgy9qKFnJ7iYLAraZrDbOIU+LwReapkNTSYIZ2yFnYACWbxrAq964Cpe8bW1Hvw8lS2pRszoQy0kWubcIbCaLoUNwTLL++I//GJs3b0YikcAzzzyDn/zkJ1izZk0nj41hnoOqERIvQed4hCaItW+WkuWfnS6op1IQzdGGGXEIwSqLDzqP5Q9Lbe1AM8wNGs1kaYpufS04SKyF3vXrAEGAlspCzfKWkjVgI1m+jKmEzEG6pDhCgi+0mRkYRXKsrIR4Nrw2wsHJ5Hdp1JrJSpsdWQ5I1ou/OYGf37YT+Tpda63AFSXL6gdrjmTZZ7jY4o2BgSQMnv+mNViybqDxk9uAXckqkaxSjLtuKVlsJouhM3C8rXbnnXdClmVMTEzgAx/4QM3n7dy505UDY5j/8IclCB4emqKj4B2ALzkNX0Gor2SZf85MjAMAsl5AQaRqumCchV70FOhMVq7GTFbKtAqKEm8tdnmvF94zzkDhwAHkZzzwmCRryEayvGlCssRg9e4tNyFEIoAoAqoKNRaDODKC/J69AAAfi2+3IFl2QZuSVahOsppRsp7/9THMnM7i0AtT2HTxYleOVVU0qApRktqbyaLEsrngC0rKBJGHILTk0GdgYGgBHjP4Qi3UUrLoTFYEQIlksaoFBrfg+I7zl3/5l508DoYeBMdxCA3KmDmdxXRwKZblp7EoDkwuqjOTZf45efoY+b8PgF69jJiFXvQW/KaSlUsr0DUdfMWCMh0rzWPZZ6vkTRsJyYp7EKoykyWmU1ABCKHOlwBzPA9xaAjq6dNQJ6egJZMwsllwfj8kptxbsAdf8HQmq4aSpTmcydJU3erOmR5P131uM6AqFse1Z9ejC69mgy+YBYmBoTugSpZa1MBHogDKSZY1LxoOwdANm5LFbL0M7oCRLIa2EBoiJOtUZDmWTb2AsbiBvbOCL+wR7uTPqYkTAICkXwDAVSdZppI1wEhWT0AOesBxgGEQohWIlCtPqVgpvt0O76ZNwL/dh3zcAyhxQMmXkSw+Tc4DMTI354E4PExI1tQktPgMAMC3eXPX4sfnI7w2JYvz0nTBGnZBK12wPslKTORgmAXUdIPFDRTM2U/J315cdCnCvUmSxXbHGRi6ApouaBgAV4VkaYlST5ZStNl6mV2QwSW44l1IJpP4u7/7O5x33nluvB1DD4EGGCQCxNozFgcShQSKms0yJohAdCXAi0BkBQAgO3mSvM5HbGN1lSxmF+wJ8DwHOVg7/KIyvp1C3rQZAFCYMYlVLl5GspDOAgCEyNz08FkJg9PTyLN5rKooC77w1S8jdpouGD9VIlbTJ9xTsvJZGnrR3kyf9TM3qWRRuyDbHWdgmFuIUmmJa4SIi6aMZKXovGjY2gwBV/46BoZ20NZV/+GHH8b3vvc93HvvvYhEInjLW97i1nEx9Ajogjkrk1mrJTOlGPeyQuL3/QLIxoEgCRYoTk3CDyDhJYvpypmsYk5FOm4mCzIlq2fgD3uRSylVY9xLdsFyhUveuAEAoGQEaEUOQi6OwUBJ/TTS5ixXNNKpwy6DYHVlTSFnJgvKbB6rDGVKltWTVT3C3elMlp1kZRNF5NOKRdrbgRV60WY6pbfFdEFqF2RKFgPD3IIXePAiB101YATJ/aPMLkjTBSPhkq3XK3S8KoRh4aDpu86JEyfwgx/8AN///vcxMzODeDyOn/zkJ3j729/OTswFiLCpZGkSuYAtT4gANExmK0jW4BrANpqlxKYBADPmAq2yJ8tKFoywZMFegj/swfSJ6oXEqVh5RxaFEInAs3QplBMnkI97EMjFMTQsYTjohW4YMNJk8S4MRjt+/AAgDhGSpYyfRGHfPgCAb8uWOfnevQKvqUCTmSwyK1dbyTJ3ixuUEcdPZcv+Pj2extL17aePWfHtbV5H6ExVMd9s8AWbyWJg6BY8koCCqlYlWaUNoJKSJTGrIIOLcKyJ3nPPPbj66quxYcMGPP/887jtttswPj4OnuexZcsWRrAWKEJDZIElCOT/ozGS4jUrxr0CemwGAJDw+iEJPLxidZLFVKzeghXjnqhNsipnsgBA3myWEsc9QC4OUeDxXx+7FP/1sUuhZsh7iYNDs17XCVC7YOaxx2AoCiGBy5fPyffuFZTPZBFlUq8ZfGEuZIKNlCzTFuoht6XpE+7MZbmtZGlKqffKCZQCswsyMHQLdL7K8JllxIlShLuVLhgJlz6nrMuOwUU4JlnveMc7sG3bNpw8eRL/+q//imuvvRaSJDV+IUNfg6oSMuchXVlJBd6igYnsRN3XcTPk4paQg7NULMBGstg8Vk+BxrhXKlmGbljF0pVKFgB4N24EABRmPFZX1mhYxginABoJQxDmimSZdkHlBAlnkc86i20iVUCydUaV7IK1gi+oklWbZBm6YdkFV51Ffs8xlxIG3ZrJsi++mrEMFpldkIGha6AJg7pMZnqpkmUUizByRH0XQqGS4syULAYX4Zhk3XDDDfj2t7+NHTt24M4770Q8Hu/kcTH0CAIRCRzPQQCHmSAJv1g0A0zlpuq+TkySXesZKVS1iDjO4tt7Ev6QGeNeMZOVSytk958DAgOz+65o+AVVsii0WAwAwIs6+ODczGRRJcs6NhZ6MQtU1YEBaAINvmigZNWZyUrF81CLOniBw+qzyb+/a0qWmS7oDbS3Q83znLUAayb8gkW4MzB0DzTEQpf9AEoki16XAHJtYkXEDJ2AY5L193//9zh58iRuuukm/PSnP8XixYtx7bXXwjAM6Lpz6wRDf4HjOcgRsrA+GV0FABiLN1ayvEmyIJuRIghItePbGcnqLfjD1dMFqVUwEPFWLWSldsFCUoSeKJ07qkmyBFkHpLmLcLeDlRDPhuDhLVufAtMuWIVkGboOPU0UqXrpgtQqGBn1Y3g5eV5sPA3DMNo+1oJLShZgj3F3PpdFI9/b6ehiYGBoDZQ06R5zdrRQgJ7LWVZBPhgEJwisaoGhI2gqp9Ln8+H/+//+P/zv//4vdu3ahTPPPBOLFi3CJZdcgne/+9249957O3WcDPMYQTP8YiK4BACJca+nZBm6DjlNFuEJz8Cs+PaCPVmQ2QV7CtZMViXJmq4eekEhLloEIeAFDA6Fw8etx9VpEpAieueOZAnDI2V/l1noRVVQNUsx85Oo9cYOPZMhJTWor2TNmCRrcMyP6CI/eJ5DMa9Z14F2kDeVLLlNJQtoLca9yHbIGRi6BtqVpXIeQDTnKmdmZgXyKMwuyNABtFwGsG7dOnzpS1/CsWPH8E//9E/IZrN417ve5eaxMfQIBkbIDlHSvwgAsDhWX8nSk0kIpvg5IwzMsgvGTRUrEJFc2X1mmDvQmaxcxUxWOl49vp2C4zjIq8j5kz982npcm6ZKlgZ4/K4fbzXwAT84MzFPHBmBZ9GiOfm+vQYafqGAfEb1wmxCpJu7xZzXC95b/XcPADFzHis65ocg8oiOkd+1G31ZripZNGGwBbsg2yFnYJh70JksTdEhRKPkzzMzZUXEgD2ghn1OGdxD241rPM/jTW96E37xi1/g2LFjbhwTQ48hOkwWpHkviVte1EDJUmNk5ibjBRREZnVksRLi3oXfVLJyaQW6VrIRW0rWUHUlCwC8Z5AEv/yxmPWYFid/JkrW3JQRcxxnWQbZPFZtWNY53UzvyuVm2fuczGMBpY2VgTHymR8yP/v0WtAOaLqgt810QcDWlZVvgmSx1DIGhq5B9Jq25oIGwexa1BKJUkm6SbJKVQvsc8rgHlyttR4dHXXz7Rh6BLQrCx6ykBqLG5gpzKCozY7xBoDc1CkAQNIPGJofwYqZrNI81twsqhncgxz0gOMAGIRoUVjx7QO1SZa8bi0AoGDrS1Kn7TNZc6NkAYA4RBLuWAlxbVDSUlRLO79GhZplWXIaFhGbdkFzBnNwKfnsu6lkudG3J7VQSMxSyxgYugfLLljUypUsOpNlpp6y4AuGTsBVksWwMEHVCYkn/x9OAR7FqKlmpU6TmZuknwN0eZZdkJKsgcVzt6hmcAc8z0EOzg6/qFVEbIe82UwYnFRhaOSGp02RvrW5nMkCgNCVV4CPRBC+6qo5+569BkvVUUvx9nrFXJYTJSuXLiJvEvLoIvKZp0rWdJtKlmEY1kyWG0pWKySLDdQzMHQPYk2SRTeAKmay2OeUwUUwksXQNmghcdDgofrJDvSiGdScy8pMngQApAMiAK6OXZApWb0Iay7LRrKsjqw6dkFp3UZwgg5DBYpHjgAA1Bgh6oJXBzxzR7KGPvhBrH/yCXjXrZuz79lrkMwZp2JBBzzkz5VKllX26SBZMDjotXaRh0wlK34qA01rPb1WKWgwdGJh9LqhZMk0wt15uiC1FjIbEgPD3INeU5SCDiFi2gVnZqAnSSmxFXxBN0OYksXgIhjJYmgbgYgEgwMEcEiOnQEAWByvrWTlJoldMOUni/Gg7aJWyCrIzJjJgkzJ6klYMe5m+IVS0JDPEKUiWEfJ4oLD8EbJgjS/excAQKPpgn4OEOe2/JwVENeH11cKgeBpIXGFkqWniN2Pr1NETOexBsdKJDo0KEP0CtBVA4mJ2amFTkHnsXiRg+hp/3YntTKTxYIvGBi6BtqTpdiVrHhJyaLXJrYZwtAJtHTXmZmZwT/+4z/is5/9LGJmj83OnTtx4sQJVw+OoTfACzx0mZxKscHVAEiMey0lqzhNyFfaTxZmQW9phzl2kuxqB6JelizYo6iMcadWQcknlkpsq0GOQh4gZKyw+3cASiEpQrB2Mh1Dd2CPM+dk8vupLCTW6HB5sLGSNWAjWRzPlSyDbcxlUXIv+z2ukOZm7YKGYdiiodnijYFhrmHZBQvVZ7KEMFG32EwWQyfQ9FX/hRdewJVXXolIJILDhw/jxhtvxODgIO69914cPXoUP/rRjzpxnAzzHFzQA+QKiAcXAyDhF5O5yarP1U1inpaJzTBgu6jFxsmCiiUL9i78oXKSlY7Vj2+3wPOQRz3Ay0B+zx4Yum7F7AphX+cOmKEl0E2QYlYFL/ugAdBz5SRLr9gtrgaLZFUo10NLAjh9KNlWwqCbyYJAqVDYKcnSVB26aVdkShYDw9yDkia1qEEYjQIgJMtQyAaMUBl8wT6nDC6iaSXrk5/8JK6//nq89NJLkOWS9efqq6/GI4884urBMfQOpBBZcCW8JJVtURyYzFYnWcYM8UInZEKk7GXEpWRBRrJ6FZUzWU5CLyhkM1Ey/9Ir0GZmAHOBKobY+TDf4LWULMWyCxqFCiUrXT5cXg3xUzS+vZxk0ZnMdpSsQsa9jizAFvbhcCaLqlgA2yFnYOgGaLpgmV0wkbClC7IyYobOoWmS9dvf/hY333zzrMeXLl2KU6dOuXJQDL0H3wBZWGd4csGqp2QJM2TRlJDIDpKdZMUZyep5WDNZFSSr3jwWhXfpIMAZ0BIpFPbtAwDwkg5OZufDfINkqkOFrGqVN9dUskLVQ2yUomadH3a7IAAMLW0/YZAqWXLAJSWLzqE5nMmi8e2iVwDHsxk/Boa5hjWTVdAh2u2CFT1ZzC7I0Ak0TbK8Xi+S5g6AHQcOHMDIyIgrB1UNX/ziF3HxxRfD7/cjan5QGsEwDPzFX/wFFi9eDJ/PhyuvvBIvvfRSx45xISNsFhIrhhnjngDiydNVn+tJkkH2mNmrZU8XZEXEvQ86k5VLUbugmSzogGTx4UF4w2QBm370MQCA6NXmrIiYwTm8tvkk3ktnsiqCL6iSFa6uZM2cygIG6bDyhcqDTaiSlZzKWQugZpF3WclqdiaLFhGzxDIGhu5AtNkFeXu6YKKijJh+VlnwBYOLaJpkXXPNNfjrv/5rKKafleM4HD16FH/yJ3+C6667zvUDpCgWi/iDP/gDfOhDH3L8mq997Wu44447cOedd+Kpp55CIBDA61//euQrhrMZ2sfQCLH6CCoP+GXwAIzx2STL0HV402TRPS2Qi1tIpjviCjIJsjAfYEpWz8JfI/jCCcmCbwDeKLm2ZB4jJGuui4gZnMFbpmTRdMEKu6ClZFWfyYqfrt2J5w9L8IU8gFGyETcLaybLLSVLLoV9OAErImZg6C6qlhEnk6UOv3CYzE6qxJrOPqsMbqJpknXbbbchnU5jdHQUuVwOr3nNa7B27VqEQiF88Ytf7MQxAgA+//nP45ZbbsGWLVscPd8wDPzt3/4tPve5z+Haa6/F1q1b8aMf/Qjj4+P4xS9+0bHjXKgYMecpAiogrFhB/nw6iaJWLHuelkiAN2tvJrkoeZ6pZFEVKzjgrZ9CxzCvYc1kpRXomt6UXRC+gVLC4P79AOa+iJjBGeyqDuc17YKVM1mp+j1ZcTNNdGBRdRLd7lxWIdsZJUvJl/q36oEVnDIwdBelnizNsgtC1wGz8F4Ih8uUckayGNxE0yvZSCSCBx54AI8++iheeOEFpNNpnHvuubjyyis7cXwt49ChQzh16lTZcUUiEVxwwQV44okn8M53vrPq6wqFAgq2Qs1q1kiG2Vi6JAgdBkRw0JdtAPYdwFgcmMpNYUlwifU8LU4iudMyoKB8JouFXvQH5KAHHAcYBpBNKsjEndsF4Ru0SBaFIM9tETGDM1AlyzAA3Ud+P0blTBbtyapFsmjoRY3P/NDSAE7sj7ecMJjPuDuTZd/8KRa0hptBdHaLWZAYGLoDOpOlFnVwkgTe74eeJZs78HjAyTIU8x7FixwEkdXHMriHlq/8l156KS699FI3j8VV0BCORYsWlT2+aNGiugEdX/7yl/H5z3++o8fWjwj6PMjwQEgHMkMr4Ucp/KKMZJnlskk/YKgBiDwHr3lRowupATaP1dPgeQ5y0INcSsHU8RR03QDPc/BHHJQJ+wYgR8tJFlOy5idEjwBe5KCrBlQPUZx020yWYRiWJafWTFa1jiw7hpbOLyVL8PDWz1zMqQ1JFouFZmDoLkRbuqBhGBCiUYtkCeEwOI4rbYawLjsGl9H0GXXHHXdUfZzjOMiyjLVr1+Kyyy6DIDS+qdx666346le/Wvc5e/fuxcaNG5s9zJbx2c9+Fp/85CetvyeTSSxfvnzOvn+vguM4ZD1AqAAkA4sIyYrNjnEvTJG/J/2AofkR8IpWSShTsvoH/rCEXErB6cNECQ4MeME7SVfzDUDwGhDDItQkufEJssZmsuYpvD4RuZQCzfz9GPmSC8DI5wFzdpevUkasazpmTlOSVcsuSK4FrSpZbvdkAaWf2Un4BbULsuALBobuwLL/GYCm6BCiUSjj4wBKNmaWLMjQKTR957n99tsxOTmJbDaLgYEBAEA8Hoff70cwGMTExATWrFmDhx9+uCE5+dSnPoXrr7++7nPWrFnT7CECAMbGxgAAp0+fxuLFi63HT58+jXPOOafm67xeL7zeBqWpDFWheHmgYGBGiGIMwNiMgZMVMe6piRMAgKSfA3SZdWT1KfxhCdMnMpgwSZYjqyAA+Mg1RR7hkTadukzJmr/w+oliqYh+8AB0W6gQVbHA8+ADs0lUcioPXTMgevia5we9FmSTReTSRfiCDtRQG6iSJQfcUbIAYv1zSrLoDrmH2QUZGLoCqmQB5V1ZAMBHKuLbmeLM4DKaNp9+6Utfwqte9Sq89NJLmJ6exvT0NA4cOIALLrgA3/jGN3D06FGMjY3hlltuafheIyMj2LhxY93/JKm5myrF6tWrMTY2hgcffNB6LJlM4qmnnsJFF13U0nsy1IfuJxeopE4WVCMJYCpZbs3MTp4k/w9KAHiLZOUzCrJmsiAjWb0PGuM+cZgstJsmWTbLoOBlM1nzFTQIQhXMMmKbXVBPlZIFqVptB53Hio75a3ZISbKI8DB57+kTzatZdCbLTSVL8jlPGGTBFwwM3QXPl+as1KIOIRqxvkZL0lkRMUOn0DTJ+tznPofbb78dZ5xxhvXY2rVr8Td/8zf47Gc/i2XLluFrX/saHjPjl93C0aNH8fzzz+Po0aPQNA3PP/88nn/+eaTTJa/+xo0b8fOf/xwAsa994hOfwBe+8AXcd9992LVrF973vvdhyZIlePOb3+zqsTEQCEGyW5zLcdC8IngDyB49XPYcahfMB8nCKWBe1KiKFRzwWosYht6F3+w8oj1FoaEmSVY4az0kykzJmq+g5EXhZ0e4a8kGyYIN5rEoaMJgbLy5uSxdNyy1ya2ZLKC5QuJigdkFGRi6DdFLC4nLlSxWRMzQaTS9mj158iRUdfbNRVVVK1BiyZIlSFGriEv4i7/4C/zwhz+0/r5t2zYAwMMPP4zf+73fAwDs378fiUTCes5nPvMZZDIZ3HTTTZiZmcGll16K+++/H7LscMHH0BS8UQlADkpKgbJ4GMLhUzCOj5c9R41NQwKQD5KFVWV8Oysh7g9QJYsiOODQgktJVjAJgMSCC8wuOG9Bgx9U3iwjtkW46+YGGB+uFd9uBt3UmMeiGFoawOEXpppWsux2Prd6soBSUmAx17ggWWF2QQaGrsMjCShk1LKuLKB0bVJYCihDh9C0knX55Zfj5ptvxnPPPWc99txzz+FDH/oQXvva1wIAdu3ahdWrV7t3lAB+8IMfwDCMWf9RggWQNCv7jBfHcfjrv/5rnDp1Cvl8Hr/+9a+xfv16V4+LoYSAuZDmsiq45SRRUBgvn8nS4zMAgHyA7E7TImI2j9VfCFSQLOdKVhQAIPo1RN/yJkTO9DGSNY8hUSULRCmqqmRVCb0AgPhpZ0rWUItKFlVRPV4BguBeLLPX1g/WCLSMWGJ2QQaGrkGsUkgMAEKYWAeLTMli6BCavvN897vfxeDgILZv326FRJx33nkYHBzEd7/7XQBAMBjEbbfd5vrBMsxvRIaI8sBpAL9sHQAgcCpR9hxuhiy88kFycQtIZMFi7WozktUXqFSyHM9k8QIgR8BxwOJPfhBLXks6t+Bh6YLzEZRwKIZJsqrNZFVRsgzDcKxkDS4l14Tp8QwMo3EBMEUnkgUBwNMEyVIKVMliizcGhm6hVEisV5AsqmSx2UmGzqDpu8/Y2BgeeOAB7Nu3DwcOHAAAbNiwARs2bLCec/nll7t3hAw9g8GQFy9xBkIGB34RUQyjUwUomgKPQBZhYoIsrHL+CBBndsF+hX+WXbAJi65vAMgngFwcKJqzWVLQxaNjcAvWTJZBFif2MmKrIys0uyMrmyiimNfAcUB0tD7Jii7ygxc4KHkNqVgeYXMzpxEKppLldTFZELApWXkndkE6k8VsSAwM3QItJK6cyeJDbCaLobNo+cpP0/8YGCgGAh4keR0hTQAGVgIghcRTuSksDi6GoevwpMgiLGvO3oRkkSQLJlmyYD/BFyqRLDnoae7m5RsA4odNkmVaxFhP1rwEnWFQNPL71e0zWUmaLjibIMfMZMHwiA+Cp76hQhB4DIz5MX0ig9iJjHOSZSpZsstKVmkmy7ldkO2QMzB0Dx5qF1Qq7II0wt2ayWKfUwZ30fTdR9M0/OAHP8CDDz6IiYkJ6Lpe9vWHHnrItYNj6C0M+CUkeANLNaDgicIPEuM+kRrH4uBiaIkEeNPtk/FGARAli6pYwUEvGzztE/hCEjgOMIwmrILWiwkBJyTLDDtgM1nzElTJKqqEKJUpWenaStaMw2RBisElQUyfyGB6PI1VW4cdvSbfISWLpgs6i3BnA/UMDN2GaG7yqQUNwuJShDs/q4yYfU4Z3EXTZ9THP/5x/OAHP8Ab3/hGnHXWWVX7TxgWJgb8EpImi8oURHhEDh7VwOlDLwGLt0ObngYApGVANcjFLeAVbaEXzBLWL+B5DnKQFNW2TLIyk4BWIH9mdsF5CVq3oJi1ZvYyYqpkCVVmspzOY1EMLQ3gpd8215XVqZksqZngC2ZDYmDoOqiSNXsmK2I+zj6nDJ1B03efu+++G//yL/+Cq6++uhPHw9DDsJOsxHQewkgAgyfTSB9+CbgYUGMx8jU/oCrE8hPyiogdZvNY/Qh/WEIupSA46DC+nYKSrOSJ0mMs+GJegvZPFYvkc2/kSsEXWoqE3PBV0gVjTSpZrSQM5rNK2TG6BYtkNejJMgyjtHhjNiQGhq6BzmSpikbUK0EANM2yCzJbL0On0DTJkiQJa9eu7cSxMPQ4QrKIlHmNmpnKwT8WBU6moRw5CgDQTJKV9AP5AiFZRMkiC6fBxWwh3U/whyVMn8i0oGQNkv8njpP/cwIgNknUGOYENASiYJIsvVCAYRjgOA56qnZPVvwUTRN19pmnGzDxU1lomu4okt2ayXKxIwtwHuGuFDTAtEczuyADQ/cgWumCGjiex/DNN0M5cQKe5cutxwGmZDG4j6Yj3D/1qU/hG9/4RlNRugwLAzzPAX5ykcrE8tCWLiJfOEFKqovTpDMrGeBQKJCFd8ArIHaS7Gozu2B/YePFizG8PIjVZzubobFAlazEMfJ/KQAwW/K8hDWTldcIn9A0yztIlazKmaxCTkU2QYJunCpZoSEZHq8AXTMwY/ZrNYKVLuiykkV3uxuVEdOFG8eVdtIZGBjmHlbwhfmZHPnYR7Hkq1+xxl3oZ5UFXzC4jaa31x599FE8/PDD+O///m+ceeaZ8HjKb2D33nuvawfH0HsQQiIwYUAr6uBXrwLwLLwniYKVmSRkK+nnkM1LAIqQNQ45M1nQ6a42Q29g/avGsP5VY82/0CJZpl2QhV7MW9AyYkMHNMELUStAz+chSFLNdEGqYvkjkqUKNQLHcRhcEsDpQ0nETmQs+2A9dGomy2uzC1LVrhqs7h2vwGaXGRi6CCvCvVh9Y4QG1LDgCwa30fQZFY1G8Za3vKUTx8LQB4iGvMhwOQQMDsII6coKnia2ofwEIVmFkBeZPEml1BMk2CA0KDNLDQMBJVnZKfJ/No81byF6ePACB10zoHn8JZIVDkNLk8+9EC5XsuInm5vHohhaGsTpQ0lMj6exDosaPr9gzmTJHZrJ0jUDmqJDlKrvftOZLQ+7rjEsUGiaBoWm4nQRos+AHOFhcCrytnAeCs6rk6/z1b/OsPDg8XggCO0rm01f/b///e+3/U0Z+hdRv4QEn0VA4yCGSVfWQKwIQ1VRjE1BBKBGAsgUyQJEiZn9WCz0goGCkiwKpmTNW3AcB8knIp9WoAWiQD4OI5+HoSgwsoRM8cHqStagw2RBiqGl5DxwmjCYz5hKlsszWR6vAHAADGJ9rEWyrCJiZkFiWGAwDAOnTp3CzMxMtw8FAMBFNGx5UwSiZODQoUOzvr7pdWRudDJxEtMppjozEESjUYyNjbXlRGBbbAyuYtAvIcnrWKLxEDyjUATAowG5E8egxWIQAeiREHQzJCw7RXaNWAkxgwVGsnoKXkqyfCQOWc/lLRULAIRQefBFnCYLNvmZH2wyYbDQoXRBjuMgySKKORXFnIpApHooC4tvZ1iooARrdHQUfr+/63bZQlZBOl6AKPGIjJRv7ui6gbhEg3gCZLacYUHDMAxks1lMTEwAABYvXtzye7VEsn72s5/hX/7lX3D06FEUi8Wyr+3cubPlg2HofUQDHpwyY9y1pIDTAxyWTRmYemk3jHgCAKBHIkAa4Dkgebq1BRdDH4ORrJ4CnXnSfMQWaORz0FPmPJbfD04sv81QJSvarJJlqt3JqTyKebWuvVhTdKhFvez43ITkEwjJytcOv1CYXZBhAULTNItgDQ0NdftwAACcLqAgGhBFAbJcnnaraTo8ItmQ8fnkrhNChvkBn48kYE9MTGB0dLRl62DTkUd33HEH3v/+92PRokV47rnncP7552NoaAivvPIK3vCGN7R0EAz9gwG/hIRJslKxPOLDZJc3+cp+CDNkB9qIkEV0QBKtUlJmF2SwUEmy2EzWvAadUVJloljp+QI0K/SiXMXSFB3JSdKlNdjkTJYvJMEXlgDAKjCvBdqRBQ6OwzWagZMY9yKzCzIsQNAZLL9//ly3KXGqlopt6Ib1HEawGOyg53A7c4VNk6zvfOc7uOuuu/DNb34TkiThM5/5DB544AF87GMfQyKRaPlAGPoDgxUkKzNKdrdzrxyEmCaLKz1CdreGPCJyKXLyDjS5q83QxxBEwGsLS5BYtP98BlWKVPP3RJQsM769oiNrZiILwyDEwx+Rmv5eVM2KjdcnWVayoE8E1wH7D1XR6pEshRWcMixgzCfCwpkr3WrNQ/QxjrUsMFTAjXO46dPq6NGjuPjiiwEQOS1l2kL+8A//ED/96U/bPiCG3kbU70GSkqzpPJQlhFBxe18GZ17MjBDpTVoEsvgIDbFkQYYK+KKlP0uMgM9nUFVHNW2dei4PjdoFKzqy7PNYrdzAhpYSIjd9ov5cltWRFXB3HotCssW410KxQL4msVhoBoauwrrW6PWVLAYGt9E0yRobG0MsRnqPVqxYgSeffBIAcOjQIVZQzICBgGSRrEJWhTFGGtV9L48DAJI+QBTIwmtEJ6cfswoyzILdMshmsuY1JDNYQhOJh123z2TV6MgaWNQacR5sUsmSOzCPBdhIVp1CYqZkMTDME1h2wdlfKilZjGQxuI+mSdZrX/ta3HfffQCA97///bjllltw1VVX4R3veAfrz2LAgF+CwgE5U7byDK8DAPAaGUJP+gHBIAuvAdPmypIFGWbBTrI87PyYz6BKlmKSLCNfsJQsoY6S1QqcKll0JqvTSlahrl3QVLIYyWJg6CpKdkFjlhhQUrI6ewz/8z//Y819Vfvv8ssv7+wBMHQFTW/z3XXXXdB1smD+8Ic/jKGhITz++OO45pprcPPNN7t+gAy9hQFzVzvBG/BpHHz+5VB5QCSnDJJ+gNMDAAwEC+TixkgWwywwJatnYM1kCSS1S8/noJvBF5UzWZaS1eIM5uDiAMABuZSCbLIIf7j6XFeBdmR1SskyiVPd4Asrwp3ZBRkYuokyK6AB0nNH/2qSrk4rWRdffDFOnjw56/H77rsPf/RHf4Q//uM/7uj3Z+gOmlayeJ6HaIvkfec734k77rgDH/3oRyFJzQ8yM/QXIj4POA5W+MX/v707j4uq3v8H/jowzLCvIjMIiAuISxak3pAUcAnz5hUzNS0N09JQ+ZUrWYFLi7lcTb0WWUnd6zfL7Fo30dzAErlidqG8KppXwAUiZHOQfc7vj2EOM7KIOMPm6/l4zCM962fG05l5n/fn8/5YVjgiz7FufYm1ALFG+wPLqkwbebG7INVjEGRxTFZ7JlUXFLSVRMVyvTFZtnVBlqgRUaTLZN1lZUEdC4U57LtoM2ZNzZely2RZGnmOLJ3mjMlid0Gi9kFoIKiS/q7RbWPaIEsul0OpVBq8CgsLsXjxYixfvhyTJk0CABw7dgxDhgyBQqGASqVCdHQ0qqvr7jMhISGIiorC0qVL4ezsDKVSiRUrVhicq6ioCLNnz4arqyvs7e0xYsQIpKenS+vT09MRGhoKOzs72Nvb4+GHH8ZPP/1k0vd/v2rRI7aioiKkpqYiLy9PymrpzJgxwygNo45JZm4Ge0sLlNzSADCHrNQKuU4C3Au0N7Zia0CstoaVphTmVdplLf3BRZ2YlXPdn1ldsF2TugtC+5BNU14ujcnSz2TdLChHdZUGZjIB9l0s6x+omVzcbVDyRxluXCuFh59zg9tI1QVNlMlqXgl3XXdBZrKI2pIgCNpISxTrjcuSMlmtPCSrqKgI48ePR0hICFavXg0AuHbtGsaOHYuIiAh89tlnOH/+PF544QVYWloaBFKffvopFi5ciJMnTyIlJQUREREICgrC6NGjAQCTJk2ClZUV9u/fDwcHB8TFxWHkyJG4cOECnJ2d8cwzz8Df3x/vv/8+zM3NkZaWBgsL0zyQut/d9d3/X//6F5555hmo1WrY29sbRP+CIDDIIjhZW6C4qAIAIN40R65eUqLEGqiutESXGm0S1b6LJSwUfNJLtzEYk8VMVnsmt9YFWdr/io1UF9SNx3Lsag0z85bXS3bpZovL6flNZrIqdGOyTJXJakZ3waoKZrKI2ovaGEsag6UjjclqxcIXGo0G06ZNg0wmw86dO6Xf0du2bYOnpye2bt0KQRDg5+eH69evY9myZYiJiYGZmfa+OXDgQMTGxgIAfHx8sHXrVhw5cgSjR4/G8ePHpSSIQqHtXbB+/Xrs3bsXX331FV588UVkZ2djyZIl8PPzk45BpnHX33SLFi3C888/D7VajaKiIhQWFkovXdVBur/pVxgsL6xBnnPdj4xKeyuUVYrootHeVDgeixrEMVkdhpTJ0mj/qykvh6akdp4sveqC9zoeS0fXvfhGExUGpTFZNiauLljeeHVBaTJiPkQianNCIxUG22KerOXLlyMlJQXffPMN7PQmbD937hwCAwMNkhdBQUFQq9W4evWqtGzgwIEGx1OpVMjLywOg7QqoVqvh4uICW1tb6XX58mVcunQJALBw4ULMnj0bo0aNwpo1a6TlZHx3/Q107do1REVFtavZvKl9cbKW46o0IXEFypSOAPIBABoHW5RWVsOlhuXbqQkMsjoMXZe8Ko05RGgnI65Ra7NMBpmsHF2QdW//ni7u2sCt4HopRI3Y4BPoitYak9WM6oIW7C5I1OYEMwA1DY3Jat15snbt2oX169dj3759Lc4g3d61TxAEaeiOWq2GSqVCUlJSvf0cHR0BACtWrMC0adOwb98+7N+/H7Gxsdi1axcrhJvAXcfuYWFhHCBHTXK0tpAKX5SrqyAq3etWOjngZnk1utRob2gtLeVMnRyDrA5DF3BoRAEaMwtoyisazmT9rivffm8P6BzcrGAmE1BVUYObBeUNblNu6kyWZTNKuNd2F2QJd6K2J2Wybu8u2ErVBQEgLS0Ns2bNwpo1axAWFlZvfd++fZGSkmIQCCYnJ8POzg4eHh7NOkdAQAByc3Mhk8nQu3dvg1eXLl2k7Xx9ffHKK6/g4MGDePLJJ7Fjx457f4NUT7O+gXTzYgHAn//8ZyxZsgRnz57FAw88UC+i/stf/mLcFlKH42wtR6UAiBYChCoRVg69UCP8AnMRMHd2QmlJFVx0ExEzyKKGMMjqMCwU5hDMBIgaEdUya2jKy+rGZNnrZ7Jqgyy3e/v3NDc3g5ObDW5cU+PGNbVUbVCfycdk3aG7oEYjorpS+2SZY7KI2p4uUVWvu6DGcL2p5OfnIzw8HCEhIXj22WeRm5trsN7c3ByRkZHYtGkTFixYgPnz5yMjIwOxsbFYuHChNB7rTkaNGoXAwECEh4dj7dq18PX1xfXr17Fv3z5MmDAB/fv3x5IlS/DUU0+hR48euHr1Kk6dOoWJEyea4m3f95oVZIWHh9dbtmrVqnrLBEFATU3jfdTp/uBko60yVqkwg6KqBs6iO74eKqBbAaDp3g1VJ2tgLTKTRU3gZMQdhiAIUFjJUF5ahWqZFcTSW9DUdhc0rx1vUHazEuWlVYAAON7jmCwAcOlWG2RdL0WPB10N1omiKI3JsjRRJks3Dq26ogaaGk29Qh66LBYAyDlPFlGbqxuT1TaZrH379iErKwtZWVlQqVT11nfv3h2ZmZlISEjAkiVL8OCDD8LZ2RmzZs3C66+/3uzzCIKAhIQEvPbaa5g5cyb++OMPKJVKDB8+HG5ubjA3N8eNGzcwY8YM/P777+jSpQuefPJJrFy50phvl2o16+5/e5l2oqY41j49LrMQoADgUNEF24Zrn+Y+Z+UMmVr7A8TSUQ4LOZ/yUgOsXQDrLtrHjJYObd0augO5dV2QVV1QANR+Z5jVBlm6ohd2zpZG+X/epZstgN9RcK1+hcGqihpoarsEmSqTZWGlV8ynvAaWNrcFWbXjsczMBZhbtOKIeiJqkK6wRf1MlnaBmYlTWc899xyee+65O24XHByM1NTURtc3NNZq7969Bn+3s7PD5s2bsXnz5gaP8fnnn9+xHWQcfMRGRudsrc1k3TQX4QjAutxButIcLR1hVVYDwBx2biyeQo0wlwFzftAGWTJOct7eSZkdmRWq/7gCABAsLCDUlhAuyLm3SYhv11SFQd0cWWbmAmRy0wQ45uZmkFmYobpKg8qyaljaGAZzlZyImKhdkQpb1BuTVbuez0LIBJp9WR09ehT9+vVDSe2AZn3FxcXo378/fvjhB6M2jjomx9ogqwDap9nmpXVjJhzkDrCt0N7VOB6LmuTQDXD0bOtWUDPoxihVyaykiYjN9OZRLMrVBVnGebCizWRpj1tTbdjTQhqPZWNh0ophdeOy6he/qJLKt/M5JlF70GgJ91auLkj3l2YHWZs2bcILL7wAe72BzDoODg6YM2cONm7caNTGUcfkXDsm6w+N9seHeLPuaa6NhQOcq7U3M1cP2/o7E1GHoyvjXi2rC6LMbY0/R5aOrZMCcktzaDQiimqrFupI47GsTRvgNFXGvbJCV76dmSyi9qCu8IVhlKVLbDHIIlNodpCVnp6OMWPGNLr+sccew+nTp43SKOrYnGrHQeRUaZ8oVxbV3dTksEWX2sqCSg+7+jsTUYej311QR7+yYIEuyDJS9loQBDjXzpd147rhuKxyE1cW1NGVZq8oq1/sSZfJsuBExETtg5muhHvdIlEUpdQWuwuSKTT7svr999/rlWvXJ5PJ8McffxilUdSx6boLFgm1c2XdrIZCtAQACGU2sBIFiBA5ETFRJyG3rh9k6SoLVpZXQ11QAQBwNtKYLABw7lY7Luua4bgs3ZgsU82RpdNUJktX+IJzZBG1Dw1lsvTnzGImi0yh2UFWt27dcObMmUbX//LLLw2WpaT7j1xmBluFDOUCYK7QXmLTvZ7HCM8RsChwBADclIGVBYk6ibpMVl13QF1lweK8MgCApa0FLG2Nl11yqc1kFdxW/KK8VJvJsjRxJkvRVHdBqfAFx2QRtQcNjcky6DnIGItMoNlB1tixY/HGG2+gvLy83rqysjLExsbiiSeeMGrjqONytLYABEBhr81qTXCbjPdGvIeiXO0PLrWCdzSizkLRUCbLXhtkFeQYdzyWjouUyTLsLihlslprTFZDhS8qdIUv+CCJqD2oK+FeP5MlmAnMZJFJNPtb6PXXX8fXX38NX19fzJ8/H3369AEAnD9/Hn/7299QU1OD1157zWQNpY7FyVqOq4VlEGxlwB/AzQJtcH6z9ql2uRU7QBN1Fg2OybI1nCPL2BOP6zJZN2+Uo7K8GvLarFFFaV11QVPSna/hTJau8AUzWUTtgZTJ0usiKLLoBZlYs78B3NzccOLECbz00kt49dVX62bJFgSEhYXhb3/7G9zc3EzWUOpYnGorDGpqJ+0suaENsm79of1vlS1/fBB1FrqsTrVFXSCly2QV1pZvN+Z4LEDb/dDaQY5bxZUouF4KZU/tpNWtl8nS3tsqmyp8wTFZRO1C3ZisumV1maw2aBDdF+7qW6h79+5ISEhAYWEhfvvtN4iiCB8fHzg5OZmqfdRB6SoMVtaOybp5oxyiKKKqdgA87E37lJmIWo/UXdBCf0yWtrqgLshyNHJ3QQBwcbfBreJK3Lim1guydGOyWqe7YEWDJdxruwsyyCJqFwRddUH97oIi58hqDUlJSQgNDUVhYSEcHR3bujmtqkXxu5OTEwYPHowhQ4YwwKIGOdVWGCyt/Z1z80Y5bpVUQqzUQAMRMkd5G7aOiIxJbqV9aGJYXdAWmhoNivOMOxGxPudu9YtflJfqqguauLtgk5MR13YX5GTERO1Cg5ksXXdBMwFJSUkQBKHRV2hoaOs3ugGJiYkYO3YsXFxcYG1tjX79+mHRokW4du2a0c6RmZkJQRCQlpZmtGPeibe3d4Of+5o1a4xy/BUrVuChhx4yyrHuBpOkZBK6IKvYTDspxc0bZdIA+GIzEdYmfspMRK1HymSZW0rLzOzsUfxHGTQ1ImRyM9g5WTa2e4u5NDBXVkWrzZPVVAl3ZrKI2hMpW6WpX/jCTACGDh2KnJyceq+4uDgIgoDIyMi2aLaBuLg4jBo1CkqlEnv27MHZs2fxwQcfoLi4GBs2bGj19lRWVhr1eKtWrar3+S9YsMCo52htDLLIJJxqnyLfqJ35r7SkEvnZ2h9C+WYibBXsLkjUWegKX2gEGWrMtH82t7eTugo6KW2k7jrGpKswqJ/J0o3JsjTxPFl1Jdzrj8mq5Jgsonal4RLuddUF5XI5lEqlwauwsBCLFy/G8uXLMWnSJGm/Y8eOYciQIVAoFFCpVIiOjkZ1dd3DlpCQEERFRWHp0qVwdnaGUqnEihUrDNpTVFSE2bNnw9XVFfb29hgxYgTS09Mbbf/Vq1cRFRWFqKgofPLJJwgJCYG3tzeGDx+Ojz76CDExMdK2x48fx7Bhw2BlZQVPT09ERUWhtLTuHunt7Y23334bzz//POzs7ODl5YUPP/xQWt+jRw8AgL+/PwRBQEhICAAgIiIC4eHheOutt+Du7i4VwPv73/+OQYMGwc7ODkqlEtOmTUNeXl5z/lkM6PbXf9nYaO/xNTU1mDVrFnr06AErKyv06dMH7733nsH+SUlJGDJkCGxsbODo6IigoCBkZWUhPj4eK1euRHp6upQhi4+Pv+v2tQSDLDIJXSYrv7IKMrkZIAJZ/72hXWaugS1LGxN1GhYKc6k7jm6uLDM7O6myoKOb8bsKArUVCwWg7GYVbpVUQqMRpTFSJs9kNTUZcUXtZMTsLkgEURRxq7K61V/646+gV8Jdt7z2GXCDY7KKioowfvx4hISEYPXq1dLya9euYezYsRg8eDDS09Px/vvv4+OPP8abb75psP+nn34KGxsbnDx5EmvXrsWqVatw6NAhaf2kSZOQl5eH/fv34/Tp0wgICMDIkSNRUFDQ4Ge4e/duVFZWYunSpQ2u1411unTpEsaMGYOJEyfil19+wRdffIHjx49j/vz5Bttv2LABgwYNwn/+8x9ERkbipZdeQkZGBgAgNTUVAHD48GHk5OTg66+/ljfijTEAAEPNSURBVPY7cuQIMjIycOjQIXz33XcAgKqqKqxevRrp6enYu3cvMjMzERER0WA7W0qj0cDDwwO7d+/G2bNnERMTg+XLl+PLL78EAFRXVyM8PBzBwcH45ZdfkJKSghdffBGCIGDKlClYtGgR+vfvL2XIpkyZYtT2NYbfAGQSuiCrsKwKds6WKMy9hZzfigAAN8xF2PDHB1GnIZgJkFvJUHGrGtUyKygqS2BuZ4fC3CIAgLPKNEGWhdwcDl2sUPxHGW5cU8PVyw6o/V3VatUFGxiTxUwWUZ2yqhr0i/m+1c97dlUYrOXa+4B+ICWK2jFajVUX1Gg0mDZtGmQyGXbu3Gmw77Zt2+Dp6YmtW7dCEAT4+fnh+vXrWLZsGWJiYmBmpj3YwIEDERsbCwDw8fHB1q1bceTIEYwePRrHjx9Hamoq8vLyoFAoAADr16/H3r178dVXX+HFF1+s914uXrwIe3t7qFSqJt/zO++8g2eeeQYvv/yydO7NmzcjODgY77//Piwttd22x44dK3WBXLZsGTZu3IjExET06dMHrq6uAAAXFxcolUqD49vY2OCjjz6CXF43rv7555+X/tyzZ09s3rwZgwcPhlqthq2tbZPt1bds2TK8/vrrBsv279+PYcOGwcLCAitXrpSW9+jRAykpKfjyyy8xefJklJSUoLi4GE888QR69eoFAOjbt6+0va2tLWQyWb33Y2r8pUsm4Vj7FLnwVhXsXBxRmHsLmhrtDe2GmQa2DLKIOhWFdV2QBQBm9vYozNEOxnYycvl2fS7dbFH8RxkKrpfCvov2B4RMYQ5zmWk7auhnskRRNPghxhLuRO2LQbJKFAEI0DRSXXD58uVISUlBamoq7OzsDNadO3cOgYGBBvsEBQVBrVbj6tWr8PLyAqANsvSpVCqpC116ejrUajVcXFwMtikrK8OlS5cabP/t95jGpKen45dffsHOnTsN9tVoNLh8+bIUeOi3TxAEKJXKZnXxe+CBBwwCLAA4ffo0VqxYgfT0dBQWFkKj0aYIs7Oz0a9fvzseU2fJkiX1MmDdunWT/vy3v/0Nn3zyCbKzs1FWVobKykqpmIWzszMiIiIQFhaG0aNHY9SoUZg8efIdg1JT4y9dMgnn2nmyCksrYddDIS0Xoc1kMcgi6lykubLMrQBBgGBlhcLf68ZkmYpzNxv8L+0PbRn3Xtoy7qYu3w7UvV9RBKoqaqRCGABQqesuyMmIiWBlYY6zq8La5Lw6giDUpq9EbTdBc73ugnrPY3bt2oX169dj37598PHxafG5LSwMuysLgiAFH2q1GiqVCklJSfX2a6zEua+vL4qLi5GTk9Nk4KBWqzFnzhxERUXVW6cLAO/UvqboxkjplJaWIiwsDGFhYdi5cydcXV2RnZ2NsLCwuy6M0aVLF/Tu3bvBdbt27cLixYuxYcMGBAYGws7ODuvWrcPJkyelbXbs2IGoqCgcOHAAX3zxBV5//XUcOnQIjzzyyF21w5j4DUAmoesuWK0RobCve+pRagHUCGB3QaJORlcIolpmBTM7O9wqqUZVeQ0EMwEOXa3usHfL1VUYLG21yoIAILMwg2AmQNSIqCyrC7JqqjXQVGufkFtw7CkRBEGQuu21bTu0D0WkMVm3ZbLS0tIwa9YsrFmzBmFhDQeFffv2xZ49ewwyS8nJybCzs4OHh0ez2hEQEIDc3FzIZDJ4e3s3a5+nnnoK0dHRWLt2LTZu3FhvfVFRERwdHREQEICzZ882Gqw0hy5TVVNTv6jP7c6fP48bN25gzZo18PT0BAD89NNPLT53Y5KTkzF06FCDKo8NZf38/f3h7++PV199FYGBgfi///s/PPLII5DL5c16P8bGwhdkElZyc1haaC8vwbbu5lpU+9vHlk94iToVKZMls64dj6UteuHgamXSrntShcGcUpSX6oIs099fBEFocFyWrqsgwBLuRO3J7RUG9asL5ufnIzw8HCEhIXj22WeRm5tr8Prjjz8AAJGRkbhy5QoWLFiA8+fP45tvvkFsbCwWLlwojce6k1GjRiEwMBDh4eE4ePAgMjMzceLECbz22muNBiienp7YuHEj3nvvPcyaNQvHjh1DVlYWkpOTMWfOHKk4x7Jly3DixAnMnz8faWlpuHjxIr755pt6hS+a0rVrV1hZWeHAgQP4/fffUVxc3Oi2Xl5ekMvl2LJlC/73v//h22+/NSgUcjdu3rxZ73MvKSkBoB1b9tNPP+H777/HhQsX8MYbb+DUqVPSvpcvX8arr76KlJQUZGVl4eDBg7h48aLUPdLb2xuXL19GWloa8vPzUVFR0aI23i0GWWQyumxWld4PjXxzbTqa3QWJOhdprqzaTJYuyDLFJMT6dEFcdUUN/qidJsLSxBMR6ygaqDCoC7jMLcxgZs6vWKL2QtCrMAjoVxcE9u3bh6ysLCQkJEClUtV7DR48GIB2jFBCQgJSU1Px4IMPYu7cuZg1a1a9gg1NtkMQkJCQgOHDh2PmzJnw9fXF008/jaysLLi5uTW6X2RkJA4ePIhr165hwoQJ8PPzw+zZs2Fvb4/FixcD0I61OnbsGC5cuIBhw4bB398fMTExcHd3b3b7ZDIZNm/ejLi4OLi7u2P8+PGNbuvq6or4+Hjs3r0b/fr1w5o1a7B+/fpmn0tfTExMvc9dV01xzpw5ePLJJzFlyhT86U9/wo0bNwyyWtbW1jh//jwmTpwIX19fvPjii5g3bx7mzJkDAJg4cSLGjBmD0NBQuLq64vPPP29RG++WIBrUuKTblZSUwMHBAcXFxbC3t2/r5nQoj7/3I87llGD75Idw4UNtadD9tlU4I6tGcvQIdHM0XRciImpdx7+8iPSjV9A963s80CUHmY+/hjM/XENAWHcETuhl0nN/8VYq8q+o0dXbHnmZJeg7VIURM/reeUcjnXfcggfh1V87iP3GNTV2rU6FlZ0Fnl83zORtIGpPysvLcfnyZfTo0UOqZNdeFOSUorqyBg6uVlBYW+DGdTVqqjRwdLPm+Emqp6lrubmxAR+zkck41z5NVkPUzpUFIFfQdqVhJouoc5Fb13UXNMhkmah8uz5nd22XwT+ybwIAFK2UydL9MKswyGTVVhbkeCyidkVXnE/qLtjEPFlExsAgi0zGUTdX1q0qBE/rgwGjPZFvpr272cj5A4SoM9F1nauSWUHh64PC3NrKgm6mqyyooyt+oZv3pjXGZAF149D0x2FV1XYXtOCTcaJ2pW5M1m2FL/hLmEykw1xab731FoYOHQpra+tGS1zqq6qqwrJly/DAAw/AxsYG7u7umDFjBq5fv276xhIAwKm2wlfRrUr4PaJCz9BugABYWphBxrEKRJ2KLrCRBw6H/eyXcKtEW77X1GOyAO1cWfpaa0yWrvBFQ5ksFr0gal/qxmRpAyxpMmJmsshEOswv3crKSkyaNAkvvfRSs7a/desWfv75Z7zxxhv4+eef8fXXXyMjIwN/+ctfTNxS0nGuzWQV3NL+2FLXzh1jq2idH0BE1Hqk6oKQoSivHABg46iQlpuSrrugTqtlsizrF76oqr3PWbBLNFG7ImWyNKJ20k7dcjMGWWQaHeZbYOXKlQCA+Pj4Zm3v4OCAQ4cOGSzbunUrhgwZguzsbINJ2fRVVFQYlHbUlY+ku6ffXRAASqUgi094iTobXWBTcasaBTmtU1lQx9ZJG8zpgp3W7i6oX8KdmSyi9knKWOnNlaVd3kYNok6vw2SyjKG4uBiCIDTZ3fCdd96Bg4OD9NJNrkZ3z8mmrrsgANysDbI4ETFR56MLOCrKqlGkG4+lNP14LED748lFL5vVliXcdeOzLBhkEbUrdYUvRGj0il6wuyCZyn0TZJWXl2PZsmWYOnVqk+UWX331VRQXF0uvK1eutGIrOxfdPFkFpbdnshhkEXU2UsBxq7rV5sjS56w3LqvVM1lleoUvau9zct7niNoXM113Qb2iF4yvyITaNMiKjo6WniI09jp//vw9n6eqqgqTJ0+GKIp4//33m9xWoVDA3t7e4EUtowuydJksdTmDLKLOSpqMuEqD/KvaSYGdVK2TyQJgkMlSWLdWCffGC18wk0XUvuhnsqSiFxyPRSbUpr92Fy1ahIiIiCa36dmz5z2dQxdgZWVl4ejRowyaWpGzjW5MlmHhC3YXJOp85JYyQAAgAupC7bjW1sxkuXSrDbKEuqyaqdWVcGd3QaL2ThdQiaIozZXFroJkSm36a9fV1RWurq4mO74uwLp48SISExPh4uJisnNRfY61T5PLqzQoq6xBaUXtRMScP4ao0xHMBMgt64pPyK1ksLaXt9r5Xb3sYeukgH0Xq1Z7Oq0/Dk1HVwRDzvscUbuiPxlxXSarDRt0n0hKSkJoaCgKCwubNQVTZ9JhLq/s7GykpaUhOzsbNTU1SEtLQ1paGtRqtbSNn58f/vnPfwLQBlhPPfUUfvrpJ+zcuRM1NTXIzc1Fbm4uKisr2+pt3FdsFTLIan/sFN6qhLqiSlpORJ2PfgbJSWndqk+JLRTmeHZ1IMa/4t9q52y4hHuN1B4iaj/0S7jXjcnSLktKSmpy6EpoaGibtVtfYmIixo4dCxcXF1hbW6Nfv35YtGgRrl27ZrRzZGZmQhAEpKWlGe2YTXn66acxZswYg2UHDhyAIAhYsWKFwfIVK1Y0Wh38bsTHx7dKwNdhgqyYmBj4+/sjNjYWarUa/v7+8Pf3x08//SRtk5GRgeLiYgDAtWvX8O233+Lq1at46KGHoFKppNeJEyfa6m3cVwRBgJNel0F17Y8PGzmDLKLOSK5XcKI1x2PpmMvMYNaKYyx0kxHrxmHp/5kl3InaF8NMVu2y2l/BQ4cORU5OTr1XXFwcBEFAZGRk2zRaT1xcHEaNGgWlUok9e/bg7Nmz+OCDD1BcXIwNGza0enuMlbAIDQ1FcnIyqqvrHlYlJibC09MTSUlJBtsmJia2m4C3OTpMkBUfH1/bj9bwFRISIm0jiqI0xsvb27vB7W/fh0zLqbbLYGFpVV11QXajIeqUbs9kdXa691tTpUFNtfZXm258lgXvc0TtiuGYLMNMllwuh1KpNHgVFhZi8eLFWL58OSZNmiQd59ixYxgyZAgUCgVUKhWio6MNAoSQkBBERUVh6dKlcHZ2hlKprJeRKSoqwuzZs+Hq6gp7e3uMGDEC6enpjbb96tWriIqKQlRUFD755BOEhITA29sbw4cPx0cffYSYmBhp2+PHj2PYsGGwsrKCp6cnoqKiUFpaKq339vbG22+/jeeffx52dnbw8vLChx9+KK3v0aMHAMDf3x+CIEi/mSMiIhAeHo633noL7u7u6NOnDwDg73//OwYNGgQ7OzsolUpMmzYNeXl5zf53CQ0NhVqtNkiaJCUlITo6GidPnkR5uXZy+/Lycpw8eVIKsu70GaanpyM0NBR2dnawt7fHww8/jJ9++glJSUmYOXOmNK1TQxkzY+kwQRZ1THUTEldKhS84GTFR5yQ3CLJaP5PV2vQDKV2XQV13QWayiGqJIlBZ2vovvQmHAf3ugrhjdcGioiKMHz8eISEhWL16tbT82rVrGDt2LAYPHoz09HS8//77+Pjjj/Hmm28a7P/pp5/CxsYGJ0+exNq1a7Fq1SocOnRIWj9p0iTk5eVh//79OH36NAICAjBy5EgUFBQ02J7du3ejsrISS5cubXC9ruvbpUuXMGbMGEycOBG//PILvvjiCxw/fhzz58832H7Dhg0YNGgQ/vOf/yAyMhIvvfQSMjIyAACpqakAgMOHDyMnJwdff/21tN+RI0eQkZGBQ4cO4bvvvgOgHZ6zevVqpKenY+/evcjMzLxjUTt9vr6+cHd3R2JiIgDg5s2b+PnnnzFp0iR4e3sjJSUFAHDixAlUVFRIQdadPsNnnnkGHh4eOHXqFE6fPo3o6GhYWFhg6NCh2LRpE+zt7aWM5eLFi5vd3rvBR21kUs4NBFmsLkjUOenPT3U/ZLLMzARYKMxRVVGDirJqWNnJ60q482ESkVbVLeBt99Y/7/LrgLzuYY9BCXfRcJk+jUaDadOmQSaTYefOnQZjS7dt2wZPT09s3boVgiDAz88P169fx7JlyxATEwMzM23uYuDAgYiNjQUA+Pj4YOvWrThy5AhGjx6N48ePIzU1FXl5eVAoFACA9evXY+/evfjqq6/w4osv1mvTxYsXYW9vD5VK1eRbfuedd/DMM8/g5Zdfls69efNmBAcH4/3334elpSUAYOzYsVIXyGXLlmHjxo1ITExEnz59pIJ0Li4uUCqVBse3sbHBRx99BLm8rqjR888/L/25Z8+e2Lx5MwYPHgy1Wg1bW1s0R2hoKJKSkvDqq6/ixx9/hK+vL1xdXTF8+HCpcEZSUhJ69OiB7t27N+szzM7OxpIlS+Dn5yd9FjoODg4QBKHe+zM2ZrLIpJxsGuguyCCLqFPSdZ8zl5nBvotVG7emddSVca+BKIpSd0FWFyRqX6RgSWw6k7V8+XKkpKTgm2++gZ2dncG6c+fOITAw0CDwCgoKglqtxtWrV6VlAwcONNhPpVJJXejS09OhVqvh4uICW1tb6XX58mVcunSpwbaLotisQkLp6emIj483OG5YWBg0Gg0uX77cYPt0wUZzuvg98MADBgEWAJw+fRrjxo2Dl5cX7OzsEBwcDEBbsK65QkJCkJycjKqqKiQlJUldFIODg6VxWbpgS/c+7/QZLly4ELNnz8aoUaOwZs2aRj9bU+K3AJmUU4PdBXnZEXVGusIXjm5WrVqAoi3JrWQoLapARVk1qqs00hNyzpNFVMvCWptVaovz6qtNKzQ0Jktn165dWL9+Pfbt22eQ+bjrU1sYToguCAI0Gu24TbVaDZVKVa+oA4BGK975+vqiuLgYOTk5TWaz1Go15syZg6ioqHrr9KvyNdW+ptjYGHYDLy0tRVhYGMLCwrBz5064uroiOzsbYWFhd1UYIzQ0FKWlpTh16hQSExOxZMkSANog6/nnn0dBQQFOnjyJOXPmSO/zTp/hihUrMG3aNOzbtw/79+9HbGwsdu3ahQkTJjS7XfeKv3bJpPSDrFJ2FyTq1Gxq58Vydm9eF5HOQDf2qrKsWpqIGAAs5AyyiABo++TJ236Mpn5ApampP09WWloaZs2ahTVr1iAsLKzBY/Tt2xd79uwxyCwlJyfDzs4OHh4ezWpHQEAAcnNzIZPJ4O3t3ax9nnrqKURHR2Pt2rXYuHFjvfVFRUVwdHREQEAAzp49i969ezfruA3RZapqamrusCVw/vx53LhxA2vWrIGnpycAGBSwaK5evXrB09MT3377LdLS0qRsWLdu3dCtWzds2LABlZWVUiaruZ+hr68vfH198corr2Dq1KnYsWMHJkyYALlc3qz3d6/YXZBMSjchceGtKmayiDo53yFKPBLeE3/6S8+2bkqr0XWRrCyvRlXtPc5CYd5qEyITUfPoJ62kIKt2YX5+PsLDwxESEoJnn31WmldV9/rjjz8AAJGRkbhy5QoWLFiA8+fP45tvvkFsbCwWLlwojce6k1GjRiEwMBDh4eE4ePAgMjMzceLECbz22muNBiienp7YuHEj3nvvPcyaNQvHjh1DVlYWkpOTMWfOHKk4x7Jly3DixAnMnz8faWlpuHjxIr755pt6hS+a0rVrV1hZWeHAgQP4/fffpamRGuLl5QW5XI4tW7bgf//7H7799luDQiF3IzQ0FNu2bUPv3r3h5uYmLQ8ODsaWLVukAhnAnT/DsrIyzJ8/H0lJSdLndOrUKfTt2xeAtsKiWq3GkSNHkJ+fj1u3brWozXfCIItMyrl2nqz8mxUor9KmohlkEXVOcisZHh7jDQfX+2M8FlA3JquyrLqu6AW7ChK1O7py3QCguW1M1r59+5CVlYWEhASDeVV1r8GDBwPQZlYSEhKQmpqKBx98EHPnzsWsWbPw+uuv31U7EhISMHz4cMycORO+vr54+umnkZWVZRBc3C4yMhIHDx7EtWvXMGHCBPj5+WH27Nmwt7eXquMNHDgQx44dw4ULFzBs2DD4+/sjJiZGCk6aQyaTYfPmzYiLi4O7uzvGjx/f6Laurq6Ij4/H7t270a9fP6xZswbr169v9rn0hYaG4ubNm/WmWQoODsbNmzcN5se602dobm6OGzduYMaMGfD19cXkyZPx+OOPY+XKlQC086LNnTsXU6ZMgaurK9auXduiNt+JIIq31bgkAyUlJXBwcEBxcTHs7e3bujkdzumsQkx8/wTsLWUoqR0QfuHNxyGXMb4noo4v8e/ncDY5B3/6Sw+4+zjhnxt+hqObNZ5Z+UhbN42o1ZWXl+Py5cvo0aOHVMmuPfnjyk2p6AUAOLpZs0gNNaipa7m5sQF/6ZJJ6SYj1gVYcpkZAywi6jR0mayKshpUltd1FySi9uf2Qhfs1kumxF+7ZFK67oI67CpIRJ2J3GBMFufIImrPhNt+9TanLDpRSzHIIpOyt7SA/oMiBllE1Jnoj8nSVReUc0wWUbtUP5PVRg2h+wIvLzIpMzMBjtZ12SyWbyeizkQ3nkNb+KK2uyDHeBC1S7cnrsyYySITYpBFJqcr4w4AtuxGQ0SdiFTCvaymrrsgM1lE7VK97oGMsciEGGSRyTnpZbLYXZCIOhO5Ve1kxOV1JdzlfJhE1C7pdw8UzASOySKTYpBFJufE7oJE1EkZjslid0Gi9kw/qGKARabGIItMzsmguyB/fBBR52E4JouFL4jaM4Mgi7+AycR4iZHJOdmwuyARdU5SJquC82QRtXcG3QWZySITY5BFJsfugkTUWekKX0AEbhVXAqjLbhFR+2LYXbANG9KBCIKAvXv3tnUzOiQGWWRy7C5IRJ2VuYUZzGTaX2vqwnIArC5I1G7pBVaC3iSeSUlJEASh0VdoaGgbNNaQIAiwtLREVlaWwfLw8HBERETc8/FXrFiBhx566J6PQ3UYZJHJ6c+TZcsnvETUyeiyWWU3qwBwTBZRe6UfWOlntYYOHYqcnJx6r7i4OAiCgMjIyLZobj2CICAmJsaoxxRFEdXV1UY95p1UVla26vnaCoMsMjlnG3YXJKLO6/bugRa8zxFJRFHErapbrf4SRbFeWwSDTFbdn+VyOZRKpcGrsLAQixcvxvLlyzFp0iRp22PHjmHIkCFQKBRQqVSIjo42CFJCQkIQFRWFpUuXwtnZGUqlEitWrDBoR1FREWbPng1XV1fY29tjxIgRSE9Pv+NnOX/+fPzjH//AmTNnGt2moqICUVFR6Nq1KywtLfHoo4/i1KlT0npd1m7//v14+OGHoVAo8I9//AMrV65Eenq6lL2Lj4+X9snPz8eECRNgbW0NHx8ffPvttwbnPHPmDB5//HHY2trCzc0N06dPR35+vsFnMn/+fLz88svo0qULwsLCpHYcOXIEgwYNgrW1NYYOHYqMjIw7fg4dBb8JyOScOBkxEXViuuIXOuwuSFSnrLoMf/q/P7X6eU9OOwlrC2uDZc0t4V5UVITx48cjJCQEq1evlpZfu3YNY8eORUREBD777DOcP38eL7zwAiwtLQ0CqU8//RQLFy7EyZMnkZKSgoiICAQFBWH06NEAgEmTJsHKygr79++Hg4MD4uLiMHLkSFy4cAHOzs6NtisoKAgXLlxAdHQ0vvvuuwa3Wbp0Kfbs2YNPP/0U3bt3x9q1axEWFobffvvN4NjR0dFYv349evbsCUtLSyxatAgHDhzA4cOHAQAODg7StitXrsTatWuxbt06bNmyBc888wyysrLg7OyMoqIijBgxArNnz8bGjRtRVlaGZcuWYfLkyTh69KjBZ/LSSy8hOTkZAJCTkwMAeO2117Bhwwa4urpi7ty5eP7556VtOjpmssjkDKsLWjSxJRFRx6ObkFj6O7tFE7VL+nGVmVnDQZZGo8G0adMgk8mwc+dOg2Bs27Zt8PT0xNatW+Hn54fw8HCsXLkSGzZsgEajkbYbOHAgYmNj4ePjgxkzZmDQoEE4cuQIAOD48eNITU3F7t27MWjQIPj4+GD9+vVwdHTEV199dcf38M477+DAgQP48ccf660rLS3F+++/j3Xr1uHxxx9Hv379sH37dlhZWeHjjz822HbVqlUYPXo0evXqhW7dusHW1hYymUzK5FlZWUnbRkREYOrUqejduzfefvttqNVqpKamAgC2bt0Kf39/vP322/Dz84O/vz8++eQTJCYm4sKFC9IxfHx8sHbtWvTp0wd9+vSRlr/11lsIDg5Gv379EB0djRMnTqC8vPyOn0NHwG8CMjlHq7rAyoaZLCLqZOp1F2Qmi0hiJbPCyWkn2+S8tzMck9XwfsuXL0dKSgpSU1NhZ2dnsO7cuXMIDAw0CLyCgoKgVqtx9epVeHl5AdAGWfpUKhXy8vIAAOnp6VCr1XBxcTHYpqysDJcuXbrj++rXrx9mzJiB6OjoehmfS5cuoaqqCkFBQdIyCwsLDBkyBOfOnTPYdtCgQXc8l47++7GxsYG9vb3B+0lMTIStrW29/S5dugRfX18AwMMPP3zHY6tUKgBAXl6e9Fl2ZAyyyORk5mbwcLJCTnE53Owt27o5RERGpdDrLigIgMyCnUSIdARBqNdtr60YTkZcP8ratWsX1q9fj3379sHHx6fF57GwMOy1IwiClOlSq9VQqVRISkqqt5+jo2Ozjr9y5Ur4+vreU2l1GxubZm97p/czbtw4vPvuu/X20wVNTZ1P/9i6fx/9rGBHxiCLWsWnzw9BYWklutgq2ropRERGZaEXZFlYyjjJKVE7ZVD44rb/T9PS0jBr1iysWbMGYWFhDe7ft29f7NmzB6IoSvsnJyfDzs4OHh4ezWpDQEAAcnNzIZPJ4O3t3aL34enpifnz52P58uXo1auXtLxXr16Qy+VITk5G9+7dAQBVVVU4deoUXn755SaPKZfLUVNTc9dtCQgIwJ49e+Dt7Q2ZjGGFPj5uo1bRy9UWg7wbH8xJRNRR6WeyWL6dqP0yzGTVLc/Pz0d4eDhCQkLw7LPPIjc31+D1xx9/AAAiIyNx5coVLFiwAOfPn8c333yD2NhYLFy4EGZmzftJPWrUKAQGBiI8PBwHDx5EZmYmTpw4gddeew0//fRTs9/Lq6++iuvXr0uFKgBttuill17CkiVLcODAAZw9exYvvPACbt26hVmzZjV5PG9vb1y+fBlpaWnIz89HRUVFs9oxb948FBQUYOrUqTh16hQuXbqE77//HjNnzmxR0NaZMMgiIiK6B/pjsiw47pSo3dIPrPQDrn379iErKwsJCQlQqVT1XoMHDwYAdOvWDQkJCUhNTcWDDz6IuXPnYtasWXj99deb3wZBQEJCAoYPH46ZM2fC19cXTz/9NLKysuDm5tbs4zg7O2PZsmX1ikSsWbMGEydOxPTp0xEQEIDffvsN33//PZycnJo83sSJEzFmzBiEhobC1dUVn3/+ebPa4e7ujuTkZNTU1OCxxx7DAw88gJdffhmOjo7NDjw7K0FsaCIBkpSUlMDBwQHFxcWwt7dv6+YQEVE7898fryFpp3Zul67e9pgU3fwB5USdSXl5OS5fvowePXrA0rL9jcHWaETkX7kJAHBS2vChCDWqqWu5ubHB/R1iEhER3SM5uwsSdQiGY7Larh10f2CQRUREdA/0gyw+GSdqvwRBgLnMDBAEmJkzyiLTYhkQIiKie2BY+IJfq0TtmaObNUSNCDNz5hnItPhtQEREdA/0Jx/mRMRE7Zu5jMEVtQ5eaURERPeAJdyJiOh2DLKIiIjugeGYLHYQISIiBllERET3xEJuDtSOoWd3QSIiAhhkERER3RPBTJAKXrC7IBERAQyyiIiI7pncShtcsbsgEREBDLKIiIjumZWtHABgacMgi4g6l4iICISHh7d1MzocBllERET3KHBCL/g/5gV3H8e2bgoR3aWkpCQIgtDoKzQ0tK2biGPHjmHEiBFwdnaGtbU1fHx88Nxzz6GystJo58jMzIQgCEhLS7vnY8XHxzf4WVpaWt57Q2sJgoC9e/ca7XjGxkduRERE98izrzM8+zq3dTOIqAWGDh2KnJycesu//fZbzJ07F5GRkW3Qqjpnz57FmDFjsGDBAmzevBlWVla4ePEi9uzZg5qamjZtW1Ps7e2RkZFhsEwQhDZqTetjJouIiIiITEIURWhu3Wr1lyiKzW6jXC6HUqk0eBUWFmLx4sVYvnw5Jk2aJG177NgxDBkyBAqFAiqVCtHR0aiurpbWh4SEICoqCkuXLoWzszOUSiVWrFhhcL6ioiLMnj0brq6usLe3x4gRI5Cent5o+w4ePAilUom1a9diwIAB6NWrF8aMGYPt27fDyspK2m7Pnj3o378/FAoFvL29sWHDBoPjNJT5cXR0RHx8PACgR48eAAB/f38IgoCQkBCDbdevXw+VSgUXFxfMmzcPVVVVTX6ugiDU+1zd3Nyk9QcOHMCjjz4KR0dHuLi44IknnsClS5ek9ZWVlZg/fz5UKhUsLS3RvXt3vPPOOwAAb29vAMCECRMgCIL09/aEmSwiIiIiMgmxrAwZAQ+3+nn7/HwagrV1i/YtKirC+PHjERISgtWrV0vLr127hrFjxyIiIgKfffYZzp8/jxdeeAGWlpYGgdSnn36KhQsX4uTJk0hJSUFERASCgoIwevRoAMCkSZNgZWWF/fv3w8HBAXFxcRg5ciQuXLgAZ+f6GXGlUomcnBz88MMPGD58eINtPn36NCZPnowVK1ZgypQpOHHiBCIjI+Hi4oKIiIhmve/U1FQMGTIEhw8fRv/+/SGXy6V1iYmJUKlUSExMxG+//YYpU6bgoYcewgsvvNCsYzektLQUCxcuxMCBA6FWqxETE4MJEyYgLS0NZmZm2Lx5M7799lt8+eWX8PLywpUrV3DlyhUAwKlTp9C1a1fs2LEDY8aMgbl5+6vsyiCLiIiIiAiARqPBtGnTIJPJsHPnToPubdu2bYOnpye2bt0KQRDg5+eH69evY9myZYiJiYGZmbaD2MCBAxEbGwsA8PHxwdatW3HkyBGMHj0ax48fR2pqKvLy8qBQKABoM0R79+7FV199hRdffLFemyZNmoTvv/8ewcHBUCqVeOSRRzBy5EjMmDED9vb2AIC//vWvGDlyJN544w0AgK+vL86ePYt169Y1O8hydXUFALi4uECpVBqsc3JywtatW2Fubg4/Pz/8+c9/xpEjR5oMsoqLi2Fra2uwbNiwYdi/fz8AYOLEiQbrPvnkE7i6uuLs2bMYMGAAsrOz4ePjg0cffRSCIKB79+712uro6Fivre0FgywiIiIiMgnBygp9fj7dJudtieXLlyMlJQWpqamws7MzWHfu3DkEBgYaBF5BQUFQq9W4evUqvLy8AGiDLH0qlQp5eXkAgPT0dKjVari4uBhsU1ZWZtBVTp+5uTl27NiBN998E0ePHsXJkyfx9ttv491330VqaipUKhXOnTuH8ePHG+wXFBSETZs2oaam5p4zPf379zc4hkqlwq+//trkPnZ2dvj5558Nlul3b7x48SJiYmJw8uRJ5OfnQ6PRAACys7MxYMAAREREYPTo0ejTpw/GjBmDJ554Ao899tg9vY/WxCCLiIiIiExCEIQWd9trbbt27cL69euxb98++Pj4tPg4FhYWBn8XBEEKINRqNVQqFZKSkurt5+jo2ORxu3XrhunTp2P69OlYvXo1fH198cEHH2DlypXNapcgCPXGqt1pXJVOU++pMWZmZujdu3ej68eNG4fu3btj+/btcHd3h0ajwYABA6SKiQEBAbh8+TL279+Pw4cPY/LkyRg1ahS++uqrZrW5rTHIIiIiIqL7WlpaGmbNmoU1a9YgLCyswW369u2LPXv2QBRFKZuVnJwMOzs7eHh4NOs8AQEByM3NhUwmu6diDU5OTlCpVCgtLZXalpycbLBNcnIyfH19pQyUq6urQRXFixcv4tatW9LfdWOwWqNi4Y0bN5CRkYHt27dj2LBhAIDjx4/X287e3h5TpkzBlClT8NRTT2HMmDEoKCiAs7MzLCws2nV1RQZZRERERHTfys/PR3h4OEJCQvDss88iNzfXYL25uTlcXV0RGRmJTZs2YcGCBZg/fz4yMjIQGxuLhQsXSuOx7mTUqFEIDAxEeHg41q5dC19fX1y/fh379u3DhAkTMGjQoHr7xMXFIS0tDRMmTECvXr1QXl6Ozz77DP/973+xZcsWAMCiRYswePBgrF69GlOmTEFKSgq2bt2Kbdu2SccZMWIEtm7disDAQNTU1GDZsmUGGaquXbvCysoKBw4cgIeHBywtLeHg4NCSjxSAtrLk7Z+l7jxOTk5wcXHBhx9+CJVKhezsbERHRxts99e//hUqlQr+/v4wMzPD7t27oVQqpYyft7c3jhw5gqCgICgUCjg5ObW4rabAEu5EREREdN/at28fsrKykJCQAJVKVe81ePBgANruegkJCUhNTcWDDz6IuXPnYtasWXj99debfS5BEJCQkIDhw4dj5syZ8PX1xdNPP42srCyD8ub6hgwZArVajblz56J///4IDg7Gv//9b+zduxfBwcEAtBmyL7/8Ert27cKAAQMQExODVatWGRS92LBhAzw9PTFs2DBMmzYNixcvhrVeV06ZTIbNmzcjLi4O7u7u9cZ43a2SkpIGP8+8vDyYmZlh165dOH36NAYMGIBXXnkF69atM9jfzs4Oa9euxaBBgzB48GBkZmYiISFBCmg3bNiAQ4cOwdPTE/7+/vfUVlMQxLuZSOA+VFJSAgcHBxQXF0sVXIiIiIjIUHl5OS5fvowePXrA0tKyrZtD1GJNXcvNjQ06TCbrrbfewtChQ2FtbX3HgYENmTt3LgRBwKZNm4zeNiIiIiIiIp0OE2RVVlZi0qRJeOmll+5633/+85/497//DXd3dxO0jIiIiIiIqE6HKXyhK08ZHx9/V/tdu3YNCxYswPfff48///nPJmgZERERERFRnQ4TZLWERqPB9OnTsWTJEvTv379Z+1RUVKCiokL6e0lJiamaR0REREREnVCH6S7YEu+++y5kMhmioqKavc8777wDBwcH6eXp6WnCFhIRERERUWfTpkFWdHS0dibwJl7nz59v0bFPnz6N9957D/Hx8dKEcc3x6quvori4WHpduXKlRecnIiIiIqL7U5t2F1y0aJFB/f6G9OzZs0XH/vHHH5GXlwcvLy9pWU1NDRYtWoRNmzYhMzOzwf0UCgUUCkWLzklERERERNSmQZarqytcXV1Ncuzp06dj1KhRBsvCwsIwffp0zJw50yTnJCIiIiIi6jCFL7Kzs1FQUIDs7GzU1NQgLS0NANC7d2/Y2toCAPz8/PDOO+9gwoQJcHFxgYuLi8ExLCwsoFQq0adPn9ZuPhERERER3Sc6TJAVExODTz/9VPq7v78/ACAxMREhISEAgIyMDBQXF7dF84iIiIiIOp2IiAgUFRVh7969bd2UDqXDVBeMj4+HKIr1XroACwBEUWxyjFdmZiZefvllk7eViIiIiDqGpKSkJouwhYaGtnUTcezYMYwYMQLOzs6wtraGj48PnnvuOVRWVhrtHJmZmRAEQeot1lLnz5+HIAj497//bbD8kUcegaWlJcrLy6Vl5eXlsLS0xMcff3xP5wQAb29vbNq06Z6PYywdJsgiIiIiIjK2oUOHIicnp94rLi4OgiAgMjKyTdt39uxZjBkzBoMGDcIPP/yAX3/9FVu2bIFcLkdNTU2btq0hfn5+UCqVSEpKkpbdvHkTP//8M1xdXQ2Cr5SUFFRUVGDEiBFt0FLTYpBFRERERCYhiiKqKmpa/SWKYrPbKJfLoVQqDV6FhYVYvHgxli9fjkmTJknbHjt2DEOGDIFCoYBKpUJ0dDSqq6ul9SEhIYiKisLSpUvh7OwMpVKJFStWGJyvqKgIs2fPhqurK+zt7TFixAikp6c32r6DBw9CqVRi7dq1GDBgAHr16oUxY8Zg+/btsLKykrbbs2cP+vfvD4VCAW9vb2zYsMHgOIIg1Ovy5+joiPj4eABAjx49AGiH5AiCYNBbDADWr18PlUoFFxcXzJs3D1VVVY22OTQ01CDIOn78OHx9fTFu3DiD5UlJSejevbt07m+++QYBAQGwtLREz549sXLlSunzFUURK1asgJeXFxQKBdzd3aW5cENCQpCVlYVXXnlFykC2tQ4zJouIiIiIOpbqSg0+/H/HWv28L74XDAuFeYv2LSoqwvjx4xESEoLVq1dLy69du4axY8ciIiICn332Gc6fP48XXngBlpaWBoHUp59+ioULF+LkyZNISUlBREQEgoKCMHr0aADApEmTYGVlhf3798PBwQFxcXEYOXIkLly4AGdn53rtUSqVyMnJwQ8//IDhw4c32ObTp09j8uTJWLFiBaZMmYITJ04gMjISLi4ud5wuSSc1NRVDhgzB4cOH0b9/f8jlcmldYmIiVCoVEhMT8dtvv2HKlCl46KGH8MILLzR4rNDQULzyyiuorq6GTCaTaigMGzYM27Ztkz6vxMREqTvmjz/+iBkzZmDz5s0YNmwYLl26hBdffBEAEBsbiz179mDjxo3YtWsX+vfvj9zcXCk4/frrr/Hggw/ixRdfbLRNrY2ZLCIiIiIiABqNBtOmTYNMJsPOnTsNMiLbtm2Dp6cntm7dCj8/P4SHh2PlypXYsGEDNBqNtN3AgQMRGxsLHx8fzJgxA4MGDcKRI0cAaDM6qamp2L17NwYNGgQfHx+sX78ejo6O+Oqrrxps06RJkzB16lQEBwdDpVJhwoQJ2Lp1K0pKSqRt/vrXv2LkyJF444034Ovri4iICMyfPx/r1q1r9nvXTavk4uICpVJpEPA5OTlJ7/uJJ57An//8Z+k9NSQ0NBSlpaU4deoUAG3GKjg4GMOHD8fJkydRXl6OsrIypKamSkHWypUrER0djeeeew49e/bE6NGjsXr1asTFxQHQVhpXKpUYNWoUvLy8MGTIECmgcnZ2hrm5Oezs7KRsZFtjJouIiIiITEImN8OL7wW3yXlbYvny5UhJSUFqairs7OwM1p07dw6BgYEGgVdQUBDUajWuXr0KLy8vANogS59KpUJeXh4AID09HWq1ut40Q2VlZbh06VKDbTI3N8eOHTvw5ptv4ujRozh58iTefvttvPvuu0hNTYVKpcK5c+cwfvx4g/2CgoKwadMm1NTUwNy8ZVk9nf79+xscQ6VS4ddff210+969e8PDwwNJSUno378//vOf/yA4OBhdu3aFl5cXUlJSIIoiKioqpCArPT0dycnJeOutt6Tj1NTUoLy8HLdu3cKkSZOwadMm9OzZE2PGjMHYsWMxbtw4yGTtM5xpn60iIiIiog5PEIQWd9trbbt27cL69euxb98++Pj4tPg4FhYWBn8XBEHKdKnVaqhUKoNxSTqOjo5NHrdbt26YPn06pk+fjtWrV8PX1xcffPABVq5c2ax2CYJQb6xaU+Oq9DX1nhoTEhKCxMREDBw4ED4+PujatSsAIDg4GImJiRBFEb1794anpycA7WezcuVKPPnkk/WOZWlpCU9PT2RkZODw4cM4dOgQIiMjsW7dOhw7dqxe+9oDBllEREREdF9LS0vDrFmzsGbNGoSFhTW4Td++fbFnzx6Ioihls5KTk2FnZwcPD49mnScgIAC5ubmQyWTw9vZucXudnJygUqlQWloqtS05Odlgm+TkZPj6+koZKFdXV+Tk5EjrL168iFu3bkl/143BMlbFwtDQUERFRaFfv34GRTSGDx+O7du3QxRFg/L4AQEByMjIQO/evRs9ppWVFcaNG4dx48Zh3rx58PPzw6+//oqAgIB2V22RQRYRERER3bfy8/MRHh6OkJAQPPvss8jNzTVYb25uDldXV0RGRmLTpk1YsGAB5s+fj4yMDMTGxmLhwoUwM2te98RRo0YhMDAQ4eHhWLt2LXx9fXH9+nXs27cPEyZMwKBBg+rtExcXh7S0NEyYMAG9evVCeXk5PvvsM/z3v//Fli1bAACLFi3C4MGDsXr1akyZMgUpKSnYunUrtm3bJh1nxIgR2Lp1KwIDA1FTU4Nly5YZZIC6du0KKysrHDhwAB4eHrC0tISDg0NLPlIAdeOyPvnkE2zfvl1aHhwcjNmzZwOAQXn8mJgYPPHEE/Dy8sJTTz0FMzMzpKen48yZM3jzzTcRHx+Pmpoa/OlPf4K1tTX+8Y9/wMrKCt27dwegnSfrhx9+wNNPPw2FQoEuXbq0uO3GwMIXRERERHTf2rdvH7KyspCQkACVSlXvNXjwYADa7noJCQlITU3Fgw8+iLlz52LWrFl4/fXXm30uQRCQkJCA4cOHY+bMmfD19cXTTz+NrKwsuLm5NbjPkCFDoFarMXfuXPTv3x/BwcH497//jb179yI4WDveLSAgAF9++SV27dqFAQMGICYmBqtWrTKoLLhhwwZ4enpi2LBhmDZtGhYvXgxra2tpvUwmw+bNmxEXFwd3d/d6Y7zuVo8ePdC9e3fcvHlTaicAeHl5wd3dHZWVlQYZrrCwMHz33Xc4ePAgBg8ejEceeQQbN26UgihHR0ds374dQUFBGDhwIA4fPox//etf0vi2VatWITMzE7169ZKKeLQlQbybiQTuQyUlJXBwcEBxcTHs7e3bujlERERE7VJ5eTkuX76MHj16wNLSsq2bQ9RiTV3LzY0NmMkiIiIiIiIyIgZZRERERERERsQgi4iIiIiIyIgYZBERERERERkRgywiIiIiMhrWVKOOzhjXMIMsIiIiIrpnujmX9Ce4JeqIdNew/jxid4uTERMRERHRPTM3N4ejoyPy8vIAANbW1hAEoY1bRdR8oiji1q1byMvLg6OjI8zNzVt8LAZZRERERGQUSqUSAKRAi6gjcnR0lK7llmKQRURERERGIQgCVCoVunbtiqqqqrZuDtFds7CwuKcMlg6DLCIiIiIyKnNzc6P8UCXqqFj4goiIiIiIyIgYZBERERERERkRgywiIiIiIiIj4pisO9BNRlZSUtLGLSEiIiIiorakiwnuNGExg6w7uHnzJgDA09OzjVtCRERERETtwc2bN+Hg4NDoekG8Uxh2n9NoNLh+/Trs7Ow4oV4HVVJSAk9PT1y5cgX29vZt3Ry6D/Cao9bGa45aE683am3t6ZoTRRE3b96Eu7s7zMwaH3nFTNYdmJmZwcPDo62bQUZgb2/f5v9j0v2F1xy1Nl5z1Jp4vVFray/XXFMZLB0WviAiIiIiIjIiBllERERERERGxCCLOj2FQoHY2FgoFIq2bgrdJ3jNUWvjNUetidcbtbaOeM2x8AUREREREZERMZNFRERERERkRAyyiIiIiIiIjIhBFhERERERkRExyCIiIiIiIjIiBlnUIbzzzjsYPHgw7Ozs0LVrV4SHhyMjI8Ngm/LycsybNw8uLi6wtbXFxIkT8fvvv0vrb9y4gTFjxsDd3R0KhQKenp6YP38+SkpKDI6TlJSEgIAAKBQK9O7dG/Hx8a3xFqkdMcb1pu/GjRvw8PCAIAgoKioyWMfrjQDjXXOCINR77dq1y2AbXnMEGPc+Fx8fj4EDB8LS0hJdu3bFvHnzDNb/8ssvGDZsGCwtLeHp6Ym1a9ea9L1R+2OM6y0+Pr7Be5wgCMjLy5O2azf3OJGoAwgLCxN37NghnjlzRkxLSxPHjh0renl5iWq1Wtpm7ty5oqenp3jkyBHxp59+Eh955BFx6NCh0vqCggJx27Zt4qlTp8TMzEzx8OHDYp8+fcSpU6dK2/zvf/8Tra2txYULF4pnz54Vt2zZIpqbm4sHDhxo1fdLbcsY15u+8ePHi48//rgIQCwsLJSW83ojHWNdcwDEHTt2iDk5OdKrrKxMWs9rjnSMdc1t2LBBdHd3F3fu3Cn+9ttvYnp6uvjNN99I64uLi0U3NzfxmWeeEc+cOSN+/vnnopWVlRgXF9dq75XanjGut1u3bhnc23JycsSwsDAxODhY2qY93eMYZFGHlJeXJwIQjx07JoqiKBYVFYkWFhbi7t27pW3OnTsnAhBTUlIaPc57770nenh4SH9funSp2L9/f4NtpkyZIoaFhRn5HVBHci/X27Zt28Tg4GDxyJEj9YIsXm/UmJZecwDEf/7zn40el9ccNaYl11xBQYFoZWUlHj58uNHjbtu2TXRychIrKiqkZcuWLRP79OljondCHYExfsfl5eWJFhYW4meffSYta0/3OHYXpA6puLgYAODs7AwAOH36NKqqqjBq1ChpGz8/P3h5eSElJaXBY1y/fh1ff/01goODpWUpKSkGxwCAsLCwRo9B94eWXm9nz57FqlWr8Nlnn8HMrP7tltcbNeZe7nHz5s1Dly5dMGTIEHzyyScQ9abD5DVHjWnJNXfo0CFoNBpcu3YNffv2hYeHByZPnowrV65I+6SkpGD48OGQy+XSsrCwMGRkZKCwsLA13hq1Q8b4HffZZ5/B2toaTz31lLSsPd3jGGRRh6PRaPDyyy8jKCgIAwYMAADk5uZCLpfD0dHRYFs3Nzfk5uYaLJs6dSqsra3RrVs32Nvb46OPPpLW5ebmws3Nrd4xSkpKUFZWZpo3RO1aS6+3iooKTJ06FevWrYOXl1eDx+b1Rg25l3vcqlWr8OWXX+LQoUOYOHEiIiMjsWXLFmk9rzlqSEuvuf/973/QaDR4++23sWnTJnz11VcoKCjA6NGjUVlZKR2noWtOt47uP/f6O07n448/xrRp02BlZSUta0/3OFmrno3ICObNm4czZ87g+PHjLdp/48aNiI2NxYULF/Dqq69i4cKF2LZtm5FbSZ1FS6+3V199FX379sWzzz5ropZRZ3Uv97g33nhD+rO/vz9KS0uxbt06REVFGbOJ1Mm09JrTaDSoqqrC5s2b8dhjjwEAPv/8cyiVSiQmJiIsLMwUzaUO7l5/xwHajNW5c+fw97//3YgtMy5msqhDmT9/Pr777jskJibCw8NDWq5UKlFZWVmvctvvv/8OpVJpsEypVMLPzw9/+ctfEBcXh/fffx85OTnSutsrJ/3++++wt7c3eFJC94d7ud6OHj2K3bt3QyaTQSaTYeTIkQCALl26IDY2VjoOrzfSZ4x7nL4//elPuHr1KioqKqTj8JojffdyzalUKgBAv379pPWurq7o0qULsrOzpeM0dM3p1tH9xVj3uI8++ggPPfQQHn74YYPl7ekexyCLOgRRFDF//nz885//xNGjR9GjRw+D9Q8//DAsLCxw5MgRaVlGRgays7MRGBjY6HE1Gg0ASD9AAgMDDY4BaPucN3UM6nyMcb3t2bMH6enpSEtLQ1pamtQt9ccff5TKG/N6Ix1T3ePS0tLg5OQEhUIBgNcc1THGNRcUFCQt1ykoKEB+fj66d+8OQHvN/fDDD6iqqpK2OXToEPr06QMnJyeTvT9qX4x5j1Or1fjyyy8xa9aseudpV/e4Vi+1QdQCL730kujg4CAmJSUZlO68deuWtM3cuXNFLy8v8ejRo+JPP/0kBgYGioGBgdL6ffv2iZ988on466+/ipcvXxa/++47sW/fvmJQUJC0ja7055IlS8Rz586Jf/vb31je+D5kjOvtdomJiY2WcOf1Rsa45r799ltx+/bt4q+//ipevHhR3LZtm2htbS3GxMRI2/CaIx1j3efGjx8v9u/fX0xOThZ//fVX8YknnhD79esnVlZWiqKorRrn5uYmTp8+XTxz5oy4a9cu0dramiXc7zPG/F796KOPREtLS4PvU532dI9jkEUdAoAGXzt27JC2KSsrEyMjI0UnJyfR2tpanDBhgpiTkyOtP3r0qBgYGCg6ODiIlpaWoo+Pj7hs2bJ6/5MmJiaKDz30kCiXy8WePXsanIPuD8a43m7XUJClW87rjYxxze3fv1986KGHRFtbW9HGxkZ88MEHxQ8++ECsqakxOBevORJF493niouLxeeff150dHQUnZ2dxQkTJojZ2dkG26Snp4uPPvqoqFAoxG7duolr1qxpjbdI7Ygxv1cDAwPFadOmNXqu9nKPE0RRr7YrERERERER3ROOySIiIiIiIjIiBllERERERERGxCCLiIiIiIjIiBhkERERERERGRGDLCIiIiIiIiNikEVERERERGREDLKIiIiIiIiMiEEWERERERGRETHIIiIiIiIiMiIGWUREdF8RRRGjRo1CWFhYvXXbtm2Do6Mjrl692gYtIyKizoJBFhER3VcEQcCOHTtw8uRJxMXFScsvX76MpUuXYsuWLfDw8DDqOauqqox6PCIiat8YZBER0X3H09MT7733HhYvXozLly9DFEXMmjULjz32GPz9/fH444/D1tYWbm5umD59OvLz86V9Dxw4gEcffRSOjo5wcXHBE088gUuXLknrMzMzIQgCvvjiCwQHB8PS0hI7d+5si7dJRERtRBBFUWzrRhAREbWF8PBwFBcX48knn8Tq1avx3//+F/3798fs2bMxY8YMlJWVYdmyZaiursbRo0cBAHv27IEgCBg4cCDUajViYmKQmZmJtLQ0mJmZITMzEz169IC3tzc2bNgAf39/WFpaQqVStfG7JSKi1sIgi4iI7lt5eXno378/CgoKsGfPHpw5cwY//vgjvv/+e2mbq1evwtPTExkZGfD19a13jPz8fLi6uuLXX3/FgAEDpCBr06ZN+H//7/+15tshIqJ2gt0FiYjovtW1a1fMmTMHffv2RXh4ONLT05GYmAhbW1vp5efnBwBSl8CLFy9i6tSp6NmzJ+zt7eHt7Q0AyM7ONjj2oEGDWvW9EBFR+yFr6wYQERG1JZlMBplM+3WoVqsxbtw4vPvuu/W203X3GzduHLp3747t27fD3d0dGo0GAwYMQGVlpcH2NjY2pm88ERG1SwyyiIiIagUEBGDPnj3w9vaWAi99N27cQEZGBrZv345hw4YBAI4fP97azSQionaO3QWJiIhqzZs3DwUFBZg6dSpOnTqFS5cu4fvvv8fMmTNRU1MDJycnuLi44MMPP8Rvv/2Go0ePYuHChW3dbCIiamcYZBEREdVyd3dHcnIyampq8Nhjj+GBBx7Ayy+/DEdHR5iZmcHMzAy7du3C6dOnMWDAALzyyitYt25dWzebiIjaGVYXJCIiIiIiMiJmsoiIiIiIiIyIQRYREREREZERMcgiIiIiIiIyIgZZRERERERERsQgi4iIiIiIyIgYZBERERERERkRgywiIiIiIiIjYpBFRERERERkRAyyiIiIiIiIjIhBFhERERERkRExyCIiIiIiIjKi/w/XqhnvspUxYgAAAABJRU5ErkJggg==" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 54 + "execution_count": 12 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "District", + "id": "cdb91b16e915cf71" }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-03T11:32:12.479307Z", - "start_time": "2025-01-03T11:32:12.476573Z" + "end_time": "2025-01-09T11:44:55.983008Z", + "start_time": "2025-01-09T11:44:55.705797Z" } }, "cell_type": "code", + "source": [ + "predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'District']).sum().reset_index()\n", + "\n", + "# Plot each zone\n", + "plt.figure(figsize=(10, 6))\n", + "for district in predictions_from_cmip_sum['District'].unique():\n", + " district_data = predictions_from_cmip_sum[predictions_from_cmip_sum['District'] == district]\n", + " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", + " plt.plot(district_data['Year'], district_data['Percentage_Difference'], label=f'{district}')\n", + "\n", + "plt.xlabel(\"Year\")\n", + "plt.ylabel(\"Change ANC cases due to weather\")\n", + "plt.axhline(y=0, color='black', linestyle='--')\n", + "plt.ylim(-1.5, 0)\n", + "plt.legend(title='Districts')\n", + "plt.show()" + ], + "id": "cce81039627dfb67", + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 13 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "# Loop over all ", + "id": "f49ed5d53595c9f0" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-09T11:44:59.376473Z", + "start_time": "2025-01-09T11:44:58.166348Z" + } + }, + "cell_type": "code", + "source": [ + "model_types = ['lowest', 'median', 'highest']\n", + "ssp_scenarios = [\"ssp245\", \"ssp585\"]\n", + "\n", + "results_list = []\n", + "\n", + "for scenario in ssp_scenarios:\n", + " for model_type in model_types:\n", + " predictions_from_cmip = pd.read_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv')\n", + " predictions_from_cmip['Percentage_Difference'] = (\n", + " predictions_from_cmip['Difference_in_Expectation'] / \n", + " predictions_from_cmip['Predicted_No_Weather_Model']\n", + " ) * 100\n", + " \n", + " births_model_subset = births_model.iloc[15:].copy()\n", + " matching_rows = min(len(births_model_subset), len(predictions_from_cmip))\n", + " multiplied_values = (\n", + " births_model_subset.head(matching_rows).iloc[:, 1].values *\n", + " predictions_from_cmip['Percentage_Difference'].head(matching_rows).values\n", + " )\n", + " \n", + " births_model_subset['Multiplied_Values'] = multiplied_values\n", + " \n", + " for zone in predictions_from_cmip['Zone'].unique():\n", + " zone_data = predictions_from_cmip[predictions_from_cmip['Zone'] == zone]\n", + " zone_data['Percentage_Difference'] = (\n", + " (zone_data['Difference_in_Expectation'] / zone_data['Predicted_No_Weather_Model']) * 100\n", + " )\n", + " \n", + " results_list.append({\n", + " \"Scenario\": scenario,\n", + " \"Model_Type\": model_type,\n", + " \"Zone\": zone,\n", + " \"Percentage_Difference\": zone_data['Percentage_Difference'].mean(),\n", + " \"Multiplied_Values\": multiplied_values.mean()\n", + " })\n", + "\n", + " " + ], + "id": "a9e5133a6a49985a", + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/3827770855.py:25: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " zone_data['Percentage_Difference'] = (\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/3827770855.py:25: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " zone_data['Percentage_Difference'] = (\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/3827770855.py:25: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " zone_data['Percentage_Difference'] = (\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/3827770855.py:25: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " zone_data['Percentage_Difference'] = (\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/3827770855.py:25: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " zone_data['Percentage_Difference'] = (\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/3827770855.py:25: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " zone_data['Percentage_Difference'] = (\n" + ] + } + ], + "execution_count": 14 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-09T11:45:00.968214Z", + "start_time": "2025-01-09T11:45:00.964031Z" + } + }, + "cell_type": "code", + "source": "results_list", + "id": "bc2715c9d4c9cfd3", + "outputs": [ + { + "data": { + "text/plain": [ + "[{'Scenario': 'ssp245',\n", + " 'Model_Type': 'lowest',\n", + " 'Zone': 'Central West',\n", + " 'Percentage_Difference': -0.1931910818987726,\n", + " 'Multiplied_Values': nan},\n", + " {'Scenario': 'ssp245',\n", + " 'Model_Type': 'lowest',\n", + " 'Zone': 'South East',\n", + " 'Percentage_Difference': -0.3314323561856577,\n", + " 'Multiplied_Values': nan},\n", + " {'Scenario': 'ssp245',\n", + " 'Model_Type': 'lowest',\n", + " 'Zone': nan,\n", + " 'Percentage_Difference': nan,\n", + " 'Multiplied_Values': nan},\n", + " {'Scenario': 'ssp245',\n", + " 'Model_Type': 'lowest',\n", + " 'Zone': 'Northern',\n", + " 'Percentage_Difference': -0.24607017494457492,\n", + " 'Multiplied_Values': nan},\n", + " {'Scenario': 'ssp245',\n", + " 'Model_Type': 'lowest',\n", + " 'Zone': 'South West',\n", + " 'Percentage_Difference': -0.47686076003686034,\n", + " 'Multiplied_Values': nan},\n", + " {'Scenario': 'ssp245',\n", + " 'Model_Type': 'lowest',\n", + " 'Zone': 'Central East',\n", + " 'Percentage_Difference': -0.11908906889403516,\n", + " 'Multiplied_Values': nan},\n", + " {'Scenario': 'ssp245',\n", + " 'Model_Type': 'median',\n", + " 'Zone': 'Central West',\n", + " 'Percentage_Difference': -0.36628333460755774,\n", + " 'Multiplied_Values': nan},\n", + " {'Scenario': 'ssp245',\n", + " 'Model_Type': 'median',\n", + " 'Zone': 'South East',\n", + " 'Percentage_Difference': -0.5370975141167456,\n", + " 'Multiplied_Values': nan},\n", + " {'Scenario': 'ssp245',\n", + " 'Model_Type': 'median',\n", + " 'Zone': nan,\n", + " 'Percentage_Difference': nan,\n", + " 'Multiplied_Values': nan},\n", + " {'Scenario': 'ssp245',\n", + " 'Model_Type': 'median',\n", + " 'Zone': 'Northern',\n", + " 'Percentage_Difference': -0.1767448997486594,\n", + " 'Multiplied_Values': nan},\n", + " {'Scenario': 'ssp245',\n", + " 'Model_Type': 'median',\n", + " 'Zone': 'South West',\n", + " 'Percentage_Difference': -0.535989250210467,\n", + " 'Multiplied_Values': nan},\n", + " {'Scenario': 'ssp245',\n", + " 'Model_Type': 'median',\n", + " 'Zone': 'Central East',\n", + " 'Percentage_Difference': -0.23255844930782898,\n", + " 'Multiplied_Values': nan},\n", + " {'Scenario': 'ssp245',\n", + " 'Model_Type': 'highest',\n", + " 'Zone': 'Central West',\n", + " 'Percentage_Difference': 0.12906250288407198,\n", + " 'Multiplied_Values': nan},\n", + " {'Scenario': 'ssp245',\n", + " 'Model_Type': 'highest',\n", + " 'Zone': 'South East',\n", + " 'Percentage_Difference': 0.036544565987316396,\n", + " 'Multiplied_Values': nan},\n", + " {'Scenario': 'ssp245',\n", + " 'Model_Type': 'highest',\n", + " 'Zone': nan,\n", + " 'Percentage_Difference': nan,\n", + " 'Multiplied_Values': nan},\n", + " {'Scenario': 'ssp245',\n", + " 'Model_Type': 'highest',\n", + " 'Zone': 'Northern',\n", + " 'Percentage_Difference': -0.11865510374052105,\n", + " 'Multiplied_Values': nan},\n", + " {'Scenario': 'ssp245',\n", + " 'Model_Type': 'highest',\n", + " 'Zone': 'South West',\n", + " 'Percentage_Difference': -0.02237424340918628,\n", + " 'Multiplied_Values': nan},\n", + " {'Scenario': 'ssp245',\n", + " 'Model_Type': 'highest',\n", + " 'Zone': 'Central East',\n", + " 'Percentage_Difference': 0.12450572159528503,\n", + " 'Multiplied_Values': nan},\n", + " {'Scenario': 'ssp585',\n", + " 'Model_Type': 'lowest',\n", + " 'Zone': 'Central West',\n", + " 'Percentage_Difference': -0.22897010507117518,\n", + " 'Multiplied_Values': nan},\n", + " {'Scenario': 'ssp585',\n", + " 'Model_Type': 'lowest',\n", + " 'Zone': 'South East',\n", + " 'Percentage_Difference': -0.3152239861164687,\n", + " 'Multiplied_Values': nan},\n", + " {'Scenario': 'ssp585',\n", + " 'Model_Type': 'lowest',\n", + " 'Zone': nan,\n", + " 'Percentage_Difference': nan,\n", + " 'Multiplied_Values': nan},\n", + " {'Scenario': 'ssp585',\n", + " 'Model_Type': 'lowest',\n", + " 'Zone': 'Northern',\n", + " 'Percentage_Difference': -0.15877546019135516,\n", + " 'Multiplied_Values': nan},\n", + " {'Scenario': 'ssp585',\n", + " 'Model_Type': 'lowest',\n", + " 'Zone': 'South West',\n", + " 'Percentage_Difference': -0.4406747802624256,\n", + " 'Multiplied_Values': nan},\n", + " {'Scenario': 'ssp585',\n", + " 'Model_Type': 'lowest',\n", + " 'Zone': 'Central East',\n", + " 'Percentage_Difference': -0.14957537455833142,\n", + " 'Multiplied_Values': nan},\n", + " {'Scenario': 'ssp585',\n", + " 'Model_Type': 'median',\n", + " 'Zone': 'Central West',\n", + " 'Percentage_Difference': -0.314623863084536,\n", + " 'Multiplied_Values': nan},\n", + " {'Scenario': 'ssp585',\n", + " 'Model_Type': 'median',\n", + " 'Zone': 'South East',\n", + " 'Percentage_Difference': -0.33844763980757053,\n", + " 'Multiplied_Values': nan},\n", + " {'Scenario': 'ssp585',\n", + " 'Model_Type': 'median',\n", + " 'Zone': nan,\n", + " 'Percentage_Difference': nan,\n", + " 'Multiplied_Values': nan},\n", + " {'Scenario': 'ssp585',\n", + " 'Model_Type': 'median',\n", + " 'Zone': 'Northern',\n", + " 'Percentage_Difference': -0.08126478735382436,\n", + " 'Multiplied_Values': nan},\n", + " {'Scenario': 'ssp585',\n", + " 'Model_Type': 'median',\n", + " 'Zone': 'South West',\n", + " 'Percentage_Difference': -0.3079082261332242,\n", + " 'Multiplied_Values': nan},\n", + " {'Scenario': 'ssp585',\n", + " 'Model_Type': 'median',\n", + " 'Zone': 'Central East',\n", + " 'Percentage_Difference': -0.19505941246927425,\n", + " 'Multiplied_Values': nan},\n", + " {'Scenario': 'ssp585',\n", + " 'Model_Type': 'highest',\n", + " 'Zone': 'Central West',\n", + " 'Percentage_Difference': -0.053375539588824426,\n", + " 'Multiplied_Values': nan},\n", + " {'Scenario': 'ssp585',\n", + " 'Model_Type': 'highest',\n", + " 'Zone': 'South East',\n", + " 'Percentage_Difference': -0.35838668109186017,\n", + " 'Multiplied_Values': nan},\n", + " {'Scenario': 'ssp585',\n", + " 'Model_Type': 'highest',\n", + " 'Zone': nan,\n", + " 'Percentage_Difference': nan,\n", + " 'Multiplied_Values': nan},\n", + " {'Scenario': 'ssp585',\n", + " 'Model_Type': 'highest',\n", + " 'Zone': 'Northern',\n", + " 'Percentage_Difference': -0.15422680749880371,\n", + " 'Multiplied_Values': nan},\n", + " {'Scenario': 'ssp585',\n", + " 'Model_Type': 'highest',\n", + " 'Zone': 'South West',\n", + " 'Percentage_Difference': -0.33682704005296926,\n", + " 'Multiplied_Values': nan},\n", + " {'Scenario': 'ssp585',\n", + " 'Model_Type': 'highest',\n", + " 'Zone': 'Central East',\n", + " 'Percentage_Difference': -0.08754498899133552,\n", + " 'Multiplied_Values': nan}]" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 15 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "# Try add a map ", + "id": "7eefb2b319ba4739" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Change names of some \"districts\" for consistency ", + "id": "16e6ddbdd7d8fc0b" + }, + { + "metadata": {}, + "cell_type": "markdown", "source": "", - "id": "a6f75ad676cb7db5", + "id": "143a79f7bd3378b" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-09T11:45:06.833084Z", + "start_time": "2025-01-09T11:45:06.830522Z" + } + }, + "cell_type": "code", + "source": [ + "predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace(\"Mzimba North\", \"Mzimba\")\n", + "predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace(\"Mzimba South\", \"Mzimba\")\n" + ], + "id": "4fc203ff0269768", "outputs": [], - "execution_count": 47 + "execution_count": 16 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-09T11:49:47.255665Z", + "start_time": "2025-01-09T11:49:46.640771Z" + } + }, + "cell_type": "code", + "source": [ + "import geopandas as gpd\n", + "from netCDF4 import Dataset\n", + "from shapely.geometry import Polygon\n", + "from matplotlib import colors as mcolors\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import numpy as np\n", + "\n", + "file_path_historical_data = \"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/2011/60ab007aa16d679a32f9c3e186d2f744.nc\"\n", + "dataset = Dataset(file_path_historical_data, mode='r')\n", + "pr_data = dataset.variables['tp'][:]\n", + "lat_data = dataset.variables['latitude'][:]\n", + "long_data = dataset.variables['longitude'][:]\n", + "meshgrid_from_netCDF = np.meshgrid(long_data, lat_data)\n", + "\n", + "malawi = gpd.read_file(\"/Users/rem76/PycharmProjects/TLOmodel/resources/mapping/ResourceFile_mwi_admbnda_adm0_nso_20181016.shp\")\n", + "malawi_admin2 = gpd.read_file(\"/Users/rem76/PycharmProjects/TLOmodel/resources/mapping/ResourceFile_mwi_admbnda_adm2_nso_20181016.shp\")\n", + "\n", + "# change names of some districts for consistency \n", + "predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace(\"Mzimba North\", \"Mzimba\")\n", + "predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace(\"Mzimba South\", \"Mzimba\")\n", + "malawi_admin2['ADM2_EN'] = malawi_admin2['ADM2_EN'].replace('Blantyre City', 'Blantyre')\n", + "malawi_admin2['ADM2_EN'] = malawi_admin2['ADM2_EN'].replace('Mzuzu City', 'Mzuzu')\n", + "malawi_admin2['ADM2_EN'] = malawi_admin2['ADM2_EN'].replace('Lilongwe City', 'Lilongwe')\n", + "\n", + "difference_lat = lat_data[1] - lat_data[0]\n", + "difference_long = long_data[1] - long_data[0]\n", + "\n", + "polygons = []\n", + "for x in long_data:\n", + " for y in lat_data:\n", + " bottom_left = (x, y)\n", + " bottom_right = (x + difference_long, y)\n", + " top_right = (x + difference_long, y + difference_lat)\n", + " top_left = (x, y + difference_lat)\n", + " polygon = Polygon([bottom_left, bottom_right, top_right, top_left])\n", + " polygons.append(polygon)\n", + "grid = gpd.GeoDataFrame({'geometry': polygons}, crs=malawi.crs)\n", + "\n", + "grid_clipped_ADM2 = gpd.overlay(grid, malawi_admin2, how='intersection')\n", + "\n", + "# Read predictions and calculate Percentage_Difference\n", + "predictions_from_cmip_sum['Percentage_Difference'] = (\n", + " predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model']\n", + ") * 100\n", + "\n", + "percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean()\n", + "grid_clipped_ADM2['Percentage_Difference'] = grid_clipped_ADM2['ADM2_EN'].map(percentage_diff_by_district)\n", + "\n", + "\n", + "fig, ax = plt.subplots(figsize=(12, 12))\n", + "\n", + "malawi_admin2.plot(ax=ax, edgecolor='black', color='white')\n", + "grid_clipped_ADM2.loc[grid_clipped_ADM2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0\n", + "\n", + "\n", + "grid_clipped_ADM2.dropna(subset=['Percentage_Difference']).plot(\n", + " ax=ax,\n", + " column='Percentage_Difference',\n", + " cmap='Blues_r',\n", + " edgecolor='black',\n", + " alpha=0.6,\n", + " legend=False\n", + ")\n", + "\n", + "sm = plt.cm.ScalarMappable(cmap='Blues_r', norm=mcolors.Normalize(\n", + " vmin=grid_clipped_ADM2['Percentage_Difference'].min(), vmax=grid_clipped_ADM2['Percentage_Difference'].max()))\n", + "sm.set_array([])\n", + "cbar = plt.colorbar(sm, ax=ax, orientation=\"vertical\", shrink=0.7)\n", + "plt.clim(grid_clipped_ADM2['Percentage_Difference'].min(), 0)\n", + "cbar.set_label(\"Percentage Difference (%)\", fontsize=12)\n", + "\n", + "plt.xlabel(\"Longitude\", fontsize=14)\n", + "plt.ylabel(\"Latitude\", fontsize=14)\n", + "plt.title(\"Malawi Districts by Percentage Difference\", fontsize=16)\n", + "plt.tight_layout()\n", + "\n", + "plt.show()\n" + ], + "id": "1dfcf27d72655955", + "outputs": [ + { + "ename": "RuntimeError", + "evalue": "You must first define an image, e.g., with imshow", + "output_type": "error", + "traceback": [ + "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m", + "\u001B[0;31mRuntimeError\u001B[0m Traceback (most recent call last)", + "Cell \u001B[0;32mIn[24], line 70\u001B[0m\n\u001B[1;32m 68\u001B[0m sm\u001B[38;5;241m.\u001B[39mset_array([])\n\u001B[1;32m 69\u001B[0m cbar \u001B[38;5;241m=\u001B[39m plt\u001B[38;5;241m.\u001B[39mcolorbar(sm, ax\u001B[38;5;241m=\u001B[39max, orientation\u001B[38;5;241m=\u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mvertical\u001B[39m\u001B[38;5;124m\"\u001B[39m, shrink\u001B[38;5;241m=\u001B[39m\u001B[38;5;241m0.7\u001B[39m)\n\u001B[0;32m---> 70\u001B[0m \u001B[43mplt\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mclim\u001B[49m\u001B[43m(\u001B[49m\u001B[43mgrid_clipped_ADM2\u001B[49m\u001B[43m[\u001B[49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[38;5;124;43mPercentage_Difference\u001B[39;49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[43m]\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mmin\u001B[49m\u001B[43m(\u001B[49m\u001B[43m)\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m0\u001B[39;49m\u001B[43m)\u001B[49m\n\u001B[1;32m 71\u001B[0m cbar\u001B[38;5;241m.\u001B[39mset_label(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mPercentage Difference (\u001B[39m\u001B[38;5;124m%\u001B[39m\u001B[38;5;124m)\u001B[39m\u001B[38;5;124m\"\u001B[39m, fontsize\u001B[38;5;241m=\u001B[39m\u001B[38;5;241m12\u001B[39m)\n\u001B[1;32m 73\u001B[0m plt\u001B[38;5;241m.\u001B[39mxlabel(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mLongitude\u001B[39m\u001B[38;5;124m\"\u001B[39m, fontsize\u001B[38;5;241m=\u001B[39m\u001B[38;5;241m14\u001B[39m)\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/matplotlib/pyplot.py:2157\u001B[0m, in \u001B[0;36mclim\u001B[0;34m(vmin, vmax)\u001B[0m\n\u001B[1;32m 2155\u001B[0m im \u001B[38;5;241m=\u001B[39m gci()\n\u001B[1;32m 2156\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m im \u001B[38;5;129;01mis\u001B[39;00m \u001B[38;5;28;01mNone\u001B[39;00m:\n\u001B[0;32m-> 2157\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m \u001B[38;5;167;01mRuntimeError\u001B[39;00m(\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mYou must first define an image, e.g., with imshow\u001B[39m\u001B[38;5;124m'\u001B[39m)\n\u001B[1;32m 2159\u001B[0m im\u001B[38;5;241m.\u001B[39mset_clim(vmin, vmax)\n", + "\u001B[0;31mRuntimeError\u001B[0m: You must first define an image, e.g., with imshow" + ] + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 24 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-09T11:39:23.007883Z", + "start_time": "2025-01-09T11:39:23.004578Z" + } + }, + "cell_type": "code", + "source": [ + "# Get unique districts from both sources\n", + "adm2_districts = set(grid_clipped_ADM2['ADM2_EN'].unique())\n", + "prediction_districts = set(predictions_from_cmip_sum['District'].unique())\n", + "\n", + "# Districts in ADM2 but not in predictions\n", + "missing_in_predictions = adm2_districts - prediction_districts\n", + "print(\"Districts in ADM2 but not in predictions:\", missing_in_predictions)\n", + "\n", + "# Districts in predictions but not in ADM2\n", + "missing_in_adm2 = prediction_districts - adm2_districts\n", + "print(\"Districts in predictions but not in ADM2:\", missing_in_adm2)" + ], + "id": "165106827759887c", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Districts in ADM2 but not in predictions: {'Likoma', 'Lilongwe City', 'Zomba City', 'Mzuzu City'}\n", + "Districts in predictions but not in ADM2: set()\n" + ] + } + ], + "execution_count": 20 }, { "metadata": {}, @@ -4886,7 +5864,7 @@ "outputs": [], "execution_count": null, "source": "", - "id": "d99dea658199bd53" + "id": "a835bddc9c0be86f" } ], "metadata": { From 0016678d25acb120f7cb52df164a00fa0776c85a Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 9 Jan 2025 13:51:47 +0000 Subject: [PATCH 171/291] Added map showing projected decrease (%) by district of ANC cases (for ssp585 median) --- src/scripts/climate_change/cohort_model.ipynb | 4570 +++++------------ 1 file changed, 1289 insertions(+), 3281 deletions(-) diff --git a/src/scripts/climate_change/cohort_model.ipynb b/src/scripts/climate_change/cohort_model.ipynb index 5508640b5a..8d958524b3 100644 --- a/src/scripts/climate_change/cohort_model.ipynb +++ b/src/scripts/climate_change/cohort_model.ipynb @@ -6,8 +6,8 @@ "metadata": { "collapsed": true, "ExecuteTime": { - "end_time": "2025-01-09T11:44:41.243549Z", - "start_time": "2025-01-09T11:44:40.438524Z" + "end_time": "2025-01-09T12:02:46.081729Z", + "start_time": "2025-01-09T12:02:45.023438Z" } }, "source": [ @@ -48,8 +48,6 @@ " ),\n", " do_scaling=True\n", " )\n", - "print(births_results)\n", - "\n", "births_results = births_results.groupby(by=births_results.index).sum()\n", "births_results = births_results.replace({0: np.nan})\n", "\n", @@ -187,7 +185,7 @@ ] } ], - "execution_count": 1 + "execution_count": 2 }, { "metadata": {}, @@ -198,37 +196,37 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-09T11:44:42.287386Z", - "start_time": "2025-01-09T11:44:42.285045Z" + "end_time": "2025-01-09T12:05:21.197626Z", + "start_time": "2025-01-09T12:05:21.190699Z" } }, "cell_type": "code", "source": [ - "scenario = 'ssp245'\n", - "model_type = 'lowest'" + "scenario = 'ssp585'\n", + "model_type = 'median'" ], "id": "bbff583692196586", "outputs": [], - "execution_count": 2 + "execution_count": 18 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-09T11:44:43.001534Z", - "start_time": "2025-01-09T11:44:42.828177Z" + "end_time": "2025-01-09T12:05:21.858393Z", + "start_time": "2025-01-09T12:05:21.663569Z" } }, "cell_type": "code", "source": "predictions_from_cmip = pd.read_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv')", "id": "3be0a4515f3e890e", "outputs": [], - "execution_count": 3 + "execution_count": 19 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-09T11:44:43.466150Z", - "start_time": "2025-01-09T11:44:43.286795Z" + "end_time": "2025-01-09T12:05:22.252382Z", + "start_time": "2025-01-09T12:05:22.052107Z" } }, "cell_type": "code", @@ -482,196 +480,196 @@ "45 GovernmentGovernmentGovernmentGovernmentGovern... \n", "\n", " Facility_Type Precipitation \\\n", - "0 ClinicDistrict HospitalRural/Community Hospita... 370655.578345 \n", - "1 ClinicDistrict HospitalRural/Community Hospita... 305845.723518 \n", - "2 ClinicDistrict HospitalRural/Community Hospita... 380236.133055 \n", - "3 ClinicDistrict HospitalRural/Community Hospita... 396234.125976 \n", - "4 ClinicDistrict HospitalRural/Community Hospita... 317163.607434 \n", - "5 ClinicDistrict HospitalRural/Community Hospita... 385409.189618 \n", - "6 ClinicDistrict HospitalRural/Community Hospita... 406289.858606 \n", - "7 ClinicDistrict HospitalRural/Community Hospita... 333604.956760 \n", - "8 ClinicDistrict HospitalRural/Community Hospita... 322006.856259 \n", - "9 ClinicDistrict HospitalRural/Community Hospita... 391560.967791 \n", - "10 ClinicDistrict HospitalRural/Community Hospita... 367661.767185 \n", - "11 ClinicDistrict HospitalRural/Community Hospita... 378095.303002 \n", - "12 ClinicDistrict HospitalRural/Community Hospita... 374197.949271 \n", - "13 ClinicDistrict HospitalRural/Community Hospita... 374291.695816 \n", - "14 ClinicDistrict HospitalRural/Community Hospita... 398962.867137 \n", - "15 ClinicDistrict HospitalRural/Community Hospita... 329938.705708 \n", - "16 ClinicDistrict HospitalRural/Community Hospita... 349982.489824 \n", - "17 ClinicDistrict HospitalRural/Community Hospita... 265019.061881 \n", - "18 ClinicDistrict HospitalRural/Community Hospita... 317116.288589 \n", - "19 ClinicDistrict HospitalRural/Community Hospita... 358615.638348 \n", - "20 ClinicDistrict HospitalRural/Community Hospita... 441360.716573 \n", - "21 ClinicDistrict HospitalRural/Community Hospita... 485128.815221 \n", - "22 ClinicDistrict HospitalRural/Community Hospita... 339348.499913 \n", - "23 ClinicDistrict HospitalRural/Community Hospita... 353296.312971 \n", - "24 ClinicDistrict HospitalRural/Community Hospita... 333745.253478 \n", - "25 ClinicDistrict HospitalRural/Community Hospita... 513923.146927 \n", - "26 ClinicDistrict HospitalRural/Community Hospita... 271825.288644 \n", - "27 ClinicDistrict HospitalRural/Community Hospita... 365895.719222 \n", - "28 ClinicDistrict HospitalRural/Community Hospita... 325208.687060 \n", - "29 ClinicDistrict HospitalRural/Community Hospita... 382143.812346 \n", - "30 ClinicDistrict HospitalRural/Community Hospita... 287994.569053 \n", - "31 ClinicDistrict HospitalRural/Community Hospita... 332374.359974 \n", - "32 ClinicDistrict HospitalRural/Community Hospita... 392877.314013 \n", - "33 ClinicDistrict HospitalRural/Community Hospita... 302066.178485 \n", - "34 ClinicDistrict HospitalRural/Community Hospita... 327708.324530 \n", - "35 ClinicDistrict HospitalRural/Community Hospita... 309435.437644 \n", - "36 ClinicDistrict HospitalRural/Community Hospita... 320279.427886 \n", - "37 ClinicDistrict HospitalRural/Community Hospita... 330832.389669 \n", - "38 ClinicDistrict HospitalRural/Community Hospita... 435362.126119 \n", - "39 ClinicDistrict HospitalRural/Community Hospita... 304940.147499 \n", - "40 ClinicDistrict HospitalRural/Community Hospita... 353974.887443 \n", - "41 ClinicDistrict HospitalRural/Community Hospita... 295464.487169 \n", - "42 ClinicDistrict HospitalRural/Community Hospita... 297221.496710 \n", - "43 ClinicDistrict HospitalRural/Community Hospita... 409016.019784 \n", - "44 ClinicDistrict HospitalRural/Community Hospita... 420878.539429 \n", - "45 ClinicDistrict HospitalRural/Community Hospita... 405718.142702 \n", + "0 ClinicDistrict HospitalRural/Community Hospita... 377371.401757 \n", + "1 ClinicDistrict HospitalRural/Community Hospita... 424179.161524 \n", + "2 ClinicDistrict HospitalRural/Community Hospita... 416785.291442 \n", + "3 ClinicDistrict HospitalRural/Community Hospita... 431174.255009 \n", + "4 ClinicDistrict HospitalRural/Community Hospita... 405743.410420 \n", + "5 ClinicDistrict HospitalRural/Community Hospita... 410793.849551 \n", + "6 ClinicDistrict HospitalRural/Community Hospita... 430219.873937 \n", + "7 ClinicDistrict HospitalRural/Community Hospita... 332427.056762 \n", + "8 ClinicDistrict HospitalRural/Community Hospita... 392896.036283 \n", + "9 ClinicDistrict HospitalRural/Community Hospita... 409775.392632 \n", + "10 ClinicDistrict HospitalRural/Community Hospita... 410851.208278 \n", + "11 ClinicDistrict HospitalRural/Community Hospita... 456535.963741 \n", + "12 ClinicDistrict HospitalRural/Community Hospita... 452334.398335 \n", + "13 ClinicDistrict HospitalRural/Community Hospita... 329049.810569 \n", + "14 ClinicDistrict HospitalRural/Community Hospita... 414644.190834 \n", + "15 ClinicDistrict HospitalRural/Community Hospita... 392121.029719 \n", + "16 ClinicDistrict HospitalRural/Community Hospita... 380754.054252 \n", + "17 ClinicDistrict HospitalRural/Community Hospita... 296596.215293 \n", + "18 ClinicDistrict HospitalRural/Community Hospita... 423715.504984 \n", + "19 ClinicDistrict HospitalRural/Community Hospita... 368319.084368 \n", + "20 ClinicDistrict HospitalRural/Community Hospita... 418134.051457 \n", + "21 ClinicDistrict HospitalRural/Community Hospita... 380622.271982 \n", + "22 ClinicDistrict HospitalRural/Community Hospita... 388922.127329 \n", + "23 ClinicDistrict HospitalRural/Community Hospita... 373888.999201 \n", + "24 ClinicDistrict HospitalRural/Community Hospita... 403081.277311 \n", + "25 ClinicDistrict HospitalRural/Community Hospita... 377526.089751 \n", + "26 ClinicDistrict HospitalRural/Community Hospita... 312891.203066 \n", + "27 ClinicDistrict HospitalRural/Community Hospita... 383090.314471 \n", + "28 ClinicDistrict HospitalRural/Community Hospita... 370916.909122 \n", + "29 ClinicDistrict HospitalRural/Community Hospita... 358979.193679 \n", + "30 ClinicDistrict HospitalRural/Community Hospita... 411059.228901 \n", + "31 ClinicDistrict HospitalRural/Community Hospita... 457632.022035 \n", + "32 ClinicDistrict HospitalRural/Community Hospita... 366158.628623 \n", + "33 ClinicDistrict HospitalRural/Community Hospita... 414749.367352 \n", + "34 ClinicDistrict HospitalRural/Community Hospita... 394182.173776 \n", + "35 ClinicDistrict HospitalRural/Community Hospita... 412930.274807 \n", + "36 ClinicDistrict HospitalRural/Community Hospita... 350708.805302 \n", + "37 ClinicDistrict HospitalRural/Community Hospita... 293182.399170 \n", + "38 ClinicDistrict HospitalRural/Community Hospita... 377478.093086 \n", + "39 ClinicDistrict HospitalRural/Community Hospita... 291362.431282 \n", + "40 ClinicDistrict HospitalRural/Community Hospita... 368970.926878 \n", + "41 ClinicDistrict HospitalRural/Community Hospita... 397265.484764 \n", + "42 ClinicDistrict HospitalRural/Community Hospita... 327967.298680 \n", + "43 ClinicDistrict HospitalRural/Community Hospita... 315778.193228 \n", + "44 ClinicDistrict HospitalRural/Community Hospita... 342508.889264 \n", + "45 ClinicDistrict HospitalRural/Community Hospita... 369080.727151 \n", "\n", " Lag_1_Precipitation Lag_2_Precipitation Lag_3_Precipitation \\\n", - "0 390008.338639 385074.053901 383551.519335 \n", - "1 324216.805408 351108.236956 352944.118983 \n", - "2 351903.960266 349493.164255 344770.234996 \n", - "3 379492.789825 375543.857029 381029.229862 \n", - "4 375481.180687 385373.062799 381129.073629 \n", - "5 311938.841921 285932.285061 289579.937651 \n", - "6 433698.584038 455288.388297 455102.702313 \n", - "7 315844.250082 324314.368396 316195.532608 \n", - "8 371283.829234 345593.426372 354934.926046 \n", - "9 399207.341834 400410.349670 392246.728746 \n", - "10 341985.164411 327819.997189 330789.556355 \n", - "11 398497.779822 408894.912655 378604.565588 \n", - "12 348875.547726 360367.235995 389923.203199 \n", - "13 370981.253838 381170.945543 378471.104964 \n", - "14 394083.987840 401617.097706 408341.613660 \n", - "15 344469.424679 340683.245254 342518.356804 \n", - "16 331135.927791 335947.246630 335248.047067 \n", - "17 328321.508621 302510.901036 300226.263604 \n", - "18 252246.251731 271260.885375 274124.334082 \n", - "19 410050.158172 387974.439450 387736.897200 \n", - "20 369108.855991 362046.586240 342819.132014 \n", - "21 482869.984890 480685.090489 500151.794189 \n", - "22 419334.638122 449504.867423 447116.625283 \n", - "23 317922.916948 310749.912224 313141.518581 \n", - "24 325481.247456 336295.941280 330700.546457 \n", - "25 502910.647286 435891.016355 437939.836711 \n", - "26 325017.559932 392209.231985 393915.875687 \n", - "27 355003.796484 335224.704315 335946.670289 \n", - "28 360724.744731 376450.353321 368811.709372 \n", - "29 329764.214376 325974.066284 334512.344383 \n", - "30 331417.631119 333207.967531 331162.787180 \n", - "31 265016.427098 267520.943494 269888.025290 \n", - "32 457908.115607 448849.771066 446651.780946 \n", - "33 278375.606401 291501.477315 289945.485496 \n", - "34 318063.470421 302154.611762 306083.376401 \n", - "35 327543.125082 336866.204386 331980.842360 \n", - "36 330945.691553 322432.738606 318079.159985 \n", - "37 285321.675202 301954.830856 310662.088357 \n", - "38 433776.704399 419118.260070 404772.957169 \n", - "39 317030.377297 304945.762400 319651.502857 \n", - "40 329874.956467 337015.684029 328940.852077 \n", - "41 354202.699889 365879.087584 373323.111876 \n", - "42 272255.281494 280888.319603 281510.797522 \n", - "43 378752.521246 360679.750486 359521.705424 \n", - "44 445824.370857 462306.136722 461148.128688 \n", - "45 364719.332490 323443.731437 324834.166014 \n", + "0 398942.636170 404727.057797 405704.571665 \n", + "1 413397.817913 388309.667883 385397.116828 \n", + "2 407187.589904 420216.307417 421615.911783 \n", + "3 406189.704606 403165.981005 401105.177547 \n", + "4 420471.214026 421450.033447 424520.950185 \n", + "5 410824.557725 391493.761671 388196.210212 \n", + "6 432044.900550 456751.262273 456752.721138 \n", + "7 348112.188236 353270.524412 357410.845800 \n", + "8 405019.687496 388565.288508 388245.552346 \n", + "9 372460.875926 375124.877747 371846.112765 \n", + "10 408169.132145 406485.011941 407092.899084 \n", + "11 451325.020396 433158.134992 433133.983599 \n", + "12 481501.033891 524791.840222 527391.207421 \n", + "13 339513.871817 320576.954584 319333.523933 \n", + "14 392029.707764 393257.108114 394526.442838 \n", + "15 371789.329465 387244.681484 386630.546157 \n", + "16 440952.201046 424662.364695 425051.043775 \n", + "17 286935.705860 311049.994112 312185.510318 \n", + "18 392470.951022 356521.858749 353794.312578 \n", + "19 394609.621848 426205.552210 424729.506080 \n", + "20 414178.271428 393702.776056 395566.258413 \n", + "21 385122.990507 393876.211485 395324.082930 \n", + "22 374058.228036 360407.393814 361159.265562 \n", + "23 367702.143527 383792.892262 381569.846621 \n", + "24 406359.400288 413379.564221 402964.624861 \n", + "25 362825.700917 354087.658823 342715.089184 \n", + "26 358797.936758 363399.872412 387024.433983 \n", + "27 375109.947590 372857.980106 358164.961912 \n", + "28 367650.235635 359381.996323 367921.786733 \n", + "29 363845.441546 357419.463077 345612.633741 \n", + "30 398093.244924 420338.093431 427216.475603 \n", + "31 460331.584266 421106.585969 427549.155747 \n", + "32 355110.662118 385804.286252 377495.302483 \n", + "33 404952.222454 380148.672904 390887.435379 \n", + "34 405715.733698 429608.759456 429014.390163 \n", + "35 409799.355286 410974.276816 413298.745816 \n", + "36 353761.775712 344252.932147 343209.200439 \n", + "37 325069.624722 344289.047467 342084.186261 \n", + "38 353257.222779 353764.890202 357823.798670 \n", + "39 302326.827366 304020.083180 303828.779931 \n", + "40 368964.162462 357775.533341 356652.040920 \n", + "41 323346.039126 322784.762289 316952.269236 \n", + "42 383625.207672 394279.969633 398120.412976 \n", + "43 360494.854893 356119.648704 357486.445092 \n", + "44 323961.673652 331898.505904 332841.894862 \n", + "45 347439.884447 315453.846359 311453.513947 \n", "\n", " Lag_4_Precipitation Predicted_Weather_Model Predicted_No_Weather_Model \\\n", - "0 382881.752808 453186.019359 452178.159027 \n", - "1 353891.586301 448903.391472 451324.318689 \n", - "2 345157.532117 450203.526071 450472.090644 \n", - "3 379415.048009 446538.199648 449621.471846 \n", - "4 382864.345741 446948.806790 448772.459257 \n", - "5 289345.079079 445167.350051 447925.049844 \n", - "6 455034.373344 443225.944431 447079.240580 \n", - "7 314871.921748 445182.353097 446235.028444 \n", - "8 356543.998012 444463.766354 445392.410418 \n", - "9 391937.348081 443436.073774 444551.383494 \n", - "10 329650.101725 441556.996446 443711.944667 \n", - "11 379596.718666 443325.455792 442874.090938 \n", - "12 389558.939179 440375.155656 442037.819314 \n", - "13 377682.655534 441294.684850 441203.126808 \n", - "14 409745.578729 442671.748454 440370.010437 \n", - "15 341977.330400 437801.561953 439538.467226 \n", - "16 335789.435760 435274.468592 438708.494203 \n", - "17 296296.047432 437029.478846 437880.088405 \n", - "18 278184.608227 434377.435798 437053.246871 \n", - "19 387661.416146 434394.568891 436227.966648 \n", - "20 340516.424995 434086.915088 435404.244787 \n", - "21 502277.800794 434927.534834 434582.078347 \n", - "22 445805.292269 435351.610440 433761.464389 \n", - "23 313923.715557 430707.116763 432942.399983 \n", - "24 330244.876504 430982.665089 432124.882203 \n", - "25 438231.552425 428731.420008 431308.908127 \n", - "26 393957.931607 430192.671905 430494.474841 \n", - "27 336884.175544 427640.316088 429681.579436 \n", - "28 365595.615071 427806.610028 428870.219007 \n", - "29 337541.046047 425278.010843 428060.390657 \n", - "30 331449.273326 426811.173251 427252.091491 \n", - "31 269433.014822 425621.733459 426445.318624 \n", - "32 445524.032754 424963.149920 425640.069171 \n", - "33 291038.100935 423293.012832 424836.340258 \n", - "34 305678.254498 422200.602069 424034.129012 \n", - "35 330169.889911 421642.817151 423233.432568 \n", - "36 317973.894415 422645.018611 422434.248066 \n", - "37 312810.479228 421026.188284 421636.572650 \n", - "38 405190.542219 419003.352104 420840.403471 \n", - "39 319575.723877 419156.256610 420045.737685 \n", - "40 329238.343810 418797.992003 419252.572452 \n", - "41 372541.004296 418424.138509 418460.904941 \n", - "42 281840.507716 417481.752292 417670.732321 \n", - "43 359548.833442 414833.508183 416882.051771 \n", - "44 461552.424105 415995.972386 416094.860473 \n", - "45 323233.055405 412944.024703 415309.155615 \n", + "0 404895.268433 450413.811572 452178.159027 \n", + "1 386621.761142 449805.162811 451324.318689 \n", + "2 421535.968891 448780.570788 450472.090644 \n", + "3 400973.159779 446657.461648 449621.471846 \n", + "4 419592.912552 447811.134508 448772.459257 \n", + "5 391638.197677 447111.614783 447925.049844 \n", + "6 456824.623648 448389.823951 447079.240580 \n", + "7 357753.146752 443503.204711 446235.028444 \n", + "8 388673.117569 445468.831800 445392.410418 \n", + "9 373019.671935 441550.545941 444551.383494 \n", + "10 406919.996712 442181.994730 443711.944667 \n", + "11 432861.285260 439591.654817 442874.090938 \n", + "12 527784.234663 437890.108389 442037.819314 \n", + "13 318825.960831 440318.995534 441203.126808 \n", + "14 394260.244027 442379.145149 440370.010437 \n", + "15 387202.538290 438585.581628 439538.467226 \n", + "16 423444.969850 439207.738143 438708.494203 \n", + "17 313717.825313 436501.827701 437880.088405 \n", + "18 353491.313705 435213.523261 437053.246871 \n", + "19 424904.453286 433980.084304 436227.966648 \n", + "20 394030.949034 436281.073753 435404.244787 \n", + "21 396757.245029 434232.446019 434582.078347 \n", + "22 357396.518341 431881.487367 433761.464389 \n", + "23 384605.158226 431705.820487 432942.399983 \n", + "24 402279.134778 429946.439795 432124.882203 \n", + "25 343650.740769 430370.073359 431308.908127 \n", + "26 387553.261741 431264.483456 430494.474841 \n", + "27 357983.056662 427120.049100 429681.579436 \n", + "28 368369.784160 428888.240001 428870.219007 \n", + "29 345685.373340 427162.001628 428060.390657 \n", + "30 426320.093861 424371.134246 427252.091491 \n", + "31 427585.588743 429015.574874 426445.318624 \n", + "32 376728.920725 424851.189902 425640.069171 \n", + "33 392238.633130 424630.686008 424836.340258 \n", + "34 428209.211053 421981.174732 424034.129012 \n", + "35 414461.110789 422383.644429 423233.432568 \n", + "36 343006.625602 421716.445639 422434.248066 \n", + "37 342232.642746 419713.526935 421636.572650 \n", + "38 357126.722312 419519.270457 420840.403471 \n", + "39 303106.289335 418301.255283 420045.737685 \n", + "40 355879.690701 417565.319731 419252.572452 \n", + "41 316486.677194 418492.789945 418460.904941 \n", + "42 400442.667319 416393.707279 417670.732321 \n", + "43 357120.223981 417560.781784 416882.051771 \n", + "44 333370.975675 414846.238601 416094.860473 \n", + "45 310691.844984 413085.183289 415309.155615 \n", "\n", " Difference_in_Expectation \n", - "0 1007.860332 \n", - "1 -2420.927217 \n", - "2 -268.564573 \n", - "3 -3083.272198 \n", - "4 -1823.652467 \n", - "5 -2757.699793 \n", - "6 -3853.296150 \n", - "7 -1052.675347 \n", - "8 -928.644064 \n", - "9 -1115.309720 \n", - "10 -2154.948222 \n", - "11 451.364853 \n", - "12 -1662.663659 \n", - "13 91.558042 \n", - "14 2301.738017 \n", - "15 -1736.905273 \n", - "16 -3434.025611 \n", - "17 -850.609558 \n", - "18 -2675.811073 \n", - "19 -1833.397757 \n", - "20 -1317.329699 \n", - "21 345.456487 \n", - "22 1590.146050 \n", - "23 -2235.283220 \n", - "24 -1142.217114 \n", - "25 -2577.488119 \n", - "26 -301.802936 \n", - "27 -2041.263348 \n", - "28 -1063.608979 \n", - "29 -2782.379814 \n", - "30 -440.918241 \n", - "31 -823.585164 \n", - "32 -676.919251 \n", - "33 -1543.327426 \n", - "34 -1833.526943 \n", - "35 -1590.615417 \n", - "36 210.770545 \n", - "37 -610.384366 \n", - "38 -1837.051367 \n", - "39 -889.481075 \n", - "40 -454.580449 \n", - "41 -36.766432 \n", - "42 -188.980029 \n", - "43 -2048.543588 \n", - "44 -98.888087 \n", - "45 -2365.130912 " + "0 -1764.347455 \n", + "1 -1519.155878 \n", + "2 -1691.519856 \n", + "3 -2964.010197 \n", + "4 -961.324749 \n", + "5 -813.435061 \n", + "6 1310.583371 \n", + "7 -2731.823733 \n", + "8 76.421382 \n", + "9 -3000.837553 \n", + "10 -1529.949937 \n", + "11 -3282.436122 \n", + "12 -4147.710925 \n", + "13 -884.131274 \n", + "14 2009.134712 \n", + "15 -952.885598 \n", + "16 499.243940 \n", + "17 -1378.260704 \n", + "18 -1839.723610 \n", + "19 -2247.882344 \n", + "20 876.828966 \n", + "21 -349.632328 \n", + "22 -1879.977022 \n", + "23 -1236.579496 \n", + "24 -2178.442408 \n", + "25 -938.834768 \n", + "26 770.008615 \n", + "27 -2561.530336 \n", + "28 18.020994 \n", + "29 -898.389029 \n", + "30 -2880.957246 \n", + "31 2570.256250 \n", + "32 -788.879269 \n", + "33 -205.654250 \n", + "34 -2052.954280 \n", + "35 -849.788140 \n", + "36 -717.802427 \n", + "37 -1923.045715 \n", + "38 -1321.133014 \n", + "39 -1744.482402 \n", + "40 -1687.252721 \n", + "41 31.885004 \n", + "42 -1277.025042 \n", + "43 678.730014 \n", + "44 -1248.621872 \n", + "45 -2223.972326 " ], "text/html": [ "
\n", @@ -723,14 +721,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 370655.578345\n", - " 390008.338639\n", - " 385074.053901\n", - " 383551.519335\n", - " 382881.752808\n", - " 453186.019359\n", + " 377371.401757\n", + " 398942.636170\n", + " 404727.057797\n", + " 405704.571665\n", + " 404895.268433\n", + " 450413.811572\n", " 452178.159027\n", - " 1007.860332\n", + " -1764.347455\n", " \n", " \n", " 1\n", @@ -743,14 +741,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 305845.723518\n", - " 324216.805408\n", - " 351108.236956\n", - " 352944.118983\n", - " 353891.586301\n", - " 448903.391472\n", + " 424179.161524\n", + " 413397.817913\n", + " 388309.667883\n", + " 385397.116828\n", + " 386621.761142\n", + " 449805.162811\n", " 451324.318689\n", - " -2420.927217\n", + " -1519.155878\n", " \n", " \n", " 2\n", @@ -763,14 +761,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 380236.133055\n", - " 351903.960266\n", - " 349493.164255\n", - " 344770.234996\n", - " 345157.532117\n", - " 450203.526071\n", + " 416785.291442\n", + " 407187.589904\n", + " 420216.307417\n", + " 421615.911783\n", + " 421535.968891\n", + " 448780.570788\n", " 450472.090644\n", - " -268.564573\n", + " -1691.519856\n", " \n", " \n", " 3\n", @@ -783,14 +781,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 396234.125976\n", - " 379492.789825\n", - " 375543.857029\n", - " 381029.229862\n", - " 379415.048009\n", - " 446538.199648\n", + " 431174.255009\n", + " 406189.704606\n", + " 403165.981005\n", + " 401105.177547\n", + " 400973.159779\n", + " 446657.461648\n", " 449621.471846\n", - " -3083.272198\n", + " -2964.010197\n", " \n", " \n", " 4\n", @@ -803,14 +801,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 317163.607434\n", - " 375481.180687\n", - " 385373.062799\n", - " 381129.073629\n", - " 382864.345741\n", - " 446948.806790\n", + " 405743.410420\n", + " 420471.214026\n", + " 421450.033447\n", + " 424520.950185\n", + " 419592.912552\n", + " 447811.134508\n", " 448772.459257\n", - " -1823.652467\n", + " -961.324749\n", " \n", " \n", " 5\n", @@ -823,14 +821,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 385409.189618\n", - " 311938.841921\n", - " 285932.285061\n", - " 289579.937651\n", - " 289345.079079\n", - " 445167.350051\n", + " 410793.849551\n", + " 410824.557725\n", + " 391493.761671\n", + " 388196.210212\n", + " 391638.197677\n", + " 447111.614783\n", " 447925.049844\n", - " -2757.699793\n", + " -813.435061\n", " \n", " \n", " 6\n", @@ -843,14 +841,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 406289.858606\n", - " 433698.584038\n", - " 455288.388297\n", - " 455102.702313\n", - " 455034.373344\n", - " 443225.944431\n", + " 430219.873937\n", + " 432044.900550\n", + " 456751.262273\n", + " 456752.721138\n", + " 456824.623648\n", + " 448389.823951\n", " 447079.240580\n", - " -3853.296150\n", + " 1310.583371\n", " \n", " \n", " 7\n", @@ -863,14 +861,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 333604.956760\n", - " 315844.250082\n", - " 324314.368396\n", - " 316195.532608\n", - " 314871.921748\n", - " 445182.353097\n", + " 332427.056762\n", + " 348112.188236\n", + " 353270.524412\n", + " 357410.845800\n", + " 357753.146752\n", + " 443503.204711\n", " 446235.028444\n", - " -1052.675347\n", + " -2731.823733\n", " \n", " \n", " 8\n", @@ -883,14 +881,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 322006.856259\n", - " 371283.829234\n", - " 345593.426372\n", - " 354934.926046\n", - " 356543.998012\n", - " 444463.766354\n", + " 392896.036283\n", + " 405019.687496\n", + " 388565.288508\n", + " 388245.552346\n", + " 388673.117569\n", + " 445468.831800\n", " 445392.410418\n", - " -928.644064\n", + " 76.421382\n", " \n", " \n", " 9\n", @@ -903,14 +901,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 391560.967791\n", - " 399207.341834\n", - " 400410.349670\n", - " 392246.728746\n", - " 391937.348081\n", - " 443436.073774\n", + " 409775.392632\n", + " 372460.875926\n", + " 375124.877747\n", + " 371846.112765\n", + " 373019.671935\n", + " 441550.545941\n", " 444551.383494\n", - " -1115.309720\n", + " -3000.837553\n", " \n", " \n", " 10\n", @@ -923,14 +921,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 367661.767185\n", - " 341985.164411\n", - " 327819.997189\n", - " 330789.556355\n", - " 329650.101725\n", - " 441556.996446\n", + " 410851.208278\n", + " 408169.132145\n", + " 406485.011941\n", + " 407092.899084\n", + " 406919.996712\n", + " 442181.994730\n", " 443711.944667\n", - " -2154.948222\n", + " -1529.949937\n", " \n", " \n", " 11\n", @@ -943,14 +941,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 378095.303002\n", - " 398497.779822\n", - " 408894.912655\n", - " 378604.565588\n", - " 379596.718666\n", - " 443325.455792\n", + " 456535.963741\n", + " 451325.020396\n", + " 433158.134992\n", + " 433133.983599\n", + " 432861.285260\n", + " 439591.654817\n", " 442874.090938\n", - " 451.364853\n", + " -3282.436122\n", " \n", " \n", " 12\n", @@ -963,14 +961,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 374197.949271\n", - " 348875.547726\n", - " 360367.235995\n", - " 389923.203199\n", - " 389558.939179\n", - " 440375.155656\n", + " 452334.398335\n", + " 481501.033891\n", + " 524791.840222\n", + " 527391.207421\n", + " 527784.234663\n", + " 437890.108389\n", " 442037.819314\n", - " -1662.663659\n", + " -4147.710925\n", " \n", " \n", " 13\n", @@ -983,14 +981,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 374291.695816\n", - " 370981.253838\n", - " 381170.945543\n", - " 378471.104964\n", - " 377682.655534\n", - " 441294.684850\n", + " 329049.810569\n", + " 339513.871817\n", + " 320576.954584\n", + " 319333.523933\n", + " 318825.960831\n", + " 440318.995534\n", " 441203.126808\n", - " 91.558042\n", + " -884.131274\n", " \n", " \n", " 14\n", @@ -1003,14 +1001,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 398962.867137\n", - " 394083.987840\n", - " 401617.097706\n", - " 408341.613660\n", - " 409745.578729\n", - " 442671.748454\n", + " 414644.190834\n", + " 392029.707764\n", + " 393257.108114\n", + " 394526.442838\n", + " 394260.244027\n", + " 442379.145149\n", " 440370.010437\n", - " 2301.738017\n", + " 2009.134712\n", " \n", " \n", " 15\n", @@ -1023,14 +1021,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 329938.705708\n", - " 344469.424679\n", - " 340683.245254\n", - " 342518.356804\n", - " 341977.330400\n", - " 437801.561953\n", + " 392121.029719\n", + " 371789.329465\n", + " 387244.681484\n", + " 386630.546157\n", + " 387202.538290\n", + " 438585.581628\n", " 439538.467226\n", - " -1736.905273\n", + " -952.885598\n", " \n", " \n", " 16\n", @@ -1043,14 +1041,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 349982.489824\n", - " 331135.927791\n", - " 335947.246630\n", - " 335248.047067\n", - " 335789.435760\n", - " 435274.468592\n", + " 380754.054252\n", + " 440952.201046\n", + " 424662.364695\n", + " 425051.043775\n", + " 423444.969850\n", + " 439207.738143\n", " 438708.494203\n", - " -3434.025611\n", + " 499.243940\n", " \n", " \n", " 17\n", @@ -1063,14 +1061,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 265019.061881\n", - " 328321.508621\n", - " 302510.901036\n", - " 300226.263604\n", - " 296296.047432\n", - " 437029.478846\n", + " 296596.215293\n", + " 286935.705860\n", + " 311049.994112\n", + " 312185.510318\n", + " 313717.825313\n", + " 436501.827701\n", " 437880.088405\n", - " -850.609558\n", + " -1378.260704\n", " \n", " \n", " 18\n", @@ -1083,14 +1081,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 317116.288589\n", - " 252246.251731\n", - " 271260.885375\n", - " 274124.334082\n", - " 278184.608227\n", - " 434377.435798\n", + " 423715.504984\n", + " 392470.951022\n", + " 356521.858749\n", + " 353794.312578\n", + " 353491.313705\n", + " 435213.523261\n", " 437053.246871\n", - " -2675.811073\n", + " -1839.723610\n", " \n", " \n", " 19\n", @@ -1103,14 +1101,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 358615.638348\n", - " 410050.158172\n", - " 387974.439450\n", - " 387736.897200\n", - " 387661.416146\n", - " 434394.568891\n", + " 368319.084368\n", + " 394609.621848\n", + " 426205.552210\n", + " 424729.506080\n", + " 424904.453286\n", + " 433980.084304\n", " 436227.966648\n", - " -1833.397757\n", + " -2247.882344\n", " \n", " \n", " 20\n", @@ -1123,14 +1121,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 441360.716573\n", - " 369108.855991\n", - " 362046.586240\n", - " 342819.132014\n", - " 340516.424995\n", - " 434086.915088\n", + " 418134.051457\n", + " 414178.271428\n", + " 393702.776056\n", + " 395566.258413\n", + " 394030.949034\n", + " 436281.073753\n", " 435404.244787\n", - " -1317.329699\n", + " 876.828966\n", " \n", " \n", " 21\n", @@ -1143,14 +1141,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 485128.815221\n", - " 482869.984890\n", - " 480685.090489\n", - " 500151.794189\n", - " 502277.800794\n", - " 434927.534834\n", + " 380622.271982\n", + " 385122.990507\n", + " 393876.211485\n", + " 395324.082930\n", + " 396757.245029\n", + " 434232.446019\n", " 434582.078347\n", - " 345.456487\n", + " -349.632328\n", " \n", " \n", " 22\n", @@ -1163,14 +1161,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 339348.499913\n", - " 419334.638122\n", - " 449504.867423\n", - " 447116.625283\n", - " 445805.292269\n", - " 435351.610440\n", + " 388922.127329\n", + " 374058.228036\n", + " 360407.393814\n", + " 361159.265562\n", + " 357396.518341\n", + " 431881.487367\n", " 433761.464389\n", - " 1590.146050\n", + " -1879.977022\n", " \n", " \n", " 23\n", @@ -1183,14 +1181,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 353296.312971\n", - " 317922.916948\n", - " 310749.912224\n", - " 313141.518581\n", - " 313923.715557\n", - " 430707.116763\n", + " 373888.999201\n", + " 367702.143527\n", + " 383792.892262\n", + " 381569.846621\n", + " 384605.158226\n", + " 431705.820487\n", " 432942.399983\n", - " -2235.283220\n", + " -1236.579496\n", " \n", " \n", " 24\n", @@ -1203,14 +1201,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 333745.253478\n", - " 325481.247456\n", - " 336295.941280\n", - " 330700.546457\n", - " 330244.876504\n", - " 430982.665089\n", + " 403081.277311\n", + " 406359.400288\n", + " 413379.564221\n", + " 402964.624861\n", + " 402279.134778\n", + " 429946.439795\n", " 432124.882203\n", - " -1142.217114\n", + " -2178.442408\n", " \n", " \n", " 25\n", @@ -1223,14 +1221,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 513923.146927\n", - " 502910.647286\n", - " 435891.016355\n", - " 437939.836711\n", - " 438231.552425\n", - " 428731.420008\n", + " 377526.089751\n", + " 362825.700917\n", + " 354087.658823\n", + " 342715.089184\n", + " 343650.740769\n", + " 430370.073359\n", " 431308.908127\n", - " -2577.488119\n", + " -938.834768\n", " \n", " \n", " 26\n", @@ -1243,14 +1241,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 271825.288644\n", - " 325017.559932\n", - " 392209.231985\n", - " 393915.875687\n", - " 393957.931607\n", - " 430192.671905\n", + " 312891.203066\n", + " 358797.936758\n", + " 363399.872412\n", + " 387024.433983\n", + " 387553.261741\n", + " 431264.483456\n", " 430494.474841\n", - " -301.802936\n", + " 770.008615\n", " \n", " \n", " 27\n", @@ -1263,14 +1261,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 365895.719222\n", - " 355003.796484\n", - " 335224.704315\n", - " 335946.670289\n", - " 336884.175544\n", - " 427640.316088\n", + " 383090.314471\n", + " 375109.947590\n", + " 372857.980106\n", + " 358164.961912\n", + " 357983.056662\n", + " 427120.049100\n", " 429681.579436\n", - " -2041.263348\n", + " -2561.530336\n", " \n", " \n", " 28\n", @@ -1283,14 +1281,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 325208.687060\n", - " 360724.744731\n", - " 376450.353321\n", - " 368811.709372\n", - " 365595.615071\n", - " 427806.610028\n", + " 370916.909122\n", + " 367650.235635\n", + " 359381.996323\n", + " 367921.786733\n", + " 368369.784160\n", + " 428888.240001\n", " 428870.219007\n", - " -1063.608979\n", + " 18.020994\n", " \n", " \n", " 29\n", @@ -1303,14 +1301,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 382143.812346\n", - " 329764.214376\n", - " 325974.066284\n", - " 334512.344383\n", - " 337541.046047\n", - " 425278.010843\n", + " 358979.193679\n", + " 363845.441546\n", + " 357419.463077\n", + " 345612.633741\n", + " 345685.373340\n", + " 427162.001628\n", " 428060.390657\n", - " -2782.379814\n", + " -898.389029\n", " \n", " \n", " 30\n", @@ -1323,14 +1321,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 287994.569053\n", - " 331417.631119\n", - " 333207.967531\n", - " 331162.787180\n", - " 331449.273326\n", - " 426811.173251\n", + " 411059.228901\n", + " 398093.244924\n", + " 420338.093431\n", + " 427216.475603\n", + " 426320.093861\n", + " 424371.134246\n", " 427252.091491\n", - " -440.918241\n", + " -2880.957246\n", " \n", " \n", " 31\n", @@ -1343,14 +1341,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 332374.359974\n", - " 265016.427098\n", - " 267520.943494\n", - " 269888.025290\n", - " 269433.014822\n", - " 425621.733459\n", + " 457632.022035\n", + " 460331.584266\n", + " 421106.585969\n", + " 427549.155747\n", + " 427585.588743\n", + " 429015.574874\n", " 426445.318624\n", - " -823.585164\n", + " 2570.256250\n", " \n", " \n", " 32\n", @@ -1363,14 +1361,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 392877.314013\n", - " 457908.115607\n", - " 448849.771066\n", - " 446651.780946\n", - " 445524.032754\n", - " 424963.149920\n", + " 366158.628623\n", + " 355110.662118\n", + " 385804.286252\n", + " 377495.302483\n", + " 376728.920725\n", + " 424851.189902\n", " 425640.069171\n", - " -676.919251\n", + " -788.879269\n", " \n", " \n", " 33\n", @@ -1383,14 +1381,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 302066.178485\n", - " 278375.606401\n", - " 291501.477315\n", - " 289945.485496\n", - " 291038.100935\n", - " 423293.012832\n", + " 414749.367352\n", + " 404952.222454\n", + " 380148.672904\n", + " 390887.435379\n", + " 392238.633130\n", + " 424630.686008\n", " 424836.340258\n", - " -1543.327426\n", + " -205.654250\n", " \n", " \n", " 34\n", @@ -1403,14 +1401,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 327708.324530\n", - " 318063.470421\n", - " 302154.611762\n", - " 306083.376401\n", - " 305678.254498\n", - " 422200.602069\n", + " 394182.173776\n", + " 405715.733698\n", + " 429608.759456\n", + " 429014.390163\n", + " 428209.211053\n", + " 421981.174732\n", " 424034.129012\n", - " -1833.526943\n", + " -2052.954280\n", " \n", " \n", " 35\n", @@ -1423,14 +1421,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 309435.437644\n", - " 327543.125082\n", - " 336866.204386\n", - " 331980.842360\n", - " 330169.889911\n", - " 421642.817151\n", + " 412930.274807\n", + " 409799.355286\n", + " 410974.276816\n", + " 413298.745816\n", + " 414461.110789\n", + " 422383.644429\n", " 423233.432568\n", - " -1590.615417\n", + " -849.788140\n", " \n", " \n", " 36\n", @@ -1443,14 +1441,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 320279.427886\n", - " 330945.691553\n", - " 322432.738606\n", - " 318079.159985\n", - " 317973.894415\n", - " 422645.018611\n", + " 350708.805302\n", + " 353761.775712\n", + " 344252.932147\n", + " 343209.200439\n", + " 343006.625602\n", + " 421716.445639\n", " 422434.248066\n", - " 210.770545\n", + " -717.802427\n", " \n", " \n", " 37\n", @@ -1463,14 +1461,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 330832.389669\n", - " 285321.675202\n", - " 301954.830856\n", - " 310662.088357\n", - " 312810.479228\n", - " 421026.188284\n", + " 293182.399170\n", + " 325069.624722\n", + " 344289.047467\n", + " 342084.186261\n", + " 342232.642746\n", + " 419713.526935\n", " 421636.572650\n", - " -610.384366\n", + " -1923.045715\n", " \n", " \n", " 38\n", @@ -1483,14 +1481,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 435362.126119\n", - " 433776.704399\n", - " 419118.260070\n", - " 404772.957169\n", - " 405190.542219\n", - " 419003.352104\n", + " 377478.093086\n", + " 353257.222779\n", + " 353764.890202\n", + " 357823.798670\n", + " 357126.722312\n", + " 419519.270457\n", " 420840.403471\n", - " -1837.051367\n", + " -1321.133014\n", " \n", " \n", " 39\n", @@ -1503,14 +1501,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 304940.147499\n", - " 317030.377297\n", - " 304945.762400\n", - " 319651.502857\n", - " 319575.723877\n", - " 419156.256610\n", + " 291362.431282\n", + " 302326.827366\n", + " 304020.083180\n", + " 303828.779931\n", + " 303106.289335\n", + " 418301.255283\n", " 420045.737685\n", - " -889.481075\n", + " -1744.482402\n", " \n", " \n", " 40\n", @@ -1523,14 +1521,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 353974.887443\n", - " 329874.956467\n", - " 337015.684029\n", - " 328940.852077\n", - " 329238.343810\n", - " 418797.992003\n", + " 368970.926878\n", + " 368964.162462\n", + " 357775.533341\n", + " 356652.040920\n", + " 355879.690701\n", + " 417565.319731\n", " 419252.572452\n", - " -454.580449\n", + " -1687.252721\n", " \n", " \n", " 41\n", @@ -1543,14 +1541,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 295464.487169\n", - " 354202.699889\n", - " 365879.087584\n", - " 373323.111876\n", - " 372541.004296\n", - " 418424.138509\n", + " 397265.484764\n", + " 323346.039126\n", + " 322784.762289\n", + " 316952.269236\n", + " 316486.677194\n", + " 418492.789945\n", " 418460.904941\n", - " -36.766432\n", + " 31.885004\n", " \n", " \n", " 42\n", @@ -1563,14 +1561,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 297221.496710\n", - " 272255.281494\n", - " 280888.319603\n", - " 281510.797522\n", - " 281840.507716\n", - " 417481.752292\n", + " 327967.298680\n", + " 383625.207672\n", + " 394279.969633\n", + " 398120.412976\n", + " 400442.667319\n", + " 416393.707279\n", " 417670.732321\n", - " -188.980029\n", + " -1277.025042\n", " \n", " \n", " 43\n", @@ -1583,14 +1581,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 409016.019784\n", - " 378752.521246\n", - " 360679.750486\n", - " 359521.705424\n", - " 359548.833442\n", - " 414833.508183\n", + " 315778.193228\n", + " 360494.854893\n", + " 356119.648704\n", + " 357486.445092\n", + " 357120.223981\n", + " 417560.781784\n", " 416882.051771\n", - " -2048.543588\n", + " 678.730014\n", " \n", " \n", " 44\n", @@ -1603,14 +1601,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 420878.539429\n", - " 445824.370857\n", - " 462306.136722\n", - " 461148.128688\n", - " 461552.424105\n", - " 415995.972386\n", + " 342508.889264\n", + " 323961.673652\n", + " 331898.505904\n", + " 332841.894862\n", + " 333370.975675\n", + " 414846.238601\n", " 416094.860473\n", - " -98.888087\n", + " -1248.621872\n", " \n", " \n", " 45\n", @@ -1623,32 +1621,32 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 405718.142702\n", - " 364719.332490\n", - " 323443.731437\n", - " 324834.166014\n", - " 323233.055405\n", - " 412944.024703\n", + " 369080.727151\n", + " 347439.884447\n", + " 315453.846359\n", + " 311453.513947\n", + " 310691.844984\n", + " 413085.183289\n", " 415309.155615\n", - " -2365.130912\n", + " -2223.972326\n", " \n", " \n", "\n", "
" ] }, - "execution_count": 4, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 4 + "execution_count": 20 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-09T11:44:43.904823Z", - "start_time": "2025-01-09T11:44:43.875882Z" + "end_time": "2025-01-09T12:05:23.438504Z", + "start_time": "2025-01-09T12:05:23.404339Z" } }, "cell_type": "code", @@ -1902,196 +1900,196 @@ "45 GovernmentGovernmentGovernmentGovernmentGovern... \n", "\n", " Facility_Type Precipitation \\\n", - "0 ClinicDistrict HospitalRural/Community Hospita... 370655.578345 \n", - "1 ClinicDistrict HospitalRural/Community Hospita... 305845.723518 \n", - "2 ClinicDistrict HospitalRural/Community Hospita... 380236.133055 \n", - "3 ClinicDistrict HospitalRural/Community Hospita... 396234.125976 \n", - "4 ClinicDistrict HospitalRural/Community Hospita... 317163.607434 \n", - "5 ClinicDistrict HospitalRural/Community Hospita... 385409.189618 \n", - "6 ClinicDistrict HospitalRural/Community Hospita... 406289.858606 \n", - "7 ClinicDistrict HospitalRural/Community Hospita... 333604.956760 \n", - "8 ClinicDistrict HospitalRural/Community Hospita... 322006.856259 \n", - "9 ClinicDistrict HospitalRural/Community Hospita... 391560.967791 \n", - "10 ClinicDistrict HospitalRural/Community Hospita... 367661.767185 \n", - "11 ClinicDistrict HospitalRural/Community Hospita... 378095.303002 \n", - "12 ClinicDistrict HospitalRural/Community Hospita... 374197.949271 \n", - "13 ClinicDistrict HospitalRural/Community Hospita... 374291.695816 \n", - "14 ClinicDistrict HospitalRural/Community Hospita... 398962.867137 \n", - "15 ClinicDistrict HospitalRural/Community Hospita... 329938.705708 \n", - "16 ClinicDistrict HospitalRural/Community Hospita... 349982.489824 \n", - "17 ClinicDistrict HospitalRural/Community Hospita... 265019.061881 \n", - "18 ClinicDistrict HospitalRural/Community Hospita... 317116.288589 \n", - "19 ClinicDistrict HospitalRural/Community Hospita... 358615.638348 \n", - "20 ClinicDistrict HospitalRural/Community Hospita... 441360.716573 \n", - "21 ClinicDistrict HospitalRural/Community Hospita... 485128.815221 \n", - "22 ClinicDistrict HospitalRural/Community Hospita... 339348.499913 \n", - "23 ClinicDistrict HospitalRural/Community Hospita... 353296.312971 \n", - "24 ClinicDistrict HospitalRural/Community Hospita... 333745.253478 \n", - "25 ClinicDistrict HospitalRural/Community Hospita... 513923.146927 \n", - "26 ClinicDistrict HospitalRural/Community Hospita... 271825.288644 \n", - "27 ClinicDistrict HospitalRural/Community Hospita... 365895.719222 \n", - "28 ClinicDistrict HospitalRural/Community Hospita... 325208.687060 \n", - "29 ClinicDistrict HospitalRural/Community Hospita... 382143.812346 \n", - "30 ClinicDistrict HospitalRural/Community Hospita... 287994.569053 \n", - "31 ClinicDistrict HospitalRural/Community Hospita... 332374.359974 \n", - "32 ClinicDistrict HospitalRural/Community Hospita... 392877.314013 \n", - "33 ClinicDistrict HospitalRural/Community Hospita... 302066.178485 \n", - "34 ClinicDistrict HospitalRural/Community Hospita... 327708.324530 \n", - "35 ClinicDistrict HospitalRural/Community Hospita... 309435.437644 \n", - "36 ClinicDistrict HospitalRural/Community Hospita... 320279.427886 \n", - "37 ClinicDistrict HospitalRural/Community Hospita... 330832.389669 \n", - "38 ClinicDistrict HospitalRural/Community Hospita... 435362.126119 \n", - "39 ClinicDistrict HospitalRural/Community Hospita... 304940.147499 \n", - "40 ClinicDistrict HospitalRural/Community Hospita... 353974.887443 \n", - "41 ClinicDistrict HospitalRural/Community Hospita... 295464.487169 \n", - "42 ClinicDistrict HospitalRural/Community Hospita... 297221.496710 \n", - "43 ClinicDistrict HospitalRural/Community Hospita... 409016.019784 \n", - "44 ClinicDistrict HospitalRural/Community Hospita... 420878.539429 \n", - "45 ClinicDistrict HospitalRural/Community Hospita... 405718.142702 \n", + "0 ClinicDistrict HospitalRural/Community Hospita... 377371.401757 \n", + "1 ClinicDistrict HospitalRural/Community Hospita... 424179.161524 \n", + "2 ClinicDistrict HospitalRural/Community Hospita... 416785.291442 \n", + "3 ClinicDistrict HospitalRural/Community Hospita... 431174.255009 \n", + "4 ClinicDistrict HospitalRural/Community Hospita... 405743.410420 \n", + "5 ClinicDistrict HospitalRural/Community Hospita... 410793.849551 \n", + "6 ClinicDistrict HospitalRural/Community Hospita... 430219.873937 \n", + "7 ClinicDistrict HospitalRural/Community Hospita... 332427.056762 \n", + "8 ClinicDistrict HospitalRural/Community Hospita... 392896.036283 \n", + "9 ClinicDistrict HospitalRural/Community Hospita... 409775.392632 \n", + "10 ClinicDistrict HospitalRural/Community Hospita... 410851.208278 \n", + "11 ClinicDistrict HospitalRural/Community Hospita... 456535.963741 \n", + "12 ClinicDistrict HospitalRural/Community Hospita... 452334.398335 \n", + "13 ClinicDistrict HospitalRural/Community Hospita... 329049.810569 \n", + "14 ClinicDistrict HospitalRural/Community Hospita... 414644.190834 \n", + "15 ClinicDistrict HospitalRural/Community Hospita... 392121.029719 \n", + "16 ClinicDistrict HospitalRural/Community Hospita... 380754.054252 \n", + "17 ClinicDistrict HospitalRural/Community Hospita... 296596.215293 \n", + "18 ClinicDistrict HospitalRural/Community Hospita... 423715.504984 \n", + "19 ClinicDistrict HospitalRural/Community Hospita... 368319.084368 \n", + "20 ClinicDistrict HospitalRural/Community Hospita... 418134.051457 \n", + "21 ClinicDistrict HospitalRural/Community Hospita... 380622.271982 \n", + "22 ClinicDistrict HospitalRural/Community Hospita... 388922.127329 \n", + "23 ClinicDistrict HospitalRural/Community Hospita... 373888.999201 \n", + "24 ClinicDistrict HospitalRural/Community Hospita... 403081.277311 \n", + "25 ClinicDistrict HospitalRural/Community Hospita... 377526.089751 \n", + "26 ClinicDistrict HospitalRural/Community Hospita... 312891.203066 \n", + "27 ClinicDistrict HospitalRural/Community Hospita... 383090.314471 \n", + "28 ClinicDistrict HospitalRural/Community Hospita... 370916.909122 \n", + "29 ClinicDistrict HospitalRural/Community Hospita... 358979.193679 \n", + "30 ClinicDistrict HospitalRural/Community Hospita... 411059.228901 \n", + "31 ClinicDistrict HospitalRural/Community Hospita... 457632.022035 \n", + "32 ClinicDistrict HospitalRural/Community Hospita... 366158.628623 \n", + "33 ClinicDistrict HospitalRural/Community Hospita... 414749.367352 \n", + "34 ClinicDistrict HospitalRural/Community Hospita... 394182.173776 \n", + "35 ClinicDistrict HospitalRural/Community Hospita... 412930.274807 \n", + "36 ClinicDistrict HospitalRural/Community Hospita... 350708.805302 \n", + "37 ClinicDistrict HospitalRural/Community Hospita... 293182.399170 \n", + "38 ClinicDistrict HospitalRural/Community Hospita... 377478.093086 \n", + "39 ClinicDistrict HospitalRural/Community Hospita... 291362.431282 \n", + "40 ClinicDistrict HospitalRural/Community Hospita... 368970.926878 \n", + "41 ClinicDistrict HospitalRural/Community Hospita... 397265.484764 \n", + "42 ClinicDistrict HospitalRural/Community Hospita... 327967.298680 \n", + "43 ClinicDistrict HospitalRural/Community Hospita... 315778.193228 \n", + "44 ClinicDistrict HospitalRural/Community Hospita... 342508.889264 \n", + "45 ClinicDistrict HospitalRural/Community Hospita... 369080.727151 \n", "\n", " Lag_1_Precipitation Lag_2_Precipitation Lag_3_Precipitation \\\n", - "0 390008.338639 385074.053901 383551.519335 \n", - "1 324216.805408 351108.236956 352944.118983 \n", - "2 351903.960266 349493.164255 344770.234996 \n", - "3 379492.789825 375543.857029 381029.229862 \n", - "4 375481.180687 385373.062799 381129.073629 \n", - "5 311938.841921 285932.285061 289579.937651 \n", - "6 433698.584038 455288.388297 455102.702313 \n", - "7 315844.250082 324314.368396 316195.532608 \n", - "8 371283.829234 345593.426372 354934.926046 \n", - "9 399207.341834 400410.349670 392246.728746 \n", - "10 341985.164411 327819.997189 330789.556355 \n", - "11 398497.779822 408894.912655 378604.565588 \n", - "12 348875.547726 360367.235995 389923.203199 \n", - "13 370981.253838 381170.945543 378471.104964 \n", - "14 394083.987840 401617.097706 408341.613660 \n", - "15 344469.424679 340683.245254 342518.356804 \n", - "16 331135.927791 335947.246630 335248.047067 \n", - "17 328321.508621 302510.901036 300226.263604 \n", - "18 252246.251731 271260.885375 274124.334082 \n", - "19 410050.158172 387974.439450 387736.897200 \n", - "20 369108.855991 362046.586240 342819.132014 \n", - "21 482869.984890 480685.090489 500151.794189 \n", - "22 419334.638122 449504.867423 447116.625283 \n", - "23 317922.916948 310749.912224 313141.518581 \n", - "24 325481.247456 336295.941280 330700.546457 \n", - "25 502910.647286 435891.016355 437939.836711 \n", - "26 325017.559932 392209.231985 393915.875687 \n", - "27 355003.796484 335224.704315 335946.670289 \n", - "28 360724.744731 376450.353321 368811.709372 \n", - "29 329764.214376 325974.066284 334512.344383 \n", - "30 331417.631119 333207.967531 331162.787180 \n", - "31 265016.427098 267520.943494 269888.025290 \n", - "32 457908.115607 448849.771066 446651.780946 \n", - "33 278375.606401 291501.477315 289945.485496 \n", - "34 318063.470421 302154.611762 306083.376401 \n", - "35 327543.125082 336866.204386 331980.842360 \n", - "36 330945.691553 322432.738606 318079.159985 \n", - "37 285321.675202 301954.830856 310662.088357 \n", - "38 433776.704399 419118.260070 404772.957169 \n", - "39 317030.377297 304945.762400 319651.502857 \n", - "40 329874.956467 337015.684029 328940.852077 \n", - "41 354202.699889 365879.087584 373323.111876 \n", - "42 272255.281494 280888.319603 281510.797522 \n", - "43 378752.521246 360679.750486 359521.705424 \n", - "44 445824.370857 462306.136722 461148.128688 \n", - "45 364719.332490 323443.731437 324834.166014 \n", + "0 398942.636170 404727.057797 405704.571665 \n", + "1 413397.817913 388309.667883 385397.116828 \n", + "2 407187.589904 420216.307417 421615.911783 \n", + "3 406189.704606 403165.981005 401105.177547 \n", + "4 420471.214026 421450.033447 424520.950185 \n", + "5 410824.557725 391493.761671 388196.210212 \n", + "6 432044.900550 456751.262273 456752.721138 \n", + "7 348112.188236 353270.524412 357410.845800 \n", + "8 405019.687496 388565.288508 388245.552346 \n", + "9 372460.875926 375124.877747 371846.112765 \n", + "10 408169.132145 406485.011941 407092.899084 \n", + "11 451325.020396 433158.134992 433133.983599 \n", + "12 481501.033891 524791.840222 527391.207421 \n", + "13 339513.871817 320576.954584 319333.523933 \n", + "14 392029.707764 393257.108114 394526.442838 \n", + "15 371789.329465 387244.681484 386630.546157 \n", + "16 440952.201046 424662.364695 425051.043775 \n", + "17 286935.705860 311049.994112 312185.510318 \n", + "18 392470.951022 356521.858749 353794.312578 \n", + "19 394609.621848 426205.552210 424729.506080 \n", + "20 414178.271428 393702.776056 395566.258413 \n", + "21 385122.990507 393876.211485 395324.082930 \n", + "22 374058.228036 360407.393814 361159.265562 \n", + "23 367702.143527 383792.892262 381569.846621 \n", + "24 406359.400288 413379.564221 402964.624861 \n", + "25 362825.700917 354087.658823 342715.089184 \n", + "26 358797.936758 363399.872412 387024.433983 \n", + "27 375109.947590 372857.980106 358164.961912 \n", + "28 367650.235635 359381.996323 367921.786733 \n", + "29 363845.441546 357419.463077 345612.633741 \n", + "30 398093.244924 420338.093431 427216.475603 \n", + "31 460331.584266 421106.585969 427549.155747 \n", + "32 355110.662118 385804.286252 377495.302483 \n", + "33 404952.222454 380148.672904 390887.435379 \n", + "34 405715.733698 429608.759456 429014.390163 \n", + "35 409799.355286 410974.276816 413298.745816 \n", + "36 353761.775712 344252.932147 343209.200439 \n", + "37 325069.624722 344289.047467 342084.186261 \n", + "38 353257.222779 353764.890202 357823.798670 \n", + "39 302326.827366 304020.083180 303828.779931 \n", + "40 368964.162462 357775.533341 356652.040920 \n", + "41 323346.039126 322784.762289 316952.269236 \n", + "42 383625.207672 394279.969633 398120.412976 \n", + "43 360494.854893 356119.648704 357486.445092 \n", + "44 323961.673652 331898.505904 332841.894862 \n", + "45 347439.884447 315453.846359 311453.513947 \n", "\n", " Lag_4_Precipitation Predicted_Weather_Model Predicted_No_Weather_Model \\\n", - "0 382881.752808 453186.019359 452178.159027 \n", - "1 353891.586301 448903.391472 451324.318689 \n", - "2 345157.532117 450203.526071 450472.090644 \n", - "3 379415.048009 446538.199648 449621.471846 \n", - "4 382864.345741 446948.806790 448772.459257 \n", - "5 289345.079079 445167.350051 447925.049844 \n", - "6 455034.373344 443225.944431 447079.240580 \n", - "7 314871.921748 445182.353097 446235.028444 \n", - "8 356543.998012 444463.766354 445392.410418 \n", - "9 391937.348081 443436.073774 444551.383494 \n", - "10 329650.101725 441556.996446 443711.944667 \n", - "11 379596.718666 443325.455792 442874.090938 \n", - "12 389558.939179 440375.155656 442037.819314 \n", - "13 377682.655534 441294.684850 441203.126808 \n", - "14 409745.578729 442671.748454 440370.010437 \n", - "15 341977.330400 437801.561953 439538.467226 \n", - "16 335789.435760 435274.468592 438708.494203 \n", - "17 296296.047432 437029.478846 437880.088405 \n", - "18 278184.608227 434377.435798 437053.246871 \n", - "19 387661.416146 434394.568891 436227.966648 \n", - "20 340516.424995 434086.915088 435404.244787 \n", - "21 502277.800794 434927.534834 434582.078347 \n", - "22 445805.292269 435351.610440 433761.464389 \n", - "23 313923.715557 430707.116763 432942.399983 \n", - "24 330244.876504 430982.665089 432124.882203 \n", - "25 438231.552425 428731.420008 431308.908127 \n", - "26 393957.931607 430192.671905 430494.474841 \n", - "27 336884.175544 427640.316088 429681.579436 \n", - "28 365595.615071 427806.610028 428870.219007 \n", - "29 337541.046047 425278.010843 428060.390657 \n", - "30 331449.273326 426811.173251 427252.091491 \n", - "31 269433.014822 425621.733459 426445.318624 \n", - "32 445524.032754 424963.149920 425640.069171 \n", - "33 291038.100935 423293.012832 424836.340258 \n", - "34 305678.254498 422200.602069 424034.129012 \n", - "35 330169.889911 421642.817151 423233.432568 \n", - "36 317973.894415 422645.018611 422434.248066 \n", - "37 312810.479228 421026.188284 421636.572650 \n", - "38 405190.542219 419003.352104 420840.403471 \n", - "39 319575.723877 419156.256610 420045.737685 \n", - "40 329238.343810 418797.992003 419252.572452 \n", - "41 372541.004296 418424.138509 418460.904941 \n", - "42 281840.507716 417481.752292 417670.732321 \n", - "43 359548.833442 414833.508183 416882.051771 \n", - "44 461552.424105 415995.972386 416094.860473 \n", - "45 323233.055405 412944.024703 415309.155615 \n", + "0 404895.268433 450413.811572 452178.159027 \n", + "1 386621.761142 449805.162811 451324.318689 \n", + "2 421535.968891 448780.570788 450472.090644 \n", + "3 400973.159779 446657.461648 449621.471846 \n", + "4 419592.912552 447811.134508 448772.459257 \n", + "5 391638.197677 447111.614783 447925.049844 \n", + "6 456824.623648 448389.823951 447079.240580 \n", + "7 357753.146752 443503.204711 446235.028444 \n", + "8 388673.117569 445468.831800 445392.410418 \n", + "9 373019.671935 441550.545941 444551.383494 \n", + "10 406919.996712 442181.994730 443711.944667 \n", + "11 432861.285260 439591.654817 442874.090938 \n", + "12 527784.234663 437890.108389 442037.819314 \n", + "13 318825.960831 440318.995534 441203.126808 \n", + "14 394260.244027 442379.145149 440370.010437 \n", + "15 387202.538290 438585.581628 439538.467226 \n", + "16 423444.969850 439207.738143 438708.494203 \n", + "17 313717.825313 436501.827701 437880.088405 \n", + "18 353491.313705 435213.523261 437053.246871 \n", + "19 424904.453286 433980.084304 436227.966648 \n", + "20 394030.949034 436281.073753 435404.244787 \n", + "21 396757.245029 434232.446019 434582.078347 \n", + "22 357396.518341 431881.487367 433761.464389 \n", + "23 384605.158226 431705.820487 432942.399983 \n", + "24 402279.134778 429946.439795 432124.882203 \n", + "25 343650.740769 430370.073359 431308.908127 \n", + "26 387553.261741 431264.483456 430494.474841 \n", + "27 357983.056662 427120.049100 429681.579436 \n", + "28 368369.784160 428888.240001 428870.219007 \n", + "29 345685.373340 427162.001628 428060.390657 \n", + "30 426320.093861 424371.134246 427252.091491 \n", + "31 427585.588743 429015.574874 426445.318624 \n", + "32 376728.920725 424851.189902 425640.069171 \n", + "33 392238.633130 424630.686008 424836.340258 \n", + "34 428209.211053 421981.174732 424034.129012 \n", + "35 414461.110789 422383.644429 423233.432568 \n", + "36 343006.625602 421716.445639 422434.248066 \n", + "37 342232.642746 419713.526935 421636.572650 \n", + "38 357126.722312 419519.270457 420840.403471 \n", + "39 303106.289335 418301.255283 420045.737685 \n", + "40 355879.690701 417565.319731 419252.572452 \n", + "41 316486.677194 418492.789945 418460.904941 \n", + "42 400442.667319 416393.707279 417670.732321 \n", + "43 357120.223981 417560.781784 416882.051771 \n", + "44 333370.975675 414846.238601 416094.860473 \n", + "45 310691.844984 413085.183289 415309.155615 \n", "\n", " Difference_in_Expectation Percentage_Difference \n", - "0 1007.860332 0.002229 \n", - "1 -2420.927217 -0.005364 \n", - "2 -268.564573 -0.000596 \n", - "3 -3083.272198 -0.006857 \n", - "4 -1823.652467 -0.004064 \n", - "5 -2757.699793 -0.006157 \n", - "6 -3853.296150 -0.008619 \n", - "7 -1052.675347 -0.002359 \n", - "8 -928.644064 -0.002085 \n", - "9 -1115.309720 -0.002509 \n", - "10 -2154.948222 -0.004857 \n", - "11 451.364853 0.001019 \n", - "12 -1662.663659 -0.003761 \n", - "13 91.558042 0.000208 \n", - "14 2301.738017 0.005227 \n", - "15 -1736.905273 -0.003952 \n", - "16 -3434.025611 -0.007828 \n", - "17 -850.609558 -0.001943 \n", - "18 -2675.811073 -0.006122 \n", - "19 -1833.397757 -0.004203 \n", - "20 -1317.329699 -0.003026 \n", - "21 345.456487 0.000795 \n", - "22 1590.146050 0.003666 \n", - "23 -2235.283220 -0.005163 \n", - "24 -1142.217114 -0.002643 \n", - "25 -2577.488119 -0.005976 \n", - "26 -301.802936 -0.000701 \n", - "27 -2041.263348 -0.004751 \n", - "28 -1063.608979 -0.002480 \n", - "29 -2782.379814 -0.006500 \n", - "30 -440.918241 -0.001032 \n", - "31 -823.585164 -0.001931 \n", - "32 -676.919251 -0.001590 \n", - "33 -1543.327426 -0.003633 \n", - "34 -1833.526943 -0.004324 \n", - "35 -1590.615417 -0.003758 \n", - "36 210.770545 0.000499 \n", - "37 -610.384366 -0.001448 \n", - "38 -1837.051367 -0.004365 \n", - "39 -889.481075 -0.002118 \n", - "40 -454.580449 -0.001084 \n", - "41 -36.766432 -0.000088 \n", - "42 -188.980029 -0.000452 \n", - "43 -2048.543588 -0.004914 \n", - "44 -98.888087 -0.000238 \n", - "45 -2365.130912 -0.005695 " + "0 -1764.347455 -0.003902 \n", + "1 -1519.155878 -0.003366 \n", + "2 -1691.519856 -0.003755 \n", + "3 -2964.010197 -0.006592 \n", + "4 -961.324749 -0.002142 \n", + "5 -813.435061 -0.001816 \n", + "6 1310.583371 0.002931 \n", + "7 -2731.823733 -0.006122 \n", + "8 76.421382 0.000172 \n", + "9 -3000.837553 -0.006750 \n", + "10 -1529.949937 -0.003448 \n", + "11 -3282.436122 -0.007412 \n", + "12 -4147.710925 -0.009383 \n", + "13 -884.131274 -0.002004 \n", + "14 2009.134712 0.004562 \n", + "15 -952.885598 -0.002168 \n", + "16 499.243940 0.001138 \n", + "17 -1378.260704 -0.003148 \n", + "18 -1839.723610 -0.004209 \n", + "19 -2247.882344 -0.005153 \n", + "20 876.828966 0.002014 \n", + "21 -349.632328 -0.000805 \n", + "22 -1879.977022 -0.004334 \n", + "23 -1236.579496 -0.002856 \n", + "24 -2178.442408 -0.005041 \n", + "25 -938.834768 -0.002177 \n", + "26 770.008615 0.001789 \n", + "27 -2561.530336 -0.005961 \n", + "28 18.020994 0.000042 \n", + "29 -898.389029 -0.002099 \n", + "30 -2880.957246 -0.006743 \n", + "31 2570.256250 0.006027 \n", + "32 -788.879269 -0.001853 \n", + "33 -205.654250 -0.000484 \n", + "34 -2052.954280 -0.004841 \n", + "35 -849.788140 -0.002008 \n", + "36 -717.802427 -0.001699 \n", + "37 -1923.045715 -0.004561 \n", + "38 -1321.133014 -0.003139 \n", + "39 -1744.482402 -0.004153 \n", + "40 -1687.252721 -0.004024 \n", + "41 31.885004 0.000076 \n", + "42 -1277.025042 -0.003057 \n", + "43 678.730014 0.001628 \n", + "44 -1248.621872 -0.003001 \n", + "45 -2223.972326 -0.005355 " ], "text/html": [ "
\n", @@ -2144,15 +2142,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 370655.578345\n", - " 390008.338639\n", - " 385074.053901\n", - " 383551.519335\n", - " 382881.752808\n", - " 453186.019359\n", + " 377371.401757\n", + " 398942.636170\n", + " 404727.057797\n", + " 405704.571665\n", + " 404895.268433\n", + " 450413.811572\n", " 452178.159027\n", - " 1007.860332\n", - " 0.002229\n", + " -1764.347455\n", + " -0.003902\n", " \n", " \n", " 1\n", @@ -2165,15 +2163,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 305845.723518\n", - " 324216.805408\n", - " 351108.236956\n", - " 352944.118983\n", - " 353891.586301\n", - " 448903.391472\n", + " 424179.161524\n", + " 413397.817913\n", + " 388309.667883\n", + " 385397.116828\n", + " 386621.761142\n", + " 449805.162811\n", " 451324.318689\n", - " -2420.927217\n", - " -0.005364\n", + " -1519.155878\n", + " -0.003366\n", " \n", " \n", " 2\n", @@ -2186,15 +2184,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 380236.133055\n", - " 351903.960266\n", - " 349493.164255\n", - " 344770.234996\n", - " 345157.532117\n", - " 450203.526071\n", + " 416785.291442\n", + " 407187.589904\n", + " 420216.307417\n", + " 421615.911783\n", + " 421535.968891\n", + " 448780.570788\n", " 450472.090644\n", - " -268.564573\n", - " -0.000596\n", + " -1691.519856\n", + " -0.003755\n", " \n", " \n", " 3\n", @@ -2207,15 +2205,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 396234.125976\n", - " 379492.789825\n", - " 375543.857029\n", - " 381029.229862\n", - " 379415.048009\n", - " 446538.199648\n", + " 431174.255009\n", + " 406189.704606\n", + " 403165.981005\n", + " 401105.177547\n", + " 400973.159779\n", + " 446657.461648\n", " 449621.471846\n", - " -3083.272198\n", - " -0.006857\n", + " -2964.010197\n", + " -0.006592\n", " \n", " \n", " 4\n", @@ -2228,15 +2226,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 317163.607434\n", - " 375481.180687\n", - " 385373.062799\n", - " 381129.073629\n", - " 382864.345741\n", - " 446948.806790\n", + " 405743.410420\n", + " 420471.214026\n", + " 421450.033447\n", + " 424520.950185\n", + " 419592.912552\n", + " 447811.134508\n", " 448772.459257\n", - " -1823.652467\n", - " -0.004064\n", + " -961.324749\n", + " -0.002142\n", " \n", " \n", " 5\n", @@ -2249,15 +2247,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 385409.189618\n", - " 311938.841921\n", - " 285932.285061\n", - " 289579.937651\n", - " 289345.079079\n", - " 445167.350051\n", + " 410793.849551\n", + " 410824.557725\n", + " 391493.761671\n", + " 388196.210212\n", + " 391638.197677\n", + " 447111.614783\n", " 447925.049844\n", - " -2757.699793\n", - " -0.006157\n", + " -813.435061\n", + " -0.001816\n", " \n", " \n", " 6\n", @@ -2270,15 +2268,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 406289.858606\n", - " 433698.584038\n", - " 455288.388297\n", - " 455102.702313\n", - " 455034.373344\n", - " 443225.944431\n", + " 430219.873937\n", + " 432044.900550\n", + " 456751.262273\n", + " 456752.721138\n", + " 456824.623648\n", + " 448389.823951\n", " 447079.240580\n", - " -3853.296150\n", - " -0.008619\n", + " 1310.583371\n", + " 0.002931\n", " \n", " \n", " 7\n", @@ -2291,15 +2289,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 333604.956760\n", - " 315844.250082\n", - " 324314.368396\n", - " 316195.532608\n", - " 314871.921748\n", - " 445182.353097\n", + " 332427.056762\n", + " 348112.188236\n", + " 353270.524412\n", + " 357410.845800\n", + " 357753.146752\n", + " 443503.204711\n", " 446235.028444\n", - " -1052.675347\n", - " -0.002359\n", + " -2731.823733\n", + " -0.006122\n", " \n", " \n", " 8\n", @@ -2312,15 +2310,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 322006.856259\n", - " 371283.829234\n", - " 345593.426372\n", - " 354934.926046\n", - " 356543.998012\n", - " 444463.766354\n", + " 392896.036283\n", + " 405019.687496\n", + " 388565.288508\n", + " 388245.552346\n", + " 388673.117569\n", + " 445468.831800\n", " 445392.410418\n", - " -928.644064\n", - " -0.002085\n", + " 76.421382\n", + " 0.000172\n", " \n", " \n", " 9\n", @@ -2333,15 +2331,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 391560.967791\n", - " 399207.341834\n", - " 400410.349670\n", - " 392246.728746\n", - " 391937.348081\n", - " 443436.073774\n", + " 409775.392632\n", + " 372460.875926\n", + " 375124.877747\n", + " 371846.112765\n", + " 373019.671935\n", + " 441550.545941\n", " 444551.383494\n", - " -1115.309720\n", - " -0.002509\n", + " -3000.837553\n", + " -0.006750\n", " \n", " \n", " 10\n", @@ -2354,15 +2352,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 367661.767185\n", - " 341985.164411\n", - " 327819.997189\n", - " 330789.556355\n", - " 329650.101725\n", - " 441556.996446\n", + " 410851.208278\n", + " 408169.132145\n", + " 406485.011941\n", + " 407092.899084\n", + " 406919.996712\n", + " 442181.994730\n", " 443711.944667\n", - " -2154.948222\n", - " -0.004857\n", + " -1529.949937\n", + " -0.003448\n", " \n", " \n", " 11\n", @@ -2375,15 +2373,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 378095.303002\n", - " 398497.779822\n", - " 408894.912655\n", - " 378604.565588\n", - " 379596.718666\n", - " 443325.455792\n", + " 456535.963741\n", + " 451325.020396\n", + " 433158.134992\n", + " 433133.983599\n", + " 432861.285260\n", + " 439591.654817\n", " 442874.090938\n", - " 451.364853\n", - " 0.001019\n", + " -3282.436122\n", + " -0.007412\n", " \n", " \n", " 12\n", @@ -2396,15 +2394,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 374197.949271\n", - " 348875.547726\n", - " 360367.235995\n", - " 389923.203199\n", - " 389558.939179\n", - " 440375.155656\n", + " 452334.398335\n", + " 481501.033891\n", + " 524791.840222\n", + " 527391.207421\n", + " 527784.234663\n", + " 437890.108389\n", " 442037.819314\n", - " -1662.663659\n", - " -0.003761\n", + " -4147.710925\n", + " -0.009383\n", " \n", " \n", " 13\n", @@ -2417,15 +2415,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 374291.695816\n", - " 370981.253838\n", - " 381170.945543\n", - " 378471.104964\n", - " 377682.655534\n", - " 441294.684850\n", + " 329049.810569\n", + " 339513.871817\n", + " 320576.954584\n", + " 319333.523933\n", + " 318825.960831\n", + " 440318.995534\n", " 441203.126808\n", - " 91.558042\n", - " 0.000208\n", + " -884.131274\n", + " -0.002004\n", " \n", " \n", " 14\n", @@ -2438,15 +2436,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 398962.867137\n", - " 394083.987840\n", - " 401617.097706\n", - " 408341.613660\n", - " 409745.578729\n", - " 442671.748454\n", + " 414644.190834\n", + " 392029.707764\n", + " 393257.108114\n", + " 394526.442838\n", + " 394260.244027\n", + " 442379.145149\n", " 440370.010437\n", - " 2301.738017\n", - " 0.005227\n", + " 2009.134712\n", + " 0.004562\n", " \n", " \n", " 15\n", @@ -2459,15 +2457,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 329938.705708\n", - " 344469.424679\n", - " 340683.245254\n", - " 342518.356804\n", - " 341977.330400\n", - " 437801.561953\n", + " 392121.029719\n", + " 371789.329465\n", + " 387244.681484\n", + " 386630.546157\n", + " 387202.538290\n", + " 438585.581628\n", " 439538.467226\n", - " -1736.905273\n", - " -0.003952\n", + " -952.885598\n", + " -0.002168\n", " \n", " \n", " 16\n", @@ -2480,15 +2478,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 349982.489824\n", - " 331135.927791\n", - " 335947.246630\n", - " 335248.047067\n", - " 335789.435760\n", - " 435274.468592\n", + " 380754.054252\n", + " 440952.201046\n", + " 424662.364695\n", + " 425051.043775\n", + " 423444.969850\n", + " 439207.738143\n", " 438708.494203\n", - " -3434.025611\n", - " -0.007828\n", + " 499.243940\n", + " 0.001138\n", " \n", " \n", " 17\n", @@ -2501,15 +2499,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 265019.061881\n", - " 328321.508621\n", - " 302510.901036\n", - " 300226.263604\n", - " 296296.047432\n", - " 437029.478846\n", + " 296596.215293\n", + " 286935.705860\n", + " 311049.994112\n", + " 312185.510318\n", + " 313717.825313\n", + " 436501.827701\n", " 437880.088405\n", - " -850.609558\n", - " -0.001943\n", + " -1378.260704\n", + " -0.003148\n", " \n", " \n", " 18\n", @@ -2522,15 +2520,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 317116.288589\n", - " 252246.251731\n", - " 271260.885375\n", - " 274124.334082\n", - " 278184.608227\n", - " 434377.435798\n", + " 423715.504984\n", + " 392470.951022\n", + " 356521.858749\n", + " 353794.312578\n", + " 353491.313705\n", + " 435213.523261\n", " 437053.246871\n", - " -2675.811073\n", - " -0.006122\n", + " -1839.723610\n", + " -0.004209\n", " \n", " \n", " 19\n", @@ -2543,15 +2541,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 358615.638348\n", - " 410050.158172\n", - " 387974.439450\n", - " 387736.897200\n", - " 387661.416146\n", - " 434394.568891\n", + " 368319.084368\n", + " 394609.621848\n", + " 426205.552210\n", + " 424729.506080\n", + " 424904.453286\n", + " 433980.084304\n", " 436227.966648\n", - " -1833.397757\n", - " -0.004203\n", + " -2247.882344\n", + " -0.005153\n", " \n", " \n", " 20\n", @@ -2564,15 +2562,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 441360.716573\n", - " 369108.855991\n", - " 362046.586240\n", - " 342819.132014\n", - " 340516.424995\n", - " 434086.915088\n", + " 418134.051457\n", + " 414178.271428\n", + " 393702.776056\n", + " 395566.258413\n", + " 394030.949034\n", + " 436281.073753\n", " 435404.244787\n", - " -1317.329699\n", - " -0.003026\n", + " 876.828966\n", + " 0.002014\n", " \n", " \n", " 21\n", @@ -2585,15 +2583,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 485128.815221\n", - " 482869.984890\n", - " 480685.090489\n", - " 500151.794189\n", - " 502277.800794\n", - " 434927.534834\n", + " 380622.271982\n", + " 385122.990507\n", + " 393876.211485\n", + " 395324.082930\n", + " 396757.245029\n", + " 434232.446019\n", " 434582.078347\n", - " 345.456487\n", - " 0.000795\n", + " -349.632328\n", + " -0.000805\n", " \n", " \n", " 22\n", @@ -2606,15 +2604,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 339348.499913\n", - " 419334.638122\n", - " 449504.867423\n", - " 447116.625283\n", - " 445805.292269\n", - " 435351.610440\n", + " 388922.127329\n", + " 374058.228036\n", + " 360407.393814\n", + " 361159.265562\n", + " 357396.518341\n", + " 431881.487367\n", " 433761.464389\n", - " 1590.146050\n", - " 0.003666\n", + " -1879.977022\n", + " -0.004334\n", " \n", " \n", " 23\n", @@ -2627,15 +2625,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 353296.312971\n", - " 317922.916948\n", - " 310749.912224\n", - " 313141.518581\n", - " 313923.715557\n", - " 430707.116763\n", + " 373888.999201\n", + " 367702.143527\n", + " 383792.892262\n", + " 381569.846621\n", + " 384605.158226\n", + " 431705.820487\n", " 432942.399983\n", - " -2235.283220\n", - " -0.005163\n", + " -1236.579496\n", + " -0.002856\n", " \n", " \n", " 24\n", @@ -2648,15 +2646,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 333745.253478\n", - " 325481.247456\n", - " 336295.941280\n", - " 330700.546457\n", - " 330244.876504\n", - " 430982.665089\n", + " 403081.277311\n", + " 406359.400288\n", + " 413379.564221\n", + " 402964.624861\n", + " 402279.134778\n", + " 429946.439795\n", " 432124.882203\n", - " -1142.217114\n", - " -0.002643\n", + " -2178.442408\n", + " -0.005041\n", " \n", " \n", " 25\n", @@ -2669,15 +2667,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 513923.146927\n", - " 502910.647286\n", - " 435891.016355\n", - " 437939.836711\n", - " 438231.552425\n", - " 428731.420008\n", + " 377526.089751\n", + " 362825.700917\n", + " 354087.658823\n", + " 342715.089184\n", + " 343650.740769\n", + " 430370.073359\n", " 431308.908127\n", - " -2577.488119\n", - " -0.005976\n", + " -938.834768\n", + " -0.002177\n", " \n", " \n", " 26\n", @@ -2690,15 +2688,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 271825.288644\n", - " 325017.559932\n", - " 392209.231985\n", - " 393915.875687\n", - " 393957.931607\n", - " 430192.671905\n", + " 312891.203066\n", + " 358797.936758\n", + " 363399.872412\n", + " 387024.433983\n", + " 387553.261741\n", + " 431264.483456\n", " 430494.474841\n", - " -301.802936\n", - " -0.000701\n", + " 770.008615\n", + " 0.001789\n", " \n", " \n", " 27\n", @@ -2711,15 +2709,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 365895.719222\n", - " 355003.796484\n", - " 335224.704315\n", - " 335946.670289\n", - " 336884.175544\n", - " 427640.316088\n", + " 383090.314471\n", + " 375109.947590\n", + " 372857.980106\n", + " 358164.961912\n", + " 357983.056662\n", + " 427120.049100\n", " 429681.579436\n", - " -2041.263348\n", - " -0.004751\n", + " -2561.530336\n", + " -0.005961\n", " \n", " \n", " 28\n", @@ -2732,15 +2730,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 325208.687060\n", - " 360724.744731\n", - " 376450.353321\n", - " 368811.709372\n", - " 365595.615071\n", - " 427806.610028\n", + " 370916.909122\n", + " 367650.235635\n", + " 359381.996323\n", + " 367921.786733\n", + " 368369.784160\n", + " 428888.240001\n", " 428870.219007\n", - " -1063.608979\n", - " -0.002480\n", + " 18.020994\n", + " 0.000042\n", " \n", " \n", " 29\n", @@ -2753,15 +2751,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 382143.812346\n", - " 329764.214376\n", - " 325974.066284\n", - " 334512.344383\n", - " 337541.046047\n", - " 425278.010843\n", + " 358979.193679\n", + " 363845.441546\n", + " 357419.463077\n", + " 345612.633741\n", + " 345685.373340\n", + " 427162.001628\n", " 428060.390657\n", - " -2782.379814\n", - " -0.006500\n", + " -898.389029\n", + " -0.002099\n", " \n", " \n", " 30\n", @@ -2774,15 +2772,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 287994.569053\n", - " 331417.631119\n", - " 333207.967531\n", - " 331162.787180\n", - " 331449.273326\n", - " 426811.173251\n", + " 411059.228901\n", + " 398093.244924\n", + " 420338.093431\n", + " 427216.475603\n", + " 426320.093861\n", + " 424371.134246\n", " 427252.091491\n", - " -440.918241\n", - " -0.001032\n", + " -2880.957246\n", + " -0.006743\n", " \n", " \n", " 31\n", @@ -2795,15 +2793,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 332374.359974\n", - " 265016.427098\n", - " 267520.943494\n", - " 269888.025290\n", - " 269433.014822\n", - " 425621.733459\n", + " 457632.022035\n", + " 460331.584266\n", + " 421106.585969\n", + " 427549.155747\n", + " 427585.588743\n", + " 429015.574874\n", " 426445.318624\n", - " -823.585164\n", - " -0.001931\n", + " 2570.256250\n", + " 0.006027\n", " \n", " \n", " 32\n", @@ -2816,15 +2814,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 392877.314013\n", - " 457908.115607\n", - " 448849.771066\n", - " 446651.780946\n", - " 445524.032754\n", - " 424963.149920\n", + " 366158.628623\n", + " 355110.662118\n", + " 385804.286252\n", + " 377495.302483\n", + " 376728.920725\n", + " 424851.189902\n", " 425640.069171\n", - " -676.919251\n", - " -0.001590\n", + " -788.879269\n", + " -0.001853\n", " \n", " \n", " 33\n", @@ -2837,15 +2835,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 302066.178485\n", - " 278375.606401\n", - " 291501.477315\n", - " 289945.485496\n", - " 291038.100935\n", - " 423293.012832\n", + " 414749.367352\n", + " 404952.222454\n", + " 380148.672904\n", + " 390887.435379\n", + " 392238.633130\n", + " 424630.686008\n", " 424836.340258\n", - " -1543.327426\n", - " -0.003633\n", + " -205.654250\n", + " -0.000484\n", " \n", " \n", " 34\n", @@ -2858,15 +2856,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 327708.324530\n", - " 318063.470421\n", - " 302154.611762\n", - " 306083.376401\n", - " 305678.254498\n", - " 422200.602069\n", + " 394182.173776\n", + " 405715.733698\n", + " 429608.759456\n", + " 429014.390163\n", + " 428209.211053\n", + " 421981.174732\n", " 424034.129012\n", - " -1833.526943\n", - " -0.004324\n", + " -2052.954280\n", + " -0.004841\n", " \n", " \n", " 35\n", @@ -2879,15 +2877,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 309435.437644\n", - " 327543.125082\n", - " 336866.204386\n", - " 331980.842360\n", - " 330169.889911\n", - " 421642.817151\n", + " 412930.274807\n", + " 409799.355286\n", + " 410974.276816\n", + " 413298.745816\n", + " 414461.110789\n", + " 422383.644429\n", " 423233.432568\n", - " -1590.615417\n", - " -0.003758\n", + " -849.788140\n", + " -0.002008\n", " \n", " \n", " 36\n", @@ -2900,15 +2898,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 320279.427886\n", - " 330945.691553\n", - " 322432.738606\n", - " 318079.159985\n", - " 317973.894415\n", - " 422645.018611\n", + " 350708.805302\n", + " 353761.775712\n", + " 344252.932147\n", + " 343209.200439\n", + " 343006.625602\n", + " 421716.445639\n", " 422434.248066\n", - " 210.770545\n", - " 0.000499\n", + " -717.802427\n", + " -0.001699\n", " \n", " \n", " 37\n", @@ -2921,15 +2919,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 330832.389669\n", - " 285321.675202\n", - " 301954.830856\n", - " 310662.088357\n", - " 312810.479228\n", - " 421026.188284\n", + " 293182.399170\n", + " 325069.624722\n", + " 344289.047467\n", + " 342084.186261\n", + " 342232.642746\n", + " 419713.526935\n", " 421636.572650\n", - " -610.384366\n", - " -0.001448\n", + " -1923.045715\n", + " -0.004561\n", " \n", " \n", " 38\n", @@ -2942,15 +2940,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 435362.126119\n", - " 433776.704399\n", - " 419118.260070\n", - " 404772.957169\n", - " 405190.542219\n", - " 419003.352104\n", + " 377478.093086\n", + " 353257.222779\n", + " 353764.890202\n", + " 357823.798670\n", + " 357126.722312\n", + " 419519.270457\n", " 420840.403471\n", - " -1837.051367\n", - " -0.004365\n", + " -1321.133014\n", + " -0.003139\n", " \n", " \n", " 39\n", @@ -2963,15 +2961,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 304940.147499\n", - " 317030.377297\n", - " 304945.762400\n", - " 319651.502857\n", - " 319575.723877\n", - " 419156.256610\n", + " 291362.431282\n", + " 302326.827366\n", + " 304020.083180\n", + " 303828.779931\n", + " 303106.289335\n", + " 418301.255283\n", " 420045.737685\n", - " -889.481075\n", - " -0.002118\n", + " -1744.482402\n", + " -0.004153\n", " \n", " \n", " 40\n", @@ -2984,15 +2982,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 353974.887443\n", - " 329874.956467\n", - " 337015.684029\n", - " 328940.852077\n", - " 329238.343810\n", - " 418797.992003\n", + " 368970.926878\n", + " 368964.162462\n", + " 357775.533341\n", + " 356652.040920\n", + " 355879.690701\n", + " 417565.319731\n", " 419252.572452\n", - " -454.580449\n", - " -0.001084\n", + " -1687.252721\n", + " -0.004024\n", " \n", " \n", " 41\n", @@ -3005,15 +3003,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 295464.487169\n", - " 354202.699889\n", - " 365879.087584\n", - " 373323.111876\n", - " 372541.004296\n", - " 418424.138509\n", + " 397265.484764\n", + " 323346.039126\n", + " 322784.762289\n", + " 316952.269236\n", + " 316486.677194\n", + " 418492.789945\n", " 418460.904941\n", - " -36.766432\n", - " -0.000088\n", + " 31.885004\n", + " 0.000076\n", " \n", " \n", " 42\n", @@ -3026,15 +3024,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 297221.496710\n", - " 272255.281494\n", - " 280888.319603\n", - " 281510.797522\n", - " 281840.507716\n", - " 417481.752292\n", + " 327967.298680\n", + " 383625.207672\n", + " 394279.969633\n", + " 398120.412976\n", + " 400442.667319\n", + " 416393.707279\n", " 417670.732321\n", - " -188.980029\n", - " -0.000452\n", + " -1277.025042\n", + " -0.003057\n", " \n", " \n", " 43\n", @@ -3047,15 +3045,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 409016.019784\n", - " 378752.521246\n", - " 360679.750486\n", - " 359521.705424\n", - " 359548.833442\n", - " 414833.508183\n", + " 315778.193228\n", + " 360494.854893\n", + " 356119.648704\n", + " 357486.445092\n", + " 357120.223981\n", + " 417560.781784\n", " 416882.051771\n", - " -2048.543588\n", - " -0.004914\n", + " 678.730014\n", + " 0.001628\n", " \n", " \n", " 44\n", @@ -3068,15 +3066,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 420878.539429\n", - " 445824.370857\n", - " 462306.136722\n", - " 461148.128688\n", - " 461552.424105\n", - " 415995.972386\n", + " 342508.889264\n", + " 323961.673652\n", + " 331898.505904\n", + " 332841.894862\n", + " 333370.975675\n", + " 414846.238601\n", " 416094.860473\n", - " -98.888087\n", - " -0.000238\n", + " -1248.621872\n", + " -0.003001\n", " \n", " \n", " 45\n", @@ -3089,2068 +3087,254 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 405718.142702\n", - " 364719.332490\n", - " 323443.731437\n", - " 324834.166014\n", - " 323233.055405\n", - " 412944.024703\n", + " 369080.727151\n", + " 347439.884447\n", + " 315453.846359\n", + " 311453.513947\n", + " 310691.844984\n", + " 413085.183289\n", " 415309.155615\n", - " -2365.130912\n", - " -0.005695\n", + " -2223.972326\n", + " -0.005355\n", " \n", " \n", "\n", "
" ] }, - "execution_count": 5, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 5 + "execution_count": 21 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-09T12:05:27.013287Z", + "start_time": "2025-01-09T12:05:24.490284Z" + } + }, + "cell_type": "code", + "source": "X_Data = pd.read_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/X_basis_weather_filtered_predictions_{scenario}_{model_type}.csv')\n", + "id": "23e931c4a52c75e0", + "outputs": [], + "execution_count": 22 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-09T11:44:47.118081Z", - "start_time": "2025-01-09T11:44:44.949435Z" + "end_time": "2025-01-09T12:05:27.018619Z", + "start_time": "2025-01-09T12:05:27.014718Z" } }, "cell_type": "code", "source": [ - "X_Data = pd.read_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/X_basis_weather_filtered_predictions_{scenario}_{model_type}.csv')\n", - "X_Data" + "births_model_subset = births_model.iloc[15:].copy()\n", + "\n", + "matching_rows = min(len(births_model_subset), len(predictions_from_cmip_sum))\n", + "\n", + "multiplied_values = births_model_subset.head(matching_rows).iloc[:, 1].values * predictions_from_cmip_sum['Percentage_Difference'].head(matching_rows).values\n", + "\n", + "births_model_subset['Multiplied_Values'] = multiplied_values" ], - "id": "23e931c4a52c75e0", + "id": "fd6b107fed0933cb", + "outputs": [], + "execution_count": 23 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-09T12:05:29.112472Z", + "start_time": "2025-01-09T12:05:29.017124Z" + } + }, + "cell_type": "code", + "source": [ + "year_range = range(2025, 2061)\n", + "\n", + "plt.plot(year_range, multiplied_values)\n", + "plt.ylabel(\"Change ANC cases due to weather\")\n", + "plt.axhline(y=0, color='black', linestyle='--') " + ], + "id": "c0ed116b28287eaa", "outputs": [ { "data": { "text/plain": [ - " 0 1 2 3 4 5 6 7 8 9 \\\n", - "0 278.839565 104.469566 2025.0 1.0 1.0 1.0 0.0 0.0 0.0 0.0 \n", - "1 314.940604 105.141358 2025.0 2.0 1.0 0.0 0.0 1.0 0.0 0.0 \n", - "2 243.284699 75.971366 2025.0 3.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", - "3 376.344881 171.678366 2025.0 4.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", - "4 310.515664 76.252856 2025.0 5.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", - "... ... ... ... ... ... ... ... ... ... ... \n", - "181051 328.073671 113.592252 2070.0 8.0 0.0 0.0 1.0 0.0 0.0 0.0 \n", - "181052 272.709461 99.514648 2070.0 9.0 0.0 0.0 0.0 1.0 0.0 0.0 \n", - "181053 272.709461 99.514648 2070.0 10.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", - "181054 272.737490 79.155316 2070.0 11.0 0.0 0.0 1.0 0.0 0.0 0.0 \n", - "181055 175.643851 76.903689 2070.0 12.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", - "\n", - " ... 371 372 373 374 375 376 377 378 379 380 \n", - "0 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 1099.0 0.084097 \n", - "1 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 632.0 0.089463 \n", - "2 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 873.0 NaN \n", - "3 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 873.0 NaN \n", - "4 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 873.0 NaN \n", - "... ... ... ... ... ... ... ... ... ... ... ... \n", - "181051 ... 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0 485.0 0.162431 \n", - "181052 ... 0.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 508.0 0.116303 \n", - "181053 ... 0.0 0.0 0.0 0.0 0.0 1.0 0.0 0.0 873.0 NaN \n", - "181054 ... 0.0 0.0 0.0 0.0 0.0 0.0 1.0 0.0 1149.0 0.233156 \n", - "181055 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 1.0 873.0 0.098121 \n", - "\n", - "[181056 rows x 381 columns]" + "" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "
" ], - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
0123456789...371372373374375376377378379380
0278.839565104.4695662025.01.01.01.00.00.00.00.0...0.00.00.00.00.00.00.00.01099.00.084097
1314.940604105.1413582025.02.01.00.00.01.00.00.0...0.00.00.00.00.00.00.00.0632.00.089463
2243.28469975.9713662025.03.00.00.00.00.00.00.0...0.00.00.00.00.00.00.00.0873.0NaN
3376.344881171.6783662025.04.00.00.00.00.00.00.0...0.00.00.00.00.00.00.00.0873.0NaN
4310.51566476.2528562025.05.00.00.00.00.00.00.0...0.00.00.00.00.00.00.00.0873.0NaN
..................................................................
181051328.073671113.5922522070.08.00.00.01.00.00.00.0...0.00.00.01.00.00.00.00.0485.00.162431
181052272.70946199.5146482070.09.00.00.00.01.00.00.0...0.00.00.00.01.00.00.00.0508.00.116303
181053272.70946199.5146482070.010.00.00.00.00.00.00.0...0.00.00.00.00.01.00.00.0873.0NaN
181054272.73749079.1553162070.011.00.00.01.00.00.00.0...0.00.00.00.00.00.01.00.01149.00.233156
181055175.64385176.9036892070.012.00.00.00.00.00.00.0...0.00.00.00.00.00.00.01.0873.00.098121
\n", - "

181056 rows × 381 columns

\n", - "
" + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 24 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-09T12:05:30.143163Z", + "start_time": "2025-01-09T12:05:30.041274Z" + } + }, + "cell_type": "code", + "source": [ + "plt.plot(year_range, predictions_from_cmip_sum.iloc[0:36, -1]*100)\n", + "plt.xlabel(\"Percentage Change in ANC cases due to weather\")\n", + "plt.axhline(y=0, color='black', linestyle='--') " + ], + "id": "55dba29ded951def", + "outputs": [ + { + "data": { + "text/plain": [ + "" ] }, - "execution_count": 6, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi8AAAGwCAYAAABhDIVPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/OQEPoAAAACXBIWXMAAA9hAAAPYQGoP6dpAACdbUlEQVR4nO2deZxT5fX/Pzd7ZsnsKwwM+wwioCAILuCXUZTWra11wYrWolVxKViV1orVKq3aqrVa1KqoP6m27rUWiwguSAFREGQYdhiW2fct6/P7I3meJDNJJsu9Wc/79ZqXkjzJ3Ny5ufdzz/mccyTGGANBEARBEESCoIr1BhAEQRAEQYQCiReCIAiCIBIKEi8EQRAEQSQUJF4IgiAIgkgoSLwQBEEQBJFQkHghCIIgCCKhIPFCEARBEERCoYn1BsiNw+HA8ePHkZmZCUmSYr05BEEQBEEEAWMMnZ2dKC0thUoVOLaSdOLl+PHjKCsri/VmEARBEAQRBrW1tRg6dGjANUknXjIzMwE4P7zJZIrx1hAEQRAEEQwdHR0oKysT1/FAJJ144akik8lE4oUgCIIgEoxgLB9k2CUIgiAIIqEg8UIQBEEQREJB4oUgCIIgiISCxAtBEARBEAkFiReCIAiCIBIKEi8EQRAEQSQUJF4IgiAIgkgoSLwQBEEQBJFQkHghCIIgCCKhIPFCEARBEERCQeKFIAiCIIiEIiri5emnn0Z5eTkMBgOmT5+OzZs3B1zf1taGW265BSUlJdDr9Rg7diw+/PDDaGwqQRAEQRBxjuKDGd944w0sXrwYK1aswPTp0/HEE09g7ty5qKmpQWFh4YD1FosF5557LgoLC/Hmm29iyJAhOHz4MLKzs5XeVIIgCIKQHcYY+qwOGHXqWG9K0iAxxpiSv2D69Ok47bTT8Je//AUA4HA4UFZWhltvvRX33HPPgPUrVqzAo48+it27d0Or1Yb8+zo6OpCVlYX29naaKk0QBEHEnPvf/w5/33wE/7n9LIwsyIj15sQtoVy/FU0bWSwWbN26FVVVVe5fqFKhqqoKGzdu9Pma999/HzNmzMAtt9yCoqIiTJgwAQ8//DDsdrvP9WazGR0dHV4/BEEQBBEvfHW4BWabA98ebY/1piQNioqXpqYm2O12FBUVeT1eVFSEuro6n685cOAA3nzzTdjtdnz44Yf4zW9+gz/+8Y/43e9+53P98uXLkZWVJX7Kyspk/xwEQRAEES49ZufNd0u3JcZbkjzEXbWRw+FAYWEhnnvuOUyZMgWXX345fv3rX2PFihU+1y9duhTt7e3ip7a2NspbTBAEQRD+6bbYAABtPSRe5EJRw25+fj7UajXq6+u9Hq+vr0dxcbHP15SUlECr1UKtdhubKisrUVdXB4vFAp1O57Ver9dDr9fLv/EEQRAEIQM88tLaY43xliQPikZedDodpkyZgrVr14rHHA4H1q5dixkzZvh8zRlnnIF9+/bB4XCIx/bs2YOSkpIBwoUgCIIg4hnGGHqsXLxQ5EUuFE8bLV68GM8//zxefvllVFdX46abbkJ3dzeuu+46AMA111yDpUuXivU33XQTWlpacPvtt2PPnj3497//jYcffhi33HKL0ptKEARBELJitjlgdziLetso8iIbivd5ufzyy9HY2Ij77rsPdXV1mDx5MlavXi1MvEeOHIFK5dZQZWVl+Oijj/CLX/wCEydOxJAhQ3D77bfj7rvvVnpTCYIgCEJWeizuSlky7MqH4n1eog31eSEIgiDihdqWHpz1yDoAQGmWAV8unRPjLYpf4qbPC0EQBEGkMp6RFzLsygeJF4IgCIJQCF4mDQC9Vjv6rL4brhKhQeKFIAiCIBSi1+ItVsi0Kw8kXgiCIAhCIbrNNq9/k2lXHki8EARBEIRC9AyIvJB4kQMSLwRBEAShEJ6eF4BMu3JB4oUgCIIgFIKPBuBQl115IPFCEARBEArRP/JCaSN5IPFCEARBEArR3/PS0k1pIzkg8UIQBEEQCtHjirwYtWoAFHmRCxIvBEEQBKEQ3PMyJMcIgDwvckHihSAIgiAUgntehmRz8UJpIzkg8UIQBEEQCsE9LzzyQmkjeSDxQhAEQRAKwTvs8sgLddiVBxIvBEEQBKEQPPIy1BV56eizwWZ3xHKTkgISLwRBEAShEFy8lLoiLwDQ3ku+l0gh8UIQBEEQCsFLpU0GLTINGgBk2pUDEi8EQRAEoRDdrlLpNJ0auek6AGTalQMSLwRBEAShAHYHQ6/VLV6y05zihUy7kUPihSAIgiAUgAsXAEjXa5CTpgUAtFHaKGJIvBAEQRCEAvS4yqRVEqDXqJDjirxQl93IIfFCEARBEArQ7ao0StdpIEkSsl2RFzLsRg6JF4JIUewORrl3glAQXmmUpncOZcxNI8OuXJB4IYgU5Zf/3I7THvoY+xo6Y70pBJGU9HhEXgAgO50Mu3JB4oUgUpRvattgdzDsPNYR600hiKSEjwYw6pyRFzLsygeJF4JIUZo6zc7/dpljvCUEkZz0j7yQYVc+SLwQRArSZ7Wj03VX2NRFJ1KCUAIeeeGeFzLsygeJF4JIQTyjLRR5IQhl6B958eywyxiL2XYlAyReCCIF8Yy2NJN4IQhF4OIlTXhenOLF5mDockVliPAg8UIQKQj3uwCUNiIIpeCl0ul6Z+TFoFXDoHVedlu7KXUUCSReCCIF8UwVUeSFIJSBD2Xk1UYAmXblgsQLQaQgXp6Xbsq/E4QSiMiLh3jJJvEiC1ERL08//TTKy8thMBgwffp0bN68OajXvf7665AkCZdccomyG0gQKYZnqshic4jKI4Ig5KNbeF404rHcdOr1IgeKi5c33ngDixcvxrJly/D1119j0qRJmDt3LhoaGgK+7tChQ7jzzjtx1llnKb2JBJFyNPZLFTWT74UgZIcPZkzXU+RFbhQXL3/605+wcOFCXHfddRg/fjxWrFiBtLQ0vPjii35fY7fbMX/+fPz2t7/FyJEjld5Egkg5PA27AJVLE4QSdPPZRh6RF95lt5VGBESEouLFYrFg69atqKqqcv9ClQpVVVXYuHGj39c98MADKCwsxPXXXz/o7zCbzejo6PD6IQgiMFysqCTnv8m0SxDy08v7vOh9GXYpbRQJioqXpqYm2O12FBUVeT1eVFSEuro6n6/54osv8MILL+D5558P6ncsX74cWVlZ4qesrCzi7SaIZId7Xsrz0gEAjZQ2IgjZ8eV5obSRPMRVtVFnZyd+8pOf4Pnnn0d+fn5Qr1m6dCna29vFT21trcJbSRCJjcXmQHuv866voiQTAEVeCEIJuOclzatUmgy7cqAZfEn45OfnQ61Wo76+3uvx+vp6FBcXD1i/f/9+HDp0CBdeeKF4zOFwODdUo0FNTQ1GjRrl9Rq9Xg+9Xq/A1hNEctLc7RQqGpWEkfkZAMjzQhBK4CvykpNOkRc5UDTyotPpMGXKFKxdu1Y85nA4sHbtWsyYMWPA+oqKCuzYsQPbtm0TPxdddBHOOeccbNu2jVJCBCEDTZ3Ok2Zehg4FmU7hT9VGBCE/7g67PjwvZNiNCEUjLwCwePFiLFiwAFOnTsW0adPwxBNPoLu7G9dddx0A4JprrsGQIUOwfPlyGAwGTJgwwev12dnZADDgcYIgwoNHWfIz9MjP0Hs9RhCEPFhsDljtzuaPPquNKG0UEYqLl8svvxyNjY247777UFdXh8mTJ2P16tXCxHvkyBGoVHFlvSGIpKbRQ7zkZTjvAinyQhDywiuNAG/PCzfs9lrt6LPaYdCqB7yWGBzFxQsALFq0CIsWLfL53Pr16wO+duXKlfJvEEGkMI2dAyMv/ZvWEQQRGbzHi06jglbtvkE3GTRQqyTYHQxtPVYUZ5F4CQcKeRBEiiHSRpk65LsiL519Npht9kAvIwgiBHosAyuNAECSJI/UEUU8w4XEC0GkGLzHS0GGHllGLTSuTnWUOiII+eATpdN1AxMc2WTajRgSLwSRYjR5pI0kSSLfC0EoQLefyAtApl05IPFCECkGTxvxMmmqOCII+elxRV7S9AEiL5Q2ChsSLwSRYniWSgNAHokXgpAdHnlJDxB5aSPxEjYkXggihbDaHSJUzc26/L9NlDYiCNno9dFdl+Pusktpo3Ah8UIQKUSLyyCoVkmi0yePwNB8I4KQj24fE6U51GU3cki8EEQKwXu85KbroHJVGbkjLyReCEIufA1l5FCpdOSQeCGIFKK/3wUA8tJdkRe6CyQI2fA1lJHjNuxS2ihcSLwQRArBfS082gIA+a6qIx6VIQgicnoCGnad3z8y7IYPiReCSCFEmbRX5MXV54UiLwQhG90BSqVz06nPS6SQeCGIFEI0qMt0ixfe76Wl2wKHg8Vkuwgi2ei1+o+88LRRe68VNrsjqtuVLJB4IYgUwu15caeNeAjb7mBo66U7QYKQAxF58eV5MWrF/7fTdy4sSLwQRArh9ry4Iy86jQpZrpMplUsThDz4G8wIABq1CpkGp6ih1FF4kHghiBTCV7WR89/O6EsjiReCkIVAnheATLuRQuKFUJQN+5rwl0/2kpciTvAnXvJEozo6kRKEHASqNgKoy26k+JaEBCETv35nBw419+CM0fk4ZVhOrDcnpbE7mOiwm5+p83qugOYbEYSsBOrzAng0qqMqv7CgyAuhGDa7A7WtvQBobk480NJtgYMBkgTkpnmLlzxX2ogiLwQhD7zDrq/xAIDHiABKG4UFiRdCMeo6+mB3pYvIUR97eFQlN00Hjdr7q59PkReCkA3GGHqsgSMv2WnU6yUSSLwQinHUFXUBgA4SLzHHn98FcEdeKEJGEJHTZ3WAuWx+g0VeyLAbHiReCMXwFC8UeYk9Qrz087sAFHkhCDnpdpl1AcCgGcywS+IlHEi8EIpxjMRLXNHUObDHC4eXSjd3k3ghiEjpEQ3q1GJ6e39yKG0UESReCMU42toj/p/SRrEnUNpIRF466S6QICKlWzSo81/QKwy7VG0UFiReCMXw8rz0kXiJNY0BPS/Ox3qtdtGfgiCI8BA9Xvz4XQAy7EYKiRdCMY62uSMvlDaKPe7RAAM9L+k6NQxa5+mAoi8EERk9g/R4AbwNu4xRE89QIfFCKILN7sCJtj7xbxIvscfXRGmOJEnIS3eljsj3QhARwUcD+OuuC7jFi83B0GWmaGeokHghFKG+0wybx0iAjl76csYa7nkp8JE2AtyihoscgiDCg6eNjAHEi9Ej2tlGqaOQIfFCKMLRFmfKSOdqhkaRl9jicDA0d/uvNgKA/HRecURpI4KIBD4aID1A2ghwR19a6DsXMiReCEU41uY0644tzgDgNIJabI5YblJK09pjEd2O83x4XgDPiiOKvBBEJPDRAGkBDLsAkE0jAsKGxAuhCLzSqKLYJB6j6Evs4Gbd7DQttGrfX3sx34juAgkiIoKPvDgrjihtFDokXghF4D1ehuWmIdPg/AJTuXTsCNTjhcOfa6QuuwQREcFGXmg4Y/iQeCEUgUdehuYYkWV03l1Q5CV2DGbWBTwnS5N4IYhI4EMZB428pFOvl3Ah8UIoglu8pMFkIPESaxoDlElzuLBppuGMBBERIvISoNoIoC67kRAV8fL000+jvLwcBoMB06dPx+bNm/2uff7553HWWWchJycHOTk5qKqqCrieiD/sDobjbQMjLzQiIHYEalDHyaPhjAQhC91BNKkDyLAbCYqLlzfeeAOLFy/GsmXL8PXXX2PSpEmYO3cuGhoafK5fv349rrzySqxbtw4bN25EWVkZzjvvPBw7dkzpTSVkor6jDzYHg0YlochkIPESBwTjeeFpo9YeK2x2qgwjiHAJZjwAQIbdSFBcvPzpT3/CwoULcd1112H8+PFYsWIF0tLS8OKLL/pc/9prr+Hmm2/G5MmTUVFRgb/97W9wOBxYu3at0ptKyAQvky7NNkKtksjzEgcE43nJSdOBD8ClvhO+aew045HVu3GkuWfwxUTK0m0OLvJCht3wUVS8WCwWbN26FVVVVe5fqFKhqqoKGzduDOo9enp6YLVakZub6/N5s9mMjo4Orx8itvBKo6E5RgCAyej8ApN4iR0i8pLpP22kVknIdTWqayLfi0/+8VUtnlm/H0+u3RvrTSHiGBF5Gczzks7nG9G5MVQUFS9NTU2w2+0oKiryeryoqAh1dXVBvcfdd9+N0tJSLwHkyfLly5GVlSV+ysrKIt5uIjKOtjgjL0OyneLFnTaiEQGxgg9bDJQ28nyefC++qWt3zuv6prY1xltCxDNiMKM+uD4vFOkMnbiuNvr973+P119/He+88w4MBoPPNUuXLkV7e7v4qa2tjfJWEv3xrDQCQGmjGMMYQ3P34J4XwLNRHYkXX/D9cqCxm/oWEX7psQw+mBFwG3Z7rXb0ucqrieBQVLzk5+dDrVajvr7e6/H6+noUFxcHfO1jjz2G3//+9/jvf/+LiRMn+l2n1+thMpm8fojYcrStf9qIxEssae+1wmoPPBqA4x4RQHeCvvAsI99xtD2GW0LEM93mwQczAoDJoIHaZTSj1FFoKCpedDodpkyZ4mW25ebbGTNm+H3dI488ggcffBCrV6/G1KlTldxEQgE8G9QBbvFCd6qxgaeATAYN9JrAJ9O8dJd4ociLTzzD+9tq22K3IQmEw8Hw8IfVeG9balSM2uwOmF1z3AZrUidJErKNvFEd3TCEQuA9KwOLFy/GggULMHXqVEybNg1PPPEEuru7cd111wEArrnmGgwZMgTLly8HAPzhD3/Afffdh1WrVqG8vFx4YzIyMpCRkaH05hIR4tXjJZfSRvFAI/e7BGhQx+GGXoq8+MZTvHx7tC12G5JAbDvahuc+O4DCTD0unjwk1pujOD0e6Z/BxgMATtNuc7eFxEuIKC5eLr/8cjQ2NuK+++5DXV0dJk+ejNWrVwsT75EjR6BSuQNAf/3rX2GxWPCjH/3I632WLVuG+++/X+nNJSKkobMPVrurx4vrYkniJbYE0+OFk++KvJDnZSAOB/O6wGyvpbRRMOxv6ALgHPjJGIMkSTHeImXpcZVJa1QSdH6GoHrCTbut3XR+DAXFxQsALFq0CIsWLfL53Pr1673+fejQIeU3iFCMY66UUUm2ARrXF5ePB+gy2+BwMKhUyX3yijeC6fHCEZEXqjYaQFuvFQ6ndQgqCajr6EN9Rx+KTL6LCQgnB5u6ATijsh19NnEzk6x0W9yjAYIRatRlNzziutqISDy434WXSQPuyAtjQGcflUtHG3fkJbBZF3B7Xmi+0UBaut3eobFFmQCA7eR7GRQuXgCgLQUu0L280miQMmmOu8tu8u8bOSHxQsiKu0FdmnhMp1HBqHXmfil1FH2C7fECuH0xzV3OED/hhgu6vAw9Jg3NBgBsJ9/LoHiKl1ToZ9Id5FBGjrvLLp0bQ4HECyEr/SuNONRlN3a4u+sOLl7yXB0/LXYHOihK5gW/8Oam6zCxLAsA+V4Gw+Fg/SIvyf/97wlyKCOHd9mltFFokHghZKV/gzpOFpVLx4xQDLsGrRqZrnA3+V68afYQLzzy8u3RNjgcFKHyx/H2XlE2DKRI5MUSauSFG3aTf9/ICYkXQlb6zzXiUMVR7OBzioLxvAAeXXbJ9+KFSBul6zCuOBN6jQodfTYcau4e5JWpi2fUBUiN6AKvNgrW85JNaaOwIPFCyIbDwXC8zTn7hcRLfMAYQ2MIkRfPdRR58YYbdvMydNCqVTip1NnNm3wv/klF8RJ65IUPZ0z+fSMnJF4I2WjsMsNid0CtklDcr3yUl0t3kHiJKp1mGyyusH1BEJ4XwDPyQuLFE3fayLkfJ5VlAyDfSyAONDrFC++OkArRBfdco9CqjVJh38gJiRdCNnjKqNjk7vHCoflGsaGp0ylAMvQaGLTB3QnyyEsjpY284H4NbmqezMULRV78wiMvFcXOKFUq+Dp6eOQliO66gNuw29Fnhc3uGGQ1wSHxQsiGv0ojgNJGsSJUvwvgLAUGKPLSH89qIwCY6DLtfne8Q0S3CG+4eDl1eDaAFEkbmXm1UXDiJdujDxadH4OHxAshG/4qjQCKvMSKUCqNOAUZ1GXXF839xEt5XhpMBg0sNgf21HfGctPiErPNLqKxU4bnAEiNFvgi8hJk2kijViHT4FxLqaPgIfFCyIa/SiPAs1SaeodEk3DEizvyIs9d8qd7GvHxrnpZ3itWMMZEyoN7giRJEr4XmjA9kCPNPXAwZ8pyTKGzI3FKRF6E5yW4yAtApt1wIPFCyAaljeIP7nnhM4uCgQudZhn8CT0WGxa+8hV+/v+2JvTfvqPXBpurnwuPvABwd9ol8TKAA66U0ciCdLHPWnuSv3NzD++wG2SpNECm3XAg8ULIRsC0kSssStVG0aWxK/jRABweWeDCJxJq6jphsTlgczAcakrcfih8ynaGXgO9xn1HzSMv3x6liqP+cL/LiPx0EVmw2pmITCQr3SFWGwE0nDEcSLwQsuBwMBxrCxB5SaNS6VjQ2Bl62ijfVQrcabahzxrZhaamzu0FSeRmbv39LpxJQ51jAvY0dKLLTClRTw42usWLUaeGQeu83CR7xREfzBhstRHgPq4obRQ8JF4IWWjqMsNic0AlAcVZhgHPe6aNkj1sHE+E43kxGTXQqp2NOSJNHe32EC9Hmnsieq9Ywv0//cVLocmAkiwDGAN2HqPoiyeekRcAyE2R6AJvUhda5MV5fmxJAUOzXJB4IWSh1pUyKskyQqseeFhx8WJzMNHEiVAeLl6CbVAHOI2oeenylEtXn+gQ/3+4JXHFCy+T9lVy7jnniHAjPC/5GQDcqZFkn2/UE2KpNECG3XAg8ULIAq80GuIjZQQARq0aGlebzUQ2biYSjDG3eAkh8gK4Db6RlEszxpIm8sJHA/SPvADUadcXHX1WceyU5zs9cO7USHJ//0MdDwB4GnZJvAQLiRdCFgJVGgHOu3maLB1dui129FmdzdNCqTYCICIvTRGUS9d3mL2EanJ4XgaKQO57oXJpN9zvUpCpR6ZrNIg7NZK8F2jG3JHlYAczAjScMRxIvBCyEKjSiCN8L/QFjQq8WihNpw66YRZHjuGM1XXOlFGhK2XV0GkWZsZEo/9oAE8mDM2CJAHH2nqpsZ+LgyJllC4eSwVTqtnmgN1VUh9K5CUV9o3ckHghZCFQgzpOJvV6iSrhmHU5+WI4Y/gn090nnCmjaSNyRan8kQT1vfQfDeCJyaDFqAKnr4N8L048e7xwhOcliS/QnuI8lBsGMuyGDokXQhYClUlzqMtudHGLl9BSRs7XRB552e2KvFSWmFDuugNP1NSRqDbysy+5aXcb+V4ADKw0AoDcFGjExv0uBq0Kaj5KOwg8DbtUjRkcJF6IiGGM4RhPG2UHkTaiyEtUCKdBHSdPhsgL7/FSUZyJYbnO4yJRTbuB0kYAMKnM6XuhyIuTg01dAIARrkojwD09OZn7vHC/S6hpWi5ebA5G/YKChMQLETGNXWaYA/R44WQZnV9oEi/RwT0aIJy0UWSRF4vNgX0NzgtYRYkJw/Oc4uVwS+JFXhhjAdNGgPeYgFS/c2aMeTWo4+SkgCm12xx6pREAGHVq6DXOy3GyV2PJBYkXImK4WbfYZIBO4/+QMhmoy240icTzIkYEhBl52d/YBZuDIdOgQWmWAcPznBexwwkYeek022CxO6u28nxUGwFARUkmdGoVWnusqG3pjebmxR2NnWZ0W+xQSRARN8BDvKRA5CWUBnUcz/lPxOCQeCEiJphKI8DD80LiJSq4e7yE7nnhfWFaus2ieiIUuN+lojgTkiRhuOsilojipcUl4IxaNYx+7qj1GjUqS5yTk7eneOpovyvqUpab5nUzk5Pu7mWSrNEpEXkJYTQAJ1Wa+MkFiRciYoKpNALI8xJtmiLwvHB/goOFV765W/hdTAAgIi/H2nphdUUxEgXe4yVvEBHoblbXpvAWxTe+yqQBd+TFbHOgN8KZWfFKJJEX3qiO0kbBQeKFiJjBGtRxTCReoopIG4XhedGqVeJkGk7qiJdJV7iiEYWZehi0KtgdDMfbEiutMphZlyN8LykeefFl1gWcPhAeiUlW34vbsBt65CUnRWY/yQWJFyJijoWaNqIOu1GhKYyJ0p7kZYQ/38idNnJGXlQqSfgfDiVY6ijQaABPeMXRzmMdsCVYdElORJl0gXfkRZIkdxv8JE2N9PChjCF01+Vkp0ApuZyQeCEiZrC5RhxKG0WPXosd3a67wHD6vHi+rjFE8dLabUF9h/M144ozxePDcp0XsyMJ1usl0GgAT0bmZyBDr0Gv1Y69rkqrVOSAn7QR4I4uJKuvo9s1lNGfNyoQ1GU3NEi8EBHBGAs6bUTiJXrwlJFeo0JGGHeBgGfkJbSTKfe7lOUavX63KJdOtMhLV3CeF5VKwkTXnKNU9b3Y7A7Ry2dEAPGSrKkREXkJQ7yQYTc0SLwQEdHUZYHZ5oAkASVZg3heXKXSfVYHzLbkNOzFC40eZdKSFHynT08Kwuz10j9lxCnPS9S0UeAeL55MFL6X1Oy0e7S1FzYHg0GrQrFpYM+n3CRvVOeeKE2GXaUh8UJEBE8ZDdbjBQAyDRrw62hHr7xdJP93oJmm+noQSYM6Djeohhx5cZl1Kz1SRgAwzFVxdCTBGtU1hyBeJpelduTlgMusW56XDpWP9vjJ7uvoMfOJ0mTYVRoSL0REBJsyApxh9Uy9/F12O/qsuOaFzfjJC5vC6kmSjPAKoXB6vHC48GnuDi/yMq5f5IX3ejnS0pNQfT745x+s2ghwl0vX1Hcm7ATtSDjg6vHCB1X2J9kbsYU7HgBwCzuKvARHVMTL008/jfLychgMBkyfPh2bN28OuP6f//wnKioqYDAYcPLJJ+PDDz+MxmYSYRBsgzqOEuXSx9t6YbE70NlnIz+Ni0i663L4xboxhMiL3cGwp56PBfCOvAzJMUKtktBndaChM/yBj9GGe16CibwUmwwoyNTD7mDYdSL1Uke+BjJ6kp3kIwK6RbVR+IbdZBV2chOeky8E3njjDSxevBgrVqzA9OnT8cQTT2Du3LmoqalBYWHhgPVffvklrrzySixfvhzf//73sWrVKlxyySX4+uuvMWHChKB/b3d3N9TqgQeQWq2GwWDwWucPlUoFo9EY1tqeHv93l5IkIS0tLay1vb29cDj8l2Gmp6eHtbavrw92u/87RX9rD9Y1wWHpQ4GRif2TlpYmfBZmsxk2mztFlK6ywWHpQ31LG7rzdQHX9sdoNEKlcupti8UCq9V5AjxS3wKHpQ8AUFvfAn1Rpt+1vjAYDOJYCWWt1WqFxeL/RKPX66HRaEJea7PZYDb7v7jrdDpotdqAa483tcJh6UOOwX1/Yrfb0dfX5/d9tVotdDqdWJvm+ls1tLQNOPY91zocDvT2OkXsoaZudHd3Q69RocDg/M7wtVq1CqUmPQ43tKH6SAMyRuQN2AaNRgO93im4GGPo6fHvjwllbSjfe8+1jDE0tnbAYXMgTbINeJ2v7/34Aj3WNbdj054TqMjXB1ybbOcILl6GZKp97uM0lRUOSx9aPHxUg33vgz1H9FrsWLn5OC6bWobheemDfpeVOEd0dHaBOewwakP/3qdrJTgsfeiyAM1tHTBo1X7XynGO8LU21HNEsGs9zxGDrQ0apjDTpk1jt9xyi/i33W5npaWlbPny5T7X//jHP2bf+973vB6bPn06u/HGG32u7+vrY+3t7eKntraWAfD7M2/ePK/Xp6Wl+V07a9Ysr7X5+fl+106dOtVr7fDhw/2uHT9+vNfa8ePH+107fPhwr7VTp071uzY/P99r7axZs/yuTUtL81o7b968gPvNkx/96EcB13Z1dYm1CxYsCLi2oaFBrL355psDrj148KBYe+eddwZcu3PnTrF22bJlAddu3rxZrH3kkUcCrl23bp1Y+5e//CXg2g8++ECsfemllwKu/cc//iHW/uMf/wi49qWXXhJrP/jgg4Brr/7F/WLtunXrAq595JFHxNrNmzcHXLts2TKxdufOnQHX3nnnnWLtJb9/O+Dam2++WaxtaGgIuHbBggVibVdXV8C1P/rRj7yO4UBrPc8RXX1WJmn1ftfSOcL9wxhjpz/8MRt+9wdszryLAq4975GPxPvKeY4Y8vMX2E9e2MQYi905oujKh9lne5zbHMo54sUXXwy4VqlzxF/+8hexNtbniPb2dgaAtbe3s8FQNG1ksViwdetWVFVVicdUKhWqqqqwceNGn6/ZuHGj13oAmDt3rt/1y5cvR1ZWlvgpKyuT7wMQRIKT4arwihcG6wUUb1DZavD0WGw40e68Ex+sPF/JXiabDjSjL8bjB8LxvIRbFZiqSIwp55w7fvw4hgwZgi+//BIzZswQj99111349NNPsWnTpgGv0el0ePnll3HllVeKx5555hn89re/RX19/YD1ZrPZKyTW0dGBsrIyHD9+HCaTacB6Shv5XhtO2ogxhlMfXIM+qwOrbz8Lw1157kBh3nvf2YG3vj6G2+eMxs9nj5YlbfSH/1Rj5ZeHne//vUrMP314yqeN5j35GQ429WDVjWfgzHHFAMILCZ/6wBr0Wu346I6zRLVQ/7WeIeFb//41Pt7VgHsuqMCCmeUD1j67fh8een87LphQjD9dPnnANsRb2mhbbRsuenwtSrL0+OTOcwas9XWOaOuxYMbyTwAAG5f+n/B5JPs54lC7Dd/78xfISdNi411n+1xb29yD8574DGlpadj9uwsAyJc2uvvNb/GvXU2QJBVe+ek0nF6eFfW00Zl/WIuWPuCjxbNRUWwK+Rxx7qMf40BTD166bipOH5nvd22ypo06OjqQlZWF9vZ2n9dvTxT3vCiNXq8XJzBP0tPTvb54/ghmTThrPU8mcq71PPnJudbzxB7s2qYuMyySDmo9MGpIHvSagR6j/n+fgtwsqHTN6IN2wP7097f0hU6nE1+MdpsaKp1zm7rs6gHv67k2lPcdDK1WK770cq7VaDTiJBXu2haLCiqdAcU57qoPtXrgvvEHX1uQa8LR1l70sIF/L45KpRLP7W+1QaUzYPKIIp/rywsyoNIZcKKHDbotkiQFvb2hrAWC/y63dJuh0hlQkGsK+nySnp6OUaV5ONjUjX2tNswqyPG5NtnOEQf3HwcAjCzI8Lt2iFoHlc6APpsDfVY7DFp1SN/7QGtbrRIkySlGPtvTiLPHFijyvQ+0to/pIKnsYjBjqOeIgtwsHOpwwAxdwONNjnOEL8I5RwSD5zlCLhRNG+Xn50OtVg+ImNTX16O4uNjna4qLi0NaT8QOXmlUlGnwKVx8oUSX3UaPypVmCvOjz2pHZ5/z7rQggmojwF2tFEyjum6zTXTPHdevxwsn0brsNotKo9D2I++0+20K9Xs52Bi40ghwppM0rv4vclfVNHS4j9HP9jbK+t7B4HAwMS07nMGMAHXZDQVFxYtOp8OUKVOwdu1a8ZjD4cDatWu90kiezJgxw2s9AKxZs8bveiJ28AZ1wfR44ZgM8vd58RIvYUxATja4gNOpVTAZIwuu8vlGwezXmnpnc7qCTL0YLdAfPpyxvdeaEDNcgp0o3Z9UnDA9WJk04BrOmK7MBbq+w53C2FPfhbp2/ykNJej18NmEM5gR8OyyG//fjVijeJ+XxYsX4/nnn8fLL7+M6upq3HTTTeju7sZ1110HALjmmmuwdOlSsf7222/H6tWr8cc//hG7d+/G/fffj6+++gqLFi1SelOJEDkWQoM6Du/zImeHXc/BgaE2VEtGeHfdvAxdxCbAUCIvNa6ZRhV+oi6A08hY6Gp+lwjRl1BGA3jCm9Vtq21PqIZ8kRBoIKMnuWl8AKF8NzB9Vjs6XNFGLp6iHX3hPV4kyTlTLBxykrwPjpwoLl4uv/xyPPbYY7jvvvswefJkbNu2DatXr0ZRUREA4MiRIzhx4oRYP3PmTKxatQrPPfccJk2ahDfffBPvvvtuSD1eiOjA00ahVJDInTYy2+xeJ0GKvLgjUZE0qOPkicjL4OJl9wlnZ93KksBGO5E6aol/8dIUQoM6T04qNUGjktDUZRYVOMkMYwwHGp3NCUcUBBYvvJOsnJEXfszrNCpcOLEEgNP3Ek3EaACdJuybhmwaERA0UTHsLlq0yG/kZP369QMeu+yyy3DZZZcpvFVEpLjTRsGbCeXusNtfrIQ6RDAZ4fugIIK5Rhx35GXwk2l1EJEXABiel44th1pxpDn+Zxy1hDAawBODVo1xxZn47ngHtte2oTQ7sUrEQ6W1xyoiH+V5g0Re0nnkRb4LdEOnUyAWZupx9tgC/PmTffhiXxPsDga1jxlLSuAeyhie3wWg4YyhQLONiLAJZa4Rh0deOvrk+XLyOy5+wujos8Fi81/6mQq4RwOEP9eIkxdk2ogxJiIv/sy6HD7jKBGmSwvPSxhRLJE6SgHfC4+6DMk2DugM2x+3KVW+CzQ36xZm6jGpLBuZeg3aeqzYeSx6Ixr4XKNw/S4AFPMDJSMkXoiwYIyFPNcIcIuXzj6bLEMUuXgZWZAu7rBSPeTKoyRypI24ABpMvNR19KGjzwa1SsLoQt9D+TjDXGmjIwkgXkKZKN2fSaLiKPlnHAm/yyApIwDITeeTpeWMvHDxYoBWrcLM0c7RE9FMHbmHMkYSeYksKtVntcNqT42bNxIvRFi0dFuEu740O/geMSaPjq+dMkRfuFm3KNMgLjCpnjpqlGEoI4e/x2Al6LtPOFNGowrSBy2b52mFwy2JkDYKr9oIcEdedhxrT/pp58FUGnFyFPB18EqjQpPzeD17bAEA4PO9TbL9jsHoMbuGMobRXZfD00bhGHbNNjsufOoLnPPYephtyT/RnMQLERaix4tJH3SPF8BpqDO6wspy+F545KUgUy8uMKlu2uXVRvkyel7aeqwB7+iq65wpo4riwGZdwG3Yre8wo9cSvyfZPqtd3E3nhpGCG1OYiTSdGl1mm0irJCvB9HjhKFFR4468uMTLGKd4+fpIqyw3ScHQ7TpWjBFEXnhKraPPGrLg/WD7Cext6MLR1t6EqOSLFBIvRFgcaws9ZcTJkrFc2lO8uKMEqR15kdPzkm3UinRcoDw8j7xUlAT2uwDOEzTv93MkjiuOeLRJq5aQGYaPQa2SMKHUmTrafjS5U0chRV542khGX4cQLyZnFLgsNw0j8tNhczBs3N8s2+8JRI/LsJuuj0S8OPcNY6Hd3DHGsPLLQ+LfJF4Iwg+80mhIGFUUcpZLe0VeQmiolsxwz0uk3XUBQKWSRDrOsxlgf4Lp8eLJcJ46iuOKoxaPMulwS18nlbnESxJ32nU4GA428x4vgf1OgDJpo4YOd7UR5+wxztlA0er30m3mnpfw00ZatQqZLmEfyv7ZergVOzzMyfF8UyAXJF6IsAin0ojDu77KIl54WXCGHnnpwZf1JisWm0PsVzk8L4Db7+HP92K22bHflRYJJm0EuFNH8XyS5RG8UEcDeMJ9L8ncafd4ey8sNge0aimonk9CvCjQ56Uw0+2/O8uVOvpsT3R8LyLyEkHaCAhv/7zkirrwKGkitCGIFBIvRFiEU2nEkbNc2nfkJXXTRvyCq1FJYj9HCu8X0+Qn8rK/oRs2B4PJoEFJVnDmbS5eDsXxSZZH8MIx63L4mIDqEx1Ja6I84PK7DM9LD6qnCi8H7rbYZdknFptDCGtu2AWAGaPyoFVLONLSE5UIn4i8RFAqDYRu2j3e1ovVO+sAAFdPHwYgMRpARgqJFyIswplrxJGrUR1jzKdhN5V7JDR18r4kOqhkas7ljrz4Fi+7uVm3xBR0emV4Lk8bxe9JNtzRAJ4MzTEiN10Hq52h2uULSjYOBjkWgGMyaITIkaMZG/d4aVSSGD0AOPutTBnunOgdjZLpXqs8kZdQu+z+v/8dht3BMH1ELuae5BxgHM8RTbkg8UKEjHePl9h5XrotdlGunZ/hHgbYlMriRcYyac5gXXZD9bsAiZI2ily8SJIk+r0kq+9FmHWD6PECuIYzpsnX66XB4wamv2DnqaNPo5A6ksPzAoQ2nLHPasffNx8BAFx3RrnooXS0pTfpy/NJvBAh09pjFSWk4bQ9571eOiIULzzqkq5TI12vobQR5O3xwhmsy657LEBwfhfAbdg92tobt021+GiASKu2xpc698vuuuSMvAQ7kNETd5ddGcSLD7MuZ5ar38vG/U2KH2c9MowHANxptWDSRu9tO4bWHiuGZBtRVVmEkiwjtGoJFrsDdR3JPVOLxAsRMnyadGGmftBW4L6QK/LS2K88Mt9lrEzlaiNlIi+Bq7j4WIBgyqQ5hZl66DUq2B0Mx11l9/GGO20U2b4cW+TcL3vrk1O8HGxyDWQMotKIkytMqZGnjdyRl4F+q/ElJuSl69BtsePrw60R/65AyOd5Cc6wyxjDSxsOAQCumTEcGrUKapUkfIjxXMknByReiJARZdJhpIwA+cULLwnmkZdeq13cBaUa3POSnxl5jxdOfoDIS0u3RVw8xhUFL15UKgnDcvlJNj5TR3KkjQBnszoA2FPfCcaSK5RvttlFCjmYHi+cbDnTRv2663qiUkk4M0ol0/JVGwW3b/53oAW76zph1KpxxWnDxOP8e1UbxylZOSDxQoRMJJVGgNuwG2naiE+S5dUwaTo1DFrnIZ2q0ZemLm9BJweB+udws+6w3LSQB9KJXi9xepJ1D2WMTLyMLEiHSnIODQ3UKycROdLcA8aATL0mpPQaF4RylEv3767bH95tV+lRAd0WeTwv2UF2IF755UEAwKWnDkFWmruykPvJ4vWmQC5IvBAhE0mlEeBZKh1ZdMSz0ghwGgHdvV6S6yIRLEoadpu7zQMiB6KzbghmXY44yTbFZ3jbs0ldJBi0ajHPaU99co0J2N/oHsgYSiO/YC/QwcDFS5HJd5n+Wa7Iy45j7YpWIvaKqdLy9HkJZNitbenBml31AIDrZpZ7PScimnF6UyAXJF6IkImk0ghQIG3kccfF75JTtVxaCfHCL95WOxsw0sGzTDpUhHiJw5Os2WZHp2vQXiR9Xjhjipx+kD1J5nsJZSyAJ3JOluYRWH+Rl0KTARXFmWAM+FzB1FG3MOxG6HlJH7zPy6v/OwwHA84cnY8x/dK1XLwkwtT2SCDxQoRM5Gkjd4fdSDwAjT5SJKk+nJGXM8vpeTFo1aJleWO/iBavoKkMK/LivODF40mWG0nVKslrEnq4CNNuQ7KJl9DNukDovUwC0dAxsLtuf2ZFYcp0jyiVlq/Drq/zY4/Fhtc9yqP7I75XcXhTICckXoiQcPZ4kSdtZHcwUXIdDr4jL7zXS+qljWx2h7gYyBl58Xw/zzJ0u4OJSMK4cMSLCG93x52RlUewctLkafY3upBHXpIrbRRqjxdOrkwjAuwOJv5Wvgy7nLOE76VRkWPNYnPA4irFTo+4z4tz39gcDF3mgan1t78+ho4+G4bnpeGccYUDni/LdZ6X23utaJdxcne8QeKFCIn2XqswpoUzlBEAjFo1tGpJvF+4BEobpWLkpaXbAsYAleQ+AcoFN2N6Nqo73NyNPqsDBq1K3O2FwpAcI9QqCX1Wh/AtxAvCrCtDyghwR16SreIo1O66nGBSI8HQ3GWGgwGSFPhvNbU8BwatCvUdZtQokLrr9bgJM0YYeTHq1NBrnJfm/h2IPadHL5hR7lNYp+k04px4uCU+/WRyQOKFCAmeMsrPCK/HC+A01kbqe7E7mChl9RQv7l4v8XUxjAY8pZObrg9qxkwocCO054gAnjIaV5QZ1u/TqlVCAMdbZYRclUackQXOuT+dfTbUdyTHsdneaxVitjxU8SJT5IWL3vwMPTRq/5czg1aN00fmAQA+V6DbLve76NQq6DSRX1b9Td7+Yl8T9jV0IV2nxo+mDvX7eh7VTObUEYkXIiQiTRlxuI8gXPHS2mOB3cEgSd7VICLykoKGXeF3kemC6wn30HgOZxTN6ULorNufeB3QKFePF45eoxafNVl8L4dcUZfCTD0yQiyT5xfnTrMtos63g5l1PRFTphUw7YruuhFWGnH8ddld6WpKd9nUsoBerGEpUC5N4oUIiUgrjTiR9nrhKaPcNB20Hndc/GLjbw5PMtPkI40mF6IE3UMUishLGH4XTrxWRvDRAHKljQBgrGhWlxy+lwMus+7IEP0ugPP7z4N1kZh23WbdwY/5WWOdJdObDrZ4pXnkgHv3IvW7cESjOo/v26GmbnxS0wDA2VE3EPH6vZITEi9ESERaacSJNG3ky+8CuI2lLSlo2FWiTJqT79rPXpEXPtMohLEA/YnXcmm5RgN4MtZVLp0sYwIONvIy6dAqjQBnFRc/B0QyWbo+iEojzqiCDJRmGWCxObD5UEvYv9MX3TJVGnF8pY1e3ngIjAHnjCvAyILA+9z9vYqviKackHghQkK2tJFC4sXTsJtMxshgcIsXBdJG6d7puC6zTeTTI0sb8XLp+DrJcsN3roz7coyHaTcZCGcgoyc8NRJJTyaRNgpQacSRJMmdOtojb+pIrqGMHPf4BOf5sbPPin9+dRQAcO0ZIwZ9/bBc59+ktiU+54bJAYkXIiTkShtluXq9hNtl11ePF8CdNrI5BjZUS3bcnhcFIy+u/V7jiroUmfQR+ULcnpf4jLzImTYaIyIvXUkhrMNtUMfJDaKT7GA09BvOOhhnj1VGvMg1GoDTv8vuW1uPostsw6iCdJzt6hgcCJ42Ot7eC7NN3hRZvEDihQgaZ48XedNGkXpe+kde9Bp3Q7VU6/WiZNqof/O/GuF3CT/qArhPsvHWk6JFZsMu4LzIq1USOs021LmGCSYqjLGwe7xweKO6lggmSw8216g/Z4zOg0oC9jZ04US7fFGJHlc/lkhHA3A8DbsOB8PLGw8DAK6dWR7UGIb8DB3SdGow5r7hTDZIvBBB09FrE02Twu3xwlHK8wJ4NlRLLdMu3yf5Chh2+Xt2mW3os9rFWIBwOut6kqbTiAtPPOXnuRCUM/Ki16hR7oo0Jbppt6HTjB6LHWqVhLIwb2TkGBHQ2BF8tRHgFEwTh2YDkLdkWv7Ii9uw++meRhxs6kamQYMfnOq/PNoTSXJPbU/WcmkSL0TQ1Lr8LvkZuogbMUVaKh1IvLijBKkZeZFzojQnU6+BzlXV1dRldg9kjMCsy4m31JHV7hDpTDkjL4DHmIAE970ccJl1y3KMYfc1ibTXi8PBQk4bAe7U0acylkz3WmSOvHgYdl9yNaW7fGpZSJPb+fcqWSuOSLwQQcPDj0MiTBkBMqSNAlyoRbl0CvV6sTuYSHXIOdeII0mSV5fd6rrIe7xwuLkwXky7/GIqSe7UhlyMEeIlsSMv7jLp0CuNOP56mQRLa48FNofTOxSKYOcl0xv2NcHukMd7JHfkhRt2DzR247M9jZAk4JoZ5SG9h5guTeKFSHXkqjQClE0b8flGLSmUNmrptog26bkyX3A5fL/uONaOzj4bNCoJoyK4eHHK46yhlmhQl6aTvVMxL5fek+CN6txl0uH5XQCP1EiYaSMedclN14UU/Zk0NBuZBg3aeqzYcaw9rN/dH+55kbtUutfqFEVVlUWi8VywDBMDGuPjpkBuSLwQQSNXpREQWam02WYXr/PteeFlvamTNuIpo9w0XcA26ZHA9+sXrnD7qIIMWVqhD4uzXi9KmHU5PG20L8ErjiKtNAL8t8APllDNuhyNWoUzRjmjL3JVHSlVbcS5bmZ5yO+R7CMCSLwQQfHF3iZ8XF0PIPJKI8AjbdQXunjhJcFatbvRlSf9K2NSASUrjTg88rJxfzMAefwugLvXy+E4SRvJPRrAk/K8dGhcFUcn2hO34ijcgYyeiLRRmOndBpdZN5yO0tz38rlMvpcemT0vmQaNiPqNK8rEjFF5Ib+Hp2E3kYWyPxQVLy0tLZg/fz5MJhOys7Nx/fXXo6vLf663paUFt956K8aNGwej0Yhhw4bhtttuQ3u7PKE9InRq6jpx7UubcfULm3C0tRcmgwYzw/gi9YdHXvqsjpD7EIiUUYbeZ9kgv8g2pZBhV4gXBfwuHC6MuJlVDr8L4L5DrO8wo88a+54ULbzSSIFmfzqNSgwxTNRmdVa7Q9zNh1smDXhGXsJLHbsjL8GbdTlnuXqlfH2kLawbqP64O+zKE3lRqSSxf649I7jy6P7E89R2OVBUvMyfPx/fffcd1qxZgw8++ACfffYZbrjhBr/rjx8/juPHj+Oxxx7Dzp07sXLlSqxevRrXX3+9kptJ+KC+ow93v/ktLnjyM6yvaYRGJeHameVY/8tzZPE5ZOo14N/HUFNHgfwuQGoOZ2zqVK5BHad/5165Ii/ZaVqYXL154iHErWTaCPAcE5CYpt2jrb2wORiMWjWKwhAOHO55ae+1whbGcEYeeQmmu25/ynLTMDI/HXYHw5f7mkN+fX9E5EUmzwsA3HneWFw5bRguPWVIWK/XqlUozXb+feLheyU38shEH1RXV2P16tXYsmULpk6dCgB46qmnMG/ePDz22GMoLS0d8JoJEybgrbfeEv8eNWoUHnroIVx99dWw2WzQaBTbXMJFt9mGZz87gOc/OyDMYvNOLsZdcytCHnsfCJVKQqZeg44+Gzp6bSgM4To4mHhx93lJvrsNf0QnbdRPvETY44UjSRKG56Vjx7F2HGrqFr6QWNGswFwjT8YUZgKoS9jIy4FGp+gqz0+HKgJDc5ZRC0kCGHMKmLwQj10eTSgKs6/R2WMLcKCpG5/vbcT5E4rDeg8OH8yYFuJ07UBcMW0YrpgW2XsMz01HbUsvDjf34LTyXFm2izEGs80Bg1Y+oRYOikVeNm7ciOzsbCFcAKCqqgoqlQqbNm0K+n3a29thMpn8Chez2YyOjg6vHyJ0bHYHXtt0GLMeXY8/r92LXqsdpw7Lxls3zcAz86fIKlw4WWnhmXYHEy/8jrktzDu6RKQxCuLF872zjFoUh9BbYzC4aTce7hCVGA3giej10pCYkRfhd4kgZQQ4jbO831M4pt1werx4wlNHn+1tjNgT4p4qHdsLen/KxHRp+fxkR1p6MGHZR7j0mQ0x9dIoFsqoq6tDYWGh9y/TaJCbm4u6urqg3qOpqQkPPvhgwFTT8uXL8dvf/jaibU1lGGP4ZHcDlv9nN/a5TqbleWm4+/wKnD+hOKxca7BkGbWoRW/IvV4au1xGPT8X6pw0nbija+2xhmXoSzTEBVcBnwYnzyMSUVGcKeuxEU/l0mIoo8Jpo30NzoojJb9jShDpQEZPctN1aO+1huV7EUMZw/x+nz4yD1q1hNqWXhxq7omocqrbVSodafNOuVFiavv2o+2wOZirNUPsjt2QIy/33HMPJEkK+LN79+6IN6yjowPf+973MH78eNx///1+1y1duhTt7e3ip7a2NuLfnSrsONqOK5//H65/+Svsa+hCTpoWyy4cj//+YhYuOLlE8QMz3C67g0Ve1CpJ9DpJlXJppaMFgLcZuLJEHrMuZ7irUd2hOKg44seMUvuyPN9ZcdRltuF4AlYcydHjhcObsYU6WZoxhvqO8A27AJCu12DqcGcqJdKqI3fkJb6sDUqUS2+vbQMATBqaJdt7hkPIe3rJkiW49tprA64ZOXIkiouL0dDQ4PW4zWZDS0sLiosD5xc7Oztx/vnnIzMzE++88w602oHlsBy9Xg+9PvnvrOXmH1tqcddb3wJwVkD89IwRuGn2KJ+lx0oRbrn0YOIFcEYgmrstKVMuzU/+OQqKl1yPiNY4mfwunHhMG+UqFMXSqlUYkZ+OvQ1d2FPfGfGcsGgjR48XTriTpTt6bbDYnCnhcAy7nNNG5GLjgWZUnwjfbsAYQ7fLsJsmU6m0XLjTRvJ9r7492gbA2ewvloQsXgoKClBQUDDouhkzZqCtrQ1bt27FlClTAACffPIJHA4Hpk+f7vd1HR0dmDt3LvR6Pd5//30YDPLl1Qk3/93l7NlyzrgCPHjJBFl6t4SK6LIbYshYjAYIJF7S9QC6UqZcOhqRF41ahYIMPRo6zRgvc+Sl3NXr5VhrL2x2h2KN9gbD7mBoc0UC8xQy7AJO38vehi7sre/EOeMKB39BnNDlMRFbnshLeJOlecrIZNBEZBzlvVBqW8KfvNxndYBbP+Iu8uK6KWjutqDLbENGhIZim92BncecQm9SWWwjL4qdISorK3H++edj4cKF2Lx5MzZs2IBFixbhiiuuEJVGx44dQ0VFBTZv3gzAKVzOO+88dHd344UXXkBHRwfq6upQV1cHuz32/R+SiVrXHe61Z4yIiXABwhsRwBgTkZdA4WJRLp0CkZc+q12ErZWMvADAg5dMwJ3njcVEmUPGhZl66DUq2BwMx9til0pp7bGICxEv5VWCMXxMQIKVS3/naqdfkmWQZe5TuJOlIzXrcspc3cL56JNw4GXSAGCMcQVOfzINWuHdkqMJ5N6GLvRa7cjQazAyP/KWGZGg6O3Na6+9hoqKCsyZMwfz5s3DmWeeieeee048b7VaUVNTg54e54Hz9ddfY9OmTdixYwdGjx6NkpIS8UNeFvlgjInwPL/ziAWmMNJGnWYb+qzOcHGgyhpRLp0CnhceddGqneXnSjL3pGIs+r8xsvuhVCpJHIux9L3wfZmdplU0+pOo06W/PeoUL3KJ1+wwJ0tHatblDHUdc8faesMe0ijKpHXqiErHlcIdXYo8dcRTRicPyYr5Z1X0TJebm4tVq1b5fb68vNyr1Gr27NlJ2cY43mjqsqDXaockIab59nDmG/GoS6ZeE9DZz+82QjUCJiLC75KmS7jKFU+G56Vhb0NXTGccKV1pxBGN6hKs4ujbY1y8ZMvyfrlisnRo31O3WTcy8VJsMkCrlmC1M9R39KE0jPOh8LvEWaURZ1huGrbVtslSybedi9cYp4wAmm2UkvCoS2mWUZbBeuESTtooGLMu4E4bNaVA2kjpjrDRgs84krMnRahEwzsEOD+rVi2hx2LHsbbw/RbRht95yxV5cU+WDtHz0iFP2kitkoRg4YNnQ0Xu0QByI2e5NK80mhxjsy5A4iUl4eHDstzYVjnwlvDtvbZBVrrh4iV/MPGSnjpddvlda+KLF542il3kpcWVZlR6X/KKIyBxxgS09VjE3fvEIdmyvGdOjNNGADDU5XsJN63SkwCRFyDytFGf1Y6aOmeac2JZdqSbFTEkXlKQePC7AB6l0gpEXvJTaL5RtFIdSjNMgbLOUFF6NIAnY1y+l0QZE8D9LuV5aaI7dqTkhJk2ksuwCwBlroKFSCMv6Qr7zcKFf68iTRt9d7wDNgdDfoYOpVmxrwIm8ZKCJLR44WXSg7TBzxPzjZJfvCRL5IWXSx9p6YmZ940fL0qnjQBgbCEXL4kReXGnjLJle08eeWnrtYZkmHVXHMoYeQmz4qjXGt+RF56OPdbWC2sE41I8+7vEg0eLxEsKckSkjWIrXrhht9NsC/rEFarnpctsQ581ucvsm5PE8zIkxwi1SkKv1S7+ztEmmv4ht2k3sSIvcpbJ8w67jIV2EyMmSssgXvh5MNxyaRF5iVPPC29DYHcwHI/AX+X++2fLtGWRQeIlBamNs8gLAHQGWS4drHjJ1GugVTvvDpI9ddSaJOJFq1ahNNsZjo6V70WMBlBwRhRnjCiX7oIjzDLdaKLExUurViHT5X1rCTJ11GW2odtVnixH2sjteQnvwt4Tp911OZ5tCCLpYM3NuvFQaQSQeEk5zDa76JAZa/GiVatEqDXYiqNgxYskScK025LkqaNkibwA7tSRHA21wsFdbaS856U8Lw06tQq91vivOGro6ENdRx9UEjBhiLzdlXNCHBHAoy7pOnXEHWMBt+flRHt4aRV3tVF8ihcgct9Le69VDOSM9VgADomXFONYay8Yc37x4+FiF2q5dLCeF8CjXDrJG9WJyIsMHU9jjRx3iJEQzbSRRq3CyAJXxVGcp454f48xhZmylwTniJ5MwZ0D5DTrAs6GljqNCg4G1IUxKJNHXuI1bQREPjtsh+vvX5ZrjIvrBkDiJeXw9LvEg+kqlMnSdgcTpc/B5LpTxbSr9CDBaBLLcmmHg4l+I9FIGwHA6MLEGBMgOqsqMEk4Ny20EQENQUZfg0WlkiIql+62xHefF8BjunSY36vtcTKM0RMSLylGvPhdOO6Ko8F7vbR0W+BggCQFd2ecn87nGyVv5MV5wU2myEvsGtW1e1S85ERpX45NkHJpHnmZpIB4CbXXi5xmXU4k5dI9ZlfkJU49L4A78hJuo7p4mSTtCYmXFCNeyqQ5oYwI4H6XvHRdUHNn8lKg10t7rxXc66n0UMZoUJ4vXzfQUOHHSaZBE7XO06LiSIbIS21LDz7f2xjx+/SHMYYdCpRJc9y9XkJMGwUYzBoqkZRL9yRA5MXzpiCcNgTba+WvNIsUEi8phhAvefEiXniX3SDEiyuCEmggoyc8bdSUxJEXXqGRadBAq+AgwWjBRXVbjxXtIbaMj5RojQbwhFcc7WuIrOLI4WC45sXN+MkLm7H1cItcmwfAGY1o7bFCq5ZQUZIp63sDHiMCQoy8FJlkjLzkRhB5sfAmdfEbeSnLNUKSnCmuUG/m6r3M2iReiBhxxFUOGOseL5ysECZLB1tpxMkVaaPkjbzE4oKrJGk6jfj7Hm6JbuqIpxejaUgcnuuuOAq3wysAfLGvCQdd1SBrqxvk2jwAbr9DZYkJeo38F+hQu+y6DbvyiZfIPC/OtJFRG7/iRa9Ro8RlcA7VtMtLpMcUZsZVF2ESLykEY8w91ygnvsRLKGmjYMULHxGQzJOlxUTpJBEvgLOEGIi8nXmoRHM0AEeuiqO/bz4i/v+LfU0Rb5cnvL/LyQrddQvPS6jiRca0ET8fhpU2ivPxAJyyME27/O8/KU76u3BIvKQQrT1WdLnMZfxOI9YoKV5SYThjskVeAI/8fJR9L7Hal27Tbni+l4bOPqzZVS/+veNYe8iDDgPB77yVMmu6xUuQnhcFDLv8fFjfYYbZFlpH7u44H8zIGR7mTcF2Bf1OkUDiJYXgF4NikwGGOAlx8lLpYFqDh9LjBfDs82KJ2awcpRGRlySoNOKIcumm6KaNhHiJcsn5mEJu2g0v8vLPr47C5mCYMjwHY4sywBiwYb880ReHg2HnMZdZU6E775z04D0vfVY7OvqcYkHOyEtuuk6Ij2Mhpu/cnpf4jrwMzwv9poAx5o68kHghYkW8VRoBoQ1nbOx03nGFGnmx2Bwi4pRsJFOPF87wCMs6wyVWnYrFdOkw0kYOB8PrW5wpo6umDcOZowsAAF/slUe8HGjqQrfFDqNWjdEFGbK8Z39yPYYzDmZabuhw3sDoNSph9pcDSZLCLpfuSZDIi0gbheAlO9zcg/ZeK3QaFcYVy2/WjgQSLylEbZwMZPQkK025tJFRp0a664SSrKbdZOquy+F3iAcau2CLYApuqLREca6RJ7xcOpyKoy/2NaG2pRcmgwbfm1iCs8bmAwA+39skS7SRl8hOGGIKqj1BOGS7jl27g6GzL/BNRoPrBqbQpJe9yWY45dJ2B0Of1XmMxnOHXcDdqC6UtBFPGY0vMUWtfUCwxNfWEIrCjVrxFHkJpcNuY2fw3XU5ostuko4ISKa5RpxxRZnITtOiqcuCf249GrXfywVuNA27gFOs6TQq9FkdIRtGuVH3B6cOhUGrxvQRudCpVTjW1itLl2LRWXdIdsTv5Q+dRiVmFA1m2lXCrMsJp1yaR12A+B3MyOERzYZOM3otwfl6uHidXJat1GaFDYmXFMLd4yU+zLqAZ6m0LeCdomeuuyAj+BMXv6g3JWvkpSf5xItRp8Zt/zcGAPDH/+5Bd5RSfrEy7KpVEkYVhD4mwNOoe+W0YQCcpeanDs8GAFka1m2PUqVJtisCO9hkaSXMupxwyqW530WtkqCL8z5LWUatmOAdrEj+Vph146vSCCDxklLEs+fF7mBiRogveKM5nTq0XHeyl0u7owXJI14A4OrTh6M8Lw1NXWY8++l+xX8fYyymQlB02g3B9+Jp1PX0I5w1xul7+TxC34vF5sCuEx0AlK804ft8sMnS9WFEX4NlqCiXDj7ywoV1mk4dF7PiAiFJUkgVRza7AzuP88662UpuWliQeFGYHUfb46JU12Jz4ER7fDWoAwCDViXuWAKljjz9LqGcJJK9XDoZIy+AM5VwzwUVAIDnPj8Q1rTfUOjos8Fqd0b+YiNenOIj2DEBnkZdHnXhnDna6Xv53/7miDxDe+o7YbE5YDJoRO8dpeC+l8EmS3PDrlwTpT3hkZdjIaTuRKVRnPtdOMNdbQgOBzE7bE99F/qsDmTqNRiZn670poUMiReFYIzh9//ZjQv/8gVmP7oeb2w5EtNy3eNtvXAwp1gIttQ4GkiSJCIpgSqOuHjJD/GOS5RLJ2HaqM9qFyfPZBMvADD3pGJMHZ6DPqsDj/23RtHfxcVtuk4dkzYC7unSwUVePI26359Y4vXchCFZyE7TotNsE4bLcOAlshOHZiseVeCTpQeLvAjDrgKRF35T19Rl8fKyBEJEXuLc78LhY2GCSY15ThJXqeIvqkTiRQFsdgd++ea3WOEKd3eabbj7rR245sXNOBpGB0c58EwZxVt4M5jhjKH2eOG4DbuRixe7g+GVjYfC7schNzwVplVLwvCYTEiShF9/rxIA8NbXR/GdK4StBLEuOR/rMePIHkTFUX+jridqlYQzRjmjL5/tCT915HnxUhp35CXw91SY9hWIvHh6QoLt9dJjTazIC7cMBNOGgAvfSXFo1gVIvMhOr8WOG1/dije3HoVKApb/4GT8el4l9BoVPt/bhLmPf4ZX/3c4oiFs4RCPfhdOMF12Qy2T5nDPixxpo4+r63Hfe9/h3nd3RvxectDiUWkUb4JULk4ZloMLJ5WCMeDhD6sVi17GYjSAJ8Ny06DXqGC2OQa9K/Zl1O3PmWOc4iWSUQHCrBsF8ZIb5HyjBgU9L0DoYwL4aIB47/HCGR7CiABeaRSNv384kHiRkbYeC65+YRPW7m6AXqPCsz+ZiiunDcPCs0di9R1nY1p5Lrotdvzm3Z246m//CyrvKBfx2OOFE0y5dLgnLbfnJfLIC+80GmxoX2mSsbuuL+6aOw46tQob9jVjfU3kFTS+4PsyP0bpN++Ko8DHlz+jrifc97Ktti2ooaf96bXYxXZEw6zpniztf1stNof4OykmXnJ5xVFwkZdEGQ3AEWmj1p6AEb5eix01Ufz7hwOJF5k43taLy1ZsxNbDrTAZNPh/P5uOc8cXiedH5Kfj9RtOx28vOglpOjX+d6AFc5/4DC98cTCoMHGkJELkJRjPS6iRFzFZWoa0UfUJ55e5tccq6+yYcIlVO/toU5abhuvOKAcAPPRhtSKN61rioF+Ou+LIv2k3kFHXk7LcNIzIT4fdwfC//c0hb8uuEx2wOxjyM/QoyZI/RdMfPlg0UKk0Tx1r1ZJign2o6LIbbOSFe14SI21UkmWEVi3Bameo6/Bvgt91oh12B0NBZnT+/uFA4kUG9jV04od//RJ7G7pQbDLgnz+fidPKcwesU6kkLJhZjo/uOBszR+Whz+rAgx/swo+f3Yj9jeENZQuWVBUv7lJpc8Sput11HeL/D0YxauaPVIm8AMDN54xGTpoW+xq68MZXtbK/vyg5j6EQHCMqjvxHXrhRN9OgwfdOLvG7DnBHX8JJHXG/y6ShWVFJSfJjOJBhl/d4KcjQK2YgLcsJNfLCPS+JEXlRqyQh0AJF/j1TRvGakibxEiFbD7fiRys24kR7H0YWpOOtm2cOOgOiLDcNr/1sOh6+9GRk6DXYergVFzz5OVZ8ul+Ru0rGWFx21+XwaiMlPC/8js7BnLNTwqWzz+rVefNgY/yIl2SaKO2PLKMWt89xNq57fM0edIaRCgmEGA0Q08jL4NOluVH3h6cOhXGQCyb3vYTT74VXGkXDrAu4xUugUmmeOi5QwKzLEZGXtiAjLyJtlBiRF8B9DQjke4nXSdKekHiJgE9212P+3/6Hth4rJpdl482fz8SQ7OC610qShKumD8NHvzgbZ48tgMXmwO//sxs//OuXqKmT11PR3mtFpyu8yb+c8YRnl11fMMbCrjbSqlWie2ckpt3+PoQDTcpGyoKBh9hzUkC8AMBV04djRH46mrosePbTA7K+d6wNu4B7uvT+Rt8VR55G3SumlQ36fjNG5UGtknCwqTvkKkdRaRKlixefLN3W438CvNJmXcDtCQw28uKeKJ0YkRcguMGnYpJ0nFYaASRewuatrUex8JWt6LM6MHtcAVYtnB5WvnxIthEvX3caHv3RRJgMGmw/2o7vP/U5Vu88Idu28pRRYaZ+0Lu1WDBYtVFHnw0WmzMiFWrkBXDfTUfS64X7XTgHm+Ig8tKVOpEXwLtx3fOfH8DxttCm/wYiHqJYZR4VR0d8XFi4UffUYdmoKDYN+n4mg1bMpAllynRHnxUHXJHFaLWF55EXm4OJG63+KDkagMMb1bX3WoMyOrurjRIw8uJHvLT3WMX5beKQ+Kw0Aki8hMWzn+7Hkn9uh93B8INThuD5a6ZGdPBKkoTLppZhzeJZOGdcAax2hr/KeGcZz34XYHDxwlNGmQZNWA3E5BjOyP0u41yh/QPxkDZKscgLAJw3vgjTynNhtsnbuC4exiyoVZLfZnXBGnX7w30vn4fge9npuusekm0U3x2lMWjVMLq+221+Uke8u26RgmmjdL1GHANHg4i+8GqjRPG8AIOnjb491gbAGaGJ53MLiZcQcDgYHvr3Liz/z24AwA1nj8Rjl02CVqaBXEUmA5ZdeBIAoPp4h4g2REq8i5fBSqXD9btw3L1ewo+87HZFXi44uRgAcKi5O+q9evoTDxUy0cazcd3bXx8T5euRwBiLm3051o9pd8N+t1H3+xNLg36/s1y+lw37moKuavz2WHSGMfYnd5CKIyW763oiTLtBpNp42iiRIi/D8wKPCPDsrBzPKCpeWlpaMH/+fJhMJmRnZ+P6669HV1dwXgHGGC644AJIkoR3331Xyc0MCqvdgSX/3I7nPz8IAPjVvAr8al6l7K734XlpyDJqYbE7ZPO+xHOPF8DdYddftVG4fhdOpOXSjDHxtzh3fBE0Kgl9VkfAUsNo0BonF9xoM6ksGxdPdl7Af/fvXRE3rusy22BxGeVjXXY+psj3dOlVm1wddU8ZElLqd1JZNjL0GrT1WIPuUCw66w7JDvr3yAH3pvlrVCc8LyZlxYu7XDqIyEuCjQcA3L1sOvpsaO8ZeM7dVtsGIH6b03EUFS/z58/Hd999hzVr1uCDDz7AZ599hhtuuCGo1z7xxBNxVaK1troe73xzDBqVhD/9eBJuOHuUIr9HkiSRZ94WwVwST+I98hJs2ijcyEukwxmPtfWi02yDVi1hbFGmaPQUS9+LwxHbKcix5pdzx0GnUeF/B1qwtrohovfiUReDVhXzO+ixha7Ii0evF6+OutODTxkBTsP6jFF5AIKvOopVZ1XRZdfPTYbbsKts35GholFd8JGXRBkPADijRPxcerhl4Dns2zgfC8BRTLxUV1dj9erV+Nvf/obp06fjzDPPxFNPPYXXX38dx48fD/jabdu24Y9//CNefPFFpTYvZM6fUILb54zB8wum4genDlX0d3GH/7cuBRwpQrwoPBk2XHjkxWxzoM81K8STWKeNeMpodGEmtGqVmLB6QOHePIFo77WCZwFSoc9Lf4bmpOGnZ4wAADz8n2pYI2gx0CzMurEfWMojL54VR29uDc2o2x+eOgrGtNvcZcYxlxF6QpTFCz+OW31EA2x2B5q6lK82AkKMvCRYh10OHxNwuJ/vpa69D/UdZqgk4KTS0I+1aKKYeNm4cSOys7MxdepU8VhVVRVUKhU2bdrk93U9PT246qqr8PTTT6O4uHjQ32M2m9HR0eH1oxS/OHcszhlXqNj7c7ji5bnHSLDaHTje5kxvxGvkJVOvAQ+y+XL4Rxx5idCwy826Fa7+PSO4eIlh5IVfcE0GjWyeq0Tj5nNGITddhwON3Xjd1f8kHETVVhx0Ki7LSYNBq4LF5sBhl6/q9c3OpnyhGHU94abdrYdb0WsZeHPgCT/njCxIF160aOEeETDwJqO52wLGAJUExU3E3PMSTHl5ryiVTpzIC+C+ke1fccRL5McWZcY8CjkYip316urqUFjofaHXaDTIzc1FXV2d39f94he/wMyZM3HxxRcH9XuWL1+OrKws8VNWNnj/g3iHh2v3NnSKnGq4nGjrg93BoNeowvaMKI1KJYkTpS/fS6SeF17+Gm7kpdrld3GLF+fdcSzTRqmcMuKYDFrcUeVqXPfx3rBm+ADxZXxWeVUcdWHD/iYcaekJ2ajryYj8dAzJNsJid2DTwcCjAoRZMwYlsjkBhjPySqP8DD3UCnXX5XhGXgbzUwnPS4JFXvxVHH0b5f4+kRCyeLnnnnsgSVLAn927d4e1Me+//z4++eQTPPHEE0G/ZunSpWhvbxc/tbXytw6PNoUmA4pNBjgYIq6mOOJh1lWqpbYcBPK9yBV5aQrT87L7hCvyUuIMo/LISyzFSzyU9sYDV04bhpEF6WjptuCv6/eH9R7NcSReAA/fS31n2EZdTyRJEqmjwXwv38aws6o7beRDvPBKI4XNuoC710uX2YY2HyksDmMsIauNAM9Gdd7nMO53mhjlSrNwCFm8LFmyBNXV1QF/Ro4cieLiYjQ0eBvpbDYbWlpa/KaDPvnkE+zfvx/Z2dnQaDTQaJwHxA9/+EPMnj3b52v0ej1MJpPXTzLAyxQjTR3Fu1mXE2hEQOSGXedJ0bPZXbD0We1CpFS6Ii+jCpzipbalR7Zy9lChyIsTrVqFpRc4S6df+OKg8GuEQjyMBvCEzzj6cn9z2Ebd/pwZhO+FMYbtR2NTJg14RF589HmJllkXcPac4eeaQOXSFrsDNpcvKZGqjQBgWK7zHOYZeWGMJVTkJWS5WFBQgIKCgkHXzZgxA21tbdi6dSumTJkCwClOHA4Hpk+f7vM199xzD372s595PXbyySfj8ccfx4UXXhjqpiY0E4dm46Pv6iOuOEoU8eIezuidJrM7mLi4hCtesoxaqFUS7K4KnVCaXO1r6IKDOUUC//0FmXqk69TotthxpKVHhPmjSTylOmJNVWUhpo/IxaaDLfjDf3bjz1eeEtLr42E0gCd8uvTGA84UzylhGnU9OWNUPiQJqKnvRENHHwp9fAdOtPehqcsMtUrC+JIYiJcApdL1Ueiu60lZjhGNnWYcbe31G4Xi3XUBIC2M5pmxhF8PTnT0wWyzQ69R41BzDzr6bNBrVIPO54sHFPO8VFZW4vzzz8fChQuxefNmbNiwAYsWLcIVV1yB0lJn7vbYsWOoqKjA5s2bAQDFxcWYMGGC1w8ADBs2DCNGjFBqU+MSUXEUoXiJ9x4vHH9po+ZuMxzcqBfmxUWlksRFPtTUUfUJd2ddXrovSRJGFMS24khMlCbxAkmScO/3xkOSgPe3H8eGEKcoN8fZmAXeqI5zVZhGXU9y0nWYUOoUJP6mTH/rYdaMxRiRwGkj3uNF+cgL4DnjyH/khVca6TUqaBLMNJ+foUOaTg3G3FVV213VrSeVmhKiCEDRLXzttddQUVGBOXPmYN68eTjzzDPx3HPPieetVitqamrQ0xPa0LBUgE9zrW3pFReqcEiUyIu/Lrs8ZZSbHplRL1zT7m5u1i3xvqDE2rQbD7N44omTh2bhJ6cPBwD8+p0dPkvu/RFvUawh2UbRKj8So25/BpsyHUuzLuCdNupvlOWG3WhFXoaKiiP/achErTQCnIK/v2k3ESZJe6KoeMnNzcWqVavQ2dmJ9vZ2vPjii8jIcIfYy8vLwRjz62cBnHm4Sy65RMnNjEuyjFrRT2R7BNGXRBEvWX667Ebqd+Hkh1kuzcukK/uF7WNt2hWRlxTs8eKPO+eOQ5FJj0PNPXh63b6gXyfESxyUSgPeFUeXRmDU7Y/o97KvyWcVjRAvMTJr5rqOZYvdIYywnMYojQbglLkqjgJ5XrqFWTexUkYcYdp1jQngkZdY+J3CIf5jQykM77T7bW14pt32HquIZPCW0PGKyU/aSC7xkhdmo7oaP5EXbtqNVa8XEXmJkwtuPGAyaHG/azbYik/3D5gP5A8uaPPjxPMCAAvPHonTR+bi57Pk6+Q9ZXgOjFo1GjvNqOm3b+LBrGnUqaHXOC9J/aPN0U4bBdOorsfMhzImXuQF8Jwu3Qur3YHvjjtv1BLBrAuQeIlr3M3q2sJ6Pb9ryM/Qx30pnz/PS6Q9XjjcL9MUgnhp7DSjqcsClQSMKeyfNqLISzxy/oRizKkohNXO8Kt3dgw6PLPHYkOf1VkxFi+RFwC4aFIpXr9hBkqz5bvp0GvUmDYiF8DAqiNu1tTF2KzJU3eeJcoOBxM3MVGLvOS6G9X56/XCIy+x8AfJwTDXgMYjLd3YU98Js82BTIMG5a7H4x0SL3EMzz1uP9oe1vA5d8oovqMugMdwxj6lIy/Bp414yqg8L33ACarcJV4aO83oDLM5WiS0xFFL+3hCkiQ8cMkEpOnU2HKoFf/cGrjvE4/E6TQqpCfoRSgU/PV74TdI40tia9bMThs4WbqlxyJKkiM9DwRLSZYRkgT0WR3iBqo/PS7DbnqClUlzPEcEuOdZZcd1PzBPSLzEMSeVmqBRSWjqMuN4e+gTjBPF7wJ4Rl68S6VlEy+uO7pQzM98plH/lBHgTFFwH82hpugaznstdvS6DKk56dFt4Z4IDMk2YvG5YwEAD3+4O2CFmafxOZ4GwSrFWWOcbS42HWz2MjWL5mQxniSc6zqe2zzECzfr5qXroiasdBoVSlwpKn+po25zYjao47jTRj3C7xLrv38okHiJYwxatSibDGdIYyKKF6UMu6LLbgjipVrMNPLdY0MMaGyKbrk0vyvVqVXISMBKh2hw7cxynFRqQnuvFb/7YJffdfFWaaQ0Y4syUJipR5/Vga8Pt4rHdxxrAxD7ShMRefH4nvLuutGKunCGDlIuLSIvCRqxG5JjhFolwWxz4JMaZ0PZWP/9Q4HES5zDfS/bw+i0myg9XgDngEFAQc9LOGmjE94zjfojBjQ2Rtf30ip6vGhTIloQDhq1Cst/cDJUEvDutuP4fG+jz3XxNhpAaSRJEoMaP3f1e7HZHdh5jJs1Yxx58TFZOtpmXc5g5dJiNECC3kBo1SqUZjv3Kb9JnOy63iQCJF7iHH4y2Z4ikZcusw02u7vlvmyl0i5vSLDVRja7A/sanBGVyhI/kZeC2Jh2460jbLwycWg2rplRDgC4992dPnu/cDGbSv1y+o8K2NfYhV6rHek6NUYWRL9btCe+Jks3RLm7LqdMVBz5jrx0J3jkBQCG57rNuYWZehRnRVcgRgKJlziHh/F2HmsftHLCE5vdgWOuOwY+/jye4YZdAOjsc54U+qx28f9yGXZ7rXYR7g3EwaZuWOwOpOvUGOKn4iNWFUetQryQ32Uwlpw3FsUmAw439+CpT/YOeL4lBYUgj7zsPN6Olm6LaMUwYUiW4hObB4M3qvM07PLIS1EUhjJ6wiMvtS1+Ii9mXm2UmJEXwDsqn0gpI4DES9wztigDBq0KnWZbSD1FTrT3weZg0KlVKIrCMLNI0apVotkTTx3xqItOoxJppXBJ06lh0DoP92CiL9Wu/i7jijP9uu89Iy/hVIOFC0VegifToMVvL3b2fnn20wPY06+/SXMK9sspNBlQUZwJxoAN+5o8OqvG3qzJS/99GXajMZTRE35hT+rIi8eN7eQEaU7HIfES52jUKjGTJJTUEfe7DM01JkzpW1a/cukGj94OkXo7JEny6PUyuO9lt2umUYWflBHgPLmpJGeqy185pRKIyEsaRV6CYe5JxTh3fBFsDoZfve3d+yXVDLscHn35Ym8TdhzjlUbZMdwiJyLy0u3peYlN2ohHXo619cLuI+rNIy+J6nkB3OXSQHz8/UOBxEsCMDGMIY2J5Hfh9G9UJ5ffhcPvroMpl+YzjSoDNOzSa9SiE2c0TbsUeQmd3150EtJ1anx1uBWvb3H3fmlO0RlR3Pfy6Z5GMXw0Hjqrcs9Lm4+0UWGU00YlWUZoVBKsdiYElCfJEHnxThtR5IWQGT5rIpSKo0QUL/1HBMhVacQJZTijeyyA/8gLEBvfC3leQqc024gl540DAPz+P9XiYtTiGg2QSmkjAJg+Ig86tQp1HX2w2hly0rRxMUIkp1+pNGPMIwIb3bSRWiWJDse+fC+9lsTu8wI4KymrKotwzYzhokw9USDxkgDwO6JdxztgsTkCL3aRkOLFoHTkhfd6CZziae+14lib82TF++z4IxYVR6loMpWDBTPLcfKQLHT02fC7D6oBAC1dqbkvjTo1ppbniH+fPDQ7LsruedrIbHOg12JHe69VnPOi3ecF8CyXHuh76RZTpRM38qJRq/C3BVPxwMUTYr0pIUPiJQEYnpeGLKMWFrtDRAQGI5F6vHDcjeqc4Vil0kaDRV74Ph6SbRTb5I+RMej1wisxqLtuaKhVEh6+1Nn75f3tx/Hf7+rEBSjVPC+AO3UEABOHxEfKIF2nhs7VRbelxyKiLllGLQza6IsEMV3aR+SFVy0mcuQlkSHxkgBIkiTykduD9L0kYuRFac+Lu9dL4MjLbtFZd/ABdSPynX0xDkaxyy7NNQqfk4dm4dqZIwAA97y9AwCgVUsRV7MlImeNLhD/Hy9+B0mSkO3R68VdaRSbY12US/uKvIjxAIkbeUlkSLwkCDx1FEzFUUefVXSoTKTIi8no3WVXds8Lj7wMYtitDjDTqD8jCvhk1h6v5npKYXcwYWakyEt4LDlvLEqzDF6TueMhZRJtTio1oTwvDZl6DaYMzxn8BVGCR8FaeyzuSqMom3U5gcql3eMBUk/4xgMkXhIEfmf0bRCmXZ4yykvXJdTsm/6l0k0yR15ygzTs1gwy08iTEpMBeo0KVjvz20ZcTtp7reBVmzkJZrCLF9L1GvzWI8efiikjAFCpJLx500z8546zhB8sHhCRlx5rzMy6HH+N6hwO5jEegCIvsYDES4LAZ07sbehEtzlwh1j+RUukqAvgPZyRMSZ/2sh1gm4OYNh1OJi70iiItJFKJUW14ohHC0wGTdQm7CYj544vwtyTigDExggaL+Rn6EW5f7wgIi/dFtR3xEfkpa6jzyuy2usxaoIiL7GBzn4JQqHJgGKTAQ7mHBUQiNoE9LsA3p6Xjl4bLK6TRb7caaMui9+OuEdbe9FtsUOnVglRMhi84iiUDsjhIvwucXSnnKg8dOnJuOK0Miw6Z3SsN4XwICfNM20U28hLQYYeOo0KdgfDiXZ3rxcedZEkiM7dRHShvZ5ABJs6SkSzLuDd56Wxy3miMBk0slUZ8Ds6m4OJiqb+VLtSRmOKMqAJMrLhjrwob9p1+zTI7xIp+Rl6/P6HEzF9ZF6sN4XwQIiXbgsaY2zYVakkDM0eaNr19Lukol8qHiDxkkBMcqWOBqs4SlTx4pk2apA5ZQQ4O+JmuqpK/PV62c3NukH4XTjuiqPoRV5SrS8JkTrkCMOuNWajATwZyk27Hr6XbjGUkfwusYLESwIhKo4GES+J2OMF8DTs2mT3u3CE78WPabem3hl5qQyi0ogjIi9R6PXS2kPddYnkJkcYdj3SRqbYDZf1VS7dkwSjARIdEi8JxMmutFFtS6/f+Tx2h7vqZVheYokX3mHX7mAiilEgc67bPSIgcORlXBBmXQ5vVHe8vU+c1JSiOUU7whKpA4+81Lb0CG9JLCMvvFGdZzVhdxKMBkh0SLwkEFlGrbhQ+hvSWN/RB4vdAa1aQnEM71bCwaBVie6a+11RDLl6vHBEubQP8ddrseNgs/P3hpI2yknXifLOQ00D+0HICUVeiGSHe14OuyLIGXoN0mPY8sFdLu0ReXFVfCbyaIBEh8RLgiE67db6Nu1yv8vQnDSoVYllJJMkSZh29zU4za9yp43yAqSN9tR3gjEgP0MX8u8dGaVyaZooTSQ7uS7xwgsCYxl1ATwb1bkjLz0UeYk5JF4SjIku34u/yMuRBPW7cLJcXXYPNCojXvJFl92BaaPdITSn60+0xgTQRGki2cnud2zHug8Pj7zUd/bBbHOKFuF5ochLzCDxkmBMKuMzjtp99ipx93iJ/Xj7cOCRF7NCk2TzAnTZFWMBQvC7cKLV64WqjYhkJ1OvgcYjahxLsy7gPGcYtWowBhxvc1Y/kecl9pB4STBOKs2CWiWhqcvs1TSJk6hl0pz+U5zl9rzwtFGTD8Mu76wbilmXE60uu0K80GgAIklxDmd0H99FMY68SJKEslxv3wv3vNBQxthB4iXBMGjVGFfkvLj6GtKYdOJFds+Lb8MuY0ykjSpLwkkbKS9eei120ZY8N4PEC5G8eKZFYzUawBM+QoGXS1PkJfaQeElAPFNH/UnUHi8cXi4NACpJ/qF57j4v3pGXhk4zWnusUEnA6MKMkN+Xi5e2HqvfMvZIaXFVGunUKuovQSQ1npGXWI0G8KTM5Xvhpl3q8xJ7SLwkIJP8mHa7zTY0ubwciSpePCMveRl62SumuBhq67V6DVqrPuGMuowsyAhrHIFBq8YQVxtxpUy7LaLHi45akhNJTa6XeImjyIvr5pB32E2LYQl3qkPiJQHhFUc7jrbD4XCbdnlIMydN6xXBSCQ8xYvcfhfA2UNCkpxlmK09VvH47hAmSfuDR18OKNRpl0decmSORhFEvJETZ2kj7nlxR16c4oUiL7GDxEsCMrYoAwatCp1mm1d1y5HmxPa7AIDJ6L6TUaJEUq2SxF2dZ7l0jYziRSnfS4tre/NIvBBJTo5n5CUOmm0OFV12XYZdV9qIIi+xQzHx0tLSgvnz58NkMiE7OxvXX389uroGD6dv3LgR//d//4f09HSYTCacffbZ6O3tHfR1qYRGrcKEUj5huk08nug9XoB+kReFwsXCtOtRLs3TRuH0eOEoL16ckSKKvBDJDhcvBq0KmXEgEPiIgKYuC3otdrdhV6aJ90ToKCZe5s+fj++++w5r1qzBBx98gM8++ww33HBDwNds3LgR559/Ps477zxs3rwZW7ZswaJFi6BSUYCoPzx15FlxVJvglUaAu88LoKB4Sfcul7bYHNjvaopXEcJAxv6MKKDIC0HIARfohZmGuPB3mYwaIaKOtva4S6WpSV3MUETSVldXY/Xq1diyZQumTp0KAHjqqacwb948PPbYYygtLfX5ul/84he47bbbcM8994jHxo0bF/B3mc1mmM3u8H9HR4cMnyD+8VVxlOhl0oDynhdgYOTlQFMXrHaGTL1GmG7DYZTostsNh4NBJbPZWEReqMcLkeTwKOaYMCr/lECSJAzNTUP1iQ7UtvZ4eF5iHxVKVRQJaWzcuBHZ2dlCuABAVVUVVCoVNm3a5PM1DQ0N2LRpEwoLCzFz5kwUFRVh1qxZ+OKLLwL+ruXLlyMrK0v8lJWVyfpZ4hVecbTrRAcsrm60ySBePI3GykVevD0vfJJ0RUlmRHd5Q3KM0KolmG0OHG+XP9XJIy/U44VIdk4dlo03bjgdj142KdabIvAsl+6m8QAxRxHxUldXh8LCQq/HNBoNcnNzUVdX5/M1Bw4cAADcf//9WLhwIVavXo1TTz0Vc+bMwd69e/3+rqVLl6K9vV381NbWyvdB4pjheWnIMmphsTlQU9cJh4Oh1uWET2jPS1o0PC/O9+X9WHZH0FnXE7VKwvA85VJHra7IC3XXJZIdSZIwfWSe7H2eIsGzXJoGM8aekMTLPffcA0mSAv7s3r07rA1xOJzRgxtvvBHXXXcdTjnlFDz++OMYN24cXnzxRb+v0+v1MJlMXj+pgCRJ7gnTR9vQ0GmGxeaARiWhJCv27vxwydBpRG8XpQ27vCdOJAMZ+6OkaZdHinJoKCNBRB1eLn2wqUdEuyltFDtC2vNLlizBtddeG3DNyJEjUVxcjIaGBq/HbTYbWlpaUFxc7PN1JSUlAIDx48d7PV5ZWYkjR46Espkpw6Sh2fh8bxO+PdqGsa6RAUNyjNCoE9fgrFJJWHjWSBxv68UIVxRDbrhhl3fZ5WmjygjMupyRCvZ64X1p8mgoI0FEHR552VPfKR4zUp+XmBGSeCkoKEBBQcGg62bMmIG2tjZs3boVU6ZMAQB88skncDgcmD59us/XlJeXo7S0FDU1NV6P79mzBxdccEEom5kyiMhLbTumjcgDkNh+F849F1Qo+v75HvONWrstqOtwDrjkAjASlIq82B0MraJJHUVeCCLa8MgL9xZq1RJ0msS9UUx0FNnzlZWVOP/887Fw4UJs3rwZGzZswKJFi3DFFVeISqNjx46hoqICmzdvBuBMg/zyl7/En//8Z7z55pvYt28ffvOb32D37t24/vrrldjMhGdSWTYAYG9DJ2pcqY9E9rtEizwx38gi/C5luUZkytCVeGSBszrigMwjAtp7rWCuZspUbUQQ0YdHXjjkd4ktiu391157DYsWLcKcOXOgUqnwwx/+EH/+85/F81arFTU1Nejp6RGP3XHHHejr68MvfvELtLS0YNKkSVizZg1GjRql1GYmNEUmA4pNBtR19OHDHU4jdDJEXpSGe166zDZsdzX5G1ckj1eKR16OtvbCbLNDr5EnrMwrjUwGDbQJnBYkiEQlQ69BTppWpG9pNEBsUUy85ObmYtWqVX6fLy8vB2NswOP33HOPV58XIjATh2ahblcfjrU5K41IvAxOpl4DrVqC1c6wYV8TAHn8LoAzJZWp16DTbMOR5h6MkSEVBbh7vOQp1PuGIIjBKctNQ2uPs7cWjQaILXQLl+Dw1BGHxMvgSJIkTK9bDrUAkKfSiL8377R7QEbfC4+85KSR34UgYsXQHHcTS4q8xBYSLwkOb1bHIc9LcPDUUZ/VWfIYyViA/ihh2uWRl1yqNCKImFHm4Xshz0tsIfGS4JzsqjgCnH4Iz/b6hH880y96jQrlMpZlC/EiY7m06K5LlUYEETM8Iy9pFHmJKSReEpwso1ZcLIflUdQlWPI9OneOLcoUjfHkgFccUeSFIJKLoR6RbfK8xBYSL0nAJFf0hfwuwZPnMR+oIsKxAP0RjepkLJemyAtBxJ4y8rzEDSRekoDzJxRDJQFnjRm8gSDhxDNtVFEi70iJcpd4aeqyoL3XKst7tvRQ5IUgYs1Q8rzEDSRekoDzJ5Rg1wPn48ppw2K9KQmD58C3SpkjLxl6DQpdc5kOyZQ6osgLQcQeg1aNfNeND02Uji0kXpIEg5a+SKGQ75E2inSatC/krjhqJc8LQcQFfEwARV5iC4kXIiUpzXaegEqyDIo0fhspc68XPlE6l0YDEERMqXSlmUuzDTHektSGpCORkowrysRDl06QZRijL0bmy1dx1Guxi340uRkkXggiltw9twJzKgpx9ljyGMYSEi9ESiJJEuZPH67Y+/O00YHGyCuOeNRFp1ZRhQNBxJisNC3mVBbFejNSHkobEYQC8BEBB5u6fc7wCgW330UHSZKvHw1BEESiQuKFIBSgLCcNapWEHosdDZ3miN6LR15y0illRBAEAZB4IQhF0GlUoqHVgQjHBLT2WAAAeSReCIIgAJB4IQjFkGtMQHOXU7xQ5IUgCMIJiReCUAh3r5fITLsUeSEIgvCGxAtBKIS74iiyyEtLtyvyQj1eCIIgAJB4IQjFGClTl10uXqjHC0EQhBMSLwShELxc+khLD6x2R9jvI8QLRV4IgiAAkHghCMUoyjTAqFXD5mA42tob9vsI8UKeF4IgCAAkXghCMVQqSRbTLokXgiAIb0i8EISC8NRRuKZdu4OhrdfdYZcgCIIg8UIQisJNu/vDnHHU1mMBny6QnaaVa7MIgiASGhIvBKEgE4ZkAQA27GsOa8YR7/GSZdRCq6avK0EQBEDihSAU5czR+dCpVTjS0hNW9IV316WUEUEQhBsSLwShIOl6DWaMygMAfFzdEPLreeSFxAtBEIQbEi8EoTBVlYUAgLXV9SG/tpm66xIEQQyAxAtBKMw5FU7xsvVwK1pdYiRY+Hqaa0QQBOGGxAtBKMzQnDRUFGfCwYD1e0JLHYnIC4kXgiAIAYkXgogCVZVFAEL3vVDkhSAIYiAkXggiCsxx+V4+q2mExRb8nCOKvBAEQQyExAtBRIFJQ7ORn6FDp9mGrw61BP06Xm1EkReCIAg3iomXlpYWzJ8/HyaTCdnZ2bj++uvR1RW4z0VdXR1+8pOfoLi4GOnp6Tj11FPx1ltvKbWJBBE1VCoJ54xzRl9CSR21dFHkhSAIoj+KiZf58+fju+++w5o1a/DBBx/gs88+ww033BDwNddccw1qamrw/vvvY8eOHfjBD36AH//4x/jmm2+U2kyCiBpzXL6Xtbvrg+6220KRF4IgiAEoIl6qq6uxevVq/O1vf8P06dNx5pln4qmnnsLrr7+O48eP+33dl19+iVtvvRXTpk3DyJEjce+99yI7Oxtbt25VYjMJIqqcNcbZbfdwcw/2BzGoscdiQ5/V6Y+hyAtBEIQbRcTLxo0bkZ2djalTp4rHqqqqoFKpsGnTJr+vmzlzJt544w20tLTA4XDg9ddfR19fH2bPnu33NWazGR0dHV4/BBGPpOs1ON3VbTeYhnUtLrOuTqNCuk6t6LYRBEEkEoqIl7q6OhQWFno9ptFokJubi7q6Or+v+8c//gGr1Yq8vDzo9XrceOONeOeddzB69Gi/r1m+fDmysrLET1lZmWyfgyDkxt1td3DfCxcvuWk6SJKk6HYRBEEkEiGJl3vuuQeSJAX82b17d9gb85vf/AZtbW34+OOP8dVXX2Hx4sX48Y9/jB07dvh9zdKlS9He3i5+amtrw/79BKE0/+fqtvvV4ZZBu+0K8UIpI4IgCC80oSxesmQJrr322oBrRo4cieLiYjQ0eN9Z2mw2tLS0oLi42Ofr9u/fj7/85S/YuXMnTjrpJADApEmT8Pnnn+Ppp5/GihUrfL5Or9dDr9eH8jEIImbwbru76zrx6Z5GXHLKEL9rSbwQBEH4JiTxUlBQgIKCgkHXzZgxA21tbdi6dSumTJkCAPjkk0/gcDgwffp0n6/p6ekBAKhU3sEgtVoNhyP4pl4EEe/MqSzE7rpOfFxdT+KFIAgiDBTxvFRWVuL888/HwoULsXnzZmzYsAGLFi3CFVdcgdLSUgDAsWPHUFFRgc2bNwMAKioqMHr0aNx4443YvHkz9u/fjz/+8Y9Ys2YNLrnkEiU2kyBiAi+Z/nRPI6x2/8KcxAtBEIRvFOvz8tprr6GiogJz5szBvHnzcOaZZ+K5554Tz1utVtTU1IiIi1arxYcffoiCggJceOGFmDhxIl555RW8/PLLmDdvnlKbSRBRZ9LQbOSl69DZZ8OWg/677fLuuiReCIIgvAkpbRQKubm5WLVqld/ny8vLBzTqGjNmDHXUJZIetUrCORWFeHPrUazd3YCZo/N9rmum7roEQRA+odlGBBED3CXT/rvt0lwjgiAI35B4IYgYcOaYAujUKhwK0G1XTJROI/FCEAThCYkXgogBGXoNpo/MBeC/2y7vA5OXQeKFIAjCExIvBBEjqsSgxoHddu0OhrZeKwCKvBAEQfSHxAtBxAjebXfr4Va09Xh3223rsYBbYXLStNHeNIIgiLiGxAtBxIiy3DSMK8qE3cGwvqbR6zne4yXLqIVGTV9TgiAIT+isSBAxZA6vOuqXOuLihSqNCIIgBkLihSBiCO+2u76mwavbLhcv1OOFIAhiICReCCKGTC7z6LZ7yN1tt4W66xIEQfiFxAtBxBC1SsLscbxhnTt11OLqrptLlUYEQRADIPFCEDGGd9v9xMP3IiIv1OOFIAhiACReCCLGnDXW2W33YFM39jd2AfCYKE2RF4IgiAGQeCGIGOOr264QL+R5IQiCGACJF4KIA+a4GtZ97PK9kHghCILwD4kXgogDeMk077bbSuKFIAjCLyReCCIO8Oy2++meRjFRmsQLQRDEQEi8EESc8H+uqqN/bT8Os83ZsI7EC0EQxEBIvBBEnMBLpte55hzpNCqk6dSx3CSCIIi4hMQLQcQJk8tykJuug93hHCedl66DJEkx3iqCIIj4g8QLQcQJapWEc1zddgEgh3q8EARB+ITEC0HEEXzKNADkUXddgiAIn5B4IYg44qwx+dCqnakiirwQBEH4hsQLQcQRmQYtTh+ZB4AqjQiCIPyhifUGEAThzU2zRuFoay++N7Ek1ptCEAQRl0iMMRbrjZCTjo4OZGVlob29HSaTKdabQxAEQRBEEIRy/aa0EUEQBEEQCQWJF4IgCIIgEgoSLwRBEARBJBQkXgiCIAiCSChIvBAEQRAEkVCQeCEIgiAIIqEg8UIQBEEQREJB4oUgCIIgiIRCMfHy0EMPYebMmUhLS0N2dnZQr2GM4b777kNJSQmMRiOqqqqwd+9epTaRIAiCIIgERDHxYrFYcNlll+Gmm24K+jWPPPII/vznP2PFihXYtGkT0tPTMXfuXPT19Sm1mQRBEARBJBiKjwdYuXIl7rjjDrS1tQVcxxhDaWkplixZgjvvvBMA0N7ejqKiIqxcuRJXXHGFz9eZzWaYzWbx746ODpSVldF4AIIgCIJIIBJyPMDBgwdRV1eHqqoq8VhWVhamT5+OjRs3+n3d8uXLkZWVJX7KysqisbkEQRAEQcSIuBEvdXV1AICioiKvx4uKisRzvli6dCna29vFT21traLbSRAEQRBEbAlJvNxzzz2QJCngz+7du5XaVp/o9XqYTCavH4IgCIIgkhdNKIuXLFmCa6+9NuCakSNHhrUhxcXFAID6+nqUlJSIx+vr6zF58uSg34dbeDo6OsLaDoIgCIIgog+/bgdjxQ1JvBQUFKCgoCC8rRqEESNGoLi4GGvXrhVipaOjA5s2bQqpYqmzsxMAyPtCEARBEAlIZ2cnsrKyAq4JSbyEwpEjR9DS0oIjR47Abrdj27ZtAIDRo0cjIyMDAFBRUYHly5fj0ksvhSRJuOOOO/C73/0OY8aMwYgRI/Cb3/wGpaWluOSSS4L+vaWlpaitrUVmZiYkSZL1M/FKptra2pRMT6X65wdoH6T65wdoH9DnT+3PDyi3Dxhj6OzsRGlp6aBrFRMv9913H15++WXx71NOOQUAsG7dOsyePRsAUFNTg/b2drHmrrvuQnd3N2644Qa0tbXhzDPPxOrVq2EwGIL+vSqVCkOHDpXnQ/gh1b01qf75AdoHqf75AdoH9PlT+/MDyuyDwSIuHMXEy8qVK7Fy5cqAa/rntSRJwgMPPIAHHnhAqc0iCIIgCCLBiZtSaYIgCIIgiGAg8RICer0ey5Ytg16vj/WmxIRU//wA7YNU//wA7QP6/Kn9+YH42AeKjwcgCIIgCIKQE4q8EARBEASRUJB4IQiCIAgioSDxQhAEQRBEQkHihSAIgiCIhCKlxMvy5ctx2mmnITMzE4WFhbjkkktQU1Pjtaavrw+33HIL8vLykJGRgR/+8Ieor68Xz2/fvh1XXnklysrKYDQaUVlZiSeffNLrPdavX+9zaGWg6djRQo590NzcjPPPPx+lpaXQ6/UoKyvDokWLBsyTWr9+PU499VTo9XqMHj160L4/0SBanz/ZjwFPmpubMXToUEiShLa2Nq/nkvUY8MTf54/XY0Cuz+/rs73++utea+Lx7w9Ebx8k+zEAOHu6TZw4EQaDAYWFhbjlllu8nv/2229x1llnwWAwoKysDI888og8H4KlEHPnzmUvvfQS27lzJ9u2bRubN28eGzZsGOvq6hJrfv7zn7OysjK2du1a9tVXX7HTTz+dzZw5Uzz/wgsvsNtuu42tX7+e7d+/n7366qvMaDSyp556SqxZt24dA8BqamrYiRMnxI/dbo/q5/WFHPugpaWFPfPMM2zLli3s0KFD7OOPP2bjxo1jV155pVhz4MABlpaWxhYvXsx27drFnnrqKaZWq9nq1auj+nn7E63Pn+zHgCcXX3wxu+CCCxgA1traKh5P5mPAE3+fP16PAbk+PwD20ksveX223t5e8Xy8/v0Zi94+SPZj4I9//CMrLS1lr732Gtu3bx/bvn07e++998Tz7e3trKioiM2fP5/t3LmT/f3vf2dGo5E9++yzEX+GlBIv/WloaGAA2KeffsoYY6ytrY1ptVr2z3/+U6yprq5mANjGjRv9vs/NN9/MzjnnHPFvfsB6nsjiFbn2wZNPPsmGDh0q/n3XXXexk046yWvN5ZdfzubOnSvzJ4gMpT5/qhwDzzzzDJs1axZbu3btgM+bCsdAoM+fKMdAuJ8fAHvnnXf8vm+i/P0ZU24fJPMx0NLSwoxGI/v444/9vu8zzzzDcnJymNlsFo/dfffdbNy4cRFvc0qljfrD5yrl5uYCALZu3Qqr1YqqqiqxpqKiAsOGDcPGjRsDvg9/D08mT56MkpISnHvuudiwYYPMWy8PcuyD48eP4+2338asWbPEYxs3bvR6DwCYO3duwP0YC5T6/JxkPgZ27dqFBx54AK+88gpUqoGnkmQ/Bgb7/Jx4PwYi+Q7ccsstyM/Px7Rp0/Diiy96jXxJlL8/oNw+4CTjMbBmzRo4HA4cO3YMlZWVGDp0KH784x+jtrZWvGbjxo04++yzodPpxGNz585FTU0NWltbI9rmlBUvDocDd9xxB8444wxMmDABAFBXVwedTofs7GyvtUVFRX5zlF9++SXeeOMN3HDDDeKxkpISrFixAm+99RbeeustlJWVYfbs2fj6668V+zzhEOk+uPLKK5GWloYhQ4bAZDLhb3/7m3iurq4ORUVFA96jo6MDvb29ynygEFHy8yf7MWA2m3HllVfi0UcfxbBhw3y+dzIfA8F8/kQ4BiL5DjzwwAP4xz/+gTVr1uCHP/whbr75Zjz11FPi+UT4+wPK7oNkPgYOHDgAh8OBhx9+GE888QTefPNNtLS04Nxzz4XFYhHv4+sY4M9FgmKDGeOdW265BTt37sQXX3wR9nvs3LkTF198MZYtW4bzzjtPPD5u3DiMGzdO/HvmzJnYv38/Hn/8cbz66qsRbbecRLoPHn/8cSxbtgx79uzB0qVLsXjxYjzzzDMyb6VyKPn5k/0YWLp0KSorK3H11VcrtGXRQcnPnwjHQCTfgd/85jfi/0855RR0d3fj0UcfxW233SbnJiqOkvsgmY8Bh8MBq9WKP//5z+L69/e//x3FxcVYt24d5s6dq8TmClIy8rJo0SJ88MEHWLduHYYOHSoeLy4uhsViGVAxUV9fj+LiYq/Hdu3ahTlz5uCGG27AvffeO+jvnDZtGvbt2yfL9suBHPuguLgYFRUVuOiii/Dss8/ir3/9K06cOCGe6+9Mr6+vh8lkgtFoVOZDhYDSn98XyXQMfPLJJ/jnP/8JjUYDjUaDOXPmAADy8/OxbNky8T7JegwE8/l9EU/HgBzfAU+mT5+Oo0ePwmw2i/eJ578/oPw+8EWyHAMlJSUAgPHjx4vnCwoKkJ+fjyNHjoj38XUM8OciImLXTALhcDjYLbfcwkpLS9mePXsGPM9NSm+++aZ4bPfu3QNMWjt37mSFhYXsl7/8ZdC/u6qqil166aWRfQAZkGsf9OfTTz9lANjBgwcZY06z3oQJE7zWXHnllTE360Xr8/simY6Bffv2sR07doifF198kQFgX375Jauvr2eMJfcxEMzn90U8HANKfQd+97vfsZycHPHveP37Mxa9feCLZDkGampqGAAvw25zczNTqVTso48+Yoy5DbsWi0WsWbp0qSyG3ZQSLzfddBPLyspi69ev9ypb6+npEWt+/vOfs2HDhrFPPvmEffXVV2zGjBlsxowZ4vkdO3awgoICdvXVV3u9R0NDg1jz+OOPs3fffZft3buX7dixg91+++1MpVIFdGVHCzn2wb///W/24osvsh07drCDBw+yDz74gFVWVrIzzjhDrOFlkr/85S9ZdXU1e/rpp+OiTDJanz/Zj4H++KqqSOZjoD++Pn+8HgNyfP7333+fPf/882zHjh1s79697JlnnmFpaWnsvvvuE2vi9e/PWPT2QTIfA4w52wScdNJJbMOGDWzHjh3s+9//Phs/frwQK21tbayoqIj95Cc/YTt37mSvv/46S0tLo1LpUAHg8+ell14Sa3p7e9nNN9/McnJyWFpaGrv00kvZiRMnxPPLli3z+R7Dhw8Xa/7whz+wUaNGMYPBwHJzc9ns2bPZJ598EsVP6h859sEnn3zCZsyYwbKyspjBYGBjxoxhd99994BywHXr1rHJkycznU7HRo4c6fU7YkW0Pn+yHwP98VcSmqzHQH98ff54PQbk+Pz/+c9/2OTJk1lGRgZLT09nkyZNYitWrBjQvyQe//6MRW8fJPMxwJizj8tPf/pTlp2dzXJzc9mll17Kjhw54rVm+/bt7Mwzz2R6vZ4NGTKE/f73v5flM0iuD0IQBEEQBJEQpKRhlyAIgiCIxIXEC0EQBEEQCQWJF4IgCIIgEgoSLwRBEARBJBQkXgiCIAiCSChIvBAEQRAEkVCQeCEIgiAIIqEg8UIQBEEQREJB4oUgYsjKlSsHjJ1PJO6//35Mnjw51ptBADh06BAkScK2bdtivSkJxfr16yFJ0oAhhER8Q+KF8OLaa6+FJEmQJAk6nQ6jR4/GAw88AJvNFutNGxRJkvDuu+/GejO8WLduHebNm4e8vDykpaVh/PjxWLJkCY4dOxbrTZOFO++8E2vXrpXlvXp7e5Gbm4v8/HyfU3nLy8shSRL+97//eT1+xx13YPbs2V6PdXR04Ne//jUqKipgMBhQXFyMqqoqvP3226Cm4pFx7bXX4pJLLon1ZoTF7Nmzcccdd8R6MwgZIPFCDOD888/HiRMnsHfvXixZsgT3338/Hn300bDey263w+FwyLyFicGzzz6LqqoqFBcX46233sKuXbuwYsUKtLe3449//GOsN08WMjIykJeXJ8t7vfXWWzjppJNQUVHhV4QaDAbcfffdAd+nra0NM2fOxCuvvIKlS5fi66+/xmeffYbLL78cd911F9rb22XZXoIIhNVqjfUmJDeyTEgikoYFCxawiy++2Ouxc889l51++umMMcb6+vrYkiVLWGlpKUtLS2PTpk1j69atE2tfeukllpWVxd577z1WWVnJ1Go1O3jwIOvr62N33XUXGzp0KNPpdGzUqFHsb3/7m3jdjh072Pnnn8/S09NZYWEhu/rqq1ljY6N4ftasWezWW29lv/zlL1lOTg4rKipiy5YtE88PHz7c56DMffv2sYsuuogVFhay9PR0NnXqVLZmzRqvz3f8+HE2b948ZjAYWHl5OXvttdfY8OHD2eOPPy7WtLa2suuvv57l5+ezzMxMds4557Bt27b53Y+1tbVMp9OxO+64w+fzfIAf31+rV69mFRUVLD09nc2dO5cdP35crN28eTOrqqpieXl5zGQysbPPPptt3brV6/0AsOeff55dcsklzGg0stGjR7P33nvPa817773HRo8ezfR6PZs9ezZbuXLlgGGCn3/+OTvzzDOZwWBgQ4cOZbfeeivr6ury+zmXLVvGJk2aJP7Nj59HH32UFRcXs9zcXHbzzTeLKbOBmD17NluxYgX761//ys4999wBzw8fPpzddtttTKfTsX//+9/i8dtvv53NmjVL/Pumm25i6enp7NixYwPeo7Ozk1mtVr/b8P7777OpU6cyvV7P8vLy2CWXXCKee+WVV9iUKVNYRkYGKyoqYldeeSWrr68Xz7e0tLCrrrqK5efnM4PBwEaPHs1efPFF8fyRI0fYZZddxrKyslhOTg676KKL2MGDB8Xz69atY6eddhpLS0tjWVlZbObMmezQoUN+t3XTpk1s8uTJTK/XsylTprC3336bAWDffPMNY8x9bHnyzjvvsP6n/XfffZedcsopTK/XsxEjRrD777/f7z7yNZiWf/+//fZbds4554ghhAsXLmSdnZ1+t3/KlCns0UcfFf+++OKLmUajEa+pra1lANjevXsZY4Ofe5qamtgVV1zBSktLmdFoZBMmTGCrVq0Szy9YsGDAth88eFAM1fz444/ZlClTmNFoZDNmzGC7d+8OaT8BYM888wy78MILWVpamtf5iZAfEi+EF77Ey0UXXcROPfVUxhhjP/vZz9jMmTPZZ599xvbt28ceffRRptfr2Z49exhjzhOmVqtlM2fOZBs2bGC7d+9m3d3d7Mc//jErKytjb7/9Ntu/fz/7+OOP2euvv84Yc17ICwoK2NKlS1l1dTX7+uuv2bnnnsvOOeccsQ2zZs1iJpOJ3X///WzPnj3s5ZdfZpIksf/+97+MMcYaGhrEVNQTJ06whoYGxhhj27ZtYytWrGA7duxge/bsYffeey8zGAzs8OHD4r2rqqrY5MmT2f/+9z+2detWNmvWLGY0Gr3ES1VVFbvwwgvZli1b2J49e9iSJUtYXl4ea25u9rkf//SnPzEAXiLEF3x/VVVVsS1btrCtW7eyyspKdtVVV4k1a9euZa+++iqrrq5mu3btYtdffz0rKipiHR0dYg0ANnToULZq1Sq2d+9edtttt7GMjAyxfQcOHGBarZbdeeedbPfu3ezvf/87GzJkiJd42bdvH0tPT2ePP/4427NnD9uwYQM75ZRT2LXXXut3+32JF5PJxH7+85+z6upq9q9//YulpaWx5557LuB+2LdvH9Pr9aylpYU1Nzczg8Ew4MLNBeVtt93GJk6cKKb3eooXu93OcnJy2A033BDw9/nigw8+YGq1mt13331s165dbNu2bezhhx8Wz7/wwgvsww8/ZPv372cbN25kM2bMYBdccIF4/pZbbmGTJ09mW7ZsYQcPHmRr1qxh77//PmOMMYvFwiorK9lPf/pT9u2337Jdu3axq666io0bN46ZzWZmtVpZVlYWu/POO9m+ffvYrl272MqVK72OU086OztZQUEBu+qqq9jOnTvZv/71LzZy5MiQxctnn33GTCYTW7lyJdu/fz/773//y8rLy9n999/v9/f++Mc/Zueffz47ceIEO3HiBDObzayrq4uVlJSwH/zgB2zHjh1s7dq1bMSIEWzBggV+9/fixYvZ9773PcYYYw6Hg+Xm5rL8/Hz2n//8hzHG2P/7f/+PDRkyRKwf7Nxz9OhR9uijj7JvvvmG7d+/n/35z39marWabdq0iTHGWFtbG5sxYwZbuHCh2HabzSbEy/Tp09n69evZd999x8466yw2c+bMkPYTAFZYWMhefPFFtn//fr9/O0IeSLwQXniKF4fDwdasWcP0ej2788472eHDh5larR5wRztnzhy2dOlSxpjzhAnAKypRU1PDAAyIeHAefPBBdt5553k9xu+6ampqGGNO8XLmmWd6rTnttNPY3XffLf4NgL3zzjuDfsaTTjqJPfXUU4wxxqqrqxkAtmXLFvH83r17GQAhXj7//HNmMplYX1+f1/uMGjWKPfvssz5/x0033cRMJtOg28L31759+8RjTz/9NCsqKvL7GrvdzjIzM9m//vUv8RgAdu+994p/d3V1MQDiQnD33XezCRMmeL3Pr3/9ay/xcv311w+46H/++edMpVKx3t5en9viS7wMHz6c2Ww28dhll13GLr/8cr+fhzHGfvWrX3lFOS6++OIBd65cvDQ0NLDMzEz2yiuvMMa8xUt9fT0DwP70pz8F/H2+mDFjBps/f37Q67ds2cIAiEjBhRdeyK677jqfa1999VU2btw45nA4xGNms5kZjUb20UcfsebmZgaArV+/Pqjf/eyzz7K8vDyvv8tf//rXkMXLnDlzvAQa39aSkhK/v9vXDc5zzz3HcnJyvKJ0//73v5lKpWJ1dXU+3+f9999nWVlZzGazsW3btrHi4mJ2++23i+/0z372MyHigzn3+OJ73/seW7Jkifj3rFmz2O233+61xjPy4rntAMT+DWY/AfAbaSXkhzwvxAA++OADZGRkwGAw4IILLsDll1+O+++/Hzt27IDdbsfYsWORkZEhfj799FPs379fvF6n02HixIni39u2bYNarcasWbN8/r7t27dj3bp1Xu9ZUVEBAF7v6/meAFBSUoKGhoaAn6Wrqwt33nknKisrkZ2djYyMDFRXV+PIkSMAgJqaGmg0Gpx66qniNaNHj0ZOTo7X9nV1dSEvL89rGw8ePOi1fZ4wxiBJUsBt46SlpWHUqFF+P1d9fT0WLlyIMWPGICsrCyaTCV1dXeIzcDz3T3p6Okwmk3ifmpoanHbaaV7rp02b5vXv7du3Y+XKlV6fce7cuXA4HDh48GBQnwUATjrpJKjVar+fpz92ux0vv/wyrr76avHY1VdfjZUrV/r0SxUUFODOO+/EfffdB4vF4vUci8CMu23bNsyZM8fv81u3bsWFF16IYcOGITMzUxzP/O9w00034fXXX8fkyZNx11134csvvxSv3b59O/bt24fMzEyxb3Nzc9HX14f9+/cjNzcX1157LebOnYsLL7wQTz75JE6cOOF3W6qrqzFx4kQYDAbx2IwZM0L+zNu3b8cDDzzg9TdfuHAhTpw4gZ6enqDfp7q6GpMmTUJ6erp47IwzzoDD4UBNTY3P15x11lno7OzEN998g08//RSzZs3C7NmzsX79egDAp59+KozYwZx77HY7HnzwQZx88snIzc1FRkYGPvroowHfE394fn9KSkoAQBy3we6nqVOnBrfDiIjRxHoDiPjjnHPOwV//+lfodDqUlpZCo3EeJl1dXVCr1di6davXxQlwGjc5RqPR68JtNBoD/r6uri5ceOGF+MMf/jDgOX4SAQCtVuv1nCRJg5qB77zzTqxZswaPPfYYRo8eDaPRiB/96EcDLnqDbV9JSYk4qXrir8x57NixaG9vx4kTJ7w+gy98fS7Pi/CCBQvQ3NyMJ598EsOHD4der8eMGTMGfIZw9o8nXV1duPHGG3HbbbcNeG7YsGFBv0+o2/HRRx/h2LFjuPzyy70et9vtWLt2Lc4999wBr1m8eDGeeeYZPPPMM16PFxQUIDs7G7t37w56ezmBjtPu7m7MnTsXc+fOxWuvvYaCggIcOXIEc+fOFX+HCy64AIcPH8aHH36INWvWYM6cObjlllvw2GOPoaurC1OmTMFrr7024L0LCgoAAC+99BJuu+02rF69Gm+88QbuvfderFmzBqeffnrInwUAVCrVADHX30Ta1dWF3/72t/jBD34w4PWewkgJsrOzMWnSJKxfvx4bN27Eueeei7PPPhuXX3459uzZg7179wqBGMy559FHH8WTTz6JJ554AieffDLS09Nxxx13BP1d9zxu+fmLH7fB7idP8UYoC4kXYgDp6ekYPXr0gMdPOeUU2O12NDQ04Kyzzgr6/U4++WQ4HA58+umnqKqqGvD8qaeeirfeegvl5eVCKIWDVquF3W73emzDhg249tprcemllwJwnoQOHToknh83bhxsNhu++eYbTJkyBQCwb98+tLa2em1fXV0dNBoNysvLg9qWH/3oR7jnnnvwyCOP4PHHHx/wfFtbW9D9XTZs2IBnnnkG8+bNAwDU1taiqakpqNdyxo0bhw8//NDrsS1btnj9+9RTT8WuXbt8/u2V5IUXXsAVV1yBX//6116PP/TQQ3jhhRd8ipeMjAz85je/wf3334+LLrpIPK5SqXDFFVfg1VdfxbJly1BaWur1uq6uLhgMBp/H2cSJE7F27Vpcd911A57bvXs3mpub8fvf/x5lZWUAgK+++mrAuoKCAixYsAALFizAWWedhV/+8pd47LHHcOqpp+KNN95AYWEhTCaT331xyimn4JRTTsHSpUsxY8YMrFq1yqd4qaysxKuvvoq+vj5x8exfQl5QUIDOzk50d3eLi2r/HjCnnnoqampqQvqb63S6Ad+zyspKrFy50ut3bdiwASqVCuPGjfP7XrNmzcK6deuwefNmPPTQQ8jNzUVlZSUeeughlJSUYOzYsWK/DHbu2bBhAy6++GIRwXM4HNizZw/Gjx8fcNuDIZz9RCgLpY2IoBk7dizmz5+Pa665Bm+//TYOHjyIzZs3Y/ny5fj3v//t93Xl5eVYsGABfvrTn+Ldd9/FwYMHsX79evzjH/8AANxyyy1oaWnBlVdeiS1btmD//v346KOPcN1114V0oikvL8fatWtRV1cnxMeYMWPw9ttvY9u2bdi+fTuuuuoqryhARUUFqqqqcMMNN2Dz5s345ptvcMMNN3hFj6qqqjBjxgxccskl+O9//4tDhw7hyy+/xK9//WufFzAAKCsrw+OPP44nn3wS119/PT799FMcPnwYGzZswI033ogHH3ww6M81ZswYvPrqq6iursamTZswf/78QaNZ/bnxxhuxe/du3H333dizZw/+8Y9/YOXKlQDcd5l33303vvzySyxatAjbtm3D3r178d5772HRokUh/a5QaGxsxL/+9S8sWLAAEyZM8Pq55ppr8O6776KlpcXna2+44QZkZWVh1apVXo8/9NBDKCsrw/Tp0/HKK69g165d2Lt3L1588UWccsop6Orq8vl+y5Ytw9///ncsW7YM1dXV2LFjh4gGDhs2DDqdDk899RQOHDiA999/f8Df8L777sN7772Hffv24bvvvsMHH3yAyspKAMD8+fORn5+Piy++GJ9//rn4Dtx22204evQoDh48iKVLl2Ljxo04fPgw/vvf/2Lv3r3i9f256qqrIEkSFi5ciF27duHDDz/EY4895rVm+vTpSEtLw69+9Svs378fq1atEn9zz21+5ZVX8Nvf/hbfffcdqqur8frrr+Pee+/1/QeD83v27bffoqamBk1NTbBarZg/fz4MBgMWLFiAnTt3Yt26dbj11lvxk5/8BEVFRX7fa/bs2fjoo4+g0WhEqnj27Nl47bXXvNLMwZx7xowZgzVr1uDLL79EdXU1brzxRtTX1w/Y9k2bNuHQoUNoamoKOjIZzn4iFCa2lhsi3vBlxvPEYrGw++67j5WXlzOtVstKSkrYpZdeyr799lvGmG+TIGOM9fb2sl/84hespKSE6XS6AWWke/bsYZdeeinLzs5mRqORVVRUsDvuuEMYHH0Z7S6++GKvaob333+fjR49mmk0GlEqffDgQXbOOecwo9HIysrK2F/+8pcB73X8+HF2wQUXML1ez4YPH85WrVrFCgsL2YoVK8Sajo4Oduutt7LS0lKm1WpZWVkZmz9/Pjty5EjA/blmzRo2d+5clpOTwwwGA6uoqGB33nmnqEIKxlT59ddfs6lTpzKDwcDGjBnD/vnPfw4o5YYPs3JWVhZ76aWXxL/7l0pzg6en6XPz5s3s3HPPZRkZGSw9PZ1NnDiRPfTQQ34/n79SaU/6lzJ78thjj7Hs7GyfpdRms5llZ2ezJ598kjHGBnxmxhhbtWoVAzDg/dva2tg999zDxowZw3Q6HSsqKmJVVVXsnXfe8TLN9uett95ikydPZjqdjuXn57Mf/OAHXr+rvLyc6fV6NmPGDPb+++97GWQffPBBVllZyYxGI8vNzWUXX3wxO3DggHj9iRMn2DXXXMPy8/OZXq9nI0eOZAsXLmTt7e2srq6OXXLJJeL7MXz4cHbfffeJiipfbNy4kU2aNInpdDo2efJk9tZbb3ltD2POY2n06NHMaDSy73//++y5554bUCq9evVqNnPmTGY0GpnJZGLTpk0LWB3W0NAgjhFEUCrNGGPNzc1MkiQvQzc//j2/f4wNfu5pbm5mF198McvIyGCFhYXs3nvvZddcc43X8VhTU8NOP/10ZjQaB5RKe7YM+Oabb8Tzwe4nX99BQjkkxqjdJEF4cvToUZSVleHjjz8OaOBMdB566CGsWLECtbW1sd4UgiCIkCDPC5HyfPLJJ+jq6sLJJ5+MEydO4K677kJ5eTnOPvvsWG+arDzzzDM47bTTkJeXhw0bNuDRRx9VNCVEEAShFCReiJTHarXiV7/6FQ4cOIDMzEzMnDkTr7322oCqmURn7969+N3vfoeWlhYMGzYMS5YswdKlS2O9WQRBECFDaSOCIAiCIBIKqjYiCIIgCCKhIPFCEARBEERCQeKFIAiCIIiEgsQLQRAEQRAJBYkXgiAIgiASChIvBEEQBEEkFCReCIIgCIJIKEi8EARBEASRUPx/Tlk+weTrwwoAAAAASUVORK5CYII=" + }, + "metadata": {}, + "output_type": "display_data" } ], - "execution_count": 6 + "execution_count": 25 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "# Negative values - missed cases?", + "id": "247b1e99fa019564" }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-09T11:44:47.122067Z", - "start_time": "2025-01-09T11:44:47.119725Z" + "end_time": "2025-01-09T12:05:33.249117Z", + "start_time": "2025-01-09T12:05:33.241578Z" } }, "cell_type": "code", "source": [ - "births_model_subset = births_model.iloc[15:].copy()\n", - "\n", - "matching_rows = min(len(births_model_subset), len(predictions_from_cmip_sum))\n", - "\n", - "multiplied_values = births_model_subset.head(matching_rows).iloc[:, 1].values * predictions_from_cmip_sum['Percentage_Difference'].head(matching_rows).values\n", + "negative_sum = np.sum(multiplied_values[multiplied_values < 0])\n", "\n", - "births_model_subset['Multiplied_Values'] = multiplied_values" + "print(\"Sum of values < 0:\", negative_sum)\n", + "print(negative_sum/births_model_subset['Model_mean'].sum() * 100)\n" ], - "id": "fd6b107fed0933cb", - "outputs": [], - "execution_count": 7 + "id": "67d8c94409dcd37", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sum of values < 0: -87753.71340159839\n", + "-0.30641921667530275\n" + ] + } + ], + "execution_count": 26 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "Difference by Zone", + "id": "197776c5bef6b35c" }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-09T11:44:47.146371Z", - "start_time": "2025-01-09T11:44:47.122652Z" + "end_time": "2025-01-09T11:52:20.723816Z", + "start_time": "2025-01-09T11:52:20.533633Z" } }, "cell_type": "code", - "source": "predictions_from_cmip_sum", - "id": "4fa2a35688fd5c48", + "source": [ + "predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'Zone']).sum().reset_index()\n", + "\n", + "# Plot each zone\n", + "plt.figure(figsize=(10, 6))\n", + "for zone in predictions_from_cmip_sum['Zone'].unique():\n", + " zone_data = predictions_from_cmip_sum[predictions_from_cmip_sum['Zone'] == zone]\n", + " zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data['Predicted_No_Weather_Model']) * 100\n", + " plt.plot(zone_data['Year'], zone_data['Percentage_Difference'], label=f'Zone {zone}')\n", + "\n", + "plt.xlabel(\"Year\")\n", + "plt.ylabel(\"Change ANC cases due to weather\")\n", + "plt.axhline(y=0, color='black', linestyle='--')\n", + "plt.ylim(-1.5, 0)\n", + "plt.legend(title='Zones')\n", + "plt.show()" + ], + "id": "8f79bf2846942b7f", "outputs": [ - { - "data": { - "text/plain": [ - " Year Month Facility_ID Altitude \\\n", - "0 2025 25584 643536 3435564.0 \n", - "1 2026 25584 643536 3435564.0 \n", - "2 2027 25584 643536 3435564.0 \n", - "3 2028 25584 643536 3435564.0 \n", - "4 2029 25584 643536 3435564.0 \n", - "5 2030 25584 643536 3435564.0 \n", - "6 2031 25584 643536 3435564.0 \n", - "7 2032 25584 643536 3435564.0 \n", - "8 2033 25584 643536 3435564.0 \n", - "9 2034 25584 643536 3435564.0 \n", - "10 2035 25584 643536 3435564.0 \n", - "11 2036 25584 643536 3435564.0 \n", - "12 2037 25584 643536 3435564.0 \n", - "13 2038 25584 643536 3435564.0 \n", - "14 2039 25584 643536 3435564.0 \n", - "15 2040 25584 643536 3435564.0 \n", - "16 2041 25584 643536 3435564.0 \n", - "17 2042 25584 643536 3435564.0 \n", - "18 2043 25584 643536 3435564.0 \n", - "19 2044 25584 643536 3435564.0 \n", - "20 2045 25584 643536 3435564.0 \n", - "21 2046 25584 643536 3435564.0 \n", - "22 2047 25584 643536 3435564.0 \n", - "23 2048 25584 643536 3435564.0 \n", - "24 2049 25584 643536 3435564.0 \n", - "25 2050 25584 643536 3435564.0 \n", - "26 2051 25584 643536 3435564.0 \n", - "27 2052 25584 643536 3435564.0 \n", - "28 2053 25584 643536 3435564.0 \n", - "29 2054 25584 643536 3435564.0 \n", - "30 2055 25584 643536 3435564.0 \n", - "31 2056 25584 643536 3435564.0 \n", - "32 2057 25584 643536 3435564.0 \n", - "33 2058 25584 643536 3435564.0 \n", - "34 2059 25584 643536 3435564.0 \n", - "35 2060 25584 643536 3435564.0 \n", - "36 2061 25584 643536 3435564.0 \n", - "37 2062 25584 643536 3435564.0 \n", - "38 2063 25584 643536 3435564.0 \n", - "39 2064 25584 643536 3435564.0 \n", - "40 2065 25584 643536 3435564.0 \n", - "41 2066 25584 643536 3435564.0 \n", - "42 2067 25584 643536 3435564.0 \n", - "43 2068 25584 643536 3435564.0 \n", - "44 2069 25584 643536 3435564.0 \n", - "45 2070 25584 643536 3435564.0 \n", - "\n", - " Zone \\\n", - "0 Central WestSouth EastNorthernSouth EastNorthe... \n", - "1 Central WestSouth EastNorthernSouth EastNorthe... \n", - "2 Central WestSouth EastNorthernSouth EastNorthe... \n", - "3 Central WestSouth EastNorthernSouth EastNorthe... \n", - "4 Central WestSouth EastNorthernSouth EastNorthe... \n", - "5 Central WestSouth EastNorthernSouth EastNorthe... \n", - "6 Central WestSouth EastNorthernSouth EastNorthe... \n", - "7 Central WestSouth EastNorthernSouth EastNorthe... \n", - "8 Central WestSouth EastNorthernSouth EastNorthe... \n", - "9 Central WestSouth EastNorthernSouth EastNorthe... \n", - "10 Central WestSouth EastNorthernSouth EastNorthe... \n", - "11 Central WestSouth EastNorthernSouth EastNorthe... \n", - "12 Central WestSouth EastNorthernSouth EastNorthe... \n", - "13 Central WestSouth EastNorthernSouth EastNorthe... \n", - "14 Central WestSouth EastNorthernSouth EastNorthe... \n", - "15 Central WestSouth EastNorthernSouth EastNorthe... \n", - "16 Central WestSouth EastNorthernSouth EastNorthe... \n", - "17 Central WestSouth EastNorthernSouth EastNorthe... \n", - "18 Central WestSouth EastNorthernSouth EastNorthe... \n", - "19 Central WestSouth EastNorthernSouth EastNorthe... \n", - "20 Central WestSouth EastNorthernSouth EastNorthe... \n", - "21 Central WestSouth EastNorthernSouth EastNorthe... \n", - "22 Central WestSouth EastNorthernSouth EastNorthe... \n", - "23 Central WestSouth EastNorthernSouth EastNorthe... \n", - "24 Central WestSouth EastNorthernSouth EastNorthe... \n", - "25 Central WestSouth EastNorthernSouth EastNorthe... \n", - "26 Central WestSouth EastNorthernSouth EastNorthe... \n", - "27 Central WestSouth EastNorthernSouth EastNorthe... \n", - "28 Central WestSouth EastNorthernSouth EastNorthe... \n", - "29 Central WestSouth EastNorthernSouth EastNorthe... \n", - "30 Central WestSouth EastNorthernSouth EastNorthe... \n", - "31 Central WestSouth EastNorthernSouth EastNorthe... \n", - "32 Central WestSouth EastNorthernSouth EastNorthe... \n", - "33 Central WestSouth EastNorthernSouth EastNorthe... \n", - "34 Central WestSouth EastNorthernSouth EastNorthe... \n", - "35 Central WestSouth EastNorthernSouth EastNorthe... \n", - "36 Central WestSouth EastNorthernSouth EastNorthe... \n", - "37 Central WestSouth EastNorthernSouth EastNorthe... \n", - "38 Central WestSouth EastNorthernSouth EastNorthe... \n", - "39 Central WestSouth EastNorthernSouth EastNorthe... \n", - "40 Central WestSouth EastNorthernSouth EastNorthe... \n", - "41 Central WestSouth EastNorthernSouth EastNorthe... \n", - "42 Central WestSouth EastNorthernSouth EastNorthe... \n", - "43 Central WestSouth EastNorthernSouth EastNorthe... \n", - "44 Central WestSouth EastNorthernSouth EastNorthe... \n", - "45 Central WestSouth EastNorthernSouth EastNorthe... \n", - "\n", - " District \\\n", - "0 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "1 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "2 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "3 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "4 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "5 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "6 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "7 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "8 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "9 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "10 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "11 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "12 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "13 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "14 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "15 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "16 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "17 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "18 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "19 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "20 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "21 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "22 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "23 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "24 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "25 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "26 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "27 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "28 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "29 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "30 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "31 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "32 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "33 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "34 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "35 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "36 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "37 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "38 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "39 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "40 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "41 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "42 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "43 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "44 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "45 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "\n", - " Resid \\\n", - "0 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "1 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "2 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "3 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "4 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "5 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "6 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "7 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "8 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "9 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "10 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "11 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "12 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "13 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "14 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "15 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "16 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "17 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "18 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "19 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "20 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "21 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "22 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "23 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "24 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "25 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "26 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "27 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "28 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "29 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "30 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "31 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "32 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "33 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "34 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "35 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "36 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "37 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "38 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "39 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "40 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "41 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "42 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "43 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "44 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "45 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "\n", - " Owner \\\n", - "0 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "1 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "2 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "3 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "4 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "5 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "6 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "7 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "8 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "9 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "10 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "11 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "12 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "13 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "14 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "15 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "16 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "17 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "18 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "19 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "20 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "21 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "22 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "23 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "24 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "25 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "26 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "27 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "28 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "29 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "30 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "31 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "32 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "33 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "34 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "35 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "36 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "37 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "38 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "39 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "40 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "41 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "42 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "43 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "44 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "45 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "\n", - " Facility_Type Precipitation \\\n", - "0 ClinicDistrict HospitalRural/Community Hospita... 370655.578345 \n", - "1 ClinicDistrict HospitalRural/Community Hospita... 305845.723518 \n", - "2 ClinicDistrict HospitalRural/Community Hospita... 380236.133055 \n", - "3 ClinicDistrict HospitalRural/Community Hospita... 396234.125976 \n", - "4 ClinicDistrict HospitalRural/Community Hospita... 317163.607434 \n", - "5 ClinicDistrict HospitalRural/Community Hospita... 385409.189618 \n", - "6 ClinicDistrict HospitalRural/Community Hospita... 406289.858606 \n", - "7 ClinicDistrict HospitalRural/Community Hospita... 333604.956760 \n", - "8 ClinicDistrict HospitalRural/Community Hospita... 322006.856259 \n", - "9 ClinicDistrict HospitalRural/Community Hospita... 391560.967791 \n", - "10 ClinicDistrict HospitalRural/Community Hospita... 367661.767185 \n", - "11 ClinicDistrict HospitalRural/Community Hospita... 378095.303002 \n", - "12 ClinicDistrict HospitalRural/Community Hospita... 374197.949271 \n", - "13 ClinicDistrict HospitalRural/Community Hospita... 374291.695816 \n", - "14 ClinicDistrict HospitalRural/Community Hospita... 398962.867137 \n", - "15 ClinicDistrict HospitalRural/Community Hospita... 329938.705708 \n", - "16 ClinicDistrict HospitalRural/Community Hospita... 349982.489824 \n", - "17 ClinicDistrict HospitalRural/Community Hospita... 265019.061881 \n", - "18 ClinicDistrict HospitalRural/Community Hospita... 317116.288589 \n", - "19 ClinicDistrict HospitalRural/Community Hospita... 358615.638348 \n", - "20 ClinicDistrict HospitalRural/Community Hospita... 441360.716573 \n", - "21 ClinicDistrict HospitalRural/Community Hospita... 485128.815221 \n", - "22 ClinicDistrict HospitalRural/Community Hospita... 339348.499913 \n", - "23 ClinicDistrict HospitalRural/Community Hospita... 353296.312971 \n", - "24 ClinicDistrict HospitalRural/Community Hospita... 333745.253478 \n", - "25 ClinicDistrict HospitalRural/Community Hospita... 513923.146927 \n", - "26 ClinicDistrict HospitalRural/Community Hospita... 271825.288644 \n", - "27 ClinicDistrict HospitalRural/Community Hospita... 365895.719222 \n", - "28 ClinicDistrict HospitalRural/Community Hospita... 325208.687060 \n", - "29 ClinicDistrict HospitalRural/Community Hospita... 382143.812346 \n", - "30 ClinicDistrict HospitalRural/Community Hospita... 287994.569053 \n", - "31 ClinicDistrict HospitalRural/Community Hospita... 332374.359974 \n", - "32 ClinicDistrict HospitalRural/Community Hospita... 392877.314013 \n", - "33 ClinicDistrict HospitalRural/Community Hospita... 302066.178485 \n", - "34 ClinicDistrict HospitalRural/Community Hospita... 327708.324530 \n", - "35 ClinicDistrict HospitalRural/Community Hospita... 309435.437644 \n", - "36 ClinicDistrict HospitalRural/Community Hospita... 320279.427886 \n", - "37 ClinicDistrict HospitalRural/Community Hospita... 330832.389669 \n", - "38 ClinicDistrict HospitalRural/Community Hospita... 435362.126119 \n", - "39 ClinicDistrict HospitalRural/Community Hospita... 304940.147499 \n", - "40 ClinicDistrict HospitalRural/Community Hospita... 353974.887443 \n", - "41 ClinicDistrict HospitalRural/Community Hospita... 295464.487169 \n", - "42 ClinicDistrict HospitalRural/Community Hospita... 297221.496710 \n", - "43 ClinicDistrict HospitalRural/Community Hospita... 409016.019784 \n", - "44 ClinicDistrict HospitalRural/Community Hospita... 420878.539429 \n", - "45 ClinicDistrict HospitalRural/Community Hospita... 405718.142702 \n", - "\n", - " Lag_1_Precipitation Lag_2_Precipitation Lag_3_Precipitation \\\n", - "0 390008.338639 385074.053901 383551.519335 \n", - "1 324216.805408 351108.236956 352944.118983 \n", - "2 351903.960266 349493.164255 344770.234996 \n", - "3 379492.789825 375543.857029 381029.229862 \n", - "4 375481.180687 385373.062799 381129.073629 \n", - "5 311938.841921 285932.285061 289579.937651 \n", - "6 433698.584038 455288.388297 455102.702313 \n", - "7 315844.250082 324314.368396 316195.532608 \n", - "8 371283.829234 345593.426372 354934.926046 \n", - "9 399207.341834 400410.349670 392246.728746 \n", - "10 341985.164411 327819.997189 330789.556355 \n", - "11 398497.779822 408894.912655 378604.565588 \n", - "12 348875.547726 360367.235995 389923.203199 \n", - "13 370981.253838 381170.945543 378471.104964 \n", - "14 394083.987840 401617.097706 408341.613660 \n", - "15 344469.424679 340683.245254 342518.356804 \n", - "16 331135.927791 335947.246630 335248.047067 \n", - "17 328321.508621 302510.901036 300226.263604 \n", - "18 252246.251731 271260.885375 274124.334082 \n", - "19 410050.158172 387974.439450 387736.897200 \n", - "20 369108.855991 362046.586240 342819.132014 \n", - "21 482869.984890 480685.090489 500151.794189 \n", - "22 419334.638122 449504.867423 447116.625283 \n", - "23 317922.916948 310749.912224 313141.518581 \n", - "24 325481.247456 336295.941280 330700.546457 \n", - "25 502910.647286 435891.016355 437939.836711 \n", - "26 325017.559932 392209.231985 393915.875687 \n", - "27 355003.796484 335224.704315 335946.670289 \n", - "28 360724.744731 376450.353321 368811.709372 \n", - "29 329764.214376 325974.066284 334512.344383 \n", - "30 331417.631119 333207.967531 331162.787180 \n", - "31 265016.427098 267520.943494 269888.025290 \n", - "32 457908.115607 448849.771066 446651.780946 \n", - "33 278375.606401 291501.477315 289945.485496 \n", - "34 318063.470421 302154.611762 306083.376401 \n", - "35 327543.125082 336866.204386 331980.842360 \n", - "36 330945.691553 322432.738606 318079.159985 \n", - "37 285321.675202 301954.830856 310662.088357 \n", - "38 433776.704399 419118.260070 404772.957169 \n", - "39 317030.377297 304945.762400 319651.502857 \n", - "40 329874.956467 337015.684029 328940.852077 \n", - "41 354202.699889 365879.087584 373323.111876 \n", - "42 272255.281494 280888.319603 281510.797522 \n", - "43 378752.521246 360679.750486 359521.705424 \n", - "44 445824.370857 462306.136722 461148.128688 \n", - "45 364719.332490 323443.731437 324834.166014 \n", - "\n", - " Lag_4_Precipitation Predicted_Weather_Model Predicted_No_Weather_Model \\\n", - "0 382881.752808 453186.019359 452178.159027 \n", - "1 353891.586301 448903.391472 451324.318689 \n", - "2 345157.532117 450203.526071 450472.090644 \n", - "3 379415.048009 446538.199648 449621.471846 \n", - "4 382864.345741 446948.806790 448772.459257 \n", - "5 289345.079079 445167.350051 447925.049844 \n", - "6 455034.373344 443225.944431 447079.240580 \n", - "7 314871.921748 445182.353097 446235.028444 \n", - "8 356543.998012 444463.766354 445392.410418 \n", - "9 391937.348081 443436.073774 444551.383494 \n", - "10 329650.101725 441556.996446 443711.944667 \n", - "11 379596.718666 443325.455792 442874.090938 \n", - "12 389558.939179 440375.155656 442037.819314 \n", - "13 377682.655534 441294.684850 441203.126808 \n", - "14 409745.578729 442671.748454 440370.010437 \n", - "15 341977.330400 437801.561953 439538.467226 \n", - "16 335789.435760 435274.468592 438708.494203 \n", - "17 296296.047432 437029.478846 437880.088405 \n", - "18 278184.608227 434377.435798 437053.246871 \n", - "19 387661.416146 434394.568891 436227.966648 \n", - "20 340516.424995 434086.915088 435404.244787 \n", - "21 502277.800794 434927.534834 434582.078347 \n", - "22 445805.292269 435351.610440 433761.464389 \n", - "23 313923.715557 430707.116763 432942.399983 \n", - "24 330244.876504 430982.665089 432124.882203 \n", - "25 438231.552425 428731.420008 431308.908127 \n", - "26 393957.931607 430192.671905 430494.474841 \n", - "27 336884.175544 427640.316088 429681.579436 \n", - "28 365595.615071 427806.610028 428870.219007 \n", - "29 337541.046047 425278.010843 428060.390657 \n", - "30 331449.273326 426811.173251 427252.091491 \n", - "31 269433.014822 425621.733459 426445.318624 \n", - "32 445524.032754 424963.149920 425640.069171 \n", - "33 291038.100935 423293.012832 424836.340258 \n", - "34 305678.254498 422200.602069 424034.129012 \n", - "35 330169.889911 421642.817151 423233.432568 \n", - "36 317973.894415 422645.018611 422434.248066 \n", - "37 312810.479228 421026.188284 421636.572650 \n", - "38 405190.542219 419003.352104 420840.403471 \n", - "39 319575.723877 419156.256610 420045.737685 \n", - "40 329238.343810 418797.992003 419252.572452 \n", - "41 372541.004296 418424.138509 418460.904941 \n", - "42 281840.507716 417481.752292 417670.732321 \n", - "43 359548.833442 414833.508183 416882.051771 \n", - "44 461552.424105 415995.972386 416094.860473 \n", - "45 323233.055405 412944.024703 415309.155615 \n", - "\n", - " Difference_in_Expectation Percentage_Difference \n", - "0 1007.860332 0.002229 \n", - "1 -2420.927217 -0.005364 \n", - "2 -268.564573 -0.000596 \n", - "3 -3083.272198 -0.006857 \n", - "4 -1823.652467 -0.004064 \n", - "5 -2757.699793 -0.006157 \n", - "6 -3853.296150 -0.008619 \n", - "7 -1052.675347 -0.002359 \n", - "8 -928.644064 -0.002085 \n", - "9 -1115.309720 -0.002509 \n", - "10 -2154.948222 -0.004857 \n", - "11 451.364853 0.001019 \n", - "12 -1662.663659 -0.003761 \n", - "13 91.558042 0.000208 \n", - "14 2301.738017 0.005227 \n", - "15 -1736.905273 -0.003952 \n", - "16 -3434.025611 -0.007828 \n", - "17 -850.609558 -0.001943 \n", - "18 -2675.811073 -0.006122 \n", - "19 -1833.397757 -0.004203 \n", - "20 -1317.329699 -0.003026 \n", - "21 345.456487 0.000795 \n", - "22 1590.146050 0.003666 \n", - "23 -2235.283220 -0.005163 \n", - "24 -1142.217114 -0.002643 \n", - "25 -2577.488119 -0.005976 \n", - "26 -301.802936 -0.000701 \n", - "27 -2041.263348 -0.004751 \n", - "28 -1063.608979 -0.002480 \n", - "29 -2782.379814 -0.006500 \n", - "30 -440.918241 -0.001032 \n", - "31 -823.585164 -0.001931 \n", - "32 -676.919251 -0.001590 \n", - "33 -1543.327426 -0.003633 \n", - "34 -1833.526943 -0.004324 \n", - "35 -1590.615417 -0.003758 \n", - "36 210.770545 0.000499 \n", - "37 -610.384366 -0.001448 \n", - "38 -1837.051367 -0.004365 \n", - "39 -889.481075 -0.002118 \n", - "40 -454.580449 -0.001084 \n", - "41 -36.766432 -0.000088 \n", - "42 -188.980029 -0.000452 \n", - "43 -2048.543588 -0.004914 \n", - "44 -98.888087 -0.000238 \n", - "45 -2365.130912 -0.005695 " - ], - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
YearMonthFacility_IDAltitudeZoneDistrictResidOwnerFacility_TypePrecipitationLag_1_PrecipitationLag_2_PrecipitationLag_3_PrecipitationLag_4_PrecipitationPredicted_Weather_ModelPredicted_No_Weather_ModelDifference_in_ExpectationPercentage_Difference
02025255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...370655.578345390008.338639385074.053901383551.519335382881.752808453186.019359452178.1590271007.8603320.002229
12026255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...305845.723518324216.805408351108.236956352944.118983353891.586301448903.391472451324.318689-2420.927217-0.005364
22027255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...380236.133055351903.960266349493.164255344770.234996345157.532117450203.526071450472.090644-268.564573-0.000596
32028255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...396234.125976379492.789825375543.857029381029.229862379415.048009446538.199648449621.471846-3083.272198-0.006857
42029255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...317163.607434375481.180687385373.062799381129.073629382864.345741446948.806790448772.459257-1823.652467-0.004064
52030255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...385409.189618311938.841921285932.285061289579.937651289345.079079445167.350051447925.049844-2757.699793-0.006157
62031255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...406289.858606433698.584038455288.388297455102.702313455034.373344443225.944431447079.240580-3853.296150-0.008619
72032255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...333604.956760315844.250082324314.368396316195.532608314871.921748445182.353097446235.028444-1052.675347-0.002359
82033255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...322006.856259371283.829234345593.426372354934.926046356543.998012444463.766354445392.410418-928.644064-0.002085
92034255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...391560.967791399207.341834400410.349670392246.728746391937.348081443436.073774444551.383494-1115.309720-0.002509
102035255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...367661.767185341985.164411327819.997189330789.556355329650.101725441556.996446443711.944667-2154.948222-0.004857
112036255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...378095.303002398497.779822408894.912655378604.565588379596.718666443325.455792442874.090938451.3648530.001019
122037255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...374197.949271348875.547726360367.235995389923.203199389558.939179440375.155656442037.819314-1662.663659-0.003761
132038255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...374291.695816370981.253838381170.945543378471.104964377682.655534441294.684850441203.12680891.5580420.000208
142039255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...398962.867137394083.987840401617.097706408341.613660409745.578729442671.748454440370.0104372301.7380170.005227
152040255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...329938.705708344469.424679340683.245254342518.356804341977.330400437801.561953439538.467226-1736.905273-0.003952
162041255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...349982.489824331135.927791335947.246630335248.047067335789.435760435274.468592438708.494203-3434.025611-0.007828
172042255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...265019.061881328321.508621302510.901036300226.263604296296.047432437029.478846437880.088405-850.609558-0.001943
182043255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...317116.288589252246.251731271260.885375274124.334082278184.608227434377.435798437053.246871-2675.811073-0.006122
192044255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...358615.638348410050.158172387974.439450387736.897200387661.416146434394.568891436227.966648-1833.397757-0.004203
202045255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...441360.716573369108.855991362046.586240342819.132014340516.424995434086.915088435404.244787-1317.329699-0.003026
212046255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...485128.815221482869.984890480685.090489500151.794189502277.800794434927.534834434582.078347345.4564870.000795
222047255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...339348.499913419334.638122449504.867423447116.625283445805.292269435351.610440433761.4643891590.1460500.003666
232048255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...353296.312971317922.916948310749.912224313141.518581313923.715557430707.116763432942.399983-2235.283220-0.005163
242049255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...333745.253478325481.247456336295.941280330700.546457330244.876504430982.665089432124.882203-1142.217114-0.002643
252050255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...513923.146927502910.647286435891.016355437939.836711438231.552425428731.420008431308.908127-2577.488119-0.005976
262051255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...271825.288644325017.559932392209.231985393915.875687393957.931607430192.671905430494.474841-301.802936-0.000701
272052255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...365895.719222355003.796484335224.704315335946.670289336884.175544427640.316088429681.579436-2041.263348-0.004751
282053255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...325208.687060360724.744731376450.353321368811.709372365595.615071427806.610028428870.219007-1063.608979-0.002480
292054255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...382143.812346329764.214376325974.066284334512.344383337541.046047425278.010843428060.390657-2782.379814-0.006500
302055255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...287994.569053331417.631119333207.967531331162.787180331449.273326426811.173251427252.091491-440.918241-0.001032
312056255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...332374.359974265016.427098267520.943494269888.025290269433.014822425621.733459426445.318624-823.585164-0.001931
322057255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...392877.314013457908.115607448849.771066446651.780946445524.032754424963.149920425640.069171-676.919251-0.001590
332058255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...302066.178485278375.606401291501.477315289945.485496291038.100935423293.012832424836.340258-1543.327426-0.003633
342059255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...327708.324530318063.470421302154.611762306083.376401305678.254498422200.602069424034.129012-1833.526943-0.004324
352060255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...309435.437644327543.125082336866.204386331980.842360330169.889911421642.817151423233.432568-1590.615417-0.003758
362061255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...320279.427886330945.691553322432.738606318079.159985317973.894415422645.018611422434.248066210.7705450.000499
372062255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...330832.389669285321.675202301954.830856310662.088357312810.479228421026.188284421636.572650-610.384366-0.001448
382063255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...435362.126119433776.704399419118.260070404772.957169405190.542219419003.352104420840.403471-1837.051367-0.004365
392064255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...304940.147499317030.377297304945.762400319651.502857319575.723877419156.256610420045.737685-889.481075-0.002118
402065255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...353974.887443329874.956467337015.684029328940.852077329238.343810418797.992003419252.572452-454.580449-0.001084
412066255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...295464.487169354202.699889365879.087584373323.111876372541.004296418424.138509418460.904941-36.766432-0.000088
422067255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...297221.496710272255.281494280888.319603281510.797522281840.507716417481.752292417670.732321-188.980029-0.000452
432068255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...409016.019784378752.521246360679.750486359521.705424359548.833442414833.508183416882.051771-2048.543588-0.004914
442069255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...420878.539429445824.370857462306.136722461148.128688461552.424105415995.972386416094.860473-98.888087-0.000238
452070255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...405718.142702364719.332490323443.731437324834.166014323233.055405412944.024703415309.155615-2365.130912-0.005695
\n", - "
" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "execution_count": 8 - }, - { - "metadata": { - "ExecuteTime": { - "end_time": "2025-01-09T11:44:47.692803Z", - "start_time": "2025-01-09T11:44:47.597022Z" - } - }, - "cell_type": "code", - "source": [ - "year_range = range(2025, 2061)\n", - "\n", - "plt.plot(year_range, multiplied_values)\n", - "plt.ylabel(\"Change ANC cases due to weather\")\n", - "plt.axhline(y=0, color='black', linestyle='--') " - ], - "id": "c0ed116b28287eaa", - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "execution_count": 9 - }, - { - "metadata": { - "ExecuteTime": { - "end_time": "2025-01-09T11:44:50.894208Z", - "start_time": "2025-01-09T11:44:50.806926Z" - } - }, - "cell_type": "code", - "source": [ - "plt.plot(year_range, predictions_from_cmip_sum.iloc[0:36, -1]*100)\n", - "plt.xlabel(\"Percentage Change in ANC cases due to weather\")\n", - "plt.axhline(y=0, color='black', linestyle='--') " - ], - "id": "55dba29ded951def", - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "execution_count": 10 - }, - { - "metadata": {}, - "cell_type": "markdown", - "source": "# Negative values - missed cases?", - "id": "247b1e99fa019564" - }, - { - "metadata": { - "ExecuteTime": { - "end_time": "2025-01-09T11:44:50.898667Z", - "start_time": "2025-01-09T11:44:50.896052Z" - } - }, - "cell_type": "code", - "source": [ - "negative_sum = np.sum(multiplied_values[multiplied_values < 0])\n", - "\n", - "print(\"Sum of values < 0:\", negative_sum)" - ], - "id": "67d8c94409dcd37", - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Sum of values < 0: -93565.2828118447\n" - ] - } - ], - "execution_count": 11 - }, - { - "metadata": {}, - "cell_type": "markdown", - "source": "Difference by Zone", - "id": "197776c5bef6b35c" - }, - { - "metadata": { - "ExecuteTime": { - "end_time": "2025-01-09T11:44:53.427516Z", - "start_time": "2025-01-09T11:44:53.229300Z" - } - }, - "cell_type": "code", - "source": [ - "predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'Zone']).sum().reset_index()\n", - "\n", - "# Plot each zone\n", - "plt.figure(figsize=(10, 6))\n", - "for zone in predictions_from_cmip_sum['Zone'].unique():\n", - " zone_data = predictions_from_cmip_sum[predictions_from_cmip_sum['Zone'] == zone]\n", - " zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data['Predicted_No_Weather_Model']) * 100\n", - " plt.plot(zone_data['Year'], zone_data['Percentage_Difference'], label=f'Zone {zone}')\n", - "\n", - "plt.xlabel(\"Year\")\n", - "plt.ylabel(\"Change ANC cases due to weather\")\n", - "plt.axhline(y=0, color='black', linestyle='--')\n", - "plt.ylim(-1.5, 0)\n", - "plt.legend(title='Zones')\n", - "plt.show()" - ], - "id": "8f79bf2846942b7f", - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/4003818095.py:7: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/4003818095.py:7: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/4003818095.py:7: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/4003818095.py:7: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/4003818095.py:7: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data['Predicted_No_Weather_Model']) * 100\n" - ] - }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/4003818095.py:7: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data['Predicted_No_Weather_Model']) * 100\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/4003818095.py:7: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data['Predicted_No_Weather_Model']) * 100\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/4003818095.py:7: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data['Predicted_No_Weather_Model']) * 100\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/4003818095.py:7: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data['Predicted_No_Weather_Model']) * 100\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/4003818095.py:7: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data['Predicted_No_Weather_Model']) * 100\n" + ] + }, { "data": { "text/plain": [ "
" ], - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 12 + "execution_count": 36 }, { "metadata": {}, @@ -5161,8 +3345,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-09T11:44:55.983008Z", - "start_time": "2025-01-09T11:44:55.705797Z" + "end_time": "2025-01-09T13:28:18.206069Z", + "start_time": "2025-01-09T13:28:17.922833Z" } }, "cell_type": "code", @@ -5179,7 +3363,7 @@ "plt.xlabel(\"Year\")\n", "plt.ylabel(\"Change ANC cases due to weather\")\n", "plt.axhline(y=0, color='black', linestyle='--')\n", - "plt.ylim(-1.5, 0)\n", + "plt.ylim(-2.5, 0)\n", "plt.legend(title='Districts')\n", "plt.show()" ], @@ -5189,169 +3373,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/1838649022.py:7: SettingWithCopyWarning: \n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_18188/3611777628.py:7: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", @@ -5364,13 +3386,13 @@ "text/plain": [ "
" ], - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 13 + "execution_count": 35 }, { "metadata": {}, @@ -5381,8 +3403,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-09T11:44:59.376473Z", - "start_time": "2025-01-09T11:44:58.166348Z" + "end_time": "2025-01-09T13:28:20.701932Z", + "start_time": "2025-01-09T13:28:19.465368Z" } }, "cell_type": "code", @@ -5431,37 +3453,37 @@ "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/3827770855.py:25: SettingWithCopyWarning: \n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_18188/3827770855.py:25: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " zone_data['Percentage_Difference'] = (\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/3827770855.py:25: SettingWithCopyWarning: \n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_18188/3827770855.py:25: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " zone_data['Percentage_Difference'] = (\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/3827770855.py:25: SettingWithCopyWarning: \n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_18188/3827770855.py:25: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " zone_data['Percentage_Difference'] = (\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/3827770855.py:25: SettingWithCopyWarning: \n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_18188/3827770855.py:25: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " zone_data['Percentage_Difference'] = (\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/3827770855.py:25: SettingWithCopyWarning: \n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_18188/3827770855.py:25: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " zone_data['Percentage_Difference'] = (\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/3827770855.py:25: SettingWithCopyWarning: \n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_18188/3827770855.py:25: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", @@ -5470,13 +3492,13 @@ ] } ], - "execution_count": 14 + "execution_count": 36 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-09T11:45:00.968214Z", - "start_time": "2025-01-09T11:45:00.964031Z" + "end_time": "2025-01-09T13:28:21.974599Z", + "start_time": "2025-01-09T13:28:21.970166Z" } }, "cell_type": "code", @@ -5668,12 +3690,12 @@ " 'Multiplied_Values': nan}]" ] }, - "execution_count": 15, + "execution_count": 37, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 15 + "execution_count": 37 }, { "metadata": {}, @@ -5696,8 +3718,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-09T11:45:06.833084Z", - "start_time": "2025-01-09T11:45:06.830522Z" + "end_time": "2025-01-09T13:28:24.117221Z", + "start_time": "2025-01-09T13:28:24.113163Z" } }, "cell_type": "code", @@ -5707,13 +3729,13 @@ ], "id": "4fc203ff0269768", "outputs": [], - "execution_count": 16 + "execution_count": 38 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-09T11:49:47.255665Z", - "start_time": "2025-01-09T11:49:46.640771Z" + "end_time": "2025-01-09T13:28:25.180232Z", + "start_time": "2025-01-09T13:28:24.547590Z" } }, "cell_type": "code", @@ -5806,7 +3828,7 @@ "traceback": [ "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m", "\u001B[0;31mRuntimeError\u001B[0m Traceback (most recent call last)", - "Cell \u001B[0;32mIn[24], line 70\u001B[0m\n\u001B[1;32m 68\u001B[0m sm\u001B[38;5;241m.\u001B[39mset_array([])\n\u001B[1;32m 69\u001B[0m cbar \u001B[38;5;241m=\u001B[39m plt\u001B[38;5;241m.\u001B[39mcolorbar(sm, ax\u001B[38;5;241m=\u001B[39max, orientation\u001B[38;5;241m=\u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mvertical\u001B[39m\u001B[38;5;124m\"\u001B[39m, shrink\u001B[38;5;241m=\u001B[39m\u001B[38;5;241m0.7\u001B[39m)\n\u001B[0;32m---> 70\u001B[0m \u001B[43mplt\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mclim\u001B[49m\u001B[43m(\u001B[49m\u001B[43mgrid_clipped_ADM2\u001B[49m\u001B[43m[\u001B[49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[38;5;124;43mPercentage_Difference\u001B[39;49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[43m]\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mmin\u001B[49m\u001B[43m(\u001B[49m\u001B[43m)\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m0\u001B[39;49m\u001B[43m)\u001B[49m\n\u001B[1;32m 71\u001B[0m cbar\u001B[38;5;241m.\u001B[39mset_label(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mPercentage Difference (\u001B[39m\u001B[38;5;124m%\u001B[39m\u001B[38;5;124m)\u001B[39m\u001B[38;5;124m\"\u001B[39m, fontsize\u001B[38;5;241m=\u001B[39m\u001B[38;5;241m12\u001B[39m)\n\u001B[1;32m 73\u001B[0m plt\u001B[38;5;241m.\u001B[39mxlabel(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mLongitude\u001B[39m\u001B[38;5;124m\"\u001B[39m, fontsize\u001B[38;5;241m=\u001B[39m\u001B[38;5;241m14\u001B[39m)\n", + "Cell \u001B[0;32mIn[39], line 70\u001B[0m\n\u001B[1;32m 68\u001B[0m sm\u001B[38;5;241m.\u001B[39mset_array([])\n\u001B[1;32m 69\u001B[0m cbar \u001B[38;5;241m=\u001B[39m plt\u001B[38;5;241m.\u001B[39mcolorbar(sm, ax\u001B[38;5;241m=\u001B[39max, orientation\u001B[38;5;241m=\u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mvertical\u001B[39m\u001B[38;5;124m\"\u001B[39m, shrink\u001B[38;5;241m=\u001B[39m\u001B[38;5;241m0.7\u001B[39m)\n\u001B[0;32m---> 70\u001B[0m \u001B[43mplt\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mclim\u001B[49m\u001B[43m(\u001B[49m\u001B[43mgrid_clipped_ADM2\u001B[49m\u001B[43m[\u001B[49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[38;5;124;43mPercentage_Difference\u001B[39;49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[43m]\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mmin\u001B[49m\u001B[43m(\u001B[49m\u001B[43m)\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m0\u001B[39;49m\u001B[43m)\u001B[49m\n\u001B[1;32m 71\u001B[0m cbar\u001B[38;5;241m.\u001B[39mset_label(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mPercentage Difference (\u001B[39m\u001B[38;5;124m%\u001B[39m\u001B[38;5;124m)\u001B[39m\u001B[38;5;124m\"\u001B[39m, fontsize\u001B[38;5;241m=\u001B[39m\u001B[38;5;241m12\u001B[39m)\n\u001B[1;32m 73\u001B[0m plt\u001B[38;5;241m.\u001B[39mxlabel(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mLongitude\u001B[39m\u001B[38;5;124m\"\u001B[39m, fontsize\u001B[38;5;241m=\u001B[39m\u001B[38;5;241m14\u001B[39m)\n", "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/matplotlib/pyplot.py:2157\u001B[0m, in \u001B[0;36mclim\u001B[0;34m(vmin, vmax)\u001B[0m\n\u001B[1;32m 2155\u001B[0m im \u001B[38;5;241m=\u001B[39m gci()\n\u001B[1;32m 2156\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m im \u001B[38;5;129;01mis\u001B[39;00m \u001B[38;5;28;01mNone\u001B[39;00m:\n\u001B[0;32m-> 2157\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m \u001B[38;5;167;01mRuntimeError\u001B[39;00m(\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mYou must first define an image, e.g., with imshow\u001B[39m\u001B[38;5;124m'\u001B[39m)\n\u001B[1;32m 2159\u001B[0m im\u001B[38;5;241m.\u001B[39mset_clim(vmin, vmax)\n", "\u001B[0;31mRuntimeError\u001B[0m: You must first define an image, e.g., with imshow" ] @@ -5816,21 +3838,16 @@ "text/plain": [ "
" ], - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 24 + "execution_count": 39 }, { - "metadata": { - "ExecuteTime": { - "end_time": "2025-01-09T11:39:23.007883Z", - "start_time": "2025-01-09T11:39:23.004578Z" - } - }, + "metadata": {}, "cell_type": "code", "source": [ "# Get unique districts from both sources\n", @@ -5846,25 +3863,16 @@ "print(\"Districts in predictions but not in ADM2:\", missing_in_adm2)" ], "id": "165106827759887c", - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Districts in ADM2 but not in predictions: {'Likoma', 'Lilongwe City', 'Zomba City', 'Mzuzu City'}\n", - "Districts in predictions but not in ADM2: set()\n" - ] - } - ], - "execution_count": 20 + "outputs": [], + "execution_count": null }, { "metadata": {}, "cell_type": "code", - "outputs": [], - "execution_count": null, "source": "", - "id": "a835bddc9c0be86f" + "id": "a835bddc9c0be86f", + "outputs": [], + "execution_count": null } ], "metadata": { From 3c687ac1a612508b4e2f3c91997f69d9b8b73b9d Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 9 Jan 2025 14:53:29 +0000 Subject: [PATCH 172/291] Python file for calculating and plotting the projected disruptions in ANC care --- src/scripts/climate_change/cohort_model.py | 189 +++++++++++++++++++++ 1 file changed, 189 insertions(+) create mode 100644 src/scripts/climate_change/cohort_model.py diff --git a/src/scripts/climate_change/cohort_model.py b/src/scripts/climate_change/cohort_model.py new file mode 100644 index 0000000000..09bd2f78ad --- /dev/null +++ b/src/scripts/climate_change/cohort_model.py @@ -0,0 +1,189 @@ +from pathlib import Path + +import geopandas as gpd +from netCDF4 import Dataset +from shapely.geometry import Polygon +from matplotlib import colors as mcolors +import matplotlib.pyplot as plt +import pandas as pd +import numpy as np + +from tlo.analysis.utils import ( + extract_results, + make_age_grp_lookup, + make_calendar_period_lookup, + summarize, +) + +min_year = 2025 +max_year = 2061 + +## Get birth results +results_folder_to_save = Path('/Users/rem76/Desktop/Climate_change_health/Results/ANC_disruptions') +results_folder_for_births = Path("/Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-09-25T110820Z") +resourcefilepath = Path("/Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-09-25T110820Z") +agegrps, agegrplookup = make_age_grp_lookup() +calperiods, calperiodlookup = make_calendar_period_lookup() +births_results = extract_results( + results_folder_for_births, + module="tlo.methods.demography", + key="on_birth", + custom_generate_series=( + lambda df: df.assign(year=df['date'].dt.year).groupby(['year'])['year'].count() + ), + do_scaling=True + ) +births_results = births_results.groupby(by=births_results.index).sum() +births_results = births_results.replace({0: np.nan}) + +births_model = summarize(births_results, collapse_columns=True) +births_model.columns = ['Model_' + col for col in births_model.columns] +births_model_subset = births_model.iloc[15:].copy() # don't want 2010-2024 + +# Load map of Malawi for later +file_path_historical_data = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/2011/60ab007aa16d679a32f9c3e186d2f744.nc" +dataset = Dataset(file_path_historical_data, mode='r') +pr_data = dataset.variables['tp'][:] +lat_data = dataset.variables['latitude'][:] +long_data = dataset.variables['longitude'][:] +meshgrid_from_netCDF = np.meshgrid(long_data, lat_data) + +malawi = gpd.read_file("/Users/rem76/PycharmProjects/TLOmodel/resources/mapping/ResourceFile_mwi_admbnda_adm0_nso_20181016.shp") +malawi_admin2 = gpd.read_file("/Users/rem76/PycharmProjects/TLOmodel/resources/mapping/ResourceFile_mwi_admbnda_adm2_nso_20181016.shp") + +# change names of some districts for consistency +malawi_admin2['ADM2_EN'] = malawi_admin2['ADM2_EN'].replace('Blantyre City', 'Blantyre') +malawi_admin2['ADM2_EN'] = malawi_admin2['ADM2_EN'].replace('Mzuzu City', 'Mzuzu') +malawi_admin2['ADM2_EN'] = malawi_admin2['ADM2_EN'].replace('Lilongwe City', 'Lilongwe') + +difference_lat = lat_data[1] - lat_data[0] +difference_long = long_data[1] - long_data[0] + +# Get expected disturbance from the model +scenarios = ['ssp245', 'ssp585'] +model_types = ['lowest', 'median', 'highest'] +year_range = range(min_year, max_year) + +# Loop through scenarios and model types +for scenario in scenarios: + for model_type in model_types: + predictions_from_cmip = pd.read_csv( + f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' + ) + predictions_from_cmip_sum = predictions_from_cmip.groupby('Year').sum().reset_index() + predictions_from_cmip_sum['Percentage_Difference'] = ( + predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum[ + 'Predicted_No_Weather_Model']) + # Match birth results and predictions + matching_rows = min(len(births_model_subset), len(predictions_from_cmip_sum)) + print(matching_rows) + multiplied_values = births_model_subset.head(matching_rows).iloc[:, 1].values * predictions_from_cmip_sum[ + 'Percentage_Difference'].head(matching_rows).values + births_model_subset['Multiplied_Values'] = multiplied_values + + # Plot the results + plt.plot(year_range, multiplied_values) + plt.ylabel("Change ANC cases due to weather") + plt.axhline(y=0, color='black', linestyle='--') + plt.plot(year_range, predictions_from_cmip_sum.iloc[0:36, -1] * 100) + plt.xlabel("Percentage Change in ANC cases due to weather") + plt.axhline(y=0, color='black', linestyle='--') + + # Check for negative values (missed cases?) + negative_sum = np.sum(multiplied_values[multiplied_values < 0]) + print("Sum of values < 0:", negative_sum) + print(negative_sum / births_model_subset['Model_mean'].sum() * 100) + + # Plot by zone + predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'Zone']).sum().reset_index() + plt.figure(figsize=(10, 6)) + for zone in predictions_from_cmip_sum['Zone'].unique(): + zone_data = predictions_from_cmip_sum[predictions_from_cmip_sum['Zone'] == zone] + zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data[ + 'Predicted_No_Weather_Model']) * 100 + plt.plot(zone_data['Year'], zone_data['Percentage_Difference'], label=f'Zone {zone}') + plt.xlabel("Year") + plt.ylabel("Change ANC cases due to weather") + plt.axhline(y=0, color='black', linestyle='--') + plt.ylim(-1.5, 0) + plt.legend(title='Zones') + + # Plot by district + predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'District']).sum().reset_index() + plt.figure(figsize=(10, 6)) + for district in predictions_from_cmip_sum['District'].unique(): + district_data = predictions_from_cmip_sum[predictions_from_cmip_sum['District'] == district] + district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data[ + 'Predicted_No_Weather_Model']) * 100 + plt.plot(district_data['Year'], district_data['Percentage_Difference'], label=f'{district}') + plt.xlabel("Year") + plt.ylabel("Change ANC cases due to weather") + plt.axhline(y=0, color='black', linestyle='--') + plt.ylim(-2.5, 0) + plt.legend(title='Districts') + + # Generate district map visualization + predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( + {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"}) + polygons = [ + Polygon( + [(x, y), (x + difference_long, y), (x + difference_long, y + difference_lat), (x, y + difference_lat)]) + for x in long_data for y in lat_data + ] + grid = gpd.GeoDataFrame({'geometry': polygons}, crs=malawi.crs) + grid_clipped_ADM2 = gpd.overlay(grid, malawi_admin2, how='intersection') + predictions_from_cmip_sum['Percentage_Difference'] = (predictions_from_cmip_sum['Difference_in_Expectation'] / + predictions_from_cmip_sum[ + 'Predicted_No_Weather_Model']) * 100 + percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() + grid_clipped_ADM2['Percentage_Difference'] = grid_clipped_ADM2['ADM2_EN'].map(percentage_diff_by_district) + grid_clipped_ADM2.loc[grid_clipped_ADM2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 + + # Plot map + fig, ax = plt.subplots(figsize=(12, 12)) + malawi_admin2.plot(ax=ax, edgecolor='white', color='white') + grid_clipped_ADM2.dropna(subset=['Percentage_Difference']).plot( + ax=ax, + column='Percentage_Difference', + cmap='Blues_r', + edgecolor='black', + alpha=1, + legend=False + ) + sm = plt.cm.ScalarMappable(cmap='Blues_r', + norm=mcolors.Normalize(vmin=grid_clipped_ADM2['Percentage_Difference'].min(), + vmax=grid_clipped_ADM2['Percentage_Difference'].max())) + sm.set_array([]) + cbar = plt.colorbar(sm, ax=ax, orientation="vertical", shrink=0.7) + cbar.set_label("Percentage Difference (%)", fontsize=12) + plt.xlabel("Longitude", fontsize=14) + plt.ylabel("Latitude", fontsize=14) + plt.title(f"{scenario}: {model_type}", fontsize=16) + plt.tight_layout() + plt.savefig(results_folder_to_save / f'{scenario}_{model_type}_map_Malawi_cumulative_difference.png') + # Save multiplied values by model and scenario + multiplied_values_df = pd.DataFrame({ + 'Year': year_range[:matching_rows], + 'Scenario': scenario, + 'Model_Type': model_type, + 'Multiplied_Values': multiplied_values + }) + multiplied_values_df.to_csv(results_folder_to_save/f'multiplied_values_{scenario}_{model_type}.csv', index=False) + +# +# # Get unique districts from both sources +# adm2_districts = set(grid_clipped_ADM2['ADM2_EN'].unique()) +# prediction_districts = set(predictions_from_cmip_sum['District'].unique()) +# +# # Districts in ADM2 but not in predictions +# missing_in_predictions = adm2_districts - prediction_districts +# print("Districts in ADM2 but not in predictions:", missing_in_predictions) +# +# # Districts in predictions but not in ADM2 +# missing_in_adm2 = prediction_districts - adm2_districts +# print("Districts in predictions but not in ADM2:", missing_in_adm2) +# + + + + From 7d498122b6a2a5d863dc12db7f07398d57e43e86 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 9 Jan 2025 15:08:57 +0000 Subject: [PATCH 173/291] Added plot of them all --- src/scripts/climate_change/cohort_model.py | 92 ++++++++++++++++++++-- 1 file changed, 85 insertions(+), 7 deletions(-) diff --git a/src/scripts/climate_change/cohort_model.py b/src/scripts/climate_change/cohort_model.py index 09bd2f78ad..c67dba1410 100644 --- a/src/scripts/climate_change/cohort_model.py +++ b/src/scripts/climate_change/cohort_model.py @@ -131,18 +131,18 @@ for x in long_data for y in lat_data ] grid = gpd.GeoDataFrame({'geometry': polygons}, crs=malawi.crs) - grid_clipped_ADM2 = gpd.overlay(grid, malawi_admin2, how='intersection') + #grid_clipped_ADM2 = gpd.overlay(grid, malawi_admin2, how='intersection') predictions_from_cmip_sum['Percentage_Difference'] = (predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum[ 'Predicted_No_Weather_Model']) * 100 percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() - grid_clipped_ADM2['Percentage_Difference'] = grid_clipped_ADM2['ADM2_EN'].map(percentage_diff_by_district) - grid_clipped_ADM2.loc[grid_clipped_ADM2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 + malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) + malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 # Plot map fig, ax = plt.subplots(figsize=(12, 12)) - malawi_admin2.plot(ax=ax, edgecolor='white', color='white') - grid_clipped_ADM2.dropna(subset=['Percentage_Difference']).plot( + #malawi_admin2.plot(ax=ax, edgecolor='white', color='white') + malawi_admin2.dropna(subset=['Percentage_Difference']).plot( ax=ax, column='Percentage_Difference', cmap='Blues_r', @@ -151,8 +151,8 @@ legend=False ) sm = plt.cm.ScalarMappable(cmap='Blues_r', - norm=mcolors.Normalize(vmin=grid_clipped_ADM2['Percentage_Difference'].min(), - vmax=grid_clipped_ADM2['Percentage_Difference'].max())) + norm=mcolors.Normalize(vmin=malawi_admin2['Percentage_Difference'].min(), + vmax=malawi_admin2['Percentage_Difference'].max())) sm.set_array([]) cbar = plt.colorbar(sm, ax=ax, orientation="vertical", shrink=0.7) cbar.set_label("Percentage Difference (%)", fontsize=12) @@ -186,4 +186,82 @@ +## now all grids +fig, axes = plt.subplots(2, 3, figsize=(18, 12), constrained_layout=True) +global_min = float('inf') +global_max = float('-inf') + +for scenario in scenarios: + for model_type in model_types: + predictions_from_cmip = pd.read_csv( + f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' + ) + predictions_from_cmip_sum = predictions_from_cmip.groupby('District').sum().reset_index() + predictions_from_cmip_sum['Percentage_Difference'] = ( + predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model'] + ) * 100 + + predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( + {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} + ) + percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() + malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) + malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 + + local_min = malawi_admin2['Percentage_Difference'].min() + local_max = malawi_admin2['Percentage_Difference'].max() + global_min = min(global_min, local_min) + global_max = max(global_max, local_max) + +for i, scenario in enumerate(scenarios): + for j, model_type in enumerate(model_types): + predictions_from_cmip = pd.read_csv( + f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' + ) + predictions_from_cmip_sum = predictions_from_cmip.groupby('District').sum().reset_index() + predictions_from_cmip_sum['Percentage_Difference'] = ( + predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model'] + ) * 100 + + predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( + {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} + ) + percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() + malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) + malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 + + ax = axes[i, j] + malawi_admin2.dropna(subset=['Percentage_Difference']).plot( + ax=ax, + column='Percentage_Difference', + cmap='Blues_r', + edgecolor='black', + alpha=1, + legend=False, + vmin=global_min, + vmax=global_max + ) + + ax.set_title(f"{scenario}: {model_type}", fontsize=14) + + if i != 1: + ax.set_xlabel("") + if j != 0: + ax.set_ylabel("") + else: + ax.set_ylabel("Latitude", fontsize=10) + + if i == 1: + ax.set_xlabel("Longitude", fontsize=10) + +sm = plt.cm.ScalarMappable( + cmap='Blues_r', + norm=mcolors.Normalize(vmin=global_min, vmax=global_max) +) +sm.set_array([]) +fig.colorbar(sm, ax=axes, orientation="vertical", shrink=0.8, label="Percentage Difference (%)") + +plt.suptitle("Percentage Difference Maps by Scenario and Model Type", fontsize=16, y=1.02) +plt.savefig(results_folder_to_save / 'percentage_difference_maps_grid.png') +plt.show() From 87fdc85d0de6b57b289bf54cd8db9b58989d1f0b Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 10 Jan 2025 11:55:59 +0000 Subject: [PATCH 174/291] Readded scaling --- ...al_realtionship_reporting_precipitation.py | 348 +++++++++--------- 1 file changed, 169 insertions(+), 179 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index cbf5437e8f..aae6e98346 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -308,38 +308,39 @@ def repeat_info(info, num_facilities, year_range, historical): np.array(minimum_distance) ]) # Continuous columns that need to be standardized (weather_data, lag variables, altitude, minimum_distance) -# X_continuous = np.column_stack([ -# year_flattened, -# month_flattened, -# altitude, -# np.array(minimum_distance) -# ]) -# X_categorical = np.column_stack([ -# resid_encoded, -# zone_encoded, -# owner_encoded, -# ftype_encoded, -# facility_encoded, -# ]) -# scaler = StandardScaler() -# X_continuous_scaled = scaler.fit_transform(X_continuous) -# X_weather_standardized = np.column_stack([X_continuous_scaled, X_categorical]) -# X_weather_standardized = np.column_stack([X_continuous, X_categorical]) +X_continuous = np.column_stack([ + year_flattened, + month_flattened, + altitude, + np.array(minimum_distance) +]) +X_categorical = np.column_stack([ + resid_encoded, + zone_encoded, + dist_encoded, + owner_encoded, + ftype_encoded, + facility_encoded, +]) +scaler = StandardScaler() +X_continuous_scaled = scaler.fit_transform(X_continuous) +X_ANC_standardized = np.column_stack([X_continuous_scaled, X_categorical]) +#X_weather_standardized = np.column_stack([X_continuous, X_categorical]) coefficient_names = ["year", "month"] + list(resid_encoded.columns) + list(zone_encoded.columns) + \ list(owner_encoded.columns) + list(ftype_encoded.columns) + \ list(facility_encoded.columns) + ["altitude", "minimum_distance"] coefficient_names = pd.Series(coefficient_names) -results, y_pred, mask_ANC_data = build_model(X , y, poisson = poisson, log_y=log_y, X_mask_mm=mask_threshold) +results, y_pred, mask_ANC_data = build_model(X_ANC_standardized , y, poisson = poisson, log_y=log_y, X_mask_mm=mask_threshold) coefficients = results.params coefficients_df = pd.DataFrame(coefficients, columns=['coefficients']) -continuous_coefficients = coefficients[:len(X[0])] -categorical_coefficients = coefficients[len(X[0]):] -#means = scaler.mean_ -#scales = scaler.scale_ -#rescaled_continuous_coefficients = continuous_coefficients * scales -#rescaled_coefficients = np.concatenate([rescaled_continuous_coefficients, categorical_coefficients]) -#rescaled_coefficients_df = pd.DataFrame(rescaled_coefficients, columns=['rescaled coefficients']) +continuous_coefficients = coefficients[:len(X_continuous_scaled[0])] +categorical_coefficients = coefficients[len(X_continuous_scaled[0]):] +means = scaler.mean_ +scales = scaler.scale_ +rescaled_continuous_coefficients = continuous_coefficients * scales +rescaled_coefficients = np.concatenate([rescaled_continuous_coefficients, categorical_coefficients]) +rescaled_coefficients_df = pd.DataFrame(rescaled_coefficients, columns=['rescaled coefficients']) p_values = results.pvalues p_values_df = pd.DataFrame(p_values, columns=['p_values']) #results_df = pd.concat([coefficient_names, coefficients_df, p_values_df, rescaled_coefficients_df], axis=1) @@ -449,37 +450,38 @@ def repeat_info(info, num_facilities, year_range, historical): np.array(minimum_distance), #np.array(above_below_X)[mask_ANC_data], ]) - # Continuous columns that need to be standardized (weather_data, lag variables, altitude, minimum_distance) -# X_continuous = np.column_stack([ -# weather_data, -# np.array(year_flattened), -# np.array(month_flattened), -# lag_1_month, -# lag_2_month, -# lag_3_month, -# lag_4_month, -# lag_1_5_day, -# lag_2_5_day, -# lag_3_5_day, -# lag_4_5_day, -# np.array(altitude), -# np.array(minimum_distance),] -# ) -# X_categorical = np.column_stack([ -# resid_encoded, -# zone_encoded, -# owner_encoded, -# ftype_encoded, -# facility_encoded, -# #np.array(above_below_X)[mask_ANC_data], -# ]) -# -# scaler = StandardScaler() -# #X_continuous_scaled = scaler.fit_transform(X_continuous) -# #X_weather_standardized = np.column_stack([X_continuous_scaled, X_categorical]) -# X_weather_standardized = np.column_stack([X_continuous, X_categorical]) - -results_of_weather_model, y_pred_weather, mask_all_data = build_model(X_weather, y, poisson = poisson, log_y=log_y, +# Continuous columns that need to be standardized (weather_data, lag variables, altitude, minimum_distance) +X_continuous = np.column_stack([ + weather_data, + np.array(year_flattened), + np.array(month_flattened), + lag_1_month, + lag_2_month, + lag_3_month, + lag_4_month, + lag_1_5_day, + lag_2_5_day, + lag_3_5_day, + lag_4_5_day, + np.array(altitude), + np.array(minimum_distance),] +) +X_categorical = np.column_stack([ + resid_encoded, + zone_encoded, + dist_encoded, + owner_encoded, + ftype_encoded, + facility_encoded, + #np.array(above_below_X)[mask_ANC_data], + ]) + +scaler = StandardScaler() +X_continuous_scaled = scaler.fit_transform(X_continuous) +X_weather_standardized = np.column_stack([X_continuous_scaled, X_categorical]) +#X_weather_standardized = np.column_stack([X_continuous, X_categorical]) + +results_of_weather_model, y_pred_weather, mask_all_data = build_model(X_weather_standardized, y, poisson = poisson, log_y=log_y, X_mask_mm=mask_threshold) coefficient_names_weather = ["precip_monthly_total", "precip_5_day_max", "year", "month"] + \ @@ -607,55 +609,42 @@ def get_weather_data(ssp_scenario, model_type): for ssp_scenario in ssp_scenarios: for model_type in model_types: print(ssp_scenario, model_type) - if use_all_weather: - weather_data_prediction_five_day_cumulative_df, weather_data_prediction_monthly_df = get_weather_data(ssp_scenario, + weather_data_prediction_five_day_cumulative_df, weather_data_prediction_monthly_df = get_weather_data(ssp_scenario, model_type) - lag_1_month_prediction = weather_data_prediction_monthly_df.shift(1).values - lag_2_month_prediction = weather_data_prediction_monthly_df.shift(2).values - lag_3_month_prediction = weather_data_prediction_monthly_df.shift(3).values - lag_4_month_prediction = weather_data_prediction_monthly_df.shift(4).values + lag_1_month_prediction = weather_data_prediction_monthly_df.shift(1).values + lag_2_month_prediction = weather_data_prediction_monthly_df.shift(2).values + lag_3_month_prediction = weather_data_prediction_monthly_df.shift(3).values + lag_4_month_prediction = weather_data_prediction_monthly_df.shift(4).values - lag_1_month_prediction = lag_1_month_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() - lag_2_month_prediction = lag_2_month_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() - lag_3_month_prediction = lag_3_month_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() - lag_4_month_prediction = lag_4_month_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() + lag_1_month_prediction = lag_1_month_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() + lag_2_month_prediction = lag_2_month_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() + lag_3_month_prediction = lag_3_month_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() + lag_4_month_prediction = lag_4_month_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() - lag_1_5_day_prediction = weather_data_prediction_five_day_cumulative_df.shift(1).values - lag_2_5_day_prediction = weather_data_prediction_five_day_cumulative_df.shift(2).values - lag_3_5_day_prediction = weather_data_prediction_five_day_cumulative_df.shift(3).values - lag_4_5_day_prediction = weather_data_prediction_five_day_cumulative_df.shift(4).values + lag_1_5_day_prediction = weather_data_prediction_five_day_cumulative_df.shift(1).values + lag_2_5_day_prediction = weather_data_prediction_five_day_cumulative_df.shift(2).values + lag_3_5_day_prediction = weather_data_prediction_five_day_cumulative_df.shift(3).values + lag_4_5_day_prediction = weather_data_prediction_five_day_cumulative_df.shift(4).values - lag_1_5_day_prediction = lag_1_5_day_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() - lag_2_5_day_prediction = lag_2_5_day_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() - lag_3_5_day_prediction = lag_3_5_day_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() - lag_4_5_day_prediction = lag_4_5_day_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() - weather_data_prediction_five_day_cumulative = weather_data_prediction_five_day_cumulative_df # keep these seperate for binary features + lag_1_5_day_prediction = lag_1_5_day_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() + lag_2_5_day_prediction = lag_2_5_day_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() + lag_3_5_day_prediction = lag_3_5_day_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() + lag_4_5_day_prediction = lag_4_5_day_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() + weather_data_prediction_five_day_cumulative = weather_data_prediction_five_day_cumulative_df # keep these seperate for binary features # need for binary comparison - lag_12_month = weather_data_prediction_monthly_df.shift(12).values - lag_12_month = lag_12_month[(min_year_for_analysis - absolute_min_year) * 12:].flatten() + lag_12_month = weather_data_prediction_monthly_df.shift(12).values + lag_12_month = lag_12_month[(min_year_for_analysis - absolute_min_year) * 12:].flatten() - weather_data_prediction_monthly = weather_data_prediction_monthly_df # keep these seperate for binary features + weather_data_prediction_monthly = weather_data_prediction_monthly_df # keep these seperate for binary features - weather_data_prediction_five_day_cumulative = weather_data_prediction_five_day_cumulative.iloc[(min_year_for_analysis - absolute_min_year) * 12:] - weather_data_prediction_monthly = weather_data_prediction_monthly.iloc[(min_year_for_analysis - absolute_min_year) * 12:] - weather_data_prediction_monthly_flattened = weather_data_prediction_monthly.values.flatten() - weather_data_prediction_five_day_cumulative_flattened = weather_data_prediction_five_day_cumulative.values.flatten() - weather_data_prediction_flatten = np.vstack((weather_data_prediction_monthly_flattened, weather_data_prediction_five_day_cumulative_flattened)).T - num_facilities = len(weather_data_prediction_monthly.columns) - else: - if five_day: - weather_data_prediction = pd.read_csv( - f"{data_path}Precipitation_data/Downscaled_CMIP6_data/{ssp_scenario}/prediction_weather_by_smaller_facilities_with_ANC_lm.csv", index_col=0, - dtype={'column_name': 'float64'}) - else: - weather_data_prediction = pd.read_csv( - f"{data_path}Precipitation_data/Downscaled_CMIP6_data/{ssp_scenario}/prediction_weather_monthly_by_smaller_facilities_with_ANC_lm.csv", - index_col=0, dtype={'column_name': 'float64'}) - weather_data_prediction = weather_data_prediction.iloc[(min_year_for_analysis - absolute_min_year) * 12:] - weather_data_prediction_flatten = weather_data_prediction.values.flatten() - num_facilities = len(weather_data_prediction.columns) + weather_data_prediction_five_day_cumulative = weather_data_prediction_five_day_cumulative.iloc[(min_year_for_analysis - absolute_min_year) * 12:] + weather_data_prediction_monthly = weather_data_prediction_monthly.iloc[(min_year_for_analysis - absolute_min_year) * 12:] + weather_data_prediction_monthly_flattened = weather_data_prediction_monthly.values.flatten() + weather_data_prediction_five_day_cumulative_flattened = weather_data_prediction_five_day_cumulative.values.flatten() + weather_data_prediction_flatten = np.vstack((weather_data_prediction_monthly_flattened, weather_data_prediction_five_day_cumulative_flattened)).T + num_facilities = len(weather_data_prediction_monthly.columns) missing_facility = [col for col in expanded_facility_info.index if col not in weather_data_prediction_monthly.columns] expanded_facility_info = expanded_facility_info.drop(missing_facility) @@ -714,36 +703,36 @@ def get_weather_data(ssp_scenario, model_type): minimum_distance_prediction, #above_below_X_prediction ]) - # X_continuous_weather = np.column_stack([ - # weather_data_prediction_flatten, - # np.array(year_flattened_prediction), - # np.array(month_flattened_prediction), - # lag_1_month_prediction, - # lag_2_month_prediction, - # lag_3_month_prediction, - # lag_4_month_prediction, - # lag_1_5_day_prediction, - # lag_2_5_day_prediction, - # lag_3_5_day_prediction, - # lag_4_5_day_prediction, - # altitude_prediction, - # minimum_distance_prediction - # ]) - # - # X_categorical_weather = np.column_stack([ - # resid_encoded_prediction, - # zone_encoded_prediction, - # owner_encoded_prediction, - # ftype_encoded_prediction, - # facility_encoded_prediction - # ]) - # - # #scaler_weather = StandardScaler() - # #X_continuous_weather_scaled = scaler_weather.fit_transform(X_continuous_weather) - # #X_weather_standardized = np.column_stack([X_continuous_weather_scaled, X_categorical_weather]) - # X_weather_standardized = np.column_stack([X_continuous_weather, X_categorical_weather]) + X_continuous_weather = np.column_stack([ + weather_data_prediction_flatten, + np.array(year_flattened_prediction), + np.array(month_flattened_prediction), + lag_1_month_prediction, + lag_2_month_prediction, + lag_3_month_prediction, + lag_4_month_prediction, + lag_1_5_day_prediction, + lag_2_5_day_prediction, + lag_3_5_day_prediction, + lag_4_5_day_prediction, + altitude_prediction, + minimum_distance_prediction + ]) + + X_categorical_weather = np.column_stack([ + resid_encoded_prediction, + zone_encoded_prediction, + dist_encoded_prediction, + owner_encoded_prediction, + ftype_encoded_prediction, + facility_encoded_prediction + ]) + + scaler_weather = StandardScaler() + X_continuous_weather_scaled = scaler_weather.fit_transform(X_continuous_weather) + X_weather_standardized = np.column_stack([X_continuous_weather_scaled, X_categorical_weather]) - X_basis_weather_filtered = X_basis_weather[X_basis_weather[:, 0] > mask_threshold] + X_basis_weather_filtered = X_weather_standardized[X_weather_standardized[:, 0] > mask_threshold] # format output year_month_labels = np.array([f"{y}-{m}" for y, m in zip(X_basis_weather_filtered[:, 2], X_basis_weather[:, 3])]) predictions_weather = results_of_weather_model.predict(X_basis_weather_filtered) @@ -761,40 +750,41 @@ def get_weather_data(ssp_scenario, model_type): if use_residuals: predictions = results_of_weather_model.predict(X_basis_weather_filtered) else: - # X_continuous_ANC = np.column_stack([ - # np.array(year_flattened_prediction), - # np.array(month_flattened_prediction), - # altitude_prediction, - # minimum_distance_prediction - # ]) - # - # X_categorical_ANC = np.column_stack([ - # resid_encoded_prediction, - # zone_encoded_prediction, - # owner_encoded_prediction, - # ftype_encoded_prediction, - # facility_encoded_prediction - # ]) - - #scaler_ANC = StandardScaler() - #X_continuous_ANC_scaled = scaler_ANC.fit_transform(X_continuous_ANC) - - #X_bases_ANC_standardized = np.column_stack([X_continuous_ANC_scaled, X_categorical_ANC]) - #X_bases_ANC_standardized = np.column_stack([X_continuous_ANC, X_categorical_ANC]) - X_basis_ANC = np.column_stack([ + X_continuous_ANC = np.column_stack([ np.array(year_flattened_prediction), np.array(month_flattened_prediction), + altitude_prediction, + minimum_distance_prediction + ]) + + X_categorical_ANC = np.column_stack([ resid_encoded_prediction, zone_encoded_prediction, dist_encoded_prediction, owner_encoded_prediction, ftype_encoded_prediction, - facility_encoded_prediction, - altitude_prediction, - minimum_distance_prediction, - # above_below_X_prediction + facility_encoded_prediction ]) - y_pred_ANC = results.predict(X_basis_ANC) + + scaler_ANC = StandardScaler() + X_continuous_ANC_scaled = scaler_ANC.fit_transform(X_continuous_ANC) + + X_bases_ANC_standardized = np.column_stack([X_continuous_ANC_scaled, X_categorical_ANC]) + #X_bases_ANC_standardized = np.column_stack([X_continuous_ANC, X_categorical_ANC]) + # X_basis_ANC = np.column_stack([ + # np.array(year_flattened_prediction), + # np.array(month_flattened_prediction), + # resid_encoded_prediction, + # zone_encoded_prediction, + # dist_encoded_prediction, + # owner_encoded_prediction, + # ftype_encoded_prediction, + # facility_encoded_prediction, + # altitude_prediction, + # minimum_distance_prediction, + # # above_below_X_prediction + # ]) + y_pred_ANC = results.predict(X_bases_ANC_standardized) if log_y: predictions = np.exp(predictions_weather) - np.exp(y_pred_ANC[X_basis_weather[:, 0] > mask_threshold]) data_weather_predictions['y_pred_no_weather'] = np.exp(y_pred_ANC[X_basis_weather[:, 0] > mask_threshold]) @@ -829,31 +819,31 @@ def get_weather_data(ssp_scenario, model_type): plt.tight_layout() plt.show() - # Format output: Add all relevant X variables - full_data_weather_predictions = pd.DataFrame({ - 'Year': year_flattened_prediction[X_basis_weather[:, 0] > mask_threshold], - 'Month': np.array(month_flattened_prediction)[X_basis_weather[:, 0] > mask_threshold], - 'Facility_ID': facility_flattened_prediction[X_basis_weather[:, 0] > mask_threshold], - 'Altitude': np.array(altitude_prediction)[X_basis_weather[:, 0] > mask_threshold], - 'Zone': np.array(zone_info_prediction)[X_basis_weather[:, 0] > mask_threshold], - 'District':np.array(dist_info_prediction)[X_basis_weather[:, 0] > mask_threshold], - 'Resid': np.array(resid_info_prediction)[X_basis_weather[:, 0] > mask_threshold], - 'Owner': np.array(owner_info_prediction)[X_basis_weather[:, 0] > mask_threshold], - 'Facility_Type': np.array(ftype_info_prediction)[X_basis_weather[:, 0] > mask_threshold], - 'Precipitation': X_basis_weather[X_basis_weather[:, 0] > mask_threshold, 0], - 'Lag_1_Precipitation': np.array(lag_1_month_prediction)[X_basis_weather[:, 0] > mask_threshold], - 'Lag_2_Precipitation': np.array(lag_2_month_prediction)[X_basis_weather[:, 0] > mask_threshold], - 'Lag_3_Precipitation': np.array(lag_3_month_prediction)[X_basis_weather[:, 0] > mask_threshold], - 'Lag_4_Precipitation': np.array(lag_4_month_prediction)[X_basis_weather[:, 0] > mask_threshold], - 'Predicted_Weather_Model': np.exp(predictions_weather), - 'Predicted_No_Weather_Model': np.exp(y_pred_ANC[X_basis_weather[:, 0] > mask_threshold]), - 'Difference_in_Expectation': predictions, - }) - - #Save the results - full_data_weather_predictions.to_csv(f"{data_path}weather_predictions_with_X_{ssp_scenario}_{model_type}.csv", index=False) - - X_basis_weather_filtered = pd.DataFrame(X_basis_weather_filtered) - - # Save to CSV - X_basis_weather_filtered.to_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/X_basis_weather_filtered_predictions_{ssp_scenario}_{model_type}.csv', index=False) + # # Format output: Add all relevant X variables + # full_data_weather_predictions = pd.DataFrame({ + # 'Year': year_flattened_prediction[X_basis_weather[:, 0] > mask_threshold], + # 'Month': np.array(month_flattened_prediction)[X_basis_weather[:, 0] > mask_threshold], + # 'Facility_ID': facility_flattened_prediction[X_basis_weather[:, 0] > mask_threshold], + # 'Altitude': np.array(altitude_prediction)[X_basis_weather[:, 0] > mask_threshold], + # 'Zone': np.array(zone_info_prediction)[X_basis_weather[:, 0] > mask_threshold], + # 'District':np.array(dist_info_prediction)[X_basis_weather[:, 0] > mask_threshold], + # 'Resid': np.array(resid_info_prediction)[X_basis_weather[:, 0] > mask_threshold], + # 'Owner': np.array(owner_info_prediction)[X_basis_weather[:, 0] > mask_threshold], + # 'Facility_Type': np.array(ftype_info_prediction)[X_basis_weather[:, 0] > mask_threshold], + # 'Precipitation': X_basis_weather[X_basis_weather[:, 0] > mask_threshold, 0], + # 'Lag_1_Precipitation': np.array(lag_1_month_prediction)[X_basis_weather[:, 0] > mask_threshold], + # 'Lag_2_Precipitation': np.array(lag_2_month_prediction)[X_basis_weather[:, 0] > mask_threshold], + # 'Lag_3_Precipitation': np.array(lag_3_month_prediction)[X_basis_weather[:, 0] > mask_threshold], + # 'Lag_4_Precipitation': np.array(lag_4_month_prediction)[X_basis_weather[:, 0] > mask_threshold], + # 'Predicted_Weather_Model': np.exp(predictions_weather), + # 'Predicted_No_Weather_Model': np.exp(y_pred_ANC[X_basis_weather[:, 0] > mask_threshold]), + # 'Difference_in_Expectation': predictions, + # }) + # + # #Save the results + # full_data_weather_predictions.to_csv(f"{data_path}weather_predictions_with_X_{ssp_scenario}_{model_type}.csv", index=False) + # + # X_basis_weather_filtered = pd.DataFrame(X_basis_weather_filtered) + # + # # Save to CSV + # X_basis_weather_filtered.to_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/X_basis_weather_filtered_predictions_{ssp_scenario}_{model_type}.csv', index=False) From 34110a1bb88edace3a04f2ecc2a8218da608c82e Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 10 Jan 2025 11:59:15 +0000 Subject: [PATCH 175/291] Rmoved if log y as y will always be logged --- ...al_realtionship_reporting_precipitation.py | 181 ++++++------------ 1 file changed, 54 insertions(+), 127 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index aae6e98346..b02e626e07 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -347,17 +347,8 @@ def repeat_info(info, num_facilities, year_range, historical): results_df = pd.concat([coefficient_names, coefficients_df, p_values_df], axis=1) results_df.to_csv('/Users/rem76/Desktop/Climate_change_health/Data/results_of_model_historical.csv') -if use_residuals: - if log_y: - y_weather = (y[mask_ANC_data] - np.exp(y_pred)) + 1 # for poisson - else: - y_weather = (y[mask_ANC_data] - y_pred) + 1 # for poisson -else: - if log_y: - y_weather = np.exp(y_pred) - else: - y_weather = y_pred +y_weather = np.exp(y_pred) print("ANC prediction", results.summary()) @@ -365,20 +356,13 @@ def repeat_info(info, num_facilities, year_range, historical): year_month_labels = np.array([f"{y}-{m}" for y, m in zip(year_flattened, month_flattened)]) y_filtered = y[mask_ANC_data] year_month_labels_filtered = year_month_labels[mask_ANC_data] -if log_y: - data_ANC_predictions = pd.DataFrame({ +data_ANC_predictions = pd.DataFrame({ 'Year_Month': year_month_labels_filtered, 'y_filtered': y_filtered, 'y_pred': np.exp(y_pred), 'residuals': y_filtered - np.exp(y_pred) }) -else: - data_ANC_predictions = pd.DataFrame({ - 'Year_Month': year_month_labels_filtered, - 'y_filtered': y_filtered, - 'y_pred': y_pred, - 'residuals': y_filtered - y_pred - }) + data_ANC_predictions = data_ANC_predictions.sort_values(by='Year_Month').reset_index(drop=True) x_labels = data_ANC_predictions['Year_Month'][::num_facilities*12] @@ -545,26 +529,16 @@ def repeat_info(info, num_facilities, year_range, historical): monthly_weather_predictions = X_filtered[:, 0][np.isin(indices_all_data, common_indices)] -if log_y: - axs[0].scatter(X_filtered[:, 0], y[mask_all_data], color='red', alpha=0.5, label = 'Non weather model') - axs[0].hlines(y = 0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color = 'black', linestyle = '--') - axs[0].scatter(X_filtered[:, 0], np.exp(y_pred_weather), label='Weather model', color="blue", alpha = 0.5) - axs[0].hlines(y=0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color='black', linestyle='--') - axs[0].set_ylabel('ANC visits') +axs[0].scatter(X_filtered[:, 0], y[mask_all_data], color='red', alpha=0.5, label = 'Non weather model') +axs[0].hlines(y = 0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color = 'black', linestyle = '--') +axs[0].scatter(X_filtered[:, 0], np.exp(y_pred_weather), label='Weather model', color="blue", alpha = 0.5) +axs[0].hlines(y=0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color='black', linestyle='--') +axs[0].set_ylabel('ANC visits') + +axs[1].scatter(monthly_weather_predictions, np.exp(matched_y_pred_weather) - np.exp(matched_y_pred), color='red', alpha=0.5, label = 'Residuals') +axs[1].hlines(y = 0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color = 'black', linestyle = '--') +axs[1].set_ylabel('Difference between weather and non-weather model') - axs[1].scatter(monthly_weather_predictions, np.exp(matched_y_pred_weather) - np.exp(matched_y_pred), color='red', alpha=0.5, label = 'Residuals') - axs[1].hlines(y = 0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color = 'black', linestyle = '--') - axs[1].set_ylabel('Difference between weather and non-weather model') -else: - axs[0].scatter(X_filtered[:, 0], y[mask_all_data], color='red', alpha=0.5, label = 'Non weather model') - axs[0].hlines(y = 0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color = 'black', linestyle = '--') - axs[0].scatter(X_filtered[:, 0], y_pred, label='Weather model') - axs[0].hlines(y=0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color='black', linestyle='--') - axs[0].set_ylabel('ANC visits') - - axs[1].scatter(monthly_weather_predictions, matched_y_pred_weather- matched_y_pred, color='red', alpha=0.5, label = 'Residuals') - axs[1].hlines(y = 0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color = 'black', linestyle = '--') - axs[1].set_ylabel('Difference between weather and non-weather model') axs[0].set_xlabel('Monthly precipitation (mm)') axs[1].set_xlabel('Monthly precipitation (mm)') @@ -681,28 +655,6 @@ def get_weather_data(ssp_scenario, model_type): minimum_distance_prediction = np.nan_to_num(minimum_distance_prediction, nan=np.nan, posinf=np.nan, neginf=np.nan) # just in case # Weather data - X_basis_weather = np.column_stack([ - weather_data_prediction_flatten, - np.array(year_flattened_prediction), - np.array(month_flattened_prediction), - resid_encoded_prediction, - zone_encoded_prediction, - dist_encoded_prediction, - owner_encoded_prediction, - ftype_encoded_prediction, - lag_1_month_prediction, - lag_2_month_prediction, - lag_3_month_prediction, - lag_4_month_prediction, - lag_1_5_day_prediction, - lag_2_5_day_prediction, - lag_3_5_day_prediction, - lag_4_5_day_prediction, - facility_encoded_prediction, - altitude_prediction, - minimum_distance_prediction, - #above_below_X_prediction - ]) X_continuous_weather = np.column_stack([ weather_data_prediction_flatten, np.array(year_flattened_prediction), @@ -730,34 +682,27 @@ def get_weather_data(ssp_scenario, model_type): scaler_weather = StandardScaler() X_continuous_weather_scaled = scaler_weather.fit_transform(X_continuous_weather) - X_weather_standardized = np.column_stack([X_continuous_weather_scaled, X_categorical_weather]) + X_basis_weather = np.column_stack([X_continuous_weather_scaled, X_categorical_weather]) - X_basis_weather_filtered = X_weather_standardized[X_weather_standardized[:, 0] > mask_threshold] + X_basis_weather_filtered = X_basis_weather[X_basis_weather[:, 0] > mask_threshold] # format output year_month_labels = np.array([f"{y}-{m}" for y, m in zip(X_basis_weather_filtered[:, 2], X_basis_weather[:, 3])]) predictions_weather = results_of_weather_model.predict(X_basis_weather_filtered) - if log_y: - data_weather_predictions = pd.DataFrame({ + + data_weather_predictions = pd.DataFrame({ 'Year_Month': year_month_labels, 'y_pred_weather': np.exp(predictions_weather) }) - else: - data_weather_predictions = pd.DataFrame({ - 'Year_Month': year_month_labels, - 'y_pred_weather': predictions_weather - }) - if use_residuals: - predictions = results_of_weather_model.predict(X_basis_weather_filtered) - else: - X_continuous_ANC = np.column_stack([ + + X_continuous_ANC = np.column_stack([ np.array(year_flattened_prediction), np.array(month_flattened_prediction), altitude_prediction, minimum_distance_prediction ]) - X_categorical_ANC = np.column_stack([ + X_categorical_ANC = np.column_stack([ resid_encoded_prediction, zone_encoded_prediction, dist_encoded_prediction, @@ -766,32 +711,14 @@ def get_weather_data(ssp_scenario, model_type): facility_encoded_prediction ]) - scaler_ANC = StandardScaler() - X_continuous_ANC_scaled = scaler_ANC.fit_transform(X_continuous_ANC) - - X_bases_ANC_standardized = np.column_stack([X_continuous_ANC_scaled, X_categorical_ANC]) - #X_bases_ANC_standardized = np.column_stack([X_continuous_ANC, X_categorical_ANC]) - # X_basis_ANC = np.column_stack([ - # np.array(year_flattened_prediction), - # np.array(month_flattened_prediction), - # resid_encoded_prediction, - # zone_encoded_prediction, - # dist_encoded_prediction, - # owner_encoded_prediction, - # ftype_encoded_prediction, - # facility_encoded_prediction, - # altitude_prediction, - # minimum_distance_prediction, - # # above_below_X_prediction - # ]) - y_pred_ANC = results.predict(X_bases_ANC_standardized) - if log_y: - predictions = np.exp(predictions_weather) - np.exp(y_pred_ANC[X_basis_weather[:, 0] > mask_threshold]) - data_weather_predictions['y_pred_no_weather'] = np.exp(y_pred_ANC[X_basis_weather[:, 0] > mask_threshold]) + scaler_ANC = StandardScaler() + X_continuous_ANC_scaled = scaler_ANC.fit_transform(X_continuous_ANC) - else: - predictions = predictions_weather - y_pred_ANC[X_basis_weather[:, 0] > mask_threshold] - data_weather_predictions['y_pred_no_weather'] = y_pred_ANC[X_basis_weather[:, 0] > mask_threshold] + X_bases_ANC_standardized = np.column_stack([X_continuous_ANC_scaled, X_categorical_ANC]) + + y_pred_ANC = results.predict(X_bases_ANC_standardized) + predictions = np.exp(predictions_weather) - np.exp(y_pred_ANC[X_basis_weather[:, 0] > mask_threshold]) + data_weather_predictions['y_pred_no_weather'] = np.exp(y_pred_ANC[X_basis_weather[:, 0] > mask_threshold]) data_weather_predictions['difference_in_expectation'] = predictions data_weather_predictions['weather'] = X_basis_weather[X_basis_weather[:, 0] > mask_threshold, 0] @@ -819,31 +746,31 @@ def get_weather_data(ssp_scenario, model_type): plt.tight_layout() plt.show() - # # Format output: Add all relevant X variables - # full_data_weather_predictions = pd.DataFrame({ - # 'Year': year_flattened_prediction[X_basis_weather[:, 0] > mask_threshold], - # 'Month': np.array(month_flattened_prediction)[X_basis_weather[:, 0] > mask_threshold], - # 'Facility_ID': facility_flattened_prediction[X_basis_weather[:, 0] > mask_threshold], - # 'Altitude': np.array(altitude_prediction)[X_basis_weather[:, 0] > mask_threshold], - # 'Zone': np.array(zone_info_prediction)[X_basis_weather[:, 0] > mask_threshold], - # 'District':np.array(dist_info_prediction)[X_basis_weather[:, 0] > mask_threshold], - # 'Resid': np.array(resid_info_prediction)[X_basis_weather[:, 0] > mask_threshold], - # 'Owner': np.array(owner_info_prediction)[X_basis_weather[:, 0] > mask_threshold], - # 'Facility_Type': np.array(ftype_info_prediction)[X_basis_weather[:, 0] > mask_threshold], - # 'Precipitation': X_basis_weather[X_basis_weather[:, 0] > mask_threshold, 0], - # 'Lag_1_Precipitation': np.array(lag_1_month_prediction)[X_basis_weather[:, 0] > mask_threshold], - # 'Lag_2_Precipitation': np.array(lag_2_month_prediction)[X_basis_weather[:, 0] > mask_threshold], - # 'Lag_3_Precipitation': np.array(lag_3_month_prediction)[X_basis_weather[:, 0] > mask_threshold], - # 'Lag_4_Precipitation': np.array(lag_4_month_prediction)[X_basis_weather[:, 0] > mask_threshold], - # 'Predicted_Weather_Model': np.exp(predictions_weather), - # 'Predicted_No_Weather_Model': np.exp(y_pred_ANC[X_basis_weather[:, 0] > mask_threshold]), - # 'Difference_in_Expectation': predictions, - # }) - # - # #Save the results - # full_data_weather_predictions.to_csv(f"{data_path}weather_predictions_with_X_{ssp_scenario}_{model_type}.csv", index=False) - # - # X_basis_weather_filtered = pd.DataFrame(X_basis_weather_filtered) - # - # # Save to CSV - # X_basis_weather_filtered.to_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/X_basis_weather_filtered_predictions_{ssp_scenario}_{model_type}.csv', index=False) + # Format output: Add all relevant X variables + full_data_weather_predictions = pd.DataFrame({ + 'Year': year_flattened_prediction[X_basis_weather[:, 0] > mask_threshold], + 'Month': np.array(month_flattened_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'Facility_ID': facility_flattened_prediction[X_basis_weather[:, 0] > mask_threshold], + 'Altitude': np.array(altitude_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'Zone': np.array(zone_info_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'District':np.array(dist_info_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'Resid': np.array(resid_info_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'Owner': np.array(owner_info_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'Facility_Type': np.array(ftype_info_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'Precipitation': X_basis_weather[X_basis_weather[:, 0] > mask_threshold, 0], + 'Lag_1_Precipitation': np.array(lag_1_month_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'Lag_2_Precipitation': np.array(lag_2_month_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'Lag_3_Precipitation': np.array(lag_3_month_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'Lag_4_Precipitation': np.array(lag_4_month_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'Predicted_Weather_Model': np.exp(predictions_weather), + 'Predicted_No_Weather_Model': np.exp(y_pred_ANC[X_basis_weather[:, 0] > mask_threshold]), + 'Difference_in_Expectation': predictions, + }) + + #Save the results + full_data_weather_predictions.to_csv(f"{data_path}weather_predictions_with_X_{ssp_scenario}_{model_type}.csv", index=False) + + X_basis_weather_filtered = pd.DataFrame(X_basis_weather_filtered) + + # Save to CSV + X_basis_weather_filtered.to_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/X_basis_weather_filtered_predictions_{ssp_scenario}_{model_type}.csv', index=False) From 26c25215007b77e225fb19ed5cc737ffd2f04541 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 10 Jan 2025 12:00:06 +0000 Subject: [PATCH 176/291] Rmoved use residuals as changed that analysis --- ...historical_realtionship_reporting_precipitation.py | 11 +++-------- 1 file changed, 3 insertions(+), 8 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index b02e626e07..8878c534bb 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -21,7 +21,6 @@ absolute_min_year = 2011 mask_threshold = -np.inf # accounts for scaling use_percentile_mask_threshold = False -use_residuals = False from sklearn.preprocessing import StandardScaler poisson=False @@ -387,13 +386,9 @@ def repeat_info(info, num_facilities, year_range, historical): axs[0].legend(loc='upper left') # Panel B: Residuals -if use_residuals: - axs[1].scatter(data_ANC_predictions['Year_Month'], data_ANC_predictions['residuals'], color='#9AC4F8', alpha=0.7, label='Residuals') - axs[1].scatter(data_ANC_predictions_grouped['Year_Month'], np.exp(data_ANC_predictions_grouped['residuals']), - color='red', alpha=0.7, label='Mean Residuals') -else: - axs[1].scatter(data_ANC_predictions['Year_Month'], (data_ANC_predictions['y_filtered'] - data_ANC_predictions['y_pred']), color='#9AC4F8', alpha=0.7, label='Residuals') - axs[1].scatter(data_ANC_predictions_grouped['Year_Month'], data_ANC_predictions_grouped['residuals'], + +axs[1].scatter(data_ANC_predictions['Year_Month'], (data_ANC_predictions['y_filtered'] - data_ANC_predictions['y_pred']), color='#9AC4F8', alpha=0.7, label='Residuals') +axs[1].scatter(data_ANC_predictions_grouped['Year_Month'], data_ANC_predictions_grouped['residuals'], color='red', alpha=0.7, label='Mean Residuals') axs[1].set_xticks(xticks) From 2b2d0283140e4b25cdb42f7ea907a307c34d1c9c Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 10 Jan 2025 13:18:10 +0000 Subject: [PATCH 177/291] The standard scaler introduces very weird results (esp. for the Dedza region, which suddenly has > 20,000 birth disruptions) --- ...al_realtionship_reporting_precipitation.py | 91 +++++++++---------- 1 file changed, 44 insertions(+), 47 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 8878c534bb..0e13fa719c 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -5,6 +5,7 @@ import statsmodels.api as sm from statsmodels.genmod.families import NegativeBinomial, Poisson from statsmodels.genmod.generalized_linear_model import GLM +from sklearn.preprocessing import StandardScaler ANC = True daily_max = False @@ -21,15 +22,9 @@ absolute_min_year = 2011 mask_threshold = -np.inf # accounts for scaling use_percentile_mask_threshold = False -from sklearn.preprocessing import StandardScaler -poisson=False -if use_residuals: - poisson = False -if poisson: - log_y = False -else: - log_y = True +poisson = False +log_y = True covid_months = range((2020 - min_year_for_analysis)* 12 + 4, (2020 - min_year_for_analysis)* 12 + 4 + 20) # Bingling's paper: disruption between April 2020 and Dec 2021, a period of 20 months cyclone_freddy_months_phalombe = range((2023 - min_year_for_analysis)* 12 + 4, (2020 - min_year_for_analysis)* 12 + 4 + 14) # From news report and DHIS2, see disruption from April 2023 - June 2024, 14 months @@ -169,19 +164,25 @@ def repeat_info(info, num_facilities, year_range, historical): lag_2_month = weather_data_monthly_df.shift(2).values lag_3_month = weather_data_monthly_df.shift(3).values lag_4_month = weather_data_monthly_df.shift(4).values + lag_9_month = weather_data_monthly_df.shift(9).values + lag_1_month = lag_1_month[(min_year_for_analysis - absolute_min_year) * 12:].flatten() lag_2_month = lag_2_month[(min_year_for_analysis - absolute_min_year) * 12:].flatten() lag_3_month = lag_3_month[(min_year_for_analysis - absolute_min_year) * 12:].flatten() lag_4_month = lag_4_month[(min_year_for_analysis - absolute_min_year) * 12:].flatten() + lag_9_month = lag_9_month[(min_year_for_analysis - absolute_min_year) * 12:].flatten() lag_1_5_day = weather_data_five_day_cumulative_df.shift(1).values lag_2_5_day = weather_data_five_day_cumulative_df.shift(2).values lag_3_5_day = weather_data_five_day_cumulative_df.shift(3).values lag_4_5_day = weather_data_five_day_cumulative_df.shift(4).values + lag_9_5_day = weather_data_five_day_cumulative_df.shift(9).values + lag_1_5_day = lag_1_5_day[(min_year_for_analysis - absolute_min_year) * 12:].flatten() lag_2_5_day = lag_2_5_day[(min_year_for_analysis - absolute_min_year) * 12:].flatten() lag_3_5_day = lag_3_5_day[(min_year_for_analysis - absolute_min_year) * 12:].flatten() lag_4_5_day = lag_4_5_day[(min_year_for_analysis - absolute_min_year) * 12:].flatten() + lag_9_5_day = lag_9_5_day[(min_year_for_analysis - absolute_min_year) * 12:].flatten() # need for binary lag_12_month = weather_data_monthly_df.shift(12).values @@ -294,18 +295,6 @@ def repeat_info(info, num_facilities, year_range, historical): ########################## STEP 1: GENERATE PREDICTIONS OF ANC DATA ########################## ############################################################################################## -X = np.column_stack([ - year_flattened, - month_flattened, - resid_encoded, - zone_encoded, - dist_encoded, - owner_encoded, - ftype_encoded, - facility_encoded, - altitude, - np.array(minimum_distance) -]) # Continuous columns that need to be standardized (weather_data, lag variables, altitude, minimum_distance) X_continuous = np.column_stack([ year_flattened, @@ -323,8 +312,8 @@ def repeat_info(info, num_facilities, year_range, historical): ]) scaler = StandardScaler() X_continuous_scaled = scaler.fit_transform(X_continuous) +X_continuous_scaled = X_continuous X_ANC_standardized = np.column_stack([X_continuous_scaled, X_categorical]) -#X_weather_standardized = np.column_stack([X_continuous, X_categorical]) coefficient_names = ["year", "month"] + list(resid_encoded.columns) + list(zone_encoded.columns) + \ list(owner_encoded.columns) + list(ftype_encoded.columns) + \ @@ -420,10 +409,12 @@ def repeat_info(info, num_facilities, year_range, historical): lag_2_month, lag_3_month, lag_4_month, + lag_9_month, lag_1_5_day, lag_2_5_day, lag_3_5_day, lag_4_5_day, + lag_9_5_day, facility_encoded, np.array(altitude), np.array(minimum_distance), @@ -457,8 +448,9 @@ def repeat_info(info, num_facilities, year_range, historical): scaler = StandardScaler() X_continuous_scaled = scaler.fit_transform(X_continuous) +X_continuous_scaled = X_continuous + X_weather_standardized = np.column_stack([X_continuous_scaled, X_categorical]) -#X_weather_standardized = np.column_stack([X_continuous, X_categorical]) results_of_weather_model, y_pred_weather, mask_all_data = build_model(X_weather_standardized, y, poisson = poisson, log_y=log_y, X_mask_mm=mask_threshold) @@ -473,12 +465,12 @@ def repeat_info(info, num_facilities, year_range, historical): coefficients_weather = results_of_weather_model.params coefficients_weather_df = pd.DataFrame(coefficients_weather, columns=['coefficients']) #rescale coefficients -continuous_coefficients = coefficients_weather[:len(X_weather[0])] -categorical_coefficients = coefficients_weather[len(X_weather[0]):] -#means = scaler.mean_ -#scales = scaler.scale_ -#rescaled_continuous_coefficients = continuous_coefficients * scales -#rescaled_coefficients_weather = np.concatenate([rescaled_continuous_coefficients, categorical_coefficients]) +continuous_coefficients = coefficients_weather[:len(X_continuous_scaled[0])] +categorical_coefficients = coefficients_weather[len(X_continuous_scaled[0]):] +means = scaler.mean_ +scales = scaler.scale_ +rescaled_continuous_coefficients = continuous_coefficients * scales +rescaled_coefficients_weather = np.concatenate([rescaled_continuous_coefficients, categorical_coefficients]) rescaled_coefficients_weather = np.concatenate([continuous_coefficients, categorical_coefficients]) rescaled_coefficients_df = pd.DataFrame(rescaled_coefficients_weather, columns=['rescaled coefficients']) @@ -491,25 +483,21 @@ def repeat_info(info, num_facilities, year_range, historical): print("All predictors", results_of_weather_model.summary()) # X_filtered = X_weather[mask_all_data] -# # Effect size -# if use_residuals: -# y_mean = np.mean(y_weather[mask_all_data]) -# SS_total = np.sum((y_weather[mask_all_data] - y_mean) ** 2) -# else: -# y_mean = np.mean(y[mask_all_data]) -# SS_total = np.sum((y[mask_all_data] - y_mean) ** 2) -# -# predictor_variances = np.var(X_filtered, axis=0, ddof=1) -# coefficients = results_of_weather_model.params -# SS_effect = coefficients**2 * predictor_variances -# eta_squared = SS_effect / SS_total -# effect_size_summary = pd.DataFrame({ -# 'Coefficient': coefficients, -# 'SS_effect': SS_effect, -# 'Eta-squared': eta_squared -# }).sort_values(by='Eta-squared', ascending=False) -# -# print(effect_size_summary) +# Effect size +y_mean = np.mean(y[mask_all_data]) +SS_total = np.sum((y[mask_all_data] - y_mean) ** 2) + +predictor_variances = np.var(X_filtered, axis=0, ddof=1) +coefficients = results_of_weather_model.params +SS_effect = coefficients**2 * predictor_variances +eta_squared = SS_effect / SS_total +effect_size_summary = pd.DataFrame({ + 'Coefficient': coefficients, + 'SS_effect': SS_effect, + 'Eta-squared': eta_squared +}).sort_values(by='Eta-squared', ascending=False) + +print(effect_size_summary) fig, axs = plt.subplots(1, 2, figsize=(10, 6)) @@ -585,21 +573,26 @@ def get_weather_data(ssp_scenario, model_type): lag_2_month_prediction = weather_data_prediction_monthly_df.shift(2).values lag_3_month_prediction = weather_data_prediction_monthly_df.shift(3).values lag_4_month_prediction = weather_data_prediction_monthly_df.shift(4).values + lag_9_month_prediction = weather_data_prediction_monthly_df.shift(9).values lag_1_month_prediction = lag_1_month_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() lag_2_month_prediction = lag_2_month_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() lag_3_month_prediction = lag_3_month_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() lag_4_month_prediction = lag_4_month_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() + lag_9_month_prediction = lag_9_month_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() lag_1_5_day_prediction = weather_data_prediction_five_day_cumulative_df.shift(1).values lag_2_5_day_prediction = weather_data_prediction_five_day_cumulative_df.shift(2).values lag_3_5_day_prediction = weather_data_prediction_five_day_cumulative_df.shift(3).values lag_4_5_day_prediction = weather_data_prediction_five_day_cumulative_df.shift(4).values + lag_9_5_day_prediction = weather_data_prediction_five_day_cumulative_df.shift(9).values lag_1_5_day_prediction = lag_1_5_day_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() lag_2_5_day_prediction = lag_2_5_day_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() lag_3_5_day_prediction = lag_3_5_day_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() lag_4_5_day_prediction = lag_4_5_day_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() + lag_9_5_day_prediction = lag_9_5_day_prediction[(min_year_for_analysis - absolute_min_year) * 12:].flatten() + weather_data_prediction_five_day_cumulative = weather_data_prediction_five_day_cumulative_df # keep these seperate for binary features # need for binary comparison @@ -658,10 +651,12 @@ def get_weather_data(ssp_scenario, model_type): lag_2_month_prediction, lag_3_month_prediction, lag_4_month_prediction, + lag_9_month_prediction, lag_1_5_day_prediction, lag_2_5_day_prediction, lag_3_5_day_prediction, lag_4_5_day_prediction, + lag_9_5_day_prediction, altitude_prediction, minimum_distance_prediction ]) @@ -677,6 +672,7 @@ def get_weather_data(ssp_scenario, model_type): scaler_weather = StandardScaler() X_continuous_weather_scaled = scaler_weather.fit_transform(X_continuous_weather) + X_continuous_weather_scaled = X_continuous_weather X_basis_weather = np.column_stack([X_continuous_weather_scaled, X_categorical_weather]) X_basis_weather_filtered = X_basis_weather[X_basis_weather[:, 0] > mask_threshold] @@ -708,6 +704,7 @@ def get_weather_data(ssp_scenario, model_type): scaler_ANC = StandardScaler() X_continuous_ANC_scaled = scaler_ANC.fit_transform(X_continuous_ANC) + X_continuous_ANC_scaled = X_continuous_ANC X_bases_ANC_standardized = np.column_stack([X_continuous_ANC_scaled, X_categorical_ANC]) From 3096b0fdbd73b5efacac267466b7a02a0fc4509b Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 10 Jan 2025 13:34:38 +0000 Subject: [PATCH 178/291] Removing the facilities reduces R^2 but also increases significance of predictors --- ...al_realtionship_reporting_precipitation.py | 36 ++++++++----------- 1 file changed, 15 insertions(+), 21 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 0e13fa719c..a6dd78f3cc 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -6,6 +6,7 @@ from statsmodels.genmod.families import NegativeBinomial, Poisson from statsmodels.genmod.generalized_linear_model import GLM from sklearn.preprocessing import StandardScaler +from statsmodels.stats.outliers_influence import variance_inflation_factor ANC = True daily_max = False @@ -127,6 +128,11 @@ def stepwise_selection(X, y, log_y, poisson, p_value_threshold=0.05): return included +def calculate_vif(X): + vif_data = pd.DataFrame() + vif_data["feature"] = X.columns + vif_data["VIF"] = [variance_inflation_factor(X.values, i) for i in range(X.shape[1])] + return vif_data def repeat_info(info, num_facilities, year_range, historical): # Repeat facilities in alternating order for each month and year @@ -308,12 +314,13 @@ def repeat_info(info, num_facilities, year_range, historical): dist_encoded, owner_encoded, ftype_encoded, - facility_encoded, + #facility_encoded, ]) scaler = StandardScaler() X_continuous_scaled = scaler.fit_transform(X_continuous) X_continuous_scaled = X_continuous X_ANC_standardized = np.column_stack([X_continuous_scaled, X_categorical]) +X_ANC_standardized = pd.DataFrame(X_ANC_standardized) coefficient_names = ["year", "month"] + list(resid_encoded.columns) + list(zone_encoded.columns) + \ list(owner_encoded.columns) + list(ftype_encoded.columns) + \ @@ -415,7 +422,7 @@ def repeat_info(info, num_facilities, year_range, historical): lag_3_5_day, lag_4_5_day, lag_9_5_day, - facility_encoded, + #facility_encoded, np.array(altitude), np.array(minimum_distance), #np.array(above_below_X)[mask_ANC_data], @@ -429,20 +436,23 @@ def repeat_info(info, num_facilities, year_range, historical): lag_2_month, lag_3_month, lag_4_month, + lag_9_month, lag_1_5_day, lag_2_5_day, lag_3_5_day, lag_4_5_day, + lag_9_5_day, np.array(altitude), np.array(minimum_distance),] ) + X_categorical = np.column_stack([ resid_encoded, zone_encoded, dist_encoded, owner_encoded, ftype_encoded, - facility_encoded, + #facility_encoded, #np.array(above_below_X)[mask_ANC_data], ]) @@ -483,22 +493,6 @@ def repeat_info(info, num_facilities, year_range, historical): print("All predictors", results_of_weather_model.summary()) # X_filtered = X_weather[mask_all_data] -# Effect size -y_mean = np.mean(y[mask_all_data]) -SS_total = np.sum((y[mask_all_data] - y_mean) ** 2) - -predictor_variances = np.var(X_filtered, axis=0, ddof=1) -coefficients = results_of_weather_model.params -SS_effect = coefficients**2 * predictor_variances -eta_squared = SS_effect / SS_total -effect_size_summary = pd.DataFrame({ - 'Coefficient': coefficients, - 'SS_effect': SS_effect, - 'Eta-squared': eta_squared -}).sort_values(by='Eta-squared', ascending=False) - -print(effect_size_summary) - fig, axs = plt.subplots(1, 2, figsize=(10, 6)) @@ -667,7 +661,7 @@ def get_weather_data(ssp_scenario, model_type): dist_encoded_prediction, owner_encoded_prediction, ftype_encoded_prediction, - facility_encoded_prediction + #facility_encoded_prediction ]) scaler_weather = StandardScaler() @@ -699,7 +693,7 @@ def get_weather_data(ssp_scenario, model_type): dist_encoded_prediction, owner_encoded_prediction, ftype_encoded_prediction, - facility_encoded_prediction + #facility_encoded_prediction ]) scaler_ANC = StandardScaler() From 91dacecc0d67be0d0c1880e7cb892e4d73d8afc5 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 10 Jan 2025 13:45:07 +0000 Subject: [PATCH 179/291] Tried PCA... Made worse --- ...historical_realtionship_reporting_precipitation.py | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index a6dd78f3cc..93cb6e6be0 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -300,6 +300,9 @@ def repeat_info(info, num_facilities, year_range, historical): ########################## STEP 1: GENERATE PREDICTIONS OF ANC DATA ########################## ############################################################################################## +from sklearn.impute import SimpleImputer +from sklearn.decomposition import PCA +from sklearn.preprocessing import StandardScaler # Continuous columns that need to be standardized (weather_data, lag variables, altitude, minimum_distance) X_continuous = np.column_stack([ @@ -320,13 +323,17 @@ def repeat_info(info, num_facilities, year_range, historical): X_continuous_scaled = scaler.fit_transform(X_continuous) X_continuous_scaled = X_continuous X_ANC_standardized = np.column_stack([X_continuous_scaled, X_categorical]) -X_ANC_standardized = pd.DataFrame(X_ANC_standardized) +pca = PCA(n_components=30) # Specify the number of components you want +imputer = SimpleImputer(strategy='mean') +X_ANC_standardized_imputed = imputer.fit_transform(X_ANC_standardized) +X_continuous_reduced = pca.fit_transform(X_ANC_standardized_imputed) +X_ANC_standardized = np.column_stack([X_continuous_reduced, X_categorical]) coefficient_names = ["year", "month"] + list(resid_encoded.columns) + list(zone_encoded.columns) + \ list(owner_encoded.columns) + list(ftype_encoded.columns) + \ list(facility_encoded.columns) + ["altitude", "minimum_distance"] coefficient_names = pd.Series(coefficient_names) -results, y_pred, mask_ANC_data = build_model(X_ANC_standardized , y, poisson = poisson, log_y=log_y, X_mask_mm=mask_threshold) +results, y_pred, mask_ANC_data = build_model(X_continuous_reduced , y, poisson = poisson, log_y=log_y, X_mask_mm=mask_threshold) coefficients = results.params coefficients_df = pd.DataFrame(coefficients, columns=['coefficients']) continuous_coefficients = coefficients[:len(X_continuous_scaled[0])] From 706f404dc0e98a42d32a53666a1710b286a91a2c Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 10 Jan 2025 13:46:06 +0000 Subject: [PATCH 180/291] Tried PCA... Made worse, but all predictors did have significant coefficients --- ...ear_model_historical_realtionship_reporting_precipitation.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 93cb6e6be0..8ec0e396ce 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -333,7 +333,7 @@ def repeat_info(info, num_facilities, year_range, historical): list(owner_encoded.columns) + list(ftype_encoded.columns) + \ list(facility_encoded.columns) + ["altitude", "minimum_distance"] coefficient_names = pd.Series(coefficient_names) -results, y_pred, mask_ANC_data = build_model(X_continuous_reduced , y, poisson = poisson, log_y=log_y, X_mask_mm=mask_threshold) +results, y_pred, mask_ANC_data = build_model(X_ANC_standardized , y, poisson = poisson, log_y=log_y, X_mask_mm=mask_threshold) coefficients = results.params coefficients_df = pd.DataFrame(coefficients, columns=['coefficients']) continuous_coefficients = coefficients[:len(X_continuous_scaled[0])] From d3e4aae0487800c3c07fa8ded229fc853fd4a8d1 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 10 Jan 2025 13:46:48 +0000 Subject: [PATCH 181/291] Actually, it was the imputer that made it work --- ...r_model_historical_realtionship_reporting_precipitation.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 8ec0e396ce..f1a1334d0e 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -317,13 +317,13 @@ def repeat_info(info, num_facilities, year_range, historical): dist_encoded, owner_encoded, ftype_encoded, - #facility_encoded, + facility_encoded, ]) scaler = StandardScaler() X_continuous_scaled = scaler.fit_transform(X_continuous) X_continuous_scaled = X_continuous X_ANC_standardized = np.column_stack([X_continuous_scaled, X_categorical]) -pca = PCA(n_components=30) # Specify the number of components you want +pca = PCA(n_components=44) # Specify the number of components you want imputer = SimpleImputer(strategy='mean') X_ANC_standardized_imputed = imputer.fit_transform(X_ANC_standardized) X_continuous_reduced = pca.fit_transform(X_ANC_standardized_imputed) From 0e5c0c7fd41ce18ba599de165bd58972d81987cb Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 10 Jan 2025 13:53:33 +0000 Subject: [PATCH 182/291] Not even, it was a mistake... --- ..._historical_realtionship_reporting_precipitation.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index f1a1334d0e..02ea73201f 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -326,8 +326,7 @@ def repeat_info(info, num_facilities, year_range, historical): pca = PCA(n_components=44) # Specify the number of components you want imputer = SimpleImputer(strategy='mean') X_ANC_standardized_imputed = imputer.fit_transform(X_ANC_standardized) -X_continuous_reduced = pca.fit_transform(X_ANC_standardized_imputed) -X_ANC_standardized = np.column_stack([X_continuous_reduced, X_categorical]) +X_ANC_standardized = pca.fit_transform(X_ANC_standardized_imputed) coefficient_names = ["year", "month"] + list(resid_encoded.columns) + list(zone_encoded.columns) + \ list(owner_encoded.columns) + list(ftype_encoded.columns) + \ @@ -466,8 +465,11 @@ def repeat_info(info, num_facilities, year_range, historical): scaler = StandardScaler() X_continuous_scaled = scaler.fit_transform(X_continuous) X_continuous_scaled = X_continuous - -X_weather_standardized = np.column_stack([X_continuous_scaled, X_categorical]) +pca = PCA(n_components=44) # Specify the number of components you want +imputer = SimpleImputer(strategy='mean') +X_ANC_standardized_imputed = imputer.fit_transform(X_ANC_standardized) +X_continuous_reduced = pca.fit_transform(X_ANC_standardized_imputed) +X_weather_standardized = np.column_stack([X_continuous_reduced, X_categorical]) results_of_weather_model, y_pred_weather, mask_all_data = build_model(X_weather_standardized, y, poisson = poisson, log_y=log_y, X_mask_mm=mask_threshold) From 0c850415b9829ab10ea434b76911d64392870075 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 10 Jan 2025 13:55:07 +0000 Subject: [PATCH 183/291] Removed PCA --- ...historical_realtionship_reporting_precipitation.py | 11 ++--------- 1 file changed, 2 insertions(+), 9 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 02ea73201f..39ff020026 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -323,10 +323,6 @@ def repeat_info(info, num_facilities, year_range, historical): X_continuous_scaled = scaler.fit_transform(X_continuous) X_continuous_scaled = X_continuous X_ANC_standardized = np.column_stack([X_continuous_scaled, X_categorical]) -pca = PCA(n_components=44) # Specify the number of components you want -imputer = SimpleImputer(strategy='mean') -X_ANC_standardized_imputed = imputer.fit_transform(X_ANC_standardized) -X_ANC_standardized = pca.fit_transform(X_ANC_standardized_imputed) coefficient_names = ["year", "month"] + list(resid_encoded.columns) + list(zone_encoded.columns) + \ list(owner_encoded.columns) + list(ftype_encoded.columns) + \ @@ -465,11 +461,8 @@ def repeat_info(info, num_facilities, year_range, historical): scaler = StandardScaler() X_continuous_scaled = scaler.fit_transform(X_continuous) X_continuous_scaled = X_continuous -pca = PCA(n_components=44) # Specify the number of components you want -imputer = SimpleImputer(strategy='mean') -X_ANC_standardized_imputed = imputer.fit_transform(X_ANC_standardized) -X_continuous_reduced = pca.fit_transform(X_ANC_standardized_imputed) -X_weather_standardized = np.column_stack([X_continuous_reduced, X_categorical]) + +X_weather_standardized = np.column_stack([X_continuous_scaled, X_categorical]) results_of_weather_model, y_pred_weather, mask_all_data = build_model(X_weather_standardized, y, poisson = poisson, log_y=log_y, X_mask_mm=mask_threshold) From e6f38f9b8e949a1200601ab7fbfe0a2e4d9f3c4b Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 10 Jan 2025 16:43:54 +0000 Subject: [PATCH 184/291] Testing statistically significant results --- src/scripts/climate_change/cohort_model.py | 501 +++++++++++++-------- 1 file changed, 310 insertions(+), 191 deletions(-) diff --git a/src/scripts/climate_change/cohort_model.py b/src/scripts/climate_change/cohort_model.py index c67dba1410..84be2caa96 100644 --- a/src/scripts/climate_change/cohort_model.py +++ b/src/scripts/climate_change/cohort_model.py @@ -1,4 +1,6 @@ from pathlib import Path +from scipy.stats import ttest_rel, wilcoxon, shapiro +from scipy.stats import ttest_1samp import geopandas as gpd from netCDF4 import Dataset @@ -63,205 +65,322 @@ scenarios = ['ssp245', 'ssp585'] model_types = ['lowest', 'median', 'highest'] year_range = range(min_year, max_year) - -# Loop through scenarios and model types -for scenario in scenarios: - for model_type in model_types: - predictions_from_cmip = pd.read_csv( - f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' - ) - predictions_from_cmip_sum = predictions_from_cmip.groupby('Year').sum().reset_index() - predictions_from_cmip_sum['Percentage_Difference'] = ( - predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum[ - 'Predicted_No_Weather_Model']) - # Match birth results and predictions - matching_rows = min(len(births_model_subset), len(predictions_from_cmip_sum)) - print(matching_rows) - multiplied_values = births_model_subset.head(matching_rows).iloc[:, 1].values * predictions_from_cmip_sum[ - 'Percentage_Difference'].head(matching_rows).values - births_model_subset['Multiplied_Values'] = multiplied_values - - # Plot the results - plt.plot(year_range, multiplied_values) - plt.ylabel("Change ANC cases due to weather") - plt.axhline(y=0, color='black', linestyle='--') - plt.plot(year_range, predictions_from_cmip_sum.iloc[0:36, -1] * 100) - plt.xlabel("Percentage Change in ANC cases due to weather") - plt.axhline(y=0, color='black', linestyle='--') - - # Check for negative values (missed cases?) - negative_sum = np.sum(multiplied_values[multiplied_values < 0]) - print("Sum of values < 0:", negative_sum) - print(negative_sum / births_model_subset['Model_mean'].sum() * 100) - - # Plot by zone - predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'Zone']).sum().reset_index() - plt.figure(figsize=(10, 6)) - for zone in predictions_from_cmip_sum['Zone'].unique(): - zone_data = predictions_from_cmip_sum[predictions_from_cmip_sum['Zone'] == zone] - zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data[ - 'Predicted_No_Weather_Model']) * 100 - plt.plot(zone_data['Year'], zone_data['Percentage_Difference'], label=f'Zone {zone}') - plt.xlabel("Year") - plt.ylabel("Change ANC cases due to weather") - plt.axhline(y=0, color='black', linestyle='--') - plt.ylim(-1.5, 0) - plt.legend(title='Zones') - - # Plot by district - predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'District']).sum().reset_index() - plt.figure(figsize=(10, 6)) - for district in predictions_from_cmip_sum['District'].unique(): - district_data = predictions_from_cmip_sum[predictions_from_cmip_sum['District'] == district] - district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data[ - 'Predicted_No_Weather_Model']) * 100 - plt.plot(district_data['Year'], district_data['Percentage_Difference'], label=f'{district}') - plt.xlabel("Year") - plt.ylabel("Change ANC cases due to weather") - plt.axhline(y=0, color='black', linestyle='--') - plt.ylim(-2.5, 0) - plt.legend(title='Districts') - - # Generate district map visualization - predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( - {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"}) - polygons = [ - Polygon( - [(x, y), (x + difference_long, y), (x + difference_long, y + difference_lat), (x, y + difference_lat)]) - for x in long_data for y in lat_data - ] - grid = gpd.GeoDataFrame({'geometry': polygons}, crs=malawi.crs) - #grid_clipped_ADM2 = gpd.overlay(grid, malawi_admin2, how='intersection') - predictions_from_cmip_sum['Percentage_Difference'] = (predictions_from_cmip_sum['Difference_in_Expectation'] / - predictions_from_cmip_sum[ - 'Predicted_No_Weather_Model']) * 100 - percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() - malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) - malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 - - # Plot map - fig, ax = plt.subplots(figsize=(12, 12)) - #malawi_admin2.plot(ax=ax, edgecolor='white', color='white') - malawi_admin2.dropna(subset=['Percentage_Difference']).plot( - ax=ax, - column='Percentage_Difference', - cmap='Blues_r', - edgecolor='black', - alpha=1, - legend=False - ) - sm = plt.cm.ScalarMappable(cmap='Blues_r', - norm=mcolors.Normalize(vmin=malawi_admin2['Percentage_Difference'].min(), - vmax=malawi_admin2['Percentage_Difference'].max())) - sm.set_array([]) - cbar = plt.colorbar(sm, ax=ax, orientation="vertical", shrink=0.7) - cbar.set_label("Percentage Difference (%)", fontsize=12) - plt.xlabel("Longitude", fontsize=14) - plt.ylabel("Latitude", fontsize=14) - plt.title(f"{scenario}: {model_type}", fontsize=16) - plt.tight_layout() - plt.savefig(results_folder_to_save / f'{scenario}_{model_type}_map_Malawi_cumulative_difference.png') - # Save multiplied values by model and scenario - multiplied_values_df = pd.DataFrame({ - 'Year': year_range[:matching_rows], - 'Scenario': scenario, - 'Model_Type': model_type, - 'Multiplied_Values': multiplied_values - }) - multiplied_values_df.to_csv(results_folder_to_save/f'multiplied_values_{scenario}_{model_type}.csv', index=False) - # -# # Get unique districts from both sources -# adm2_districts = set(grid_clipped_ADM2['ADM2_EN'].unique()) -# prediction_districts = set(predictions_from_cmip_sum['District'].unique()) +# # Loop through scenarios and model types +# for scenario in scenarios: +# for model_type in model_types: +# predictions_from_cmip = pd.read_csv( +# f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' +# ) +# predictions_from_cmip_sum = predictions_from_cmip.groupby('Year').sum().reset_index() +# predictions_from_cmip_sum['Percentage_Difference'] = ( +# predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum[ +# 'Predicted_No_Weather_Model']) +# # Match birth results and predictions +# matching_rows = min(len(births_model_subset), len(predictions_from_cmip_sum)) +# print(matching_rows) +# multiplied_values = births_model_subset.head(matching_rows).iloc[:, 1].values * predictions_from_cmip_sum[ +# 'Percentage_Difference'].head(matching_rows).values +# births_model_subset['Multiplied_Values'] = multiplied_values # -# # Districts in ADM2 but not in predictions -# missing_in_predictions = adm2_districts - prediction_districts -# print("Districts in ADM2 but not in predictions:", missing_in_predictions) +# # Plot the results +# plt.plot(year_range, multiplied_values) +# plt.ylabel("Change ANC cases due to weather") +# plt.axhline(y=0, color='black', linestyle='--') +# plt.plot(year_range, predictions_from_cmip_sum.iloc[0:36, -1] * 100) +# plt.xlabel("Percentage Change in ANC cases due to weather") +# plt.axhline(y=0, color='black', linestyle='--') # -# # Districts in predictions but not in ADM2 -# missing_in_adm2 = prediction_districts - adm2_districts -# print("Districts in predictions but not in ADM2:", missing_in_adm2) +# # Check for negative values (missed cases?) +# negative_sum = np.sum(multiplied_values[multiplied_values < 0]) +# print("Sum of values < 0:", negative_sum) +# print(negative_sum / births_model_subset['Model_mean'].sum() * 100) # +# # Plot by zone +# predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'Zone']).sum().reset_index() +# plt.figure(figsize=(10, 6)) +# for zone in predictions_from_cmip_sum['Zone'].unique(): +# zone_data = predictions_from_cmip_sum[predictions_from_cmip_sum['Zone'] == zone] +# zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data[ +# 'Predicted_No_Weather_Model']) * 100 +# plt.plot(zone_data['Year'], zone_data['Percentage_Difference'], label=f'Zone {zone}') +# plt.xlabel("Year") +# plt.ylabel("Change ANC cases due to weather") +# plt.axhline(y=0, color='black', linestyle='--') +# plt.ylim(-1.5, 0) +# plt.legend(title='Zones') +# +# # Plot by district +# predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'District']).sum().reset_index() +# plt.figure(figsize=(10, 6)) +# for district in predictions_from_cmip_sum['District'].unique(): +# district_data = predictions_from_cmip_sum[predictions_from_cmip_sum['District'] == district] +# district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data[ +# 'Predicted_No_Weather_Model']) * 100 +# plt.plot(district_data['Year'], district_data['Percentage_Difference'], label=f'{district}') +# plt.xlabel("Year") +# plt.ylabel("Change ANC cases due to weather") +# plt.axhline(y=0, color='black', linestyle='--') +# plt.ylim(-2.5, 0) +# plt.legend(title='Districts') +# +# # Generate district map visualization +# predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( +# {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"}) +# polygons = [ +# Polygon( +# [(x, y), (x + difference_long, y), (x + difference_long, y + difference_lat), (x, y + difference_lat)]) +# for x in long_data for y in lat_data +# ] +# grid = gpd.GeoDataFrame({'geometry': polygons}, crs=malawi.crs) +# #grid_clipped_ADM2 = gpd.overlay(grid, malawi_admin2, how='intersection') +# predictions_from_cmip_sum['Percentage_Difference'] = (predictions_from_cmip_sum['Difference_in_Expectation'] / +# predictions_from_cmip_sum[ +# 'Predicted_No_Weather_Model']) * 100 +# percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() +# malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) +# malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 +# +# # Plot map +# fig, ax = plt.subplots(figsize=(12, 12)) +# #malawi_admin2.plot(ax=ax, edgecolor='white', color='white') +# malawi_admin2.dropna(subset=['Percentage_Difference']).plot( +# ax=ax, +# column='Percentage_Difference', +# cmap='Blues_r', +# edgecolor='black', +# alpha=1, +# legend=False +# ) +# sm = plt.cm.ScalarMappable(cmap='Blues_r', +# norm=mcolors.Normalize(vmin=malawi_admin2['Percentage_Difference'].min(), +# vmax=malawi_admin2['Percentage_Difference'].max())) +# sm.set_array([]) +# cbar = plt.colorbar(sm, ax=ax, orientation="vertical", shrink=0.7) +# cbar.set_label("Percentage Difference (%)", fontsize=12) +# plt.xlabel("Longitude", fontsize=14) +# plt.ylabel("Latitude", fontsize=14) +# plt.title(f"{scenario}: {model_type}", fontsize=16) +# plt.tight_layout() +# plt.savefig(results_folder_to_save / f'{scenario}_{model_type}_map_Malawi_cumulative_difference.png') +# # Save multiplied values by model and scenario +# multiplied_values_df = pd.DataFrame({ +# 'Year': year_range[:matching_rows], +# 'Scenario': scenario, +# 'Model_Type': model_type, +# 'Multiplied_Values': multiplied_values +# }) +# multiplied_values_df.to_csv(results_folder_to_save/f'multiplied_values_{scenario}_{model_type}.csv', index=False) +# +# # +# # # Get unique districts from both sources +# # adm2_districts = set(grid_clipped_ADM2['ADM2_EN'].unique()) +# # prediction_districts = set(predictions_from_cmip_sum['District'].unique()) +# # +# # # Districts in ADM2 but not in predictions +# # missing_in_predictions = adm2_districts - prediction_districts +# # print("Districts in ADM2 but not in predictions:", missing_in_predictions) +# # +# # # Districts in predictions but not in ADM2 +# # missing_in_adm2 = prediction_districts - adm2_districts +# # print("Districts in predictions but not in ADM2:", missing_in_adm2) +# # +# +# +# +# ## now all grids +# fig, axes = plt.subplots(2, 3, figsize=(18, 12), constrained_layout=True) +# +# global_min = float('inf') +# global_max = float('-inf') +# +# for scenario in scenarios: +# for model_type in model_types: +# predictions_from_cmip = pd.read_csv( +# f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' +# ) +# predictions_from_cmip_sum = predictions_from_cmip.groupby('District').sum().reset_index() +# predictions_from_cmip_sum['Percentage_Difference'] = ( +# predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model'] +# ) * 100 +# +# predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( +# {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} +# ) +# percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() +# malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) +# malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 +# +# local_min = malawi_admin2['Percentage_Difference'].min() +# local_max = malawi_admin2['Percentage_Difference'].max() +# global_min = min(global_min, local_min) +# global_max = max(global_max, local_max) +# +# for i, scenario in enumerate(scenarios): +# for j, model_type in enumerate(model_types): +# predictions_from_cmip = pd.read_csv( +# f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' +# ) +# predictions_from_cmip_sum = predictions_from_cmip.groupby('District').sum().reset_index() +# predictions_from_cmip_sum['Percentage_Difference'] = ( +# predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model'] +# ) * 100 +# +# predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( +# {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} +# ) +# percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() +# malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) +# malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 +# +# ax = axes[i, j] +# malawi_admin2.dropna(subset=['Percentage_Difference']).plot( +# ax=ax, +# column='Percentage_Difference', +# cmap='Blues_r', +# edgecolor='black', +# alpha=1, +# legend=False, +# vmin=global_min, +# vmax=global_max +# ) +# +# ax.set_title(f"{scenario}: {model_type}", fontsize=14) +# +# if i != 1: +# ax.set_xlabel("") +# if j != 0: +# ax.set_ylabel("") +# else: +# ax.set_ylabel("Latitude", fontsize=10) +# +# if i == 1: +# ax.set_xlabel("Longitude", fontsize=10) +# +# sm = plt.cm.ScalarMappable( +# cmap='Blues_r', +# norm=mcolors.Normalize(vmin=global_min, vmax=global_max) +# ) +# sm.set_array([]) +# fig.colorbar(sm, ax=axes, orientation="vertical", shrink=0.8, label="Percentage Difference (%)") +# plt.suptitle("Percentage Difference Maps by Scenario and Model Type", fontsize=16, y=1.02) +# plt.savefig(results_folder_to_save / 'percentage_difference_maps_grid.png') +# plt.show() +# +# percentage_diff_by_year_district = {} +# +# for scenario in scenarios: +# for model_type in model_types: +# predictions_from_cmip = pd.read_csv( +# f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' +# ) +# +# predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'District']).sum().reset_index() +# predictions_from_cmip_sum.loc[predictions_from_cmip_sum['Difference_in_Expectation'] > 0, 'Difference_in_Expectation'] = 0 +# +# predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( +# {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} +# ) +# +# # Collect percentage differences by year and district +# for year, year_data in predictions_from_cmip_sum.groupby('Year'): +# if year not in percentage_diff_by_year_district: +# percentage_diff_by_year_district[year] = {} +# for _, row in year_data.iterrows(): +# district = row['District'] +# percentage_diff = row['Difference_in_Expectation'] +# +# if district not in percentage_diff_by_year_district[year]: +# percentage_diff_by_year_district[year][district] = 0 +# percentage_diff_by_year_district[year][district] += percentage_diff +# data_for_plot = pd.DataFrame.from_dict(percentage_diff_by_year_district, orient='index').fillna(0) +# +# fig, ax = plt.subplots(figsize=(12, 8)) +# data_for_plot.plot(kind='bar', stacked=True, ax=ax, cmap='tab20') +# ax.set_xlabel('Year', fontsize=12) +# ax.set_ylabel('Percentage Difference (%)', fontsize=12) +# ax.legend(title='District', bbox_to_anchor=(1.05, 1), loc='upper left', fontsize=10) +# plt.tight_layout() +# plt.savefig(results_folder_to_save / 'stacked_bar_percentage_difference.png') +# plt.show() +# +# all_districts = set() +# +# for i, scenario in enumerate(scenarios): +# for j, model_type in enumerate(model_types): +# predictions_from_cmip = pd.read_csv( +# f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' +# ) +# +# predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'District']).sum().reset_index() +# predictions_from_cmip_sum.loc[predictions_from_cmip_sum['Difference_in_Expectation'] > 0, 'Difference_in_Expectation'] = 0 +# +# predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( +# {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} +# ) +# +# # Create Period column to group years into 5-year intervals +# predictions_from_cmip_sum['Period'] = ((predictions_from_cmip_sum['Year'] - 1) // 5) * 5 + 1 +# +# # Collect percentage differences by 5-year period and district +# for period, period_data in predictions_from_cmip_sum.groupby('Period'): +# for _, row in period_data.iterrows(): +# district = row['District'] +# percentage_diff = row['Difference_in_Expectation'] +# +# if period not in percentage_diff_by_year_district: +# percentage_diff_by_year_district[period] = {} +# if district not in percentage_diff_by_year_district[period]: +# percentage_diff_by_year_district[period][district] = 0 +# percentage_diff_by_year_district[period][district] += percentage_diff +# all_districts.add(district) +# +# data_for_plot = pd.DataFrame.from_dict(percentage_diff_by_year_district, orient='index').fillna(0) +# +# # Plotting the data in the respective subplot +# ax = axes[i, j] +# data_for_plot.plot(kind='bar', stacked=True, ax=ax, cmap='tab20', legend=False) +# ax.set_title(f"{scenario}: {model_type}", fontsize=10) +# if i == len(scenarios) - 1: +# ax.set_xlabel('Period (5 years)', fontsize=10) +# if j == 0: +# ax.set_ylabel('Defecit of ANC services', fontsize=10) +# +# # # Create a single legend outside the grid +# # handles, labels = ax.get_legend_handles_labels() +# # fig.legend( +# # handles, +# # labels, +# # title="District", +# # bbox_to_anchor=(1.02, 0.5), +# # loc='center left', +# # fontsize=10 +# # ) +# +# plt.tight_layout(rect=[0, 0, 0.85, 1]) # Leave space for the legend +# plt.savefig(results_folder_to_save / 'stacked_bar_percentage_difference_5_years_grid_single_legend.png') +# plt.show() +significant_results_year = [] - -## now all grids -fig, axes = plt.subplots(2, 3, figsize=(18, 12), constrained_layout=True) - -global_min = float('inf') -global_max = float('-inf') - +# Assuming 'district' is a column in your data for scenario in scenarios: for model_type in model_types: predictions_from_cmip = pd.read_csv( f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' ) - predictions_from_cmip_sum = predictions_from_cmip.groupby('District').sum().reset_index() - predictions_from_cmip_sum['Percentage_Difference'] = ( - predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model'] - ) * 100 - - predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( - {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} - ) - percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() - malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) - malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 - - local_min = malawi_admin2['Percentage_Difference'].min() - local_max = malawi_admin2['Percentage_Difference'].max() - global_min = min(global_min, local_min) - global_max = max(global_max, local_max) - -for i, scenario in enumerate(scenarios): - for j, model_type in enumerate(model_types): - predictions_from_cmip = pd.read_csv( - f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' - ) - predictions_from_cmip_sum = predictions_from_cmip.groupby('District').sum().reset_index() - predictions_from_cmip_sum['Percentage_Difference'] = ( - predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model'] - ) * 100 - - predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( - {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} - ) - percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() - malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) - malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 - - ax = axes[i, j] - malawi_admin2.dropna(subset=['Percentage_Difference']).plot( - ax=ax, - column='Percentage_Difference', - cmap='Blues_r', - edgecolor='black', - alpha=1, - legend=False, - vmin=global_min, - vmax=global_max - ) - - ax.set_title(f"{scenario}: {model_type}", fontsize=14) - - if i != 1: - ax.set_xlabel("") - if j != 0: - ax.set_ylabel("") - else: - ax.set_ylabel("Latitude", fontsize=10) - - if i == 1: - ax.set_xlabel("Longitude", fontsize=10) - -sm = plt.cm.ScalarMappable( - cmap='Blues_r', - norm=mcolors.Normalize(vmin=global_min, vmax=global_max) -) -sm.set_array([]) -fig.colorbar(sm, ax=axes, orientation="vertical", shrink=0.8, label="Percentage Difference (%)") - -plt.suptitle("Percentage Difference Maps by Scenario and Model Type", fontsize=16, y=1.02) -plt.savefig(results_folder_to_save / 'percentage_difference_maps_grid.png') -plt.show() + predictions_from_cmip_sum = predictions_from_cmip.groupby(['District', 'Year']).sum().reset_index() + for district in predictions_from_cmip_sum['District'].unique(): + district_values = predictions_from_cmip_sum[predictions_from_cmip_sum['District'] == district] + no_weather_model = district_values['Predicted_No_Weather_Model'].values + weather_model = district_values['Predicted_Weather_Model'].values + + # Calculate the difference + difference = no_weather_model - weather_model + + # Perform a one-sample t-test assuming 0 as the null hypothesis mean + t_stat, p_value = ttest_1samp(difference, popmean=0) + # Print results if p-value is below 0.05 (statistically significant) + if p_value < 0.05: + print(f"Scenario: {scenario}, Model Type: {model_type}, District: {district}, " + f"t-stat: {t_stat:.2f}, p-value: {p_value:.4f}") From 345e545c77e61d6e332415e91e9701379b705dd4 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 10 Jan 2025 17:26:20 +0000 Subject: [PATCH 185/291] Tidy --- ...model_historical_realtionship_reporting_precipitation.py | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 39ff020026..4ad0c26766 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -299,10 +299,8 @@ def repeat_info(info, num_facilities, year_range, historical): minimum_distance = np.nan_to_num(minimum_distance, nan=np.nan, posinf=np.nan, neginf=np.nan) # just in case ########################## STEP 1: GENERATE PREDICTIONS OF ANC DATA ########################## + ############################################################################################## -from sklearn.impute import SimpleImputer -from sklearn.decomposition import PCA -from sklearn.preprocessing import StandardScaler # Continuous columns that need to be standardized (weather_data, lag variables, altitude, minimum_distance) X_continuous = np.column_stack([ @@ -317,7 +315,7 @@ def repeat_info(info, num_facilities, year_range, historical): dist_encoded, owner_encoded, ftype_encoded, - facility_encoded, + #facility_encoded, ]) scaler = StandardScaler() X_continuous_scaled = scaler.fit_transform(X_continuous) From 940967fafbf88abb7ddbc8b92a2b6cbdd792bf65 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 10 Jan 2025 17:26:27 +0000 Subject: [PATCH 186/291] Tidy --- src/scripts/climate_change/cohort_model.ipynb | 1950 ++++++++++------- 1 file changed, 1105 insertions(+), 845 deletions(-) diff --git a/src/scripts/climate_change/cohort_model.ipynb b/src/scripts/climate_change/cohort_model.ipynb index 8d958524b3..7eae776830 100644 --- a/src/scripts/climate_change/cohort_model.ipynb +++ b/src/scripts/climate_change/cohort_model.ipynb @@ -6,8 +6,8 @@ "metadata": { "collapsed": true, "ExecuteTime": { - "end_time": "2025-01-09T12:02:46.081729Z", - "start_time": "2025-01-09T12:02:45.023438Z" + "end_time": "2025-01-10T12:59:21.769589Z", + "start_time": "2025-01-10T12:59:21.461785Z" } }, "source": [ @@ -57,121 +57,6 @@ " " ], "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "draw 0 \\\n", - "run 0 1 2 3 4 \n", - "year \n", - "2010 628547.29707 643232.30216 640615.17254 621277.49257 631746.01105 \n", - "2011 541745.83134 528514.78715 545526.12968 523280.52791 535929.98774 \n", - "2012 554249.89508 554686.08335 564718.41356 560356.53086 545380.73359 \n", - "2013 580421.19128 569661.88062 590017.33322 579403.41865 583329.11308 \n", - "2014 591035.10585 598450.30644 596996.34554 592925.25502 615025.46070 \n", - "2015 607901.05229 617497.19423 602812.18914 613571.49980 618514.96686 \n", - "2016 637998.04292 625203.18700 634217.74458 636689.47811 644977.05524 \n", - "2017 648321.16531 636834.87420 646431.01614 634072.34849 658062.70334 \n", - "2018 659225.87206 640324.38036 657917.30725 651083.69102 671148.35144 \n", - "2019 676237.21459 643232.30216 656317.95026 660679.83296 659225.87206 \n", - "2020 658644.28770 663878.54694 678708.94812 659807.45642 655736.36590 \n", - "2021 641196.75690 647884.97704 654282.40500 648175.76922 637561.85465 \n", - "2022 644104.67870 652101.46365 648030.37313 635090.12112 639161.21164 \n", - "2023 650502.10666 655445.57372 653846.21673 641632.94517 651519.87929 \n", - "2024 666059.48829 670421.37099 667368.05310 650211.31448 657044.93071 \n", - "2025 676964.19504 680453.70120 668822.01400 683943.20736 670130.57881 \n", - "2026 692957.76494 678854.34421 704880.24432 688014.29788 660970.62514 \n", - "2027 700227.56944 711713.86055 694702.51802 705607.22477 701826.92643 \n", - "2028 721600.79467 699064.40072 701099.94598 688014.29788 722473.17121 \n", - "2029 718402.08069 734395.65059 748353.67523 734541.04668 710986.88010 \n", - "2030 732069.31315 739193.72156 735704.21540 700954.54989 724217.92429 \n", - "2031 751843.18139 749807.63613 748208.27914 749662.24004 741956.24727 \n", - "2032 741083.87073 745154.96125 756059.66800 739484.51374 737158.17630 \n", - "2033 738321.34502 768854.52392 759839.96634 743264.81208 772925.61444 \n", - "2034 771617.04963 770744.67309 791536.31396 754605.70710 775106.55579 \n", - "2035 769872.29655 780922.39939 777869.08150 784993.48991 788773.78825 \n", - "2036 789355.37261 801423.24808 804767.35815 799823.89109 815235.87663 \n", - "2037 807384.48777 799096.91064 797933.74192 769145.31610 808547.65649 \n", - "2038 822796.47331 792554.08659 814508.89618 803313.39725 815235.87663 \n", - "2039 799533.09891 824832.01857 794880.42403 816399.04535 817998.40234 \n", - "2040 814363.50009 829339.29736 832538.01134 829193.90127 828466.92082 \n", - "2041 831229.44653 828030.73255 819016.17497 809274.63694 821487.90850 \n", - "2042 850567.12650 837190.68622 835155.14096 854638.21702 844896.67899 \n", - "2043 864379.75505 853765.84048 839517.02366 838935.43930 838499.25103 \n", - "2044 864961.33941 845623.65944 832828.80352 834282.76442 863652.77460 \n", - "2045 883717.43502 834864.34878 850130.93823 847949.99688 849258.56169 \n", - "2046 855801.38574 858709.30754 854492.82093 861035.64498 851875.69131 \n", - "2047 880518.72104 856528.36619 877901.59142 867723.86512 885171.39592 \n", - "2048 889824.07080 861617.22934 863071.19024 881827.28585 872376.54000 \n", - "2049 889242.48644 870631.78692 882699.66239 857546.13882 866124.50813 \n", - "2050 870050.20256 861181.04107 866851.48858 879355.55232 891714.21997 \n", - "2051 888370.10990 900437.98537 894476.74568 877320.00706 883281.24675 \n", - "2052 879355.55232 887933.92163 895058.33004 900874.17364 892586.59651 \n", - "2053 891714.21997 922392.79496 894476.74568 890987.23952 898984.02447 \n", - "2054 889387.88253 894040.55741 905817.64070 863652.77460 900437.98537 \n", - "2055 893458.97305 900583.38146 907416.99769 890987.23952 901891.94627 \n", - "2056 892877.38869 894185.95350 894912.93395 890405.65516 900292.58928 \n", - "2057 913959.82174 894767.53786 889533.27862 893895.16132 905963.03679 \n", - "2058 917449.32790 912796.65302 902473.53063 895785.31049 929226.41119 \n", - "2059 911778.88039 922974.37932 909743.33513 908870.95859 924864.52849 \n", - "2060 19919.26433 18465.30343 22536.39395 18901.49170 20064.66042 \n", - "\n", - "draw \n", - "run 5 6 7 8 9 \n", - "year \n", - "2010 631309.82278 637416.45856 608918.82492 608628.03274 636689.47811 \n", - "2011 546543.90231 543054.39615 514556.76251 534766.81902 527642.41061 \n", - "2012 556430.83643 569371.08844 548579.44757 547997.86321 548870.23975 \n", - "2013 576350.10076 581584.36000 577513.26948 579839.60692 586964.01533 \n", - "2014 612989.91544 581875.15218 580421.19128 588563.37232 598886.49471 \n", - "2015 623167.64174 622440.66129 623603.83001 618660.36295 622295.26520 \n", - "2016 636834.87420 626802.54399 604120.75395 635671.70548 640905.96472 \n", - "2017 650792.89884 644250.07479 637561.85465 655154.78154 626657.14790 \n", - "2018 644540.86697 653555.42455 636398.68593 667222.65701 658789.68379 \n", - "2019 674928.64978 652537.65192 666931.86483 664023.94303 662279.18995 \n", - "2020 658353.49552 664169.33912 635671.70548 669403.59836 652683.04801 \n", - "2021 657481.11898 626075.56354 649775.12621 650647.50275 640469.77645 \n", - "2022 650938.29493 643959.28261 636689.47811 632763.78368 649338.93794 \n", - "2023 656463.34635 660970.62514 657481.11898 643813.88652 663151.56649 \n", - "2024 658935.07988 654282.40500 659807.45642 662569.98213 664169.33912 \n", - "2025 683652.41518 679145.13639 692666.97276 668095.03355 668095.03355 \n", - "2026 686124.14871 676818.79895 693539.34930 666495.67656 675219.44196 \n", - "2027 694847.91411 683216.22691 706334.20522 699936.77726 694847.91411 \n", - "2028 719129.06114 724508.71647 708515.14657 695138.70629 702263.11470 \n", - "2029 720001.43768 745591.14952 706188.80913 708224.35439 726108.07346 \n", - "2030 715784.95107 735849.61149 726108.07346 708660.54266 710841.48401 \n", - "2031 723781.73602 745881.94170 730324.56007 740938.47464 733232.48187 \n", - "2032 723636.33993 741810.85118 735413.42322 740356.89028 723781.73602 \n", - "2033 737594.36457 755187.29146 763765.66077 723781.73602 742683.22772 \n", - "2034 742101.64336 785429.67818 756932.04454 749516.84395 768854.52392 \n", - "2035 791536.31396 765219.62167 756641.25236 780050.02285 768418.33565 \n", - "2036 770453.88091 795316.61230 796043.59275 793862.65140 795752.80057 \n", - "2037 804331.16988 774670.36752 776705.91278 807966.07213 788482.99607 \n", - "2038 804040.37770 824105.03812 797061.36538 809856.22130 804331.16988 \n", - "2039 824541.22639 820470.13587 807384.48777 818579.98670 799242.30673 \n", - "2040 819597.75933 801859.43635 826867.56383 823959.64203 833555.78397 \n", - "2041 836172.91359 831229.44653 816689.83753 824250.43421 828612.31691 \n", - "2042 850421.73041 844169.69854 830647.86217 839953.21193 847513.80861 \n", - "2043 839953.21193 833119.59570 824977.41466 834137.36833 860599.45671 \n", - "2044 841988.75719 855946.78183 854202.02875 865542.92377 848386.18515 \n", - "2045 859727.08017 852602.67176 841552.56892 839517.02366 871358.76737 \n", - "2046 866996.88467 866415.30031 860599.45671 853475.04830 852893.46394 \n", - "2047 852166.48349 851003.31477 868887.03384 848676.97733 867287.67685 \n", - "2048 873394.31263 877320.00706 872812.72827 827885.33646 857546.13882 \n", - "2049 866124.50813 866560.69640 864815.94332 866996.88467 864379.75505 \n", - "2050 854202.02875 880518.72104 880373.32495 874412.08526 872231.14391 \n", - "2051 888370.10990 883717.43502 890841.84343 865106.73550 856673.76228 \n", - "2052 871358.76737 885462.18810 892150.40824 902182.73845 892150.40824 \n", - "2053 880809.51322 884444.41547 867723.86512 882408.87021 896803.08312 \n", - "2054 891714.21997 872376.54000 876883.81879 899565.60883 896366.89485 \n", - "2055 895058.33004 893313.57696 880809.51322 890405.65516 874121.29308 \n", - "2056 883135.85066 909452.54295 882118.07803 886479.96073 875429.85789 \n", - "2057 870922.57910 899129.42056 904509.07589 887643.12945 894476.74568 \n", - "2058 878046.98751 874702.87744 886916.14900 904509.07589 932134.33299 \n", - "2059 901310.36191 905526.84852 914396.01001 903927.49153 903927.49153 \n", - "2060 20064.66042 17883.71907 18174.51125 19337.67997 20646.24478 \n" - ] - }, { "name": "stderr", "output_type": "stream", @@ -185,7 +70,7 @@ ] } ], - "execution_count": 2 + "execution_count": 40 }, { "metadata": {}, @@ -196,8 +81,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-09T12:05:21.197626Z", - "start_time": "2025-01-09T12:05:21.190699Z" + "end_time": "2025-01-10T12:59:22.146505Z", + "start_time": "2025-01-10T12:59:22.142886Z" } }, "cell_type": "code", @@ -207,26 +92,26 @@ ], "id": "bbff583692196586", "outputs": [], - "execution_count": 18 + "execution_count": 41 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-09T12:05:21.858393Z", - "start_time": "2025-01-09T12:05:21.663569Z" + "end_time": "2025-01-10T12:59:22.793563Z", + "start_time": "2025-01-10T12:59:22.607733Z" } }, "cell_type": "code", "source": "predictions_from_cmip = pd.read_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv')", "id": "3be0a4515f3e890e", "outputs": [], - "execution_count": 19 + "execution_count": 42 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-09T12:05:22.252382Z", - "start_time": "2025-01-09T12:05:22.052107Z" + "end_time": "2025-01-10T12:59:23.269203Z", + "start_time": "2025-01-10T12:59:23.091777Z" } }, "cell_type": "code", @@ -480,52 +365,52 @@ "45 GovernmentGovernmentGovernmentGovernmentGovern... \n", "\n", " Facility_Type Precipitation \\\n", - "0 ClinicDistrict HospitalRural/Community Hospita... 377371.401757 \n", - "1 ClinicDistrict HospitalRural/Community Hospita... 424179.161524 \n", - "2 ClinicDistrict HospitalRural/Community Hospita... 416785.291442 \n", - "3 ClinicDistrict HospitalRural/Community Hospita... 431174.255009 \n", - "4 ClinicDistrict HospitalRural/Community Hospita... 405743.410420 \n", - "5 ClinicDistrict HospitalRural/Community Hospita... 410793.849551 \n", - "6 ClinicDistrict HospitalRural/Community Hospita... 430219.873937 \n", - "7 ClinicDistrict HospitalRural/Community Hospita... 332427.056762 \n", - "8 ClinicDistrict HospitalRural/Community Hospita... 392896.036283 \n", - "9 ClinicDistrict HospitalRural/Community Hospita... 409775.392632 \n", - "10 ClinicDistrict HospitalRural/Community Hospita... 410851.208278 \n", - "11 ClinicDistrict HospitalRural/Community Hospita... 456535.963741 \n", - "12 ClinicDistrict HospitalRural/Community Hospita... 452334.398335 \n", - "13 ClinicDistrict HospitalRural/Community Hospita... 329049.810569 \n", - "14 ClinicDistrict HospitalRural/Community Hospita... 414644.190834 \n", - "15 ClinicDistrict HospitalRural/Community Hospita... 392121.029719 \n", - "16 ClinicDistrict HospitalRural/Community Hospita... 380754.054252 \n", - "17 ClinicDistrict HospitalRural/Community Hospita... 296596.215293 \n", - "18 ClinicDistrict HospitalRural/Community Hospita... 423715.504984 \n", - "19 ClinicDistrict HospitalRural/Community Hospita... 368319.084368 \n", - "20 ClinicDistrict HospitalRural/Community Hospita... 418134.051457 \n", - "21 ClinicDistrict HospitalRural/Community Hospita... 380622.271982 \n", - "22 ClinicDistrict HospitalRural/Community Hospita... 388922.127329 \n", - "23 ClinicDistrict HospitalRural/Community Hospita... 373888.999201 \n", - "24 ClinicDistrict HospitalRural/Community Hospita... 403081.277311 \n", - "25 ClinicDistrict HospitalRural/Community Hospita... 377526.089751 \n", - "26 ClinicDistrict HospitalRural/Community Hospita... 312891.203066 \n", - "27 ClinicDistrict HospitalRural/Community Hospita... 383090.314471 \n", - "28 ClinicDistrict HospitalRural/Community Hospita... 370916.909122 \n", - "29 ClinicDistrict HospitalRural/Community Hospita... 358979.193679 \n", - "30 ClinicDistrict HospitalRural/Community Hospita... 411059.228901 \n", - "31 ClinicDistrict HospitalRural/Community Hospita... 457632.022035 \n", - "32 ClinicDistrict HospitalRural/Community Hospita... 366158.628623 \n", - "33 ClinicDistrict HospitalRural/Community Hospita... 414749.367352 \n", - "34 ClinicDistrict HospitalRural/Community Hospita... 394182.173776 \n", - "35 ClinicDistrict HospitalRural/Community Hospita... 412930.274807 \n", - "36 ClinicDistrict HospitalRural/Community Hospita... 350708.805302 \n", - "37 ClinicDistrict HospitalRural/Community Hospita... 293182.399170 \n", - "38 ClinicDistrict HospitalRural/Community Hospita... 377478.093086 \n", - "39 ClinicDistrict HospitalRural/Community Hospita... 291362.431282 \n", - "40 ClinicDistrict HospitalRural/Community Hospita... 368970.926878 \n", - "41 ClinicDistrict HospitalRural/Community Hospita... 397265.484764 \n", - "42 ClinicDistrict HospitalRural/Community Hospita... 327967.298680 \n", - "43 ClinicDistrict HospitalRural/Community Hospita... 315778.193228 \n", - "44 ClinicDistrict HospitalRural/Community Hospita... 342508.889264 \n", - "45 ClinicDistrict HospitalRural/Community Hospita... 369080.727151 \n", + "0 ClinicDistrict HospitalRural/Community Hospita... -44.979294 \n", + "1 ClinicDistrict HospitalRural/Community Hospita... 332.932458 \n", + "2 ClinicDistrict HospitalRural/Community Hospita... 273.236578 \n", + "3 ClinicDistrict HospitalRural/Community Hospita... 389.408735 \n", + "4 ClinicDistrict HospitalRural/Community Hospita... 184.087757 \n", + "5 ClinicDistrict HospitalRural/Community Hospita... 224.863481 \n", + "6 ClinicDistrict HospitalRural/Community Hospita... 381.703350 \n", + "7 ClinicDistrict HospitalRural/Community Hospita... -407.846396 \n", + "8 ClinicDistrict HospitalRural/Community Hospita... 80.361929 \n", + "9 ClinicDistrict HospitalRural/Community Hospita... 216.640767 \n", + "10 ClinicDistrict HospitalRural/Community Hospita... 225.326578 \n", + "11 ClinicDistrict HospitalRural/Community Hospita... 594.171531 \n", + "12 ClinicDistrict HospitalRural/Community Hospita... 560.249358 \n", + "13 ClinicDistrict HospitalRural/Community Hospita... -435.113264 \n", + "14 ClinicDistrict HospitalRural/Community Hospita... 255.949977 \n", + "15 ClinicDistrict HospitalRural/Community Hospita... 74.104759 \n", + "16 ClinicDistrict HospitalRural/Community Hospita... -17.668776 \n", + "17 ClinicDistrict HospitalRural/Community Hospita... -697.133816 \n", + "18 ClinicDistrict HospitalRural/Community Hospita... 329.189035 \n", + "19 ClinicDistrict HospitalRural/Community Hospita... -118.064977 \n", + "20 ClinicDistrict HospitalRural/Community Hospita... 284.126060 \n", + "21 ClinicDistrict HospitalRural/Community Hospita... -18.732747 \n", + "22 ClinicDistrict HospitalRural/Community Hospita... 48.277785 \n", + "23 ClinicDistrict HospitalRural/Community Hospita... -73.095163 \n", + "24 ClinicDistrict HospitalRural/Community Hospita... 162.594496 \n", + "25 ClinicDistrict HospitalRural/Community Hospita... -43.730389 \n", + "26 ClinicDistrict HospitalRural/Community Hospita... -565.572993 \n", + "27 ClinicDistrict HospitalRural/Community Hospita... 1.193485 \n", + "28 ClinicDistrict HospitalRural/Community Hospita... -97.090923 \n", + "29 ClinicDistrict HospitalRural/Community Hospita... -193.472441 \n", + "30 ClinicDistrict HospitalRural/Community Hospita... 227.006074 \n", + "31 ClinicDistrict HospitalRural/Community Hospita... 603.020776 \n", + "32 ClinicDistrict HospitalRural/Community Hospita... -135.507846 \n", + "33 ClinicDistrict HospitalRural/Community Hospita... 256.799140 \n", + "34 ClinicDistrict HospitalRural/Community Hospita... 90.745815 \n", + "35 ClinicDistrict HospitalRural/Community Hospita... 242.112335 \n", + "36 ClinicDistrict HospitalRural/Community Hospita... -260.245065 \n", + "37 ClinicDistrict HospitalRural/Community Hospita... -724.695938 \n", + "38 ClinicDistrict HospitalRural/Community Hospita... -44.117900 \n", + "39 ClinicDistrict HospitalRural/Community Hospita... -739.389811 \n", + "40 ClinicDistrict HospitalRural/Community Hospita... -112.802197 \n", + "41 ClinicDistrict HospitalRural/Community Hospita... 115.639539 \n", + "42 ClinicDistrict HospitalRural/Community Hospita... -443.853139 \n", + "43 ClinicDistrict HospitalRural/Community Hospita... -542.264304 \n", + "44 ClinicDistrict HospitalRural/Community Hospita... -326.448717 \n", + "45 ClinicDistrict HospitalRural/Community Hospita... -111.915703 \n", "\n", " Lag_1_Precipitation Lag_2_Precipitation Lag_3_Precipitation \\\n", "0 398942.636170 404727.057797 405704.571665 \n", @@ -576,100 +461,100 @@ "45 347439.884447 315453.846359 311453.513947 \n", "\n", " Lag_4_Precipitation Predicted_Weather_Model Predicted_No_Weather_Model \\\n", - "0 404895.268433 450413.811572 452178.159027 \n", - "1 386621.761142 449805.162811 451324.318689 \n", - "2 421535.968891 448780.570788 450472.090644 \n", - "3 400973.159779 446657.461648 449621.471846 \n", - "4 419592.912552 447811.134508 448772.459257 \n", - "5 391638.197677 447111.614783 447925.049844 \n", - "6 456824.623648 448389.823951 447079.240580 \n", - "7 357753.146752 443503.204711 446235.028444 \n", - "8 388673.117569 445468.831800 445392.410418 \n", - "9 373019.671935 441550.545941 444551.383494 \n", - "10 406919.996712 442181.994730 443711.944667 \n", - "11 432861.285260 439591.654817 442874.090938 \n", - "12 527784.234663 437890.108389 442037.819314 \n", - "13 318825.960831 440318.995534 441203.126808 \n", - "14 394260.244027 442379.145149 440370.010437 \n", - "15 387202.538290 438585.581628 439538.467226 \n", - "16 423444.969850 439207.738143 438708.494203 \n", - "17 313717.825313 436501.827701 437880.088405 \n", - "18 353491.313705 435213.523261 437053.246871 \n", - "19 424904.453286 433980.084304 436227.966648 \n", - "20 394030.949034 436281.073753 435404.244787 \n", - "21 396757.245029 434232.446019 434582.078347 \n", - "22 357396.518341 431881.487367 433761.464389 \n", - "23 384605.158226 431705.820487 432942.399983 \n", - "24 402279.134778 429946.439795 432124.882203 \n", - "25 343650.740769 430370.073359 431308.908127 \n", - "26 387553.261741 431264.483456 430494.474841 \n", - "27 357983.056662 427120.049100 429681.579436 \n", - "28 368369.784160 428888.240001 428870.219007 \n", - "29 345685.373340 427162.001628 428060.390657 \n", - "30 426320.093861 424371.134246 427252.091491 \n", - "31 427585.588743 429015.574874 426445.318624 \n", - "32 376728.920725 424851.189902 425640.069171 \n", - "33 392238.633130 424630.686008 424836.340258 \n", - "34 428209.211053 421981.174732 424034.129012 \n", - "35 414461.110789 422383.644429 423233.432568 \n", - "36 343006.625602 421716.445639 422434.248066 \n", - "37 342232.642746 419713.526935 421636.572650 \n", - "38 357126.722312 419519.270457 420840.403471 \n", - "39 303106.289335 418301.255283 420045.737685 \n", - "40 355879.690701 417565.319731 419252.572452 \n", - "41 316486.677194 418492.789945 418460.904941 \n", - "42 400442.667319 416393.707279 417670.732321 \n", - "43 357120.223981 417560.781784 416882.051771 \n", - "44 333370.975675 414846.238601 416094.860473 \n", - "45 310691.844984 413085.183289 415309.155615 \n", + "0 404895.268433 462904.609783 inf \n", + "1 386621.761142 463055.752459 inf \n", + "2 421535.968891 462644.111845 inf \n", + "3 400973.159779 460807.846722 inf \n", + "4 419592.912552 463079.419720 inf \n", + "5 391638.197677 462967.863359 inf \n", + "6 456824.623648 465600.988271 inf \n", + "7 357753.146752 459795.744898 inf \n", + "8 388673.117569 463363.585021 inf \n", + "9 373019.671935 459224.382654 inf \n", + "10 406919.996712 460943.631939 inf \n", + "11 432861.285260 458660.558966 inf \n", + "12 527784.234663 457513.243165 inf \n", + "13 318825.960831 460652.792462 inf \n", + "14 394260.244027 464478.060160 inf \n", + "15 387202.538290 460399.603672 inf \n", + "16 423444.969850 462078.098890 inf \n", + "17 313717.825313 458999.883435 inf \n", + "18 353491.313705 458590.220256 inf \n", + "19 424904.453286 457829.716881 inf \n", + "20 394030.949034 461670.160494 inf \n", + "21 396757.245029 459754.510452 inf \n", + "22 357396.518341 457511.882275 inf \n", + "23 384605.158226 458112.644483 inf \n", + "24 402279.134778 456805.271242 inf \n", + "25 343650.740769 457958.753892 inf \n", + "26 387553.261741 459851.993366 inf \n", + "27 357983.056662 455471.906375 inf \n", + "28 368369.784160 458541.506902 inf \n", + "29 345685.373340 457047.936409 inf \n", + "30 426320.093861 454546.519303 inf \n", + "31 427585.588743 461538.408159 inf \n", + "32 376728.920725 456574.397364 inf \n", + "33 392238.633130 457278.838177 inf \n", + "34 428209.211053 454699.104888 inf \n", + "35 414461.110789 456058.544801 inf \n", + "36 343006.625602 455642.820816 inf \n", + "37 342232.642746 453684.658941 inf \n", + "38 357126.722312 454491.481680 inf \n", + "39 303106.289335 453393.217586 inf \n", + "40 355879.690701 453532.539649 inf \n", + "41 316486.677194 455525.969985 inf \n", + "42 400442.667319 453623.172343 inf \n", + "43 357120.223981 455839.764978 inf \n", + "44 333370.975675 453085.420366 inf \n", + "45 310691.844984 451557.724220 inf \n", "\n", " Difference_in_Expectation \n", - "0 -1764.347455 \n", - "1 -1519.155878 \n", - "2 -1691.519856 \n", - "3 -2964.010197 \n", - "4 -961.324749 \n", - "5 -813.435061 \n", - "6 1310.583371 \n", - "7 -2731.823733 \n", - "8 76.421382 \n", - "9 -3000.837553 \n", - "10 -1529.949937 \n", - "11 -3282.436122 \n", - "12 -4147.710925 \n", - "13 -884.131274 \n", - "14 2009.134712 \n", - "15 -952.885598 \n", - "16 499.243940 \n", - "17 -1378.260704 \n", - "18 -1839.723610 \n", - "19 -2247.882344 \n", - "20 876.828966 \n", - "21 -349.632328 \n", - "22 -1879.977022 \n", - "23 -1236.579496 \n", - "24 -2178.442408 \n", - "25 -938.834768 \n", - "26 770.008615 \n", - "27 -2561.530336 \n", - "28 18.020994 \n", - "29 -898.389029 \n", - "30 -2880.957246 \n", - "31 2570.256250 \n", - "32 -788.879269 \n", - "33 -205.654250 \n", - "34 -2052.954280 \n", - "35 -849.788140 \n", - "36 -717.802427 \n", - "37 -1923.045715 \n", - "38 -1321.133014 \n", - "39 -1744.482402 \n", - "40 -1687.252721 \n", - "41 31.885004 \n", - "42 -1277.025042 \n", - "43 678.730014 \n", - "44 -1248.621872 \n", - "45 -2223.972326 " + "0 -inf \n", + "1 -inf \n", + "2 -inf \n", + "3 -inf \n", + "4 -inf \n", + "5 -inf \n", + "6 -inf \n", + "7 -inf \n", + "8 -inf \n", + "9 -inf \n", + "10 -inf \n", + "11 -inf \n", + "12 -inf \n", + "13 -inf \n", + "14 -inf \n", + "15 -inf \n", + "16 -inf \n", + "17 -inf \n", + "18 -inf \n", + "19 -inf \n", + "20 -inf \n", + "21 -inf \n", + "22 -inf \n", + "23 -inf \n", + "24 -inf \n", + "25 -inf \n", + "26 -inf \n", + "27 -inf \n", + "28 -inf \n", + "29 -inf \n", + "30 -inf \n", + "31 -inf \n", + "32 -inf \n", + "33 -inf \n", + "34 -inf \n", + "35 -inf \n", + "36 -inf \n", + "37 -inf \n", + "38 -inf \n", + "39 -inf \n", + "40 -inf \n", + "41 -inf \n", + "42 -inf \n", + "43 -inf \n", + "44 -inf \n", + "45 -inf " ], "text/html": [ "
\n", @@ -721,14 +606,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 377371.401757\n", + " -44.979294\n", " 398942.636170\n", " 404727.057797\n", " 405704.571665\n", " 404895.268433\n", - " 450413.811572\n", - " 452178.159027\n", - " -1764.347455\n", + " 462904.609783\n", + " inf\n", + " -inf\n", " \n", " \n", " 1\n", @@ -741,14 +626,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 424179.161524\n", + " 332.932458\n", " 413397.817913\n", " 388309.667883\n", " 385397.116828\n", " 386621.761142\n", - " 449805.162811\n", - " 451324.318689\n", - " -1519.155878\n", + " 463055.752459\n", + " inf\n", + " -inf\n", " \n", " \n", " 2\n", @@ -761,14 +646,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 416785.291442\n", + " 273.236578\n", " 407187.589904\n", " 420216.307417\n", " 421615.911783\n", " 421535.968891\n", - " 448780.570788\n", - " 450472.090644\n", - " -1691.519856\n", + " 462644.111845\n", + " inf\n", + " -inf\n", " \n", " \n", " 3\n", @@ -781,14 +666,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 431174.255009\n", + " 389.408735\n", " 406189.704606\n", " 403165.981005\n", " 401105.177547\n", " 400973.159779\n", - " 446657.461648\n", - " 449621.471846\n", - " -2964.010197\n", + " 460807.846722\n", + " inf\n", + " -inf\n", " \n", " \n", " 4\n", @@ -801,14 +686,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 405743.410420\n", + " 184.087757\n", " 420471.214026\n", " 421450.033447\n", " 424520.950185\n", " 419592.912552\n", - " 447811.134508\n", - " 448772.459257\n", - " -961.324749\n", + " 463079.419720\n", + " inf\n", + " -inf\n", " \n", " \n", " 5\n", @@ -821,14 +706,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 410793.849551\n", + " 224.863481\n", " 410824.557725\n", " 391493.761671\n", " 388196.210212\n", " 391638.197677\n", - " 447111.614783\n", - " 447925.049844\n", - " -813.435061\n", + " 462967.863359\n", + " inf\n", + " -inf\n", " \n", " \n", " 6\n", @@ -841,14 +726,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 430219.873937\n", + " 381.703350\n", " 432044.900550\n", " 456751.262273\n", " 456752.721138\n", " 456824.623648\n", - " 448389.823951\n", - " 447079.240580\n", - " 1310.583371\n", + " 465600.988271\n", + " inf\n", + " -inf\n", " \n", " \n", " 7\n", @@ -861,14 +746,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 332427.056762\n", + " -407.846396\n", " 348112.188236\n", " 353270.524412\n", " 357410.845800\n", " 357753.146752\n", - " 443503.204711\n", - " 446235.028444\n", - " -2731.823733\n", + " 459795.744898\n", + " inf\n", + " -inf\n", " \n", " \n", " 8\n", @@ -881,14 +766,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 392896.036283\n", + " 80.361929\n", " 405019.687496\n", " 388565.288508\n", " 388245.552346\n", " 388673.117569\n", - " 445468.831800\n", - " 445392.410418\n", - " 76.421382\n", + " 463363.585021\n", + " inf\n", + " -inf\n", " \n", " \n", " 9\n", @@ -901,14 +786,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 409775.392632\n", + " 216.640767\n", " 372460.875926\n", " 375124.877747\n", " 371846.112765\n", " 373019.671935\n", - " 441550.545941\n", - " 444551.383494\n", - " -3000.837553\n", + " 459224.382654\n", + " inf\n", + " -inf\n", " \n", " \n", " 10\n", @@ -921,14 +806,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 410851.208278\n", + " 225.326578\n", " 408169.132145\n", " 406485.011941\n", " 407092.899084\n", " 406919.996712\n", - " 442181.994730\n", - " 443711.944667\n", - " -1529.949937\n", + " 460943.631939\n", + " inf\n", + " -inf\n", " \n", " \n", " 11\n", @@ -941,14 +826,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 456535.963741\n", + " 594.171531\n", " 451325.020396\n", " 433158.134992\n", " 433133.983599\n", " 432861.285260\n", - " 439591.654817\n", - " 442874.090938\n", - " -3282.436122\n", + " 458660.558966\n", + " inf\n", + " -inf\n", " \n", " \n", " 12\n", @@ -961,14 +846,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 452334.398335\n", + " 560.249358\n", " 481501.033891\n", " 524791.840222\n", " 527391.207421\n", " 527784.234663\n", - " 437890.108389\n", - " 442037.819314\n", - " -4147.710925\n", + " 457513.243165\n", + " inf\n", + " -inf\n", " \n", " \n", " 13\n", @@ -981,14 +866,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 329049.810569\n", + " -435.113264\n", " 339513.871817\n", " 320576.954584\n", " 319333.523933\n", " 318825.960831\n", - " 440318.995534\n", - " 441203.126808\n", - " -884.131274\n", + " 460652.792462\n", + " inf\n", + " -inf\n", " \n", " \n", " 14\n", @@ -1001,14 +886,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 414644.190834\n", + " 255.949977\n", " 392029.707764\n", " 393257.108114\n", " 394526.442838\n", " 394260.244027\n", - " 442379.145149\n", - " 440370.010437\n", - " 2009.134712\n", + " 464478.060160\n", + " inf\n", + " -inf\n", " \n", " \n", " 15\n", @@ -1021,14 +906,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 392121.029719\n", + " 74.104759\n", " 371789.329465\n", " 387244.681484\n", " 386630.546157\n", " 387202.538290\n", - " 438585.581628\n", - " 439538.467226\n", - " -952.885598\n", + " 460399.603672\n", + " inf\n", + " -inf\n", " \n", " \n", " 16\n", @@ -1041,14 +926,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 380754.054252\n", + " -17.668776\n", " 440952.201046\n", " 424662.364695\n", " 425051.043775\n", " 423444.969850\n", - " 439207.738143\n", - " 438708.494203\n", - " 499.243940\n", + " 462078.098890\n", + " inf\n", + " -inf\n", " \n", " \n", " 17\n", @@ -1061,14 +946,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 296596.215293\n", + " -697.133816\n", " 286935.705860\n", " 311049.994112\n", " 312185.510318\n", " 313717.825313\n", - " 436501.827701\n", - " 437880.088405\n", - " -1378.260704\n", + " 458999.883435\n", + " inf\n", + " -inf\n", " \n", " \n", " 18\n", @@ -1081,14 +966,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 423715.504984\n", + " 329.189035\n", " 392470.951022\n", " 356521.858749\n", " 353794.312578\n", " 353491.313705\n", - " 435213.523261\n", - " 437053.246871\n", - " -1839.723610\n", + " 458590.220256\n", + " inf\n", + " -inf\n", " \n", " \n", " 19\n", @@ -1101,14 +986,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 368319.084368\n", + " -118.064977\n", " 394609.621848\n", " 426205.552210\n", " 424729.506080\n", " 424904.453286\n", - " 433980.084304\n", - " 436227.966648\n", - " -2247.882344\n", + " 457829.716881\n", + " inf\n", + " -inf\n", " \n", " \n", " 20\n", @@ -1121,14 +1006,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 418134.051457\n", + " 284.126060\n", " 414178.271428\n", " 393702.776056\n", " 395566.258413\n", " 394030.949034\n", - " 436281.073753\n", - " 435404.244787\n", - " 876.828966\n", + " 461670.160494\n", + " inf\n", + " -inf\n", " \n", " \n", " 21\n", @@ -1141,14 +1026,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 380622.271982\n", + " -18.732747\n", " 385122.990507\n", " 393876.211485\n", " 395324.082930\n", " 396757.245029\n", - " 434232.446019\n", - " 434582.078347\n", - " -349.632328\n", + " 459754.510452\n", + " inf\n", + " -inf\n", " \n", " \n", " 22\n", @@ -1161,14 +1046,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 388922.127329\n", + " 48.277785\n", " 374058.228036\n", " 360407.393814\n", " 361159.265562\n", " 357396.518341\n", - " 431881.487367\n", - " 433761.464389\n", - " -1879.977022\n", + " 457511.882275\n", + " inf\n", + " -inf\n", " \n", " \n", " 23\n", @@ -1181,14 +1066,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 373888.999201\n", + " -73.095163\n", " 367702.143527\n", " 383792.892262\n", " 381569.846621\n", " 384605.158226\n", - " 431705.820487\n", - " 432942.399983\n", - " -1236.579496\n", + " 458112.644483\n", + " inf\n", + " -inf\n", " \n", " \n", " 24\n", @@ -1201,14 +1086,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 403081.277311\n", + " 162.594496\n", " 406359.400288\n", " 413379.564221\n", " 402964.624861\n", " 402279.134778\n", - " 429946.439795\n", - " 432124.882203\n", - " -2178.442408\n", + " 456805.271242\n", + " inf\n", + " -inf\n", " \n", " \n", " 25\n", @@ -1221,14 +1106,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 377526.089751\n", + " -43.730389\n", " 362825.700917\n", " 354087.658823\n", " 342715.089184\n", " 343650.740769\n", - " 430370.073359\n", - " 431308.908127\n", - " -938.834768\n", + " 457958.753892\n", + " inf\n", + " -inf\n", " \n", " \n", " 26\n", @@ -1241,14 +1126,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 312891.203066\n", + " -565.572993\n", " 358797.936758\n", " 363399.872412\n", " 387024.433983\n", " 387553.261741\n", - " 431264.483456\n", - " 430494.474841\n", - " 770.008615\n", + " 459851.993366\n", + " inf\n", + " -inf\n", " \n", " \n", " 27\n", @@ -1261,14 +1146,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 383090.314471\n", + " 1.193485\n", " 375109.947590\n", " 372857.980106\n", " 358164.961912\n", " 357983.056662\n", - " 427120.049100\n", - " 429681.579436\n", - " -2561.530336\n", + " 455471.906375\n", + " inf\n", + " -inf\n", " \n", " \n", " 28\n", @@ -1281,14 +1166,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 370916.909122\n", + " -97.090923\n", " 367650.235635\n", " 359381.996323\n", " 367921.786733\n", " 368369.784160\n", - " 428888.240001\n", - " 428870.219007\n", - " 18.020994\n", + " 458541.506902\n", + " inf\n", + " -inf\n", " \n", " \n", " 29\n", @@ -1301,14 +1186,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 358979.193679\n", + " -193.472441\n", " 363845.441546\n", " 357419.463077\n", " 345612.633741\n", " 345685.373340\n", - " 427162.001628\n", - " 428060.390657\n", - " -898.389029\n", + " 457047.936409\n", + " inf\n", + " -inf\n", " \n", " \n", " 30\n", @@ -1321,14 +1206,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 411059.228901\n", + " 227.006074\n", " 398093.244924\n", " 420338.093431\n", " 427216.475603\n", " 426320.093861\n", - " 424371.134246\n", - " 427252.091491\n", - " -2880.957246\n", + " 454546.519303\n", + " inf\n", + " -inf\n", " \n", " \n", " 31\n", @@ -1341,14 +1226,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 457632.022035\n", + " 603.020776\n", " 460331.584266\n", " 421106.585969\n", " 427549.155747\n", " 427585.588743\n", - " 429015.574874\n", - " 426445.318624\n", - " 2570.256250\n", + " 461538.408159\n", + " inf\n", + " -inf\n", " \n", " \n", " 32\n", @@ -1361,14 +1246,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 366158.628623\n", + " -135.507846\n", " 355110.662118\n", " 385804.286252\n", " 377495.302483\n", " 376728.920725\n", - " 424851.189902\n", - " 425640.069171\n", - " -788.879269\n", + " 456574.397364\n", + " inf\n", + " -inf\n", " \n", " \n", " 33\n", @@ -1381,14 +1266,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 414749.367352\n", + " 256.799140\n", " 404952.222454\n", " 380148.672904\n", " 390887.435379\n", " 392238.633130\n", - " 424630.686008\n", - " 424836.340258\n", - " -205.654250\n", + " 457278.838177\n", + " inf\n", + " -inf\n", " \n", " \n", " 34\n", @@ -1401,14 +1286,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 394182.173776\n", + " 90.745815\n", " 405715.733698\n", " 429608.759456\n", " 429014.390163\n", " 428209.211053\n", - " 421981.174732\n", - " 424034.129012\n", - " -2052.954280\n", + " 454699.104888\n", + " inf\n", + " -inf\n", " \n", " \n", " 35\n", @@ -1421,14 +1306,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 412930.274807\n", + " 242.112335\n", " 409799.355286\n", " 410974.276816\n", " 413298.745816\n", " 414461.110789\n", - " 422383.644429\n", - " 423233.432568\n", - " -849.788140\n", + " 456058.544801\n", + " inf\n", + " -inf\n", " \n", " \n", " 36\n", @@ -1441,14 +1326,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 350708.805302\n", + " -260.245065\n", " 353761.775712\n", " 344252.932147\n", " 343209.200439\n", " 343006.625602\n", - " 421716.445639\n", - " 422434.248066\n", - " -717.802427\n", + " 455642.820816\n", + " inf\n", + " -inf\n", " \n", " \n", " 37\n", @@ -1461,14 +1346,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 293182.399170\n", + " -724.695938\n", " 325069.624722\n", " 344289.047467\n", " 342084.186261\n", " 342232.642746\n", - " 419713.526935\n", - " 421636.572650\n", - " -1923.045715\n", + " 453684.658941\n", + " inf\n", + " -inf\n", " \n", " \n", " 38\n", @@ -1481,14 +1366,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 377478.093086\n", + " -44.117900\n", " 353257.222779\n", " 353764.890202\n", " 357823.798670\n", " 357126.722312\n", - " 419519.270457\n", - " 420840.403471\n", - " -1321.133014\n", + " 454491.481680\n", + " inf\n", + " -inf\n", " \n", " \n", " 39\n", @@ -1501,14 +1386,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 291362.431282\n", + " -739.389811\n", " 302326.827366\n", " 304020.083180\n", " 303828.779931\n", " 303106.289335\n", - " 418301.255283\n", - " 420045.737685\n", - " -1744.482402\n", + " 453393.217586\n", + " inf\n", + " -inf\n", " \n", " \n", " 40\n", @@ -1521,14 +1406,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 368970.926878\n", + " -112.802197\n", " 368964.162462\n", " 357775.533341\n", " 356652.040920\n", " 355879.690701\n", - " 417565.319731\n", - " 419252.572452\n", - " -1687.252721\n", + " 453532.539649\n", + " inf\n", + " -inf\n", " \n", " \n", " 41\n", @@ -1541,14 +1426,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 397265.484764\n", + " 115.639539\n", " 323346.039126\n", " 322784.762289\n", " 316952.269236\n", " 316486.677194\n", - " 418492.789945\n", - " 418460.904941\n", - " 31.885004\n", + " 455525.969985\n", + " inf\n", + " -inf\n", " \n", " \n", " 42\n", @@ -1561,14 +1446,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 327967.298680\n", + " -443.853139\n", " 383625.207672\n", " 394279.969633\n", " 398120.412976\n", " 400442.667319\n", - " 416393.707279\n", - " 417670.732321\n", - " -1277.025042\n", + " 453623.172343\n", + " inf\n", + " -inf\n", " \n", " \n", " 43\n", @@ -1581,14 +1466,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 315778.193228\n", + " -542.264304\n", " 360494.854893\n", " 356119.648704\n", " 357486.445092\n", " 357120.223981\n", - " 417560.781784\n", - " 416882.051771\n", - " 678.730014\n", + " 455839.764978\n", + " inf\n", + " -inf\n", " \n", " \n", " 44\n", @@ -1601,14 +1486,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 342508.889264\n", + " -326.448717\n", " 323961.673652\n", " 331898.505904\n", " 332841.894862\n", " 333370.975675\n", - " 414846.238601\n", - " 416094.860473\n", - " -1248.621872\n", + " 453085.420366\n", + " inf\n", + " -inf\n", " \n", " \n", " 45\n", @@ -1621,32 +1506,32 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 369080.727151\n", + " -111.915703\n", " 347439.884447\n", " 315453.846359\n", " 311453.513947\n", " 310691.844984\n", - " 413085.183289\n", - " 415309.155615\n", - " -2223.972326\n", + " 451557.724220\n", + " inf\n", + " -inf\n", " \n", " \n", "\n", "
" ] }, - "execution_count": 20, + "execution_count": 43, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 20 + "execution_count": 43 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-09T12:05:23.438504Z", - "start_time": "2025-01-09T12:05:23.404339Z" + "end_time": "2025-01-10T12:59:23.840232Z", + "start_time": "2025-01-10T12:59:23.811190Z" } }, "cell_type": "code", @@ -1900,52 +1785,52 @@ "45 GovernmentGovernmentGovernmentGovernmentGovern... \n", "\n", " Facility_Type Precipitation \\\n", - "0 ClinicDistrict HospitalRural/Community Hospita... 377371.401757 \n", - "1 ClinicDistrict HospitalRural/Community Hospita... 424179.161524 \n", - "2 ClinicDistrict HospitalRural/Community Hospita... 416785.291442 \n", - "3 ClinicDistrict HospitalRural/Community Hospita... 431174.255009 \n", - "4 ClinicDistrict HospitalRural/Community Hospita... 405743.410420 \n", - "5 ClinicDistrict HospitalRural/Community Hospita... 410793.849551 \n", - "6 ClinicDistrict HospitalRural/Community Hospita... 430219.873937 \n", - "7 ClinicDistrict HospitalRural/Community Hospita... 332427.056762 \n", - "8 ClinicDistrict HospitalRural/Community Hospita... 392896.036283 \n", - "9 ClinicDistrict HospitalRural/Community Hospita... 409775.392632 \n", - "10 ClinicDistrict HospitalRural/Community Hospita... 410851.208278 \n", - "11 ClinicDistrict HospitalRural/Community Hospita... 456535.963741 \n", - "12 ClinicDistrict HospitalRural/Community Hospita... 452334.398335 \n", - "13 ClinicDistrict HospitalRural/Community Hospita... 329049.810569 \n", - "14 ClinicDistrict HospitalRural/Community Hospita... 414644.190834 \n", - "15 ClinicDistrict HospitalRural/Community Hospita... 392121.029719 \n", - "16 ClinicDistrict HospitalRural/Community Hospita... 380754.054252 \n", - "17 ClinicDistrict HospitalRural/Community Hospita... 296596.215293 \n", - "18 ClinicDistrict HospitalRural/Community Hospita... 423715.504984 \n", - "19 ClinicDistrict HospitalRural/Community Hospita... 368319.084368 \n", - "20 ClinicDistrict HospitalRural/Community Hospita... 418134.051457 \n", - "21 ClinicDistrict HospitalRural/Community Hospita... 380622.271982 \n", - "22 ClinicDistrict HospitalRural/Community Hospita... 388922.127329 \n", - "23 ClinicDistrict HospitalRural/Community Hospita... 373888.999201 \n", - "24 ClinicDistrict HospitalRural/Community Hospita... 403081.277311 \n", - "25 ClinicDistrict HospitalRural/Community Hospita... 377526.089751 \n", - "26 ClinicDistrict HospitalRural/Community Hospita... 312891.203066 \n", - "27 ClinicDistrict HospitalRural/Community Hospita... 383090.314471 \n", - "28 ClinicDistrict HospitalRural/Community Hospita... 370916.909122 \n", - "29 ClinicDistrict HospitalRural/Community Hospita... 358979.193679 \n", - "30 ClinicDistrict HospitalRural/Community Hospita... 411059.228901 \n", - "31 ClinicDistrict HospitalRural/Community Hospita... 457632.022035 \n", - "32 ClinicDistrict HospitalRural/Community Hospita... 366158.628623 \n", - "33 ClinicDistrict HospitalRural/Community Hospita... 414749.367352 \n", - "34 ClinicDistrict HospitalRural/Community Hospita... 394182.173776 \n", - "35 ClinicDistrict HospitalRural/Community Hospita... 412930.274807 \n", - "36 ClinicDistrict HospitalRural/Community Hospita... 350708.805302 \n", - "37 ClinicDistrict HospitalRural/Community Hospita... 293182.399170 \n", - "38 ClinicDistrict HospitalRural/Community Hospita... 377478.093086 \n", - "39 ClinicDistrict HospitalRural/Community Hospita... 291362.431282 \n", - "40 ClinicDistrict HospitalRural/Community Hospita... 368970.926878 \n", - "41 ClinicDistrict HospitalRural/Community Hospita... 397265.484764 \n", - "42 ClinicDistrict HospitalRural/Community Hospita... 327967.298680 \n", - "43 ClinicDistrict HospitalRural/Community Hospita... 315778.193228 \n", - "44 ClinicDistrict HospitalRural/Community Hospita... 342508.889264 \n", - "45 ClinicDistrict HospitalRural/Community Hospita... 369080.727151 \n", + "0 ClinicDistrict HospitalRural/Community Hospita... -44.979294 \n", + "1 ClinicDistrict HospitalRural/Community Hospita... 332.932458 \n", + "2 ClinicDistrict HospitalRural/Community Hospita... 273.236578 \n", + "3 ClinicDistrict HospitalRural/Community Hospita... 389.408735 \n", + "4 ClinicDistrict HospitalRural/Community Hospita... 184.087757 \n", + "5 ClinicDistrict HospitalRural/Community Hospita... 224.863481 \n", + "6 ClinicDistrict HospitalRural/Community Hospita... 381.703350 \n", + "7 ClinicDistrict HospitalRural/Community Hospita... -407.846396 \n", + "8 ClinicDistrict HospitalRural/Community Hospita... 80.361929 \n", + "9 ClinicDistrict HospitalRural/Community Hospita... 216.640767 \n", + "10 ClinicDistrict HospitalRural/Community Hospita... 225.326578 \n", + "11 ClinicDistrict HospitalRural/Community Hospita... 594.171531 \n", + "12 ClinicDistrict HospitalRural/Community Hospita... 560.249358 \n", + "13 ClinicDistrict HospitalRural/Community Hospita... -435.113264 \n", + "14 ClinicDistrict HospitalRural/Community Hospita... 255.949977 \n", + "15 ClinicDistrict HospitalRural/Community Hospita... 74.104759 \n", + "16 ClinicDistrict HospitalRural/Community Hospita... -17.668776 \n", + "17 ClinicDistrict HospitalRural/Community Hospita... -697.133816 \n", + "18 ClinicDistrict HospitalRural/Community Hospita... 329.189035 \n", + "19 ClinicDistrict HospitalRural/Community Hospita... -118.064977 \n", + "20 ClinicDistrict HospitalRural/Community Hospita... 284.126060 \n", + "21 ClinicDistrict HospitalRural/Community Hospita... -18.732747 \n", + "22 ClinicDistrict HospitalRural/Community Hospita... 48.277785 \n", + "23 ClinicDistrict HospitalRural/Community Hospita... -73.095163 \n", + "24 ClinicDistrict HospitalRural/Community Hospita... 162.594496 \n", + "25 ClinicDistrict HospitalRural/Community Hospita... -43.730389 \n", + "26 ClinicDistrict HospitalRural/Community Hospita... -565.572993 \n", + "27 ClinicDistrict HospitalRural/Community Hospita... 1.193485 \n", + "28 ClinicDistrict HospitalRural/Community Hospita... -97.090923 \n", + "29 ClinicDistrict HospitalRural/Community Hospita... -193.472441 \n", + "30 ClinicDistrict HospitalRural/Community Hospita... 227.006074 \n", + "31 ClinicDistrict HospitalRural/Community Hospita... 603.020776 \n", + "32 ClinicDistrict HospitalRural/Community Hospita... -135.507846 \n", + "33 ClinicDistrict HospitalRural/Community Hospita... 256.799140 \n", + "34 ClinicDistrict HospitalRural/Community Hospita... 90.745815 \n", + "35 ClinicDistrict HospitalRural/Community Hospita... 242.112335 \n", + "36 ClinicDistrict HospitalRural/Community Hospita... -260.245065 \n", + "37 ClinicDistrict HospitalRural/Community Hospita... -724.695938 \n", + "38 ClinicDistrict HospitalRural/Community Hospita... -44.117900 \n", + "39 ClinicDistrict HospitalRural/Community Hospita... -739.389811 \n", + "40 ClinicDistrict HospitalRural/Community Hospita... -112.802197 \n", + "41 ClinicDistrict HospitalRural/Community Hospita... 115.639539 \n", + "42 ClinicDistrict HospitalRural/Community Hospita... -443.853139 \n", + "43 ClinicDistrict HospitalRural/Community Hospita... -542.264304 \n", + "44 ClinicDistrict HospitalRural/Community Hospita... -326.448717 \n", + "45 ClinicDistrict HospitalRural/Community Hospita... -111.915703 \n", "\n", " Lag_1_Precipitation Lag_2_Precipitation Lag_3_Precipitation \\\n", "0 398942.636170 404727.057797 405704.571665 \n", @@ -1996,100 +1881,100 @@ "45 347439.884447 315453.846359 311453.513947 \n", "\n", " Lag_4_Precipitation Predicted_Weather_Model Predicted_No_Weather_Model \\\n", - "0 404895.268433 450413.811572 452178.159027 \n", - "1 386621.761142 449805.162811 451324.318689 \n", - "2 421535.968891 448780.570788 450472.090644 \n", - "3 400973.159779 446657.461648 449621.471846 \n", - "4 419592.912552 447811.134508 448772.459257 \n", - "5 391638.197677 447111.614783 447925.049844 \n", - "6 456824.623648 448389.823951 447079.240580 \n", - "7 357753.146752 443503.204711 446235.028444 \n", - "8 388673.117569 445468.831800 445392.410418 \n", - "9 373019.671935 441550.545941 444551.383494 \n", - "10 406919.996712 442181.994730 443711.944667 \n", - "11 432861.285260 439591.654817 442874.090938 \n", - "12 527784.234663 437890.108389 442037.819314 \n", - "13 318825.960831 440318.995534 441203.126808 \n", - "14 394260.244027 442379.145149 440370.010437 \n", - "15 387202.538290 438585.581628 439538.467226 \n", - "16 423444.969850 439207.738143 438708.494203 \n", - "17 313717.825313 436501.827701 437880.088405 \n", - "18 353491.313705 435213.523261 437053.246871 \n", - "19 424904.453286 433980.084304 436227.966648 \n", - "20 394030.949034 436281.073753 435404.244787 \n", - "21 396757.245029 434232.446019 434582.078347 \n", - "22 357396.518341 431881.487367 433761.464389 \n", - "23 384605.158226 431705.820487 432942.399983 \n", - "24 402279.134778 429946.439795 432124.882203 \n", - "25 343650.740769 430370.073359 431308.908127 \n", - "26 387553.261741 431264.483456 430494.474841 \n", - "27 357983.056662 427120.049100 429681.579436 \n", - "28 368369.784160 428888.240001 428870.219007 \n", - "29 345685.373340 427162.001628 428060.390657 \n", - "30 426320.093861 424371.134246 427252.091491 \n", - "31 427585.588743 429015.574874 426445.318624 \n", - "32 376728.920725 424851.189902 425640.069171 \n", - "33 392238.633130 424630.686008 424836.340258 \n", - "34 428209.211053 421981.174732 424034.129012 \n", - "35 414461.110789 422383.644429 423233.432568 \n", - "36 343006.625602 421716.445639 422434.248066 \n", - "37 342232.642746 419713.526935 421636.572650 \n", - "38 357126.722312 419519.270457 420840.403471 \n", - "39 303106.289335 418301.255283 420045.737685 \n", - "40 355879.690701 417565.319731 419252.572452 \n", - "41 316486.677194 418492.789945 418460.904941 \n", - "42 400442.667319 416393.707279 417670.732321 \n", - "43 357120.223981 417560.781784 416882.051771 \n", - "44 333370.975675 414846.238601 416094.860473 \n", - "45 310691.844984 413085.183289 415309.155615 \n", + "0 404895.268433 462904.609783 inf \n", + "1 386621.761142 463055.752459 inf \n", + "2 421535.968891 462644.111845 inf \n", + "3 400973.159779 460807.846722 inf \n", + "4 419592.912552 463079.419720 inf \n", + "5 391638.197677 462967.863359 inf \n", + "6 456824.623648 465600.988271 inf \n", + "7 357753.146752 459795.744898 inf \n", + "8 388673.117569 463363.585021 inf \n", + "9 373019.671935 459224.382654 inf \n", + "10 406919.996712 460943.631939 inf \n", + "11 432861.285260 458660.558966 inf \n", + "12 527784.234663 457513.243165 inf \n", + "13 318825.960831 460652.792462 inf \n", + "14 394260.244027 464478.060160 inf \n", + "15 387202.538290 460399.603672 inf \n", + "16 423444.969850 462078.098890 inf \n", + "17 313717.825313 458999.883435 inf \n", + "18 353491.313705 458590.220256 inf \n", + "19 424904.453286 457829.716881 inf \n", + "20 394030.949034 461670.160494 inf \n", + "21 396757.245029 459754.510452 inf \n", + "22 357396.518341 457511.882275 inf \n", + "23 384605.158226 458112.644483 inf \n", + "24 402279.134778 456805.271242 inf \n", + "25 343650.740769 457958.753892 inf \n", + "26 387553.261741 459851.993366 inf \n", + "27 357983.056662 455471.906375 inf \n", + "28 368369.784160 458541.506902 inf \n", + "29 345685.373340 457047.936409 inf \n", + "30 426320.093861 454546.519303 inf \n", + "31 427585.588743 461538.408159 inf \n", + "32 376728.920725 456574.397364 inf \n", + "33 392238.633130 457278.838177 inf \n", + "34 428209.211053 454699.104888 inf \n", + "35 414461.110789 456058.544801 inf \n", + "36 343006.625602 455642.820816 inf \n", + "37 342232.642746 453684.658941 inf \n", + "38 357126.722312 454491.481680 inf \n", + "39 303106.289335 453393.217586 inf \n", + "40 355879.690701 453532.539649 inf \n", + "41 316486.677194 455525.969985 inf \n", + "42 400442.667319 453623.172343 inf \n", + "43 357120.223981 455839.764978 inf \n", + "44 333370.975675 453085.420366 inf \n", + "45 310691.844984 451557.724220 inf \n", "\n", " Difference_in_Expectation Percentage_Difference \n", - "0 -1764.347455 -0.003902 \n", - "1 -1519.155878 -0.003366 \n", - "2 -1691.519856 -0.003755 \n", - "3 -2964.010197 -0.006592 \n", - "4 -961.324749 -0.002142 \n", - "5 -813.435061 -0.001816 \n", - "6 1310.583371 0.002931 \n", - "7 -2731.823733 -0.006122 \n", - "8 76.421382 0.000172 \n", - "9 -3000.837553 -0.006750 \n", - "10 -1529.949937 -0.003448 \n", - "11 -3282.436122 -0.007412 \n", - "12 -4147.710925 -0.009383 \n", - "13 -884.131274 -0.002004 \n", - "14 2009.134712 0.004562 \n", - "15 -952.885598 -0.002168 \n", - "16 499.243940 0.001138 \n", - "17 -1378.260704 -0.003148 \n", - "18 -1839.723610 -0.004209 \n", - "19 -2247.882344 -0.005153 \n", - "20 876.828966 0.002014 \n", - "21 -349.632328 -0.000805 \n", - "22 -1879.977022 -0.004334 \n", - "23 -1236.579496 -0.002856 \n", - "24 -2178.442408 -0.005041 \n", - "25 -938.834768 -0.002177 \n", - "26 770.008615 0.001789 \n", - "27 -2561.530336 -0.005961 \n", - "28 18.020994 0.000042 \n", - "29 -898.389029 -0.002099 \n", - "30 -2880.957246 -0.006743 \n", - "31 2570.256250 0.006027 \n", - "32 -788.879269 -0.001853 \n", - "33 -205.654250 -0.000484 \n", - "34 -2052.954280 -0.004841 \n", - "35 -849.788140 -0.002008 \n", - "36 -717.802427 -0.001699 \n", - "37 -1923.045715 -0.004561 \n", - "38 -1321.133014 -0.003139 \n", - "39 -1744.482402 -0.004153 \n", - "40 -1687.252721 -0.004024 \n", - "41 31.885004 0.000076 \n", - "42 -1277.025042 -0.003057 \n", - "43 678.730014 0.001628 \n", - "44 -1248.621872 -0.003001 \n", - "45 -2223.972326 -0.005355 " + "0 -inf NaN \n", + "1 -inf NaN \n", + "2 -inf NaN \n", + "3 -inf NaN \n", + "4 -inf NaN \n", + "5 -inf NaN \n", + "6 -inf NaN \n", + "7 -inf NaN \n", + "8 -inf NaN \n", + "9 -inf NaN \n", + "10 -inf NaN \n", + "11 -inf NaN \n", + "12 -inf NaN \n", + "13 -inf NaN \n", + "14 -inf NaN \n", + "15 -inf NaN \n", + "16 -inf NaN \n", + "17 -inf NaN \n", + "18 -inf NaN \n", + "19 -inf NaN \n", + "20 -inf NaN \n", + "21 -inf NaN \n", + "22 -inf NaN \n", + "23 -inf NaN \n", + "24 -inf NaN \n", + "25 -inf NaN \n", + "26 -inf NaN \n", + "27 -inf NaN \n", + "28 -inf NaN \n", + "29 -inf NaN \n", + "30 -inf NaN \n", + "31 -inf NaN \n", + "32 -inf NaN \n", + "33 -inf NaN \n", + "34 -inf NaN \n", + "35 -inf NaN \n", + "36 -inf NaN \n", + "37 -inf NaN \n", + "38 -inf NaN \n", + "39 -inf NaN \n", + "40 -inf NaN \n", + "41 -inf NaN \n", + "42 -inf NaN \n", + "43 -inf NaN \n", + "44 -inf NaN \n", + "45 -inf NaN " ], "text/html": [ "
\n", @@ -2142,15 +2027,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 377371.401757\n", + " -44.979294\n", " 398942.636170\n", " 404727.057797\n", " 405704.571665\n", " 404895.268433\n", - " 450413.811572\n", - " 452178.159027\n", - " -1764.347455\n", - " -0.003902\n", + " 462904.609783\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 1\n", @@ -2163,15 +2048,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 424179.161524\n", + " 332.932458\n", " 413397.817913\n", " 388309.667883\n", " 385397.116828\n", " 386621.761142\n", - " 449805.162811\n", - " 451324.318689\n", - " -1519.155878\n", - " -0.003366\n", + " 463055.752459\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 2\n", @@ -2184,15 +2069,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 416785.291442\n", + " 273.236578\n", " 407187.589904\n", " 420216.307417\n", " 421615.911783\n", " 421535.968891\n", - " 448780.570788\n", - " 450472.090644\n", - " -1691.519856\n", - " -0.003755\n", + " 462644.111845\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 3\n", @@ -2205,15 +2090,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 431174.255009\n", + " 389.408735\n", " 406189.704606\n", " 403165.981005\n", " 401105.177547\n", " 400973.159779\n", - " 446657.461648\n", - " 449621.471846\n", - " -2964.010197\n", - " -0.006592\n", + " 460807.846722\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 4\n", @@ -2226,15 +2111,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 405743.410420\n", + " 184.087757\n", " 420471.214026\n", " 421450.033447\n", " 424520.950185\n", " 419592.912552\n", - " 447811.134508\n", - " 448772.459257\n", - " -961.324749\n", - " -0.002142\n", + " 463079.419720\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 5\n", @@ -2247,15 +2132,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 410793.849551\n", + " 224.863481\n", " 410824.557725\n", " 391493.761671\n", " 388196.210212\n", " 391638.197677\n", - " 447111.614783\n", - " 447925.049844\n", - " -813.435061\n", - " -0.001816\n", + " 462967.863359\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 6\n", @@ -2268,15 +2153,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 430219.873937\n", + " 381.703350\n", " 432044.900550\n", " 456751.262273\n", " 456752.721138\n", " 456824.623648\n", - " 448389.823951\n", - " 447079.240580\n", - " 1310.583371\n", - " 0.002931\n", + " 465600.988271\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 7\n", @@ -2289,15 +2174,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 332427.056762\n", + " -407.846396\n", " 348112.188236\n", " 353270.524412\n", " 357410.845800\n", " 357753.146752\n", - " 443503.204711\n", - " 446235.028444\n", - " -2731.823733\n", - " -0.006122\n", + " 459795.744898\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 8\n", @@ -2310,15 +2195,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 392896.036283\n", + " 80.361929\n", " 405019.687496\n", " 388565.288508\n", " 388245.552346\n", " 388673.117569\n", - " 445468.831800\n", - " 445392.410418\n", - " 76.421382\n", - " 0.000172\n", + " 463363.585021\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 9\n", @@ -2331,15 +2216,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 409775.392632\n", + " 216.640767\n", " 372460.875926\n", " 375124.877747\n", " 371846.112765\n", " 373019.671935\n", - " 441550.545941\n", - " 444551.383494\n", - " -3000.837553\n", - " -0.006750\n", + " 459224.382654\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 10\n", @@ -2352,15 +2237,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 410851.208278\n", + " 225.326578\n", " 408169.132145\n", " 406485.011941\n", " 407092.899084\n", " 406919.996712\n", - " 442181.994730\n", - " 443711.944667\n", - " -1529.949937\n", - " -0.003448\n", + " 460943.631939\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 11\n", @@ -2373,15 +2258,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 456535.963741\n", + " 594.171531\n", " 451325.020396\n", " 433158.134992\n", " 433133.983599\n", " 432861.285260\n", - " 439591.654817\n", - " 442874.090938\n", - " -3282.436122\n", - " -0.007412\n", + " 458660.558966\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 12\n", @@ -2394,15 +2279,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 452334.398335\n", + " 560.249358\n", " 481501.033891\n", " 524791.840222\n", " 527391.207421\n", " 527784.234663\n", - " 437890.108389\n", - " 442037.819314\n", - " -4147.710925\n", - " -0.009383\n", + " 457513.243165\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 13\n", @@ -2415,15 +2300,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 329049.810569\n", + " -435.113264\n", " 339513.871817\n", " 320576.954584\n", " 319333.523933\n", " 318825.960831\n", - " 440318.995534\n", - " 441203.126808\n", - " -884.131274\n", - " -0.002004\n", + " 460652.792462\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 14\n", @@ -2436,15 +2321,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 414644.190834\n", + " 255.949977\n", " 392029.707764\n", " 393257.108114\n", " 394526.442838\n", " 394260.244027\n", - " 442379.145149\n", - " 440370.010437\n", - " 2009.134712\n", - " 0.004562\n", + " 464478.060160\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 15\n", @@ -2457,15 +2342,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 392121.029719\n", + " 74.104759\n", " 371789.329465\n", " 387244.681484\n", " 386630.546157\n", " 387202.538290\n", - " 438585.581628\n", - " 439538.467226\n", - " -952.885598\n", - " -0.002168\n", + " 460399.603672\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 16\n", @@ -2478,15 +2363,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 380754.054252\n", + " -17.668776\n", " 440952.201046\n", " 424662.364695\n", " 425051.043775\n", " 423444.969850\n", - " 439207.738143\n", - " 438708.494203\n", - " 499.243940\n", - " 0.001138\n", + " 462078.098890\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 17\n", @@ -2499,15 +2384,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 296596.215293\n", + " -697.133816\n", " 286935.705860\n", " 311049.994112\n", " 312185.510318\n", " 313717.825313\n", - " 436501.827701\n", - " 437880.088405\n", - " -1378.260704\n", - " -0.003148\n", + " 458999.883435\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 18\n", @@ -2520,15 +2405,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 423715.504984\n", + " 329.189035\n", " 392470.951022\n", " 356521.858749\n", " 353794.312578\n", " 353491.313705\n", - " 435213.523261\n", - " 437053.246871\n", - " -1839.723610\n", - " -0.004209\n", + " 458590.220256\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 19\n", @@ -2541,15 +2426,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 368319.084368\n", + " -118.064977\n", " 394609.621848\n", " 426205.552210\n", " 424729.506080\n", " 424904.453286\n", - " 433980.084304\n", - " 436227.966648\n", - " -2247.882344\n", - " -0.005153\n", + " 457829.716881\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 20\n", @@ -2562,15 +2447,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 418134.051457\n", + " 284.126060\n", " 414178.271428\n", " 393702.776056\n", " 395566.258413\n", " 394030.949034\n", - " 436281.073753\n", - " 435404.244787\n", - " 876.828966\n", - " 0.002014\n", + " 461670.160494\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 21\n", @@ -2583,15 +2468,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 380622.271982\n", + " -18.732747\n", " 385122.990507\n", " 393876.211485\n", " 395324.082930\n", " 396757.245029\n", - " 434232.446019\n", - " 434582.078347\n", - " -349.632328\n", - " -0.000805\n", + " 459754.510452\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 22\n", @@ -2604,15 +2489,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 388922.127329\n", + " 48.277785\n", " 374058.228036\n", " 360407.393814\n", " 361159.265562\n", " 357396.518341\n", - " 431881.487367\n", - " 433761.464389\n", - " -1879.977022\n", - " -0.004334\n", + " 457511.882275\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 23\n", @@ -2625,15 +2510,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 373888.999201\n", + " -73.095163\n", " 367702.143527\n", " 383792.892262\n", " 381569.846621\n", " 384605.158226\n", - " 431705.820487\n", - " 432942.399983\n", - " -1236.579496\n", - " -0.002856\n", + " 458112.644483\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 24\n", @@ -2646,15 +2531,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 403081.277311\n", + " 162.594496\n", " 406359.400288\n", " 413379.564221\n", " 402964.624861\n", " 402279.134778\n", - " 429946.439795\n", - " 432124.882203\n", - " -2178.442408\n", - " -0.005041\n", + " 456805.271242\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 25\n", @@ -2667,15 +2552,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 377526.089751\n", + " -43.730389\n", " 362825.700917\n", " 354087.658823\n", " 342715.089184\n", " 343650.740769\n", - " 430370.073359\n", - " 431308.908127\n", - " -938.834768\n", - " -0.002177\n", + " 457958.753892\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 26\n", @@ -2688,15 +2573,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 312891.203066\n", + " -565.572993\n", " 358797.936758\n", " 363399.872412\n", " 387024.433983\n", " 387553.261741\n", - " 431264.483456\n", - " 430494.474841\n", - " 770.008615\n", - " 0.001789\n", + " 459851.993366\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 27\n", @@ -2709,15 +2594,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 383090.314471\n", + " 1.193485\n", " 375109.947590\n", " 372857.980106\n", " 358164.961912\n", " 357983.056662\n", - " 427120.049100\n", - " 429681.579436\n", - " -2561.530336\n", - " -0.005961\n", + " 455471.906375\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 28\n", @@ -2730,15 +2615,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 370916.909122\n", + " -97.090923\n", " 367650.235635\n", " 359381.996323\n", " 367921.786733\n", " 368369.784160\n", - " 428888.240001\n", - " 428870.219007\n", - " 18.020994\n", - " 0.000042\n", + " 458541.506902\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 29\n", @@ -2751,15 +2636,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 358979.193679\n", + " -193.472441\n", " 363845.441546\n", " 357419.463077\n", " 345612.633741\n", " 345685.373340\n", - " 427162.001628\n", - " 428060.390657\n", - " -898.389029\n", - " -0.002099\n", + " 457047.936409\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 30\n", @@ -2772,15 +2657,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 411059.228901\n", + " 227.006074\n", " 398093.244924\n", " 420338.093431\n", " 427216.475603\n", " 426320.093861\n", - " 424371.134246\n", - " 427252.091491\n", - " -2880.957246\n", - " -0.006743\n", + " 454546.519303\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 31\n", @@ -2793,15 +2678,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 457632.022035\n", + " 603.020776\n", " 460331.584266\n", " 421106.585969\n", " 427549.155747\n", " 427585.588743\n", - " 429015.574874\n", - " 426445.318624\n", - " 2570.256250\n", - " 0.006027\n", + " 461538.408159\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 32\n", @@ -2814,15 +2699,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 366158.628623\n", + " -135.507846\n", " 355110.662118\n", " 385804.286252\n", " 377495.302483\n", " 376728.920725\n", - " 424851.189902\n", - " 425640.069171\n", - " -788.879269\n", - " -0.001853\n", + " 456574.397364\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 33\n", @@ -2835,15 +2720,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 414749.367352\n", + " 256.799140\n", " 404952.222454\n", " 380148.672904\n", " 390887.435379\n", " 392238.633130\n", - " 424630.686008\n", - " 424836.340258\n", - " -205.654250\n", - " -0.000484\n", + " 457278.838177\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 34\n", @@ -2856,15 +2741,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 394182.173776\n", + " 90.745815\n", " 405715.733698\n", " 429608.759456\n", " 429014.390163\n", " 428209.211053\n", - " 421981.174732\n", - " 424034.129012\n", - " -2052.954280\n", - " -0.004841\n", + " 454699.104888\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 35\n", @@ -2877,15 +2762,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 412930.274807\n", + " 242.112335\n", " 409799.355286\n", " 410974.276816\n", " 413298.745816\n", " 414461.110789\n", - " 422383.644429\n", - " 423233.432568\n", - " -849.788140\n", - " -0.002008\n", + " 456058.544801\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 36\n", @@ -2898,15 +2783,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 350708.805302\n", + " -260.245065\n", " 353761.775712\n", " 344252.932147\n", " 343209.200439\n", " 343006.625602\n", - " 421716.445639\n", - " 422434.248066\n", - " -717.802427\n", - " -0.001699\n", + " 455642.820816\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 37\n", @@ -2919,15 +2804,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 293182.399170\n", + " -724.695938\n", " 325069.624722\n", " 344289.047467\n", " 342084.186261\n", " 342232.642746\n", - " 419713.526935\n", - " 421636.572650\n", - " -1923.045715\n", - " -0.004561\n", + " 453684.658941\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 38\n", @@ -2940,15 +2825,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 377478.093086\n", + " -44.117900\n", " 353257.222779\n", " 353764.890202\n", " 357823.798670\n", " 357126.722312\n", - " 419519.270457\n", - " 420840.403471\n", - " -1321.133014\n", - " -0.003139\n", + " 454491.481680\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 39\n", @@ -2961,15 +2846,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 291362.431282\n", + " -739.389811\n", " 302326.827366\n", " 304020.083180\n", " 303828.779931\n", " 303106.289335\n", - " 418301.255283\n", - " 420045.737685\n", - " -1744.482402\n", - " -0.004153\n", + " 453393.217586\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 40\n", @@ -2982,15 +2867,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 368970.926878\n", + " -112.802197\n", " 368964.162462\n", " 357775.533341\n", " 356652.040920\n", " 355879.690701\n", - " 417565.319731\n", - " 419252.572452\n", - " -1687.252721\n", - " -0.004024\n", + " 453532.539649\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 41\n", @@ -3003,15 +2888,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 397265.484764\n", + " 115.639539\n", " 323346.039126\n", " 322784.762289\n", " 316952.269236\n", " 316486.677194\n", - " 418492.789945\n", - " 418460.904941\n", - " 31.885004\n", - " 0.000076\n", + " 455525.969985\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 42\n", @@ -3024,15 +2909,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 327967.298680\n", + " -443.853139\n", " 383625.207672\n", " 394279.969633\n", " 398120.412976\n", " 400442.667319\n", - " 416393.707279\n", - " 417670.732321\n", - " -1277.025042\n", - " -0.003057\n", + " 453623.172343\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 43\n", @@ -3045,15 +2930,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 315778.193228\n", + " -542.264304\n", " 360494.854893\n", " 356119.648704\n", " 357486.445092\n", " 357120.223981\n", - " 417560.781784\n", - " 416882.051771\n", - " 678.730014\n", - " 0.001628\n", + " 455839.764978\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 44\n", @@ -3066,15 +2951,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 342508.889264\n", + " -326.448717\n", " 323961.673652\n", " 331898.505904\n", " 332841.894862\n", " 333370.975675\n", - " 414846.238601\n", - " 416094.860473\n", - " -1248.621872\n", - " -0.003001\n", + " 453085.420366\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", " 45\n", @@ -3087,46 +2972,421 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 369080.727151\n", + " -111.915703\n", " 347439.884447\n", " 315453.846359\n", " 311453.513947\n", " 310691.844984\n", - " 413085.183289\n", - " 415309.155615\n", - " -2223.972326\n", - " -0.005355\n", + " 451557.724220\n", + " inf\n", + " -inf\n", + " NaN\n", " \n", " \n", "\n", "
" ] }, - "execution_count": 21, + "execution_count": 44, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 21 + "execution_count": 44 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-09T12:05:27.013287Z", - "start_time": "2025-01-09T12:05:24.490284Z" + "end_time": "2025-01-10T12:59:26.743239Z", + "start_time": "2025-01-10T12:59:24.265945Z" } }, "cell_type": "code", "source": "X_Data = pd.read_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/X_basis_weather_filtered_predictions_{scenario}_{model_type}.csv')\n", "id": "23e931c4a52c75e0", "outputs": [], - "execution_count": 22 + "execution_count": 45 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-10T12:59:44.804923Z", + "start_time": "2025-01-10T12:59:44.791156Z" + } + }, + "cell_type": "code", + "source": "X_Data", + "id": "822d8ced153a3212", + "outputs": [ + { + "data": { + "text/plain": [ + " 0 1 2 3 4 5 6 \\\n", + "0 1.048343 0.810635 -1.694798 -1.593255 0.865784 -0.556619 -0.692498 \n", + "1 1.774797 1.999924 -1.694798 -1.303572 1.367884 -0.393471 -0.694058 \n", + "2 1.370042 1.374079 -1.694798 -1.013890 0.899921 0.022860 -0.730727 \n", + "3 2.193023 2.566294 -1.694798 -0.724207 1.848773 -0.140611 -0.468354 \n", + "4 1.750054 0.914118 -1.694798 -0.434524 1.545592 -0.292019 -0.624782 \n", + "... ... ... ... ... ... ... ... \n", + "181051 2.124416 1.864759 1.694798 0.434524 1.083275 -0.534858 -0.713874 \n", + "181052 0.616089 0.497958 1.694798 0.724207 0.038357 -0.580187 -0.773157 \n", + "181053 0.616089 0.497958 1.694798 1.013890 0.038357 -0.580187 -0.773157 \n", + "181054 1.677813 1.075421 1.694798 1.303572 0.519968 -0.603433 -0.700931 \n", + "181055 0.490431 0.121353 1.694798 1.593255 0.039985 -0.699167 -0.784913 \n", + "\n", + " 7 8 9 ... 371 372 373 374 375 376 377 \\\n", + "0 -0.784889 0.216669 -0.375922 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", + "1 -0.773609 0.680066 -0.192419 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", + "2 -0.754700 0.439918 0.251719 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", + "3 -0.736643 1.007995 0.270999 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", + "4 -0.758322 1.243891 -0.091395 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", + "... ... ... ... ... ... ... ... ... ... ... ... \n", + "181051 -0.555571 1.947227 -0.539065 ... 0.0 0.0 0.0 0.0 0.0 1.0 0.0 \n", + "181052 -0.761919 -0.221811 -0.538509 ... 0.0 0.0 0.0 0.0 0.0 0.0 1.0 \n", + "181053 -0.761919 -0.221811 -0.538509 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", + "181054 -0.685821 0.667956 -0.652100 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", + "181055 -0.784889 0.669824 -0.737891 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", + "\n", + " 378 379 380 \n", + "0 0.0 0.0 0.0 \n", + "1 0.0 0.0 0.0 \n", + "2 0.0 0.0 0.0 \n", + "3 0.0 0.0 0.0 \n", + "4 0.0 0.0 0.0 \n", + "... ... ... ... \n", + "181051 0.0 0.0 0.0 \n", + "181052 0.0 0.0 0.0 \n", + "181053 1.0 0.0 0.0 \n", + "181054 0.0 1.0 0.0 \n", + "181055 0.0 0.0 1.0 \n", + "\n", + "[181056 rows x 381 columns]" + ], + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
0123456789...371372373374375376377378379380
01.0483430.810635-1.694798-1.5932550.865784-0.556619-0.692498-0.7848890.216669-0.375922...0.00.00.00.00.00.00.00.00.00.0
11.7747971.999924-1.694798-1.3035721.367884-0.393471-0.694058-0.7736090.680066-0.192419...0.00.00.00.00.00.00.00.00.00.0
21.3700421.374079-1.694798-1.0138900.8999210.022860-0.730727-0.7547000.4399180.251719...0.00.00.00.00.00.00.00.00.00.0
32.1930232.566294-1.694798-0.7242071.848773-0.140611-0.468354-0.7366431.0079950.270999...0.00.00.00.00.00.00.00.00.00.0
41.7500540.914118-1.694798-0.4345241.545592-0.292019-0.624782-0.7583221.243891-0.091395...0.00.00.00.00.00.00.00.00.00.0
..................................................................
1810512.1244161.8647591.6947980.4345241.083275-0.534858-0.713874-0.5555711.947227-0.539065...0.00.00.00.00.01.00.00.00.00.0
1810520.6160890.4979581.6947980.7242070.038357-0.580187-0.773157-0.761919-0.221811-0.538509...0.00.00.00.00.00.01.00.00.00.0
1810530.6160890.4979581.6947981.0138900.038357-0.580187-0.773157-0.761919-0.221811-0.538509...0.00.00.00.00.00.00.01.00.00.0
1810541.6778131.0754211.6947981.3035720.519968-0.603433-0.700931-0.6858210.667956-0.652100...0.00.00.00.00.00.00.00.01.00.0
1810550.4904310.1213531.6947981.5932550.039985-0.699167-0.784913-0.7848890.669824-0.737891...0.00.00.00.00.00.00.00.00.01.0
\n", + "

181056 rows × 381 columns

\n", + "
" + ] + }, + "execution_count": 51, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 51 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-09T12:05:27.018619Z", - "start_time": "2025-01-09T12:05:27.014718Z" + "end_time": "2025-01-10T12:59:26.748910Z", + "start_time": "2025-01-10T12:59:26.745170Z" } }, "cell_type": "code", @@ -3141,13 +3401,13 @@ ], "id": "fd6b107fed0933cb", "outputs": [], - "execution_count": 23 + "execution_count": 46 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-09T12:05:29.112472Z", - "start_time": "2025-01-09T12:05:29.017124Z" + "end_time": "2025-01-10T12:59:26.836837Z", + "start_time": "2025-01-10T12:59:26.749976Z" } }, "cell_type": "code", @@ -3163,10 +3423,10 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 24, + "execution_count": 47, "metadata": {}, "output_type": "execute_result" }, @@ -3175,19 +3435,19 @@ "text/plain": [ "
" ], - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 24 + "execution_count": 47 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-09T12:05:30.143163Z", - "start_time": "2025-01-09T12:05:30.041274Z" + "end_time": "2025-01-10T12:59:26.915207Z", + "start_time": "2025-01-10T12:59:26.839621Z" } }, "cell_type": "code", @@ -3201,10 +3461,10 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 25, + "execution_count": 48, "metadata": {}, "output_type": "execute_result" }, @@ -3213,13 +3473,13 @@ "text/plain": [ "
" ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi8AAAGwCAYAAABhDIVPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/OQEPoAAAACXBIWXMAAA9hAAAPYQGoP6dpAACdbUlEQVR4nO2deZxT5fX/Pzd7ZsnsKwwM+wwioCAILuCXUZTWra11wYrWolVxKViV1orVKq3aqrVa1KqoP6m27rUWiwguSAFREGQYdhiW2fct6/P7I3meJDNJJsu9Wc/79ZqXkjzJ3Ny5ufdzz/mccyTGGANBEARBEESCoIr1BhAEQRAEQYQCiReCIAiCIBIKEi8EQRAEQSQUJF4IgiAIgkgoSLwQBEEQBJFQkHghCIIgCCKhIPFCEARBEERCoYn1BsiNw+HA8ePHkZmZCUmSYr05BEEQBEEEAWMMnZ2dKC0thUoVOLaSdOLl+PHjKCsri/VmEARBEAQRBrW1tRg6dGjANUknXjIzMwE4P7zJZIrx1hAEQRAEEQwdHR0oKysT1/FAJJ144akik8lE4oUgCIIgEoxgLB9k2CUIgiAIIqEg8UIQBEEQREJB4oUgCIIgiISCxAtBEARBEAkFiReCIAiCIBIKEi8EQRAEQSQUJF4IgiAIgkgoSLwQBEEQBJFQkHghCIIgCCKhIPFCEARBEERCQeKFIAiCIIiEIiri5emnn0Z5eTkMBgOmT5+OzZs3B1zf1taGW265BSUlJdDr9Rg7diw+/PDDaGwqQRAEQRBxjuKDGd944w0sXrwYK1aswPTp0/HEE09g7ty5qKmpQWFh4YD1FosF5557LgoLC/Hmm29iyJAhOHz4MLKzs5XeVIIgCIKQHcYY+qwOGHXqWG9K0iAxxpiSv2D69Ok47bTT8Je//AUA4HA4UFZWhltvvRX33HPPgPUrVqzAo48+it27d0Or1Yb8+zo6OpCVlYX29naaKk0QBEHEnPvf/w5/33wE/7n9LIwsyIj15sQtoVy/FU0bWSwWbN26FVVVVe5fqFKhqqoKGzdu9Pma999/HzNmzMAtt9yCoqIiTJgwAQ8//DDsdrvP9WazGR0dHV4/BEEQBBEvfHW4BWabA98ebY/1piQNioqXpqYm2O12FBUVeT1eVFSEuro6n685cOAA3nzzTdjtdnz44Yf4zW9+gz/+8Y/43e9+53P98uXLkZWVJX7Kyspk/xwEQRAEES49ZufNd0u3JcZbkjzEXbWRw+FAYWEhnnvuOUyZMgWXX345fv3rX2PFihU+1y9duhTt7e3ip7a2NspbTBAEQRD+6bbYAABtPSRe5EJRw25+fj7UajXq6+u9Hq+vr0dxcbHP15SUlECr1UKtdhubKisrUVdXB4vFAp1O57Ver9dDr9fLv/EEQRAEIQM88tLaY43xliQPikZedDodpkyZgrVr14rHHA4H1q5dixkzZvh8zRlnnIF9+/bB4XCIx/bs2YOSkpIBwoUgCIIg4hnGGHqsXLxQ5EUuFE8bLV68GM8//zxefvllVFdX46abbkJ3dzeuu+46AMA111yDpUuXivU33XQTWlpacPvtt2PPnj3497//jYcffhi33HKL0ptKEARBELJitjlgdziLetso8iIbivd5ufzyy9HY2Ij77rsPdXV1mDx5MlavXi1MvEeOHIFK5dZQZWVl+Oijj/CLX/wCEydOxJAhQ3D77bfj7rvvVnpTCYIgCEJWeizuSlky7MqH4n1eog31eSEIgiDihdqWHpz1yDoAQGmWAV8unRPjLYpf4qbPC0EQBEGkMp6RFzLsygeJF4IgCIJQCF4mDQC9Vjv6rL4brhKhQeKFIAiCIBSi1+ItVsi0Kw8kXgiCIAhCIbrNNq9/k2lXHki8EARBEIRC9AyIvJB4kQMSLwRBEAShEJ6eF4BMu3JB4oUgCIIgFIKPBuBQl115IPFCEARBEArRP/JCaSN5IPFCEARBEArR3/PS0k1pIzkg8UIQBEEQCtHjirwYtWoAFHmRCxIvBEEQBKEQ3PMyJMcIgDwvckHihSAIgiAUgntehmRz8UJpIzkg8UIQBEEQCsE9LzzyQmkjeSDxQhAEQRAKwTvs8sgLddiVBxIvBEEQBKEQPPIy1BV56eizwWZ3xHKTkgISLwRBEAShEFy8lLoiLwDQ3ku+l0gh8UIQBEEQCsFLpU0GLTINGgBk2pUDEi8EQRAEoRDdrlLpNJ0auek6AGTalQMSLwRBEAShAHYHQ6/VLV6y05zihUy7kUPihSAIgiAUgAsXAEjXa5CTpgUAtFHaKGJIvBAEQRCEAvS4yqRVEqDXqJDjirxQl93IIfFCEARBEArQ7ao0StdpIEkSsl2RFzLsRg6JF4JIUewORrl3glAQXmmUpncOZcxNI8OuXJB4IYgU5Zf/3I7THvoY+xo6Y70pBJGU9HhEXgAgO50Mu3JB4oUgUpRvattgdzDsPNYR600hiKSEjwYw6pyRFzLsygeJF4JIUZo6zc7/dpljvCUEkZz0j7yQYVc+SLwQRArSZ7Wj03VX2NRFJ1KCUAIeeeGeFzLsygeJF4JIQTyjLRR5IQhl6B958eywyxiL2XYlAyReCCIF8Yy2NJN4IQhF4OIlTXhenOLF5mDockVliPAg8UIQKQj3uwCUNiIIpeCl0ul6Z+TFoFXDoHVedlu7KXUUCSReCCIF8UwVUeSFIJSBD2Xk1UYAmXblgsQLQaQgXp6Xbsq/E4QSiMiLh3jJJvEiC1ERL08//TTKy8thMBgwffp0bN68OajXvf7665AkCZdccomyG0gQKYZnqshic4jKI4Ig5KNbeF404rHcdOr1IgeKi5c33ngDixcvxrJly/D1119j0qRJmDt3LhoaGgK+7tChQ7jzzjtx1llnKb2JBJFyNPZLFTWT74UgZIcPZkzXU+RFbhQXL3/605+wcOFCXHfddRg/fjxWrFiBtLQ0vPjii35fY7fbMX/+fPz2t7/FyJEjld5Egkg5PA27AJVLE4QSdPPZRh6RF95lt5VGBESEouLFYrFg69atqKqqcv9ClQpVVVXYuHGj39c98MADKCwsxPXXXz/o7zCbzejo6PD6IQgiMFysqCTnv8m0SxDy08v7vOh9GXYpbRQJioqXpqYm2O12FBUVeT1eVFSEuro6n6/54osv8MILL+D5558P6ncsX74cWVlZ4qesrCzi7SaIZId7Xsrz0gEAjZQ2IgjZ8eV5obSRPMRVtVFnZyd+8pOf4Pnnn0d+fn5Qr1m6dCna29vFT21trcJbSRCJjcXmQHuv866voiQTAEVeCEIJuOclzatUmgy7cqAZfEn45OfnQ61Wo76+3uvx+vp6FBcXD1i/f/9+HDp0CBdeeKF4zOFwODdUo0FNTQ1GjRrl9Rq9Xg+9Xq/A1hNEctLc7RQqGpWEkfkZAMjzQhBK4CvykpNOkRc5UDTyotPpMGXKFKxdu1Y85nA4sHbtWsyYMWPA+oqKCuzYsQPbtm0TPxdddBHOOeccbNu2jVJCBCEDTZ3Ok2Zehg4FmU7hT9VGBCE/7g67PjwvZNiNCEUjLwCwePFiLFiwAFOnTsW0adPwxBNPoLu7G9dddx0A4JprrsGQIUOwfPlyGAwGTJgwwev12dnZADDgcYIgwoNHWfIz9MjP0Hs9RhCEPFhsDljtzuaPPquNKG0UEYqLl8svvxyNjY247777UFdXh8mTJ2P16tXCxHvkyBGoVHFlvSGIpKbRQ7zkZTjvAinyQhDywiuNAG/PCzfs9lrt6LPaYdCqB7yWGBzFxQsALFq0CIsWLfL53Pr16wO+duXKlfJvEEGkMI2dAyMv/ZvWEQQRGbzHi06jglbtvkE3GTRQqyTYHQxtPVYUZ5F4CQcKeRBEiiHSRpk65LsiL519Npht9kAvIwgiBHosAyuNAECSJI/UEUU8w4XEC0GkGLzHS0GGHllGLTSuTnWUOiII+eATpdN1AxMc2WTajRgSLwSRYjR5pI0kSSLfC0EoQLefyAtApl05IPFCECkGTxvxMmmqOCII+elxRV7S9AEiL5Q2ChsSLwSRYniWSgNAHokXgpAdHnlJDxB5aSPxEjYkXggihbDaHSJUzc26/L9NlDYiCNno9dFdl+Pusktpo3Ah8UIQKUSLyyCoVkmi0yePwNB8I4KQj24fE6U51GU3cki8EEQKwXu85KbroHJVGbkjLyReCEIufA1l5FCpdOSQeCGIFKK/3wUA8tJdkRe6CyQI2fA1lJHjNuxS2ihcSLwQRArBfS082gIA+a6qIx6VIQgicnoCGnad3z8y7IYPiReCSCFEmbRX5MXV54UiLwQhG90BSqVz06nPS6SQeCGIFEI0qMt0ixfe76Wl2wKHg8Vkuwgi2ei1+o+88LRRe68VNrsjqtuVLJB4IYgUwu15caeNeAjb7mBo66U7QYKQAxF58eV5MWrF/7fTdy4sSLwQRArh9ry4Iy86jQpZrpMplUsThDz4G8wIABq1CpkGp6ih1FF4kHghiBTCV7WR89/O6EsjiReCkIVAnheATLuRQuKFUJQN+5rwl0/2kpciTvAnXvJEozo6kRKEHASqNgKoy26k+JaEBCETv35nBw419+CM0fk4ZVhOrDcnpbE7mOiwm5+p83qugOYbEYSsBOrzAng0qqMqv7CgyAuhGDa7A7WtvQBobk480NJtgYMBkgTkpnmLlzxX2ogiLwQhD7zDrq/xAIDHiABKG4UFiRdCMeo6+mB3pYvIUR97eFQlN00Hjdr7q59PkReCkA3GGHqsgSMv2WnU6yUSSLwQinHUFXUBgA4SLzHHn98FcEdeKEJGEJHTZ3WAuWx+g0VeyLAbHiReCMXwFC8UeYk9Qrz087sAFHkhCDnpdpl1AcCgGcywS+IlHEi8EIpxjMRLXNHUObDHC4eXSjd3k3ghiEjpEQ3q1GJ6e39yKG0UESReCMU42toj/p/SRrEnUNpIRF466S6QICKlWzSo81/QKwy7VG0UFiReCMXw8rz0kXiJNY0BPS/Ox3qtdtGfgiCI8BA9Xvz4XQAy7EYKiRdCMY62uSMvlDaKPe7RAAM9L+k6NQxa5+mAoi8EERk9g/R4AbwNu4xRE89QIfFCKILN7sCJtj7xbxIvscfXRGmOJEnIS3eljsj3QhARwUcD+OuuC7jFi83B0GWmaGeokHghFKG+0wybx0iAjl76csYa7nkp8JE2AtyihoscgiDCg6eNjAHEi9Ej2tlGqaOQIfFCKMLRFmfKSOdqhkaRl9jicDA0d/uvNgKA/HRecURpI4KIBD4aID1A2ghwR19a6DsXMiReCEU41uY0644tzgDgNIJabI5YblJK09pjEd2O83x4XgDPiiOKvBBEJPDRAGkBDLsAkE0jAsKGxAuhCLzSqKLYJB6j6Evs4Gbd7DQttGrfX3sx34juAgkiIoKPvDgrjihtFDokXghF4D1ehuWmIdPg/AJTuXTsCNTjhcOfa6QuuwQREcFGXmg4Y/iQeCEUgUdehuYYkWV03l1Q5CV2DGbWBTwnS5N4IYhI4EMZB428pFOvl3Ah8UIoglu8pMFkIPESaxoDlElzuLBppuGMBBERIvISoNoIoC67kRAV8fL000+jvLwcBoMB06dPx+bNm/2uff7553HWWWchJycHOTk5qKqqCrieiD/sDobjbQMjLzQiIHYEalDHyaPhjAQhC91BNKkDyLAbCYqLlzfeeAOLFy/GsmXL8PXXX2PSpEmYO3cuGhoafK5fv349rrzySqxbtw4bN25EWVkZzjvvPBw7dkzpTSVkor6jDzYHg0YlochkIPESBwTjeeFpo9YeK2x2qgwjiHAJZjwAQIbdSFBcvPzpT3/CwoULcd1112H8+PFYsWIF0tLS8OKLL/pc/9prr+Hmm2/G5MmTUVFRgb/97W9wOBxYu3at0ptKyAQvky7NNkKtksjzEgcE43nJSdOBD8ClvhO+aew045HVu3GkuWfwxUTK0m0OLvJCht3wUVS8WCwWbN26FVVVVe5fqFKhqqoKGzduDOo9enp6YLVakZub6/N5s9mMjo4Orx8itvBKo6E5RgCAyej8ApN4iR0i8pLpP22kVknIdTWqayLfi0/+8VUtnlm/H0+u3RvrTSHiGBF5Gczzks7nG9G5MVQUFS9NTU2w2+0oKiryeryoqAh1dXVBvcfdd9+N0tJSLwHkyfLly5GVlSV+ysrKIt5uIjKOtjgjL0OyneLFnTaiEQGxgg9bDJQ28nyefC++qWt3zuv6prY1xltCxDNiMKM+uD4vFOkMnbiuNvr973+P119/He+88w4MBoPPNUuXLkV7e7v4qa2tjfJWEv3xrDQCQGmjGMMYQ3P34J4XwLNRHYkXX/D9cqCxm/oWEX7psQw+mBFwG3Z7rXb0ucqrieBQVLzk5+dDrVajvr7e6/H6+noUFxcHfO1jjz2G3//+9/jvf/+LiRMn+l2n1+thMpm8fojYcrStf9qIxEssae+1wmoPPBqA4x4RQHeCvvAsI99xtD2GW0LEM93mwQczAoDJoIHaZTSj1FFoKCpedDodpkyZ4mW25ebbGTNm+H3dI488ggcffBCrV6/G1KlTldxEQgE8G9QBbvFCd6qxgaeATAYN9JrAJ9O8dJd4ociLTzzD+9tq22K3IQmEw8Hw8IfVeG9balSM2uwOmF1z3AZrUidJErKNvFEd3TCEQuA9KwOLFy/GggULMHXqVEybNg1PPPEEuru7cd111wEArrnmGgwZMgTLly8HAPzhD3/Afffdh1WrVqG8vFx4YzIyMpCRkaH05hIR4tXjJZfSRvFAI/e7BGhQx+GGXoq8+MZTvHx7tC12G5JAbDvahuc+O4DCTD0unjwk1pujOD0e6Z/BxgMATtNuc7eFxEuIKC5eLr/8cjQ2NuK+++5DXV0dJk+ejNWrVwsT75EjR6BSuQNAf/3rX2GxWPCjH/3I632WLVuG+++/X+nNJSKkobMPVrurx4vrYkniJbYE0+OFk++KvJDnZSAOB/O6wGyvpbRRMOxv6ALgHPjJGIMkSTHeImXpcZVJa1QSdH6GoHrCTbut3XR+DAXFxQsALFq0CIsWLfL53Pr1673+fejQIeU3iFCMY66UUUm2ARrXF5ePB+gy2+BwMKhUyX3yijeC6fHCEZEXqjYaQFuvFQ6ndQgqCajr6EN9Rx+KTL6LCQgnB5u6ATijsh19NnEzk6x0W9yjAYIRatRlNzziutqISDy434WXSQPuyAtjQGcflUtHG3fkJbBZF3B7Xmi+0UBaut3eobFFmQCA7eR7GRQuXgCgLQUu0L280miQMmmOu8tu8u8bOSHxQsiKu0FdmnhMp1HBqHXmfil1FH2C7fECuH0xzV3OED/hhgu6vAw9Jg3NBgBsJ9/LoHiKl1ToZ9Id5FBGjrvLLp0bQ4HECyEr/SuNONRlN3a4u+sOLl7yXB0/LXYHOihK5gW/8Oam6zCxLAsA+V4Gw+Fg/SIvyf/97wlyKCOHd9mltFFokHghZKV/gzpOFpVLx4xQDLsGrRqZrnA3+V68afYQLzzy8u3RNjgcFKHyx/H2XlE2DKRI5MUSauSFG3aTf9/ICYkXQlb6zzXiUMVR7OBzioLxvAAeXXbJ9+KFSBul6zCuOBN6jQodfTYcau4e5JWpi2fUBUiN6AKvNgrW85JNaaOwIPFCyIbDwXC8zTn7hcRLfMAYQ2MIkRfPdRR58YYbdvMydNCqVTip1NnNm3wv/klF8RJ65IUPZ0z+fSMnJF4I2WjsMsNid0CtklDcr3yUl0t3kHiJKp1mGyyusH1BEJ4XwDPyQuLFE3fayLkfJ5VlAyDfSyAONDrFC++OkArRBfdco9CqjVJh38gJiRdCNnjKqNjk7vHCoflGsaGp0ylAMvQaGLTB3QnyyEsjpY284H4NbmqezMULRV78wiMvFcXOKFUq+Dp6eOQliO66gNuw29Fnhc3uGGQ1wSHxQsiGv0ojgNJGsSJUvwvgLAUGKPLSH89qIwCY6DLtfne8Q0S3CG+4eDl1eDaAFEkbmXm1UXDiJdujDxadH4OHxAshG/4qjQCKvMSKUCqNOAUZ1GXXF839xEt5XhpMBg0sNgf21HfGctPiErPNLqKxU4bnAEiNFvgi8hJk2kijViHT4FxLqaPgIfFCyIa/SiPAs1SaeodEk3DEizvyIs9d8qd7GvHxrnpZ3itWMMZEyoN7giRJEr4XmjA9kCPNPXAwZ8pyTKGzI3FKRF6E5yW4yAtApt1wIPFCyAaljeIP7nnhM4uCgQudZhn8CT0WGxa+8hV+/v+2JvTfvqPXBpurnwuPvABwd9ol8TKAA66U0ciCdLHPWnuSv3NzD++wG2SpNECm3XAg8ULIRsC0kSssStVG0aWxK/jRABweWeDCJxJq6jphsTlgczAcakrcfih8ynaGXgO9xn1HzSMv3x6liqP+cL/LiPx0EVmw2pmITCQr3SFWGwE0nDEcSLwQsuBwMBxrCxB5SaNS6VjQ2Bl62ijfVQrcabahzxrZhaamzu0FSeRmbv39LpxJQ51jAvY0dKLLTClRTw42usWLUaeGQeu83CR7xREfzBhstRHgPq4obRQ8JF4IWWjqMsNic0AlAcVZhgHPe6aNkj1sHE+E43kxGTXQqp2NOSJNHe32EC9Hmnsieq9Ywv0//cVLocmAkiwDGAN2HqPoiyeekRcAyE2R6AJvUhda5MV5fmxJAUOzXJB4IWSh1pUyKskyQqseeFhx8WJzMNHEiVAeLl6CbVAHOI2oeenylEtXn+gQ/3+4JXHFCy+T9lVy7jnniHAjPC/5GQDcqZFkn2/UE2KpNECG3XAg8ULIAq80GuIjZQQARq0aGlebzUQ2biYSjDG3eAkh8gK4Db6RlEszxpIm8sJHA/SPvADUadcXHX1WceyU5zs9cO7USHJ//0MdDwB4GnZJvAQLiRdCFgJVGgHOu3maLB1dui129FmdzdNCqTYCICIvTRGUS9d3mL2EanJ4XgaKQO57oXJpN9zvUpCpR6ZrNIg7NZK8F2jG3JHlYAczAjScMRxIvBCyEKjSiCN8L/QFjQq8WihNpw66YRZHjuGM1XXOlFGhK2XV0GkWZsZEo/9oAE8mDM2CJAHH2nqpsZ+LgyJllC4eSwVTqtnmgN1VUh9K5CUV9o3ckHghZCFQgzpOJvV6iSrhmHU5+WI4Y/gn090nnCmjaSNyRan8kQT1vfQfDeCJyaDFqAKnr4N8L048e7xwhOcliS/QnuI8lBsGMuyGDokXQhYClUlzqMtudHGLl9BSRs7XRB552e2KvFSWmFDuugNP1NSRqDbysy+5aXcb+V4ADKw0AoDcFGjExv0uBq0Kaj5KOwg8DbtUjRkcJF6IiGGM4RhPG2UHkTaiyEtUCKdBHSdPhsgL7/FSUZyJYbnO4yJRTbuB0kYAMKnM6XuhyIuTg01dAIARrkojwD09OZn7vHC/S6hpWi5ebA5G/YKChMQLETGNXWaYA/R44WQZnV9oEi/RwT0aIJy0UWSRF4vNgX0NzgtYRYkJw/Oc4uVwS+JFXhhjAdNGgPeYgFS/c2aMeTWo4+SkgCm12xx6pREAGHVq6DXOy3GyV2PJBYkXImK4WbfYZIBO4/+QMhmoy240icTzIkYEhBl52d/YBZuDIdOgQWmWAcPznBexwwkYeek022CxO6u28nxUGwFARUkmdGoVWnusqG3pjebmxR2NnWZ0W+xQSRARN8BDvKRA5CWUBnUcz/lPxOCQeCEiJphKI8DD80LiJSq4e7yE7nnhfWFaus2ieiIUuN+lojgTkiRhuOsilojipcUl4IxaNYx+7qj1GjUqS5yTk7eneOpovyvqUpab5nUzk5Pu7mWSrNEpEXkJYTQAJ1Wa+MkFiRciYoKpNALI8xJtmiLwvHB/goOFV765W/hdTAAgIi/H2nphdUUxEgXe4yVvEBHoblbXpvAWxTe+yqQBd+TFbHOgN8KZWfFKJJEX3qiO0kbBQeKFiJjBGtRxTCReoopIG4XhedGqVeJkGk7qiJdJV7iiEYWZehi0KtgdDMfbEiutMphZlyN8LykeefFl1gWcPhAeiUlW34vbsBt65CUnRWY/yQWJFyJijoWaNqIOu1GhKYyJ0p7kZYQ/38idNnJGXlQqSfgfDiVY6ijQaABPeMXRzmMdsCVYdElORJl0gXfkRZIkdxv8JE2N9PChjCF01+Vkp0ApuZyQeCEiZrC5RhxKG0WPXosd3a67wHD6vHi+rjFE8dLabUF9h/M144ozxePDcp0XsyMJ1usl0GgAT0bmZyBDr0Gv1Y69rkqrVOSAn7QR4I4uJKuvo9s1lNGfNyoQ1GU3NEi8EBHBGAs6bUTiJXrwlJFeo0JGGHeBgGfkJbSTKfe7lOUavX63KJdOtMhLV3CeF5VKwkTXnKNU9b3Y7A7Ry2dEAPGSrKkREXkJQ7yQYTc0SLwQEdHUZYHZ5oAkASVZg3heXKXSfVYHzLbkNOzFC40eZdKSFHynT08Kwuz10j9lxCnPS9S0UeAeL55MFL6X1Oy0e7S1FzYHg0GrQrFpYM+n3CRvVOeeKE2GXaUh8UJEBE8ZDdbjBQAyDRrw62hHr7xdJP93oJmm+noQSYM6Djeohhx5cZl1Kz1SRgAwzFVxdCTBGtU1hyBeJpelduTlgMusW56XDpWP9vjJ7uvoMfOJ0mTYVRoSL0REBJsyApxh9Uy9/F12O/qsuOaFzfjJC5vC6kmSjPAKoXB6vHC48GnuDi/yMq5f5IX3ejnS0pNQfT745x+s2ghwl0vX1Hcm7ATtSDjg6vHCB1X2J9kbsYU7HgBwCzuKvARHVMTL008/jfLychgMBkyfPh2bN28OuP6f//wnKioqYDAYcPLJJ+PDDz+MxmYSYRBsgzqOEuXSx9t6YbE70NlnIz+Ni0i663L4xboxhMiL3cGwp56PBfCOvAzJMUKtktBndaChM/yBj9GGe16CibwUmwwoyNTD7mDYdSL1Uke+BjJ6kp3kIwK6RbVR+IbdZBV2chOeky8E3njjDSxevBgrVqzA9OnT8cQTT2Du3LmoqalBYWHhgPVffvklrrzySixfvhzf//73sWrVKlxyySX4+uuvMWHChKB/b3d3N9TqgQeQWq2GwWDwWucPlUoFo9EY1tqeHv93l5IkIS0tLay1vb29cDj8l2Gmp6eHtbavrw92u/87RX9rD9Y1wWHpQ4GRif2TlpYmfBZmsxk2mztFlK6ywWHpQ31LG7rzdQHX9sdoNEKlcupti8UCq9V5AjxS3wKHpQ8AUFvfAn1Rpt+1vjAYDOJYCWWt1WqFxeL/RKPX66HRaEJea7PZYDb7v7jrdDpotdqAa483tcJh6UOOwX1/Yrfb0dfX5/d9tVotdDqdWJvm+ls1tLQNOPY91zocDvT2OkXsoaZudHd3Q69RocDg/M7wtVq1CqUmPQ43tKH6SAMyRuQN2AaNRgO93im4GGPo6fHvjwllbSjfe8+1jDE0tnbAYXMgTbINeJ2v7/34Aj3WNbdj054TqMjXB1ybbOcILl6GZKp97uM0lRUOSx9aPHxUg33vgz1H9FrsWLn5OC6bWobheemDfpeVOEd0dHaBOewwakP/3qdrJTgsfeiyAM1tHTBo1X7XynGO8LU21HNEsGs9zxGDrQ0apjDTpk1jt9xyi/i33W5npaWlbPny5T7X//jHP2bf+973vB6bPn06u/HGG32u7+vrY+3t7eKntraWAfD7M2/ePK/Xp6Wl+V07a9Ysr7X5+fl+106dOtVr7fDhw/2uHT9+vNfa8ePH+107fPhwr7VTp071uzY/P99r7axZs/yuTUtL81o7b968gPvNkx/96EcB13Z1dYm1CxYsCLi2oaFBrL355psDrj148KBYe+eddwZcu3PnTrF22bJlAddu3rxZrH3kkUcCrl23bp1Y+5e//CXg2g8++ECsfemllwKu/cc//iHW/uMf/wi49qWXXhJrP/jgg4Brr/7F/WLtunXrAq595JFHxNrNmzcHXLts2TKxdufOnQHX3nnnnWLtJb9/O+Dam2++WaxtaGgIuHbBggVibVdXV8C1P/rRj7yO4UBrPc8RXX1WJmn1ftfSOcL9wxhjpz/8MRt+9wdszryLAq4975GPxPvKeY4Y8vMX2E9e2MQYi905oujKh9lne5zbHMo54sUXXwy4VqlzxF/+8hexNtbniPb2dgaAtbe3s8FQNG1ksViwdetWVFVVicdUKhWqqqqwceNGn6/ZuHGj13oAmDt3rt/1y5cvR1ZWlvgpKyuT7wMQRIKT4arwihcG6wUUb1DZavD0WGw40e68Ex+sPF/JXiabDjSjL8bjB8LxvIRbFZiqSIwp55w7fvw4hgwZgi+//BIzZswQj99111349NNPsWnTpgGv0el0ePnll3HllVeKx5555hn89re/RX19/YD1ZrPZKyTW0dGBsrIyHD9+HCaTacB6Shv5XhtO2ogxhlMfXIM+qwOrbz8Lw1157kBh3nvf2YG3vj6G2+eMxs9nj5YlbfSH/1Rj5ZeHne//vUrMP314yqeN5j35GQ429WDVjWfgzHHFAMILCZ/6wBr0Wu346I6zRLVQ/7WeIeFb//41Pt7VgHsuqMCCmeUD1j67fh8een87LphQjD9dPnnANsRb2mhbbRsuenwtSrL0+OTOcwas9XWOaOuxYMbyTwAAG5f+n/B5JPs54lC7Dd/78xfISdNi411n+1xb29yD8574DGlpadj9uwsAyJc2uvvNb/GvXU2QJBVe+ek0nF6eFfW00Zl/WIuWPuCjxbNRUWwK+Rxx7qMf40BTD166bipOH5nvd22ypo06OjqQlZWF9vZ2n9dvTxT3vCiNXq8XJzBP0tPTvb54/ghmTThrPU8mcq71PPnJudbzxB7s2qYuMyySDmo9MGpIHvSagR6j/n+fgtwsqHTN6IN2wP7097f0hU6nE1+MdpsaKp1zm7rs6gHv67k2lPcdDK1WK770cq7VaDTiJBXu2haLCiqdAcU57qoPtXrgvvEHX1uQa8LR1l70sIF/L45KpRLP7W+1QaUzYPKIIp/rywsyoNIZcKKHDbotkiQFvb2hrAWC/y63dJuh0hlQkGsK+nySnp6OUaV5ONjUjX2tNswqyPG5NtnOEQf3HwcAjCzI8Lt2iFoHlc6APpsDfVY7DFp1SN/7QGtbrRIkySlGPtvTiLPHFijyvQ+0to/pIKnsYjBjqOeIgtwsHOpwwAxdwONNjnOEL8I5RwSD5zlCLhRNG+Xn50OtVg+ImNTX16O4uNjna4qLi0NaT8QOXmlUlGnwKVx8oUSX3UaPypVmCvOjz2pHZ5/z7rQggmojwF2tFEyjum6zTXTPHdevxwsn0brsNotKo9D2I++0+20K9Xs52Bi40ghwppM0rv4vclfVNHS4j9HP9jbK+t7B4HAwMS07nMGMAHXZDQVFxYtOp8OUKVOwdu1a8ZjD4cDatWu90kiezJgxw2s9AKxZs8bveiJ28AZ1wfR44ZgM8vd58RIvYUxATja4gNOpVTAZIwuu8vlGwezXmnpnc7qCTL0YLdAfPpyxvdeaEDNcgp0o3Z9UnDA9WJk04BrOmK7MBbq+w53C2FPfhbp2/ykNJej18NmEM5gR8OyyG//fjVijeJ+XxYsX4/nnn8fLL7+M6upq3HTTTeju7sZ1110HALjmmmuwdOlSsf7222/H6tWr8cc//hG7d+/G/fffj6+++gqLFi1SelOJEDkWQoM6Du/zImeHXc/BgaE2VEtGeHfdvAxdxCbAUCIvNa6ZRhV+oi6A08hY6Gp+lwjRl1BGA3jCm9Vtq21PqIZ8kRBoIKMnuWl8AKF8NzB9Vjs6XNFGLp6iHX3hPV4kyTlTLBxykrwPjpwoLl4uv/xyPPbYY7jvvvswefJkbNu2DatXr0ZRUREA4MiRIzhx4oRYP3PmTKxatQrPPfccJk2ahDfffBPvvvtuSD1eiOjA00ahVJDInTYy2+xeJ0GKvLgjUZE0qOPkicjL4OJl9wlnZ93KksBGO5E6aol/8dIUQoM6T04qNUGjktDUZRYVOMkMYwwHGp3NCUcUBBYvvJOsnJEXfszrNCpcOLEEgNP3Ek3EaACdJuybhmwaERA0UTHsLlq0yG/kZP369QMeu+yyy3DZZZcpvFVEpLjTRsGbCeXusNtfrIQ6RDAZ4fugIIK5Rhx35GXwk2l1EJEXABiel44th1pxpDn+Zxy1hDAawBODVo1xxZn47ngHtte2oTQ7sUrEQ6W1xyoiH+V5g0Re0nnkRb4LdEOnUyAWZupx9tgC/PmTffhiXxPsDga1jxlLSuAeyhie3wWg4YyhQLONiLAJZa4Rh0deOvrk+XLyOy5+wujos8Fi81/6mQq4RwOEP9eIkxdk2ogxJiIv/sy6HD7jKBGmSwvPSxhRLJE6SgHfC4+6DMk2DugM2x+3KVW+CzQ36xZm6jGpLBuZeg3aeqzYeSx6Ixr4XKNw/S4AFPMDJSMkXoiwYIyFPNcIcIuXzj6bLEMUuXgZWZAu7rBSPeTKoyRypI24ABpMvNR19KGjzwa1SsLoQt9D+TjDXGmjIwkgXkKZKN2fSaLiKPlnHAm/yyApIwDITeeTpeWMvHDxYoBWrcLM0c7RE9FMHbmHMkYSeYksKtVntcNqT42bNxIvRFi0dFuEu740O/geMSaPjq+dMkRfuFm3KNMgLjCpnjpqlGEoI4e/x2Al6LtPOFNGowrSBy2b52mFwy2JkDYKr9oIcEdedhxrT/pp58FUGnFyFPB18EqjQpPzeD17bAEA4PO9TbL9jsHoMbuGMobRXZfD00bhGHbNNjsufOoLnPPYephtyT/RnMQLERaix4tJH3SPF8BpqDO6wspy+F545KUgUy8uMKlu2uXVRvkyel7aeqwB7+iq65wpo4riwGZdwG3Yre8wo9cSvyfZPqtd3E3nhpGCG1OYiTSdGl1mm0irJCvB9HjhKFFR4468uMTLGKd4+fpIqyw3ScHQ7TpWjBFEXnhKraPPGrLg/WD7Cext6MLR1t6EqOSLFBIvRFgcaws9ZcTJkrFc2lO8uKMEqR15kdPzkm3UinRcoDw8j7xUlAT2uwDOEzTv93MkjiuOeLRJq5aQGYaPQa2SMKHUmTrafjS5U0chRV542khGX4cQLyZnFLgsNw0j8tNhczBs3N8s2+8JRI/LsJuuj0S8OPcNY6Hd3DHGsPLLQ+LfJF4Iwg+80mhIGFUUcpZLe0VeQmiolsxwz0uk3XUBQKWSRDrOsxlgf4Lp8eLJcJ46iuOKoxaPMulwS18nlbnESxJ32nU4GA428x4vgf1OgDJpo4YOd7UR5+wxztlA0er30m3mnpfw00ZatQqZLmEfyv7ZergVOzzMyfF8UyAXJF6IsAin0ojDu77KIl54WXCGHnnpwZf1JisWm0PsVzk8L4Db7+HP92K22bHflRYJJm0EuFNH8XyS5RG8UEcDeMJ9L8ncafd4ey8sNge0aimonk9CvCjQ56Uw0+2/O8uVOvpsT3R8LyLyEkHaCAhv/7zkirrwKGkitCGIFBIvRFiEU2nEkbNc2nfkJXXTRvyCq1FJYj9HCu8X0+Qn8rK/oRs2B4PJoEFJVnDmbS5eDsXxSZZH8MIx63L4mIDqEx1Ja6I84PK7DM9LD6qnCi8H7rbYZdknFptDCGtu2AWAGaPyoFVLONLSE5UIn4i8RFAqDYRu2j3e1ovVO+sAAFdPHwYgMRpARgqJFyIswplrxJGrUR1jzKdhN5V7JDR18r4kOqhkas7ljrz4Fi+7uVm3xBR0emV4Lk8bxe9JNtzRAJ4MzTEiN10Hq52h2uULSjYOBjkWgGMyaITIkaMZG/d4aVSSGD0AOPutTBnunOgdjZLpXqs8kZdQu+z+v/8dht3BMH1ELuae5BxgHM8RTbkg8UKEjHePl9h5XrotdlGunZ/hHgbYlMriRcYyac5gXXZD9bsAiZI2ily8SJIk+r0kq+9FmHWD6PECuIYzpsnX66XB4wamv2DnqaNPo5A6ksPzAoQ2nLHPasffNx8BAFx3RrnooXS0pTfpy/NJvBAh09pjFSWk4bQ9571eOiIULzzqkq5TI12vobQR5O3xwhmsy657LEBwfhfAbdg92tobt021+GiASKu2xpc698vuuuSMvAQ7kNETd5ddGcSLD7MuZ5ar38vG/U2KH2c9MowHANxptWDSRu9tO4bWHiuGZBtRVVmEkiwjtGoJFrsDdR3JPVOLxAsRMnyadGGmftBW4L6QK/LS2K88Mt9lrEzlaiNlIi+Bq7j4WIBgyqQ5hZl66DUq2B0Mx11l9/GGO20U2b4cW+TcL3vrk1O8HGxyDWQMotKIkytMqZGnjdyRl4F+q/ElJuSl69BtsePrw60R/65AyOd5Cc6wyxjDSxsOAQCumTEcGrUKapUkfIjxXMknByReiJARZdJhpIwA+cULLwnmkZdeq13cBaUa3POSnxl5jxdOfoDIS0u3RVw8xhUFL15UKgnDcvlJNj5TR3KkjQBnszoA2FPfCcaSK5RvttlFCjmYHi+cbDnTRv2663qiUkk4M0ol0/JVGwW3b/53oAW76zph1KpxxWnDxOP8e1UbxylZOSDxQoRMJJVGgNuwG2naiE+S5dUwaTo1DFrnIZ2q0ZemLm9BJweB+udws+6w3LSQB9KJXi9xepJ1D2WMTLyMLEiHSnIODQ3UKycROdLcA8aATL0mpPQaF4RylEv3767bH95tV+lRAd0WeTwv2UF2IF755UEAwKWnDkFWmruykPvJ4vWmQC5IvBAhE0mlEeBZKh1ZdMSz0ghwGgHdvV6S6yIRLEoadpu7zQMiB6KzbghmXY44yTbFZ3jbs0ldJBi0ajHPaU99co0J2N/oHsgYSiO/YC/QwcDFS5HJd5n+Wa7Iy45j7YpWIvaKqdLy9HkJZNitbenBml31AIDrZpZ7PScimnF6UyAXJF6IkImk0ghQIG3kccfF75JTtVxaCfHCL95WOxsw0sGzTDpUhHiJw5Os2WZHp2vQXiR9Xjhjipx+kD1J5nsJZSyAJ3JOluYRWH+Rl0KTARXFmWAM+FzB1FG3MOxG6HlJH7zPy6v/OwwHA84cnY8x/dK1XLwkwtT2SCDxQoRM5Gkjd4fdSDwAjT5SJKk+nJGXM8vpeTFo1aJleWO/iBavoKkMK/LivODF40mWG0nVKslrEnq4CNNuQ7KJl9DNukDovUwC0dAxsLtuf2ZFYcp0jyiVlq/Drq/zY4/Fhtc9yqP7I75XcXhTICckXoiQcPZ4kSdtZHcwUXIdDr4jL7zXS+qljWx2h7gYyBl58Xw/zzJ0u4OJSMK4cMSLCG93x52RlUewctLkafY3upBHXpIrbRRqjxdOrkwjAuwOJv5Wvgy7nLOE76VRkWPNYnPA4irFTo+4z4tz39gcDF3mgan1t78+ho4+G4bnpeGccYUDni/LdZ6X23utaJdxcne8QeKFCIn2XqswpoUzlBEAjFo1tGpJvF+4BEobpWLkpaXbAsYAleQ+AcoFN2N6Nqo73NyNPqsDBq1K3O2FwpAcI9QqCX1Wh/AtxAvCrCtDyghwR16SreIo1O66nGBSI8HQ3GWGgwGSFPhvNbU8BwatCvUdZtQokLrr9bgJM0YYeTHq1NBrnJfm/h2IPadHL5hR7lNYp+k04px4uCU+/WRyQOKFCAmeMsrPCK/HC+A01kbqe7E7mChl9RQv7l4v8XUxjAY8pZObrg9qxkwocCO054gAnjIaV5QZ1u/TqlVCAMdbZYRclUackQXOuT+dfTbUdyTHsdneaxVitjxU8SJT5IWL3vwMPTRq/5czg1aN00fmAQA+V6DbLve76NQq6DSRX1b9Td7+Yl8T9jV0IV2nxo+mDvX7eh7VTObUEYkXIiQiTRlxuI8gXPHS2mOB3cEgSd7VICLykoKGXeF3kemC6wn30HgOZxTN6ULorNufeB3QKFePF45eoxafNVl8L4dcUZfCTD0yQiyT5xfnTrMtos63g5l1PRFTphUw7YruuhFWGnH8ddld6WpKd9nUsoBerGEpUC5N4oUIiUgrjTiR9nrhKaPcNB20Hndc/GLjbw5PMtPkI40mF6IE3UMUishLGH4XTrxWRvDRAHKljQBgrGhWlxy+lwMus+7IEP0ugPP7z4N1kZh23WbdwY/5WWOdJdObDrZ4pXnkgHv3IvW7cESjOo/v26GmbnxS0wDA2VE3EPH6vZITEi9ESERaacSJNG3ky+8CuI2lLSlo2FWiTJqT79rPXpEXPtMohLEA/YnXcmm5RgN4MtZVLp0sYwIONvIy6dAqjQBnFRc/B0QyWbo+iEojzqiCDJRmGWCxObD5UEvYv9MX3TJVGnF8pY1e3ngIjAHnjCvAyILA+9z9vYqviKackHghQkK2tJFC4sXTsJtMxshgcIsXBdJG6d7puC6zTeTTI0sb8XLp+DrJcsN3roz7coyHaTcZCGcgoyc8NRJJTyaRNgpQacSRJMmdOtojb+pIrqGMHPf4BOf5sbPPin9+dRQAcO0ZIwZ9/bBc59+ktiU+54bJAYkXIiTkShtluXq9hNtl11ePF8CdNrI5BjZUS3bcnhcFIy+u/V7jiroUmfQR+ULcnpf4jLzImTYaIyIvXUkhrMNtUMfJDaKT7GA09BvOOhhnj1VGvMg1GoDTv8vuW1uPostsw6iCdJzt6hgcCJ42Ot7eC7NN3hRZvEDihQgaZ48XedNGkXpe+kde9Bp3Q7VU6/WiZNqof/O/GuF3CT/qArhPsvHWk6JFZsMu4LzIq1USOs021LmGCSYqjLGwe7xweKO6lggmSw8216g/Z4zOg0oC9jZ04US7fFGJHlc/lkhHA3A8DbsOB8PLGw8DAK6dWR7UGIb8DB3SdGow5r7hTDZIvBBB09FrE02Twu3xwlHK8wJ4NlRLLdMu3yf5Chh2+Xt2mW3os9rFWIBwOut6kqbTiAtPPOXnuRCUM/Ki16hR7oo0Jbppt6HTjB6LHWqVhLIwb2TkGBHQ2BF8tRHgFEwTh2YDkLdkWv7Ii9uw++meRhxs6kamQYMfnOq/PNoTSXJPbU/WcmkSL0TQ1Lr8LvkZuogbMUVaKh1IvLijBKkZeZFzojQnU6+BzlXV1dRldg9kjMCsy4m31JHV7hDpTDkjL4DHmIAE970ccJl1y3KMYfc1ibTXi8PBQk4bAe7U0acylkz3WmSOvHgYdl9yNaW7fGpZSJPb+fcqWSuOSLwQQcPDj0MiTBkBMqSNAlyoRbl0CvV6sTuYSHXIOdeII0mSV5fd6rrIe7xwuLkwXky7/GIqSe7UhlyMEeIlsSMv7jLp0CuNOP56mQRLa48FNofTOxSKYOcl0xv2NcHukMd7JHfkhRt2DzR247M9jZAk4JoZ5SG9h5guTeKFSHXkqjQClE0b8flGLSmUNmrptog26bkyX3A5fL/uONaOzj4bNCoJoyK4eHHK46yhlmhQl6aTvVMxL5fek+CN6txl0uH5XQCP1EiYaSMedclN14UU/Zk0NBuZBg3aeqzYcaw9rN/dH+55kbtUutfqFEVVlUWi8VywDBMDGuPjpkBuSLwQQSNXpREQWam02WYXr/PteeFlvamTNuIpo9w0XcA26ZHA9+sXrnD7qIIMWVqhD4uzXi9KmHU5PG20L8ErjiKtNAL8t8APllDNuhyNWoUzRjmjL3JVHSlVbcS5bmZ5yO+R7CMCSLwQQfHF3iZ8XF0PIPJKI8AjbdQXunjhJcFatbvRlSf9K2NSASUrjTg88rJxfzMAefwugLvXy+E4SRvJPRrAk/K8dGhcFUcn2hO34ijcgYyeiLRRmOndBpdZN5yO0tz38rlMvpcemT0vmQaNiPqNK8rEjFF5Ib+Hp2E3kYWyPxQVLy0tLZg/fz5MJhOys7Nx/fXXo6vLf663paUFt956K8aNGwej0Yhhw4bhtttuQ3u7PKE9InRq6jpx7UubcfULm3C0tRcmgwYzw/gi9YdHXvqsjpD7EIiUUYbeZ9kgv8g2pZBhV4gXBfwuHC6MuJlVDr8L4L5DrO8wo88a+54ULbzSSIFmfzqNSgwxTNRmdVa7Q9zNh1smDXhGXsJLHbsjL8GbdTlnuXqlfH2kLawbqP64O+zKE3lRqSSxf649I7jy6P7E89R2OVBUvMyfPx/fffcd1qxZgw8++ACfffYZbrjhBr/rjx8/juPHj+Oxxx7Dzp07sXLlSqxevRrXX3+9kptJ+KC+ow93v/ktLnjyM6yvaYRGJeHameVY/8tzZPE5ZOo14N/HUFNHgfwuQGoOZ2zqVK5BHad/5165Ii/ZaVqYXL154iHErWTaCPAcE5CYpt2jrb2wORiMWjWKwhAOHO55ae+1whbGcEYeeQmmu25/ynLTMDI/HXYHw5f7mkN+fX9E5EUmzwsA3HneWFw5bRguPWVIWK/XqlUozXb+feLheyU38shEH1RXV2P16tXYsmULpk6dCgB46qmnMG/ePDz22GMoLS0d8JoJEybgrbfeEv8eNWoUHnroIVx99dWw2WzQaBTbXMJFt9mGZz87gOc/OyDMYvNOLsZdcytCHnsfCJVKQqZeg44+Gzp6bSgM4To4mHhx93lJvrsNf0QnbdRPvETY44UjSRKG56Vjx7F2HGrqFr6QWNGswFwjT8YUZgKoS9jIy4FGp+gqz0+HKgJDc5ZRC0kCGHMKmLwQj10eTSgKs6/R2WMLcKCpG5/vbcT5E4rDeg8OH8yYFuJ07UBcMW0YrpgW2XsMz01HbUsvDjf34LTyXFm2izEGs80Bg1Y+oRYOikVeNm7ciOzsbCFcAKCqqgoqlQqbNm0K+n3a29thMpn8Chez2YyOjg6vHyJ0bHYHXtt0GLMeXY8/r92LXqsdpw7Lxls3zcAz86fIKlw4WWnhmXYHEy/8jrktzDu6RKQxCuLF872zjFoUh9BbYzC4aTce7hCVGA3giej10pCYkRfhd4kgZQQ4jbO831M4pt1werx4wlNHn+1tjNgT4p4qHdsLen/KxHRp+fxkR1p6MGHZR7j0mQ0x9dIoFsqoq6tDYWGh9y/TaJCbm4u6urqg3qOpqQkPPvhgwFTT8uXL8dvf/jaibU1lGGP4ZHcDlv9nN/a5TqbleWm4+/wKnD+hOKxca7BkGbWoRW/IvV4au1xGPT8X6pw0nbija+2xhmXoSzTEBVcBnwYnzyMSUVGcKeuxEU/l0mIoo8Jpo30NzoojJb9jShDpQEZPctN1aO+1huV7EUMZw/x+nz4yD1q1hNqWXhxq7omocqrbVSodafNOuVFiavv2o+2wOZirNUPsjt2QIy/33HMPJEkK+LN79+6IN6yjowPf+973MH78eNx///1+1y1duhTt7e3ip7a2NuLfnSrsONqOK5//H65/+Svsa+hCTpoWyy4cj//+YhYuOLlE8QMz3C67g0Ve1CpJ9DpJlXJppaMFgLcZuLJEHrMuZ7irUd2hOKg44seMUvuyPN9ZcdRltuF4AlYcydHjhcObsYU6WZoxhvqO8A27AJCu12DqcGcqJdKqI3fkJb6sDUqUS2+vbQMATBqaJdt7hkPIe3rJkiW49tprA64ZOXIkiouL0dDQ4PW4zWZDS0sLiosD5xc7Oztx/vnnIzMzE++88w602oHlsBy9Xg+9PvnvrOXmH1tqcddb3wJwVkD89IwRuGn2KJ+lx0oRbrn0YOIFcEYgmrstKVMuzU/+OQqKl1yPiNY4mfwunHhMG+UqFMXSqlUYkZ+OvQ1d2FPfGfGcsGgjR48XTriTpTt6bbDYnCnhcAy7nNNG5GLjgWZUnwjfbsAYQ7fLsJsmU6m0XLjTRvJ9r7492gbA2ewvloQsXgoKClBQUDDouhkzZqCtrQ1bt27FlClTAACffPIJHA4Hpk+f7vd1HR0dmDt3LvR6Pd5//30YDPLl1Qk3/93l7NlyzrgCPHjJBFl6t4SK6LIbYshYjAYIJF7S9QC6UqZcOhqRF41ahYIMPRo6zRgvc+Sl3NXr5VhrL2x2h2KN9gbD7mBoc0UC8xQy7AJO38vehi7sre/EOeMKB39BnNDlMRFbnshLeJOlecrIZNBEZBzlvVBqW8KfvNxndYBbP+Iu8uK6KWjutqDLbENGhIZim92BncecQm9SWWwjL4qdISorK3H++edj4cKF2Lx5MzZs2IBFixbhiiuuEJVGx44dQ0VFBTZv3gzAKVzOO+88dHd344UXXkBHRwfq6upQV1cHuz32/R+SiVrXHe61Z4yIiXABwhsRwBgTkZdA4WJRLp0CkZc+q12ErZWMvADAg5dMwJ3njcVEmUPGhZl66DUq2BwMx9til0pp7bGICxEv5VWCMXxMQIKVS3/naqdfkmWQZe5TuJOlIzXrcspc3cL56JNw4GXSAGCMcQVOfzINWuHdkqMJ5N6GLvRa7cjQazAyP/KWGZGg6O3Na6+9hoqKCsyZMwfz5s3DmWeeieeee048b7VaUVNTg54e54Hz9ddfY9OmTdixYwdGjx6NkpIS8UNeFvlgjInwPL/ziAWmMNJGnWYb+qzOcHGgyhpRLp0CnhceddGqneXnSjL3pGIs+r8xsvuhVCpJHIux9L3wfZmdplU0+pOo06W/PeoUL3KJ1+wwJ0tHatblDHUdc8faesMe0ijKpHXqiErHlcIdXYo8dcRTRicPyYr5Z1X0TJebm4tVq1b5fb68vNyr1Gr27NlJ2cY43mjqsqDXaockIab59nDmG/GoS6ZeE9DZz+82QjUCJiLC75KmS7jKFU+G56Vhb0NXTGccKV1pxBGN6hKs4ujbY1y8ZMvyfrlisnRo31O3WTcy8VJsMkCrlmC1M9R39KE0jPOh8LvEWaURZ1huGrbVtslSybedi9cYp4wAmm2UkvCoS2mWUZbBeuESTtooGLMu4E4bNaVA2kjpjrDRgs84krMnRahEwzsEOD+rVi2hx2LHsbbw/RbRht95yxV5cU+WDtHz0iFP2kitkoRg4YNnQ0Xu0QByI2e5NK80mhxjsy5A4iUl4eHDstzYVjnwlvDtvbZBVrrh4iV/MPGSnjpddvlda+KLF542il3kpcWVZlR6X/KKIyBxxgS09VjE3fvEIdmyvGdOjNNGADDU5XsJN63SkwCRFyDytFGf1Y6aOmeac2JZdqSbFTEkXlKQePC7AB6l0gpEXvJTaL5RtFIdSjNMgbLOUFF6NIAnY1y+l0QZE8D9LuV5aaI7dqTkhJk2ksuwCwBlroKFSCMv6Qr7zcKFf68iTRt9d7wDNgdDfoYOpVmxrwIm8ZKCJLR44WXSg7TBzxPzjZJfvCRL5IWXSx9p6YmZ940fL0qnjQBgbCEXL4kReXGnjLJle08eeWnrtYZkmHVXHMoYeQmz4qjXGt+RF56OPdbWC2sE41I8+7vEg0eLxEsKckSkjWIrXrhht9NsC/rEFarnpctsQ581ucvsm5PE8zIkxwi1SkKv1S7+ztEmmv4ht2k3sSIvcpbJ8w67jIV2EyMmSssgXvh5MNxyaRF5iVPPC29DYHcwHI/AX+X++2fLtGWRQeIlBamNs8gLAHQGWS4drHjJ1GugVTvvDpI9ddSaJOJFq1ahNNsZjo6V70WMBlBwRhRnjCiX7oIjzDLdaKLExUurViHT5X1rCTJ11GW2odtVnixH2sjteQnvwt4Tp911OZ5tCCLpYM3NuvFQaQSQeEk5zDa76JAZa/GiVatEqDXYiqNgxYskScK025LkqaNkibwA7tSRHA21wsFdbaS856U8Lw06tQq91vivOGro6ENdRx9UEjBhiLzdlXNCHBHAoy7pOnXEHWMBt+flRHt4aRV3tVF8ihcgct9Le69VDOSM9VgADomXFONYay8Yc37x4+FiF2q5dLCeF8CjXDrJG9WJyIsMHU9jjRx3iJEQzbSRRq3CyAJXxVGcp454f48xhZmylwTniJ5MwZ0D5DTrAs6GljqNCg4G1IUxKJNHXuI1bQREPjtsh+vvX5ZrjIvrBkDiJeXw9LvEg+kqlMnSdgcTpc/B5LpTxbSr9CDBaBLLcmmHg4l+I9FIGwHA6MLEGBMgOqsqMEk4Ny20EQENQUZfg0WlkiIql+62xHefF8BjunSY36vtcTKM0RMSLylGvPhdOO6Ko8F7vbR0W+BggCQFd2ecn87nGyVv5MV5wU2myEvsGtW1e1S85ERpX45NkHJpHnmZpIB4CbXXi5xmXU4k5dI9ZlfkJU49L4A78hJuo7p4mSTtCYmXFCNeyqQ5oYwI4H6XvHRdUHNn8lKg10t7rxXc66n0UMZoUJ4vXzfQUOHHSaZBE7XO06LiSIbIS21LDz7f2xjx+/SHMYYdCpRJc9y9XkJMGwUYzBoqkZRL9yRA5MXzpiCcNgTba+WvNIsUEi8phhAvefEiXniX3SDEiyuCEmggoyc8bdSUxJEXXqGRadBAq+AgwWjBRXVbjxXtIbaMj5RojQbwhFcc7WuIrOLI4WC45sXN+MkLm7H1cItcmwfAGY1o7bFCq5ZQUZIp63sDHiMCQoy8FJlkjLzkRhB5sfAmdfEbeSnLNUKSnCmuUG/m6r3M2iReiBhxxFUOGOseL5ysECZLB1tpxMkVaaPkjbzE4oKrJGk6jfj7Hm6JbuqIpxejaUgcnuuuOAq3wysAfLGvCQdd1SBrqxvk2jwAbr9DZYkJeo38F+hQu+y6DbvyiZfIPC/OtJFRG7/iRa9Ro8RlcA7VtMtLpMcUZsZVF2ESLykEY8w91ygnvsRLKGmjYMULHxGQzJOlxUTpJBEvgLOEGIi8nXmoRHM0AEeuiqO/bz4i/v+LfU0Rb5cnvL/LyQrddQvPS6jiRca0ET8fhpU2ivPxAJyyME27/O8/KU76u3BIvKQQrT1WdLnMZfxOI9YoKV5SYThjskVeAI/8fJR9L7Hal27Tbni+l4bOPqzZVS/+veNYe8iDDgPB77yVMmu6xUuQnhcFDLv8fFjfYYbZFlpH7u44H8zIGR7mTcF2Bf1OkUDiJYXgF4NikwGGOAlx8lLpYFqDh9LjBfDs82KJ2awcpRGRlySoNOKIcumm6KaNhHiJcsn5mEJu2g0v8vLPr47C5mCYMjwHY4sywBiwYb880ReHg2HnMZdZU6E775z04D0vfVY7OvqcYkHOyEtuuk6Ij2Mhpu/cnpf4jrwMzwv9poAx5o68kHghYkW8VRoBoQ1nbOx03nGFGnmx2Bwi4pRsJFOPF87wCMs6wyVWnYrFdOkw0kYOB8PrW5wpo6umDcOZowsAAF/slUe8HGjqQrfFDqNWjdEFGbK8Z39yPYYzDmZabuhw3sDoNSph9pcDSZLCLpfuSZDIi0gbheAlO9zcg/ZeK3QaFcYVy2/WjgQSLylEbZwMZPQkK025tJFRp0a664SSrKbdZOquy+F3iAcau2CLYApuqLREca6RJ7xcOpyKoy/2NaG2pRcmgwbfm1iCs8bmAwA+39skS7SRl8hOGGIKqj1BOGS7jl27g6GzL/BNRoPrBqbQpJe9yWY45dJ2B0Of1XmMxnOHXcDdqC6UtBFPGY0vMUWtfUCwxNfWEIrCjVrxFHkJpcNuY2fw3XU5ostuko4ISKa5RpxxRZnITtOiqcuCf249GrXfywVuNA27gFOs6TQq9FkdIRtGuVH3B6cOhUGrxvQRudCpVTjW1itLl2LRWXdIdsTv5Q+dRiVmFA1m2lXCrMsJp1yaR12A+B3MyOERzYZOM3otwfl6uHidXJat1GaFDYmXFMLd4yU+zLqAZ6m0LeCdomeuuyAj+BMXv6g3JWvkpSf5xItRp8Zt/zcGAPDH/+5Bd5RSfrEy7KpVEkYVhD4mwNOoe+W0YQCcpeanDs8GAFka1m2PUqVJtisCO9hkaSXMupxwyqW530WtkqCL8z5LWUatmOAdrEj+Vph146vSCCDxklLEs+fF7mBiRogveKM5nTq0XHeyl0u7owXJI14A4OrTh6M8Lw1NXWY8++l+xX8fYyymQlB02g3B9+Jp1PX0I5w1xul7+TxC34vF5sCuEx0AlK804ft8sMnS9WFEX4NlqCiXDj7ywoV1mk4dF7PiAiFJUkgVRza7AzuP88662UpuWliQeFGYHUfb46JU12Jz4ER7fDWoAwCDViXuWAKljjz9LqGcJJK9XDoZIy+AM5VwzwUVAIDnPj8Q1rTfUOjos8Fqd0b+YiNenOIj2DEBnkZdHnXhnDna6Xv53/7miDxDe+o7YbE5YDJoRO8dpeC+l8EmS3PDrlwTpT3hkZdjIaTuRKVRnPtdOMNdbQgOBzE7bE99F/qsDmTqNRiZn670poUMiReFYIzh9//ZjQv/8gVmP7oeb2w5EtNy3eNtvXAwp1gIttQ4GkiSJCIpgSqOuHjJD/GOS5RLJ2HaqM9qFyfPZBMvADD3pGJMHZ6DPqsDj/23RtHfxcVtuk4dkzYC7unSwUVePI26359Y4vXchCFZyE7TotNsE4bLcOAlshOHZiseVeCTpQeLvAjDrgKRF35T19Rl8fKyBEJEXuLc78LhY2GCSY15ThJXqeIvqkTiRQFsdgd++ea3WOEKd3eabbj7rR245sXNOBpGB0c58EwZxVt4M5jhjKH2eOG4DbuRixe7g+GVjYfC7schNzwVplVLwvCYTEiShF9/rxIA8NbXR/GdK4StBLEuOR/rMePIHkTFUX+jridqlYQzRjmjL5/tCT915HnxUhp35CXw91SY9hWIvHh6QoLt9dJjTazIC7cMBNOGgAvfSXFo1gVIvMhOr8WOG1/dije3HoVKApb/4GT8el4l9BoVPt/bhLmPf4ZX/3c4oiFs4RCPfhdOMF12Qy2T5nDPixxpo4+r63Hfe9/h3nd3RvxectDiUWkUb4JULk4ZloMLJ5WCMeDhD6sVi17GYjSAJ8Ny06DXqGC2OQa9K/Zl1O3PmWOc4iWSUQHCrBsF8ZIb5HyjBgU9L0DoYwL4aIB47/HCGR7CiABeaRSNv384kHiRkbYeC65+YRPW7m6AXqPCsz+ZiiunDcPCs0di9R1nY1p5Lrotdvzm3Z246m//CyrvKBfx2OOFE0y5dLgnLbfnJfLIC+80GmxoX2mSsbuuL+6aOw46tQob9jVjfU3kFTS+4PsyP0bpN++Ko8DHlz+jrifc97Ktti2ooaf96bXYxXZEw6zpniztf1stNof4OykmXnJ5xVFwkZdEGQ3AEWmj1p6AEb5eix01Ufz7hwOJF5k43taLy1ZsxNbDrTAZNPh/P5uOc8cXiedH5Kfj9RtOx28vOglpOjX+d6AFc5/4DC98cTCoMHGkJELkJRjPS6iRFzFZWoa0UfUJ55e5tccq6+yYcIlVO/toU5abhuvOKAcAPPRhtSKN61rioF+Ou+LIv2k3kFHXk7LcNIzIT4fdwfC//c0hb8uuEx2wOxjyM/QoyZI/RdMfPlg0UKk0Tx1r1ZJign2o6LIbbOSFe14SI21UkmWEVi3Bameo6/Bvgt91oh12B0NBZnT+/uFA4kUG9jV04od//RJ7G7pQbDLgnz+fidPKcwesU6kkLJhZjo/uOBszR+Whz+rAgx/swo+f3Yj9jeENZQuWVBUv7lJpc8Sput11HeL/D0YxauaPVIm8AMDN54xGTpoW+xq68MZXtbK/vyg5j6EQHCMqjvxHXrhRN9OgwfdOLvG7DnBHX8JJHXG/y6ShWVFJSfJjOJBhl/d4KcjQK2YgLcsJNfLCPS+JEXlRqyQh0AJF/j1TRvGakibxEiFbD7fiRys24kR7H0YWpOOtm2cOOgOiLDcNr/1sOh6+9GRk6DXYergVFzz5OVZ8ul+Ru0rGWFx21+XwaiMlPC/8js7BnLNTwqWzz+rVefNgY/yIl2SaKO2PLKMWt89xNq57fM0edIaRCgmEGA0Q08jL4NOluVH3h6cOhXGQCyb3vYTT74VXGkXDrAu4xUugUmmeOi5QwKzLEZGXtiAjLyJtlBiRF8B9DQjke4nXSdKekHiJgE9212P+3/6Hth4rJpdl482fz8SQ7OC610qShKumD8NHvzgbZ48tgMXmwO//sxs//OuXqKmT11PR3mtFpyu8yb+c8YRnl11fMMbCrjbSqlWie2ckpt3+PoQDTcpGyoKBh9hzUkC8AMBV04djRH46mrosePbTA7K+d6wNu4B7uvT+Rt8VR55G3SumlQ36fjNG5UGtknCwqTvkKkdRaRKlixefLN3W438CvNJmXcDtCQw28uKeKJ0YkRcguMGnYpJ0nFYaASRewuatrUex8JWt6LM6MHtcAVYtnB5WvnxIthEvX3caHv3RRJgMGmw/2o7vP/U5Vu88Idu28pRRYaZ+0Lu1WDBYtVFHnw0WmzMiFWrkBXDfTUfS64X7XTgHm+Ig8tKVOpEXwLtx3fOfH8DxttCm/wYiHqJYZR4VR0d8XFi4UffUYdmoKDYN+n4mg1bMpAllynRHnxUHXJHFaLWF55EXm4OJG63+KDkagMMb1bX3WoMyOrurjRIw8uJHvLT3WMX5beKQ+Kw0Aki8hMWzn+7Hkn9uh93B8INThuD5a6ZGdPBKkoTLppZhzeJZOGdcAax2hr/KeGcZz34XYHDxwlNGmQZNWA3E5BjOyP0u41yh/QPxkDZKscgLAJw3vgjTynNhtsnbuC4exiyoVZLfZnXBGnX7w30vn4fge9npuusekm0U3x2lMWjVMLq+221+Uke8u26RgmmjdL1GHANHg4i+8GqjRPG8AIOnjb491gbAGaGJ53MLiZcQcDgYHvr3Liz/z24AwA1nj8Rjl02CVqaBXEUmA5ZdeBIAoPp4h4g2REq8i5fBSqXD9btw3L1ewo+87HZFXi44uRgAcKi5O+q9evoTDxUy0cazcd3bXx8T5euRwBiLm3051o9pd8N+t1H3+xNLg36/s1y+lw37moKuavz2WHSGMfYnd5CKIyW763oiTLtBpNp42iiRIi/D8wKPCPDsrBzPKCpeWlpaMH/+fJhMJmRnZ+P6669HV1dwXgHGGC644AJIkoR3331Xyc0MCqvdgSX/3I7nPz8IAPjVvAr8al6l7K734XlpyDJqYbE7ZPO+xHOPF8DdYddftVG4fhdOpOXSjDHxtzh3fBE0Kgl9VkfAUsNo0BonF9xoM6ksGxdPdl7Af/fvXRE3rusy22BxGeVjXXY+psj3dOlVm1wddU8ZElLqd1JZNjL0GrT1WIPuUCw66w7JDvr3yAH3pvlrVCc8LyZlxYu7XDqIyEuCjQcA3L1sOvpsaO8ZeM7dVtsGIH6b03EUFS/z58/Hd999hzVr1uCDDz7AZ599hhtuuCGo1z7xxBNxVaK1troe73xzDBqVhD/9eBJuOHuUIr9HkiSRZ94WwVwST+I98hJs2ijcyEukwxmPtfWi02yDVi1hbFGmaPQUS9+LwxHbKcix5pdzx0GnUeF/B1qwtrohovfiUReDVhXzO+ixha7Ii0evF6+OutODTxkBTsP6jFF5AIKvOopVZ1XRZdfPTYbbsKts35GholFd8JGXRBkPADijRPxcerhl4Dns2zgfC8BRTLxUV1dj9erV+Nvf/obp06fjzDPPxFNPPYXXX38dx48fD/jabdu24Y9//CNefPFFpTYvZM6fUILb54zB8wum4genDlX0d3GH/7cuBRwpQrwoPBk2XHjkxWxzoM81K8STWKeNeMpodGEmtGqVmLB6QOHePIFo77WCZwFSoc9Lf4bmpOGnZ4wAADz8n2pYI2gx0CzMurEfWMojL54VR29uDc2o2x+eOgrGtNvcZcYxlxF6QpTFCz+OW31EA2x2B5q6lK82AkKMvCRYh10OHxNwuJ/vpa69D/UdZqgk4KTS0I+1aKKYeNm4cSOys7MxdepU8VhVVRVUKhU2bdrk93U9PT246qqr8PTTT6O4uHjQ32M2m9HR0eH1oxS/OHcszhlXqNj7c7ji5bnHSLDaHTje5kxvxGvkJVOvAQ+y+XL4Rxx5idCwy826Fa7+PSO4eIlh5IVfcE0GjWyeq0Tj5nNGITddhwON3Xjd1f8kHETVVhx0Ki7LSYNBq4LF5sBhl6/q9c3OpnyhGHU94abdrYdb0WsZeHPgCT/njCxIF160aOEeETDwJqO52wLGAJUExU3E3PMSTHl5ryiVTpzIC+C+ke1fccRL5McWZcY8CjkYip316urqUFjofaHXaDTIzc1FXV2d39f94he/wMyZM3HxxRcH9XuWL1+OrKws8VNWNnj/g3iHh2v3NnSKnGq4nGjrg93BoNeowvaMKI1KJYkTpS/fS6SeF17+Gm7kpdrld3GLF+fdcSzTRqmcMuKYDFrcUeVqXPfx3rBm+ADxZXxWeVUcdWHD/iYcaekJ2ajryYj8dAzJNsJid2DTwcCjAoRZMwYlsjkBhjPySqP8DD3UCnXX5XhGXgbzUwnPS4JFXvxVHH0b5f4+kRCyeLnnnnsgSVLAn927d4e1Me+//z4++eQTPPHEE0G/ZunSpWhvbxc/tbXytw6PNoUmA4pNBjgYIq6mOOJh1lWqpbYcBPK9yBV5aQrT87L7hCvyUuIMo/LISyzFSzyU9sYDV04bhpEF6WjptuCv6/eH9R7NcSReAA/fS31n2EZdTyRJEqmjwXwv38aws6o7beRDvPBKI4XNuoC710uX2YY2HyksDmMsIauNAM9Gdd7nMO53mhjlSrNwCFm8LFmyBNXV1QF/Ro4cieLiYjQ0eBvpbDYbWlpa/KaDPvnkE+zfvx/Z2dnQaDTQaJwHxA9/+EPMnj3b52v0ej1MJpPXTzLAyxQjTR3Fu1mXE2hEQOSGXedJ0bPZXbD0We1CpFS6Ii+jCpzipbalR7Zy9lChyIsTrVqFpRc4S6df+OKg8GuEQjyMBvCEzzj6cn9z2Ebd/pwZhO+FMYbtR2NTJg14RF589HmJllkXcPac4eeaQOXSFrsDNpcvKZGqjQBgWK7zHOYZeWGMJVTkJWS5WFBQgIKCgkHXzZgxA21tbdi6dSumTJkCwClOHA4Hpk+f7vM199xzD372s595PXbyySfj8ccfx4UXXhjqpiY0E4dm46Pv6iOuOEoU8eIezuidJrM7mLi4hCtesoxaqFUS7K4KnVCaXO1r6IKDOUUC//0FmXqk69TotthxpKVHhPmjSTylOmJNVWUhpo/IxaaDLfjDf3bjz1eeEtLr42E0gCd8uvTGA84UzylhGnU9OWNUPiQJqKnvRENHHwp9fAdOtPehqcsMtUrC+JIYiJcApdL1Ueiu60lZjhGNnWYcbe31G4Xi3XUBIC2M5pmxhF8PTnT0wWyzQ69R41BzDzr6bNBrVIPO54sHFPO8VFZW4vzzz8fChQuxefNmbNiwAYsWLcIVV1yB0lJn7vbYsWOoqKjA5s2bAQDFxcWYMGGC1w8ADBs2DCNGjFBqU+MSUXEUoXiJ9x4vHH9po+ZuMxzcqBfmxUWlksRFPtTUUfUJd2ddXrovSRJGFMS24khMlCbxAkmScO/3xkOSgPe3H8eGEKcoN8fZmAXeqI5zVZhGXU9y0nWYUOoUJP6mTH/rYdaMxRiRwGkj3uNF+cgL4DnjyH/khVca6TUqaBLMNJ+foUOaTg3G3FVV213VrSeVmhKiCEDRLXzttddQUVGBOXPmYN68eTjzzDPx3HPPieetVitqamrQ0xPa0LBUgE9zrW3pFReqcEiUyIu/Lrs8ZZSbHplRL1zT7m5u1i3xvqDE2rQbD7N44omTh2bhJ6cPBwD8+p0dPkvu/RFvUawh2UbRKj8So25/BpsyHUuzLuCdNupvlOWG3WhFXoaKiiP/achErTQCnIK/v2k3ESZJe6KoeMnNzcWqVavQ2dmJ9vZ2vPjii8jIcIfYy8vLwRjz62cBnHm4Sy65RMnNjEuyjFrRT2R7BNGXRBEvWX667Ebqd+Hkh1kuzcukK/uF7WNt2hWRlxTs8eKPO+eOQ5FJj0PNPXh63b6gXyfESxyUSgPeFUeXRmDU7Y/o97KvyWcVjRAvMTJr5rqOZYvdIYywnMYojQbglLkqjgJ5XrqFWTexUkYcYdp1jQngkZdY+J3CIf5jQykM77T7bW14pt32HquIZPCW0PGKyU/aSC7xkhdmo7oaP5EXbtqNVa8XEXmJkwtuPGAyaHG/azbYik/3D5gP5A8uaPPjxPMCAAvPHonTR+bi57Pk6+Q9ZXgOjFo1GjvNqOm3b+LBrGnUqaHXOC9J/aPN0U4bBdOorsfMhzImXuQF8Jwu3Qur3YHvjjtv1BLBrAuQeIlr3M3q2sJ6Pb9ryM/Qx30pnz/PS6Q9XjjcL9MUgnhp7DSjqcsClQSMKeyfNqLISzxy/oRizKkohNXO8Kt3dgw6PLPHYkOf1VkxFi+RFwC4aFIpXr9hBkqz5bvp0GvUmDYiF8DAqiNu1tTF2KzJU3eeJcoOBxM3MVGLvOS6G9X56/XCIy+x8AfJwTDXgMYjLd3YU98Js82BTIMG5a7H4x0SL3EMzz1uP9oe1vA5d8oovqMugMdwxj6lIy/Bp414yqg8L33ACarcJV4aO83oDLM5WiS0xFFL+3hCkiQ8cMkEpOnU2HKoFf/cGrjvE4/E6TQqpCfoRSgU/PV74TdI40tia9bMThs4WbqlxyJKkiM9DwRLSZYRkgT0WR3iBqo/PS7DbnqClUlzPEcEuOdZZcd1PzBPSLzEMSeVmqBRSWjqMuN4e+gTjBPF7wJ4Rl68S6VlEy+uO7pQzM98plH/lBHgTFFwH82hpugaznstdvS6DKk56dFt4Z4IDMk2YvG5YwEAD3+4O2CFmafxOZ4GwSrFWWOcbS42HWz2MjWL5mQxniSc6zqe2zzECzfr5qXroiasdBoVSlwpKn+po25zYjao47jTRj3C7xLrv38okHiJYwxatSibDGdIYyKKF6UMu6LLbgjipVrMNPLdY0MMaGyKbrk0vyvVqVXISMBKh2hw7cxynFRqQnuvFb/7YJffdfFWaaQ0Y4syUJipR5/Vga8Pt4rHdxxrAxD7ShMRefH4nvLuutGKunCGDlIuLSIvCRqxG5JjhFolwWxz4JMaZ0PZWP/9Q4HES5zDfS/bw+i0myg9XgDngEFAQc9LOGmjE94zjfojBjQ2Rtf30ip6vGhTIloQDhq1Cst/cDJUEvDutuP4fG+jz3XxNhpAaSRJEoMaP3f1e7HZHdh5jJs1Yxx58TFZOtpmXc5g5dJiNECC3kBo1SqUZjv3Kb9JnOy63iQCJF7iHH4y2Z4ikZcusw02u7vlvmyl0i5vSLDVRja7A/sanBGVyhI/kZeC2Jh2460jbLwycWg2rplRDgC4992dPnu/cDGbSv1y+o8K2NfYhV6rHek6NUYWRL9btCe+Jks3RLm7LqdMVBz5jrx0J3jkBQCG57rNuYWZehRnRVcgRgKJlziHh/F2HmsftHLCE5vdgWOuOwY+/jye4YZdAOjsc54U+qx28f9yGXZ7rXYR7g3EwaZuWOwOpOvUGOKn4iNWFUetQryQ32Uwlpw3FsUmAw439+CpT/YOeL4lBYUgj7zsPN6Olm6LaMUwYUiW4hObB4M3qvM07PLIS1EUhjJ6wiMvtS1+Ii9mXm2UmJEXwDsqn0gpI4DES9wztigDBq0KnWZbSD1FTrT3weZg0KlVKIrCMLNI0apVotkTTx3xqItOoxJppXBJ06lh0DoP92CiL9Wu/i7jijP9uu89Iy/hVIOFC0VegifToMVvL3b2fnn20wPY06+/SXMK9sspNBlQUZwJxoAN+5o8OqvG3qzJS/99GXajMZTRE35hT+rIi8eN7eQEaU7HIfES52jUKjGTJJTUEfe7DM01JkzpW1a/cukGj94OkXo7JEny6PUyuO9lt2umUYWflBHgPLmpJGeqy185pRKIyEsaRV6CYe5JxTh3fBFsDoZfve3d+yXVDLscHn35Ym8TdhzjlUbZMdwiJyLy0u3peYlN2ohHXo619cLuI+rNIy+J6nkB3OXSQHz8/UOBxEsCMDGMIY2J5Hfh9G9UJ5ffhcPvroMpl+YzjSoDNOzSa9SiE2c0TbsUeQmd3150EtJ1anx1uBWvb3H3fmlO0RlR3Pfy6Z5GMXw0Hjqrcs9Lm4+0UWGU00YlWUZoVBKsdiYElCfJEHnxThtR5IWQGT5rIpSKo0QUL/1HBMhVacQJZTijeyyA/8gLEBvfC3leQqc024gl540DAPz+P9XiYtTiGg2QSmkjAJg+Ig86tQp1HX2w2hly0rRxMUIkp1+pNGPMIwIb3bSRWiWJDse+fC+9lsTu8wI4KymrKotwzYzhokw9USDxkgDwO6JdxztgsTkCL3aRkOLFoHTkhfd6CZziae+14lib82TF++z4IxYVR6loMpWDBTPLcfKQLHT02fC7D6oBAC1dqbkvjTo1ppbniH+fPDQ7LsruedrIbHOg12JHe69VnPOi3ecF8CyXHuh76RZTpRM38qJRq/C3BVPxwMUTYr0pIUPiJQEYnpeGLKMWFrtDRAQGI5F6vHDcjeqc4Vil0kaDRV74Ph6SbRTb5I+RMej1wisxqLtuaKhVEh6+1Nn75f3tx/Hf7+rEBSjVPC+AO3UEABOHxEfKIF2nhs7VRbelxyKiLllGLQza6IsEMV3aR+SFVy0mcuQlkSHxkgBIkiTykduD9L0kYuRFac+Lu9dL4MjLbtFZd/ABdSPynX0xDkaxyy7NNQqfk4dm4dqZIwAA97y9AwCgVUsRV7MlImeNLhD/Hy9+B0mSkO3R68VdaRSbY12US/uKvIjxAIkbeUlkSLwkCDx1FEzFUUefVXSoTKTIi8no3WVXds8Lj7wMYtitDjDTqD8jCvhk1h6v5npKYXcwYWakyEt4LDlvLEqzDF6TueMhZRJtTio1oTwvDZl6DaYMzxn8BVGCR8FaeyzuSqMom3U5gcql3eMBUk/4xgMkXhIEfmf0bRCmXZ4yykvXJdTsm/6l0k0yR15ygzTs1gwy08iTEpMBeo0KVjvz20ZcTtp7reBVmzkJZrCLF9L1GvzWI8efiikjAFCpJLx500z8546zhB8sHhCRlx5rzMy6HH+N6hwO5jEegCIvsYDES4LAZ07sbehEtzlwh1j+RUukqAvgPZyRMSZ/2sh1gm4OYNh1OJi70iiItJFKJUW14ohHC0wGTdQm7CYj544vwtyTigDExggaL+Rn6EW5f7wgIi/dFtR3xEfkpa6jzyuy2usxaoIiL7GBzn4JQqHJgGKTAQ7mHBUQiNoE9LsA3p6Xjl4bLK6TRb7caaMui9+OuEdbe9FtsUOnVglRMhi84iiUDsjhIvwucXSnnKg8dOnJuOK0Miw6Z3SsN4XwICfNM20U28hLQYYeOo0KdgfDiXZ3rxcedZEkiM7dRHShvZ5ABJs6SkSzLuDd56Wxy3miMBk0slUZ8Ds6m4OJiqb+VLtSRmOKMqAJMrLhjrwob9p1+zTI7xIp+Rl6/P6HEzF9ZF6sN4XwQIiXbgsaY2zYVakkDM0eaNr19Lukol8qHiDxkkBMcqWOBqs4SlTx4pk2apA5ZQQ4O+JmuqpK/PV62c3NukH4XTjuiqPoRV5SrS8JkTrkCMOuNWajATwZyk27Hr6XbjGUkfwusYLESwIhKo4GES+J2OMF8DTs2mT3u3CE78WPabem3hl5qQyi0ogjIi9R6PXS2kPddYnkJkcYdj3SRqbYDZf1VS7dkwSjARIdEi8JxMmutFFtS6/f+Tx2h7vqZVheYokX3mHX7mAiilEgc67bPSIgcORlXBBmXQ5vVHe8vU+c1JSiOUU7whKpA4+81Lb0CG9JLCMvvFGdZzVhdxKMBkh0SLwkEFlGrbhQ+hvSWN/RB4vdAa1aQnEM71bCwaBVie6a+11RDLl6vHBEubQP8ddrseNgs/P3hpI2yknXifLOQ00D+0HICUVeiGSHe14OuyLIGXoN0mPY8sFdLu0ReXFVfCbyaIBEh8RLgiE67db6Nu1yv8vQnDSoVYllJJMkSZh29zU4za9yp43yAqSN9tR3gjEgP0MX8u8dGaVyaZooTSQ7uS7xwgsCYxl1ATwb1bkjLz0UeYk5JF4SjIku34u/yMuRBPW7cLJcXXYPNCojXvJFl92BaaPdITSn60+0xgTQRGki2cnud2zHug8Pj7zUd/bBbHOKFuF5ochLzCDxkmBMKuMzjtp99ipx93iJ/Xj7cOCRF7NCk2TzAnTZFWMBQvC7cKLV64WqjYhkJ1OvgcYjahxLsy7gPGcYtWowBhxvc1Y/kecl9pB4STBOKs2CWiWhqcvs1TSJk6hl0pz+U5zl9rzwtFGTD8Mu76wbilmXE60uu0K80GgAIklxDmd0H99FMY68SJKEslxv3wv3vNBQxthB4iXBMGjVGFfkvLj6GtKYdOJFds+Lb8MuY0ykjSpLwkkbKS9eei120ZY8N4PEC5G8eKZFYzUawBM+QoGXS1PkJfaQeElAPFNH/UnUHi8cXi4NACpJ/qF57j4v3pGXhk4zWnusUEnA6MKMkN+Xi5e2HqvfMvZIaXFVGunUKuovQSQ1npGXWI0G8KTM5Xvhpl3q8xJ7SLwkIJP8mHa7zTY0ubwciSpePCMveRl62SumuBhq67V6DVqrPuGMuowsyAhrHIFBq8YQVxtxpUy7LaLHi45akhNJTa6XeImjyIvr5pB32E2LYQl3qkPiJQHhFUc7jrbD4XCbdnlIMydN6xXBSCQ8xYvcfhfA2UNCkpxlmK09VvH47hAmSfuDR18OKNRpl0decmSORhFEvJETZ2kj7nlxR16c4oUiL7GDxEsCMrYoAwatCp1mm1d1y5HmxPa7AIDJ6L6TUaJEUq2SxF2dZ7l0jYziRSnfS4tre/NIvBBJTo5n5CUOmm0OFV12XYZdV9qIIi+xQzHx0tLSgvnz58NkMiE7OxvXX389uroGD6dv3LgR//d//4f09HSYTCacffbZ6O3tHfR1qYRGrcKEUj5huk08nug9XoB+kReFwsXCtOtRLs3TRuH0eOEoL16ckSKKvBDJDhcvBq0KmXEgEPiIgKYuC3otdrdhV6aJ90ToKCZe5s+fj++++w5r1qzBBx98gM8++ww33HBDwNds3LgR559/Ps477zxs3rwZW7ZswaJFi6BSUYCoPzx15FlxVJvglUaAu88LoKB4Sfcul7bYHNjvaopXEcJAxv6MKKDIC0HIARfohZmGuPB3mYwaIaKOtva4S6WpSV3MUETSVldXY/Xq1diyZQumTp0KAHjqqacwb948PPbYYygtLfX5ul/84he47bbbcM8994jHxo0bF/B3mc1mmM3u8H9HR4cMnyD+8VVxlOhl0oDynhdgYOTlQFMXrHaGTL1GmG7DYZTostsNh4NBJbPZWEReqMcLkeTwKOaYMCr/lECSJAzNTUP1iQ7UtvZ4eF5iHxVKVRQJaWzcuBHZ2dlCuABAVVUVVCoVNm3a5PM1DQ0N2LRpEwoLCzFz5kwUFRVh1qxZ+OKLLwL+ruXLlyMrK0v8lJWVyfpZ4hVecbTrRAcsrm60ySBePI3GykVevD0vfJJ0RUlmRHd5Q3KM0KolmG0OHG+XP9XJIy/U44VIdk4dlo03bjgdj142KdabIvAsl+6m8QAxRxHxUldXh8LCQq/HNBoNcnNzUVdX5/M1Bw4cAADcf//9WLhwIVavXo1TTz0Vc+bMwd69e/3+rqVLl6K9vV381NbWyvdB4pjheWnIMmphsTlQU9cJh4Oh1uWET2jPS1o0PC/O9+X9WHZH0FnXE7VKwvA85VJHra7IC3XXJZIdSZIwfWSe7H2eIsGzXJoGM8aekMTLPffcA0mSAv7s3r07rA1xOJzRgxtvvBHXXXcdTjnlFDz++OMYN24cXnzxRb+v0+v1MJlMXj+pgCRJ7gnTR9vQ0GmGxeaARiWhJCv27vxwydBpRG8XpQ27vCdOJAMZ+6OkaZdHinJoKCNBRB1eLn2wqUdEuyltFDtC2vNLlizBtddeG3DNyJEjUVxcjIaGBq/HbTYbWlpaUFxc7PN1JSUlAIDx48d7PV5ZWYkjR46Espkpw6Sh2fh8bxO+PdqGsa6RAUNyjNCoE9fgrFJJWHjWSBxv68UIVxRDbrhhl3fZ5WmjygjMupyRCvZ64X1p8mgoI0FEHR552VPfKR4zUp+XmBGSeCkoKEBBQcGg62bMmIG2tjZs3boVU6ZMAQB88skncDgcmD59us/XlJeXo7S0FDU1NV6P79mzBxdccEEom5kyiMhLbTumjcgDkNh+F849F1Qo+v75HvONWrstqOtwDrjkAjASlIq82B0MraJJHUVeCCLa8MgL9xZq1RJ0msS9UUx0FNnzlZWVOP/887Fw4UJs3rwZGzZswKJFi3DFFVeISqNjx46hoqICmzdvBuBMg/zyl7/En//8Z7z55pvYt28ffvOb32D37t24/vrrldjMhGdSWTYAYG9DJ2pcqY9E9rtEizwx38gi/C5luUZkytCVeGSBszrigMwjAtp7rWCuZspUbUQQ0YdHXjjkd4ktiu391157DYsWLcKcOXOgUqnwwx/+EH/+85/F81arFTU1Nejp6RGP3XHHHejr68MvfvELtLS0YNKkSVizZg1GjRql1GYmNEUmA4pNBtR19OHDHU4jdDJEXpSGe166zDZsdzX5G1ckj1eKR16OtvbCbLNDr5EnrMwrjUwGDbQJnBYkiEQlQ69BTppWpG9pNEBsUUy85ObmYtWqVX6fLy8vB2NswOP33HOPV58XIjATh2ahblcfjrU5K41IvAxOpl4DrVqC1c6wYV8TAHn8LoAzJZWp16DTbMOR5h6MkSEVBbh7vOQp1PuGIIjBKctNQ2uPs7cWjQaILXQLl+Dw1BGHxMvgSJIkTK9bDrUAkKfSiL8377R7QEbfC4+85KSR34UgYsXQHHcTS4q8xBYSLwkOb1bHIc9LcPDUUZ/VWfIYyViA/ihh2uWRl1yqNCKImFHm4Xshz0tsIfGS4JzsqjgCnH4Iz/b6hH880y96jQrlMpZlC/EiY7m06K5LlUYEETM8Iy9pFHmJKSReEpwso1ZcLIflUdQlWPI9OneOLcoUjfHkgFccUeSFIJKLoR6RbfK8xBYSL0nAJFf0hfwuwZPnMR+oIsKxAP0RjepkLJemyAtBxJ4y8rzEDSRekoDzJxRDJQFnjRm8gSDhxDNtVFEi70iJcpd4aeqyoL3XKst7tvRQ5IUgYs1Q8rzEDSRekoDzJ5Rg1wPn48ppw2K9KQmD58C3SpkjLxl6DQpdc5kOyZQ6osgLQcQeg1aNfNeND02Uji0kXpIEg5a+SKGQ75E2inSatC/krjhqJc8LQcQFfEwARV5iC4kXIiUpzXaegEqyDIo0fhspc68XPlE6l0YDEERMqXSlmUuzDTHektSGpCORkowrysRDl06QZRijL0bmy1dx1Guxi340uRkkXggiltw9twJzKgpx9ljyGMYSEi9ESiJJEuZPH67Y+/O00YHGyCuOeNRFp1ZRhQNBxJisNC3mVBbFejNSHkobEYQC8BEBB5u6fc7wCgW330UHSZKvHw1BEESiQuKFIBSgLCcNapWEHosdDZ3miN6LR15y0illRBAEAZB4IQhF0GlUoqHVgQjHBLT2WAAAeSReCIIgAJB4IQjFkGtMQHOXU7xQ5IUgCMIJiReCUAh3r5fITLsUeSEIgvCGxAtBKIS74iiyyEtLtyvyQj1eCIIgAJB4IQjFGClTl10uXqjHC0EQhBMSLwShELxc+khLD6x2R9jvI8QLRV4IgiAAkHghCMUoyjTAqFXD5mA42tob9vsI8UKeF4IgCAAkXghCMVQqSRbTLokXgiAIb0i8EISC8NRRuKZdu4OhrdfdYZcgCIIg8UIQisJNu/vDnHHU1mMBny6QnaaVa7MIgiASGhIvBKEgE4ZkAQA27GsOa8YR7/GSZdRCq6avK0EQBEDihSAU5czR+dCpVTjS0hNW9IV316WUEUEQhBsSLwShIOl6DWaMygMAfFzdEPLreeSFxAtBEIQbEi8EoTBVlYUAgLXV9SG/tpm66xIEQQyAxAtBKMw5FU7xsvVwK1pdYiRY+Hqaa0QQBOGGxAtBKMzQnDRUFGfCwYD1e0JLHYnIC4kXgiAIAYkXgogCVZVFAEL3vVDkhSAIYiAkXggiCsxx+V4+q2mExRb8nCOKvBAEQQyExAtBRIFJQ7ORn6FDp9mGrw61BP06Xm1EkReCIAg3iomXlpYWzJ8/HyaTCdnZ2bj++uvR1RW4z0VdXR1+8pOfoLi4GOnp6Tj11FPx1ltvKbWJBBE1VCoJ54xzRl9CSR21dFHkhSAIoj+KiZf58+fju+++w5o1a/DBBx/gs88+ww033BDwNddccw1qamrw/vvvY8eOHfjBD36AH//4x/jmm2+U2kyCiBpzXL6Xtbvrg+6220KRF4IgiAEoIl6qq6uxevVq/O1vf8P06dNx5pln4qmnnsLrr7+O48eP+33dl19+iVtvvRXTpk3DyJEjce+99yI7Oxtbt25VYjMJIqqcNcbZbfdwcw/2BzGoscdiQ5/V6Y+hyAtBEIQbRcTLxo0bkZ2djalTp4rHqqqqoFKpsGnTJr+vmzlzJt544w20tLTA4XDg9ddfR19fH2bPnu33NWazGR0dHV4/BBGPpOs1ON3VbTeYhnUtLrOuTqNCuk6t6LYRBEEkEoqIl7q6OhQWFno9ptFokJubi7q6Or+v+8c//gGr1Yq8vDzo9XrceOONeOeddzB69Gi/r1m+fDmysrLET1lZmWyfgyDkxt1td3DfCxcvuWk6SJKk6HYRBEEkEiGJl3vuuQeSJAX82b17d9gb85vf/AZtbW34+OOP8dVXX2Hx4sX48Y9/jB07dvh9zdKlS9He3i5+amtrw/79BKE0/+fqtvvV4ZZBu+0K8UIpI4IgCC80oSxesmQJrr322oBrRo4cieLiYjQ0eN9Z2mw2tLS0oLi42Ofr9u/fj7/85S/YuXMnTjrpJADApEmT8Pnnn+Ppp5/GihUrfL5Or9dDr9eH8jEIImbwbru76zrx6Z5GXHLKEL9rSbwQBEH4JiTxUlBQgIKCgkHXzZgxA21tbdi6dSumTJkCAPjkk0/gcDgwffp0n6/p6ekBAKhU3sEgtVoNhyP4pl4EEe/MqSzE7rpOfFxdT+KFIAgiDBTxvFRWVuL888/HwoULsXnzZmzYsAGLFi3CFVdcgdLSUgDAsWPHUFFRgc2bNwMAKioqMHr0aNx4443YvHkz9u/fjz/+8Y9Ys2YNLrnkEiU2kyBiAi+Z/nRPI6x2/8KcxAtBEIRvFOvz8tprr6GiogJz5szBvHnzcOaZZ+K5554Tz1utVtTU1IiIi1arxYcffoiCggJceOGFmDhxIl555RW8/PLLmDdvnlKbSRBRZ9LQbOSl69DZZ8OWg/677fLuuiReCIIgvAkpbRQKubm5WLVqld/ny8vLBzTqGjNmDHXUJZIetUrCORWFeHPrUazd3YCZo/N9rmum7roEQRA+odlGBBED3CXT/rvt0lwjgiAI35B4IYgYcOaYAujUKhwK0G1XTJROI/FCEAThCYkXgogBGXoNpo/MBeC/2y7vA5OXQeKFIAjCExIvBBEjqsSgxoHddu0OhrZeKwCKvBAEQfSHxAtBxAjebXfr4Va09Xh3223rsYBbYXLStNHeNIIgiLiGxAtBxIiy3DSMK8qE3cGwvqbR6zne4yXLqIVGTV9TgiAIT+isSBAxZA6vOuqXOuLihSqNCIIgBkLihSBiCO+2u76mwavbLhcv1OOFIAhiICReCCKGTC7z6LZ7yN1tt4W66xIEQfiFxAtBxBC1SsLscbxhnTt11OLqrptLlUYEQRADIPFCEDGGd9v9xMP3IiIv1OOFIAhiACReCCLGnDXW2W33YFM39jd2AfCYKE2RF4IgiAGQeCGIGOOr264QL+R5IQiCGACJF4KIA+a4GtZ97PK9kHghCILwD4kXgogDeMk077bbSuKFIAjCLyReCCIO8Oy2++meRjFRmsQLQRDEQEi8EESc8H+uqqN/bT8Os83ZsI7EC0EQxEBIvBBEnMBLpte55hzpNCqk6dSx3CSCIIi4hMQLQcQJk8tykJuug93hHCedl66DJEkx3iqCIIj4g8QLQcQJapWEc1zddgEgh3q8EARB+ITEC0HEEXzKNADkUXddgiAIn5B4IYg44qwx+dCqnakiirwQBEH4hsQLQcQRmQYtTh+ZB4AqjQiCIPyhifUGEAThzU2zRuFoay++N7Ek1ptCEAQRl0iMMRbrjZCTjo4OZGVlob29HSaTKdabQxAEQRBEEIRy/aa0EUEQBEEQCQWJF4IgCIIgEgoSLwRBEARBJBQkXgiCIAiCSChIvBAEQRAEkVCQeCEIgiAIIqEg8UIQBEEQREJB4oUgCIIgiIRCMfHy0EMPYebMmUhLS0N2dnZQr2GM4b777kNJSQmMRiOqqqqwd+9epTaRIAiCIIgERDHxYrFYcNlll+Gmm24K+jWPPPII/vznP2PFihXYtGkT0tPTMXfuXPT19Sm1mQRBEARBJBiKjwdYuXIl7rjjDrS1tQVcxxhDaWkplixZgjvvvBMA0N7ejqKiIqxcuRJXXHGFz9eZzWaYzWbx746ODpSVldF4AIIgCIJIIBJyPMDBgwdRV1eHqqoq8VhWVhamT5+OjRs3+n3d8uXLkZWVJX7KysqisbkEQRAEQcSIuBEvdXV1AICioiKvx4uKisRzvli6dCna29vFT21traLbSRAEQRBEbAlJvNxzzz2QJCngz+7du5XaVp/o9XqYTCavH4IgCIIgkhdNKIuXLFmCa6+9NuCakSNHhrUhxcXFAID6+nqUlJSIx+vr6zF58uSg34dbeDo6OsLaDoIgCIIgog+/bgdjxQ1JvBQUFKCgoCC8rRqEESNGoLi4GGvXrhVipaOjA5s2bQqpYqmzsxMAyPtCEARBEAlIZ2cnsrKyAq4JSbyEwpEjR9DS0oIjR47Abrdj27ZtAIDRo0cjIyMDAFBRUYHly5fj0ksvhSRJuOOOO/C73/0OY8aMwYgRI/Cb3/wGpaWluOSSS4L+vaWlpaitrUVmZiYkSZL1M/FKptra2pRMT6X65wdoH6T65wdoH9DnT+3PDyi3Dxhj6OzsRGlp6aBrFRMv9913H15++WXx71NOOQUAsG7dOsyePRsAUFNTg/b2drHmrrvuQnd3N2644Qa0tbXhzDPPxOrVq2EwGIL+vSqVCkOHDpXnQ/gh1b01qf75AdoHqf75AdoH9PlT+/MDyuyDwSIuHMXEy8qVK7Fy5cqAa/rntSRJwgMPPIAHHnhAqc0iCIIgCCLBiZtSaYIgCIIgiGAg8RICer0ey5Ytg16vj/WmxIRU//wA7YNU//wA7QP6/Kn9+YH42AeKjwcgCIIgCIKQE4q8EARBEASRUJB4IQiCIAgioSDxQhAEQRBEQkHihSAIgiCIhCKlxMvy5ctx2mmnITMzE4WFhbjkkktQU1Pjtaavrw+33HIL8vLykJGRgR/+8Ieor68Xz2/fvh1XXnklysrKYDQaUVlZiSeffNLrPdavX+9zaGWg6djRQo590NzcjPPPPx+lpaXQ6/UoKyvDokWLBsyTWr9+PU499VTo9XqMHj160L4/0SBanz/ZjwFPmpubMXToUEiShLa2Nq/nkvUY8MTf54/XY0Cuz+/rs73++utea+Lx7w9Ebx8k+zEAOHu6TZw4EQaDAYWFhbjlllu8nv/2229x1llnwWAwoKysDI888og8H4KlEHPnzmUvvfQS27lzJ9u2bRubN28eGzZsGOvq6hJrfv7zn7OysjK2du1a9tVXX7HTTz+dzZw5Uzz/wgsvsNtuu42tX7+e7d+/n7366qvMaDSyp556SqxZt24dA8BqamrYiRMnxI/dbo/q5/WFHPugpaWFPfPMM2zLli3s0KFD7OOPP2bjxo1jV155pVhz4MABlpaWxhYvXsx27drFnnrqKaZWq9nq1auj+nn7E63Pn+zHgCcXX3wxu+CCCxgA1traKh5P5mPAE3+fP16PAbk+PwD20ksveX223t5e8Xy8/v0Zi94+SPZj4I9//CMrLS1lr732Gtu3bx/bvn07e++998Tz7e3trKioiM2fP5/t3LmT/f3vf2dGo5E9++yzEX+GlBIv/WloaGAA2KeffsoYY6ytrY1ptVr2z3/+U6yprq5mANjGjRv9vs/NN9/MzjnnHPFvfsB6nsjiFbn2wZNPPsmGDh0q/n3XXXexk046yWvN5ZdfzubOnSvzJ4gMpT5/qhwDzzzzDJs1axZbu3btgM+bCsdAoM+fKMdAuJ8fAHvnnXf8vm+i/P0ZU24fJPMx0NLSwoxGI/v444/9vu8zzzzDcnJymNlsFo/dfffdbNy4cRFvc0qljfrD5yrl5uYCALZu3Qqr1YqqqiqxpqKiAsOGDcPGjRsDvg9/D08mT56MkpISnHvuudiwYYPMWy8PcuyD48eP4+2338asWbPEYxs3bvR6DwCYO3duwP0YC5T6/JxkPgZ27dqFBx54AK+88gpUqoGnkmQ/Bgb7/Jx4PwYi+Q7ccsstyM/Px7Rp0/Diiy96jXxJlL8/oNw+4CTjMbBmzRo4HA4cO3YMlZWVGDp0KH784x+jtrZWvGbjxo04++yzodPpxGNz585FTU0NWltbI9rmlBUvDocDd9xxB8444wxMmDABAFBXVwedTofs7GyvtUVFRX5zlF9++SXeeOMN3HDDDeKxkpISrFixAm+99RbeeustlJWVYfbs2fj6668V+zzhEOk+uPLKK5GWloYhQ4bAZDLhb3/7m3iurq4ORUVFA96jo6MDvb29ynygEFHy8yf7MWA2m3HllVfi0UcfxbBhw3y+dzIfA8F8/kQ4BiL5DjzwwAP4xz/+gTVr1uCHP/whbr75Zjz11FPi+UT4+wPK7oNkPgYOHDgAh8OBhx9+GE888QTefPNNtLS04Nxzz4XFYhHv4+sY4M9FgmKDGeOdW265BTt37sQXX3wR9nvs3LkTF198MZYtW4bzzjtPPD5u3DiMGzdO/HvmzJnYv38/Hn/8cbz66qsRbbecRLoPHn/8cSxbtgx79uzB0qVLsXjxYjzzzDMyb6VyKPn5k/0YWLp0KSorK3H11VcrtGXRQcnPnwjHQCTfgd/85jfi/0855RR0d3fj0UcfxW233SbnJiqOkvsgmY8Bh8MBq9WKP//5z+L69/e//x3FxcVYt24d5s6dq8TmClIy8rJo0SJ88MEHWLduHYYOHSoeLy4uhsViGVAxUV9fj+LiYq/Hdu3ahTlz5uCGG27AvffeO+jvnDZtGvbt2yfL9suBHPuguLgYFRUVuOiii/Dss8/ir3/9K06cOCGe6+9Mr6+vh8lkgtFoVOZDhYDSn98XyXQMfPLJJ/jnP/8JjUYDjUaDOXPmAADy8/OxbNky8T7JegwE8/l9EU/HgBzfAU+mT5+Oo0ePwmw2i/eJ578/oPw+8EWyHAMlJSUAgPHjx4vnCwoKkJ+fjyNHjoj38XUM8OciImLXTALhcDjYLbfcwkpLS9mePXsGPM9NSm+++aZ4bPfu3QNMWjt37mSFhYXsl7/8ZdC/u6qqil166aWRfQAZkGsf9OfTTz9lANjBgwcZY06z3oQJE7zWXHnllTE360Xr8/simY6Bffv2sR07doifF198kQFgX375Jauvr2eMJfcxEMzn90U8HANKfQd+97vfsZycHPHveP37Mxa9feCLZDkGampqGAAvw25zczNTqVTso48+Yoy5DbsWi0WsWbp0qSyG3ZQSLzfddBPLyspi69ev9ypb6+npEWt+/vOfs2HDhrFPPvmEffXVV2zGjBlsxowZ4vkdO3awgoICdvXVV3u9R0NDg1jz+OOPs3fffZft3buX7dixg91+++1MpVIFdGVHCzn2wb///W/24osvsh07drCDBw+yDz74gFVWVrIzzjhDrOFlkr/85S9ZdXU1e/rpp+OiTDJanz/Zj4H++KqqSOZjoD++Pn+8HgNyfP7333+fPf/882zHjh1s79697JlnnmFpaWnsvvvuE2vi9e/PWPT2QTIfA4w52wScdNJJbMOGDWzHjh3s+9//Phs/frwQK21tbayoqIj95Cc/YTt37mSvv/46S0tLo1LpUAHg8+ell14Sa3p7e9nNN9/McnJyWFpaGrv00kvZiRMnxPPLli3z+R7Dhw8Xa/7whz+wUaNGMYPBwHJzc9ns2bPZJ598EsVP6h859sEnn3zCZsyYwbKyspjBYGBjxoxhd99994BywHXr1rHJkycznU7HRo4c6fU7YkW0Pn+yHwP98VcSmqzHQH98ff54PQbk+Pz/+c9/2OTJk1lGRgZLT09nkyZNYitWrBjQvyQe//6MRW8fJPMxwJizj8tPf/pTlp2dzXJzc9mll17Kjhw54rVm+/bt7Mwzz2R6vZ4NGTKE/f73v5flM0iuD0IQBEEQBJEQpKRhlyAIgiCIxIXEC0EQBEEQCQWJF4IgCIIgEgoSLwRBEARBJBQkXgiCIAiCSChIvBAEQRAEkVCQeCEIgiAIIqEg8UIQBEEQREJB4oUgYsjKlSsHjJ1PJO6//35Mnjw51ptBADh06BAkScK2bdtivSkJxfr16yFJ0oAhhER8Q+KF8OLaa6+FJEmQJAk6nQ6jR4/GAw88AJvNFutNGxRJkvDuu+/GejO8WLduHebNm4e8vDykpaVh/PjxWLJkCY4dOxbrTZOFO++8E2vXrpXlvXp7e5Gbm4v8/HyfU3nLy8shSRL+97//eT1+xx13YPbs2V6PdXR04Ne//jUqKipgMBhQXFyMqqoqvP3226Cm4pFx7bXX4pJLLon1ZoTF7Nmzcccdd8R6MwgZIPFCDOD888/HiRMnsHfvXixZsgT3338/Hn300bDey263w+FwyLyFicGzzz6LqqoqFBcX46233sKuXbuwYsUKtLe3449//GOsN08WMjIykJeXJ8t7vfXWWzjppJNQUVHhV4QaDAbcfffdAd+nra0NM2fOxCuvvIKlS5fi66+/xmeffYbLL78cd911F9rb22XZXoIIhNVqjfUmJDeyTEgikoYFCxawiy++2Ouxc889l51++umMMcb6+vrYkiVLWGlpKUtLS2PTpk1j69atE2tfeukllpWVxd577z1WWVnJ1Go1O3jwIOvr62N33XUXGzp0KNPpdGzUqFHsb3/7m3jdjh072Pnnn8/S09NZYWEhu/rqq1ljY6N4ftasWezWW29lv/zlL1lOTg4rKipiy5YtE88PHz7c56DMffv2sYsuuogVFhay9PR0NnXqVLZmzRqvz3f8+HE2b948ZjAYWHl5OXvttdfY8OHD2eOPPy7WtLa2suuvv57l5+ezzMxMds4557Bt27b53Y+1tbVMp9OxO+64w+fzfIAf31+rV69mFRUVLD09nc2dO5cdP35crN28eTOrqqpieXl5zGQysbPPPptt3brV6/0AsOeff55dcsklzGg0stGjR7P33nvPa817773HRo8ezfR6PZs9ezZbuXLlgGGCn3/+OTvzzDOZwWBgQ4cOZbfeeivr6ury+zmXLVvGJk2aJP7Nj59HH32UFRcXs9zcXHbzzTeLKbOBmD17NluxYgX761//ys4999wBzw8fPpzddtttTKfTsX//+9/i8dtvv53NmjVL/Pumm25i6enp7NixYwPeo7Ozk1mtVr/b8P7777OpU6cyvV7P8vLy2CWXXCKee+WVV9iUKVNYRkYGKyoqYldeeSWrr68Xz7e0tLCrrrqK5efnM4PBwEaPHs1efPFF8fyRI0fYZZddxrKyslhOTg676KKL2MGDB8Xz69atY6eddhpLS0tjWVlZbObMmezQoUN+t3XTpk1s8uTJTK/XsylTprC3336bAWDffPMNY8x9bHnyzjvvsP6n/XfffZedcsopTK/XsxEjRrD777/f7z7yNZiWf/+//fZbds4554ghhAsXLmSdnZ1+t3/KlCns0UcfFf+++OKLmUajEa+pra1lANjevXsZY4Ofe5qamtgVV1zBSktLmdFoZBMmTGCrVq0Szy9YsGDAth88eFAM1fz444/ZlClTmNFoZDNmzGC7d+8OaT8BYM888wy78MILWVpamtf5iZAfEi+EF77Ey0UXXcROPfVUxhhjP/vZz9jMmTPZZ599xvbt28ceffRRptfr2Z49exhjzhOmVqtlM2fOZBs2bGC7d+9m3d3d7Mc//jErKytjb7/9Ntu/fz/7+OOP2euvv84Yc17ICwoK2NKlS1l1dTX7+uuv2bnnnsvOOeccsQ2zZs1iJpOJ3X///WzPnj3s5ZdfZpIksf/+97+MMcYaGhrEVNQTJ06whoYGxhhj27ZtYytWrGA7duxge/bsYffeey8zGAzs8OHD4r2rqqrY5MmT2f/+9z+2detWNmvWLGY0Gr3ES1VVFbvwwgvZli1b2J49e9iSJUtYXl4ea25u9rkf//SnPzEAXiLEF3x/VVVVsS1btrCtW7eyyspKdtVVV4k1a9euZa+++iqrrq5mu3btYtdffz0rKipiHR0dYg0ANnToULZq1Sq2d+9edtttt7GMjAyxfQcOHGBarZbdeeedbPfu3ezvf/87GzJkiJd42bdvH0tPT2ePP/4427NnD9uwYQM75ZRT2LXXXut3+32JF5PJxH7+85+z6upq9q9//YulpaWx5557LuB+2LdvH9Pr9aylpYU1Nzczg8Ew4MLNBeVtt93GJk6cKKb3eooXu93OcnJy2A033BDw9/nigw8+YGq1mt13331s165dbNu2bezhhx8Wz7/wwgvsww8/ZPv372cbN25kM2bMYBdccIF4/pZbbmGTJ09mW7ZsYQcPHmRr1qxh77//PmOMMYvFwiorK9lPf/pT9u2337Jdu3axq666io0bN46ZzWZmtVpZVlYWu/POO9m+ffvYrl272MqVK72OU086OztZQUEBu+qqq9jOnTvZv/71LzZy5MiQxctnn33GTCYTW7lyJdu/fz/773//y8rLy9n999/v9/f++Mc/Zueffz47ceIEO3HiBDObzayrq4uVlJSwH/zgB2zHjh1s7dq1bMSIEWzBggV+9/fixYvZ9773PcYYYw6Hg+Xm5rL8/Hz2n//8hzHG2P/7f/+PDRkyRKwf7Nxz9OhR9uijj7JvvvmG7d+/n/35z39marWabdq0iTHGWFtbG5sxYwZbuHCh2HabzSbEy/Tp09n69evZd999x8466yw2c+bMkPYTAFZYWMhefPFFtn//fr9/O0IeSLwQXniKF4fDwdasWcP0ej2788472eHDh5larR5wRztnzhy2dOlSxpjzhAnAKypRU1PDAAyIeHAefPBBdt5553k9xu+6ampqGGNO8XLmmWd6rTnttNPY3XffLf4NgL3zzjuDfsaTTjqJPfXUU4wxxqqrqxkAtmXLFvH83r17GQAhXj7//HNmMplYX1+f1/uMGjWKPfvssz5/x0033cRMJtOg28L31759+8RjTz/9NCsqKvL7GrvdzjIzM9m//vUv8RgAdu+994p/d3V1MQDiQnD33XezCRMmeL3Pr3/9ay/xcv311w+46H/++edMpVKx3t5en9viS7wMHz6c2Ww28dhll13GLr/8cr+fhzHGfvWrX3lFOS6++OIBd65cvDQ0NLDMzEz2yiuvMMa8xUt9fT0DwP70pz8F/H2+mDFjBps/f37Q67ds2cIAiEjBhRdeyK677jqfa1999VU2btw45nA4xGNms5kZjUb20UcfsebmZgaArV+/Pqjf/eyzz7K8vDyvv8tf//rXkMXLnDlzvAQa39aSkhK/v9vXDc5zzz3HcnJyvKJ0//73v5lKpWJ1dXU+3+f9999nWVlZzGazsW3btrHi4mJ2++23i+/0z372MyHigzn3+OJ73/seW7Jkifj3rFmz2O233+61xjPy4rntAMT+DWY/AfAbaSXkhzwvxAA++OADZGRkwGAw4IILLsDll1+O+++/Hzt27IDdbsfYsWORkZEhfj799FPs379fvF6n02HixIni39u2bYNarcasWbN8/r7t27dj3bp1Xu9ZUVEBAF7v6/meAFBSUoKGhoaAn6Wrqwt33nknKisrkZ2djYyMDFRXV+PIkSMAgJqaGmg0Gpx66qniNaNHj0ZOTo7X9nV1dSEvL89rGw8ePOi1fZ4wxiBJUsBt46SlpWHUqFF+P1d9fT0WLlyIMWPGICsrCyaTCV1dXeIzcDz3T3p6Okwmk3ifmpoanHbaaV7rp02b5vXv7du3Y+XKlV6fce7cuXA4HDh48GBQnwUATjrpJKjVar+fpz92ux0vv/wyrr76avHY1VdfjZUrV/r0SxUUFODOO+/EfffdB4vF4vUci8CMu23bNsyZM8fv81u3bsWFF16IYcOGITMzUxzP/O9w00034fXXX8fkyZNx11134csvvxSv3b59O/bt24fMzEyxb3Nzc9HX14f9+/cjNzcX1157LebOnYsLL7wQTz75JE6cOOF3W6qrqzFx4kQYDAbx2IwZM0L+zNu3b8cDDzzg9TdfuHAhTpw4gZ6enqDfp7q6GpMmTUJ6erp47IwzzoDD4UBNTY3P15x11lno7OzEN998g08//RSzZs3C7NmzsX79egDAp59+KozYwZx77HY7HnzwQZx88snIzc1FRkYGPvroowHfE394fn9KSkoAQBy3we6nqVOnBrfDiIjRxHoDiPjjnHPOwV//+lfodDqUlpZCo3EeJl1dXVCr1di6davXxQlwGjc5RqPR68JtNBoD/r6uri5ceOGF+MMf/jDgOX4SAQCtVuv1nCRJg5qB77zzTqxZswaPPfYYRo8eDaPRiB/96EcDLnqDbV9JSYk4qXrir8x57NixaG9vx4kTJ7w+gy98fS7Pi/CCBQvQ3NyMJ598EsOHD4der8eMGTMGfIZw9o8nXV1duPHGG3HbbbcNeG7YsGFBv0+o2/HRRx/h2LFjuPzyy70et9vtWLt2Lc4999wBr1m8eDGeeeYZPPPMM16PFxQUIDs7G7t37w56ezmBjtPu7m7MnTsXc+fOxWuvvYaCggIcOXIEc+fOFX+HCy64AIcPH8aHH36INWvWYM6cObjlllvw2GOPoaurC1OmTMFrr7024L0LCgoAAC+99BJuu+02rF69Gm+88QbuvfderFmzBqeffnrInwUAVCrVADHX30Ta1dWF3/72t/jBD34w4PWewkgJsrOzMWnSJKxfvx4bN27Eueeei7PPPhuXX3459uzZg7179wqBGMy559FHH8WTTz6JJ554AieffDLS09Nxxx13BP1d9zxu+fmLH7fB7idP8UYoC4kXYgDp6ekYPXr0gMdPOeUU2O12NDQ04Kyzzgr6/U4++WQ4HA58+umnqKqqGvD8qaeeirfeegvl5eVCKIWDVquF3W73emzDhg249tprcemllwJwnoQOHToknh83bhxsNhu++eYbTJkyBQCwb98+tLa2em1fXV0dNBoNysvLg9qWH/3oR7jnnnvwyCOP4PHHHx/wfFtbW9D9XTZs2IBnnnkG8+bNAwDU1taiqakpqNdyxo0bhw8//NDrsS1btnj9+9RTT8WuXbt8/u2V5IUXXsAVV1yBX//6116PP/TQQ3jhhRd8ipeMjAz85je/wf3334+LLrpIPK5SqXDFFVfg1VdfxbJly1BaWur1uq6uLhgMBp/H2cSJE7F27Vpcd911A57bvXs3mpub8fvf/x5lZWUAgK+++mrAuoKCAixYsAALFizAWWedhV/+8pd47LHHcOqpp+KNN95AYWEhTCaT331xyimn4JRTTsHSpUsxY8YMrFq1yqd4qaysxKuvvoq+vj5x8exfQl5QUIDOzk50d3eLi2r/HjCnnnoqampqQvqb63S6Ad+zyspKrFy50ut3bdiwASqVCuPGjfP7XrNmzcK6deuwefNmPPTQQ8jNzUVlZSUeeughlJSUYOzYsWK/DHbu2bBhAy6++GIRwXM4HNizZw/Gjx8fcNuDIZz9RCgLpY2IoBk7dizmz5+Pa665Bm+//TYOHjyIzZs3Y/ny5fj3v//t93Xl5eVYsGABfvrTn+Ldd9/FwYMHsX79evzjH/8AANxyyy1oaWnBlVdeiS1btmD//v346KOPcN1114V0oikvL8fatWtRV1cnxMeYMWPw9ttvY9u2bdi+fTuuuuoqryhARUUFqqqqcMMNN2Dz5s345ptvcMMNN3hFj6qqqjBjxgxccskl+O9//4tDhw7hyy+/xK9//WufFzAAKCsrw+OPP44nn3wS119/PT799FMcPnwYGzZswI033ogHH3ww6M81ZswYvPrqq6iursamTZswf/78QaNZ/bnxxhuxe/du3H333dizZw/+8Y9/YOXKlQDcd5l33303vvzySyxatAjbtm3D3r178d5772HRokUh/a5QaGxsxL/+9S8sWLAAEyZM8Pq55ppr8O6776KlpcXna2+44QZkZWVh1apVXo8/9NBDKCsrw/Tp0/HKK69g165d2Lt3L1588UWccsop6Orq8vl+y5Ytw9///ncsW7YM1dXV2LFjh4gGDhs2DDqdDk899RQOHDiA999/f8Df8L777sN7772Hffv24bvvvsMHH3yAyspKAMD8+fORn5+Piy++GJ9//rn4Dtx22204evQoDh48iKVLl2Ljxo04fPgw/vvf/2Lv3r3i9f256qqrIEkSFi5ciF27duHDDz/EY4895rVm+vTpSEtLw69+9Svs378fq1atEn9zz21+5ZVX8Nvf/hbfffcdqqur8frrr+Pee+/1/QeD83v27bffoqamBk1NTbBarZg/fz4MBgMWLFiAnTt3Yt26dbj11lvxk5/8BEVFRX7fa/bs2fjoo4+g0WhEqnj27Nl47bXXvNLMwZx7xowZgzVr1uDLL79EdXU1brzxRtTX1w/Y9k2bNuHQoUNoamoKOjIZzn4iFCa2lhsi3vBlxvPEYrGw++67j5WXlzOtVstKSkrYpZdeyr799lvGmG+TIGOM9fb2sl/84hespKSE6XS6AWWke/bsYZdeeinLzs5mRqORVVRUsDvuuEMYHH0Z7S6++GKvaob333+fjR49mmk0GlEqffDgQXbOOecwo9HIysrK2F/+8pcB73X8+HF2wQUXML1ez4YPH85WrVrFCgsL2YoVK8Sajo4Oduutt7LS0lKm1WpZWVkZmz9/Pjty5EjA/blmzRo2d+5clpOTwwwGA6uoqGB33nmnqEIKxlT59ddfs6lTpzKDwcDGjBnD/vnPfw4o5YYPs3JWVhZ76aWXxL/7l0pzg6en6XPz5s3s3HPPZRkZGSw9PZ1NnDiRPfTQQ34/n79SaU/6lzJ78thjj7Hs7GyfpdRms5llZ2ezJ598kjHGBnxmxhhbtWoVAzDg/dva2tg999zDxowZw3Q6HSsqKmJVVVXsnXfe8TLN9uett95ikydPZjqdjuXn57Mf/OAHXr+rvLyc6fV6NmPGDPb+++97GWQffPBBVllZyYxGI8vNzWUXX3wxO3DggHj9iRMn2DXXXMPy8/OZXq9nI0eOZAsXLmTt7e2srq6OXXLJJeL7MXz4cHbfffeJiipfbNy4kU2aNInpdDo2efJk9tZbb3ltD2POY2n06NHMaDSy73//++y5554bUCq9evVqNnPmTGY0GpnJZGLTpk0LWB3W0NAgjhFEUCrNGGPNzc1MkiQvQzc//j2/f4wNfu5pbm5mF198McvIyGCFhYXs3nvvZddcc43X8VhTU8NOP/10ZjQaB5RKe7YM+Oabb8Tzwe4nX99BQjkkxqjdJEF4cvToUZSVleHjjz8OaOBMdB566CGsWLECtbW1sd4UgiCIkCDPC5HyfPLJJ+jq6sLJJ5+MEydO4K677kJ5eTnOPvvsWG+arDzzzDM47bTTkJeXhw0bNuDRRx9VNCVEEAShFCReiJTHarXiV7/6FQ4cOIDMzEzMnDkTr7322oCqmURn7969+N3vfoeWlhYMGzYMS5YswdKlS2O9WQRBECFDaSOCIAiCIBIKqjYiCIIgCCKhIPFCEARBEERCQeKFIAiCIIiEgsQLQRAEQRAJBYkXgiAIgiASChIvBEEQBEEkFCReCIIgCIJIKEi8EARBEASRUPx/Tlk+weTrwwoAAAAASUVORK5CYII=" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 25 + "execution_count": 48 }, { "metadata": {}, @@ -3230,8 +3490,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-09T12:05:33.249117Z", - "start_time": "2025-01-09T12:05:33.241578Z" + "end_time": "2025-01-10T12:59:28.510716Z", + "start_time": "2025-01-10T12:59:28.507553Z" } }, "cell_type": "code", @@ -3247,12 +3507,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "Sum of values < 0: -87753.71340159839\n", - "-0.30641921667530275\n" + "Sum of values < 0: 0.0\n", + "0.0\n" ] } ], - "execution_count": 26 + "execution_count": 49 }, { "metadata": {}, From f9b5ff3109d01f813956e63f9696d3ab241df222 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 13 Jan 2025 09:57:23 +0000 Subject: [PATCH 187/291] Correlation matrix - removing ftype and district reduced multicollinearity and improvied predictions --- ...al_realtionship_reporting_precipitation.py | 107 +++++++++++------- 1 file changed, 66 insertions(+), 41 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 4ad0c26766..79321591c8 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -7,6 +7,7 @@ from statsmodels.genmod.generalized_linear_model import GLM from sklearn.preprocessing import StandardScaler from statsmodels.stats.outliers_influence import variance_inflation_factor +from sklearn.feature_selection import SelectKBest, f_regression ANC = True daily_max = False @@ -17,7 +18,7 @@ else: five_day = False cumulative = False - +feature_selection = False use_all_weather = True min_year_for_analysis = 2012 absolute_min_year = 2011 @@ -73,16 +74,37 @@ weather_data_historical = pd.read_csv( "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_ANC_lm.csv", index_col=0) -def build_model(X, y, poisson=False, log_y=False, X_mask_mm=0): + + +def build_model(X, y, poisson=False, log_y=False, X_mask_mm=0, feature_selection=False, k_best=None): epsilon = 1 + # Log-transform y with clipping for positivity if log_y: - y = np.log(np.clip(y, epsilon, None)) # Log-transform y with clipping for positivity - mask = (~np.isnan(X).any(axis=1) & ~np.isnan(y) & ( - X[:, 0] >= X_mask_mm) & (y <= 1e4)) - model = GLM(y[mask], X[mask], family=NegativeBinomial(), method='nm' ) if poisson else sm.OLS(y[mask], X[mask]) + y = np.log(np.clip(y, epsilon, None)) + + # Apply mask to filter valid data + mask = (~np.isnan(X).any(axis=1) & ~np.isnan(y) & + (X[:, 0] >= X_mask_mm) & (y <= 1e4)) + X_filtered, y_filtered = X[mask], y[mask] + + # Feature selection step (optional) + if feature_selection: + if poisson: + raise ValueError("Feature selection using f_regression is only compatible with OLS regression.") + selector = SelectKBest(score_func=f_regression, k=k_best or 'all') + X_filtered = selector.fit_transform(X_filtered, y_filtered) + selected_features = selector.get_support() + else: + selected_features = np.ones(X.shape[1], dtype=bool) # Keep all features if no selection + + # Build the model + model = GLM(y_filtered, X_filtered, family=NegativeBinomial(), method='nm') if poisson else sm.OLS(y_filtered, + X_filtered) model_fit = model.fit() - return model_fit, model_fit.predict(X[mask]), mask + + return model_fit, model_fit.predict(X_filtered), mask, selected_features + def create_binary_feature(threshold, weather_data_df, recent_months): binary_feature_list = [] @@ -312,21 +334,48 @@ def repeat_info(info, num_facilities, year_range, historical): X_categorical = np.column_stack([ resid_encoded, zone_encoded, - dist_encoded, + #dist_encoded, owner_encoded, - ftype_encoded, + #ftype_encoded, #facility_encoded, ]) scaler = StandardScaler() X_continuous_scaled = scaler.fit_transform(X_continuous) X_continuous_scaled = X_continuous X_ANC_standardized = np.column_stack([X_continuous_scaled, X_categorical]) +# Create column names +# continuous_columns = ['Year', 'Month', 'Altitude', 'Minimum_Distance'] +# categorical_columns = [ +# f'Resid_{i}' for i in range(resid_encoded.shape[1]) +# ] + [ +# f'Zone_{i}' for i in range(zone_encoded.shape[1]) +# ] + [ +# f'Dist_{i}' for i in range(dist_encoded.shape[1]) +# ] + [ +# f'Owner_{i}' for i in range(owner_encoded.shape[1]) +# ] + [ +# f'Ftype_{i}' for i in range(ftype_encoded.shape[1]) +# ] + [ +# f'Facility_{i}' for i in range(facility_encoded.shape[1]) +# ] +# +# # Combine into a DataFrame +# columns = continuous_columns + categorical_columns +# df_combined = pd.DataFrame(X_ANC_standardized, columns=columns) +# +# # Standardize the continuous variables +# df_combined[continuous_columns] = (df_combined[continuous_columns] - df_combined[continuous_columns].mean()) / df_combined[continuous_columns].std() +# +# # Compute the correlation matrix +# correlation_matrix = df_combined.corr() +#correlation_matrix.to_csv('/Users/rem76/Desktop/Climate_change_health/Data/correlation_matrix_of_predictors.csv') +# Display the correlation matrix coefficient_names = ["year", "month"] + list(resid_encoded.columns) + list(zone_encoded.columns) + \ list(owner_encoded.columns) + list(ftype_encoded.columns) + \ list(facility_encoded.columns) + ["altitude", "minimum_distance"] coefficient_names = pd.Series(coefficient_names) -results, y_pred, mask_ANC_data = build_model(X_ANC_standardized , y, poisson = poisson, log_y=log_y, X_mask_mm=mask_threshold) +results, y_pred, mask_ANC_data, selected_features = build_model(X_ANC_standardized , y, poisson = poisson, log_y=log_y, X_mask_mm=mask_threshold, feature_selection = feature_selection) coefficients = results.params coefficients_df = pd.DataFrame(coefficients, columns=['coefficients']) continuous_coefficients = coefficients[:len(X_continuous_scaled[0])] @@ -403,30 +452,6 @@ def repeat_info(info, num_facilities, year_range, historical): ############################################################################################## -X_weather = np.column_stack([ - weather_data, - np.array(year_flattened), - np.array(month_flattened), - resid_encoded, - zone_encoded, - dist_encoded, - owner_encoded, - ftype_encoded, - lag_1_month, - lag_2_month, - lag_3_month, - lag_4_month, - lag_9_month, - lag_1_5_day, - lag_2_5_day, - lag_3_5_day, - lag_4_5_day, - lag_9_5_day, - #facility_encoded, - np.array(altitude), - np.array(minimum_distance), - #np.array(above_below_X)[mask_ANC_data], -]) # Continuous columns that need to be standardized (weather_data, lag variables, altitude, minimum_distance) X_continuous = np.column_stack([ weather_data, @@ -449,9 +474,9 @@ def repeat_info(info, num_facilities, year_range, historical): X_categorical = np.column_stack([ resid_encoded, zone_encoded, - dist_encoded, + #dist_encoded, owner_encoded, - ftype_encoded, + #ftype_encoded, #facility_encoded, #np.array(above_below_X)[mask_ANC_data], ]) @@ -462,8 +487,8 @@ def repeat_info(info, num_facilities, year_range, historical): X_weather_standardized = np.column_stack([X_continuous_scaled, X_categorical]) -results_of_weather_model, y_pred_weather, mask_all_data = build_model(X_weather_standardized, y, poisson = poisson, log_y=log_y, - X_mask_mm=mask_threshold) +results_of_weather_model, y_pred_weather, mask_all_data, selected_features = build_model(X_weather_standardized, y, poisson = poisson, log_y=log_y, + X_mask_mm=mask_threshold, feature_selection = feature_selection) coefficient_names_weather = ["precip_monthly_total", "precip_5_day_max", "year", "month"] + \ list(resid_encoded.columns) + list(zone_encoded.columns) + \ @@ -492,7 +517,7 @@ def repeat_info(info, num_facilities, year_range, historical): print("All predictors", results_of_weather_model.summary()) # -X_filtered = X_weather[mask_all_data] +X_filtered = X_weather_standardized[mask_all_data] fig, axs = plt.subplots(1, 2, figsize=(10, 6)) @@ -690,9 +715,9 @@ def get_weather_data(ssp_scenario, model_type): X_categorical_ANC = np.column_stack([ resid_encoded_prediction, zone_encoded_prediction, - dist_encoded_prediction, + #dist_encoded_prediction, owner_encoded_prediction, - ftype_encoded_prediction, + #ftype_encoded_prediction, #facility_encoded_prediction ]) From d9d0959f8998253284c0744222d0237481a8882d Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 13 Jan 2025 10:07:00 +0000 Subject: [PATCH 188/291] Correlation matrix - removing ftype and district reduced multicollinearity and improvied predictions --- ...r_model_historical_realtionship_reporting_precipitation.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 79321591c8..af5804ccd9 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -683,9 +683,9 @@ def get_weather_data(ssp_scenario, model_type): X_categorical_weather = np.column_stack([ resid_encoded_prediction, zone_encoded_prediction, - dist_encoded_prediction, + #dist_encoded_prediction, owner_encoded_prediction, - ftype_encoded_prediction, + #ftype_encoded_prediction, #facility_encoded_prediction ]) From 07efa88a55168e8f9bef54c800519d49a3353719 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 13 Jan 2025 11:09:37 +0000 Subject: [PATCH 189/291] Reordered naming of predictors for saving results --- ...ical_realtionship_reporting_precipitation.py | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index af5804ccd9..f189359117 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -371,9 +371,8 @@ def repeat_info(info, num_facilities, year_range, historical): #correlation_matrix.to_csv('/Users/rem76/Desktop/Climate_change_health/Data/correlation_matrix_of_predictors.csv') # Display the correlation matrix -coefficient_names = ["year", "month"] + list(resid_encoded.columns) + list(zone_encoded.columns) + \ - list(owner_encoded.columns) + list(ftype_encoded.columns) + \ - list(facility_encoded.columns) + ["altitude", "minimum_distance"] +coefficient_names = ["year", "month", "altitude", "minimum_distance"] + list(resid_encoded.columns) + list(zone_encoded.columns) + \ + list(owner_encoded.columns) coefficient_names = pd.Series(coefficient_names) results, y_pred, mask_ANC_data, selected_features = build_model(X_ANC_standardized , y, poisson = poisson, log_y=log_y, X_mask_mm=mask_threshold, feature_selection = feature_selection) coefficients = results.params @@ -468,7 +467,7 @@ def repeat_info(info, num_facilities, year_range, historical): lag_4_5_day, lag_9_5_day, np.array(altitude), - np.array(minimum_distance),] + np.array(minimum_distance)] ) X_categorical = np.column_stack([ @@ -490,12 +489,12 @@ def repeat_info(info, num_facilities, year_range, historical): results_of_weather_model, y_pred_weather, mask_all_data, selected_features = build_model(X_weather_standardized, y, poisson = poisson, log_y=log_y, X_mask_mm=mask_threshold, feature_selection = feature_selection) -coefficient_names_weather = ["precip_monthly_total", "precip_5_day_max", "year", "month"] + \ +coefficient_names_weather = ["precip_monthly_total", "precip_5_day_max", "year", "month", + "lag_1_month", "lag_2_month", "lag_3_month", "lag_4_month", "lag_9_month", + "lag_1_5_day", "lag_2_5_day", "lag_3_5_day", "lag_4_5_day", "lag_9_month", + "altitude", "minimum_distance"] + \ list(resid_encoded.columns) + list(zone_encoded.columns) + \ - list(owner_encoded.columns) + list(ftype_encoded.columns) + \ - ["lag_1_month", "lag_2_month", "lag_3_month", "lag_4_month"] + \ - ["lag_1_5_day", "lag_2_5_day", "lag_3_5_day", "lag_4_5_day"] + \ - list(facility_encoded.columns) + ["altitude", "minimum_distance"] + list(owner_encoded.columns) coefficient_names_weather = pd.Series(coefficient_names_weather) coefficients_weather = results_of_weather_model.params coefficients_weather_df = pd.DataFrame(coefficients_weather, columns=['coefficients']) From 2881fac0e32aeb72c2c327bf21125e597a393b1d Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 13 Jan 2025 11:10:07 +0000 Subject: [PATCH 190/291] Identical --- src/scripts/climate_change/cohort_model.ipynb | 1826 ++++++++--------- 1 file changed, 913 insertions(+), 913 deletions(-) diff --git a/src/scripts/climate_change/cohort_model.ipynb b/src/scripts/climate_change/cohort_model.ipynb index 7eae776830..22037e48c5 100644 --- a/src/scripts/climate_change/cohort_model.ipynb +++ b/src/scripts/climate_change/cohort_model.ipynb @@ -6,8 +6,8 @@ "metadata": { "collapsed": true, "ExecuteTime": { - "end_time": "2025-01-10T12:59:21.769589Z", - "start_time": "2025-01-10T12:59:21.461785Z" + "end_time": "2025-01-13T10:17:11.513188Z", + "start_time": "2025-01-13T10:17:10.336338Z" } }, "source": [ @@ -70,7 +70,7 @@ ] } ], - "execution_count": 40 + "execution_count": 52 }, { "metadata": {}, @@ -81,8 +81,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-10T12:59:22.146505Z", - "start_time": "2025-01-10T12:59:22.142886Z" + "end_time": "2025-01-13T10:17:11.625639Z", + "start_time": "2025-01-13T10:17:11.573080Z" } }, "cell_type": "code", @@ -92,26 +92,26 @@ ], "id": "bbff583692196586", "outputs": [], - "execution_count": 41 + "execution_count": 53 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-10T12:59:22.793563Z", - "start_time": "2025-01-10T12:59:22.607733Z" + "end_time": "2025-01-13T10:17:13.738496Z", + "start_time": "2025-01-13T10:17:12.468147Z" } }, "cell_type": "code", "source": "predictions_from_cmip = pd.read_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv')", "id": "3be0a4515f3e890e", "outputs": [], - "execution_count": 42 + "execution_count": 54 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-10T12:59:23.269203Z", - "start_time": "2025-01-10T12:59:23.091777Z" + "end_time": "2025-01-13T10:17:14.670960Z", + "start_time": "2025-01-13T10:17:14.235012Z" } }, "cell_type": "code", @@ -365,52 +365,52 @@ "45 GovernmentGovernmentGovernmentGovernmentGovern... \n", "\n", " Facility_Type Precipitation \\\n", - "0 ClinicDistrict HospitalRural/Community Hospita... -44.979294 \n", - "1 ClinicDistrict HospitalRural/Community Hospita... 332.932458 \n", - "2 ClinicDistrict HospitalRural/Community Hospita... 273.236578 \n", - "3 ClinicDistrict HospitalRural/Community Hospita... 389.408735 \n", - "4 ClinicDistrict HospitalRural/Community Hospita... 184.087757 \n", - "5 ClinicDistrict HospitalRural/Community Hospita... 224.863481 \n", - "6 ClinicDistrict HospitalRural/Community Hospita... 381.703350 \n", - "7 ClinicDistrict HospitalRural/Community Hospita... -407.846396 \n", - "8 ClinicDistrict HospitalRural/Community Hospita... 80.361929 \n", - "9 ClinicDistrict HospitalRural/Community Hospita... 216.640767 \n", - "10 ClinicDistrict HospitalRural/Community Hospita... 225.326578 \n", - "11 ClinicDistrict HospitalRural/Community Hospita... 594.171531 \n", - "12 ClinicDistrict HospitalRural/Community Hospita... 560.249358 \n", - "13 ClinicDistrict HospitalRural/Community Hospita... -435.113264 \n", - "14 ClinicDistrict HospitalRural/Community Hospita... 255.949977 \n", - "15 ClinicDistrict HospitalRural/Community Hospita... 74.104759 \n", - "16 ClinicDistrict HospitalRural/Community Hospita... -17.668776 \n", - "17 ClinicDistrict HospitalRural/Community Hospita... -697.133816 \n", - "18 ClinicDistrict HospitalRural/Community Hospita... 329.189035 \n", - "19 ClinicDistrict HospitalRural/Community Hospita... -118.064977 \n", - "20 ClinicDistrict HospitalRural/Community Hospita... 284.126060 \n", - "21 ClinicDistrict HospitalRural/Community Hospita... -18.732747 \n", - "22 ClinicDistrict HospitalRural/Community Hospita... 48.277785 \n", - "23 ClinicDistrict HospitalRural/Community Hospita... -73.095163 \n", - "24 ClinicDistrict HospitalRural/Community Hospita... 162.594496 \n", - "25 ClinicDistrict HospitalRural/Community Hospita... -43.730389 \n", - "26 ClinicDistrict HospitalRural/Community Hospita... -565.572993 \n", - "27 ClinicDistrict HospitalRural/Community Hospita... 1.193485 \n", - "28 ClinicDistrict HospitalRural/Community Hospita... -97.090923 \n", - "29 ClinicDistrict HospitalRural/Community Hospita... -193.472441 \n", - "30 ClinicDistrict HospitalRural/Community Hospita... 227.006074 \n", - "31 ClinicDistrict HospitalRural/Community Hospita... 603.020776 \n", - "32 ClinicDistrict HospitalRural/Community Hospita... -135.507846 \n", - "33 ClinicDistrict HospitalRural/Community Hospita... 256.799140 \n", - "34 ClinicDistrict HospitalRural/Community Hospita... 90.745815 \n", - "35 ClinicDistrict HospitalRural/Community Hospita... 242.112335 \n", - "36 ClinicDistrict HospitalRural/Community Hospita... -260.245065 \n", - "37 ClinicDistrict HospitalRural/Community Hospita... -724.695938 \n", - "38 ClinicDistrict HospitalRural/Community Hospita... -44.117900 \n", - "39 ClinicDistrict HospitalRural/Community Hospita... -739.389811 \n", - "40 ClinicDistrict HospitalRural/Community Hospita... -112.802197 \n", - "41 ClinicDistrict HospitalRural/Community Hospita... 115.639539 \n", - "42 ClinicDistrict HospitalRural/Community Hospita... -443.853139 \n", - "43 ClinicDistrict HospitalRural/Community Hospita... -542.264304 \n", - "44 ClinicDistrict HospitalRural/Community Hospita... -326.448717 \n", - "45 ClinicDistrict HospitalRural/Community Hospita... -111.915703 \n", + "0 ClinicDistrict HospitalRural/Community Hospita... 377371.401757 \n", + "1 ClinicDistrict HospitalRural/Community Hospita... 424179.161524 \n", + "2 ClinicDistrict HospitalRural/Community Hospita... 416785.291442 \n", + "3 ClinicDistrict HospitalRural/Community Hospita... 431174.255009 \n", + "4 ClinicDistrict HospitalRural/Community Hospita... 405743.410420 \n", + "5 ClinicDistrict HospitalRural/Community Hospita... 410793.849551 \n", + "6 ClinicDistrict HospitalRural/Community Hospita... 430219.873937 \n", + "7 ClinicDistrict HospitalRural/Community Hospita... 332427.056762 \n", + "8 ClinicDistrict HospitalRural/Community Hospita... 392896.036283 \n", + "9 ClinicDistrict HospitalRural/Community Hospita... 409775.392632 \n", + "10 ClinicDistrict HospitalRural/Community Hospita... 410851.208278 \n", + "11 ClinicDistrict HospitalRural/Community Hospita... 456535.963741 \n", + "12 ClinicDistrict HospitalRural/Community Hospita... 452334.398335 \n", + "13 ClinicDistrict HospitalRural/Community Hospita... 329049.810569 \n", + "14 ClinicDistrict HospitalRural/Community Hospita... 414644.190834 \n", + "15 ClinicDistrict HospitalRural/Community Hospita... 392121.029719 \n", + "16 ClinicDistrict HospitalRural/Community Hospita... 380754.054252 \n", + "17 ClinicDistrict HospitalRural/Community Hospita... 296596.215293 \n", + "18 ClinicDistrict HospitalRural/Community Hospita... 423715.504984 \n", + "19 ClinicDistrict HospitalRural/Community Hospita... 368319.084368 \n", + "20 ClinicDistrict HospitalRural/Community Hospita... 418134.051457 \n", + "21 ClinicDistrict HospitalRural/Community Hospita... 380622.271982 \n", + "22 ClinicDistrict HospitalRural/Community Hospita... 388922.127329 \n", + "23 ClinicDistrict HospitalRural/Community Hospita... 373888.999201 \n", + "24 ClinicDistrict HospitalRural/Community Hospita... 403081.277311 \n", + "25 ClinicDistrict HospitalRural/Community Hospita... 377526.089751 \n", + "26 ClinicDistrict HospitalRural/Community Hospita... 312891.203066 \n", + "27 ClinicDistrict HospitalRural/Community Hospita... 383090.314471 \n", + "28 ClinicDistrict HospitalRural/Community Hospita... 370916.909122 \n", + "29 ClinicDistrict HospitalRural/Community Hospita... 358979.193679 \n", + "30 ClinicDistrict HospitalRural/Community Hospita... 411059.228901 \n", + "31 ClinicDistrict HospitalRural/Community Hospita... 457632.022035 \n", + "32 ClinicDistrict HospitalRural/Community Hospita... 366158.628623 \n", + "33 ClinicDistrict HospitalRural/Community Hospita... 414749.367352 \n", + "34 ClinicDistrict HospitalRural/Community Hospita... 394182.173776 \n", + "35 ClinicDistrict HospitalRural/Community Hospita... 412930.274807 \n", + "36 ClinicDistrict HospitalRural/Community Hospita... 350708.805302 \n", + "37 ClinicDistrict HospitalRural/Community Hospita... 293182.399170 \n", + "38 ClinicDistrict HospitalRural/Community Hospita... 377478.093086 \n", + "39 ClinicDistrict HospitalRural/Community Hospita... 291362.431282 \n", + "40 ClinicDistrict HospitalRural/Community Hospita... 368970.926878 \n", + "41 ClinicDistrict HospitalRural/Community Hospita... 397265.484764 \n", + "42 ClinicDistrict HospitalRural/Community Hospita... 327967.298680 \n", + "43 ClinicDistrict HospitalRural/Community Hospita... 315778.193228 \n", + "44 ClinicDistrict HospitalRural/Community Hospita... 342508.889264 \n", + "45 ClinicDistrict HospitalRural/Community Hospita... 369080.727151 \n", "\n", " Lag_1_Precipitation Lag_2_Precipitation Lag_3_Precipitation \\\n", "0 398942.636170 404727.057797 405704.571665 \n", @@ -461,100 +461,100 @@ "45 347439.884447 315453.846359 311453.513947 \n", "\n", " Lag_4_Precipitation Predicted_Weather_Model Predicted_No_Weather_Model \\\n", - "0 404895.268433 462904.609783 inf \n", - "1 386621.761142 463055.752459 inf \n", - "2 421535.968891 462644.111845 inf \n", - "3 400973.159779 460807.846722 inf \n", - "4 419592.912552 463079.419720 inf \n", - "5 391638.197677 462967.863359 inf \n", - "6 456824.623648 465600.988271 inf \n", - "7 357753.146752 459795.744898 inf \n", - "8 388673.117569 463363.585021 inf \n", - "9 373019.671935 459224.382654 inf \n", - "10 406919.996712 460943.631939 inf \n", - "11 432861.285260 458660.558966 inf \n", - "12 527784.234663 457513.243165 inf \n", - "13 318825.960831 460652.792462 inf \n", - "14 394260.244027 464478.060160 inf \n", - "15 387202.538290 460399.603672 inf \n", - "16 423444.969850 462078.098890 inf \n", - "17 313717.825313 458999.883435 inf \n", - "18 353491.313705 458590.220256 inf \n", - "19 424904.453286 457829.716881 inf \n", - "20 394030.949034 461670.160494 inf \n", - "21 396757.245029 459754.510452 inf \n", - "22 357396.518341 457511.882275 inf \n", - "23 384605.158226 458112.644483 inf \n", - "24 402279.134778 456805.271242 inf \n", - "25 343650.740769 457958.753892 inf \n", - "26 387553.261741 459851.993366 inf \n", - "27 357983.056662 455471.906375 inf \n", - "28 368369.784160 458541.506902 inf \n", - "29 345685.373340 457047.936409 inf \n", - "30 426320.093861 454546.519303 inf \n", - "31 427585.588743 461538.408159 inf \n", - "32 376728.920725 456574.397364 inf \n", - "33 392238.633130 457278.838177 inf \n", - "34 428209.211053 454699.104888 inf \n", - "35 414461.110789 456058.544801 inf \n", - "36 343006.625602 455642.820816 inf \n", - "37 342232.642746 453684.658941 inf \n", - "38 357126.722312 454491.481680 inf \n", - "39 303106.289335 453393.217586 inf \n", - "40 355879.690701 453532.539649 inf \n", - "41 316486.677194 455525.969985 inf \n", - "42 400442.667319 453623.172343 inf \n", - "43 357120.223981 455839.764978 inf \n", - "44 333370.975675 453085.420366 inf \n", - "45 310691.844984 451557.724220 inf \n", + "0 404895.268433 388170.416938 388952.687143 \n", + "1 386621.761142 388977.642536 389766.195898 \n", + "2 421535.968891 388911.689878 390581.406135 \n", + "3 400973.159779 389655.410904 391398.321414 \n", + "4 419592.912552 390987.782909 392216.945302 \n", + "5 391638.197677 393005.343703 393037.281371 \n", + "6 456824.623648 393189.485844 393859.333204 \n", + "7 357753.146752 395178.035869 394683.104387 \n", + "8 388673.117569 397007.193660 395508.598518 \n", + "9 373019.671935 395590.239618 396335.819201 \n", + "10 406919.996712 396228.566729 397164.770045 \n", + "11 432861.285260 393402.035448 397995.454671 \n", + "12 527784.234663 390976.277924 398827.876704 \n", + "13 318825.960831 404201.512252 399662.039777 \n", + "14 394260.244027 403020.063982 400497.947534 \n", + "15 387202.538290 401362.282444 401335.603622 \n", + "16 423444.969850 403300.817741 402175.011698 \n", + "17 313717.825313 406220.414477 403016.175427 \n", + "18 353491.313705 404751.067224 403859.098481 \n", + "19 424904.453286 403545.677376 404703.784539 \n", + "20 394030.949034 407191.372127 405550.237289 \n", + "21 396757.245029 407276.140971 406398.460425 \n", + "22 357396.518341 408048.952446 407248.457651 \n", + "23 384605.158226 408947.493196 408100.232678 \n", + "24 402279.134778 408196.179944 408953.789223 \n", + "25 343650.740769 412851.654339 409809.131013 \n", + "26 387553.261741 412999.055953 410666.261781 \n", + "27 357983.056662 412439.576549 411525.185270 \n", + "28 368369.784160 415583.193519 412385.905229 \n", + "29 345685.373340 415439.588486 413248.425414 \n", + "30 426320.093861 411662.387625 414112.749593 \n", + "31 427585.588743 417317.863182 414978.881537 \n", + "32 376728.920725 417068.108674 415846.825027 \n", + "33 392238.633130 416997.538415 416716.583853 \n", + "34 428209.211053 415847.029809 417588.161812 \n", + "35 414461.110789 417671.538047 418461.562707 \n", + "36 343006.625602 422880.625880 419336.790352 \n", + "37 342232.642746 423813.772316 420213.848568 \n", + "38 357126.722312 423217.736245 421092.741184 \n", + "39 303106.289335 426016.517117 421973.472035 \n", + "40 355879.690701 424905.114511 422856.044967 \n", + "41 316486.677194 428467.851539 423740.463833 \n", + "42 400442.667319 425844.848271 424626.732493 \n", + "43 357120.223981 430382.494644 425514.854816 \n", + "44 333370.975675 429356.305250 426404.834679 \n", + "45 310691.844984 430541.830595 427296.675968 \n", "\n", " Difference_in_Expectation \n", - "0 -inf \n", - "1 -inf \n", - "2 -inf \n", - "3 -inf \n", - "4 -inf \n", - "5 -inf \n", - "6 -inf \n", - "7 -inf \n", - "8 -inf \n", - "9 -inf \n", - "10 -inf \n", - "11 -inf \n", - "12 -inf \n", - "13 -inf \n", - "14 -inf \n", - "15 -inf \n", - "16 -inf \n", - "17 -inf \n", - "18 -inf \n", - "19 -inf \n", - "20 -inf \n", - "21 -inf \n", - "22 -inf \n", - "23 -inf \n", - "24 -inf \n", - "25 -inf \n", - "26 -inf \n", - "27 -inf \n", - "28 -inf \n", - "29 -inf \n", - "30 -inf \n", - "31 -inf \n", - "32 -inf \n", - "33 -inf \n", - "34 -inf \n", - "35 -inf \n", - "36 -inf \n", - "37 -inf \n", - "38 -inf \n", - "39 -inf \n", - "40 -inf \n", - "41 -inf \n", - "42 -inf \n", - "43 -inf \n", - "44 -inf \n", - "45 -inf " + "0 -782.270206 \n", + "1 -788.553362 \n", + "2 -1669.716257 \n", + "3 -1742.910510 \n", + "4 -1229.162393 \n", + "5 -31.937669 \n", + "6 -669.847360 \n", + "7 494.931482 \n", + "8 1498.595142 \n", + "9 -745.579583 \n", + "10 -936.203316 \n", + "11 -4593.419222 \n", + "12 -7851.598780 \n", + "13 4539.472475 \n", + "14 2522.116449 \n", + "15 26.678823 \n", + "16 1125.806043 \n", + "17 3204.239050 \n", + "18 891.968743 \n", + "19 -1158.107162 \n", + "20 1641.134838 \n", + "21 877.680546 \n", + "22 800.494794 \n", + "23 847.260518 \n", + "24 -757.609279 \n", + "25 3042.523326 \n", + "26 2332.794171 \n", + "27 914.391279 \n", + "28 3197.288290 \n", + "29 2191.163072 \n", + "30 -2450.361967 \n", + "31 2338.981646 \n", + "32 1221.283647 \n", + "33 280.954562 \n", + "34 -1741.132002 \n", + "35 -790.024660 \n", + "36 3543.835527 \n", + "37 3599.923748 \n", + "38 2124.995061 \n", + "39 4043.045082 \n", + "40 2049.069544 \n", + "41 4727.387706 \n", + "42 1218.115778 \n", + "43 4867.639828 \n", + "44 2951.470571 \n", + "45 3245.154627 " ], "text/html": [ "
\n", @@ -606,14 +606,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -44.979294\n", + " 377371.401757\n", " 398942.636170\n", " 404727.057797\n", " 405704.571665\n", " 404895.268433\n", - " 462904.609783\n", - " inf\n", - " -inf\n", + " 388170.416938\n", + " 388952.687143\n", + " -782.270206\n", " \n", " \n", " 1\n", @@ -626,14 +626,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 332.932458\n", + " 424179.161524\n", " 413397.817913\n", " 388309.667883\n", " 385397.116828\n", " 386621.761142\n", - " 463055.752459\n", - " inf\n", - " -inf\n", + " 388977.642536\n", + " 389766.195898\n", + " -788.553362\n", " \n", " \n", " 2\n", @@ -646,14 +646,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 273.236578\n", + " 416785.291442\n", " 407187.589904\n", " 420216.307417\n", " 421615.911783\n", " 421535.968891\n", - " 462644.111845\n", - " inf\n", - " -inf\n", + " 388911.689878\n", + " 390581.406135\n", + " -1669.716257\n", " \n", " \n", " 3\n", @@ -666,14 +666,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 389.408735\n", + " 431174.255009\n", " 406189.704606\n", " 403165.981005\n", " 401105.177547\n", " 400973.159779\n", - " 460807.846722\n", - " inf\n", - " -inf\n", + " 389655.410904\n", + " 391398.321414\n", + " -1742.910510\n", " \n", " \n", " 4\n", @@ -686,14 +686,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 184.087757\n", + " 405743.410420\n", " 420471.214026\n", " 421450.033447\n", " 424520.950185\n", " 419592.912552\n", - " 463079.419720\n", - " inf\n", - " -inf\n", + " 390987.782909\n", + " 392216.945302\n", + " -1229.162393\n", " \n", " \n", " 5\n", @@ -706,14 +706,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 224.863481\n", + " 410793.849551\n", " 410824.557725\n", " 391493.761671\n", " 388196.210212\n", " 391638.197677\n", - " 462967.863359\n", - " inf\n", - " -inf\n", + " 393005.343703\n", + " 393037.281371\n", + " -31.937669\n", " \n", " \n", " 6\n", @@ -726,14 +726,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 381.703350\n", + " 430219.873937\n", " 432044.900550\n", " 456751.262273\n", " 456752.721138\n", " 456824.623648\n", - " 465600.988271\n", - " inf\n", - " -inf\n", + " 393189.485844\n", + " 393859.333204\n", + " -669.847360\n", " \n", " \n", " 7\n", @@ -746,14 +746,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -407.846396\n", + " 332427.056762\n", " 348112.188236\n", " 353270.524412\n", " 357410.845800\n", " 357753.146752\n", - " 459795.744898\n", - " inf\n", - " -inf\n", + " 395178.035869\n", + " 394683.104387\n", + " 494.931482\n", " \n", " \n", " 8\n", @@ -766,14 +766,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 80.361929\n", + " 392896.036283\n", " 405019.687496\n", " 388565.288508\n", " 388245.552346\n", " 388673.117569\n", - " 463363.585021\n", - " inf\n", - " -inf\n", + " 397007.193660\n", + " 395508.598518\n", + " 1498.595142\n", " \n", " \n", " 9\n", @@ -786,14 +786,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 216.640767\n", + " 409775.392632\n", " 372460.875926\n", " 375124.877747\n", " 371846.112765\n", " 373019.671935\n", - " 459224.382654\n", - " inf\n", - " -inf\n", + " 395590.239618\n", + " 396335.819201\n", + " -745.579583\n", " \n", " \n", " 10\n", @@ -806,14 +806,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 225.326578\n", + " 410851.208278\n", " 408169.132145\n", " 406485.011941\n", " 407092.899084\n", " 406919.996712\n", - " 460943.631939\n", - " inf\n", - " -inf\n", + " 396228.566729\n", + " 397164.770045\n", + " -936.203316\n", " \n", " \n", " 11\n", @@ -826,14 +826,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 594.171531\n", + " 456535.963741\n", " 451325.020396\n", " 433158.134992\n", " 433133.983599\n", " 432861.285260\n", - " 458660.558966\n", - " inf\n", - " -inf\n", + " 393402.035448\n", + " 397995.454671\n", + " -4593.419222\n", " \n", " \n", " 12\n", @@ -846,14 +846,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 560.249358\n", + " 452334.398335\n", " 481501.033891\n", " 524791.840222\n", " 527391.207421\n", " 527784.234663\n", - " 457513.243165\n", - " inf\n", - " -inf\n", + " 390976.277924\n", + " 398827.876704\n", + " -7851.598780\n", " \n", " \n", " 13\n", @@ -866,14 +866,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -435.113264\n", + " 329049.810569\n", " 339513.871817\n", " 320576.954584\n", " 319333.523933\n", " 318825.960831\n", - " 460652.792462\n", - " inf\n", - " -inf\n", + " 404201.512252\n", + " 399662.039777\n", + " 4539.472475\n", " \n", " \n", " 14\n", @@ -886,14 +886,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 255.949977\n", + " 414644.190834\n", " 392029.707764\n", " 393257.108114\n", " 394526.442838\n", " 394260.244027\n", - " 464478.060160\n", - " inf\n", - " -inf\n", + " 403020.063982\n", + " 400497.947534\n", + " 2522.116449\n", " \n", " \n", " 15\n", @@ -906,14 +906,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 74.104759\n", + " 392121.029719\n", " 371789.329465\n", " 387244.681484\n", " 386630.546157\n", " 387202.538290\n", - " 460399.603672\n", - " inf\n", - " -inf\n", + " 401362.282444\n", + " 401335.603622\n", + " 26.678823\n", " \n", " \n", " 16\n", @@ -926,14 +926,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -17.668776\n", + " 380754.054252\n", " 440952.201046\n", " 424662.364695\n", " 425051.043775\n", " 423444.969850\n", - " 462078.098890\n", - " inf\n", - " -inf\n", + " 403300.817741\n", + " 402175.011698\n", + " 1125.806043\n", " \n", " \n", " 17\n", @@ -946,14 +946,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -697.133816\n", + " 296596.215293\n", " 286935.705860\n", " 311049.994112\n", " 312185.510318\n", " 313717.825313\n", - " 458999.883435\n", - " inf\n", - " -inf\n", + " 406220.414477\n", + " 403016.175427\n", + " 3204.239050\n", " \n", " \n", " 18\n", @@ -966,14 +966,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 329.189035\n", + " 423715.504984\n", " 392470.951022\n", " 356521.858749\n", " 353794.312578\n", " 353491.313705\n", - " 458590.220256\n", - " inf\n", - " -inf\n", + " 404751.067224\n", + " 403859.098481\n", + " 891.968743\n", " \n", " \n", " 19\n", @@ -986,14 +986,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -118.064977\n", + " 368319.084368\n", " 394609.621848\n", " 426205.552210\n", " 424729.506080\n", " 424904.453286\n", - " 457829.716881\n", - " inf\n", - " -inf\n", + " 403545.677376\n", + " 404703.784539\n", + " -1158.107162\n", " \n", " \n", " 20\n", @@ -1006,14 +1006,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 284.126060\n", + " 418134.051457\n", " 414178.271428\n", " 393702.776056\n", " 395566.258413\n", " 394030.949034\n", - " 461670.160494\n", - " inf\n", - " -inf\n", + " 407191.372127\n", + " 405550.237289\n", + " 1641.134838\n", " \n", " \n", " 21\n", @@ -1026,14 +1026,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -18.732747\n", + " 380622.271982\n", " 385122.990507\n", " 393876.211485\n", " 395324.082930\n", " 396757.245029\n", - " 459754.510452\n", - " inf\n", - " -inf\n", + " 407276.140971\n", + " 406398.460425\n", + " 877.680546\n", " \n", " \n", " 22\n", @@ -1046,14 +1046,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 48.277785\n", + " 388922.127329\n", " 374058.228036\n", " 360407.393814\n", " 361159.265562\n", " 357396.518341\n", - " 457511.882275\n", - " inf\n", - " -inf\n", + " 408048.952446\n", + " 407248.457651\n", + " 800.494794\n", " \n", " \n", " 23\n", @@ -1066,14 +1066,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -73.095163\n", + " 373888.999201\n", " 367702.143527\n", " 383792.892262\n", " 381569.846621\n", " 384605.158226\n", - " 458112.644483\n", - " inf\n", - " -inf\n", + " 408947.493196\n", + " 408100.232678\n", + " 847.260518\n", " \n", " \n", " 24\n", @@ -1086,14 +1086,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 162.594496\n", + " 403081.277311\n", " 406359.400288\n", " 413379.564221\n", " 402964.624861\n", " 402279.134778\n", - " 456805.271242\n", - " inf\n", - " -inf\n", + " 408196.179944\n", + " 408953.789223\n", + " -757.609279\n", " \n", " \n", " 25\n", @@ -1106,14 +1106,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -43.730389\n", + " 377526.089751\n", " 362825.700917\n", " 354087.658823\n", " 342715.089184\n", " 343650.740769\n", - " 457958.753892\n", - " inf\n", - " -inf\n", + " 412851.654339\n", + " 409809.131013\n", + " 3042.523326\n", " \n", " \n", " 26\n", @@ -1126,14 +1126,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -565.572993\n", + " 312891.203066\n", " 358797.936758\n", " 363399.872412\n", " 387024.433983\n", " 387553.261741\n", - " 459851.993366\n", - " inf\n", - " -inf\n", + " 412999.055953\n", + " 410666.261781\n", + " 2332.794171\n", " \n", " \n", " 27\n", @@ -1146,14 +1146,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 1.193485\n", + " 383090.314471\n", " 375109.947590\n", " 372857.980106\n", " 358164.961912\n", " 357983.056662\n", - " 455471.906375\n", - " inf\n", - " -inf\n", + " 412439.576549\n", + " 411525.185270\n", + " 914.391279\n", " \n", " \n", " 28\n", @@ -1166,14 +1166,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -97.090923\n", + " 370916.909122\n", " 367650.235635\n", " 359381.996323\n", " 367921.786733\n", " 368369.784160\n", - " 458541.506902\n", - " inf\n", - " -inf\n", + " 415583.193519\n", + " 412385.905229\n", + " 3197.288290\n", " \n", " \n", " 29\n", @@ -1186,14 +1186,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -193.472441\n", + " 358979.193679\n", " 363845.441546\n", " 357419.463077\n", " 345612.633741\n", " 345685.373340\n", - " 457047.936409\n", - " inf\n", - " -inf\n", + " 415439.588486\n", + " 413248.425414\n", + " 2191.163072\n", " \n", " \n", " 30\n", @@ -1206,14 +1206,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 227.006074\n", + " 411059.228901\n", " 398093.244924\n", " 420338.093431\n", " 427216.475603\n", " 426320.093861\n", - " 454546.519303\n", - " inf\n", - " -inf\n", + " 411662.387625\n", + " 414112.749593\n", + " -2450.361967\n", " \n", " \n", " 31\n", @@ -1226,14 +1226,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 603.020776\n", + " 457632.022035\n", " 460331.584266\n", " 421106.585969\n", " 427549.155747\n", " 427585.588743\n", - " 461538.408159\n", - " inf\n", - " -inf\n", + " 417317.863182\n", + " 414978.881537\n", + " 2338.981646\n", " \n", " \n", " 32\n", @@ -1246,14 +1246,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -135.507846\n", + " 366158.628623\n", " 355110.662118\n", " 385804.286252\n", " 377495.302483\n", " 376728.920725\n", - " 456574.397364\n", - " inf\n", - " -inf\n", + " 417068.108674\n", + " 415846.825027\n", + " 1221.283647\n", " \n", " \n", " 33\n", @@ -1266,14 +1266,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 256.799140\n", + " 414749.367352\n", " 404952.222454\n", " 380148.672904\n", " 390887.435379\n", " 392238.633130\n", - " 457278.838177\n", - " inf\n", - " -inf\n", + " 416997.538415\n", + " 416716.583853\n", + " 280.954562\n", " \n", " \n", " 34\n", @@ -1286,14 +1286,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 90.745815\n", + " 394182.173776\n", " 405715.733698\n", " 429608.759456\n", " 429014.390163\n", " 428209.211053\n", - " 454699.104888\n", - " inf\n", - " -inf\n", + " 415847.029809\n", + " 417588.161812\n", + " -1741.132002\n", " \n", " \n", " 35\n", @@ -1306,14 +1306,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 242.112335\n", + " 412930.274807\n", " 409799.355286\n", " 410974.276816\n", " 413298.745816\n", " 414461.110789\n", - " 456058.544801\n", - " inf\n", - " -inf\n", + " 417671.538047\n", + " 418461.562707\n", + " -790.024660\n", " \n", " \n", " 36\n", @@ -1326,14 +1326,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -260.245065\n", + " 350708.805302\n", " 353761.775712\n", " 344252.932147\n", " 343209.200439\n", " 343006.625602\n", - " 455642.820816\n", - " inf\n", - " -inf\n", + " 422880.625880\n", + " 419336.790352\n", + " 3543.835527\n", " \n", " \n", " 37\n", @@ -1346,14 +1346,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -724.695938\n", + " 293182.399170\n", " 325069.624722\n", " 344289.047467\n", " 342084.186261\n", " 342232.642746\n", - " 453684.658941\n", - " inf\n", - " -inf\n", + " 423813.772316\n", + " 420213.848568\n", + " 3599.923748\n", " \n", " \n", " 38\n", @@ -1366,14 +1366,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -44.117900\n", + " 377478.093086\n", " 353257.222779\n", " 353764.890202\n", " 357823.798670\n", " 357126.722312\n", - " 454491.481680\n", - " inf\n", - " -inf\n", + " 423217.736245\n", + " 421092.741184\n", + " 2124.995061\n", " \n", " \n", " 39\n", @@ -1386,14 +1386,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -739.389811\n", + " 291362.431282\n", " 302326.827366\n", " 304020.083180\n", " 303828.779931\n", " 303106.289335\n", - " 453393.217586\n", - " inf\n", - " -inf\n", + " 426016.517117\n", + " 421973.472035\n", + " 4043.045082\n", " \n", " \n", " 40\n", @@ -1406,14 +1406,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -112.802197\n", + " 368970.926878\n", " 368964.162462\n", " 357775.533341\n", " 356652.040920\n", " 355879.690701\n", - " 453532.539649\n", - " inf\n", - " -inf\n", + " 424905.114511\n", + " 422856.044967\n", + " 2049.069544\n", " \n", " \n", " 41\n", @@ -1426,14 +1426,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 115.639539\n", + " 397265.484764\n", " 323346.039126\n", " 322784.762289\n", " 316952.269236\n", " 316486.677194\n", - " 455525.969985\n", - " inf\n", - " -inf\n", + " 428467.851539\n", + " 423740.463833\n", + " 4727.387706\n", " \n", " \n", " 42\n", @@ -1446,14 +1446,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -443.853139\n", + " 327967.298680\n", " 383625.207672\n", " 394279.969633\n", " 398120.412976\n", " 400442.667319\n", - " 453623.172343\n", - " inf\n", - " -inf\n", + " 425844.848271\n", + " 424626.732493\n", + " 1218.115778\n", " \n", " \n", " 43\n", @@ -1466,14 +1466,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -542.264304\n", + " 315778.193228\n", " 360494.854893\n", " 356119.648704\n", " 357486.445092\n", " 357120.223981\n", - " 455839.764978\n", - " inf\n", - " -inf\n", + " 430382.494644\n", + " 425514.854816\n", + " 4867.639828\n", " \n", " \n", " 44\n", @@ -1486,14 +1486,14 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -326.448717\n", + " 342508.889264\n", " 323961.673652\n", " 331898.505904\n", " 332841.894862\n", " 333370.975675\n", - " 453085.420366\n", - " inf\n", - " -inf\n", + " 429356.305250\n", + " 426404.834679\n", + " 2951.470571\n", " \n", " \n", " 45\n", @@ -1506,32 +1506,32 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -111.915703\n", + " 369080.727151\n", " 347439.884447\n", " 315453.846359\n", " 311453.513947\n", " 310691.844984\n", - " 451557.724220\n", - " inf\n", - " -inf\n", + " 430541.830595\n", + " 427296.675968\n", + " 3245.154627\n", " \n", " \n", "\n", "
" ] }, - "execution_count": 43, + "execution_count": 55, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 43 + "execution_count": 55 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-10T12:59:23.840232Z", - "start_time": "2025-01-10T12:59:23.811190Z" + "end_time": "2025-01-13T10:17:15.993279Z", + "start_time": "2025-01-13T10:17:15.830390Z" } }, "cell_type": "code", @@ -1785,52 +1785,52 @@ "45 GovernmentGovernmentGovernmentGovernmentGovern... \n", "\n", " Facility_Type Precipitation \\\n", - "0 ClinicDistrict HospitalRural/Community Hospita... -44.979294 \n", - "1 ClinicDistrict HospitalRural/Community Hospita... 332.932458 \n", - "2 ClinicDistrict HospitalRural/Community Hospita... 273.236578 \n", - "3 ClinicDistrict HospitalRural/Community Hospita... 389.408735 \n", - "4 ClinicDistrict HospitalRural/Community Hospita... 184.087757 \n", - "5 ClinicDistrict HospitalRural/Community Hospita... 224.863481 \n", - "6 ClinicDistrict HospitalRural/Community Hospita... 381.703350 \n", - "7 ClinicDistrict HospitalRural/Community Hospita... -407.846396 \n", - "8 ClinicDistrict HospitalRural/Community Hospita... 80.361929 \n", - "9 ClinicDistrict HospitalRural/Community Hospita... 216.640767 \n", - "10 ClinicDistrict HospitalRural/Community Hospita... 225.326578 \n", - "11 ClinicDistrict HospitalRural/Community Hospita... 594.171531 \n", - "12 ClinicDistrict HospitalRural/Community Hospita... 560.249358 \n", - "13 ClinicDistrict HospitalRural/Community Hospita... -435.113264 \n", - "14 ClinicDistrict HospitalRural/Community Hospita... 255.949977 \n", - "15 ClinicDistrict HospitalRural/Community Hospita... 74.104759 \n", - "16 ClinicDistrict HospitalRural/Community Hospita... -17.668776 \n", - "17 ClinicDistrict HospitalRural/Community Hospita... -697.133816 \n", - "18 ClinicDistrict HospitalRural/Community Hospita... 329.189035 \n", - "19 ClinicDistrict HospitalRural/Community Hospita... -118.064977 \n", - "20 ClinicDistrict HospitalRural/Community Hospita... 284.126060 \n", - "21 ClinicDistrict HospitalRural/Community Hospita... -18.732747 \n", - "22 ClinicDistrict HospitalRural/Community Hospita... 48.277785 \n", - "23 ClinicDistrict HospitalRural/Community Hospita... -73.095163 \n", - "24 ClinicDistrict HospitalRural/Community Hospita... 162.594496 \n", - "25 ClinicDistrict HospitalRural/Community Hospita... -43.730389 \n", - "26 ClinicDistrict HospitalRural/Community Hospita... -565.572993 \n", - "27 ClinicDistrict HospitalRural/Community Hospita... 1.193485 \n", - "28 ClinicDistrict HospitalRural/Community Hospita... -97.090923 \n", - "29 ClinicDistrict HospitalRural/Community Hospita... -193.472441 \n", - "30 ClinicDistrict HospitalRural/Community Hospita... 227.006074 \n", - "31 ClinicDistrict HospitalRural/Community Hospita... 603.020776 \n", - "32 ClinicDistrict HospitalRural/Community Hospita... -135.507846 \n", - "33 ClinicDistrict HospitalRural/Community Hospita... 256.799140 \n", - "34 ClinicDistrict HospitalRural/Community Hospita... 90.745815 \n", - "35 ClinicDistrict HospitalRural/Community Hospita... 242.112335 \n", - "36 ClinicDistrict HospitalRural/Community Hospita... -260.245065 \n", - "37 ClinicDistrict HospitalRural/Community Hospita... -724.695938 \n", - "38 ClinicDistrict HospitalRural/Community Hospita... -44.117900 \n", - "39 ClinicDistrict HospitalRural/Community Hospita... -739.389811 \n", - "40 ClinicDistrict HospitalRural/Community Hospita... -112.802197 \n", - "41 ClinicDistrict HospitalRural/Community Hospita... 115.639539 \n", - "42 ClinicDistrict HospitalRural/Community Hospita... -443.853139 \n", - "43 ClinicDistrict HospitalRural/Community Hospita... -542.264304 \n", - "44 ClinicDistrict HospitalRural/Community Hospita... -326.448717 \n", - "45 ClinicDistrict HospitalRural/Community Hospita... -111.915703 \n", + "0 ClinicDistrict HospitalRural/Community Hospita... 377371.401757 \n", + "1 ClinicDistrict HospitalRural/Community Hospita... 424179.161524 \n", + "2 ClinicDistrict HospitalRural/Community Hospita... 416785.291442 \n", + "3 ClinicDistrict HospitalRural/Community Hospita... 431174.255009 \n", + "4 ClinicDistrict HospitalRural/Community Hospita... 405743.410420 \n", + "5 ClinicDistrict HospitalRural/Community Hospita... 410793.849551 \n", + "6 ClinicDistrict HospitalRural/Community Hospita... 430219.873937 \n", + "7 ClinicDistrict HospitalRural/Community Hospita... 332427.056762 \n", + "8 ClinicDistrict HospitalRural/Community Hospita... 392896.036283 \n", + "9 ClinicDistrict HospitalRural/Community Hospita... 409775.392632 \n", + "10 ClinicDistrict HospitalRural/Community Hospita... 410851.208278 \n", + "11 ClinicDistrict HospitalRural/Community Hospita... 456535.963741 \n", + "12 ClinicDistrict HospitalRural/Community Hospita... 452334.398335 \n", + "13 ClinicDistrict HospitalRural/Community Hospita... 329049.810569 \n", + "14 ClinicDistrict HospitalRural/Community Hospita... 414644.190834 \n", + "15 ClinicDistrict HospitalRural/Community Hospita... 392121.029719 \n", + "16 ClinicDistrict HospitalRural/Community Hospita... 380754.054252 \n", + "17 ClinicDistrict HospitalRural/Community Hospita... 296596.215293 \n", + "18 ClinicDistrict HospitalRural/Community Hospita... 423715.504984 \n", + "19 ClinicDistrict HospitalRural/Community Hospita... 368319.084368 \n", + "20 ClinicDistrict HospitalRural/Community Hospita... 418134.051457 \n", + "21 ClinicDistrict HospitalRural/Community Hospita... 380622.271982 \n", + "22 ClinicDistrict HospitalRural/Community Hospita... 388922.127329 \n", + "23 ClinicDistrict HospitalRural/Community Hospita... 373888.999201 \n", + "24 ClinicDistrict HospitalRural/Community Hospita... 403081.277311 \n", + "25 ClinicDistrict HospitalRural/Community Hospita... 377526.089751 \n", + "26 ClinicDistrict HospitalRural/Community Hospita... 312891.203066 \n", + "27 ClinicDistrict HospitalRural/Community Hospita... 383090.314471 \n", + "28 ClinicDistrict HospitalRural/Community Hospita... 370916.909122 \n", + "29 ClinicDistrict HospitalRural/Community Hospita... 358979.193679 \n", + "30 ClinicDistrict HospitalRural/Community Hospita... 411059.228901 \n", + "31 ClinicDistrict HospitalRural/Community Hospita... 457632.022035 \n", + "32 ClinicDistrict HospitalRural/Community Hospita... 366158.628623 \n", + "33 ClinicDistrict HospitalRural/Community Hospita... 414749.367352 \n", + "34 ClinicDistrict HospitalRural/Community Hospita... 394182.173776 \n", + "35 ClinicDistrict HospitalRural/Community Hospita... 412930.274807 \n", + "36 ClinicDistrict HospitalRural/Community Hospita... 350708.805302 \n", + "37 ClinicDistrict HospitalRural/Community Hospita... 293182.399170 \n", + "38 ClinicDistrict HospitalRural/Community Hospita... 377478.093086 \n", + "39 ClinicDistrict HospitalRural/Community Hospita... 291362.431282 \n", + "40 ClinicDistrict HospitalRural/Community Hospita... 368970.926878 \n", + "41 ClinicDistrict HospitalRural/Community Hospita... 397265.484764 \n", + "42 ClinicDistrict HospitalRural/Community Hospita... 327967.298680 \n", + "43 ClinicDistrict HospitalRural/Community Hospita... 315778.193228 \n", + "44 ClinicDistrict HospitalRural/Community Hospita... 342508.889264 \n", + "45 ClinicDistrict HospitalRural/Community Hospita... 369080.727151 \n", "\n", " Lag_1_Precipitation Lag_2_Precipitation Lag_3_Precipitation \\\n", "0 398942.636170 404727.057797 405704.571665 \n", @@ -1881,100 +1881,100 @@ "45 347439.884447 315453.846359 311453.513947 \n", "\n", " Lag_4_Precipitation Predicted_Weather_Model Predicted_No_Weather_Model \\\n", - "0 404895.268433 462904.609783 inf \n", - "1 386621.761142 463055.752459 inf \n", - "2 421535.968891 462644.111845 inf \n", - "3 400973.159779 460807.846722 inf \n", - "4 419592.912552 463079.419720 inf \n", - "5 391638.197677 462967.863359 inf \n", - "6 456824.623648 465600.988271 inf \n", - "7 357753.146752 459795.744898 inf \n", - "8 388673.117569 463363.585021 inf \n", - "9 373019.671935 459224.382654 inf \n", - "10 406919.996712 460943.631939 inf \n", - "11 432861.285260 458660.558966 inf \n", - "12 527784.234663 457513.243165 inf \n", - "13 318825.960831 460652.792462 inf \n", - "14 394260.244027 464478.060160 inf \n", - "15 387202.538290 460399.603672 inf \n", - "16 423444.969850 462078.098890 inf \n", - "17 313717.825313 458999.883435 inf \n", - "18 353491.313705 458590.220256 inf \n", - "19 424904.453286 457829.716881 inf \n", - "20 394030.949034 461670.160494 inf \n", - "21 396757.245029 459754.510452 inf \n", - "22 357396.518341 457511.882275 inf \n", - "23 384605.158226 458112.644483 inf \n", - "24 402279.134778 456805.271242 inf \n", - "25 343650.740769 457958.753892 inf \n", - "26 387553.261741 459851.993366 inf \n", - "27 357983.056662 455471.906375 inf \n", - "28 368369.784160 458541.506902 inf \n", - "29 345685.373340 457047.936409 inf \n", - "30 426320.093861 454546.519303 inf \n", - "31 427585.588743 461538.408159 inf \n", - "32 376728.920725 456574.397364 inf \n", - "33 392238.633130 457278.838177 inf \n", - "34 428209.211053 454699.104888 inf \n", - "35 414461.110789 456058.544801 inf \n", - "36 343006.625602 455642.820816 inf \n", - "37 342232.642746 453684.658941 inf \n", - "38 357126.722312 454491.481680 inf \n", - "39 303106.289335 453393.217586 inf \n", - "40 355879.690701 453532.539649 inf \n", - "41 316486.677194 455525.969985 inf \n", - "42 400442.667319 453623.172343 inf \n", - "43 357120.223981 455839.764978 inf \n", - "44 333370.975675 453085.420366 inf \n", - "45 310691.844984 451557.724220 inf \n", + "0 404895.268433 388170.416938 388952.687143 \n", + "1 386621.761142 388977.642536 389766.195898 \n", + "2 421535.968891 388911.689878 390581.406135 \n", + "3 400973.159779 389655.410904 391398.321414 \n", + "4 419592.912552 390987.782909 392216.945302 \n", + "5 391638.197677 393005.343703 393037.281371 \n", + "6 456824.623648 393189.485844 393859.333204 \n", + "7 357753.146752 395178.035869 394683.104387 \n", + "8 388673.117569 397007.193660 395508.598518 \n", + "9 373019.671935 395590.239618 396335.819201 \n", + "10 406919.996712 396228.566729 397164.770045 \n", + "11 432861.285260 393402.035448 397995.454671 \n", + "12 527784.234663 390976.277924 398827.876704 \n", + "13 318825.960831 404201.512252 399662.039777 \n", + "14 394260.244027 403020.063982 400497.947534 \n", + "15 387202.538290 401362.282444 401335.603622 \n", + "16 423444.969850 403300.817741 402175.011698 \n", + "17 313717.825313 406220.414477 403016.175427 \n", + "18 353491.313705 404751.067224 403859.098481 \n", + "19 424904.453286 403545.677376 404703.784539 \n", + "20 394030.949034 407191.372127 405550.237289 \n", + "21 396757.245029 407276.140971 406398.460425 \n", + "22 357396.518341 408048.952446 407248.457651 \n", + "23 384605.158226 408947.493196 408100.232678 \n", + "24 402279.134778 408196.179944 408953.789223 \n", + "25 343650.740769 412851.654339 409809.131013 \n", + "26 387553.261741 412999.055953 410666.261781 \n", + "27 357983.056662 412439.576549 411525.185270 \n", + "28 368369.784160 415583.193519 412385.905229 \n", + "29 345685.373340 415439.588486 413248.425414 \n", + "30 426320.093861 411662.387625 414112.749593 \n", + "31 427585.588743 417317.863182 414978.881537 \n", + "32 376728.920725 417068.108674 415846.825027 \n", + "33 392238.633130 416997.538415 416716.583853 \n", + "34 428209.211053 415847.029809 417588.161812 \n", + "35 414461.110789 417671.538047 418461.562707 \n", + "36 343006.625602 422880.625880 419336.790352 \n", + "37 342232.642746 423813.772316 420213.848568 \n", + "38 357126.722312 423217.736245 421092.741184 \n", + "39 303106.289335 426016.517117 421973.472035 \n", + "40 355879.690701 424905.114511 422856.044967 \n", + "41 316486.677194 428467.851539 423740.463833 \n", + "42 400442.667319 425844.848271 424626.732493 \n", + "43 357120.223981 430382.494644 425514.854816 \n", + "44 333370.975675 429356.305250 426404.834679 \n", + "45 310691.844984 430541.830595 427296.675968 \n", "\n", " Difference_in_Expectation Percentage_Difference \n", - "0 -inf NaN \n", - "1 -inf NaN \n", - "2 -inf NaN \n", - "3 -inf NaN \n", - "4 -inf NaN \n", - "5 -inf NaN \n", - "6 -inf NaN \n", - "7 -inf NaN \n", - "8 -inf NaN \n", - "9 -inf NaN \n", - "10 -inf NaN \n", - "11 -inf NaN \n", - "12 -inf NaN \n", - "13 -inf NaN \n", - "14 -inf NaN \n", - "15 -inf NaN \n", - "16 -inf NaN \n", - "17 -inf NaN \n", - "18 -inf NaN \n", - "19 -inf NaN \n", - "20 -inf NaN \n", - "21 -inf NaN \n", - "22 -inf NaN \n", - "23 -inf NaN \n", - "24 -inf NaN \n", - "25 -inf NaN \n", - "26 -inf NaN \n", - "27 -inf NaN \n", - "28 -inf NaN \n", - "29 -inf NaN \n", - "30 -inf NaN \n", - "31 -inf NaN \n", - "32 -inf NaN \n", - "33 -inf NaN \n", - "34 -inf NaN \n", - "35 -inf NaN \n", - "36 -inf NaN \n", - "37 -inf NaN \n", - "38 -inf NaN \n", - "39 -inf NaN \n", - "40 -inf NaN \n", - "41 -inf NaN \n", - "42 -inf NaN \n", - "43 -inf NaN \n", - "44 -inf NaN \n", - "45 -inf NaN " + "0 -782.270206 -0.002011 \n", + "1 -788.553362 -0.002023 \n", + "2 -1669.716257 -0.004275 \n", + "3 -1742.910510 -0.004453 \n", + "4 -1229.162393 -0.003134 \n", + "5 -31.937669 -0.000081 \n", + "6 -669.847360 -0.001701 \n", + "7 494.931482 0.001254 \n", + "8 1498.595142 0.003789 \n", + "9 -745.579583 -0.001881 \n", + "10 -936.203316 -0.002357 \n", + "11 -4593.419222 -0.011541 \n", + "12 -7851.598780 -0.019687 \n", + "13 4539.472475 0.011358 \n", + "14 2522.116449 0.006297 \n", + "15 26.678823 0.000066 \n", + "16 1125.806043 0.002799 \n", + "17 3204.239050 0.007951 \n", + "18 891.968743 0.002209 \n", + "19 -1158.107162 -0.002862 \n", + "20 1641.134838 0.004047 \n", + "21 877.680546 0.002160 \n", + "22 800.494794 0.001966 \n", + "23 847.260518 0.002076 \n", + "24 -757.609279 -0.001853 \n", + "25 3042.523326 0.007424 \n", + "26 2332.794171 0.005681 \n", + "27 914.391279 0.002222 \n", + "28 3197.288290 0.007753 \n", + "29 2191.163072 0.005302 \n", + "30 -2450.361967 -0.005917 \n", + "31 2338.981646 0.005636 \n", + "32 1221.283647 0.002937 \n", + "33 280.954562 0.000674 \n", + "34 -1741.132002 -0.004169 \n", + "35 -790.024660 -0.001888 \n", + "36 3543.835527 0.008451 \n", + "37 3599.923748 0.008567 \n", + "38 2124.995061 0.005046 \n", + "39 4043.045082 0.009581 \n", + "40 2049.069544 0.004846 \n", + "41 4727.387706 0.011156 \n", + "42 1218.115778 0.002869 \n", + "43 4867.639828 0.011439 \n", + "44 2951.470571 0.006922 \n", + "45 3245.154627 0.007595 " ], "text/html": [ "
\n", @@ -2027,15 +2027,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -44.979294\n", + " 377371.401757\n", " 398942.636170\n", " 404727.057797\n", " 405704.571665\n", " 404895.268433\n", - " 462904.609783\n", - " inf\n", - " -inf\n", - " NaN\n", + " 388170.416938\n", + " 388952.687143\n", + " -782.270206\n", + " -0.002011\n", " \n", " \n", " 1\n", @@ -2048,15 +2048,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 332.932458\n", + " 424179.161524\n", " 413397.817913\n", " 388309.667883\n", " 385397.116828\n", " 386621.761142\n", - " 463055.752459\n", - " inf\n", - " -inf\n", - " NaN\n", + " 388977.642536\n", + " 389766.195898\n", + " -788.553362\n", + " -0.002023\n", " \n", " \n", " 2\n", @@ -2069,15 +2069,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 273.236578\n", + " 416785.291442\n", " 407187.589904\n", " 420216.307417\n", " 421615.911783\n", " 421535.968891\n", - " 462644.111845\n", - " inf\n", - " -inf\n", - " NaN\n", + " 388911.689878\n", + " 390581.406135\n", + " -1669.716257\n", + " -0.004275\n", " \n", " \n", " 3\n", @@ -2090,15 +2090,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 389.408735\n", + " 431174.255009\n", " 406189.704606\n", " 403165.981005\n", " 401105.177547\n", " 400973.159779\n", - " 460807.846722\n", - " inf\n", - " -inf\n", - " NaN\n", + " 389655.410904\n", + " 391398.321414\n", + " -1742.910510\n", + " -0.004453\n", " \n", " \n", " 4\n", @@ -2111,15 +2111,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 184.087757\n", + " 405743.410420\n", " 420471.214026\n", " 421450.033447\n", " 424520.950185\n", " 419592.912552\n", - " 463079.419720\n", - " inf\n", - " -inf\n", - " NaN\n", + " 390987.782909\n", + " 392216.945302\n", + " -1229.162393\n", + " -0.003134\n", " \n", " \n", " 5\n", @@ -2132,15 +2132,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 224.863481\n", + " 410793.849551\n", " 410824.557725\n", " 391493.761671\n", " 388196.210212\n", " 391638.197677\n", - " 462967.863359\n", - " inf\n", - " -inf\n", - " NaN\n", + " 393005.343703\n", + " 393037.281371\n", + " -31.937669\n", + " -0.000081\n", " \n", " \n", " 6\n", @@ -2153,15 +2153,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 381.703350\n", + " 430219.873937\n", " 432044.900550\n", " 456751.262273\n", " 456752.721138\n", " 456824.623648\n", - " 465600.988271\n", - " inf\n", - " -inf\n", - " NaN\n", + " 393189.485844\n", + " 393859.333204\n", + " -669.847360\n", + " -0.001701\n", " \n", " \n", " 7\n", @@ -2174,15 +2174,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -407.846396\n", + " 332427.056762\n", " 348112.188236\n", " 353270.524412\n", " 357410.845800\n", " 357753.146752\n", - " 459795.744898\n", - " inf\n", - " -inf\n", - " NaN\n", + " 395178.035869\n", + " 394683.104387\n", + " 494.931482\n", + " 0.001254\n", " \n", " \n", " 8\n", @@ -2195,15 +2195,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 80.361929\n", + " 392896.036283\n", " 405019.687496\n", " 388565.288508\n", " 388245.552346\n", " 388673.117569\n", - " 463363.585021\n", - " inf\n", - " -inf\n", - " NaN\n", + " 397007.193660\n", + " 395508.598518\n", + " 1498.595142\n", + " 0.003789\n", " \n", " \n", " 9\n", @@ -2216,15 +2216,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 216.640767\n", + " 409775.392632\n", " 372460.875926\n", " 375124.877747\n", " 371846.112765\n", " 373019.671935\n", - " 459224.382654\n", - " inf\n", - " -inf\n", - " NaN\n", + " 395590.239618\n", + " 396335.819201\n", + " -745.579583\n", + " -0.001881\n", " \n", " \n", " 10\n", @@ -2237,15 +2237,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 225.326578\n", + " 410851.208278\n", " 408169.132145\n", " 406485.011941\n", " 407092.899084\n", " 406919.996712\n", - " 460943.631939\n", - " inf\n", - " -inf\n", - " NaN\n", + " 396228.566729\n", + " 397164.770045\n", + " -936.203316\n", + " -0.002357\n", " \n", " \n", " 11\n", @@ -2258,15 +2258,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 594.171531\n", + " 456535.963741\n", " 451325.020396\n", " 433158.134992\n", " 433133.983599\n", " 432861.285260\n", - " 458660.558966\n", - " inf\n", - " -inf\n", - " NaN\n", + " 393402.035448\n", + " 397995.454671\n", + " -4593.419222\n", + " -0.011541\n", " \n", " \n", " 12\n", @@ -2279,15 +2279,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 560.249358\n", + " 452334.398335\n", " 481501.033891\n", " 524791.840222\n", " 527391.207421\n", " 527784.234663\n", - " 457513.243165\n", - " inf\n", - " -inf\n", - " NaN\n", + " 390976.277924\n", + " 398827.876704\n", + " -7851.598780\n", + " -0.019687\n", " \n", " \n", " 13\n", @@ -2300,15 +2300,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -435.113264\n", + " 329049.810569\n", " 339513.871817\n", " 320576.954584\n", " 319333.523933\n", " 318825.960831\n", - " 460652.792462\n", - " inf\n", - " -inf\n", - " NaN\n", + " 404201.512252\n", + " 399662.039777\n", + " 4539.472475\n", + " 0.011358\n", " \n", " \n", " 14\n", @@ -2321,15 +2321,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 255.949977\n", + " 414644.190834\n", " 392029.707764\n", " 393257.108114\n", " 394526.442838\n", " 394260.244027\n", - " 464478.060160\n", - " inf\n", - " -inf\n", - " NaN\n", + " 403020.063982\n", + " 400497.947534\n", + " 2522.116449\n", + " 0.006297\n", " \n", " \n", " 15\n", @@ -2342,15 +2342,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 74.104759\n", + " 392121.029719\n", " 371789.329465\n", " 387244.681484\n", " 386630.546157\n", " 387202.538290\n", - " 460399.603672\n", - " inf\n", - " -inf\n", - " NaN\n", + " 401362.282444\n", + " 401335.603622\n", + " 26.678823\n", + " 0.000066\n", " \n", " \n", " 16\n", @@ -2363,15 +2363,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -17.668776\n", + " 380754.054252\n", " 440952.201046\n", " 424662.364695\n", " 425051.043775\n", " 423444.969850\n", - " 462078.098890\n", - " inf\n", - " -inf\n", - " NaN\n", + " 403300.817741\n", + " 402175.011698\n", + " 1125.806043\n", + " 0.002799\n", " \n", " \n", " 17\n", @@ -2384,15 +2384,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -697.133816\n", + " 296596.215293\n", " 286935.705860\n", " 311049.994112\n", " 312185.510318\n", " 313717.825313\n", - " 458999.883435\n", - " inf\n", - " -inf\n", - " NaN\n", + " 406220.414477\n", + " 403016.175427\n", + " 3204.239050\n", + " 0.007951\n", " \n", " \n", " 18\n", @@ -2405,15 +2405,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 329.189035\n", + " 423715.504984\n", " 392470.951022\n", " 356521.858749\n", " 353794.312578\n", " 353491.313705\n", - " 458590.220256\n", - " inf\n", - " -inf\n", - " NaN\n", + " 404751.067224\n", + " 403859.098481\n", + " 891.968743\n", + " 0.002209\n", " \n", " \n", " 19\n", @@ -2426,15 +2426,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -118.064977\n", + " 368319.084368\n", " 394609.621848\n", " 426205.552210\n", " 424729.506080\n", " 424904.453286\n", - " 457829.716881\n", - " inf\n", - " -inf\n", - " NaN\n", + " 403545.677376\n", + " 404703.784539\n", + " -1158.107162\n", + " -0.002862\n", " \n", " \n", " 20\n", @@ -2447,15 +2447,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 284.126060\n", + " 418134.051457\n", " 414178.271428\n", " 393702.776056\n", " 395566.258413\n", " 394030.949034\n", - " 461670.160494\n", - " inf\n", - " -inf\n", - " NaN\n", + " 407191.372127\n", + " 405550.237289\n", + " 1641.134838\n", + " 0.004047\n", " \n", " \n", " 21\n", @@ -2468,15 +2468,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -18.732747\n", + " 380622.271982\n", " 385122.990507\n", " 393876.211485\n", " 395324.082930\n", " 396757.245029\n", - " 459754.510452\n", - " inf\n", - " -inf\n", - " NaN\n", + " 407276.140971\n", + " 406398.460425\n", + " 877.680546\n", + " 0.002160\n", " \n", " \n", " 22\n", @@ -2489,15 +2489,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 48.277785\n", + " 388922.127329\n", " 374058.228036\n", " 360407.393814\n", " 361159.265562\n", " 357396.518341\n", - " 457511.882275\n", - " inf\n", - " -inf\n", - " NaN\n", + " 408048.952446\n", + " 407248.457651\n", + " 800.494794\n", + " 0.001966\n", " \n", " \n", " 23\n", @@ -2510,15 +2510,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -73.095163\n", + " 373888.999201\n", " 367702.143527\n", " 383792.892262\n", " 381569.846621\n", " 384605.158226\n", - " 458112.644483\n", - " inf\n", - " -inf\n", - " NaN\n", + " 408947.493196\n", + " 408100.232678\n", + " 847.260518\n", + " 0.002076\n", " \n", " \n", " 24\n", @@ -2531,15 +2531,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 162.594496\n", + " 403081.277311\n", " 406359.400288\n", " 413379.564221\n", " 402964.624861\n", " 402279.134778\n", - " 456805.271242\n", - " inf\n", - " -inf\n", - " NaN\n", + " 408196.179944\n", + " 408953.789223\n", + " -757.609279\n", + " -0.001853\n", " \n", " \n", " 25\n", @@ -2552,15 +2552,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -43.730389\n", + " 377526.089751\n", " 362825.700917\n", " 354087.658823\n", " 342715.089184\n", " 343650.740769\n", - " 457958.753892\n", - " inf\n", - " -inf\n", - " NaN\n", + " 412851.654339\n", + " 409809.131013\n", + " 3042.523326\n", + " 0.007424\n", " \n", " \n", " 26\n", @@ -2573,15 +2573,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -565.572993\n", + " 312891.203066\n", " 358797.936758\n", " 363399.872412\n", " 387024.433983\n", " 387553.261741\n", - " 459851.993366\n", - " inf\n", - " -inf\n", - " NaN\n", + " 412999.055953\n", + " 410666.261781\n", + " 2332.794171\n", + " 0.005681\n", " \n", " \n", " 27\n", @@ -2594,15 +2594,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 1.193485\n", + " 383090.314471\n", " 375109.947590\n", " 372857.980106\n", " 358164.961912\n", " 357983.056662\n", - " 455471.906375\n", - " inf\n", - " -inf\n", - " NaN\n", + " 412439.576549\n", + " 411525.185270\n", + " 914.391279\n", + " 0.002222\n", " \n", " \n", " 28\n", @@ -2615,15 +2615,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -97.090923\n", + " 370916.909122\n", " 367650.235635\n", " 359381.996323\n", " 367921.786733\n", " 368369.784160\n", - " 458541.506902\n", - " inf\n", - " -inf\n", - " NaN\n", + " 415583.193519\n", + " 412385.905229\n", + " 3197.288290\n", + " 0.007753\n", " \n", " \n", " 29\n", @@ -2636,15 +2636,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -193.472441\n", + " 358979.193679\n", " 363845.441546\n", " 357419.463077\n", " 345612.633741\n", " 345685.373340\n", - " 457047.936409\n", - " inf\n", - " -inf\n", - " NaN\n", + " 415439.588486\n", + " 413248.425414\n", + " 2191.163072\n", + " 0.005302\n", " \n", " \n", " 30\n", @@ -2657,15 +2657,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 227.006074\n", + " 411059.228901\n", " 398093.244924\n", " 420338.093431\n", " 427216.475603\n", " 426320.093861\n", - " 454546.519303\n", - " inf\n", - " -inf\n", - " NaN\n", + " 411662.387625\n", + " 414112.749593\n", + " -2450.361967\n", + " -0.005917\n", " \n", " \n", " 31\n", @@ -2678,15 +2678,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 603.020776\n", + " 457632.022035\n", " 460331.584266\n", " 421106.585969\n", " 427549.155747\n", " 427585.588743\n", - " 461538.408159\n", - " inf\n", - " -inf\n", - " NaN\n", + " 417317.863182\n", + " 414978.881537\n", + " 2338.981646\n", + " 0.005636\n", " \n", " \n", " 32\n", @@ -2699,15 +2699,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -135.507846\n", + " 366158.628623\n", " 355110.662118\n", " 385804.286252\n", " 377495.302483\n", " 376728.920725\n", - " 456574.397364\n", - " inf\n", - " -inf\n", - " NaN\n", + " 417068.108674\n", + " 415846.825027\n", + " 1221.283647\n", + " 0.002937\n", " \n", " \n", " 33\n", @@ -2720,15 +2720,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 256.799140\n", + " 414749.367352\n", " 404952.222454\n", " 380148.672904\n", " 390887.435379\n", " 392238.633130\n", - " 457278.838177\n", - " inf\n", - " -inf\n", - " NaN\n", + " 416997.538415\n", + " 416716.583853\n", + " 280.954562\n", + " 0.000674\n", " \n", " \n", " 34\n", @@ -2741,15 +2741,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 90.745815\n", + " 394182.173776\n", " 405715.733698\n", " 429608.759456\n", " 429014.390163\n", " 428209.211053\n", - " 454699.104888\n", - " inf\n", - " -inf\n", - " NaN\n", + " 415847.029809\n", + " 417588.161812\n", + " -1741.132002\n", + " -0.004169\n", " \n", " \n", " 35\n", @@ -2762,15 +2762,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 242.112335\n", + " 412930.274807\n", " 409799.355286\n", " 410974.276816\n", " 413298.745816\n", " 414461.110789\n", - " 456058.544801\n", - " inf\n", - " -inf\n", - " NaN\n", + " 417671.538047\n", + " 418461.562707\n", + " -790.024660\n", + " -0.001888\n", " \n", " \n", " 36\n", @@ -2783,15 +2783,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -260.245065\n", + " 350708.805302\n", " 353761.775712\n", " 344252.932147\n", " 343209.200439\n", " 343006.625602\n", - " 455642.820816\n", - " inf\n", - " -inf\n", - " NaN\n", + " 422880.625880\n", + " 419336.790352\n", + " 3543.835527\n", + " 0.008451\n", " \n", " \n", " 37\n", @@ -2804,15 +2804,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -724.695938\n", + " 293182.399170\n", " 325069.624722\n", " 344289.047467\n", " 342084.186261\n", " 342232.642746\n", - " 453684.658941\n", - " inf\n", - " -inf\n", - " NaN\n", + " 423813.772316\n", + " 420213.848568\n", + " 3599.923748\n", + " 0.008567\n", " \n", " \n", " 38\n", @@ -2825,15 +2825,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -44.117900\n", + " 377478.093086\n", " 353257.222779\n", " 353764.890202\n", " 357823.798670\n", " 357126.722312\n", - " 454491.481680\n", - " inf\n", - " -inf\n", - " NaN\n", + " 423217.736245\n", + " 421092.741184\n", + " 2124.995061\n", + " 0.005046\n", " \n", " \n", " 39\n", @@ -2846,15 +2846,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -739.389811\n", + " 291362.431282\n", " 302326.827366\n", " 304020.083180\n", " 303828.779931\n", " 303106.289335\n", - " 453393.217586\n", - " inf\n", - " -inf\n", - " NaN\n", + " 426016.517117\n", + " 421973.472035\n", + " 4043.045082\n", + " 0.009581\n", " \n", " \n", " 40\n", @@ -2867,15 +2867,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -112.802197\n", + " 368970.926878\n", " 368964.162462\n", " 357775.533341\n", " 356652.040920\n", " 355879.690701\n", - " 453532.539649\n", - " inf\n", - " -inf\n", - " NaN\n", + " 424905.114511\n", + " 422856.044967\n", + " 2049.069544\n", + " 0.004846\n", " \n", " \n", " 41\n", @@ -2888,15 +2888,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " 115.639539\n", + " 397265.484764\n", " 323346.039126\n", " 322784.762289\n", " 316952.269236\n", " 316486.677194\n", - " 455525.969985\n", - " inf\n", - " -inf\n", - " NaN\n", + " 428467.851539\n", + " 423740.463833\n", + " 4727.387706\n", + " 0.011156\n", " \n", " \n", " 42\n", @@ -2909,15 +2909,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -443.853139\n", + " 327967.298680\n", " 383625.207672\n", " 394279.969633\n", " 398120.412976\n", " 400442.667319\n", - " 453623.172343\n", - " inf\n", - " -inf\n", - " NaN\n", + " 425844.848271\n", + " 424626.732493\n", + " 1218.115778\n", + " 0.002869\n", " \n", " \n", " 43\n", @@ -2930,15 +2930,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -542.264304\n", + " 315778.193228\n", " 360494.854893\n", " 356119.648704\n", " 357486.445092\n", " 357120.223981\n", - " 455839.764978\n", - " inf\n", - " -inf\n", - " NaN\n", + " 430382.494644\n", + " 425514.854816\n", + " 4867.639828\n", + " 0.011439\n", " \n", " \n", " 44\n", @@ -2951,15 +2951,15 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -326.448717\n", + " 342508.889264\n", " 323961.673652\n", " 331898.505904\n", " 332841.894862\n", " 333370.975675\n", - " 453085.420366\n", - " inf\n", - " -inf\n", - " NaN\n", + " 429356.305250\n", + " 426404.834679\n", + " 2951.470571\n", + " 0.006922\n", " \n", " \n", " 45\n", @@ -2972,46 +2972,46 @@ " UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...\n", " GovernmentGovernmentGovernmentGovernmentGovern...\n", " ClinicDistrict HospitalRural/Community Hospita...\n", - " -111.915703\n", + " 369080.727151\n", " 347439.884447\n", " 315453.846359\n", " 311453.513947\n", " 310691.844984\n", - " 451557.724220\n", - " inf\n", - " -inf\n", - " NaN\n", + " 430541.830595\n", + " 427296.675968\n", + " 3245.154627\n", + " 0.007595\n", " \n", " \n", "\n", "
" ] }, - "execution_count": 44, + "execution_count": 56, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 44 + "execution_count": 56 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-10T12:59:26.743239Z", - "start_time": "2025-01-10T12:59:24.265945Z" + "end_time": "2025-01-13T10:17:18.418410Z", + "start_time": "2025-01-13T10:17:17.079433Z" } }, "cell_type": "code", "source": "X_Data = pd.read_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/X_basis_weather_filtered_predictions_{scenario}_{model_type}.csv')\n", "id": "23e931c4a52c75e0", "outputs": [], - "execution_count": 45 + "execution_count": 57 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-10T12:59:44.804923Z", - "start_time": "2025-01-10T12:59:44.791156Z" + "end_time": "2025-01-13T10:17:18.760024Z", + "start_time": "2025-01-13T10:17:18.505205Z" } }, "cell_type": "code", @@ -3021,46 +3021,46 @@ { "data": { "text/plain": [ - " 0 1 2 3 4 5 6 \\\n", - "0 1.048343 0.810635 -1.694798 -1.593255 0.865784 -0.556619 -0.692498 \n", - "1 1.774797 1.999924 -1.694798 -1.303572 1.367884 -0.393471 -0.694058 \n", - "2 1.370042 1.374079 -1.694798 -1.013890 0.899921 0.022860 -0.730727 \n", - "3 2.193023 2.566294 -1.694798 -0.724207 1.848773 -0.140611 -0.468354 \n", - "4 1.750054 0.914118 -1.694798 -0.434524 1.545592 -0.292019 -0.624782 \n", - "... ... ... ... ... ... ... ... \n", - "181051 2.124416 1.864759 1.694798 0.434524 1.083275 -0.534858 -0.713874 \n", - "181052 0.616089 0.497958 1.694798 0.724207 0.038357 -0.580187 -0.773157 \n", - "181053 0.616089 0.497958 1.694798 1.013890 0.038357 -0.580187 -0.773157 \n", - "181054 1.677813 1.075421 1.694798 1.303572 0.519968 -0.603433 -0.700931 \n", - "181055 0.490431 0.121353 1.694798 1.593255 0.039985 -0.699167 -0.784913 \n", + " 0 1 2 3 4 5 \\\n", + "0 227.138960 75.990148 2025.0 1.0 204.619988 28.311729 \n", + "1 317.116784 131.526620 2025.0 2.0 266.829631 48.524785 \n", + "2 266.984248 102.301429 2025.0 3.0 208.849500 100.105702 \n", + "3 368.917876 157.974521 2025.0 4.0 326.411230 79.852705 \n", + "4 314.052188 80.822535 2025.0 5.0 288.847396 61.094069 \n", + "... ... ... ... ... ... ... \n", + "181051 360.420224 125.214790 2070.0 8.0 231.566870 31.007845 \n", + "181052 173.600507 61.389035 2070.0 9.0 102.102642 25.391810 \n", + "181053 173.600507 61.389035 2070.0 10.0 102.102642 25.391810 \n", + "181054 305.104483 88.354924 2070.0 11.0 161.773682 22.511754 \n", + "181055 158.036557 43.802619 2070.0 12.0 102.304400 10.650906 \n", "\n", - " 7 8 9 ... 371 372 373 374 375 376 377 \\\n", - "0 -0.784889 0.216669 -0.375922 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", - "1 -0.773609 0.680066 -0.192419 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", - "2 -0.754700 0.439918 0.251719 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", - "3 -0.736643 1.007995 0.270999 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", - "4 -0.758322 1.243891 -0.091395 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", - "... ... ... ... ... ... ... ... ... ... ... ... \n", - "181051 -0.555571 1.947227 -0.539065 ... 0.0 0.0 0.0 0.0 0.0 1.0 0.0 \n", - "181052 -0.761919 -0.221811 -0.538509 ... 0.0 0.0 0.0 0.0 0.0 0.0 1.0 \n", - "181053 -0.761919 -0.221811 -0.538509 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", - "181054 -0.685821 0.667956 -0.652100 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", - "181055 -0.784889 0.669824 -0.737891 ... 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", + " 6 7 8 9 ... 14 15 \\\n", + "0 11.450683 0.000000 36.713877 48.249343 ... 1099.0 0.084097 \n", + "1 11.257423 1.397600 185.851873 69.883888 ... 632.0 0.089463 \n", + "2 6.713944 3.740560 84.189766 58.672121 ... 873.0 NaN \n", + "3 39.223389 5.977963 165.061924 85.193863 ... 873.0 NaN \n", + "4 19.841130 3.291834 124.108802 96.207108 ... 873.0 NaN \n", + "... ... ... ... ... ... ... ... \n", + "181051 8.802028 28.414062 267.244762 129.043669 ... 485.0 0.162431 \n", + "181052 1.456647 2.846097 47.272313 27.778078 ... 508.0 0.116303 \n", + "181053 1.456647 2.846097 47.272313 27.778078 ... 873.0 NaN \n", + "181054 10.405741 12.275218 169.608339 69.318523 ... 1149.0 0.233156 \n", + "181055 0.000000 0.000000 86.131665 69.405718 ... 873.0 0.098121 \n", "\n", - " 378 379 380 \n", - "0 0.0 0.0 0.0 \n", - "1 0.0 0.0 0.0 \n", - "2 0.0 0.0 0.0 \n", - "3 0.0 0.0 0.0 \n", - "4 0.0 0.0 0.0 \n", - "... ... ... ... \n", - "181051 0.0 0.0 0.0 \n", - "181052 0.0 0.0 0.0 \n", - "181053 1.0 0.0 0.0 \n", - "181054 0.0 1.0 0.0 \n", - "181055 0.0 0.0 1.0 \n", + " 16 17 18 19 20 21 22 23 \n", + "0 1.0 1.0 0.0 0.0 0.0 1.0 0.0 0.0 \n", + "1 1.0 0.0 0.0 1.0 0.0 1.0 0.0 0.0 \n", + "2 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", + "3 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", + "4 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", + "... ... ... ... ... ... ... ... ... \n", + "181051 0.0 0.0 1.0 0.0 0.0 1.0 0.0 0.0 \n", + "181052 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0 \n", + "181053 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", + "181054 0.0 0.0 1.0 0.0 0.0 1.0 0.0 0.0 \n", + "181055 0.0 0.0 0.0 0.0 0.0 1.0 0.0 0.0 \n", "\n", - "[181056 rows x 381 columns]" + "[181056 rows x 24 columns]" ], "text/html": [ "
\n", @@ -3092,82 +3092,82 @@ " 8\n", " 9\n", " ...\n", - " 371\n", - " 372\n", - " 373\n", - " 374\n", - " 375\n", - " 376\n", - " 377\n", - " 378\n", - " 379\n", - " 380\n", + " 14\n", + " 15\n", + " 16\n", + " 17\n", + " 18\n", + " 19\n", + " 20\n", + " 21\n", + " 22\n", + " 23\n", " \n", " \n", " \n", " \n", " 0\n", - " 1.048343\n", - " 0.810635\n", - " -1.694798\n", - " -1.593255\n", - " 0.865784\n", - " -0.556619\n", - " -0.692498\n", - " -0.784889\n", - " 0.216669\n", - " -0.375922\n", + " 227.138960\n", + " 75.990148\n", + " 2025.0\n", + " 1.0\n", + " 204.619988\n", + " 28.311729\n", + " 11.450683\n", + " 0.000000\n", + " 36.713877\n", + " 48.249343\n", " ...\n", + " 1099.0\n", + " 0.084097\n", + " 1.0\n", + " 1.0\n", " 0.0\n", " 0.0\n", " 0.0\n", - " 0.0\n", - " 0.0\n", - " 0.0\n", - " 0.0\n", - " 0.0\n", + " 1.0\n", " 0.0\n", " 0.0\n", " \n", " \n", " 1\n", - " 1.774797\n", - " 1.999924\n", - " -1.694798\n", - " -1.303572\n", - " 1.367884\n", - " -0.393471\n", - " -0.694058\n", - " -0.773609\n", - " 0.680066\n", - " -0.192419\n", + " 317.116784\n", + " 131.526620\n", + " 2025.0\n", + " 2.0\n", + " 266.829631\n", + " 48.524785\n", + " 11.257423\n", + " 1.397600\n", + " 185.851873\n", + " 69.883888\n", " ...\n", + " 632.0\n", + " 0.089463\n", + " 1.0\n", " 0.0\n", " 0.0\n", + " 1.0\n", " 0.0\n", - " 0.0\n", - " 0.0\n", - " 0.0\n", - " 0.0\n", - " 0.0\n", + " 1.0\n", " 0.0\n", " 0.0\n", " \n", " \n", " 2\n", - " 1.370042\n", - " 1.374079\n", - " -1.694798\n", - " -1.013890\n", - " 0.899921\n", - " 0.022860\n", - " -0.730727\n", - " -0.754700\n", - " 0.439918\n", - " 0.251719\n", + " 266.984248\n", + " 102.301429\n", + " 2025.0\n", + " 3.0\n", + " 208.849500\n", + " 100.105702\n", + " 6.713944\n", + " 3.740560\n", + " 84.189766\n", + " 58.672121\n", " ...\n", - " 0.0\n", - " 0.0\n", + " 873.0\n", + " NaN\n", " 0.0\n", " 0.0\n", " 0.0\n", @@ -3179,19 +3179,19 @@ " \n", " \n", " 3\n", - " 2.193023\n", - " 2.566294\n", - " -1.694798\n", - " -0.724207\n", - " 1.848773\n", - " -0.140611\n", - " -0.468354\n", - " -0.736643\n", - " 1.007995\n", - " 0.270999\n", + " 368.917876\n", + " 157.974521\n", + " 2025.0\n", + " 4.0\n", + " 326.411230\n", + " 79.852705\n", + " 39.223389\n", + " 5.977963\n", + " 165.061924\n", + " 85.193863\n", " ...\n", - " 0.0\n", - " 0.0\n", + " 873.0\n", + " NaN\n", " 0.0\n", " 0.0\n", " 0.0\n", @@ -3203,19 +3203,19 @@ " \n", " \n", " 4\n", - " 1.750054\n", - " 0.914118\n", - " -1.694798\n", - " -0.434524\n", - " 1.545592\n", - " -0.292019\n", - " -0.624782\n", - " -0.758322\n", - " 1.243891\n", - " -0.091395\n", + " 314.052188\n", + " 80.822535\n", + " 2025.0\n", + " 5.0\n", + " 288.847396\n", + " 61.094069\n", + " 19.841130\n", + " 3.291834\n", + " 124.108802\n", + " 96.207108\n", " ...\n", - " 0.0\n", - " 0.0\n", + " 873.0\n", + " NaN\n", " 0.0\n", " 0.0\n", " 0.0\n", @@ -3251,44 +3251,43 @@ " \n", " \n", " 181051\n", - " 2.124416\n", - " 1.864759\n", - " 1.694798\n", - " 0.434524\n", - " 1.083275\n", - " -0.534858\n", - " -0.713874\n", - " -0.555571\n", - " 1.947227\n", - " -0.539065\n", + " 360.420224\n", + " 125.214790\n", + " 2070.0\n", + " 8.0\n", + " 231.566870\n", + " 31.007845\n", + " 8.802028\n", + " 28.414062\n", + " 267.244762\n", + " 129.043669\n", " ...\n", - " 0.0\n", - " 0.0\n", - " 0.0\n", + " 485.0\n", + " 0.162431\n", " 0.0\n", " 0.0\n", " 1.0\n", " 0.0\n", " 0.0\n", + " 1.0\n", " 0.0\n", " 0.0\n", " \n", " \n", " 181052\n", - " 0.616089\n", - " 0.497958\n", - " 1.694798\n", - " 0.724207\n", - " 0.038357\n", - " -0.580187\n", - " -0.773157\n", - " -0.761919\n", - " -0.221811\n", - " -0.538509\n", + " 173.600507\n", + " 61.389035\n", + " 2070.0\n", + " 9.0\n", + " 102.102642\n", + " 25.391810\n", + " 1.456647\n", + " 2.846097\n", + " 47.272313\n", + " 27.778078\n", " ...\n", - " 0.0\n", - " 0.0\n", - " 0.0\n", + " 508.0\n", + " 0.116303\n", " 0.0\n", " 0.0\n", " 0.0\n", @@ -3296,20 +3295,23 @@ " 0.0\n", " 0.0\n", " 0.0\n", + " 0.0\n", " \n", " \n", " 181053\n", - " 0.616089\n", - " 0.497958\n", - " 1.694798\n", - " 1.013890\n", - " 0.038357\n", - " -0.580187\n", - " -0.773157\n", - " -0.761919\n", - " -0.221811\n", - " -0.538509\n", + " 173.600507\n", + " 61.389035\n", + " 2070.0\n", + " 10.0\n", + " 102.102642\n", + " 25.391810\n", + " 1.456647\n", + " 2.846097\n", + " 47.272313\n", + " 27.778078\n", " ...\n", + " 873.0\n", + " NaN\n", " 0.0\n", " 0.0\n", " 0.0\n", @@ -3317,76 +3319,74 @@ " 0.0\n", " 0.0\n", " 0.0\n", - " 1.0\n", - " 0.0\n", " 0.0\n", " \n", " \n", " 181054\n", - " 1.677813\n", - " 1.075421\n", - " 1.694798\n", - " 1.303572\n", - " 0.519968\n", - " -0.603433\n", - " -0.700931\n", - " -0.685821\n", - " 0.667956\n", - " -0.652100\n", + " 305.104483\n", + " 88.354924\n", + " 2070.0\n", + " 11.0\n", + " 161.773682\n", + " 22.511754\n", + " 10.405741\n", + " 12.275218\n", + " 169.608339\n", + " 69.318523\n", " ...\n", + " 1149.0\n", + " 0.233156\n", " 0.0\n", " 0.0\n", - " 0.0\n", - " 0.0\n", - " 0.0\n", - " 0.0\n", + " 1.0\n", " 0.0\n", " 0.0\n", " 1.0\n", " 0.0\n", + " 0.0\n", " \n", " \n", " 181055\n", - " 0.490431\n", - " 0.121353\n", - " 1.694798\n", - " 1.593255\n", - " 0.039985\n", - " -0.699167\n", - " -0.784913\n", - " -0.784889\n", - " 0.669824\n", - " -0.737891\n", + " 158.036557\n", + " 43.802619\n", + " 2070.0\n", + " 12.0\n", + " 102.304400\n", + " 10.650906\n", + " 0.000000\n", + " 0.000000\n", + " 86.131665\n", + " 69.405718\n", " ...\n", + " 873.0\n", + " 0.098121\n", " 0.0\n", " 0.0\n", " 0.0\n", " 0.0\n", " 0.0\n", + " 1.0\n", " 0.0\n", " 0.0\n", - " 0.0\n", - " 0.0\n", - " 1.0\n", " \n", " \n", "\n", - "

181056 rows × 381 columns

\n", + "

181056 rows × 24 columns

\n", "
" ] }, - "execution_count": 51, + "execution_count": 58, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 51 + "execution_count": 58 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-10T12:59:26.748910Z", - "start_time": "2025-01-10T12:59:26.745170Z" + "end_time": "2025-01-13T10:17:19.294884Z", + "start_time": "2025-01-13T10:17:19.136951Z" } }, "cell_type": "code", @@ -3401,13 +3401,13 @@ ], "id": "fd6b107fed0933cb", "outputs": [], - "execution_count": 46 + "execution_count": 59 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-10T12:59:26.836837Z", - "start_time": "2025-01-10T12:59:26.749976Z" + "end_time": "2025-01-13T10:17:21.172464Z", + "start_time": "2025-01-13T10:17:21.002613Z" } }, "cell_type": "code", @@ -3423,10 +3423,10 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 47, + "execution_count": 60, "metadata": {}, "output_type": "execute_result" }, @@ -3435,19 +3435,19 @@ "text/plain": [ "
" ], - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 47 + "execution_count": 60 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-10T12:59:26.915207Z", - "start_time": "2025-01-10T12:59:26.839621Z" + "end_time": "2025-01-13T10:17:21.691092Z", + "start_time": "2025-01-13T10:17:21.234583Z" } }, "cell_type": "code", @@ -3461,10 +3461,10 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 48, + "execution_count": 61, "metadata": {}, "output_type": "execute_result" }, @@ -3473,13 +3473,13 @@ "text/plain": [ "
" ], - "image/png": "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" + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi8AAAGwCAYAAABhDIVPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/OQEPoAAAACXBIWXMAAA9hAAAPYQGoP6dpAACBOUlEQVR4nO3deXiTVfo38G+WJuleure0pexl30VwAX6gIKPiMo7roI7irqPixowDjo7j6z6OiuiMijriuO8OigiogOxlkVIoLV3oRvc9aZPz/pE8T5M2adM2T5b2+7muXtDkSXKSZrlzzn3uWyWEECAiIiIKEGpfD4CIiIioJxi8EBERUUBh8EJEREQBhcELERERBRQGL0RERBRQGLwQERFRQGHwQkRERAFF6+sBeJrFYkFxcTHCw8OhUql8PRwiIiJygxAC9fX1SE5Ohlrd9dxKvwteiouLkZqa6uthEBERUS8UFhYiJSWly2P6XfASHh4OwHrnIyIifDwaIiIickddXR1SU1Plz/Gu9LvgRVoqioiIYPBCREQUYNxJ+WDCLhEREQUUBi9EREQUUBi8EBERUUBh8EJEREQBhcELERERBRQGL0RERBRQGLwQERFRQGHwQkRERAGFwQsREREFFAYvREREFFAYvBAREVFAYfBCREREAYXBC1E/0Wwy+3oIREReweCFqB94eVMOxq1aj+3HK309FCIixTF4IeoH9hVUwyKA/x0q8fVQiIgUx+CFqB9oabUAAHadqPbxSIiIlMfghagfaG615rscKa1DXUurj0dDRKQsBi9E/YCUrCsEsDefsy9E1L8xeCHqB1pa23ca7TpR5cOREBEpj8ELUT/Q7BC8cOaFiPo3Bi9E/YB98LK/sAbGNtZ8IaL+i8ELUT8gLRtp1CoY2yw4dLLOxyMiIlIOgxeiAGexCHmr9JTUKADAbua9EFE/xuCFKMAZ2yzy/88aGQeASbtE1L8xeCEKcPb5LmeOjAUA7M6vhsUifDUkIiJFKRq8/Pjjj7jggguQnJwMlUqFzz77rNvLbN68GVOnToVer8eIESOwdu1aJYdIFPCk4EWnUWNiSiSCgzSoaWrF8VMNPh4ZEZEyFA1eGhsbMWnSJLz88stuHZ+Xl4ff/OY3mDdvHjIzM3H33XfjxhtvxLfffqvkMIkCmpSsawhSI0ijxpS0KADcMk1E/ZdWySs/77zzcN5557l9/Jo1azB06FA8++yzAIAxY8bg559/xvPPP4+FCxcqNUyigCZV1w3WaQAA09Ojse14JXafqMJVM9N8OTQiIkX4Vc7L9u3bsWDBAofTFi5ciO3bt7u8jNFoRF1dncMP0UAizbwEB1mDlxnpgwAAO5m0S0T9lF8FL6WlpUhISHA4LSEhAXV1dWhubnZ6mSeeeAKRkZHyT2pqqjeGSuQ3muVlI2vwMiVtENQqoKi6GSW1zl83RESBzK+Cl95YsWIFamtr5Z/CwkJfD4nIq6RlIyl4CdNrMS45EgCwm3kvRNQP+VXwkpiYiLKyMofTysrKEBERgeDgYKeX0ev1iIiIcPghGkiaOywbAcB029IRi9URUX/kV8HLrFmzsHHjRofTNmzYgFmzZvloRET+z2irrisl7ALAjPRoANxxRET9k6LBS0NDAzIzM5GZmQnAuhU6MzMTBQUFAKxLPkuXLpWPv+WWW5Cbm4sHHngAR44cwerVq/HBBx/gnnvuUXKYRAHN6czLEOvMS1ZpHepaWn0yLiIipSgavOzevRtTpkzBlClTAAD33nsvpkyZgpUrVwIASkpK5EAGAIYOHYqvv/4aGzZswKRJk/Dss8/i3//+N7dJE3WhY8IuAMRHGDAkJgRCAHvzOftCRP2LonVe5s6dCyFclyh3Vj137ty52Ldvn4KjIupf2hN2Hb+LzEiPRn5lE3afqMbc0fG+GBoRkSL8KueFiHquY50XiVTvhU0aiai/YfBCFODk4EXnGLxMtyXtZhbWwGTXeZqIKNAxeCEKcM5yXgBgWGwookN1MLZZcPBkrS+GRkSkCAYvRAGuWdoq3SF4UalU8q4j1nshov6EwQtRgOvYmNHeaUNZ74WI+h8GL0QBrqXV+W4joD3vZU9+FSwW1zv/iIgCCYMXogDnarcRAIxLjoAhSI3qplbkVjR4e2hERIpg8EIU4Fwl7AJAkEaNKanWvJedeVw6IqL+gcELUYBz1h7A3gw2aSSifobBC1GAa+kiYRcAZkhJu/kMXoiof2DwQhTgulo2AoApaYOgVgGFVc0orW3x5tCIiBTB4IUowHW3bBSm12JscgQAYDdnX4ioH2DwQhTAhBBosRWpczXzAgDTh9iWjvIYvBBR4GPwQhTAjHY9i1zlvACBV6yuosGIupZWXw+DiPwUgxeiACZV1wUAg9b1y1lqE3CktM7vg4KqRhMWPLcFV7z6C4RgYT0i6ozBC1EAk/JdgjQqaDWuX87xEQYMiQmBRQD7Cmq8NLre+SW3EjVNrThcUocSJhhTD7Sa2T19oGDwQhTAuttpZC9Q8l522y1tHSiq8d1AKKDsPlGFjL+sxz83HvP1UMgLGLwQBbCuWgN0JBWr2+Xnxer22O2I2l9U68ORUCD56kAJzBaBlzfl4FS90dfDIYUxeCEKYHLw0kWyrkQqVpdZWANTm39OrzeZ2vBrcZ38O2deyF37CmsAWJPY//1zrm8HQ4pj8EIUwJpN1iDEnZmXYbGhiA7VwdhmwaFi/5zRyCysQZtFIEijAgAcKKxlN2w/s+FwGTYdKff1MBwY28zIsgt639mej+pGkw9HREpj8EIUwHqS86JSqeRdR/7a52iPLd9lfkYC9Fo16o1tyKts9PGoSFLTZMKt/9mDP7y1CztyK309HNnh4jqYzBYMCgnC2KQINJnMeHNrnq+HRQpi8EIUwNqDF/deyjPSrUtH/tphene+dVwzh0VjnK0qMJeO/MeJyia0WQSEAO77aD8ajG2+HhIA64wdAExOjcKd/zcCAPDmthN+XxaAeo/BC1EAk5syujHzAgDTbUm7e/Kr/G45xmIR2FtgDV5mpEdjYkoUAGB/oX8ucQ1EhVVNdv9vxuNfZ/lwNO2k4GVK2iAsHJeIEfFhqG9pw9vbTvh0XKQcBi9EAaylzf2EXQAYPzgShiA1qptakVvRoOTQeuxoeT3qW9oQotMgIzEck1IjAXDmxZ8UVluDlxHxYQCA93YWYFO27/Nf7Gde1GoV7phnnX15/ec8NPrJ7BB5FoMXogAmVdh1J+cFAII0akxJlbZM+9fSkVTfZUpaFLQatTzz8mtxHYuP+YnCqmYAwOLxibj+jHQAwIMfHUBNk++SY6saTcivtAZVk1KjAADnT0xCekwIqptasW5Hgc/GRsph8EIUwLrrKO2Mv9Z7kZKIp9mK6Q2NCUW4QQtjmwVHy+p9OTSyKbLNvKREh+DBRRkYFheK8nojVn3xq8/GlFloDXqHxYUiMjgIAKDVqHHbXOvsy6s/5solBaj/YPBCFMB6sttIMj1datLoZ8GLLVlX2hGlVqswMUVaOmLeiz8oqrbOvKQOCoEhSINnL5sEtQr4PLMY3xws8cmYMm3tLibbZl0kF00ZjMFRwahoMOL9XYXeHxgpisELUQDracIuYF2WUausSwClftI7qKyuBUXVzVCrrOOTSEtHzHvxPYtF4KQteEkZFAzAmiArzXD8+dODKK/3/vNJKk43pUPwotOqccvc4QCANVuO+21hRuodBi9EAayl1Vakzs2EXQAINwRhrG0b8u58/5h9kfJdMhIjEG4Ikk+fZJt54Y4j3yurb4HJbIFGrUJSpEE+/a75IzE2KQLVTa340yeHvNoJ3GIR2C8n6w7qdP5l01IQH65HSW0LPtlb5LVxkfIYvBAFsN4sGwHtTRp3+0nSrhRESVu5JdLMS3ZZPfMWfExK1k2OMjh0MNdp1Xju8kkI0qjwfVYZPtrjvSAhr7IRdS1t0GvVyEgK73S+IUiDm84eBgBYvfk42pj43W8weCEKYL1J2AXai9X5S97LHlu+y7QhjsFLUqQBsWF6mC3CoecReZ9U4yV1UEin8zISI3DPOaMAAI9+eRgna5q9MiYp32X84EgEaZx/nF01Mw0xoToUVDXhi/3FXhkXKY/BC1EAa2/M2LOXsjTDkVVSh3ofVyFtNLY3Y5SSiSUqlUpeOmLei29JNV6cBS8AcPPZwzE1LQr1xjbc/+F+rxRBzHSR72IvRKfFDWcNBQC8vCkHZj8rzki9w+CFKIDJdV60PZt5SYgwIC06BBYB7LN9e/WV/YU1MFsEkiINGBwV3On89qRd5r34krRslBrd+W8EABq1Cs/+bjKCgzTYdrwS7/ySr/iY5OJ0dknezvz+9CGIDA7C8VON+N8h3+yKIs9i8EIUwOSclx4k7Eqkgl6+7jC928WSkWSirdLufs68+JRc48XFzAsADI0NxYrFGQCAJ/6XhdxTylVxbmk1I6vEOmPXcZt0R+GGILmo3ks/5PhdawzqOQYvRAGspZc5LwDkxoe+ziXpWN+lo0m2mZfcU41stOdDco0XFzMvkmtmDsEZI2LQ0mrB8g/3K5Yk+2txLdosArFheqczdh1dP3sowvRaHCmtx8Yjvm9pQH3D4IUogMlbpfsQvBz2YfBitgjsk4KXDvkukuhQnVxX5CCXjnyi1WxBSW17gbquqNUqPP3bSQjXa7GvoAav/piryJj22RWnU6lU3R4fGRKEpbOGAABe/OGYV7d0k+cxeCEKYPJuo14sG41NsgYveRWNaPBR87qjZfWoN7Yh1NaM0RVp9oVLR75RXNMMiwD0WjXiwvXdHp8cFYxVF44DAPzj+6OKBMhycbpu8l3s3XDmUBiC1DhQVIsfj1V4fEzkPQxeiAJYbxN2ASAmTI/ECGuxMSl3wNukfkZT0gY51A7pSG4TwGJ1PiEl66YMCnZrlgMALp06GOeMTUCrWeDeDzI9XuHWVVuArsSE6XH1TNvsy0bOvgQyBi9EAUoIYZew27uXsq+XjrpL1pWwTYBvyduko7teMrKnUqnw94snIDpUhyOl9fjnxmMeG8+peiNO1jRDpWoPbN1109nDoNOqsTu/Gr/keqfOkdkiUN3ou87b/RGDF6IAZbT7JtubnBfAPmnXNzMaUoXfjpV1O5qQEgmVCiiubcGpeqM3hkZ2irqp8eJKXLgef7toPADg9Z/z0GTyzPKktEV6RFyYQzsJdyREGHD59FQAwEubPBdQdeXPnx7EzCc2ysUYqe8YvBAFKPty+T1tDyAZm2z91uqLHUeltS04WSM1Y+w6eAnTazEiLgwAZ198wX7ZqKfOG5+ItOgQNLea8X2WZ3b5ZBZag4CeLBnZu3nOMGjVKmzNqfRKQLEzrwqmNgte2Zyj+G0NFAxeiAKUtGQUpFG5LI3eHWnm5WhZvde77kr9jMYkRSBMr+32+Ily0i7zXrytN8tGEpVKhQsmJQEAvvRQeX65sm43Qa8rKYNCcOnUFADASz8oP/tSVmfttr3xSDnyKhoVv72BgMELUYCSk3V7OesCWL9JRwYHodUscKy83lNDc4u8ZNRNvotkUirbBPiKXF23h8tGkgsmJQMAtmSfQm1z32r1WCxCTtzu7cwLANw6dzjUKmBT9ikcOqlcQNxgbEOj7bUqBLB2a55itzWQeCV4efnll5Geng6DwYCZM2di586dLo9du3YtVCqVw4/BYHB5PNFA1duO0vZUKpW8ZdrbS0fSzMs0F/VdOrJvE8BdIt7TbDKjosGaZ9RdgTpXMhIjMCohDCazBd/9Wtqn8Rw/1YB6YxuCgzQYlRDW6+tJjw3FbyZagyolGzaW1rY4/P7hnqI+B3DkheDl/fffx7333otVq1Zh7969mDRpEhYuXIjyctdrnxERESgpKZF/8vOV75FBFGj6UqDOni92HDUa25BVYp3pcXfmZUxSOII0KlQ1muRqr6Q8KVk3XK9FZHDPkmPtXWALFL480LfeQlJ9lwkpkV1ur3eHNHOjZBfsctuS0fC4UGQkhqPJZMZ/dxYodnsDheLBy3PPPYdly5bh+uuvx9ixY7FmzRqEhITgjTfecHkZlUqFxMRE+SchIUHpYRIFnL60BrA3brD3dxxl2poxJkcakOxGaXcA0Gs1yEi0jpVNGr1HyndJiQ5xu8aLM+fblo625lSgsqH3O8akyrpddZJ2l1TnqKzD7IgnldqCl8RIA/5whrW79VvbTijWNmGgUDR4MZlM2LNnDxYsWNB+g2o1FixYgO3bt7u8XENDA4YMGYLU1FQsWbIEv/76q8tjjUYj6urqHH6IBgI556UX1XXtjU2y5pIcLq7zWsM6Kd/F3SUjiVysjnkvXiP3NOrFTiN7Q2NDMWFwJMwWgf8d6v3SkdxJ2hPBS6Q1eJECDCWU1VkDtYQIAy6cnIzYMB2Ka1v69BiQwsFLRUUFzGZzp5mThIQElJY6/8ONHj0ab7zxBj7//HP85z//gcViwezZs1FUVOT0+CeeeAKRkZHyT2pqqsfvB5E/klsDBPXtZTw8LhR6rRqNJjPyq5o8MbRuSfku7i4ZSdgmwPsKq7rvJu2uvu46ajK1IbvU1km6B20BXJGCl/I6o2KBu7TTKCHCAEOQRq7w+/rPTNztC7/bbTRr1iwsXboUkydPxpw5c/DJJ58gLi4Or776qtPjV6xYgdraWvmnsLDQyyMm8g1PJOwCgFajlvsKeWPpyGwR8tR/d8XpOppo23F06KT3ZokGOnmnUS+Tde1JCbI7T1R1SmR1x8GiWlgEkBChR1Jk38cTH66HSgWYzBZUNSlTAVcKXqQlqmtOHwKdRo3MwhoWresDRYOX2NhYaDQalJWVOZxeVlaGxMREt64jKCgIU6ZMQU6O8+I+er0eERERDj9EA4Gncl4A7xarO1JahwZjG8L0WjmHxV0j4sIQHKRBg7ENuRUNCo2Q7BX2srquM4OjgjF9yCAIAXx9sOeJu55cMgKAII0aMaHWRpO9Cabc0T7zYr2duHA9lky2BnFvcPal1xQNXnQ6HaZNm4aNGzfKp1ksFmzcuBGzZs1y6zrMZjMOHjyIpKQkpYZJFJA8Gbx4c8eR9G1zSloUNOqeJYBqNWqMtyUY72eTRq+Qlo16U6DOGanmS2+2J7cHL70rTudMYqQ1qChTKO9FynmJj2gv+XHDWdbE3f8dKpF3c1HPKL5sdO+99+Jf//oX3nrrLWRlZeHWW29FY2Mjrr/+egDA0qVLsWLFCvn4Rx99FN999x1yc3Oxd+9eXHPNNcjPz8eNN96o9FCJAkqzybpboa8Ju4B9jyPlgxc5WbeH+S6Sicx78Zra5lbUtVj7EfWmNYAz501IhFoF7C+sQUFlzz642yvrRnlkLED7co4SSbsWi0B5veOyEWCte3PGiBhYBPD2dpYC6Q3Fg5fLL78czzzzDFauXInJkycjMzMT69evl5N4CwoKUFLSPn1YXV2NZcuWYcyYMVi8eDHq6uqwbds2jB07VumhEgWUZg/OvGQkRkCtAioajHJdCqVIMy/Th/Rsp5FE2nHENgHKk2ZdYkJ1CHWjhYM74sMNmDU8BgDw5QH3Z1/K6lpQUtsCtQqYMLhnnaS7IiXtKrFdurrJhFazNTcrLlzvcN4NZ1pnX97bWYBGo2caVg4kXknYveOOO5Cfnw+j0YgdO3Zg5syZ8nmbN2/G2rVr5d+ff/55+djS0lJ8/fXXmDJlijeGSRRQPLlsFKzTYLit8aGSsy8ltc1yM8be7haR8h2yiuu83o9poJG2SXtq1kUiF6zrwdKRlOQ9KiHcY4EUoOzMi3SdsWG6Tv3H5o6Kx7DYUNS3tOHD3dxo0lN+t9uIiNzT3tvIMy/j9qUj5WY0pCWjscnuNWN0Ji06BFEhQTCZLcgu9W4/poGmyK5AnSctGp+III0KR0rrcazMvb+hEktGgHULMwCUKDDzUm5X46UjtVqF689IBwC8ue0EzNw91yMMXogCVEubZ7ZKS8Z5YcfR7hNSfZfeLRkB1grc0rIB816UJSfremCnkb2oEB3OHhkHwP12AfsKrIGvp3YaSeRlIwVmXuxrvDhz6bQURAYHIb+yCRuzypweQ84xeCEKUNLMS7AHEnYB7yTt7s7vW7KuZJLcpLGmjyPqmV0nqnD63zfi4z3Oi2b2N4XVnqvx0pG06+ir/cXdNto0WwQOnpQ6SXtupxFgt2ykwMxLaTfBS4hOiytPSwPAonU9xeCFKEB5MmEXsC7lAEBBVRPqWjzf9bbB2IasEmtg1NPidB21twnwbtLuF5nFKK1rwV8+P6RoMz9/odTMCwAsGJsAvVaN3IrGbgPmo2X1aDKZEarTYER87ztJO5Ngm3mpa2mTvxB4SntrAL3LY66dPQRatQo78qpw6CST0N3F4IX6hdrmVjSZBlbGvicTdgHrVP5gW5NEJeq9ZBbUwCKshcr6Wh11km3pwPqh5r2/e7YtP6PJZMbKzw51O2MQyIQQ7X2NPJzzAgBhei3mj4kH0P2uIynfZWJKz2sDdSdcr0WIbfbS00m75d3MvABAUmQwFk+w1jF7YytnX9zF4IUCXlWjCQue24LzX/x5QJWM91R7AHtjFVw6kvoZ9XXJCLB+GCRE6GER3qlNA1g/zI/aJZduPFLer5vrVTSY0NxqhkoFJEe5/vDtC2nX0Vf7S7oMBDNtO4080c+oI5VK1d6g0cNLR6V1nWu8OCNtm/5yf7HipQr6CwYvFPDWbjuBU/VG5J5qRG5Fo6+H4zXtu408F7woueNIru/SxyUjiVyszvatXGmn6o2oaWqFWgXcfPYwAMCqL35FbbPnl9j8gbTTKCHcAL3Wc88xe/My4hGq0+BkTTP2Frju8yPvNPJwsq6kfbu0Z5cC26vrul42AqwzidOHDEKrWeCdX1i0zh0MXiigNRrb8Na2E/Lv3vog8wctrdYaJ55K2AXadxx5etmozWzB3j4Wp+tokpfzXqQlo/TYUNxzzigMiw3FqXojnlp/xCu3721KJutKDEEanDvO2ufuy/3Odx01GNtwtNz62Csx8wLYJ+0aPXadrWYLKhtdb5XuSJp9eXdHgbwkTK4xeKGA9t7OAodvvgNp66ync16A9pmXnPIGj76BHimtR6PJjHC9FqNtHaz7aqKXdxxJNWVGJ4TDEKTB4xdPAGD9sJG2gPcnSibr2rtgkjXf46sDJU5rnRwoqoGw5UrFhyuzfJWgwHbpU/VGCAEEaVSIDtF1e/y54xKRMigYVY0mfLrvpMfG0V8xeKGAZWqz4N8/WRPczhwRC2Bgzbx4ercRACRFGjAoJAhtFoFjZZ7r2iwtGU3uRTNGV6QdRycqm1DbpPzSjRS8jEqwBl+zhsfgd9NTAAArPjnY76r9KlWgrqMzR8QhMjgIFQ1G7Mit7HS+pztJO6PEdmkpEIoPN0DtxnNeo1bhutnpAKzdpvtzMrgnMHihgPVZ5kmU1rUgPlyPRy609r7KKqmHsa3/T7kKIdoTdnWeexmrVCq7YnWeW47Z7eElI8C6O2pIjPWD9cDJGo9drytSsq79zNGfFo9BTKgOx8ob8OqW44qPwZsKq2zLRh5uDdCRTqvG4gm2pSMnu47kZF0Fg5cEBVoEtBeo6zrfxd7vZqQiVKfBsfIG/HiswmNj6Y8YvFBAMlsE1tg+LG48ayiGx4VhkK1k/JGS/l8y3thmgfTFzJMJu4Ayxer2SJV1PZSsK2lfOlI278ViEThqm4mSZl4AawC18gJr4PziphzknvLcbJWvFdpmXpTYJt2RtOvof4dKHWawhBDYJ828KJTvAlhnHAHPLhuVddEawJUIQxB+NyMVAIvWdYfBCwWkDYdLkXuqEREGLa6aOQQqlUqu/TEQ8l6Mre1v8J5cNgLst0t7JiA4WdOM4toWaNQqj397lpJ2MxVeLiyqbkZzqxk6jRrpMY4f5hdOSsZZI2NharPgz5/2j9ovZotAcY1yNV46mjksBrFhetQ0tWJrTvuMQ3FtC07VG6FRqzA+2XOdpDuStkqX1xs91mOou9YArlw/eyhUKuDHo6fc7vs0EDF4oYAjhMArm62zLtfOTpcb/Ekl45X+IPMH0pKRVq3q1K22r6Rlo6ySeo+8kUvJrGOTIjzaDRhoL1andNKutNNoeHwYtB0eb5VKhccvmgBDkBrbcyvxUT9oHVBW14JWs4BWreq2RoknaNQqnD/Rmrhr32laWjLKSAz36K66jmLD9NCoVTBbBCoaPLPjqLvWAK6kxYTg3LEJAIA3tp7wyFj6IwYvFHC2H6/E/qJaGILUcoIbAExK9U3JeF9QIllXMjQ2FMFBGjS3mpHngbo5ezzUz8iZcckRUKusU/RKNNaTSPkuGS52SqXFhODuBaMAAI9/k4VKD30A+oq00yg5KtjjFW1dkXYdfXe4TN7pllmoTDPGjjRqFeLCrLkpnkraLXejNYArN5xprSP0yd4ijwVT/Q2DFwo4r9hyXS6fnoqYsPY3Bin/4fipBkV68/gTuUCdAt9GNWoVMpKsH9KeWDrafcKzxenshei0cg6KkjvNOu40cuaGM4diTFIEappa8bevsxQbizd4o8ZLR1NSB2FwVDAajG3YnF0OwDs7jSTSdmlPJe32duYFAGakD8Kk1CgY2yzyLDM5YvBCAeVgUS1+OlYBjVqFG88a5nBebJgeKYOCIQRwqJ/PvrS3BlDmJSwl7fa1WF1xTTOOlNqaMXpwp5E9bzRpbN9p5LopYJBGjScumQCVCvh030n8dOyUYuNRmrdqvNhT2y0dfbG/GK1mi9xJekqa5wPfjhJtMySemsHrbc4LYF2KXH6OdSbvnV/y5fwjasfghQLKK1tyAFiTJJ0lEsp5L/08aVeJAnX22rdL9y14eXt7PiwCOH1YtJwU6WlymwCF/uatZguOn+q808iZyalRuHZWOgDgz58e8niXYm/x5k4jexdMsu462phVjr351WhptSDcoMWw2FDFb1tqFuqJZaMmUxvqW6wNQ3uzbAQAZ42MxenDomFqs+CF74/1eUz9DYMXChi5pxrkRni3zBnu9Bg576Wwf8+8KB+8tO846u3umWaTGe/tLAAA/OGMoR4bW0dSwHrwZO/H2pW8ika0mgVCdRq563ZX7ls4GkmRBhRUNeGfPwTmh06RrcZLisI1XjoalxyBobGhMLZZ8Mx32QCsAaE7Rd76ypO1XqRt0qE6DcINQb26DpVKhfsXZgAAPtpbJAfQZMXghQLGaz/mQghgwZh4lyXmJyn8LdxfKNFR2t6ohHBo1CpUN7WipJffRD/ZV4Ta5lakRgdj/pgED4+w3ejEcOg0atQ0taLAttzhSXK+S2I4VKruP0TD9Fo8umQ8AOtzNqvEO12vPUmuruvFZSPA+oF9gW3paNcJ7yTrShIjPZew25clI3vThgzCgjHxMFsEnttwtM/j6k8YvFBAKK1twcd7rVtQb53rfNYFAMYPjoRaBZTUtii6+8TXpOUIpbaPGoI0GBlvze/oTd6LEAJv2rZ5Xjd7qKI7VnRaNcbYZor2K5D3Iue7dLNkZO+csQlYNC4RZovAik8Oeqx2iDeY2iwosb12vJmwK5GWjiTeCl48O/Niaw3QyyUje8vPHQ2VCvj6QAkOnezfM8o9weCFAsLrP+ei1SxwWno0pnWR+Bmq12JkvPK7T3xNWjYyaJWrfTG2D5V2fzpWgZzyBoTqNLjM1v9HSXKHaQX+5u7sNHLmkQvHIVyvRWZhDf7zS77Hx6WU4ppmCGFNBo8L6/uHb0+NTAh32JLutZkXW/BS5sGZF0/UyBmTFIELbQGdtJRGDF4oANQ0mbBuhzV3oqtZF8lAqPci13lRsHBXX3ocvbnVWtr8sumpiOjlmn9PKJm066ynkTsSIw14YNFoAMDT32bjnV/ysSO3ElWNJo+P0ZMK7ZaM3FkmU4I0+5IaHexQDkFJUkJ5o8mM+j6WWuhNa4Cu3HvOKGjVKmzOPoWdef2vg3lveLbcJZEC3tmej0aTGRmJ4Zg7Oq7b4yelRuGD3UX9Ou+lxdYeQKmcF6D3PY6On2rApuxTUKngUERQSVNsfW8OFNXC1GaBTuuZ72XNJjPybXk0PZ15AYCrZw7Bp/tOYm9BDf7y2SH59JhQHYbHh2Gk9JMQjhHxYYgP13cbMDSZ2lBRb8KpBmvp/FP1RpxqMOFUvRFRIUFYfs6oTlWAe8JbDRm7ctVpadhXUI3FE5K8dpshOi0iDFrUtbShrK6l14m2QPvSU7yHgpchMaG4fEYq3t1RgKfWH8GHt8zyWWDpLxi8kF9rNpnx5rYTAKyzLu68YOWk3cIaWCzCKzsVvE3JCrsSadnoZE0zappMiArRuXW5t2x/r/kZ8Uj3whZXABgWG4roUB2qGk04VFyLqR6qC5JT3gAhrMFGXHjPZwDUahX+tXQ6/v1zHo6U1OFYeQOKqptR2WhCZV5Vp2/R4QatLaAJR2KkAdVNJlQ0GNuDlHojGrvZfj1hcGSfPvR9tU3a3qBQHf597Qyv325ipAF1LQ0orTViRHzPg1VJuQeXjSR3/t9IfLSnCLvzq7E5+xTmZcR77LoDEYMX8msf7C5EVaMJqdHB+I2bb8ijE8Oh16pR19KGE5WNGBbnurBYoGpP2FVu5TfCEITU6GAUVjXjcHEdZo+I7fYytc2tcm+f6xXcHt2RSqXC9CGD8N3hMuzKq/JY8CL1NOrNrIskJkyPBxdlyL83mdqQe6oRx8rrkVPegGNlDcgpb0B+VRPqW9qwt6AGe209fVwxBKkRF65HXJje+m+4HjnlDfgltwrfHy7rW/DigwJ1/iIhwoCjZQ0oqe1bUbiyPrQGcCUx0oDrZqfj1R9z8dS32ZgzKq5ffjFzF4MX8lutZgte+zEXAHDT2cPdngoP0qgxLjkCewtqcKCotl8GL0rXeZGMS4pEYVUzfnUzePlgVyGaTGaMTgjH7OExio6toxnp0dbg5UQ1bp7jmevsbb5LV0J0WowfHInxgx27JBvbzDhR0SQHNWV1RnnGJy5cj1i7QCVUp+k0C/lLbiWueO0XbMouR5vZ0uulo6Jq39R48Qdy0m4fdhwJIfrUGqArt8wZjnU7CpBVUoevDpbIibwDEYMX8ltf7i/GyZpmxIbpcNm0nu1YmZQahb0FNcgsrMFFUwYrNELfUbrOi2RccgTW/1rqVtJum9mCtbYlo+vPSPf6mrzUO2lPfpXHlgt7u9OoN/RaDUYnhvc6UJo+ZBAig4NQ3dSKvQU1OG1o79oxFPnBspGvJHqgv1FtcytMbdacNE9slbY3KFSHZWcPw3MbjuK577Jx3vhEj3eVDxQD816T37NYBNbYGjBef8bQHn9IS9sr+2vSbou3gpfB7iftfp9VhpM1zRgUEuSTgHFcciQMQWpUN7Uit8Iz1Uil4KWrnkb+QqtRY54toX1jVlmvrqPJ1IaKButuqIG6bAQApbW97+QsBT6DQoKgV6CUwR/OHIqYUB1OVDbJS7QDEYMX8ks/HCnH0bIGhOu1+P2sIT2+vLR19tfiOvlbUH/SbNttpPiykW279PFTDd326XnDVpTuqplpigdVzui0ajlolaqz9kVtU6v8QTTSCzMvnrBgrLWS8YZeBi/SklG4QYvIEOW3uPsbTywbeXqbdEdhei1unzcCAPDC98fkLzIDDYMX8jtCCKzebG3AePXpQ3pVJyQ9JgQRBi1MbRY5b6E/aVG4wq4kPlyP2DAdLAJyd2hnDp2sxc68KmjVKvz+9HRFx9SV09KtSyW7TvS9FsbRcuvzJjnS4JVaNZ5w9qg4aNUq5J5qRG4veuEM5GRdwDPLRp5qDdCVq2amITnSgNK6FryzPXAKIHoSgxfyOzvzqrC3oAY6rRp/OCO9V9ehUqkwyfYtPLMfVtr1xlZpwPo4jnWjw7TUCmDxhCTFuke7Y7oteNntgZkX+55GgSLCEITTh1kTpTdmlff48nLw4oO2AP5Aeu5WNBjRau7djK1UodeTO406MgRpcPeCUQCA1Ztz+lxULxAxeCG/84ot1+W301L6VORJznvpx8GLPkj5l7BUrO6wiwaDp+qN+HJ/MQDrerwvTUmLgloFFFQ19bm3VW96GvmD+WOs9T++78XSUWG1VKBuYM68RIfoEKRRQQigvL53eS9l9Z6v8eLMJVMHY1hcKKqbWvHvn/IUvS1/xOCF/EpeRSM226qz3nTWsD5dl5Il431NrvPihdyS7irtvrsjHyazBVPSorzWh8aVcEMQxiRZx9vX2Zf2ZN3ACl4W2Dp4786vRnUPWxG0d5MemDMvarUK8eFS0m7vgl8p58VT1XVd0WrUWH6Otf3Ev3/KRWVD75OMAxGDF/Ir7+209jCaOyquz9VZpWZ9x8ob0GBs6/PY/ImxzTs5L0B70u6Rkjq0dZhKN7aZ5aaDf/BiUbquzPBA3osQQp558cY2aU9KjQ7B6IRwmC0Cm4/2bOlIbg0wALdJS6Slo97O3HmyKWN3zhufiPGDI9BoMuOVzccVvz1/wuCF/IaxzSxv/btqZs93GHUUH2FAcqQBQqDftZL35szLkOgQhOo0MLZZkFvR6HDeV/tLUNFgQmKEAYvGJyo+FndI9V76ErycajCiuqkVahUwIt7/t0l3tGCstHTUw+BlANd4kSRG9HXmRfmEXYlarcL9C63Vm9/+JR/FNX2rDBxIGLyQ31h/qBRVjdYPwnluNGB0x0S7Pkf9hRDCawm7gPUNUlqKsS9WJ4TAG7bu0UtnD/GbYlnTh1hnXrJK6nqdyHi01LpTJz0m1Cfbvvtqvm3paEv2KbdLBdQ2taK+xTpDOVCXjYC+zby0mS04Ve/51gBdOXtkLE4bGg1TmwX/3HjMK7fpD/zj3YYIwLod1iWjy2ek9qkrrr1J/bBYnclsgUVY/2/wwrIRYJf3crI972XXiWr8WlwHQ5AaV85I88o43JEYaUBqdDAsAtjXTY8gV6Rt4YG2ZCSZnBKF2DAdGoxtnZo/uiLNusSG6RCiG7jF16WZl5JezLxUNppgEYBGrUJMmHeCF5VKhQcXWXNfPtxT1Kst8oGIwQv5hZzyBuzIq4JaBVxxWqrHrndSqjVfY39h/1k2ajG1f5M2KFDB05lxTrZLv/Gzddbl4ikpGBTqXsdpb5kxRNoy3bulIznfJcCSdSVqtQrzM6yzL+7uOpK2SacM0J1GkoQ+1HqRZmviwvTQeLFp4rQh0ZifEQ+zReC5DUe9dru+xOCF/II06/J/GQlIivTclPWEwZFQqYCTNc3ydG6ga7El62rUKgRpvPMGOTa5fdlICIHCqiZ8d7gUgLWPkb+ZLift9m7HUXaZ9dtroG2Ttme/ZVoI0e3xzHex6kuV3VIv1HhxZfm51tmXrw6UoLy+b2UCAgGDF/K5llYzPt5rTdS9eqZnlx/CDUEYbusqfaCfLB3ZJ+t6q/nhqIRwBGlUqGtpQ1F1M975JR8WAZw1MtYvl1Zm2JJ29xVW97jYmMUicKwscHoauXLmyFjotWoUVTcj240q0wO5m7Q9+4Rdd4I+e2X1yrYG6MrY5AiMteWm7cjte4Vpf8fghXzum4MlqG1uxeCoYJw9yjOJuvYm9bOkXW91lLan06oxMt4apOzOr5K3tPvjrAtg3SE0KCQILa0Wt5pK2jtZ04wmkxk6jRpDYvq2Xd+XQnRanDEiFoB71XYHemsAidQJ2thmQW1zzxK+y72408iZmcOsM4478ip9cvvexOCFfE5aMrpiRqoi68STpbyXov6R9yLvNNJ59+UrJe0+8+1R1Le0YWhsKOaOivfqGNylUqkwrZd5L1JxuuHxYX6zg6q3pIJ1Gw53n/ciV9cdoK0BJIYgDaJtOVw9zXuRlo181SJj5lBrawjOvHjIyy+/jPT0dBgMBsycORM7d+7s8vgPP/wQGRkZMBgMmDBhAr755htvDJN84GhZPXbnV0OjVuF3MzyXqGvPfsdRT6eB/ZHUlNFbyboSKXg5aaslcd3sdKi9mJTYUzN6We8lW24LELhLRhIp72V/UU2XeRBCCLm67kCfeQHaZ056WutFWjaKD/d+zgsAnDbUGrAfK2/o9xV3FQ9e3n//fdx7771YtWoV9u7di0mTJmHhwoUoL3c+jblt2zZceeWVuOGGG7Bv3z5cdNFFuOiii3Do0CGlh0o+IM26LBgTr9hUa0ZiBHQaNWqaWlFgmxoPZO0zL14OXgZHyv8PN2jx22kpXr39nrJv0tiToDXQdxrZS4gwYGJKJIQANh1xvXR0qsGIllYLVCogOWpgz7wAQKJt6ajHwUutb5eNokN1cpK5u1vkA5Xim/mfe+45LFu2DNdffz0AYM2aNfj666/xxhtv4KGHHup0/AsvvIBFixbh/vvvBwA89thj2LBhA1566SWsWbPG7dttbGyERtP5zV2j0cBgMDgc54parUZwcHCvjm1qanL5hqlSqRASEtKrY5ubm2GxuE5ADA0N7dWxLS0tMJvNHjk2JCRETiQ1Go1oa3Nemr/ZZMZHewoBWCvqdnUsAAQHB0OttsbbJpMJra2u16Ptj4WlDSNjgnCwqBa/HC1G7MRkh2MNBoP8XOnueu2PbW1thcnkuneMXq+HVqvt8bFtbW0wGl1/a2posp5nCNJ0e6xOp0NQUBAAwGw2o6XF9ZtxUFAQdDqdy2PTIjSwmKynXTpzOEL11vFaLBY0N7uu7Gl/vd0dq9VqoddbPziEEGhqch1sdnfs0CgNgiwmnKpuQVZRJcamxsrndfVaPlxYAaB9p1Ggv0eclR6OzNwyfLMvH+ePjXH6HnG0qBoWUwuSIvVoNTaj1faU8vV7RE+P7e17RMdjo/UWWEwtyC+rQmNjjNvvEcWVNRCW9mUjX7xHTE4y4EhxNXbkVeG8CUlefY9wdWxP3iPcJhRkNBqFRqMRn376qcPpS5cuFRdeeKHTy6Smpornn3/e4bSVK1eKiRMnOj2+paVF1NbWyj+FhYUCgMufxYsXO1w+JCTE5bFz5sxxODY2NtblsdOnT3c4dsiQIS6PHTt2rMOxY8eOdXnskCFDHI6dPn26y2NjY2Mdjp0zZ47LY0NCQhyOXbx4cZePmxBC1DWbxMGiGvHb3/62y2MbGhrk67322mu7PDblznfFmU9uFGazRdx2221dHpuXlydf73333dflsYcOHZKPXbVqVZfH7ty5Uz72qaee6vLYTZs2yce+9NJLXR771Vdfyce++eabXR77wQcfyMd+8MEHXR5726pnxZAHvxJLX98hvvrqqy6Pfemll+Tr3bRpU5fHPvXUU/KxO3fu7PLYux/4k3zsoUOHujz2vvvuk4/Ny8vr+r7ddpt8bHl5eZfHXnvttfKxDQ0NXR478/8cX/ddHRsyfIYY8uBXoqCyUQjB9wiJO+8REk++R5SXl8vHBsJ7RMKVfxc1jSYhhO/eI2IW3y0W/eNHIYTw2XvEqlWr5GPdfY+ora0VAERtba3ojqLLRhUVFTCbzUhISHA4PSEhAaWlpU4vU1pa2qPjn3jiCURGRso/qanK5E0QcM/7+3H+iz/jRIXrb5e9ceVpaX6dO+FvpK2/3mgN4EpkcJDPbrs3qpvc764shECoToPB/XD5pKfbxqnngjRqRAT7vkLxkdI61Db1rj1GIFAJoVwGY3FxMQYPHoxt27Zh1qxZ8ukPPPAAtmzZgh07dnS6jE6nw1tvvYUrr7xSPm316tX461//irKyzhnzRqPRYUqsrq4OqampKC4uRkRERKfjuWzk/NjupnmrjCqc/fQmCAFoRRvW3ThDrrrakTvTvFkldbhk9TYE6Q345U8LEBeuV3RK+MjJapz/4s8wBKmx688LHNoPBNqy0ds7ivDkdzm4eMpgPH3p+ICaEvbmshEAbDlajlve2Yv02DD8+KeF8umuXsv/O1iC5R8dxJSh8fjs9jO6PBYInPeIR7/8Fe/tLMRl01Pw7FUzOx37l88O4qM9J3Hb3OG4c/5I+fyBumwkPW9GJ4bjs9vPcOs9Yk9+Fa75906kJ0TixwcXAPDde8RvXt6OE1VG/GvpdMwbFRMw7xF1dXWIjIxEbW2t089ve4qGh7GxsdBoNJ2CjrKyMiQmOu9Am5iY2KPj9Xq9/AZmLzQ01OHF5Io7x/TmWPs3E08ea//m58lj7QM6Z17ddhRCACoV0AYtHvz8KL6880yE6bt+Crn6+3x2KBdqnQGLxichzpaZ7+pYZ3Q6ndtrpDqdDuOHxCMyPAz1xjacbBAYm+z8b9mT6w0KCpJf9J48VqvVym9SzrTaJkwNQepuj7Wn0Wjcfg735Fi1Wq3IsSqVqs/HnpGRAo3+MArq2lBe34L4cOvz3NX1FtSZodLqHCrr9of3iMVTh+L9zFP4Ka8eFouQZzqlY8uaAbXOgBGDY13eh+7eI3p7bE9e90q+R9gfOywpBmqdAZXGzs8rV9db11YLtc6AxMj24331HjFrRAJO7CzAjtxKnDM2IaDeI9yl6LKRTqfDtGnTsHHjRvk0i8WCjRs3OszE2Js1a5bD8QCwYcMGl8eT8swWgY92WxNrH71wHJIjDciraMTKz3q3A6zR2IbP9hUDAK7ycEVdV9RqFSbK9V5qvHKbSmnxQZG6QBUZHCQHInvcaBWQ3Y92Gtk7fVg0QnUalNcbcai4c72jwipbjZcBXl1XIlXZrWo0ya+37sitAXxU48Xe6XKxuv6740jxrdL33nsv/vWvf+Gtt95CVlYWbr31VjQ2Nsq7j5YuXYoVK1bIx//xj3/E+vXr8eyzz+LIkSN45JFHsHv3btxxxx1KD5Vc+OnYKRTXtiAqJAiXTU/FC1dOgVoFfLLvJD7eU9Tj6/tyfzEajG1IjwnBrGExCozYuf5SaVfeKs3gxS0zetDn6Kitp1FGPwte9FqNXL36+w4F68wWgeIaqUAda7wA1qBXr7V+PJbXuVcvpVxqDeCjGi/2pGJ1vxbXoq6lf+a9KB68XH755XjmmWewcuVKTJ48GZmZmVi/fr2clFtQUICSkhL5+NmzZ2PdunV47bXXMGnSJHz00Uf47LPPMH78eKWHSi68v8s663LR5MEwBGkwIz0a9ywYBQD4y+eHcLyHLdjftdV2uWqmdxN1J9qCl8wAD15aGLz0yHRbsbrd+V1/C21pNeNEpTVnxR/7NfWVVG33+w6tAkpqm9FmEQjSqHxWn8TfqFQqebuzu1V2S31c48VeYqQBQ2JCYBHuzTgGIq9U2L3jjjuQn58Po9GIHTt2YObM9oSxzZs3Y+3atQ7HX3bZZcjOzobRaMShQ4ewePFibwyTnKhoMMqlxS+3q4B727wRmD08Bk0mM+5ct8/tqdWDRbU4eLIWOo0av53m3Z1hk22Vdo+VN6DJ5Drpz9/JjRm9XKQuUElVR38trkOj0fXfPae8AUJYC33FhvWw5kQAmJcRD7UKOFxSJ1dJBtobMiZHBSvSniNQyVV23QxepC7U/rBsBAAzbc/7X/ppn6PAbtxBivtkbxHaLAKTUqMwJqk9+1ujVuH5yycjJlSHwyV1eOKbLLeub93OfADAovGJcv8Qb0mMNCAhQg+zRfS4WZ8/kZaN9Jx5cUtSZDAGRwXDbBHYV1Dj8jipp9GohDCvdev2puhQHaYNsc5C/ZDVvnTEhozOSXkvZW5W2fWnZSOg//c5YvBCLgkh8F/bktEVTvoOJUQY8MzvJgEA3tqej29/dV6LR1Lf0orPM72bqNtRf8h7aW71fZ2XQONOn6Ojck+j/rdkJJkvNWq0WzpiQ0bnknqwbCSE8KtlI6C9w/TBk7VdzjgGKgYv5NKe/GrknmpEiE6DCyYlOz1m3uh43HT2MADAAx8dcJiO7ujzzGI0mcwYHhcqT2l6m9SkMZDzXpjz0nNyn6Mu8l6OlPbPnUb2pLyXX45XosH2gVZkm3lJ4cyLg540Z6w3tskzov4SvKQMCpFnHPfk97+8FwYv5JI063L+xKQu67ncd+5oTEqNQm1zK/743j60OaniKYSQE3WvPC3NZ9Py0szLgaLO20UDhRy86PjydZe042hfQY3LKrMDYeZleFwo0mNCYDJb8NPRUwCAQqmbNHcaOehJwm657ZgIg9avctGkL4k7+mHeC9/9yKm6llZ8fcC6C+xyJ0tG9nRaNV68YgrC9Vrszq/GCxuPdToms7AGWSV10GnVPu1GPCHFWuuloKoJVY3ul4z3J1LCLuu8uG9kfBgiDFo0mczIKumc71Tb3IoS2zfskf04eFGpVPLsywZb3gtrvDjXk5mX0lprvkuinyTrSqSlo/6Y98LghZz6cn8xmlvNGBEfhqlpg7o9Pi0mBH+/ZAIA4KVNOdiWU+Fw/jrbrMv5E5IQFeK7nRyRwUEYFmut9BioxepY56Xn1GqVvHTkrN7LMdusS1KkIeD6NvWUlPey6Ug5mk1mlNVbP5w58+JICkTK61tgsXTdRUfeaeQnS0YSKWl3f1GN2ztCAwWDF3LqfbtEXXeXeC6YlIwrT0uFEMAf389ERYP120htcyu+PODbRF17Ut5LoCbtssJu78j1Xpwk7UqVdUf343wXyfT0QYgMDkJ1k/V1KYQ1EI7x8u4/fxcfrodKBbSaBaq6aewpLS1J7Sf8xZCYECRE6NFqFthb0L/yXhi8UCeHi+twoKgWQRoVLp4yuEeXXXn+OIyMD8OpeiOWf7AfFovAZ/tOoqXVglEJYfJWTV+aZFs6CtS8lxbuNuoV+0q7HZscHi3t//kukiCNGvNGW6vtrt16AgCQMii4X24P74sgjRqxYdZtz90tHUk5L4mR/rFNWqJSqfrtlmkGL9TJB7Y+RueOTURMWM9ejME6DV66air0WjW2HD2Ff/2UKy8ZXeXDRF179jMvCjZVV4QQon3ZyI8SAwPBhMGR0GnUqGgw4kSlYwdquafRAAhegPalo8O2/B8uGTmX6GbeS5mthYC/LRsBdnkv/Sxpl8ELOWhpNeOTvdZ+Rd0l6royOjEcqy4YBwD4f+uPILusHoYgNS6e6rtEXXtjkiKgVatQ2WiSq4sGilazgNm2/s5lo54xBGkw0TbrZl/vRQghF6gbCMtGADBndBy0dtV0mazrnLtVdv112Qhoz3vZV1ADY1v/yXth8EIOvv21FHUtbRgcFYwzR8T2+nquPC0Vv5mYBGli44KJyX6TCGkI0sjVggMtabfZLumOy0Y9N8O2ddQ+76WiwYTqplaoVMCI+DBfDc2rIgxB8jdygDMvrkjLQGXdBC/ty0b+F7wMjwtFbJgexjYL9hcG5lK5MwxeyMF/d1qXjC6bntKnpokqlQpPXDIBadEhUKuApbPSPTRCz5iUGph5L1KyrloFBGl8vwQXaGbISbvtyYvSrEt6TOiAms2StkwDLFDnijvLRhaLaG8NEOFfOS+AlPcibZn2zNKRq1pJ3sTghWT5lY3YnlsJlQq4bHrfmyZGGILwxR1nYP3dZ8v1VfyFVKxuw+Ey/JJbGTC5L/bVdf0hfyjQTEuzvonnVjTKu+Ha810GxqyLxDF44bKRM+4sG1U2mtBmEVCpgLge5gh6S3veS9+TdhuMbZj79GY8uf6IXHPKF1yXTSUHtc2t+HRvEdRqFdQq649GbY1qNSoV1GrYna6CWmX9XatRYWraIJ/WNnGXlKh79sg4DI7yzJtZVIjOL+/76cNioFGrkFfRiCte+wXDYkNx5WlpuHRaitcbRvYEk3X7JjIkCKMTwpFdVo/dJ6qxaHzigNppZC81OgRXzUxDaW0LMgZIrk9PJUVa3we7WjaSzosN00Or8c/5AKmz+p78arSaLQjqwzjf+DkPJ2uasf5QKZafM8pTQ+wxBi9uqmgw4pEvD/fqsuMHR+CL28/s0zKM0trMFny425qo66wJY3+TGh2CL+84E+/8ko8vMk8it6IRj3+Thae/zcai8Ym4amYaZg6N9rvZDVbX7bvp6YNswUsVFo1PbJ95GYAf4H+/eIKvh+DXpJyXki6WjdoL1PnnrAsAjIoPR1RIEGqaWnGgqLbXJStqmkz414+5AIB7zhnl02CNwYubQnVanD8xCRZh3e1hEda1TosQMAvrjgWz7XeLBTAL6/+PlNTj0Mk6fHmgGEsm96xmijdtzj6F8nojYkJ18jbK/m5scgSeuGQC/vybMfgisxjv7SzAwZO1+GJ/Mb7YX+yXszGsrtt3M9Kj8e6OAuzKr4bFIuTqupx9oI6kZaP6ljY0mdoQouv8kSltk070w23SErVahdPSo/Hd4TLsyKvsdfCyZksu6o1tyEgMx/kTkjw8yp5h8OKmxEgDXrpqao8v99IPx/DMd0fx3IajWDwhqU/TdUqSmjBeMnUwdFr/HKNSwvRaXDUzDVfNTMPBolqs21ngt7MxLVw26jOp0u6vJ2uRc6oBjSYzdBo1hsSE+nhk5G/CDUEI1WnQaDKjtLYFw+I650VJMy/xfhy8AMDMYTHW4CW3CrfN7fnly+tasHZbHgDg/oWjfb6SMLA+pXzg+jOGIjZMh/zKJrnkvr8pr2vBpuxyAL2v7dJfTEiJxBOXTMCOPy/A3y+egAmDI2EyW/DF/mJc8dovmP/sFmyxdeP1hWaTNcvfoGXw0luDo4KRFGlAm0XIr8lhcaF++8WCfCuhm+7S8rKRH9Z4sTfTrkxAWy92C728KQctrRZMSYvC/2XEe3p4PcZXq8JC9Vrc+X8jAQD/3HjMp9nZrny0twhmi8D0IYMwIp5T50D7bMyXd56JL+84E1eeloZQnQa5FY14bsNRn41L7mvEmZdeU6namzR+tMea5zVQitNRz0nLQa6Sdsv8tDVAR2OSIhBu0KLRZMavxZ07q3elsKoJ63ZaK6Xfv3C0X+QCMnjxgitPS0PKoGCU1xuxdtsJXw/HgRDt3z4H+qyLK9JszPs3zwIAFFQ2+mws7TkvfOn2hVTvpba5FcDAaQtAPdde68Xo9PxSW86Lvy8baWx5LwCws4dbpv+58RhazQJnjIjB7OG9L17qSXwH9AKdVo17Fli3lK3Zclx+w/QHv+RWIb+yCWF6LX4z0bcJWP5uSIy1kFd1UysajG0+GUMLE3Y9YvqQaIffB9o2aXKfVDXX1cyLXF3Xz4MXoHd9jnLKG/CxrWXMfeeOVmRcvcHgxUsumjIYoxLCUNvcitd+PO7r4cje32WdCrxwcrLTTHpqF24IwqAQa4uDwqqmbo5WhrTsyITdvhmdGI5wvdbhdyJnpOClpLZzHzRTmwWVjSYA/tmUsSOpz9HOvCq5R1p3nv/+KCzCWtRwSlrvdikpgcGLl2jUKjlqfePnEyiv77pXhjfUNrXim0OlAIDLPVBRdyCQesAU+Cp4sc286Jmw2ycatQrTbEtHITqNx4oyUv/TXmW387KR9D6u06jlLzb+bFxyBML0WtS1tOFIafd5L4dO1uLrAyVQqYDl5/quIJ0zDF686JyxCZiSFoXmVjNe+iHH18PBZ5knYWqzICMxXO62S11LtfWA8dXMS0urdZcAZ176boZt/X9kQrjPt32S/5ITdp0UqiuT8130fpHE2h2tRi3XeNmR233ei7Q54YKJyXIzW3/B4MWLVCoV7l9onX15b2cBCip98wEIWBN1pdouV8xIDYgXnj9IibZ+Qy+q7jyF7A0sUuc5l01PwZkjYnHL2cN8PRTyY9Ky0akGY6ellnK5uq7/LxlJ3M172ZNfhR+OlEOjVuEeH7YBcIXBi5fNHh6Ls0bGotUs8Pz3vttye+hkHbJK6qDTqnHRFP+t/OtvfD/zwuDFU+LDDfjPjTNxno8rhZJ/iw3TQ6NWwWwRcjNPSWkAtAboSKr3sjOvChYXeS9CCDy1PhsAcNm0FAyN9b8CjgxefOCBhRkArMs27qw7epqpzYIn1x8BAJw3PtEvGyf6KynnpbDatwm7rPNC5B0atQrx4dbgpLTD0pG0bBRIMy8TBkfBEKRGdVMrjpU3OD3m55wK7Mirgk6jxl3zR3p5hO5h8OIDE1IisXhCIoQAnvnWu7MvFovAgx8fwM85FQgO0uCWOcO9evuBLk0KXqqaIYR72fqexGUjIu+TgpOODRrLAnDZSKe1y3txsnQkhMDT31pnXa45fQiS/TSZncGLjyw/dzQ0ahW+zyrDnvyeFQzqi/+3/gg+3XcSGrUKq6+Z6ndJWP4uOcoAlcoaRFQ0mLx++1LwYmCROiKvcVVltyyAarzYk7ZMO0va/e5wGQ4U1SJEp8Ft8/z3yy3fAX1keFwYfjs1BQDw1Ppsr3yL//dPuXjN1s78yUsnYt5o3/enCDR6rUZ+o/LF0pGRMy9EXpfoor9Re1PGwMl5AdrzXnbkVTp89pgtAs9+Z511+cMZQxEb5r/3i8GLD/1xwUjotGrsyKvCj8cqFL2tz/adxN++zgIAPLgoA7+dlqLo7fVnvkza5bIRkfcluNguHYg5LwAwKTUKOq0aFQ0mHD/V3u7ky/3FOFrWgAiDFsv8fBcegxcfSo4KxtLThwAAnlp/xGXmd1/9ePQU7vtwPwDg+jPSccsc/35S+jtfbpduZmNGIq+Tmi7az7w0GNvkNiGBFrwYgjSYkhoFoD3vpdVskeu63DxnOCKD/bvoHoMXH7tt3giE6bX4tbgO3xwq8fj1HyiqwS3/2YM2i8AFk5Lxl9+MZU2XPvLpzIvJVqSOMy9EXpMYYf3CYh+8SDVewvRahOkDr7XKzGHtrQIA4MPdRSioakJsmA7Xn5Huw5G5h8GLj0WH6nDjWUMBAM99dxRtZovHrjuvohHXv7kLTSYzzhgRg2cum8hKoh6Q5sMWAS1ywi6DFyJvkXNealvkHJHSAM13kZwu5b3kVqGl1Yx/bjwGALh93oiA6HPH4MUP3HjWMESH6pBb0YiP9hR55DrL61uw9I0dqGw0YVxyBNZcM439cDzEl7VeWKSOyPukJP0mkxn1tqWiclu+S6DtNJJMSRuEII0KpXUt+Ps3WSita0FypAFXzUzz9dDcwuDFD4Tptbh93ggAwD++PyZ/QPVWfUsrrntjFwqrmpEWHYK115+GcIN/r18GklRbzktxTYtHZ8q602q2oM2WF8Xghch7gnUaRBissxFS0m5pANZ4sRes02BSShQA4O3t+QCsm0gC5Usugxc/cfXMNCRHGlBa14J3bE+k3jC2mXHzO3twuKQOsWE6vP2H0xAXHpjTmv4qIdwAnUYNs0V0KlqlpGa7oNag40uXyJs6bpcOxAJ1HZ1mWzoCgKGxobh0auDsQuU7oJ8wBGlwt6351erNOahrae3xdVgsAvd+sB/bjlciVKfBm9edhnQ/7EkR6NRqFQYPss6+eHPpqMXWGkCtAnQavnSJvEkKUqQWAeXyNunA/XIoJe0CwD3njII2gN5X/D8rZwC5ZMpgvLrlOI6fasRFL23FmOQIDIsNxbC4UAyNDcPQ2FCX29eEEHj0q8P4+kAJgjQqrPn9NExIifTyPRg4UqNDkFfRiKKqZsBLRSib7ZJ1uWOMyLuSIh2r7Ab6shFgLVY3fnAEYsP0OD/AGpQyePEjWo0aK84bgxvf3o3cikbkVjR2OiYmVGcLZtoDmuFxofjucBnWbjsBAHjmskk4a2Scl0c/sKTaZl68ueOIBeqIfCexQ3+j/rBsZAjS4Ks7z/L1MHqFwYufWTA2AT89MA/ZpfXIswUwuacakFfRiPJ6IyobTahsNGHXiWqnl3/4N2OwZPJgL4964PHFjqOWVmtyMLdJE3lfgt3MixCiXywbBTIGL34oNTpE/nC012Bsw4mKRhy3BTPST+6pRjQY23D7vOG48SxWz/UGXxSqa7blvASzui6R10kzL6V1LahuaoXJttMwPjxwZ14CGYOXABKm12L84EiMH+yYyyKEQJPJjNAArPIYqKTt0oVebBHAGi9EvtOesGuUl4xiQnXQaQMnybU/UfRRr6qqwtVXX42IiAhERUXhhhtuQENDQ5eXmTt3LlQqlcPPLbfcouQwA55KpWLg4mXSzMupeqM8I6I05rwQ+Y60Vbqy0Sj3NYsP4HyXQKdo8HL11Vfj119/xYYNG/DVV1/hxx9/xE033dTt5ZYtW4aSkhL556mnnlJymEQ9FhUShHBbwFjkpbwXKUjSB/GbHpG3RYfoEKRRQQjg4MlaAEAi8118RrGv61lZWVi/fj127dqF6dOnAwBefPFFLF68GM888wySk5NdXjYkJASJiYlKDY2oz1QqFVKiQ5BVUofC6iaMTAhX/DZb2jjzQuQrarUKCREGFFU340BRDYDA3mkU6BT7Crd9+3ZERUXJgQsALFiwAGq1Gjt27Ojysu+++y5iY2Mxfvx4rFixAk1Nrr/ZGo1G1NXVOfwQeYO0Xbqwyjt5L0zYJfItKWl3f2ENAC4b+ZJiMy+lpaWIj493vDGtFtHR0SgtLXV5uauuugpDhgxBcnIyDhw4gAcffBDZ2dn45JNPnB7/xBNP4K9//atHx07kDnm7tJd2HDFhl8i3pO3S1U3WCuiB2pSxP+hx8PLQQw/hySef7PKYrKysXg/IPidmwoQJSEpKwvz583H8+HEMH965lOmKFStw7733yr/X1dUhNTW117dP5K5UL7cIsK+wS0Te1zFYYY0X3+lx8LJ8+XJcd911XR4zbNgwJCYmory83OH0trY2VFVV9SifZebMmQCAnJwcp8GLXq+HXs8nEHlfWow08+KtZSMWqSPypc7BC2defKXHwUtcXBzi4rovPT9r1izU1NRgz549mDZtGgDghx9+gMVikQMSd2RmZgIAkpICq+8C9X/2heqEEIr3G2LCLpFvSctG8u8MXnxGsYTdMWPGYNGiRVi2bBl27tyJrVu34o477sAVV1wh7zQ6efIkMjIysHPnTgDA8ePH8dhjj2HPnj04ceIEvvjiCyxduhRnn302Jk6cqNRQiXolxRa81BvbUNvc8y7gPdUiJ+xyqzSRLyTZBS9atQoxoTofjmZgU/Rd8N1330VGRgbmz5+PxYsX48wzz8Rrr70mn9/a2ors7Gx5N5FOp8P333+Pc889FxkZGVi+fDkuvfRSfPnll0oOk6hXgnUaxIZZlyy9sXTEInVEvmW/bBQfrodaze7uvqJoWdbo6GisW7fO5fnp6ekQQsi/p6amYsuWLUoOicijUqODUdFgRGF1EyakRHZ/gT5gwi6Rb8XbJehym7Rvcf6ZqA+82aCRdV6IfEuv1SDatlTEnUa+xeCFqA/SbLVeCrwQvEh1XgxaBi9EviIl6bLGi28xeCHqA292l25ptW6V5swLke9I/Yy4bORbbEVM1AfSslGRN5aNmPNC5HOXTE1BYXUzFoxJ8PVQBjQGL0R9ILUIKKpuhsUiFN19wN1GRL53waRkXDDJdWNh8g4uGxH1QVKkARq1CiazBeX1RkVvq4UJu0REABi8EPWJVqOWC1cp3eOofdmIL1siGtj4LkjUR/KOo0rlgpdWswVtFmtNJC4bEdFAx+CFqI/kWi8KzrxI26QBJuwSETF4Ieojebu0gi0CpCUjlQrQa/myJaKBje+CRH0k7ThSdObFZKvxEqRRvHs1EZG/Y/BC1EcpXqj1wm3SRETtGLwQ9ZGUsFtS1wJjm7mbo3uHBeqIiNoxeCHqo9gwHYKDNBACKK5pUeQ2WrhNmohIxndCoj5SqVRIGSQl7SqzdCQvG7FAHRERgxciT1A6aVeurstlIyIiBi9EnpA6SNnt0sx5ISJqx+CFyAOUnnlh8EJE1I7BC5EHyMGLQjkvLa3tdV6IiAY6Bi9EHiC3CFAseGHOCxGRhMELkQdILQKqm1rRYGzz+PU3m7jbiIhIwuCFyAPCDUGICgkCoMzsC3NeiIjaMXgh8hAll47YHoCIqB2DFyIPkZaOChQIXqQ6L6ywS0TE4IXIY6QdR0XVnq/10tLGnBciIgmDFyIPUXTZyMScFyIiCYMXIg9RslAdc16IiNoxeCHyEPsWAUIIj153M4vUERHJGLwQecjgQcFQqayzJJWNJo9edwuXjYiIZAxeiDxEr9UgMcIAwPM7jtoTdvmSJSLiOyGRBymVtMuEXSKidgxeiDwoxVbrxdPbpZmwS0TUjsELkQcpNfMiN2ZknRciIgYvRJ6kxHbpNrMFrWbr7iXOvBARMXgh8ihpu7QnE3Zb2izy/5nzQkTE4IXIo9JirDMvxTUtaDNbujnaPVKyLgDotXzJEhHxnZDIgxLCDdBp1DBbBEpqWzxynS12yboqlcoj10lEFMgYvBB5kFqtwmCp0q6H8l6amaxLROSAwQuRh6XYgpeiKs9sl5aWjZisS0RkxeCFyMM8veNImnnRB/HlSkQEMHgh8rg0W/DiqR1HLSxQR0TkgMELkYd5ulAdgxciIkcMXog8LDVaStj1UM4LE3aJiBwoFrw8/vjjmD17NkJCQhAVFeXWZYQQWLlyJZKSkhAcHIwFCxbg2LFjSg2RSBHSzMupeqM8a9IXzSZrvRgWqCMislIseDGZTLjssstw6623un2Zp556Cv/85z+xZs0a7NixA6GhoVi4cCFaWjxTL4PIG6JCghCm1wIAijyQtCvNvDB4ISKyUix4+etf/4p77rkHEyZMcOt4IQT+8Y9/4OGHH8aSJUswceJEvP322yguLsZnn32m1DCJPE6lUsnbpT2RtNue88JVXiIiwI9yXvLy8lBaWooFCxbIp0VGRmLmzJnYvn27y8sZjUbU1dU5/BD5mrTjqNADtV6YsEtE5MhvgpfS0lIAQEJCgsPpCQkJ8nnOPPHEE4iMjJR/UlNTFR0nkTvkWi8emHmRitQZmLBLRASgh8HLQw89BJVK1eXPkSNHlBqrUytWrEBtba38U1hY6NXbJ3Im1YMtApo580JE5EDbk4OXL1+O6667rstjhg0b1quBJCYmAgDKysqQlJQkn15WVobJkye7vJxer4der+/VbRIpJdWDy0YMXoiIHPUoeImLi0NcXJwiAxk6dCgSExOxceNGOVipq6vDjh07erRjicgf2C8bCSH61A26hbuNiIgcKJbzUlBQgMzMTBQUFMBsNiMzMxOZmZloaGiQj8nIyMCnn34KwLpD4+6778bf/vY3fPHFFzh48CCWLl2K5ORkXHTRRUoNk0gR0m6jemMbaptb+3RdLa3WOi+ceSEisurRzEtPrFy5Em+99Zb8+5QpUwAAmzZtwty5cwEA2dnZqK2tlY954IEH0NjYiJtuugk1NTU488wzsX79ehgMBqWGSaSIEJ0WsWF6VDQYUVjVjKgQXa+viwm7RESOFAte1q5di7Vr13Z5jBDC4XeVSoVHH30Ujz76qFLDIvKa1Ohga/BS3YQJKZG9vh7mvBAROfKbrdJE/Y2nGjSyzgsRkSMGL0QKaW/Q2Lfgpb09AF+uREQAgxcixbTPvPRtuzR3GxEROWLwQqSQNA9V2ZUSdoOZsEtEBIDBC5FipFovRdXNsFhEN0e7xq3SRESOGLwQKSQp0gCNWgWT2YLyemOvrqPNbIHJzOCFiMgegxcihWg1aiRFWmsU9TZpt6XNIv+fy0ZERFYMXogU1Nft0lKyLgDotXy5EhEBDF6IFCVtly7oZfAiV9cNUvepPxIRUX/C4IVIQdKOo94GLyxQR0TUGYMXIgWlxYQCAPIreznzwuCFiKgTBi9EChoWaw1eTlQ09urybMpIRNQZgxciBaXbgpfKRhNqm1t7fHm5NYCWwQsRkYTBC5GCwvRaxIXrAfRu9kUuUMeZFyIiGYMXIoUNteW9nKjsTfDCnBcioo4YvBApbKht6Sj3VM+Dl2Y2ZSQi6oTBC5HCpLyX3sy8sCkjEVFnDF6IFDY01lrrpTc5L+1bpflSJSKS8B2RSGFDY8MAALkVjRCiZ92ljVw2IiLqhMELkcKGxFhnXupb2lDVaOrRZVmkjoioMwYvRAozBGkwOMra4yivh0tHTNglIuqMwQuRF6Tb8l56HLyYWOeFiKgjBi9EXpDey1ovrPNCRNQZgxciL5BqvfR+2YgvVSIiCd8RibygPXjpWXfpFua8EBF1wuCFyAuG2nWX7sl2ae42IiLqjMELkRekRodAo1ahudWMsjqj25djhV0ios4YvBB5QZBGjdRBPd8uzYRdIqLOGLwQeUl6L5J2WeeFiKgzBi9EXtKb7dItrdY6LwxeiIjaMXgh8pJhcdbgJfdUz2demPNCRNSOwQuRl/R05sVsETC12SrscuaFiEjG4IXIS6Tt0gWVTTBbut8uLSXrAgxeiIjsMXgh8pLkqGDoNGqYzBYU1zR3e3yzXfCi1/KlSkQk4TsikZdo1CqkxbjfoFGq8aLXqqFWqxQdGxFRIGHwQuRFPelxZGxjsi4RkTMMXoi8qCfBS7OJybpERM4weCHyIrnHkRs7jtjXiIjIOQYvRF4kbZd2a+aF1XWJiJxi8ELkRVKhuqLqZrmGiytsykhE5ByDFyIvig/XI0SngdkiUFjd1OWxUsKuIYgvUyIie3xXJPIilUqFIVKl3W6WjuSZFy4bERE5YPBC5GXD3NxxxJwXIiLnGLwQeVl6rHuF6rjbiIjIOcWCl8cffxyzZ89GSEgIoqKi3LrMddddB5VK5fCzaNEipYZI5BNDY8MAdL9duoUJu0RETmmVumKTyYTLLrsMs2bNwuuvv+725RYtWoQ333xT/l2v1ysxPCKfGSrNvJzqJnix7UbishERkSPFgpe//vWvAIC1a9f26HJ6vR6JiYluH280GmE0GuXf6+rqenR7RN4m1Xoprm1BS6vZZXAiJewyeCEicuR3OS+bN29GfHw8Ro8ejVtvvRWVlZVdHv/EE08gMjJS/klNTfXSSIl6JzpUhwiD9XtDV0tHzHkhInLOr4KXRYsW4e2338bGjRvx5JNPYsuWLTjvvPNgNptdXmbFihWora2VfwoLC704YqKeU6lU7W0CukjabQ9e/OplSkTkcz1aNnrooYfw5JNPdnlMVlYWMjIyejWYK664Qv7/hAkTMHHiRAwfPhybN2/G/PnznV5Gr9czL4YCztDYUOwvqkVehetCdUzYJSJyrkfBy/Lly3Hdddd1ecywYcP6Mp5O1xUbG4ucnByXwQtRIEqXa700uDyGdV6IiJzrUfASFxeHuLg4pcbSSVFRESorK5GUlOS12yTyhvZloy5mXhi8EBE5pdhiekFBATIzM1FQUACz2YzMzExkZmaioaH9m2ZGRgY+/fRTAEBDQwPuv/9+/PLLLzhx4gQ2btyIJUuWYMSIEVi4cKFSwyTyCSl4ye0y58W6VZoJu0REjhTbKr1y5Uq89dZb8u9TpkwBAGzatAlz584FAGRnZ6O2thYAoNFocODAAbz11luoqalBcnIyzj33XDz22GPMaaF+R1o2qmgwor6lFeGGoE7HSDMvzHkhInKkWPCydu3abmu8CCHk/wcHB+Pbb79VajhEfiXCEITYMB0qGkzIr2zC+MGRnY5hY0YiIue4B5PIR6Rida6WjpiwS0TkHIMXIh/prtZLe8IuX6ZERPb4rkjkI+3bpTsHLxaLgLGNCbtERM4weCHykaFdBC8tbe1VpZmwS0TkiMELkY/Iy0ZO+htJyboAYNAyeCEissfghchHpITdmqZWVDeaHM6TknX1WjXUapXXx0ZE5M8YvBD5SLBOg6RIAwAgr8PsC6vrEhG5xuCFyIek2Ze8Ux2DFybrEhG5wuCFyIeGxjnPe2lmdV0iIpcYvBD50NAY5zuOpIRdLhsREXXG4IXIh1zVepFnXligjoioE74zEvmQfZVd+15fbMpIROQagxciH0qLDoFaBTSazDhVb5RPl3cbscYLEVEnDF6IfEinVSNlUAgAx6UjOeeFMy9ERJ0weCHysXQnlXabuVWaiMglBi9EPjY0xjrzkms/8yIn7DJ4ISLqiMELkY/ZJ+1KmLBLROQagxciH3O2XVrOedHyJUpE1BHfGYl8bFhsGAAgv7IJFot1u7S824gzL0REnTB4IfKx5CgDgjQqGNssKKlrAcCcFyKirjB4IfIxrUaNtGjbdmlbg8YWBi9ERC4xeCHyA1LSbp5tuzQbMxIRucbghcgPpEsNGm0zL2zMSETkGoMXIj8wNM6xUF2LrUgdgxcios4YvBD5gaExjrVemPNCROQagxciPyDNvBRUNaHNbOFuIyKiLjB4IfIDCeEGGILUaLMIFFU32yXs8iVKRNQR3xmJ/IBarWpP2q1oZMIuEVEXGLwQ+Qlpu/TxUw0wtjFhl4jIFQYvRH5C6nF0pLRePo05L0REnTF4IfIT0sxLVkmdfBpnXoiIOmPwQuQnpODlWFkDAECnVUOjVvlySEREfonBC5GfkIIXk9ma78IlIyIi5xi8EPmJmFAdwvVa+XcGL0REzjF4IfITKpVKTtoFAEMQX55ERM7w3ZHIjwx1CF4480JE5AyDFyI/Yj/zEqxj8EJE5AyDFyI/Msw+eOHMCxGRUwxeiPxIOoMXIqJuMXgh8iNDY5jzQkTUHQYvRH4kMiQI0aE6AAxeiIhcYfBC5GfSY0IAAME6vjyJiJzhuyORnxkaGwYAMGg580JE5IxiwcuJEydwww03YOjQoQgODsbw4cOxatUqmEymLi/X0tKC22+/HTExMQgLC8Oll16KsrIypYZJ5HcunJyM1Ohg/N+YeF8PhYjIL2m7P6R3jhw5AovFgldffRUjRozAoUOHsGzZMjQ2NuKZZ55xebl77rkHX3/9NT788ENERkbijjvuwCWXXIKtW7cqNVQivzJnVBx+euD/fD0MIiK/pRJCCG/d2NNPP41XXnkFubm5Ts+vra1FXFwc1q1bh9/+9rcArEHQmDFjsH37dpx++umdLmM0GmE0GuXf6+rqkJqaitraWkRERChzR4iIiMij6urqEBkZ6dbnt1dzXmpraxEdHe3y/D179qC1tRULFiyQT8vIyEBaWhq2b9/u9DJPPPEEIiMj5Z/U1FSPj5uIiIj8h9eCl5ycHLz44ou4+eabXR5TWloKnU6HqKgoh9MTEhJQWlrq9DIrVqxAbW2t/FNYWOjJYRMREZGf6XHw8tBDD0GlUnX5c+TIEYfLnDx5EosWLcJll12GZcuWeWzwAKDX6xEREeHwQ0RERP1XjxN2ly9fjuuuu67LY4YNGyb/v7i4GPPmzcPs2bPx2muvdXm5xMREmEwm1NTUOMy+lJWVITExsadDJSIion6ox8FLXFwc4uLi3Dr25MmTmDdvHqZNm4Y333wTanXXEz3Tpk1DUFAQNm7ciEsvvRQAkJ2djYKCAsyaNaunQyUiIqJ+SLGcl5MnT2Lu3LlIS0vDM888g1OnTqG0tNQhd+XkyZPIyMjAzp07AQCRkZG44YYbcO+992LTpk3Ys2cPrr/+esyaNcvpTiMiIiIaeBSr87Jhwwbk5OQgJycHKSkpDudJu7NbW1uRnZ2NpqYm+bznn38earUal156KYxGIxYuXIjVq1crNUwiIiIKMF6t8+INPdknTkRERP7Bb+u8EBEREfUVgxciIiIKKAxeiIiIKKAweCEiIqKAwuCFiIiIAopiW6V9Rdo8VVdX5+OREBERkbukz213NkH3u+Clvr4eANhdmoiIKADV19cjMjKyy2P6XZ0Xi8WC4uJihIeHQ6VSefS66+rqkJqaisLCwgFZQ2ag33+Aj8FAv/8AHwPe/4F9/wHlHgMhBOrr65GcnNxtO6F+N/OiVqs7VfT1tIHevXqg33+Aj8FAv/8AHwPe/4F9/wFlHoPuZlwkTNglIiKigMLghYiIiAIKg5ce0Ov1WLVqFfR6va+H4hMD/f4DfAwG+v0H+Bjw/g/s+w/4x2PQ7xJ2iYiIqH/jzAsREREFFAYvREREFFAYvBAREVFAYfBCREREAWVABS9PPPEEZsyYgfDwcMTHx+Oiiy5Cdna2wzEtLS24/fbbERMTg7CwMFx66aUoKyuTz9+/fz+uvPJKpKamIjg4GGPGjMELL7zgcB2bN2+GSqXq9FNaWuqV+9kVTzwGlZWVWLRoEZKTk6HX65Gamoo77rijUz+pzZs3Y+rUqdDr9RgxYgTWrl3rjbvYJW/d//7+HLBXWVmJlJQUqFQq1NTUOJzXX58D9lzdf399Dnjq/ju7b//9738djvHHvz/gvcegvz8HAGDt2rWYOHEiDAYD4uPjcfvttzucf+DAAZx11lkwGAxITU3FU0895Zk7IQaQhQsXijfffFMcOnRIZGZmisWLF4u0tDTR0NAgH3PLLbeI1NRUsXHjRrF7925x+umni9mzZ8vnv/766+Kuu+4SmzdvFsePHxfvvPOOCA4OFi+++KJ8zKZNmwQAkZ2dLUpKSuQfs9ns1fvrjCceg6qqKrF69Wqxa9cuceLECfH999+L0aNHiyuvvFI+Jjc3V4SEhIh7771XHD58WLz44otCo9GI9evXe/X+duSt+9/fnwP2lixZIs477zwBQFRXV8un9+fngD1X999fnwOeuv8AxJtvvulw35qbm+Xz/fXvL4T3HoP+/hx49tlnRXJysnj33XdFTk6O2L9/v/j888/l82tra0VCQoK4+uqrxaFDh8R7770ngoODxauvvtrn+zCggpeOysvLBQCxZcsWIYQQNTU1IigoSHz44YfyMVlZWQKA2L59u8vrue2228S8efPk36UnrP0bmb/y1GPwwgsviJSUFPn3Bx54QIwbN87hmMsvv1wsXLjQw/egb5S6/wPlObB69WoxZ84csXHjxk73dyA8B7q6/4HyHOjt/QcgPv30U5fXGyh/fyGUewz683OgqqpKBAcHi++//97l9a5evVoMGjRIGI1G+bQHH3xQjB49us9jHlDLRh3V1tYCAKKjowEAe/bsQWtrKxYsWCAfk5GRgbS0NGzfvr3L65Guw97kyZORlJSEc845B1u3bvXw6D3DE49BcXExPvnkE8yZM0c+bfv27Q7XAQALFy7s8nH0BaXuv6Q/PwcOHz6MRx99FG+//bbTJmr9/TnQ3f2X+PtzoC+vgdtvvx2xsbE47bTT8MYbb0DYlQ0LlL8/oNxjIOmPz4ENGzbAYrHg5MmTGDNmDFJSUvC73/0OhYWF8mW2b9+Os88+GzqdTj5t4cKFyM7ORnV1dZ/GPGCDF4vFgrvvvhtnnHEGxo8fDwAoLS2FTqdDVFSUw7EJCQku1yi3bduG999/HzfddJN8WlJSEtasWYOPP/4YH3/8MVJTUzF37lzs3btXsfvTG319DK688kqEhIRg8ODBiIiIwL///W/5vNLSUiQkJHS6jrq6OjQ3Nytzh3pIyfvf358DRqMRV155JZ5++mmkpaU5ve7+/Bxw5/4HwnOgL6+BRx99FB988AE2bNiASy+9FLfddhtefPFF+fxA+PsDyj4G/fk5kJubC4vFgr///e/4xz/+gY8++ghVVVU455xzYDKZ5Otx9hyQzuuLftdV2l233347Dh06hJ9//rnX13Ho0CEsWbIEq1atwrnnniufPnr0aIwePVr+ffbs2Th+/Dief/55vPPOO30atyf19TF4/vnnsWrVKhw9ehQrVqzAvffei9WrV3t4lMpR8v739+fAihUrMGbMGFxzzTUKjcw7lLz/gfAc6Mtr4C9/+Yv8/ylTpqCxsRFPP/007rrrLk8OUXFKPgb9+TlgsVjQ2tqKf/7zn/Ln33vvvYfExERs2rQJCxcuVGK4sgE583LHHXfgq6++wqZNm5CSkiKfnpiYCJPJ1GnHRFlZGRITEx1OO3z4MObPn4+bbroJDz/8cLe3edpppyEnJ8cj4/cETzwGiYmJyMjIwIUXXohXX30Vr7zyCkpKSuTzOmaml5WVISIiAsHBwcrcqR5Q+v4705+eAz/88AM+/PBDaLVaaLVazJ8/HwAQGxuLVatWydfTX58D7tx/Z/zpOeCJ14C9mTNnoqioCEajUb4ef/77A8o/Bs70l+dAUlISAGDs2LHy+XFxcYiNjUVBQYF8Pc6eA9J5fdLnrJkAYrFYxO233y6Sk5PF0aNHO50vJSl99NFH8mlHjhzplKR16NAhER8fL+6//363b3vBggXi4osv7tsd8ABPPQYdbdmyRQAQeXl5Qghrst748eMdjrnyyit9nqznrfvvTH96DuTk5IiDBw/KP2+88YYAILZt2ybKysqEEP37OeDO/XfGH54DSr0G/va3v4lBgwbJv/vr318I7z0GzvSX50B2drYA4JCwW1lZKdRqtfj222+FEO0JuyaTST5mxYoVHknYHVDBy6233ioiIyPF5s2bHbatNTU1ycfccsstIi0tTfzwww9i9+7dYtasWWLWrFny+QcPHhRxcXHimmuucbiO8vJy+Zjnn39efPbZZ+LYsWPi4MGD4o9//KNQq9VdZmV7iyceg6+//lq88cYb4uDBgyIvL0989dVXYsyYMeKMM86Qj5G2Sd5///0iKytLvPzyy36xTdJb97+/Pwc6craroj8/Bzpydv/99Tngifv/xRdfiH/961/i4MGD4tixY2L16tUiJCRErFy5Uj7GX//+QnjvMejPzwEhrGUCxo0bJ7Zu3SoOHjwozj//fDF27Fg5WKmpqREJCQni97//vTh06JD473//K0JCQrhVuqcAOP1588035WOam5vFbbfdJgYNGiRCQkLExRdfLEpKSuTzV61a5fQ6hgwZIh/z5JNPiuHDhwuDwSCio6PF3LlzxQ8//ODFe+qaJx6DH374QcyaNUtERkYKg8EgRo4cKR588MFO2wE3bdokJk+eLHQ6nRg2bJjDbfiKt+5/f38OdORqS2h/fQ505Oz+++tzwBP3/3//+5+YPHmyCAsLE6GhoWLSpElizZo1neqX+OPfXwjvPQb9+TkghLWOyx/+8AcRFRUloqOjxcUXXywKCgocjtm/f78488wzhV6vF4MHDxb/7//9P4/cB5XtjhAREREFhAGZsEtERESBi8ELERERBRQGL0RERBRQGLwQERFRQGHwQkRERAGFwQsREREFFAYvREREFFAYvBAREVFAYfBC5ENr167t1HY+kDzyyCOYPHmyr4dBAE6cOAGVSoXMzExfDyWgbN68GSqVqlMTQvJvDF7IwXXXXQeVSgWVSgWdTocRI0bg0UcfRVtbm6+H1i2VSoXPPvvM18NwsGnTJixevBgxMTEICQnB2LFjsXz5cpw8edLXQ/OI++67Dxs3bvTIdTU3NyM6OhqxsbFOu/Kmp6dDpVLhl19+cTj97rvvxty5cx1Oq6urw5///GdkZGTAYDAgMTERCxYswCeffAIWFe+b6667DhdddJGvh9Erc+fOxd133+3rYZAHMHihThYtWoSSkhIcO3YMy5cvxyOPPIKnn366V9dlNpthsVg8PMLA8Oqrr2LBggVITEzExx9/jMOHD2PNmjWora3Fs88+6+vheURYWBhiYmI8cl0ff/wxxo0bh4yMDJdBqMFgwIMPPtjl9dTU1GD27Nl4++23sWLFCuzduxc//vgjLr/8cjzwwAOora31yHiJutLa2urrIfRvHumQRP3GtddeK5YsWeJw2jnnnCNOP/10IYQQLS0tYvny5SI5OVmEhISI0047TWzatEk+9s033xSRkZHi888/F2PGjBEajUbk5eWJlpYW8cADD4iUlBSh0+nE8OHDxb///W/5cgcPHhSLFi0SoaGhIj4+XlxzzTXi1KlT8vlz5swRd955p7j//vvFoEGDREJCgli1apV8/pAhQ5w2yszJyREXXnihiI+PF6GhoWL69Oliw4YNDvevuLhYLF68WBgMBpGeni7effddMWTIEPH888/Lx1RXV4sbbrhBxMbGivDwcDFv3jyRmZnp8nEsLCwUOp1O3H333U7Plxr4SY/X+vXrRUZGhggNDRULFy4UxcXF8rE7d+4UCxYsEDExMSIiIkKcffbZYs+ePQ7XB0D861//EhdddJEIDg4WI0aMEJ9//rnDMZ9//rkYMWKE0Ov1Yu7cuWLt2rWdmgn+9NNP4swzzxQGg0GkpKSIO++8UzQ0NLi8n6tWrRKTJk2Sf5eeP08//bRITEwU0dHR4rbbbpO7zHZl7ty5Ys2aNeKVV14R55xzTqfzhwwZIu666y6h0+nE119/LZ/+xz/+UcyZM0f+/dZbbxWhoaHi5MmTna6jvr5etLa2uhzDF198IaZPny70er2IiYkRF110kXze22+/LaZNmybCwsJEQkKCuPLKK0VZWZl8flVVlbjqqqtEbGysMBgMYsSIEeKNN96Qzy8oKBCXXXaZiIyMFIMGDRIXXnihyMvLk8/ftGmTmDFjhggJCRGRkZFi9uzZ4sSJEy7HumPHDjF58mSh1+vFtGnTxCeffCIAiH379gkh2p9b9j799FPR8W3/s88+E1OmTBF6vV4MHTpUPPLIIy4fI2eNaaXX/4EDB8S8efPkJoTLli0T9fX1Lsc/bdo08fTTT8u/L1myRGi1WvkyhYWFAoA4duyYEKL7956KigpxxRVXiOTkZBEcHCzGjx8v1q1bJ59/7bXXdhp7Xl6e3FTz+++/F9OmTRPBwcFi1qxZ4siRIz16nACI1atXiwsuuECEhIQ4vD+R5zF4IQfOgpcLL7xQTJ06VQghxI033ihmz54tfvzxR5GTkyOefvppodfrxdGjR4UQ1jfMoKAgMXv2bLF161Zx5MgR0djYKH73u9+J1NRU8cknn4jjx4+L77//Xvz3v/8VQlg/yOPi4sSKFStEVlaW2Lt3rzjnnHPEvHnz5DHMmTNHREREiEceeUQcPXpUvPXWW0KlUonvvvtOCCFEeXm53BW1pKRElJeXCyGEyMzMFGvWrBEHDx4UR48eFQ8//LAwGAwiPz9fvu4FCxaIyZMni19++UXs2bNHzJkzRwQHBzsELwsWLBAXXHCB2LVrlzh69KhYvny5iImJEZWVlU4fx+eee04AcAhCnJEerwULFohdu3aJPXv2iDFjxoirrrpKPmbjxo3inXfeEVlZWeLw4cPihhtuEAkJCaKurk4+BoBISUkR69atE8eOHRN33XWXCAsLk8eXm5srgoKCxH333SeOHDki3nvvPTF48GCH4CUnJ0eEhoaK559/Xhw9elRs3bpVTJkyRVx33XUux+8seImIiBC33HKLyMrKEl9++aUICQkRr732WpePQ05OjtDr9aKqqkpUVlYKg8HQ6YNbCijvuusuMXHiRLl7r33wYjabxaBBg8RNN93U5e0589VXXwmNRiNWrlwpDh8+LDIzM8Xf//53+fzXX39dfPPNN+L48eNi+/btYtasWeK8886Tz7/99tvF5MmTxa5du0ReXp7YsGGD+OKLL4QQQphMJjFmzBjxhz/8QRw4cEAcPnxYXHXVVWL06NHCaDSK1tZWERkZKe677z6Rk5MjDh8+LNauXevwPLVXX18v4uLixFVXXSUOHTokvvzySzFs2LAeBy8//vijiIiIEGvXrhXHjx8X3333nUhPTxePPPKIy9v93e9+JxYtWiRKSkpESUmJMBqNoqGhQSQlJYlLLrlEHDx4UGzcuFEMHTpUXHvttS4f73vvvVf85je/EUIIYbFYRHR0tIiNjRX/+9//hBBC/Oc//xGDBw+Wj+/uvaeoqEg8/fTTYt++feL48ePin//8p9BoNGLHjh1CCCFqamrErFmzxLJly+Sxt7W1ycHLzJkzxebNm8Wvv/4qzjrrLDF79uwePU4ARHx8vHjjjTfE8ePHXf7tyDMYvJAD++DFYrGIDRs2CL1eL+677z6Rn58vNBpNp2+08+fPFytWrBBCWN8wATjMSmRnZwsAnWY8JI899pg499xzHU6TvnVlZ2cLIazBy5lnnulwzIwZM8SDDz4o/w5AfPrpp93ex3HjxokXX3xRCCFEVlaWACB27doln3/s2DEBQA5efvrpJxERESFaWlocrmf48OHi1VdfdXobt956q4iIiOh2LNLjlZOTI5/28ssvi4SEBJeXMZvNIjw8XHz55ZfyaQDEww8/LP/e0NAgAMgfBA8++KAYP368w/X8+c9/dghebrjhhk4f+j/99JNQq9WiubnZ6VicBS9DhgwRbW1t8mmXXXaZuPzyy13eHyGE+NOf/uQwy7FkyZJO31yl4KW8vFyEh4eLt99+WwjhGLyUlZUJAOK5557r8vacmTVrlrj66qvdPn7Xrl0CgDxTcMEFF4jrr7/e6bHvvPOOGD16tLBYLPJpRqNRBAcHi2+//VZUVlYKAGLz5s1u3farr74qYmJiHP4ur7zySo+Dl/nz5zsEaNJYk5KSXN62sy84r732mhg0aJDDLN3XX38t1Gq1KC0tdXo9X3zxhYiMjBRtbW0iMzNTJCYmij/+8Y/ya/rGG2+Ug3h33nuc+c1vfiOWL18u/z5nzhzxxz/+0eEY+5kX+7EDkB9fdx4nAC5nWsnzmPNCnXz11VcICwuDwWDAeeedh8svvxyPPPIIDh48CLPZjFGjRiEsLEz+2bJlC44fPy5fXqfTYeLEifLvmZmZ0Gg0mDNnjtPb279/PzZt2uRwnRkZGQDgcL321wkASUlJKC8v7/K+NDQ04L777sOYMWMQFRWFsLAwZGVloaCgAACQnZ0NrVaLqVOnypcZMWIEBg0a5DC+hoYGxMTEOIwxLy/PYXz2hBBQqVRdjk0SEhKC4cOHu7xfZWVlWLZsGUaOHInIyEhERESgoaFBvg8S+8cnNDQUERER8vVkZ2djxowZDsefdtppDr/v378fa9eudbiPCxcuhMViQV5enlv3BQDGjRsHjUbj8v50ZDab8dZbb+Gaa66RT7vmmmuwdu1ap/lScXFxuO+++7By5UqYTCaH80QfknEzMzMxf/58l+fv2bMHF1xwAdLS0hAeHi4/n6W/w6233or//ve/mDx5Mh544AFs27ZNvuz+/fuRk5OD8PBw+bGNjo5GS0sLjh8/jujoaFx33XVYuHAhLrjgArzwwgsoKSlxOZasrCxMnDgRBoNBPm3WrFk9vs/79+/Ho48+6vA3X7ZsGUpKStDU1OT29WRlZWHSpEkIDQ2VTzvjjDNgsViQnZ3t9DJnnXUW6uvrsW/fPmzZsgVz5szB3LlzsXnzZgDAli1b5ERsd957zGYzHnvsMUyYMAHR0dEICwvDt99+2+l14or96ycpKQkA5Oetu4/T9OnT3XvAqM+0vh4A+Z958+bhlVdegU6nQ3JyMrRa69OkoaEBGo0Ge/bscfhwAqyJm5Lg4GCHD+7g4OAub6+hoQEXXHABnnzyyU7nSW8iABAUFORwnkql6jYZ+L777sOGDRvwzDPPYMSIEQgODsZvf/vbTh963Y0vKSlJflO152qb86hRo1BbW4uSkhKH++CMs/tl/yF87bXXorKyEi+88AKGDBkCvV6PWbNmdboPvXl87DU0NODmm2/GXXfd1em8tLQ0t6+np+P49ttvcfLkSVx++eUOp5vNZmzcuBHnnHNOp8vce++9WL16NVavXu1welxcHKKionDkyBG3xyvp6nna2NiIhQsXYuHChXj33XcRFxeHgoICLFy4UP47nHfeecjPz8c333yDDRs2YP78+bj99tvxzDPPoKGhAdOmTcO7777b6brj4uIAAG+++SbuuusurF+/Hu+//z4efvhhbNiwAaeffnqP7wsAqNXqTsFcxyTShoYG/PWvf8Ull1zS6fL2gZESoqKiMGnSJGzevBnbt2/HOeecg7PPPhuXX345jh49imPHjskBojvvPU8//TReeOEF/OMf/8CECRMQGhqKu+++2+3Xuv3zVnr/kp637j5O9sEbKYvBC3USGhqKESNGdDp9ypQpMJvNKC8vx1lnneX29U2YMAEWiwVbtmzBggULOp0/depUfPzxx0hPT5cDpd4ICgqC2Wx2OG3r1q247rrrcPHFFwOwvgmdOHFCPn/06NFoa2vDvn37MG3aNABATk4OqqurHcZXWloKrVaL9PR0t8by29/+Fg899BCeeuopPP/8853Or6mpcbu+y9atW7F69WosXrwYAFBYWIiKigq3LisZPXo0vvnmG4fTdu3a5fD71KlTcfjwYad/eyW9/vrruOKKK/DnP//Z4fTHH38cr7/+utPgJSwsDH/5y1/wyCOP4MILL5RPV6vVuOKKK/DOO+9g1apVSE5OdrhcQ0MDDAaD0+fZxIkTsXHjRlx//fWdzjty5AgqKyvx//7f/0NqaioAYPfu3Z2Oi4uLw7XXXotrr70WZ511Fu6//34888wzmDp1Kt5//33Ex8cjIiLC5WMxZcoUTJkyBStWrMCsWbOwbt06p8HLmDFj8M4776ClpUX+8Oy4hTwuLg719fVobGyUP1Q71oCZOnUqsrOze/Q31+l0nV5nY8aMwdq1ax1ua+vWrVCr1Rg9erTL65ozZw42bdqEnTt34vHHH0d0dDTGjBmDxx9/HElJSRg1apT8uHT33rN161YsWbJEnsGzWCw4evQoxo4d2+XY3dGbx4mUxWUjctuoUaNw9dVXY+nSpfjkk0+Ql5eHnTt34oknnsDXX3/t8nLp6em49tpr8Yc//AGfffYZ8vLysHnzZnzwwQcAgNtvvx1VVVW48sorsWvXLhw/fhzffvstrr/++h690aSnp2Pjxo0oLS2Vg4+RI0fik08+QWZmJvbv34+rrrrKYRYgIyMDCxYswE033YSdO3di3759uOmmmxxmjxYsWIBZs2bhoosuwnfffYcTJ05g27Zt+POf/+z0AwwAUlNT8fzzz+OFF17ADTfcgC1btiA/Px9bt27FzTffjMcee8zt+zVy5Ei88847yMrKwo4dO3D11Vd3O5vV0c0334wjR47gwQcfxNGjR/HBBx9g7dq1ANq/ZT744IPYtm0b7rjjDmRmZuLYsWP4/PPPcccdd/Totnri1KlT+PLLL3Httddi/PjxDj9Lly7FZ599hqqqKqeXvemmmxAZGYl169Y5nP74448jNTUVM2fOxNtvv43Dhw/j2LFjeOONNzBlyhQ0NDQ4vb5Vq1bhvffew6pVq5CVlYWDBw/Ks4FpaWnQ6XR48cUXkZubiy+++KLT33DlypX4/PPPkZOTg19//RVfffUVxowZAwC4+uqrERsbiyVLluCnn36SXwN33XUXioqKkJeXhxUrVmD79u3Iz8/Hd999h2PHjsmX7+iqq66CSqXCsmXLcPjwYXzzzTd45plnHI6ZOXMmQkJC8Kc//QnHjx/HunXr5L+5/Zjffvtt/PWvf8Wvv/6KrKws/Pe//8XDDz/s/A8G6+vswIEDyM7ORkVFBVpbW3H11VfDYDDg2muvxaFDh7Bp0ybceeed+P3vf4+EhASX1zV37lx8++230Gq18lLx3Llz8e677zosM7vz3jNy5Ehs2LAB27ZtQ1ZWFm6++WaUlZV1GvuOHTtw4sQJVFRUuD0z2ZvHiRTm25Qb8jfOkvHsmUwmsXLlSpGeni6CgoJEUlKSuPjii8WBAweEEM6TBIUQorm5Wdxzzz0iKSlJ6HS6TttIjx49Ki6++GIRFRUlgoODRUZGhrj77rvlBEdniXZLlixx2M3wxRdfiBEjRgitVitvlc7LyxPz5s0TwcHBIjU1Vbz00kudrqu4uFicd955Qq/XiyFDhoh169aJ+Ph4sWbNGvmYuro6ceedd4rk5GQRFBQkUlNTxdVXXy0KCgq6fDw3bNggFi5cKAYNGiQMBoPIyMgQ9913n7wLyZ2kyr1794rp06cLg8EgRo4cKT788MNOW7nhJFk5MjJSvPnmm/LvHbdKSwme9kmfO3fuFOecc44ICwsToaGhYuLEieLxxx93ef9cbZW213Ers71nnnlGREVFOd1KbTQaRVRUlHjhhReEEKLTfRZCiHXr1gkAna6/pqZGPPTQQ2LkyJFCp9OJhIQEsWDBAvHpp586JM129PHHH4vJkycLnU4nYmNjxSWXXOJwW+np6UKv14tZs2aJL774wiFB9rHHHhNjxowRwcHBIjo6WixZskTk5ubKly8pKRFLly4VsbGxQq/Xi2HDholly5aJ2tpaUVpaKi666CL59TFkyBCxcuVKeUeVM9u3bxeTJk0SOp1OTJ48WXz88ccO4xHC+lwaMWKECA4OFueff7547bXXOm2VXr9+vZg9e7YIDg4WERER4rTTTutyd1h5ebn8HEEftkoLIURlZaVQqVQOCd3S89/+9SdE9+89lZWVYsmSJSIsLEzEx8eLhx9+WCxdutTh+ZidnS1OP/10ERwc3GmrtH3JgH379snnu/s4OXsNknJUQrDcJJG9oqIipKam4vvvv+8ygTPQPf7441izZg0KCwt9PRQioh5hzgsNeD/88AMaGhowYcIElJSU4IEHHkB6ejrOPvtsXw/No1avXo0ZM2YgJiYGW7duxdNPP63okhARkVIYvNCA19raij/96U/Izc1FeHg4Zs+ejXfffbfTrplAd+zYMfztb39DVVUV0tLSsHz5cqxYscLXwyIi6jEuGxEREVFA4W4jIiIiCigMXoiIiCigMHghIiKigMLghYiIiAIKgxciIiIKKAxeiIiIKKAweCEiIqKAwuCFiIiIAsr/ByAAoaLM1uOZAAAAAElFTkSuQmCC" }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 48 + "execution_count": 61 }, { "metadata": {}, @@ -3490,8 +3490,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-10T12:59:28.510716Z", - "start_time": "2025-01-10T12:59:28.507553Z" + "end_time": "2025-01-13T10:17:24.698336Z", + "start_time": "2025-01-13T10:17:24.680930Z" } }, "cell_type": "code", @@ -3507,12 +3507,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "Sum of values < 0: 0.0\n", - "0.0\n" + "Sum of values < 0: -53722.68208498721\n", + "-0.18758935119751025\n" ] } ], - "execution_count": 49 + "execution_count": 62 }, { "metadata": {}, From 4ad52343732e6d76bb061549e04f7c5224b0ff0a Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 13 Jan 2025 14:08:39 +0000 Subject: [PATCH 191/291] Fixed up graphs and edited to make 5-year groupings --- src/scripts/climate_change/cohort_model.py | 270 ++++++++++++--------- 1 file changed, 149 insertions(+), 121 deletions(-) diff --git a/src/scripts/climate_change/cohort_model.py b/src/scripts/climate_change/cohort_model.py index 84be2caa96..2efb9a25b8 100644 --- a/src/scripts/climate_change/cohort_model.py +++ b/src/scripts/climate_change/cohort_model.py @@ -90,7 +90,7 @@ # plt.plot(year_range, predictions_from_cmip_sum.iloc[0:36, -1] * 100) # plt.xlabel("Percentage Change in ANC cases due to weather") # plt.axhline(y=0, color='black', linestyle='--') -# +# plt.ylim(-12000,0) # # Check for negative values (missed cases?) # negative_sum = np.sum(multiplied_values[multiplied_values < 0]) # print("Sum of values < 0:", negative_sum) @@ -171,21 +171,21 @@ # 'Multiplied_Values': multiplied_values # }) # multiplied_values_df.to_csv(results_folder_to_save/f'multiplied_values_{scenario}_{model_type}.csv', index=False) + +# +# # Get unique districts from both sources +# adm2_districts = set(grid_clipped_ADM2['ADM2_EN'].unique()) +# prediction_districts = set(predictions_from_cmip_sum['District'].unique()) # -# # -# # # Get unique districts from both sources -# # adm2_districts = set(grid_clipped_ADM2['ADM2_EN'].unique()) -# # prediction_districts = set(predictions_from_cmip_sum['District'].unique()) -# # -# # # Districts in ADM2 but not in predictions -# # missing_in_predictions = adm2_districts - prediction_districts -# # print("Districts in ADM2 but not in predictions:", missing_in_predictions) -# # -# # # Districts in predictions but not in ADM2 -# # missing_in_adm2 = prediction_districts - adm2_districts -# # print("Districts in predictions but not in ADM2:", missing_in_adm2) -# # +# # Districts in ADM2 but not in predictions +# missing_in_predictions = adm2_districts - prediction_districts +# print("Districts in ADM2 but not in predictions:", missing_in_predictions) # +# # Districts in predictions but not in ADM2 +# missing_in_adm2 = prediction_districts - adm2_districts +# print("Districts in predictions but not in ADM2:", missing_in_adm2) +# + # # # ## now all grids @@ -266,121 +266,149 @@ # plt.suptitle("Percentage Difference Maps by Scenario and Model Type", fontsize=16, y=1.02) # plt.savefig(results_folder_to_save / 'percentage_difference_maps_grid.png') # plt.show() +# Create a figure with a grid layout (2 rows, 3 columns) +fig, axes = plt.subplots(2, 3, figsize=(18, 12), constrained_layout=True) + +# Initialize variables to track global min/max for color normalization +global_min = float('inf') +global_max = float('-inf') + +# Loop over scenarios and model types to process the data +for scenario in scenarios: + for model_type in model_types: + predictions_from_cmip = pd.read_csv( + f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' + ) + + predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'District']).sum().reset_index() + predictions_from_cmip_sum.loc[predictions_from_cmip_sum['Difference_in_Expectation'] > 0, 'Difference_in_Expectation'] = 0 + + predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( + {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} + ) + + # Collect percentage differences by year and district + percentage_diff_by_year_district = {} + + for year, year_data in predictions_from_cmip_sum.groupby('Year'): + if year not in percentage_diff_by_year_district: + percentage_diff_by_year_district[year] = {} + for _, row in year_data.iterrows(): + district = row['District'] + percentage_diff = row['Difference_in_Expectation'] + + if district not in percentage_diff_by_year_district[year]: + percentage_diff_by_year_district[year][district] = 0 + percentage_diff_by_year_district[year][district] += percentage_diff + + # Prepare data for plotting + data_for_plot = pd.DataFrame.from_dict(percentage_diff_by_year_district, orient='index').fillna(0) + + # Plot on corresponding subplot + ax = axes[scenarios.index(scenario), model_types.index(model_type)] + data_for_plot.plot(kind='bar', stacked=True, ax=ax, cmap='tab20', legend = False) + + ax.set_title(f"{scenario}: {model_type}", fontsize=14) + ax.set_xlabel('Year', fontsize=12) + ax.set_ylabel('Percentage Difference (%)', fontsize=12) + + # Update global min/max for color scaling + local_min = data_for_plot.min().min() + local_max = data_for_plot.max().max() + global_min = min(global_min, local_min) + global_max = max(global_max, local_max) + +fig = plt.gcf() +handles, labels = ax.get_legend_handles_labels() +fig.legend(handles, labels, loc='center left', bbox_to_anchor=(1.05, 0.5), fontsize=12, title="Districts") + +# Adjust the overall layout +plt.suptitle("Percentage Difference by Year and District", fontsize=16, y=1.02) +plt.savefig(results_folder_to_save / 'percentage_difference_by_year_district_grid.png') +plt.show() + + +all_districts = set() +significant_results_year = [] # -# percentage_diff_by_year_district = {} -# +# # Assuming 'district' is a column in your data # for scenario in scenarios: # for model_type in model_types: # predictions_from_cmip = pd.read_csv( # f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' # ) -# -# predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'District']).sum().reset_index() -# predictions_from_cmip_sum.loc[predictions_from_cmip_sum['Difference_in_Expectation'] > 0, 'Difference_in_Expectation'] = 0 -# -# predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( -# {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} -# ) -# -# # Collect percentage differences by year and district -# for year, year_data in predictions_from_cmip_sum.groupby('Year'): -# if year not in percentage_diff_by_year_district: -# percentage_diff_by_year_district[year] = {} -# for _, row in year_data.iterrows(): -# district = row['District'] -# percentage_diff = row['Difference_in_Expectation'] -# -# if district not in percentage_diff_by_year_district[year]: -# percentage_diff_by_year_district[year][district] = 0 -# percentage_diff_by_year_district[year][district] += percentage_diff -# data_for_plot = pd.DataFrame.from_dict(percentage_diff_by_year_district, orient='index').fillna(0) -# -# fig, ax = plt.subplots(figsize=(12, 8)) -# data_for_plot.plot(kind='bar', stacked=True, ax=ax, cmap='tab20') -# ax.set_xlabel('Year', fontsize=12) -# ax.set_ylabel('Percentage Difference (%)', fontsize=12) -# ax.legend(title='District', bbox_to_anchor=(1.05, 1), loc='upper left', fontsize=10) -# plt.tight_layout() -# plt.savefig(results_folder_to_save / 'stacked_bar_percentage_difference.png') -# plt.show() -# -# all_districts = set() -# -# for i, scenario in enumerate(scenarios): -# for j, model_type in enumerate(model_types): -# predictions_from_cmip = pd.read_csv( -# f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' -# ) -# -# predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'District']).sum().reset_index() -# predictions_from_cmip_sum.loc[predictions_from_cmip_sum['Difference_in_Expectation'] > 0, 'Difference_in_Expectation'] = 0 -# -# predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( -# {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} -# ) -# -# # Create Period column to group years into 5-year intervals -# predictions_from_cmip_sum['Period'] = ((predictions_from_cmip_sum['Year'] - 1) // 5) * 5 + 1 -# -# # Collect percentage differences by 5-year period and district -# for period, period_data in predictions_from_cmip_sum.groupby('Period'): -# for _, row in period_data.iterrows(): -# district = row['District'] -# percentage_diff = row['Difference_in_Expectation'] -# -# if period not in percentage_diff_by_year_district: -# percentage_diff_by_year_district[period] = {} -# if district not in percentage_diff_by_year_district[period]: -# percentage_diff_by_year_district[period][district] = 0 -# percentage_diff_by_year_district[period][district] += percentage_diff -# all_districts.add(district) -# -# data_for_plot = pd.DataFrame.from_dict(percentage_diff_by_year_district, orient='index').fillna(0) -# -# # Plotting the data in the respective subplot -# ax = axes[i, j] -# data_for_plot.plot(kind='bar', stacked=True, ax=ax, cmap='tab20', legend=False) -# ax.set_title(f"{scenario}: {model_type}", fontsize=10) -# if i == len(scenarios) - 1: -# ax.set_xlabel('Period (5 years)', fontsize=10) -# if j == 0: -# ax.set_ylabel('Defecit of ANC services', fontsize=10) -# -# # # Create a single legend outside the grid -# # handles, labels = ax.get_legend_handles_labels() -# # fig.legend( -# # handles, -# # labels, -# # title="District", -# # bbox_to_anchor=(1.02, 0.5), -# # loc='center left', -# # fontsize=10 -# # ) -# -# plt.tight_layout(rect=[0, 0, 0.85, 1]) # Leave space for the legend -# plt.savefig(results_folder_to_save / 'stacked_bar_percentage_difference_5_years_grid_single_legend.png') -# plt.show() +# predictions_from_cmip_sum = predictions_from_cmip.groupby(['District', 'Year']).sum().reset_index() +# for district in predictions_from_cmip_sum['District'].unique(): +# district_values = predictions_from_cmip_sum[predictions_from_cmip_sum['District'] == district] +# no_weather_model = district_values['Predicted_No_Weather_Model'].values +# weather_model = district_values['Predicted_Weather_Model'].values +# +# # Calculate the difference +# difference = no_weather_model - weather_model +# +# # Perform a one-sample t-test assuming 0 as the null hypothesis mean +# t_stat, p_value = ttest_1samp(difference, popmean=0) +# # Print results if p-value is below 0.05 (statistically significant) +# if p_value < 0.05: +# print(f"Scenario: {scenario}, Model Type: {model_type}, District: {district}, " +# f"t-stat: {t_stat:.2f}, p-value: {p_value:.4f}") +# ## now all grids -significant_results_year = [] +# Define the dictionary outside the loop to accumulate data across all iterations +percentage_diff_by_year_district = {} -# Assuming 'district' is a column in your data -for scenario in scenarios: - for model_type in model_types: +# Create the figure and axes grid +fig, axes = plt.subplots(2, 3, figsize=(18, 12), constrained_layout=True) + +all_districts = set() + +for i, scenario in enumerate(scenarios): + for j, model_type in enumerate(model_types): + # Load the data predictions_from_cmip = pd.read_csv( f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' ) - predictions_from_cmip_sum = predictions_from_cmip.groupby(['District', 'Year']).sum().reset_index() - for district in predictions_from_cmip_sum['District'].unique(): - district_values = predictions_from_cmip_sum[predictions_from_cmip_sum['District'] == district] - no_weather_model = district_values['Predicted_No_Weather_Model'].values - weather_model = district_values['Predicted_Weather_Model'].values - - # Calculate the difference - difference = no_weather_model - weather_model - - # Perform a one-sample t-test assuming 0 as the null hypothesis mean - t_stat, p_value = ttest_1samp(difference, popmean=0) - # Print results if p-value is below 0.05 (statistically significant) - if p_value < 0.05: - print(f"Scenario: {scenario}, Model Type: {model_type}, District: {district}, " - f"t-stat: {t_stat:.2f}, p-value: {p_value:.4f}") + + # Summing data by Year and District + predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'District']).sum().reset_index() + + # Adjust the 'Difference_in_Expectation' values + predictions_from_cmip_sum.loc[predictions_from_cmip_sum['Difference_in_Expectation'] > 0, 'Difference_in_Expectation'] = 0 + + # Rename districts + predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( + {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} + ) + + # Create Period column to group years into 5-year intervals + predictions_from_cmip_sum['Period'] = ((predictions_from_cmip_sum['Year'] - 1) // 5) * 5 + 5 + + # Collect percentage differences by 5-year period and district + for period, period_data in predictions_from_cmip_sum.groupby('Period'): + for _, row in period_data.iterrows(): + district = row['District'] + percentage_diff = row['Difference_in_Expectation'] + + # Initialize dictionary structure if not already present + if period not in percentage_diff_by_year_district: + percentage_diff_by_year_district[period] = {} + if district not in percentage_diff_by_year_district[period]: + percentage_diff_by_year_district[period][district] = 0 + percentage_diff_by_year_district[period][district] += percentage_diff + all_districts.add(district) + + # Create a DataFrame for plotting + data_for_plot = pd.DataFrame.from_dict(percentage_diff_by_year_district, orient='index').fillna(0) + # Plotting the data in the respective subplot + ax = axes[i, j] + data_for_plot.plot(kind='bar', stacked=True, ax=ax, cmap='tab20', legend=False) + ax.set_title(f"{scenario}: {model_type}", fontsize=10) + if i == len(scenarios) - 1: + ax.set_xlabel('Period (5 years)', fontsize=10) + if j == 0: + ax.set_ylabel('Deficit of ANC services', fontsize=10) + if (i == 0) & (j == 2): + ax.legend(title="Districts", fontsize=8, title_fontsize=10, bbox_to_anchor=(1.09, 1)) +plt.tight_layout() +plt.savefig(results_folder_to_save / 'stacked_bar_percentage_difference_5_years_grid_single_legend.png') +plt.show() From 4a1567cee4b2b3409533dc81da0c8391df7378b8 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 14 Jan 2025 09:55:16 +0000 Subject: [PATCH 192/291] Undid hashing out --- src/scripts/climate_change/cohort_model.py | 453 +++++++++++---------- 1 file changed, 231 insertions(+), 222 deletions(-) diff --git a/src/scripts/climate_change/cohort_model.py b/src/scripts/climate_change/cohort_model.py index 2efb9a25b8..1493debaa3 100644 --- a/src/scripts/climate_change/cohort_model.py +++ b/src/scripts/climate_change/cohort_model.py @@ -65,208 +65,217 @@ scenarios = ['ssp245', 'ssp585'] model_types = ['lowest', 'median', 'highest'] year_range = range(min_year, max_year) -# -# # Loop through scenarios and model types -# for scenario in scenarios: -# for model_type in model_types: -# predictions_from_cmip = pd.read_csv( -# f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' -# ) -# predictions_from_cmip_sum = predictions_from_cmip.groupby('Year').sum().reset_index() -# predictions_from_cmip_sum['Percentage_Difference'] = ( -# predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum[ -# 'Predicted_No_Weather_Model']) -# # Match birth results and predictions -# matching_rows = min(len(births_model_subset), len(predictions_from_cmip_sum)) -# print(matching_rows) -# multiplied_values = births_model_subset.head(matching_rows).iloc[:, 1].values * predictions_from_cmip_sum[ -# 'Percentage_Difference'].head(matching_rows).values -# births_model_subset['Multiplied_Values'] = multiplied_values -# -# # Plot the results -# plt.plot(year_range, multiplied_values) -# plt.ylabel("Change ANC cases due to weather") -# plt.axhline(y=0, color='black', linestyle='--') -# plt.plot(year_range, predictions_from_cmip_sum.iloc[0:36, -1] * 100) -# plt.xlabel("Percentage Change in ANC cases due to weather") -# plt.axhline(y=0, color='black', linestyle='--') -# plt.ylim(-12000,0) -# # Check for negative values (missed cases?) -# negative_sum = np.sum(multiplied_values[multiplied_values < 0]) -# print("Sum of values < 0:", negative_sum) -# print(negative_sum / births_model_subset['Model_mean'].sum() * 100) -# -# # Plot by zone -# predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'Zone']).sum().reset_index() -# plt.figure(figsize=(10, 6)) -# for zone in predictions_from_cmip_sum['Zone'].unique(): -# zone_data = predictions_from_cmip_sum[predictions_from_cmip_sum['Zone'] == zone] -# zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data[ -# 'Predicted_No_Weather_Model']) * 100 -# plt.plot(zone_data['Year'], zone_data['Percentage_Difference'], label=f'Zone {zone}') -# plt.xlabel("Year") -# plt.ylabel("Change ANC cases due to weather") -# plt.axhline(y=0, color='black', linestyle='--') -# plt.ylim(-1.5, 0) -# plt.legend(title='Zones') -# -# # Plot by district -# predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'District']).sum().reset_index() -# plt.figure(figsize=(10, 6)) -# for district in predictions_from_cmip_sum['District'].unique(): -# district_data = predictions_from_cmip_sum[predictions_from_cmip_sum['District'] == district] -# district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data[ -# 'Predicted_No_Weather_Model']) * 100 -# plt.plot(district_data['Year'], district_data['Percentage_Difference'], label=f'{district}') -# plt.xlabel("Year") -# plt.ylabel("Change ANC cases due to weather") -# plt.axhline(y=0, color='black', linestyle='--') -# plt.ylim(-2.5, 0) -# plt.legend(title='Districts') -# -# # Generate district map visualization -# predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( -# {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"}) -# polygons = [ -# Polygon( -# [(x, y), (x + difference_long, y), (x + difference_long, y + difference_lat), (x, y + difference_lat)]) -# for x in long_data for y in lat_data -# ] -# grid = gpd.GeoDataFrame({'geometry': polygons}, crs=malawi.crs) -# #grid_clipped_ADM2 = gpd.overlay(grid, malawi_admin2, how='intersection') -# predictions_from_cmip_sum['Percentage_Difference'] = (predictions_from_cmip_sum['Difference_in_Expectation'] / -# predictions_from_cmip_sum[ -# 'Predicted_No_Weather_Model']) * 100 -# percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() -# malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) -# malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 -# -# # Plot map -# fig, ax = plt.subplots(figsize=(12, 12)) -# #malawi_admin2.plot(ax=ax, edgecolor='white', color='white') -# malawi_admin2.dropna(subset=['Percentage_Difference']).plot( -# ax=ax, -# column='Percentage_Difference', -# cmap='Blues_r', -# edgecolor='black', -# alpha=1, -# legend=False -# ) -# sm = plt.cm.ScalarMappable(cmap='Blues_r', -# norm=mcolors.Normalize(vmin=malawi_admin2['Percentage_Difference'].min(), -# vmax=malawi_admin2['Percentage_Difference'].max())) -# sm.set_array([]) -# cbar = plt.colorbar(sm, ax=ax, orientation="vertical", shrink=0.7) -# cbar.set_label("Percentage Difference (%)", fontsize=12) -# plt.xlabel("Longitude", fontsize=14) -# plt.ylabel("Latitude", fontsize=14) -# plt.title(f"{scenario}: {model_type}", fontsize=16) -# plt.tight_layout() -# plt.savefig(results_folder_to_save / f'{scenario}_{model_type}_map_Malawi_cumulative_difference.png') -# # Save multiplied values by model and scenario -# multiplied_values_df = pd.DataFrame({ -# 'Year': year_range[:matching_rows], -# 'Scenario': scenario, -# 'Model_Type': model_type, -# 'Multiplied_Values': multiplied_values -# }) -# multiplied_values_df.to_csv(results_folder_to_save/f'multiplied_values_{scenario}_{model_type}.csv', index=False) +results_list = [] -# -# # Get unique districts from both sources -# adm2_districts = set(grid_clipped_ADM2['ADM2_EN'].unique()) -# prediction_districts = set(predictions_from_cmip_sum['District'].unique()) -# -# # Districts in ADM2 but not in predictions -# missing_in_predictions = adm2_districts - prediction_districts -# print("Districts in ADM2 but not in predictions:", missing_in_predictions) -# -# # Districts in predictions but not in ADM2 -# missing_in_adm2 = prediction_districts - adm2_districts -# print("Districts in predictions but not in ADM2:", missing_in_adm2) -# +# Loop through scenarios and model types +for scenario in scenarios: + for model_type in model_types: + predictions_from_cmip = pd.read_csv( + f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' + ) + predictions_from_cmip_sum = predictions_from_cmip.groupby('Year').sum().reset_index() + predictions_from_cmip_sum['Percentage_Difference'] = ( + predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum[ + 'Predicted_No_Weather_Model']) + # Match birth results and predictions + matching_rows = min(len(births_model_subset), len(predictions_from_cmip_sum)) + multiplied_values = births_model_subset.head(matching_rows).iloc[:, 1].values * predictions_from_cmip_sum[ + 'Percentage_Difference'].head(matching_rows).values + births_model_subset['Multiplied_Values'] = multiplied_values + + # Plot the results + plt.plot(year_range, multiplied_values) + plt.ylabel("Change ANC cases due to weather") + plt.axhline(y=0, color='black', linestyle='--') + plt.plot(year_range, predictions_from_cmip_sum.iloc[0:36, -1] * 100) + plt.xlabel("Percentage Change in ANC cases due to weather") + plt.axhline(y=0, color='black', linestyle='--') + plt.ylim(-12000,0) + # Check for negative values (missed cases?) + negative_sum = np.sum(multiplied_values[multiplied_values < 0]) + + result_df = pd.DataFrame({ + "Scenario": [scenario], + "Model_Type": [model_type], + "Negative_Sum": [negative_sum], + "Negative_Percentage": [negative_sum / births_model_subset['Model_mean'].sum() * 100] + }) + + results_list.append(result_df) + # Plot by zone + predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'Zone']).sum().reset_index() + plt.figure(figsize=(10, 6)) + for zone in predictions_from_cmip_sum['Zone'].unique(): + zone_data = predictions_from_cmip_sum[predictions_from_cmip_sum['Zone'] == zone] + zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data[ + 'Predicted_No_Weather_Model']) * 100 + plt.plot(zone_data['Year'], zone_data['Percentage_Difference'], label=f'Zone {zone}') + plt.xlabel("Year") + plt.ylabel("Change ANC cases due to weather") + plt.axhline(y=0, color='black', linestyle='--') + plt.ylim(-1.5, 0) + plt.legend(title='Zones') + + # Plot by district + predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'District']).sum().reset_index() + plt.figure(figsize=(10, 6)) + for district in predictions_from_cmip_sum['District'].unique(): + district_data = predictions_from_cmip_sum[predictions_from_cmip_sum['District'] == district] + district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data[ + 'Predicted_No_Weather_Model']) * 100 + plt.plot(district_data['Year'], district_data['Percentage_Difference'], label=f'{district}') + plt.xlabel("Year") + plt.ylabel("Change ANC cases due to weather") + plt.axhline(y=0, color='black', linestyle='--') + plt.ylim(-2.5, 0) + plt.legend(title='Districts') + + # Generate district map visualization + predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( + {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"}) + polygons = [ + Polygon( + [(x, y), (x + difference_long, y), (x + difference_long, y + difference_lat), (x, y + difference_lat)]) + for x in long_data for y in lat_data + ] + grid = gpd.GeoDataFrame({'geometry': polygons}, crs=malawi.crs) + grid_clipped_ADM2 = gpd.overlay(grid, malawi_admin2, how='intersection') + predictions_from_cmip_sum['Percentage_Difference'] = (predictions_from_cmip_sum['Difference_in_Expectation'] / + predictions_from_cmip_sum[ + 'Predicted_No_Weather_Model']) * 100 + percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() + malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) + malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 + + # Plot map + fig, ax = plt.subplots(figsize=(12, 12)) + #malawi_admin2.plot(ax=ax, edgecolor='white', color='white') + malawi_admin2.dropna(subset=['Percentage_Difference']).plot( + ax=ax, + column='Percentage_Difference', + cmap='Blues_r', + edgecolor='black', + alpha=1, + legend=False + ) + sm = plt.cm.ScalarMappable(cmap='Blues_r', + norm=mcolors.Normalize(vmin=malawi_admin2['Percentage_Difference'].min(), + vmax=malawi_admin2['Percentage_Difference'].max())) + sm.set_array([]) + cbar = plt.colorbar(sm, ax=ax, orientation="vertical", shrink=0.7) + cbar.set_label("Percentage Difference (%)", fontsize=12) + plt.xlabel("Longitude", fontsize=14) + plt.ylabel("Latitude", fontsize=14) + plt.title(f"{scenario}: {model_type}", fontsize=16) + plt.tight_layout() + plt.savefig(results_folder_to_save / f'{scenario}_{model_type}_map_Malawi_cumulative_difference.png') + # Save multiplied values by model and scenario + multiplied_values_df = pd.DataFrame({ + 'Year': year_range[:matching_rows], + 'Scenario': scenario, + 'Model_Type': model_type, + 'Multiplied_Values': multiplied_values + }) + multiplied_values_df.to_csv(results_folder_to_save/f'multiplied_values_{scenario}_{model_type}.csv', index=False) + +final_results = pd.concat(results_list, ignore_index=True) +final_results.to_csv('/Users/rem76/Desktop/Climate_change_health/Results/ANC_disruptions/negative_sums_and_percentages.csv', index=False) + +# Get unique districts from both sources +adm2_districts = set(grid_clipped_ADM2['ADM2_EN'].unique()) +prediction_districts = set(predictions_from_cmip_sum['District'].unique()) + +# Districts in ADM2 but not in predictions +missing_in_predictions = adm2_districts - prediction_districts +print("Districts in ADM2 but not in predictions:", missing_in_predictions) + +# Districts in predictions but not in ADM2 +missing_in_adm2 = prediction_districts - adm2_districts +print("Districts in predictions but not in ADM2:", missing_in_adm2) + + + + +## now all grids +fig, axes = plt.subplots(2, 3, figsize=(18, 12), constrained_layout=True) -# -# -# ## now all grids -# fig, axes = plt.subplots(2, 3, figsize=(18, 12), constrained_layout=True) -# -# global_min = float('inf') -# global_max = float('-inf') -# -# for scenario in scenarios: -# for model_type in model_types: -# predictions_from_cmip = pd.read_csv( -# f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' -# ) -# predictions_from_cmip_sum = predictions_from_cmip.groupby('District').sum().reset_index() -# predictions_from_cmip_sum['Percentage_Difference'] = ( -# predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model'] -# ) * 100 -# -# predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( -# {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} -# ) -# percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() -# malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) -# malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 -# -# local_min = malawi_admin2['Percentage_Difference'].min() -# local_max = malawi_admin2['Percentage_Difference'].max() -# global_min = min(global_min, local_min) -# global_max = max(global_max, local_max) -# -# for i, scenario in enumerate(scenarios): -# for j, model_type in enumerate(model_types): -# predictions_from_cmip = pd.read_csv( -# f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' -# ) -# predictions_from_cmip_sum = predictions_from_cmip.groupby('District').sum().reset_index() -# predictions_from_cmip_sum['Percentage_Difference'] = ( -# predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model'] -# ) * 100 -# -# predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( -# {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} -# ) -# percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() -# malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) -# malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 -# -# ax = axes[i, j] -# malawi_admin2.dropna(subset=['Percentage_Difference']).plot( -# ax=ax, -# column='Percentage_Difference', -# cmap='Blues_r', -# edgecolor='black', -# alpha=1, -# legend=False, -# vmin=global_min, -# vmax=global_max -# ) -# -# ax.set_title(f"{scenario}: {model_type}", fontsize=14) -# -# if i != 1: -# ax.set_xlabel("") -# if j != 0: -# ax.set_ylabel("") -# else: -# ax.set_ylabel("Latitude", fontsize=10) -# -# if i == 1: -# ax.set_xlabel("Longitude", fontsize=10) -# -# sm = plt.cm.ScalarMappable( -# cmap='Blues_r', -# norm=mcolors.Normalize(vmin=global_min, vmax=global_max) -# ) -# sm.set_array([]) -# fig.colorbar(sm, ax=axes, orientation="vertical", shrink=0.8, label="Percentage Difference (%)") -# plt.suptitle("Percentage Difference Maps by Scenario and Model Type", fontsize=16, y=1.02) -# plt.savefig(results_folder_to_save / 'percentage_difference_maps_grid.png') -# plt.show() -# Create a figure with a grid layout (2 rows, 3 columns) +global_min = float('inf') +global_max = float('-inf') + +for scenario in scenarios: + for model_type in model_types: + predictions_from_cmip = pd.read_csv( + f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' + ) + predictions_from_cmip_sum = predictions_from_cmip.groupby('District').sum().reset_index() + predictions_from_cmip_sum['Percentage_Difference'] = ( + predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model'] + ) * 100 + + predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( + {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} + ) + percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() + malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) + malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 + + local_min = malawi_admin2['Percentage_Difference'].min() + local_max = malawi_admin2['Percentage_Difference'].max() + global_min = min(global_min, local_min) + global_max = max(global_max, local_max) + +for i, scenario in enumerate(scenarios): + for j, model_type in enumerate(model_types): + predictions_from_cmip = pd.read_csv( + f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' + ) + predictions_from_cmip_sum = predictions_from_cmip.groupby('District').sum().reset_index() + predictions_from_cmip_sum['Percentage_Difference'] = ( + predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model'] + ) * 100 + + predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( + {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} + ) + percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() + malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) + malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 + + ax = axes[i, j] + malawi_admin2.dropna(subset=['Percentage_Difference']).plot( + ax=ax, + column='Percentage_Difference', + cmap='Blues_r', + edgecolor='black', + alpha=1, + legend=False, + vmin=global_min, + vmax=global_max + ) + + ax.set_title(f"{scenario}: {model_type}", fontsize=14) + + if i != 1: + ax.set_xlabel("") + if j != 0: + ax.set_ylabel("") + else: + ax.set_ylabel("Latitude", fontsize=10) + + if i == 1: + ax.set_xlabel("Longitude", fontsize=10) + +sm = plt.cm.ScalarMappable( + cmap='Blues_r', + norm=mcolors.Normalize(vmin=global_min, vmax=global_max) +) +sm.set_array([]) +fig.colorbar(sm, ax=axes, orientation="vertical", shrink=0.8, label="Percentage Difference (%)") +plt.suptitle("Percentage Difference Maps by Scenario and Model Type", fontsize=16, y=1.02) +plt.savefig(results_folder_to_save / 'percentage_difference_maps_grid.png') +plt.show() + +## By district fig, axes = plt.subplots(2, 3, figsize=(18, 12), constrained_layout=True) # Initialize variables to track global min/max for color normalization @@ -331,28 +340,28 @@ all_districts = set() significant_results_year = [] # -# # Assuming 'district' is a column in your data -# for scenario in scenarios: -# for model_type in model_types: -# predictions_from_cmip = pd.read_csv( -# f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' -# ) -# predictions_from_cmip_sum = predictions_from_cmip.groupby(['District', 'Year']).sum().reset_index() -# for district in predictions_from_cmip_sum['District'].unique(): -# district_values = predictions_from_cmip_sum[predictions_from_cmip_sum['District'] == district] -# no_weather_model = district_values['Predicted_No_Weather_Model'].values -# weather_model = district_values['Predicted_Weather_Model'].values -# -# # Calculate the difference -# difference = no_weather_model - weather_model -# -# # Perform a one-sample t-test assuming 0 as the null hypothesis mean -# t_stat, p_value = ttest_1samp(difference, popmean=0) -# # Print results if p-value is below 0.05 (statistically significant) -# if p_value < 0.05: -# print(f"Scenario: {scenario}, Model Type: {model_type}, District: {district}, " -# f"t-stat: {t_stat:.2f}, p-value: {p_value:.4f}") -# ## now all grids +# Assuming 'district' is a column in your data +for scenario in scenarios: + for model_type in model_types: + predictions_from_cmip = pd.read_csv( + f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' + ) + predictions_from_cmip_sum = predictions_from_cmip.groupby(['District', 'Year']).sum().reset_index() + for district in predictions_from_cmip_sum['District'].unique(): + district_values = predictions_from_cmip_sum[predictions_from_cmip_sum['District'] == district] + no_weather_model = district_values['Predicted_No_Weather_Model'].values + weather_model = district_values['Predicted_Weather_Model'].values + + # Calculate the difference + difference = no_weather_model - weather_model + + # Perform a one-sample t-test assuming 0 as the null hypothesis mean + t_stat, p_value = ttest_1samp(difference, popmean=0) + # Print results if p-value is below 0.05 (statistically significant) + if p_value < 0.05: + print(f"Scenario: {scenario}, Model Type: {model_type}, District: {district}, " + f"t-stat: {t_stat:.2f}, p-value: {p_value:.4f}") +## now all grids # Define the dictionary outside the loop to accumulate data across all iterations percentage_diff_by_year_district = {} From 86878eb27cd723b0952f5f381833b2ba06dfa800 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 14 Jan 2025 10:04:35 +0000 Subject: [PATCH 193/291] Tidied --- src/scripts/climate_change/CIL_CMIP6_downscaling.py | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/src/scripts/climate_change/CIL_CMIP6_downscaling.py b/src/scripts/climate_change/CIL_CMIP6_downscaling.py index af66a51ae3..f478ea7328 100644 --- a/src/scripts/climate_change/CIL_CMIP6_downscaling.py +++ b/src/scripts/climate_change/CIL_CMIP6_downscaling.py @@ -149,7 +149,7 @@ def extract_nc_files_from_unzipped_folders(directory): nc_file_directory = os.path.join(base_dir, 'nc_files') # NB these are daily scenarios = ["ssp245", "ssp585"] - +scenarios = ["spp585"] data_by_model_and_grid = {} for scenario in scenarios: print(scenario) @@ -162,9 +162,9 @@ def extract_nc_files_from_unzipped_folders(directory): file_pattern = os.path.join(file_path_downscaled, "CIL_subset_ssp245_*.nc") data_all_models = xr.open_mfdataset(file_pattern, combine='nested', concat_dim="time") data_all_models.compute() - - data_all_models.to_netcdf(output_file) - #data_all_models = xr.open_dataset(file_path_downscaled) + #output_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/" + #output_path = os.path.join(output_dir, output_file) + #data_all_models.to_netcdf(output_path) ## Get models of interest - min, med, max # Assuming 'pr' is the variable representing precipitation in the dataset @@ -186,7 +186,6 @@ def extract_nc_files_from_unzipped_folders(directory): max_model = max_model_object.values.item() models_of_interest = [min_model, median_model, max_model] - #models_of_interest = [median_model] print("Models of interest", models_of_interest) # see which facilities have reporting data and data on latitude and longitude From 1fd422d75a6bc7ec314858c46ede223edb9b8c57 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 15 Jan 2025 14:08:12 +0000 Subject: [PATCH 194/291] Added calculation based on the % in each district. However, am getting extremely high numbers of distruption... --- src/scripts/climate_change/cohort_model.py | 189 ++++++++++++++++----- 1 file changed, 148 insertions(+), 41 deletions(-) diff --git a/src/scripts/climate_change/cohort_model.py b/src/scripts/climate_change/cohort_model.py index 1493debaa3..d34b4513ba 100644 --- a/src/scripts/climate_change/cohort_model.py +++ b/src/scripts/climate_change/cohort_model.py @@ -41,7 +41,7 @@ births_model = summarize(births_results, collapse_columns=True) births_model.columns = ['Model_' + col for col in births_model.columns] births_model_subset = births_model.iloc[15:].copy() # don't want 2010-2024 - +# # Load map of Malawi for later file_path_historical_data = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/2011/60ab007aa16d679a32f9c3e186d2f744.nc" dataset = Dataset(file_path_historical_data, mode='r') @@ -61,13 +61,13 @@ difference_lat = lat_data[1] - lat_data[0] difference_long = long_data[1] - long_data[0] -# Get expected disturbance from the model +# # Get expected disturbance from the model scenarios = ['ssp245', 'ssp585'] model_types = ['lowest', 'median', 'highest'] year_range = range(min_year, max_year) results_list = [] -# Loop through scenarios and model types +#Loop through scenarios and model types for scenario in scenarios: for model_type in model_types: predictions_from_cmip = pd.read_csv( @@ -238,6 +238,7 @@ {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} ) percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() + print(percentage_diff_by_district) malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 @@ -272,16 +273,22 @@ sm.set_array([]) fig.colorbar(sm, ax=axes, orientation="vertical", shrink=0.8, label="Percentage Difference (%)") plt.suptitle("Percentage Difference Maps by Scenario and Model Type", fontsize=16, y=1.02) -plt.savefig(results_folder_to_save / 'percentage_difference_maps_grid.png') +# plt.savefig(results_folder_to_save / 'percentage_difference_maps_grid.png') plt.show() ## By district fig, axes = plt.subplots(2, 3, figsize=(18, 12), constrained_layout=True) +population_file = "/Users/rem76/PycharmProjects/TLOmodel/resources/demography/ResourceFile_PopulationSize_2018Census.csv" +population_data = pd.read_csv(population_file) +population_data_grouped = population_data.groupby("District")["Count"].sum() +total_population = population_data_grouped.sum() +population_percentage = population_data_grouped / total_population # Initialize variables to track global min/max for color normalization global_min = float('inf') global_max = float('-inf') - +# +percentage_diff_by_year_district = {} # Loop over scenarios and model types to process the data for scenario in scenarios: for model_type in model_types: @@ -290,7 +297,11 @@ ) predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'District']).sum().reset_index() - predictions_from_cmip_sum.loc[predictions_from_cmip_sum['Difference_in_Expectation'] > 0, 'Difference_in_Expectation'] = 0 + predictions_from_cmip_sum['Percentage_Difference'] = ( + predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model'] + ) * 100 + predictions_from_cmip_sum.loc[predictions_from_cmip_sum['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 + predictions_from_cmip_sum = predictions_from_cmip_sum[predictions_from_cmip_sum['Year'] <= 2060] predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} @@ -300,15 +311,18 @@ percentage_diff_by_year_district = {} for year, year_data in predictions_from_cmip_sum.groupby('Year'): + if year not in percentage_diff_by_year_district: percentage_diff_by_year_district[year] = {} for _, row in year_data.iterrows(): district = row['District'] - percentage_diff = row['Difference_in_Expectation'] - + percentage_diff = row['Percentage_Difference'] + row_index = births_model.index.get_loc(year) + number_of_births = population_percentage[district] * births_model.iloc[row_index][ + "Model_mean"] if district not in percentage_diff_by_year_district[year]: percentage_diff_by_year_district[year][district] = 0 - percentage_diff_by_year_district[year][district] += percentage_diff + percentage_diff_by_year_district[year][district] += percentage_diff * 1 # Prepare data for plotting data_for_plot = pd.DataFrame.from_dict(percentage_diff_by_year_district, orient='index').fillna(0) @@ -320,22 +334,38 @@ ax.set_title(f"{scenario}: {model_type}", fontsize=14) ax.set_xlabel('Year', fontsize=12) ax.set_ylabel('Percentage Difference (%)', fontsize=12) - + ax.legend() # Update global min/max for color scaling local_min = data_for_plot.min().min() local_max = data_for_plot.max().max() global_min = min(global_min, local_min) global_max = max(global_max, local_max) -fig = plt.gcf() -handles, labels = ax.get_legend_handles_labels() -fig.legend(handles, labels, loc='center left', bbox_to_anchor=(1.05, 0.5), fontsize=12, title="Districts") - # Adjust the overall layout plt.suptitle("Percentage Difference by Year and District", fontsize=16, y=1.02) -plt.savefig(results_folder_to_save / 'percentage_difference_by_year_district_grid.png') +#plt.savefig(results_folder_to_save / 'percentage_difference_by_year_district_grid.png') plt.show() +# Calculate the average percentage difference over all years for each district +average_percentage_diff_by_district = {} + +for year, year_data in percentage_diff_by_year_district.items(): + for district, total_percentage_diff in year_data.items(): + if district not in average_percentage_diff_by_district: + average_percentage_diff_by_district[district] = {'total_diff': 0, 'count': 0} + average_percentage_diff_by_district[district]['total_diff'] += total_percentage_diff + average_percentage_diff_by_district[district]['count'] += 1 + +# Calculate averages +for district, values in average_percentage_diff_by_district.items(): + values['average_diff'] = values['total_diff'] / values['count'] + +# Convert to a DataFrame for easy plotting or reporting +average_percentage_diff_df = pd.DataFrame.from_dict(average_percentage_diff_by_district, orient='index') +average_percentage_diff_df = average_percentage_diff_df[['average_diff']] + +# Print or plot the average percentage differences +print("average_percentage_diff_df", average_percentage_diff_df) all_districts = set() significant_results_year = [] @@ -363,52 +393,127 @@ f"t-stat: {t_stat:.2f}, p-value: {p_value:.4f}") ## now all grids -# Define the dictionary outside the loop to accumulate data across all iterations -percentage_diff_by_year_district = {} +#### Now do number of births based on the TLO model and 2018 census +population_file = "/Users/rem76/PycharmProjects/TLOmodel/resources/demography/ResourceFile_PopulationSize_2018Census.csv" +population_data = pd.read_csv(population_file) + +population_data_grouped = population_data.groupby("District")["Count"].sum() +total_population = population_data_grouped.sum() +population_percentage = population_data_grouped / total_population # Create the figure and axes grid fig, axes = plt.subplots(2, 3, figsize=(18, 12), constrained_layout=True) -all_districts = set() - +y_min = float('inf') +y_max = float('-inf') +year_groupings = range(2025, 2060, 5) for i, scenario in enumerate(scenarios): for j, model_type in enumerate(model_types): - # Load the data + percentage_diff_by_year_district = {} + predictions_from_cmip = pd.read_csv( f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' ) - # Summing data by Year and District predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'District']).sum().reset_index() + predictions_from_cmip_sum = predictions_from_cmip_sum[predictions_from_cmip_sum['Year'] <= 2060] + predictions_from_cmip_sum['Percentage_Difference'] = ( + predictions_from_cmip_sum[ + 'Difference_in_Expectation'] / + predictions_from_cmip_sum['Predicted_No_Weather_Model'] + ) * 100 + predictions_from_cmip_sum.loc[ + predictions_from_cmip_sum['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 + predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( + {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} + ) + + for year in year_groupings: + subset = predictions_from_cmip_sum[ + (predictions_from_cmip_sum['Year'] >= year) & + (predictions_from_cmip_sum['Year'] <= year + 5) + ] + for _, row in subset.iterrows(): + district = row['District'] + percentage_diff = row['Percentage_Difference'] + row_index = births_model_subset.index.get_loc(year) + number_of_births = population_percentage[district] * births_model_subset.iloc[row_index]["Model_mean"] + number_of_births = number_of_births/5 # was for the whole period, but doing year by year + if year not in percentage_diff_by_year_district: + percentage_diff_by_year_district[year] = {} + if district not in percentage_diff_by_year_district[year]: + percentage_diff_by_year_district[year][district] = 0 + percentage_diff_by_year_district[year][district] += (percentage_diff * number_of_births) - # Adjust the 'Difference_in_Expectation' values - predictions_from_cmip_sum.loc[predictions_from_cmip_sum['Difference_in_Expectation'] > 0, 'Difference_in_Expectation'] = 0 + data_for_plot = pd.DataFrame.from_dict(percentage_diff_by_year_district, orient='index').fillna(0) + y_min = min(y_min, data_for_plot.min().min()) + y_max = max(y_max, data_for_plot.max().max()) - # Rename districts + ax = axes[i, j] + data_for_plot.plot(kind='bar', stacked=True, ax=ax, cmap='tab20', legend=False) + ax.set_title(f"{scenario}: {model_type}", fontsize=10) + if i == len(scenarios) - 1: + ax.set_xlabel('Period (5 years)', fontsize=10) + if j == 0: + ax.set_ylabel('Deficit of ANC services', fontsize=10) + if (i == 0) & (j == 2): + ax.legend(title="Districts", fontsize=8, title_fontsize=10, bbox_to_anchor=(1.09, 1)) + +for ax in axes.flatten(): + ax.set_ylim(y_min*7, y_max) + +plt.tight_layout() +plt.savefig(results_folder_to_save / 'stacked_bar_percentage_difference_5_years_grid_single_legend_with_births.png') +plt.show() +# +# + +# Create the figure and axes grid +fig, axes = plt.subplots(2, 3, figsize=(18, 12), constrained_layout=True) + +y_min = float('inf') +y_max = float('-inf') +for i, scenario in enumerate(scenarios): + for j, model_type in enumerate(model_types): + percentage_diff_by_year_district = {} + + predictions_from_cmip = pd.read_csv( + f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' + ) + + predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'District']).sum().reset_index() + predictions_from_cmip_sum = predictions_from_cmip_sum[predictions_from_cmip_sum['Year'] <= 2060] + predictions_from_cmip_sum['Percentage_Difference'] = (predictions_from_cmip_sum[ + 'Difference_in_Expectation'] / + predictions_from_cmip_sum['Predicted_No_Weather_Model'] + ) * 100 + predictions_from_cmip_sum.loc[ + predictions_from_cmip_sum['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} ) - # Create Period column to group years into 5-year intervals - predictions_from_cmip_sum['Period'] = ((predictions_from_cmip_sum['Year'] - 1) // 5) * 5 + 5 - - # Collect percentage differences by 5-year period and district - for period, period_data in predictions_from_cmip_sum.groupby('Period'): - for _, row in period_data.iterrows(): + for year in year_groupings: + subset = predictions_from_cmip_sum[ + (predictions_from_cmip_sum['Year'] >= year) & + (predictions_from_cmip_sum['Year'] <= year + 5) + ] + for _, row in subset.iterrows(): district = row['District'] - percentage_diff = row['Difference_in_Expectation'] + row_index = births_model_subset.index.get_loc(year) - # Initialize dictionary structure if not already present - if period not in percentage_diff_by_year_district: - percentage_diff_by_year_district[period] = {} - if district not in percentage_diff_by_year_district[period]: - percentage_diff_by_year_district[period][district] = 0 - percentage_diff_by_year_district[period][district] += percentage_diff - all_districts.add(district) + number_of_births = population_percentage[district] * births_model.iloc[row_index]["Model_mean"] + number_of_births = number_of_births/5 # was for the whole period, but doing year by year + if year not in percentage_diff_by_year_district: + percentage_diff_by_year_district[year] = {} + if district not in percentage_diff_by_year_district[year]: + percentage_diff_by_year_district[year][district] = 0 + percentage_diff_by_year_district[year][district] += (number_of_births) - # Create a DataFrame for plotting data_for_plot = pd.DataFrame.from_dict(percentage_diff_by_year_district, orient='index').fillna(0) - # Plotting the data in the respective subplot + y_min = min(y_min, data_for_plot.min().min()) + y_max = max(y_max, data_for_plot.max().max()) + ax = axes[i, j] data_for_plot.plot(kind='bar', stacked=True, ax=ax, cmap='tab20', legend=False) ax.set_title(f"{scenario}: {model_type}", fontsize=10) @@ -418,6 +523,8 @@ ax.set_ylabel('Deficit of ANC services', fontsize=10) if (i == 0) & (j == 2): ax.legend(title="Districts", fontsize=8, title_fontsize=10, bbox_to_anchor=(1.09, 1)) + + plt.tight_layout() -plt.savefig(results_folder_to_save / 'stacked_bar_percentage_difference_5_years_grid_single_legend.png') +# plt.savefig(results_folder_to_save / 'stacked_bar_percentage_difference_5_years_grid_single_legend_with_births.png') plt.show() From 765a14e6e7ce602fe699aa1cc70875bd9a71b955 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 15 Jan 2025 14:09:53 +0000 Subject: [PATCH 195/291] Added in ssp126 --- .../CIL_CMIP6_downscaling_accessing_data.py | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/src/scripts/climate_change/CIL_CMIP6_downscaling_accessing_data.py b/src/scripts/climate_change/CIL_CMIP6_downscaling_accessing_data.py index 35d502295c..6b27f68bbc 100644 --- a/src/scripts/climate_change/CIL_CMIP6_downscaling_accessing_data.py +++ b/src/scripts/climate_change/CIL_CMIP6_downscaling_accessing_data.py @@ -38,7 +38,7 @@ ) # Get the collections -scenarios = ["ssp585"]#, "ssp585"] # Change as needed +scenarios = ["ssp126", "ssp245", "ssp585"] # Change as needed variable_id = "pr" # Precipitation variable for scenario in scenarios: @@ -52,11 +52,16 @@ # Read and process each dataset datasets_by_model = [] for item in tqdm(ensemble): + print(item) + if (item == 'Item id=cil-gdpcir-CAS-FGOALS-g3-ssp126-r1i1p1f1-day') & (scenario == 'ssp126'): + continue + if variable_id not in item.assets: + print(f"Variable {variable_id} not found in item {item}. Skipping.") + continue asset = item.assets[variable_id] datasets_by_model.append( xr.open_dataset(asset.href, **asset.extra_fields["xarray:open_kwargs"]) ) - # Combine datasets by model all_datasets = xr.concat( datasets_by_model, @@ -67,10 +72,9 @@ # Define the spatial and temporal bounds lon_bounds = slice(32.67161823, 35.91841716) lat_bounds = slice(-17.12627881, -9.36366167) - #years_for_retrieval = ['2034', '2037', '2040', '2043', '2045', '2046', '2055', '2060', '2062', '2063', - #'2064'] #'2032', '2026', '2029', - years_for_retrieval = ['2033', '2036','2037', '2041', '2047', '2048', '2050', '2054', '2060'] + + years_for_retrieval = range(2024, 2061) # Process each year output_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/" yearly_files = [] From bb9bb8ad4525baba931705011feea97038cf9027 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 15 Jan 2025 14:16:08 +0000 Subject: [PATCH 196/291] Unneccessary --- .../climate_change/CIL_CMIP6_downscaling.py | 292 ------------------ 1 file changed, 292 deletions(-) delete mode 100644 src/scripts/climate_change/CIL_CMIP6_downscaling.py diff --git a/src/scripts/climate_change/CIL_CMIP6_downscaling.py b/src/scripts/climate_change/CIL_CMIP6_downscaling.py deleted file mode 100644 index f478ea7328..0000000000 --- a/src/scripts/climate_change/CIL_CMIP6_downscaling.py +++ /dev/null @@ -1,292 +0,0 @@ -#!/usr/bin/env python -# coding: utf-8 - -# From https://planetarycomputer.microsoft.com/dataset/cil-gdpcir-cc0#Ensemble-example - -# In[1]: - - -import planetary_computer -import pystac_client - -import xarray as xr -import numpy as np -import pandas as pd -from dask.diagnostics import ProgressBar -from tqdm.auto import tqdm - -import os -import re -import glob -import shutil -import zipfile -from pathlib import Path - -import difflib -from scipy.spatial import KDTree - -import matplotlib.pyplot as plt -import geopandas as gpd -import regionmask -import cartopy.crs as ccrs - -from netCDF4 import Dataset - -from carbonplan import styles # noqa: F401 -import intake -import cmip6_downscaling - - -# Load and organise data - -# In[52]: - - -import xarray as xr -import pandas as pd -from pystac_client import Client -from planetary_computer import sign_inplace -from tqdm import tqdm - - - -ANC = True -Inpatient = False -multiplier = 1 # no need for multiplier -years = range(2025, 2071) # final date is 1st Jan 2100 -month_lengths = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] * len(years) -window_size = 5 - -if ANC: - reporting_data = pd.read_csv( - "/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_ANC_by_smaller_facility_lm.csv") -elif Inpatient: - reporting_data = pd.read_csv( - "/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_Inpatient_by_smaller_facility_lm.csv") -general_facilities = gpd.read_file("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_districts.shp") - -facilities_with_lat_long = pd.read_csv( - "/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_lat_long_region.csv") - - -# In[3]: - - -def unzip_all_in_directory(directory): - """ - Unzips all .zip files in the specified directory, extracting each into a separate folder. - - Parameters: - directory (str): The path to the folder containing the .zip files. - """ - for filename in os.listdir(directory): - if filename.endswith('.zip'): - file_path = os.path.join(directory, filename) - extract_dir = os.path.join(directory, filename[:-4]) - os.makedirs(extract_dir, exist_ok=True) - - try: - with zipfile.ZipFile(file_path, 'r') as zip_ref: - zip_ref.extractall(extract_dir) - except zipfile.BadZipFile: - print(f"Skipped {filename}: not a valid zip file.") - -def get_facility_lat_long(reporting_facility, facilities_df, cutoff=0.90, n_matches=3): - """ - Function to find the closest matching facility name and return its latitude and longitude. - - Parameters: - - reporting_facility: The facility name for which latitude and longitude are needed. - - facilities_df : DataFrame containing facility names ('Fname') and their corresponding latitudes ('A109__Latitude') and longitudes ('A109__Longitude'). - - cutoff: The minimum similarity score for a match. Default is 0.90. - - n_matches: The maximum number of matches to consider. Default is 3. - - Returns: match_name, lat_for_facility, long_for_facility - - """ - matching_facility_name = difflib.get_close_matches(reporting_facility, facilities_df['Fname'], n=n_matches, - cutoff=cutoff) - - if matching_facility_name: - match_name = matching_facility_name[0] # Access the string directly - lat_for_facility = facilities_df.loc[facilities_df['Fname'] == match_name, "A109__Latitude"].iloc[0] - long_for_facility = facilities_df.loc[facilities_df['Fname'] == match_name, "A109__Longitude"].iloc[0] - return match_name, lat_for_facility, long_for_facility - else: - return np.nan, np.nan, np.nan - -def extract_nc_files_from_unzipped_folders(directory): - """ - Searches for .nc files in the specified directory and all its subfolders, - and copies them to the output directory, maintaining the folder structure. - - Parameters: - directory (str): The path to the folder containing the unzipped folders. - """ - output_directory = os.path.join(directory, 'nc_files') - if not os.path.exists(output_directory): - os.makedirs(output_directory) - - for root, _, files in os.walk(directory): - # Skip the output directory to prevent recursive copying - if root == output_directory: - continue - - for filename in files: - if filename.endswith('.nc'): - source_file_path = os.path.join(root, filename) - destination_file_path = os.path.join(output_directory, filename) - - # Only copy if the file does not already exist in the output directory - if not os.path.exists(destination_file_path): - shutil.copy2(source_file_path, output_directory) - - -# In[ ]: - - -base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/" -nc_file_directory = os.path.join(base_dir, 'nc_files') -# NB these are daily -scenarios = ["ssp245", "ssp585"] -scenarios = ["spp585"] -data_by_model_and_grid = {} -for scenario in scenarios: - print(scenario) - scenario_directory = os.path.join(base_dir, scenario) - - grid_centroids = {} - cumulative_sum_by_models = {} - file_path_downscaled = f"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/" - output_file = f"CIL_combined_{scenario}_2025_2070.nc" - file_pattern = os.path.join(file_path_downscaled, "CIL_subset_ssp245_*.nc") - data_all_models = xr.open_mfdataset(file_pattern, combine='nested', concat_dim="time") - data_all_models.compute() - #output_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/" - #output_path = os.path.join(output_dir, output_file) - #data_all_models.to_netcdf(output_path) - - ## Get models of interest - min, med, max - # Assuming 'pr' is the variable representing precipitation in the dataset - pr_aggregated = data_all_models.mean(dim=["lat", "lon", "time"], skipna=True) # Work with the 'pr' DataArray - - # Find the model with the lowest value - min_model_object = pr_aggregated['pr'].idxmin(dim="model") - min_model = min_model_object.values.item() - # Find the model with the median value - sorted_models = pr_aggregated.sortby("model") - n_models = len(pr_aggregated.model) - median_index = n_models // 2 - median_model_object = sorted_models["model"][median_index] - print(median_model_object) - median_model = median_model_object.values.item() - print(median_model) - # Find the model with the highest value - max_model_object = pr_aggregated['pr'].idxmax(dim="model") - max_model = max_model_object.values.item() - - models_of_interest = [min_model, median_model, max_model] - - print("Models of interest", models_of_interest) - # see which facilities have reporting data and data on latitude and longitude - weather_df_lowest_window = pd.DataFrame() - weather_df_median_window = pd.DataFrame() - weather_df_highest_window = pd.DataFrame() - - weather_df_lowest_monthly = pd.DataFrame() - weather_df_median_monthly = pd.DataFrame() - weather_df_highest_monthly = pd.DataFrame() - for model in models_of_interest: - data_per_model = data_all_models.sel(model=model) - pr_data = data_per_model.variables['pr'][:] # in kg m-2 s-1 = mm s-1 x 86400 to get to day - lat_data = data_per_model.variables['lat'][:] - lon_data = data_per_model.variables['lon'][:] - lon_grid, lat_grid = np.meshgrid(lon_data, lat_data) - centroids = np.column_stack((lat_grid.ravel(), lon_grid.ravel())) - - # Store centroids - grid_centroids[model] = centroids - grid_dictionary = {} - grid = 0 - for i in lat_data: - for j in lon_data: - precip_data_for_grid = data_per_model.sel(lat=i, lon=j, method="nearest") # across all time points - grid_dictionary[grid] = precip_data_for_grid.pr.data - grid += 1 - data_by_model_and_grid[model] = grid_dictionary - - for reporting_facility in reporting_data.columns: - print(reporting_facility) - grid_precipitation_for_facility = {} - match_name, lat_for_facility, long_for_facility = get_facility_lat_long(reporting_facility, facilities_with_lat_long) - if not np.isnan(long_for_facility) and not np.isnan(lat_for_facility): - facility_location = np.array([lat_for_facility, long_for_facility]) - kd_trees_by_model = {} - - # Loop over each model of interest - for model in models_of_interest: - centroids = grid_centroids[model] - kd_tree = KDTree(centroids) - distance, closest_grid_index = kd_tree.query(facility_location) - grid_precipitation_for_facility[model] = data_by_model_and_grid[model][closest_grid_index] - - cumulative_sum_monthly = [] - cumulative_sum_window = [] - - begin_day = 0 - # Calculate monthly cumulative sums - for month_idx, month_length in enumerate(month_lengths): - days_for_grid_monthly = grid_precipitation_for_facility[model][begin_day:begin_day + month_length] - cumulative_sums_monthly = [ - sum(days_for_grid_monthly) - ] - max_cumulative_sums_monthly = max(cumulative_sums_monthly) - cumulative_sum_monthly.append(max_cumulative_sums_monthly) - begin_day += month_length - - begin_day = 0 - # Calculate windowed cumulative sums - for month_idx, month_length in enumerate(month_lengths): - days_for_grid_window = grid_precipitation_for_facility[model][begin_day:begin_day + month_length] - - cumulative_sums_window = [ - sum(days_for_grid_window[day:day + window_size]) - for day in range(month_length - window_size + 1) - ] - - max_cumulative_sums_window = max(cumulative_sums_window) - cumulative_sum_window.append(max_cumulative_sums_window) - begin_day += month_length - - # Assign the calculated data to the correct dataframe based on the model - if model == min_model: - weather_df_lowest_monthly[reporting_facility] = cumulative_sum_monthly - weather_df_lowest_window[reporting_facility] = cumulative_sum_window - elif model == median_model: - weather_df_median_monthly[reporting_facility] = cumulative_sum_monthly - weather_df_median_window[reporting_facility] = cumulative_sum_window - elif model == max_model: - weather_df_highest_monthly[reporting_facility] = cumulative_sum_monthly - weather_df_highest_window[reporting_facility] = cumulative_sum_window - - if ANC: - weather_df_lowest_window.to_csv(Path(scenario_directory) / f"lowest_model_daily_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{scenario}.csv", index=False) - weather_df_median_window.to_csv(Path(scenario_directory) / f"median_model_daily_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{scenario}.csv", index=False) - weather_df_highest_window.to_csv(Path(scenario_directory) / f"highest_model_daily_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{scenario}.csv", index=False) - - weather_df_lowest_monthly.to_csv(Path(scenario_directory) / f"lowest_model_monthly_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{scenario}.csv", index=False) - weather_df_median_monthly.to_csv(Path(scenario_directory) / f"median_model_monthly_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{scenario}.csv", index=False) - weather_df_highest_monthly.to_csv(Path(scenario_directory) / f"highest_model_monthly_prediction_weather_by_facility_KDBall_ANC_downscaled_CIL_{scenario}.csv", index=False) - - -# In[27]: - - -data_all_models.mean(dim=["lat", "lon", "time"], skipna=True) - - -# In[ ]: - - - - From fbd064ae2b55b921689589e46bab8eda5c1b75dc Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 15 Jan 2025 14:35:47 +0000 Subject: [PATCH 197/291] added 126 --- .../CIL_CMIP6_downscaling.ipynb | 8675 ++--------------- 1 file changed, 1074 insertions(+), 7601 deletions(-) diff --git a/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb b/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb index a402bcc90e..1c9b0e507e 100644 --- a/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb +++ b/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb @@ -9,8 +9,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-08T16:28:56.441662Z", - "start_time": "2025-01-08T16:28:54.657651Z" + "end_time": "2025-01-15T14:15:28.845008Z", + "start_time": "2025-01-15T14:15:28.804393Z" } }, "cell_type": "code", @@ -47,13 +47,13 @@ ], "id": "7b5963dac1c0b629", "outputs": [], - "execution_count": 1 + "execution_count": 15 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-08T19:08:50.482403Z", - "start_time": "2025-01-08T19:08:46.931480Z" + "end_time": "2025-01-15T14:15:35.763392Z", + "start_time": "2025-01-15T14:15:29.187878Z" } }, "cell_type": "code", @@ -506,13 +506,13 @@ " tracking_id: hdl:21.14100/ed432434-922e-4cea-8400-c32159...\n", " variable_id: pr\n", " variant_label: r1i1p1f1\n", - " version_id: v20190811" ] }, - "execution_count": 10, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 10 + "execution_count": 16 }, { "metadata": {}, @@ -826,15 +826,15 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-08T16:47:24.877431Z", - "start_time": "2025-01-08T16:47:24.641918Z" + "end_time": "2025-01-15T14:15:38.758317Z", + "start_time": "2025-01-15T14:15:38.556568Z" } }, "cell_type": "code", "source": [ "ANC = True\n", "Inpatient = False\n", - "multiplier = 1 # no need for multiplier \n", + "multiplier = 1 # no need for multiplier\n", "years = range(2025, 2071) # final date is 1st Jan 2100\n", "month_lengths = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] * len(years)\n", "window_size = 5\n", @@ -856,18 +856,18 @@ "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/4112377517.py:16: DtypeWarning: Columns (58,59,105,127,136,142,149,150,258,285,296,319,344,345,360,393,394,427,428,437,449,450,452,453,461,462,478,479,489,490,492,493,494,497,498,499,500,501,502,503,572,580,585,586,587,588,591,592,593,594,607,608,609,610,619,620,621,622,626,634,872,887,967,978,1066,1510) have mixed types. Specify dtype option on import or set low_memory=False.\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/700573990.py:16: DtypeWarning: Columns (58,59,105,127,136,142,149,150,258,285,296,319,344,345,360,393,394,427,428,437,449,450,452,453,461,462,478,479,489,490,492,493,494,497,498,499,500,501,502,503,572,580,585,586,587,588,591,592,593,594,607,608,609,610,619,620,621,622,626,634,872,887,967,978,1066,1510) have mixed types. Specify dtype option on import or set low_memory=False.\n", " facilities_with_lat_long = pd.read_csv(\n" ] } ], - "execution_count": 5 + "execution_count": 17 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-08T16:47:26.312607Z", - "start_time": "2025-01-08T16:47:26.305093Z" + "end_time": "2025-01-15T14:15:39.509853Z", + "start_time": "2025-01-15T14:15:39.504469Z" } }, "cell_type": "code", @@ -943,19 +943,21 @@ ], "id": "a9a92aa8bbb6b45a", "outputs": [], - "execution_count": 6 + "execution_count": 18 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-09T11:06:05.311500Z", - "start_time": "2025-01-09T10:47:08.857112Z" + "end_time": "2025-01-15T14:20:45.961332Z", + "start_time": "2025-01-15T14:15:40.892618Z" } }, "cell_type": "code", "source": [ "base_dir = \"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/\"\n", "scenarios = [\"ssp245\", \"ssp585\"]\n", + "scenarios = [\"ssp126\"]\n", + "\n", "window_size = 5\n", "\n", "data_by_model_and_grid = {}\n", @@ -1088,9 +1090,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "Processing scenario: ssp245\n", + "Processing scenario: ssp126\n", "Models of interest ['HadGEM3-GC31-LL', 'GFDL-CM4', 'INM-CM5-0']\n", - "Processing file: CIL_subset_ssp245_2024.nc\n", + "Processing file: CIL_subset_ssp126_2024.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2024, month 1\n", "Processing year 2024, month 2\n", @@ -1110,945 +1112,945 @@ "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" ] }, @@ -2056,7 +2058,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Processing model: GFDL-CM4\n", + "Model GFDL-CM4 not found in file CIL_subset_ssp126_2024.nc, skipping.\n", + "Processing model: INM-CM5-0\n", "Processing year 2024, month 1\n", "Processing year 2024, month 2\n", "Processing year 2024, month 3\n", @@ -2075,945 +2078,945 @@ "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" ] }, @@ -3021,5742 +3024,21 @@ "name": "stdout", "output_type": "stream", "text": [ - "Processing model: INM-CM5-0\n", - "Processing year 2024, month 1\n", - "Processing year 2024, month 2\n", - "Processing year 2024, month 3\n", - "Processing year 2024, month 4\n", - "Processing year 2024, month 5\n", - "Processing year 2024, month 6\n", - "Processing year 2024, month 7\n", - "Processing year 2024, month 8\n", - "Processing year 2024, month 9\n", - "Processing year 2024, month 10\n", - "Processing year 2024, month 11\n", - "Processing year 2024, month 12\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Processing file: CIL_subset_ssp245_2025.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2025, month 1\n", - "Processing year 2025, month 2\n", - "Processing year 2025, month 3\n", - "Processing year 2025, month 4\n", - "Processing year 2025, month 5\n", - "Processing year 2025, month 6\n", - "Processing year 2025, month 7\n", - "Processing year 2025, month 8\n", - "Processing year 2025, month 9\n", - "Processing year 2025, month 10\n", - "Processing year 2025, month 11\n", - "Processing year 2025, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2025, month 1\n", - "Processing year 2025, month 2\n", - "Processing year 2025, month 3\n", - "Processing year 2025, month 4\n", - "Processing year 2025, month 5\n", - "Processing year 2025, month 6\n", - "Processing year 2025, month 7\n", - "Processing year 2025, month 8\n", - "Processing year 2025, month 9\n", - "Processing year 2025, month 10\n", - "Processing year 2025, month 11\n", - "Processing year 2025, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2025, month 1\n", - "Processing year 2025, month 2\n", - "Processing year 2025, month 3\n", - "Processing year 2025, month 4\n", - "Processing year 2025, month 5\n", - "Processing year 2025, month 6\n", - "Processing year 2025, month 7\n", - "Processing year 2025, month 8\n", - "Processing year 2025, month 9\n", - "Processing year 2025, month 10\n", - "Processing year 2025, month 11\n", - "Processing year 2025, month 12\n", - "Processing file: CIL_subset_ssp245_2026.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2026, month 1\n", - "Processing year 2026, month 2\n", - "Processing year 2026, month 3\n", - "Processing year 2026, month 4\n", - "Processing year 2026, month 5\n", - "Processing year 2026, month 6\n", - "Processing year 2026, month 7\n", - "Processing year 2026, month 8\n", - "Processing year 2026, month 9\n", - "Processing year 2026, month 10\n", - "Processing year 2026, month 11\n", - "Processing year 2026, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2026, month 1\n", - "Processing year 2026, month 2\n", - "Processing year 2026, month 3\n", - "Processing year 2026, month 4\n", - "Processing year 2026, month 5\n", - "Processing year 2026, month 6\n", - "Processing year 2026, month 7\n", - "Processing year 2026, month 8\n", - "Processing year 2026, month 9\n", - "Processing year 2026, month 10\n", - "Processing year 2026, month 11\n", - "Processing year 2026, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2026, month 1\n", - "Processing year 2026, month 2\n", - "Processing year 2026, month 3\n", - "Processing year 2026, month 4\n", - "Processing year 2026, month 5\n", - "Processing year 2026, month 6\n", - "Processing year 2026, month 7\n", - "Processing year 2026, month 8\n", - "Processing year 2026, month 9\n", - "Processing year 2026, month 10\n", - "Processing year 2026, month 11\n", - "Processing year 2026, month 12\n", - "Processing file: CIL_subset_ssp245_2027.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2027, month 1\n", - "Processing year 2027, month 2\n", - "Processing year 2027, month 3\n", - "Processing year 2027, month 4\n", - "Processing year 2027, month 5\n", - "Processing year 2027, month 6\n", - "Processing year 2027, month 7\n", - "Processing year 2027, month 8\n", - "Processing year 2027, month 9\n", - "Processing year 2027, month 10\n", - "Processing year 2027, month 11\n", - "Processing year 2027, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2027, month 1\n", - "Processing year 2027, month 2\n", - "Processing year 2027, month 3\n", - "Processing year 2027, month 4\n", - "Processing year 2027, month 5\n", - "Processing year 2027, month 6\n", - "Processing year 2027, month 7\n", - "Processing year 2027, month 8\n", - "Processing year 2027, month 9\n", - "Processing year 2027, month 10\n", - "Processing year 2027, month 11\n", - "Processing year 2027, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2027, month 1\n", - "Processing year 2027, month 2\n", - "Processing year 2027, month 3\n", - "Processing year 2027, month 4\n", - "Processing year 2027, month 5\n", - "Processing year 2027, month 6\n", - "Processing year 2027, month 7\n", - "Processing year 2027, month 8\n", - "Processing year 2027, month 9\n", - "Processing year 2027, month 10\n", - "Processing year 2027, month 11\n", - "Processing year 2027, month 12\n", - "Processing file: CIL_subset_ssp245_2028.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2028, month 1\n", - "Processing year 2028, month 2\n", - "Processing year 2028, month 3\n", - "Processing year 2028, month 4\n", - "Processing year 2028, month 5\n", - "Processing year 2028, month 6\n", - "Processing year 2028, month 7\n", - "Processing year 2028, month 8\n", - "Processing year 2028, month 9\n", - "Processing year 2028, month 10\n", - "Processing year 2028, month 11\n", - "Processing year 2028, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2028, month 1\n", - "Processing year 2028, month 2\n", - "Processing year 2028, month 3\n", - "Processing year 2028, month 4\n", - "Processing year 2028, month 5\n", - "Processing year 2028, month 6\n", - "Processing year 2028, month 7\n", - "Processing year 2028, month 8\n", - "Processing year 2028, month 9\n", - "Processing year 2028, month 10\n", - "Processing year 2028, month 11\n", - "Processing year 2028, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2028, month 1\n", - "Processing year 2028, month 2\n", - "Processing year 2028, month 3\n", - "Processing year 2028, month 4\n", - "Processing year 2028, month 5\n", - "Processing year 2028, month 6\n", - "Processing year 2028, month 7\n", - "Processing year 2028, month 8\n", - "Processing year 2028, month 9\n", - "Processing year 2028, month 10\n", - "Processing year 2028, month 11\n", - "Processing year 2028, month 12\n", - "Processing file: CIL_subset_ssp245_2029.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2029, month 1\n", - "Processing year 2029, month 2\n", - "Processing year 2029, month 3\n", - "Processing year 2029, month 4\n", - "Processing year 2029, month 5\n", - "Processing year 2029, month 6\n", - "Processing year 2029, month 7\n", - "Processing year 2029, month 8\n", - "Processing year 2029, month 9\n", - "Processing year 2029, month 10\n", - "Processing year 2029, month 11\n", - "Processing year 2029, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2029, month 1\n", - "Processing year 2029, month 2\n", - "Processing year 2029, month 3\n", - "Processing year 2029, month 4\n", - "Processing year 2029, month 5\n", - "Processing year 2029, month 6\n", - "Processing year 2029, month 7\n", - "Processing year 2029, month 8\n", - "Processing year 2029, month 9\n", - "Processing year 2029, month 10\n", - "Processing year 2029, month 11\n", - "Processing year 2029, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2029, month 1\n", - "Processing year 2029, month 2\n", - "Processing year 2029, month 3\n", - "Processing year 2029, month 4\n", - "Processing year 2029, month 5\n", - "Processing year 2029, month 6\n", - "Processing year 2029, month 7\n", - "Processing year 2029, month 8\n", - "Processing year 2029, month 9\n", - "Processing year 2029, month 10\n", - "Processing year 2029, month 11\n", - "Processing year 2029, month 12\n", - "Processing file: CIL_subset_ssp245_2030.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2030, month 1\n", - "Processing year 2030, month 2\n", - "Processing year 2030, month 3\n", - "Processing year 2030, month 4\n", - "Processing year 2030, month 5\n", - "Processing year 2030, month 6\n", - "Processing year 2030, month 7\n", - "Processing year 2030, month 8\n", - "Processing year 2030, month 9\n", - "Processing year 2030, month 10\n", - "Processing year 2030, month 11\n", - "Processing year 2030, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2030, month 1\n", - "Processing year 2030, month 2\n", - "Processing year 2030, month 3\n", - "Processing year 2030, month 4\n", - "Processing year 2030, month 5\n", - "Processing year 2030, month 6\n", - "Processing year 2030, month 7\n", - "Processing year 2030, month 8\n", - "Processing year 2030, month 9\n", - "Processing year 2030, month 10\n", - "Processing year 2030, month 11\n", - "Processing year 2030, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2030, month 1\n", - "Processing year 2030, month 2\n", - "Processing year 2030, month 3\n", - "Processing year 2030, month 4\n", - "Processing year 2030, month 5\n", - "Processing year 2030, month 6\n", - "Processing year 2030, month 7\n", - "Processing year 2030, month 8\n", - "Processing year 2030, month 9\n", - "Processing year 2030, month 10\n", - "Processing year 2030, month 11\n", - "Processing year 2030, month 12\n", - "Processing file: CIL_subset_ssp245_2031.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2031, month 1\n", - "Processing year 2031, month 2\n", - "Processing year 2031, month 3\n", - "Processing year 2031, month 4\n", - "Processing year 2031, month 5\n", - "Processing year 2031, month 6\n", - "Processing year 2031, month 7\n", - "Processing year 2031, month 8\n", - "Processing year 2031, month 9\n", - "Processing year 2031, month 10\n", - "Processing year 2031, month 11\n", - "Processing year 2031, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2031, month 1\n", - "Processing year 2031, month 2\n", - "Processing year 2031, month 3\n", - "Processing year 2031, month 4\n", - "Processing year 2031, month 5\n", - "Processing year 2031, month 6\n", - "Processing year 2031, month 7\n", - "Processing year 2031, month 8\n", - "Processing year 2031, month 9\n", - "Processing year 2031, month 10\n", - "Processing year 2031, month 11\n", - "Processing year 2031, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2031, month 1\n", - "Processing year 2031, month 2\n", - "Processing year 2031, month 3\n", - "Processing year 2031, month 4\n", - "Processing year 2031, month 5\n", - "Processing year 2031, month 6\n", - "Processing year 2031, month 7\n", - "Processing year 2031, month 8\n", - "Processing year 2031, month 9\n", - "Processing year 2031, month 10\n", - "Processing year 2031, month 11\n", - "Processing year 2031, month 12\n", - "Processing file: CIL_subset_ssp245_2032.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2032, month 1\n", - "Processing year 2032, month 2\n", - "Processing year 2032, month 3\n", - "Processing year 2032, month 4\n", - "Processing year 2032, month 5\n", - "Processing year 2032, month 6\n", - "Processing year 2032, month 7\n", - "Processing year 2032, month 8\n", - "Processing year 2032, month 9\n", - "Processing year 2032, month 10\n", - "Processing year 2032, month 11\n", - "Processing year 2032, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2032, month 1\n", - "Processing year 2032, month 2\n", - "Processing year 2032, month 3\n", - "Processing year 2032, month 4\n", - "Processing year 2032, month 5\n", - "Processing year 2032, month 6\n", - "Processing year 2032, month 7\n", - "Processing year 2032, month 8\n", - "Processing year 2032, month 9\n", - "Processing year 2032, month 10\n", - "Processing year 2032, month 11\n", - "Processing year 2032, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2032, month 1\n", - "Processing year 2032, month 2\n", - "Processing year 2032, month 3\n", - "Processing year 2032, month 4\n", - "Processing year 2032, month 5\n", - "Processing year 2032, month 6\n", - "Processing year 2032, month 7\n", - "Processing year 2032, month 8\n", - "Processing year 2032, month 9\n", - "Processing year 2032, month 10\n", - "Processing year 2032, month 11\n", - "Processing year 2032, month 12\n", - "Processing file: CIL_subset_ssp245_2033.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2033, month 1\n", - "Processing year 2033, month 2\n", - "Processing year 2033, month 3\n", - "Processing year 2033, month 4\n", - "Processing year 2033, month 5\n", - "Processing year 2033, month 6\n", - "Processing year 2033, month 7\n", - "Processing year 2033, month 8\n", - "Processing year 2033, month 9\n", - "Processing year 2033, month 10\n", - "Processing year 2033, month 11\n", - "Processing year 2033, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2033, month 1\n", - "Processing year 2033, month 2\n", - "Processing year 2033, month 3\n", - "Processing year 2033, month 4\n", - "Processing year 2033, month 5\n", - "Processing year 2033, month 6\n", - "Processing year 2033, month 7\n", - "Processing year 2033, month 8\n", - "Processing year 2033, month 9\n", - "Processing year 2033, month 10\n", - "Processing year 2033, month 11\n", - "Processing year 2033, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2033, month 1\n", - "Processing year 2033, month 2\n", - "Processing year 2033, month 3\n", - "Processing year 2033, month 4\n", - "Processing year 2033, month 5\n", - "Processing year 2033, month 6\n", - "Processing year 2033, month 7\n", - "Processing year 2033, month 8\n", - "Processing year 2033, month 9\n", - "Processing year 2033, month 10\n", - "Processing year 2033, month 11\n", - "Processing year 2033, month 12\n", - "Processing file: CIL_subset_ssp245_2034.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2034, month 1\n", - "Processing year 2034, month 2\n", - "Processing year 2034, month 3\n", - "Processing year 2034, month 4\n", - "Processing year 2034, month 5\n", - "Processing year 2034, month 6\n", - "Processing year 2034, month 7\n", - "Processing year 2034, month 8\n", - "Processing year 2034, month 9\n", - "Processing year 2034, month 10\n", - "Processing year 2034, month 11\n", - "Processing year 2034, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2034, month 1\n", - "Processing year 2034, month 2\n", - "Processing year 2034, month 3\n", - "Processing year 2034, month 4\n", - "Processing year 2034, month 5\n", - "Processing year 2034, month 6\n", - "Processing year 2034, month 7\n", - "Processing year 2034, month 8\n", - "Processing year 2034, month 9\n", - "Processing year 2034, month 10\n", - "Processing year 2034, month 11\n", - "Processing year 2034, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2034, month 1\n", - "Processing year 2034, month 2\n", - "Processing year 2034, month 3\n", - "Processing year 2034, month 4\n", - "Processing year 2034, month 5\n", - "Processing year 2034, month 6\n", - "Processing year 2034, month 7\n", - "Processing year 2034, month 8\n", - "Processing year 2034, month 9\n", - "Processing year 2034, month 10\n", - "Processing year 2034, month 11\n", - "Processing year 2034, month 12\n", - "Processing file: CIL_subset_ssp245_2035.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2035, month 1\n", - "Processing year 2035, month 2\n", - "Processing year 2035, month 3\n", - "Processing year 2035, month 4\n", - "Processing year 2035, month 5\n", - "Processing year 2035, month 6\n", - "Processing year 2035, month 7\n", - "Processing year 2035, month 8\n", - "Processing year 2035, month 9\n", - "Processing year 2035, month 10\n", - "Processing year 2035, month 11\n", - "Processing year 2035, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2035, month 1\n", - "Processing year 2035, month 2\n", - "Processing year 2035, month 3\n", - "Processing year 2035, month 4\n", - "Processing year 2035, month 5\n", - "Processing year 2035, month 6\n", - "Processing year 2035, month 7\n", - "Processing year 2035, month 8\n", - "Processing year 2035, month 9\n", - "Processing year 2035, month 10\n", - "Processing year 2035, month 11\n", - "Processing year 2035, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2035, month 1\n", - "Processing year 2035, month 2\n", - "Processing year 2035, month 3\n", - "Processing year 2035, month 4\n", - "Processing year 2035, month 5\n", - "Processing year 2035, month 6\n", - "Processing year 2035, month 7\n", - "Processing year 2035, month 8\n", - "Processing year 2035, month 9\n", - "Processing year 2035, month 10\n", - "Processing year 2035, month 11\n", - "Processing year 2035, month 12\n", - "Processing file: CIL_subset_ssp245_2036.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2036, month 1\n", - "Processing year 2036, month 2\n", - "Processing year 2036, month 3\n", - "Processing year 2036, month 4\n", - "Processing year 2036, month 5\n", - "Processing year 2036, month 6\n", - "Processing year 2036, month 7\n", - "Processing year 2036, month 8\n", - "Processing year 2036, month 9\n", - "Processing year 2036, month 10\n", - "Processing year 2036, month 11\n", - "Processing year 2036, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2036, month 1\n", - "Processing year 2036, month 2\n", - "Processing year 2036, month 3\n", - "Processing year 2036, month 4\n", - "Processing year 2036, month 5\n", - "Processing year 2036, month 6\n", - "Processing year 2036, month 7\n", - "Processing year 2036, month 8\n", - "Processing year 2036, month 9\n", - "Processing year 2036, month 10\n", - "Processing year 2036, month 11\n", - "Processing year 2036, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2036, month 1\n", - "Processing year 2036, month 2\n", - "Processing year 2036, month 3\n", - "Processing year 2036, month 4\n", - "Processing year 2036, month 5\n", - "Processing year 2036, month 6\n", - "Processing year 2036, month 7\n", - "Processing year 2036, month 8\n", - "Processing year 2036, month 9\n", - "Processing year 2036, month 10\n", - "Processing year 2036, month 11\n", - "Processing year 2036, month 12\n", - "Processing file: CIL_subset_ssp245_2037.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2037, month 1\n", - "Processing year 2037, month 2\n", - "Processing year 2037, month 3\n", - "Processing year 2037, month 4\n", - "Processing year 2037, month 5\n", - "Processing year 2037, month 6\n", - "Processing year 2037, month 7\n", - "Processing year 2037, month 8\n", - "Processing year 2037, month 9\n", - "Processing year 2037, month 10\n", - "Processing year 2037, month 11\n", - "Processing year 2037, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2037, month 1\n", - "Processing year 2037, month 2\n", - "Processing year 2037, month 3\n", - "Processing year 2037, month 4\n", - "Processing year 2037, month 5\n", - "Processing year 2037, month 6\n", - "Processing year 2037, month 7\n", - "Processing year 2037, month 8\n", - "Processing year 2037, month 9\n", - "Processing year 2037, month 10\n", - "Processing year 2037, month 11\n", - "Processing year 2037, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2037, month 1\n", - "Processing year 2037, month 2\n", - "Processing year 2037, month 3\n", - "Processing year 2037, month 4\n", - "Processing year 2037, month 5\n", - "Processing year 2037, month 6\n", - "Processing year 2037, month 7\n", - "Processing year 2037, month 8\n", - "Processing year 2037, month 9\n", - "Processing year 2037, month 10\n", - "Processing year 2037, month 11\n", - "Processing year 2037, month 12\n", - "Processing file: CIL_subset_ssp245_2038.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2038, month 1\n", - "Processing year 2038, month 2\n", - "Processing year 2038, month 3\n", - "Processing year 2038, month 4\n", - "Processing year 2038, month 5\n", - "Processing year 2038, month 6\n", - "Processing year 2038, month 7\n", - "Processing year 2038, month 8\n", - "Processing year 2038, month 9\n", - "Processing year 2038, month 10\n", - "Processing year 2038, month 11\n", - "Processing year 2038, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2038, month 1\n", - "Processing year 2038, month 2\n", - "Processing year 2038, month 3\n", - "Processing year 2038, month 4\n", - "Processing year 2038, month 5\n", - "Processing year 2038, month 6\n", - "Processing year 2038, month 7\n", - "Processing year 2038, month 8\n", - "Processing year 2038, month 9\n", - "Processing year 2038, month 10\n", - "Processing year 2038, month 11\n", - "Processing year 2038, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2038, month 1\n", - "Processing year 2038, month 2\n", - "Processing year 2038, month 3\n", - "Processing year 2038, month 4\n", - "Processing year 2038, month 5\n", - "Processing year 2038, month 6\n", - "Processing year 2038, month 7\n", - "Processing year 2038, month 8\n", - "Processing year 2038, month 9\n", - "Processing year 2038, month 10\n", - "Processing year 2038, month 11\n", - "Processing year 2038, month 12\n", - "Processing file: CIL_subset_ssp245_2039.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2039, month 1\n", - "Processing year 2039, month 2\n", - "Processing year 2039, month 3\n", - "Processing year 2039, month 4\n", - "Processing year 2039, month 5\n", - "Processing year 2039, month 6\n", - "Processing year 2039, month 7\n", - "Processing year 2039, month 8\n", - "Processing year 2039, month 9\n", - "Processing year 2039, month 10\n", - "Processing year 2039, month 11\n", - "Processing year 2039, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2039, month 1\n", - "Processing year 2039, month 2\n", - "Processing year 2039, month 3\n", - "Processing year 2039, month 4\n", - "Processing year 2039, month 5\n", - "Processing year 2039, month 6\n", - "Processing year 2039, month 7\n", - "Processing year 2039, month 8\n", - "Processing year 2039, month 9\n", - "Processing year 2039, month 10\n", - "Processing year 2039, month 11\n", - "Processing year 2039, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2039, month 1\n", - "Processing year 2039, month 2\n", - "Processing year 2039, month 3\n", - "Processing year 2039, month 4\n", - "Processing year 2039, month 5\n", - "Processing year 2039, month 6\n", - "Processing year 2039, month 7\n", - "Processing year 2039, month 8\n", - "Processing year 2039, month 9\n", - "Processing year 2039, month 10\n", - "Processing year 2039, month 11\n", - "Processing year 2039, month 12\n", - "Processing file: CIL_subset_ssp245_2040.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2040, month 1\n", - "Processing year 2040, month 2\n", - "Processing year 2040, month 3\n", - "Processing year 2040, month 4\n", - "Processing year 2040, month 5\n", - "Processing year 2040, month 6\n", - "Processing year 2040, month 7\n", - "Processing year 2040, month 8\n", - "Processing year 2040, month 9\n", - "Processing year 2040, month 10\n", - "Processing year 2040, month 11\n", - "Processing year 2040, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2040, month 1\n", - "Processing year 2040, month 2\n", - "Processing year 2040, month 3\n", - "Processing year 2040, month 4\n", - "Processing year 2040, month 5\n", - "Processing year 2040, month 6\n", - "Processing year 2040, month 7\n", - "Processing year 2040, month 8\n", - "Processing year 2040, month 9\n", - "Processing year 2040, month 10\n", - "Processing year 2040, month 11\n", - "Processing year 2040, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2040, month 1\n", - "Processing year 2040, month 2\n", - "Processing year 2040, month 3\n", - "Processing year 2040, month 4\n", - "Processing year 2040, month 5\n", - "Processing year 2040, month 6\n", - "Processing year 2040, month 7\n", - "Processing year 2040, month 8\n", - "Processing year 2040, month 9\n", - "Processing year 2040, month 10\n", - "Processing year 2040, month 11\n", - "Processing year 2040, month 12\n", - "Processing file: CIL_subset_ssp245_2041.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2041, month 1\n", - "Processing year 2041, month 2\n", - "Processing year 2041, month 3\n", - "Processing year 2041, month 4\n", - "Processing year 2041, month 5\n", - "Processing year 2041, month 6\n", - "Processing year 2041, month 7\n", - "Processing year 2041, month 8\n", - "Processing year 2041, month 9\n", - "Processing year 2041, month 10\n", - "Processing year 2041, month 11\n", - "Processing year 2041, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2041, month 1\n", - "Processing year 2041, month 2\n", - "Processing year 2041, month 3\n", - "Processing year 2041, month 4\n", - "Processing year 2041, month 5\n", - "Processing year 2041, month 6\n", - "Processing year 2041, month 7\n", - "Processing year 2041, month 8\n", - "Processing year 2041, month 9\n", - "Processing year 2041, month 10\n", - "Processing year 2041, month 11\n", - "Processing year 2041, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2041, month 1\n", - "Processing year 2041, month 2\n", - "Processing year 2041, month 3\n", - "Processing year 2041, month 4\n", - "Processing year 2041, month 5\n", - "Processing year 2041, month 6\n", - "Processing year 2041, month 7\n", - "Processing year 2041, month 8\n", - "Processing year 2041, month 9\n", - "Processing year 2041, month 10\n", - "Processing year 2041, month 11\n", - "Processing year 2041, month 12\n", - "Processing file: CIL_subset_ssp245_2042.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2042, month 1\n", - "Processing year 2042, month 2\n", - "Processing year 2042, month 3\n", - "Processing year 2042, month 4\n", - "Processing year 2042, month 5\n", - "Processing year 2042, month 6\n", - "Processing year 2042, month 7\n", - "Processing year 2042, month 8\n", - "Processing year 2042, month 9\n", - "Processing year 2042, month 10\n", - "Processing year 2042, month 11\n", - "Processing year 2042, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2042, month 1\n", - "Processing year 2042, month 2\n", - "Processing year 2042, month 3\n", - "Processing year 2042, month 4\n", - "Processing year 2042, month 5\n", - "Processing year 2042, month 6\n", - "Processing year 2042, month 7\n", - "Processing year 2042, month 8\n", - "Processing year 2042, month 9\n", - "Processing year 2042, month 10\n", - "Processing year 2042, month 11\n", - "Processing year 2042, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2042, month 1\n", - "Processing year 2042, month 2\n", - "Processing year 2042, month 3\n", - "Processing year 2042, month 4\n", - "Processing year 2042, month 5\n", - "Processing year 2042, month 6\n", - "Processing year 2042, month 7\n", - "Processing year 2042, month 8\n", - "Processing year 2042, month 9\n", - "Processing year 2042, month 10\n", - "Processing year 2042, month 11\n", - "Processing year 2042, month 12\n", - "Processing file: CIL_subset_ssp245_2043.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2043, month 1\n", - "Processing year 2043, month 2\n", - "Processing year 2043, month 3\n", - "Processing year 2043, month 4\n", - "Processing year 2043, month 5\n", - "Processing year 2043, month 6\n", - "Processing year 2043, month 7\n", - "Processing year 2043, month 8\n", - "Processing year 2043, month 9\n", - "Processing year 2043, month 10\n", - "Processing year 2043, month 11\n", - "Processing year 2043, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2043, month 1\n", - "Processing year 2043, month 2\n", - "Processing year 2043, month 3\n", - "Processing year 2043, month 4\n", - "Processing year 2043, month 5\n", - "Processing year 2043, month 6\n", - "Processing year 2043, month 7\n", - "Processing year 2043, month 8\n", - "Processing year 2043, month 9\n", - "Processing year 2043, month 10\n", - "Processing year 2043, month 11\n", - "Processing year 2043, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2043, month 1\n", - "Processing year 2043, month 2\n", - "Processing year 2043, month 3\n", - "Processing year 2043, month 4\n", - "Processing year 2043, month 5\n", - "Processing year 2043, month 6\n", - "Processing year 2043, month 7\n", - "Processing year 2043, month 8\n", - "Processing year 2043, month 9\n", - "Processing year 2043, month 10\n", - "Processing year 2043, month 11\n", - "Processing year 2043, month 12\n", - "Processing file: CIL_subset_ssp245_2044.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2044, month 1\n", - "Processing year 2044, month 2\n", - "Processing year 2044, month 3\n", - "Processing year 2044, month 4\n", - "Processing year 2044, month 5\n", - "Processing year 2044, month 6\n", - "Processing year 2044, month 7\n", - "Processing year 2044, month 8\n", - "Processing year 2044, month 9\n", - "Processing year 2044, month 10\n", - "Processing year 2044, month 11\n", - "Processing year 2044, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2044, month 1\n", - "Processing year 2044, month 2\n", - "Processing year 2044, month 3\n", - "Processing year 2044, month 4\n", - "Processing year 2044, month 5\n", - "Processing year 2044, month 6\n", - "Processing year 2044, month 7\n", - "Processing year 2044, month 8\n", - "Processing year 2044, month 9\n", - "Processing year 2044, month 10\n", - "Processing year 2044, month 11\n", - "Processing year 2044, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2044, month 1\n", - "Processing year 2044, month 2\n", - "Processing year 2044, month 3\n", - "Processing year 2044, month 4\n", - "Processing year 2044, month 5\n", - "Processing year 2044, month 6\n", - "Processing year 2044, month 7\n", - "Processing year 2044, month 8\n", - "Processing year 2044, month 9\n", - "Processing year 2044, month 10\n", - "Processing year 2044, month 11\n", - "Processing year 2044, month 12\n", - "Processing file: CIL_subset_ssp245_2045.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2045, month 1\n", - "Processing year 2045, month 2\n", - "Processing year 2045, month 3\n", - "Processing year 2045, month 4\n", - "Processing year 2045, month 5\n", - "Processing year 2045, month 6\n", - "Processing year 2045, month 7\n", - "Processing year 2045, month 8\n", - "Processing year 2045, month 9\n", - "Processing year 2045, month 10\n", - "Processing year 2045, month 11\n", - "Processing year 2045, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2045, month 1\n", - "Processing year 2045, month 2\n", - "Processing year 2045, month 3\n", - "Processing year 2045, month 4\n", - "Processing year 2045, month 5\n", - "Processing year 2045, month 6\n", - "Processing year 2045, month 7\n", - "Processing year 2045, month 8\n", - "Processing year 2045, month 9\n", - "Processing year 2045, month 10\n", - "Processing year 2045, month 11\n", - "Processing year 2045, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2045, month 1\n", - "Processing year 2045, month 2\n", - "Processing year 2045, month 3\n", - "Processing year 2045, month 4\n", - "Processing year 2045, month 5\n", - "Processing year 2045, month 6\n", - "Processing year 2045, month 7\n", - "Processing year 2045, month 8\n", - "Processing year 2045, month 9\n", - "Processing year 2045, month 10\n", - "Processing year 2045, month 11\n", - "Processing year 2045, month 12\n", - "Processing file: CIL_subset_ssp245_2046.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2046, month 1\n", - "Processing year 2046, month 2\n", - "Processing year 2046, month 3\n", - "Processing year 2046, month 4\n", - "Processing year 2046, month 5\n", - "Processing year 2046, month 6\n", - "Processing year 2046, month 7\n", - "Processing year 2046, month 8\n", - "Processing year 2046, month 9\n", - "Processing year 2046, month 10\n", - "Processing year 2046, month 11\n", - "Processing year 2046, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2046, month 1\n", - "Processing year 2046, month 2\n", - "Processing year 2046, month 3\n", - "Processing year 2046, month 4\n", - "Processing year 2046, month 5\n", - "Processing year 2046, month 6\n", - "Processing year 2046, month 7\n", - "Processing year 2046, month 8\n", - "Processing year 2046, month 9\n", - "Processing year 2046, month 10\n", - "Processing year 2046, month 11\n", - "Processing year 2046, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2046, month 1\n", - "Processing year 2046, month 2\n", - "Processing year 2046, month 3\n", - "Processing year 2046, month 4\n", - "Processing year 2046, month 5\n", - "Processing year 2046, month 6\n", - "Processing year 2046, month 7\n", - "Processing year 2046, month 8\n", - "Processing year 2046, month 9\n", - "Processing year 2046, month 10\n", - "Processing year 2046, month 11\n", - "Processing year 2046, month 12\n", - "Processing file: CIL_subset_ssp245_2047.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2047, month 1\n", - "Processing year 2047, month 2\n", - "Processing year 2047, month 3\n", - "Processing year 2047, month 4\n", - "Processing year 2047, month 5\n", - "Processing year 2047, month 6\n", - "Processing year 2047, month 7\n", - "Processing year 2047, month 8\n", - "Processing year 2047, month 9\n", - "Processing year 2047, month 10\n", - "Processing year 2047, month 11\n", - "Processing year 2047, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2047, month 1\n", - "Processing year 2047, month 2\n", - "Processing year 2047, month 3\n", - "Processing year 2047, month 4\n", - "Processing year 2047, month 5\n", - "Processing year 2047, month 6\n", - "Processing year 2047, month 7\n", - "Processing year 2047, month 8\n", - "Processing year 2047, month 9\n", - "Processing year 2047, month 10\n", - "Processing year 2047, month 11\n", - "Processing year 2047, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2047, month 1\n", - "Processing year 2047, month 2\n", - "Processing year 2047, month 3\n", - "Processing year 2047, month 4\n", - "Processing year 2047, month 5\n", - "Processing year 2047, month 6\n", - "Processing year 2047, month 7\n", - "Processing year 2047, month 8\n", - "Processing year 2047, month 9\n", - "Processing year 2047, month 10\n", - "Processing year 2047, month 11\n", - "Processing year 2047, month 12\n", - "Processing file: CIL_subset_ssp245_2048.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2048, month 1\n", - "Processing year 2048, month 2\n", - "Processing year 2048, month 3\n", - "Processing year 2048, month 4\n", - "Processing year 2048, month 5\n", - "Processing year 2048, month 6\n", - "Processing year 2048, month 7\n", - "Processing year 2048, month 8\n", - "Processing year 2048, month 9\n", - "Processing year 2048, month 10\n", - "Processing year 2048, month 11\n", - "Processing year 2048, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2048, month 1\n", - "Processing year 2048, month 2\n", - "Processing year 2048, month 3\n", - "Processing year 2048, month 4\n", - "Processing year 2048, month 5\n", - "Processing year 2048, month 6\n", - "Processing year 2048, month 7\n", - "Processing year 2048, month 8\n", - "Processing year 2048, month 9\n", - "Processing year 2048, month 10\n", - "Processing year 2048, month 11\n", - "Processing year 2048, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2048, month 1\n", - "Processing year 2048, month 2\n", - "Processing year 2048, month 3\n", - "Processing year 2048, month 4\n", - "Processing year 2048, month 5\n", - "Processing year 2048, month 6\n", - "Processing year 2048, month 7\n", - "Processing year 2048, month 8\n", - "Processing year 2048, month 9\n", - "Processing year 2048, month 10\n", - "Processing year 2048, month 11\n", - "Processing year 2048, month 12\n", - "Processing file: CIL_subset_ssp245_2049.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2049, month 1\n", - "Processing year 2049, month 2\n", - "Processing year 2049, month 3\n", - "Processing year 2049, month 4\n", - "Processing year 2049, month 5\n", - "Processing year 2049, month 6\n", - "Processing year 2049, month 7\n", - "Processing year 2049, month 8\n", - "Processing year 2049, month 9\n", - "Processing year 2049, month 10\n", - "Processing year 2049, month 11\n", - "Processing year 2049, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2049, month 1\n", - "Processing year 2049, month 2\n", - "Processing year 2049, month 3\n", - "Processing year 2049, month 4\n", - "Processing year 2049, month 5\n", - "Processing year 2049, month 6\n", - "Processing year 2049, month 7\n", - "Processing year 2049, month 8\n", - "Processing year 2049, month 9\n", - "Processing year 2049, month 10\n", - "Processing year 2049, month 11\n", - "Processing year 2049, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2049, month 1\n", - "Processing year 2049, month 2\n", - "Processing year 2049, month 3\n", - "Processing year 2049, month 4\n", - "Processing year 2049, month 5\n", - "Processing year 2049, month 6\n", - "Processing year 2049, month 7\n", - "Processing year 2049, month 8\n", - "Processing year 2049, month 9\n", - "Processing year 2049, month 10\n", - "Processing year 2049, month 11\n", - "Processing year 2049, month 12\n", - "Processing file: CIL_subset_ssp245_2050.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2050, month 1\n", - "Processing year 2050, month 2\n", - "Processing year 2050, month 3\n", - "Processing year 2050, month 4\n", - "Processing year 2050, month 5\n", - "Processing year 2050, month 6\n", - "Processing year 2050, month 7\n", - "Processing year 2050, month 8\n", - "Processing year 2050, month 9\n", - "Processing year 2050, month 10\n", - "Processing year 2050, month 11\n", - "Processing year 2050, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2050, month 1\n", - "Processing year 2050, month 2\n", - "Processing year 2050, month 3\n", - "Processing year 2050, month 4\n", - "Processing year 2050, month 5\n", - "Processing year 2050, month 6\n", - "Processing year 2050, month 7\n", - "Processing year 2050, month 8\n", - "Processing year 2050, month 9\n", - "Processing year 2050, month 10\n", - "Processing year 2050, month 11\n", - "Processing year 2050, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2050, month 1\n", - "Processing year 2050, month 2\n", - "Processing year 2050, month 3\n", - "Processing year 2050, month 4\n", - "Processing year 2050, month 5\n", - "Processing year 2050, month 6\n", - "Processing year 2050, month 7\n", - "Processing year 2050, month 8\n", - "Processing year 2050, month 9\n", - "Processing year 2050, month 10\n", - "Processing year 2050, month 11\n", - "Processing year 2050, month 12\n", - "Processing file: CIL_subset_ssp245_2051.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2051, month 1\n", - "Processing year 2051, month 2\n", - "Processing year 2051, month 3\n", - "Processing year 2051, month 4\n", - "Processing year 2051, month 5\n", - "Processing year 2051, month 6\n", - "Processing year 2051, month 7\n", - "Processing year 2051, month 8\n", - "Processing year 2051, month 9\n", - "Processing year 2051, month 10\n", - "Processing year 2051, month 11\n", - "Processing year 2051, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2051, month 1\n", - "Processing year 2051, month 2\n", - "Processing year 2051, month 3\n", - "Processing year 2051, month 4\n", - "Processing year 2051, month 5\n", - "Processing year 2051, month 6\n", - "Processing year 2051, month 7\n", - "Processing year 2051, month 8\n", - "Processing year 2051, month 9\n", - "Processing year 2051, month 10\n", - "Processing year 2051, month 11\n", - "Processing year 2051, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2051, month 1\n", - "Processing year 2051, month 2\n", - "Processing year 2051, month 3\n", - "Processing year 2051, month 4\n", - "Processing year 2051, month 5\n", - "Processing year 2051, month 6\n", - "Processing year 2051, month 7\n", - "Processing year 2051, month 8\n", - "Processing year 2051, month 9\n", - "Processing year 2051, month 10\n", - "Processing year 2051, month 11\n", - "Processing year 2051, month 12\n", - "Processing file: CIL_subset_ssp245_2052.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2052, month 1\n", - "Processing year 2052, month 2\n", - "Processing year 2052, month 3\n", - "Processing year 2052, month 4\n", - "Processing year 2052, month 5\n", - "Processing year 2052, month 6\n", - "Processing year 2052, month 7\n", - "Processing year 2052, month 8\n", - "Processing year 2052, month 9\n", - "Processing year 2052, month 10\n", - "Processing year 2052, month 11\n", - "Processing year 2052, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2052, month 1\n", - "Processing year 2052, month 2\n", - "Processing year 2052, month 3\n", - "Processing year 2052, month 4\n", - "Processing year 2052, month 5\n", - "Processing year 2052, month 6\n", - "Processing year 2052, month 7\n", - "Processing year 2052, month 8\n", - "Processing year 2052, month 9\n", - "Processing year 2052, month 10\n", - "Processing year 2052, month 11\n", - "Processing year 2052, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2052, month 1\n", - "Processing year 2052, month 2\n", - "Processing year 2052, month 3\n", - "Processing year 2052, month 4\n", - "Processing year 2052, month 5\n", - "Processing year 2052, month 6\n", - "Processing year 2052, month 7\n", - "Processing year 2052, month 8\n", - "Processing year 2052, month 9\n", - "Processing year 2052, month 10\n", - "Processing year 2052, month 11\n", - "Processing year 2052, month 12\n", - "Processing file: CIL_subset_ssp245_2053.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2053, month 1\n", - "Processing year 2053, month 2\n", - "Processing year 2053, month 3\n", - "Processing year 2053, month 4\n", - "Processing year 2053, month 5\n", - "Processing year 2053, month 6\n", - "Processing year 2053, month 7\n", - "Processing year 2053, month 8\n", - "Processing year 2053, month 9\n", - "Processing year 2053, month 10\n", - "Processing year 2053, month 11\n", - "Processing year 2053, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2053, month 1\n", - "Processing year 2053, month 2\n", - "Processing year 2053, month 3\n", - "Processing year 2053, month 4\n", - "Processing year 2053, month 5\n", - "Processing year 2053, month 6\n", - "Processing year 2053, month 7\n", - "Processing year 2053, month 8\n", - "Processing year 2053, month 9\n", - "Processing year 2053, month 10\n", - "Processing year 2053, month 11\n", - "Processing year 2053, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2053, month 1\n", - "Processing year 2053, month 2\n", - "Processing year 2053, month 3\n", - "Processing year 2053, month 4\n", - "Processing year 2053, month 5\n", - "Processing year 2053, month 6\n", - "Processing year 2053, month 7\n", - "Processing year 2053, month 8\n", - "Processing year 2053, month 9\n", - "Processing year 2053, month 10\n", - "Processing year 2053, month 11\n", - "Processing year 2053, month 12\n", - "Processing file: CIL_subset_ssp245_2054.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2054, month 1\n", - "Processing year 2054, month 2\n", - "Processing year 2054, month 3\n", - "Processing year 2054, month 4\n", - "Processing year 2054, month 5\n", - "Processing year 2054, month 6\n", - "Processing year 2054, month 7\n", - "Processing year 2054, month 8\n", - "Processing year 2054, month 9\n", - "Processing year 2054, month 10\n", - "Processing year 2054, month 11\n", - "Processing year 2054, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2054, month 1\n", - "Processing year 2054, month 2\n", - "Processing year 2054, month 3\n", - "Processing year 2054, month 4\n", - "Processing year 2054, month 5\n", - "Processing year 2054, month 6\n", - "Processing year 2054, month 7\n", - "Processing year 2054, month 8\n", - "Processing year 2054, month 9\n", - "Processing year 2054, month 10\n", - "Processing year 2054, month 11\n", - "Processing year 2054, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2054, month 1\n", - "Processing year 2054, month 2\n", - "Processing year 2054, month 3\n", - "Processing year 2054, month 4\n", - "Processing year 2054, month 5\n", - "Processing year 2054, month 6\n", - "Processing year 2054, month 7\n", - "Processing year 2054, month 8\n", - "Processing year 2054, month 9\n", - "Processing year 2054, month 10\n", - "Processing year 2054, month 11\n", - "Processing year 2054, month 12\n", - "Processing file: CIL_subset_ssp245_2055.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2055, month 1\n", - "Processing year 2055, month 2\n", - "Processing year 2055, month 3\n", - "Processing year 2055, month 4\n", - "Processing year 2055, month 5\n", - "Processing year 2055, month 6\n", - "Processing year 2055, month 7\n", - "Processing year 2055, month 8\n", - "Processing year 2055, month 9\n", - "Processing year 2055, month 10\n", - "Processing year 2055, month 11\n", - "Processing year 2055, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2055, month 1\n", - "Processing year 2055, month 2\n", - "Processing year 2055, month 3\n", - "Processing year 2055, month 4\n", - "Processing year 2055, month 5\n", - "Processing year 2055, month 6\n", - "Processing year 2055, month 7\n", - "Processing year 2055, month 8\n", - "Processing year 2055, month 9\n", - "Processing year 2055, month 10\n", - "Processing year 2055, month 11\n", - "Processing year 2055, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2055, month 1\n", - "Processing year 2055, month 2\n", - "Processing year 2055, month 3\n", - "Processing year 2055, month 4\n", - "Processing year 2055, month 5\n", - "Processing year 2055, month 6\n", - "Processing year 2055, month 7\n", - "Processing year 2055, month 8\n", - "Processing year 2055, month 9\n", - "Processing year 2055, month 10\n", - "Processing year 2055, month 11\n", - "Processing year 2055, month 12\n", - "Processing file: CIL_subset_ssp245_2056.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2056, month 1\n", - "Processing year 2056, month 2\n", - "Processing year 2056, month 3\n", - "Processing year 2056, month 4\n", - "Processing year 2056, month 5\n", - "Processing year 2056, month 6\n", - "Processing year 2056, month 7\n", - "Processing year 2056, month 8\n", - "Processing year 2056, month 9\n", - "Processing year 2056, month 10\n", - "Processing year 2056, month 11\n", - "Processing year 2056, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2056, month 1\n", - "Processing year 2056, month 2\n", - "Processing year 2056, month 3\n", - "Processing year 2056, month 4\n", - "Processing year 2056, month 5\n", - "Processing year 2056, month 6\n", - "Processing year 2056, month 7\n", - "Processing year 2056, month 8\n", - "Processing year 2056, month 9\n", - "Processing year 2056, month 10\n", - "Processing year 2056, month 11\n", - "Processing year 2056, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2056, month 1\n", - "Processing year 2056, month 2\n", - "Processing year 2056, month 3\n", - "Processing year 2056, month 4\n", - "Processing year 2056, month 5\n", - "Processing year 2056, month 6\n", - "Processing year 2056, month 7\n", - "Processing year 2056, month 8\n", - "Processing year 2056, month 9\n", - "Processing year 2056, month 10\n", - "Processing year 2056, month 11\n", - "Processing year 2056, month 12\n", - "Processing file: CIL_subset_ssp245_2057.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2057, month 1\n", - "Processing year 2057, month 2\n", - "Processing year 2057, month 3\n", - "Processing year 2057, month 4\n", - "Processing year 2057, month 5\n", - "Processing year 2057, month 6\n", - "Processing year 2057, month 7\n", - "Processing year 2057, month 8\n", - "Processing year 2057, month 9\n", - "Processing year 2057, month 10\n", - "Processing year 2057, month 11\n", - "Processing year 2057, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2057, month 1\n", - "Processing year 2057, month 2\n", - "Processing year 2057, month 3\n", - "Processing year 2057, month 4\n", - "Processing year 2057, month 5\n", - "Processing year 2057, month 6\n", - "Processing year 2057, month 7\n", - "Processing year 2057, month 8\n", - "Processing year 2057, month 9\n", - "Processing year 2057, month 10\n", - "Processing year 2057, month 11\n", - "Processing year 2057, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2057, month 1\n", - "Processing year 2057, month 2\n", - "Processing year 2057, month 3\n", - "Processing year 2057, month 4\n", - "Processing year 2057, month 5\n", - "Processing year 2057, month 6\n", - "Processing year 2057, month 7\n", - "Processing year 2057, month 8\n", - "Processing year 2057, month 9\n", - "Processing year 2057, month 10\n", - "Processing year 2057, month 11\n", - "Processing year 2057, month 12\n", - "Processing file: CIL_subset_ssp245_2058.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2058, month 1\n", - "Processing year 2058, month 2\n", - "Processing year 2058, month 3\n", - "Processing year 2058, month 4\n", - "Processing year 2058, month 5\n", - "Processing year 2058, month 6\n", - "Processing year 2058, month 7\n", - "Processing year 2058, month 8\n", - "Processing year 2058, month 9\n", - "Processing year 2058, month 10\n", - "Processing year 2058, month 11\n", - "Processing year 2058, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2058, month 1\n", - "Processing year 2058, month 2\n", - "Processing year 2058, month 3\n", - "Processing year 2058, month 4\n", - "Processing year 2058, month 5\n", - "Processing year 2058, month 6\n", - "Processing year 2058, month 7\n", - "Processing year 2058, month 8\n", - "Processing year 2058, month 9\n", - "Processing year 2058, month 10\n", - "Processing year 2058, month 11\n", - "Processing year 2058, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2058, month 1\n", - "Processing year 2058, month 2\n", - "Processing year 2058, month 3\n", - "Processing year 2058, month 4\n", - "Processing year 2058, month 5\n", - "Processing year 2058, month 6\n", - "Processing year 2058, month 7\n", - "Processing year 2058, month 8\n", - "Processing year 2058, month 9\n", - "Processing year 2058, month 10\n", - "Processing year 2058, month 11\n", - "Processing year 2058, month 12\n", - "Processing file: CIL_subset_ssp245_2059.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2059, month 1\n", - "Processing year 2059, month 2\n", - "Processing year 2059, month 3\n", - "Processing year 2059, month 4\n", - "Processing year 2059, month 5\n", - "Processing year 2059, month 6\n", - "Processing year 2059, month 7\n", - "Processing year 2059, month 8\n", - "Processing year 2059, month 9\n", - "Processing year 2059, month 10\n", - "Processing year 2059, month 11\n", - "Processing year 2059, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2059, month 1\n", - "Processing year 2059, month 2\n", - "Processing year 2059, month 3\n", - "Processing year 2059, month 4\n", - "Processing year 2059, month 5\n", - "Processing year 2059, month 6\n", - "Processing year 2059, month 7\n", - "Processing year 2059, month 8\n", - "Processing year 2059, month 9\n", - "Processing year 2059, month 10\n", - "Processing year 2059, month 11\n", - "Processing year 2059, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2059, month 1\n", - "Processing year 2059, month 2\n", - "Processing year 2059, month 3\n", - "Processing year 2059, month 4\n", - "Processing year 2059, month 5\n", - "Processing year 2059, month 6\n", - "Processing year 2059, month 7\n", - "Processing year 2059, month 8\n", - "Processing year 2059, month 9\n", - "Processing year 2059, month 10\n", - "Processing year 2059, month 11\n", - "Processing year 2059, month 12\n", - "Processing file: CIL_subset_ssp245_2060.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2060, month 1\n", - "Processing year 2060, month 2\n", - "Processing year 2060, month 3\n", - "Processing year 2060, month 4\n", - "Processing year 2060, month 5\n", - "Processing year 2060, month 6\n", - "Processing year 2060, month 7\n", - "Processing year 2060, month 8\n", - "Processing year 2060, month 9\n", - "Processing year 2060, month 10\n", - "Processing year 2060, month 11\n", - "Processing year 2060, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2060, month 1\n", - "Processing year 2060, month 2\n", - "Processing year 2060, month 3\n", - "Processing year 2060, month 4\n", - "Processing year 2060, month 5\n", - "Processing year 2060, month 6\n", - "Processing year 2060, month 7\n", - "Processing year 2060, month 8\n", - "Processing year 2060, month 9\n", - "Processing year 2060, month 10\n", - "Processing year 2060, month 11\n", - "Processing year 2060, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2060, month 1\n", - "Processing year 2060, month 2\n", - "Processing year 2060, month 3\n", - "Processing year 2060, month 4\n", - "Processing year 2060, month 5\n", - "Processing year 2060, month 6\n", - "Processing year 2060, month 7\n", - "Processing year 2060, month 8\n", - "Processing year 2060, month 9\n", - "Processing year 2060, month 10\n", - "Processing year 2060, month 11\n", - "Processing year 2060, month 12\n", - "Processing file: CIL_subset_ssp245_2061.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2061, month 1\n", - "Processing year 2061, month 2\n", - "Processing year 2061, month 3\n", - "Processing year 2061, month 4\n", - "Processing year 2061, month 5\n", - "Processing year 2061, month 6\n", - "Processing year 2061, month 7\n", - "Processing year 2061, month 8\n", - "Processing year 2061, month 9\n", - "Processing year 2061, month 10\n", - "Processing year 2061, month 11\n", - "Processing year 2061, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2061, month 1\n", - "Processing year 2061, month 2\n", - "Processing year 2061, month 3\n", - "Processing year 2061, month 4\n", - "Processing year 2061, month 5\n", - "Processing year 2061, month 6\n", - "Processing year 2061, month 7\n", - "Processing year 2061, month 8\n", - "Processing year 2061, month 9\n", - "Processing year 2061, month 10\n", - "Processing year 2061, month 11\n", - "Processing year 2061, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2061, month 1\n", - "Processing year 2061, month 2\n", - "Processing year 2061, month 3\n", - "Processing year 2061, month 4\n", - "Processing year 2061, month 5\n", - "Processing year 2061, month 6\n", - "Processing year 2061, month 7\n", - "Processing year 2061, month 8\n", - "Processing year 2061, month 9\n", - "Processing year 2061, month 10\n", - "Processing year 2061, month 11\n", - "Processing year 2061, month 12\n", - "Processing file: CIL_subset_ssp245_2062.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2062, month 1\n", - "Processing year 2062, month 2\n", - "Processing year 2062, month 3\n", - "Processing year 2062, month 4\n", - "Processing year 2062, month 5\n", - "Processing year 2062, month 6\n", - "Processing year 2062, month 7\n", - "Processing year 2062, month 8\n", - "Processing year 2062, month 9\n", - "Processing year 2062, month 10\n", - "Processing year 2062, month 11\n", - "Processing year 2062, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2062, month 1\n", - "Processing year 2062, month 2\n", - "Processing year 2062, month 3\n", - "Processing year 2062, month 4\n", - "Processing year 2062, month 5\n", - "Processing year 2062, month 6\n", - "Processing year 2062, month 7\n", - "Processing year 2062, month 8\n", - "Processing year 2062, month 9\n", - "Processing year 2062, month 10\n", - "Processing year 2062, month 11\n", - "Processing year 2062, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2062, month 1\n", - "Processing year 2062, month 2\n", - "Processing year 2062, month 3\n", - "Processing year 2062, month 4\n", - "Processing year 2062, month 5\n", - "Processing year 2062, month 6\n", - "Processing year 2062, month 7\n", - "Processing year 2062, month 8\n", - "Processing year 2062, month 9\n", - "Processing year 2062, month 10\n", - "Processing year 2062, month 11\n", - "Processing year 2062, month 12\n", - "Processing file: CIL_subset_ssp245_2063.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2063, month 1\n", - "Processing year 2063, month 2\n", - "Processing year 2063, month 3\n", - "Processing year 2063, month 4\n", - "Processing year 2063, month 5\n", - "Processing year 2063, month 6\n", - "Processing year 2063, month 7\n", - "Processing year 2063, month 8\n", - "Processing year 2063, month 9\n", - "Processing year 2063, month 10\n", - "Processing year 2063, month 11\n", - "Processing year 2063, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2063, month 1\n", - "Processing year 2063, month 2\n", - "Processing year 2063, month 3\n", - "Processing year 2063, month 4\n", - "Processing year 2063, month 5\n", - "Processing year 2063, month 6\n", - "Processing year 2063, month 7\n", - "Processing year 2063, month 8\n", - "Processing year 2063, month 9\n", - "Processing year 2063, month 10\n", - "Processing year 2063, month 11\n", - "Processing year 2063, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2063, month 1\n", - "Processing year 2063, month 2\n", - "Processing year 2063, month 3\n", - "Processing year 2063, month 4\n", - "Processing year 2063, month 5\n", - "Processing year 2063, month 6\n", - "Processing year 2063, month 7\n", - "Processing year 2063, month 8\n", - "Processing year 2063, month 9\n", - "Processing year 2063, month 10\n", - "Processing year 2063, month 11\n", - "Processing year 2063, month 12\n", - "Processing file: CIL_subset_ssp245_2064.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2064, month 1\n", - "Processing year 2064, month 2\n", - "Processing year 2064, month 3\n", - "Processing year 2064, month 4\n", - "Processing year 2064, month 5\n", - "Processing year 2064, month 6\n", - "Processing year 2064, month 7\n", - "Processing year 2064, month 8\n", - "Processing year 2064, month 9\n", - "Processing year 2064, month 10\n", - "Processing year 2064, month 11\n", - "Processing year 2064, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2064, month 1\n", - "Processing year 2064, month 2\n", - "Processing year 2064, month 3\n", - "Processing year 2064, month 4\n", - "Processing year 2064, month 5\n", - "Processing year 2064, month 6\n", - "Processing year 2064, month 7\n", - "Processing year 2064, month 8\n", - "Processing year 2064, month 9\n", - "Processing year 2064, month 10\n", - "Processing year 2064, month 11\n", - "Processing year 2064, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2064, month 1\n", - "Processing year 2064, month 2\n", - "Processing year 2064, month 3\n", - "Processing year 2064, month 4\n", - "Processing year 2064, month 5\n", - "Processing year 2064, month 6\n", - "Processing year 2064, month 7\n", - "Processing year 2064, month 8\n", - "Processing year 2064, month 9\n", - "Processing year 2064, month 10\n", - "Processing year 2064, month 11\n", - "Processing year 2064, month 12\n", - "Processing file: CIL_subset_ssp245_2065.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2065, month 1\n", - "Processing year 2065, month 2\n", - "Processing year 2065, month 3\n", - "Processing year 2065, month 4\n", - "Processing year 2065, month 5\n", - "Processing year 2065, month 6\n", - "Processing year 2065, month 7\n", - "Processing year 2065, month 8\n", - "Processing year 2065, month 9\n", - "Processing year 2065, month 10\n", - "Processing year 2065, month 11\n", - "Processing year 2065, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2065, month 1\n", - "Processing year 2065, month 2\n", - "Processing year 2065, month 3\n", - "Processing year 2065, month 4\n", - "Processing year 2065, month 5\n", - "Processing year 2065, month 6\n", - "Processing year 2065, month 7\n", - "Processing year 2065, month 8\n", - "Processing year 2065, month 9\n", - "Processing year 2065, month 10\n", - "Processing year 2065, month 11\n", - "Processing year 2065, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2065, month 1\n", - "Processing year 2065, month 2\n", - "Processing year 2065, month 3\n", - "Processing year 2065, month 4\n", - "Processing year 2065, month 5\n", - "Processing year 2065, month 6\n", - "Processing year 2065, month 7\n", - "Processing year 2065, month 8\n", - "Processing year 2065, month 9\n", - "Processing year 2065, month 10\n", - "Processing year 2065, month 11\n", - "Processing year 2065, month 12\n", - "Processing file: CIL_subset_ssp245_2066.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2066, month 1\n", - "Processing year 2066, month 2\n", - "Processing year 2066, month 3\n", - "Processing year 2066, month 4\n", - "Processing year 2066, month 5\n", - "Processing year 2066, month 6\n", - "Processing year 2066, month 7\n", - "Processing year 2066, month 8\n", - "Processing year 2066, month 9\n", - "Processing year 2066, month 10\n", - "Processing year 2066, month 11\n", - "Processing year 2066, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2066, month 1\n", - "Processing year 2066, month 2\n", - "Processing year 2066, month 3\n", - "Processing year 2066, month 4\n", - "Processing year 2066, month 5\n", - "Processing year 2066, month 6\n", - "Processing year 2066, month 7\n", - "Processing year 2066, month 8\n", - "Processing year 2066, month 9\n", - "Processing year 2066, month 10\n", - "Processing year 2066, month 11\n", - "Processing year 2066, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2066, month 1\n", - "Processing year 2066, month 2\n", - "Processing year 2066, month 3\n", - "Processing year 2066, month 4\n", - "Processing year 2066, month 5\n", - "Processing year 2066, month 6\n", - "Processing year 2066, month 7\n", - "Processing year 2066, month 8\n", - "Processing year 2066, month 9\n", - "Processing year 2066, month 10\n", - "Processing year 2066, month 11\n", - "Processing year 2066, month 12\n", - "Processing file: CIL_subset_ssp245_2067.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2067, month 1\n", - "Processing year 2067, month 2\n", - "Processing year 2067, month 3\n", - "Processing year 2067, month 4\n", - "Processing year 2067, month 5\n", - "Processing year 2067, month 6\n", - "Processing year 2067, month 7\n", - "Processing year 2067, month 8\n", - "Processing year 2067, month 9\n", - "Processing year 2067, month 10\n", - "Processing year 2067, month 11\n", - "Processing year 2067, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2067, month 1\n", - "Processing year 2067, month 2\n", - "Processing year 2067, month 3\n", - "Processing year 2067, month 4\n", - "Processing year 2067, month 5\n", - "Processing year 2067, month 6\n", - "Processing year 2067, month 7\n", - "Processing year 2067, month 8\n", - "Processing year 2067, month 9\n", - "Processing year 2067, month 10\n", - "Processing year 2067, month 11\n", - "Processing year 2067, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2067, month 1\n", - "Processing year 2067, month 2\n", - "Processing year 2067, month 3\n", - "Processing year 2067, month 4\n", - "Processing year 2067, month 5\n", - "Processing year 2067, month 6\n", - "Processing year 2067, month 7\n", - "Processing year 2067, month 8\n", - "Processing year 2067, month 9\n", - "Processing year 2067, month 10\n", - "Processing year 2067, month 11\n", - "Processing year 2067, month 12\n", - "Processing file: CIL_subset_ssp245_2068.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2068, month 1\n", - "Processing year 2068, month 2\n", - "Processing year 2068, month 3\n", - "Processing year 2068, month 4\n", - "Processing year 2068, month 5\n", - "Processing year 2068, month 6\n", - "Processing year 2068, month 7\n", - "Processing year 2068, month 8\n", - "Processing year 2068, month 9\n", - "Processing year 2068, month 10\n", - "Processing year 2068, month 11\n", - "Processing year 2068, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2068, month 1\n", - "Processing year 2068, month 2\n", - "Processing year 2068, month 3\n", - "Processing year 2068, month 4\n", - "Processing year 2068, month 5\n", - "Processing year 2068, month 6\n", - "Processing year 2068, month 7\n", - "Processing year 2068, month 8\n", - "Processing year 2068, month 9\n", - "Processing year 2068, month 10\n", - "Processing year 2068, month 11\n", - "Processing year 2068, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2068, month 1\n", - "Processing year 2068, month 2\n", - "Processing year 2068, month 3\n", - "Processing year 2068, month 4\n", - "Processing year 2068, month 5\n", - "Processing year 2068, month 6\n", - "Processing year 2068, month 7\n", - "Processing year 2068, month 8\n", - "Processing year 2068, month 9\n", - "Processing year 2068, month 10\n", - "Processing year 2068, month 11\n", - "Processing year 2068, month 12\n", - "Processing file: CIL_subset_ssp245_2069.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2069, month 1\n", - "Processing year 2069, month 2\n", - "Processing year 2069, month 3\n", - "Processing year 2069, month 4\n", - "Processing year 2069, month 5\n", - "Processing year 2069, month 6\n", - "Processing year 2069, month 7\n", - "Processing year 2069, month 8\n", - "Processing year 2069, month 9\n", - "Processing year 2069, month 10\n", - "Processing year 2069, month 11\n", - "Processing year 2069, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2069, month 1\n", - "Processing year 2069, month 2\n", - "Processing year 2069, month 3\n", - "Processing year 2069, month 4\n", - "Processing year 2069, month 5\n", - "Processing year 2069, month 6\n", - "Processing year 2069, month 7\n", - "Processing year 2069, month 8\n", - "Processing year 2069, month 9\n", - "Processing year 2069, month 10\n", - "Processing year 2069, month 11\n", - "Processing year 2069, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2069, month 1\n", - "Processing year 2069, month 2\n", - "Processing year 2069, month 3\n", - "Processing year 2069, month 4\n", - "Processing year 2069, month 5\n", - "Processing year 2069, month 6\n", - "Processing year 2069, month 7\n", - "Processing year 2069, month 8\n", - "Processing year 2069, month 9\n", - "Processing year 2069, month 10\n", - "Processing year 2069, month 11\n", - "Processing year 2069, month 12\n", - "Processing file: CIL_subset_ssp245_2070.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2070, month 1\n", - "Processing year 2070, month 2\n", - "Processing year 2070, month 3\n", - "Processing year 2070, month 4\n", - "Processing year 2070, month 5\n", - "Processing year 2070, month 6\n", - "Processing year 2070, month 7\n", - "Processing year 2070, month 8\n", - "Processing year 2070, month 9\n", - "Processing year 2070, month 10\n", - "Processing year 2070, month 11\n", - "Processing year 2070, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2070, month 1\n", - "Processing year 2070, month 2\n", - "Processing year 2070, month 3\n", - "Processing year 2070, month 4\n", - "Processing year 2070, month 5\n", - "Processing year 2070, month 6\n", - "Processing year 2070, month 7\n", - "Processing year 2070, month 8\n", - "Processing year 2070, month 9\n", - "Processing year 2070, month 10\n", - "Processing year 2070, month 11\n", - "Processing year 2070, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2070, month 1\n", - "Processing year 2070, month 2\n", - "Processing year 2070, month 3\n", - "Processing year 2070, month 4\n", - "Processing year 2070, month 5\n", - "Processing year 2070, month 6\n", - "Processing year 2070, month 7\n", - "Processing year 2070, month 8\n", - "Processing year 2070, month 9\n", - "Processing year 2070, month 10\n", - "Processing year 2070, month 11\n", - "Processing year 2070, month 12\n", - "Saved monthly data for lowest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp245/lowest_monthly_prediction_weather_by_facility.csv\n", - "Saved window data for lowest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp245/lowest_window_prediction_weather_by_facility.csv\n", - "Saved monthly data for median model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp245/median_monthly_prediction_weather_by_facility.csv\n", - "Saved window data for median model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp245/median_window_prediction_weather_by_facility.csv\n", - "Saved monthly data for highest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp245/highest_monthly_prediction_weather_by_facility.csv\n", - "Saved window data for highest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp245/highest_window_prediction_weather_by_facility.csv\n", - "Processing scenario: ssp585\n", - "Models of interest ['HadGEM3-GC31-LL', 'GFDL-CM4', 'INM-CM5-0']\n", - "Processing file: CIL_subset_ssp585_2024.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2024, month 1\n", - "Processing year 2024, month 2\n", - "Processing year 2024, month 3\n", - "Processing year 2024, month 4\n", - "Processing year 2024, month 5\n", - "Processing year 2024, month 6\n", - "Processing year 2024, month 7\n", - "Processing year 2024, month 8\n", - "Processing year 2024, month 9\n", - "Processing year 2024, month 10\n", - "Processing year 2024, month 11\n", - "Processing year 2024, month 12\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Processing model: GFDL-CM4\n", - "Processing year 2024, month 1\n", - "Processing year 2024, month 2\n", - "Processing year 2024, month 3\n", - "Processing year 2024, month 4\n", - "Processing year 2024, month 5\n", - "Processing year 2024, month 6\n", - "Processing year 2024, month 7\n", - "Processing year 2024, month 8\n", - "Processing year 2024, month 9\n", - "Processing year 2024, month 10\n", - "Processing year 2024, month 11\n", - "Processing year 2024, month 12\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Processing model: INM-CM5-0\n", - "Processing year 2024, month 1\n", - "Processing year 2024, month 2\n", - "Processing year 2024, month 3\n", - "Processing year 2024, month 4\n", - "Processing year 2024, month 5\n", - "Processing year 2024, month 6\n", - "Processing year 2024, month 7\n", - "Processing year 2024, month 8\n", - "Processing year 2024, month 9\n", - "Processing year 2024, month 10\n", - "Processing year 2024, month 11\n", - "Processing year 2024, month 12\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:110: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/106336242.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Processing file: CIL_subset_ssp585_2025.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2025, month 1\n", - "Processing year 2025, month 2\n", - "Processing year 2025, month 3\n", - "Processing year 2025, month 4\n", - "Processing year 2025, month 5\n", - "Processing year 2025, month 6\n", - "Processing year 2025, month 7\n", - "Processing year 2025, month 8\n", - "Processing year 2025, month 9\n", - "Processing year 2025, month 10\n", - "Processing year 2025, month 11\n", - "Processing year 2025, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2025, month 1\n", - "Processing year 2025, month 2\n", - "Processing year 2025, month 3\n", - "Processing year 2025, month 4\n", - "Processing year 2025, month 5\n", - "Processing year 2025, month 6\n", - "Processing year 2025, month 7\n", - "Processing year 2025, month 8\n", - "Processing year 2025, month 9\n", - "Processing year 2025, month 10\n", - "Processing year 2025, month 11\n", - "Processing year 2025, month 12\n", + "Processing file: CIL_subset_ssp126_2025.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2025, month 1\n", + "Processing year 2025, month 2\n", + "Processing year 2025, month 3\n", + "Processing year 2025, month 4\n", + "Processing year 2025, month 5\n", + "Processing year 2025, month 6\n", + "Processing year 2025, month 7\n", + "Processing year 2025, month 8\n", + "Processing year 2025, month 9\n", + "Processing year 2025, month 10\n", + "Processing year 2025, month 11\n", + "Processing year 2025, month 12\n", + "Model GFDL-CM4 not found in file CIL_subset_ssp126_2025.nc, skipping.\n", "Processing model: INM-CM5-0\n", "Processing year 2025, month 1\n", "Processing year 2025, month 2\n", @@ -8770,7 +3052,7 @@ "Processing year 2025, month 10\n", "Processing year 2025, month 11\n", "Processing year 2025, month 12\n", - "Processing file: CIL_subset_ssp585_2026.nc\n", + "Processing file: CIL_subset_ssp126_2026.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2026, month 1\n", "Processing year 2026, month 2\n", @@ -8784,19 +3066,7 @@ "Processing year 2026, month 10\n", "Processing year 2026, month 11\n", "Processing year 2026, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2026, month 1\n", - "Processing year 2026, month 2\n", - "Processing year 2026, month 3\n", - "Processing year 2026, month 4\n", - "Processing year 2026, month 5\n", - "Processing year 2026, month 6\n", - "Processing year 2026, month 7\n", - "Processing year 2026, month 8\n", - "Processing year 2026, month 9\n", - "Processing year 2026, month 10\n", - "Processing year 2026, month 11\n", - "Processing year 2026, month 12\n", + "Model GFDL-CM4 not found in file CIL_subset_ssp126_2026.nc, skipping.\n", "Processing model: INM-CM5-0\n", "Processing year 2026, month 1\n", "Processing year 2026, month 2\n", @@ -8810,7 +3080,7 @@ "Processing year 2026, month 10\n", "Processing year 2026, month 11\n", "Processing year 2026, month 12\n", - "Processing file: CIL_subset_ssp585_2027.nc\n", + "Processing file: CIL_subset_ssp126_2027.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2027, month 1\n", "Processing year 2027, month 2\n", @@ -8824,19 +3094,7 @@ "Processing year 2027, month 10\n", "Processing year 2027, month 11\n", "Processing year 2027, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2027, month 1\n", - "Processing year 2027, month 2\n", - "Processing year 2027, month 3\n", - "Processing year 2027, month 4\n", - "Processing year 2027, month 5\n", - "Processing year 2027, month 6\n", - "Processing year 2027, month 7\n", - "Processing year 2027, month 8\n", - "Processing year 2027, month 9\n", - "Processing year 2027, month 10\n", - "Processing year 2027, month 11\n", - "Processing year 2027, month 12\n", + "Model GFDL-CM4 not found in file CIL_subset_ssp126_2027.nc, skipping.\n", "Processing model: INM-CM5-0\n", "Processing year 2027, month 1\n", "Processing year 2027, month 2\n", @@ -8850,7 +3108,7 @@ "Processing year 2027, month 10\n", "Processing year 2027, month 11\n", "Processing year 2027, month 12\n", - "Processing file: CIL_subset_ssp585_2028.nc\n", + "Processing file: CIL_subset_ssp126_2028.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2028, month 1\n", "Processing year 2028, month 2\n", @@ -8864,19 +3122,7 @@ "Processing year 2028, month 10\n", "Processing year 2028, month 11\n", "Processing year 2028, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2028, month 1\n", - "Processing year 2028, month 2\n", - "Processing year 2028, month 3\n", - "Processing year 2028, month 4\n", - "Processing year 2028, month 5\n", - "Processing year 2028, month 6\n", - "Processing year 2028, month 7\n", - "Processing year 2028, month 8\n", - "Processing year 2028, month 9\n", - "Processing year 2028, month 10\n", - "Processing year 2028, month 11\n", - "Processing year 2028, month 12\n", + "Model GFDL-CM4 not found in file CIL_subset_ssp126_2028.nc, skipping.\n", "Processing model: INM-CM5-0\n", "Processing year 2028, month 1\n", "Processing year 2028, month 2\n", @@ -8890,7 +3136,7 @@ "Processing year 2028, month 10\n", "Processing year 2028, month 11\n", "Processing year 2028, month 12\n", - "Processing file: CIL_subset_ssp585_2029.nc\n", + "Processing file: CIL_subset_ssp126_2029.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2029, month 1\n", "Processing year 2029, month 2\n", @@ -8904,19 +3150,7 @@ "Processing year 2029, month 10\n", "Processing year 2029, month 11\n", "Processing year 2029, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2029, month 1\n", - "Processing year 2029, month 2\n", - "Processing year 2029, month 3\n", - "Processing year 2029, month 4\n", - "Processing year 2029, month 5\n", - "Processing year 2029, month 6\n", - "Processing year 2029, month 7\n", - "Processing year 2029, month 8\n", - "Processing year 2029, month 9\n", - "Processing year 2029, month 10\n", - "Processing year 2029, month 11\n", - "Processing year 2029, month 12\n", + "Model GFDL-CM4 not found in file CIL_subset_ssp126_2029.nc, skipping.\n", "Processing model: INM-CM5-0\n", "Processing year 2029, month 1\n", "Processing year 2029, month 2\n", @@ -8930,7 +3164,7 @@ "Processing year 2029, month 10\n", "Processing year 2029, month 11\n", "Processing year 2029, month 12\n", - "Processing file: CIL_subset_ssp585_2030.nc\n", + "Processing file: CIL_subset_ssp126_2030.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2030, month 1\n", "Processing year 2030, month 2\n", @@ -8944,19 +3178,7 @@ "Processing year 2030, month 10\n", "Processing year 2030, month 11\n", "Processing year 2030, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2030, month 1\n", - "Processing year 2030, month 2\n", - "Processing year 2030, month 3\n", - "Processing year 2030, month 4\n", - "Processing year 2030, month 5\n", - "Processing year 2030, month 6\n", - "Processing year 2030, month 7\n", - "Processing year 2030, month 8\n", - "Processing year 2030, month 9\n", - "Processing year 2030, month 10\n", - "Processing year 2030, month 11\n", - "Processing year 2030, month 12\n", + "Model GFDL-CM4 not found in file CIL_subset_ssp126_2030.nc, skipping.\n", "Processing model: INM-CM5-0\n", "Processing year 2030, month 1\n", "Processing year 2030, month 2\n", @@ -8970,7 +3192,7 @@ "Processing year 2030, month 10\n", "Processing year 2030, month 11\n", "Processing year 2030, month 12\n", - "Processing file: CIL_subset_ssp585_2031.nc\n", + "Processing file: CIL_subset_ssp126_2031.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2031, month 1\n", "Processing year 2031, month 2\n", @@ -8984,19 +3206,7 @@ "Processing year 2031, month 10\n", "Processing year 2031, month 11\n", "Processing year 2031, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2031, month 1\n", - "Processing year 2031, month 2\n", - "Processing year 2031, month 3\n", - "Processing year 2031, month 4\n", - "Processing year 2031, month 5\n", - "Processing year 2031, month 6\n", - "Processing year 2031, month 7\n", - "Processing year 2031, month 8\n", - "Processing year 2031, month 9\n", - "Processing year 2031, month 10\n", - "Processing year 2031, month 11\n", - "Processing year 2031, month 12\n", + "Model GFDL-CM4 not found in file CIL_subset_ssp126_2031.nc, skipping.\n", "Processing model: INM-CM5-0\n", "Processing year 2031, month 1\n", "Processing year 2031, month 2\n", @@ -9010,7 +3220,7 @@ "Processing year 2031, month 10\n", "Processing year 2031, month 11\n", "Processing year 2031, month 12\n", - "Processing file: CIL_subset_ssp585_2032.nc\n", + "Processing file: CIL_subset_ssp126_2032.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2032, month 1\n", "Processing year 2032, month 2\n", @@ -9024,19 +3234,7 @@ "Processing year 2032, month 10\n", "Processing year 2032, month 11\n", "Processing year 2032, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2032, month 1\n", - "Processing year 2032, month 2\n", - "Processing year 2032, month 3\n", - "Processing year 2032, month 4\n", - "Processing year 2032, month 5\n", - "Processing year 2032, month 6\n", - "Processing year 2032, month 7\n", - "Processing year 2032, month 8\n", - "Processing year 2032, month 9\n", - "Processing year 2032, month 10\n", - "Processing year 2032, month 11\n", - "Processing year 2032, month 12\n", + "Model GFDL-CM4 not found in file CIL_subset_ssp126_2032.nc, skipping.\n", "Processing model: INM-CM5-0\n", "Processing year 2032, month 1\n", "Processing year 2032, month 2\n", @@ -9050,7 +3248,7 @@ "Processing year 2032, month 10\n", "Processing year 2032, month 11\n", "Processing year 2032, month 12\n", - "Processing file: CIL_subset_ssp585_2033.nc\n", + "Processing file: CIL_subset_ssp126_2033.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2033, month 1\n", "Processing year 2033, month 2\n", @@ -9064,19 +3262,7 @@ "Processing year 2033, month 10\n", "Processing year 2033, month 11\n", "Processing year 2033, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2033, month 1\n", - "Processing year 2033, month 2\n", - "Processing year 2033, month 3\n", - "Processing year 2033, month 4\n", - "Processing year 2033, month 5\n", - "Processing year 2033, month 6\n", - "Processing year 2033, month 7\n", - "Processing year 2033, month 8\n", - "Processing year 2033, month 9\n", - "Processing year 2033, month 10\n", - "Processing year 2033, month 11\n", - "Processing year 2033, month 12\n", + "Model GFDL-CM4 not found in file CIL_subset_ssp126_2033.nc, skipping.\n", "Processing model: INM-CM5-0\n", "Processing year 2033, month 1\n", "Processing year 2033, month 2\n", @@ -9090,7 +3276,7 @@ "Processing year 2033, month 10\n", "Processing year 2033, month 11\n", "Processing year 2033, month 12\n", - "Processing file: CIL_subset_ssp585_2034.nc\n", + "Processing file: CIL_subset_ssp126_2034.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2034, month 1\n", "Processing year 2034, month 2\n", @@ -9104,19 +3290,7 @@ "Processing year 2034, month 10\n", "Processing year 2034, month 11\n", "Processing year 2034, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2034, month 1\n", - "Processing year 2034, month 2\n", - "Processing year 2034, month 3\n", - "Processing year 2034, month 4\n", - "Processing year 2034, month 5\n", - "Processing year 2034, month 6\n", - "Processing year 2034, month 7\n", - "Processing year 2034, month 8\n", - "Processing year 2034, month 9\n", - "Processing year 2034, month 10\n", - "Processing year 2034, month 11\n", - "Processing year 2034, month 12\n", + "Model GFDL-CM4 not found in file CIL_subset_ssp126_2034.nc, skipping.\n", "Processing model: INM-CM5-0\n", "Processing year 2034, month 1\n", "Processing year 2034, month 2\n", @@ -9130,7 +3304,7 @@ "Processing year 2034, month 10\n", "Processing year 2034, month 11\n", "Processing year 2034, month 12\n", - "Processing file: CIL_subset_ssp585_2035.nc\n", + "Processing file: CIL_subset_ssp126_2035.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2035, month 1\n", "Processing year 2035, month 2\n", @@ -9144,19 +3318,7 @@ "Processing year 2035, month 10\n", "Processing year 2035, month 11\n", "Processing year 2035, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2035, month 1\n", - "Processing year 2035, month 2\n", - "Processing year 2035, month 3\n", - "Processing year 2035, month 4\n", - "Processing year 2035, month 5\n", - "Processing year 2035, month 6\n", - "Processing year 2035, month 7\n", - "Processing year 2035, month 8\n", - "Processing year 2035, month 9\n", - "Processing year 2035, month 10\n", - "Processing year 2035, month 11\n", - "Processing year 2035, month 12\n", + "Model GFDL-CM4 not found in file CIL_subset_ssp126_2035.nc, skipping.\n", "Processing model: INM-CM5-0\n", "Processing year 2035, month 1\n", "Processing year 2035, month 2\n", @@ -9170,7 +3332,7 @@ "Processing year 2035, month 10\n", "Processing year 2035, month 11\n", "Processing year 2035, month 12\n", - "Processing file: CIL_subset_ssp585_2036.nc\n", + "Processing file: CIL_subset_ssp126_2036.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2036, month 1\n", "Processing year 2036, month 2\n", @@ -9184,19 +3346,7 @@ "Processing year 2036, month 10\n", "Processing year 2036, month 11\n", "Processing year 2036, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2036, month 1\n", - "Processing year 2036, month 2\n", - "Processing year 2036, month 3\n", - "Processing year 2036, month 4\n", - "Processing year 2036, month 5\n", - "Processing year 2036, month 6\n", - "Processing year 2036, month 7\n", - "Processing year 2036, month 8\n", - "Processing year 2036, month 9\n", - "Processing year 2036, month 10\n", - "Processing year 2036, month 11\n", - "Processing year 2036, month 12\n", + "Model GFDL-CM4 not found in file CIL_subset_ssp126_2036.nc, skipping.\n", "Processing model: INM-CM5-0\n", "Processing year 2036, month 1\n", "Processing year 2036, month 2\n", @@ -9210,7 +3360,7 @@ "Processing year 2036, month 10\n", "Processing year 2036, month 11\n", "Processing year 2036, month 12\n", - "Processing file: CIL_subset_ssp585_2037.nc\n", + "Processing file: CIL_subset_ssp126_2037.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2037, month 1\n", "Processing year 2037, month 2\n", @@ -9224,19 +3374,7 @@ "Processing year 2037, month 10\n", "Processing year 2037, month 11\n", "Processing year 2037, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2037, month 1\n", - "Processing year 2037, month 2\n", - "Processing year 2037, month 3\n", - "Processing year 2037, month 4\n", - "Processing year 2037, month 5\n", - "Processing year 2037, month 6\n", - "Processing year 2037, month 7\n", - "Processing year 2037, month 8\n", - "Processing year 2037, month 9\n", - "Processing year 2037, month 10\n", - "Processing year 2037, month 11\n", - "Processing year 2037, month 12\n", + "Model GFDL-CM4 not found in file CIL_subset_ssp126_2037.nc, skipping.\n", "Processing model: INM-CM5-0\n", "Processing year 2037, month 1\n", "Processing year 2037, month 2\n", @@ -9250,7 +3388,7 @@ "Processing year 2037, month 10\n", "Processing year 2037, month 11\n", "Processing year 2037, month 12\n", - "Processing file: CIL_subset_ssp585_2038.nc\n", + "Processing file: CIL_subset_ssp126_2038.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2038, month 1\n", "Processing year 2038, month 2\n", @@ -9264,19 +3402,7 @@ "Processing year 2038, month 10\n", "Processing year 2038, month 11\n", "Processing year 2038, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2038, month 1\n", - "Processing year 2038, month 2\n", - "Processing year 2038, month 3\n", - "Processing year 2038, month 4\n", - "Processing year 2038, month 5\n", - "Processing year 2038, month 6\n", - "Processing year 2038, month 7\n", - "Processing year 2038, month 8\n", - "Processing year 2038, month 9\n", - "Processing year 2038, month 10\n", - "Processing year 2038, month 11\n", - "Processing year 2038, month 12\n", + "Model GFDL-CM4 not found in file CIL_subset_ssp126_2038.nc, skipping.\n", "Processing model: INM-CM5-0\n", "Processing year 2038, month 1\n", "Processing year 2038, month 2\n", @@ -9290,7 +3416,7 @@ "Processing year 2038, month 10\n", "Processing year 2038, month 11\n", "Processing year 2038, month 12\n", - "Processing file: CIL_subset_ssp585_2039.nc\n", + "Processing file: CIL_subset_ssp126_2039.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2039, month 1\n", "Processing year 2039, month 2\n", @@ -9304,19 +3430,7 @@ "Processing year 2039, month 10\n", "Processing year 2039, month 11\n", "Processing year 2039, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2039, month 1\n", - "Processing year 2039, month 2\n", - "Processing year 2039, month 3\n", - "Processing year 2039, month 4\n", - "Processing year 2039, month 5\n", - "Processing year 2039, month 6\n", - "Processing year 2039, month 7\n", - "Processing year 2039, month 8\n", - "Processing year 2039, month 9\n", - "Processing year 2039, month 10\n", - "Processing year 2039, month 11\n", - "Processing year 2039, month 12\n", + "Model GFDL-CM4 not found in file CIL_subset_ssp126_2039.nc, skipping.\n", "Processing model: INM-CM5-0\n", "Processing year 2039, month 1\n", "Processing year 2039, month 2\n", @@ -9330,7 +3444,7 @@ "Processing year 2039, month 10\n", "Processing year 2039, month 11\n", "Processing year 2039, month 12\n", - "Processing file: CIL_subset_ssp585_2040.nc\n", + "Processing file: CIL_subset_ssp126_2040.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2040, month 1\n", "Processing year 2040, month 2\n", @@ -9344,19 +3458,7 @@ "Processing year 2040, month 10\n", "Processing year 2040, month 11\n", "Processing year 2040, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2040, month 1\n", - "Processing year 2040, month 2\n", - "Processing year 2040, month 3\n", - "Processing year 2040, month 4\n", - "Processing year 2040, month 5\n", - "Processing year 2040, month 6\n", - "Processing year 2040, month 7\n", - "Processing year 2040, month 8\n", - "Processing year 2040, month 9\n", - "Processing year 2040, month 10\n", - "Processing year 2040, month 11\n", - "Processing year 2040, month 12\n", + "Model GFDL-CM4 not found in file CIL_subset_ssp126_2040.nc, skipping.\n", "Processing model: INM-CM5-0\n", "Processing year 2040, month 1\n", "Processing year 2040, month 2\n", @@ -9370,7 +3472,7 @@ "Processing year 2040, month 10\n", "Processing year 2040, month 11\n", "Processing year 2040, month 12\n", - "Processing file: CIL_subset_ssp585_2041.nc\n", + "Processing file: CIL_subset_ssp126_2041.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2041, month 1\n", "Processing year 2041, month 2\n", @@ -9384,19 +3486,7 @@ "Processing year 2041, month 10\n", "Processing year 2041, month 11\n", "Processing year 2041, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2041, month 1\n", - "Processing year 2041, month 2\n", - "Processing year 2041, month 3\n", - "Processing year 2041, month 4\n", - "Processing year 2041, month 5\n", - "Processing year 2041, month 6\n", - "Processing year 2041, month 7\n", - "Processing year 2041, month 8\n", - "Processing year 2041, month 9\n", - "Processing year 2041, month 10\n", - "Processing year 2041, month 11\n", - "Processing year 2041, month 12\n", + "Model GFDL-CM4 not found in file CIL_subset_ssp126_2041.nc, skipping.\n", "Processing model: INM-CM5-0\n", "Processing year 2041, month 1\n", "Processing year 2041, month 2\n", @@ -9410,7 +3500,7 @@ "Processing year 2041, month 10\n", "Processing year 2041, month 11\n", "Processing year 2041, month 12\n", - "Processing file: CIL_subset_ssp585_2042.nc\n", + "Processing file: CIL_subset_ssp126_2042.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2042, month 1\n", "Processing year 2042, month 2\n", @@ -9424,19 +3514,7 @@ "Processing year 2042, month 10\n", "Processing year 2042, month 11\n", "Processing year 2042, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2042, month 1\n", - "Processing year 2042, month 2\n", - "Processing year 2042, month 3\n", - "Processing year 2042, month 4\n", - "Processing year 2042, month 5\n", - "Processing year 2042, month 6\n", - "Processing year 2042, month 7\n", - "Processing year 2042, month 8\n", - "Processing year 2042, month 9\n", - "Processing year 2042, month 10\n", - "Processing year 2042, month 11\n", - "Processing year 2042, month 12\n", + "Model GFDL-CM4 not found in file CIL_subset_ssp126_2042.nc, skipping.\n", "Processing model: INM-CM5-0\n", "Processing year 2042, month 1\n", "Processing year 2042, month 2\n", @@ -9450,7 +3528,7 @@ "Processing year 2042, month 10\n", "Processing year 2042, month 11\n", "Processing year 2042, month 12\n", - "Processing file: CIL_subset_ssp585_2043.nc\n", + "Processing file: CIL_subset_ssp126_2043.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2043, month 1\n", "Processing year 2043, month 2\n", @@ -9464,19 +3542,7 @@ "Processing year 2043, month 10\n", "Processing year 2043, month 11\n", "Processing year 2043, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2043, month 1\n", - "Processing year 2043, month 2\n", - "Processing year 2043, month 3\n", - "Processing year 2043, month 4\n", - "Processing year 2043, month 5\n", - "Processing year 2043, month 6\n", - "Processing year 2043, month 7\n", - "Processing year 2043, month 8\n", - "Processing year 2043, month 9\n", - "Processing year 2043, month 10\n", - "Processing year 2043, month 11\n", - "Processing year 2043, month 12\n", + "Model GFDL-CM4 not found in file CIL_subset_ssp126_2043.nc, skipping.\n", "Processing model: INM-CM5-0\n", "Processing year 2043, month 1\n", "Processing year 2043, month 2\n", @@ -9490,7 +3556,7 @@ "Processing year 2043, month 10\n", "Processing year 2043, month 11\n", "Processing year 2043, month 12\n", - "Processing file: CIL_subset_ssp585_2044.nc\n", + "Processing file: CIL_subset_ssp126_2044.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2044, month 1\n", "Processing year 2044, month 2\n", @@ -9504,19 +3570,7 @@ "Processing year 2044, month 10\n", "Processing year 2044, month 11\n", "Processing year 2044, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2044, month 1\n", - "Processing year 2044, month 2\n", - "Processing year 2044, month 3\n", - "Processing year 2044, month 4\n", - "Processing year 2044, month 5\n", - "Processing year 2044, month 6\n", - "Processing year 2044, month 7\n", - "Processing year 2044, month 8\n", - "Processing year 2044, month 9\n", - "Processing year 2044, month 10\n", - "Processing year 2044, month 11\n", - "Processing year 2044, month 12\n", + "Model GFDL-CM4 not found in file CIL_subset_ssp126_2044.nc, skipping.\n", "Processing model: INM-CM5-0\n", "Processing year 2044, month 1\n", "Processing year 2044, month 2\n", @@ -9530,7 +3584,7 @@ "Processing year 2044, month 10\n", "Processing year 2044, month 11\n", "Processing year 2044, month 12\n", - "Processing file: CIL_subset_ssp585_2045.nc\n", + "Processing file: CIL_subset_ssp126_2045.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2045, month 1\n", "Processing year 2045, month 2\n", @@ -9544,19 +3598,7 @@ "Processing year 2045, month 10\n", "Processing year 2045, month 11\n", "Processing year 2045, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2045, month 1\n", - "Processing year 2045, month 2\n", - "Processing year 2045, month 3\n", - "Processing year 2045, month 4\n", - "Processing year 2045, month 5\n", - "Processing year 2045, month 6\n", - "Processing year 2045, month 7\n", - "Processing year 2045, month 8\n", - "Processing year 2045, month 9\n", - "Processing year 2045, month 10\n", - "Processing year 2045, month 11\n", - "Processing year 2045, month 12\n", + "Model GFDL-CM4 not found in file CIL_subset_ssp126_2045.nc, skipping.\n", "Processing model: INM-CM5-0\n", "Processing year 2045, month 1\n", "Processing year 2045, month 2\n", @@ -9570,7 +3612,7 @@ "Processing year 2045, month 10\n", "Processing year 2045, month 11\n", "Processing year 2045, month 12\n", - "Processing file: CIL_subset_ssp585_2046.nc\n", + "Processing file: CIL_subset_ssp126_2046.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2046, month 1\n", "Processing year 2046, month 2\n", @@ -9584,19 +3626,7 @@ "Processing year 2046, month 10\n", "Processing year 2046, month 11\n", "Processing year 2046, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2046, month 1\n", - "Processing year 2046, month 2\n", - "Processing year 2046, month 3\n", - "Processing year 2046, month 4\n", - "Processing year 2046, month 5\n", - "Processing year 2046, month 6\n", - "Processing year 2046, month 7\n", - "Processing year 2046, month 8\n", - "Processing year 2046, month 9\n", - "Processing year 2046, month 10\n", - "Processing year 2046, month 11\n", - "Processing year 2046, month 12\n", + "Model GFDL-CM4 not found in file CIL_subset_ssp126_2046.nc, skipping.\n", "Processing model: INM-CM5-0\n", "Processing year 2046, month 1\n", "Processing year 2046, month 2\n", @@ -9610,7 +3640,7 @@ "Processing year 2046, month 10\n", "Processing year 2046, month 11\n", "Processing year 2046, month 12\n", - "Processing file: CIL_subset_ssp585_2047.nc\n", + "Processing file: CIL_subset_ssp126_2047.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2047, month 1\n", "Processing year 2047, month 2\n", @@ -9624,19 +3654,7 @@ "Processing year 2047, month 10\n", "Processing year 2047, month 11\n", "Processing year 2047, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2047, month 1\n", - "Processing year 2047, month 2\n", - "Processing year 2047, month 3\n", - "Processing year 2047, month 4\n", - "Processing year 2047, month 5\n", - "Processing year 2047, month 6\n", - "Processing year 2047, month 7\n", - "Processing year 2047, month 8\n", - "Processing year 2047, month 9\n", - "Processing year 2047, month 10\n", - "Processing year 2047, month 11\n", - "Processing year 2047, month 12\n", + "Model GFDL-CM4 not found in file CIL_subset_ssp126_2047.nc, skipping.\n", "Processing model: INM-CM5-0\n", "Processing year 2047, month 1\n", "Processing year 2047, month 2\n", @@ -9650,7 +3668,7 @@ "Processing year 2047, month 10\n", "Processing year 2047, month 11\n", "Processing year 2047, month 12\n", - "Processing file: CIL_subset_ssp585_2048.nc\n", + "Processing file: CIL_subset_ssp126_2048.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2048, month 1\n", "Processing year 2048, month 2\n", @@ -9664,19 +3682,7 @@ "Processing year 2048, month 10\n", "Processing year 2048, month 11\n", "Processing year 2048, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2048, month 1\n", - "Processing year 2048, month 2\n", - "Processing year 2048, month 3\n", - "Processing year 2048, month 4\n", - "Processing year 2048, month 5\n", - "Processing year 2048, month 6\n", - "Processing year 2048, month 7\n", - "Processing year 2048, month 8\n", - "Processing year 2048, month 9\n", - "Processing year 2048, month 10\n", - "Processing year 2048, month 11\n", - "Processing year 2048, month 12\n", + "Model GFDL-CM4 not found in file CIL_subset_ssp126_2048.nc, skipping.\n", "Processing model: INM-CM5-0\n", "Processing year 2048, month 1\n", "Processing year 2048, month 2\n", @@ -9690,7 +3696,7 @@ "Processing year 2048, month 10\n", "Processing year 2048, month 11\n", "Processing year 2048, month 12\n", - "Processing file: CIL_subset_ssp585_2049.nc\n", + "Processing file: CIL_subset_ssp126_2049.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2049, month 1\n", "Processing year 2049, month 2\n", @@ -9704,19 +3710,7 @@ "Processing year 2049, month 10\n", "Processing year 2049, month 11\n", "Processing year 2049, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2049, month 1\n", - "Processing year 2049, month 2\n", - "Processing year 2049, month 3\n", - "Processing year 2049, month 4\n", - "Processing year 2049, month 5\n", - "Processing year 2049, month 6\n", - "Processing year 2049, month 7\n", - "Processing year 2049, month 8\n", - "Processing year 2049, month 9\n", - "Processing year 2049, month 10\n", - "Processing year 2049, month 11\n", - "Processing year 2049, month 12\n", + "Model GFDL-CM4 not found in file CIL_subset_ssp126_2049.nc, skipping.\n", "Processing model: INM-CM5-0\n", "Processing year 2049, month 1\n", "Processing year 2049, month 2\n", @@ -9730,7 +3724,7 @@ "Processing year 2049, month 10\n", "Processing year 2049, month 11\n", "Processing year 2049, month 12\n", - "Processing file: CIL_subset_ssp585_2050.nc\n", + "Processing file: CIL_subset_ssp126_2050.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2050, month 1\n", "Processing year 2050, month 2\n", @@ -9744,19 +3738,7 @@ "Processing year 2050, month 10\n", "Processing year 2050, month 11\n", "Processing year 2050, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2050, month 1\n", - "Processing year 2050, month 2\n", - "Processing year 2050, month 3\n", - "Processing year 2050, month 4\n", - "Processing year 2050, month 5\n", - "Processing year 2050, month 6\n", - "Processing year 2050, month 7\n", - "Processing year 2050, month 8\n", - "Processing year 2050, month 9\n", - "Processing year 2050, month 10\n", - "Processing year 2050, month 11\n", - "Processing year 2050, month 12\n", + "Model GFDL-CM4 not found in file CIL_subset_ssp126_2050.nc, skipping.\n", "Processing model: INM-CM5-0\n", "Processing year 2050, month 1\n", "Processing year 2050, month 2\n", @@ -9770,7 +3752,7 @@ "Processing year 2050, month 10\n", "Processing year 2050, month 11\n", "Processing year 2050, month 12\n", - "Processing file: CIL_subset_ssp585_2051.nc\n", + "Processing file: CIL_subset_ssp126_2051.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2051, month 1\n", "Processing year 2051, month 2\n", @@ -9784,19 +3766,7 @@ "Processing year 2051, month 10\n", "Processing year 2051, month 11\n", "Processing year 2051, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2051, month 1\n", - "Processing year 2051, month 2\n", - "Processing year 2051, month 3\n", - "Processing year 2051, month 4\n", - "Processing year 2051, month 5\n", - "Processing year 2051, month 6\n", - "Processing year 2051, month 7\n", - "Processing year 2051, month 8\n", - "Processing year 2051, month 9\n", - "Processing year 2051, month 10\n", - "Processing year 2051, month 11\n", - "Processing year 2051, month 12\n", + "Model GFDL-CM4 not found in file CIL_subset_ssp126_2051.nc, skipping.\n", "Processing model: INM-CM5-0\n", "Processing year 2051, month 1\n", "Processing year 2051, month 2\n", @@ -9810,7 +3780,7 @@ "Processing year 2051, month 10\n", "Processing year 2051, month 11\n", "Processing year 2051, month 12\n", - "Processing file: CIL_subset_ssp585_2052.nc\n", + "Processing file: CIL_subset_ssp126_2052.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2052, month 1\n", "Processing year 2052, month 2\n", @@ -9824,19 +3794,7 @@ "Processing year 2052, month 10\n", "Processing year 2052, month 11\n", "Processing year 2052, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2052, month 1\n", - "Processing year 2052, month 2\n", - "Processing year 2052, month 3\n", - "Processing year 2052, month 4\n", - "Processing year 2052, month 5\n", - "Processing year 2052, month 6\n", - "Processing year 2052, month 7\n", - "Processing year 2052, month 8\n", - "Processing year 2052, month 9\n", - "Processing year 2052, month 10\n", - "Processing year 2052, month 11\n", - "Processing year 2052, month 12\n", + "Model GFDL-CM4 not found in file CIL_subset_ssp126_2052.nc, skipping.\n", "Processing model: INM-CM5-0\n", "Processing year 2052, month 1\n", "Processing year 2052, month 2\n", @@ -9850,7 +3808,7 @@ "Processing year 2052, month 10\n", "Processing year 2052, month 11\n", "Processing year 2052, month 12\n", - "Processing file: CIL_subset_ssp585_2053.nc\n", + "Processing file: CIL_subset_ssp126_2053.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2053, month 1\n", "Processing year 2053, month 2\n", @@ -9864,19 +3822,7 @@ "Processing year 2053, month 10\n", "Processing year 2053, month 11\n", "Processing year 2053, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2053, month 1\n", - "Processing year 2053, month 2\n", - "Processing year 2053, month 3\n", - "Processing year 2053, month 4\n", - "Processing year 2053, month 5\n", - "Processing year 2053, month 6\n", - "Processing year 2053, month 7\n", - "Processing year 2053, month 8\n", - "Processing year 2053, month 9\n", - "Processing year 2053, month 10\n", - "Processing year 2053, month 11\n", - "Processing year 2053, month 12\n", + "Model GFDL-CM4 not found in file CIL_subset_ssp126_2053.nc, skipping.\n", "Processing model: INM-CM5-0\n", "Processing year 2053, month 1\n", "Processing year 2053, month 2\n", @@ -9890,7 +3836,7 @@ "Processing year 2053, month 10\n", "Processing year 2053, month 11\n", "Processing year 2053, month 12\n", - "Processing file: CIL_subset_ssp585_2054.nc\n", + "Processing file: CIL_subset_ssp126_2054.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2054, month 1\n", "Processing year 2054, month 2\n", @@ -9904,19 +3850,7 @@ "Processing year 2054, month 10\n", "Processing year 2054, month 11\n", "Processing year 2054, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2054, month 1\n", - "Processing year 2054, month 2\n", - "Processing year 2054, month 3\n", - "Processing year 2054, month 4\n", - "Processing year 2054, month 5\n", - "Processing year 2054, month 6\n", - "Processing year 2054, month 7\n", - "Processing year 2054, month 8\n", - "Processing year 2054, month 9\n", - "Processing year 2054, month 10\n", - "Processing year 2054, month 11\n", - "Processing year 2054, month 12\n", + "Model GFDL-CM4 not found in file CIL_subset_ssp126_2054.nc, skipping.\n", "Processing model: INM-CM5-0\n", "Processing year 2054, month 1\n", "Processing year 2054, month 2\n", @@ -9930,7 +3864,7 @@ "Processing year 2054, month 10\n", "Processing year 2054, month 11\n", "Processing year 2054, month 12\n", - "Processing file: CIL_subset_ssp585_2055.nc\n", + "Processing file: CIL_subset_ssp126_2055.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2055, month 1\n", "Processing year 2055, month 2\n", @@ -9944,19 +3878,7 @@ "Processing year 2055, month 10\n", "Processing year 2055, month 11\n", "Processing year 2055, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2055, month 1\n", - "Processing year 2055, month 2\n", - "Processing year 2055, month 3\n", - "Processing year 2055, month 4\n", - "Processing year 2055, month 5\n", - "Processing year 2055, month 6\n", - "Processing year 2055, month 7\n", - "Processing year 2055, month 8\n", - "Processing year 2055, month 9\n", - "Processing year 2055, month 10\n", - "Processing year 2055, month 11\n", - "Processing year 2055, month 12\n", + "Model GFDL-CM4 not found in file CIL_subset_ssp126_2055.nc, skipping.\n", "Processing model: INM-CM5-0\n", "Processing year 2055, month 1\n", "Processing year 2055, month 2\n", @@ -9970,7 +3892,7 @@ "Processing year 2055, month 10\n", "Processing year 2055, month 11\n", "Processing year 2055, month 12\n", - "Processing file: CIL_subset_ssp585_2056.nc\n", + "Processing file: CIL_subset_ssp126_2056.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2056, month 1\n", "Processing year 2056, month 2\n", @@ -9984,19 +3906,7 @@ "Processing year 2056, month 10\n", "Processing year 2056, month 11\n", "Processing year 2056, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2056, month 1\n", - "Processing year 2056, month 2\n", - "Processing year 2056, month 3\n", - "Processing year 2056, month 4\n", - "Processing year 2056, month 5\n", - "Processing year 2056, month 6\n", - "Processing year 2056, month 7\n", - "Processing year 2056, month 8\n", - "Processing year 2056, month 9\n", - "Processing year 2056, month 10\n", - "Processing year 2056, month 11\n", - "Processing year 2056, month 12\n", + "Model GFDL-CM4 not found in file CIL_subset_ssp126_2056.nc, skipping.\n", "Processing model: INM-CM5-0\n", "Processing year 2056, month 1\n", "Processing year 2056, month 2\n", @@ -10010,7 +3920,7 @@ "Processing year 2056, month 10\n", "Processing year 2056, month 11\n", "Processing year 2056, month 12\n", - "Processing file: CIL_subset_ssp585_2057.nc\n", + "Processing file: CIL_subset_ssp126_2057.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2057, month 1\n", "Processing year 2057, month 2\n", @@ -10024,19 +3934,7 @@ "Processing year 2057, month 10\n", "Processing year 2057, month 11\n", "Processing year 2057, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2057, month 1\n", - "Processing year 2057, month 2\n", - "Processing year 2057, month 3\n", - "Processing year 2057, month 4\n", - "Processing year 2057, month 5\n", - "Processing year 2057, month 6\n", - "Processing year 2057, month 7\n", - "Processing year 2057, month 8\n", - "Processing year 2057, month 9\n", - "Processing year 2057, month 10\n", - "Processing year 2057, month 11\n", - "Processing year 2057, month 12\n", + "Model GFDL-CM4 not found in file CIL_subset_ssp126_2057.nc, skipping.\n", "Processing model: INM-CM5-0\n", "Processing year 2057, month 1\n", "Processing year 2057, month 2\n", @@ -10050,7 +3948,7 @@ "Processing year 2057, month 10\n", "Processing year 2057, month 11\n", "Processing year 2057, month 12\n", - "Processing file: CIL_subset_ssp585_2058.nc\n", + "Processing file: CIL_subset_ssp126_2058.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2058, month 1\n", "Processing year 2058, month 2\n", @@ -10064,19 +3962,7 @@ "Processing year 2058, month 10\n", "Processing year 2058, month 11\n", "Processing year 2058, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2058, month 1\n", - "Processing year 2058, month 2\n", - "Processing year 2058, month 3\n", - "Processing year 2058, month 4\n", - "Processing year 2058, month 5\n", - "Processing year 2058, month 6\n", - "Processing year 2058, month 7\n", - "Processing year 2058, month 8\n", - "Processing year 2058, month 9\n", - "Processing year 2058, month 10\n", - "Processing year 2058, month 11\n", - "Processing year 2058, month 12\n", + "Model GFDL-CM4 not found in file CIL_subset_ssp126_2058.nc, skipping.\n", "Processing model: INM-CM5-0\n", "Processing year 2058, month 1\n", "Processing year 2058, month 2\n", @@ -10090,7 +3976,7 @@ "Processing year 2058, month 10\n", "Processing year 2058, month 11\n", "Processing year 2058, month 12\n", - "Processing file: CIL_subset_ssp585_2059.nc\n", + "Processing file: CIL_subset_ssp126_2059.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2059, month 1\n", "Processing year 2059, month 2\n", @@ -10104,19 +3990,7 @@ "Processing year 2059, month 10\n", "Processing year 2059, month 11\n", "Processing year 2059, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2059, month 1\n", - "Processing year 2059, month 2\n", - "Processing year 2059, month 3\n", - "Processing year 2059, month 4\n", - "Processing year 2059, month 5\n", - "Processing year 2059, month 6\n", - "Processing year 2059, month 7\n", - "Processing year 2059, month 8\n", - "Processing year 2059, month 9\n", - "Processing year 2059, month 10\n", - "Processing year 2059, month 11\n", - "Processing year 2059, month 12\n", + "Model GFDL-CM4 not found in file CIL_subset_ssp126_2059.nc, skipping.\n", "Processing model: INM-CM5-0\n", "Processing year 2059, month 1\n", "Processing year 2059, month 2\n", @@ -10130,7 +4004,7 @@ "Processing year 2059, month 10\n", "Processing year 2059, month 11\n", "Processing year 2059, month 12\n", - "Processing file: CIL_subset_ssp585_2060.nc\n", + "Processing file: CIL_subset_ssp126_2060.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2060, month 1\n", "Processing year 2060, month 2\n", @@ -10144,19 +4018,7 @@ "Processing year 2060, month 10\n", "Processing year 2060, month 11\n", "Processing year 2060, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2060, month 1\n", - "Processing year 2060, month 2\n", - "Processing year 2060, month 3\n", - "Processing year 2060, month 4\n", - "Processing year 2060, month 5\n", - "Processing year 2060, month 6\n", - "Processing year 2060, month 7\n", - "Processing year 2060, month 8\n", - "Processing year 2060, month 9\n", - "Processing year 2060, month 10\n", - "Processing year 2060, month 11\n", - "Processing year 2060, month 12\n", + "Model GFDL-CM4 not found in file CIL_subset_ssp126_2060.nc, skipping.\n", "Processing model: INM-CM5-0\n", "Processing year 2060, month 1\n", "Processing year 2060, month 2\n", @@ -10169,417 +4031,28 @@ "Processing year 2060, month 9\n", "Processing year 2060, month 10\n", "Processing year 2060, month 11\n", - "Processing year 2060, month 12\n", - "Processing file: CIL_subset_ssp585_2061.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2061, month 1\n", - "Processing year 2061, month 2\n", - "Processing year 2061, month 3\n", - "Processing year 2061, month 4\n", - "Processing year 2061, month 5\n", - "Processing year 2061, month 6\n", - "Processing year 2061, month 7\n", - "Processing year 2061, month 8\n", - "Processing year 2061, month 9\n", - "Processing year 2061, month 10\n", - "Processing year 2061, month 11\n", - "Processing year 2061, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2061, month 1\n", - "Processing year 2061, month 2\n", - "Processing year 2061, month 3\n", - "Processing year 2061, month 4\n", - "Processing year 2061, month 5\n", - "Processing year 2061, month 6\n", - "Processing year 2061, month 7\n", - "Processing year 2061, month 8\n", - "Processing year 2061, month 9\n", - "Processing year 2061, month 10\n", - "Processing year 2061, month 11\n", - "Processing year 2061, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2061, month 1\n", - "Processing year 2061, month 2\n", - "Processing year 2061, month 3\n", - "Processing year 2061, month 4\n", - "Processing year 2061, month 5\n", - "Processing year 2061, month 6\n", - "Processing year 2061, month 7\n", - "Processing year 2061, month 8\n", - "Processing year 2061, month 9\n", - "Processing year 2061, month 10\n", - "Processing year 2061, month 11\n", - "Processing year 2061, month 12\n", - "Processing file: CIL_subset_ssp585_2062.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2062, month 1\n", - "Processing year 2062, month 2\n", - "Processing year 2062, month 3\n", - "Processing year 2062, month 4\n", - "Processing year 2062, month 5\n", - "Processing year 2062, month 6\n", - "Processing year 2062, month 7\n", - "Processing year 2062, month 8\n", - "Processing year 2062, month 9\n", - "Processing year 2062, month 10\n", - "Processing year 2062, month 11\n", - "Processing year 2062, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2062, month 1\n", - "Processing year 2062, month 2\n", - "Processing year 2062, month 3\n", - "Processing year 2062, month 4\n", - "Processing year 2062, month 5\n", - "Processing year 2062, month 6\n", - "Processing year 2062, month 7\n", - "Processing year 2062, month 8\n", - "Processing year 2062, month 9\n", - "Processing year 2062, month 10\n", - "Processing year 2062, month 11\n", - "Processing year 2062, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2062, month 1\n", - "Processing year 2062, month 2\n", - "Processing year 2062, month 3\n", - "Processing year 2062, month 4\n", - "Processing year 2062, month 5\n", - "Processing year 2062, month 6\n", - "Processing year 2062, month 7\n", - "Processing year 2062, month 8\n", - "Processing year 2062, month 9\n", - "Processing year 2062, month 10\n", - "Processing year 2062, month 11\n", - "Processing year 2062, month 12\n", - "Processing file: CIL_subset_ssp585_2063.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2063, month 1\n", - "Processing year 2063, month 2\n", - "Processing year 2063, month 3\n", - "Processing year 2063, month 4\n", - "Processing year 2063, month 5\n", - "Processing year 2063, month 6\n", - "Processing year 2063, month 7\n", - "Processing year 2063, month 8\n", - "Processing year 2063, month 9\n", - "Processing year 2063, month 10\n", - "Processing year 2063, month 11\n", - "Processing year 2063, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2063, month 1\n", - "Processing year 2063, month 2\n", - "Processing year 2063, month 3\n", - "Processing year 2063, month 4\n", - "Processing year 2063, month 5\n", - "Processing year 2063, month 6\n", - "Processing year 2063, month 7\n", - "Processing year 2063, month 8\n", - "Processing year 2063, month 9\n", - "Processing year 2063, month 10\n", - "Processing year 2063, month 11\n", - "Processing year 2063, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2063, month 1\n", - "Processing year 2063, month 2\n", - "Processing year 2063, month 3\n", - "Processing year 2063, month 4\n", - "Processing year 2063, month 5\n", - "Processing year 2063, month 6\n", - "Processing year 2063, month 7\n", - "Processing year 2063, month 8\n", - "Processing year 2063, month 9\n", - "Processing year 2063, month 10\n", - "Processing year 2063, month 11\n", - "Processing year 2063, month 12\n", - "Processing file: CIL_subset_ssp585_2064.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2064, month 1\n", - "Processing year 2064, month 2\n", - "Processing year 2064, month 3\n", - "Processing year 2064, month 4\n", - "Processing year 2064, month 5\n", - "Processing year 2064, month 6\n", - "Processing year 2064, month 7\n", - "Processing year 2064, month 8\n", - "Processing year 2064, month 9\n", - "Processing year 2064, month 10\n", - "Processing year 2064, month 11\n", - "Processing year 2064, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2064, month 1\n", - "Processing year 2064, month 2\n", - "Processing year 2064, month 3\n", - "Processing year 2064, month 4\n", - "Processing year 2064, month 5\n", - "Processing year 2064, month 6\n", - "Processing year 2064, month 7\n", - "Processing year 2064, month 8\n", - "Processing year 2064, month 9\n", - "Processing year 2064, month 10\n", - "Processing year 2064, month 11\n", - "Processing year 2064, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2064, month 1\n", - "Processing year 2064, month 2\n", - "Processing year 2064, month 3\n", - "Processing year 2064, month 4\n", - "Processing year 2064, month 5\n", - "Processing year 2064, month 6\n", - "Processing year 2064, month 7\n", - "Processing year 2064, month 8\n", - "Processing year 2064, month 9\n", - "Processing year 2064, month 10\n", - "Processing year 2064, month 11\n", - "Processing year 2064, month 12\n", - "Processing file: CIL_subset_ssp585_2065.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2065, month 1\n", - "Processing year 2065, month 2\n", - "Processing year 2065, month 3\n", - "Processing year 2065, month 4\n", - "Processing year 2065, month 5\n", - "Processing year 2065, month 6\n", - "Processing year 2065, month 7\n", - "Processing year 2065, month 8\n", - "Processing year 2065, month 9\n", - "Processing year 2065, month 10\n", - "Processing year 2065, month 11\n", - "Processing year 2065, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2065, month 1\n", - "Processing year 2065, month 2\n", - "Processing year 2065, month 3\n", - "Processing year 2065, month 4\n", - "Processing year 2065, month 5\n", - "Processing year 2065, month 6\n", - "Processing year 2065, month 7\n", - "Processing year 2065, month 8\n", - "Processing year 2065, month 9\n", - "Processing year 2065, month 10\n", - "Processing year 2065, month 11\n", - "Processing year 2065, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2065, month 1\n", - "Processing year 2065, month 2\n", - "Processing year 2065, month 3\n", - "Processing year 2065, month 4\n", - "Processing year 2065, month 5\n", - "Processing year 2065, month 6\n", - "Processing year 2065, month 7\n", - "Processing year 2065, month 8\n", - "Processing year 2065, month 9\n", - "Processing year 2065, month 10\n", - "Processing year 2065, month 11\n", - "Processing year 2065, month 12\n", - "Processing file: CIL_subset_ssp585_2066.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2066, month 1\n", - "Processing year 2066, month 2\n", - "Processing year 2066, month 3\n", - "Processing year 2066, month 4\n", - "Processing year 2066, month 5\n", - "Processing year 2066, month 6\n", - "Processing year 2066, month 7\n", - "Processing year 2066, month 8\n", - "Processing year 2066, month 9\n", - "Processing year 2066, month 10\n", - "Processing year 2066, month 11\n", - "Processing year 2066, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2066, month 1\n", - "Processing year 2066, month 2\n", - "Processing year 2066, month 3\n", - "Processing year 2066, month 4\n", - "Processing year 2066, month 5\n", - "Processing year 2066, month 6\n", - "Processing year 2066, month 7\n", - "Processing year 2066, month 8\n", - "Processing year 2066, month 9\n", - "Processing year 2066, month 10\n", - "Processing year 2066, month 11\n", - "Processing year 2066, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2066, month 1\n", - "Processing year 2066, month 2\n", - "Processing year 2066, month 3\n", - "Processing year 2066, month 4\n", - "Processing year 2066, month 5\n", - "Processing year 2066, month 6\n", - "Processing year 2066, month 7\n", - "Processing year 2066, month 8\n", - "Processing year 2066, month 9\n", - "Processing year 2066, month 10\n", - "Processing year 2066, month 11\n", - "Processing year 2066, month 12\n", - "Processing file: CIL_subset_ssp585_2067.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2067, month 1\n", - "Processing year 2067, month 2\n", - "Processing year 2067, month 3\n", - "Processing year 2067, month 4\n", - "Processing year 2067, month 5\n", - "Processing year 2067, month 6\n", - "Processing year 2067, month 7\n", - "Processing year 2067, month 8\n", - "Processing year 2067, month 9\n", - "Processing year 2067, month 10\n", - "Processing year 2067, month 11\n", - "Processing year 2067, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2067, month 1\n", - "Processing year 2067, month 2\n", - "Processing year 2067, month 3\n", - "Processing year 2067, month 4\n", - "Processing year 2067, month 5\n", - "Processing year 2067, month 6\n", - "Processing year 2067, month 7\n", - "Processing year 2067, month 8\n", - "Processing year 2067, month 9\n", - "Processing year 2067, month 10\n", - "Processing year 2067, month 11\n", - "Processing year 2067, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2067, month 1\n", - "Processing year 2067, month 2\n", - "Processing year 2067, month 3\n", - "Processing year 2067, month 4\n", - "Processing year 2067, month 5\n", - "Processing year 2067, month 6\n", - "Processing year 2067, month 7\n", - "Processing year 2067, month 8\n", - "Processing year 2067, month 9\n", - "Processing year 2067, month 10\n", - "Processing year 2067, month 11\n", - "Processing year 2067, month 12\n", - "Processing file: CIL_subset_ssp585_2068.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2068, month 1\n", - "Processing year 2068, month 2\n", - "Processing year 2068, month 3\n", - "Processing year 2068, month 4\n", - "Processing year 2068, month 5\n", - "Processing year 2068, month 6\n", - "Processing year 2068, month 7\n", - "Processing year 2068, month 8\n", - "Processing year 2068, month 9\n", - "Processing year 2068, month 10\n", - "Processing year 2068, month 11\n", - "Processing year 2068, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2068, month 1\n", - "Processing year 2068, month 2\n", - "Processing year 2068, month 3\n", - "Processing year 2068, month 4\n", - "Processing year 2068, month 5\n", - "Processing year 2068, month 6\n", - "Processing year 2068, month 7\n", - "Processing year 2068, month 8\n", - "Processing year 2068, month 9\n", - "Processing year 2068, month 10\n", - "Processing year 2068, month 11\n", - "Processing year 2068, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2068, month 1\n", - "Processing year 2068, month 2\n", - "Processing year 2068, month 3\n", - "Processing year 2068, month 4\n", - "Processing year 2068, month 5\n", - "Processing year 2068, month 6\n", - "Processing year 2068, month 7\n", - "Processing year 2068, month 8\n", - "Processing year 2068, month 9\n", - "Processing year 2068, month 10\n", - "Processing year 2068, month 11\n", - "Processing year 2068, month 12\n", - "Processing file: CIL_subset_ssp585_2069.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2069, month 1\n", - "Processing year 2069, month 2\n", - "Processing year 2069, month 3\n", - "Processing year 2069, month 4\n", - "Processing year 2069, month 5\n", - "Processing year 2069, month 6\n", - "Processing year 2069, month 7\n", - "Processing year 2069, month 8\n", - "Processing year 2069, month 9\n", - "Processing year 2069, month 10\n", - "Processing year 2069, month 11\n", - "Processing year 2069, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2069, month 1\n", - "Processing year 2069, month 2\n", - "Processing year 2069, month 3\n", - "Processing year 2069, month 4\n", - "Processing year 2069, month 5\n", - "Processing year 2069, month 6\n", - "Processing year 2069, month 7\n", - "Processing year 2069, month 8\n", - "Processing year 2069, month 9\n", - "Processing year 2069, month 10\n", - "Processing year 2069, month 11\n", - "Processing year 2069, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2069, month 1\n", - "Processing year 2069, month 2\n", - "Processing year 2069, month 3\n", - "Processing year 2069, month 4\n", - "Processing year 2069, month 5\n", - "Processing year 2069, month 6\n", - "Processing year 2069, month 7\n", - "Processing year 2069, month 8\n", - "Processing year 2069, month 9\n", - "Processing year 2069, month 10\n", - "Processing year 2069, month 11\n", - "Processing year 2069, month 12\n", - "Processing file: CIL_subset_ssp585_2070.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2070, month 1\n", - "Processing year 2070, month 2\n", - "Processing year 2070, month 3\n", - "Processing year 2070, month 4\n", - "Processing year 2070, month 5\n", - "Processing year 2070, month 6\n", - "Processing year 2070, month 7\n", - "Processing year 2070, month 8\n", - "Processing year 2070, month 9\n", - "Processing year 2070, month 10\n", - "Processing year 2070, month 11\n", - "Processing year 2070, month 12\n", - "Processing model: GFDL-CM4\n", - "Processing year 2070, month 1\n", - "Processing year 2070, month 2\n", - "Processing year 2070, month 3\n", - "Processing year 2070, month 4\n", - "Processing year 2070, month 5\n", - "Processing year 2070, month 6\n", - "Processing year 2070, month 7\n", - "Processing year 2070, month 8\n", - "Processing year 2070, month 9\n", - "Processing year 2070, month 10\n", - "Processing year 2070, month 11\n", - "Processing year 2070, month 12\n", - "Processing model: INM-CM5-0\n", - "Processing year 2070, month 1\n", - "Processing year 2070, month 2\n", - "Processing year 2070, month 3\n", - "Processing year 2070, month 4\n", - "Processing year 2070, month 5\n", - "Processing year 2070, month 6\n", - "Processing year 2070, month 7\n", - "Processing year 2070, month 8\n", - "Processing year 2070, month 9\n", - "Processing year 2070, month 10\n", - "Processing year 2070, month 11\n", - "Processing year 2070, month 12\n", - "Saved monthly data for lowest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/lowest_monthly_prediction_weather_by_facility.csv\n", - "Saved window data for lowest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/lowest_window_prediction_weather_by_facility.csv\n", - "Saved monthly data for median model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/median_monthly_prediction_weather_by_facility.csv\n", - "Saved window data for median model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/median_window_prediction_weather_by_facility.csv\n", - "Saved monthly data for highest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/highest_monthly_prediction_weather_by_facility.csv\n", - "Saved window data for highest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/highest_window_prediction_weather_by_facility.csv\n" + "Processing year 2060, month 12\n" + ] + }, + { + "ename": "OSError", + "evalue": "Cannot save file into a non-existent directory: '/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp126'", + "output_type": "error", + "traceback": [ + "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m", + "\u001B[0;31mOSError\u001B[0m Traceback (most recent call last)", + "Cell \u001B[0;32mIn[19], line 127\u001B[0m\n\u001B[1;32m 124\u001B[0m \u001B[38;5;28;01mfor\u001B[39;00m metric_type, df \u001B[38;5;129;01min\u001B[39;00m weather_dfs\u001B[38;5;241m.\u001B[39mitems():\n\u001B[1;32m 125\u001B[0m \u001B[38;5;66;03m# Use the category in the output file name\u001B[39;00m\n\u001B[1;32m 126\u001B[0m output_file \u001B[38;5;241m=\u001B[39m Path(scenario_directory) \u001B[38;5;241m/\u001B[39m \u001B[38;5;124mf\u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;132;01m{\u001B[39;00mcategory\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m_\u001B[39m\u001B[38;5;132;01m{\u001B[39;00mmetric_type\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m_prediction_weather_by_facility.csv\u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[0;32m--> 127\u001B[0m \u001B[43mdf\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mto_csv\u001B[49m\u001B[43m(\u001B[49m\u001B[43moutput_file\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mindex\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43;01mTrue\u001B[39;49;00m\u001B[43m)\u001B[49m\n\u001B[1;32m 128\u001B[0m \u001B[38;5;28mprint\u001B[39m(\u001B[38;5;124mf\u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mSaved \u001B[39m\u001B[38;5;132;01m{\u001B[39;00mmetric_type\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m data for \u001B[39m\u001B[38;5;132;01m{\u001B[39;00mcategory\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m model to \u001B[39m\u001B[38;5;132;01m{\u001B[39;00moutput_file\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m\"\u001B[39m)\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/pandas/util/_decorators.py:333\u001B[0m, in \u001B[0;36mdeprecate_nonkeyword_arguments..decorate..wrapper\u001B[0;34m(*args, **kwargs)\u001B[0m\n\u001B[1;32m 327\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;28mlen\u001B[39m(args) \u001B[38;5;241m>\u001B[39m num_allow_args:\n\u001B[1;32m 328\u001B[0m warnings\u001B[38;5;241m.\u001B[39mwarn(\n\u001B[1;32m 329\u001B[0m msg\u001B[38;5;241m.\u001B[39mformat(arguments\u001B[38;5;241m=\u001B[39m_format_argument_list(allow_args)),\n\u001B[1;32m 330\u001B[0m \u001B[38;5;167;01mFutureWarning\u001B[39;00m,\n\u001B[1;32m 331\u001B[0m stacklevel\u001B[38;5;241m=\u001B[39mfind_stack_level(),\n\u001B[1;32m 332\u001B[0m )\n\u001B[0;32m--> 333\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[43mfunc\u001B[49m\u001B[43m(\u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43margs\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mkwargs\u001B[49m\u001B[43m)\u001B[49m\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/pandas/core/generic.py:3967\u001B[0m, in \u001B[0;36mNDFrame.to_csv\u001B[0;34m(self, path_or_buf, sep, na_rep, float_format, columns, header, index, index_label, mode, encoding, compression, quoting, quotechar, lineterminator, chunksize, date_format, doublequote, escapechar, decimal, errors, storage_options)\u001B[0m\n\u001B[1;32m 3956\u001B[0m df \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mself\u001B[39m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(\u001B[38;5;28mself\u001B[39m, ABCDataFrame) \u001B[38;5;28;01melse\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mto_frame()\n\u001B[1;32m 3958\u001B[0m formatter \u001B[38;5;241m=\u001B[39m DataFrameFormatter(\n\u001B[1;32m 3959\u001B[0m frame\u001B[38;5;241m=\u001B[39mdf,\n\u001B[1;32m 3960\u001B[0m header\u001B[38;5;241m=\u001B[39mheader,\n\u001B[0;32m (...)\u001B[0m\n\u001B[1;32m 3964\u001B[0m decimal\u001B[38;5;241m=\u001B[39mdecimal,\n\u001B[1;32m 3965\u001B[0m )\n\u001B[0;32m-> 3967\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[43mDataFrameRenderer\u001B[49m\u001B[43m(\u001B[49m\u001B[43mformatter\u001B[49m\u001B[43m)\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mto_csv\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m 3968\u001B[0m \u001B[43m \u001B[49m\u001B[43mpath_or_buf\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 3969\u001B[0m \u001B[43m \u001B[49m\u001B[43mlineterminator\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mlineterminator\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 3970\u001B[0m \u001B[43m \u001B[49m\u001B[43msep\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43msep\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 3971\u001B[0m \u001B[43m \u001B[49m\u001B[43mencoding\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mencoding\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 3972\u001B[0m \u001B[43m \u001B[49m\u001B[43merrors\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43merrors\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 3973\u001B[0m \u001B[43m \u001B[49m\u001B[43mcompression\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mcompression\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 3974\u001B[0m \u001B[43m \u001B[49m\u001B[43mquoting\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mquoting\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 3975\u001B[0m \u001B[43m \u001B[49m\u001B[43mcolumns\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mcolumns\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 3976\u001B[0m \u001B[43m \u001B[49m\u001B[43mindex_label\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mindex_label\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 3977\u001B[0m \u001B[43m \u001B[49m\u001B[43mmode\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mmode\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 3978\u001B[0m \u001B[43m \u001B[49m\u001B[43mchunksize\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mchunksize\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 3979\u001B[0m \u001B[43m \u001B[49m\u001B[43mquotechar\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mquotechar\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 3980\u001B[0m \u001B[43m \u001B[49m\u001B[43mdate_format\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mdate_format\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 3981\u001B[0m \u001B[43m \u001B[49m\u001B[43mdoublequote\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mdoublequote\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 3982\u001B[0m \u001B[43m \u001B[49m\u001B[43mescapechar\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mescapechar\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 3983\u001B[0m \u001B[43m \u001B[49m\u001B[43mstorage_options\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mstorage_options\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 3984\u001B[0m \u001B[43m\u001B[49m\u001B[43m)\u001B[49m\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/pandas/io/formats/format.py:1014\u001B[0m, in \u001B[0;36mDataFrameRenderer.to_csv\u001B[0;34m(self, path_or_buf, encoding, sep, columns, index_label, mode, compression, quoting, quotechar, lineterminator, chunksize, date_format, doublequote, escapechar, errors, storage_options)\u001B[0m\n\u001B[1;32m 993\u001B[0m created_buffer \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;01mFalse\u001B[39;00m\n\u001B[1;32m 995\u001B[0m csv_formatter \u001B[38;5;241m=\u001B[39m CSVFormatter(\n\u001B[1;32m 996\u001B[0m path_or_buf\u001B[38;5;241m=\u001B[39mpath_or_buf,\n\u001B[1;32m 997\u001B[0m lineterminator\u001B[38;5;241m=\u001B[39mlineterminator,\n\u001B[0;32m (...)\u001B[0m\n\u001B[1;32m 1012\u001B[0m formatter\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mfmt,\n\u001B[1;32m 1013\u001B[0m )\n\u001B[0;32m-> 1014\u001B[0m \u001B[43mcsv_formatter\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43msave\u001B[49m\u001B[43m(\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 1016\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m created_buffer:\n\u001B[1;32m 1017\u001B[0m \u001B[38;5;28;01massert\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(path_or_buf, StringIO)\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/pandas/io/formats/csvs.py:251\u001B[0m, in \u001B[0;36mCSVFormatter.save\u001B[0;34m(self)\u001B[0m\n\u001B[1;32m 247\u001B[0m \u001B[38;5;250m\u001B[39m\u001B[38;5;124;03m\"\"\"\u001B[39;00m\n\u001B[1;32m 248\u001B[0m \u001B[38;5;124;03mCreate the writer & save.\u001B[39;00m\n\u001B[1;32m 249\u001B[0m \u001B[38;5;124;03m\"\"\"\u001B[39;00m\n\u001B[1;32m 250\u001B[0m \u001B[38;5;66;03m# apply compression and byte/text conversion\u001B[39;00m\n\u001B[0;32m--> 251\u001B[0m \u001B[38;5;28;01mwith\u001B[39;00m \u001B[43mget_handle\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m 252\u001B[0m \u001B[43m \u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mfilepath_or_buffer\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 253\u001B[0m \u001B[43m \u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mmode\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 254\u001B[0m \u001B[43m \u001B[49m\u001B[43mencoding\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mencoding\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 255\u001B[0m \u001B[43m \u001B[49m\u001B[43merrors\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43merrors\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 256\u001B[0m \u001B[43m \u001B[49m\u001B[43mcompression\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mcompression\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 257\u001B[0m \u001B[43m \u001B[49m\u001B[43mstorage_options\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mstorage_options\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 258\u001B[0m \u001B[43m\u001B[49m\u001B[43m)\u001B[49m \u001B[38;5;28;01mas\u001B[39;00m handles:\n\u001B[1;32m 259\u001B[0m \u001B[38;5;66;03m# Note: self.encoding is irrelevant here\u001B[39;00m\n\u001B[1;32m 260\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mwriter \u001B[38;5;241m=\u001B[39m csvlib\u001B[38;5;241m.\u001B[39mwriter(\n\u001B[1;32m 261\u001B[0m handles\u001B[38;5;241m.\u001B[39mhandle,\n\u001B[1;32m 262\u001B[0m lineterminator\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mlineterminator,\n\u001B[0;32m (...)\u001B[0m\n\u001B[1;32m 267\u001B[0m quotechar\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mquotechar,\n\u001B[1;32m 268\u001B[0m )\n\u001B[1;32m 270\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_save()\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/pandas/io/common.py:749\u001B[0m, in \u001B[0;36mget_handle\u001B[0;34m(path_or_buf, mode, encoding, compression, memory_map, is_text, errors, storage_options)\u001B[0m\n\u001B[1;32m 747\u001B[0m \u001B[38;5;66;03m# Only for write methods\u001B[39;00m\n\u001B[1;32m 748\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mr\u001B[39m\u001B[38;5;124m\"\u001B[39m \u001B[38;5;129;01mnot\u001B[39;00m \u001B[38;5;129;01min\u001B[39;00m mode \u001B[38;5;129;01mand\u001B[39;00m is_path:\n\u001B[0;32m--> 749\u001B[0m \u001B[43mcheck_parent_directory\u001B[49m\u001B[43m(\u001B[49m\u001B[38;5;28;43mstr\u001B[39;49m\u001B[43m(\u001B[49m\u001B[43mhandle\u001B[49m\u001B[43m)\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 751\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m compression:\n\u001B[1;32m 752\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m compression \u001B[38;5;241m!=\u001B[39m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mzstd\u001B[39m\u001B[38;5;124m\"\u001B[39m:\n\u001B[1;32m 753\u001B[0m \u001B[38;5;66;03m# compression libraries do not like an explicit text-mode\u001B[39;00m\n", + "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/pandas/io/common.py:616\u001B[0m, in \u001B[0;36mcheck_parent_directory\u001B[0;34m(path)\u001B[0m\n\u001B[1;32m 614\u001B[0m parent \u001B[38;5;241m=\u001B[39m Path(path)\u001B[38;5;241m.\u001B[39mparent\n\u001B[1;32m 615\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;129;01mnot\u001B[39;00m parent\u001B[38;5;241m.\u001B[39mis_dir():\n\u001B[0;32m--> 616\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m \u001B[38;5;167;01mOSError\u001B[39;00m(\u001B[38;5;124mrf\u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mCannot save file into a non-existent directory: \u001B[39m\u001B[38;5;124m'\u001B[39m\u001B[38;5;132;01m{\u001B[39;00mparent\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m'\u001B[39m\u001B[38;5;124m\"\u001B[39m)\n", + "\u001B[0;31mOSError\u001B[0m: Cannot save file into a non-existent directory: '/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp126'" ] } ], - "execution_count": 14 + "execution_count": 19 }, { "metadata": { @@ -20620,7 +14093,7 @@ } }, "cell_type": "code", - "source": "data_all_models.mean(dim=[\"lat\", \"lon\", \"time\"], skipna=True) ", + "source": "data_all_models.mean(dim=[\"lat\", \"lon\", \"time\"], skipna=True)", "id": "b49522beae4dffc8", "outputs": [ { From e39a4048dd381598868529d4e1a2f3a45cd3a91f Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 15 Jan 2025 14:36:05 +0000 Subject: [PATCH 198/291] Was using %, not proption... daft --- src/scripts/climate_change/cohort_model.py | 591 +++++++++------------ 1 file changed, 251 insertions(+), 340 deletions(-) diff --git a/src/scripts/climate_change/cohort_model.py b/src/scripts/climate_change/cohort_model.py index d34b4513ba..56d1285bef 100644 --- a/src/scripts/climate_change/cohort_model.py +++ b/src/scripts/climate_change/cohort_model.py @@ -19,7 +19,9 @@ min_year = 2025 max_year = 2061 - +scenarios = ['ssp245', 'ssp585'] +model_types = ['lowest', 'median', 'highest'] +year_range = range(min_year, max_year) ## Get birth results results_folder_to_save = Path('/Users/rem76/Desktop/Climate_change_health/Results/ANC_disruptions') results_folder_for_births = Path("/Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-09-25T110820Z") @@ -58,340 +60,248 @@ malawi_admin2['ADM2_EN'] = malawi_admin2['ADM2_EN'].replace('Mzuzu City', 'Mzuzu') malawi_admin2['ADM2_EN'] = malawi_admin2['ADM2_EN'].replace('Lilongwe City', 'Lilongwe') -difference_lat = lat_data[1] - lat_data[0] -difference_long = long_data[1] - long_data[0] - -# # Get expected disturbance from the model -scenarios = ['ssp245', 'ssp585'] -model_types = ['lowest', 'median', 'highest'] -year_range = range(min_year, max_year) -results_list = [] - -#Loop through scenarios and model types -for scenario in scenarios: - for model_type in model_types: - predictions_from_cmip = pd.read_csv( - f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' - ) - predictions_from_cmip_sum = predictions_from_cmip.groupby('Year').sum().reset_index() - predictions_from_cmip_sum['Percentage_Difference'] = ( - predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum[ - 'Predicted_No_Weather_Model']) - # Match birth results and predictions - matching_rows = min(len(births_model_subset), len(predictions_from_cmip_sum)) - multiplied_values = births_model_subset.head(matching_rows).iloc[:, 1].values * predictions_from_cmip_sum[ - 'Percentage_Difference'].head(matching_rows).values - births_model_subset['Multiplied_Values'] = multiplied_values - - # Plot the results - plt.plot(year_range, multiplied_values) - plt.ylabel("Change ANC cases due to weather") - plt.axhline(y=0, color='black', linestyle='--') - plt.plot(year_range, predictions_from_cmip_sum.iloc[0:36, -1] * 100) - plt.xlabel("Percentage Change in ANC cases due to weather") - plt.axhline(y=0, color='black', linestyle='--') - plt.ylim(-12000,0) - # Check for negative values (missed cases?) - negative_sum = np.sum(multiplied_values[multiplied_values < 0]) - - result_df = pd.DataFrame({ - "Scenario": [scenario], - "Model_Type": [model_type], - "Negative_Sum": [negative_sum], - "Negative_Percentage": [negative_sum / births_model_subset['Model_mean'].sum() * 100] - }) - - results_list.append(result_df) - # Plot by zone - predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'Zone']).sum().reset_index() - plt.figure(figsize=(10, 6)) - for zone in predictions_from_cmip_sum['Zone'].unique(): - zone_data = predictions_from_cmip_sum[predictions_from_cmip_sum['Zone'] == zone] - zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data[ - 'Predicted_No_Weather_Model']) * 100 - plt.plot(zone_data['Year'], zone_data['Percentage_Difference'], label=f'Zone {zone}') - plt.xlabel("Year") - plt.ylabel("Change ANC cases due to weather") - plt.axhline(y=0, color='black', linestyle='--') - plt.ylim(-1.5, 0) - plt.legend(title='Zones') - - # Plot by district - predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'District']).sum().reset_index() - plt.figure(figsize=(10, 6)) - for district in predictions_from_cmip_sum['District'].unique(): - district_data = predictions_from_cmip_sum[predictions_from_cmip_sum['District'] == district] - district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data[ - 'Predicted_No_Weather_Model']) * 100 - plt.plot(district_data['Year'], district_data['Percentage_Difference'], label=f'{district}') - plt.xlabel("Year") - plt.ylabel("Change ANC cases due to weather") - plt.axhline(y=0, color='black', linestyle='--') - plt.ylim(-2.5, 0) - plt.legend(title='Districts') - - # Generate district map visualization - predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( - {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"}) - polygons = [ - Polygon( - [(x, y), (x + difference_long, y), (x + difference_long, y + difference_lat), (x, y + difference_lat)]) - for x in long_data for y in lat_data - ] - grid = gpd.GeoDataFrame({'geometry': polygons}, crs=malawi.crs) - grid_clipped_ADM2 = gpd.overlay(grid, malawi_admin2, how='intersection') - predictions_from_cmip_sum['Percentage_Difference'] = (predictions_from_cmip_sum['Difference_in_Expectation'] / - predictions_from_cmip_sum[ - 'Predicted_No_Weather_Model']) * 100 - percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() - malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) - malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 - - # Plot map - fig, ax = plt.subplots(figsize=(12, 12)) - #malawi_admin2.plot(ax=ax, edgecolor='white', color='white') - malawi_admin2.dropna(subset=['Percentage_Difference']).plot( - ax=ax, - column='Percentage_Difference', - cmap='Blues_r', - edgecolor='black', - alpha=1, - legend=False - ) - sm = plt.cm.ScalarMappable(cmap='Blues_r', - norm=mcolors.Normalize(vmin=malawi_admin2['Percentage_Difference'].min(), - vmax=malawi_admin2['Percentage_Difference'].max())) - sm.set_array([]) - cbar = plt.colorbar(sm, ax=ax, orientation="vertical", shrink=0.7) - cbar.set_label("Percentage Difference (%)", fontsize=12) - plt.xlabel("Longitude", fontsize=14) - plt.ylabel("Latitude", fontsize=14) - plt.title(f"{scenario}: {model_type}", fontsize=16) - plt.tight_layout() - plt.savefig(results_folder_to_save / f'{scenario}_{model_type}_map_Malawi_cumulative_difference.png') - # Save multiplied values by model and scenario - multiplied_values_df = pd.DataFrame({ - 'Year': year_range[:matching_rows], - 'Scenario': scenario, - 'Model_Type': model_type, - 'Multiplied_Values': multiplied_values - }) - multiplied_values_df.to_csv(results_folder_to_save/f'multiplied_values_{scenario}_{model_type}.csv', index=False) - -final_results = pd.concat(results_list, ignore_index=True) -final_results.to_csv('/Users/rem76/Desktop/Climate_change_health/Results/ANC_disruptions/negative_sums_and_percentages.csv', index=False) - -# Get unique districts from both sources -adm2_districts = set(grid_clipped_ADM2['ADM2_EN'].unique()) -prediction_districts = set(predictions_from_cmip_sum['District'].unique()) - -# Districts in ADM2 but not in predictions -missing_in_predictions = adm2_districts - prediction_districts -print("Districts in ADM2 but not in predictions:", missing_in_predictions) - -# Districts in predictions but not in ADM2 -missing_in_adm2 = prediction_districts - adm2_districts -print("Districts in predictions but not in ADM2:", missing_in_adm2) - - - - -## now all grids -fig, axes = plt.subplots(2, 3, figsize=(18, 12), constrained_layout=True) - -global_min = float('inf') -global_max = float('-inf') - -for scenario in scenarios: - for model_type in model_types: - predictions_from_cmip = pd.read_csv( - f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' - ) - predictions_from_cmip_sum = predictions_from_cmip.groupby('District').sum().reset_index() - predictions_from_cmip_sum['Percentage_Difference'] = ( - predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model'] - ) * 100 - - predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( - {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} - ) - percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() - malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) - malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 - - local_min = malawi_admin2['Percentage_Difference'].min() - local_max = malawi_admin2['Percentage_Difference'].max() - global_min = min(global_min, local_min) - global_max = max(global_max, local_max) - -for i, scenario in enumerate(scenarios): - for j, model_type in enumerate(model_types): - predictions_from_cmip = pd.read_csv( - f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' - ) - predictions_from_cmip_sum = predictions_from_cmip.groupby('District').sum().reset_index() - predictions_from_cmip_sum['Percentage_Difference'] = ( - predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model'] - ) * 100 - - predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( - {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} - ) - percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() - print(percentage_diff_by_district) - malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) - malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 - - ax = axes[i, j] - malawi_admin2.dropna(subset=['Percentage_Difference']).plot( - ax=ax, - column='Percentage_Difference', - cmap='Blues_r', - edgecolor='black', - alpha=1, - legend=False, - vmin=global_min, - vmax=global_max - ) - - ax.set_title(f"{scenario}: {model_type}", fontsize=14) - - if i != 1: - ax.set_xlabel("") - if j != 0: - ax.set_ylabel("") - else: - ax.set_ylabel("Latitude", fontsize=10) - - if i == 1: - ax.set_xlabel("Longitude", fontsize=10) - -sm = plt.cm.ScalarMappable( - cmap='Blues_r', - norm=mcolors.Normalize(vmin=global_min, vmax=global_max) -) -sm.set_array([]) -fig.colorbar(sm, ax=axes, orientation="vertical", shrink=0.8, label="Percentage Difference (%)") -plt.suptitle("Percentage Difference Maps by Scenario and Model Type", fontsize=16, y=1.02) -# plt.savefig(results_folder_to_save / 'percentage_difference_maps_grid.png') -plt.show() - -## By district -fig, axes = plt.subplots(2, 3, figsize=(18, 12), constrained_layout=True) -population_file = "/Users/rem76/PycharmProjects/TLOmodel/resources/demography/ResourceFile_PopulationSize_2018Census.csv" -population_data = pd.read_csv(population_file) - -population_data_grouped = population_data.groupby("District")["Count"].sum() -total_population = population_data_grouped.sum() -population_percentage = population_data_grouped / total_population -# Initialize variables to track global min/max for color normalization -global_min = float('inf') -global_max = float('-inf') -# -percentage_diff_by_year_district = {} -# Loop over scenarios and model types to process the data -for scenario in scenarios: - for model_type in model_types: - predictions_from_cmip = pd.read_csv( - f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' - ) - - predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'District']).sum().reset_index() - predictions_from_cmip_sum['Percentage_Difference'] = ( - predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model'] - ) * 100 - predictions_from_cmip_sum.loc[predictions_from_cmip_sum['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 - predictions_from_cmip_sum = predictions_from_cmip_sum[predictions_from_cmip_sum['Year'] <= 2060] - - predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( - {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} - ) - - # Collect percentage differences by year and district - percentage_diff_by_year_district = {} - - for year, year_data in predictions_from_cmip_sum.groupby('Year'): - - if year not in percentage_diff_by_year_district: - percentage_diff_by_year_district[year] = {} - for _, row in year_data.iterrows(): - district = row['District'] - percentage_diff = row['Percentage_Difference'] - row_index = births_model.index.get_loc(year) - number_of_births = population_percentage[district] * births_model.iloc[row_index][ - "Model_mean"] - if district not in percentage_diff_by_year_district[year]: - percentage_diff_by_year_district[year][district] = 0 - percentage_diff_by_year_district[year][district] += percentage_diff * 1 - - # Prepare data for plotting - data_for_plot = pd.DataFrame.from_dict(percentage_diff_by_year_district, orient='index').fillna(0) - - # Plot on corresponding subplot - ax = axes[scenarios.index(scenario), model_types.index(model_type)] - data_for_plot.plot(kind='bar', stacked=True, ax=ax, cmap='tab20', legend = False) - - ax.set_title(f"{scenario}: {model_type}", fontsize=14) - ax.set_xlabel('Year', fontsize=12) - ax.set_ylabel('Percentage Difference (%)', fontsize=12) - ax.legend() - # Update global min/max for color scaling - local_min = data_for_plot.min().min() - local_max = data_for_plot.max().max() - global_min = min(global_min, local_min) - global_max = max(global_max, local_max) - -# Adjust the overall layout -plt.suptitle("Percentage Difference by Year and District", fontsize=16, y=1.02) -#plt.savefig(results_folder_to_save / 'percentage_difference_by_year_district_grid.png') -plt.show() - -# Calculate the average percentage difference over all years for each district -average_percentage_diff_by_district = {} - -for year, year_data in percentage_diff_by_year_district.items(): - for district, total_percentage_diff in year_data.items(): - if district not in average_percentage_diff_by_district: - average_percentage_diff_by_district[district] = {'total_diff': 0, 'count': 0} - average_percentage_diff_by_district[district]['total_diff'] += total_percentage_diff - average_percentage_diff_by_district[district]['count'] += 1 - -# Calculate averages -for district, values in average_percentage_diff_by_district.items(): - values['average_diff'] = values['total_diff'] / values['count'] - -# Convert to a DataFrame for easy plotting or reporting -average_percentage_diff_df = pd.DataFrame.from_dict(average_percentage_diff_by_district, orient='index') -average_percentage_diff_df = average_percentage_diff_df[['average_diff']] - -# Print or plot the average percentage differences -print("average_percentage_diff_df", average_percentage_diff_df) - -all_districts = set() -significant_results_year = [] +# difference_lat = lat_data[1] - lat_data[0] +# difference_long = long_data[1] - long_data[0] # -# Assuming 'district' is a column in your data -for scenario in scenarios: - for model_type in model_types: - predictions_from_cmip = pd.read_csv( - f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' - ) - predictions_from_cmip_sum = predictions_from_cmip.groupby(['District', 'Year']).sum().reset_index() - for district in predictions_from_cmip_sum['District'].unique(): - district_values = predictions_from_cmip_sum[predictions_from_cmip_sum['District'] == district] - no_weather_model = district_values['Predicted_No_Weather_Model'].values - weather_model = district_values['Predicted_Weather_Model'].values - - # Calculate the difference - difference = no_weather_model - weather_model +# # # Get expected disturbance from the model - # Perform a one-sample t-test assuming 0 as the null hypothesis mean - t_stat, p_value = ttest_1samp(difference, popmean=0) - # Print results if p-value is below 0.05 (statistically significant) - if p_value < 0.05: - print(f"Scenario: {scenario}, Model Type: {model_type}, District: {district}, " - f"t-stat: {t_stat:.2f}, p-value: {p_value:.4f}") -## now all grids +# results_list = [] +# +# #Loop through scenarios and model types +# for scenario in scenarios: +# for model_type in model_types: +# predictions_from_cmip = pd.read_csv( +# f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' +# ) +# predictions_from_cmip_sum = predictions_from_cmip.groupby('Year').sum().reset_index() +# predictions_from_cmip_sum['Percentage_Difference'] = ( +# predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum[ +# 'Predicted_No_Weather_Model']) +# # Match birth results and predictions +# matching_rows = min(len(births_model_subset), len(predictions_from_cmip_sum)) +# multiplied_values = births_model_subset.head(matching_rows).iloc[:, 1].values * predictions_from_cmip_sum[ +# 'Percentage_Difference'].head(matching_rows).values +# births_model_subset['Multiplied_Values'] = multiplied_values +# +# # Plot the results +# plt.plot(year_range, multiplied_values) +# plt.ylabel("Change ANC cases due to weather") +# plt.axhline(y=0, color='black', linestyle='--') +# plt.plot(year_range, predictions_from_cmip_sum.iloc[0:36, -1] * 100) +# plt.xlabel("Percentage Change in ANC cases due to weather") +# plt.axhline(y=0, color='black', linestyle='--') +# plt.ylim(-12000,0) +# # Check for negative values (missed cases?) +# negative_sum = np.sum(multiplied_values[multiplied_values < 0]) +# +# result_df = pd.DataFrame({ +# "Scenario": [scenario], +# "Model_Type": [model_type], +# "Negative_Sum": [negative_sum], +# "Negative_Percentage": [negative_sum / births_model_subset['Model_mean'].sum() * 100] +# }) +# +# results_list.append(result_df) +# # Plot by zone +# predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'Zone']).sum().reset_index() +# plt.figure(figsize=(10, 6)) +# for zone in predictions_from_cmip_sum['Zone'].unique(): +# zone_data = predictions_from_cmip_sum[predictions_from_cmip_sum['Zone'] == zone] +# zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data[ +# 'Predicted_No_Weather_Model']) * 100 +# plt.plot(zone_data['Year'], zone_data['Percentage_Difference'], label=f'Zone {zone}') +# plt.xlabel("Year") +# plt.ylabel("Change ANC cases due to weather") +# plt.axhline(y=0, color='black', linestyle='--') +# plt.ylim(-1.5, 0) +# plt.legend(title='Zones') +# +# # Plot by district +# predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'District']).sum().reset_index() +# plt.figure(figsize=(10, 6)) +# for district in predictions_from_cmip_sum['District'].unique(): +# district_data = predictions_from_cmip_sum[predictions_from_cmip_sum['District'] == district] +# district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data[ +# 'Predicted_No_Weather_Model']) * 100 +# plt.plot(district_data['Year'], district_data['Percentage_Difference'], label=f'{district}') +# plt.xlabel("Year") +# plt.ylabel("Change ANC cases due to weather") +# plt.axhline(y=0, color='black', linestyle='--') +# plt.ylim(-2.5, 0) +# plt.legend(title='Districts') +# +# # Generate district map visualization +# predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( +# {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"}) +# polygons = [ +# Polygon( +# [(x, y), (x + difference_long, y), (x + difference_long, y + difference_lat), (x, y + difference_lat)]) +# for x in long_data for y in lat_data +# ] +# grid = gpd.GeoDataFrame({'geometry': polygons}, crs=malawi.crs) +# grid_clipped_ADM2 = gpd.overlay(grid, malawi_admin2, how='intersection') +# predictions_from_cmip_sum['Percentage_Difference'] = (predictions_from_cmip_sum['Difference_in_Expectation'] / +# predictions_from_cmip_sum[ +# 'Predicted_No_Weather_Model']) * 100 +# percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() +# malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) +# malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 +# +# # Plot map +# fig, ax = plt.subplots(figsize=(12, 12)) +# #malawi_admin2.plot(ax=ax, edgecolor='white', color='white') +# malawi_admin2.dropna(subset=['Percentage_Difference']).plot( +# ax=ax, +# column='Percentage_Difference', +# cmap='Blues_r', +# edgecolor='black', +# alpha=1, +# legend=False +# ) +# sm = plt.cm.ScalarMappable(cmap='Blues_r', +# norm=mcolors.Normalize(vmin=malawi_admin2['Percentage_Difference'].min(), +# vmax=malawi_admin2['Percentage_Difference'].max())) +# sm.set_array([]) +# cbar = plt.colorbar(sm, ax=ax, orientation="vertical", shrink=0.7) +# cbar.set_label("Percentage Difference (%)", fontsize=12) +# plt.xlabel("Longitude", fontsize=14) +# plt.ylabel("Latitude", fontsize=14) +# plt.title(f"{scenario}: {model_type}", fontsize=16) +# plt.tight_layout() +# plt.savefig(results_folder_to_save / f'{scenario}_{model_type}_map_Malawi_cumulative_difference.png') +# # Save multiplied values by model and scenario +# multiplied_values_df = pd.DataFrame({ +# 'Year': year_range[:matching_rows], +# 'Scenario': scenario, +# 'Model_Type': model_type, +# 'Multiplied_Values': multiplied_values +# }) +# multiplied_values_df.to_csv(results_folder_to_save/f'multiplied_values_{scenario}_{model_type}.csv', index=False) +# +# final_results = pd.concat(results_list, ignore_index=True) +# final_results.to_csv('/Users/rem76/Desktop/Climate_change_health/Results/ANC_disruptions/negative_sums_and_percentages.csv', index=False) +# +# # Get unique districts from both sources +# adm2_districts = set(grid_clipped_ADM2['ADM2_EN'].unique()) +# prediction_districts = set(predictions_from_cmip_sum['District'].unique()) +# +# # Districts in ADM2 but not in predictions +# missing_in_predictions = adm2_districts - prediction_districts +# print("Districts in ADM2 but not in predictions:", missing_in_predictions) +# +# # Districts in predictions but not in ADM2 +# missing_in_adm2 = prediction_districts - adm2_districts +# print("Districts in predictions but not in ADM2:", missing_in_adm2) +# +# +# +# +# ## now all grids +# fig, axes = plt.subplots(2, 3, figsize=(18, 12), constrained_layout=True) +# +# global_min = float('inf') +# global_max = float('-inf') +# +# for scenario in scenarios: +# for model_type in model_types: +# predictions_from_cmip = pd.read_csv( +# f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' +# ) +# predictions_from_cmip_sum = predictions_from_cmip.groupby('District').sum().reset_index() +# predictions_from_cmip_sum['Percentage_Difference'] = ( +# predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model'] +# ) * 100 +# +# predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( +# {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} +# ) +# percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() +# malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) +# malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 +# +# local_min = malawi_admin2['Percentage_Difference'].min() +# local_max = malawi_admin2['Percentage_Difference'].max() +# global_min = min(global_min, local_min) +# global_max = max(global_max, local_max) +# +# for i, scenario in enumerate(scenarios): +# for j, model_type in enumerate(model_types): +# predictions_from_cmip = pd.read_csv( +# f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' +# ) +# predictions_from_cmip_sum = predictions_from_cmip.groupby('District').sum().reset_index() +# predictions_from_cmip_sum['Percentage_Difference'] = ( +# predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model'] +# ) * 100 +# +# predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( +# {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} +# ) +# percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() +# print(percentage_diff_by_district) +# malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) +# malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 +# +# ax = axes[i, j] +# malawi_admin2.dropna(subset=['Percentage_Difference']).plot( +# ax=ax, +# column='Percentage_Difference', +# cmap='Blues_r', +# edgecolor='black', +# alpha=1, +# legend=False, +# vmin=global_min, +# vmax=global_max +# ) +# +# ax.set_title(f"{scenario}: {model_type}", fontsize=14) +# +# if i != 1: +# ax.set_xlabel("") +# if j != 0: +# ax.set_ylabel("") +# else: +# ax.set_ylabel("Latitude", fontsize=10) +# +# if i == 1: +# ax.set_xlabel("Longitude", fontsize=10) +# +# sm = plt.cm.ScalarMappable( +# cmap='Blues_r', +# norm=mcolors.Normalize(vmin=global_min, vmax=global_max) +# ) +# sm.set_array([]) +# fig.colorbar(sm, ax=axes, orientation="vertical", shrink=0.8, label="Percentage Difference (%)") +# plt.suptitle("Percentage Difference Maps by Scenario and Model Type", fontsize=16, y=1.02) +# # plt.savefig(results_folder_to_save / 'percentage_difference_maps_grid.png') +# plt.show() +# +# +# +# significant_results_year = [] +# # +# # Assuming 'district' is a column in your data +# for scenario in scenarios: +# for model_type in model_types: +# predictions_from_cmip = pd.read_csv( +# f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' +# ) +# predictions_from_cmip_sum = predictions_from_cmip.groupby(['District', 'Year']).sum().reset_index() +# for district in predictions_from_cmip_sum['District'].unique(): +# district_values = predictions_from_cmip_sum[predictions_from_cmip_sum['District'] == district] +# no_weather_model = district_values['Predicted_No_Weather_Model'].values +# weather_model = district_values['Predicted_Weather_Model'].values +# +# # Calculate the difference +# difference = no_weather_model - weather_model +# +# # Perform a one-sample t-test assuming 0 as the null hypothesis mean +# t_stat, p_value = ttest_1samp(difference, popmean=0) +# # Print results if p-value is below 0.05 (statistically significant) +# if p_value < 0.05: +# print(f"Scenario: {scenario}, Model Type: {model_type}, District: {district}, " +# f"t-stat: {t_stat:.2f}, p-value: {p_value:.4f}") +# ## now all grids #### Now do number of births based on the TLO model and 2018 census population_file = "/Users/rem76/PycharmProjects/TLOmodel/resources/demography/ResourceFile_PopulationSize_2018Census.csv" @@ -399,11 +309,11 @@ population_data_grouped = population_data.groupby("District")["Count"].sum() total_population = population_data_grouped.sum() -population_percentage = population_data_grouped / total_population +population_proportion = population_data_grouped / total_population # Create the figure and axes grid fig, axes = plt.subplots(2, 3, figsize=(18, 12), constrained_layout=True) - +print(births_model_subset) y_min = float('inf') y_max = float('-inf') year_groupings = range(2025, 2060, 5) @@ -421,7 +331,7 @@ predictions_from_cmip_sum[ 'Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model'] - ) * 100 + ) predictions_from_cmip_sum.loc[ predictions_from_cmip_sum['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( @@ -436,9 +346,11 @@ for _, row in subset.iterrows(): district = row['District'] percentage_diff = row['Percentage_Difference'] + #print(percentage_diff) row_index = births_model_subset.index.get_loc(year) - number_of_births = population_percentage[district] * births_model_subset.iloc[row_index]["Model_mean"] - number_of_births = number_of_births/5 # was for the whole period, but doing year by year + + number_of_births = population_proportion[district] * births_model_subset.iloc[row_index]["Model_mean"] + #print(percentage_diff * number_of_births) if year not in percentage_diff_by_year_district: percentage_diff_by_year_district[year] = {} if district not in percentage_diff_by_year_district[year]: @@ -502,8 +414,7 @@ district = row['District'] row_index = births_model_subset.index.get_loc(year) - number_of_births = population_percentage[district] * births_model.iloc[row_index]["Model_mean"] - number_of_births = number_of_births/5 # was for the whole period, but doing year by year + number_of_births = population_proportion[district] * births_model.iloc[row_index]["Model_mean"] if year not in percentage_diff_by_year_district: percentage_diff_by_year_district[year] = {} if district not in percentage_diff_by_year_district[year]: From f7a70442202bdd2e3407f8fb281f2140b599e1dc Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 15 Jan 2025 14:46:14 +0000 Subject: [PATCH 199/291] Identical --- .../CIL_CMIP6_downscaling.ipynb | 20007 ++++++++-------- 1 file changed, 9998 insertions(+), 10009 deletions(-) diff --git a/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb b/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb index 1c9b0e507e..c82ab114a1 100644 --- a/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb +++ b/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb @@ -948,8 +948,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-15T14:20:45.961332Z", - "start_time": "2025-01-15T14:15:40.892618Z" + "end_time": "2025-01-15T14:43:54.621320Z", + "start_time": "2025-01-15T14:37:49.608103Z" } }, "cell_type": "code", @@ -4031,34 +4031,23 @@ "Processing year 2060, month 9\n", "Processing year 2060, month 10\n", "Processing year 2060, month 11\n", - "Processing year 2060, month 12\n" - ] - }, - { - "ename": "OSError", - "evalue": "Cannot save file into a non-existent directory: '/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp126'", - "output_type": "error", - "traceback": [ - "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m", - "\u001B[0;31mOSError\u001B[0m Traceback (most recent call last)", - "Cell \u001B[0;32mIn[19], line 127\u001B[0m\n\u001B[1;32m 124\u001B[0m \u001B[38;5;28;01mfor\u001B[39;00m metric_type, df \u001B[38;5;129;01min\u001B[39;00m weather_dfs\u001B[38;5;241m.\u001B[39mitems():\n\u001B[1;32m 125\u001B[0m \u001B[38;5;66;03m# Use the category in the output file name\u001B[39;00m\n\u001B[1;32m 126\u001B[0m output_file \u001B[38;5;241m=\u001B[39m Path(scenario_directory) \u001B[38;5;241m/\u001B[39m \u001B[38;5;124mf\u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;132;01m{\u001B[39;00mcategory\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m_\u001B[39m\u001B[38;5;132;01m{\u001B[39;00mmetric_type\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m_prediction_weather_by_facility.csv\u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[0;32m--> 127\u001B[0m \u001B[43mdf\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mto_csv\u001B[49m\u001B[43m(\u001B[49m\u001B[43moutput_file\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mindex\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43;01mTrue\u001B[39;49;00m\u001B[43m)\u001B[49m\n\u001B[1;32m 128\u001B[0m \u001B[38;5;28mprint\u001B[39m(\u001B[38;5;124mf\u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mSaved \u001B[39m\u001B[38;5;132;01m{\u001B[39;00mmetric_type\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m data for \u001B[39m\u001B[38;5;132;01m{\u001B[39;00mcategory\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m model to \u001B[39m\u001B[38;5;132;01m{\u001B[39;00moutput_file\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m\"\u001B[39m)\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/pandas/util/_decorators.py:333\u001B[0m, in \u001B[0;36mdeprecate_nonkeyword_arguments..decorate..wrapper\u001B[0;34m(*args, **kwargs)\u001B[0m\n\u001B[1;32m 327\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;28mlen\u001B[39m(args) \u001B[38;5;241m>\u001B[39m num_allow_args:\n\u001B[1;32m 328\u001B[0m warnings\u001B[38;5;241m.\u001B[39mwarn(\n\u001B[1;32m 329\u001B[0m msg\u001B[38;5;241m.\u001B[39mformat(arguments\u001B[38;5;241m=\u001B[39m_format_argument_list(allow_args)),\n\u001B[1;32m 330\u001B[0m \u001B[38;5;167;01mFutureWarning\u001B[39;00m,\n\u001B[1;32m 331\u001B[0m stacklevel\u001B[38;5;241m=\u001B[39mfind_stack_level(),\n\u001B[1;32m 332\u001B[0m )\n\u001B[0;32m--> 333\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[43mfunc\u001B[49m\u001B[43m(\u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43margs\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mkwargs\u001B[49m\u001B[43m)\u001B[49m\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/pandas/core/generic.py:3967\u001B[0m, in \u001B[0;36mNDFrame.to_csv\u001B[0;34m(self, path_or_buf, sep, na_rep, float_format, columns, header, index, index_label, mode, encoding, compression, quoting, quotechar, lineterminator, chunksize, date_format, doublequote, escapechar, decimal, errors, storage_options)\u001B[0m\n\u001B[1;32m 3956\u001B[0m df \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mself\u001B[39m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(\u001B[38;5;28mself\u001B[39m, ABCDataFrame) \u001B[38;5;28;01melse\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mto_frame()\n\u001B[1;32m 3958\u001B[0m formatter \u001B[38;5;241m=\u001B[39m DataFrameFormatter(\n\u001B[1;32m 3959\u001B[0m frame\u001B[38;5;241m=\u001B[39mdf,\n\u001B[1;32m 3960\u001B[0m header\u001B[38;5;241m=\u001B[39mheader,\n\u001B[0;32m (...)\u001B[0m\n\u001B[1;32m 3964\u001B[0m decimal\u001B[38;5;241m=\u001B[39mdecimal,\n\u001B[1;32m 3965\u001B[0m )\n\u001B[0;32m-> 3967\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[43mDataFrameRenderer\u001B[49m\u001B[43m(\u001B[49m\u001B[43mformatter\u001B[49m\u001B[43m)\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mto_csv\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m 3968\u001B[0m \u001B[43m \u001B[49m\u001B[43mpath_or_buf\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 3969\u001B[0m \u001B[43m \u001B[49m\u001B[43mlineterminator\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mlineterminator\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 3970\u001B[0m \u001B[43m \u001B[49m\u001B[43msep\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43msep\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 3971\u001B[0m \u001B[43m \u001B[49m\u001B[43mencoding\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mencoding\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 3972\u001B[0m \u001B[43m \u001B[49m\u001B[43merrors\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43merrors\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 3973\u001B[0m \u001B[43m \u001B[49m\u001B[43mcompression\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mcompression\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 3974\u001B[0m \u001B[43m \u001B[49m\u001B[43mquoting\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mquoting\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 3975\u001B[0m \u001B[43m \u001B[49m\u001B[43mcolumns\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mcolumns\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 3976\u001B[0m \u001B[43m \u001B[49m\u001B[43mindex_label\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mindex_label\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 3977\u001B[0m \u001B[43m \u001B[49m\u001B[43mmode\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mmode\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 3978\u001B[0m \u001B[43m \u001B[49m\u001B[43mchunksize\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mchunksize\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 3979\u001B[0m \u001B[43m \u001B[49m\u001B[43mquotechar\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mquotechar\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 3980\u001B[0m \u001B[43m \u001B[49m\u001B[43mdate_format\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mdate_format\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 3981\u001B[0m \u001B[43m \u001B[49m\u001B[43mdoublequote\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mdoublequote\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 3982\u001B[0m \u001B[43m \u001B[49m\u001B[43mescapechar\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mescapechar\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 3983\u001B[0m \u001B[43m \u001B[49m\u001B[43mstorage_options\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mstorage_options\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 3984\u001B[0m \u001B[43m\u001B[49m\u001B[43m)\u001B[49m\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/pandas/io/formats/format.py:1014\u001B[0m, in \u001B[0;36mDataFrameRenderer.to_csv\u001B[0;34m(self, path_or_buf, encoding, sep, columns, index_label, mode, compression, quoting, quotechar, lineterminator, chunksize, date_format, doublequote, escapechar, errors, storage_options)\u001B[0m\n\u001B[1;32m 993\u001B[0m created_buffer \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;01mFalse\u001B[39;00m\n\u001B[1;32m 995\u001B[0m csv_formatter \u001B[38;5;241m=\u001B[39m CSVFormatter(\n\u001B[1;32m 996\u001B[0m path_or_buf\u001B[38;5;241m=\u001B[39mpath_or_buf,\n\u001B[1;32m 997\u001B[0m lineterminator\u001B[38;5;241m=\u001B[39mlineterminator,\n\u001B[0;32m (...)\u001B[0m\n\u001B[1;32m 1012\u001B[0m formatter\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mfmt,\n\u001B[1;32m 1013\u001B[0m )\n\u001B[0;32m-> 1014\u001B[0m \u001B[43mcsv_formatter\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43msave\u001B[49m\u001B[43m(\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 1016\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m created_buffer:\n\u001B[1;32m 1017\u001B[0m \u001B[38;5;28;01massert\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(path_or_buf, StringIO)\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/pandas/io/formats/csvs.py:251\u001B[0m, in \u001B[0;36mCSVFormatter.save\u001B[0;34m(self)\u001B[0m\n\u001B[1;32m 247\u001B[0m \u001B[38;5;250m\u001B[39m\u001B[38;5;124;03m\"\"\"\u001B[39;00m\n\u001B[1;32m 248\u001B[0m \u001B[38;5;124;03mCreate the writer & save.\u001B[39;00m\n\u001B[1;32m 249\u001B[0m \u001B[38;5;124;03m\"\"\"\u001B[39;00m\n\u001B[1;32m 250\u001B[0m \u001B[38;5;66;03m# apply compression and byte/text conversion\u001B[39;00m\n\u001B[0;32m--> 251\u001B[0m \u001B[38;5;28;01mwith\u001B[39;00m \u001B[43mget_handle\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m 252\u001B[0m \u001B[43m \u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mfilepath_or_buffer\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 253\u001B[0m \u001B[43m \u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mmode\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 254\u001B[0m \u001B[43m \u001B[49m\u001B[43mencoding\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mencoding\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 255\u001B[0m \u001B[43m \u001B[49m\u001B[43merrors\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43merrors\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 256\u001B[0m \u001B[43m \u001B[49m\u001B[43mcompression\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mcompression\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 257\u001B[0m \u001B[43m \u001B[49m\u001B[43mstorage_options\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mstorage_options\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 258\u001B[0m \u001B[43m\u001B[49m\u001B[43m)\u001B[49m \u001B[38;5;28;01mas\u001B[39;00m handles:\n\u001B[1;32m 259\u001B[0m \u001B[38;5;66;03m# Note: self.encoding is irrelevant here\u001B[39;00m\n\u001B[1;32m 260\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mwriter \u001B[38;5;241m=\u001B[39m csvlib\u001B[38;5;241m.\u001B[39mwriter(\n\u001B[1;32m 261\u001B[0m handles\u001B[38;5;241m.\u001B[39mhandle,\n\u001B[1;32m 262\u001B[0m lineterminator\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mlineterminator,\n\u001B[0;32m (...)\u001B[0m\n\u001B[1;32m 267\u001B[0m quotechar\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mquotechar,\n\u001B[1;32m 268\u001B[0m )\n\u001B[1;32m 270\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_save()\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/pandas/io/common.py:749\u001B[0m, in \u001B[0;36mget_handle\u001B[0;34m(path_or_buf, mode, encoding, compression, memory_map, is_text, errors, storage_options)\u001B[0m\n\u001B[1;32m 747\u001B[0m \u001B[38;5;66;03m# Only for write methods\u001B[39;00m\n\u001B[1;32m 748\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mr\u001B[39m\u001B[38;5;124m\"\u001B[39m \u001B[38;5;129;01mnot\u001B[39;00m \u001B[38;5;129;01min\u001B[39;00m mode \u001B[38;5;129;01mand\u001B[39;00m is_path:\n\u001B[0;32m--> 749\u001B[0m \u001B[43mcheck_parent_directory\u001B[49m\u001B[43m(\u001B[49m\u001B[38;5;28;43mstr\u001B[39;49m\u001B[43m(\u001B[49m\u001B[43mhandle\u001B[49m\u001B[43m)\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 751\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m compression:\n\u001B[1;32m 752\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m compression \u001B[38;5;241m!=\u001B[39m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mzstd\u001B[39m\u001B[38;5;124m\"\u001B[39m:\n\u001B[1;32m 753\u001B[0m \u001B[38;5;66;03m# compression libraries do not like an explicit text-mode\u001B[39;00m\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/pandas/io/common.py:616\u001B[0m, in \u001B[0;36mcheck_parent_directory\u001B[0;34m(path)\u001B[0m\n\u001B[1;32m 614\u001B[0m parent \u001B[38;5;241m=\u001B[39m Path(path)\u001B[38;5;241m.\u001B[39mparent\n\u001B[1;32m 615\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;129;01mnot\u001B[39;00m parent\u001B[38;5;241m.\u001B[39mis_dir():\n\u001B[0;32m--> 616\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m \u001B[38;5;167;01mOSError\u001B[39;00m(\u001B[38;5;124mrf\u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mCannot save file into a non-existent directory: \u001B[39m\u001B[38;5;124m'\u001B[39m\u001B[38;5;132;01m{\u001B[39;00mparent\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m'\u001B[39m\u001B[38;5;124m\"\u001B[39m)\n", - "\u001B[0;31mOSError\u001B[0m: Cannot save file into a non-existent directory: '/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp126'" + "Processing year 2060, month 12\n", + "Saved monthly data for lowest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp126/lowest_monthly_prediction_weather_by_facility.csv\n", + "Saved window data for lowest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp126/lowest_window_prediction_weather_by_facility.csv\n", + "Saved monthly data for median model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp126/median_monthly_prediction_weather_by_facility.csv\n", + "Saved window data for median model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp126/median_window_prediction_weather_by_facility.csv\n", + "Saved monthly data for highest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp126/highest_monthly_prediction_weather_by_facility.csv\n", + "Saved window data for highest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp126/highest_window_prediction_weather_by_facility.csv\n" ] } ], - "execution_count": 19 + "execution_count": 21 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-08T16:11:03.429200Z", - "start_time": "2025-01-08T16:11:03.108089Z" + "end_time": "2025-01-15T14:37:42.819759Z", + "start_time": "2025-01-15T14:37:42.664733Z" } }, "cell_type": "code", @@ -4068,9998 +4057,9998 @@ { "data": { "text/plain": [ - "{0: {'monthly': {(2025, 1): 242.72029519081116,\n", - " (2025, 2): 197.7868596315384,\n", - " (2025, 3): 54.24176561832428,\n", - " (2025, 4): 36.53253209590912,\n", - " (2025, 5): 1.125024437904358,\n", - " (2025, 6): 1.3439419269561768,\n", - " (2025, 7): 1.4093778133392334,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.6215115785598755,\n", - " (2025, 10): 11.295680284500122,\n", - " (2025, 11): 293.9915255308151,\n", - " (2025, 12): 201.35513615608215},\n", - " 'window': {(2025, 1): 73.51446151733398,\n", - " (2025, 2): 92.10350131988525,\n", - " (2025, 3): 32.855849504470825,\n", - " (2025, 4): 23.820181369781494,\n", - " (2025, 5): 1.125024437904358,\n", - " (2025, 6): 1.3439419269561768,\n", - " (2025, 7): 1.4093778133392334,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.6215115785598755,\n", - " (2025, 10): 6.021182060241699,\n", - " (2025, 11): 190.1914358139038,\n", - " (2025, 12): 81.58871841430664}},\n", - " 1: {'monthly': {(2025, 1): 216.12262678146362,\n", - " (2025, 2): 162.03844916820526,\n", - " (2025, 3): 45.35058856010437,\n", - " (2025, 4): 28.609829783439636,\n", - " (2025, 5): 3.7662864923477173,\n", - " (2025, 6): 1.99960196018219,\n", - " (2025, 7): 1.8277497291564941,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 4.800233721733093,\n", - " (2025, 10): 7.432849645614624,\n", - " (2025, 11): 142.29843258857727,\n", - " (2025, 12): 163.56579220294952},\n", - " 'window': {(2025, 1): 68.4930624961853,\n", - " (2025, 2): 91.71835279464722,\n", - " (2025, 3): 31.78004026412964,\n", - " (2025, 4): 18.284509897232056,\n", - " (2025, 5): 3.7662864923477173,\n", - " (2025, 6): 1.99960196018219,\n", - " (2025, 7): 1.8277497291564941,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 3.5864031314849854,\n", - " (2025, 10): 4.873299598693848,\n", - " (2025, 11): 87.67362260818481,\n", - " (2025, 12): 62.13548183441162}},\n", - " 2: {'monthly': {(2025, 1): 233.4443941116333,\n", - " (2025, 2): 161.06021070480347,\n", - " (2025, 3): 41.75236940383911,\n", - " (2025, 4): 26.59097933769226,\n", - " (2025, 5): 3.2791682481765747,\n", - " (2025, 6): 2.73736310005188,\n", - " (2025, 7): 1.8277497291564941,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 4.262776732444763,\n", - " (2025, 10): 9.216603517532349,\n", - " (2025, 11): 148.77169907093048,\n", - " (2025, 12): 164.98977148532867},\n", - " 'window': {(2025, 1): 76.94510650634766,\n", - " (2025, 2): 94.6546516418457,\n", - " (2025, 3): 26.08426594734192,\n", - " (2025, 4): 17.49377727508545,\n", - " (2025, 5): 3.2791682481765747,\n", - " (2025, 6): 2.73736310005188,\n", - " (2025, 7): 1.8277497291564941,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 3.184852361679077,\n", - " (2025, 10): 5.85781192779541,\n", - " (2025, 11): 97.34354400634766,\n", - " (2025, 12): 63.31545400619507}},\n", - " 3: {'monthly': {(2025, 1): 254.9647114276886,\n", - " (2025, 2): 155.50093579292297,\n", - " (2025, 3): 37.28219556808472,\n", - " (2025, 4): 26.514697313308716,\n", - " (2025, 5): 2.839548707008362,\n", - " (2025, 6): 2.9927518367767334,\n", - " (2025, 7): 1.8277497291564941,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 2.914567232131958,\n", - " (2025, 10): 9.794552326202393,\n", - " (2025, 11): 148.0523282289505,\n", - " (2025, 12): 158.31202459335327},\n", - " 'window': {(2025, 1): 82.3767032623291,\n", - " (2025, 2): 85.51951503753662,\n", - " (2025, 3): 23.58493137359619,\n", - " (2025, 4): 17.581899404525757,\n", - " (2025, 5): 2.839548707008362,\n", - " (2025, 6): 2.9927518367767334,\n", - " (2025, 7): 1.8277497291564941,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 2.914567232131958,\n", - " (2025, 10): 6.3611741065979,\n", - " (2025, 11): 98.76856279373169,\n", - " (2025, 12): 61.054667472839355}},\n", - " 4: {'monthly': {(2025, 1): 287.16160094738007,\n", - " (2025, 2): 156.56632888317108,\n", - " (2025, 3): 36.794334053993225,\n", - " (2025, 4): 35.329665660858154,\n", - " (2025, 5): 2.454015851020813,\n", - " (2025, 6): 3.0738065242767334,\n", - " (2025, 7): 5.729572296142578,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 2.90962290763855,\n", - " (2025, 10): 11.04184341430664,\n", - " (2025, 11): 129.21431696414948,\n", - " (2025, 12): 169.71300137043},\n", - " 'window': {(2025, 1): 97.5433349609375,\n", - " (2025, 2): 71.41565799713135,\n", - " (2025, 3): 22.62652063369751,\n", - " (2025, 4): 24.96459412574768,\n", - " (2025, 5): 2.454015851020813,\n", - " (2025, 6): 3.0738065242767334,\n", - " (2025, 7): 2.3387882709503174,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 2.90962290763855,\n", - " (2025, 10): 7.817776203155518,\n", - " (2025, 11): 81.08000445365906,\n", - " (2025, 12): 63.56834173202515}},\n", - " 5: {'monthly': {(2025, 1): 152.4552481174469,\n", - " (2025, 2): 121.48478829860687,\n", - " (2025, 3): 52.18624401092529,\n", - " (2025, 4): 52.29652941226959,\n", - " (2025, 5): 4.232350587844849,\n", - " (2025, 6): 5.129804849624634,\n", - " (2025, 7): 7.459167718887329,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 6.5161731243133545,\n", - " (2025, 10): 10.150599002838135,\n", - " (2025, 11): 87.9732677936554,\n", - " (2025, 12): 99.04669451713562},\n", - " 'window': {(2025, 1): 48.71608090400696,\n", - " (2025, 2): 67.58498859405518,\n", - " (2025, 3): 42.02871584892273,\n", - " (2025, 4): 39.417742013931274,\n", - " (2025, 5): 3.210795044898987,\n", - " (2025, 6): 4.049909472465515,\n", - " (2025, 7): 4.399542570114136,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 4.592437744140625,\n", - " (2025, 10): 7.26452374458313,\n", - " (2025, 11): 52.007405281066895,\n", - " (2025, 12): 35.481975078582764}},\n", - " 6: {'monthly': {(2025, 1): 150.82909643650055,\n", - " (2025, 2): 118.07477414608002,\n", - " (2025, 3): 47.0850133895874,\n", - " (2025, 4): 49.47685492038727,\n", - " (2025, 5): 2.715729594230652,\n", - " (2025, 6): 4.910821914672852,\n", - " (2025, 7): 7.621808648109436,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 6.458508133888245,\n", - " (2025, 10): 8.464794635772705,\n", - " (2025, 11): 88.52476596832275,\n", - " (2025, 12): 107.80052506923676},\n", - " 'window': {(2025, 1): 51.3891966342926,\n", - " (2025, 2): 72.4222002029419,\n", - " (2025, 3): 39.95784318447113,\n", - " (2025, 4): 35.78232741355896,\n", - " (2025, 5): 2.715729594230652,\n", - " (2025, 6): 3.830926537513733,\n", - " (2025, 7): 4.399542570114136,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 4.578286170959473,\n", - " (2025, 10): 7.245257139205933,\n", - " (2025, 11): 55.49178171157837,\n", - " (2025, 12): 38.728036880493164}},\n", - " 7: {'monthly': {(2025, 1): 135.1075301170349,\n", - " (2025, 2): 105.55169975757599,\n", - " (2025, 3): 48.94171380996704,\n", - " (2025, 4): 42.29969680309296,\n", - " (2025, 5): 2.4726717472076416,\n", - " (2025, 6): 4.15595817565918,\n", - " (2025, 7): 8.592421174049377,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 6.4729825258255005,\n", - " (2025, 10): 10.563262820243835,\n", - " (2025, 11): 90.37465763092041,\n", - " (2025, 12): 103.39897692203522},\n", - " 'window': {(2025, 1): 52.43373775482178,\n", - " (2025, 2): 61.264678955078125,\n", - " (2025, 3): 39.52932381629944,\n", - " (2025, 4): 29.252273559570312,\n", - " (2025, 5): 2.4726717472076416,\n", - " (2025, 6): 3.076062798500061,\n", - " (2025, 7): 4.399542570114136,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 4.7265143394470215,\n", - " (2025, 10): 7.447058439254761,\n", - " (2025, 11): 59.18511354923248,\n", - " (2025, 12): 34.406667590141296}},\n", - " 8: {'monthly': {(2025, 1): 137.1134386062622,\n", - " (2025, 2): 104.22368049621582,\n", - " (2025, 3): 54.607306718826294,\n", - " (2025, 4): 59.17346513271332,\n", - " (2025, 5): 2.661251425743103,\n", - " (2025, 6): 5.7662200927734375,\n", - " (2025, 7): 8.430274605751038,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 6.7778507471084595,\n", - " (2025, 10): 10.174914598464966,\n", - " (2025, 11): 117.45633363723755,\n", - " (2025, 12): 105.2785975933075},\n", - " 'window': {(2025, 1): 53.6931049823761,\n", - " (2025, 2): 48.378979206085205,\n", - " (2025, 3): 37.84114074707031,\n", - " (2025, 4): 44.193548798561096,\n", - " (2025, 5): 1.4454398155212402,\n", - " (2025, 6): 3.6636334657669067,\n", - " (2025, 7): 4.543016672134399,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 5.1774444580078125,\n", - " (2025, 10): 9.067684173583984,\n", - " (2025, 11): 65.96828985214233,\n", - " (2025, 12): 37.31221961975098}},\n", - " 9: {'monthly': {(2025, 1): 152.94469892978668,\n", - " (2025, 2): 124.00417995452881,\n", - " (2025, 3): 69.19271993637085,\n", - " (2025, 4): 46.21683692932129,\n", - " (2025, 5): 7.316042900085449,\n", - " (2025, 6): 3.9841806888580322,\n", - " (2025, 7): 8.039825201034546,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 10.944538593292236,\n", - " (2025, 10): 16.619274258613586,\n", - " (2025, 11): 100.48983561992645,\n", - " (2025, 12): 97.84331595897675},\n", - " 'window': {(2025, 1): 71.82591724395752,\n", - " (2025, 2): 60.16821098327637,\n", - " (2025, 3): 38.147056579589844,\n", - " (2025, 4): 31.25300621986389,\n", - " (2025, 5): 4.487376570701599,\n", - " (2025, 6): 2.328857898712158,\n", - " (2025, 7): 4.256126880645752,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 6.03425407409668,\n", - " (2025, 10): 11.90073013305664,\n", - " (2025, 11): 68.36128997802734,\n", - " (2025, 12): 30.89588952064514}},\n", - " 10: {'monthly': {(2025, 1): 145.44792759418488,\n", - " (2025, 2): 114.9477891921997,\n", - " (2025, 3): 67.50746881961823,\n", - " (2025, 4): 54.183799505233765,\n", - " (2025, 5): 7.058018207550049,\n", - " (2025, 6): 4.08739173412323,\n", - " (2025, 7): 12.13927948474884,\n", - " (2025, 8): 1.0156681537628174,\n", - " (2025, 9): 12.09643268585205,\n", - " (2025, 10): 22.009426474571228,\n", - " (2025, 11): 99.24441874027252,\n", - " (2025, 12): 100.92724859714508},\n", - " 'window': {(2025, 1): 67.00965976715088,\n", - " (2025, 2): 61.9244966506958,\n", - " (2025, 3): 38.509392976760864,\n", - " (2025, 4): 40.83987212181091,\n", - " (2025, 5): 4.264992594718933,\n", - " (2025, 6): 2.826067566871643,\n", - " (2025, 7): 8.29413390159607,\n", - " (2025, 8): 1.0156681537628174,\n", - " (2025, 9): 6.481685638427734,\n", - " (2025, 10): 15.70923137664795,\n", - " (2025, 11): 67.16708660125732,\n", - " (2025, 12): 34.33808672428131}},\n", - " 11: {'monthly': {(2025, 1): 139.95035588741302,\n", - " (2025, 2): 122.04769134521484,\n", - " (2025, 3): 68.55006468296051,\n", - " (2025, 4): 64.72765338420868,\n", - " (2025, 5): 8.2379230260849,\n", - " (2025, 6): 10.800941228866577,\n", - " (2025, 7): 8.053625226020813,\n", - " (2025, 8): 1.431247353553772,\n", - " (2025, 9): 13.74570894241333,\n", - " (2025, 10): 27.393906831741333,\n", - " (2025, 11): 93.06492328643799,\n", - " (2025, 12): 120.93473529815674},\n", - " 'window': {(2025, 1): 60.13694524765015,\n", - " (2025, 2): 62.594160079956055,\n", - " (2025, 3): 38.89575171470642,\n", - " (2025, 4): 50.116201400756836,\n", - " (2025, 5): 4.364106059074402,\n", - " (2025, 6): 7.138206720352173,\n", - " (2025, 7): 4.256126880645752,\n", - " (2025, 8): 1.431247353553772,\n", - " (2025, 9): 8.144371032714844,\n", - " (2025, 10): 19.73897361755371,\n", - " (2025, 11): 59.32257032394409,\n", - " (2025, 12): 48.80408811569214}},\n", - " 12: {'monthly': {(2025, 1): 148.27944254875183,\n", - " (2025, 2): 146.25126481056213,\n", - " (2025, 3): 69.77374863624573,\n", - " (2025, 4): 79.63234639167786,\n", - " (2025, 5): 11.29406988620758,\n", - " (2025, 6): 13.499855041503906,\n", - " (2025, 7): 11.105743288993835,\n", - " (2025, 8): 2.9060627222061157,\n", - " (2025, 9): 15.707955718040466,\n", - " (2025, 10): 27.32894778251648,\n", - " (2025, 11): 91.65286219120026,\n", - " (2025, 12): 144.15321683883667},\n", - " 'window': {(2025, 1): 50.42962980270386,\n", - " (2025, 2): 79.91398906707764,\n", - " (2025, 3): 35.8476505279541,\n", - " (2025, 4): 60.831214427948,\n", - " (2025, 5): 4.34578263759613,\n", - " (2025, 6): 11.146587610244751,\n", - " (2025, 7): 5.796663999557495,\n", - " (2025, 8): 2.9060627222061157,\n", - " (2025, 9): 8.92073667049408,\n", - " (2025, 10): 19.102243423461914,\n", - " (2025, 11): 51.033039569854736,\n", - " (2025, 12): 58.4827094078064}},\n", - " 13: {'monthly': {(2025, 1): 249.22912275791168,\n", - " (2025, 2): 191.9676457643509,\n", - " (2025, 3): 61.733248472213745,\n", - " (2025, 4): 27.34773826599121,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 2.059919595718384,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 3.842095732688904,\n", - " (2025, 11): 112.8606733083725,\n", - " (2025, 12): 155.83990597724915},\n", - " 'window': {(2025, 1): 67.95952892303467,\n", - " (2025, 2): 101.41579914093018,\n", - " (2025, 3): 32.7286981344223,\n", - " (2025, 4): 16.469815373420715,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 2.059919595718384,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 2.8166024684906006,\n", - " (2025, 11): 56.05797100067139,\n", - " (2025, 12): 53.42811870574951}},\n", - " 14: {'monthly': {(2025, 1): 242.60850322246552,\n", - " (2025, 2): 137.0102480649948,\n", - " (2025, 3): 55.859442710876465,\n", - " (2025, 4): 19.6950763463974,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.6317617893218994,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.459745168685913,\n", - " (2025, 10): 5.909443616867065,\n", - " (2025, 11): 97.95981788635254,\n", - " (2025, 12): 154.9647879600525},\n", - " 'window': {(2025, 1): 86.1264181137085,\n", - " (2025, 2): 63.88818979263306,\n", - " (2025, 3): 37.800379037857056,\n", - " (2025, 4): 12.81462299823761,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.6317617893218994,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.459745168685913,\n", - " (2025, 10): 3.894387722015381,\n", - " (2025, 11): 46.84900784492493,\n", - " (2025, 12): 49.77821493148804}},\n", - " 15: {'monthly': {(2025, 1): 232.19223272800446,\n", - " (2025, 2): 148.5682249069214,\n", - " (2025, 3): 56.11139619350433,\n", - " (2025, 4): 22.970368027687073,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.90993332862854,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.6587696075439453,\n", - " (2025, 10): 6.711116552352905,\n", - " (2025, 11): 84.51631188392639,\n", - " (2025, 12): 129.51838076114655},\n", - " 'window': {(2025, 1): 92.83096218109131,\n", - " (2025, 2): 76.80672454833984,\n", - " (2025, 3): 39.41438317298889,\n", - " (2025, 4): 16.503418564796448,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.90993332862854,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.6587696075439453,\n", - " (2025, 10): 4.425355911254883,\n", - " (2025, 11): 39.5791871547699,\n", - " (2025, 12): 45.6242835521698}},\n", - " 16: {'monthly': {(2025, 1): 244.3237144947052,\n", - " (2025, 2): 161.8519846200943,\n", - " (2025, 3): 55.5875141620636,\n", - " (2025, 4): 22.002213954925537,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.8864054679870605,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.652530312538147,\n", - " (2025, 10): 6.264004349708557,\n", - " (2025, 11): 91.66033124923706,\n", - " (2025, 12): 132.0481904745102},\n", - " 'window': {(2025, 1): 90.34821319580078,\n", - " (2025, 2): 87.78351211547852,\n", - " (2025, 3): 39.07024121284485,\n", - " (2025, 4): 15.246269226074219,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.8864054679870605,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.652530312538147,\n", - " (2025, 10): 4.408710479736328,\n", - " (2025, 11): 44.279481530189514,\n", - " (2025, 12): 42.704076051712036}},\n", - " 17: {'monthly': {(2025, 1): 217.33190762996674,\n", - " (2025, 2): 179.92060470581055,\n", - " (2025, 3): 54.72659993171692,\n", - " (2025, 4): 21.881802082061768,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.961252212524414,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.9231994152069092,\n", - " (2025, 10): 7.876139402389526,\n", - " (2025, 11): 110.76641261577606,\n", - " (2025, 12): 137.5805379152298},\n", - " 'window': {(2025, 1): 78.42352962493896,\n", - " (2025, 2): 109.0632791519165,\n", - " (2025, 3): 37.34203553199768,\n", - " (2025, 4): 13.923739433288574,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.961252212524414,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.9231994152069092,\n", - " (2025, 10): 5.1308159828186035,\n", - " (2025, 11): 56.29197454452515,\n", - " (2025, 12): 46.19855320453644}},\n", - " 18: {'monthly': {(2025, 1): 228.86905705928802,\n", - " (2025, 2): 169.45881366729736,\n", - " (2025, 3): 37.18255794048309,\n", - " (2025, 4): 37.95800495147705,\n", - " (2025, 5): 1.015185832977295,\n", - " (2025, 6): 4.7061744928359985,\n", - " (2025, 7): 6.114260911941528,\n", - " (2025, 8): 1.0428850650787354,\n", - " (2025, 9): 4.274160385131836,\n", - " (2025, 10): 3.710489869117737,\n", - " (2025, 11): 139.02069544792175,\n", - " (2025, 12): 112.33563041687012},\n", - " 'window': {(2025, 1): 95.17367839813232,\n", - " (2025, 2): 117.22720909118652,\n", - " (2025, 3): 28.15985608100891,\n", - " (2025, 4): 28.099672555923462,\n", - " (2025, 5): 1.015185832977295,\n", - " (2025, 6): 4.7061744928359985,\n", - " (2025, 7): 4.65280556678772,\n", - " (2025, 8): 1.0428850650787354,\n", - " (2025, 9): 2.5455822944641113,\n", - " (2025, 10): 2.6116329431533813,\n", - " (2025, 11): 88.57647585868835,\n", - " (2025, 12): 37.741063833236694}},\n", - " 19: {'monthly': {(2025, 1): 213.5872085094452,\n", - " (2025, 2): 199.68929779529572,\n", - " (2025, 3): 37.94545817375183,\n", - " (2025, 4): 35.827142000198364,\n", - " (2025, 5): 1.015185832977295,\n", - " (2025, 6): 4.719216823577881,\n", - " (2025, 7): 7.3781222105026245,\n", - " (2025, 8): 1.0428850650787354,\n", - " (2025, 9): 5.721921682357788,\n", - " (2025, 10): 5.47610604763031,\n", - " (2025, 11): 131.30576932430267,\n", - " (2025, 12): 110.3931313753128},\n", - " 'window': {(2025, 1): 92.13667106628418,\n", - " (2025, 2): 141.86876487731934,\n", - " (2025, 3): 30.672905445098877,\n", - " (2025, 4): 26.42360210418701,\n", - " (2025, 5): 1.015185832977295,\n", - " (2025, 6): 4.719216823577881,\n", - " (2025, 7): 5.916666865348816,\n", - " (2025, 8): 1.0428850650787354,\n", - " (2025, 9): 3.178166627883911,\n", - " (2025, 10): 3.82229483127594,\n", - " (2025, 11): 99.43399667739868,\n", - " (2025, 12): 39.86208987236023}},\n", - " 20: {'monthly': {(2025, 1): 189.4272177219391,\n", - " (2025, 2): 168.90109360218048,\n", - " (2025, 3): 43.96516311168671,\n", - " (2025, 4): 41.71600937843323,\n", - " (2025, 5): 1.015185832977295,\n", - " (2025, 6): 5.140294194221497,\n", - " (2025, 7): 5.149662613868713,\n", - " (2025, 8): 2.08172070980072,\n", - " (2025, 9): 7.146820068359375,\n", - " (2025, 10): 7.404236197471619,\n", - " (2025, 11): 140.76979780197144,\n", - " (2025, 12): 114.3897145986557},\n", - " 'window': {(2025, 1): 78.13536405563354,\n", - " (2025, 2): 120.2734055519104,\n", - " (2025, 3): 34.659780740737915,\n", - " (2025, 4): 32.81459093093872,\n", - " (2025, 5): 1.015185832977295,\n", - " (2025, 6): 5.140294194221497,\n", - " (2025, 7): 3.688207268714905,\n", - " (2025, 8): 1.0428850650787354,\n", - " (2025, 9): 4.73984432220459,\n", - " (2025, 10): 5.1265705823898315,\n", - " (2025, 11): 99.08236145973206,\n", - " (2025, 12): 39.60468780994415}},\n", - " 21: {'monthly': {(2025, 1): 182.38318026065826,\n", - " (2025, 2): 136.4600886106491,\n", - " (2025, 3): 60.11043167114258,\n", - " (2025, 4): 55.291372776031494,\n", - " (2025, 5): 1.015185832977295,\n", - " (2025, 6): 6.250462889671326,\n", - " (2025, 7): 5.050062656402588,\n", - " (2025, 8): 2.1762994527816772,\n", - " (2025, 9): 8.823559999465942,\n", - " (2025, 10): 10.639675617218018,\n", - " (2025, 11): 153.9115710258484,\n", - " (2025, 12): 129.28334748744965},\n", - " 'window': {(2025, 1): 62.52886915206909,\n", - " (2025, 2): 87.49998950958252,\n", - " (2025, 3): 46.94036626815796,\n", - " (2025, 4): 43.71191477775574,\n", - " (2025, 5): 1.015185832977295,\n", - " (2025, 6): 6.250462889671326,\n", - " (2025, 7): 3.5886073112487793,\n", - " (2025, 8): 1.133414387702942,\n", - " (2025, 9): 6.409912586212158,\n", - " (2025, 10): 6.5213717222213745,\n", - " (2025, 11): 99.84016513824463,\n", - " (2025, 12): 47.47462844848633}},\n", - " 22: {'monthly': {(2025, 1): 184.7082690000534,\n", - " (2025, 2): 177.86380910873413,\n", - " (2025, 3): 83.15282213687897,\n", - " (2025, 4): 52.1490558385849,\n", - " (2025, 5): 3.4073885679244995,\n", - " (2025, 6): 12.518825769424438,\n", - " (2025, 7): 9.959367752075195,\n", - " (2025, 8): 1.0436676740646362,\n", - " (2025, 9): 7.864073753356934,\n", - " (2025, 10): 4.900745630264282,\n", - " (2025, 11): 94.25943982601166,\n", - " (2025, 12): 115.28593063354492},\n", - " 'window': {(2025, 1): 83.1702675819397,\n", - " (2025, 2): 123.22061347961426,\n", - " (2025, 3): 43.380000591278076,\n", - " (2025, 4): 36.378358364105225,\n", - " (2025, 5): 1.9776510000228882,\n", - " (2025, 6): 9.023261904716492,\n", - " (2025, 7): 7.090661644935608,\n", - " (2025, 8): 1.0436676740646362,\n", - " (2025, 9): 4.398099422454834,\n", - " (2025, 10): 2.7275915145874023,\n", - " (2025, 11): 46.71242666244507,\n", - " (2025, 12): 43.85554623603821}},\n", - " 23: {'monthly': {(2025, 1): 176.4819518327713,\n", - " (2025, 2): 154.61845445632935,\n", - " (2025, 3): 76.60640120506287,\n", - " (2025, 4): 51.96744477748871,\n", - " (2025, 5): 5.4748125076293945,\n", - " (2025, 6): 12.333269834518433,\n", - " (2025, 7): 7.870053291320801,\n", - " (2025, 8): 1.1189507246017456,\n", - " (2025, 9): 7.842662811279297,\n", - " (2025, 10): 9.198851227760315,\n", - " (2025, 11): 80.55919134616852,\n", - " (2025, 12): 107.66820454597473},\n", - " 'window': {(2025, 1): 88.59416675567627,\n", - " (2025, 2): 105.52160024642944,\n", - " (2025, 3): 42.21366834640503,\n", - " (2025, 4): 38.40726447105408,\n", - " (2025, 5): 2.471808910369873,\n", - " (2025, 6): 8.837705969810486,\n", - " (2025, 7): 3.9771920442581177,\n", - " (2025, 8): 1.1189507246017456,\n", - " (2025, 9): 5.262660503387451,\n", - " (2025, 10): 4.644401907920837,\n", - " (2025, 11): 39.797433376312256,\n", - " (2025, 12): 37.45400655269623}},\n", - " 24: {'monthly': {(2025, 1): 185.23678612709045,\n", - " (2025, 2): 129.98267698287964,\n", - " (2025, 3): 77.52877390384674,\n", - " (2025, 4): 61.22716200351715,\n", - " (2025, 5): 5.439498424530029,\n", - " (2025, 6): 14.470493912696838,\n", - " (2025, 7): 8.148488283157349,\n", - " (2025, 8): 1.284326195716858,\n", - " (2025, 9): 11.021090745925903,\n", - " (2025, 10): 11.744053483009338,\n", - " (2025, 11): 72.87658047676086,\n", - " (2025, 12): 120.93143677711487},\n", - " 'window': {(2025, 1): 91.47716999053955,\n", - " (2025, 2): 79.97553443908691,\n", - " (2025, 3): 44.16167116165161,\n", - " (2025, 4): 44.64498710632324,\n", - " (2025, 5): 2.3525876998901367,\n", - " (2025, 6): 10.974930047988892,\n", - " (2025, 7): 4.13297426700592,\n", - " (2025, 8): 1.284326195716858,\n", - " (2025, 9): 7.203515529632568,\n", - " (2025, 10): 6.0898051261901855,\n", - " (2025, 11): 39.07590675354004,\n", - " (2025, 12): 40.67360067367554}},\n", - " 25: {'monthly': {(2025, 1): 210.75018084049225,\n", - " (2025, 2): 124.55218636989594,\n", - " (2025, 3): 86.89159667491913,\n", - " (2025, 4): 68.97172808647156,\n", - " (2025, 5): 9.140530824661255,\n", - " (2025, 6): 17.32026767730713,\n", - " (2025, 7): 8.196346759796143,\n", - " (2025, 8): 2.4053910970687866,\n", - " (2025, 9): 11.78540587425232,\n", - " (2025, 10): 13.922070860862732,\n", - " (2025, 11): 77.46376526355743,\n", - " (2025, 12): 134.70812118053436},\n", - " 'window': {(2025, 1): 86.81382274627686,\n", - " (2025, 2): 69.72485828399658,\n", - " (2025, 3): 49.1210880279541,\n", - " (2025, 4): 52.11043834686279,\n", - " (2025, 5): 3.231466770172119,\n", - " (2025, 6): 13.824703812599182,\n", - " (2025, 7): 4.207401752471924,\n", - " (2025, 8): 1.2600092887878418,\n", - " (2025, 9): 8.726362228393555,\n", - " (2025, 10): 7.121205449104309,\n", - " (2025, 11): 40.86165952682495,\n", - " (2025, 12): 51.428250312805176}},\n", - " 26: {'monthly': {(2025, 1): 269.2101329565048,\n", - " (2025, 2): 193.33549785614014,\n", - " (2025, 3): 61.17111003398895,\n", - " (2025, 4): 27.480571627616882,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 4.325158953666687,\n", - " (2025, 11): 125.5162924528122,\n", - " (2025, 12): 152.90465474128723},\n", - " 'window': {(2025, 1): 75.72653150558472,\n", - " (2025, 2): 98.55378437042236,\n", - " (2025, 3): 31.216501712799072,\n", - " (2025, 4): 15.252967357635498,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 3.299665689468384,\n", - " (2025, 11): 66.50041818618774,\n", - " (2025, 12): 51.00997734069824}},\n", - " 27: {'monthly': {(2025, 1): 234.52305328845978,\n", - " (2025, 2): 147.5542950630188,\n", - " (2025, 3): 58.78539037704468,\n", - " (2025, 4): 25.08925175666809,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 2.10481858253479,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.5290722846984863,\n", - " (2025, 10): 6.654446601867676,\n", - " (2025, 11): 104.17090725898743,\n", - " (2025, 12): 152.890571475029},\n", - " 'window': {(2025, 1): 82.65954208374023,\n", - " (2025, 2): 71.95663261413574,\n", - " (2025, 3): 40.59626626968384,\n", - " (2025, 4): 16.035751342773438,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 2.10481858253479,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.5290722846984863,\n", - " (2025, 10): 4.079342365264893,\n", - " (2025, 11): 54.78475213050842,\n", - " (2025, 12): 59.4109206199646}},\n", - " 28: {'monthly': {(2025, 1): 231.41994202136993,\n", - " (2025, 2): 160.8769497871399,\n", - " (2025, 3): 55.638405442237854,\n", - " (2025, 4): 25.58198118209839,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 2.314507246017456,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.612658143043518,\n", - " (2025, 10): 6.910551309585571,\n", - " (2025, 11): 102.11535632610321,\n", - " (2025, 12): 143.45359575748444},\n", - " 'window': {(2025, 1): 83.36008930206299,\n", - " (2025, 2): 87.77257823944092,\n", - " (2025, 3): 39.33837652206421,\n", - " (2025, 4): 16.98373579978943,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 2.314507246017456,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.612658143043518,\n", - " (2025, 10): 4.302337646484375,\n", - " (2025, 11): 52.58218443393707,\n", - " (2025, 12): 59.81249523162842}},\n", - " 29: {'monthly': {(2025, 1): 222.59759306907654,\n", - " (2025, 2): 175.50381863117218,\n", - " (2025, 3): 49.63894081115723,\n", - " (2025, 4): 20.551815271377563,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.993557333946228,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.491347074508667,\n", - " (2025, 10): 5.900858521461487,\n", - " (2025, 11): 98.7986695766449,\n", - " (2025, 12): 133.81533324718475},\n", - " 'window': {(2025, 1): 76.3696517944336,\n", - " (2025, 2): 104.66628074645996,\n", - " (2025, 3): 35.26089692115784,\n", - " (2025, 4): 13.377806425094604,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.993557333946228,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.491347074508667,\n", - " (2025, 10): 3.978696823120117,\n", - " (2025, 11): 53.94710040092468,\n", - " (2025, 12): 49.909245014190674}},\n", - " 30: {'monthly': {(2025, 1): 209.18218183517456,\n", - " (2025, 2): 190.5131186246872,\n", - " (2025, 3): 44.580507040023804,\n", - " (2025, 4): 20.26715612411499,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.8446515798568726,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.6396238803863525,\n", - " (2025, 10): 5.965296030044556,\n", - " (2025, 11): 105.849769115448,\n", - " (2025, 12): 129.84584867954254},\n", - " 'window': {(2025, 1): 70.79307651519775,\n", - " (2025, 2): 122.22093391418457,\n", - " (2025, 3): 30.300590991973877,\n", - " (2025, 4): 12.411158800125122,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.8446515798568726,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.6396238803863525,\n", - " (2025, 10): 4.374277591705322,\n", - " (2025, 11): 58.92324638366699,\n", - " (2025, 12): 42.39523100852966}},\n", - " 31: {'monthly': {(2025, 1): 217.04488563537598,\n", - " (2025, 2): 187.46244311332703,\n", - " (2025, 3): 42.971639752388,\n", - " (2025, 4): 37.32084596157074,\n", - " (2025, 5): 1.015185832977295,\n", - " (2025, 6): 5.138524174690247,\n", - " (2025, 7): 5.207779288291931,\n", - " (2025, 8): 1.0428850650787354,\n", - " (2025, 9): 5.942322731018066,\n", - " (2025, 10): 5.94823944568634,\n", - " (2025, 11): 126.66509163379669,\n", - " (2025, 12): 108.05130875110626},\n", - " 'window': {(2025, 1): 87.47740340232849,\n", - " (2025, 2): 137.07593441009521,\n", - " (2025, 3): 34.28690958023071,\n", - " (2025, 4): 27.12294340133667,\n", - " (2025, 5): 1.015185832977295,\n", - " (2025, 6): 5.138524174690247,\n", - " (2025, 7): 3.7463239431381226,\n", - " (2025, 8): 1.0428850650787354,\n", - " (2025, 9): 3.873234510421753,\n", - " (2025, 10): 4.402799010276794,\n", - " (2025, 11): 90.41926741600037,\n", - " (2025, 12): 36.27821135520935}},\n", - " 32: {'monthly': {(2025, 1): 220.63040328025818,\n", - " (2025, 2): 196.93984615802765,\n", - " (2025, 3): 45.75208926200867,\n", - " (2025, 4): 44.00732672214508,\n", - " (2025, 5): 1.015185832977295,\n", - " (2025, 6): 5.543266415596008,\n", - " (2025, 7): 4.924695014953613,\n", - " (2025, 8): 1.0428850650787354,\n", - " (2025, 9): 8.339553117752075,\n", - " (2025, 10): 8.565890908241272,\n", - " (2025, 11): 140.91501700878143,\n", - " (2025, 12): 110.2646553516388},\n", - " 'window': {(2025, 1): 90.64660286903381,\n", - " (2025, 2): 147.03265571594238,\n", - " (2025, 3): 38.77984380722046,\n", - " (2025, 4): 31.78760004043579,\n", - " (2025, 5): 1.015185832977295,\n", - " (2025, 6): 5.543266415596008,\n", - " (2025, 7): 3.4632396697998047,\n", - " (2025, 8): 1.0428850650787354,\n", - " (2025, 9): 6.2734808921813965,\n", - " (2025, 10): 6.407427668571472,\n", - " (2025, 11): 101.36366939544678,\n", - " (2025, 12): 37.04167890548706}},\n", - " 33: {'monthly': {(2025, 1): 197.68813931941986,\n", - " (2025, 2): 167.53871250152588,\n", - " (2025, 3): 52.30336081981659,\n", - " (2025, 4): 48.570619106292725,\n", - " (2025, 5): 1.0819464921951294,\n", - " (2025, 6): 6.051826357841492,\n", - " (2025, 7): 6.699302673339844,\n", - " (2025, 8): 2.0542237758636475,\n", - " (2025, 9): 10.275604963302612,\n", - " (2025, 10): 11.76202118396759,\n", - " (2025, 11): 153.19762802124023,\n", - " (2025, 12): 120.36028063297272},\n", - " 'window': {(2025, 1): 77.80814051628113,\n", - " (2025, 2): 113.9347791671753,\n", - " (2025, 3): 41.346192359924316,\n", - " (2025, 4): 37.84156918525696,\n", - " (2025, 5): 1.0819464921951294,\n", - " (2025, 6): 6.051826357841492,\n", - " (2025, 7): 4.1481016874313354,\n", - " (2025, 8): 1.0428850650787354,\n", - " (2025, 9): 8.351032257080078,\n", - " (2025, 10): 8.142548441886902,\n", - " (2025, 11): 108.06031560897827,\n", - " (2025, 12): 39.64739942550659}},\n", - " 34: {'monthly': {(2025, 1): 185.8077211380005,\n", - " (2025, 2): 136.03681409358978,\n", - " (2025, 3): 70.00961112976074,\n", - " (2025, 4): 62.1231963634491,\n", - " (2025, 5): 3.3617366552352905,\n", - " (2025, 6): 6.989424347877502,\n", - " (2025, 7): 7.014299154281616,\n", - " (2025, 8): 2.0954264402389526,\n", - " (2025, 9): 9.951886177062988,\n", - " (2025, 10): 11.213122963905334,\n", - " (2025, 11): 168.9057059288025,\n", - " (2025, 12): 136.92484545707703},\n", - " 'window': {(2025, 1): 64.57412528991699,\n", - " (2025, 2): 80.02114772796631,\n", - " (2025, 3): 53.470789432525635,\n", - " (2025, 4): 46.90598726272583,\n", - " (2025, 5): 1.1472095251083374,\n", - " (2025, 6): 6.989424347877502,\n", - " (2025, 7): 4.49705958366394,\n", - " (2025, 8): 1.0525413751602173,\n", - " (2025, 9): 7.752420425415039,\n", - " (2025, 10): 7.642602324485779,\n", - " (2025, 11): 109.72435760498047,\n", - " (2025, 12): 51.09493589401245}},\n", - " 35: {'monthly': {(2025, 1): 167.7621626853943,\n", - " (2025, 2): 178.7678415775299,\n", - " (2025, 3): 73.79765236377716,\n", - " (2025, 4): 53.15182650089264,\n", - " (2025, 5): 5.902846097946167,\n", - " (2025, 6): 12.644668579101562,\n", - " (2025, 7): 7.808280348777771,\n", - " (2025, 8): 1.7876213788986206,\n", - " (2025, 9): 11.370310306549072,\n", - " (2025, 10): 10.26318907737732,\n", - " (2025, 11): 106.10316300392151,\n", - " (2025, 12): 126.8608900308609},\n", - " 'window': {(2025, 1): 70.89574098587036,\n", - " (2025, 2): 128.7497911453247,\n", - " (2025, 3): 42.851518630981445,\n", - " (2025, 4): 38.818886041641235,\n", - " (2025, 5): 2.801955819129944,\n", - " (2025, 6): 9.149104714393616,\n", - " (2025, 7): 4.939574241638184,\n", - " (2025, 8): 1.7876213788986206,\n", - " (2025, 9): 7.08406925201416,\n", - " (2025, 10): 5.7810012102127075,\n", - " (2025, 11): 54.90509033203125,\n", - " (2025, 12): 44.41382575035095}},\n", - " 36: {'monthly': {(2025, 1): 168.78210282325745,\n", - " (2025, 2): 164.2158443927765,\n", - " (2025, 3): 71.75923597812653,\n", - " (2025, 4): 61.91836869716644,\n", - " (2025, 5): 6.083523988723755,\n", - " (2025, 6): 15.722778677940369,\n", - " (2025, 7): 7.110312342643738,\n", - " (2025, 8): 2.18778133392334,\n", - " (2025, 9): 15.39732313156128,\n", - " (2025, 10): 12.613068699836731,\n", - " (2025, 11): 96.64381897449493,\n", - " (2025, 12): 124.87272489070892},\n", - " 'window': {(2025, 1): 79.7074842453003,\n", - " (2025, 2): 114.57633399963379,\n", - " (2025, 3): 39.03855609893799,\n", - " (2025, 4): 47.58109903335571,\n", - " (2025, 5): 3.121551275253296,\n", - " (2025, 6): 12.227214813232422,\n", - " (2025, 7): 4.24160623550415,\n", - " (2025, 8): 2.18778133392334,\n", - " (2025, 9): 10.457525253295898,\n", - " (2025, 10): 8.533931732177734,\n", - " (2025, 11): 52.14000606536865,\n", - " (2025, 12): 48.32494294643402}},\n", - " 37: {'monthly': {(2025, 1): 207.066455245018,\n", - " (2025, 2): 160.64349269866943,\n", - " (2025, 3): 90.57079541683197,\n", - " (2025, 4): 83.56554162502289,\n", - " (2025, 5): 8.85178256034851,\n", - " (2025, 6): 22.212830185890198,\n", - " (2025, 7): 7.470936417579651,\n", - " (2025, 8): 5.731096148490906,\n", - " (2025, 9): 21.43623983860016,\n", - " (2025, 10): 17.9470237493515,\n", - " (2025, 11): 106.6329175233841,\n", - " (2025, 12): 158.48017120361328},\n", - " 'window': {(2025, 1): 87.97211265563965,\n", - " (2025, 2): 101.8157548904419,\n", - " (2025, 3): 50.00299787521362,\n", - " (2025, 4): 63.21684694290161,\n", - " (2025, 5): 3.8483372926712036,\n", - " (2025, 6): 18.504592418670654,\n", - " (2025, 7): 4.6022303104400635,\n", - " (2025, 8): 2.5029304027557373,\n", - " (2025, 9): 14.413331985473633,\n", - " (2025, 10): 11.762094497680664,\n", - " (2025, 11): 61.63176441192627,\n", - " (2025, 12): 54.81823539733887}},\n", - " 38: {'monthly': {(2025, 1): 211.29682660102844,\n", - " (2025, 2): 143.4262135028839,\n", - " (2025, 3): 90.16159689426422,\n", - " (2025, 4): 88.38096714019775,\n", - " (2025, 5): 9.725332021713257,\n", - " (2025, 6): 23.12700080871582,\n", - " (2025, 7): 10.997109174728394,\n", - " (2025, 8): 2.025512933731079,\n", - " (2025, 9): 22.3877911567688,\n", - " (2025, 10): 20.733163714408875,\n", - " (2025, 11): 101.71214210987091,\n", - " (2025, 12): 168.4849681854248},\n", - " 'window': {(2025, 1): 83.08082103729248,\n", - " (2025, 2): 84.62892055511475,\n", - " (2025, 3): 51.75865650177002,\n", - " (2025, 4): 64.1157431602478,\n", - " (2025, 5): 3.858232021331787,\n", - " (2025, 6): 19.51085352897644,\n", - " (2025, 7): 4.749959230422974,\n", - " (2025, 8): 2.025512933731079,\n", - " (2025, 9): 15.998893737792969,\n", - " (2025, 10): 13.056001901626587,\n", - " (2025, 11): 59.541799545288086,\n", - " (2025, 12): 55.11964750289917}},\n", - " 39: {'monthly': {(2025, 1): 296.4524360895157,\n", - " (2025, 2): 191.58143639564514,\n", - " (2025, 3): 59.628233551979065,\n", - " (2025, 4): 26.270928859710693,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.2417072057724,\n", - " (2025, 7): 1.075585126876831,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 4.831566691398621,\n", - " (2025, 11): 124.49008584022522,\n", - " (2025, 12): 167.13095879554749},\n", - " 'window': {(2025, 1): 83.5554838180542,\n", - " (2025, 2): 96.55543375015259,\n", - " (2025, 3): 30.959187269210815,\n", - " (2025, 4): 14.1568843126297,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.2417072057724,\n", - " (2025, 7): 1.075585126876831,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 3.8060734272003174,\n", - " (2025, 11): 65.11164617538452,\n", - " (2025, 12): 58.320932388305664}},\n", - " 40: {'monthly': {(2025, 1): 241.6214954853058,\n", - " (2025, 2): 152.18533992767334,\n", - " (2025, 3): 60.39606332778931,\n", - " (2025, 4): 30.635706901550293,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 2.502605676651001,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.424442172050476,\n", - " (2025, 10): 6.745775938034058,\n", - " (2025, 11): 107.91759061813354,\n", - " (2025, 12): 157.00966322422028},\n", - " 'window': {(2025, 1): 79.48181056976318,\n", - " (2025, 2): 81.60733222961426,\n", - " (2025, 3): 38.00331401824951,\n", - " (2025, 4): 22.243346691131592,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 2.502605676651001,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.424442172050476,\n", - " (2025, 10): 3.800204277038574,\n", - " (2025, 11): 58.88387322425842,\n", - " (2025, 12): 63.339359760284424}},\n", - " 41: {'monthly': {(2025, 1): 220.77707302570343,\n", - " (2025, 2): 161.75414180755615,\n", - " (2025, 3): 56.88142681121826,\n", - " (2025, 4): 30.925682544708252,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 3.113647699356079,\n", - " (2025, 7): 1.0161051750183105,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.5987908840179443,\n", - " (2025, 10): 8.53209674358368,\n", - " (2025, 11): 111.22626733779907,\n", - " (2025, 12): 150.12032854557037},\n", - " 'window': {(2025, 1): 72.8059253692627,\n", - " (2025, 2): 97.5102186203003,\n", - " (2025, 3): 36.01697564125061,\n", - " (2025, 4): 21.655890703201294,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 3.113647699356079,\n", - " (2025, 7): 1.0161051750183105,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.5987908840179443,\n", - " (2025, 10): 4.265341281890869,\n", - " (2025, 11): 63.63022446632385,\n", - " (2025, 12): 67.11174249649048}},\n", - " 42: {'monthly': {(2025, 1): 197.83967399597168,\n", - " (2025, 2): 179.0376935005188,\n", - " (2025, 3): 45.93511152267456,\n", - " (2025, 4): 24.0921368598938,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 2.7727913856506348,\n", - " (2025, 7): 1.3365044593811035,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.6116654872894287,\n", - " (2025, 10): 6.814090013504028,\n", - " (2025, 11): 109.65411424636841,\n", - " (2025, 12): 136.879168510437},\n", - " 'window': {(2025, 1): 61.9579291343689,\n", - " (2025, 2): 122.91573715209961,\n", - " (2025, 3): 29.217111587524414,\n", - " (2025, 4): 16.05420732498169,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 2.7727913856506348,\n", - " (2025, 7): 1.3365044593811035,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.6116654872894287,\n", - " (2025, 10): 4.299688816070557,\n", - " (2025, 11): 63.71015691757202,\n", - " (2025, 12): 58.36389398574829}},\n", - " 43: {'monthly': {(2025, 1): 207.4445996284485,\n", - " (2025, 2): 195.59312880039215,\n", - " (2025, 3): 45.03839707374573,\n", - " (2025, 4): 24.932156205177307,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 2.2727365493774414,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.6477586030960083,\n", - " (2025, 10): 6.3825565576553345,\n", - " (2025, 11): 111.2986364364624,\n", - " (2025, 12): 128.92230677604675},\n", - " 'window': {(2025, 1): 63.71198081970215,\n", - " (2025, 2): 137.78377723693848,\n", - " (2025, 3): 26.10350251197815,\n", - " (2025, 4): 17.023497819900513,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 2.2727365493774414,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.6477586030960083,\n", - " (2025, 10): 4.395979881286621,\n", - " (2025, 11): 62.43173837661743,\n", - " (2025, 12): 50.438475608825684}},\n", - " 44: {'monthly': {(2025, 1): 212.6621859073639,\n", - " (2025, 2): 166.04497361183167,\n", - " (2025, 3): 44.77896821498871,\n", - " (2025, 4): 45.0639123916626,\n", - " (2025, 5): 1.015185832977295,\n", - " (2025, 6): 5.944376349449158,\n", - " (2025, 7): 6.245297789573669,\n", - " (2025, 8): 1.0428850650787354,\n", - " (2025, 9): 8.648027658462524,\n", - " (2025, 10): 8.870329737663269,\n", - " (2025, 11): 118.54123222827911,\n", - " (2025, 12): 111.4565337896347},\n", - " 'window': {(2025, 1): 79.5041651725769,\n", - " (2025, 2): 116.70241069793701,\n", - " (2025, 3): 37.562697887420654,\n", - " (2025, 4): 28.960942268371582,\n", - " (2025, 5): 1.015185832977295,\n", - " (2025, 6): 5.944376349449158,\n", - " (2025, 7): 3.740417003631592,\n", - " (2025, 8): 1.0428850650787354,\n", - " (2025, 9): 6.5589823722839355,\n", - " (2025, 10): 6.645871520042419,\n", - " (2025, 11): 77.6599588394165,\n", - " (2025, 12): 34.23305284976959}},\n", - " 45: {'monthly': {(2025, 1): 224.21737599372864,\n", - " (2025, 2): 168.53447341918945,\n", - " (2025, 3): 57.944884061813354,\n", - " (2025, 4): 52.6517870426178,\n", - " (2025, 5): 1.015185832977295,\n", - " (2025, 6): 7.051504015922546,\n", - " (2025, 7): 7.278271198272705,\n", - " (2025, 8): 2.2422432899475098,\n", - " (2025, 9): 11.589000940322876,\n", - " (2025, 10): 12.682711243629456,\n", - " (2025, 11): 128.38838493824005,\n", - " (2025, 12): 121.68317186832428},\n", - " 'window': {(2025, 1): 80.95399975776672,\n", - " (2025, 2): 110.17650699615479,\n", - " (2025, 3): 47.009366035461426,\n", - " (2025, 4): 37.191184520721436,\n", - " (2025, 5): 1.015185832977295,\n", - " (2025, 6): 7.051504015922546,\n", - " (2025, 7): 4.741535186767578,\n", - " (2025, 8): 1.1993582248687744,\n", - " (2025, 9): 9.36919116973877,\n", - " (2025, 10): 8.992891192436218,\n", - " (2025, 11): 85.58592748641968,\n", - " (2025, 12): 37.76639771461487}},\n", - " 46: {'monthly': {(2025, 1): 196.09181106090546,\n", - " (2025, 2): 143.79433155059814,\n", - " (2025, 3): 62.987847328186035,\n", - " (2025, 4): 58.37316358089447,\n", - " (2025, 5): 1.015185832977295,\n", - " (2025, 6): 7.3011332750320435,\n", - " (2025, 7): 7.460233211517334,\n", - " (2025, 8): 2.288799285888672,\n", - " (2025, 9): 12.238038539886475,\n", - " (2025, 10): 13.475182294845581,\n", - " (2025, 11): 134.31735599040985,\n", - " (2025, 12): 122.44147181510925},\n", - " 'window': {(2025, 1): 71.46584510803223,\n", - " (2025, 2): 88.65500545501709,\n", - " (2025, 3): 50.63513374328613,\n", - " (2025, 4): 42.276535511016846,\n", - " (2025, 5): 1.015185832977295,\n", - " (2025, 6): 7.3011332750320435,\n", - " (2025, 7): 5.998777866363525,\n", - " (2025, 8): 1.2459142208099365,\n", - " (2025, 9): 10.3596830368042,\n", - " (2025, 10): 9.820125460624695,\n", - " (2025, 11): 89.05067729949951,\n", - " (2025, 12): 45.28062582015991}},\n", - " 47: {'monthly': {(2025, 1): 184.25440967082977,\n", - " (2025, 2): 125.83872032165527,\n", - " (2025, 3): 80.67889249324799,\n", - " (2025, 4): 69.9271023273468,\n", - " (2025, 5): 1.015185832977295,\n", - " (2025, 6): 7.899642586708069,\n", - " (2025, 7): 14.45211148262024,\n", - " (2025, 8): 4.992063760757446,\n", - " (2025, 9): 9.84386944770813,\n", - " (2025, 10): 10.998208999633789,\n", - " (2025, 11): 154.5422271490097,\n", - " (2025, 12): 151.4912270307541},\n", - " 'window': {(2025, 1): 66.42644309997559,\n", - " (2025, 2): 72.64373874664307,\n", - " (2025, 3): 64.25467157363892,\n", - " (2025, 4): 53.3671817779541,\n", - " (2025, 5): 1.015185832977295,\n", - " (2025, 6): 7.899642586708069,\n", - " (2025, 7): 7.514301300048828,\n", - " (2025, 8): 1.7382625341415405,\n", - " (2025, 9): 7.727126121520996,\n", - " (2025, 10): 7.621477484703064,\n", - " (2025, 11): 97.13712501525879,\n", - " (2025, 12): 60.105345487594604}},\n", - " 48: {'monthly': {(2025, 1): 183.9944633245468,\n", - " (2025, 2): 178.76310169696808,\n", - " (2025, 3): 93.20705711841583,\n", - " (2025, 4): 60.00283169746399,\n", - " (2025, 5): 5.393218398094177,\n", - " (2025, 6): 16.52879774570465,\n", - " (2025, 7): 8.00468635559082,\n", - " (2025, 8): 4.293804049491882,\n", - " (2025, 9): 20.154239654541016,\n", - " (2025, 10): 15.959228277206421,\n", - " (2025, 11): 139.60011088848114,\n", - " (2025, 12): 139.24359107017517},\n", - " 'window': {(2025, 1): 67.90359592437744,\n", - " (2025, 2): 131.63783740997314,\n", - " (2025, 3): 53.345115661621094,\n", - " (2025, 4): 47.014169692993164,\n", - " (2025, 5): 2.4962326288223267,\n", - " (2025, 6): 13.033233880996704,\n", - " (2025, 7): 3.917205572128296,\n", - " (2025, 8): 2.987663984298706,\n", - " (2025, 9): 13.43239974975586,\n", - " (2025, 10): 10.96159839630127,\n", - " (2025, 11): 80.87849712371826,\n", - " (2025, 12): 49.736348390579224}},\n", - " 49: {'monthly': {(2025, 1): 205.01550710201263,\n", - " (2025, 2): 193.2222559452057,\n", - " (2025, 3): 98.8631477355957,\n", - " (2025, 4): 80.4154485464096,\n", - " (2025, 5): 7.401335835456848,\n", - " (2025, 6): 22.214237570762634,\n", - " (2025, 7): 9.015618801116943,\n", - " (2025, 8): 5.063643217086792,\n", - " (2025, 9): 28.233298301696777,\n", - " (2025, 10): 22.97839093208313,\n", - " (2025, 11): 135.63854229450226,\n", - " (2025, 12): 159.5798169374466},\n", - " 'window': {(2025, 1): 77.98406314849854,\n", - " (2025, 2): 137.4069309234619,\n", - " (2025, 3): 53.85909366607666,\n", - " (2025, 4): 61.63876390457153,\n", - " (2025, 5): 3.0576717853546143,\n", - " (2025, 6): 18.718673706054688,\n", - " (2025, 7): 4.988143444061279,\n", - " (2025, 8): 3.4166247844696045,\n", - " (2025, 9): 19.757183074951172,\n", - " (2025, 10): 16.12297821044922,\n", - " (2025, 11): 81.53920364379883,\n", - " (2025, 12): 56.893306732177734}},\n", - " 50: {'monthly': {(2025, 1): 231.63911652565002,\n", - " (2025, 2): 200.55707037448883,\n", - " (2025, 3): 115.48599338531494,\n", - " (2025, 4): 106.70046210289001,\n", - " (2025, 5): 11.070661187171936,\n", - " (2025, 6): 33.62795174121857,\n", - " (2025, 7): 12.48798143863678,\n", - " (2025, 8): 5.291725516319275,\n", - " (2025, 9): 34.10131549835205,\n", - " (2025, 10): 28.31821644306183,\n", - " (2025, 11): 144.4444922208786,\n", - " (2025, 12): 196.08153653144836},\n", - " 'window': {(2025, 1): 84.66138076782227,\n", - " (2025, 2): 127.55447483062744,\n", - " (2025, 3): 62.314788818359375,\n", - " (2025, 4): 78.9723539352417,\n", - " (2025, 5): 4.891212224960327,\n", - " (2025, 6): 25.44779324531555,\n", - " (2025, 7): 5.655297517776489,\n", - " (2025, 8): 3.5814406871795654,\n", - " (2025, 9): 25.299610137939453,\n", - " (2025, 10): 20.645913124084473,\n", - " (2025, 11): 89.13605499267578,\n", - " (2025, 12): 66.68709444999695}},\n", - " 51: {'monthly': {(2025, 1): 219.65311312675476,\n", - " (2025, 2): 166.56795406341553,\n", - " (2025, 3): 102.76129472255707,\n", - " (2025, 4): 96.91128587722778,\n", - " (2025, 5): 11.031126737594604,\n", - " (2025, 6): 28.610217690467834,\n", - " (2025, 7): 12.166637778282166,\n", - " (2025, 8): 4.123105525970459,\n", - " (2025, 9): 36.03355610370636,\n", - " (2025, 10): 31.065170884132385,\n", - " (2025, 11): 125.79839789867401,\n", - " (2025, 12): 191.50469970703125},\n", - " 'window': {(2025, 1): 80.95250797271729,\n", - " (2025, 2): 92.6774673461914,\n", - " (2025, 3): 55.34602975845337,\n", - " (2025, 4): 70.07388019561768,\n", - " (2025, 5): 3.9469289779663086,\n", - " (2025, 6): 23.042067050933838,\n", - " (2025, 7): 5.398233652114868,\n", - " (2025, 8): 2.792933464050293,\n", - " (2025, 9): 29.188039422035217,\n", - " (2025, 10): 22.96308946609497,\n", - " (2025, 11): 80.97633171081543,\n", - " (2025, 12): 67.76413369178772}},\n", - " 52: {'monthly': {(2025, 1): 341.9509165287018,\n", - " (2025, 2): 203.9052835702896,\n", - " (2025, 3): 64.55085694789886,\n", - " (2025, 4): 35.875415325164795,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 4.8104575872421265,\n", - " (2025, 11): 136.20147812366486,\n", - " (2025, 12): 178.6054083108902},\n", - " 'window': {(2025, 1): 110.61144256591797,\n", - " (2025, 2): 99.73887300491333,\n", - " (2025, 3): 30.009922981262207,\n", - " (2025, 4): 17.591198205947876,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 3.7849643230438232,\n", - " (2025, 11): 71.46822333335876,\n", - " (2025, 12): 68.51484680175781}},\n", - " 53: {'monthly': {(2025, 1): 260.4379937648773,\n", - " (2025, 2): 161.2901430130005,\n", - " (2025, 3): 65.39409697055817,\n", - " (2025, 4): 42.34230017662048,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 2.7353947162628174,\n", - " (2025, 7): 1.0505648851394653,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.3032550811767578,\n", - " (2025, 10): 6.550238132476807,\n", - " (2025, 11): 118.7419114112854,\n", - " (2025, 12): 151.4840431213379},\n", - " 'window': {(2025, 1): 97.22772789001465,\n", - " (2025, 2): 83.93046283721924,\n", - " (2025, 3): 37.93834602832794,\n", - " (2025, 4): 31.119478940963745,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 2.7353947162628174,\n", - " (2025, 7): 1.0505648851394653,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.3032550811767578,\n", - " (2025, 10): 3.4768948554992676,\n", - " (2025, 11): 68.39658403396606,\n", - " (2025, 12): 49.802141189575195}},\n", - " 54: {'monthly': {(2025, 1): 234.02046585083008,\n", - " (2025, 2): 160.8950216770172,\n", - " (2025, 3): 60.396047830581665,\n", - " (2025, 4): 40.021016120910645,\n", - " (2025, 5): 1.6072907447814941,\n", - " (2025, 6): 3.3234620094299316,\n", - " (2025, 7): 2.4757063388824463,\n", - " (2025, 8): 1.2047500610351562,\n", - " (2025, 9): 1.7286354303359985,\n", - " (2025, 10): 8.937928557395935,\n", - " (2025, 11): 126.46700704097748,\n", - " (2025, 12): 145.8248152732849},\n", - " 'window': {(2025, 1): 83.11051177978516,\n", - " (2025, 2): 97.9882116317749,\n", - " (2025, 3): 34.61178159713745,\n", - " (2025, 4): 30.187784910202026,\n", - " (2025, 5): 1.6072907447814941,\n", - " (2025, 6): 3.3234620094299316,\n", - " (2025, 7): 2.4757063388824463,\n", - " (2025, 8): 1.2047500610351562,\n", - " (2025, 9): 1.7286354303359985,\n", - " (2025, 10): 4.611747741699219,\n", - " (2025, 11): 72.54316425323486,\n", - " (2025, 12): 53.236446380615234}},\n", - " 55: {'monthly': {(2025, 1): 223.48676025867462,\n", - " (2025, 2): 194.69400453567505,\n", - " (2025, 3): 54.158650398254395,\n", - " (2025, 4): 32.34898805618286,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 4.322772145271301,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.3642712831497192,\n", - " (2025, 9): 1.9739724397659302,\n", - " (2025, 10): 7.7878429889678955,\n", - " (2025, 11): 130.18742609024048,\n", - " (2025, 12): 139.4767428636551},\n", - " 'window': {(2025, 1): 67.2583236694336,\n", - " (2025, 2): 132.71726894378662,\n", - " (2025, 3): 30.335254430770874,\n", - " (2025, 4): 23.942803144454956,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 3.311683177947998,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.3642712831497192,\n", - " (2025, 9): 1.9739724397659302,\n", - " (2025, 10): 5.266271114349365,\n", - " (2025, 11): 74.44782638549805,\n", - " (2025, 12): 50.3081579208374}},\n", - " 56: {'monthly': {(2025, 1): 220.23759067058563,\n", - " (2025, 2): 204.0963888168335,\n", - " (2025, 3): 55.35265505313873,\n", - " (2025, 4): 33.2869393825531,\n", - " (2025, 5): 2.5207207202911377,\n", - " (2025, 6): 8.513176679611206,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.987241268157959,\n", - " (2025, 10): 8.306429147720337,\n", - " (2025, 11): 124.3546690940857,\n", - " (2025, 12): 132.34973013401031},\n", - " 'window': {(2025, 1): 66.96156787872314,\n", - " (2025, 2): 138.2667646408081,\n", - " (2025, 3): 28.190630197525024,\n", - " (2025, 4): 22.901077270507812,\n", - " (2025, 5): 1.3422802686691284,\n", - " (2025, 6): 2.7990267276763916,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.987241268157959,\n", - " (2025, 10): 5.301670551300049,\n", - " (2025, 11): 66.68794584274292,\n", - " (2025, 12): 47.681435108184814}},\n", - " 57: {'monthly': {(2025, 1): 190.4604789018631,\n", - " (2025, 2): 140.992933511734,\n", - " (2025, 3): 44.28878402709961,\n", - " (2025, 4): 45.14829444885254,\n", - " (2025, 5): 1.015185832977295,\n", - " (2025, 6): 8.65297520160675,\n", - " (2025, 7): 8.18381941318512,\n", - " (2025, 8): 1.0428850650787354,\n", - " (2025, 9): 10.72830355167389,\n", - " (2025, 10): 12.380357503890991,\n", - " (2025, 11): 111.90956616401672,\n", - " (2025, 12): 115.57477819919586},\n", - " 'window': {(2025, 1): 61.162110805511475,\n", - " (2025, 2): 79.78342914581299,\n", - " (2025, 3): 35.42587208747864,\n", - " (2025, 4): 31.377235412597656,\n", - " (2025, 5): 1.015185832977295,\n", - " (2025, 6): 7.641844987869263,\n", - " (2025, 7): 3.610014796257019,\n", - " (2025, 8): 1.0428850650787354,\n", - " (2025, 9): 8.805235862731934,\n", - " (2025, 10): 8.543970942497253,\n", - " (2025, 11): 67.99100542068481,\n", - " (2025, 12): 34.35940742492676}},\n", - " 58: {'monthly': {(2025, 1): 201.85471165180206,\n", - " (2025, 2): 134.8854786157608,\n", - " (2025, 3): 60.08347046375275,\n", - " (2025, 4): 58.206024289131165,\n", - " (2025, 5): 2.1680941581726074,\n", - " (2025, 6): 8.476412057876587,\n", - " (2025, 7): 14.71070921421051,\n", - " (2025, 8): 3.623018741607666,\n", - " (2025, 9): 14.216488480567932,\n", - " (2025, 10): 18.84355390071869,\n", - " (2025, 11): 108.35520160198212,\n", - " (2025, 12): 128.1014528274536},\n", - " 'window': {(2025, 1): 64.28786134719849,\n", - " (2025, 2): 71.42139339447021,\n", - " (2025, 3): 46.69862937927246,\n", - " (2025, 4): 41.75593709945679,\n", - " (2025, 5): 1.114372968673706,\n", - " (2025, 6): 8.476412057876587,\n", - " (2025, 7): 5.99552309513092,\n", - " (2025, 8): 1.3638863563537598,\n", - " (2025, 9): 11.054232597351074,\n", - " (2025, 10): 11.452257871627808,\n", - " (2025, 11): 64.60591888427734,\n", - " (2025, 12): 39.1655650138855}},\n", - " 59: {'monthly': {(2025, 1): 187.41863179206848,\n", - " (2025, 2): 128.22675216197968,\n", - " (2025, 3): 69.62911713123322,\n", - " (2025, 4): 65.11788046360016,\n", - " (2025, 5): 1.015185832977295,\n", - " (2025, 6): 7.853113293647766,\n", - " (2025, 7): 9.509398102760315,\n", - " (2025, 8): 4.4722713232040405,\n", - " (2025, 9): 10.25095283985138,\n", - " (2025, 10): 10.24439799785614,\n", - " (2025, 11): 109.06526255607605,\n", - " (2025, 12): 131.73807835578918},\n", - " 'window': {(2025, 1): 67.25713777542114,\n", - " (2025, 2): 70.37629413604736,\n", - " (2025, 3): 55.3187460899353,\n", - " (2025, 4): 49.087520122528076,\n", - " (2025, 5): 1.015185832977295,\n", - " (2025, 6): 7.853113293647766,\n", - " (2025, 7): 5.80225133895874,\n", - " (2025, 8): 1.7238703966140747,\n", - " (2025, 9): 8.30353832244873,\n", - " (2025, 10): 8.102882742881775,\n", - " (2025, 11): 63.50374484062195,\n", - " (2025, 12): 48.382174491882324}},\n", - " 60: {'monthly': {(2025, 1): 211.8844826221466,\n", - " (2025, 2): 131.94388675689697,\n", - " (2025, 3): 89.59955096244812,\n", - " (2025, 4): 85.00802803039551,\n", - " (2025, 5): 2.069272756576538,\n", - " (2025, 6): 9.789007782936096,\n", - " (2025, 7): 10.141740202903748,\n", - " (2025, 8): 3.4412176609039307,\n", - " (2025, 9): 8.573669672012329,\n", - " (2025, 10): 7.291029453277588,\n", - " (2025, 11): 141.0250025987625,\n", - " (2025, 12): 182.84863913059235},\n", - " 'window': {(2025, 1): 66.39810609817505,\n", - " (2025, 2): 70.376220703125,\n", - " (2025, 3): 74.15287685394287,\n", - " (2025, 4): 67.02673864364624,\n", - " (2025, 5): 1.0540869235992432,\n", - " (2025, 6): 8.34051239490509,\n", - " (2025, 7): 6.575787544250488,\n", - " (2025, 8): 2.3983325958251953,\n", - " (2025, 9): 5.295172691345215,\n", - " (2025, 10): 5.590367674827576,\n", - " (2025, 11): 77.45444059371948,\n", - " (2025, 12): 73.09699440002441}},\n", - " 61: {'monthly': {(2025, 1): 238.3045048713684,\n", - " (2025, 2): 198.39040875434875,\n", - " (2025, 3): 134.429048538208,\n", - " (2025, 4): 87.16810274124146,\n", - " (2025, 5): 5.431681513786316,\n", - " (2025, 6): 22.88265073299408,\n", - " (2025, 7): 9.579973459243774,\n", - " (2025, 8): 4.838287591934204,\n", - " (2025, 9): 27.295601844787598,\n", - " (2025, 10): 27.701250314712524,\n", - " (2025, 11): 172.47526240348816,\n", - " (2025, 12): 178.52146887779236},\n", - " 'window': {(2025, 1): 68.3897294998169,\n", - " (2025, 2): 139.6977024078369,\n", - " (2025, 3): 75.57092380523682,\n", - " (2025, 4): 66.19115829467773,\n", - " (2025, 5): 2.4912238121032715,\n", - " (2025, 6): 18.287848711013794,\n", - " (2025, 7): 5.143536567687988,\n", - " (2025, 8): 3.519587278366089,\n", - " (2025, 9): 20.509122848510742,\n", - " (2025, 10): 16.73660373687744,\n", - " (2025, 11): 104.36846446990967,\n", - " (2025, 12): 62.019442081451416}},\n", - " 62: {'monthly': {(2025, 1): 241.2964495420456,\n", - " (2025, 2): 215.0252765417099,\n", - " (2025, 3): 142.2741082906723,\n", - " (2025, 4): 102.00735580921173,\n", - " (2025, 5): 8.612645506858826,\n", - " (2025, 6): 26.290950417518616,\n", - " (2025, 7): 9.078498721122742,\n", - " (2025, 8): 5.181000828742981,\n", - " (2025, 9): 38.80056154727936,\n", - " (2025, 10): 38.43685221672058,\n", - " (2025, 11): 156.35740292072296,\n", - " (2025, 12): 185.18392395973206},\n", - " 'window': {(2025, 1): 74.69237995147705,\n", - " (2025, 2): 149.20498657226562,\n", - " (2025, 3): 74.05427169799805,\n", - " (2025, 4): 77.01027631759644,\n", - " (2025, 5): 3.3636903762817383,\n", - " (2025, 6): 22.431612610816956,\n", - " (2025, 7): 6.209792613983154,\n", - " (2025, 8): 3.6399028301239014,\n", - " (2025, 9): 28.629730224609375,\n", - " (2025, 10): 23.36348009109497,\n", - " (2025, 11): 95.25046920776367,\n", - " (2025, 12): 61.549927711486816}},\n", - " 63: {'monthly': {(2025, 1): 248.70072889328003,\n", - " (2025, 2): 214.9025604724884,\n", - " (2025, 3): 145.4148176908493,\n", - " (2025, 4): 118.98283088207245,\n", - " (2025, 5): 13.202507019042969,\n", - " (2025, 6): 32.91032373905182,\n", - " (2025, 7): 12.244445323944092,\n", - " (2025, 8): 6.816258192062378,\n", - " (2025, 9): 52.39894640445709,\n", - " (2025, 10): 43.37973248958588,\n", - " (2025, 11): 159.6308981180191,\n", - " (2025, 12): 206.06565368175507},\n", - " 'window': {(2025, 1): 80.05762100219727,\n", - " (2025, 2): 129.66520500183105,\n", - " (2025, 3): 77.51864242553711,\n", - " (2025, 4): 85.47216415405273,\n", - " (2025, 5): 3.797527551651001,\n", - " (2025, 6): 26.974986791610718,\n", - " (2025, 7): 6.402740955352783,\n", - " (2025, 8): 5.086742401123047,\n", - " (2025, 9): 38.259098052978516,\n", - " (2025, 10): 31.22158908843994,\n", - " (2025, 11): 97.03315353393555,\n", - " (2025, 12): 63.604838371276855}},\n", - " 64: {'monthly': {(2025, 1): 227.17004430294037,\n", - " (2025, 2): 165.59837341308594,\n", - " (2025, 3): 125.59513485431671,\n", - " (2025, 4): 103.48880696296692,\n", - " (2025, 5): 12.770780682563782,\n", - " (2025, 6): 27.979989409446716,\n", - " (2025, 7): 13.276881337165833,\n", - " (2025, 8): 5.706259727478027,\n", - " (2025, 9): 52.13408088684082,\n", - " (2025, 10): 46.72335410118103,\n", - " (2025, 11): 139.04429161548615,\n", - " (2025, 12): 193.15921795368195},\n", - " 'window': {(2025, 1): 78.4951286315918,\n", - " (2025, 2): 91.82925701141357,\n", - " (2025, 3): 70.35525369644165,\n", - " (2025, 4): 72.71255731582642,\n", - " (2025, 5): 5.1397799253463745,\n", - " (2025, 6): 23.303045392036438,\n", - " (2025, 7): 6.834170818328857,\n", - " (2025, 8): 4.2903443574905396,\n", - " (2025, 9): 43.754146575927734,\n", - " (2025, 10): 35.70585918426514,\n", - " (2025, 11): 90.20003032684326,\n", - " (2025, 12): 61.3918821811676}},\n", - " 65: {'monthly': {(2025, 1): 263.05812203884125,\n", - " (2025, 2): 123.46658599376678,\n", - " (2025, 3): 91.23405838012695,\n", - " (2025, 4): 27.71826434135437,\n", - " (2025, 5): 1.059388279914856,\n", - " (2025, 6): 2.337953567504883,\n", - " (2025, 7): 5.008912682533264,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 4.680319666862488,\n", - " (2025, 10): 0.0,\n", - " (2025, 11): 120.17242586612701,\n", - " (2025, 12): 157.82865071296692},\n", - " 'window': {(2025, 1): 85.96877765655518,\n", - " (2025, 2): 61.85298502445221,\n", - " (2025, 3): 33.28946137428284,\n", - " (2025, 4): 15.630605578422546,\n", - " (2025, 5): 1.059388279914856,\n", - " (2025, 6): 1.3376967906951904,\n", - " (2025, 7): 2.603722095489502,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 3.532482147216797,\n", - " (2025, 10): 0.0,\n", - " (2025, 11): 56.54742181301117,\n", - " (2025, 12): 57.81931924819946}},\n", - " 66: {'monthly': {(2025, 1): 283.83225643634796,\n", - " (2025, 2): 122.57628905773163,\n", - " (2025, 3): 86.36240863800049,\n", - " (2025, 4): 40.97691869735718,\n", - " (2025, 5): 2.61528217792511,\n", - " (2025, 6): 6.758307218551636,\n", - " (2025, 7): 6.741133332252502,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 4.063277721405029,\n", - " (2025, 10): 4.393316984176636,\n", - " (2025, 11): 91.36466312408447,\n", - " (2025, 12): 190.63911294937134},\n", - " 'window': {(2025, 1): 81.58055067062378,\n", - " (2025, 2): 65.73395371437073,\n", - " (2025, 3): 37.30699014663696,\n", - " (2025, 4): 25.52816104888916,\n", - " (2025, 5): 1.350809097290039,\n", - " (2025, 6): 3.8135242462158203,\n", - " (2025, 7): 3.152102828025818,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 2.7029662132263184,\n", - " (2025, 10): 4.393316984176636,\n", - " (2025, 11): 46.08049416542053,\n", - " (2025, 12): 68.16438674926758}},\n", - " 67: {'monthly': {(2025, 1): 236.7822881937027,\n", - " (2025, 2): 129.58849823474884,\n", - " (2025, 3): 82.97594845294952,\n", - " (2025, 4): 44.92887794971466,\n", - " (2025, 5): 1.350809097290039,\n", - " (2025, 6): 6.668073534965515,\n", - " (2025, 7): 5.983878135681152,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 3.944369912147522,\n", - " (2025, 10): 3.8043558597564697,\n", - " (2025, 11): 103.2366191148758,\n", - " (2025, 12): 181.54727447032928},\n", - " 'window': {(2025, 1): 70.99493074417114,\n", - " (2025, 2): 74.052743434906,\n", - " (2025, 3): 35.90319585800171,\n", - " (2025, 4): 29.51868438720703,\n", - " (2025, 5): 1.350809097290039,\n", - " (2025, 6): 3.432811975479126,\n", - " (2025, 7): 2.5645023584365845,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 2.7029662132263184,\n", - " (2025, 10): 3.8043558597564697,\n", - " (2025, 11): 46.75066113471985,\n", - " (2025, 12): 61.63581323623657}},\n", - " 68: {'monthly': {(2025, 1): 211.03632962703705,\n", - " (2025, 2): 129.76741182804108,\n", - " (2025, 3): 81.25004208087921,\n", - " (2025, 4): 45.679139137268066,\n", - " (2025, 5): 1.6529747247695923,\n", - " (2025, 6): 6.765506267547607,\n", - " (2025, 7): 7.017965197563171,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 3.778913140296936,\n", - " (2025, 10): 6.058583855628967,\n", - " (2025, 11): 108.34233355522156,\n", - " (2025, 12): 182.23116040229797},\n", - " 'window': {(2025, 1): 59.78683423995972,\n", - " (2025, 2): 70.427769780159,\n", - " (2025, 3): 35.847004413604736,\n", - " (2025, 4): 29.701042652130127,\n", - " (2025, 5): 1.6529747247695923,\n", - " (2025, 6): 3.762932300567627,\n", - " (2025, 7): 3.385153889656067,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 2.7029662132263184,\n", - " (2025, 10): 3.9508590698242188,\n", - " (2025, 11): 42.61266493797302,\n", - " (2025, 12): 58.381529569625854}},\n", - " 69: {'monthly': {(2025, 1): 215.18754720687866,\n", - " (2025, 2): 131.41314005851746,\n", - " (2025, 3): 88.24478948116302,\n", - " (2025, 4): 40.54480576515198,\n", - " (2025, 5): 2.9404807090759277,\n", - " (2025, 6): 7.956616640090942,\n", - " (2025, 7): 8.415147066116333,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 4.463445663452148,\n", - " (2025, 10): 5.2195717096328735,\n", - " (2025, 11): 112.23661959171295,\n", - " (2025, 12): 180.42222011089325},\n", - " 'window': {(2025, 1): 59.81887435913086,\n", - " (2025, 2): 71.88744175434113,\n", - " (2025, 3): 37.65164041519165,\n", - " (2025, 4): 25.761240005493164,\n", - " (2025, 5): 1.8232719898223877,\n", - " (2025, 6): 3.7210179567337036,\n", - " (2025, 7): 4.965014815330505,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 3.4326329231262207,\n", - " (2025, 10): 4.045440077781677,\n", - " (2025, 11): 42.213608264923096,\n", - " (2025, 12): 58.68302059173584}},\n", - " 70: {'monthly': {(2025, 1): 208.82283675670624,\n", - " (2025, 2): 126.50351858139038,\n", - " (2025, 3): 60.42565178871155,\n", - " (2025, 4): 56.04471266269684,\n", - " (2025, 5): 3.8605927228927612,\n", - " (2025, 6): 8.489579796791077,\n", - " (2025, 7): 3.727582097053528,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 6.149792194366455,\n", - " (2025, 10): 7.331442952156067,\n", - " (2025, 11): 109.56444752216339,\n", - " (2025, 12): 159.24870944023132},\n", - " 'window': {(2025, 1): 56.72954559326172,\n", - " (2025, 2): 65.3105525970459,\n", - " (2025, 3): 38.016462326049805,\n", - " (2025, 4): 39.93749022483826,\n", - " (2025, 5): 1.5212432146072388,\n", - " (2025, 6): 7.139792084693909,\n", - " (2025, 7): 3.727582097053528,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 2.589116096496582,\n", - " (2025, 10): 3.37268328666687,\n", - " (2025, 11): 41.740407943725586,\n", - " (2025, 12): 43.83563041687012}},\n", - " 71: {'monthly': {(2025, 1): 211.86824798583984,\n", - " (2025, 2): 146.18661999702454,\n", - " (2025, 3): 74.34676563739777,\n", - " (2025, 4): 68.27218985557556,\n", - " (2025, 5): 6.311609864234924,\n", - " (2025, 6): 11.01815664768219,\n", - " (2025, 7): 2.5324223041534424,\n", - " (2025, 8): 3.5938031673431396,\n", - " (2025, 9): 5.730841159820557,\n", - " (2025, 10): 7.849411725997925,\n", - " (2025, 11): 122.24800026416779,\n", - " (2025, 12): 158.90511798858643},\n", - " 'window': {(2025, 1): 57.3961706161499,\n", - " (2025, 2): 84.19239664077759,\n", - " (2025, 3): 47.71127653121948,\n", - " (2025, 4): 48.18365669250488,\n", - " (2025, 5): 4.293334126472473,\n", - " (2025, 6): 9.995540976524353,\n", - " (2025, 7): 2.5324223041534424,\n", - " (2025, 8): 2.5133711099624634,\n", - " (2025, 9): 2.964426040649414,\n", - " (2025, 10): 2.525827407836914,\n", - " (2025, 11): 58.601948738098145,\n", - " (2025, 12): 41.60021781921387}},\n", - " 72: {'monthly': {(2025, 1): 189.17683386802673,\n", - " (2025, 2): 160.19834661483765,\n", - " (2025, 3): 77.0723067522049,\n", - " (2025, 4): 63.42357790470123,\n", - " (2025, 5): 7.845686912536621,\n", - " (2025, 6): 9.51357352733612,\n", - " (2025, 7): 3.938851237297058,\n", - " (2025, 8): 2.795011043548584,\n", - " (2025, 9): 3.9360504150390625,\n", - " (2025, 10): 5.7581998109817505,\n", - " (2025, 11): 122.48352241516113,\n", - " (2025, 12): 163.5675013065338},\n", - " 'window': {(2025, 1): 50.941611766815186,\n", - " (2025, 2): 97.26622152328491,\n", - " (2025, 3): 53.41921043395996,\n", - " (2025, 4): 47.5691351890564,\n", - " (2025, 5): 3.269097328186035,\n", - " (2025, 6): 8.438342213630676,\n", - " (2025, 7): 2.8288280963897705,\n", - " (2025, 8): 2.795011043548584,\n", - " (2025, 9): 2.236727476119995,\n", - " (2025, 10): 1.8288477659225464,\n", - " (2025, 11): 63.02794289588928,\n", - " (2025, 12): 44.816877365112305}},\n", - " 73: {'monthly': {(2025, 1): 253.09979701042175,\n", - " (2025, 2): 173.85878229141235,\n", - " (2025, 3): 85.16782402992249,\n", - " (2025, 4): 62.21206736564636,\n", - " (2025, 5): 3.4386314153671265,\n", - " (2025, 6): 8.936148762702942,\n", - " (2025, 7): 5.073719620704651,\n", - " (2025, 8): 2.3163788318634033,\n", - " (2025, 9): 2.97530198097229,\n", - " (2025, 10): 6.633344769477844,\n", - " (2025, 11): 146.39393949508667,\n", - " (2025, 12): 201.8124884366989},\n", - " 'window': {(2025, 1): 80.52366256713867,\n", - " (2025, 2): 91.12360954284668,\n", - " (2025, 3): 54.39279222488403,\n", - " (2025, 4): 44.19857096672058,\n", - " (2025, 5): 1.7714558839797974,\n", - " (2025, 6): 8.936148762702942,\n", - " (2025, 7): 2.874000310897827,\n", - " (2025, 8): 2.3163788318634033,\n", - " (2025, 9): 1.7915586233139038,\n", - " (2025, 10): 2.9112660884857178,\n", - " (2025, 11): 71.1425244808197,\n", - " (2025, 12): 72.54697799682617}},\n", - " 74: {'monthly': {(2025, 1): 311.7303113937378,\n", - " (2025, 2): 144.61558413505554,\n", - " (2025, 3): 127.18361461162567,\n", - " (2025, 4): 114.36870813369751,\n", - " (2025, 5): 18.671830534934998,\n", - " (2025, 6): 20.797780513763428,\n", - " (2025, 7): 10.180509686470032,\n", - " (2025, 8): 3.1422955989837646,\n", - " (2025, 9): 10.088618993759155,\n", - " (2025, 10): 13.65741741657257,\n", - " (2025, 11): 146.5592679977417,\n", - " (2025, 12): 181.01938092708588},\n", - " 'window': {(2025, 1): 95.46424865722656,\n", - " (2025, 2): 64.03393363952637,\n", - " (2025, 3): 73.62589168548584,\n", - " (2025, 4): 86.014235496521,\n", - " (2025, 5): 10.91013479232788,\n", - " (2025, 6): 13.39298939704895,\n", - " (2025, 7): 6.498237729072571,\n", - " (2025, 8): 1.6382170915603638,\n", - " (2025, 9): 3.487978219985962,\n", - " (2025, 10): 4.410862565040588,\n", - " (2025, 11): 70.8625283241272,\n", - " (2025, 12): 51.43097400665283}},\n", - " 75: {'monthly': {(2025, 1): 268.10530853271484,\n", - " (2025, 2): 137.73253166675568,\n", - " (2025, 3): 119.18794667720795,\n", - " (2025, 4): 98.59422540664673,\n", - " (2025, 5): 14.352666974067688,\n", - " (2025, 6): 14.209357380867004,\n", - " (2025, 7): 10.422621250152588,\n", - " (2025, 8): 2.672679901123047,\n", - " (2025, 9): 8.42499029636383,\n", - " (2025, 10): 13.6093590259552,\n", - " (2025, 11): 134.55026376247406,\n", - " (2025, 12): 158.5722702741623},\n", - " 'window': {(2025, 1): 92.53438186645508,\n", - " (2025, 2): 62.59475898742676,\n", - " (2025, 3): 77.57352495193481,\n", - " (2025, 4): 76.0434455871582,\n", - " (2025, 5): 8.636771202087402,\n", - " (2025, 6): 10.948142170906067,\n", - " (2025, 7): 5.000102519989014,\n", - " (2025, 8): 1.4494928121566772,\n", - " (2025, 9): 3.74202299118042,\n", - " (2025, 10): 4.257943153381348,\n", - " (2025, 11): 63.136860370635986,\n", - " (2025, 12): 41.23944091796875}},\n", - " 76: {'monthly': {(2025, 1): 276.2315639257431,\n", - " (2025, 2): 139.3161222934723,\n", - " (2025, 3): 122.2128734588623,\n", - " (2025, 4): 104.56251776218414,\n", - " (2025, 5): 13.170438528060913,\n", - " (2025, 6): 19.13423717021942,\n", - " (2025, 7): 9.624648809432983,\n", - " (2025, 8): 2.796787977218628,\n", - " (2025, 9): 14.542440295219421,\n", - " (2025, 10): 23.279565930366516,\n", - " (2025, 11): 134.93854236602783,\n", - " (2025, 12): 158.5689378976822},\n", - " 'window': {(2025, 1): 94.10370445251465,\n", - " (2025, 2): 62.663516998291016,\n", - " (2025, 3): 75.00194311141968,\n", - " (2025, 4): 80.58242988586426,\n", - " (2025, 5): 9.042980194091797,\n", - " (2025, 6): 12.262095093727112,\n", - " (2025, 7): 5.6195197105407715,\n", - " (2025, 8): 1.6934092044830322,\n", - " (2025, 9): 6.365742921829224,\n", - " (2025, 10): 7.046409845352173,\n", - " (2025, 11): 57.65457248687744,\n", - " (2025, 12): 45.72633981704712}},\n", - " 77: {'monthly': {(2025, 1): 242.0947299003601,\n", - " (2025, 2): 123.7306489944458,\n", - " (2025, 3): 110.22960638999939,\n", - " (2025, 4): 93.68041050434113,\n", - " (2025, 5): 14.284128546714783,\n", - " (2025, 6): 15.832693696022034,\n", - " (2025, 7): 9.41358506679535,\n", - " (2025, 8): 7.757978081703186,\n", - " (2025, 9): 14.26967978477478,\n", - " (2025, 10): 24.167202830314636,\n", - " (2025, 11): 136.96637797355652,\n", - " (2025, 12): 141.9329228401184},\n", - " 'window': {(2025, 1): 83.69701766967773,\n", - " (2025, 2): 56.09425163269043,\n", - " (2025, 3): 67.28122234344482,\n", - " (2025, 4): 70.72895336151123,\n", - " (2025, 5): 8.973753929138184,\n", - " (2025, 6): 11.306148529052734,\n", - " (2025, 7): 5.134066581726074,\n", - " (2025, 8): 4.891467094421387,\n", - " (2025, 9): 4.8119776248931885,\n", - " (2025, 10): 7.487240552902222,\n", - " (2025, 11): 55.6576566696167,\n", - " (2025, 12): 46.834144592285156}},\n", - " 78: {'monthly': {(2025, 1): 265.25264406204224,\n", - " (2025, 2): 120.1875387430191,\n", - " (2025, 3): 93.20723974704742,\n", - " (2025, 4): 34.97776210308075,\n", - " (2025, 5): 1.059388279914856,\n", - " (2025, 6): 2.337953567504883,\n", - " (2025, 7): 2.6289639472961426,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 4.012012243270874,\n", - " (2025, 10): 0.0,\n", - " (2025, 11): 113.84093642234802,\n", - " (2025, 12): 174.82997691631317},\n", - " 'window': {(2025, 1): 89.24707508087158,\n", - " (2025, 2): 60.67914342880249,\n", - " (2025, 3): 35.23443949222565,\n", - " (2025, 4): 20.998417735099792,\n", - " (2025, 5): 1.059388279914856,\n", - " (2025, 6): 1.3376967906951904,\n", - " (2025, 7): 2.6289639472961426,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 2.864174723625183,\n", - " (2025, 10): 0.0,\n", - " (2025, 11): 47.93148875236511,\n", - " (2025, 12): 66.85685682296753}},\n", - " 79: {'monthly': {(2025, 1): 255.1561473608017,\n", - " (2025, 2): 122.4292927980423,\n", - " (2025, 3): 95.11813962459564,\n", - " (2025, 4): 45.864882826805115,\n", - " (2025, 5): 1.350809097290039,\n", - " (2025, 6): 6.434711694717407,\n", - " (2025, 7): 6.158299088478088,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 3.809486150741577,\n", - " (2025, 10): 5.379624724388123,\n", - " (2025, 11): 119.34709405899048,\n", - " (2025, 12): 188.23323702812195},\n", - " 'window': {(2025, 1): 73.09427547454834,\n", - " (2025, 2): 62.025097012519836,\n", - " (2025, 3): 41.54321765899658,\n", - " (2025, 4): 31.208146691322327,\n", - " (2025, 5): 1.350809097290039,\n", - " (2025, 6): 2.788695812225342,\n", - " (2025, 7): 2.569268584251404,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 2.7029662132263184,\n", - " (2025, 10): 4.141377687454224,\n", - " (2025, 11): 50.26706051826477,\n", - " (2025, 12): 61.9737024307251}},\n", - " 80: {'monthly': {(2025, 1): 229.90854489803314,\n", - " (2025, 2): 122.25857031345367,\n", - " (2025, 3): 97.05842566490173,\n", - " (2025, 4): 52.811264395713806,\n", - " (2025, 5): 1.3644719123840332,\n", - " (2025, 6): 5.582498669624329,\n", - " (2025, 7): 10.002705454826355,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 4.073414921760559,\n", - " (2025, 10): 5.2950520515441895,\n", - " (2025, 11): 123.50065207481384,\n", - " (2025, 12): 185.11700475215912},\n", - " 'window': {(2025, 1): 69.58894443511963,\n", - " (2025, 2): 64.86743295192719,\n", - " (2025, 3): 40.426382541656494,\n", - " (2025, 4): 37.489808082580566,\n", - " (2025, 5): 1.3644719123840332,\n", - " (2025, 6): 2.825069785118103,\n", - " (2025, 7): 3.627692699432373,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 3.0305198431015015,\n", - " (2025, 10): 3.778416633605957,\n", - " (2025, 11): 45.83136248588562,\n", - " (2025, 12): 57.76091480255127}},\n", - " 81: {'monthly': {(2025, 1): 231.942316532135,\n", - " (2025, 2): 138.5462737083435,\n", - " (2025, 3): 110.83270728588104,\n", - " (2025, 4): 57.643054604530334,\n", - " (2025, 5): 2.545213222503662,\n", - " (2025, 6): 6.453288197517395,\n", - " (2025, 7): 10.007201433181763,\n", - " (2025, 8): 1.1984591484069824,\n", - " (2025, 9): 4.330943584442139,\n", - " (2025, 10): 6.972271919250488,\n", - " (2025, 11): 146.16083812713623,\n", - " (2025, 12): 183.66613268852234},\n", - " 'window': {(2025, 1): 76.88314437866211,\n", - " (2025, 2): 71.5765061378479,\n", - " (2025, 3): 45.139973640441895,\n", - " (2025, 4): 41.65147137641907,\n", - " (2025, 5): 1.406508207321167,\n", - " (2025, 6): 3.311492919921875,\n", - " (2025, 7): 3.6191192865371704,\n", - " (2025, 8): 1.1984591484069824,\n", - " (2025, 9): 3.3129353523254395,\n", - " (2025, 10): 5.261731147766113,\n", - " (2025, 11): 56.00687837600708,\n", - " (2025, 12): 57.94095730781555}},\n", - " 82: {'monthly': {(2025, 1): 262.19687843322754,\n", - " (2025, 2): 150.78048622608185,\n", - " (2025, 3): 115.82906484603882,\n", - " (2025, 4): 60.08534288406372,\n", - " (2025, 5): 3.0786505937576294,\n", - " (2025, 6): 8.679896354675293,\n", - " (2025, 7): 8.267008423805237,\n", - " (2025, 8): 1.401328206062317,\n", - " (2025, 9): 3.767023205757141,\n", - " (2025, 10): 9.254636645317078,\n", - " (2025, 11): 147.76597225666046,\n", - " (2025, 12): 190.8255294561386},\n", - " 'window': {(2025, 1): 85.79159355163574,\n", - " (2025, 2): 73.54532814025879,\n", - " (2025, 3): 48.39227247238159,\n", - " (2025, 4): 41.8918639421463,\n", - " (2025, 5): 1.765524983406067,\n", - " (2025, 6): 3.7403454780578613,\n", - " (2025, 7): 4.358040690422058,\n", - " (2025, 8): 1.401328206062317,\n", - " (2025, 9): 3.767023205757141,\n", - " (2025, 10): 6.517192482948303,\n", - " (2025, 11): 58.22282814979553,\n", - " (2025, 12): 62.55450391769409}},\n", - " 83: {'monthly': {(2025, 1): 263.5326271057129,\n", - " (2025, 2): 139.24590575695038,\n", - " (2025, 3): 74.67348563671112,\n", - " (2025, 4): 78.909383893013,\n", - " (2025, 5): 4.998216032981873,\n", - " (2025, 6): 9.058707118034363,\n", - " (2025, 7): 2.993904948234558,\n", - " (2025, 8): 1.0840785503387451,\n", - " (2025, 9): 3.376512289047241,\n", - " (2025, 10): 6.33028507232666,\n", - " (2025, 11): 134.2283103466034,\n", - " (2025, 12): 181.9171826839447},\n", - " 'window': {(2025, 1): 81.93491172790527,\n", - " (2025, 2): 67.45309543609619,\n", - " (2025, 3): 47.64772605895996,\n", - " (2025, 4): 55.26151418685913,\n", - " (2025, 5): 3.0977076292037964,\n", - " (2025, 6): 9.058707118034363,\n", - " (2025, 7): 2.993904948234558,\n", - " (2025, 8): 1.0840785503387451,\n", - " (2025, 9): 1.8104588985443115,\n", - " (2025, 10): 2.265174150466919,\n", - " (2025, 11): 57.609333515167236,\n", - " (2025, 12): 58.32779026031494}},\n", - " 84: {'monthly': {(2025, 1): 257.5127795934677,\n", - " (2025, 2): 154.36940205097198,\n", - " (2025, 3): 92.37879276275635,\n", - " (2025, 4): 96.1575413942337,\n", - " (2025, 5): 8.859336256980896,\n", - " (2025, 6): 13.981260418891907,\n", - " (2025, 7): 4.114176392555237,\n", - " (2025, 8): 5.31354296207428,\n", - " (2025, 9): 7.562465071678162,\n", - " (2025, 10): 10.080323934555054,\n", - " (2025, 11): 165.82006788253784,\n", - " (2025, 12): 198.41531574726105},\n", - " 'window': {(2025, 1): 78.1598892211914,\n", - " (2025, 2): 71.12961912155151,\n", - " (2025, 3): 56.783297538757324,\n", - " (2025, 4): 68.33902740478516,\n", - " (2025, 5): 3.570356607437134,\n", - " (2025, 6): 11.289482235908508,\n", - " (2025, 7): 4.114176392555237,\n", - " (2025, 8): 3.158108115196228,\n", - " (2025, 9): 4.109356999397278,\n", - " (2025, 10): 3.053649425506592,\n", - " (2025, 11): 79.90549755096436,\n", - " (2025, 12): 53.088228702545166}},\n", - " 85: {'monthly': {(2025, 1): 251.79012942314148,\n", - " (2025, 2): 152.07670426368713,\n", - " (2025, 3): 92.77332174777985,\n", - " (2025, 4): 83.01098275184631,\n", - " (2025, 5): 8.75395667552948,\n", - " (2025, 6): 13.501541376113892,\n", - " (2025, 7): 3.4369146823883057,\n", - " (2025, 8): 2.87890362739563,\n", - " (2025, 9): 7.24999475479126,\n", - " (2025, 10): 9.302400827407837,\n", - " (2025, 11): 168.9433035850525,\n", - " (2025, 12): 187.11336183547974},\n", - " 'window': {(2025, 1): 72.60371971130371,\n", - " (2025, 2): 75.86978816986084,\n", - " (2025, 3): 59.44987916946411,\n", - " (2025, 4): 59.23373031616211,\n", - " (2025, 5): 3.8498075008392334,\n", - " (2025, 6): 12.204374313354492,\n", - " (2025, 7): 3.4369146823883057,\n", - " (2025, 8): 2.87890362739563,\n", - " (2025, 9): 5.125330448150635,\n", - " (2025, 10): 4.46309232711792,\n", - " (2025, 11): 95.19765663146973,\n", - " (2025, 12): 69.16967105865479}},\n", - " 86: {'monthly': {(2025, 1): 254.87825632095337,\n", - " (2025, 2): 156.12750482559204,\n", - " (2025, 3): 99.56670868396759,\n", - " (2025, 4): 75.71405386924744,\n", - " (2025, 5): 8.549924731254578,\n", - " (2025, 6): 12.497374057769775,\n", - " (2025, 7): 6.754217624664307,\n", - " (2025, 8): 1.3525184392929077,\n", - " (2025, 9): 4.659030079841614,\n", - " (2025, 10): 10.528322219848633,\n", - " (2025, 11): 183.0644176006317,\n", - " (2025, 12): 208.84654796123505},\n", - " 'window': {(2025, 1): 73.31815242767334,\n", - " (2025, 2): 74.83669662475586,\n", - " (2025, 3): 55.43504333496094,\n", - " (2025, 4): 51.23063039779663,\n", - " (2025, 5): 5.122441291809082,\n", - " (2025, 6): 11.393481016159058,\n", - " (2025, 7): 4.322080731391907,\n", - " (2025, 8): 1.3525184392929077,\n", - " (2025, 9): 2.6048024892807007,\n", - " (2025, 10): 5.445341110229492,\n", - " (2025, 11): 100.35218596458435,\n", - " (2025, 12): 95.32615494728088}},\n", - " 87: {'monthly': {(2025, 1): 243.28469944000244,\n", - " (2025, 2): 123.86213207244873,\n", - " (2025, 3): 104.02778720855713,\n", - " (2025, 4): 98.48692715167999,\n", - " (2025, 5): 11.770264625549316,\n", - " (2025, 6): 9.461215257644653,\n", - " (2025, 7): 1.9288716316223145,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 2.624449372291565,\n", - " (2025, 10): 6.657801389694214,\n", - " (2025, 11): 117.53096222877502,\n", - " (2025, 12): 140.10145127773285},\n", - " 'window': {(2025, 1): 75.9713659286499,\n", - " (2025, 2): 61.741050720214844,\n", - " (2025, 3): 60.15956926345825,\n", - " (2025, 4): 78.52332401275635,\n", - " (2025, 5): 7.405276298522949,\n", - " (2025, 6): 8.193020224571228,\n", - " (2025, 7): 1.9288716316223145,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.4845983982086182,\n", - " (2025, 10): 4.18628716468811,\n", - " (2025, 11): 51.99869465827942,\n", - " (2025, 12): 44.55823516845703}},\n", - " 88: {'monthly': {(2025, 1): 222.1919709444046,\n", - " (2025, 2): 114.68594825267792,\n", - " (2025, 3): 91.93955886363983,\n", - " (2025, 4): 79.80664050579071,\n", - " (2025, 5): 8.37359619140625,\n", - " (2025, 6): 6.606139540672302,\n", - " (2025, 7): 1.6174136400222778,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 2.377721428871155,\n", - " (2025, 10): 4.588992238044739,\n", - " (2025, 11): 108.40859341621399,\n", - " (2025, 12): 119.61331117153168},\n", - " 'window': {(2025, 1): 76.61179733276367,\n", - " (2025, 2): 62.00204086303711,\n", - " (2025, 3): 58.6259880065918,\n", - " (2025, 4): 63.221665382385254,\n", - " (2025, 5): 5.8478851318359375,\n", - " (2025, 6): 6.606139540672302,\n", - " (2025, 7): 1.6174136400222778,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.267451286315918,\n", - " (2025, 10): 2.4020214080810547,\n", - " (2025, 11): 54.031947016716,\n", - " (2025, 12): 34.42208707332611}},\n", - " 89: {'monthly': {(2025, 1): 218.69764471054077,\n", - " (2025, 2): 110.29008913040161,\n", - " (2025, 3): 89.44434463977814,\n", - " (2025, 4): 73.69809544086456,\n", - " (2025, 5): 6.642237186431885,\n", - " (2025, 6): 7.018864035606384,\n", - " (2025, 7): 1.800466537475586,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 4.352529048919678,\n", - " (2025, 10): 5.610173344612122,\n", - " (2025, 11): 118.45585501194,\n", - " (2025, 12): 123.22144436836243},\n", - " 'window': {(2025, 1): 69.42041206359863,\n", - " (2025, 2): 54.693994998931885,\n", - " (2025, 3): 54.226386070251465,\n", - " (2025, 4): 56.835806369781494,\n", - " (2025, 5): 4.995591640472412,\n", - " (2025, 6): 7.018864035606384,\n", - " (2025, 7): 1.800466537475586,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.664867639541626,\n", - " (2025, 10): 2.3427982330322266,\n", - " (2025, 11): 61.07159352302551,\n", - " (2025, 12): 40.932196855545044}},\n", - " 90: {'monthly': {(2025, 1): 206.95602786540985,\n", - " (2025, 2): 100.14137184619904,\n", - " (2025, 3): 85.5794073343277,\n", - " (2025, 4): 65.43271899223328,\n", - " (2025, 5): 7.516170859336853,\n", - " (2025, 6): 6.689883589744568,\n", - " (2025, 7): 1.6776937246322632,\n", - " (2025, 8): 1.0640625953674316,\n", - " (2025, 9): 5.9117878675460815,\n", - " (2025, 10): 9.065009355545044,\n", - " (2025, 11): 124.87731885910034,\n", - " (2025, 12): 127.51125621795654},\n", - " 'window': {(2025, 1): 63.823463439941406,\n", - " (2025, 2): 46.41227149963379,\n", - " (2025, 3): 53.46083450317383,\n", - " (2025, 4): 50.3556694984436,\n", - " (2025, 5): 6.020519733428955,\n", - " (2025, 6): 6.689883589744568,\n", - " (2025, 7): 1.6776937246322632,\n", - " (2025, 8): 1.0640625953674316,\n", - " (2025, 9): 3.1184821128845215,\n", - " (2025, 10): 4.752116560935974,\n", - " (2025, 11): 61.726572155952454,\n", - " (2025, 12): 44.807363748550415}},\n", - " 91: {'monthly': {(2025, 1): 277.0974643230438,\n", - " (2025, 2): 125.53939712047577,\n", - " (2025, 3): 96.56670033931732,\n", - " (2025, 4): 44.739349365234375,\n", - " (2025, 5): 1.059388279914856,\n", - " (2025, 6): 2.337953567504883,\n", - " (2025, 7): 2.603722095489502,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 2.21669602394104,\n", - " (2025, 10): 1.057877540588379,\n", - " (2025, 11): 104.38912892341614,\n", - " (2025, 12): 189.34114110469818},\n", - " 'window': {(2025, 1): 92.98027420043945,\n", - " (2025, 2): 63.593575954437256,\n", - " (2025, 3): 39.06646680831909,\n", - " (2025, 4): 28.613413095474243,\n", - " (2025, 5): 1.059388279914856,\n", - " (2025, 6): 1.3376967906951904,\n", - " (2025, 7): 2.603722095489502,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 2.21669602394104,\n", - " (2025, 10): 1.057877540588379,\n", - " (2025, 11): 42.32777690887451,\n", - " (2025, 12): 71.47144508361816}},\n", - " 92: {'monthly': {(2025, 1): 231.47240447998047,\n", - " (2025, 2): 135.20944595336914,\n", - " (2025, 3): 100.59625315666199,\n", - " (2025, 4): 46.33695876598358,\n", - " (2025, 5): 1.350809097290039,\n", - " (2025, 6): 5.3102439641952515,\n", - " (2025, 7): 6.367721199989319,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 2.7029662132263184,\n", - " (2025, 10): 4.237248063087463,\n", - " (2025, 11): 139.7230385541916,\n", - " (2025, 12): 181.33762061595917},\n", - " 'window': {(2025, 1): 71.3974084854126,\n", - " (2025, 2): 69.1765775680542,\n", - " (2025, 3): 41.32153844833374,\n", - " (2025, 4): 31.477288007736206,\n", - " (2025, 5): 1.350809097290039,\n", - " (2025, 6): 2.7788056135177612,\n", - " (2025, 7): 2.7786906957626343,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 2.7029662132263184,\n", - " (2025, 10): 2.677032470703125,\n", - " (2025, 11): 57.91882300376892,\n", - " (2025, 12): 61.202104568481445}},\n", - " 93: {'monthly': {(2025, 1): 226.3131809234619,\n", - " (2025, 2): 138.86642491817474,\n", - " (2025, 3): 111.28257095813751,\n", - " (2025, 4): 56.44026470184326,\n", - " (2025, 5): 2.481269121170044,\n", - " (2025, 6): 6.933068156242371,\n", - " (2025, 7): 6.568758249282837,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 2.7333227396011353,\n", - " (2025, 10): 6.019146084785461,\n", - " (2025, 11): 146.25946187973022,\n", - " (2025, 12): 196.61260998249054},\n", - " 'window': {(2025, 1): 68.94553565979004,\n", - " (2025, 2): 66.98627400398254,\n", - " (2025, 3): 43.069350242614746,\n", - " (2025, 4): 41.69721531867981,\n", - " (2025, 5): 1.3302112817764282,\n", - " (2025, 6): 3.3221189975738525,\n", - " (2025, 7): 2.8541135787963867,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 2.7333227396011353,\n", - " (2025, 10): 4.215920448303223,\n", - " (2025, 11): 54.58583068847656,\n", - " (2025, 12): 64.06686305999756}},\n", - " 94: {'monthly': {(2025, 1): 299.6578668355942,\n", - " (2025, 2): 169.32405996322632,\n", - " (2025, 3): 138.32921063899994,\n", - " (2025, 4): 69.65125668048859,\n", - " (2025, 5): 2.9051589965820312,\n", - " (2025, 6): 8.966796040534973,\n", - " (2025, 7): 9.15168559551239,\n", - " (2025, 8): 1.645544171333313,\n", - " (2025, 9): 5.07309353351593,\n", - " (2025, 10): 10.042739033699036,\n", - " (2025, 11): 183.3781702518463,\n", - " (2025, 12): 218.99141609668732},\n", - " 'window': {(2025, 1): 97.29249954223633,\n", - " (2025, 2): 77.94244813919067,\n", - " (2025, 3): 52.24262285232544,\n", - " (2025, 4): 47.42096161842346,\n", - " (2025, 5): 1.553675651550293,\n", - " (2025, 6): 4.336980819702148,\n", - " (2025, 7): 5.370195508003235,\n", - " (2025, 8): 1.645544171333313,\n", - " (2025, 9): 3.927670478820801,\n", - " (2025, 10): 6.6895424127578735,\n", - " (2025, 11): 73.96412110328674,\n", - " (2025, 12): 72.59436273574829}},\n", - " 95: {'monthly': {(2025, 1): 319.5340497493744,\n", - " (2025, 2): 173.19687855243683,\n", - " (2025, 3): 138.73786687850952,\n", - " (2025, 4): 73.62939310073853,\n", - " (2025, 5): 5.724846243858337,\n", - " (2025, 6): 11.290196299552917,\n", - " (2025, 7): 10.07873547077179,\n", - " (2025, 8): 4.330814719200134,\n", - " (2025, 9): 6.049054145812988,\n", - " (2025, 10): 10.86624789237976,\n", - " (2025, 11): 178.01776313781738,\n", - " (2025, 12): 218.55184769630432},\n", - " 'window': {(2025, 1): 104.77831840515137,\n", - " (2025, 2): 77.32971429824829,\n", - " (2025, 3): 52.25050640106201,\n", - " (2025, 4): 46.45262265205383,\n", - " (2025, 5): 2.7355462312698364,\n", - " (2025, 6): 4.236639618873596,\n", - " (2025, 7): 6.035364747047424,\n", - " (2025, 8): 3.2966543436050415,\n", - " (2025, 9): 3.853134036064148,\n", - " (2025, 10): 7.520659327507019,\n", - " (2025, 11): 70.63874626159668,\n", - " (2025, 12): 71.35599994659424}},\n", - " 96: {'monthly': {(2025, 1): 252.82120096683502,\n", - " (2025, 2): 141.81007778644562,\n", - " (2025, 3): 73.89717280864716,\n", - " (2025, 4): 84.50644981861115,\n", - " (2025, 5): 5.061766624450684,\n", - " (2025, 6): 8.707733869552612,\n", - " (2025, 7): 4.270192980766296,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 2.8380852937698364,\n", - " (2025, 10): 8.18686318397522,\n", - " (2025, 11): 131.98056197166443,\n", - " (2025, 12): 192.65476143360138},\n", - " 'window': {(2025, 1): 70.96129512786865,\n", - " (2025, 2): 58.07054042816162,\n", - " (2025, 3): 46.151050090789795,\n", - " (2025, 4): 57.59116792678833,\n", - " (2025, 5): 3.1950833797454834,\n", - " (2025, 6): 8.707733869552612,\n", - " (2025, 7): 4.270192980766296,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.550754189491272,\n", - " (2025, 10): 3.835054397583008,\n", - " (2025, 11): 55.40233254432678,\n", - " (2025, 12): 57.81933784484863}},\n", - " 97: {'monthly': {(2025, 1): 278.3900331258774,\n", - " (2025, 2): 147.70144665241241,\n", - " (2025, 3): 95.3499413728714,\n", - " (2025, 4): 97.23427152633667,\n", - " (2025, 5): 6.422463417053223,\n", - " (2025, 6): 16.037393808364868,\n", - " (2025, 7): 9.292752861976624,\n", - " (2025, 8): 2.57221782207489,\n", - " (2025, 9): 5.30222749710083,\n", - " (2025, 10): 10.951244711875916,\n", - " (2025, 11): 175.28556537628174,\n", - " (2025, 12): 222.36849284172058},\n", - " 'window': {(2025, 1): 77.24560832977295,\n", - " (2025, 2): 56.91579246520996,\n", - " (2025, 3): 55.083720207214355,\n", - " (2025, 4): 66.803701877594,\n", - " (2025, 5): 3.722287893295288,\n", - " (2025, 6): 11.486609816551208,\n", - " (2025, 7): 5.555752754211426,\n", - " (2025, 8): 1.342829704284668,\n", - " (2025, 9): 2.31963849067688,\n", - " (2025, 10): 4.30371618270874,\n", - " (2025, 11): 80.75537729263306,\n", - " (2025, 12): 60.944737672805786}},\n", - " 98: {'monthly': {(2025, 1): 283.14289796352386,\n", - " (2025, 2): 149.45952379703522,\n", - " (2025, 3): 106.04027247428894,\n", - " (2025, 4): 91.1027842760086,\n", - " (2025, 5): 8.751784920692444,\n", - " (2025, 6): 15.512740969657898,\n", - " (2025, 7): 10.896851301193237,\n", - " (2025, 8): 3.646196126937866,\n", - " (2025, 9): 7.254123210906982,\n", - " (2025, 10): 13.91996943950653,\n", - " (2025, 11): 197.77519285678864,\n", - " (2025, 12): 209.91541421413422},\n", - " 'window': {(2025, 1): 85.2634162902832,\n", - " (2025, 2): 61.85077667236328,\n", - " (2025, 3): 62.68043851852417,\n", - " (2025, 4): 59.0718207359314,\n", - " (2025, 5): 5.2664207220077515,\n", - " (2025, 6): 12.912088871002197,\n", - " (2025, 7): 5.293224215507507,\n", - " (2025, 8): 2.225614905357361,\n", - " (2025, 9): 3.925796389579773,\n", - " (2025, 10): 5.849088668823242,\n", - " (2025, 11): 106.08230304718018,\n", - " (2025, 12): 77.09078776836395}},\n", - " 99: {'monthly': {(2025, 1): 232.48331356048584,\n", - " (2025, 2): 151.71931099891663,\n", - " (2025, 3): 86.88652193546295,\n", - " (2025, 4): 65.32140791416168,\n", - " (2025, 5): 5.608394384384155,\n", - " (2025, 6): 9.100839734077454,\n", - " (2025, 7): 2.948753595352173,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 3.0190746784210205,\n", - " (2025, 10): 8.76192307472229,\n", - " (2025, 11): 192.9405279159546,\n", - " (2025, 12): 208.42018163204193},\n", - " 'window': {(2025, 1): 63.41269779205322,\n", - " (2025, 2): 63.01880359649658,\n", - " (2025, 3): 54.35979461669922,\n", - " (2025, 4): 44.95553016662598,\n", - " (2025, 5): 2.811758279800415,\n", - " (2025, 6): 9.100839734077454,\n", - " (2025, 7): 2.948753595352173,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.7187448740005493,\n", - " (2025, 10): 5.1729736328125,\n", - " (2025, 11): 121.6035304069519,\n", - " (2025, 12): 96.61637961864471}},\n", - " 100: {'monthly': {(2025, 1): 253.67714977264404,\n", - " (2025, 2): 136.8028211593628,\n", - " (2025, 3): 104.11799919605255,\n", - " (2025, 4): 81.09969878196716,\n", - " (2025, 5): 9.424033880233765,\n", - " (2025, 6): 5.9659377336502075,\n", - " (2025, 7): 1.0584839582443237,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 2.720468044281006,\n", - " (2025, 10): 3.471943497657776,\n", - " (2025, 11): 112.4216240644455,\n", - " (2025, 12): 132.8412766456604},\n", - " 'window': {(2025, 1): 78.62559509277344,\n", - " (2025, 2): 73.75074195861816,\n", - " (2025, 3): 60.91443943977356,\n", - " (2025, 4): 64.60719227790833,\n", - " (2025, 5): 6.878354549407959,\n", - " (2025, 6): 5.9659377336502075,\n", - " (2025, 7): 1.0584839582443237,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.5140599012374878,\n", - " (2025, 10): 2.3869192600250244,\n", - " (2025, 11): 51.43811869621277,\n", - " (2025, 12): 41.804086208343506}},\n", - " 101: {'monthly': {(2025, 1): 277.8532223701477,\n", - " (2025, 2): 152.9505933523178,\n", - " (2025, 3): 108.40072655677795,\n", - " (2025, 4): 76.98275053501129,\n", - " (2025, 5): 9.06248140335083,\n", - " (2025, 6): 5.242628455162048,\n", - " (2025, 7): 1.2544293403625488,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 3.3544046878814697,\n", - " (2025, 10): 4.965215086936951,\n", - " (2025, 11): 131.0836958885193,\n", - " (2025, 12): 143.99616849422455},\n", - " 'window': {(2025, 1): 86.91176700592041,\n", - " (2025, 2): 83.25541687011719,\n", - " (2025, 3): 66.07458257675171,\n", - " (2025, 4): 59.6375949382782,\n", - " (2025, 5): 5.940957069396973,\n", - " (2025, 6): 5.242628455162048,\n", - " (2025, 7): 1.2544293403625488,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.9670230150222778,\n", - " (2025, 10): 2.7047343254089355,\n", - " (2025, 11): 71.93124210834503,\n", - " (2025, 12): 52.179041385650635}},\n", - " 102: {'monthly': {(2025, 1): 256.113024353981,\n", - " (2025, 2): 138.17950117588043,\n", - " (2025, 3): 100.23588502407074,\n", - " (2025, 4): 70.95790445804596,\n", - " (2025, 5): 6.296205759048462,\n", - " (2025, 6): 5.789784073829651,\n", - " (2025, 7): 1.3542345762252808,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 3.4915106296539307,\n", - " (2025, 10): 4.977767467498779,\n", - " (2025, 11): 151.14171588420868,\n", - " (2025, 12): 143.75041472911835},\n", - " 'window': {(2025, 1): 77.75953197479248,\n", - " (2025, 2): 71.79667282104492,\n", - " (2025, 3): 58.35950708389282,\n", - " (2025, 4): 53.39666748046875,\n", - " (2025, 5): 4.00905704498291,\n", - " (2025, 6): 5.789784073829651,\n", - " (2025, 7): 1.3542345762252808,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 2.073374032974243,\n", - " (2025, 10): 2.475712776184082,\n", - " (2025, 11): 88.94590353965759,\n", - " (2025, 12): 59.72186231613159}},\n", - " 103: {'monthly': {(2025, 1): 242.06343173980713,\n", - " (2025, 2): 113.58901119232178,\n", - " (2025, 3): 87.51109313964844,\n", - " (2025, 4): 61.869282960891724,\n", - " (2025, 5): 5.562716484069824,\n", - " (2025, 6): 5.452250361442566,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 2.276033401489258,\n", - " (2025, 10): 4.965387344360352,\n", - " (2025, 11): 141.69974100589752,\n", - " (2025, 12): 144.00158023834229},\n", - " 'window': {(2025, 1): 74.58579063415527,\n", - " (2025, 2): 55.48049974441528,\n", - " (2025, 3): 52.1291241645813,\n", - " (2025, 4): 45.681232929229736,\n", - " (2025, 5): 4.209499359130859,\n", - " (2025, 6): 5.452250361442566,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 2.276033401489258,\n", - " (2025, 10): 2.556119203567505,\n", - " (2025, 11): 80.98038637638092,\n", - " (2025, 12): 58.68699765205383}},\n", - " 104: {'monthly': {(2025, 1): 286.3634731769562,\n", - " (2025, 2): 145.20707404613495,\n", - " (2025, 3): 110.46562886238098,\n", - " (2025, 4): 52.35788869857788,\n", - " (2025, 5): 1.059388279914856,\n", - " (2025, 6): 2.337953567504883,\n", - " (2025, 7): 2.698874354362488,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 3.6186412572860718,\n", - " (2025, 10): 2.2302753925323486,\n", - " (2025, 11): 112.72319388389587,\n", - " (2025, 12): 211.35270750522614},\n", - " 'window': {(2025, 1): 104.59245777130127,\n", - " (2025, 2): 60.968783378601074,\n", - " (2025, 3): 44.655418395996094,\n", - " (2025, 4): 31.5513117313385,\n", - " (2025, 5): 1.059388279914856,\n", - " (2025, 6): 1.3376967906951904,\n", - " (2025, 7): 2.698874354362488,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 3.6186412572860718,\n", - " (2025, 10): 2.2302753925323486,\n", - " (2025, 11): 48.21009922027588,\n", - " (2025, 12): 72.32797908782959}},\n", - " 105: {'monthly': {(2025, 1): 249.08287489414215,\n", - " (2025, 2): 152.56268846988678,\n", - " (2025, 3): 109.10439145565033,\n", - " (2025, 4): 49.342822432518005,\n", - " (2025, 5): 2.504875421524048,\n", - " (2025, 6): 5.675889611244202,\n", - " (2025, 7): 6.2783873081207275,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 2.7029662132263184,\n", - " (2025, 10): 5.911950469017029,\n", - " (2025, 11): 154.94607961177826,\n", - " (2025, 12): 200.01241433620453},\n", - " 'window': {(2025, 1): 71.60508155822754,\n", - " (2025, 2): 69.5628752708435,\n", - " (2025, 3): 41.183191776275635,\n", - " (2025, 4): 31.38107442855835,\n", - " (2025, 5): 1.350809097290039,\n", - " (2025, 6): 3.007710814476013,\n", - " (2025, 7): 2.689356803894043,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 2.7029662132263184,\n", - " (2025, 10): 3.708306312561035,\n", - " (2025, 11): 72.091224193573,\n", - " (2025, 12): 61.717153549194336}},\n", - " 106: {'monthly': {(2025, 1): 272.0396134853363,\n", - " (2025, 2): 165.78110110759735,\n", - " (2025, 3): 136.97278356552124,\n", - " (2025, 4): 62.915879130363464,\n", - " (2025, 5): 2.6723791360855103,\n", - " (2025, 6): 5.475272297859192,\n", - " (2025, 7): 5.979428768157959,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 3.7287317514419556,\n", - " (2025, 10): 9.772231221199036,\n", - " (2025, 11): 175.51104259490967,\n", - " (2025, 12): 243.5832041501999},\n", - " 'window': {(2025, 1): 75.14994525909424,\n", - " (2025, 2): 68.31389284133911,\n", - " (2025, 3): 51.44347631931305,\n", - " (2025, 4): 44.98770761489868,\n", - " (2025, 5): 1.391312599182129,\n", - " (2025, 6): 2.8677271604537964,\n", - " (2025, 7): 2.5645023584365845,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 2.7029662132263184,\n", - " (2025, 10): 5.754459023475647,\n", - " (2025, 11): 75.82415342330933,\n", - " (2025, 12): 74.58350276947021}},\n", - " 107: {'monthly': {(2025, 1): 361.74434757232666,\n", - " (2025, 2): 197.87062001228333,\n", - " (2025, 3): 159.1908096075058,\n", - " (2025, 4): 76.9518815279007,\n", - " (2025, 5): 4.77044141292572,\n", - " (2025, 6): 12.424097180366516,\n", - " (2025, 7): 10.71955394744873,\n", - " (2025, 8): 1.5832934379577637,\n", - " (2025, 9): 11.193279266357422,\n", - " (2025, 10): 10.88224720954895,\n", - " (2025, 11): 189.3147131204605,\n", - " (2025, 12): 254.67291963100433},\n", - " 'window': {(2025, 1): 101.65064907073975,\n", - " (2025, 2): 85.33168697357178,\n", - " (2025, 3): 58.94690418243408,\n", - " (2025, 4): 47.361494302749634,\n", - " (2025, 5): 2.6062854528427124,\n", - " (2025, 6): 5.5803000926971436,\n", - " (2025, 7): 5.87658417224884,\n", - " (2025, 8): 1.5832934379577637,\n", - " (2025, 9): 8.396666049957275,\n", - " (2025, 10): 6.314050674438477,\n", - " (2025, 11): 75.80397939682007,\n", - " (2025, 12): 80.17870903015137}},\n", - " 108: {'monthly': {(2025, 1): 341.63006615638733,\n", - " (2025, 2): 191.60776352882385,\n", - " (2025, 3): 146.27835190296173,\n", - " (2025, 4): 68.01738035678864,\n", - " (2025, 5): 6.82470965385437,\n", - " (2025, 6): 13.369403839111328,\n", - " (2025, 7): 11.28999388217926,\n", - " (2025, 8): 2.7811107635498047,\n", - " (2025, 9): 5.952256560325623,\n", - " (2025, 10): 12.0100839138031,\n", - " (2025, 11): 152.29042088985443,\n", - " (2025, 12): 218.14246892929077},\n", - " 'window': {(2025, 1): 99.98952674865723,\n", - " (2025, 2): 80.67643928527832,\n", - " (2025, 3): 54.13803672790527,\n", - " (2025, 4): 38.39859318733215,\n", - " (2025, 5): 3.2537593841552734,\n", - " (2025, 6): 5.5034648180007935,\n", - " (2025, 7): 6.334212422370911,\n", - " (2025, 8): 1.7501317262649536,\n", - " (2025, 9): 4.8850483894348145,\n", - " (2025, 10): 6.49880051612854,\n", - " (2025, 11): 60.29742097854614,\n", - " (2025, 12): 69.04710817337036}},\n", - " 109: {'monthly': {(2025, 1): 232.08430862426758,\n", - " (2025, 2): 118.67116022109985,\n", - " (2025, 3): 73.58807718753815,\n", - " (2025, 4): 77.19375085830688,\n", - " (2025, 5): 3.3796491622924805,\n", - " (2025, 6): 7.423375248908997,\n", - " (2025, 7): 5.2175270318984985,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 2.44068706035614,\n", - " (2025, 10): 8.333417296409607,\n", - " (2025, 11): 109.71686124801636,\n", - " (2025, 12): 163.73496544361115},\n", - " 'window': {(2025, 1): 64.19953203201294,\n", - " (2025, 2): 49.113680839538574,\n", - " (2025, 3): 38.95898723602295,\n", - " (2025, 4): 52.93734788894653,\n", - " (2025, 5): 1.8813194036483765,\n", - " (2025, 6): 7.423375248908997,\n", - " (2025, 7): 5.2175270318984985,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.3463029861450195,\n", - " (2025, 10): 3.107392907142639,\n", - " (2025, 11): 43.71831178665161,\n", - " (2025, 12): 46.85199499130249}},\n", - " 110: {'monthly': {(2025, 1): 264.0479345321655,\n", - " (2025, 2): 139.50986301898956,\n", - " (2025, 3): 92.3061990737915,\n", - " (2025, 4): 83.30289912223816,\n", - " (2025, 5): 6.00904643535614,\n", - " (2025, 6): 7.977949261665344,\n", - " (2025, 7): 6.3877270221710205,\n", - " (2025, 8): 1.4265873432159424,\n", - " (2025, 9): 6.346933841705322,\n", - " (2025, 10): 10.202466607093811,\n", - " (2025, 11): 146.3946417570114,\n", - " (2025, 12): 193.7119470834732},\n", - " 'window': {(2025, 1): 70.2377290725708,\n", - " (2025, 2): 51.00083541870117,\n", - " (2025, 3): 47.16413116455078,\n", - " (2025, 4): 54.92643690109253,\n", - " (2025, 5): 2.865956425666809,\n", - " (2025, 6): 7.977949261665344,\n", - " (2025, 7): 6.3877270221710205,\n", - " (2025, 8): 1.4265873432159424,\n", - " (2025, 9): 2.5993878841400146,\n", - " (2025, 10): 6.16117537021637,\n", - " (2025, 11): 60.168885231018066,\n", - " (2025, 12): 56.23741292953491}},\n", - " 111: {'monthly': {(2025, 1): 298.49626338481903,\n", - " (2025, 2): 155.85247993469238,\n", - " (2025, 3): 108.66890895366669,\n", - " (2025, 4): 86.17570841312408,\n", - " (2025, 5): 5.060388088226318,\n", - " (2025, 6): 10.198359727859497,\n", - " (2025, 7): 3.7041985988616943,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 7.325383543968201,\n", - " (2025, 10): 9.06231164932251,\n", - " (2025, 11): 181.21603298187256,\n", - " (2025, 12): 227.7943913936615},\n", - " 'window': {(2025, 1): 87.16803169250488,\n", - " (2025, 2): 62.35117816925049,\n", - " (2025, 3): 65.05862426757812,\n", - " (2025, 4): 52.91213417053223,\n", - " (2025, 5): 3.119934916496277,\n", - " (2025, 6): 8.955651879310608,\n", - " (2025, 7): 3.7041985988616943,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 3.2719260454177856,\n", - " (2025, 10): 4.9321675300598145,\n", - " (2025, 11): 78.0522518157959,\n", - " (2025, 12): 65.51935410499573}},\n", - " 112: {'monthly': {(2025, 1): 249.04183721542358,\n", - " (2025, 2): 146.37783467769623,\n", - " (2025, 3): 89.72334146499634,\n", - " (2025, 4): 60.19504106044769,\n", - " (2025, 5): 5.060623049736023,\n", - " (2025, 6): 6.763291001319885,\n", - " (2025, 7): 2.5067933797836304,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.0199521780014038,\n", - " (2025, 10): 7.138890981674194,\n", - " (2025, 11): 156.80005311965942,\n", - " (2025, 12): 214.45948719978333},\n", - " 'window': {(2025, 1): 69.87834167480469,\n", - " (2025, 2): 64.18386363983154,\n", - " (2025, 3): 60.272589683532715,\n", - " (2025, 4): 44.78246450424194,\n", - " (2025, 5): 2.493560552597046,\n", - " (2025, 6): 6.763291001319885,\n", - " (2025, 7): 2.5067933797836304,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.0199521780014038,\n", - " (2025, 10): 3.2754242420196533,\n", - " (2025, 11): 87.65532493591309,\n", - " (2025, 12): 73.25127696990967}},\n", - " 113: {'monthly': {(2025, 1): 255.15164625644684,\n", - " (2025, 2): 149.11293530464172,\n", - " (2025, 3): 96.80782580375671,\n", - " (2025, 4): 64.2533129453659,\n", - " (2025, 5): 7.640849471092224,\n", - " (2025, 6): 4.931644082069397,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 2.7455183267593384,\n", - " (2025, 10): 4.973979711532593,\n", - " (2025, 11): 98.21817362308502,\n", - " (2025, 12): 119.71701085567474},\n", - " 'window': {(2025, 1): 76.39451599121094,\n", - " (2025, 2): 81.40706253051758,\n", - " (2025, 3): 55.088704347610474,\n", - " (2025, 4): 48.41992950439453,\n", - " (2025, 5): 5.66568660736084,\n", - " (2025, 6): 4.931644082069397,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.5860671997070312,\n", - " (2025, 10): 3.9276446104049683,\n", - " (2025, 11): 43.00202035903931,\n", - " (2025, 12): 37.09405469894409}},\n", - " 114: {'monthly': {(2025, 1): 296.04381144046783,\n", - " (2025, 2): 176.70611560344696,\n", - " (2025, 3): 111.37862527370453,\n", - " (2025, 4): 64.10556817054749,\n", - " (2025, 5): 7.9571850299835205,\n", - " (2025, 6): 4.467527985572815,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 2.794644594192505,\n", - " (2025, 10): 6.115269780158997,\n", - " (2025, 11): 118.48742473125458,\n", - " (2025, 12): 145.4082067012787},\n", - " 'window': {(2025, 1): 85.40210628509521,\n", - " (2025, 2): 94.29802322387695,\n", - " (2025, 3): 65.9121618270874,\n", - " (2025, 4): 48.35893964767456,\n", - " (2025, 5): 5.363621234893799,\n", - " (2025, 6): 4.467527985572815,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.7001093626022339,\n", - " (2025, 10): 4.5318063497543335,\n", - " (2025, 11): 59.13864326477051,\n", - " (2025, 12): 48.45332407951355}},\n", - " 115: {'monthly': {(2025, 1): 265.84053122997284,\n", - " (2025, 2): 155.1581153869629,\n", - " (2025, 3): 106.7834882736206,\n", - " (2025, 4): 60.2594530582428,\n", - " (2025, 5): 6.688169956207275,\n", - " (2025, 6): 5.105856776237488,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 2.8177523612976074,\n", - " (2025, 10): 3.9275859594345093,\n", - " (2025, 11): 136.61194229125977,\n", - " (2025, 12): 140.51850986480713},\n", - " 'window': {(2025, 1): 81.48994255065918,\n", - " (2025, 2): 82.61903858184814,\n", - " (2025, 3): 63.55216407775879,\n", - " (2025, 4): 44.80051612854004,\n", - " (2025, 5): 4.463176727294922,\n", - " (2025, 6): 5.105856776237488,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.679065227508545,\n", - " (2025, 10): 2.884784460067749,\n", - " (2025, 11): 75.93431210517883,\n", - " (2025, 12): 55.40281820297241}},\n", - " 116: {'monthly': {(2025, 1): 256.3521525859833,\n", - " (2025, 2): 141.89943540096283,\n", - " (2025, 3): 98.46534419059753,\n", - " (2025, 4): 50.35513484477997,\n", - " (2025, 5): 6.953295946121216,\n", - " (2025, 6): 5.4101234674453735,\n", - " (2025, 7): 1.0279228687286377,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.1512303352355957,\n", - " (2025, 10): 6.053805708885193,\n", - " (2025, 11): 134.4733155965805,\n", - " (2025, 12): 139.49594736099243},\n", - " 'window': {(2025, 1): 88.3946533203125,\n", - " (2025, 2): 65.07986879348755,\n", - " (2025, 3): 59.274555683135986,\n", - " (2025, 4): 35.47332000732422,\n", - " (2025, 5): 5.205903053283691,\n", - " (2025, 6): 5.4101234674453735,\n", - " (2025, 7): 1.0279228687286377,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.1512303352355957,\n", - " (2025, 10): 4.9464802742004395,\n", - " (2025, 11): 72.44981336593628,\n", - " (2025, 12): 55.28195142745972}},\n", - " 117: {'monthly': {(2025, 1): 275.8169219493866,\n", - " (2025, 2): 154.42329132556915,\n", - " (2025, 3): 216.39501631259918,\n", - " (2025, 4): 83.91279673576355,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 4.52395236492157,\n", - " (2025, 7): 1.2389661073684692,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 5.937850713729858,\n", - " (2025, 11): 139.2477504014969,\n", - " (2025, 12): 201.2741218805313},\n", - " 'window': {(2025, 1): 111.61024856567383,\n", - " (2025, 2): 93.18272423744202,\n", - " (2025, 3): 67.26771378517151,\n", - " (2025, 4): 44.79625606536865,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 3.294763684272766,\n", - " (2025, 7): 1.2389661073684692,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 2.4296839237213135,\n", - " (2025, 11): 64.76685905456543,\n", - " (2025, 12): 67.41202771663666}},\n", - " 118: {'monthly': {(2025, 1): 258.3620390892029,\n", - " (2025, 2): 128.6313911676407,\n", - " (2025, 3): 294.465882897377,\n", - " (2025, 4): 76.63880515098572,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 3.398778200149536,\n", - " (2025, 7): 3.4585750102996826,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 2.527076005935669,\n", - " (2025, 10): 6.261610150337219,\n", - " (2025, 11): 126.76477146148682,\n", - " (2025, 12): 268.4145164489746},\n", - " 'window': {(2025, 1): 98.49635410308838,\n", - " (2025, 2): 65.72429084777832,\n", - " (2025, 3): 101.61395406723022,\n", - " (2025, 4): 46.57457208633423,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.3110469579696655,\n", - " (2025, 7): 1.2657777070999146,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 2.527076005935669,\n", - " (2025, 10): 4.09751570224762,\n", - " (2025, 11): 47.68091058731079,\n", - " (2025, 12): 139.64282822608948}},\n", - " 119: {'monthly': {(2025, 1): 301.2052764892578,\n", - " (2025, 2): 166.39883053302765,\n", - " (2025, 3): 308.4822031259537,\n", - " (2025, 4): 92.04816818237305,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 4.438563942909241,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.0827730894088745,\n", - " (2025, 10): 12.419430255889893,\n", - " (2025, 11): 163.79079115390778,\n", - " (2025, 12): 362.15361857414246},\n", - " 'window': {(2025, 1): 106.170578956604,\n", - " (2025, 2): 85.39311528205872,\n", - " (2025, 3): 93.52712416648865,\n", - " (2025, 4): 62.87349891662598,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 2.0828628540039062,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.0827730894088745,\n", - " (2025, 10): 7.009835481643677,\n", - " (2025, 11): 76.20890426635742,\n", - " (2025, 12): 187.9257755279541}},\n", - " 120: {'monthly': {(2025, 1): 326.5047127008438,\n", - " (2025, 2): 193.24999904632568,\n", - " (2025, 3): 276.53575599193573,\n", - " (2025, 4): 100.54197025299072,\n", - " (2025, 5): 2.1997662782669067,\n", - " (2025, 6): 3.1290203332901,\n", - " (2025, 7): 9.053944110870361,\n", - " (2025, 8): 1.0349452495574951,\n", - " (2025, 9): 1.776624083518982,\n", - " (2025, 10): 12.304599404335022,\n", - " (2025, 11): 157.55353224277496,\n", - " (2025, 12): 341.65752029418945},\n", - " 'window': {(2025, 1): 115.96589660644531,\n", - " (2025, 2): 108.92726039886475,\n", - " (2025, 3): 80.12761402130127,\n", - " (2025, 4): 68.5632438659668,\n", - " (2025, 5): 1.1618026494979858,\n", - " (2025, 6): 1.82725989818573,\n", - " (2025, 7): 3.1691510677337646,\n", - " (2025, 8): 1.0349452495574951,\n", - " (2025, 9): 1.776624083518982,\n", - " (2025, 10): 6.00690770149231,\n", - " (2025, 11): 61.9470796585083,\n", - " (2025, 12): 176.1766266822815}},\n", - " 121: {'monthly': {(2025, 1): 280.9142050743103,\n", - " (2025, 2): 192.83859753608704,\n", - " (2025, 3): 223.47867286205292,\n", - " (2025, 4): 85.4840372800827,\n", - " (2025, 5): 2.53628933429718,\n", - " (2025, 6): 5.581605672836304,\n", - " (2025, 7): 7.542062997817993,\n", - " (2025, 8): 1.3630433082580566,\n", - " (2025, 9): 2.7070714235305786,\n", - " (2025, 10): 11.95646357536316,\n", - " (2025, 11): 128.10247564315796,\n", - " (2025, 12): 263.0313996076584},\n", - " 'window': {(2025, 1): 109.27976894378662,\n", - " (2025, 2): 118.80743598937988,\n", - " (2025, 3): 62.613441705703735,\n", - " (2025, 4): 56.099141120910645,\n", - " (2025, 5): 1.5091497898101807,\n", - " (2025, 6): 2.209596872329712,\n", - " (2025, 7): 3.109945774078369,\n", - " (2025, 8): 1.3630433082580566,\n", - " (2025, 9): 1.5410041809082031,\n", - " (2025, 10): 5.883304595947266,\n", - " (2025, 11): 52.43195724487305,\n", - " (2025, 12): 129.33044147491455}},\n", - " 122: {'monthly': {(2025, 1): 213.13276040554047,\n", - " (2025, 2): 158.92112600803375,\n", - " (2025, 3): 144.02882993221283,\n", - " (2025, 4): 81.36851370334625,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 2.3986973762512207,\n", - " (2025, 7): 3.2220258712768555,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 17.567728996276855,\n", - " (2025, 11): 69.45600879192352,\n", - " (2025, 12): 183.90443217754364},\n", - " 'window': {(2025, 1): 67.34588146209717,\n", - " (2025, 2): 94.56903457641602,\n", - " (2025, 3): 48.44589853286743,\n", - " (2025, 4): 55.931827545166016,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 2.3986973762512207,\n", - " (2025, 7): 3.2220258712768555,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 5.5740872621536255,\n", - " (2025, 11): 26.4003689289093,\n", - " (2025, 12): 65.90932512283325}},\n", - " 123: {'monthly': {(2025, 1): 230.93431735038757,\n", - " (2025, 2): 141.03775548934937,\n", - " (2025, 3): 170.62119591236115,\n", - " (2025, 4): 73.51576864719391,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.1989398002624512,\n", - " (2025, 7): 4.06662130355835,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.5437450408935547,\n", - " (2025, 10): 15.683007955551147,\n", - " (2025, 11): 73.13105762004852,\n", - " (2025, 12): 213.5877810716629},\n", - " 'window': {(2025, 1): 69.47761821746826,\n", - " (2025, 2): 74.92503786087036,\n", - " (2025, 3): 70.3124828338623,\n", - " (2025, 4): 52.77019739151001,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.1989398002624512,\n", - " (2025, 7): 2.8748161792755127,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.5437450408935547,\n", - " (2025, 10): 6.308616757392883,\n", - " (2025, 11): 26.273743629455566,\n", - " (2025, 12): 86.90858745574951}},\n", - " 124: {'monthly': {(2025, 1): 307.6421684026718,\n", - " (2025, 2): 158.06338703632355,\n", - " (2025, 3): 176.67489528656006,\n", - " (2025, 4): 78.10078001022339,\n", - " (2025, 5): 1.0439051389694214,\n", - " (2025, 6): 3.841708183288574,\n", - " (2025, 7): 4.339650392532349,\n", - " (2025, 8): 1.1217083930969238,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 21.16819190979004,\n", - " (2025, 11): 109.04964232444763,\n", - " (2025, 12): 231.42465579509735},\n", - " 'window': {(2025, 1): 97.77812385559082,\n", - " (2025, 2): 76.33250093460083,\n", - " (2025, 3): 70.1818470954895,\n", - " (2025, 4): 57.95455551147461,\n", - " (2025, 5): 1.0439051389694214,\n", - " (2025, 6): 3.841708183288574,\n", - " (2025, 7): 4.339650392532349,\n", - " (2025, 8): 1.1217083930969238,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 9.394171237945557,\n", - " (2025, 11): 48.447096824645996,\n", - " (2025, 12): 98.72192144393921}},\n", - " 125: {'monthly': {(2025, 1): 314.94060385227203,\n", - " (2025, 2): 132.07114350795746,\n", - " (2025, 3): 144.9608428478241,\n", - " (2025, 4): 75.64052438735962,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.1989398002624512,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.4092457294464111,\n", - " (2025, 10): 16.057546973228455,\n", - " (2025, 11): 100.83980226516724,\n", - " (2025, 12): 218.26438522338867},\n", - " 'window': {(2025, 1): 105.14135837554932,\n", - " (2025, 2): 66.81930303573608,\n", - " (2025, 3): 55.543193340301514,\n", - " (2025, 4): 58.18239879608154,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.1989398002624512,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.4092457294464111,\n", - " (2025, 10): 7.197759747505188,\n", - " (2025, 11): 40.87999963760376,\n", - " (2025, 12): 109.66462469100952}},\n", - " 126: {'monthly': {(2025, 1): 238.07593429088593,\n", - " (2025, 2): 121.54394805431366,\n", - " (2025, 3): 145.90809762477875,\n", - " (2025, 4): 79.73863554000854,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.5300917625427246,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 15.639932870864868,\n", - " (2025, 11): 83.66562688350677,\n", - " (2025, 12): 222.1014904975891},\n", - " 'window': {(2025, 1): 88.9696912765503,\n", - " (2025, 2): 48.67920637130737,\n", - " (2025, 3): 58.84268379211426,\n", - " (2025, 4): 59.41506814956665,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.5300917625427246,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 7.060210227966309,\n", - " (2025, 11): 41.55758488178253,\n", - " (2025, 12): 95.95621228218079}},\n", - " 127: {'monthly': {(2025, 1): 240.87197387218475,\n", - " (2025, 2): 124.86981546878815,\n", - " (2025, 3): 157.92657148838043,\n", - " (2025, 4): 86.17633736133575,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.7948849201202393,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.1658215522766113,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 14.169641971588135,\n", - " (2025, 11): 90.49012470245361,\n", - " (2025, 12): 230.52073788642883},\n", - " 'window': {(2025, 1): 92.00682258605957,\n", - " (2025, 2): 53.322914123535156,\n", - " (2025, 3): 65.47080278396606,\n", - " (2025, 4): 65.45600605010986,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.7948849201202393,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.1658215522766113,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 5.247386455535889,\n", - " (2025, 11): 48.445085406303406,\n", - " (2025, 12): 111.62028241157532}},\n", - " 128: {'monthly': {(2025, 1): 213.53149735927582,\n", - " (2025, 2): 108.70835041999817,\n", - " (2025, 3): 148.48048329353333,\n", - " (2025, 4): 81.43369448184967,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 2.5846880674362183,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.1454129219055176,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 9.438063621520996,\n", - " (2025, 11): 78.09291243553162,\n", - " (2025, 12): 192.73252058029175},\n", - " 'window': {(2025, 1): 81.31247997283936,\n", - " (2025, 2): 46.643027782440186,\n", - " (2025, 3): 68.23865175247192,\n", - " (2025, 4): 61.48011875152588,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.5300917625427246,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.1454129219055176,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 4.359115123748779,\n", - " (2025, 11): 39.357017397880554,\n", - " (2025, 12): 86.99467301368713}},\n", - " 129: {'monthly': {(2025, 1): 215.7230850458145,\n", - " (2025, 2): 107.40717542171478,\n", - " (2025, 3): 145.71667349338531,\n", - " (2025, 4): 66.44777023792267,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.5546544790267944,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 9.131550550460815,\n", - " (2025, 11): 76.60100769996643,\n", - " (2025, 12): 168.31831228733063},\n", - " 'window': {(2025, 1): 74.28373146057129,\n", - " (2025, 2): 44.96179223060608,\n", - " (2025, 3): 66.19780778884888,\n", - " (2025, 4): 47.06409811973572,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.5546544790267944,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 4.006606578826904,\n", - " (2025, 11): 33.08429205417633,\n", - " (2025, 12): 65.28500843048096}},\n", - " 130: {'monthly': {(2025, 1): 292.0451843738556,\n", - " (2025, 2): 171.15191793441772,\n", - " (2025, 3): 241.83111381530762,\n", - " (2025, 4): 95.27023506164551,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 5.1032315492630005,\n", - " (2025, 7): 1.3793604373931885,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 7.307154655456543,\n", - " (2025, 11): 148.31461668014526,\n", - " (2025, 12): 260.03745698928833},\n", - " 'window': {(2025, 1): 115.03540229797363,\n", - " (2025, 2): 96.73600482940674,\n", - " (2025, 3): 71.91723680496216,\n", - " (2025, 4): 52.379090309143066,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 3.6559020280838013,\n", - " (2025, 7): 1.3793604373931885,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 3.8546531200408936,\n", - " (2025, 11): 70.90589380264282,\n", - " (2025, 12): 110.06365060806274}},\n", - " 131: {'monthly': {(2025, 1): 292.43618190288544,\n", - " (2025, 2): 141.24972558021545,\n", - " (2025, 3): 308.6538956165314,\n", - " (2025, 4): 99.74707436561584,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 3.9854272603988647,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.308392882347107,\n", - " (2025, 10): 10.856126308441162,\n", - " (2025, 11): 185.9157601594925,\n", - " (2025, 12): 378.5451376438141},\n", - " 'window': {(2025, 1): 99.0553207397461,\n", - " (2025, 2): 64.60879039764404,\n", - " (2025, 3): 98.17092847824097,\n", - " (2025, 4): 60.4545202255249,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 1.6297261714935303,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.308392882347107,\n", - " (2025, 10): 5.269010066986084,\n", - " (2025, 11): 74.77163171768188,\n", - " (2025, 12): 214.83458518981934}},\n", - " 132: {'monthly': {(2025, 1): 346.1528545618057,\n", - " (2025, 2): 186.08088648319244,\n", - " (2025, 3): 310.0628366470337,\n", - " (2025, 4): 109.98296809196472,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.002833366394043,\n", - " (2025, 7): 4.803498387336731,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 2.652606964111328,\n", - " (2025, 10): 12.961244702339172,\n", - " (2025, 11): 197.22516453266144,\n", - " (2025, 12): 424.05782556533813},\n", - " 'window': {(2025, 1): 109.37752056121826,\n", - " (2025, 2): 87.00761842727661,\n", - " (2025, 3): 98.27753686904907,\n", - " (2025, 4): 69.90490055084229,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.002833366394043,\n", - " (2025, 7): 2.113234758377075,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.3962783813476562,\n", - " (2025, 10): 6.2099809646606445,\n", - " (2025, 11): 85.84640789031982,\n", - " (2025, 12): 241.10315418243408}},\n", - " 133: {'monthly': {(2025, 1): 339.8696720600128,\n", - " (2025, 2): 193.85911977291107,\n", - " (2025, 3): 242.23109602928162,\n", - " (2025, 4): 96.26956832408905,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 4.7192161083221436,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.7855510711669922,\n", - " (2025, 10): 12.087383270263672,\n", - " (2025, 11): 167.1260792016983,\n", - " (2025, 12): 350.22262489795685},\n", - " 'window': {(2025, 1): 113.54869270324707,\n", - " (2025, 2): 101.73019170761108,\n", - " (2025, 3): 76.3973708152771,\n", - " (2025, 4): 65.35817909240723,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 1.9195873737335205,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.7855510711669922,\n", - " (2025, 10): 5.677119851112366,\n", - " (2025, 11): 69.14080905914307,\n", - " (2025, 12): 182.21638345718384}},\n", - " 134: {'monthly': {(2025, 1): 289.77922677993774,\n", - " (2025, 2): 189.70275366306305,\n", - " (2025, 3): 195.24027228355408,\n", - " (2025, 4): 79.21318352222443,\n", - " (2025, 5): 2.15116024017334,\n", - " (2025, 6): 2.6930688619613647,\n", - " (2025, 7): 3.815138339996338,\n", - " (2025, 8): 1.0198549032211304,\n", - " (2025, 9): 2.5854549407958984,\n", - " (2025, 10): 9.532273173332214,\n", - " (2025, 11): 133.562584400177,\n", - " (2025, 12): 248.548810005188},\n", - " 'window': {(2025, 1): 105.54580688476562,\n", - " (2025, 2): 111.10173416137695,\n", - " (2025, 3): 55.79000663757324,\n", - " (2025, 4): 52.32069206237793,\n", - " (2025, 5): 2.15116024017334,\n", - " (2025, 6): 2.6930688619613647,\n", - " (2025, 7): 1.6295785903930664,\n", - " (2025, 8): 1.0198549032211304,\n", - " (2025, 9): 1.3685381412506104,\n", - " (2025, 10): 6.204942226409912,\n", - " (2025, 11): 53.003864765167236,\n", - " (2025, 12): 116.82110023498535}},\n", - " 135: {'monthly': {(2025, 1): 239.7558652162552,\n", - " (2025, 2): 163.2685445547104,\n", - " (2025, 3): 169.46434700489044,\n", - " (2025, 4): 83.32934093475342,\n", - " (2025, 5): 1.6327935457229614,\n", - " (2025, 6): 2.26241397857666,\n", - " (2025, 7): 3.9505006074905396,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.0732773542404175,\n", - " (2025, 10): 15.318841218948364,\n", - " (2025, 11): 79.96488678455353,\n", - " (2025, 12): 206.1039524078369},\n", - " 'window': {(2025, 1): 72.30770635604858,\n", - " (2025, 2): 99.56808042526245,\n", - " (2025, 3): 65.66405487060547,\n", - " (2025, 4): 59.708858489990234,\n", - " (2025, 5): 1.6327935457229614,\n", - " (2025, 6): 2.26241397857666,\n", - " (2025, 7): 2.735870599746704,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.0732773542404175,\n", - " (2025, 10): 5.776926159858704,\n", - " (2025, 11): 37.85817861557007,\n", - " (2025, 12): 72.36143445968628}},\n", - " 136: {'monthly': {(2025, 1): 268.02457189559937,\n", - " (2025, 2): 152.75428211688995,\n", - " (2025, 3): 184.45211040973663,\n", - " (2025, 4): 79.07199609279633,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 3.3356910943984985,\n", - " (2025, 7): 2.3323882818222046,\n", - " (2025, 8): 1.0399576425552368,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 15.493261218070984,\n", - " (2025, 11): 81.73083293437958,\n", - " (2025, 12): 195.13197708129883},\n", - " 'window': {(2025, 1): 90.67041778564453,\n", - " (2025, 2): 77.49336433410645,\n", - " (2025, 3): 83.13487339019775,\n", - " (2025, 4): 54.33684682846069,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.1989398002624512,\n", - " (2025, 7): 2.3323882818222046,\n", - " (2025, 8): 1.0399576425552368,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 5.341803193092346,\n", - " (2025, 11): 34.81559658050537,\n", - " (2025, 12): 78.80600380897522}},\n", - " 137: {'monthly': {(2025, 1): 305.2231546640396,\n", - " (2025, 2): 140.99458980560303,\n", - " (2025, 3): 172.78338193893433,\n", - " (2025, 4): 72.75705659389496,\n", - " (2025, 5): 1.4272514581680298,\n", - " (2025, 6): 2.240702509880066,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.325528860092163,\n", - " (2025, 10): 13.043865084648132,\n", - " (2025, 11): 88.68253707885742,\n", - " (2025, 12): 180.4512094259262},\n", - " 'window': {(2025, 1): 118.24256992340088,\n", - " (2025, 2): 61.816524505615234,\n", - " (2025, 3): 78.09764575958252,\n", - " (2025, 4): 55.29481220245361,\n", - " (2025, 5): 1.4272514581680298,\n", - " (2025, 6): 1.1989398002624512,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.325528860092163,\n", - " (2025, 10): 5.304360866546631,\n", - " (2025, 11): 37.92916655540466,\n", - " (2025, 12): 76.3009135723114}},\n", - " 138: {'monthly': {(2025, 1): 296.47095334529877,\n", - " (2025, 2): 121.86543834209442,\n", - " (2025, 3): 144.99928736686707,\n", - " (2025, 4): 73.39052426815033,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.1989398002624512,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.0921438932418823,\n", - " (2025, 10): 9.320000171661377,\n", - " (2025, 11): 89.26452815532684,\n", - " (2025, 12): 181.1985821723938},\n", - " 'window': {(2025, 1): 113.2105541229248,\n", - " (2025, 2): 54.76955819129944,\n", - " (2025, 3): 59.16248416900635,\n", - " (2025, 4): 56.72724485397339,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.1989398002624512,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.0921438932418823,\n", - " (2025, 10): 4.109906554222107,\n", - " (2025, 11): 38.154860496520996,\n", - " (2025, 12): 78.275390625}},\n", - " 139: {'monthly': {(2025, 1): 260.17920219898224,\n", - " (2025, 2): 121.62053966522217,\n", - " (2025, 3): 151.0442419052124,\n", - " (2025, 4): 89.79004716873169,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.5300917625427246,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.0089914798736572,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 12.222184777259827,\n", - " (2025, 11): 97.26416957378387,\n", - " (2025, 12): 222.31283807754517},\n", - " 'window': {(2025, 1): 98.4426155090332,\n", - " (2025, 2): 54.54344463348389,\n", - " (2025, 3): 64.13473606109619,\n", - " (2025, 4): 69.73222303390503,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.5300917625427246,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.0089914798736572,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 5.58203649520874,\n", - " (2025, 11): 50.35328912734985,\n", - " (2025, 12): 95.89087581634521}},\n", - " 140: {'monthly': {(2025, 1): 285.0600309371948,\n", - " (2025, 2): 125.04034280776978,\n", - " (2025, 3): 177.58127617835999,\n", - " (2025, 4): 107.5070812702179,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.5300917625427246,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.5322431325912476,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 11.32714557647705,\n", - " (2025, 11): 101.82140862941742,\n", - " (2025, 12): 241.914985537529},\n", - " 'window': {(2025, 1): 114.8392505645752,\n", - " (2025, 2): 60.26854228973389,\n", - " (2025, 3): 72.54802799224854,\n", - " (2025, 4): 84.81840467453003,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.5300917625427246,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.5322431325912476,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 4.924211025238037,\n", - " (2025, 11): 58.17380928993225,\n", - " (2025, 12): 117.47680139541626}},\n", - " 141: {'monthly': {(2025, 1): 254.55231654644012,\n", - " (2025, 2): 105.65692579746246,\n", - " (2025, 3): 164.70863115787506,\n", - " (2025, 4): 103.23600125312805,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.5300917625427246,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.4955360889434814,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 10.458309888839722,\n", - " (2025, 11): 86.03189897537231,\n", - " (2025, 12): 190.65555930137634},\n", - " 'window': {(2025, 1): 110.3923921585083,\n", - " (2025, 2): 49.157063484191895,\n", - " (2025, 3): 72.8140377998352,\n", - " (2025, 4): 83.33477687835693,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.5300917625427246,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.4955360889434814,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 4.077857971191406,\n", - " (2025, 11): 49.928767919540405,\n", - " (2025, 12): 83.87623238563538}},\n", - " 142: {'monthly': {(2025, 1): 245.3801075220108,\n", - " (2025, 2): 96.7939521074295,\n", - " (2025, 3): 143.2271362543106,\n", - " (2025, 4): 73.6219300031662,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.5300917625427246,\n", - " (2025, 7): 1.0722179412841797,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 10.07623028755188,\n", - " (2025, 11): 73.9453992843628,\n", - " (2025, 12): 167.22572934627533},\n", - " 'window': {(2025, 1): 98.90126371383667,\n", - " (2025, 2): 41.17962288856506,\n", - " (2025, 3): 65.18902063369751,\n", - " (2025, 4): 54.35377645492554,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.5300917625427246,\n", - " (2025, 7): 1.0722179412841797,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 3.541921377182007,\n", - " (2025, 11): 36.85303854942322,\n", - " (2025, 12): 62.23759567737579}},\n", - " 143: {'monthly': {(2025, 1): 275.49005448818207,\n", - " (2025, 2): 170.34832286834717,\n", - " (2025, 3): 267.8170189857483,\n", - " (2025, 4): 99.89253222942352,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 3.7360140085220337,\n", - " (2025, 7): 1.210450530052185,\n", - " (2025, 8): 2.0483686923980713,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 10.212182402610779,\n", - " (2025, 11): 158.03199243545532,\n", - " (2025, 12): 314.9993129968643},\n", - " 'window': {(2025, 1): 89.84803485870361,\n", - " (2025, 2): 84.55709552764893,\n", - " (2025, 3): 80.09156847000122,\n", - " (2025, 4): 56.849610328674316,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 2.6144723892211914,\n", - " (2025, 7): 1.210450530052185,\n", - " (2025, 8): 2.0483686923980713,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 5.1844024658203125,\n", - " (2025, 11): 69.83127307891846,\n", - " (2025, 12): 145.23947715759277}},\n", - " 144: {'monthly': {(2025, 1): 282.8449875116348,\n", - " (2025, 2): 153.64332962036133,\n", - " (2025, 3): 338.38983154296875,\n", - " (2025, 4): 102.10275971889496,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 4.246933221817017,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.9704591035842896,\n", - " (2025, 10): 11.232572555541992,\n", - " (2025, 11): 182.82277190685272,\n", - " (2025, 12): 384.794521689415},\n", - " 'window': {(2025, 1): 89.33212280273438,\n", - " (2025, 2): 67.09036827087402,\n", - " (2025, 3): 99.05489492416382,\n", - " (2025, 4): 58.72877550125122,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 1.8912321329116821,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.9704591035842896,\n", - " (2025, 10): 6.875252962112427,\n", - " (2025, 11): 78.80657577514648,\n", - " (2025, 12): 229.67746925354004}},\n", - " 145: {'monthly': {(2025, 1): 348.6314778327942,\n", - " (2025, 2): 196.86965692043304,\n", - " (2025, 3): 323.586235165596,\n", - " (2025, 4): 103.36416709423065,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 5.055894374847412,\n", - " (2025, 8): 1.1134302616119385,\n", - " (2025, 9): 2.8092029094696045,\n", - " (2025, 10): 14.373589992523193,\n", - " (2025, 11): 194.4600863456726,\n", - " (2025, 12): 410.11921775341034},\n", - " 'window': {(2025, 1): 102.03789043426514,\n", - " (2025, 2): 84.44465255737305,\n", - " (2025, 3): 95.29995346069336,\n", - " (2025, 4): 60.487173557281494,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 1.5097143650054932,\n", - " (2025, 8): 1.1134302616119385,\n", - " (2025, 9): 1.4849773645401,\n", - " (2025, 10): 7.202636957168579,\n", - " (2025, 11): 84.01962995529175,\n", - " (2025, 12): 228.530255317688}},\n", - " 146: {'monthly': {(2025, 1): 316.21606945991516,\n", - " (2025, 2): 184.02904331684113,\n", - " (2025, 3): 236.61068868637085,\n", - " (2025, 4): 78.34318244457245,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 3.3839340209960938,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.2972235679626465,\n", - " (2025, 10): 9.774455666542053,\n", - " (2025, 11): 151.77713334560394,\n", - " (2025, 12): 293.67951929569244},\n", - " 'window': {(2025, 1): 98.6380386352539,\n", - " (2025, 2): 88.67294216156006,\n", - " (2025, 3): 68.90916347503662,\n", - " (2025, 4): 46.41550540924072,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 1.2657777070999146,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.2972235679626465,\n", - " (2025, 10): 5.272441744804382,\n", - " (2025, 11): 57.02850961685181,\n", - " (2025, 12): 144.911958694458}},\n", - " 147: {'monthly': {(2025, 1): 285.89741134643555,\n", - " (2025, 2): 185.3438411951065,\n", - " (2025, 3): 194.37569844722748,\n", - " (2025, 4): 65.11225748062134,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 2.3557010889053345,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.050703525543213,\n", - " (2025, 10): 8.449161887168884,\n", - " (2025, 11): 122.7386703491211,\n", - " (2025, 12): 214.45841550827026},\n", - " 'window': {(2025, 1): 95.540207862854,\n", - " (2025, 2): 92.97565650939941,\n", - " (2025, 3): 55.756657123565674,\n", - " (2025, 4): 36.899178981781006,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 1.2657777070999146,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.050703525543213,\n", - " (2025, 10): 4.465026378631592,\n", - " (2025, 11): 41.23288083076477,\n", - " (2025, 12): 88.63617992401123}},\n", - " 148: {'monthly': {(2025, 1): 291.6168086528778,\n", - " (2025, 2): 180.90108156204224,\n", - " (2025, 3): 205.5647165775299,\n", - " (2025, 4): 86.45869624614716,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.1989398002624512,\n", - " (2025, 7): 1.2947494983673096,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 11.475716948509216,\n", - " (2025, 11): 79.84189367294312,\n", - " (2025, 12): 227.8133968114853},\n", - " 'window': {(2025, 1): 85.16968631744385,\n", - " (2025, 2): 102.53112030029297,\n", - " (2025, 3): 88.70309162139893,\n", - " (2025, 4): 59.72976016998291,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.1989398002624512,\n", - " (2025, 7): 1.2947494983673096,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 4.827746152877808,\n", - " (2025, 11): 31.20000433921814,\n", - " (2025, 12): 75.82154703140259}},\n", - " 149: {'monthly': {(2025, 1): 334.52252221107483,\n", - " (2025, 2): 174.00685679912567,\n", - " (2025, 3): 212.23979365825653,\n", - " (2025, 4): 86.48641645908356,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.1989398002624512,\n", - " (2025, 7): 1.174986481666565,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 14.578388452529907,\n", - " (2025, 11): 83.94766414165497,\n", - " (2025, 12): 203.29763913154602},\n", - " 'window': {(2025, 1): 116.43862724304199,\n", - " (2025, 2): 82.59110736846924,\n", - " (2025, 3): 102.4197940826416,\n", - " (2025, 4): 58.18883228302002,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.1989398002624512,\n", - " (2025, 7): 1.174986481666565,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 5.082823157310486,\n", - " (2025, 11): 33.97940683364868,\n", - " (2025, 12): 72.34434509277344}},\n", - " 150: {'monthly': {(2025, 1): 336.97567081451416,\n", - " (2025, 2): 141.29135644435883,\n", - " (2025, 3): 177.35446417331696,\n", - " (2025, 4): 80.33279192447662,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.1989398002624512,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 7.154487371444702,\n", - " (2025, 11): 66.68862891197205,\n", - " (2025, 12): 169.78019750118256},\n", - " 'window': {(2025, 1): 134.5170440673828,\n", - " (2025, 2): 59.067978382110596,\n", - " (2025, 3): 87.23144578933716,\n", - " (2025, 4): 58.74110698699951,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.1989398002624512,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 3.513828992843628,\n", - " (2025, 11): 32.58405947685242,\n", - " (2025, 12): 61.732802867889404}},\n", - " 151: {'monthly': {(2025, 1): 285.82198202610016,\n", - " (2025, 2): 123.98397660255432,\n", - " (2025, 3): 151.27900564670563,\n", - " (2025, 4): 75.84396076202393,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.1989398002624512,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 8.501178503036499,\n", - " (2025, 11): 69.06065618991852,\n", - " (2025, 12): 163.9510042667389},\n", - " 'window': {(2025, 1): 113.23949337005615,\n", - " (2025, 2): 54.131147146224976,\n", - " (2025, 3): 66.63621997833252,\n", - " (2025, 4): 52.9139461517334,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.1989398002624512,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 3.3039366006851196,\n", - " (2025, 11): 35.98870277404785,\n", - " (2025, 12): 60.22197246551514}},\n", - " 152: {'monthly': {(2025, 1): 309.7860703468323,\n", - " (2025, 2): 126.02512717247009,\n", - " (2025, 3): 156.18770229816437,\n", - " (2025, 4): 94.23984718322754,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 4.588772296905518,\n", - " (2025, 7): 1.0466023683547974,\n", - " (2025, 8): 1.1477694511413574,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 10.883643388748169,\n", - " (2025, 11): 77.13859820365906,\n", - " (2025, 12): 210.02517092227936},\n", - " 'window': {(2025, 1): 100.75350570678711,\n", - " (2025, 2): 58.825639724731445,\n", - " (2025, 3): 61.77825355529785,\n", - " (2025, 4): 71.41892671585083,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 2.031059503555298,\n", - " (2025, 7): 1.0466023683547974,\n", - " (2025, 8): 1.1477694511413574,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 4.777993679046631,\n", - " (2025, 11): 35.68663692474365,\n", - " (2025, 12): 83.06722640991211}},\n", - " 153: {'monthly': {(2025, 1): 341.0560487508774,\n", - " (2025, 2): 135.59340679645538,\n", - " (2025, 3): 196.12885177135468,\n", - " (2025, 4): 120.16434097290039,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 2.5620362758636475,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.5242655277252197,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 11.106979846954346,\n", - " (2025, 11): 81.04433178901672,\n", - " (2025, 12): 238.75537610054016},\n", - " 'window': {(2025, 1): 119.16030693054199,\n", - " (2025, 2): 63.73747158050537,\n", - " (2025, 3): 73.06769800186157,\n", - " (2025, 4): 93.44198513031006,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.5300917625427246,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.5242655277252197,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 4.153346061706543,\n", - " (2025, 11): 40.79114842414856,\n", - " (2025, 12): 104.19138765335083}},\n", - " 154: {'monthly': {(2025, 1): 303.54287481307983,\n", - " (2025, 2): 118.04698967933655,\n", - " (2025, 3): 177.14931726455688,\n", - " (2025, 4): 122.41805720329285,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.5300917625427246,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 2.4593966007232666,\n", - " (2025, 9): 1.1040229797363281,\n", - " (2025, 10): 9.900939345359802,\n", - " (2025, 11): 69.85319578647614,\n", - " (2025, 12): 188.66307282447815},\n", - " 'window': {(2025, 1): 124.69116306304932,\n", - " (2025, 2): 49.90353727340698,\n", - " (2025, 3): 69.03669881820679,\n", - " (2025, 4): 98.60082530975342,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.5300917625427246,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.4391673803329468,\n", - " (2025, 9): 1.1040229797363281,\n", - " (2025, 10): 3.4424173831939697,\n", - " (2025, 11): 36.84244394302368,\n", - " (2025, 12): 72.35734176635742}},\n", - " 155: {'monthly': {(2025, 1): 266.9292041063309,\n", - " (2025, 2): 96.19083714485168,\n", - " (2025, 3): 143.12159967422485,\n", - " (2025, 4): 86.93809640407562,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.5305694341659546,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 9.653633952140808,\n", - " (2025, 11): 62.68017840385437,\n", - " (2025, 12): 159.52408635616302},\n", - " 'window': {(2025, 1): 115.42925357818604,\n", - " (2025, 2): 40.172300577163696,\n", - " (2025, 3): 56.91281080245972,\n", - " (2025, 4): 64.12220430374146,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.5305694341659546,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 3.491452693939209,\n", - " (2025, 11): 29.490854263305664,\n", - " (2025, 12): 54.38049364089966}},\n", - " 156: {'monthly': {(2025, 1): 247.31253325939178,\n", - " (2025, 2): 137.92716121673584,\n", - " (2025, 3): 261.6777276992798,\n", - " (2025, 4): 94.40549576282501,\n", - " (2025, 5): 1.2366886138916016,\n", - " (2025, 6): 1.088681936264038,\n", - " (2025, 7): 1.210450530052185,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 12.313991069793701,\n", - " (2025, 11): 148.23764038085938,\n", - " (2025, 12): 318.8830692768097},\n", - " 'window': {(2025, 1): 71.88325881958008,\n", - " (2025, 2): 66.1068115234375,\n", - " (2025, 3): 74.25451755523682,\n", - " (2025, 4): 53.483689308166504,\n", - " (2025, 5): 1.2366886138916016,\n", - " (2025, 6): 1.088681936264038,\n", - " (2025, 7): 1.210450530052185,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 5.745477199554443,\n", - " (2025, 11): 58.07892465591431,\n", - " (2025, 12): 142.88052368164062}},\n", - " 157: {'monthly': {(2025, 1): 251.10372495651245,\n", - " (2025, 2): 146.3119488954544,\n", - " (2025, 3): 308.3678832054138,\n", - " (2025, 4): 75.47618567943573,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 3.4597400426864624,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 10.440967440605164,\n", - " (2025, 11): 135.9670717716217,\n", - " (2025, 12): 277.7892761230469},\n", - " 'window': {(2025, 1): 72.70858478546143,\n", - " (2025, 2): 62.12831783294678,\n", - " (2025, 3): 94.40990424156189,\n", - " (2025, 4): 40.21693706512451,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 1.2657777070999146,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 5.952597618103027,\n", - " (2025, 11): 54.39324235916138,\n", - " (2025, 12): 134.48741340637207}},\n", - " 158: {'monthly': {(2025, 1): 294.947615981102,\n", - " (2025, 2): 176.1037139892578,\n", - " (2025, 3): 283.5707173347473,\n", - " (2025, 4): 73.75940930843353,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 2.3557010889053345,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 12.972533702850342,\n", - " (2025, 11): 143.1751354932785,\n", - " (2025, 12): 264.1569073200226},\n", - " 'window': {(2025, 1): 82.0829963684082,\n", - " (2025, 2): 72.76770830154419,\n", - " (2025, 3): 84.9124584197998,\n", - " (2025, 4): 40.824331283569336,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 1.2657777070999146,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 6.983752965927124,\n", - " (2025, 11): 53.37596797943115,\n", - " (2025, 12): 124.1272497177124}},\n", - " 159: {'monthly': {(2025, 1): 257.09718894958496,\n", - " (2025, 2): 156.96150243282318,\n", - " (2025, 3): 224.55869281291962,\n", - " (2025, 4): 56.32280111312866,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.0229690074920654,\n", - " (2025, 7): 2.3557010889053345,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 2.270264148712158,\n", - " (2025, 10): 6.4781657457351685,\n", - " (2025, 11): 114.39913749694824,\n", - " (2025, 12): 202.13118290901184},\n", - " 'window': {(2025, 1): 75.2989273071289,\n", - " (2025, 2): 70.40331840515137,\n", - " (2025, 3): 66.6184778213501,\n", - " (2025, 4): 30.500120282173157,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.0229690074920654,\n", - " (2025, 7): 1.2657777070999146,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.2347145080566406,\n", - " (2025, 10): 4.193534016609192,\n", - " (2025, 11): 35.8001127243042,\n", - " (2025, 12): 72.11236906051636}},\n", - " 160: {'monthly': {(2025, 1): 253.31876504421234,\n", - " (2025, 2): 154.99300336837769,\n", - " (2025, 3): 194.91261780261993,\n", - " (2025, 4): 54.41445243358612,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 2.3557010889053345,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 6.059066534042358,\n", - " (2025, 11): 103.6327714920044,\n", - " (2025, 12): 161.1398628950119},\n", - " 'window': {(2025, 1): 74.47743606567383,\n", - " (2025, 2): 71.70397090911865,\n", - " (2025, 3): 57.13467264175415,\n", - " (2025, 4): 34.141080379486084,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 1.2657777070999146,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 4.09751570224762,\n", - " (2025, 11): 40.02948451042175,\n", - " (2025, 12): 45.175662994384766}},\n", - " 161: {'monthly': {(2025, 1): 292.9994378089905,\n", - " (2025, 2): 155.096945643425,\n", - " (2025, 3): 200.7866302728653,\n", - " (2025, 4): 80.95942986011505,\n", - " (2025, 5): 3.107686400413513,\n", - " (2025, 6): 1.1989398002624512,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 9.036722898483276,\n", - " (2025, 11): 67.3201996088028,\n", - " (2025, 12): 190.91854858398438},\n", - " 'window': {(2025, 1): 92.2607650756836,\n", - " (2025, 2): 74.77021265029907,\n", - " (2025, 3): 96.69040870666504,\n", - " (2025, 4): 52.452258586883545,\n", - " (2025, 5): 2.0624276399612427,\n", - " (2025, 6): 1.1989398002624512,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 3.7408785820007324,\n", - " (2025, 11): 27.71117615699768,\n", - " (2025, 12): 59.883034467697144}},\n", - " 162: {'monthly': {(2025, 1): 343.64893436431885,\n", - " (2025, 2): 158.75379610061646,\n", - " (2025, 3): 213.06055545806885,\n", - " (2025, 4): 79.4321471452713,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.1989398002624512,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 11.743476629257202,\n", - " (2025, 11): 78.93822300434113,\n", - " (2025, 12): 182.01627266407013},\n", - " 'window': {(2025, 1): 120.27298545837402,\n", - " (2025, 2): 68.27630758285522,\n", - " (2025, 3): 110.3734073638916,\n", - " (2025, 4): 52.839770793914795,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.1989398002624512,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 4.205596566200256,\n", - " (2025, 11): 36.17042279243469,\n", - " (2025, 12): 59.243706941604614}},\n", - " 163: {'monthly': {(2025, 1): 343.0530655384064,\n", - " (2025, 2): 135.53684294223785,\n", - " (2025, 3): 203.76342117786407,\n", - " (2025, 4): 88.3921982049942,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.1989398002624512,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 10.21592366695404,\n", - " (2025, 11): 67.66842210292816,\n", - " (2025, 12): 172.94589054584503},\n", - " 'window': {(2025, 1): 130.16069889068604,\n", - " (2025, 2): 59.23390245437622,\n", - " (2025, 3): 99.98196506500244,\n", - " (2025, 4): 58.8322057723999,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.1989398002624512,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 5.543735384941101,\n", - " (2025, 11): 33.45653581619263,\n", - " (2025, 12): 53.429739236831665}},\n", - " 164: {'monthly': {(2025, 1): 300.4931194782257,\n", - " (2025, 2): 136.77420163154602,\n", - " (2025, 3): 177.91658318042755,\n", - " (2025, 4): 86.75506794452667,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.1989398002624512,\n", - " (2025, 7): 1.0341140031814575,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 8.750201225280762,\n", - " (2025, 11): 83.83374190330505,\n", - " (2025, 12): 180.08760225772858},\n", - " 'window': {(2025, 1): 117.07372856140137,\n", - " (2025, 2): 56.866429805755615,\n", - " (2025, 3): 76.51580047607422,\n", - " (2025, 4): 52.89862775802612,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.1989398002624512,\n", - " (2025, 7): 1.0341140031814575,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 3.9183216094970703,\n", - " (2025, 11): 41.423627853393555,\n", - " (2025, 12): 52.077980041503906}},\n", - " 165: {'monthly': {(2025, 1): 356.8547167778015,\n", - " (2025, 2): 141.2528281211853,\n", - " (2025, 3): 157.90927278995514,\n", - " (2025, 4): 98.4821583032608,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.5300917625427246,\n", - " (2025, 7): 2.260707378387451,\n", - " (2025, 8): 1.3606122732162476,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 10.881825923919678,\n", - " (2025, 11): 62.8765344619751,\n", - " (2025, 12): 219.53797578811646},\n", - " 'window': {(2025, 1): 108.77407836914062,\n", - " (2025, 2): 58.68360137939453,\n", - " (2025, 3): 52.482200622558594,\n", - " (2025, 4): 71.81978797912598,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.5300917625427246,\n", - " (2025, 7): 2.260707378387451,\n", - " (2025, 8): 1.3606122732162476,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 4.243093967437744,\n", - " (2025, 11): 26.2365984916687,\n", - " (2025, 12): 75.70201873779297}},\n", - " 166: {'monthly': {(2025, 1): 376.1289850473404,\n", - " (2025, 2): 150.5991141796112,\n", - " (2025, 3): 184.986896276474,\n", - " (2025, 4): 118.08249282836914,\n", - " (2025, 5): 1.2242546081542969,\n", - " (2025, 6): 4.994794726371765,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.3306589126586914,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 11.642518520355225,\n", - " (2025, 11): 74.66251873970032,\n", - " (2025, 12): 245.65684711933136},\n", - " 'window': {(2025, 1): 112.60109424591064,\n", - " (2025, 2): 57.753737926483154,\n", - " (2025, 3): 63.33221244812012,\n", - " (2025, 4): 85.65439033508301,\n", - " (2025, 5): 1.2242546081542969,\n", - " (2025, 6): 2.770493507385254,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.3306589126586914,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 4.506953954696655,\n", - " (2025, 11): 32.560328006744385,\n", - " (2025, 12): 91.23798656463623}},\n", - " 167: {'monthly': {(2025, 1): 337.57363402843475,\n", - " (2025, 2): 126.9219560623169,\n", - " (2025, 3): 175.0331827402115,\n", - " (2025, 4): 118.27431106567383,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 3.7060160636901855,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.055999755859375,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 12.720297455787659,\n", - " (2025, 11): 60.95640587806702,\n", - " (2025, 12): 194.27024507522583},\n", - " 'window': {(2025, 1): 111.73734378814697,\n", - " (2025, 2): 47.42458176612854,\n", - " (2025, 3): 62.14018154144287,\n", - " (2025, 4): 92.7935791015625,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 2.648072600364685,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.055999755859375,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 6.354087471961975,\n", - " (2025, 11): 30.150627613067627,\n", - " (2025, 12): 66.81333923339844}},\n", - " 168: {'monthly': {(2025, 1): 287.01428389549255,\n", - " (2025, 2): 103.25780165195465,\n", - " (2025, 3): 139.89361262321472,\n", - " (2025, 4): 91.08740389347076,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 2.677360415458679,\n", - " (2025, 7): 1.0076888799667358,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 7.821628212928772,\n", - " (2025, 11): 54.11497151851654,\n", - " (2025, 12): 162.12812507152557},\n", - " 'window': {(2025, 1): 103.99455070495605,\n", - " (2025, 2): 38.95869040489197,\n", - " (2025, 3): 50.960641384124756,\n", - " (2025, 4): 65.54690790176392,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.5300917625427246,\n", - " (2025, 7): 1.0076888799667358,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 3.506302833557129,\n", - " (2025, 11): 24.968815565109253,\n", - " (2025, 12): 48.97390866279602}},\n", - " 169: {'monthly': {(2025, 1): 258.4487706422806,\n", - " (2025, 2): 160.75368630886078,\n", - " (2025, 3): 241.2890464067459,\n", - " (2025, 4): 65.95155906677246,\n", - " (2025, 5): 1.200978398323059,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.3481833934783936,\n", - " (2025, 10): 5.214057087898254,\n", - " (2025, 11): 134.20669078826904,\n", - " (2025, 12): 230.50806951522827},\n", - " 'window': {(2025, 1): 103.71542358398438,\n", - " (2025, 2): 95.27702856063843,\n", - " (2025, 3): 66.22958040237427,\n", - " (2025, 4): 35.54762840270996,\n", - " (2025, 5): 1.200978398323059,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.3481833934783936,\n", - " (2025, 10): 2.083608627319336,\n", - " (2025, 11): 53.70109462738037,\n", - " (2025, 12): 64.65978670120239}},\n", - " 170: {'monthly': {(2025, 1): 264.2519247531891,\n", - " (2025, 2): 117.98979711532593,\n", - " (2025, 3): 242.90773463249207,\n", - " (2025, 4): 98.52362895011902,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 1.0355600118637085,\n", - " (2025, 8): 1.199982762336731,\n", - " (2025, 9): 1.0979903936386108,\n", - " (2025, 10): 8.04761290550232,\n", - " (2025, 11): 97.87266278266907,\n", - " (2025, 12): 214.8787064552307},\n", - " 'window': {(2025, 1): 98.78544902801514,\n", - " (2025, 2): 66.1066484451294,\n", - " (2025, 3): 66.17503070831299,\n", - " (2025, 4): 58.26244783401489,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 1.0355600118637085,\n", - " (2025, 8): 1.199982762336731,\n", - " (2025, 9): 1.0979903936386108,\n", - " (2025, 10): 3.7040998935699463,\n", - " (2025, 11): 28.84727168083191,\n", - " (2025, 12): 57.86773681640625}},\n", - " 171: {'monthly': {(2025, 1): 279.41083538532257,\n", - " (2025, 2): 126.36815762519836,\n", - " (2025, 3): 236.10978543758392,\n", - " (2025, 4): 91.60684144496918,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.6243488788604736,\n", - " (2025, 10): 5.102797508239746,\n", - " (2025, 11): 96.5234614610672,\n", - " (2025, 12): 208.7499041557312},\n", - " 'window': {(2025, 1): 106.91469764709473,\n", - " (2025, 2): 75.25184631347656,\n", - " (2025, 3): 67.93360900878906,\n", - " (2025, 4): 57.93448543548584,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.6243488788604736,\n", - " (2025, 10): 1.8375437259674072,\n", - " (2025, 11): 32.7477445602417,\n", - " (2025, 12): 57.45966720581055}},\n", - " 172: {'monthly': {(2025, 1): 270.09809172153473,\n", - " (2025, 2): 117.9968752861023,\n", - " (2025, 3): 208.12353682518005,\n", - " (2025, 4): 68.67365252971649,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 5.8566272258758545,\n", - " (2025, 11): 90.05346930027008,\n", - " (2025, 12): 193.4442173242569},\n", - " 'window': {(2025, 1): 101.53663206100464,\n", - " (2025, 2): 71.82163286209106,\n", - " (2025, 3): 63.20608997344971,\n", - " (2025, 4): 39.84776949882507,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 2.1649197340011597,\n", - " (2025, 11): 33.417227268218994,\n", - " (2025, 12): 55.43754601478577}},\n", - " 173: {'monthly': {(2025, 1): 278.8395652770996,\n", - " (2025, 2): 134.24035274982452,\n", - " (2025, 3): 205.33166599273682,\n", - " (2025, 4): 61.12269866466522,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 1.1503764390945435,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 2.072991728782654,\n", - " (2025, 11): 83.01101076602936,\n", - " (2025, 12): 192.29491651058197},\n", - " 'window': {(2025, 1): 104.4695656299591,\n", - " (2025, 2): 78.7079644203186,\n", - " (2025, 3): 62.41400861740112,\n", - " (2025, 4): 37.736552476882935,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 1.1503764390945435,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 1.0491037368774414,\n", - " (2025, 11): 35.36257719993591,\n", - " (2025, 12): 63.12917709350586}},\n", - " 174: {'monthly': {(2025, 1): 358.53205919265747,\n", - " (2025, 2): 165.82364130020142,\n", - " (2025, 3): 187.3673459291458,\n", - " (2025, 4): 108.75004124641418,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.3609579801559448,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 1.038238525390625,\n", - " (2025, 11): 68.5645604133606,\n", - " (2025, 12): 205.81694674491882},\n", - " 'window': {(2025, 1): 124.50735282897949,\n", - " (2025, 2): 101.06717681884766,\n", - " (2025, 3): 65.8292589187622,\n", - " (2025, 4): 63.05581545829773,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.3609579801559448,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 1.038238525390625,\n", - " (2025, 11): 30.747717142105103,\n", - " (2025, 12): 72.56173849105835}},\n", - " 175: {'monthly': {(2025, 1): 368.0649505853653,\n", - " (2025, 2): 151.94197916984558,\n", - " (2025, 3): 207.85622465610504,\n", - " (2025, 4): 110.28110754489899,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.3609579801559448,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 1.038238525390625,\n", - " (2025, 11): 72.63344287872314,\n", - " (2025, 12): 231.79776406288147},\n", - " 'window': {(2025, 1): 128.24221324920654,\n", - " (2025, 2): 91.72015285491943,\n", - " (2025, 3): 76.33193111419678,\n", - " (2025, 4): 73.47475814819336,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.3609579801559448,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 1.038238525390625,\n", - " (2025, 11): 39.693532943725586,\n", - " (2025, 12): 82.16048336029053}},\n", - " 176: {'monthly': {(2025, 1): 373.5702636241913,\n", - " (2025, 2): 155.46910917758942,\n", - " (2025, 3): 233.70297825336456,\n", - " (2025, 4): 137.44647085666656,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.3609579801559448,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 1.038238525390625,\n", - " (2025, 11): 82.57673418521881,\n", - " (2025, 12): 296.141618847847},\n", - " 'window': {(2025, 1): 132.83078002929688,\n", - " (2025, 2): 92.723952293396,\n", - " (2025, 3): 83.57340908050537,\n", - " (2025, 4): 95.10831785202026,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.3609579801559448,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 1.038238525390625,\n", - " (2025, 11): 46.411887407302856,\n", - " (2025, 12): 100.47928619384766}},\n", - " 177: {'monthly': {(2025, 1): 368.79720199108124,\n", - " (2025, 2): 163.90431714057922,\n", - " (2025, 3): 231.92010521888733,\n", - " (2025, 4): 123.61424744129181,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 4.671680927276611,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 1.038238525390625,\n", - " (2025, 11): 84.03386402130127,\n", - " (2025, 12): 296.28440403938293},\n", - " 'window': {(2025, 1): 133.55443286895752,\n", - " (2025, 2): 92.06757736206055,\n", - " (2025, 3): 77.40926933288574,\n", - " (2025, 4): 81.46932029724121,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 3.3107229471206665,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 1.038238525390625,\n", - " (2025, 11): 42.248170614242554,\n", - " (2025, 12): 101.49297904968262}},\n", - " 178: {'monthly': {(2025, 1): 394.28266859054565,\n", - " (2025, 2): 191.89612877368927,\n", - " (2025, 3): 236.0393705368042,\n", - " (2025, 4): 109.06794881820679,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 3.4994393587112427,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.0332982540130615,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 0.0,\n", - " (2025, 11): 79.24163901805878,\n", - " (2025, 12): 268.48221695423126},\n", - " 'window': {(2025, 1): 156.36664199829102,\n", - " (2025, 2): 113.8575668334961,\n", - " (2025, 3): 77.31197500228882,\n", - " (2025, 4): 67.67031574249268,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.3010972738265991,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.0332982540130615,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 0.0,\n", - " (2025, 11): 46.110071897506714,\n", - " (2025, 12): 88.41906261444092}},\n", - " 179: {'monthly': {(2025, 1): 452.24647545814514,\n", - " (2025, 2): 190.97600650787354,\n", - " (2025, 3): 208.92792510986328,\n", - " (2025, 4): 113.95736229419708,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 3.470810294151306,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 1.3229310512542725,\n", - " (2025, 11): 84.74037528038025,\n", - " (2025, 12): 269.36420941352844},\n", - " 'window': {(2025, 1): 201.98942375183105,\n", - " (2025, 2): 110.04633235931396,\n", - " (2025, 3): 65.62666749954224,\n", - " (2025, 4): 67.92919731140137,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 2.3261152505874634,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 1.3229310512542725,\n", - " (2025, 11): 47.427467584609985,\n", - " (2025, 12): 93.4901819229126}},\n", - " 180: {'monthly': {(2025, 1): 465.45093166828156,\n", - " (2025, 2): 153.7826738357544,\n", - " (2025, 3): 178.1233253479004,\n", - " (2025, 4): 115.15267586708069,\n", - " (2025, 5): 1.1292829513549805,\n", - " (2025, 6): 1.3010972738265991,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.0285078287124634,\n", - " (2025, 9): 1.096373438835144,\n", - " (2025, 10): 3.0690670013427734,\n", - " (2025, 11): 71.81705617904663,\n", - " (2025, 12): 240.01707780361176},\n", - " 'window': {(2025, 1): 242.36585426330566,\n", - " (2025, 2): 83.10389804840088,\n", - " (2025, 3): 52.700103759765625,\n", - " (2025, 4): 78.69383001327515,\n", - " (2025, 5): 1.1292829513549805,\n", - " (2025, 6): 1.3010972738265991,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.0285078287124634,\n", - " (2025, 9): 1.096373438835144,\n", - " (2025, 10): 1.774458646774292,\n", - " (2025, 11): 38.315163135528564,\n", - " (2025, 12): 88.45440244674683}},\n", - " 181: {'monthly': {(2025, 1): 432.88045620918274,\n", - " (2025, 2): 115.81605875492096,\n", - " (2025, 3): 164.74673080444336,\n", - " (2025, 4): 125.02629506587982,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 2.682060956954956,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 2.0595545768737793,\n", - " (2025, 11): 68.252272605896,\n", - " (2025, 12): 204.98470830917358},\n", - " 'window': {(2025, 1): 244.18213653564453,\n", - " (2025, 2): 61.4323616027832,\n", - " (2025, 3): 46.22610664367676,\n", - " (2025, 4): 89.74093818664551,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.380963683128357,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 2.0595545768737793,\n", - " (2025, 11): 38.934159994125366,\n", - " (2025, 12): 75.50074696540833}},\n", - " 182: {'monthly': {(2025, 1): 269.64524924755096,\n", - " (2025, 2): 152.52613365650177,\n", - " (2025, 3): 219.91207230091095,\n", - " (2025, 4): 62.24680435657501,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 1.020868182182312,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.5080690383911133,\n", - " (2025, 10): 5.994057655334473,\n", - " (2025, 11): 123.61513578891754,\n", - " (2025, 12): 216.25607073307037},\n", - " 'window': {(2025, 1): 101.98350095748901,\n", - " (2025, 2): 96.82959365844727,\n", - " (2025, 3): 61.75818204879761,\n", - " (2025, 4): 36.449711322784424,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 1.020868182182312,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.5080690383911133,\n", - " (2025, 10): 3.1137951612472534,\n", - " (2025, 11): 49.259047508239746,\n", - " (2025, 12): 61.106329679489136}},\n", - " 183: {'monthly': {(2025, 1): 246.9928332567215,\n", - " (2025, 2): 105.09630084037781,\n", - " (2025, 3): 209.67429292201996,\n", - " (2025, 4): 72.43340349197388,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.1711043119430542,\n", - " (2025, 10): 7.597792863845825,\n", - " (2025, 11): 91.40438961982727,\n", - " (2025, 12): 188.96628415584564},\n", - " 'window': {(2025, 1): 94.95674133300781,\n", - " (2025, 2): 64.12993907928467,\n", - " (2025, 3): 58.5254864692688,\n", - " (2025, 4): 44.05210876464844,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.1711043119430542,\n", - " (2025, 10): 3.0736944675445557,\n", - " (2025, 11): 32.88597846031189,\n", - " (2025, 12): 54.6226282119751}},\n", - " 184: {'monthly': {(2025, 1): 238.36941742897034,\n", - " (2025, 2): 102.89551877975464,\n", - " (2025, 3): 190.1897521018982,\n", - " (2025, 4): 58.196303367614746,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 1.0535942316055298,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 7.078855037689209,\n", - " (2025, 11): 90.24515891075134,\n", - " (2025, 12): 180.11195814609528},\n", - " 'window': {(2025, 1): 96.71498489379883,\n", - " (2025, 2): 66.0757532119751,\n", - " (2025, 3): 59.64930868148804,\n", - " (2025, 4): 29.777948260307312,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 1.0535942316055298,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 2.109244227409363,\n", - " (2025, 11): 36.248584032058716,\n", - " (2025, 12): 55.0110342502594}},\n", - " 185: {'monthly': {(2025, 1): 264.26980793476105,\n", - " (2025, 2): 126.24479115009308,\n", - " (2025, 3): 196.18619012832642,\n", - " (2025, 4): 66.63646924495697,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 1.2593978643417358,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 5.671299457550049,\n", - " (2025, 11): 94.66900503635406,\n", - " (2025, 12): 205.5171412229538},\n", - " 'window': {(2025, 1): 96.44880962371826,\n", - " (2025, 2): 74.94438982009888,\n", - " (2025, 3): 63.95108890533447,\n", - " (2025, 4): 36.06721639633179,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 1.2593978643417358,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 1.7728811502456665,\n", - " (2025, 11): 38.72669172286987,\n", - " (2025, 12): 61.6865656375885}},\n", - " 186: {'monthly': {(2025, 1): 312.9178456068039,\n", - " (2025, 2): 157.8460568189621,\n", - " (2025, 3): 220.9070737361908,\n", - " (2025, 4): 76.23715376853943,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 1.7141103744506836,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 7.5655272006988525,\n", - " (2025, 11): 100.02251899242401,\n", - " (2025, 12): 232.92746007442474},\n", - " 'window': {(2025, 1): 111.53198623657227,\n", - " (2025, 2): 88.4072642326355,\n", - " (2025, 3): 69.41606044769287,\n", - " (2025, 4): 41.76097059249878,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 1.7141103744506836,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 2.897913932800293,\n", - " (2025, 11): 44.90158224105835,\n", - " (2025, 12): 75.7791497707367}},\n", - " 187: {'monthly': {(2025, 1): 394.6684641838074,\n", - " (2025, 2): 178.2318536043167,\n", - " (2025, 3): 210.38673889636993,\n", - " (2025, 4): 131.83682823181152,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.3609579801559448,\n", - " (2025, 7): 1.5171191692352295,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 1.038238525390625,\n", - " (2025, 11): 72.98281228542328,\n", - " (2025, 12): 219.7858523130417},\n", - " 'window': {(2025, 1): 132.47286701202393,\n", - " (2025, 2): 108.9351692199707,\n", - " (2025, 3): 70.29117918014526,\n", - " (2025, 4): 82.02485084533691,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.3609579801559448,\n", - " (2025, 7): 1.5171191692352295,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 1.038238525390625,\n", - " (2025, 11): 35.748849391937256,\n", - " (2025, 12): 82.68718457221985}},\n", - " 188: {'monthly': {(2025, 1): 393.2438106536865,\n", - " (2025, 2): 162.30124735832214,\n", - " (2025, 3): 242.69234764575958,\n", - " (2025, 4): 140.40084981918335,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.3609579801559448,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 1.038238525390625,\n", - " (2025, 11): 92.87443017959595,\n", - " (2025, 12): 272.1318175792694},\n", - " 'window': {(2025, 1): 134.89948749542236,\n", - " (2025, 2): 94.70892810821533,\n", - " (2025, 3): 83.78367471694946,\n", - " (2025, 4): 95.47082138061523,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.3609579801559448,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 1.038238525390625,\n", - " (2025, 11): 47.42695379257202,\n", - " (2025, 12): 98.9332857131958}},\n", - " 189: {'monthly': {(2025, 1): 435.05574905872345,\n", - " (2025, 2): 182.89651834964752,\n", - " (2025, 3): 299.5735844373703,\n", - " (2025, 4): 167.3756994009018,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.3609579801559448,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 1.038238525390625,\n", - " (2025, 11): 115.11637914180756,\n", - " (2025, 12): 342.18010795116425},\n", - " 'window': {(2025, 1): 157.75039291381836,\n", - " (2025, 2): 115.36904811859131,\n", - " (2025, 3): 103.09664630889893,\n", - " (2025, 4): 114.86573314666748,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.3609579801559448,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 1.038238525390625,\n", - " (2025, 11): 61.74885272979736,\n", - " (2025, 12): 127.14097690582275}},\n", - " 190: {'monthly': {(2025, 1): 423.1156105995178,\n", - " (2025, 2): 186.104106426239,\n", - " (2025, 3): 272.6263861656189,\n", - " (2025, 4): 142.23710370063782,\n", - " (2025, 5): 1.3231608867645264,\n", - " (2025, 6): 1.3609579801559448,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 2.0853224992752075,\n", - " (2025, 11): 106.00272786617279,\n", - " (2025, 12): 331.6211848258972},\n", - " 'window': {(2025, 1): 153.7252869606018,\n", - " (2025, 2): 109.25275993347168,\n", - " (2025, 3): 87.19009399414062,\n", - " (2025, 4): 92.41831874847412,\n", - " (2025, 5): 1.3231608867645264,\n", - " (2025, 6): 1.3609579801559448,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 1.0470839738845825,\n", - " (2025, 11): 52.59176158905029,\n", - " (2025, 12): 114.55323028564453}},\n", - " 191: {'monthly': {(2025, 1): 328.19270730018616,\n", - " (2025, 2): 159.7079074382782,\n", - " (2025, 3): 233.65435028076172,\n", - " (2025, 4): 107.8626788854599,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.3010972738265991,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 2.8647972345352173,\n", - " (2025, 11): 87.6978896856308,\n", - " (2025, 12): 271.5109246969223},\n", - " 'window': {(2025, 1): 102.29683113098145,\n", - " (2025, 2): 83.20359516143799,\n", - " (2025, 3): 78.63515663146973,\n", - " (2025, 4): 67.4683256149292,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.3010972738265991,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 1.5369069576263428,\n", - " (2025, 11): 54.78024458885193,\n", - " (2025, 12): 87.62575244903564}},\n", - " 192: {'monthly': {(2025, 1): 351.66738414764404,\n", - " (2025, 2): 155.81891405582428,\n", - " (2025, 3): 201.81197893619537,\n", - " (2025, 4): 107.07214784622192,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.3010972738265991,\n", - " (2025, 7): 1.0051720142364502,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 3.9382810592651367,\n", - " (2025, 11): 75.59266936779022,\n", - " (2025, 12): 244.3031187057495},\n", - " 'window': {(2025, 1): 122.69643783569336,\n", - " (2025, 2): 80.00560855865479,\n", - " (2025, 3): 65.17918872833252,\n", - " (2025, 4): 69.41621494293213,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.3010972738265991,\n", - " (2025, 7): 1.0051720142364502,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 2.398428201675415,\n", - " (2025, 11): 43.80075240135193,\n", - " (2025, 12): 88.35398578643799}},\n", - " 193: {'monthly': {(2025, 1): 334.79853868484497,\n", - " (2025, 2): 132.5673350095749,\n", - " (2025, 3): 179.6711404323578,\n", - " (2025, 4): 105.91713178157806,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 2.337870478630066,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 3.518249988555908,\n", - " (2025, 11): 59.835683941841125,\n", - " (2025, 12): 216.45680141448975},\n", - " 'window': {(2025, 1): 138.55584907531738,\n", - " (2025, 2): 66.5199031829834,\n", - " (2025, 3): 55.193259716033936,\n", - " (2025, 4): 71.82436275482178,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.3010972738265991,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 3.518249988555908,\n", - " (2025, 11): 31.865357995033264,\n", - " (2025, 12): 81.28794860839844}},\n", - " 194: {'monthly': {(2025, 1): 304.11256527900696,\n", - " (2025, 2): 116.72584068775177,\n", - " (2025, 3): 167.2893898487091,\n", - " (2025, 4): 117.20129907131195,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.3010972738265991,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.2571433782577515,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 4.191634654998779,\n", - " (2025, 11): 61.54721021652222,\n", - " (2025, 12): 200.5502644777298},\n", - " 'window': {(2025, 1): 133.0488133430481,\n", - " (2025, 2): 61.973422050476074,\n", - " (2025, 3): 47.82588720321655,\n", - " (2025, 4): 82.43856239318848,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.3010972738265991,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.2571433782577515,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 4.191634654998779,\n", - " (2025, 11): 33.51008713245392,\n", - " (2025, 12): 69.8609972000122}},\n", - " 195: {'monthly': {(2025, 1): 273.5052762031555,\n", - " (2025, 2): 125.98626804351807,\n", - " (2025, 3): 199.84094107151031,\n", - " (2025, 4): 53.85515511035919,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.2518246173858643,\n", - " (2025, 10): 3.297571063041687,\n", - " (2025, 11): 99.26083755493164,\n", - " (2025, 12): 190.71842777729034},\n", - " 'window': {(2025, 1): 100.83993721008301,\n", - " (2025, 2): 77.551025390625,\n", - " (2025, 3): 59.1058464050293,\n", - " (2025, 4): 32.027719020843506,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.2518246173858643,\n", - " (2025, 10): 1.836440086364746,\n", - " (2025, 11): 43.64922022819519,\n", - " (2025, 12): 58.41400599479675}},\n", - " 196: {'monthly': {(2025, 1): 231.11016964912415,\n", - " (2025, 2): 108.0434707403183,\n", - " (2025, 3): 176.32129848003387,\n", - " (2025, 4): 53.47075808048248,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 5.894254803657532,\n", - " (2025, 11): 79.95943653583527,\n", - " (2025, 12): 165.85344636440277},\n", - " 'window': {(2025, 1): 88.58072662353516,\n", - " (2025, 2): 63.85098934173584,\n", - " (2025, 3): 56.28552007675171,\n", - " (2025, 4): 29.10345220565796,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 2.6049234867095947,\n", - " (2025, 11): 33.527504205703735,\n", - " (2025, 12): 57.43168783187866}},\n", - " 197: {'monthly': {(2025, 1): 213.68914186954498,\n", - " (2025, 2): 109.0661895275116,\n", - " (2025, 3): 159.64717710018158,\n", - " (2025, 4): 58.529213309288025,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 5.049949526786804,\n", - " (2025, 11): 73.65836596488953,\n", - " (2025, 12): 152.66093957424164},\n", - " 'window': {(2025, 1): 81.50880527496338,\n", - " (2025, 2): 71.64644575119019,\n", - " (2025, 3): 54.543357849121094,\n", - " (2025, 4): 35.37870264053345,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 1.747133731842041,\n", - " (2025, 11): 33.29602575302124,\n", - " (2025, 12): 52.16058111190796}},\n", - " 198: {'monthly': {(2025, 1): 236.11513233184814,\n", - " (2025, 2): 137.05808067321777,\n", - " (2025, 3): 171.12367165088654,\n", - " (2025, 4): 78.3436404466629,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.0708140134811401,\n", - " (2025, 7): 2.2480043172836304,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 4.148183345794678,\n", - " (2025, 11): 83.39956188201904,\n", - " (2025, 12): 180.10713696479797},\n", - " 'window': {(2025, 1): 84.44415426254272,\n", - " (2025, 2): 87.31511306762695,\n", - " (2025, 3): 58.794315338134766,\n", - " (2025, 4): 47.78605246543884,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.0708140134811401,\n", - " (2025, 7): 1.2310285568237305,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 1.9102985858917236,\n", - " (2025, 11): 36.25108623504639,\n", - " (2025, 12): 59.139225244522095}},\n", - " 199: {'monthly': {(2025, 1): 291.62530410289764,\n", - " (2025, 2): 182.40907096862793,\n", - " (2025, 3): 205.16605401039124,\n", - " (2025, 4): 91.86458718776703,\n", - " (2025, 5): 5.4550029039382935,\n", - " (2025, 6): 2.2407246828079224,\n", - " (2025, 7): 1.2797486782073975,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 6.285576105117798,\n", - " (2025, 11): 101.77280867099762,\n", - " (2025, 12): 231.2849314212799},\n", - " 'window': {(2025, 1): 106.62126064300537,\n", - " (2025, 2): 101.40891075134277,\n", - " (2025, 3): 65.77999496459961,\n", - " (2025, 4): 49.779383182525635,\n", - " (2025, 5): 2.2520045042037964,\n", - " (2025, 6): 1.2099783420562744,\n", - " (2025, 7): 1.2797486782073975,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 2.370286464691162,\n", - " (2025, 11): 46.213616371154785,\n", - " (2025, 12): 83.23688054084778}},\n", - " 200: {'monthly': {(2025, 1): 387.62295389175415,\n", - " (2025, 2): 166.1817842721939,\n", - " (2025, 3): 215.11616492271423,\n", - " (2025, 4): 132.57909166812897,\n", - " (2025, 5): 2.1088693141937256,\n", - " (2025, 6): 3.480323076248169,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 1.038238525390625,\n", - " (2025, 11): 90.66707384586334,\n", - " (2025, 12): 237.80502700805664},\n", - " 'window': {(2025, 1): 115.85489559173584,\n", - " (2025, 2): 91.76450538635254,\n", - " (2025, 3): 71.44747829437256,\n", - " (2025, 4): 81.81719827651978,\n", - " (2025, 5): 2.1088693141937256,\n", - " (2025, 6): 1.3609579801559448,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 1.038238525390625,\n", - " (2025, 11): 38.794106245040894,\n", - " (2025, 12): 85.88532495498657}},\n", - " 201: {'monthly': {(2025, 1): 380.77440106868744,\n", - " (2025, 2): 157.74503779411316,\n", - " (2025, 3): 264.59328186511993,\n", - " (2025, 4): 157.01893997192383,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.3609579801559448,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 1.0555297136306763,\n", - " (2025, 11): 108.1595208644867,\n", - " (2025, 12): 307.628289937973},\n", - " 'window': {(2025, 1): 116.9866533279419,\n", - " (2025, 2): 90.54554843902588,\n", - " (2025, 3): 84.66422080993652,\n", - " (2025, 4): 106.63376522064209,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.3609579801559448,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 1.0555297136306763,\n", - " (2025, 11): 55.51309680938721,\n", - " (2025, 12): 106.5707688331604}},\n", - " 202: {'monthly': {(2025, 1): 428.5645252466202,\n", - " (2025, 2): 192.30787599086761,\n", - " (2025, 3): 318.0563279390335,\n", - " (2025, 4): 172.34109091758728,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.3609579801559448,\n", - " (2025, 7): 1.0026155710220337,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 1.4066345691680908,\n", - " (2025, 11): 129.53317594528198,\n", - " (2025, 12): 371.04972064495087},\n", - " 'window': {(2025, 1): 139.74266719818115,\n", - " (2025, 2): 117.40466022491455,\n", - " (2025, 3): 104.58672714233398,\n", - " (2025, 4): 114.75070095062256,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.3609579801559448,\n", - " (2025, 7): 1.0026155710220337,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 1.4066345691680908,\n", - " (2025, 11): 65.54154014587402,\n", - " (2025, 12): 126.673415184021}},\n", - " 203: {'monthly': {(2025, 1): 431.7368549108505,\n", - " (2025, 2): 183.49599719047546,\n", - " (2025, 3): 256.73051857948303,\n", - " (2025, 4): 145.5522632598877,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.3609579801559448,\n", - " (2025, 7): 1.0004582405090332,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 5.953716158866882,\n", - " (2025, 11): 121.66039717197418,\n", - " (2025, 12): 312.1742788553238},\n", - " 'window': {(2025, 1): 153.47732830047607,\n", - " (2025, 2): 109.7130184173584,\n", - " (2025, 3): 80.60176753997803,\n", - " (2025, 4): 90.92100620269775,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.3609579801559448,\n", - " (2025, 7): 1.0004582405090332,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 2.0984973907470703,\n", - " (2025, 11): 55.2194607257843,\n", - " (2025, 12): 105.82983350753784}},\n", - " 204: {'monthly': {(2025, 1): 285.174742937088,\n", - " (2025, 2): 149.70536494255066,\n", - " (2025, 3): 219.7185481786728,\n", - " (2025, 4): 118.72961664199829,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.3010972738265991,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.089443325996399,\n", - " (2025, 10): 4.089280486106873,\n", - " (2025, 11): 85.90948498249054,\n", - " (2025, 12): 263.1952922344208},\n", - " 'window': {(2025, 1): 92.96064472198486,\n", - " (2025, 2): 74.16324758529663,\n", - " (2025, 3): 74.79654264450073,\n", - " (2025, 4): 78.39490175247192,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.3010972738265991,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.089443325996399,\n", - " (2025, 10): 2.2121434211730957,\n", - " (2025, 11): 45.64798974990845,\n", - " (2025, 12): 84.6470422744751}},\n", - " 205: {'monthly': {(2025, 1): 272.9544245004654,\n", - " (2025, 2): 132.5428454875946,\n", - " (2025, 3): 194.9839938879013,\n", - " (2025, 4): 101.3068231344223,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.3010972738265991,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 4.590579867362976,\n", - " (2025, 11): 68.66206336021423,\n", - " (2025, 12): 228.74186861515045},\n", - " 'window': {(2025, 1): 80.76349353790283,\n", - " (2025, 2): 64.29812145233154,\n", - " (2025, 3): 64.8883924484253,\n", - " (2025, 4): 65.47421836853027,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.3010972738265991,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 3.3465206623077393,\n", - " (2025, 11): 37.884499073028564,\n", - " (2025, 12): 77.48252248764038}},\n", - " 206: {'monthly': {(2025, 1): 256.40966975688934,\n", - " (2025, 2): 114.58075857162476,\n", - " (2025, 3): 186.536306142807,\n", - " (2025, 4): 102.58432507514954,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.3010972738265991,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 6.024126768112183,\n", - " (2025, 11): 54.31561076641083,\n", - " (2025, 12): 219.26981151103973},\n", - " 'window': {(2025, 1): 78.78035831451416,\n", - " (2025, 2): 55.382381439208984,\n", - " (2025, 3): 58.429566383361816,\n", - " (2025, 4): 65.33202791213989,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.3010972738265991,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 6.024126768112183,\n", - " (2025, 11): 27.07530379295349,\n", - " (2025, 12): 76.07975959777832}},\n", - " 207: {'monthly': {(2025, 1): 249.36829006671906,\n", - " (2025, 2): 115.41556584835052,\n", - " (2025, 3): 180.77857303619385,\n", - " (2025, 4): 106.42266297340393,\n", - " (2025, 5): 1.057138204574585,\n", - " (2025, 6): 1.3010972738265991,\n", - " (2025, 7): 1.3310980796813965,\n", - " (2025, 8): 1.2334275245666504,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 6.837601542472839,\n", - " (2025, 11): 55.426525592803955,\n", - " (2025, 12): 193.69917964935303},\n", - " 'window': {(2025, 1): 80.58259868621826,\n", - " (2025, 2): 55.03288412094116,\n", - " (2025, 3): 52.24072599411011,\n", - " (2025, 4): 70.22138833999634,\n", - " (2025, 5): 1.057138204574585,\n", - " (2025, 6): 1.3010972738265991,\n", - " (2025, 7): 1.3310980796813965,\n", - " (2025, 8): 1.2334275245666504,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 6.837601542472839,\n", - " (2025, 11): 27.340267658233643,\n", - " (2025, 12): 63.77544021606445}},\n", - " 208: {'monthly': {(2025, 1): 273.53431832790375,\n", - " (2025, 2): 135.78809118270874,\n", - " (2025, 3): 210.94552302360535,\n", - " (2025, 4): 55.11189019680023,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.162357211112976,\n", - " (2025, 10): 6.014527797698975,\n", - " (2025, 11): 95.90220201015472,\n", - " (2025, 12): 202.80158042907715},\n", - " 'window': {(2025, 1): 102.32980155944824,\n", - " (2025, 2): 79.02264642715454,\n", - " (2025, 3): 63.09611511230469,\n", - " (2025, 4): 33.94230651855469,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.162357211112976,\n", - " (2025, 10): 2.438645601272583,\n", - " (2025, 11): 42.0046329498291,\n", - " (2025, 12): 61.56648850440979}},\n", - " 209: {'monthly': {(2025, 1): 239.85607254505157,\n", - " (2025, 2): 121.45603346824646,\n", - " (2025, 3): 171.05104970932007,\n", - " (2025, 4): 57.75821781158447,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 2.103111743927002,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 5.315378308296204,\n", - " (2025, 11): 82.79248046875,\n", - " (2025, 12): 161.4702204465866},\n", - " 'window': {(2025, 1): 80.75710582733154,\n", - " (2025, 2): 71.53290891647339,\n", - " (2025, 3): 60.7829475402832,\n", - " (2025, 4): 31.035650730133057,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 2.103111743927002,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 2.125143527984619,\n", - " (2025, 11): 34.97137212753296,\n", - " (2025, 12): 57.21100950241089}},\n", - " 210: {'monthly': {(2025, 1): 207.81202745437622,\n", - " (2025, 2): 119.23605680465698,\n", - " (2025, 3): 155.58664774894714,\n", - " (2025, 4): 66.9113472700119,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.4106658697128296,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 4.29548180103302,\n", - " (2025, 11): 74.63878643512726,\n", - " (2025, 12): 145.9102783203125},\n", - " 'window': {(2025, 1): 73.40953779220581,\n", - " (2025, 2): 80.60556554794312,\n", - " (2025, 3): 55.798391342163086,\n", - " (2025, 4): 43.215484857559204,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.4106658697128296,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 1.1052470207214355,\n", - " (2025, 11): 36.413641929626465,\n", - " (2025, 12): 50.13754606246948}},\n", - " 211: {'monthly': {(2025, 1): 224.15846347808838,\n", - " (2025, 2): 143.98257875442505,\n", - " (2025, 3): 154.30000686645508,\n", - " (2025, 4): 81.55229425430298,\n", - " (2025, 5): 1.2815922498703003,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 3.446349620819092,\n", - " (2025, 11): 72.67402124404907,\n", - " (2025, 12): 162.84656739234924},\n", - " 'window': {(2025, 1): 82.85389232635498,\n", - " (2025, 2): 89.84055376052856,\n", - " (2025, 3): 52.902841567993164,\n", - " (2025, 4): 49.49078416824341,\n", - " (2025, 5): 1.2815922498703003,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 1.357059359550476,\n", - " (2025, 11): 34.070528745651245,\n", - " (2025, 12): 56.247421622276306}},\n", - " 212: {'monthly': {(2025, 1): 283.92891681194305,\n", - " (2025, 2): 178.92023921012878,\n", - " (2025, 3): 187.00350844860077,\n", - " (2025, 4): 92.2113983631134,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.2871122360229492,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 7.401693820953369,\n", - " (2025, 11): 103.03796923160553,\n", - " (2025, 12): 216.88450980186462},\n", - " 'window': {(2025, 1): 101.66684293746948,\n", - " (2025, 2): 99.50668144226074,\n", - " (2025, 3): 57.994872093200684,\n", - " (2025, 4): 46.377071380615234,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.2871122360229492,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 2.3663017749786377,\n", - " (2025, 11): 44.08049249649048,\n", - " (2025, 12): 81.7158055305481}},\n", - " 213: {'monthly': {(2025, 1): 381.32078087329865,\n", - " (2025, 2): 149.77181386947632,\n", - " (2025, 3): 234.84890043735504,\n", - " (2025, 4): 145.27173221111298,\n", - " (2025, 5): 1.1651349067687988,\n", - " (2025, 6): 2.8452290296554565,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 1.038238525390625,\n", - " (2025, 11): 97.59694695472717,\n", - " (2025, 12): 262.8042668104172},\n", - " 'window': {(2025, 1): 129.03003215789795,\n", - " (2025, 2): 79.56737518310547,\n", - " (2025, 3): 79.58656167984009,\n", - " (2025, 4): 91.44960641860962,\n", - " (2025, 5): 1.1651349067687988,\n", - " (2025, 6): 2.8452290296554565,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 1.038238525390625,\n", - " (2025, 11): 45.01340365409851,\n", - " (2025, 12): 94.66356658935547}},\n", - " 214: {'monthly': {(2025, 1): 401.11282908916473,\n", - " (2025, 2): 173.65709555149078,\n", - " (2025, 3): 315.3971906900406,\n", - " (2025, 4): 186.19611167907715,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.3609579801559448,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 2.09588623046875,\n", - " (2025, 11): 128.57552874088287,\n", - " (2025, 12): 357.60811614990234},\n", - " 'window': {(2025, 1): 138.55432796478271,\n", - " (2025, 2): 99.03091144561768,\n", - " (2025, 3): 100.80730438232422,\n", - " (2025, 4): 124.12128829956055,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.3609579801559448,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 1.057647705078125,\n", - " (2025, 11): 65.78637886047363,\n", - " (2025, 12): 114.95713949203491}},\n", - " 215: {'monthly': {(2025, 1): 422.95339715480804,\n", - " (2025, 2): 208.07283675670624,\n", - " (2025, 3): 372.5158405303955,\n", - " (2025, 4): 184.74469578266144,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 3.491896629333496,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 7.537941575050354,\n", - " (2025, 11): 144.45101463794708,\n", - " (2025, 12): 399.24398505687714},\n", - " 'window': {(2025, 1): 144.92777061462402,\n", - " (2025, 2): 121.35597038269043,\n", - " (2025, 3): 117.39598178863525,\n", - " (2025, 4): 116.75601387023926,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 2.423523187637329,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 4.579764246940613,\n", - " (2025, 11): 71.12653493881226,\n", - " (2025, 12): 115.30255651473999}},\n", - " 216: {'monthly': {(2025, 1): 408.0175396203995,\n", - " (2025, 2): 194.83980238437653,\n", - " (2025, 3): 305.327134847641,\n", - " (2025, 4): 157.32778108119965,\n", - " (2025, 5): 1.206983208656311,\n", - " (2025, 6): 1.3609579801559448,\n", - " (2025, 7): 1.1439341306686401,\n", - " (2025, 8): 1.324421763420105,\n", - " (2025, 9): 2.7147011756896973,\n", - " (2025, 10): 8.837788462638855,\n", - " (2025, 11): 139.484521150589,\n", - " (2025, 12): 390.1109153032303},\n", - " 'window': {(2025, 1): 136.8659610748291,\n", - " (2025, 2): 110.26840877532959,\n", - " (2025, 3): 93.93850612640381,\n", - " (2025, 4): 92.00763320922852,\n", - " (2025, 5): 1.206983208656311,\n", - " (2025, 6): 1.3609579801559448,\n", - " (2025, 7): 1.1439341306686401,\n", - " (2025, 8): 1.324421763420105,\n", - " (2025, 9): 2.7147011756896973,\n", - " (2025, 10): 5.63313364982605,\n", - " (2025, 11): 62.72771120071411,\n", - " (2025, 12): 96.31202125549316}},\n", - " 217: {'monthly': {(2025, 1): 247.49032533168793,\n", - " (2025, 2): 147.34413707256317,\n", - " (2025, 3): 218.36401784420013,\n", - " (2025, 4): 118.7338947057724,\n", - " (2025, 5): 1.0027306079864502,\n", - " (2025, 6): 1.3010972738265991,\n", - " (2025, 7): 1.0679388046264648,\n", - " (2025, 8): 1.4308501482009888,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 5.579782009124756,\n", - " (2025, 11): 82.57270121574402,\n", - " (2025, 12): 257.5378190279007},\n", - " 'window': {(2025, 1): 71.50080394744873,\n", - " (2025, 2): 64.79634952545166,\n", - " (2025, 3): 72.33721685409546,\n", - " (2025, 4): 79.23354053497314,\n", - " (2025, 5): 1.0027306079864502,\n", - " (2025, 6): 1.3010972738265991,\n", - " (2025, 7): 1.0679388046264648,\n", - " (2025, 8): 1.4308501482009888,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 3.006197452545166,\n", - " (2025, 11): 38.835147857666016,\n", - " (2025, 12): 75.12330436706543}},\n", - " 218: {'monthly': {(2025, 1): 220.07715547084808,\n", - " (2025, 2): 120.73374009132385,\n", - " (2025, 3): 184.57047724723816,\n", - " (2025, 4): 95.09893131256104,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.3010972738265991,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 4.623870611190796,\n", - " (2025, 11): 68.54999208450317,\n", - " (2025, 12): 215.94932663440704},\n", - " 'window': {(2025, 1): 59.097426414489746,\n", - " (2025, 2): 52.4938702583313,\n", - " (2025, 3): 57.726632595062256,\n", - " (2025, 4): 59.04559278488159,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.3010972738265991,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 4.623870611190796,\n", - " (2025, 11): 32.130956172943115,\n", - " (2025, 12): 61.59466886520386}},\n", - " 219: {'monthly': {(2025, 1): 223.45456326007843,\n", - " (2025, 2): 116.83347654342651,\n", - " (2025, 3): 187.94902682304382,\n", - " (2025, 4): 99.8804075717926,\n", - " (2025, 5): 1.0076820850372314,\n", - " (2025, 6): 1.3010972738265991,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.0141935348510742,\n", - " (2025, 10): 5.750280737876892,\n", - " (2025, 11): 59.52780306339264,\n", - " (2025, 12): 222.81905257701874},\n", - " 'window': {(2025, 1): 61.15955448150635,\n", - " (2025, 2): 48.391825675964355,\n", - " (2025, 3): 56.08647680282593,\n", - " (2025, 4): 56.67344379425049,\n", - " (2025, 5): 1.0076820850372314,\n", - " (2025, 6): 1.3010972738265991,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.0141935348510742,\n", - " (2025, 10): 4.405754566192627,\n", - " (2025, 11): 28.002840876579285,\n", - " (2025, 12): 69.3822021484375}},\n", - " 220: {'monthly': {(2025, 1): 234.16321778297424,\n", - " (2025, 2): 126.42442059516907,\n", - " (2025, 3): 189.00621724128723,\n", - " (2025, 4): 100.53133487701416,\n", - " (2025, 5): 1.9477503299713135,\n", - " (2025, 6): 1.3010972738265991,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 7.266541123390198,\n", - " (2025, 11): 55.25514626502991,\n", - " (2025, 12): 211.19532191753387},\n", - " 'window': {(2025, 1): 64.26610565185547,\n", - " (2025, 2): 53.13260841369629,\n", - " (2025, 3): 57.41960573196411,\n", - " (2025, 4): 55.248135566711426,\n", - " (2025, 5): 1.9477503299713135,\n", - " (2025, 6): 1.3010972738265991,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 5.989550709724426,\n", - " (2025, 11): 25.849891543388367,\n", - " (2025, 12): 64.08226346969604}},\n", - " 221: {'monthly': {(2025, 1): 319.87261843681335,\n", - " (2025, 2): 178.0439212322235,\n", - " (2025, 3): 192.21283292770386,\n", - " (2025, 4): 46.52771711349487,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 6.723135709762573,\n", - " (2025, 11): 100.45831346511841,\n", - " (2025, 12): 213.79960358142853},\n", - " 'window': {(2025, 1): 106.82488918304443,\n", - " (2025, 2): 93.04993009567261,\n", - " (2025, 3): 60.90686273574829,\n", - " (2025, 4): 30.206780433654785,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 4.593868970870972,\n", - " (2025, 11): 40.08203887939453,\n", - " (2025, 12): 64.14185667037964}},\n", - " 222: {'monthly': {(2025, 1): 201.93376886844635,\n", - " (2025, 2): 115.1177008152008,\n", - " (2025, 3): 157.80262792110443,\n", - " (2025, 4): 71.84657287597656,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 7.16991662979126,\n", - " (2025, 11): 72.38435995578766,\n", - " (2025, 12): 180.2915471792221},\n", - " 'window': {(2025, 1): 56.3973822593689,\n", - " (2025, 2): 52.23657512664795,\n", - " (2025, 3): 44.025187969207764,\n", - " (2025, 4): 35.00493502616882,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 2.490241765975952,\n", - " (2025, 11): 29.751708507537842,\n", - " (2025, 12): 53.81435585021973}},\n", - " 223: {'monthly': {(2025, 1): 167.85564374923706,\n", - " (2025, 2): 102.62035238742828,\n", - " (2025, 3): 129.03448843955994,\n", - " (2025, 4): 50.67316782474518,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 7.36276638507843,\n", - " (2025, 11): 62.04133152961731,\n", - " (2025, 12): 149.30330753326416},\n", - " 'window': {(2025, 1): 50.98721790313721,\n", - " (2025, 2): 52.69840049743652,\n", - " (2025, 3): 36.87255883216858,\n", - " (2025, 4): 26.3230140209198,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 3.5361168384552,\n", - " (2025, 11): 26.67538046836853,\n", - " (2025, 12): 48.5055890083313}},\n", - " 224: {'monthly': {(2025, 1): 206.4002537727356,\n", - " (2025, 2): 118.98900318145752,\n", - " (2025, 3): 154.94596445560455,\n", - " (2025, 4): 60.77845108509064,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 1.0311492681503296,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 5.735262513160706,\n", - " (2025, 11): 66.72569990158081,\n", - " (2025, 12): 162.5185079574585},\n", - " 'window': {(2025, 1): 60.52603626251221,\n", - " (2025, 2): 60.44649887084961,\n", - " (2025, 3): 43.853699922561646,\n", - " (2025, 4): 32.581878900527954,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 1.0311492681503296,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 3.234016180038452,\n", - " (2025, 11): 29.43816113471985,\n", - " (2025, 12): 46.933074951171875}},\n", - " 225: {'monthly': {(2025, 1): 260.9318062067032,\n", - " (2025, 2): 159.8120757341385,\n", - " (2025, 3): 201.321821808815,\n", - " (2025, 4): 84.05749666690826,\n", - " (2025, 5): 1.4298795461654663,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.2414002418518066,\n", - " (2025, 10): 7.957514405250549,\n", - " (2025, 11): 102.83804976940155,\n", - " (2025, 12): 223.7334327697754},\n", - " 'window': {(2025, 1): 76.88580131530762,\n", - " (2025, 2): 77.85191631317139,\n", - " (2025, 3): 62.522377014160156,\n", - " (2025, 4): 47.39871382713318,\n", - " (2025, 5): 1.4298795461654663,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.2414002418518066,\n", - " (2025, 10): 2.8043665885925293,\n", - " (2025, 11): 45.90279960632324,\n", - " (2025, 12): 61.69319725036621}},\n", - " 226: {'monthly': {(2025, 1): 366.52036798000336,\n", - " (2025, 2): 198.6053066253662,\n", - " (2025, 3): 348.55371737480164,\n", - " (2025, 4): 184.0189255475998,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 2.7543609142303467,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 15.596080780029297,\n", - " (2025, 11): 104.91245770454407,\n", - " (2025, 12): 289.241095662117},\n", - " 'window': {(2025, 1): 123.72125148773193,\n", - " (2025, 2): 99.1861743927002,\n", - " (2025, 3): 92.57823276519775,\n", - " (2025, 4): 102.07728147506714,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.5553457736968994,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 7.958031177520752,\n", - " (2025, 11): 52.309977293014526,\n", - " (2025, 12): 83.25621891021729}},\n", - " 227: {'monthly': {(2025, 1): 403.2963355779648,\n", - " (2025, 2): 230.15266048908234,\n", - " (2025, 3): 416.3877184391022,\n", - " (2025, 4): 270.30404901504517,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.5553457736968994,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 13.904668092727661,\n", - " (2025, 11): 135.45642924308777,\n", - " (2025, 12): 391.2047437429428},\n", - " 'window': {(2025, 1): 134.1320676803589,\n", - " (2025, 2): 120.46742343902588,\n", - " (2025, 3): 111.61764144897461,\n", - " (2025, 4): 159.95176029205322,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.5553457736968994,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 9.79074478149414,\n", - " (2025, 11): 73.66125965118408,\n", - " (2025, 12): 110.68613719940186}},\n", - " 228: {'monthly': {(2025, 1): 359.55149269104004,\n", - " (2025, 2): 212.33527076244354,\n", - " (2025, 3): 389.0410634279251,\n", - " (2025, 4): 251.63573813438416,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.5553457736968994,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 20.509551405906677,\n", - " (2025, 11): 137.73434686660767,\n", - " (2025, 12): 386.31759428977966},\n", - " 'window': {(2025, 1): 125.51261043548584,\n", - " (2025, 2): 105.9107551574707,\n", - " (2025, 3): 103.45435237884521,\n", - " (2025, 4): 149.47849369049072,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.5553457736968994,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 11.716827511787415,\n", - " (2025, 11): 74.55585813522339,\n", - " (2025, 12): 108.82304859161377}},\n", - " 229: {'monthly': {(2025, 1): 306.53113853931427,\n", - " (2025, 2): 219.00865399837494,\n", - " (2025, 3): 343.8580548763275,\n", - " (2025, 4): 214.7391299009323,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.5553457736968994,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 29.346158623695374,\n", - " (2025, 11): 150.51690471172333,\n", - " (2025, 12): 386.5152827501297},\n", - " 'window': {(2025, 1): 108.02193069458008,\n", - " (2025, 2): 104.88340759277344,\n", - " (2025, 3): 96.37240886688232,\n", - " (2025, 4): 124.7717399597168,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.5553457736968994,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 13.980042815208435,\n", - " (2025, 11): 71.54993867874146,\n", - " (2025, 12): 106.99087905883789}},\n", - " 230: {'monthly': {(2025, 1): 246.4872831106186,\n", - " (2025, 2): 192.71495819091797,\n", - " (2025, 3): 245.79066359996796,\n", - " (2025, 4): 133.876162648201,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.4175138473510742,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.3636492490768433,\n", - " (2025, 10): 5.287878394126892,\n", - " (2025, 11): 111.23822867870331,\n", - " (2025, 12): 309.2769455909729},\n", - " 'window': {(2025, 1): 77.2144103050232,\n", - " (2025, 2): 112.47221183776855,\n", - " (2025, 3): 58.01394033432007,\n", - " (2025, 4): 69.08682060241699,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.4175138473510742,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.3636492490768433,\n", - " (2025, 10): 2.8597826957702637,\n", - " (2025, 11): 53.48014450073242,\n", - " (2025, 12): 87.07191896438599}},\n", - " 231: {'monthly': {(2025, 1): 195.99782931804657,\n", - " (2025, 2): 156.88851690292358,\n", - " (2025, 3): 187.50374913215637,\n", - " (2025, 4): 94.1546710729599,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.4175138473510742,\n", - " (2025, 7): 1.061269998550415,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.6917773485183716,\n", - " (2025, 10): 2.0837242603302,\n", - " (2025, 11): 68.17345368862152,\n", - " (2025, 12): 245.6798835992813},\n", - " 'window': {(2025, 1): 60.95684003829956,\n", - " (2025, 2): 95.21052122116089,\n", - " (2025, 3): 43.64749050140381,\n", - " (2025, 4): 46.409912109375,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.4175138473510742,\n", - " (2025, 7): 1.061269998550415,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.6917773485183716,\n", - " (2025, 10): 2.0837242603302,\n", - " (2025, 11): 39.23953318595886,\n", - " (2025, 12): 83.21810340881348}},\n", - " 232: {'monthly': {(2025, 1): 209.54100155830383,\n", - " (2025, 2): 159.09346091747284,\n", - " (2025, 3): 189.75567877292633,\n", - " (2025, 4): 98.49797856807709,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.4175138473510742,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 2.5570623874664307,\n", - " (2025, 9): 1.9311648607254028,\n", - " (2025, 10): 4.946237921714783,\n", - " (2025, 11): 71.54178154468536,\n", - " (2025, 12): 278.166063785553},\n", - " 'window': {(2025, 1): 63.580111503601074,\n", - " (2025, 2): 89.84424161911011,\n", - " (2025, 3): 45.63286352157593,\n", - " (2025, 4): 45.39612436294556,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.4175138473510742,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.5101903676986694,\n", - " (2025, 9): 1.9311648607254028,\n", - " (2025, 10): 3.6175490617752075,\n", - " (2025, 11): 43.272881507873535,\n", - " (2025, 12): 94.81770086288452}},\n", - " 233: {'monthly': {(2025, 1): 229.08553636074066,\n", - " (2025, 2): 181.61409437656403,\n", - " (2025, 3): 203.7202695608139,\n", - " (2025, 4): 92.62202978134155,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.4175138473510742,\n", - " (2025, 7): 1.4693858623504639,\n", - " (2025, 8): 1.669073462486267,\n", - " (2025, 9): 2.3043713569641113,\n", - " (2025, 10): 2.838242530822754,\n", - " (2025, 11): 63.8700852394104,\n", - " (2025, 12): 271.7279894351959},\n", - " 'window': {(2025, 1): 71.25809955596924,\n", - " (2025, 2): 103.78987836837769,\n", - " (2025, 3): 49.62845706939697,\n", - " (2025, 4): 44.143521785736084,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.4175138473510742,\n", - " (2025, 7): 1.4693858623504639,\n", - " (2025, 8): 1.669073462486267,\n", - " (2025, 9): 2.3043713569641113,\n", - " (2025, 10): 2.838242530822754,\n", - " (2025, 11): 40.53655815124512,\n", - " (2025, 12): 85.91589307785034}},\n", - " 234: {'monthly': {(2025, 1): 273.8959002494812,\n", - " (2025, 2): 166.65645384788513,\n", - " (2025, 3): 229.24714469909668,\n", - " (2025, 4): 48.67717504501343,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 6.384333610534668,\n", - " (2025, 11): 105.54201221466064,\n", - " (2025, 12): 197.08342933654785},\n", - " 'window': {(2025, 1): 100.43943786621094,\n", - " (2025, 2): 89.97407722473145,\n", - " (2025, 3): 76.28687500953674,\n", - " (2025, 4): 28.08340299129486,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 5.2033772468566895,\n", - " (2025, 11): 42.79391384124756,\n", - " (2025, 12): 62.80575084686279}},\n", - " 235: {'monthly': {(2025, 1): 216.51793789863586,\n", - " (2025, 2): 119.48564541339874,\n", - " (2025, 3): 157.53263676166534,\n", - " (2025, 4): 71.85441899299622,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 5.345678210258484,\n", - " (2025, 11): 91.64720225334167,\n", - " (2025, 12): 179.24096930027008},\n", - " 'window': {(2025, 1): 72.53413963317871,\n", - " (2025, 2): 54.42502737045288,\n", - " (2025, 3): 50.5379593372345,\n", - " (2025, 4): 35.73261833190918,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 1.6935867071151733,\n", - " (2025, 11): 33.92147707939148,\n", - " (2025, 12): 53.1882209777832}},\n", - " 236: {'monthly': {(2025, 1): 200.27958500385284,\n", - " (2025, 2): 115.62437796592712,\n", - " (2025, 3): 141.57616102695465,\n", - " (2025, 4): 60.57253539562225,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 5.344237208366394,\n", - " (2025, 11): 73.023388504982,\n", - " (2025, 12): 165.7662034034729},\n", - " 'window': {(2025, 1): 67.46398735046387,\n", - " (2025, 2): 56.525808334350586,\n", - " (2025, 3): 44.27806115150452,\n", - " (2025, 4): 35.620827198028564,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 2.241854190826416,\n", - " (2025, 11): 27.475573539733887,\n", - " (2025, 12): 51.28856372833252}},\n", - " 237: {'monthly': {(2025, 1): 238.57553672790527,\n", - " (2025, 2): 127.66957151889801,\n", - " (2025, 3): 169.37954342365265,\n", - " (2025, 4): 84.48671305179596,\n", - " (2025, 5): 1.224462628364563,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 2.010106325149536,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 6.777572870254517,\n", - " (2025, 11): 76.35643815994263,\n", - " (2025, 12): 174.20299637317657},\n", - " 'window': {(2025, 1): 73.72440910339355,\n", - " (2025, 2): 65.12637615203857,\n", - " (2025, 3): 46.4231162071228,\n", - " (2025, 4): 51.191150188446045,\n", - " (2025, 5): 1.224462628364563,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 2.010106325149536,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 2.832585334777832,\n", - " (2025, 11): 33.70972967147827,\n", - " (2025, 12): 50.7117657661438}},\n", - " 238: {'monthly': {(2025, 1): 298.4917217493057,\n", - " (2025, 2): 168.92434334754944,\n", - " (2025, 3): 221.68408632278442,\n", - " (2025, 4): 121.33095049858093,\n", - " (2025, 5): 3.175995945930481,\n", - " (2025, 6): 3.6013667583465576,\n", - " (2025, 7): 2.2581809759140015,\n", - " (2025, 8): 2.849128246307373,\n", - " (2025, 9): 3.763099193572998,\n", - " (2025, 10): 10.645146369934082,\n", - " (2025, 11): 97.46631240844727,\n", - " (2025, 12): 213.1962172985077},\n", - " 'window': {(2025, 1): 85.6056137084961,\n", - " (2025, 2): 81.97216415405273,\n", - " (2025, 3): 62.055652141571045,\n", - " (2025, 4): 68.81815481185913,\n", - " (2025, 5): 3.175995945930481,\n", - " (2025, 6): 2.473442554473877,\n", - " (2025, 7): 1.1714355945587158,\n", - " (2025, 8): 2.849128246307373,\n", - " (2025, 9): 2.6179882287979126,\n", - " (2025, 10): 4.601684093475342,\n", - " (2025, 11): 44.74652719497681,\n", - " (2025, 12): 57.213130950927734}},\n", - " 239: {'monthly': {(2025, 1): 394.6603044271469,\n", - " (2025, 2): 208.99232840538025,\n", - " (2025, 3): 386.623206615448,\n", - " (2025, 4): 241.3667355775833,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.5553457736968994,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.1106929779052734,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 18.27336585521698,\n", - " (2025, 11): 128.21563923358917,\n", - " (2025, 12): 342.4685196876526},\n", - " 'window': {(2025, 1): 125.6995038986206,\n", - " (2025, 2): 116.30711650848389,\n", - " (2025, 3): 98.49825763702393,\n", - " (2025, 4): 138.12734031677246,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.5553457736968994,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.1106929779052734,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 10.970580220222473,\n", - " (2025, 11): 68.87424373626709,\n", - " (2025, 12): 98.05483150482178}},\n", - " 240: {'monthly': {(2025, 1): 426.6401478052139,\n", - " (2025, 2): 236.76599299907684,\n", - " (2025, 3): 436.4132204055786,\n", - " (2025, 4): 339.22953259944916,\n", - " (2025, 5): 1.0200424194335938,\n", - " (2025, 6): 1.9471595287322998,\n", - " (2025, 7): 1.0087776184082031,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 19.742984175682068,\n", - " (2025, 11): 171.25743174552917,\n", - " (2025, 12): 479.24298548698425},\n", - " 'window': {(2025, 1): 135.04079246520996,\n", - " (2025, 2): 128.91118907928467,\n", - " (2025, 3): 110.59852981567383,\n", - " (2025, 4): 203.91625213623047,\n", - " (2025, 5): 1.0200424194335938,\n", - " (2025, 6): 1.9471595287322998,\n", - " (2025, 7): 1.0087776184082031,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 11.956900596618652,\n", - " (2025, 11): 92.44645404815674,\n", - " (2025, 12): 136.36158990859985}},\n", - " 241: {'monthly': {(2025, 1): 373.6465309858322,\n", - " (2025, 2): 207.4979248046875,\n", - " (2025, 3): 349.7019052505493,\n", - " (2025, 4): 285.66556334495544,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.5553457736968994,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 17.02873730659485,\n", - " (2025, 11): 142.42565441131592,\n", - " (2025, 12): 385.8250503540039},\n", - " 'window': {(2025, 1): 131.33296298980713,\n", - " (2025, 2): 111.36127185821533,\n", - " (2025, 3): 87.09891319274902,\n", - " (2025, 4): 176.8719425201416,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.5553457736968994,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 8.402053356170654,\n", - " (2025, 11): 80.08158206939697,\n", - " (2025, 12): 109.0947265625}},\n", - " 242: {'monthly': {(2025, 1): 282.45044708251953,\n", - " (2025, 2): 210.05589246749878,\n", - " (2025, 3): 292.4758048057556,\n", - " (2025, 4): 249.51370704174042,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.5553457736968994,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 17.87425446510315,\n", - " (2025, 11): 149.22257792949677,\n", - " (2025, 12): 336.02346336841583},\n", - " 'window': {(2025, 1): 101.58355236053467,\n", - " (2025, 2): 108.34710693359375,\n", - " (2025, 3): 77.56201553344727,\n", - " (2025, 4): 157.46219730377197,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.5553457736968994,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 7.61039662361145,\n", - " (2025, 11): 77.58879375457764,\n", - " (2025, 12): 95.69102668762207}},\n", - " 243: {'monthly': {(2025, 1): 239.9224715232849,\n", - " (2025, 2): 188.21568048000336,\n", - " (2025, 3): 279.36314582824707,\n", - " (2025, 4): 157.00789308547974,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.4175138473510742,\n", - " (2025, 7): 1.0403263568878174,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.0091508626937866,\n", - " (2025, 10): 4.495047092437744,\n", - " (2025, 11): 99.50795471668243,\n", - " (2025, 12): 272.2211480140686},\n", - " 'window': {(2025, 1): 77.88621807098389,\n", - " (2025, 2): 108.38362503051758,\n", - " (2025, 3): 77.6118392944336,\n", - " (2025, 4): 89.5345106124878,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.4175138473510742,\n", - " (2025, 7): 1.0403263568878174,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.0091508626937866,\n", - " (2025, 10): 3.2520986795425415,\n", - " (2025, 11): 54.19295883178711,\n", - " (2025, 12): 80.64128398895264}},\n", - " 244: {'monthly': {(2025, 1): 191.61810278892517,\n", - " (2025, 2): 140.76785480976105,\n", - " (2025, 3): 205.43467092514038,\n", - " (2025, 4): 117.3703556060791,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.4175138473510742,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.1572186946868896,\n", - " (2025, 10): 1.4253202676773071,\n", - " (2025, 11): 59.73864483833313,\n", - " (2025, 12): 226.66808784008026},\n", - " 'window': {(2025, 1): 61.30551242828369,\n", - " (2025, 2): 84.4570369720459,\n", - " (2025, 3): 47.96193885803223,\n", - " (2025, 4): 68.64692640304565,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.4175138473510742,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.1572186946868896,\n", - " (2025, 10): 1.4253202676773071,\n", - " (2025, 11): 37.768672704696655,\n", - " (2025, 12): 78.62750124931335}},\n", - " 245: {'monthly': {(2025, 1): 206.34407567977905,\n", - " (2025, 2): 136.7864534854889,\n", - " (2025, 3): 211.7112194299698,\n", - " (2025, 4): 116.88877391815186,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.4175138473510742,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.0664153099060059,\n", - " (2025, 9): 1.397840142250061,\n", - " (2025, 10): 2.728006958961487,\n", - " (2025, 11): 62.73245847225189,\n", - " (2025, 12): 243.67438888549805},\n", - " 'window': {(2025, 1): 60.81514549255371,\n", - " (2025, 2): 75.18314695358276,\n", - " (2025, 3): 50.23490333557129,\n", - " (2025, 4): 69.10823631286621,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.4175138473510742,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.0664153099060059,\n", - " (2025, 9): 1.397840142250061,\n", - " (2025, 10): 1.7216882705688477,\n", - " (2025, 11): 39.087122201919556,\n", - " (2025, 12): 84.08445882797241}},\n", - " 246: {'monthly': {(2025, 1): 225.25510942935944,\n", - " (2025, 2): 149.32656526565552,\n", - " (2025, 3): 201.40639913082123,\n", - " (2025, 4): 98.46104121208191,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.4175138473510742,\n", - " (2025, 7): 1.2656285762786865,\n", - " (2025, 8): 1.2680816650390625,\n", - " (2025, 9): 1.7468801736831665,\n", - " (2025, 10): 3.1856672763824463,\n", - " (2025, 11): 61.08494412899017,\n", - " (2025, 12): 231.197869181633},\n", - " 'window': {(2025, 1): 70.85613012313843,\n", - " (2025, 2): 82.86358404159546,\n", - " (2025, 3): 52.86068534851074,\n", - " (2025, 4): 55.17000675201416,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.4175138473510742,\n", - " (2025, 7): 1.2656285762786865,\n", - " (2025, 8): 1.2680816650390625,\n", - " (2025, 9): 1.7468801736831665,\n", - " (2025, 10): 2.151592969894409,\n", - " (2025, 11): 36.54160690307617,\n", - " (2025, 12): 77.78643083572388}},\n", - " 247: {'monthly': {(2025, 1): 227.45019209384918,\n", - " (2025, 2): 170.1435191631317,\n", - " (2025, 3): 237.0215983390808,\n", - " (2025, 4): 57.80133295059204,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 6.655245780944824,\n", - " (2025, 11): 112.41663444042206,\n", - " (2025, 12): 200.53972017765045},\n", - " 'window': {(2025, 1): 80.68683338165283,\n", - " (2025, 2): 80.20261144638062,\n", - " (2025, 3): 74.95880651473999,\n", - " (2025, 4): 32.25265645980835,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 5.377922534942627,\n", - " (2025, 11): 45.95880174636841,\n", - " (2025, 12): 56.54152011871338}},\n", - " 248: {'monthly': {(2025, 1): 234.55624103546143,\n", - " (2025, 2): 137.50278985500336,\n", - " (2025, 3): 164.53887569904327,\n", - " (2025, 4): 69.02935647964478,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 4.905952334403992,\n", - " (2025, 11): 87.79777324199677,\n", - " (2025, 12): 184.71713626384735},\n", - " 'window': {(2025, 1): 81.61124610900879,\n", - " (2025, 2): 60.07251453399658,\n", - " (2025, 3): 61.340131759643555,\n", - " (2025, 4): 38.04334092140198,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 2.772889494895935,\n", - " (2025, 11): 33.52263069152832,\n", - " (2025, 12): 53.24228858947754}},\n", - " 249: {'monthly': {(2025, 1): 221.5516095161438,\n", - " (2025, 2): 113.7992023229599,\n", - " (2025, 3): 151.4203861951828,\n", - " (2025, 4): 65.31006610393524,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 3.3673667907714844,\n", - " (2025, 11): 73.61824071407318,\n", - " (2025, 12): 168.68960511684418},\n", - " 'window': {(2025, 1): 77.72476148605347,\n", - " (2025, 2): 58.65337324142456,\n", - " (2025, 3): 50.81839966773987,\n", - " (2025, 4): 39.25525093078613,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 1.2824640274047852,\n", - " (2025, 11): 29.16438913345337,\n", - " (2025, 12): 48.7837872505188}},\n", - " 250: {'monthly': {(2025, 1): 274.39171373844147,\n", - " (2025, 2): 137.04016864299774,\n", - " (2025, 3): 181.83659601211548,\n", - " (2025, 4): 108.32819771766663,\n", - " (2025, 5): 4.955557346343994,\n", - " (2025, 6): 3.5944087505340576,\n", - " (2025, 7): 1.4125432968139648,\n", - " (2025, 8): 1.8401812314987183,\n", - " (2025, 9): 1.139490008354187,\n", - " (2025, 10): 10.557096481323242,\n", - " (2025, 11): 95.81492102146149,\n", - " (2025, 12): 195.17271208763123},\n", - " 'window': {(2025, 1): 84.21956205368042,\n", - " (2025, 2): 72.60670471191406,\n", - " (2025, 3): 50.85506558418274,\n", - " (2025, 4): 63.41263246536255,\n", - " (2025, 5): 2.3838717937469482,\n", - " (2025, 6): 1.241010069847107,\n", - " (2025, 7): 1.4125432968139648,\n", - " (2025, 8): 1.8401812314987183,\n", - " (2025, 9): 1.139490008354187,\n", - " (2025, 10): 3.9023616313934326,\n", - " (2025, 11): 37.87270402908325,\n", - " (2025, 12): 51.46285820007324}},\n", - " 251: {'monthly': {(2025, 1): 345.8156759738922,\n", - " (2025, 2): 195.02663803100586,\n", - " (2025, 3): 249.05593729019165,\n", - " (2025, 4): 169.74940490722656,\n", - " (2025, 5): 7.389976263046265,\n", - " (2025, 6): 5.908871054649353,\n", - " (2025, 7): 10.149755239486694,\n", - " (2025, 8): 3.365885853767395,\n", - " (2025, 9): 4.085206389427185,\n", - " (2025, 10): 21.987053871154785,\n", - " (2025, 11): 130.32395887374878,\n", - " (2025, 12): 243.0900331735611},\n", - " 'window': {(2025, 1): 98.90455055236816,\n", - " (2025, 2): 98.53079319000244,\n", - " (2025, 3): 67.40480470657349,\n", - " (2025, 4): 85.16368818283081,\n", - " (2025, 5): 3.099050521850586,\n", - " (2025, 6): 1.6552870273590088,\n", - " (2025, 7): 4.4089250564575195,\n", - " (2025, 8): 2.268533229827881,\n", - " (2025, 9): 1.7052253484725952,\n", - " (2025, 10): 8.430463194847107,\n", - " (2025, 11): 51.55964660644531,\n", - " (2025, 12): 62.287686824798584}},\n", - " 252: {'monthly': {(2025, 1): 421.81662452220917,\n", - " (2025, 2): 222.53889501094818,\n", - " (2025, 3): 430.8699553012848,\n", - " (2025, 4): 310.31430315971375,\n", - " (2025, 5): 1.3588405847549438,\n", - " (2025, 6): 7.461853742599487,\n", - " (2025, 7): 2.358096122741699,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 23.39218819141388,\n", - " (2025, 11): 154.40768158435822,\n", - " (2025, 12): 413.28559148311615},\n", - " 'window': {(2025, 1): 123.69172668457031,\n", - " (2025, 2): 116.94570350646973,\n", - " (2025, 3): 104.72893142700195,\n", - " (2025, 4): 174.70942974090576,\n", - " (2025, 5): 1.3588405847549438,\n", - " (2025, 6): 2.5643616914749146,\n", - " (2025, 7): 1.215187430381775,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 13.574214220046997,\n", - " (2025, 11): 85.06169891357422,\n", - " (2025, 12): 124.49143409729004}},\n", - " 253: {'monthly': {(2025, 1): 428.8512387275696,\n", - " (2025, 2): 228.8956137895584,\n", - " (2025, 3): 463.4165720939636,\n", - " (2025, 4): 427.4646100997925,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 2.6622825860977173,\n", - " (2025, 7): 2.4140772819519043,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 25.003058314323425,\n", - " (2025, 11): 204.57084250450134,\n", - " (2025, 12): 571.3393774032593},\n", - " 'window': {(2025, 1): 127.4951171875,\n", - " (2025, 2): 116.65597438812256,\n", - " (2025, 3): 115.78497695922852,\n", - " (2025, 4): 257.529221534729,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.5553457736968994,\n", - " (2025, 7): 2.4140772819519043,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 13.006116032600403,\n", - " (2025, 11): 105.36730766296387,\n", - " (2025, 12): 161.3046646118164}},\n", - " 254: {'monthly': {(2025, 1): 390.9216287136078,\n", - " (2025, 2): 195.53958177566528,\n", - " (2025, 3): 341.15224623680115,\n", - " (2025, 4): 335.0680811405182,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 2.557509422302246,\n", - " (2025, 7): 2.236418604850769,\n", - " (2025, 8): 1.0335166454315186,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 16.624141931533813,\n", - " (2025, 11): 151.9207489490509,\n", - " (2025, 12): 408.9963364601135},\n", - " 'window': {(2025, 1): 131.15241527557373,\n", - " (2025, 2): 104.66917037963867,\n", - " (2025, 3): 85.3757553100586,\n", - " (2025, 4): 216.91265678405762,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 2.557509422302246,\n", - " (2025, 7): 1.1439522504806519,\n", - " (2025, 8): 1.0335166454315186,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 7.7485493421554565,\n", - " (2025, 11): 81.82412147521973,\n", - " (2025, 12): 111.68693256378174}},\n", - " 255: {'monthly': {(2025, 1): 266.4176788330078,\n", - " (2025, 2): 165.25718367099762,\n", - " (2025, 3): 231.46593284606934,\n", - " (2025, 4): 273.4020684957504,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.5553457736968994,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 12.29162883758545,\n", - " (2025, 11): 116.47119784355164,\n", - " (2025, 12): 269.74975085258484},\n", - " 'window': {(2025, 1): 95.01444816589355,\n", - " (2025, 2): 85.76765203475952,\n", - " (2025, 3): 59.86771059036255,\n", - " (2025, 4): 191.81088495254517,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.5553457736968994,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 5.547946572303772,\n", - " (2025, 11): 68.04074382781982,\n", - " (2025, 12): 78.21909427642822}},\n", - " 256: {'monthly': {(2025, 1): 229.60655069351196,\n", - " (2025, 2): 146.55306482315063,\n", - " (2025, 3): 247.31485772132874,\n", - " (2025, 4): 153.35904347896576,\n", - " (2025, 5): 1.031073808670044,\n", - " (2025, 6): 1.4175138473510742,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.0418106317520142,\n", - " (2025, 10): 1.067665934562683,\n", - " (2025, 11): 73.84175992012024,\n", - " (2025, 12): 221.9476191997528},\n", - " 'window': {(2025, 1): 77.70272541046143,\n", - " (2025, 2): 78.06177139282227,\n", - " (2025, 3): 80.85602855682373,\n", - " (2025, 4): 95.94324970245361,\n", - " (2025, 5): 1.031073808670044,\n", - " (2025, 6): 1.4175138473510742,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.0418106317520142,\n", - " (2025, 10): 1.067665934562683,\n", - " (2025, 11): 51.67562007904053,\n", - " (2025, 12): 73.05602836608887}},\n", - " 257: {'monthly': {(2025, 1): 195.94608938694,\n", - " (2025, 2): 116.74488854408264,\n", - " (2025, 3): 205.21332275867462,\n", - " (2025, 4): 131.5421177148819,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.4175138473510742,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 1.1917744874954224,\n", - " (2025, 11): 60.67163097858429,\n", - " (2025, 12): 197.2852327823639},\n", - " 'window': {(2025, 1): 63.33911323547363,\n", - " (2025, 2): 61.721171140670776,\n", - " (2025, 3): 57.418639183044434,\n", - " (2025, 4): 81.09548854827881,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.4175138473510742,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 1.1917744874954224,\n", - " (2025, 11): 38.71168088912964,\n", - " (2025, 12): 60.32120990753174}},\n", - " 258: {'monthly': {(2025, 1): 213.11731243133545,\n", - " (2025, 2): 121.12218284606934,\n", - " (2025, 3): 222.9860999584198,\n", - " (2025, 4): 128.55054879188538,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.4175138473510742,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.1946513652801514,\n", - " (2025, 10): 1.4714252948760986,\n", - " (2025, 11): 63.21574115753174,\n", - " (2025, 12): 215.93104553222656},\n", - " 'window': {(2025, 1): 64.49951648712158,\n", - " (2025, 2): 59.91704607009888,\n", - " (2025, 3): 53.76380681991577,\n", - " (2025, 4): 77.06278562545776,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.4175138473510742,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.1946513652801514,\n", - " (2025, 10): 1.4714252948760986,\n", - " (2025, 11): 41.33145499229431,\n", - " (2025, 12): 60.02959966659546}},\n", - " 259: {'monthly': {(2025, 1): 216.83819794654846,\n", - " (2025, 2): 123.03599715232849,\n", - " (2025, 3): 193.13580226898193,\n", - " (2025, 4): 96.25019216537476,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.4175138473510742,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.409909963607788,\n", - " (2025, 10): 2.844293475151062,\n", - " (2025, 11): 59.608840107917786,\n", - " (2025, 12): 202.28444039821625},\n", - " 'window': {(2025, 1): 72.90394973754883,\n", - " (2025, 2): 65.26506090164185,\n", - " (2025, 3): 43.84467363357544,\n", - " (2025, 4): 53.69237947463989,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.4175138473510742,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.409909963607788,\n", - " (2025, 10): 2.844293475151062,\n", - " (2025, 11): 36.74420380592346,\n", - " (2025, 12): 59.82644510269165}},\n", - " 260: {'monthly': {(2025, 1): 220.6799899339676,\n", - " (2025, 2): 163.51381635665894,\n", - " (2025, 3): 237.26230895519257,\n", - " (2025, 4): 62.78717279434204,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 10.018587827682495,\n", - " (2025, 11): 123.46408426761627,\n", - " (2025, 12): 213.37545883655548},\n", - " 'window': {(2025, 1): 77.41906023025513,\n", - " (2025, 2): 70.94084119796753,\n", - " (2025, 3): 61.00535774230957,\n", - " (2025, 4): 36.86309480667114,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 4.432496547698975,\n", - " (2025, 11): 50.675185680389404,\n", - " (2025, 12): 58.01862621307373}},\n", - " 261: {'monthly': {(2025, 1): 250.162250995636,\n", - " (2025, 2): 129.56352412700653,\n", - " (2025, 3): 171.68808507919312,\n", - " (2025, 4): 69.43709206581116,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 6.603645920753479,\n", - " (2025, 11): 89.64895784854889,\n", - " (2025, 12): 183.77656745910645},\n", - " 'window': {(2025, 1): 78.36266422271729,\n", - " (2025, 2): 61.780086517333984,\n", - " (2025, 3): 54.0058958530426,\n", - " (2025, 4): 35.30723428726196,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 2.776996374130249,\n", - " (2025, 11): 36.17426633834839,\n", - " (2025, 12): 52.17266654968262}},\n", - " 262: {'monthly': {(2025, 1): 216.69495463371277,\n", - " (2025, 2): 115.01634693145752,\n", - " (2025, 3): 161.3480829000473,\n", - " (2025, 4): 57.855260491371155,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 7.148380875587463,\n", - " (2025, 11): 76.14674603939056,\n", - " (2025, 12): 159.03821349143982},\n", - " 'window': {(2025, 1): 73.97088813781738,\n", - " (2025, 2): 55.67338991165161,\n", - " (2025, 3): 55.45006990432739,\n", - " (2025, 4): 31.868408799171448,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 3.893700361251831,\n", - " (2025, 11): 29.17023468017578,\n", - " (2025, 12): 45.24798059463501}},\n", - " 263: {'monthly': {(2025, 1): 290.0836775302887,\n", - " (2025, 2): 149.81781661510468,\n", - " (2025, 3): 195.49336791038513,\n", - " (2025, 4): 109.79410886764526,\n", - " (2025, 5): 6.443316698074341,\n", - " (2025, 6): 4.399109840393066,\n", - " (2025, 7): 4.848090052604675,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 2.3186495304107666,\n", - " (2025, 10): 13.518162965774536,\n", - " (2025, 11): 103.12890934944153,\n", - " (2025, 12): 208.67552506923676},\n", - " 'window': {(2025, 1): 90.13876056671143,\n", - " (2025, 2): 72.9819130897522,\n", - " (2025, 3): 57.06071615219116,\n", - " (2025, 4): 58.898837089538574,\n", - " (2025, 5): 3.601432204246521,\n", - " (2025, 6): 2.865606665611267,\n", - " (2025, 7): 2.4300730228424072,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.1923846006393433,\n", - " (2025, 10): 4.4623188972473145,\n", - " (2025, 11): 39.973008155822754,\n", - " (2025, 12): 52.93163013458252}},\n", - " 264: {'monthly': {(2025, 1): 373.71601033210754,\n", - " (2025, 2): 222.1445928812027,\n", - " (2025, 3): 271.5296356678009,\n", - " (2025, 4): 187.94715070724487,\n", - " (2025, 5): 14.057273983955383,\n", - " (2025, 6): 14.220756530761719,\n", - " (2025, 7): 8.267739176750183,\n", - " (2025, 8): 7.910537481307983,\n", - " (2025, 9): 10.768349170684814,\n", - " (2025, 10): 26.802852630615234,\n", - " (2025, 11): 148.72660744190216,\n", - " (2025, 12): 274.5586552619934},\n", - " 'window': {(2025, 1): 104.96645641326904,\n", - " (2025, 2): 115.69377422332764,\n", - " (2025, 3): 78.11378240585327,\n", - " (2025, 4): 82.37810039520264,\n", - " (2025, 5): 4.809547543525696,\n", - " (2025, 6): 5.160336256027222,\n", - " (2025, 7): 3.319887399673462,\n", - " (2025, 8): 4.503551006317139,\n", - " (2025, 9): 4.349260210990906,\n", - " (2025, 10): 8.057207107543945,\n", - " (2025, 11): 53.55613613128662,\n", - " (2025, 12): 70.3122968673706}},\n", - " 265: {'monthly': {(2025, 1): 420.521121263504,\n", - " (2025, 2): 213.09767162799835,\n", - " (2025, 3): 441.14673590660095,\n", - " (2025, 4): 350.8299924135208,\n", - " (2025, 5): 7.280246019363403,\n", - " (2025, 6): 7.425906538963318,\n", - " (2025, 7): 1.10724937915802,\n", - " (2025, 8): 1.44016432762146,\n", - " (2025, 9): 3.406709313392639,\n", - " (2025, 10): 30.966140031814575,\n", - " (2025, 11): 160.99129056930542,\n", - " (2025, 12): 445.4013366699219},\n", - " 'window': {(2025, 1): 116.56767177581787,\n", - " (2025, 2): 100.4112138748169,\n", - " (2025, 3): 107.62940406799316,\n", - " (2025, 4): 197.68295764923096,\n", - " (2025, 5): 2.725476861000061,\n", - " (2025, 6): 3.6830108165740967,\n", - " (2025, 7): 1.10724937915802,\n", - " (2025, 8): 1.44016432762146,\n", - " (2025, 9): 3.406709313392639,\n", - " (2025, 10): 15.907206058502197,\n", - " (2025, 11): 87.73827075958252,\n", - " (2025, 12): 133.80081367492676}},\n", - " 266: {'monthly': {(2025, 1): 424.40285634994507,\n", - " (2025, 2): 217.064839720726,\n", - " (2025, 3): 495.36479330062866,\n", - " (2025, 4): 495.1383213996887,\n", - " (2025, 5): 10.977967500686646,\n", - " (2025, 6): 6.2552313804626465,\n", - " (2025, 7): 4.1299474239349365,\n", - " (2025, 8): 1.651370644569397,\n", - " (2025, 9): 1.503449559211731,\n", - " (2025, 10): 28.712345004081726,\n", - " (2025, 11): 224.31555819511414,\n", - " (2025, 12): 628.9452539682388},\n", - " 'window': {(2025, 1): 120.6766939163208,\n", - " (2025, 2): 96.39587879180908,\n", - " (2025, 3): 121.28630256652832,\n", - " (2025, 4): 289.8658027648926,\n", - " (2025, 5): 2.841267228126526,\n", - " (2025, 6): 2.4150633811950684,\n", - " (2025, 7): 2.804624080657959,\n", - " (2025, 8): 1.651370644569397,\n", - " (2025, 9): 1.503449559211731,\n", - " (2025, 10): 12.915476322174072,\n", - " (2025, 11): 112.11920642852783,\n", - " (2025, 12): 184.05717849731445}},\n", - " 267: {'monthly': {(2025, 1): 408.53393054008484,\n", - " (2025, 2): 191.70037615299225,\n", - " (2025, 3): 369.3548262119293,\n", - " (2025, 4): 351.5889754295349,\n", - " (2025, 5): 2.5697407722473145,\n", - " (2025, 6): 5.234812378883362,\n", - " (2025, 7): 5.687588334083557,\n", - " (2025, 8): 1.492410659790039,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 18.43141210079193,\n", - " (2025, 11): 165.95767533779144,\n", - " (2025, 12): 454.90378272533417},\n", - " 'window': {(2025, 1): 131.53319263458252,\n", - " (2025, 2): 90.4459867477417,\n", - " (2025, 3): 94.58151149749756,\n", - " (2025, 4): 231.34952449798584,\n", - " (2025, 5): 1.4068381786346436,\n", - " (2025, 6): 2.863976836204529,\n", - " (2025, 7): 3.0469459295272827,\n", - " (2025, 8): 1.492410659790039,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 7.905214428901672,\n", - " (2025, 11): 81.24591827392578,\n", - " (2025, 12): 130.9373950958252}},\n", - " 268: {'monthly': {(2025, 1): 270.8030284643173,\n", - " (2025, 2): 132.39619553089142,\n", - " (2025, 3): 211.61936593055725,\n", - " (2025, 4): 246.62509417533875,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 2.69199275970459,\n", - " (2025, 7): 1.2726694345474243,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.396389126777649,\n", - " (2025, 10): 14.775759220123291,\n", - " (2025, 11): 113.52238178253174,\n", - " (2025, 12): 273.1940653324127},\n", - " 'window': {(2025, 1): 92.48666763305664,\n", - " (2025, 2): 62.442105293273926,\n", - " (2025, 3): 56.174543380737305,\n", - " (2025, 4): 190.6739158630371,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 2.69199275970459,\n", - " (2025, 7): 1.2726694345474243,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.396389126777649,\n", - " (2025, 10): 7.055613040924072,\n", - " (2025, 11): 53.912962436676025,\n", - " (2025, 12): 89.17556285858154}},\n", - " 269: {'monthly': {(2025, 1): 220.49982941150665,\n", - " (2025, 2): 113.26393246650696,\n", - " (2025, 3): 200.66825151443481,\n", - " (2025, 4): 138.17516827583313,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.4175138473510742,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 1.1717835664749146,\n", - " (2025, 11): 65.10663449764252,\n", - " (2025, 12): 188.0986338853836},\n", - " 'window': {(2025, 1): 74.38881254196167,\n", - " (2025, 2): 53.99858808517456,\n", - " (2025, 3): 68.8744764328003,\n", - " (2025, 4): 79.91573905944824,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.4175138473510742,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 1.1717835664749146,\n", - " (2025, 11): 50.45273160934448,\n", - " (2025, 12): 63.420504093170166}},\n", - " 270: {'monthly': {(2025, 1): 197.2173035144806,\n", - " (2025, 2): 102.16450321674347,\n", - " (2025, 3): 193.43529343605042,\n", - " (2025, 4): 128.98129439353943,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.4175138473510742,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.0553562641143799,\n", - " (2025, 10): 1.2998586893081665,\n", - " (2025, 11): 63.04452168941498,\n", - " (2025, 12): 165.24876606464386},\n", - " 'window': {(2025, 1): 62.73795747756958,\n", - " (2025, 2): 46.151443004608154,\n", - " (2025, 3): 60.85745286941528,\n", - " (2025, 4): 69.07988262176514,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.4175138473510742,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.0553562641143799,\n", - " (2025, 10): 1.2998586893081665,\n", - " (2025, 11): 41.79635190963745,\n", - " (2025, 12): 50.93363428115845}},\n", - " 271: {'monthly': {(2025, 1): 217.69963777065277,\n", - " (2025, 2): 113.09015357494354,\n", - " (2025, 3): 219.14074456691742,\n", - " (2025, 4): 122.56795907020569,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.4175138473510742,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.059896469116211,\n", - " (2025, 9): 1.1641085147857666,\n", - " (2025, 10): 1.433806300163269,\n", - " (2025, 11): 70.23964095115662,\n", - " (2025, 12): 204.10618841648102},\n", - " 'window': {(2025, 1): 66.88926124572754,\n", - " (2025, 2): 52.33452081680298,\n", - " (2025, 3): 65.91905689239502,\n", - " (2025, 4): 62.3462176322937,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.4175138473510742,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.059896469116211,\n", - " (2025, 9): 1.1641085147857666,\n", - " (2025, 10): 1.433806300163269,\n", - " (2025, 11): 46.2233247756958,\n", - " (2025, 12): 59.16735076904297}},\n", - " 272: {'monthly': {(2025, 1): 215.4355046749115,\n", - " (2025, 2): 116.1857088804245,\n", - " (2025, 3): 187.05283546447754,\n", - " (2025, 4): 87.24211359024048,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.4175138473510742,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.1078026294708252,\n", - " (2025, 9): 1.2087488174438477,\n", - " (2025, 10): 1.4887888431549072,\n", - " (2025, 11): 68.02054297924042,\n", - " (2025, 12): 201.5623220205307},\n", - " 'window': {(2025, 1): 78.83980083465576,\n", - " (2025, 2): 56.72298002243042,\n", - " (2025, 3): 58.47787380218506,\n", - " (2025, 4): 43.83257699012756,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.4175138473510742,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.1078026294708252,\n", - " (2025, 9): 1.2087488174438477,\n", - " (2025, 10): 1.4887888431549072,\n", - " (2025, 11): 43.28503775596619,\n", - " (2025, 12): 63.77998065948486}},\n", - " 273: {'monthly': {(2025, 1): 209.36569166183472,\n", - " (2025, 2): 195.96557343006134,\n", - " (2025, 3): 274.75184285640717,\n", - " (2025, 4): 62.89815878868103,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 17.578896522521973,\n", - " (2025, 11): 114.63115739822388,\n", - " (2025, 12): 242.15732765197754},\n", - " 'window': {(2025, 1): 62.95433783531189,\n", - " (2025, 2): 70.46032428741455,\n", - " (2025, 3): 88.15755319595337,\n", - " (2025, 4): 30.299885749816895,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 16.391456842422485,\n", - " (2025, 11): 39.62305212020874,\n", - " (2025, 12): 83.68964767456055}},\n", - " 274: {'monthly': {(2025, 1): 225.6154524087906,\n", - " (2025, 2): 144.0314644575119,\n", - " (2025, 3): 170.1155984401703,\n", - " (2025, 4): 63.048099875450134,\n", - " (2025, 5): 1.1292635202407837,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 17.805840849876404,\n", - " (2025, 11): 80.36290979385376,\n", - " (2025, 12): 159.52773118019104},\n", - " 'window': {(2025, 1): 68.14518976211548,\n", - " (2025, 2): 55.50293588638306,\n", - " (2025, 3): 42.92964744567871,\n", - " (2025, 4): 22.82576894760132,\n", - " (2025, 5): 1.1292635202407837,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 12.113358616828918,\n", - " (2025, 11): 35.183063983917236,\n", - " (2025, 12): 40.563329219818115}},\n", - " 275: {'monthly': {(2025, 1): 215.40224194526672,\n", - " (2025, 2): 127.6847288608551,\n", - " (2025, 3): 142.7758014202118,\n", - " (2025, 4): 50.83638918399811,\n", - " (2025, 5): 2.2186955213546753,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 14.598539590835571,\n", - " (2025, 11): 77.41531193256378,\n", - " (2025, 12): 151.9856756925583},\n", - " 'window': {(2025, 1): 60.7557578086853,\n", - " (2025, 2): 45.71869421005249,\n", - " (2025, 3): 38.176405906677246,\n", - " (2025, 4): 14.134286046028137,\n", - " (2025, 5): 1.1292635202407837,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 9.458528399467468,\n", - " (2025, 11): 29.167386054992676,\n", - " (2025, 12): 39.78601312637329}},\n", - " 276: {'monthly': {(2025, 1): 282.0723510980606,\n", - " (2025, 2): 162.140296459198,\n", - " (2025, 3): 198.64027452468872,\n", - " (2025, 4): 85.37911021709442,\n", - " (2025, 5): 7.179651498794556,\n", - " (2025, 6): 3.9095994234085083,\n", - " (2025, 7): 2.2605466842651367,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 5.247331500053406,\n", - " (2025, 10): 20.209875345230103,\n", - " (2025, 11): 85.27367317676544,\n", - " (2025, 12): 224.16098046302795},\n", - " 'window': {(2025, 1): 75.49648189544678,\n", - " (2025, 2): 54.05100774765015,\n", - " (2025, 3): 69.71992015838623,\n", - " (2025, 4): 33.59809637069702,\n", - " (2025, 5): 3.2768136262893677,\n", - " (2025, 6): 2.638682007789612,\n", - " (2025, 7): 1.1868523359298706,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 2.7089741230010986,\n", - " (2025, 10): 12.528519630432129,\n", - " (2025, 11): 37.11965847015381,\n", - " (2025, 12): 61.21795320510864}},\n", - " 277: {'monthly': {(2025, 1): 329.94575679302216,\n", - " (2025, 2): 203.66066551208496,\n", - " (2025, 3): 254.10074472427368,\n", - " (2025, 4): 152.49667131900787,\n", - " (2025, 5): 18.829901099205017,\n", - " (2025, 6): 15.623703956604004,\n", - " (2025, 7): 9.761527180671692,\n", - " (2025, 8): 4.878904938697815,\n", - " (2025, 9): 4.001057744026184,\n", - " (2025, 10): 29.979561686515808,\n", - " (2025, 11): 104.067347407341,\n", - " (2025, 12): 282.51377749443054},\n", - " 'window': {(2025, 1): 87.41336727142334,\n", - " (2025, 2): 68.35754108428955,\n", - " (2025, 3): 83.52545642852783,\n", - " (2025, 4): 58.825453758239746,\n", - " (2025, 5): 10.601356506347656,\n", - " (2025, 6): 6.651208996772766,\n", - " (2025, 7): 4.838395118713379,\n", - " (2025, 8): 2.6059648990631104,\n", - " (2025, 9): 1.4623826742172241,\n", - " (2025, 10): 15.473065733909607,\n", - " (2025, 11): 42.04154634475708,\n", - " (2025, 12): 89.40499877929688}},\n", - " 278: {'monthly': {(2025, 1): 397.10281801223755,\n", - " (2025, 2): 227.05255556106567,\n", - " (2025, 3): 378.62349247932434,\n", - " (2025, 4): 298.4772468805313,\n", - " (2025, 5): 16.317809104919434,\n", - " (2025, 6): 11.561023831367493,\n", - " (2025, 7): 13.92371392250061,\n", - " (2025, 8): 8.423924565315247,\n", - " (2025, 9): 8.53315782546997,\n", - " (2025, 10): 15.41220998764038,\n", - " (2025, 11): 155.0212697982788,\n", - " (2025, 12): 419.2728326320648},\n", - " 'window': {(2025, 1): 173.39413833618164,\n", - " (2025, 2): 104.47088813781738,\n", - " (2025, 3): 91.7893934249878,\n", - " (2025, 4): 136.70429134368896,\n", - " (2025, 5): 4.938267469406128,\n", - " (2025, 6): 4.2392460107803345,\n", - " (2025, 7): 3.9795318841934204,\n", - " (2025, 8): 3.724949598312378,\n", - " (2025, 9): 3.922471761703491,\n", - " (2025, 10): 7.489836931228638,\n", - " (2025, 11): 80.82486629486084,\n", - " (2025, 12): 103.78984022140503}},\n", - " 279: {'monthly': {(2025, 1): 425.689608335495,\n", - " (2025, 2): 250.8211281299591,\n", - " (2025, 3): 547.1073505878448,\n", - " (2025, 4): 414.87697064876556,\n", - " (2025, 5): 20.70540761947632,\n", - " (2025, 6): 14.179459810256958,\n", - " (2025, 7): 14.74104106426239,\n", - " (2025, 8): 7.718629717826843,\n", - " (2025, 9): 9.481934428215027,\n", - " (2025, 10): 23.29227364063263,\n", - " (2025, 11): 240.55893325805664,\n", - " (2025, 12): 604.4006221294403},\n", - " 'window': {(2025, 1): 176.97453498840332,\n", - " (2025, 2): 123.5966682434082,\n", - " (2025, 3): 123.58839988708496,\n", - " (2025, 4): 186.11838912963867,\n", - " (2025, 5): 6.450153589248657,\n", - " (2025, 6): 4.7917104959487915,\n", - " (2025, 7): 3.928784132003784,\n", - " (2025, 8): 4.1229469776153564,\n", - " (2025, 9): 4.652623891830444,\n", - " (2025, 10): 13.321821808815002,\n", - " (2025, 11): 115.54511642456055,\n", - " (2025, 12): 156.00249481201172}},\n", - " 280: {'monthly': {(2025, 1): 365.602388381958,\n", - " (2025, 2): 241.0399477481842,\n", - " (2025, 3): 440.19482946395874,\n", - " (2025, 4): 295.1269153356552,\n", - " (2025, 5): 10.528730511665344,\n", - " (2025, 6): 10.19613790512085,\n", - " (2025, 7): 10.7303706407547,\n", - " (2025, 8): 7.613444566726685,\n", - " (2025, 9): 7.326686263084412,\n", - " (2025, 10): 16.958322405815125,\n", - " (2025, 11): 183.24644935131073,\n", - " (2025, 12): 501.90750432014465},\n", - " 'window': {(2025, 1): 149.54252815246582,\n", - " (2025, 2): 117.81782913208008,\n", - " (2025, 3): 109.16358757019043,\n", - " (2025, 4): 134.23750495910645,\n", - " (2025, 5): 4.247562050819397,\n", - " (2025, 6): 3.5678919553756714,\n", - " (2025, 7): 3.812059164047241,\n", - " (2025, 8): 3.5279037952423096,\n", - " (2025, 9): 2.783077120780945,\n", - " (2025, 10): 9.060283064842224,\n", - " (2025, 11): 83.1641263961792,\n", - " (2025, 12): 124.68604850769043}},\n", - " 281: {'monthly': {(2025, 1): 250.56508553028107,\n", - " (2025, 2): 171.92677330970764,\n", - " (2025, 3): 276.9432051181793,\n", - " (2025, 4): 184.24062991142273,\n", - " (2025, 5): 12.587665677070618,\n", - " (2025, 6): 10.162322640419006,\n", - " (2025, 7): 11.451166152954102,\n", - " (2025, 8): 7.974018812179565,\n", - " (2025, 9): 8.743608236312866,\n", - " (2025, 10): 10.70507299900055,\n", - " (2025, 11): 114.58728694915771,\n", - " (2025, 12): 322.62920105457306},\n", - " 'window': {(2025, 1): 94.96355056762695,\n", - " (2025, 2): 82.41141438484192,\n", - " (2025, 3): 75.20966911315918,\n", - " (2025, 4): 88.31724071502686,\n", - " (2025, 5): 5.900190472602844,\n", - " (2025, 6): 3.942609429359436,\n", - " (2025, 7): 4.140058994293213,\n", - " (2025, 8): 3.8884780406951904,\n", - " (2025, 9): 4.199999094009399,\n", - " (2025, 10): 3.7816460132598877,\n", - " (2025, 11): 55.92741537094116,\n", - " (2025, 12): 74.09245777130127}},\n", - " 282: {'monthly': {(2025, 1): 204.95418894290924,\n", - " (2025, 2): 136.36990010738373,\n", - " (2025, 3): 214.61640989780426,\n", - " (2025, 4): 114.74608385562897,\n", - " (2025, 5): 2.1955459117889404,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 3.5468934774398804,\n", - " (2025, 11): 68.70926141738892,\n", - " (2025, 12): 183.29387593269348},\n", - " 'window': {(2025, 1): 62.70143508911133,\n", - " (2025, 2): 68.8599100112915,\n", - " (2025, 3): 61.858471393585205,\n", - " (2025, 4): 50.17092180252075,\n", - " (2025, 5): 1.1006970405578613,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 2.050573468208313,\n", - " (2025, 11): 42.430328369140625,\n", - " (2025, 12): 43.879592418670654}},\n", - " 283: {'monthly': {(2025, 1): 185.4791578054428,\n", - " (2025, 2): 135.17516422271729,\n", - " (2025, 3): 199.74282550811768,\n", - " (2025, 4): 107.24038887023926,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 2.6308434009552,\n", - " (2025, 11): 57.28350758552551,\n", - " (2025, 12): 193.47417557239532},\n", - " 'window': {(2025, 1): 63.34094953536987,\n", - " (2025, 2): 79.25538206100464,\n", - " (2025, 3): 48.2353093624115,\n", - " (2025, 4): 53.32175254821777,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 1.6287841796875,\n", - " (2025, 11): 43.00269603729248,\n", - " (2025, 12): 53.01881551742554}},\n", - " 284: {'monthly': {(2025, 1): 205.01519989967346,\n", - " (2025, 2): 159.01948499679565,\n", - " (2025, 3): 228.3070526123047,\n", - " (2025, 4): 117.47142457962036,\n", - " (2025, 5): 1.0601177215576172,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 2.681560516357422,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 3.9122098684310913,\n", - " (2025, 11): 72.64094197750092,\n", - " (2025, 12): 239.04648065567017},\n", - " 'window': {(2025, 1): 72.95681095123291,\n", - " (2025, 2): 89.14984226226807,\n", - " (2025, 3): 51.99630880355835,\n", - " (2025, 4): 60.62609148025513,\n", - " (2025, 5): 1.0601177215576172,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.5837678909301758,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 2.37044620513916,\n", - " (2025, 11): 55.54196548461914,\n", - " (2025, 12): 68.84192276000977}},\n", - " 285: {'monthly': {(2025, 1): 220.79442143440247,\n", - " (2025, 2): 152.57472825050354,\n", - " (2025, 3): 220.06221413612366,\n", - " (2025, 4): 108.9788430929184,\n", - " (2025, 5): 1.0026605129241943,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 4.496600866317749,\n", - " (2025, 11): 75.09711170196533,\n", - " (2025, 12): 258.01555013656616},\n", - " 'window': {(2025, 1): 74.78263521194458,\n", - " (2025, 2): 84.8581051826477,\n", - " (2025, 3): 55.0178804397583,\n", - " (2025, 4): 55.08006763458252,\n", - " (2025, 5): 1.0026605129241943,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 3.2146308422088623,\n", - " (2025, 11): 52.896559715270996,\n", - " (2025, 12): 75.12352561950684}},\n", - " 286: {'monthly': {(2025, 1): 189.71724426746368,\n", - " (2025, 2): 163.30674266815186,\n", - " (2025, 3): 227.9548692703247,\n", - " (2025, 4): 65.69013941287994,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 13.666529536247253,\n", - " (2025, 11): 92.50059294700623,\n", - " (2025, 12): 197.4032118320465},\n", - " 'window': {(2025, 1): 50.5849289894104,\n", - " (2025, 2): 59.396042346954346,\n", - " (2025, 3): 65.35414242744446,\n", - " (2025, 4): 33.98176050186157,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 13.666529536247253,\n", - " (2025, 11): 31.344239711761475,\n", - " (2025, 12): 67.72646427154541}},\n", - " 287: {'monthly': {(2025, 1): 212.791717171669,\n", - " (2025, 2): 159.2149921655655,\n", - " (2025, 3): 187.4749813079834,\n", - " (2025, 4): 77.78734958171844,\n", - " (2025, 5): 2.1652307510375977,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 14.372201323509216,\n", - " (2025, 11): 103.81756913661957,\n", - " (2025, 12): 184.57293677330017},\n", - " 'window': {(2025, 1): 65.57112073898315,\n", - " (2025, 2): 63.95506191253662,\n", - " (2025, 3): 48.99668645858765,\n", - " (2025, 4): 31.536183834075928,\n", - " (2025, 5): 1.1292635202407837,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 7.835781216621399,\n", - " (2025, 11): 48.405052185058594,\n", - " (2025, 12): 52.23899841308594}},\n", - " 288: {'monthly': {(2025, 1): 214.49980998039246,\n", - " (2025, 2): 142.3774790763855,\n", - " (2025, 3): 158.02781522274017,\n", - " (2025, 4): 54.27084732055664,\n", - " (2025, 5): 1.1292635202407837,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 13.179431200027466,\n", - " (2025, 11): 89.20300757884979,\n", - " (2025, 12): 174.19728565216064},\n", - " 'window': {(2025, 1): 61.390793800354004,\n", - " (2025, 2): 55.7005455493927,\n", - " (2025, 3): 40.54873704910278,\n", - " (2025, 4): 19.613227367401123,\n", - " (2025, 5): 1.1292635202407837,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 8.185760140419006,\n", - " (2025, 11): 42.80529069900513,\n", - " (2025, 12): 46.249194622039795}},\n", - " 289: {'monthly': {(2025, 1): 246.12156295776367,\n", - " (2025, 2): 155.4316017627716,\n", - " (2025, 3): 174.0772044658661,\n", - " (2025, 4): 62.95204770565033,\n", - " (2025, 5): 2.2579773664474487,\n", - " (2025, 6): 2.312103271484375,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 11.70163643360138,\n", - " (2025, 11): 86.41686654090881,\n", - " (2025, 12): 203.94655072689056},\n", - " 'window': {(2025, 1): 66.62103652954102,\n", - " (2025, 2): 57.69443154335022,\n", - " (2025, 3): 57.079355239868164,\n", - " (2025, 4): 27.240578413009644,\n", - " (2025, 5): 1.2191609144210815,\n", - " (2025, 6): 1.1959878206253052,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 7.351540803909302,\n", - " (2025, 11): 38.545809268951416,\n", - " (2025, 12): 56.741201400756836}},\n", - " 290: {'monthly': {(2025, 1): 275.75574266910553,\n", - " (2025, 2): 178.72647380828857,\n", - " (2025, 3): 223.75012862682343,\n", - " (2025, 4): 130.81806457042694,\n", - " (2025, 5): 17.332924962043762,\n", - " (2025, 6): 12.021787643432617,\n", - " (2025, 7): 6.679843306541443,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.6804198026657104,\n", - " (2025, 10): 24.076976895332336,\n", - " (2025, 11): 105.08375632762909,\n", - " (2025, 12): 256.833961725235},\n", - " 'window': {(2025, 1): 75.3613338470459,\n", - " (2025, 2): 66.28598499298096,\n", - " (2025, 3): 69.05908489227295,\n", - " (2025, 4): 51.84451508522034,\n", - " (2025, 5): 8.017738342285156,\n", - " (2025, 6): 4.467013359069824,\n", - " (2025, 7): 2.7045679092407227,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.6804198026657104,\n", - " (2025, 10): 10.662084579467773,\n", - " (2025, 11): 40.02499961853027,\n", - " (2025, 12): 79.62635803222656}},\n", - " 291: {'monthly': {(2025, 1): 376.34488129615784,\n", - " (2025, 2): 212.74075257778168,\n", - " (2025, 3): 351.1738773584366,\n", - " (2025, 4): 294.1383401155472,\n", - " (2025, 5): 18.095483660697937,\n", - " (2025, 6): 15.117963552474976,\n", - " (2025, 7): 18.13223969936371,\n", - " (2025, 8): 8.959601998329163,\n", - " (2025, 9): 10.260310769081116,\n", - " (2025, 10): 21.793508768081665,\n", - " (2025, 11): 156.83099126815796,\n", - " (2025, 12): 414.0141807794571},\n", - " 'window': {(2025, 1): 171.67836570739746,\n", - " (2025, 2): 105.72722482681274,\n", - " (2025, 3): 78.87526607513428,\n", - " (2025, 4): 125.87790107727051,\n", - " (2025, 5): 5.464709401130676,\n", - " (2025, 6): 6.367325663566589,\n", - " (2025, 7): 4.879130005836487,\n", - " (2025, 8): 4.15880560874939,\n", - " (2025, 9): 4.45636773109436,\n", - " (2025, 10): 8.717504739761353,\n", - " (2025, 11): 83.69183254241943,\n", - " (2025, 12): 103.86566305160522}},\n", - " 292: {'monthly': {(2025, 1): 441.19583082199097,\n", - " (2025, 2): 259.36043894290924,\n", - " (2025, 3): 517.8410189151764,\n", - " (2025, 4): 417.80757212638855,\n", - " (2025, 5): 18.488664746284485,\n", - " (2025, 6): 19.298951625823975,\n", - " (2025, 7): 18.2230486869812,\n", - " (2025, 8): 9.270620226860046,\n", - " (2025, 9): 11.298582196235657,\n", - " (2025, 10): 27.31354594230652,\n", - " (2025, 11): 250.41540050506592,\n", - " (2025, 12): 620.8924658298492},\n", - " 'window': {(2025, 1): 190.48793029785156,\n", - " (2025, 2): 128.08814811706543,\n", - " (2025, 3): 113.3431077003479,\n", - " (2025, 4): 184.14372444152832,\n", - " (2025, 5): 6.035916686058044,\n", - " (2025, 6): 7.355826139450073,\n", - " (2025, 7): 4.814202070236206,\n", - " (2025, 8): 3.9804255962371826,\n", - " (2025, 9): 5.6169047355651855,\n", - " (2025, 10): 13.974095344543457,\n", - " (2025, 11): 121.51394939422607,\n", - " (2025, 12): 168.6855125427246}},\n", - " 293: {'monthly': {(2025, 1): 376.99900937080383,\n", - " (2025, 2): 244.88685286045074,\n", - " (2025, 3): 470.4703463315964,\n", - " (2025, 4): 341.4632331132889,\n", - " (2025, 5): 17.459916710853577,\n", - " (2025, 6): 12.05626106262207,\n", - " (2025, 7): 12.20657742023468,\n", - " (2025, 8): 7.782452583312988,\n", - " (2025, 9): 8.08807384967804,\n", - " (2025, 10): 19.234049797058105,\n", - " (2025, 11): 231.79337441921234,\n", - " (2025, 12): 548.3182047605515},\n", - " 'window': {(2025, 1): 149.98147583007812,\n", - " (2025, 2): 124.65033626556396,\n", - " (2025, 3): 105.98125267028809,\n", - " (2025, 4): 150.56842708587646,\n", - " (2025, 5): 5.757378458976746,\n", - " (2025, 6): 4.535098075866699,\n", - " (2025, 7): 3.7685506343841553,\n", - " (2025, 8): 3.2313820123672485,\n", - " (2025, 9): 3.203892469406128,\n", - " (2025, 10): 12.530512571334839,\n", - " (2025, 11): 97.60309505462646,\n", - " (2025, 12): 139.89262008666992}},\n", - " 294: {'monthly': {(2025, 1): 254.73847699165344,\n", - " (2025, 2): 191.21450817584991,\n", - " (2025, 3): 320.08541107177734,\n", - " (2025, 4): 228.2954716682434,\n", - " (2025, 5): 14.158897638320923,\n", - " (2025, 6): 15.702314019203186,\n", - " (2025, 7): 11.515593409538269,\n", - " (2025, 8): 7.981106281280518,\n", - " (2025, 9): 8.302720665931702,\n", - " (2025, 10): 14.338789820671082,\n", - " (2025, 11): 168.77665412425995,\n", - " (2025, 12): 372.6080001592636},\n", - " 'window': {(2025, 1): 93.12891101837158,\n", - " (2025, 2): 97.76115274429321,\n", - " (2025, 3): 76.8533763885498,\n", - " (2025, 4): 108.38714694976807,\n", - " (2025, 5): 5.414010047912598,\n", - " (2025, 6): 5.186012625694275,\n", - " (2025, 7): 3.5589290857315063,\n", - " (2025, 8): 3.3833703994750977,\n", - " (2025, 9): 3.759111523628235,\n", - " (2025, 10): 8.494981288909912,\n", - " (2025, 11): 75.27567672729492,\n", - " (2025, 12): 91.70908737182617}},\n", - " 295: {'monthly': {(2025, 1): 237.70824706554413,\n", - " (2025, 2): 148.45510458946228,\n", - " (2025, 3): 241.0075569152832,\n", - " (2025, 4): 139.93339502811432,\n", - " (2025, 5): 5.7051016092300415,\n", - " (2025, 6): 1.2788991928100586,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 4.5912926197052,\n", - " (2025, 11): 79.82710647583008,\n", - " (2025, 12): 237.246617436409},\n", - " 'window': {(2025, 1): 76.5148983001709,\n", - " (2025, 2): 74.59725141525269,\n", - " (2025, 3): 66.65344429016113,\n", - " (2025, 4): 62.948129653930664,\n", - " (2025, 5): 3.3076770305633545,\n", - " (2025, 6): 1.2788991928100586,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 3.0399301052093506,\n", - " (2025, 11): 48.134767055511475,\n", - " (2025, 12): 57.20744705200195}},\n", - " 296: {'monthly': {(2025, 1): 225.2207304239273,\n", - " (2025, 2): 146.574120759964,\n", - " (2025, 3): 226.16146183013916,\n", - " (2025, 4): 138.99869465827942,\n", - " (2025, 5): 1.1309374570846558,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 4.8379669189453125,\n", - " (2025, 11): 61.37073886394501,\n", - " (2025, 12): 230.68922591209412},\n", - " 'window': {(2025, 1): 72.05251789093018,\n", - " (2025, 2): 88.72400856018066,\n", - " (2025, 3): 52.86646270751953,\n", - " (2025, 4): 67.49387216567993,\n", - " (2025, 5): 1.1309374570846558,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 2.1418272256851196,\n", - " (2025, 11): 42.31483793258667,\n", - " (2025, 12): 63.26970672607422}},\n", - " 297: {'monthly': {(2025, 1): 206.83565628528595,\n", - " (2025, 2): 151.7432404756546,\n", - " (2025, 3): 230.65381503105164,\n", - " (2025, 4): 136.39409756660461,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.1662040948867798,\n", - " (2025, 10): 4.637523531913757,\n", - " (2025, 11): 68.12247776985168,\n", - " (2025, 12): 243.98482704162598},\n", - " 'window': {(2025, 1): 70.59037733078003,\n", - " (2025, 2): 89.45915079116821,\n", - " (2025, 3): 48.566887855529785,\n", - " (2025, 4): 70.95243692398071,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 1.1662040948867798,\n", - " (2025, 10): 3.5069934129714966,\n", - " (2025, 11): 51.26307153701782,\n", - " (2025, 12): 69.83489990234375}},\n", - " 298: {'monthly': {(2025, 1): 219.24215924739838,\n", - " (2025, 2): 153.48078906536102,\n", - " (2025, 3): 222.092507481575,\n", - " (2025, 4): 130.80780363082886,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 3.809258460998535,\n", - " (2025, 11): 71.34592044353485,\n", - " (2025, 12): 255.1348775625229},\n", - " 'window': {(2025, 1): 68.99073076248169,\n", - " (2025, 2): 83.06516551971436,\n", - " (2025, 3): 50.368186473846436,\n", - " (2025, 4): 67.87191200256348,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 3.809258460998535,\n", - " (2025, 11): 52.77876424789429,\n", - " (2025, 12): 73.8577070236206}},\n", - " 299: {'monthly': {(2025, 1): 162.68725609779358,\n", - " (2025, 2): 131.62465274333954,\n", - " (2025, 3): 193.2072583436966,\n", - " (2025, 4): 58.26392602920532,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 10.945929646492004,\n", - " (2025, 11): 79.96161043643951,\n", - " (2025, 12): 177.47495210170746},\n", - " 'window': {(2025, 1): 48.36470937728882,\n", - " (2025, 2): 48.62400841712952,\n", - " (2025, 3): 57.07968020439148,\n", - " (2025, 4): 29.50512933731079,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 10.945929646492004,\n", - " (2025, 11): 30.117188453674316,\n", - " (2025, 12): 58.27445697784424}},\n", - " 300: {'monthly': {(2025, 1): 212.24887359142303,\n", - " (2025, 2): 150.09371137619019,\n", - " (2025, 3): 189.08279252052307,\n", - " (2025, 4): 81.33043670654297,\n", - " (2025, 5): 1.1292635202407837,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 7.158645272254944,\n", - " (2025, 11): 106.6408611536026,\n", - " (2025, 12): 203.1845109462738},\n", - " 'window': {(2025, 1): 71.11330270767212,\n", - " (2025, 2): 67.79568195343018,\n", - " (2025, 3): 51.396491050720215,\n", - " (2025, 4): 34.83233690261841,\n", - " (2025, 5): 1.1292635202407837,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 4.357968807220459,\n", - " (2025, 11): 55.27073001861572,\n", - " (2025, 12): 62.391889572143555}},\n", - " 301: {'monthly': {(2025, 1): 201.33667182922363,\n", - " (2025, 2): 142.16926181316376,\n", - " (2025, 3): 143.7636123895645,\n", - " (2025, 4): 55.745898604393005,\n", - " (2025, 5): 1.1292635202407837,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 9.884746789932251,\n", - " (2025, 11): 84.60430896282196,\n", - " (2025, 12): 167.61791145801544},\n", - " 'window': {(2025, 1): 66.53453993797302,\n", - " (2025, 2): 65.82313537597656,\n", - " (2025, 3): 40.621089935302734,\n", - " (2025, 4): 21.111615657806396,\n", - " (2025, 5): 1.1292635202407837,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 5.93736457824707,\n", - " (2025, 11): 44.3451566696167,\n", - " (2025, 12): 50.959144115448}},\n", - " 302: {'monthly': {(2025, 1): 188.10560250282288,\n", - " (2025, 2): 129.21980011463165,\n", - " (2025, 3): 134.2267884016037,\n", - " (2025, 4): 53.99873912334442,\n", - " (2025, 5): 1.1292635202407837,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 6.132671117782593,\n", - " (2025, 11): 77.8567236661911,\n", - " (2025, 12): 156.55732488632202},\n", - " 'window': {(2025, 1): 57.546300411224365,\n", - " (2025, 2): 57.49386429786682,\n", - " (2025, 3): 43.88295841217041,\n", - " (2025, 4): 22.71336269378662,\n", - " (2025, 5): 1.1292635202407837,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 2.3688244819641113,\n", - " (2025, 11): 37.28305673599243,\n", - " (2025, 12): 46.89796257019043}},\n", - " 303: {'monthly': {(2025, 1): 226.64202499389648,\n", - " (2025, 2): 140.9806215763092,\n", - " (2025, 3): 209.54628551006317,\n", - " (2025, 4): 139.33489501476288,\n", - " (2025, 5): 16.478121280670166,\n", - " (2025, 6): 11.767149448394775,\n", - " (2025, 7): 7.372111678123474,\n", - " (2025, 8): 2.5211522579193115,\n", - " (2025, 9): 2.0108351707458496,\n", - " (2025, 10): 26.88587248325348,\n", - " (2025, 11): 105.6446886062622,\n", - " (2025, 12): 228.6530020236969},\n", - " 'window': {(2025, 1): 67.00771045684814,\n", - " (2025, 2): 55.72388958930969,\n", - " (2025, 3): 60.915913581848145,\n", - " (2025, 4): 51.6085205078125,\n", - " (2025, 5): 9.004403829574585,\n", - " (2025, 6): 7.215142250061035,\n", - " (2025, 7): 3.1933611631393433,\n", - " (2025, 8): 1.2883899211883545,\n", - " (2025, 9): 2.0108351707458496,\n", - " (2025, 10): 9.85027027130127,\n", - " (2025, 11): 42.30648612976074,\n", - " (2025, 12): 71.26049327850342}},\n", - " 304: {'monthly': {(2025, 1): 333.4156882762909,\n", - " (2025, 2): 212.4595843553543,\n", - " (2025, 3): 384.79209208488464,\n", - " (2025, 4): 323.2878106832504,\n", - " (2025, 5): 19.726492762565613,\n", - " (2025, 6): 19.09140169620514,\n", - " (2025, 7): 17.74389398097992,\n", - " (2025, 8): 11.322577595710754,\n", - " (2025, 9): 14.902034521102905,\n", - " (2025, 10): 19.981056451797485,\n", - " (2025, 11): 192.52197396755219,\n", - " (2025, 12): 413.68558645248413},\n", - " 'window': {(2025, 1): 149.10525703430176,\n", - " (2025, 2): 101.13504886627197,\n", - " (2025, 3): 84.32403564453125,\n", - " (2025, 4): 124.35704135894775,\n", - " (2025, 5): 5.848616361618042,\n", - " (2025, 6): 6.396745920181274,\n", - " (2025, 7): 5.0971890687942505,\n", - " (2025, 8): 5.273683547973633,\n", - " (2025, 9): 7.528859734535217,\n", - " (2025, 10): 10.398268699645996,\n", - " (2025, 11): 109.22648048400879,\n", - " (2025, 12): 102.8471326828003}},\n", - " 305: {'monthly': {(2025, 1): 400.7552683353424,\n", - " (2025, 2): 253.92490220069885,\n", - " (2025, 3): 535.55575299263,\n", - " (2025, 4): 434.98192286491394,\n", - " (2025, 5): 26.604504823684692,\n", - " (2025, 6): 20.60140025615692,\n", - " (2025, 7): 19.734654545783997,\n", - " (2025, 8): 11.946718692779541,\n", - " (2025, 9): 14.005615711212158,\n", - " (2025, 10): 26.397583842277527,\n", - " (2025, 11): 279.8429973125458,\n", - " (2025, 12): 576.6526221036911},\n", - " 'window': {(2025, 1): 163.22450065612793,\n", - " (2025, 2): 128.1747431755066,\n", - " (2025, 3): 119.00507831573486,\n", - " (2025, 4): 181.3159885406494,\n", - " (2025, 5): 7.423758864402771,\n", - " (2025, 6): 6.69236147403717,\n", - " (2025, 7): 5.705077171325684,\n", - " (2025, 8): 5.974905490875244,\n", - " (2025, 9): 6.955211877822876,\n", - " (2025, 10): 14.403890371322632,\n", - " (2025, 11): 147.8786497116089,\n", - " (2025, 12): 156.45749473571777}},\n", - " 306: {'monthly': {(2025, 1): 358.8752330541611,\n", - " (2025, 2): 247.1350735425949,\n", - " (2025, 3): 547.7099990844727,\n", - " (2025, 4): 410.7972483634949,\n", - " (2025, 5): 23.39901912212372,\n", - " (2025, 6): 16.65402853488922,\n", - " (2025, 7): 17.89550280570984,\n", - " (2025, 8): 10.268158555030823,\n", - " (2025, 9): 11.308249235153198,\n", - " (2025, 10): 25.269832730293274,\n", - " (2025, 11): 294.6199120283127,\n", - " (2025, 12): 553.2848632335663},\n", - " 'window': {(2025, 1): 122.74172401428223,\n", - " (2025, 2): 128.21653652191162,\n", - " (2025, 3): 121.15383720397949,\n", - " (2025, 4): 166.02063369750977,\n", - " (2025, 5): 7.028189182281494,\n", - " (2025, 6): 5.85234534740448,\n", - " (2025, 7): 4.588630199432373,\n", - " (2025, 8): 4.954517722129822,\n", - " (2025, 9): 4.15217649936676,\n", - " (2025, 10): 15.839200973510742,\n", - " (2025, 11): 136.60330963134766,\n", - " (2025, 12): 143.5025978088379}},\n", - " 307: {'monthly': {(2025, 1): 318.39638590812683,\n", - " (2025, 2): 218.51634812355042,\n", - " (2025, 3): 382.4007034301758,\n", - " (2025, 4): 273.8138916492462,\n", - " (2025, 5): 16.95348358154297,\n", - " (2025, 6): 11.86733078956604,\n", - " (2025, 7): 14.387192726135254,\n", - " (2025, 8): 10.926639199256897,\n", - " (2025, 9): 7.720752716064453,\n", - " (2025, 10): 15.260484337806702,\n", - " (2025, 11): 190.053071975708,\n", - " (2025, 12): 421.8511235713959},\n", - " 'window': {(2025, 1): 98.80987167358398,\n", - " (2025, 2): 95.62134122848511,\n", - " (2025, 3): 85.85120487213135,\n", - " (2025, 4): 126.44163513183594,\n", - " (2025, 5): 6.760623216629028,\n", - " (2025, 6): 4.8581671714782715,\n", - " (2025, 7): 5.067577123641968,\n", - " (2025, 8): 4.338736295700073,\n", - " (2025, 9): 2.994595766067505,\n", - " (2025, 10): 8.92558217048645,\n", - " (2025, 11): 81.66708755493164,\n", - " (2025, 12): 95.91598129272461}},\n", - " 308: {'monthly': {(2025, 1): 273.5691508054733,\n", - " (2025, 2): 160.85400760173798,\n", - " (2025, 3): 274.02161383628845,\n", - " (2025, 4): 156.34983551502228,\n", - " (2025, 5): 7.2783626317977905,\n", - " (2025, 6): 5.100972533226013,\n", - " (2025, 7): 7.4943671226501465,\n", - " (2025, 8): 3.521307945251465,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 4.695343494415283,\n", - " (2025, 11): 97.10872447490692,\n", - " (2025, 12): 300.6274515390396},\n", - " 'window': {(2025, 1): 75.97445774078369,\n", - " (2025, 2): 73.25068283081055,\n", - " (2025, 3): 74.58668899536133,\n", - " (2025, 4): 68.35408401489258,\n", - " (2025, 5): 3.111794114112854,\n", - " (2025, 6): 3.399803400039673,\n", - " (2025, 7): 3.848074436187744,\n", - " (2025, 8): 2.1217788457870483,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 2.366231679916382,\n", - " (2025, 11): 60.06953191757202,\n", - " (2025, 12): 78.18867588043213}},\n", - " 309: {'monthly': {(2025, 1): 224.18687105178833,\n", - " (2025, 2): 132.40254616737366,\n", - " (2025, 3): 230.37871980667114,\n", - " (2025, 4): 139.89089345932007,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 5.109009504318237,\n", - " (2025, 11): 69.63674879074097,\n", - " (2025, 12): 261.4416643381119},\n", - " 'window': {(2025, 1): 66.86137390136719,\n", - " (2025, 2): 67.63626551628113,\n", - " (2025, 3): 55.9526309967041,\n", - " (2025, 4): 66.3402771949768,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 3.997322201728821,\n", - " (2025, 11): 46.69317007064819,\n", - " (2025, 12): 71.77417278289795}},\n", - " 310: {'monthly': {(2025, 1): 194.41077649593353,\n", - " (2025, 2): 117.6606684923172,\n", - " (2025, 3): 220.68660473823547,\n", - " (2025, 4): 136.13833129405975,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 4.811738133430481,\n", - " (2025, 11): 69.77695906162262,\n", - " (2025, 12): 250.72134339809418},\n", - " 'window': {(2025, 1): 57.580835819244385,\n", - " (2025, 2): 61.92857789993286,\n", - " (2025, 3): 46.46595573425293,\n", - " (2025, 4): 69.2557692527771,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 4.811738133430481,\n", - " (2025, 11): 51.02703905105591,\n", - " (2025, 12): 71.81280899047852}},\n", - " 311: {'monthly': {(2025, 1): 206.21866023540497,\n", - " (2025, 2): 127.2322256565094,\n", - " (2025, 3): 211.05579495429993,\n", - " (2025, 4): 136.06961059570312,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 5.1552019119262695,\n", - " (2025, 11): 69.8967295885086,\n", - " (2025, 12): 250.8440661430359},\n", - " 'window': {(2025, 1): 59.2156286239624,\n", - " (2025, 2): 62.35985469818115,\n", - " (2025, 3): 43.51865911483765,\n", - " (2025, 4): 71.92830228805542,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 5.1552019119262695,\n", - " (2025, 11): 53.588847160339355,\n", - " (2025, 12): 71.2491569519043}},\n", - " 312: {'monthly': {(2025, 1): 194.523064494133,\n", - " (2025, 2): 175.75729954242706,\n", - " (2025, 3): 217.80632090568542,\n", - " (2025, 4): 72.23863577842712,\n", - " (2025, 5): 1.1819761991500854,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 11.699623584747314,\n", - " (2025, 11): 94.45672369003296,\n", - " (2025, 12): 199.1183888912201},\n", - " 'window': {(2025, 1): 58.89619159698486,\n", - " (2025, 2): 62.16115474700928,\n", - " (2025, 3): 64.24395489692688,\n", - " (2025, 4): 30.554471969604492,\n", - " (2025, 5): 1.1819761991500854,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 11.699623584747314,\n", - " (2025, 11): 39.66067314147949,\n", - " (2025, 12): 59.96241092681885}},\n", - " 313: {'monthly': {(2025, 1): 255.17175388336182,\n", - " (2025, 2): 173.0781272649765,\n", - " (2025, 3): 227.06994557380676,\n", - " (2025, 4): 110.93704867362976,\n", - " (2025, 5): 1.1292635202407837,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 9.365985035896301,\n", - " (2025, 11): 112.91352558135986,\n", - " (2025, 12): 242.39957785606384},\n", - " 'window': {(2025, 1): 79.51944828033447,\n", - " (2025, 2): 75.4406361579895,\n", - " (2025, 3): 60.36026692390442,\n", - " (2025, 4): 52.78894519805908,\n", - " (2025, 5): 1.1292635202407837,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 5.000129699707031,\n", - " (2025, 11): 52.91604280471802,\n", - " (2025, 12): 64.58662414550781}},\n", - " 314: {'monthly': {(2025, 1): 234.83491826057434,\n", - " (2025, 2): 143.06152629852295,\n", - " (2025, 3): 176.89575946331024,\n", - " (2025, 4): 91.67667055130005,\n", - " (2025, 5): 1.1292635202407837,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 12.739081501960754,\n", - " (2025, 11): 93.29798340797424,\n", - " (2025, 12): 182.68769443035126},\n", - " 'window': {(2025, 1): 74.42335224151611,\n", - " (2025, 2): 69.53931140899658,\n", - " (2025, 3): 50.84088349342346,\n", - " (2025, 4): 38.99177289009094,\n", - " (2025, 5): 1.1292635202407837,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 8.257936239242554,\n", - " (2025, 11): 44.64473581314087,\n", - " (2025, 12): 51.398290157318115}},\n", - " 315: {'monthly': {(2025, 1): 207.64981758594513,\n", - " (2025, 2): 132.3125982284546,\n", - " (2025, 3): 158.31954085826874,\n", - " (2025, 4): 80.12260818481445,\n", - " (2025, 5): 1.1292635202407837,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 8.064960837364197,\n", - " (2025, 11): 84.6522570848465,\n", - " (2025, 12): 162.02885627746582},\n", - " 'window': {(2025, 1): 68.61102628707886,\n", - " (2025, 2): 59.58103322982788,\n", - " (2025, 3): 49.63972187042236,\n", - " (2025, 4): 36.48862075805664,\n", - " (2025, 5): 1.1292635202407837,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 5.415438771247864,\n", - " (2025, 11): 42.04750633239746,\n", - " (2025, 12): 45.071749210357666}},\n", - " 316: {'monthly': {(2025, 1): 291.68079030513763,\n", - " (2025, 2): 171.55844390392303,\n", - " (2025, 3): 232.8959835767746,\n", - " (2025, 4): 168.74576485157013,\n", - " (2025, 5): 19.462653756141663,\n", - " (2025, 6): 10.796619892120361,\n", - " (2025, 7): 9.006937384605408,\n", - " (2025, 8): 4.233851671218872,\n", - " (2025, 9): 1.1253303289413452,\n", - " (2025, 10): 21.64095175266266,\n", - " (2025, 11): 105.47917151451111,\n", - " (2025, 12): 235.48617327213287},\n", - " 'window': {(2025, 1): 111.60970401763916,\n", - " (2025, 2): 68.03065299987793,\n", - " (2025, 3): 67.68226718902588,\n", - " (2025, 4): 61.064855098724365,\n", - " (2025, 5): 6.978058815002441,\n", - " (2025, 6): 5.052379488945007,\n", - " (2025, 7): 3.4841820001602173,\n", - " (2025, 8): 1.5645006895065308,\n", - " (2025, 9): 1.1253303289413452,\n", - " (2025, 10): 6.736822605133057,\n", - " (2025, 11): 45.100945472717285,\n", - " (2025, 12): 65.45136642456055}},\n", - " 317: {'monthly': {(2025, 1): 358.5321509838104,\n", - " (2025, 2): 228.7243822813034,\n", - " (2025, 3): 410.1398905515671,\n", - " (2025, 4): 332.821084856987,\n", - " (2025, 5): 19.289716243743896,\n", - " (2025, 6): 21.71224570274353,\n", - " (2025, 7): 19.19632136821747,\n", - " (2025, 8): 11.603790879249573,\n", - " (2025, 9): 12.464724659919739,\n", - " (2025, 10): 19.081082105636597,\n", - " (2025, 11): 170.3663192987442,\n", - " (2025, 12): 354.42440712451935},\n", - " 'window': {(2025, 1): 157.18986129760742,\n", - " (2025, 2): 104.77830743789673,\n", - " (2025, 3): 105.4462480545044,\n", - " (2025, 4): 135.34625339508057,\n", - " (2025, 5): 6.498356938362122,\n", - " (2025, 6): 6.21310019493103,\n", - " (2025, 7): 5.411075830459595,\n", - " (2025, 8): 6.884749054908752,\n", - " (2025, 9): 6.038686513900757,\n", - " (2025, 10): 7.827865242958069,\n", - " (2025, 11): 107.2075924873352,\n", - " (2025, 12): 86.4535722732544}},\n", - " 318: {'monthly': {(2025, 1): 392.2613070011139,\n", - " (2025, 2): 260.53529274463654,\n", - " (2025, 3): 529.586395740509,\n", - " (2025, 4): 433.7436536550522,\n", - " (2025, 5): 21.885042548179626,\n", - " (2025, 6): 21.22819435596466,\n", - " (2025, 7): 18.698824167251587,\n", - " (2025, 8): 8.401601672172546,\n", - " (2025, 9): 12.22842788696289,\n", - " (2025, 10): 21.580500721931458,\n", - " (2025, 11): 239.71416354179382,\n", - " (2025, 12): 472.8379452228546},\n", - " 'window': {(2025, 1): 155.48420429229736,\n", - " (2025, 2): 129.286762714386,\n", - " (2025, 3): 123.2064380645752,\n", - " (2025, 4): 191.05711936950684,\n", - " (2025, 5): 5.817559123039246,\n", - " (2025, 6): 7.178835034370422,\n", - " (2025, 7): 5.269909977912903,\n", - " (2025, 8): 3.896019697189331,\n", - " (2025, 9): 6.127745628356934,\n", - " (2025, 10): 10.835569262504578,\n", - " (2025, 11): 139.5602159500122,\n", - " (2025, 12): 120.58329582214355}},\n", - " 319: {'monthly': {(2025, 1): 429.6997846364975,\n", - " (2025, 2): 280.88838970661163,\n", - " (2025, 3): 718.0855960845947,\n", - " (2025, 4): 610.9216665029526,\n", - " (2025, 5): 37.901503682136536,\n", - " (2025, 6): 27.433345437049866,\n", - " (2025, 7): 29.90096604824066,\n", - " (2025, 8): 16.540147066116333,\n", - " (2025, 9): 19.14282500743866,\n", - " (2025, 10): 33.485936403274536,\n", - " (2025, 11): 319.5711340904236,\n", - " (2025, 12): 624.9097012281418},\n", - " 'window': {(2025, 1): 114.04803085327148,\n", - " (2025, 2): 125.93144607543945,\n", - " (2025, 3): 157.7159080505371,\n", - " (2025, 4): 244.9023323059082,\n", - " (2025, 5): 10.931990623474121,\n", - " (2025, 6): 8.841463088989258,\n", - " (2025, 7): 10.187610507011414,\n", - " (2025, 8): 7.035149574279785,\n", - " (2025, 9): 6.966664552688599,\n", - " (2025, 10): 17.43773353099823,\n", - " (2025, 11): 147.2019853591919,\n", - " (2025, 12): 168.0730857849121}},\n", - " 320: {'monthly': {(2025, 1): 402.76578080654144,\n", - " (2025, 2): 260.68448972702026,\n", - " (2025, 3): 533.7197995185852,\n", - " (2025, 4): 444.72295212745667,\n", - " (2025, 5): 40.78974521160126,\n", - " (2025, 6): 22.961539387702942,\n", - " (2025, 7): 28.35473132133484,\n", - " (2025, 8): 14.327380418777466,\n", - " (2025, 9): 13.37077534198761,\n", - " (2025, 10): 21.264750599861145,\n", - " (2025, 11): 206.50973784923553,\n", - " (2025, 12): 499.1735305786133},\n", - " 'window': {(2025, 1): 97.06913566589355,\n", - " (2025, 2): 91.4564037322998,\n", - " (2025, 3): 119.30931091308594,\n", - " (2025, 4): 198.02806758880615,\n", - " (2025, 5): 10.962595462799072,\n", - " (2025, 6): 7.966326117515564,\n", - " (2025, 7): 9.258179783821106,\n", - " (2025, 8): 7.829353332519531,\n", - " (2025, 9): 5.304301023483276,\n", - " (2025, 10): 10.524643659591675,\n", - " (2025, 11): 91.09627485275269,\n", - " (2025, 12): 133.5070686340332}},\n", - " 321: {'monthly': {(2025, 1): 257.1391738653183,\n", - " (2025, 2): 168.91927754878998,\n", - " (2025, 3): 280.60446524620056,\n", - " (2025, 4): 159.64695763587952,\n", - " (2025, 5): 11.17095673084259,\n", - " (2025, 6): 5.063637018203735,\n", - " (2025, 7): 2.686225652694702,\n", - " (2025, 8): 1.1304385662078857,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 3.8637890815734863,\n", - " (2025, 11): 109.33818829059601,\n", - " (2025, 12): 309.05519330501556},\n", - " 'window': {(2025, 1): 66.06420516967773,\n", - " (2025, 2): 63.918991565704346,\n", - " (2025, 3): 74.60270500183105,\n", - " (2025, 4): 65.08838510513306,\n", - " (2025, 5): 3.8610275983810425,\n", - " (2025, 6): 2.959864377975464,\n", - " (2025, 7): 1.5832607746124268,\n", - " (2025, 8): 1.1304385662078857,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 3.8637890815734863,\n", - " (2025, 11): 64.8235855102539,\n", - " (2025, 12): 73.0894672870636}},\n", - " 322: {'monthly': {(2025, 1): 212.53208339214325,\n", - " (2025, 2): 129.52160727977753,\n", - " (2025, 3): 235.52594447135925,\n", - " (2025, 4): 133.72910368442535,\n", - " (2025, 5): 1.1444810628890991,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 3.2420706748962402,\n", - " (2025, 9): 2.13326096534729,\n", - " (2025, 10): 8.000906348228455,\n", - " (2025, 11): 82.24604451656342,\n", - " (2025, 12): 272.6721034049988},\n", - " 'window': {(2025, 1): 60.99672794342041,\n", - " (2025, 2): 56.779032707214355,\n", - " (2025, 3): 56.635621070861816,\n", - " (2025, 4): 60.97691535949707,\n", - " (2025, 5): 1.1444810628890991,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.137397050857544,\n", - " (2025, 9): 1.1258207559585571,\n", - " (2025, 10): 4.85388457775116,\n", - " (2025, 11): 55.077775716781616,\n", - " (2025, 12): 67.77900505065918}},\n", - " 323: {'monthly': {(2025, 1): 210.52001237869263,\n", - " (2025, 2): 130.53384602069855,\n", - " (2025, 3): 239.0068621635437,\n", - " (2025, 4): 148.69111227989197,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.3631114959716797,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 2.1612967252731323,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 9.535511255264282,\n", - " (2025, 11): 85.15931022167206,\n", - " (2025, 12): 266.3184611797333},\n", - " 'window': {(2025, 1): 59.16511249542236,\n", - " (2025, 2): 55.651780128479004,\n", - " (2025, 3): 52.21262073516846,\n", - " (2025, 4): 66.04663753509521,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 1.3631114959716797,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.1245856285095215,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 5.944254636764526,\n", - " (2025, 11): 53.83403992652893,\n", - " (2025, 12): 67.1034460067749}},\n", - " 324: {'monthly': {(2025, 1): 201.80703008174896,\n", - " (2025, 2): 127.08749270439148,\n", - " (2025, 3): 200.265726685524,\n", - " (2025, 4): 132.68954825401306,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 5.866483569145203,\n", - " (2025, 11): 74.41146886348724,\n", - " (2025, 12): 214.94979858398438},\n", - " 'window': {(2025, 1): 60.36140441894531,\n", - " (2025, 2): 55.34499168395996,\n", - " (2025, 3): 42.12186050415039,\n", - " (2025, 4): 63.21565818786621,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 5.866483569145203,\n", - " (2025, 11): 50.12285113334656,\n", - " (2025, 12): 60.29991626739502}},\n", - " 325: {'monthly': {(2025, 1): 237.09900903701782,\n", - " (2025, 2): 191.26350617408752,\n", - " (2025, 3): 259.5107237100601,\n", - " (2025, 4): 116.57892453670502,\n", - " (2025, 5): 1.3155027627944946,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 2.01630437374115,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 12.79480266571045,\n", - " (2025, 11): 111.01312565803528,\n", - " (2025, 12): 260.6013377904892},\n", - " 'window': {(2025, 1): 71.98711204528809,\n", - " (2025, 2): 66.68327283859253,\n", - " (2025, 3): 78.77885818481445,\n", - " (2025, 4): 48.04067373275757,\n", - " (2025, 5): 1.3155027627944946,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 1.01249098777771,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 9.044896006584167,\n", - " (2025, 11): 56.69434475898743,\n", - " (2025, 12): 91.58973503112793}},\n", - " 326: {'monthly': {(2025, 1): 220.21568644046783,\n", - " (2025, 2): 191.6761531829834,\n", - " (2025, 3): 212.20149743556976,\n", - " (2025, 4): 170.8297779560089,\n", - " (2025, 5): 7.611121892929077,\n", - " (2025, 6): 2.1556739807128906,\n", - " (2025, 7): 2.400056004524231,\n", - " (2025, 8): 2.279449939727783,\n", - " (2025, 9): 1.1984628438949585,\n", - " (2025, 10): 23.36702585220337,\n", - " (2025, 11): 125.91362249851227,\n", - " (2025, 12): 264.38218677043915},\n", - " 'window': {(2025, 1): 62.84853267669678,\n", - " (2025, 2): 79.591068983078,\n", - " (2025, 3): 53.78243541717529,\n", - " (2025, 4): 53.35154914855957,\n", - " (2025, 5): 4.080973148345947,\n", - " (2025, 6): 2.1556739807128906,\n", - " (2025, 7): 2.400056004524231,\n", - " (2025, 8): 1.2610691785812378,\n", - " (2025, 9): 1.1984628438949585,\n", - " (2025, 10): 10.573194026947021,\n", - " (2025, 11): 54.158409118652344,\n", - " (2025, 12): 69.0382194519043}},\n", - " 327: {'monthly': {(2025, 1): 235.66514778137207,\n", - " (2025, 2): 203.668994307518,\n", - " (2025, 3): 236.40554690361023,\n", - " (2025, 4): 170.87354290485382,\n", - " (2025, 5): 9.579772591590881,\n", - " (2025, 6): 2.1556739807128906,\n", - " (2025, 7): 2.400056004524231,\n", - " (2025, 8): 2.0828410387039185,\n", - " (2025, 9): 2.5622715950012207,\n", - " (2025, 10): 24.98012065887451,\n", - " (2025, 11): 169.0276792049408,\n", - " (2025, 12): 264.90477681159973},\n", - " 'window': {(2025, 1): 68.21992588043213,\n", - " (2025, 2): 83.67216753959656,\n", - " (2025, 3): 67.62478399276733,\n", - " (2025, 4): 58.178486347198486,\n", - " (2025, 5): 6.0496238470077515,\n", - " (2025, 6): 2.1556739807128906,\n", - " (2025, 7): 2.400056004524231,\n", - " (2025, 8): 1.064460277557373,\n", - " (2025, 9): 2.5622715950012207,\n", - " (2025, 10): 13.189907550811768,\n", - " (2025, 11): 86.41585302352905,\n", - " (2025, 12): 82.3584680557251}},\n", - " 328: {'monthly': {(2025, 1): 358.0060957670212,\n", - " (2025, 2): 299.83972811698914,\n", - " (2025, 3): 317.3678300380707,\n", - " (2025, 4): 194.431889295578,\n", - " (2025, 5): 10.09204626083374,\n", - " (2025, 6): 1.119260311126709,\n", - " (2025, 7): 3.539165735244751,\n", - " (2025, 8): 2.139894485473633,\n", - " (2025, 9): 2.89076030254364,\n", - " (2025, 10): 26.90125334262848,\n", - " (2025, 11): 234.32881915569305,\n", - " (2025, 12): 297.5110206604004},\n", - " 'window': {(2025, 1): 108.58229541778564,\n", - " (2025, 2): 125.1525948047638,\n", - " (2025, 3): 97.91110229492188,\n", - " (2025, 4): 75.8791389465332,\n", - " (2025, 5): 4.245151042938232,\n", - " (2025, 6): 1.119260311126709,\n", - " (2025, 7): 2.400056004524231,\n", - " (2025, 8): 1.1215137243270874,\n", - " (2025, 9): 2.89076030254364,\n", - " (2025, 10): 15.636134624481201,\n", - " (2025, 11): 128.14955019950867,\n", - " (2025, 12): 96.95522785186768}},\n", - " 329: {'monthly': {(2025, 1): 550.9475910663605,\n", - " (2025, 2): 409.17646980285645,\n", - " (2025, 3): 348.0985186100006,\n", - " (2025, 4): 226.85849940776825,\n", - " (2025, 5): 22.760416388511658,\n", - " (2025, 6): 9.529913306236267,\n", - " (2025, 7): 9.05125617980957,\n", - " (2025, 8): 13.33353841304779,\n", - " (2025, 9): 4.1595529317855835,\n", - " (2025, 10): 34.630619287490845,\n", - " (2025, 11): 231.84034991264343,\n", - " (2025, 12): 373.2014743089676},\n", - " 'window': {(2025, 1): 177.68629550933838,\n", - " (2025, 2): 159.5745391845703,\n", - " (2025, 3): 100.66673851013184,\n", - " (2025, 4): 76.15360355377197,\n", - " (2025, 5): 9.564926505088806,\n", - " (2025, 6): 4.62581205368042,\n", - " (2025, 7): 5.321721792221069,\n", - " (2025, 8): 4.629127264022827,\n", - " (2025, 9): 3.0163674354553223,\n", - " (2025, 10): 18.566113710403442,\n", - " (2025, 11): 125.86939716339111,\n", - " (2025, 12): 108.77547454833984}},\n", - " 330: {'monthly': {(2025, 1): 429.38706159591675,\n", - " (2025, 2): 395.7940663099289,\n", - " (2025, 3): 374.70012378692627,\n", - " (2025, 4): 293.6360785961151,\n", - " (2025, 5): 25.911399841308594,\n", - " (2025, 6): 15.140053391456604,\n", - " (2025, 7): 16.34821343421936,\n", - " (2025, 8): 22.275375843048096,\n", - " (2025, 9): 1.6180100440979004,\n", - " (2025, 10): 51.89497721195221,\n", - " (2025, 11): 152.0087435245514,\n", - " (2025, 12): 385.5762219429016},\n", - " 'window': {(2025, 1): 142.10386848449707,\n", - " (2025, 2): 143.4593324661255,\n", - " (2025, 3): 85.75222206115723,\n", - " (2025, 4): 105.07676124572754,\n", - " (2025, 5): 10.207780957221985,\n", - " (2025, 6): 4.834999918937683,\n", - " (2025, 7): 5.707912445068359,\n", - " (2025, 8): 8.778172016143799,\n", - " (2025, 9): 1.6180100440979004,\n", - " (2025, 10): 26.04124116897583,\n", - " (2025, 11): 70.8436803817749,\n", - " (2025, 12): 93.34886264801025}},\n", - " 331: {'monthly': {(2025, 1): 376.18924152851105,\n", - " (2025, 2): 298.0910097360611,\n", - " (2025, 3): 455.61820459365845,\n", - " (2025, 4): 408.5306396484375,\n", - " (2025, 5): 28.212905168533325,\n", - " (2025, 6): 22.844727754592896,\n", - " (2025, 7): 19.818821668624878,\n", - " (2025, 8): 21.08519160747528,\n", - " (2025, 9): 3.6351006031036377,\n", - " (2025, 10): 62.270074009895325,\n", - " (2025, 11): 186.35712444782257,\n", - " (2025, 12): 414.39519333839417},\n", - " 'window': {(2025, 1): 139.86341667175293,\n", - " (2025, 2): 135.67268705368042,\n", - " (2025, 3): 92.93604183197021,\n", - " (2025, 4): 173.73432731628418,\n", - " (2025, 5): 12.286830067634583,\n", - " (2025, 6): 7.188616514205933,\n", - " (2025, 7): 5.440275311470032,\n", - " (2025, 8): 7.709134340286255,\n", - " (2025, 9): 2.314718246459961,\n", - " (2025, 10): 30.29954183101654,\n", - " (2025, 11): 73.4339427947998,\n", - " (2025, 12): 97.82576704025269}},\n", - " 332: {'monthly': {(2025, 1): 441.8482434749603,\n", - " (2025, 2): 317.683162689209,\n", - " (2025, 3): 670.5276585817337,\n", - " (2025, 4): 644.6731507778168,\n", - " (2025, 5): 48.14558959007263,\n", - " (2025, 6): 37.49331295490265,\n", - " (2025, 7): 30.240789651870728,\n", - " (2025, 8): 33.89946627616882,\n", - " (2025, 9): 11.515549659729004,\n", - " (2025, 10): 85.35930860042572,\n", - " (2025, 11): 305.2225441932678,\n", - " (2025, 12): 607.214749455452},\n", - " 'window': {(2025, 1): 174.23353385925293,\n", - " (2025, 2): 199.0396270751953,\n", - " (2025, 3): 147.00669288635254,\n", - " (2025, 4): 276.3734474182129,\n", - " (2025, 5): 18.05866050720215,\n", - " (2025, 6): 9.206222534179688,\n", - " (2025, 7): 9.75563097000122,\n", - " (2025, 8): 9.004878520965576,\n", - " (2025, 9): 5.3902013301849365,\n", - " (2025, 10): 45.329050064086914,\n", - " (2025, 11): 107.53076982498169,\n", - " (2025, 12): 155.392071723938}},\n", - " 333: {'monthly': {(2025, 1): 400.5083453655243,\n", - " (2025, 2): 270.9111121892929,\n", - " (2025, 3): 435.1437418460846,\n", - " (2025, 4): 371.6985583305359,\n", - " (2025, 5): 21.588347792625427,\n", - " (2025, 6): 15.446937441825867,\n", - " (2025, 7): 13.015448331832886,\n", - " (2025, 8): 18.615532159805298,\n", - " (2025, 9): 1.4728156328201294,\n", - " (2025, 10): 46.85620129108429,\n", - " (2025, 11): 202.31755113601685,\n", - " (2025, 12): 429.51764619350433},\n", - " 'window': {(2025, 1): 165.4974660873413,\n", - " (2025, 2): 138.2732925415039,\n", - " (2025, 3): 91.94155788421631,\n", - " (2025, 4): 148.24287223815918,\n", - " (2025, 5): 9.002834558486938,\n", - " (2025, 6): 4.6877042055130005,\n", - " (2025, 7): 5.012418985366821,\n", - " (2025, 8): 8.329209804534912,\n", - " (2025, 9): 1.4728156328201294,\n", - " (2025, 10): 22.248366594314575,\n", - " (2025, 11): 78.75196361541748,\n", - " (2025, 12): 103.87582206726074}},\n", - " 334: {'monthly': {(2025, 1): 278.34572982788086,\n", - " (2025, 2): 185.05133092403412,\n", - " (2025, 3): 238.28754138946533,\n", - " (2025, 4): 138.1394908428192,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 3.1999062299728394,\n", - " (2025, 9): 3.3138210773468018,\n", - " (2025, 10): 28.193413257598877,\n", - " (2025, 11): 100.21557867527008,\n", - " (2025, 12): 255.41357958316803},\n", - " 'window': {(2025, 1): 106.12643432617188,\n", - " (2025, 2): 88.95691728591919,\n", - " (2025, 3): 55.15674591064453,\n", - " (2025, 4): 61.32381534576416,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 3.1999062299728394,\n", - " (2025, 9): 2.1128344535827637,\n", - " (2025, 10): 11.989044904708862,\n", - " (2025, 11): 53.38956165313721,\n", - " (2025, 12): 62.995205879211426}},\n", - " 335: {'monthly': {(2025, 1): 251.55499625205994,\n", - " (2025, 2): 173.1434555053711,\n", - " (2025, 3): 229.84176325798035,\n", - " (2025, 4): 135.82300734519958,\n", - " (2025, 5): 1.1779015064239502,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.9419615268707275,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 30.593130469322205,\n", - " (2025, 11): 100.53792250156403,\n", - " (2025, 12): 250.56665909290314},\n", - " 'window': {(2025, 1): 84.77742576599121,\n", - " (2025, 2): 85.42102432250977,\n", - " (2025, 3): 49.444199562072754,\n", - " (2025, 4): 56.122676849365234,\n", - " (2025, 5): 1.1779015064239502,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.9419615268707275,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 16.398701310157776,\n", - " (2025, 11): 55.42706918716431,\n", - " (2025, 12): 65.86368560791016}},\n", - " 336: {'monthly': {(2025, 1): 251.94848537445068,\n", - " (2025, 2): 163.456103682518,\n", - " (2025, 3): 239.08224081993103,\n", - " (2025, 4): 158.01376152038574,\n", - " (2025, 5): 3.4473928213119507,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 1.0032687187194824,\n", - " (2025, 8): 1.9419615268707275,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 38.323407769203186,\n", - " (2025, 11): 102.61155319213867,\n", - " (2025, 12): 255.39022159576416},\n", - " 'window': {(2025, 1): 76.16191482543945,\n", - " (2025, 2): 81.24327754974365,\n", - " (2025, 3): 49.78317165374756,\n", - " (2025, 4): 66.73026657104492,\n", - " (2025, 5): 3.4473928213119507,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 1.0032687187194824,\n", - " (2025, 8): 1.9419615268707275,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 19.446560263633728,\n", - " (2025, 11): 56.843082427978516,\n", - " (2025, 12): 70.91684150695801}},\n", - " 337: {'monthly': {(2025, 1): 225.98806035518646,\n", - " (2025, 2): 143.09882283210754,\n", - " (2025, 3): 202.1193859577179,\n", - " (2025, 4): 141.55777966976166,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.9419615268707275,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 36.80606031417847,\n", - " (2025, 11): 82.95347034931183,\n", - " (2025, 12): 219.1183580160141},\n", - " 'window': {(2025, 1): 70.00502967834473,\n", - " (2025, 2): 68.16415119171143,\n", - " (2025, 3): 52.21530723571777,\n", - " (2025, 4): 73.5796480178833,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.9419615268707275,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 17.749274253845215,\n", - " (2025, 11): 48.33213710784912,\n", - " (2025, 12): 65.4868803024292}},\n", - " 338: {'monthly': {(2025, 1): 225.45134043693542,\n", - " (2025, 2): 181.21996533870697,\n", - " (2025, 3): 255.1179747581482,\n", - " (2025, 4): 124.21743714809418,\n", - " (2025, 5): 2.410400629043579,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 2.01630437374115,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 15.921844720840454,\n", - " (2025, 11): 126.09937536716461,\n", - " (2025, 12): 254.6143013238907},\n", - " 'window': {(2025, 1): 70.06204128265381,\n", - " (2025, 2): 61.522318840026855,\n", - " (2025, 3): 74.37092971801758,\n", - " (2025, 4): 46.8077187538147,\n", - " (2025, 5): 1.2528774738311768,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 1.01249098777771,\n", - " (2025, 8): 0.0,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 8.896986961364746,\n", - " (2025, 11): 60.90027451515198,\n", - " (2025, 12): 90.13586044311523}},\n", - " 339: {'monthly': {(2025, 1): 210.48250794410706,\n", - " (2025, 2): 184.75895941257477,\n", - " (2025, 3): 259.3467364311218,\n", - " (2025, 4): 232.15743267536163,\n", - " (2025, 5): 11.265901565551758,\n", - " (2025, 6): 2.1556739807128906,\n", - " (2025, 7): 2.400056004524231,\n", - " (2025, 8): 2.341714024543762,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 21.345502138137817,\n", - " (2025, 11): 142.0687154531479,\n", - " (2025, 12): 279.7294193506241},\n", - " 'window': {(2025, 1): 62.54350566864014,\n", - " (2025, 2): 77.05323505401611,\n", - " (2025, 3): 62.394978046417236,\n", - " (2025, 4): 89.05928325653076,\n", - " (2025, 5): 6.689352989196777,\n", - " (2025, 6): 2.1556739807128906,\n", - " (2025, 7): 2.400056004524231,\n", - " (2025, 8): 1.3233332633972168,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 11.370583534240723,\n", - " (2025, 11): 58.92886018753052,\n", - " (2025, 12): 80.11723518371582}},\n", - " 340: {'monthly': {(2025, 1): 294.52652621269226,\n", - " (2025, 2): 265.84397077560425,\n", - " (2025, 3): 330.7335362434387,\n", - " (2025, 4): 253.20286428928375,\n", - " (2025, 5): 11.70010221004486,\n", - " (2025, 6): 1.0200153589248657,\n", - " (2025, 7): 3.4929440021514893,\n", - " (2025, 8): 2.1231460571289062,\n", - " (2025, 9): 1.524940013885498,\n", - " (2025, 10): 31.423770427703857,\n", - " (2025, 11): 232.2652325630188,\n", - " (2025, 12): 300.6065698862076},\n", - " 'window': {(2025, 1): 89.13950538635254,\n", - " (2025, 2): 108.08464550971985,\n", - " (2025, 3): 96.83643245697021,\n", - " (2025, 4): 90.24822521209717,\n", - " (2025, 5): 5.462664365768433,\n", - " (2025, 6): 1.0200153589248657,\n", - " (2025, 7): 2.400056004524231,\n", - " (2025, 8): 1.1047652959823608,\n", - " (2025, 9): 1.524940013885498,\n", - " (2025, 10): 16.678308844566345,\n", - " (2025, 11): 127.92508697509766,\n", - " (2025, 12): 98.75457572937012}},\n", - " 341: {'monthly': {(2025, 1): 598.781925201416,\n", - " (2025, 2): 457.5902565717697,\n", - " (2025, 3): 562.1454336643219,\n", - " (2025, 4): 309.09968876838684,\n", - " (2025, 5): 10.017340421676636,\n", - " (2025, 6): 4.528771162033081,\n", - " (2025, 7): 4.0946550369262695,\n", - " (2025, 8): 2.5824663639068604,\n", - " (2025, 9): 7.216539740562439,\n", - " (2025, 10): 34.23454451560974,\n", - " (2025, 11): 464.47880923748016,\n", - " (2025, 12): 423.1375033855438},\n", - " 'window': {(2025, 1): 238.36513805389404,\n", - " (2025, 2): 191.16604948043823,\n", - " (2025, 3): 201.89592838287354,\n", - " (2025, 4): 131.65773010253906,\n", - " (2025, 5): 4.177662014961243,\n", - " (2025, 6): 3.516729950904846,\n", - " (2025, 7): 3.0014960765838623,\n", - " (2025, 8): 1.564085602760315,\n", - " (2025, 9): 4.292568922042847,\n", - " (2025, 10): 21.807717323303223,\n", - " (2025, 11): 275.4571166038513,\n", - " (2025, 12): 156.49690341949463}},\n", - " 342: {'monthly': {(2025, 1): 785.1029434204102,\n", - " (2025, 2): 560.4875700473785,\n", - " (2025, 3): 568.772118806839,\n", - " (2025, 4): 302.3787181377411,\n", - " (2025, 5): 22.016371488571167,\n", - " (2025, 6): 12.942697286605835,\n", - " (2025, 7): 10.993513822555542,\n", - " (2025, 8): 9.149370908737183,\n", - " (2025, 9): 4.595024108886719,\n", - " (2025, 10): 46.974252223968506,\n", - " (2025, 11): 445.1080459356308,\n", - " (2025, 12): 497.6798286437988},\n", - " 'window': {(2025, 1): 281.34972953796387,\n", - " (2025, 2): 217.0045804977417,\n", - " (2025, 3): 193.30969429016113,\n", - " (2025, 4): 121.18622481822968,\n", - " (2025, 5): 7.950483202934265,\n", - " (2025, 6): 4.06349778175354,\n", - " (2025, 7): 4.330966234207153,\n", - " (2025, 8): 2.876102089881897,\n", - " (2025, 9): 4.595024108886719,\n", - " (2025, 10): 22.479503870010376,\n", - " (2025, 11): 260.3722424507141,\n", - " (2025, 12): 161.1882610321045}},\n", - " 343: {'monthly': {(2025, 1): 492.2682377099991,\n", - " (2025, 2): 458.382457613945,\n", - " (2025, 3): 420.4818159341812,\n", - " (2025, 4): 256.53629660606384,\n", - " (2025, 5): 24.161834359169006,\n", - " (2025, 6): 15.764887928962708,\n", - " (2025, 7): 15.513911128044128,\n", - " (2025, 8): 14.794519543647766,\n", - " (2025, 9): 1.5695711374282837,\n", - " (2025, 10): 42.49834370613098,\n", - " (2025, 11): 152.91727256774902,\n", - " (2025, 12): 402.2237696647644},\n", - " 'window': {(2025, 1): 172.40564155578613,\n", - " (2025, 2): 165.58971786499023,\n", - " (2025, 3): 105.33851432800293,\n", - " (2025, 4): 84.14036083221436,\n", - " (2025, 5): 8.848913550376892,\n", - " (2025, 6): 5.11303985118866,\n", - " (2025, 7): 5.866310358047485,\n", - " (2025, 8): 6.753806948661804,\n", - " (2025, 9): 1.5695711374282837,\n", - " (2025, 10): 20.333340406417847,\n", - " (2025, 11): 79.96369647979736,\n", - " (2025, 12): 101.31161594390869}},\n", - " 344: {'monthly': {(2025, 1): 309.6844265460968,\n", - " (2025, 2): 243.08601355552673,\n", - " (2025, 3): 401.32239949703217,\n", - " (2025, 4): 334.69847786426544,\n", - " (2025, 5): 26.87366271018982,\n", - " (2025, 6): 18.862292170524597,\n", - " (2025, 7): 17.221213579177856,\n", - " (2025, 8): 20.543832659721375,\n", - " (2025, 9): 1.1457568407058716,\n", - " (2025, 10): 40.35830855369568,\n", - " (2025, 11): 153.92958617210388,\n", - " (2025, 12): 340.7444165945053},\n", - " 'window': {(2025, 1): 136.97811031341553,\n", - " (2025, 2): 127.61199021339417,\n", - " (2025, 3): 91.64776849746704,\n", - " (2025, 4): 135.51680374145508,\n", - " (2025, 5): 9.935986518859863,\n", - " (2025, 6): 6.640302300453186,\n", - " (2025, 7): 6.2163325548172,\n", - " (2025, 8): 7.545609951019287,\n", - " (2025, 9): 1.1457568407058716,\n", - " (2025, 10): 19.576393127441406,\n", - " (2025, 11): 69.17622518539429,\n", - " (2025, 12): 91.00161123275757}},\n", - " 345: {'monthly': {(2025, 1): 337.2566227912903,\n", - " (2025, 2): 290.107386469841,\n", - " (2025, 3): 505.30463564395905,\n", - " (2025, 4): 486.9293043613434,\n", - " (2025, 5): 46.93369901180267,\n", - " (2025, 6): 39.238662123680115,\n", - " (2025, 7): 38.51096272468567,\n", - " (2025, 8): 35.67331278324127,\n", - " (2025, 9): 6.216443300247192,\n", - " (2025, 10): 50.900394439697266,\n", - " (2025, 11): 210.96219193935394,\n", - " (2025, 12): 433.6711745262146},\n", - " 'window': {(2025, 1): 149.46274185180664,\n", - " (2025, 2): 191.11322832107544,\n", - " (2025, 3): 111.12268161773682,\n", - " (2025, 4): 189.0197353363037,\n", - " (2025, 5): 15.81813931465149,\n", - " (2025, 6): 9.883359432220459,\n", - " (2025, 7): 10.382338762283325,\n", - " (2025, 8): 14.220419645309448,\n", - " (2025, 9): 3.8533854484558105,\n", - " (2025, 10): 26.36990761756897,\n", - " (2025, 11): 75.36110782623291,\n", - " (2025, 12): 117.46103239059448}},\n", - " 346: {'monthly': {(2025, 1): 305.2705398797989,\n", - " (2025, 2): 211.83406698703766,\n", - " (2025, 3): 304.75273418426514,\n", - " (2025, 4): 253.66188168525696,\n", - " (2025, 5): 15.824649572372437,\n", - " (2025, 6): 14.163592457771301,\n", - " (2025, 7): 11.874176859855652,\n", - " (2025, 8): 15.89371907711029,\n", - " (2025, 9): 1.1784154176712036,\n", - " (2025, 10): 28.53017008304596,\n", - " (2025, 11): 132.49020791053772,\n", - " (2025, 12): 299.785516500473},\n", - " 'window': {(2025, 1): 141.5630979537964,\n", - " (2025, 2): 127.44403553009033,\n", - " (2025, 3): 72.47952365875244,\n", - " (2025, 4): 86.64704895019531,\n", - " (2025, 5): 6.497116208076477,\n", - " (2025, 6): 4.738503813743591,\n", - " (2025, 7): 4.1890411376953125,\n", - " (2025, 8): 8.373977661132812,\n", - " (2025, 9): 1.1784154176712036,\n", - " (2025, 10): 13.69137167930603,\n", - " (2025, 11): 59.258174896240234,\n", - " (2025, 12): 73.85692739486694}},\n", - " 347: {'monthly': {(2025, 1): 215.60875010490417,\n", - " (2025, 2): 147.3142420053482,\n", - " (2025, 3): 234.9561824798584,\n", - " (2025, 4): 123.58958232402802,\n", - " (2025, 5): 1.0187604427337646,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 3.0037156343460083,\n", - " (2025, 9): 1.0178587436676025,\n", - " (2025, 10): 23.43438744544983,\n", - " (2025, 11): 78.35990786552429,\n", - " (2025, 12): 227.0193350315094},\n", - " 'window': {(2025, 1): 80.70522212982178,\n", - " (2025, 2): 77.37099385261536,\n", - " (2025, 3): 52.06100511550903,\n", - " (2025, 4): 50.8549599647522,\n", - " (2025, 5): 1.0187604427337646,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 3.0037156343460083,\n", - " (2025, 9): 1.0178587436676025,\n", - " (2025, 10): 12.944806694984436,\n", - " (2025, 11): 43.42310667037964,\n", - " (2025, 12): 62.06339406967163}},\n", - " 348: {'monthly': {(2025, 1): 219.0494657754898,\n", - " (2025, 2): 154.64330053329468,\n", - " (2025, 3): 266.59103441238403,\n", - " (2025, 4): 143.24180352687836,\n", - " (2025, 5): 2.732785224914551,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 4.789138555526733,\n", - " (2025, 9): 1.0787101984024048,\n", - " (2025, 10): 30.12979531288147,\n", - " (2025, 11): 90.95443749427795,\n", - " (2025, 12): 259.0005269050598},\n", - " 'window': {(2025, 1): 68.31414699554443,\n", - " (2025, 2): 79.58621740341187,\n", - " (2025, 3): 60.084471225738525,\n", - " (2025, 4): 55.324620723724365,\n", - " (2025, 5): 2.732785224914551,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 2.4989960193634033,\n", - " (2025, 9): 1.0787101984024048,\n", - " (2025, 10): 17.452082991600037,\n", - " (2025, 11): 49.87313461303711,\n", - " (2025, 12): 68.53625440597534}},\n", - " 349: {'monthly': {(2025, 1): 219.8252465724945,\n", - " (2025, 2): 148.19270634651184,\n", - " (2025, 3): 242.36577105522156,\n", - " (2025, 4): 143.67109942436218,\n", - " (2025, 5): 2.4788931608200073,\n", - " (2025, 6): 1.0364371538162231,\n", - " (2025, 7): 1.0030415058135986,\n", - " (2025, 8): 1.9419615268707275,\n", - " (2025, 9): 1.0403586626052856,\n", - " (2025, 10): 33.47906744480133,\n", - " (2025, 11): 86.9520046710968,\n", - " (2025, 12): 257.5097497701645},\n", - " 'window': {(2025, 1): 67.59092807769775,\n", - " (2025, 2): 74.94609546661377,\n", - " (2025, 3): 52.99347496032715,\n", - " (2025, 4): 61.15786647796631,\n", - " (2025, 5): 2.4788931608200073,\n", - " (2025, 6): 1.0364371538162231,\n", - " (2025, 7): 1.0030415058135986,\n", - " (2025, 8): 1.9419615268707275,\n", - " (2025, 9): 1.0403586626052856,\n", - " (2025, 10): 16.707398295402527,\n", - " (2025, 11): 49.721323013305664,\n", - " (2025, 12): 69.02201747894287}},\n", - " 350: {'monthly': {(2025, 1): 198.9418295621872,\n", - " (2025, 2): 129.52871251106262,\n", - " (2025, 3): 191.41376972198486,\n", - " (2025, 4): 131.2967301607132,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 3.1617441177368164,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 32.36454498767853,\n", - " (2025, 11): 71.1389662027359,\n", - " (2025, 12): 217.74234926700592},\n", - " 'window': {(2025, 1): 64.2052993774414,\n", - " (2025, 2): 63.26905632019043,\n", - " (2025, 3): 56.818530559539795,\n", - " (2025, 4): 64.98331022262573,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.9419615268707275,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 14.580575942993164,\n", - " (2025, 11): 43.55553150177002,\n", - " (2025, 12): 66.00944137573242}},\n", - " 351: {'monthly': {(2025, 1): 216.88097155094147,\n", - " (2025, 2): 172.3420650959015,\n", - " (2025, 3): 238.4443291425705,\n", - " (2025, 4): 126.58290815353394,\n", - " (2025, 5): 2.763908863067627,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 2.01630437374115,\n", - " (2025, 8): 2.700949549674988,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 16.067772150039673,\n", - " (2025, 11): 119.59851694107056,\n", - " (2025, 12): 235.24806773662567},\n", - " 'window': {(2025, 1): 60.828542709350586,\n", - " (2025, 2): 55.01508903503418,\n", - " (2025, 3): 63.4479398727417,\n", - " (2025, 4): 47.65246534347534,\n", - " (2025, 5): 1.721029281616211,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 1.01249098777771,\n", - " (2025, 8): 2.700949549674988,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 9.460139036178589,\n", - " (2025, 11): 60.05395841598511,\n", - " (2025, 12): 84.57236099243164}},\n", - " 352: {'monthly': {(2025, 1): 216.98602890968323,\n", - " (2025, 2): 202.0851892232895,\n", - " (2025, 3): 277.94309639930725,\n", - " (2025, 4): 241.16286098957062,\n", - " (2025, 5): 12.638531804084778,\n", - " (2025, 6): 2.1852222681045532,\n", - " (2025, 7): 2.400056004524231,\n", - " (2025, 8): 3.4500924348831177,\n", - " (2025, 9): 1.031732439994812,\n", - " (2025, 10): 26.435373902320862,\n", - " (2025, 11): 124.826935172081,\n", - " (2025, 12): 286.2036155462265},\n", - " 'window': {(2025, 1): 58.899776458740234,\n", - " (2025, 2): 79.7751533985138,\n", - " (2025, 3): 68.61228084564209,\n", - " (2025, 4): 85.31876277923584,\n", - " (2025, 5): 4.384997606277466,\n", - " (2025, 6): 2.1852222681045532,\n", - " (2025, 7): 2.400056004524231,\n", - " (2025, 8): 2.4317116737365723,\n", - " (2025, 9): 1.031732439994812,\n", - " (2025, 10): 11.883933424949646,\n", - " (2025, 11): 53.526267528533936,\n", - " (2025, 12): 93.45931434631348}},\n", - " 353: {'monthly': {(2025, 1): 286.65122842788696,\n", - " (2025, 2): 236.5702257156372,\n", - " (2025, 3): 317.39005506038666,\n", - " (2025, 4): 243.8930892944336,\n", - " (2025, 5): 11.861364841461182,\n", - " (2025, 6): 5.27555239200592,\n", - " (2025, 7): 3.273147225379944,\n", - " (2025, 8): 8.089160442352295,\n", - " (2025, 9): 1.0277146100997925,\n", - " (2025, 10): 28.87752103805542,\n", - " (2025, 11): 167.08360075950623,\n", - " (2025, 12): 314.6300264596939},\n", - " 'window': {(2025, 1): 86.04678535461426,\n", - " (2025, 2): 92.48001956939697,\n", - " (2025, 3): 89.25366735458374,\n", - " (2025, 4): 84.07971096038818,\n", - " (2025, 5): 5.339000821113586,\n", - " (2025, 6): 2.918463945388794,\n", - " (2025, 7): 3.273147225379944,\n", - " (2025, 8): 4.4521403312683105,\n", - " (2025, 9): 1.0277146100997925,\n", - " (2025, 10): 14.8862065076828,\n", - " (2025, 11): 83.06083178520203,\n", - " (2025, 12): 111.64072227478027}},\n", - " 354: {'monthly': {(2025, 1): 446.97236454486847,\n", - " (2025, 2): 327.43696534633636,\n", - " (2025, 3): 452.71592569351196,\n", - " (2025, 4): 283.18788826465607,\n", - " (2025, 5): 13.903091311454773,\n", - " (2025, 6): 5.290794014930725,\n", - " (2025, 7): 3.367269277572632,\n", - " (2025, 8): 5.075513482093811,\n", - " (2025, 9): 1.3653578758239746,\n", - " (2025, 10): 25.489354372024536,\n", - " (2025, 11): 296.631520152092,\n", - " (2025, 12): 384.69648814201355},\n", - " 'window': {(2025, 1): 157.0377836227417,\n", - " (2025, 2): 131.81841135025024,\n", - " (2025, 3): 149.95544338226318,\n", - " (2025, 4): 105.24327659606934,\n", - " (2025, 5): 5.686879754066467,\n", - " (2025, 6): 4.095267295837402,\n", - " (2025, 7): 3.367269277572632,\n", - " (2025, 8): 4.057132720947266,\n", - " (2025, 9): 1.3653578758239746,\n", - " (2025, 10): 15.146490812301636,\n", - " (2025, 11): 176.3942747116089,\n", - " (2025, 12): 156.3250036239624}},\n", - " 355: {'monthly': {(2025, 1): 500.40150451660156,\n", - " (2025, 2): 356.3902713060379,\n", - " (2025, 3): 427.1695635318756,\n", - " (2025, 4): 243.31449937820435,\n", - " (2025, 5): 14.299492716789246,\n", - " (2025, 6): 2.550400495529175,\n", - " (2025, 7): 3.95507550239563,\n", - " (2025, 8): 4.845040559768677,\n", - " (2025, 9): 1.3269413709640503,\n", - " (2025, 10): 19.289637207984924,\n", - " (2025, 11): 273.1174931526184,\n", - " (2025, 12): 405.9232362508774},\n", - " 'window': {(2025, 1): 171.49611568450928,\n", - " (2025, 2): 136.87994480133057,\n", - " (2025, 3): 134.0221347808838,\n", - " (2025, 4): 88.64030647277832,\n", - " (2025, 5): 4.299044847488403,\n", - " (2025, 6): 2.550400495529175,\n", - " (2025, 7): 2.781076431274414,\n", - " (2025, 8): 2.5525126457214355,\n", - " (2025, 9): 1.3269413709640503,\n", - " (2025, 10): 11.408055067062378,\n", - " (2025, 11): 166.7874994277954,\n", - " (2025, 12): 149.8476858139038}},\n", - " 356: {'monthly': {(2025, 1): 351.2678986787796,\n", - " (2025, 2): 302.2968080043793,\n", - " (2025, 3): 320.1081373691559,\n", - " (2025, 4): 156.7321810722351,\n", - " (2025, 5): 10.486618995666504,\n", - " (2025, 6): 12.680544257164001,\n", - " (2025, 7): 11.863498568534851,\n", - " (2025, 8): 11.69752836227417,\n", - " (2025, 9): 1.1784154176712036,\n", - " (2025, 10): 21.760799527168274,\n", - " (2025, 11): 121.79124426841736,\n", - " (2025, 12): 322.46091747283936},\n", - " 'window': {(2025, 1): 145.44300746917725,\n", - " (2025, 2): 109.3827588558197,\n", - " (2025, 3): 81.29564094543457,\n", - " (2025, 4): 50.315197467803955,\n", - " (2025, 5): 4.32876980304718,\n", - " (2025, 6): 5.11321747303009,\n", - " (2025, 7): 4.314357757568359,\n", - " (2025, 8): 5.002471923828125,\n", - " (2025, 9): 1.1784154176712036,\n", - " (2025, 10): 9.573505997657776,\n", - " (2025, 11): 73.34344244003296,\n", - " (2025, 12): 91.27685070037842}},\n", - " 357: {'monthly': {(2025, 1): 253.53920567035675,\n", - " (2025, 2): 198.09429466724396,\n", - " (2025, 3): 345.5704143047333,\n", - " (2025, 4): 240.0858416557312,\n", - " (2025, 5): 20.411293029785156,\n", - " (2025, 6): 19.68152117729187,\n", - " (2025, 7): 18.866042375564575,\n", - " (2025, 8): 17.968339204788208,\n", - " (2025, 9): 1.1784154176712036,\n", - " (2025, 10): 25.44783079624176,\n", - " (2025, 11): 144.5857709646225,\n", - " (2025, 12): 318.9915220737457},\n", - " 'window': {(2025, 1): 110.91432857513428,\n", - " (2025, 2): 99.29275417327881,\n", - " (2025, 3): 96.31718492507935,\n", - " (2025, 4): 84.53508281707764,\n", - " (2025, 5): 7.255892634391785,\n", - " (2025, 6): 6.839479923248291,\n", - " (2025, 7): 6.514549493789673,\n", - " (2025, 8): 8.237096548080444,\n", - " (2025, 9): 1.1784154176712036,\n", - " (2025, 10): 11.244953513145447,\n", - " (2025, 11): 67.61477661132812,\n", - " (2025, 12): 88.84179925918579}},\n", - " 358: {'monthly': {(2025, 1): 297.42164862155914,\n", - " (2025, 2): 244.15806484222412,\n", - " (2025, 3): 388.2954887151718,\n", - " (2025, 4): 342.7280150651932,\n", - " (2025, 5): 40.78844702243805,\n", - " (2025, 6): 42.574305057525635,\n", - " (2025, 7): 42.81074249744415,\n", - " (2025, 8): 31.16748881340027,\n", - " (2025, 9): 4.024959683418274,\n", - " (2025, 10): 36.68556594848633,\n", - " (2025, 11): 195.6017884016037,\n", - " (2025, 12): 384.30864799022675},\n", - " 'window': {(2025, 1): 109.42829656600952,\n", - " (2025, 2): 146.56412982940674,\n", - " (2025, 3): 101.93483018875122,\n", - " (2025, 4): 102.34342861175537,\n", - " (2025, 5): 10.994549632072449,\n", - " (2025, 6): 13.284198999404907,\n", - " (2025, 7): 13.32313096523285,\n", - " (2025, 8): 14.885177373886108,\n", - " (2025, 9): 1.7815488576889038,\n", - " (2025, 10): 16.292572259902954,\n", - " (2025, 11): 76.5296983718872,\n", - " (2025, 12): 100.89411401748657}},\n", - " 359: {'monthly': {(2025, 1): 226.37514543533325,\n", - " (2025, 2): 180.6430733203888,\n", - " (2025, 3): 237.87443494796753,\n", - " (2025, 4): 183.54328763484955,\n", - " (2025, 5): 13.570899486541748,\n", - " (2025, 6): 15.76900851726532,\n", - " (2025, 7): 14.112905979156494,\n", - " (2025, 8): 15.370946526527405,\n", - " (2025, 9): 1.1784154176712036,\n", - " (2025, 10): 24.094041228294373,\n", - " (2025, 11): 127.4882355928421,\n", - " (2025, 12): 270.73786985874176},\n", - " 'window': {(2025, 1): 96.08165740966797,\n", - " (2025, 2): 93.74814128875732,\n", - " (2025, 3): 68.87348222732544,\n", - " (2025, 4): 54.418028831481934,\n", - " (2025, 5): 5.553355097770691,\n", - " (2025, 6): 4.887098550796509,\n", - " (2025, 7): 4.792014002799988,\n", - " (2025, 8): 8.725201606750488,\n", - " (2025, 9): 1.1784154176712036,\n", - " (2025, 10): 10.70705270767212,\n", - " (2025, 11): 69.6864161491394,\n", - " (2025, 12): 81.7558479309082}},\n", - " 360: {'monthly': {(2025, 1): 156.53010964393616,\n", - " (2025, 2): 107.93596529960632,\n", - " (2025, 3): 206.4057456254959,\n", - " (2025, 4): 112.99599647521973,\n", - " (2025, 5): 1.119225263595581,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 1.068198800086975,\n", - " (2025, 8): 3.0928685665130615,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 21.075826287269592,\n", - " (2025, 11): 60.21400189399719,\n", - " (2025, 12): 232.03782832622528},\n", - " 'window': {(2025, 1): 50.28630542755127,\n", - " (2025, 2): 62.4988112449646,\n", - " (2025, 3): 58.17721486091614,\n", - " (2025, 4): 42.75929355621338,\n", - " (2025, 5): 1.119225263595581,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 1.068198800086975,\n", - " (2025, 8): 3.0928685665130615,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 12.03019392490387,\n", - " (2025, 11): 30.713514804840088,\n", - " (2025, 12): 89.85728740692139}},\n", - " 361: {'monthly': {(2025, 1): 156.10604321956635,\n", - " (2025, 2): 121.91406917572021,\n", - " (2025, 3): 247.11229157447815,\n", - " (2025, 4): 127.25627052783966,\n", - " (2025, 5): 1.10861074924469,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.9419615268707275,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 29.347536087036133,\n", - " (2025, 11): 69.68205070495605,\n", - " (2025, 12): 253.15638053417206},\n", - " 'window': {(2025, 1): 52.00176954269409,\n", - " (2025, 2): 65.92419171333313,\n", - " (2025, 3): 67.66762185096741,\n", - " (2025, 4): 50.61474323272705,\n", - " (2025, 5): 1.10861074924469,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.9419615268707275,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 15.135427594184875,\n", - " (2025, 11): 39.29073715209961,\n", - " (2025, 12): 96.55618143081665}},\n", - " 362: {'monthly': {(2025, 1): 184.25104022026062,\n", - " (2025, 2): 130.01529777050018,\n", - " (2025, 3): 236.07979488372803,\n", - " (2025, 4): 124.15712177753448,\n", - " (2025, 5): 2.1190807819366455,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 3.13738214969635,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 30.088563561439514,\n", - " (2025, 11): 70.34565830230713,\n", - " (2025, 12): 261.4444754123688},\n", - " 'window': {(2025, 1): 64.77225399017334,\n", - " (2025, 2): 70.0956654548645,\n", - " (2025, 3): 62.10712003707886,\n", - " (2025, 4): 55.452062129974365,\n", - " (2025, 5): 2.1190807819366455,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.9419615268707275,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 14.378431558609009,\n", - " (2025, 11): 42.32256078720093,\n", - " (2025, 12): 91.64392900466919}},\n", - " 363: {'monthly': {(2025, 1): 190.50799083709717,\n", - " (2025, 2): 120.95015835762024,\n", - " (2025, 3): 204.3733276128769,\n", - " (2025, 4): 123.6000669002533,\n", - " (2025, 5): 1.0445791482925415,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.9419615268707275,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 28.55189621448517,\n", - " (2025, 11): 63.3209422826767,\n", - " (2025, 12): 246.4618180990219},\n", - " 'window': {(2025, 1): 65.3030138015747,\n", - " (2025, 2): 64.51059436798096,\n", - " (2025, 3): 54.14670467376709,\n", - " (2025, 4): 59.28178930282593,\n", - " (2025, 5): 1.0445791482925415,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.9419615268707275,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 16.692971229553223,\n", - " (2025, 11): 40.196064949035645,\n", - " (2025, 12): 78.36984825134277}},\n", - " 364: {'monthly': {(2025, 1): 200.69870698451996,\n", - " (2025, 2): 166.9845802783966,\n", - " (2025, 3): 196.9128761291504,\n", - " (2025, 4): 105.42475581169128,\n", - " (2025, 5): 4.768637537956238,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 3.078762173652649,\n", - " (2025, 8): 2.283703923225403,\n", - " (2025, 9): 1.0353877544403076,\n", - " (2025, 10): 17.06257176399231,\n", - " (2025, 11): 99.49886620044708,\n", - " (2025, 12): 216.5718867778778},\n", - " 'window': {(2025, 1): 54.04763078689575,\n", - " (2025, 2): 51.13222789764404,\n", - " (2025, 3): 52.754791259765625,\n", - " (2025, 4): 39.94315266609192,\n", - " (2025, 5): 2.4485065937042236,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 1.062457799911499,\n", - " (2025, 8): 2.283703923225403,\n", - " (2025, 9): 1.0353877544403076,\n", - " (2025, 10): 9.616197347640991,\n", - " (2025, 11): 50.072980642318726,\n", - " (2025, 12): 77.42194652557373}},\n", - " 365: {'monthly': {(2025, 1): 203.50963628292084,\n", - " (2025, 2): 189.6708688735962,\n", - " (2025, 3): 265.20481419563293,\n", - " (2025, 4): 172.01687955856323,\n", - " (2025, 5): 5.47324001789093,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 2.400056004524231,\n", - " (2025, 8): 3.9237865209579468,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 20.604114532470703,\n", - " (2025, 11): 111.22251749038696,\n", - " (2025, 12): 253.90077245235443},\n", - " 'window': {(2025, 1): 61.974122524261475,\n", - " (2025, 2): 71.25423169136047,\n", - " (2025, 3): 82.54325723648071,\n", - " (2025, 4): 64.11848831176758,\n", - " (2025, 5): 3.164874792098999,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 2.400056004524231,\n", - " (2025, 8): 2.9054057598114014,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 12.046505212783813,\n", - " (2025, 11): 45.41525936126709,\n", - " (2025, 12): 89.76169300079346}},\n", - " 366: {'monthly': {(2025, 1): 249.27217483520508,\n", - " (2025, 2): 193.58257853984833,\n", - " (2025, 3): 281.66472578048706,\n", - " (2025, 4): 172.2453943490982,\n", - " (2025, 5): 9.40317451953888,\n", - " (2025, 6): 1.234487771987915,\n", - " (2025, 7): 3.301408290863037,\n", - " (2025, 8): 7.622150897979736,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 25.54082942008972,\n", - " (2025, 11): 102.11485648155212,\n", - " (2025, 12): 284.4047499895096},\n", - " 'window': {(2025, 1): 79.92263317108154,\n", - " (2025, 2): 65.58538269996643,\n", - " (2025, 3): 98.49228858947754,\n", - " (2025, 4): 70.57616329193115,\n", - " (2025, 5): 3.832360029220581,\n", - " (2025, 6): 1.234487771987915,\n", - " (2025, 7): 3.301408290863037,\n", - " (2025, 8): 4.682494163513184,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 15.351014614105225,\n", - " (2025, 11): 45.77235770225525,\n", - " (2025, 12): 100.00908279418945}},\n", - " 367: {'monthly': {(2025, 1): 284.6091296672821,\n", - " (2025, 2): 215.51524746418,\n", - " (2025, 3): 294.96488988399506,\n", - " (2025, 4): 181.48558831214905,\n", - " (2025, 5): 7.963621735572815,\n", - " (2025, 6): 1.2883808612823486,\n", - " (2025, 7): 4.394084811210632,\n", - " (2025, 8): 6.089627385139465,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 18.58853054046631,\n", - " (2025, 11): 107.360604763031,\n", - " (2025, 12): 320.1792416572571},\n", - " 'window': {(2025, 1): 88.49491024017334,\n", - " (2025, 2): 72.93993330001831,\n", - " (2025, 3): 96.71277177333832,\n", - " (2025, 4): 68.60513401031494,\n", - " (2025, 5): 4.521909594535828,\n", - " (2025, 6): 1.2883808612823486,\n", - " (2025, 7): 3.2055033445358276,\n", - " (2025, 8): 3.935878276824951,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 9.554863691329956,\n", - " (2025, 11): 55.53293704986572,\n", - " (2025, 12): 121.80690956115723}},\n", - " 368: {'monthly': {(2025, 1): 286.638356924057,\n", - " (2025, 2): 241.02199959754944,\n", - " (2025, 3): 275.59135913848877,\n", - " (2025, 4): 140.2203449010849,\n", - " (2025, 5): 8.895679831504822,\n", - " (2025, 6): 2.759658455848694,\n", - " (2025, 7): 5.222125172615051,\n", - " (2025, 8): 4.223493337631226,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 12.966625571250916,\n", - " (2025, 11): 114.06130003929138,\n", - " (2025, 12): 290.6854283809662},\n", - " 'window': {(2025, 1): 85.16545581817627,\n", - " (2025, 2): 81.65061521530151,\n", - " (2025, 3): 90.40280628204346,\n", - " (2025, 4): 57.466068744659424,\n", - " (2025, 5): 3.572587013244629,\n", - " (2025, 6): 2.759658455848694,\n", - " (2025, 7): 4.033543705940247,\n", - " (2025, 8): 2.18634295463562,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 6.755037784576416,\n", - " (2025, 11): 57.17674779891968,\n", - " (2025, 12): 115.56759834289551}},\n", - " 369: {'monthly': {(2025, 1): 221.43311142921448,\n", - " (2025, 2): 205.16994845867157,\n", - " (2025, 3): 269.10445499420166,\n", - " (2025, 4): 138.16055476665497,\n", - " (2025, 5): 12.013728499412537,\n", - " (2025, 6): 11.698956847190857,\n", - " (2025, 7): 11.885284185409546,\n", - " (2025, 8): 11.759413123130798,\n", - " (2025, 9): 1.1784154176712036,\n", - " (2025, 10): 19.41842222213745,\n", - " (2025, 11): 123.0395804643631,\n", - " (2025, 12): 283.8026645183563},\n", - " 'window': {(2025, 1): 91.25607109069824,\n", - " (2025, 2): 80.65153670310974,\n", - " (2025, 3): 75.3668441772461,\n", - " (2025, 4): 46.357263803482056,\n", - " (2025, 5): 4.013471841812134,\n", - " (2025, 6): 5.11321747303009,\n", - " (2025, 7): 4.052142381668091,\n", - " (2025, 8): 4.20663595199585,\n", - " (2025, 9): 1.1784154176712036,\n", - " (2025, 10): 7.272506356239319,\n", - " (2025, 11): 68.9083366394043,\n", - " (2025, 12): 80.69782400131226}},\n", - " 370: {'monthly': {(2025, 1): 253.75455927848816,\n", - " (2025, 2): 233.486142039299,\n", - " (2025, 3): 362.4530608654022,\n", - " (2025, 4): 235.4016933441162,\n", - " (2025, 5): 19.891690015792847,\n", - " (2025, 6): 18.551693320274353,\n", - " (2025, 7): 17.0680935382843,\n", - " (2025, 8): 16.379220843315125,\n", - " (2025, 9): 1.1784154176712036,\n", - " (2025, 10): 26.62405836582184,\n", - " (2025, 11): 185.97259259223938,\n", - " (2025, 12): 387.7565950155258},\n", - " 'window': {(2025, 1): 78.5260181427002,\n", - " (2025, 2): 108.23166155815125,\n", - " (2025, 3): 100.81977081298828,\n", - " (2025, 4): 74.81592607498169,\n", - " (2025, 5): 6.391633868217468,\n", - " (2025, 6): 5.926976561546326,\n", - " (2025, 7): 6.454372763633728,\n", - " (2025, 8): 8.48864459991455,\n", - " (2025, 9): 1.1784154176712036,\n", - " (2025, 10): 11.79430103302002,\n", - " (2025, 11): 81.91942405700684,\n", - " (2025, 12): 97.53121757507324}},\n", - " 371: {'monthly': {(2025, 1): 296.71077263355255,\n", - " (2025, 2): 256.504865527153,\n", - " (2025, 3): 373.0331766605377,\n", - " (2025, 4): 270.7508462667465,\n", - " (2025, 5): 29.567321300506592,\n", - " (2025, 6): 31.10014796257019,\n", - " (2025, 7): 24.274214386940002,\n", - " (2025, 8): 23.94204044342041,\n", - " (2025, 9): 6.128473162651062,\n", - " (2025, 10): 35.65379452705383,\n", - " (2025, 11): 203.18541610240936,\n", - " (2025, 12): 381.0573135614395},\n", - " 'window': {(2025, 1): 81.02755403518677,\n", - " (2025, 2): 115.8754506111145,\n", - " (2025, 3): 98.14712285995483,\n", - " (2025, 4): 76.336501121521,\n", - " (2025, 5): 7.835723400115967,\n", - " (2025, 6): 8.616428852081299,\n", - " (2025, 7): 7.3764448165893555,\n", - " (2025, 8): 12.356509327888489,\n", - " (2025, 9): 3.0018885135650635,\n", - " (2025, 10): 14.656789541244507,\n", - " (2025, 11): 82.60536289215088,\n", - " (2025, 12): 94.82513332366943}},\n", - " 372: {'monthly': {(2025, 1): 250.03088986873627,\n", - " (2025, 2): 200.7722932100296,\n", - " (2025, 3): 239.86264610290527,\n", - " (2025, 4): 180.7415155172348,\n", - " (2025, 5): 14.384571075439453,\n", - " (2025, 6): 14.128893852233887,\n", - " (2025, 7): 12.400045156478882,\n", - " (2025, 8): 14.722985982894897,\n", - " (2025, 9): 1.1784154176712036,\n", - " (2025, 10): 27.04527175426483,\n", - " (2025, 11): 139.19057595729828,\n", - " (2025, 12): 282.39948749542236},\n", - " 'window': {(2025, 1): 74.984055519104,\n", - " (2025, 2): 78.93194770812988,\n", - " (2025, 3): 73.30877161026001,\n", - " (2025, 4): 51.61461925506592,\n", - " (2025, 5): 5.124765157699585,\n", - " (2025, 6): 5.858236789703369,\n", - " (2025, 7): 4.156737685203552,\n", - " (2025, 8): 7.231153726577759,\n", - " (2025, 9): 1.1784154176712036,\n", - " (2025, 10): 11.061051607131958,\n", - " (2025, 11): 73.05670118331909,\n", - " (2025, 12): 79.94560956954956}},\n", - " 373: {'monthly': {(2025, 1): 190.9708697795868,\n", - " (2025, 2): 126.08201217651367,\n", - " (2025, 3): 209.92597842216492,\n", - " (2025, 4): 127.46048724651337,\n", - " (2025, 5): 2.4272043704986572,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 1.0615803003311157,\n", - " (2025, 8): 4.901431202888489,\n", - " (2025, 9): 1.5094993114471436,\n", - " (2025, 10): 21.764520287513733,\n", - " (2025, 11): 68.70683300495148,\n", - " (2025, 12): 267.22195959091187},\n", - " 'window': {(2025, 1): 60.69397735595703,\n", - " (2025, 2): 64.34796619415283,\n", - " (2025, 3): 56.39811301231384,\n", - " (2025, 4): 45.33382034301758,\n", - " (2025, 5): 1.3102604150772095,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 1.0615803003311157,\n", - " (2025, 8): 3.601310610771179,\n", - " (2025, 9): 1.5094993114471436,\n", - " (2025, 10): 11.130811333656311,\n", - " (2025, 11): 36.58718967437744,\n", - " (2025, 12): 90.7494478225708}},\n", - " 374: {'monthly': {(2025, 1): 174.47860050201416,\n", - " (2025, 2): 118.66976809501648,\n", - " (2025, 3): 217.8259608745575,\n", - " (2025, 4): 126.73612952232361,\n", - " (2025, 5): 2.3639103174209595,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 1.0264699459075928,\n", - " (2025, 8): 5.556495189666748,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 26.828125596046448,\n", - " (2025, 11): 71.32172644138336,\n", - " (2025, 12): 244.5533059835434},\n", - " 'window': {(2025, 1): 63.16068935394287,\n", - " (2025, 2): 59.783940076828,\n", - " (2025, 3): 59.3838152885437,\n", - " (2025, 4): 47.53298306465149,\n", - " (2025, 5): 1.2781919240951538,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 1.0264699459075928,\n", - " (2025, 8): 5.556495189666748,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 11.700490713119507,\n", - " (2025, 11): 42.15406799316406,\n", - " (2025, 12): 88.17700481414795}},\n", - " 375: {'monthly': {(2025, 1): 193.5778181552887,\n", - " (2025, 2): 130.10307157039642,\n", - " (2025, 3): 230.7377905845642,\n", - " (2025, 4): 127.65150344371796,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.9744393825531006,\n", - " (2025, 9): 2.4128419160842896,\n", - " (2025, 10): 28.5751633644104,\n", - " (2025, 11): 78.05602765083313,\n", - " (2025, 12): 262.249449968338},\n", - " 'window': {(2025, 1): 72.9987440109253,\n", - " (2025, 2): 66.19435405731201,\n", - " (2025, 3): 58.67351937294006,\n", - " (2025, 4): 51.55268859863281,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.9744393825531006,\n", - " (2025, 9): 2.4128419160842896,\n", - " (2025, 10): 14.077889919281006,\n", - " (2025, 11): 49.94648838043213,\n", - " (2025, 12): 81.96543312072754}},\n", - " 376: {'monthly': {(2025, 1): 196.29886162281036,\n", - " (2025, 2): 145.1672818660736,\n", - " (2025, 3): 210.15928328037262,\n", - " (2025, 4): 129.81627869606018,\n", - " (2025, 5): 1.036284327507019,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 3.0068308115005493,\n", - " (2025, 9): 1.0175144672393799,\n", - " (2025, 10): 24.380496859550476,\n", - " (2025, 11): 78.32979333400726,\n", - " (2025, 12): 270.59621381759644},\n", - " 'window': {(2025, 1): 69.55047416687012,\n", - " (2025, 2): 68.94706726074219,\n", - " (2025, 3): 51.984792709350586,\n", - " (2025, 4): 53.50243806838989,\n", - " (2025, 5): 1.036284327507019,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.9419615268707275,\n", - " (2025, 9): 1.0175144672393799,\n", - " (2025, 10): 15.602019786834717,\n", - " (2025, 11): 46.80638790130615,\n", - " (2025, 12): 78.63866472244263}},\n", - " 377: {'monthly': {(2025, 1): 198.61538195610046,\n", - " (2025, 2): 218.45865499973297,\n", - " (2025, 3): 148.24398183822632,\n", - " (2025, 4): 94.54895412921906,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.00645911693573,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 31.823432683944702,\n", - " (2025, 11): 78.07475352287292,\n", - " (2025, 12): 229.4516648054123},\n", - " 'window': {(2025, 1): 49.734185218811035,\n", - " (2025, 2): 74.71500873565674,\n", - " (2025, 3): 49.6967887878418,\n", - " (2025, 4): 36.073750734329224,\n", - " (2025, 5): 0.0,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.00645911693573,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 28.175204038619995,\n", - " (2025, 11): 35.223655462265015,\n", - " (2025, 12): 55.38017129898071}},\n", - " 378: {'monthly': {(2025, 1): 231.07091677188873,\n", - " (2025, 2): 216.30294120311737,\n", - " (2025, 3): 161.38092279434204,\n", - " (2025, 4): 154.18177592754364,\n", - " (2025, 5): 16.283695340156555,\n", - " (2025, 6): 10.194962501525879,\n", - " (2025, 7): 14.418499231338501,\n", - " (2025, 8): 12.195276975631714,\n", - " (2025, 9): 2.4130138158798218,\n", - " (2025, 10): 50.82687222957611,\n", - " (2025, 11): 167.799654006958,\n", - " (2025, 12): 311.7821650505066},\n", - " 'window': {(2025, 1): 60.385944843292236,\n", - " (2025, 2): 79.51725912094116,\n", - " (2025, 3): 42.17004084587097,\n", - " (2025, 4): 67.14297008514404,\n", - " (2025, 5): 6.587816596031189,\n", - " (2025, 6): 3.9829492568969727,\n", - " (2025, 7): 4.7564297914505005,\n", - " (2025, 8): 4.194859147071838,\n", - " (2025, 9): 2.4130138158798218,\n", - " (2025, 10): 31.383899688720703,\n", - " (2025, 11): 89.50969219207764,\n", - " (2025, 12): 94.43879079818726}},\n", - " 379: {'monthly': {(2025, 1): 266.0464686155319,\n", - " (2025, 2): 230.73045790195465,\n", - " (2025, 3): 194.0934442281723,\n", - " (2025, 4): 147.26778781414032,\n", - " (2025, 5): 15.89085566997528,\n", - " (2025, 6): 11.166421055793762,\n", - " (2025, 7): 14.672014713287354,\n", - " (2025, 8): 11.687734365463257,\n", - " (2025, 9): 2.4130138158798218,\n", - " (2025, 10): 52.01967704296112,\n", - " (2025, 11): 142.4821093082428,\n", - " (2025, 12): 349.3825750350952},\n", - " 'window': {(2025, 1): 70.57489252090454,\n", - " (2025, 2): 78.85056447982788,\n", - " (2025, 3): 50.50910139083862,\n", - " (2025, 4): 64.98169183731079,\n", - " (2025, 5): 5.074561357498169,\n", - " (2025, 6): 4.84393036365509,\n", - " (2025, 7): 4.354551315307617,\n", - " (2025, 8): 3.544361114501953,\n", - " (2025, 9): 2.4130138158798218,\n", - " (2025, 10): 41.364744901657104,\n", - " (2025, 11): 72.06166315078735,\n", - " (2025, 12): 85.3975133895874}},\n", - " 380: {'monthly': {(2025, 1): 310.5156638622284,\n", - " (2025, 2): 247.98928368091583,\n", - " (2025, 3): 167.7472734451294,\n", - " (2025, 4): 149.3473460674286,\n", - " (2025, 5): 18.990368008613586,\n", - " (2025, 6): 15.829916715621948,\n", - " (2025, 7): 14.816816926002502,\n", - " (2025, 8): 11.6680508852005,\n", - " (2025, 9): 2.4130138158798218,\n", - " (2025, 10): 58.61530673503876,\n", - " (2025, 11): 108.94403624534607,\n", - " (2025, 12): 315.49305534362793},\n", - " 'window': {(2025, 1): 76.25285577774048,\n", - " (2025, 2): 77.00897264480591,\n", - " (2025, 3): 45.42298603057861,\n", - " (2025, 4): 57.41577935218811,\n", - " (2025, 5): 8.005570888519287,\n", - " (2025, 6): 7.644568920135498,\n", - " (2025, 7): 4.343300938606262,\n", - " (2025, 8): 3.771607756614685,\n", - " (2025, 9): 2.4130138158798218,\n", - " (2025, 10): 46.255743980407715,\n", - " (2025, 11): 54.4885778427124,\n", - " (2025, 12): 77.35351943969727}},\n", - " 381: {'monthly': {(2025, 1): 298.2936962842941,\n", - " (2025, 2): 268.509388923645,\n", - " (2025, 3): 228.43611311912537,\n", - " (2025, 4): 223.91411709785461,\n", - " (2025, 5): 27.140472650527954,\n", - " (2025, 6): 22.933682441711426,\n", - " (2025, 7): 21.93891203403473,\n", - " (2025, 8): 15.77291452884674,\n", - " (2025, 9): 2.4130138158798218,\n", - " (2025, 10): 56.15457272529602,\n", - " (2025, 11): 127.47406613826752,\n", - " (2025, 12): 327.0696165561676},\n", - " 'window': {(2025, 1): 79.06937789916992,\n", - " (2025, 2): 93.03627824783325,\n", - " (2025, 3): 58.38228368759155,\n", - " (2025, 4): 77.31579399108887,\n", - " (2025, 5): 10.198040962219238,\n", - " (2025, 6): 8.760697484016418,\n", - " (2025, 7): 8.429494619369507,\n", - " (2025, 8): 4.255627632141113,\n", - " (2025, 9): 2.4130138158798218,\n", - " (2025, 10): 40.92702007293701,\n", - " (2025, 11): 53.261640310287476,\n", - " (2025, 12): 80.95828056335449}},\n", - " 382: {'monthly': {(2025, 1): 257.7962279319763,\n", - " (2025, 2): 225.92218375205994,\n", - " (2025, 3): 357.8439984321594,\n", - " (2025, 4): 316.8320869207382,\n", - " (2025, 5): 36.355135798454285,\n", - " (2025, 6): 33.89124643802643,\n", - " (2025, 7): 27.561596274375916,\n", - " (2025, 8): 13.245617032051086,\n", - " (2025, 9): 4.587637901306152,\n", - " (2025, 10): 44.984959959983826,\n", - " (2025, 11): 204.23622107505798,\n", - " (2025, 12): 346.41009068489075},\n", - " 'window': {(2025, 1): 69.58688855171204,\n", - " (2025, 2): 72.53211665153503,\n", - " (2025, 3): 84.26786613464355,\n", - " (2025, 4): 101.69560623168945,\n", - " (2025, 5): 10.546686887741089,\n", - " (2025, 6): 9.620678901672363,\n", - " (2025, 7): 7.7488768100738525,\n", - " (2025, 8): 4.4690492153167725,\n", - " (2025, 9): 3.3949657678604126,\n", - " (2025, 10): 21.07828986644745,\n", - " (2025, 11): 74.93214797973633,\n", - " (2025, 12): 79.76274013519287}},\n", - " 383: {'monthly': {(2025, 1): 391.17837619781494,\n", - " (2025, 2): 285.3013137578964,\n", - " (2025, 3): 415.7556116580963,\n", - " (2025, 4): 343.61568200588226,\n", - " (2025, 5): 33.649176239967346,\n", - " (2025, 6): 33.920204281806946,\n", - " (2025, 7): 33.30100727081299,\n", - " (2025, 8): 14.433852791786194,\n", - " (2025, 9): 5.895186424255371,\n", - " (2025, 10): 63.50515842437744,\n", - " (2025, 11): 273.5556254386902,\n", - " (2025, 12): 469.6881364583969},\n", - " 'window': {(2025, 1): 119.55551958084106,\n", - " (2025, 2): 92.43863415718079,\n", - " (2025, 3): 98.4646167755127,\n", - " (2025, 4): 111.87009048461914,\n", - " (2025, 5): 10.470070838928223,\n", - " (2025, 6): 10.542526006698608,\n", - " (2025, 7): 10.375504970550537,\n", - " (2025, 8): 5.8355406522750854,\n", - " (2025, 9): 4.702514290809631,\n", - " (2025, 10): 38.39463138580322,\n", - " (2025, 11): 98.56103324890137,\n", - " (2025, 12): 105.02932453155518}},\n", - " 384: {'monthly': {(2025, 1): 476.46192836761475,\n", - " (2025, 2): 294.9235110282898,\n", - " (2025, 3): 346.9386968612671,\n", - " (2025, 4): 259.4800612926483,\n", - " (2025, 5): 20.946521997451782,\n", - " (2025, 6): 20.67307722568512,\n", - " (2025, 7): 24.117557168006897,\n", - " (2025, 8): 11.328252077102661,\n", - " (2025, 9): 4.568082690238953,\n", - " (2025, 10): 52.70840895175934,\n", - " (2025, 11): 174.27122056484222,\n", - " (2025, 12): 449.2020021677017},\n", - " 'window': {(2025, 1): 145.53865718841553,\n", - " (2025, 2): 87.76653695106506,\n", - " (2025, 3): 89.37370681762695,\n", - " (2025, 4): 83.73335075378418,\n", - " (2025, 5): 7.858919262886047,\n", - " (2025, 6): 6.410664439201355,\n", - " (2025, 7): 7.698988437652588,\n", - " (2025, 8): 3.2463831901550293,\n", - " (2025, 9): 3.375410556793213,\n", - " (2025, 10): 26.468900680541992,\n", - " (2025, 11): 69.56246948242188,\n", - " (2025, 12): 102.78646230697632}},\n", - " 385: {'monthly': {(2025, 1): 461.8613474369049,\n", - " (2025, 2): 263.38948225975037,\n", - " (2025, 3): 270.3003703355789,\n", - " (2025, 4): 203.93700659275055,\n", - " (2025, 5): 18.724846601486206,\n", - " (2025, 6): 18.653003811836243,\n", - " (2025, 7): 13.338500022888184,\n", - " (2025, 8): 12.689044952392578,\n", - " (2025, 9): 5.225194454193115,\n", - " (2025, 10): 47.44129765033722,\n", - " (2025, 11): 148.2873593568802,\n", - " (2025, 12): 343.2974532842636},\n", - " 'window': {(2025, 1): 119.81048488616943,\n", - " (2025, 2): 79.27916526794434,\n", - " (2025, 3): 86.22765159606934,\n", - " (2025, 4): 61.702476978302,\n", - " (2025, 5): 6.699649214744568,\n", - " (2025, 6): 6.186717748641968,\n", - " (2025, 7): 5.415377140045166,\n", - " (2025, 8): 4.057913184165955,\n", - " (2025, 9): 4.0325223207473755,\n", - " (2025, 10): 23.347680807113647,\n", - " (2025, 11): 54.29101085662842,\n", - " (2025, 12): 71.98182773590088}},\n", - " 386: {'monthly': {(2025, 1): 350.8788871765137,\n", - " (2025, 2): 196.09141647815704,\n", - " (2025, 3): 234.03759098052979,\n", - " (2025, 4): 176.8900179862976,\n", - " (2025, 5): 5.69558322429657,\n", - " (2025, 6): 1.1730079650878906,\n", - " (2025, 7): 2.51191782951355,\n", - " (2025, 8): 11.035073280334473,\n", - " (2025, 9): 2.2588181495666504,\n", - " (2025, 10): 41.17009139060974,\n", - " (2025, 11): 118.66983342170715,\n", - " (2025, 12): 345.41119503974915},\n", - " 'window': {(2025, 1): 96.73036623001099,\n", - " (2025, 2): 60.07837533950806,\n", - " (2025, 3): 68.11029624938965,\n", - " (2025, 4): 66.9998459815979,\n", - " (2025, 5): 4.602330565452576,\n", - " (2025, 6): 1.1730079650878906,\n", - " (2025, 7): 1.3970112800598145,\n", - " (2025, 8): 5.583713173866272,\n", - " (2025, 9): 2.2588181495666504,\n", - " (2025, 10): 23.754924774169922,\n", - " (2025, 11): 57.12025260925293,\n", - " (2025, 12): 92.49143600463867}},\n", - " 387: {'monthly': {(2025, 1): 287.7251374721527,\n", - " (2025, 2): 174.95839989185333,\n", - " (2025, 3): 224.30960071086884,\n", - " (2025, 4): 172.39598953723907,\n", - " (2025, 5): 4.792939782142639,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 3.0148351192474365,\n", - " (2025, 8): 8.546509385108948,\n", - " (2025, 9): 2.4205353260040283,\n", - " (2025, 10): 40.14021110534668,\n", - " (2025, 11): 115.42642629146576,\n", - " (2025, 12): 347.88990592956543},\n", - " 'window': {(2025, 1): 80.65551471710205,\n", - " (2025, 2): 55.716081619262695,\n", - " (2025, 3): 64.25454473495483,\n", - " (2025, 4): 62.078969955444336,\n", - " (2025, 5): 4.792939782142639,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 1.8999285697937012,\n", - " (2025, 8): 3.290829300880432,\n", - " (2025, 9): 2.4205353260040283,\n", - " (2025, 10): 25.099390745162964,\n", - " (2025, 11): 56.04427671432495,\n", - " (2025, 12): 117.50724792480469}},\n", - " 388: {'monthly': {(2025, 1): 261.5088436603546,\n", - " (2025, 2): 162.92159259319305,\n", - " (2025, 3): 218.21910440921783,\n", - " (2025, 4): 168.4674105644226,\n", - " (2025, 5): 2.493328809738159,\n", - " (2025, 6): 1.0623255968093872,\n", - " (2025, 7): 2.3184436559677124,\n", - " (2025, 8): 6.184147357940674,\n", - " (2025, 9): 1.1053335666656494,\n", - " (2025, 10): 37.301825165748596,\n", - " (2025, 11): 127.69328737258911,\n", - " (2025, 12): 344.9006726741791},\n", - " 'window': {(2025, 1): 76.32948780059814,\n", - " (2025, 2): 50.2638463973999,\n", - " (2025, 3): 56.4324791431427,\n", - " (2025, 4): 59.726001262664795,\n", - " (2025, 5): 2.493328809738159,\n", - " (2025, 6): 1.0623255968093872,\n", - " (2025, 7): 1.203537106513977,\n", - " (2025, 8): 3.0914485454559326,\n", - " (2025, 9): 1.1053335666656494,\n", - " (2025, 10): 25.08088207244873,\n", - " (2025, 11): 59.4459924697876,\n", - " (2025, 12): 111.99756717681885}},\n", - " 389: {'monthly': {(2025, 1): 251.6860635280609,\n", - " (2025, 2): 148.50277435779572,\n", - " (2025, 3): 203.73776352405548,\n", - " (2025, 4): 156.72035670280457,\n", - " (2025, 5): 3.7148306369781494,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 2.3764772415161133,\n", - " (2025, 8): 11.171470046043396,\n", - " (2025, 9): 3.7923269271850586,\n", - " (2025, 10): 35.74516034126282,\n", - " (2025, 11): 139.19303393363953,\n", - " (2025, 12): 336.1176869869232},\n", - " 'window': {(2025, 1): 64.22639465332031,\n", - " (2025, 2): 53.14139795303345,\n", - " (2025, 3): 49.86700201034546,\n", - " (2025, 4): 57.43122434616089,\n", - " (2025, 5): 3.7148306369781494,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 1.261570692062378,\n", - " (2025, 8): 4.149776577949524,\n", - " (2025, 9): 2.481592535972595,\n", - " (2025, 10): 25.378968238830566,\n", - " (2025, 11): 64.18398332595825,\n", - " (2025, 12): 87.13084650039673}},\n", - " 390: {'monthly': {(2025, 1): 224.97601652145386,\n", - " (2025, 2): 214.55934262275696,\n", - " (2025, 3): 160.7601579427719,\n", - " (2025, 4): 78.45660495758057,\n", - " (2025, 5): 1.2183847427368164,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 2.3235769271850586,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 31.16061782836914,\n", - " (2025, 11): 96.71229445934296,\n", - " (2025, 12): 254.87840747833252},\n", - " 'window': {(2025, 1): 56.18420457839966,\n", - " (2025, 2): 81.2243721485138,\n", - " (2025, 3): 51.8992338180542,\n", - " (2025, 4): 26.42030906677246,\n", - " (2025, 5): 1.2183847427368164,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 2.3235769271850586,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 27.313320636749268,\n", - " (2025, 11): 43.98102903366089,\n", - " (2025, 12): 58.201335430145264}},\n", - " 391: {'monthly': {(2025, 1): 240.7997703552246,\n", - " (2025, 2): 209.84111297130585,\n", - " (2025, 3): 164.1997106075287,\n", - " (2025, 4): 133.9286413192749,\n", - " (2025, 5): 16.607356786727905,\n", - " (2025, 6): 10.194962501525879,\n", - " (2025, 7): 13.713058948516846,\n", - " (2025, 8): 13.641526937484741,\n", - " (2025, 9): 2.4130138158798218,\n", - " (2025, 10): 45.8912878036499,\n", - " (2025, 11): 154.49251925945282,\n", - " (2025, 12): 334.4311034679413},\n", - " 'window': {(2025, 1): 59.93890118598938,\n", - " (2025, 2): 71.43061685562134,\n", - " (2025, 3): 49.057748794555664,\n", - " (2025, 4): 43.61038541793823,\n", - " (2025, 5): 5.380657315254211,\n", - " (2025, 6): 3.9829492568969727,\n", - " (2025, 7): 4.7564297914505005,\n", - " (2025, 8): 4.194859147071838,\n", - " (2025, 9): 2.4130138158798218,\n", - " (2025, 10): 34.560946583747864,\n", - " (2025, 11): 95.49854969978333,\n", - " (2025, 12): 104.60519671440125}},\n", - " 392: {'monthly': {(2025, 1): 296.85014176368713,\n", - " (2025, 2): 242.7622356414795,\n", - " (2025, 3): 229.10794627666473,\n", - " (2025, 4): 164.30954146385193,\n", - " (2025, 5): 23.56030261516571,\n", - " (2025, 6): 15.402674794197083,\n", - " (2025, 7): 22.037206053733826,\n", - " (2025, 8): 13.21151053905487,\n", - " (2025, 9): 3.6154028177261353,\n", - " (2025, 10): 57.07131767272949,\n", - " (2025, 11): 178.7104867696762,\n", - " (2025, 12): 408.5209176540375},\n", - " 'window': {(2025, 1): 72.18673706054688,\n", - " (2025, 2): 87.9067873954773,\n", - " (2025, 3): 67.17247343063354,\n", - " (2025, 4): 52.738234519958496,\n", - " (2025, 5): 8.6391841173172,\n", - " (2025, 6): 7.082080960273743,\n", - " (2025, 7): 6.503608226776123,\n", - " (2025, 8): 5.042662739753723,\n", - " (2025, 9): 2.4772658348083496,\n", - " (2025, 10): 42.84762525558472,\n", - " (2025, 11): 82.97522735595703,\n", - " (2025, 12): 110.57083892822266}},\n", - " 393: {'monthly': {(2025, 1): 333.2174462080002,\n", - " (2025, 2): 287.61054265499115,\n", - " (2025, 3): 213.2156252861023,\n", - " (2025, 4): 193.24943912029266,\n", - " (2025, 5): 34.86786115169525,\n", - " (2025, 6): 31.16672146320343,\n", - " (2025, 7): 30.923964500427246,\n", - " (2025, 8): 26.369957327842712,\n", - " (2025, 9): 2.610819101333618,\n", - " (2025, 10): 68.8745813369751,\n", - " (2025, 11): 163.67553865909576,\n", - " (2025, 12): 360.8512456417084},\n", - " 'window': {(2025, 1): 80.15904808044434,\n", - " (2025, 2): 120.02829027175903,\n", - " (2025, 3): 61.62597322463989,\n", - " (2025, 4): 69.0963807106018,\n", - " (2025, 5): 13.513004064559937,\n", - " (2025, 6): 13.822993755340576,\n", - " (2025, 7): 9.513137578964233,\n", - " (2025, 8): 8.176844596862793,\n", - " (2025, 9): 2.610819101333618,\n", - " (2025, 10): 50.838653802871704,\n", - " (2025, 11): 67.7097897529602,\n", - " (2025, 12): 88.16865730285645}},\n", - " 394: {'monthly': {(2025, 1): 354.56494641304016,\n", - " (2025, 2): 382.91584503650665,\n", - " (2025, 3): 393.2063744068146,\n", - " (2025, 4): 382.7973304986954,\n", - " (2025, 5): 76.29580008983612,\n", - " (2025, 6): 58.96752107143402,\n", - " (2025, 7): 55.27305519580841,\n", - " (2025, 8): 41.95960330963135,\n", - " (2025, 9): 7.563060641288757,\n", - " (2025, 10): 78.0889823436737,\n", - " (2025, 11): 258.2030841112137,\n", - " (2025, 12): 436.7881968021393},\n", - " 'window': {(2025, 1): 93.3132734298706,\n", - " (2025, 2): 174.28564548492432,\n", - " (2025, 3): 106.08757972717285,\n", - " (2025, 4): 126.47256088256836,\n", - " (2025, 5): 22.749349355697632,\n", - " (2025, 6): 21.655037760734558,\n", - " (2025, 7): 16.875603914260864,\n", - " (2025, 8): 12.385785579681396,\n", - " (2025, 9): 4.301733613014221,\n", - " (2025, 10): 50.061583518981934,\n", - " (2025, 11): 92.10174369812012,\n", - " (2025, 12): 113.70588684082031}},\n", - " 395: {'monthly': {(2025, 1): 355.5053608417511,\n", - " (2025, 2): 301.50758492946625,\n", - " (2025, 3): 582.2294985055923,\n", - " (2025, 4): 554.7850911617279,\n", - " (2025, 5): 92.64899361133575,\n", - " (2025, 6): 76.67168307304382,\n", - " (2025, 7): 67.54299867153168,\n", - " (2025, 8): 34.15017259120941,\n", - " (2025, 9): 13.168334484100342,\n", - " (2025, 10): 100.35373067855835,\n", - " (2025, 11): 415.4584513902664,\n", - " (2025, 12): 509.9376358985901},\n", - " 'window': {(2025, 1): 97.04608011245728,\n", - " (2025, 2): 103.32465028762817,\n", - " (2025, 3): 152.0138339996338,\n", - " (2025, 4): 169.3810806274414,\n", - " (2025, 5): 22.053616046905518,\n", - " (2025, 6): 18.41497254371643,\n", - " (2025, 7): 16.493852615356445,\n", - " (2025, 8): 10.685696840286255,\n", - " (2025, 9): 9.225747346878052,\n", - " (2025, 10): 34.0939245223999,\n", - " (2025, 11): 139.05353164672852,\n", - " (2025, 12): 118.42790412902832}},\n", - " 396: {'monthly': {(2025, 1): 467.6045322418213,\n", - " (2025, 2): 338.79711878299713,\n", - " (2025, 3): 485.8867073059082,\n", - " (2025, 4): 408.8932423591614,\n", - " (2025, 5): 66.14436507225037,\n", - " (2025, 6): 55.898345708847046,\n", - " (2025, 7): 66.35297548770905,\n", - " (2025, 8): 28.96527338027954,\n", - " (2025, 9): 15.864006876945496,\n", - " (2025, 10): 79.43560898303986,\n", - " (2025, 11): 280.8435559272766,\n", - " (2025, 12): 519.2977981567383},\n", - " 'window': {(2025, 1): 127.37147426605225,\n", - " (2025, 2): 114.57932043075562,\n", - " (2025, 3): 133.2949562072754,\n", - " (2025, 4): 126.17009544372559,\n", - " (2025, 5): 15.723801016807556,\n", - " (2025, 6): 13.644424319267273,\n", - " (2025, 7): 16.809112548828125,\n", - " (2025, 8): 7.874809741973877,\n", - " (2025, 9): 7.983707427978516,\n", - " (2025, 10): 32.64430356025696,\n", - " (2025, 11): 98.67273426055908,\n", - " (2025, 12): 118.52516746520996}},\n", - " 397: {'monthly': {(2025, 1): 565.9381601810455,\n", - " (2025, 2): 343.2484749555588,\n", - " (2025, 3): 350.9908608198166,\n", - " (2025, 4): 237.2973816394806,\n", - " (2025, 5): 20.696468591690063,\n", - " (2025, 6): 19.559414505958557,\n", - " (2025, 7): 27.809412717819214,\n", - " (2025, 8): 10.294922113418579,\n", - " (2025, 9): 6.652248024940491,\n", - " (2025, 10): 54.845367074012756,\n", - " (2025, 11): 153.29000341892242,\n", - " (2025, 12): 459.75830340385437},\n", - " 'window': {(2025, 1): 186.05553817749023,\n", - " (2025, 2): 105.54707908630371,\n", - " (2025, 3): 94.40079593658447,\n", - " (2025, 4): 82.3903980255127,\n", - " (2025, 5): 7.068593978881836,\n", - " (2025, 6): 5.5322794914245605,\n", - " (2025, 7): 9.484804391860962,\n", - " (2025, 8): 2.813475489616394,\n", - " (2025, 9): 5.459575891494751,\n", - " (2025, 10): 27.00109887123108,\n", - " (2025, 11): 59.92936182022095,\n", - " (2025, 12): 103.26373672485352}},\n", - " 398: {'monthly': {(2025, 1): 462.73522663116455,\n", - " (2025, 2): 281.0292670726776,\n", - " (2025, 3): 244.77227532863617,\n", - " (2025, 4): 194.22871148586273,\n", - " (2025, 5): 16.277994751930237,\n", - " (2025, 6): 20.97016131877899,\n", - " (2025, 7): 18.48587429523468,\n", - " (2025, 8): 11.584866046905518,\n", - " (2025, 9): 5.4589293003082275,\n", - " (2025, 10): 45.26326870918274,\n", - " (2025, 11): 123.3044502735138,\n", - " (2025, 12): 381.3319728374481},\n", - " 'window': {(2025, 1): 140.77972316741943,\n", - " (2025, 2): 72.08664131164551,\n", - " (2025, 3): 61.78986120223999,\n", - " (2025, 4): 57.96299362182617,\n", - " (2025, 5): 5.660076022148132,\n", - " (2025, 6): 6.228871941566467,\n", - " (2025, 7): 5.4524266719818115,\n", - " (2025, 8): 3.5922411680221558,\n", - " (2025, 9): 4.266257166862488,\n", - " (2025, 10): 19.269838452339172,\n", - " (2025, 11): 44.590792179107666,\n", - " (2025, 12): 74.86715698242188}},\n", - " 399: {'monthly': {(2025, 1): 355.82678723335266,\n", - " (2025, 2): 195.9520034790039,\n", - " (2025, 3): 222.24040126800537,\n", - " (2025, 4): 197.1688653230667,\n", - " (2025, 5): 9.82821238040924,\n", - " (2025, 6): 3.8286256790161133,\n", - " (2025, 7): 5.869580864906311,\n", - " (2025, 8): 12.562824249267578,\n", - " (2025, 9): 4.775672674179077,\n", - " (2025, 10): 47.148078203201294,\n", - " (2025, 11): 134.31491422653198,\n", - " (2025, 12): 342.34536814689636},\n", - " 'window': {(2025, 1): 111.63439464569092,\n", - " (2025, 2): 64.11992168426514,\n", - " (2025, 3): 59.29484510421753,\n", - " (2025, 4): 78.7235255241394,\n", - " (2025, 5): 7.331501603126526,\n", - " (2025, 6): 2.683408498764038,\n", - " (2025, 7): 2.629465937614441,\n", - " (2025, 8): 5.13407301902771,\n", - " (2025, 9): 4.775672674179077,\n", - " (2025, 10): 27.519674062728882,\n", - " (2025, 11): 56.83969974517822,\n", - " (2025, 12): 72.27737236022949}},\n", - " 400: {'monthly': {(2025, 1): 305.5638188123703,\n", - " (2025, 2): 199.25328409671783,\n", - " (2025, 3): 236.02567040920258,\n", - " (2025, 4): 189.29608726501465,\n", - " (2025, 5): 7.723406910896301,\n", - " (2025, 6): 1.1582361459732056,\n", - " (2025, 7): 3.155538558959961,\n", - " (2025, 8): 12.024138927459717,\n", - " (2025, 9): 2.5266382694244385,\n", - " (2025, 10): 48.076107025146484,\n", - " (2025, 11): 142.70574951171875,\n", - " (2025, 12): 359.00554966926575},\n", - " 'window': {(2025, 1): 92.06377696990967,\n", - " (2025, 2): 62.14388561248779,\n", - " (2025, 3): 63.22378849983215,\n", - " (2025, 4): 73.91641044616699,\n", - " (2025, 5): 6.603335380554199,\n", - " (2025, 6): 1.1582361459732056,\n", - " (2025, 7): 1.7370669841766357,\n", - " (2025, 8): 4.456546425819397,\n", - " (2025, 9): 2.5266382694244385,\n", - " (2025, 10): 32.52628564834595,\n", - " (2025, 11): 63.52074337005615,\n", - " (2025, 12): 88.68811988830566}},\n", - " 401: {'monthly': {(2025, 1): 243.09205603599548,\n", - " (2025, 2): 164.25001180171967,\n", - " (2025, 3): 214.45814871788025,\n", - " (2025, 4): 169.7138501405716,\n", - " (2025, 5): 3.686258912086487,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 2.5349897146224976,\n", - " (2025, 8): 9.759286403656006,\n", - " (2025, 9): 2.101896047592163,\n", - " (2025, 10): 41.302507400512695,\n", - " (2025, 11): 152.86406767368317,\n", - " (2025, 12): 371.2418472766876},\n", - " 'window': {(2025, 1): 74.16859674453735,\n", - " (2025, 2): 56.62972927093506,\n", - " (2025, 3): 55.34231615066528,\n", - " (2025, 4): 60.37463855743408,\n", - " (2025, 5): 3.686258912086487,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 1.3368600606918335,\n", - " (2025, 8): 3.2271465063095093,\n", - " (2025, 9): 2.101896047592163,\n", - " (2025, 10): 29.19648265838623,\n", - " (2025, 11): 65.23110246658325,\n", - " (2025, 12): 93.00543689727783}},\n", - " 402: {'monthly': {(2025, 1): 239.2978047132492,\n", - " (2025, 2): 149.37322771549225,\n", - " (2025, 3): 227.9884456396103,\n", - " (2025, 4): 178.38176476955414,\n", - " (2025, 5): 6.8932865858078,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 3.3500595092773438,\n", - " (2025, 8): 10.555311918258667,\n", - " (2025, 9): 1.0969375371932983,\n", - " (2025, 10): 37.93116629123688,\n", - " (2025, 11): 180.85913360118866,\n", - " (2025, 12): 433.26015877723694},\n", - " 'window': {(2025, 1): 57.17016935348511,\n", - " (2025, 2): 55.16425180435181,\n", - " (2025, 3): 51.23664903640747,\n", - " (2025, 4): 59.02246332168579,\n", - " (2025, 5): 6.8932865858078,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 2.2351529598236084,\n", - " (2025, 8): 3.62262499332428,\n", - " (2025, 9): 1.0969375371932983,\n", - " (2025, 10): 26.362661123275757,\n", - " (2025, 11): 76.0906171798706,\n", - " (2025, 12): 117.390540599823}},\n", - " 403: {'monthly': {(2025, 1): 254.18936419487,\n", - " (2025, 2): 231.3016574382782,\n", - " (2025, 3): 186.58811902999878,\n", - " (2025, 4): 97.16258442401886,\n", - " (2025, 5): 2.25938081741333,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 2.0686382055282593,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 32.78262460231781,\n", - " (2025, 11): 126.84588086605072,\n", - " (2025, 12): 274.03899919986725},\n", - " 'window': {(2025, 1): 61.997509479522705,\n", - " (2025, 2): 90.13284087181091,\n", - " (2025, 3): 62.12247323989868,\n", - " (2025, 4): 38.84200310707092,\n", - " (2025, 5): 1.2162343263626099,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 0.0,\n", - " (2025, 8): 1.0621790885925293,\n", - " (2025, 9): 0.0,\n", - " (2025, 10): 27.95562744140625,\n", - " (2025, 11): 52.34778308868408,\n", - " (2025, 12): 59.841177463531494}},\n", - " 404: {'monthly': {(2025, 1): 299.38086223602295,\n", - " (2025, 2): 245.44617664813995,\n", - " (2025, 3): 222.3202941417694,\n", - " (2025, 4): 139.8767228126526,\n", - " (2025, 5): 14.127295732498169,\n", - " (2025, 6): 10.194962501525879,\n", - " (2025, 7): 12.573134541511536,\n", - " (2025, 8): 13.351259708404541,\n", - " (2025, 9): 2.4130138158798218,\n", - " (2025, 10): 52.60688602924347,\n", - " (2025, 11): 154.10416507720947,\n", - " (2025, 12): 364.9497609138489},\n", - " 'window': {(2025, 1): 67.17158889770508,\n", - " (2025, 2): 83.23309183120728,\n", - " (2025, 3): 60.32758331298828,\n", - " (2025, 4): 43.462533950805664,\n", - " (2025, 5): 5.471682548522949,\n", - " (2025, 6): 3.9829492568969727,\n", - " (2025, 7): 4.7564297914505005,\n", - " (2025, 8): 4.194859147071838,\n", - " (2025, 9): 2.4130138158798218,\n", - " (2025, 10): 40.268171072006226,\n", - " (2025, 11): 78.96282291412354,\n", - " (2025, 12): 99.41267967224121}},\n", - " 405: {'monthly': {(2025, 1): 354.8193016052246,\n", - " (2025, 2): 323.7331368923187,\n", - " (2025, 3): 254.68063509464264,\n", - " (2025, 4): 161.94227862358093,\n", - " (2025, 5): 23.40894079208374,\n", - " (2025, 6): 14.501789331436157,\n", - " (2025, 7): 16.62921452522278,\n", - " (2025, 8): 13.264527916908264,\n", - " (2025, 9): 2.4130138158798218,\n", - " (2025, 10): 62.21217739582062,\n", - " (2025, 11): 173.97357642650604,\n", - " (2025, 12): 420.76130294799805},\n", - " 'window': {(2025, 1): 88.59060573577881,\n", - " (2025, 2): 128.10218572616577,\n", - " (2025, 3): 65.14392566680908,\n", - " (2025, 4): 44.40492248535156,\n", - " (2025, 5): 8.261230707168579,\n", - " (2025, 6): 7.617008447647095,\n", - " (2025, 7): 5.566766858100891,\n", - " (2025, 8): 5.336414456367493,\n", - " (2025, 9): 2.4130138158798218,\n", - " (2025, 10): 46.6803343296051,\n", - " (2025, 11): 69.54879093170166,\n", - " (2025, 12): 95.41789245605469}},\n", - " 406: {'monthly': {(2025, 1): 366.30227303504944,\n", - " (2025, 2): 424.11259829998016,\n", - " (2025, 3): 300.9990954399109,\n", - " (2025, 4): 233.36751341819763,\n", - " (2025, 5): 46.222063422203064,\n", - " (2025, 6): 34.31216824054718,\n", - " (2025, 7): 42.00081193447113,\n", - " (2025, 8): 28.759934306144714,\n", - " (2025, 9): 4.190047264099121,\n", - " (2025, 10): 83.43315660953522,\n", - " (2025, 11): 226.83684873580933,\n", - " (2025, 12): 421.54533553123474},\n", - " 'window': {(2025, 1): 92.74876689910889,\n", - " (2025, 2): 205.11436223983765,\n", - " (2025, 3): 80.04812955856323,\n", - " (2025, 4): 75.32588577270508,\n", - " (2025, 5): 16.14086639881134,\n", - " (2025, 6): 16.308903217315674,\n", - " (2025, 7): 13.949517488479614,\n", - " (2025, 8): 10.730651140213013,\n", - " (2025, 9): 3.1436041593551636,\n", - " (2025, 10): 59.311569690704346,\n", - " (2025, 11): 75.91806554794312,\n", - " (2025, 12): 102.71928977966309}},\n", - " 407: {'monthly': {(2025, 1): 491.77433729171753,\n", - " (2025, 2): 572.0660707950592,\n", - " (2025, 3): 671.8859686851501,\n", - " (2025, 4): 481.853214263916,\n", - " (2025, 5): 83.13158166408539,\n", - " (2025, 6): 67.16237795352936,\n", - " (2025, 7): 72.24452209472656,\n", - " (2025, 8): 63.66916525363922,\n", - " (2025, 9): 18.31210994720459,\n", - " (2025, 10): 161.02284216880798,\n", - " (2025, 11): 559.92651450634,\n", - " (2025, 12): 762.4012155532837},\n", - " 'window': {(2025, 1): 130.3943920135498,\n", - " (2025, 2): 265.15396785736084,\n", - " (2025, 3): 222.42023849487305,\n", - " (2025, 4): 174.73240661621094,\n", - " (2025, 5): 26.858149528503418,\n", - " (2025, 6): 24.784082770347595,\n", - " (2025, 7): 20.953983545303345,\n", - " (2025, 8): 18.0940682888031,\n", - " (2025, 9): 8.381268858909607,\n", - " (2025, 10): 98.21109294891357,\n", - " (2025, 11): 209.22037601470947,\n", - " (2025, 12): 226.99978256225586}},\n", - " 408: {'monthly': {(2025, 1): 613.8615343570709,\n", - " (2025, 2): 435.1833156347275,\n", - " (2025, 3): 883.5505397319794,\n", - " (2025, 4): 615.4725494384766,\n", - " (2025, 5): 72.63853108882904,\n", - " (2025, 6): 59.08660161495209,\n", - " (2025, 7): 59.499752044677734,\n", - " (2025, 8): 32.889089941978455,\n", - " (2025, 9): 31.11838161945343,\n", - " (2025, 10): 259.56393337249756,\n", - " (2025, 11): 859.4149811267853,\n", - " (2025, 12): 930.93590259552},\n", - " 'window': {(2025, 1): 215.56957387924194,\n", - " (2025, 2): 131.04236698150635,\n", - " (2025, 3): 276.6141948699951,\n", - " (2025, 4): 219.77350330352783,\n", - " (2025, 5): 17.67239487171173,\n", - " (2025, 6): 15.065851926803589,\n", - " (2025, 7): 16.190764546394348,\n", - " (2025, 8): 13.619393467903137,\n", - " (2025, 9): 18.852929830551147,\n", - " (2025, 10): 111.92443656921387,\n", - " (2025, 11): 314.5996627807617,\n", - " (2025, 12): 253.16868591308594}},\n", - " 409: {'monthly': {(2025, 1): 483.91788053512573,\n", - " (2025, 2): 350.41464924812317,\n", - " (2025, 3): 429.45069539546967,\n", - " (2025, 4): 286.01554334163666,\n", - " (2025, 5): 36.123600244522095,\n", - " (2025, 6): 36.44575774669647,\n", - " (2025, 7): 39.048909425735474,\n", - " (2025, 8): 24.275952458381653,\n", - " (2025, 9): 14.397498607635498,\n", - " (2025, 10): 86.69754946231842,\n", - " (2025, 11): 243.68934881687164,\n", - " (2025, 12): 492.54477167129517},\n", - " 'window': {(2025, 1): 109.58393859863281,\n", - " (2025, 2): 93.55229997634888,\n", - " (2025, 3): 127.19887161254883,\n", - " (2025, 4): 98.3794469833374,\n", - " (2025, 5): 10.7858247756958,\n", - " (2025, 6): 10.235669136047363,\n", - " (2025, 7): 12.214689135551453,\n", - " (2025, 8): 8.46385407447815,\n", - " (2025, 9): 10.429011821746826,\n", - " (2025, 10): 42.51486682891846,\n", - " (2025, 11): 79.6553544998169,\n", - " (2025, 12): 122.03628540039062}},\n", - " 410: {'monthly': {(2025, 1): 455.59031093120575,\n", - " (2025, 2): 305.17256903648376,\n", - " (2025, 3): 279.9323251247406,\n", - " (2025, 4): 175.00031793117523,\n", - " (2025, 5): 16.447497844696045,\n", - " (2025, 6): 22.75003957748413,\n", - " (2025, 7): 23.73805809020996,\n", - " (2025, 8): 9.067349553108215,\n", - " (2025, 9): 7.0960575342178345,\n", - " (2025, 10): 55.20582175254822,\n", - " (2025, 11): 128.53297328948975,\n", - " (2025, 12): 349.0376546382904},\n", - " 'window': {(2025, 1): 125.47527694702148,\n", - " (2025, 2): 91.39430284500122,\n", - " (2025, 3): 84.64488554000854,\n", - " (2025, 4): 68.11235523223877,\n", - " (2025, 5): 6.005581021308899,\n", - " (2025, 6): 6.624374866485596,\n", - " (2025, 7): 7.842519521713257,\n", - " (2025, 8): 2.8273340463638306,\n", - " (2025, 9): 5.903385400772095,\n", - " (2025, 10): 27.08542823791504,\n", - " (2025, 11): 50.621541023254395,\n", - " (2025, 12): 83.20463275909424}},\n", - " 411: {'monthly': {(2025, 1): 383.65081465244293,\n", - " (2025, 2): 236.28188633918762,\n", - " (2025, 3): 217.6882359981537,\n", - " (2025, 4): 169.2646118402481,\n", - " (2025, 5): 19.509973764419556,\n", - " (2025, 6): 21.39169716835022,\n", - " (2025, 7): 18.992087721824646,\n", - " (2025, 8): 9.853768467903137,\n", - " (2025, 9): 6.237155199050903,\n", - " (2025, 10): 54.23588240146637,\n", - " (2025, 11): 148.9701635837555,\n", - " (2025, 12): 306.7758071422577},\n", - " 'window': {(2025, 1): 95.06451964378357,\n", - " (2025, 2): 69.37361860275269,\n", - " (2025, 3): 57.104408740997314,\n", - " (2025, 4): 50.21376419067383,\n", - " (2025, 5): 7.5769267082214355,\n", - " (2025, 6): 6.624374866485596,\n", - " (2025, 7): 5.460999250411987,\n", - " (2025, 8): 2.8273340463638306,\n", - " (2025, 9): 4.106441855430603,\n", - " (2025, 10): 26.607850909233093,\n", - " (2025, 11): 69.47737503051758,\n", - " (2025, 12): 77.0082483291626}},\n", - " 412: {'monthly': {(2025, 1): 277.45689165592194,\n", - " (2025, 2): 194.06958281993866,\n", - " (2025, 3): 203.2811998128891,\n", - " (2025, 4): 169.331529378891,\n", - " (2025, 5): 8.988017320632935,\n", - " (2025, 6): 4.345837354660034,\n", - " (2025, 7): 4.764255881309509,\n", - " (2025, 8): 12.513350248336792,\n", - " (2025, 9): 4.403639197349548,\n", - " (2025, 10): 47.55850350856781,\n", - " (2025, 11): 124.33581066131592,\n", - " (2025, 12): 307.63446068763733},\n", - " 'window': {(2025, 1): 68.9903507232666,\n", - " (2025, 2): 73.41093397140503,\n", - " (2025, 3): 52.5990207195282,\n", - " (2025, 4): 62.08971691131592,\n", - " (2025, 5): 6.826449513435364,\n", - " (2025, 6): 2.249698281288147,\n", - " (2025, 7): 2.099519968032837,\n", - " (2025, 8): 4.460544228553772,\n", - " (2025, 9): 3.2276958227157593,\n", - " (2025, 10): 28.23025345802307,\n", - " (2025, 11): 51.40819454193115,\n", - " (2025, 12): 67.87171936035156}},\n", - " 413: {'monthly': {(2025, 1): 269.0160758495331,\n", - " (2025, 2): 210.47857999801636,\n", - " (2025, 3): 215.2943366765976,\n", - " (2025, 4): 172.52093172073364,\n", - " (2025, 5): 7.870326042175293,\n", - " (2025, 6): 1.0038779973983765,\n", - " (2025, 7): 3.125373363494873,\n", - " (2025, 8): 11.839638710021973,\n", - " (2025, 9): 5.8096678256988525,\n", - " (2025, 10): 55.4024156332016,\n", - " (2025, 11): 138.88774621486664,\n", - " (2025, 12): 338.41129517555237},\n", - " 'window': {(2025, 1): 65.47385239601135,\n", - " (2025, 2): 72.56419467926025,\n", - " (2025, 3): 58.61038398742676,\n", - " (2025, 4): 64.35157489776611,\n", - " (2025, 5): 6.869829893112183,\n", - " (2025, 6): 1.0038779973983765,\n", - " (2025, 7): 1.6123050451278687,\n", - " (2025, 8): 4.434280872344971,\n", - " (2025, 9): 3.3226197957992554,\n", - " (2025, 10): 36.780306339263916,\n", - " (2025, 11): 59.13389539718628,\n", - " (2025, 12): 88.8672924041748}},\n", - " 414: {'monthly': {(2025, 1): 204.31328582763672,\n", - " (2025, 2): 154.09993946552277,\n", - " (2025, 3): 182.02355873584747,\n", - " (2025, 4): 150.42681968212128,\n", - " (2025, 5): 3.593656897544861,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 2.3024041652679443,\n", - " (2025, 8): 9.208372354507446,\n", - " (2025, 9): 2.1426111459732056,\n", - " (2025, 10): 51.21708607673645,\n", - " (2025, 11): 149.95634245872498,\n", - " (2025, 12): 357.03613662719727},\n", - " 'window': {(2025, 1): 60.12075138092041,\n", - " (2025, 2): 58.01303577423096,\n", - " (2025, 3): 50.15891933441162,\n", - " (2025, 4): 54.08638334274292,\n", - " (2025, 5): 3.593656897544861,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 1.187497615814209,\n", - " (2025, 8): 3.680224061012268,\n", - " (2025, 9): 2.1426111459732056,\n", - " (2025, 10): 38.08528661727905,\n", - " (2025, 11): 66.5711030960083,\n", - " (2025, 12): 109.40855312347412}},\n", - " 415: {'monthly': {(2025, 1): 206.51742339134216,\n", - " (2025, 2): 131.2409154176712,\n", - " (2025, 3): 220.46432518959045,\n", - " (2025, 4): 195.14668118953705,\n", - " (2025, 5): 8.412850141525269,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 2.4064736366271973,\n", - " (2025, 8): 10.191485285758972,\n", - " (2025, 9): 2.576338291168213,\n", - " (2025, 10): 54.98588848114014,\n", - " (2025, 11): 189.23437213897705,\n", - " (2025, 12): 461.7531671524048},\n", - " 'window': {(2025, 1): 49.119667530059814,\n", - " (2025, 2): 42.909321546554565,\n", - " (2025, 3): 53.80614471435547,\n", - " (2025, 4): 69.42295742034912,\n", - " (2025, 5): 7.175348877906799,\n", - " (2025, 6): 0.0,\n", - " (2025, 7): 1.291567087173462,\n", - " (2025, 8): 4.5682114362716675,\n", - " (2025, 9): 2.576338291168213,\n", - " (2025, 10): 38.85197114944458,\n", - " (2025, 11): 80.72614336013794,\n", - " (2025, 12): 136.3961420059204}}}" + "{0: {'monthly': {(2060, 1): 226.96152710914612,\n", + " (2060, 2): 124.3744535446167,\n", + " (2060, 3): 90.96145176887512,\n", + " (2060, 4): 9.36989939212799,\n", + " (2060, 5): 25.046352744102478,\n", + " (2060, 6): 10.713938355445862,\n", + " (2060, 7): 18.632468700408936,\n", + " (2060, 8): 1.0678205490112305,\n", + " (2060, 9): 2.5074692964553833,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 26.961543679237366,\n", + " (2060, 12): 104.91223645210266},\n", + " 'window': {(2060, 1): 77.14203262329102,\n", + " (2060, 2): 79.23258972167969,\n", + " (2060, 3): 48.64540672302246,\n", + " (2060, 4): 4.174747824668884,\n", + " (2060, 5): 14.284469962120056,\n", + " (2060, 6): 6.319235682487488,\n", + " (2060, 7): 5.872297644615173,\n", + " (2060, 8): 1.0678205490112305,\n", + " (2060, 9): 2.5074692964553833,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 16.081406712532043,\n", + " (2060, 12): 58.407888531684875}},\n", + " 1: {'monthly': {(2060, 1): 232.35974085330963,\n", + " (2060, 2): 75.740971326828,\n", + " (2060, 3): 77.16537415981293,\n", + " (2060, 4): 35.2058801651001,\n", + " (2060, 5): 20.848549485206604,\n", + " (2060, 6): 18.671294331550598,\n", + " (2060, 7): 30.983839988708496,\n", + " (2060, 8): 2.125838279724121,\n", + " (2060, 9): 4.514179110527039,\n", + " (2060, 10): 1.1900677680969238,\n", + " (2060, 11): 17.78669571876526,\n", + " (2060, 12): 104.04975295066833},\n", + " 'window': {(2060, 1): 64.10760974884033,\n", + " (2060, 2): 43.244322299957275,\n", + " (2060, 3): 41.8435161113739,\n", + " (2060, 4): 24.879087805747986,\n", + " (2060, 5): 11.733335733413696,\n", + " (2060, 6): 5.289789438247681,\n", + " (2060, 7): 11.26254153251648,\n", + " (2060, 8): 2.125838279724121,\n", + " (2060, 9): 2.4989174604415894,\n", + " (2060, 10): 1.1900677680969238,\n", + " (2060, 11): 10.059302568435669,\n", + " (2060, 12): 57.6496262550354}},\n", + " 2: {'monthly': {(2060, 1): 215.54489529132843,\n", + " (2060, 2): 72.45866417884827,\n", + " (2060, 3): 76.15609204769135,\n", + " (2060, 4): 30.27928400039673,\n", + " (2060, 5): 19.188584446907043,\n", + " (2060, 6): 18.671294331550598,\n", + " (2060, 7): 28.5977041721344,\n", + " (2060, 8): 2.125838279724121,\n", + " (2060, 9): 4.514179110527039,\n", + " (2060, 10): 1.1900677680969238,\n", + " (2060, 11): 13.499667763710022,\n", + " (2060, 12): 94.55657601356506},\n", + " 'window': {(2060, 1): 56.223580837249756,\n", + " (2060, 2): 38.56722688674927,\n", + " (2060, 3): 36.09107220172882,\n", + " (2060, 4): 19.95258665084839,\n", + " (2060, 5): 10.073370695114136,\n", + " (2060, 6): 5.289789438247681,\n", + " (2060, 7): 10.401625633239746,\n", + " (2060, 8): 2.125838279724121,\n", + " (2060, 9): 2.4989174604415894,\n", + " (2060, 10): 1.1900677680969238,\n", + " (2060, 11): 9.91181218624115,\n", + " (2060, 12): 55.72283458709717}},\n", + " 3: {'monthly': {(2060, 1): 225.9303376674652,\n", + " (2060, 2): 75.87268960475922,\n", + " (2060, 3): 73.4968456029892,\n", + " (2060, 4): 27.31887149810791,\n", + " (2060, 5): 17.690482258796692,\n", + " (2060, 6): 18.671294331550598,\n", + " (2060, 7): 30.067601680755615,\n", + " (2060, 8): 3.1992900371551514,\n", + " (2060, 9): 4.514179110527039,\n", + " (2060, 10): 3.258257746696472,\n", + " (2060, 11): 12.724978566169739,\n", + " (2060, 12): 89.04957377910614},\n", + " 'window': {(2060, 1): 65.52614116668701,\n", + " (2060, 2): 35.17914915084839,\n", + " (2060, 3): 33.312012910842896,\n", + " (2060, 4): 16.511893033981323,\n", + " (2060, 5): 8.575268507003784,\n", + " (2060, 6): 5.289789438247681,\n", + " (2060, 7): 12.334270477294922,\n", + " (2060, 8): 3.1992900371551514,\n", + " (2060, 9): 2.4989174604415894,\n", + " (2060, 10): 2.0681899785995483,\n", + " (2060, 11): 9.347459435462952,\n", + " (2060, 12): 51.94138193130493}},\n", + " 4: {'monthly': {(2060, 1): 240.4055531024933,\n", + " (2060, 2): 69.19559860229492,\n", + " (2060, 3): 72.13977015018463,\n", + " (2060, 4): 31.818047404289246,\n", + " (2060, 5): 17.27072048187256,\n", + " (2060, 6): 19.70599889755249,\n", + " (2060, 7): 30.356138110160828,\n", + " (2060, 8): 2.125838279724121,\n", + " (2060, 9): 4.514179110527039,\n", + " (2060, 10): 1.1900677680969238,\n", + " (2060, 11): 15.067672848701477,\n", + " (2060, 12): 87.75210726261139},\n", + " 'window': {(2060, 1): 73.08864307403564,\n", + " (2060, 2): 34.44388198852539,\n", + " (2060, 3): 29.105742812156677,\n", + " (2060, 4): 20.24230408668518,\n", + " (2060, 5): 7.261478662490845,\n", + " (2060, 6): 5.289789438247681,\n", + " (2060, 7): 12.737078428268433,\n", + " (2060, 8): 2.125838279724121,\n", + " (2060, 9): 2.4989174604415894,\n", + " (2060, 10): 1.1900677680969238,\n", + " (2060, 11): 9.992488026618958,\n", + " (2060, 12): 44.10278558731079}},\n", + " 5: {'monthly': {(2060, 1): 233.85064482688904,\n", + " (2060, 2): 72.70675826072693,\n", + " (2060, 3): 75.96139395236969,\n", + " (2060, 4): 30.414944887161255,\n", + " (2060, 5): 18.32574450969696,\n", + " (2060, 6): 18.314934372901917,\n", + " (2060, 7): 33.44579017162323,\n", + " (2060, 8): 2.161451578140259,\n", + " (2060, 9): 2.526943325996399,\n", + " (2060, 10): 1.2444792985916138,\n", + " (2060, 11): 10.720296621322632,\n", + " (2060, 12): 92.92805922031403},\n", + " 'window': {(2060, 1): 68.39251899719238,\n", + " (2060, 2): 40.709330797195435,\n", + " (2060, 3): 29.49700164794922,\n", + " (2060, 4): 19.41972815990448,\n", + " (2060, 5): 5.4995410442352295,\n", + " (2060, 6): 5.356611490249634,\n", + " (2060, 7): 14.239262819290161,\n", + " (2060, 8): 2.161451578140259,\n", + " (2060, 9): 1.4979941844940186,\n", + " (2060, 10): 1.2444792985916138,\n", + " (2060, 11): 8.515749335289001,\n", + " (2060, 12): 63.367172956466675}},\n", + " 6: {'monthly': {(2060, 1): 216.01185750961304,\n", + " (2060, 2): 70.1438399553299,\n", + " (2060, 3): 81.87030816078186,\n", + " (2060, 4): 35.13857686519623,\n", + " (2060, 5): 17.00596594810486,\n", + " (2060, 6): 19.281175136566162,\n", + " (2060, 7): 33.60052418708801,\n", + " (2060, 8): 2.161451578140259,\n", + " (2060, 9): 2.526943325996399,\n", + " (2060, 10): 1.2444792985916138,\n", + " (2060, 11): 10.295323014259338,\n", + " (2060, 12): 81.7494101524353},\n", + " 'window': {(2060, 1): 60.72257375717163,\n", + " (2060, 2): 37.15285062789917,\n", + " (2060, 3): 37.07528257369995,\n", + " (2060, 4): 21.61951470375061,\n", + " (2060, 5): 5.4995410442352295,\n", + " (2060, 6): 5.356611490249634,\n", + " (2060, 7): 13.125999927520752,\n", + " (2060, 8): 2.161451578140259,\n", + " (2060, 9): 1.4979941844940186,\n", + " (2060, 10): 1.2444792985916138,\n", + " (2060, 11): 8.038140773773193,\n", + " (2060, 12): 52.07000279426575}},\n", + " 7: {'monthly': {(2060, 1): 204.01568126678467,\n", + " (2060, 2): 64.23091447353363,\n", + " (2060, 3): 85.9620064496994,\n", + " (2060, 4): 35.53431987762451,\n", + " (2060, 5): 16.917259097099304,\n", + " (2060, 6): 18.356149911880493,\n", + " (2060, 7): 30.19701051712036,\n", + " (2060, 8): 2.161451578140259,\n", + " (2060, 9): 2.526943325996399,\n", + " (2060, 10): 1.2444792985916138,\n", + " (2060, 11): 9.411099791526794,\n", + " (2060, 12): 69.83464550971985},\n", + " 'window': {(2060, 1): 58.430789947509766,\n", + " (2060, 2): 31.594899892807007,\n", + " (2060, 3): 39.89368534088135,\n", + " (2060, 4): 23.283489227294922,\n", + " (2060, 5): 5.4995410442352295,\n", + " (2060, 6): 5.356611490249634,\n", + " (2060, 7): 10.969779014587402,\n", + " (2060, 8): 2.161451578140259,\n", + " (2060, 9): 1.4979941844940186,\n", + " (2060, 10): 1.2444792985916138,\n", + " (2060, 11): 8.206862330436707,\n", + " (2060, 12): 39.95692443847656}},\n", + " 8: {'monthly': {(2060, 1): 218.36733281612396,\n", + " (2060, 2): 74.21986639499664,\n", + " (2060, 3): 84.8304101228714,\n", + " (2060, 4): 42.135818123817444,\n", + " (2060, 5): 25.29867374897003,\n", + " (2060, 6): 19.74134862422943,\n", + " (2060, 7): 35.075451135635376,\n", + " (2060, 8): 2.161451578140259,\n", + " (2060, 9): 2.526943325996399,\n", + " (2060, 10): 1.2444792985916138,\n", + " (2060, 11): 11.86556875705719,\n", + " (2060, 12): 91.18658149242401},\n", + " 'window': {(2060, 1): 70.33032321929932,\n", + " (2060, 2): 35.52470350265503,\n", + " (2060, 3): 36.038678884506226,\n", + " (2060, 4): 23.46430015563965,\n", + " (2060, 5): 7.597865104675293,\n", + " (2060, 6): 5.356611490249634,\n", + " (2060, 7): 13.836196064949036,\n", + " (2060, 8): 2.161451578140259,\n", + " (2060, 9): 1.4979941844940186,\n", + " (2060, 10): 1.2444792985916138,\n", + " (2060, 11): 8.26116955280304,\n", + " (2060, 12): 51.513901710510254}},\n", + " 9: {'monthly': {(2060, 1): 186.944664478302,\n", + " (2060, 2): 82.23486804962158,\n", + " (2060, 3): 74.69336688518524,\n", + " (2060, 4): 59.35540997982025,\n", + " (2060, 5): 43.03369903564453,\n", + " (2060, 6): 17.97312819957733,\n", + " (2060, 7): 31.327256560325623,\n", + " (2060, 8): 4.466005444526672,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 1.9822325706481934,\n", + " (2060, 11): 7.361091375350952,\n", + " (2060, 12): 131.29359698295593},\n", + " 'window': {(2060, 1): 60.14500570297241,\n", + " (2060, 2): 31.875240683555603,\n", + " (2060, 3): 31.9746150970459,\n", + " (2060, 4): 32.85644745826721,\n", + " (2060, 5): 14.801453113555908,\n", + " (2060, 6): 8.072823166847229,\n", + " (2060, 7): 10.759923934936523,\n", + " (2060, 8): 2.8704358339309692,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 1.9822325706481934,\n", + " (2060, 11): 5.724764108657837,\n", + " (2060, 12): 64.81610870361328}},\n", + " 10: {'monthly': {(2060, 1): 184.99872934818268,\n", + " (2060, 2): 78.02315509319305,\n", + " (2060, 3): 85.68857824802399,\n", + " (2060, 4): 51.53748035430908,\n", + " (2060, 5): 35.400421142578125,\n", + " (2060, 6): 15.918378114700317,\n", + " (2060, 7): 31.65065360069275,\n", + " (2060, 8): 4.560208201408386,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 1.9822325706481934,\n", + " (2060, 11): 6.825357675552368,\n", + " (2060, 12): 123.24709224700928},\n", + " 'window': {(2060, 1): 64.44441509246826,\n", + " (2060, 2): 30.62648856639862,\n", + " (2060, 3): 40.36911582946777,\n", + " (2060, 4): 28.241308331489563,\n", + " (2060, 5): 10.668944001197815,\n", + " (2060, 6): 6.219155430793762,\n", + " (2060, 7): 10.049416422843933,\n", + " (2060, 8): 2.964638590812683,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 1.9822325706481934,\n", + " (2060, 11): 4.051001310348511,\n", + " (2060, 12): 58.768288135528564}},\n", + " 11: {'monthly': {(2060, 1): 199.4795205593109,\n", + " (2060, 2): 80.32603764533997,\n", + " (2060, 3): 90.53969895839691,\n", + " (2060, 4): 52.29490578174591,\n", + " (2060, 5): 30.727615356445312,\n", + " (2060, 6): 19.210054636001587,\n", + " (2060, 7): 34.49882459640503,\n", + " (2060, 8): 6.046685218811035,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.1421722173690796,\n", + " (2060, 11): 15.280751943588257,\n", + " (2060, 12): 143.1884732246399},\n", + " 'window': {(2060, 1): 70.33573246002197,\n", + " (2060, 2): 30.435698986053467,\n", + " (2060, 3): 42.52820086479187,\n", + " (2060, 4): 30.338587164878845,\n", + " (2060, 5): 9.236226558685303,\n", + " (2060, 6): 7.1151416301727295,\n", + " (2060, 7): 10.624126076698303,\n", + " (2060, 8): 4.451115608215332,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.1421722173690796,\n", + " (2060, 11): 9.084230303764343,\n", + " (2060, 12): 58.41049289703369}},\n", + " 12: {'monthly': {(2060, 1): 222.52046716213226,\n", + " (2060, 2): 84.18927526473999,\n", + " (2060, 3): 92.82796204090118,\n", + " (2060, 4): 58.257102489471436,\n", + " (2060, 5): 34.70336365699768,\n", + " (2060, 6): 24.46960699558258,\n", + " (2060, 7): 37.35615885257721,\n", + " (2060, 8): 6.713040709495544,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 1.9822325706481934,\n", + " (2060, 11): 14.560459017753601,\n", + " (2060, 12): 149.9245229959488},\n", + " 'window': {(2060, 1): 62.479111671447754,\n", + " (2060, 2): 28.1489839553833,\n", + " (2060, 3): 33.8856098651886,\n", + " (2060, 4): 34.13823091983795,\n", + " (2060, 5): 8.685004949569702,\n", + " (2060, 6): 8.878517985343933,\n", + " (2060, 7): 11.719814419746399,\n", + " (2060, 8): 3.6593568325042725,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 1.9822325706481934,\n", + " (2060, 11): 6.67893385887146,\n", + " (2060, 12): 61.30430603027344}},\n", + " 13: {'monthly': {(2060, 1): 275.71551752090454,\n", + " (2060, 2): 104.31035888195038,\n", + " (2060, 3): 68.30848336219788,\n", + " (2060, 4): 4.832036972045898,\n", + " (2060, 5): 15.230712890625,\n", + " (2060, 6): 9.48189914226532,\n", + " (2060, 7): 19.5851309299469,\n", + " (2060, 8): 1.1758471727371216,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 1.1965882778167725,\n", + " (2060, 11): 19.68755352497101,\n", + " (2060, 12): 129.26710999011993},\n", + " 'window': {(2060, 1): 82.02347373962402,\n", + " (2060, 2): 59.94417667388916,\n", + " (2060, 3): 40.80641460418701,\n", + " (2060, 4): 2.7233306169509888,\n", + " (2060, 5): 5.893738031387329,\n", + " (2060, 6): 4.936112880706787,\n", + " (2060, 7): 7.216302394866943,\n", + " (2060, 8): 1.1758471727371216,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 1.1965882778167725,\n", + " (2060, 11): 12.162452816963196,\n", + " (2060, 12): 85.03817343711853}},\n", + " 14: {'monthly': {(2060, 1): 280.8995190858841,\n", + " (2060, 2): 76.77554202079773,\n", + " (2060, 3): 55.343388080596924,\n", + " (2060, 4): 12.358617186546326,\n", + " (2060, 5): 30.04008436203003,\n", + " (2060, 6): 15.26547646522522,\n", + " (2060, 7): 24.743809819221497,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 1.0435322523117065,\n", + " (2060, 11): 11.120004415512085,\n", + " (2060, 12): 95.79382359981537},\n", + " 'window': {(2060, 1): 83.27588558197021,\n", + " (2060, 2): 44.61265802383423,\n", + " (2060, 3): 23.891056656837463,\n", + " (2060, 4): 9.906206965446472,\n", + " (2060, 5): 13.106630802154541,\n", + " (2060, 6): 5.10566771030426,\n", + " (2060, 7): 8.732527613639832,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 1.0435322523117065,\n", + " (2060, 11): 7.640333294868469,\n", + " (2060, 12): 56.77288460731506}},\n", + " 15: {'monthly': {(2060, 1): 297.9669303894043,\n", + " (2060, 2): 71.68847596645355,\n", + " (2060, 3): 47.4288432598114,\n", + " (2060, 4): 13.303749442100525,\n", + " (2060, 5): 24.818320751190186,\n", + " (2060, 6): 15.26547646522522,\n", + " (2060, 7): 22.034451603889465,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 8.835997939109802,\n", + " (2060, 12): 86.48041224479675},\n", + " 'window': {(2060, 1): 94.3751049041748,\n", + " (2060, 2): 44.806376576423645,\n", + " (2060, 3): 18.837244153022766,\n", + " (2060, 4): 11.88423776626587,\n", + " (2060, 5): 9.971006393432617,\n", + " (2060, 6): 5.10566771030426,\n", + " (2060, 7): 7.372061133384705,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 6.238973259925842,\n", + " (2060, 12): 47.47452998161316}},\n", + " 16: {'monthly': {(2060, 1): 327.0283167362213,\n", + " (2060, 2): 69.149573802948,\n", + " (2060, 3): 52.6281476020813,\n", + " (2060, 4): 18.35203719139099,\n", + " (2060, 5): 22.02019166946411,\n", + " (2060, 6): 15.26547646522522,\n", + " (2060, 7): 20.036049127578735,\n", + " (2060, 8): 1.034966230392456,\n", + " (2060, 9): 1.047914743423462,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 7.13714075088501,\n", + " (2060, 12): 85.2325439453125},\n", + " 'window': {(2060, 1): 106.87643909454346,\n", + " (2060, 2): 41.4850949048996,\n", + " (2060, 3): 21.521435856819153,\n", + " (2060, 4): 15.799172401428223,\n", + " (2060, 5): 8.19351863861084,\n", + " (2060, 6): 5.10566771030426,\n", + " (2060, 7): 7.032817482948303,\n", + " (2060, 8): 1.034966230392456,\n", + " (2060, 9): 1.047914743423462,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 5.701374053955078,\n", + " (2060, 12): 49.90061545372009}},\n", + " 17: {'monthly': {(2060, 1): 337.77501368522644,\n", + " (2060, 2): 65.87799036502838,\n", + " (2060, 3): 54.104509353637695,\n", + " (2060, 4): 24.535561561584473,\n", + " (2060, 5): 20.250721335411072,\n", + " (2060, 6): 15.26547646522522,\n", + " (2060, 7): 22.933624982833862,\n", + " (2060, 8): 2.1315125226974487,\n", + " (2060, 9): 1.374363899230957,\n", + " (2060, 10): 2.294590711593628,\n", + " (2060, 11): 12.713541984558105,\n", + " (2060, 12): 75.46126532554626},\n", + " 'window': {(2060, 1): 114.07656478881836,\n", + " (2060, 2): 36.50031542778015,\n", + " (2060, 3): 21.648704767227173,\n", + " (2060, 4): 20.970149755477905,\n", + " (2060, 5): 7.081977009773254,\n", + " (2060, 6): 5.10566771030426,\n", + " (2060, 7): 8.925637364387512,\n", + " (2060, 8): 2.1315125226974487,\n", + " (2060, 9): 1.374363899230957,\n", + " (2060, 10): 1.2513712644577026,\n", + " (2060, 11): 8.276005864143372,\n", + " (2060, 12): 41.72475624084473}},\n", + " 18: {'monthly': {(2060, 1): 283.53866136074066,\n", + " (2060, 2): 57.88073492050171,\n", + " (2060, 3): 55.28987121582031,\n", + " (2060, 4): 42.37288987636566,\n", + " (2060, 5): 24.621315598487854,\n", + " (2060, 6): 20.361573219299316,\n", + " (2060, 7): 30.539228677749634,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 2.0700796842575073,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 16.218668222427368,\n", + " (2060, 12): 78.2343841791153},\n", + " 'window': {(2060, 1): 89.71606540679932,\n", + " (2060, 2): 26.57128381729126,\n", + " (2060, 3): 17.913177251815796,\n", + " (2060, 4): 26.214650630950928,\n", + " (2060, 5): 7.858853816986084,\n", + " (2060, 6): 5.147720813751221,\n", + " (2060, 7): 10.560983419418335,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 1.0696583986282349,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 10.842864871025085,\n", + " (2060, 12): 48.024280309677124}},\n", + " 19: {'monthly': {(2060, 1): 289.99115097522736,\n", + " (2060, 2): 59.80119717121124,\n", + " (2060, 3): 61.07085847854614,\n", + " (2060, 4): 45.245096921920776,\n", + " (2060, 5): 26.730894804000854,\n", + " (2060, 6): 20.133365869522095,\n", + " (2060, 7): 31.053078174591064,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 2.172034502029419,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 9.928079962730408,\n", + " (2060, 12): 71.47853910923004},\n", + " 'window': {(2060, 1): 105.30583238601685,\n", + " (2060, 2): 25.575934290885925,\n", + " (2060, 3): 23.178677558898926,\n", + " (2060, 4): 30.02705705165863,\n", + " (2060, 5): 8.661492824554443,\n", + " (2060, 6): 5.147720813751221,\n", + " (2060, 7): 11.611162662506104,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 1.102376103401184,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 8.67087459564209,\n", + " (2060, 12): 44.88334631919861}},\n", + " 20: {'monthly': {(2060, 1): 302.87652909755707,\n", + " (2060, 2): 54.842564702034,\n", + " (2060, 3): 60.318278193473816,\n", + " (2060, 4): 45.38412058353424,\n", + " (2060, 5): 27.30981969833374,\n", + " (2060, 6): 19.28374171257019,\n", + " (2060, 7): 32.507999777793884,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 2.0700796842575073,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 15.546087145805359,\n", + " (2060, 12): 71.2442227602005},\n", + " 'window': {(2060, 1): 119.7259578704834,\n", + " (2060, 2): 24.835559725761414,\n", + " (2060, 3): 19.047128677368164,\n", + " (2060, 4): 28.697428584098816,\n", + " (2060, 5): 8.851400017738342,\n", + " (2060, 6): 5.147720813751221,\n", + " (2060, 7): 12.947813987731934,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 1.0696583986282349,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 13.405994415283203,\n", + " (2060, 12): 44.04079484939575}},\n", + " 21: {'monthly': {(2060, 1): 324.27861273288727,\n", + " (2060, 2): 62.140079379081726,\n", + " (2060, 3): 76.96446585655212,\n", + " (2060, 4): 47.68307662010193,\n", + " (2060, 5): 28.956926345825195,\n", + " (2060, 6): 19.646801114082336,\n", + " (2060, 7): 38.32234442234039,\n", + " (2060, 8): 1.2039484977722168,\n", + " (2060, 9): 2.0745404958724976,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 21.834125518798828,\n", + " (2060, 12): 82.41578006744385},\n", + " 'window': {(2060, 1): 132.1976718902588,\n", + " (2060, 2): 31.405773282051086,\n", + " (2060, 3): 28.76563000679016,\n", + " (2060, 4): 25.0566463470459,\n", + " (2060, 5): 10.245465993881226,\n", + " (2060, 6): 5.147720813751221,\n", + " (2060, 7): 16.9343079328537,\n", + " (2060, 8): 1.2039484977722168,\n", + " (2060, 9): 1.074119210243225,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 17.65831768512726,\n", + " (2060, 12): 50.107163429260254}},\n", + " 22: {'monthly': {(2060, 1): 216.84882986545563,\n", + " (2060, 2): 79.51474297046661,\n", + " (2060, 3): 74.7057580947876,\n", + " (2060, 4): 48.15092611312866,\n", + " (2060, 5): 45.08745312690735,\n", + " (2060, 6): 21.81949758529663,\n", + " (2060, 7): 37.94841241836548,\n", + " (2060, 8): 3.3124797344207764,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 18.577101349830627,\n", + " (2060, 12): 137.43938148021698},\n", + " 'window': {(2060, 1): 54.70518159866333,\n", + " (2060, 2): 35.51257658004761,\n", + " (2060, 3): 21.77220928668976,\n", + " (2060, 4): 31.72324562072754,\n", + " (2060, 5): 12.371639251708984,\n", + " (2060, 6): 8.282130479812622,\n", + " (2060, 7): 14.402588248252869,\n", + " (2060, 8): 2.2932902574539185,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 10.238005518913269,\n", + " (2060, 12): 49.31591558456421}},\n", + " 23: {'monthly': {(2060, 1): 198.01714658737183,\n", + " (2060, 2): 75.50567328929901,\n", + " (2060, 3): 74.17715454101562,\n", + " (2060, 4): 62.87470293045044,\n", + " (2060, 5): 47.72959303855896,\n", + " (2060, 6): 20.466951370239258,\n", + " (2060, 7): 36.004900336265564,\n", + " (2060, 8): 3.363345146179199,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 17.98643136024475,\n", + " (2060, 12): 126.3448555469513},\n", + " 'window': {(2060, 1): 51.48584032058716,\n", + " (2060, 2): 33.519627928733826,\n", + " (2060, 3): 22.595688581466675,\n", + " (2060, 4): 42.45381140708923,\n", + " (2060, 5): 16.429280877113342,\n", + " (2060, 6): 7.708904147148132,\n", + " (2060, 7): 13.772684574127197,\n", + " (2060, 8): 2.3441556692123413,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 10.582186818122864,\n", + " (2060, 12): 53.937424659729004}},\n", + " 24: {'monthly': {(2060, 1): 212.755814909935,\n", + " (2060, 2): 77.83977007865906,\n", + " (2060, 3): 87.39669013023376,\n", + " (2060, 4): 74.842365026474,\n", + " (2060, 5): 54.39435911178589,\n", + " (2060, 6): 20.578118681907654,\n", + " (2060, 7): 51.68839085102081,\n", + " (2060, 8): 4.380195617675781,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 15.001265168190002,\n", + " (2060, 12): 132.21350872516632},\n", + " 'window': {(2060, 1): 57.95471954345703,\n", + " (2060, 2): 38.21384835243225,\n", + " (2060, 3): 25.031933307647705,\n", + " (2060, 4): 50.903972148895264,\n", + " (2060, 5): 19.315935850143433,\n", + " (2060, 6): 6.886984348297119,\n", + " (2060, 7): 18.79657471179962,\n", + " (2060, 8): 3.3610061407089233,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 9.960644602775574,\n", + " (2060, 12): 53.34445333480835}},\n", + " 25: {'monthly': {(2060, 1): 228.2965955734253,\n", + " (2060, 2): 89.62907814979553,\n", + " (2060, 3): 101.04309904575348,\n", + " (2060, 4): 73.51490819454193,\n", + " (2060, 5): 58.073058009147644,\n", + " (2060, 6): 21.70261299610138,\n", + " (2060, 7): 51.510161995887756,\n", + " (2060, 8): 6.478736877441406,\n", + " (2060, 9): 1.029809594154358,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 21.328635215759277,\n", + " (2060, 12): 149.80462884902954},\n", + " 'window': {(2060, 1): 71.0409574508667,\n", + " (2060, 2): 43.5347626209259,\n", + " (2060, 3): 29.93865728378296,\n", + " (2060, 4): 45.91067981719971,\n", + " (2060, 5): 18.1136953830719,\n", + " (2060, 6): 8.06552267074585,\n", + " (2060, 7): 19.014212369918823,\n", + " (2060, 8): 5.459547400474548,\n", + " (2060, 9): 1.029809594154358,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 11.479464411735535,\n", + " (2060, 12): 65.83091926574707}},\n", + " 26: {'monthly': {(2060, 1): 300.9923725128174,\n", + " (2060, 2): 106.11579370498657,\n", + " (2060, 3): 64.89023923873901,\n", + " (2060, 4): 7.041850924491882,\n", + " (2060, 5): 15.269606232643127,\n", + " (2060, 6): 9.48189914226532,\n", + " (2060, 7): 20.4096941947937,\n", + " (2060, 8): 1.1758471727371216,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 1.1965882778167725,\n", + " (2060, 11): 20.978981018066406,\n", + " (2060, 12): 110.30153834819794},\n", + " 'window': {(2060, 1): 109.57153511047363,\n", + " (2060, 2): 67.099374294281,\n", + " (2060, 3): 35.19744682312012,\n", + " (2060, 4): 3.605716109275818,\n", + " (2060, 5): 6.578789472579956,\n", + " (2060, 6): 4.936112880706787,\n", + " (2060, 7): 7.281499624252319,\n", + " (2060, 8): 1.1758471727371216,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 1.1965882778167725,\n", + " (2060, 11): 12.530943036079407,\n", + " (2060, 12): 73.25389003753662}},\n", + " 27: {'monthly': {(2060, 1): 285.9675942659378,\n", + " (2060, 2): 63.180262207984924,\n", + " (2060, 3): 55.756710052490234,\n", + " (2060, 4): 17.564688444137573,\n", + " (2060, 5): 30.04882049560547,\n", + " (2060, 6): 15.26547646522522,\n", + " (2060, 7): 25.65722382068634,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 10.897678256034851,\n", + " (2060, 12): 81.67393398284912},\n", + " 'window': {(2060, 1): 96.0301866531372,\n", + " (2060, 2): 30.811904311180115,\n", + " (2060, 3): 22.65938377380371,\n", + " (2060, 4): 14.007421970367432,\n", + " (2060, 5): 13.965339660644531,\n", + " (2060, 6): 5.10566771030426,\n", + " (2060, 7): 9.530768632888794,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 8.735248684883118,\n", + " (2060, 12): 50.40670609474182}},\n", + " 28: {'monthly': {(2060, 1): 322.1928827762604,\n", + " (2060, 2): 58.73407542705536,\n", + " (2060, 3): 51.3264422416687,\n", + " (2060, 4): 19.735199809074402,\n", + " (2060, 5): 23.96096396446228,\n", + " (2060, 6): 15.26547646522522,\n", + " (2060, 7): 23.913462042808533,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 9.096928119659424,\n", + " (2060, 12): 75.1400146484375},\n", + " 'window': {(2060, 1): 126.90206050872803,\n", + " (2060, 2): 30.60452401638031,\n", + " (2060, 3): 21.042474389076233,\n", + " (2060, 4): 17.241387844085693,\n", + " (2060, 5): 9.909919500350952,\n", + " (2060, 6): 5.10566771030426,\n", + " (2060, 7): 8.533485293388367,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 9.096928119659424,\n", + " (2060, 12): 44.57266020774841}},\n", + " 29: {'monthly': {(2060, 1): 334.69363033771515,\n", + " (2060, 2): 58.68753683567047,\n", + " (2060, 3): 51.84394323825836,\n", + " (2060, 4): 25.2209370136261,\n", + " (2060, 5): 19.99314570426941,\n", + " (2060, 6): 15.26547646522522,\n", + " (2060, 7): 21.729788303375244,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 8.592445611953735,\n", + " (2060, 12): 68.24425506591797},\n", + " 'window': {(2060, 1): 140.26044368743896,\n", + " (2060, 2): 29.94936490058899,\n", + " (2060, 3): 21.550683856010437,\n", + " (2060, 4): 22.290402054786682,\n", + " (2060, 5): 7.394083738327026,\n", + " (2060, 6): 5.10566771030426,\n", + " (2060, 7): 7.2805129289627075,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 7.490725994110107,\n", + " (2060, 12): 40.49748492240906}},\n", + " 30: {'monthly': {(2060, 1): 335.6134226322174,\n", + " (2060, 2): 63.06826615333557,\n", + " (2060, 3): 53.47462558746338,\n", + " (2060, 4): 32.777527928352356,\n", + " (2060, 5): 18.50051999092102,\n", + " (2060, 6): 15.515244126319885,\n", + " (2060, 7): 20.85115885734558,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 9.792150378227234,\n", + " (2060, 12): 68.15757250785828},\n", + " 'window': {(2060, 1): 136.64941215515137,\n", + " (2060, 2): 31.053982138633728,\n", + " (2060, 3): 21.455462098121643,\n", + " (2060, 4): 29.696712493896484,\n", + " (2060, 5): 6.330652356147766,\n", + " (2060, 6): 5.10566771030426,\n", + " (2060, 7): 9.182690262794495,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 8.281229734420776,\n", + " (2060, 12): 38.642252922058105}},\n", + " 31: {'monthly': {(2060, 1): 292.1636471748352,\n", + " (2060, 2): 62.630359292030334,\n", + " (2060, 3): 56.72766983509064,\n", + " (2060, 4): 50.720216035842896,\n", + " (2060, 5): 26.77993953227997,\n", + " (2060, 6): 20.07488512992859,\n", + " (2060, 7): 33.26974439620972,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 2.0700796842575073,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 13.495524048805237,\n", + " (2060, 12): 79.8779149055481},\n", + " 'window': {(2060, 1): 96.86238288879395,\n", + " (2060, 2): 30.406187176704407,\n", + " (2060, 3): 15.681460857391357,\n", + " (2060, 4): 34.43177795410156,\n", + " (2060, 5): 8.923270225524902,\n", + " (2060, 6): 5.147720813751221,\n", + " (2060, 7): 13.260712623596191,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 1.0696583986282349,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 10.683940529823303,\n", + " (2060, 12): 42.085524797439575}},\n", + " 32: {'monthly': {(2060, 1): 313.939089179039,\n", + " (2060, 2): 59.74389171600342,\n", + " (2060, 3): 69.36816716194153,\n", + " (2060, 4): 56.32128036022186,\n", + " (2060, 5): 30.154914617538452,\n", + " (2060, 6): 19.726469039916992,\n", + " (2060, 7): 39.15850210189819,\n", + " (2060, 8): 1.1209079027175903,\n", + " (2060, 9): 2.115904927253723,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 13.572490572929382,\n", + " (2060, 12): 81.46638894081116},\n", + " 'window': {(2060, 1): 110.7195634841919,\n", + " (2060, 2): 31.338606238365173,\n", + " (2060, 3): 24.410902976989746,\n", + " (2060, 4): 40.42978882789612,\n", + " (2060, 5): 9.348739385604858,\n", + " (2060, 6): 5.147720813751221,\n", + " (2060, 7): 16.471436977386475,\n", + " (2060, 8): 1.1209079027175903,\n", + " (2060, 9): 1.1154836416244507,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 11.323002219200134,\n", + " (2060, 12): 46.527843952178955}},\n", + " 33: {'monthly': {(2060, 1): 319.5274738073349,\n", + " (2060, 2): 59.354222536087036,\n", + " (2060, 3): 77.6412113904953,\n", + " (2060, 4): 57.725080609321594,\n", + " (2060, 5): 32.624388694763184,\n", + " (2060, 6): 20.055033922195435,\n", + " (2060, 7): 41.373685002326965,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 2.21674907207489,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 15.835336565971375,\n", + " (2060, 12): 78.10277485847473},\n", + " 'window': {(2060, 1): 121.05110359191895,\n", + " (2060, 2): 29.981885075569153,\n", + " (2060, 3): 28.08425807952881,\n", + " (2060, 4): 37.035592913627625,\n", + " (2060, 5): 10.675751686096191,\n", + " (2060, 6): 5.281996011734009,\n", + " (2060, 7): 17.97246539592743,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 1.2163277864456177,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 13.661487102508545,\n", + " (2060, 12): 47.269954204559326}},\n", + " 34: {'monthly': {(2060, 1): 314.3877409696579,\n", + " (2060, 2): 64.65623545646667,\n", + " (2060, 3): 90.66038620471954,\n", + " (2060, 4): 52.503979325294495,\n", + " (2060, 5): 36.33127248287201,\n", + " (2060, 6): 22.162110805511475,\n", + " (2060, 7): 51.9242844581604,\n", + " (2060, 8): 1.024043083190918,\n", + " (2060, 9): 2.2166507244110107,\n", + " (2060, 10): 1.0015662908554077,\n", + " (2060, 11): 21.986296772956848,\n", + " (2060, 12): 85.57814121246338},\n", + " 'window': {(2060, 1): 124.11465549468994,\n", + " (2060, 2): 32.42938280105591,\n", + " (2060, 3): 35.437742710113525,\n", + " (2060, 4): 29.31278121471405,\n", + " (2060, 5): 11.578647017478943,\n", + " (2060, 6): 5.467369437217712,\n", + " (2060, 7): 22.374963879585266,\n", + " (2060, 8): 1.024043083190918,\n", + " (2060, 9): 1.2162294387817383,\n", + " (2060, 10): 1.0015662908554077,\n", + " (2060, 11): 17.645082712173462,\n", + " (2060, 12): 48.46052694320679}},\n", + " 35: {'monthly': {(2060, 1): 220.57909893989563,\n", + " (2060, 2): 81.23381793498993,\n", + " (2060, 3): 70.66388010978699,\n", + " (2060, 4): 52.05650615692139,\n", + " (2060, 5): 55.09097182750702,\n", + " (2060, 6): 21.18526780605316,\n", + " (2060, 7): 39.863245248794556,\n", + " (2060, 8): 6.0618627071380615,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 20.67309880256653,\n", + " (2060, 12): 128.95277285575867},\n", + " 'window': {(2060, 1): 61.86612415313721,\n", + " (2060, 2): 41.45695877075195,\n", + " (2060, 3): 20.00838565826416,\n", + " (2060, 4): 35.031951546669006,\n", + " (2060, 5): 18.88022255897522,\n", + " (2060, 6): 6.704087018966675,\n", + " (2060, 7): 16.410173296928406,\n", + " (2060, 8): 5.042673230171204,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 11.787132620811462,\n", + " (2060, 12): 52.496760845184326}},\n", + " 36: {'monthly': {(2060, 1): 216.97652184963226,\n", + " (2060, 2): 77.6467000246048,\n", + " (2060, 3): 73.74719202518463,\n", + " (2060, 4): 69.26261603832245,\n", + " (2060, 5): 65.63064241409302,\n", + " (2060, 6): 24.683910846710205,\n", + " (2060, 7): 47.27613091468811,\n", + " (2060, 8): 3.992218017578125,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 16.92774987220764,\n", + " (2060, 12): 123.82927405834198},\n", + " 'window': {(2060, 1): 63.47757053375244,\n", + " (2060, 2): 39.74986004829407,\n", + " (2060, 3): 21.556602954864502,\n", + " (2060, 4): 48.67717504501343,\n", + " (2060, 5): 25.412168979644775,\n", + " (2060, 6): 8.842325091362,\n", + " (2060, 7): 17.720155119895935,\n", + " (2060, 8): 2.973028540611267,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 11.202586054801941,\n", + " (2060, 12): 52.04808712005615}},\n", + " 37: {'monthly': {(2060, 1): 256.3180900812149,\n", + " (2060, 2): 89.17130327224731,\n", + " (2060, 3): 100.5813010931015,\n", + " (2060, 4): 89.5719518661499,\n", + " (2060, 5): 81.90803587436676,\n", + " (2060, 6): 26.25433385372162,\n", + " (2060, 7): 68.79021334648132,\n", + " (2060, 8): 4.808828830718994,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 20.270294785499573,\n", + " (2060, 12): 155.0377138853073},\n", + " 'window': {(2060, 1): 75.49716281890869,\n", + " (2060, 2): 45.31098234653473,\n", + " (2060, 3): 27.468059420585632,\n", + " (2060, 4): 59.94999408721924,\n", + " (2060, 5): 31.84259033203125,\n", + " (2060, 6): 8.89030134677887,\n", + " (2060, 7): 29.806596517562866,\n", + " (2060, 8): 3.7896393537521362,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 12.998994708061218,\n", + " (2060, 12): 64.50573921203613}},\n", + " 38: {'monthly': {(2060, 1): 254.36921429634094,\n", + " (2060, 2): 100.66485917568207,\n", + " (2060, 3): 96.19198882579803,\n", + " (2060, 4): 87.02756667137146,\n", + " (2060, 5): 77.34562230110168,\n", + " (2060, 6): 26.229256868362427,\n", + " (2060, 7): 63.0741183757782,\n", + " (2060, 8): 5.499953508377075,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 1.788832187652588,\n", + " (2060, 11): 21.140050172805786,\n", + " (2060, 12): 161.59408152103424},\n", + " 'window': {(2060, 1): 80.32052803039551,\n", + " (2060, 2): 46.830082178115845,\n", + " (2060, 3): 25.191416263580322,\n", + " (2060, 4): 58.00192618370056,\n", + " (2060, 5): 28.35788106918335,\n", + " (2060, 6): 9.134818077087402,\n", + " (2060, 7): 26.94859290122986,\n", + " (2060, 8): 4.480764031410217,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 1.788832187652588,\n", + " (2060, 11): 12.929760456085205,\n", + " (2060, 12): 68.56751918792725}},\n", + " 39: {'monthly': {(2060, 1): 296.34627890586853,\n", + " (2060, 2): 106.02599656581879,\n", + " (2060, 3): 66.53966355323792,\n", + " (2060, 4): 4.872930526733398,\n", + " (2060, 5): 14.977654576301575,\n", + " (2060, 6): 10.490819811820984,\n", + " (2060, 7): 20.163483262062073,\n", + " (2060, 8): 1.1758471727371216,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 1.1965882778167725,\n", + " (2060, 11): 22.440502882003784,\n", + " (2060, 12): 101.86919367313385},\n", + " 'window': {(2060, 1): 106.1564769744873,\n", + " (2060, 2): 66.09535598754883,\n", + " (2060, 3): 35.5235755443573,\n", + " (2060, 4): 2.688153862953186,\n", + " (2060, 5): 6.6557347774505615,\n", + " (2060, 6): 4.936112880706787,\n", + " (2060, 7): 7.0487953424453735,\n", + " (2060, 8): 1.1758471727371216,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 1.1965882778167725,\n", + " (2060, 11): 11.939525127410889,\n", + " (2060, 12): 65.46726632118225}},\n", + " 40: {'monthly': {(2060, 1): 293.44141376018524,\n", + " (2060, 2): 63.1215763092041,\n", + " (2060, 3): 56.473179936409,\n", + " (2060, 4): 25.943652153015137,\n", + " (2060, 5): 27.41191554069519,\n", + " (2060, 6): 15.26547646522522,\n", + " (2060, 7): 25.399811625480652,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 10.54373574256897,\n", + " (2060, 12): 75.83462905883789},\n", + " 'window': {(2060, 1): 99.29912853240967,\n", + " (2060, 2): 32.747127652168274,\n", + " (2060, 3): 22.922966361045837,\n", + " (2060, 4): 21.010313749313354,\n", + " (2060, 5): 12.786853551864624,\n", + " (2060, 6): 5.10566771030426,\n", + " (2060, 7): 9.191073894500732,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 9.516861081123352,\n", + " (2060, 12): 40.26206588745117}},\n", + " 41: {'monthly': {(2060, 1): 312.1551994085312,\n", + " (2060, 2): 59.118239998817444,\n", + " (2060, 3): 56.35863268375397,\n", + " (2060, 4): 29.997666358947754,\n", + " (2060, 5): 21.863510847091675,\n", + " (2060, 6): 15.26547646522522,\n", + " (2060, 7): 25.356513500213623,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 11.32293152809143,\n", + " (2060, 12): 72.43608689308167},\n", + " 'window': {(2060, 1): 124.02936744689941,\n", + " (2060, 2): 31.41458761692047,\n", + " (2060, 3): 24.199498414993286,\n", + " (2060, 4): 26.912252187728882,\n", + " (2060, 5): 8.894617795944214,\n", + " (2060, 6): 5.10566771030426,\n", + " (2060, 7): 9.691251039505005,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 10.272989511489868,\n", + " (2060, 12): 40.635133504867554}},\n", + " 42: {'monthly': {(2060, 1): 302.9287323951721,\n", + " (2060, 2): 57.08472788333893,\n", + " (2060, 3): 56.8288209438324,\n", + " (2060, 4): 35.67411530017853,\n", + " (2060, 5): 18.65407705307007,\n", + " (2060, 6): 15.26547646522522,\n", + " (2060, 7): 23.033772230148315,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 9.466933488845825,\n", + " (2060, 12): 67.1070362329483},\n", + " 'window': {(2060, 1): 124.20862865447998,\n", + " (2060, 2): 28.935069918632507,\n", + " (2060, 3): 23.62764286994934,\n", + " (2060, 4): 31.938618421554565,\n", + " (2060, 5): 6.687414646148682,\n", + " (2060, 6): 5.10566771030426,\n", + " (2060, 7): 8.421351790428162,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 8.348963022232056,\n", + " (2060, 12): 37.56912398338318}},\n", + " 43: {'monthly': {(2060, 1): 297.01501405239105,\n", + " (2060, 2): 60.02446782588959,\n", + " (2060, 3): 59.921448945999146,\n", + " (2060, 4): 41.68176209926605,\n", + " (2060, 5): 18.838627576828003,\n", + " (2060, 6): 15.483638167381287,\n", + " (2060, 7): 19.101704716682434,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 1.1451897621154785,\n", + " (2060, 11): 11.980512022972107,\n", + " (2060, 12): 67.05636274814606},\n", + " 'window': {(2060, 1): 108.92272281646729,\n", + " (2060, 2): 31.343198657035828,\n", + " (2060, 3): 23.68299901485443,\n", + " (2060, 4): 35.69923543930054,\n", + " (2060, 5): 6.832783818244934,\n", + " (2060, 6): 5.10566771030426,\n", + " (2060, 7): 8.509528756141663,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 1.1451897621154785,\n", + " (2060, 11): 10.416757702827454,\n", + " (2060, 12): 33.76798367500305}},\n", + " 44: {'monthly': {(2060, 1): 310.572588801384,\n", + " (2060, 2): 66.20637154579163,\n", + " (2060, 3): 67.14249265193939,\n", + " (2060, 4): 50.98197638988495,\n", + " (2060, 5): 31.154293656349182,\n", + " (2060, 6): 19.781296014785767,\n", + " (2060, 7): 39.74087381362915,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 2.179506540298462,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 15.543122291564941,\n", + " (2060, 12): 91.31154823303223},\n", + " 'window': {(2060, 1): 106.13670253753662,\n", + " (2060, 2): 36.73829114437103,\n", + " (2060, 3): 24.392775535583496,\n", + " (2060, 4): 34.94693088531494,\n", + " (2060, 5): 10.81454348564148,\n", + " (2060, 6): 5.147720813751221,\n", + " (2060, 7): 15.423827648162842,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 1.1790852546691895,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 10.809877157211304,\n", + " (2060, 12): 47.75798273086548}},\n", + " 45: {'monthly': {(2060, 1): 338.05555379390717,\n", + " (2060, 2): 74.12038898468018,\n", + " (2060, 3): 87.50362753868103,\n", + " (2060, 4): 61.81269907951355,\n", + " (2060, 5): 37.02108919620514,\n", + " (2060, 6): 21.52884018421173,\n", + " (2060, 7): 51.25582206249237,\n", + " (2060, 8): 1.2169336080551147,\n", + " (2060, 9): 1.0004212856292725,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 14.514801144599915,\n", + " (2060, 12): 97.00152492523193},\n", + " 'window': {(2060, 1): 119.35415267944336,\n", + " (2060, 2): 40.48087024688721,\n", + " (2060, 3): 34.14340543746948,\n", + " (2060, 4): 38.44229733943939,\n", + " (2060, 5): 12.384299397468567,\n", + " (2060, 6): 5.24444580078125,\n", + " (2060, 7): 22.16848337650299,\n", + " (2060, 8): 1.2169336080551147,\n", + " (2060, 9): 1.0004212856292725,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 10.576711058616638,\n", + " (2060, 12): 49.71320962905884}},\n", + " 46: {'monthly': {(2060, 1): 323.9993249177933,\n", + " (2060, 2): 66.34102642536163,\n", + " (2060, 3): 92.5652767419815,\n", + " (2060, 4): 55.37121069431305,\n", + " (2060, 5): 41.89298105239868,\n", + " (2060, 6): 23.51865589618683,\n", + " (2060, 7): 56.55525732040405,\n", + " (2060, 8): 2.346856951713562,\n", + " (2060, 9): 2.1987487077713013,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 13.131214380264282,\n", + " (2060, 12): 85.30160176753998},\n", + " 'window': {(2060, 1): 120.87812328338623,\n", + " (2060, 2): 35.553818464279175,\n", + " (2060, 3): 37.55263113975525,\n", + " (2060, 4): 32.23172914981842,\n", + " (2060, 5): 13.936350226402283,\n", + " (2060, 6): 6.323542356491089,\n", + " (2060, 7): 23.068095803260803,\n", + " (2060, 8): 1.1995497941970825,\n", + " (2060, 9): 1.1983274221420288,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 10.302769303321838,\n", + " (2060, 12): 44.47944164276123}},\n", + " 47: {'monthly': {(2060, 1): 291.80711805820465,\n", + " (2060, 2): 66.82185900211334,\n", + " (2060, 3): 92.15792214870453,\n", + " (2060, 4): 47.38119912147522,\n", + " (2060, 5): 44.079264879226685,\n", + " (2060, 6): 24.032878756523132,\n", + " (2060, 7): 68.5338853597641,\n", + " (2060, 8): 1.1851654052734375,\n", + " (2060, 9): 2.473771095275879,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 18.487160325050354,\n", + " (2060, 12): 98.34291529655457},\n", + " 'window': {(2060, 1): 109.67722415924072,\n", + " (2060, 2): 34.88581192493439,\n", + " (2060, 3): 40.72154259681702,\n", + " (2060, 4): 23.35670793056488,\n", + " (2060, 5): 15.031364798545837,\n", + " (2060, 6): 6.084531545639038,\n", + " (2060, 7): 30.66501533985138,\n", + " (2060, 8): 1.1851654052734375,\n", + " (2060, 9): 1.4733498096466064,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 13.630132913589478,\n", + " (2060, 12): 52.23294687271118}},\n", + " 48: {'monthly': {(2060, 1): 232.86843287944794,\n", + " (2060, 2): 79.20909202098846,\n", + " (2060, 3): 74.777578830719,\n", + " (2060, 4): 46.5446480512619,\n", + " (2060, 5): 61.405011773109436,\n", + " (2060, 6): 22.42486083507538,\n", + " (2060, 7): 45.86200153827667,\n", + " (2060, 8): 6.049154162406921,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 20.72250521183014,\n", + " (2060, 12): 140.11458957195282},\n", + " 'window': {(2060, 1): 67.99775123596191,\n", + " (2060, 2): 41.35743045806885,\n", + " (2060, 3): 23.960975408554077,\n", + " (2060, 4): 33.193228006362915,\n", + " (2060, 5): 20.590067625045776,\n", + " (2060, 6): 8.250998854637146,\n", + " (2060, 7): 18.389763116836548,\n", + " (2060, 8): 2.8710052967071533,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 15.099194407463074,\n", + " (2060, 12): 58.4426212310791}},\n", + " 49: {'monthly': {(2060, 1): 260.52293598651886,\n", + " (2060, 2): 88.93400633335114,\n", + " (2060, 3): 87.91801726818085,\n", + " (2060, 4): 69.65221166610718,\n", + " (2060, 5): 76.21527993679047,\n", + " (2060, 6): 25.818598866462708,\n", + " (2060, 7): 61.71872842311859,\n", + " (2060, 8): 4.524521350860596,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 24.807042717933655,\n", + " (2060, 12): 158.91597938537598},\n", + " 'window': {(2060, 1): 78.7003984451294,\n", + " (2060, 2): 41.59111309051514,\n", + " (2060, 3): 27.146867275238037,\n", + " (2060, 4): 47.81881523132324,\n", + " (2060, 5): 27.432798862457275,\n", + " (2060, 6): 9.757168889045715,\n", + " (2060, 7): 26.740872144699097,\n", + " (2060, 8): 3.505331873893738,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 15.70863664150238,\n", + " (2060, 12): 66.44653129577637}},\n", + " 50: {'monthly': {(2060, 1): 305.56155347824097,\n", + " (2060, 2): 112.92953598499298,\n", + " (2060, 3): 108.7041906118393,\n", + " (2060, 4): 92.67277431488037,\n", + " (2060, 5): 98.37887167930603,\n", + " (2060, 6): 33.45290994644165,\n", + " (2060, 7): 82.38717007637024,\n", + " (2060, 8): 5.5008251667022705,\n", + " (2060, 9): 1.3174622058868408,\n", + " (2060, 10): 3.566159725189209,\n", + " (2060, 11): 26.148690462112427,\n", + " (2060, 12): 195.13830077648163},\n", + " 'window': {(2060, 1): 90.13490009307861,\n", + " (2060, 2): 44.961533546447754,\n", + " (2060, 3): 31.02476167678833,\n", + " (2060, 4): 57.912015438079834,\n", + " (2060, 5): 35.81250476837158,\n", + " (2060, 6): 12.259753704071045,\n", + " (2060, 7): 38.44519901275635,\n", + " (2060, 8): 4.481635689735413,\n", + " (2060, 9): 1.3174622058868408,\n", + " (2060, 10): 2.303812623023987,\n", + " (2060, 11): 16.67792010307312,\n", + " (2060, 12): 80.9930009841919}},\n", + " 51: {'monthly': {(2060, 1): 271.6168885231018,\n", + " (2060, 2): 103.74981260299683,\n", + " (2060, 3): 100.69607329368591,\n", + " (2060, 4): 85.75639688968658,\n", + " (2060, 5): 87.4586672782898,\n", + " (2060, 6): 29.670650601387024,\n", + " (2060, 7): 68.37385511398315,\n", + " (2060, 8): 5.560763359069824,\n", + " (2060, 9): 2.577396035194397,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 23.464828491210938,\n", + " (2060, 12): 181.35594391822815},\n", + " 'window': {(2060, 1): 85.2097339630127,\n", + " (2060, 2): 39.2038471698761,\n", + " (2060, 3): 30.043171405792236,\n", + " (2060, 4): 55.606667041778564,\n", + " (2060, 5): 31.737778782844543,\n", + " (2060, 6): 10.428610801696777,\n", + " (2060, 7): 30.850934982299805,\n", + " (2060, 8): 4.541573882102966,\n", + " (2060, 9): 1.3179986476898193,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 14.515791058540344,\n", + " (2060, 12): 80.35700416564941}},\n", + " 52: {'monthly': {(2060, 1): 269.23336243629456,\n", + " (2060, 2): 100.95813119411469,\n", + " (2060, 3): 76.843106508255,\n", + " (2060, 4): 8.69933557510376,\n", + " (2060, 5): 14.250001430511475,\n", + " (2060, 6): 9.48189914226532,\n", + " (2060, 7): 18.906371235847473,\n", + " (2060, 8): 1.1758471727371216,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 1.1965882778167725,\n", + " (2060, 11): 22.801262617111206,\n", + " (2060, 12): 88.78945195674896},\n", + " 'window': {(2060, 1): 75.22465515136719,\n", + " (2060, 2): 59.07730293273926,\n", + " (2060, 3): 43.351332664489746,\n", + " (2060, 4): 5.34756863117218,\n", + " (2060, 5): 6.071171998977661,\n", + " (2060, 6): 4.936112880706787,\n", + " (2060, 7): 7.0487953424453735,\n", + " (2060, 8): 1.1758471727371216,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 1.1965882778167725,\n", + " (2060, 11): 12.817956686019897,\n", + " (2060, 12): 51.88027000427246}},\n", + " 53: {'monthly': {(2060, 1): 271.574245929718,\n", + " (2060, 2): 64.07821762561798,\n", + " (2060, 3): 63.8915981054306,\n", + " (2060, 4): 32.86189270019531,\n", + " (2060, 5): 22.903871297836304,\n", + " (2060, 6): 17.832676649093628,\n", + " (2060, 7): 27.15268349647522,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 11.299611210823059,\n", + " (2060, 12): 86.25049686431885},\n", + " 'window': {(2060, 1): 64.22991275787354,\n", + " (2060, 2): 33.644176602363586,\n", + " (2060, 3): 26.31357741355896,\n", + " (2060, 4): 27.337915897369385,\n", + " (2060, 5): 10.871824979782104,\n", + " (2060, 6): 5.10566771030426,\n", + " (2060, 7): 10.00497579574585,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 9.318687915802002,\n", + " (2060, 12): 42.11281394958496}},\n", + " 54: {'monthly': {(2060, 1): 276.67508256435394,\n", + " (2060, 2): 62.4969801902771,\n", + " (2060, 3): 66.46016669273376,\n", + " (2060, 4): 38.3826961517334,\n", + " (2060, 5): 19.943756580352783,\n", + " (2060, 6): 15.26547646522522,\n", + " (2060, 7): 26.045981884002686,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 1.1605983972549438,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 11.695985078811646,\n", + " (2060, 12): 83.78844320774078},\n", + " 'window': {(2060, 1): 75.07154750823975,\n", + " (2060, 2): 30.190932631492615,\n", + " (2060, 3): 27.413180112838745,\n", + " (2060, 4): 30.423236846923828,\n", + " (2060, 5): 7.782383680343628,\n", + " (2060, 6): 5.10566771030426,\n", + " (2060, 7): 10.771381616592407,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 1.1605983972549438,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 8.668020009994507,\n", + " (2060, 12): 40.10166668891907}},\n", + " 55: {'monthly': {(2060, 1): 256.55820286273956,\n", + " (2060, 2): 64.56242799758911,\n", + " (2060, 3): 67.34674417972565,\n", + " (2060, 4): 40.11650240421295,\n", + " (2060, 5): 16.999387860298157,\n", + " (2060, 6): 16.498343229293823,\n", + " (2060, 7): 24.96134376525879,\n", + " (2060, 8): 1.0266549587249756,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 1.0812721252441406,\n", + " (2060, 11): 11.962963819503784,\n", + " (2060, 12): 72.541916847229},\n", + " 'window': {(2060, 1): 75.47796058654785,\n", + " (2060, 2): 31.543598294258118,\n", + " (2060, 3): 26.78738045692444,\n", + " (2060, 4): 32.83000457286835,\n", + " (2060, 5): 6.283385157585144,\n", + " (2060, 6): 5.10566771030426,\n", + " (2060, 7): 10.91094970703125,\n", + " (2060, 8): 1.0266549587249756,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 1.0812721252441406,\n", + " (2060, 11): 9.583699464797974,\n", + " (2060, 12): 34.68029713630676}},\n", + " 56: {'monthly': {(2060, 1): 257.0462359189987,\n", + " (2060, 2): 65.40068066120148,\n", + " (2060, 3): 59.88535284996033,\n", + " (2060, 4): 36.76952874660492,\n", + " (2060, 5): 17.226311206817627,\n", + " (2060, 6): 18.407957673072815,\n", + " (2060, 7): 22.947332620620728,\n", + " (2060, 8): 1.0269986391067505,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 11.929160714149475,\n", + " (2060, 12): 64.79909360408783},\n", + " 'window': {(2060, 1): 71.10840034484863,\n", + " (2060, 2): 33.15618133544922,\n", + " (2060, 3): 27.737991094589233,\n", + " (2060, 4): 32.075066804885864,\n", + " (2060, 5): 5.898266673088074,\n", + " (2060, 6): 6.118122816085815,\n", + " (2060, 7): 11.226681232452393,\n", + " (2060, 8): 1.0269986391067505,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 10.239583849906921,\n", + " (2060, 12): 29.841508865356445}},\n", + " 57: {'monthly': {(2060, 1): 282.7937602996826,\n", + " (2060, 2): 81.02010464668274,\n", + " (2060, 3): 74.17176043987274,\n", + " (2060, 4): 44.05560767650604,\n", + " (2060, 5): 37.076887130737305,\n", + " (2060, 6): 20.709493398666382,\n", + " (2060, 7): 42.1733455657959,\n", + " (2060, 8): 1.3837918043136597,\n", + " (2060, 9): 2.217339515686035,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 13.555376052856445,\n", + " (2060, 12): 96.42646145820618},\n", + " 'window': {(2060, 1): 76.16033267974854,\n", + " (2060, 2): 44.5261549949646,\n", + " (2060, 3): 28.00990867614746,\n", + " (2060, 4): 24.551158905029297,\n", + " (2060, 5): 13.080930709838867,\n", + " (2060, 6): 5.856213808059692,\n", + " (2060, 7): 16.94681739807129,\n", + " (2060, 8): 1.3837918043136597,\n", + " (2060, 9): 1.2169182300567627,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 8.620388746261597,\n", + " (2060, 12): 44.9322943687439}},\n", + " 58: {'monthly': {(2060, 1): 302.1357239484787,\n", + " (2060, 2): 87.6518737077713,\n", + " (2060, 3): 96.81672382354736,\n", + " (2060, 4): 49.37209236621857,\n", + " (2060, 5): 43.68092584609985,\n", + " (2060, 6): 25.714060187339783,\n", + " (2060, 7): 60.80825459957123,\n", + " (2060, 8): 2.5441832542419434,\n", + " (2060, 9): 2.4054065942764282,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 14.501908659934998,\n", + " (2060, 12): 99.73211181163788},\n", + " 'window': {(2060, 1): 85.13810539245605,\n", + " (2060, 2): 46.63560724258423,\n", + " (2060, 3): 39.568392515182495,\n", + " (2060, 4): 26.011451959609985,\n", + " (2060, 5): 15.48485517501831,\n", + " (2060, 6): 5.823116064071655,\n", + " (2060, 7): 24.86955201625824,\n", + " (2060, 8): 1.480594515800476,\n", + " (2060, 9): 1.4049853086471558,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 8.298777103424072,\n", + " (2060, 12): 47.08159923553467}},\n", + " 59: {'monthly': {(2060, 1): 280.5918091535568,\n", + " (2060, 2): 76.78378939628601,\n", + " (2060, 3): 103.15467810630798,\n", + " (2060, 4): 45.70095455646515,\n", + " (2060, 5): 46.743781208992004,\n", + " (2060, 6): 22.75943636894226,\n", + " (2060, 7): 66.77107536792755,\n", + " (2060, 8): 2.174009919166565,\n", + " (2060, 9): 2.788538098335266,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 15.498019933700562,\n", + " (2060, 12): 104.03657591342926},\n", + " 'window': {(2060, 1): 85.21144390106201,\n", + " (2060, 2): 39.69208884239197,\n", + " (2060, 3): 43.803524017333984,\n", + " (2060, 4): 22.774666905403137,\n", + " (2060, 5): 17.980945348739624,\n", + " (2060, 6): 6.0052220821380615,\n", + " (2060, 7): 30.459508299827576,\n", + " (2060, 8): 1.1018433570861816,\n", + " (2060, 9): 1.7881168127059937,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 9.594896912574768,\n", + " (2060, 12): 51.66110563278198}},\n", + " 60: {'monthly': {(2060, 1): 268.0081123113632,\n", + " (2060, 2): 85.52336835861206,\n", + " (2060, 3): 107.8065857887268,\n", + " (2060, 4): 40.294859409332275,\n", + " (2060, 5): 52.18461990356445,\n", + " (2060, 6): 25.9208664894104,\n", + " (2060, 7): 82.13771438598633,\n", + " (2060, 8): 1.968593716621399,\n", + " (2060, 9): 3.331012725830078,\n", + " (2060, 10): 1.9116733074188232,\n", + " (2060, 11): 24.26675319671631,\n", + " (2060, 12): 125.94556701183319},\n", + " 'window': {(2060, 1): 75.16982460021973,\n", + " (2060, 2): 49.43004250526428,\n", + " (2060, 3): 52.142391204833984,\n", + " (2060, 4): 17.15020263195038,\n", + " (2060, 5): 19.942180156707764,\n", + " (2060, 6): 8.78093671798706,\n", + " (2060, 7): 38.58820867538452,\n", + " (2060, 8): 1.968593716621399,\n", + " (2060, 9): 1.313759446144104,\n", + " (2060, 10): 1.9116733074188232,\n", + " (2060, 11): 15.726274013519287,\n", + " (2060, 12): 66.37209939956665}},\n", + " 61: {'monthly': {(2060, 1): 292.7888967990875,\n", + " (2060, 2): 109.16780197620392,\n", + " (2060, 3): 109.11694657802582,\n", + " (2060, 4): 48.500935792922974,\n", + " (2060, 5): 67.15955424308777,\n", + " (2060, 6): 25.905744552612305,\n", + " (2060, 7): 50.568225383758545,\n", + " (2060, 8): 5.09878945350647,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 1.8677104711532593,\n", + " (2060, 11): 34.522743344306946,\n", + " (2060, 12): 203.05811822414398},\n", + " 'window': {(2060, 1): 79.46556949615479,\n", + " (2060, 2): 45.08935594558716,\n", + " (2060, 3): 34.89474964141846,\n", + " (2060, 4): 26.052758932113647,\n", + " (2060, 5): 23.03054141998291,\n", + " (2060, 6): 11.202951908111572,\n", + " (2060, 7): 22.62111473083496,\n", + " (2060, 8): 4.079599976539612,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 1.8677104711532593,\n", + " (2060, 11): 19.993054032325745,\n", + " (2060, 12): 83.62812042236328}},\n", + " 62: {'monthly': {(2060, 1): 313.5308508872986,\n", + " (2060, 2): 123.57570147514343,\n", + " (2060, 3): 116.73240900039673,\n", + " (2060, 4): 61.57898247241974,\n", + " (2060, 5): 77.26106441020966,\n", + " (2060, 6): 29.3266783952713,\n", + " (2060, 7): 62.26579201221466,\n", + " (2060, 8): 5.637094259262085,\n", + " (2060, 9): 2.1040163040161133,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 33.75892102718353,\n", + " (2060, 12): 217.09416830539703},\n", + " 'window': {(2060, 1): 85.37635898590088,\n", + " (2060, 2): 43.62989282608032,\n", + " (2060, 3): 34.1554479598999,\n", + " (2060, 4): 36.99854898452759,\n", + " (2060, 5): 26.887775421142578,\n", + " (2060, 6): 13.242567658424377,\n", + " (2060, 7): 28.925058364868164,\n", + " (2060, 8): 4.617904782295227,\n", + " (2060, 9): 1.096472978591919,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 20.306493401527405,\n", + " (2060, 12): 94.40996360778809}},\n", + " 63: {'monthly': {(2060, 1): 333.19602513313293,\n", + " (2060, 2): 128.08823037147522,\n", + " (2060, 3): 126.83178520202637,\n", + " (2060, 4): 75.66251623630524,\n", + " (2060, 5): 95.61656475067139,\n", + " (2060, 6): 32.58041524887085,\n", + " (2060, 7): 77.56253051757812,\n", + " (2060, 8): 6.960810899734497,\n", + " (2060, 9): 4.214321136474609,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 32.24674463272095,\n", + " (2060, 12): 253.861119389534},\n", + " 'window': {(2060, 1): 89.35568904876709,\n", + " (2060, 2): 43.541112184524536,\n", + " (2060, 3): 39.29679727554321,\n", + " (2060, 4): 44.915099143981934,\n", + " (2060, 5): 37.04738163948059,\n", + " (2060, 6): 14.553873777389526,\n", + " (2060, 7): 36.055237770080566,\n", + " (2060, 8): 5.941621422767639,\n", + " (2060, 9): 1.7552034854888916,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 18.64852774143219,\n", + " (2060, 12): 105.69898223876953}},\n", + " 64: {'monthly': {(2060, 1): 285.6768088340759,\n", + " (2060, 2): 111.06377422809601,\n", + " (2060, 3): 104.3330717086792,\n", + " (2060, 4): 65.22247278690338,\n", + " (2060, 5): 93.03929150104523,\n", + " (2060, 6): 27.736902594566345,\n", + " (2060, 7): 63.00870990753174,\n", + " (2060, 8): 6.559736490249634,\n", + " (2060, 9): 1.4047093391418457,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 27.343021512031555,\n", + " (2060, 12): 226.40019130706787},\n", + " 'window': {(2060, 1): 76.66573810577393,\n", + " (2060, 2): 39.45415282249451,\n", + " (2060, 3): 34.79050064086914,\n", + " (2060, 4): 41.11890363693237,\n", + " (2060, 5): 37.210943818092346,\n", + " (2060, 6): 10.624871730804443,\n", + " (2060, 7): 29.069994688034058,\n", + " (2060, 8): 5.540547013282776,\n", + " (2060, 9): 1.4047093391418457,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 15.924410581588745,\n", + " (2060, 12): 98.20166873931885}},\n", + " 65: {'monthly': {(2060, 1): 440.82160449028015,\n", + " (2060, 2): 117.44339263439178,\n", + " (2060, 3): 69.91033148765564,\n", + " (2060, 4): 17.588761925697327,\n", + " (2060, 5): 19.851252555847168,\n", + " (2060, 6): 11.146860599517822,\n", + " (2060, 7): 22.507132053375244,\n", + " (2060, 8): 1.321013331413269,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 1.3135926723480225,\n", + " (2060, 11): 23.328718066215515,\n", + " (2060, 12): 134.64372944831848},\n", + " 'window': {(2060, 1): 168.71145725250244,\n", + " (2060, 2): 50.760831117630005,\n", + " (2060, 3): 22.366604804992676,\n", + " (2060, 4): 11.661816120147705,\n", + " (2060, 5): 7.053223013877869,\n", + " (2060, 6): 5.541702628135681,\n", + " (2060, 7): 7.036111116409302,\n", + " (2060, 8): 1.321013331413269,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 1.3135926723480225,\n", + " (2060, 11): 11.897464752197266,\n", + " (2060, 12): 76.34305763244629}},\n", + " 66: {'monthly': {(2060, 1): 312.22875893116,\n", + " (2060, 2): 61.02839779853821,\n", + " (2060, 3): 62.05899119377136,\n", + " (2060, 4): 37.73780298233032,\n", + " (2060, 5): 28.908432245254517,\n", + " (2060, 6): 14.497554302215576,\n", + " (2060, 7): 22.923054099082947,\n", + " (2060, 8): 2.0626766681671143,\n", + " (2060, 9): 1.123965859413147,\n", + " (2060, 10): 1.4419366121292114,\n", + " (2060, 11): 23.246323108673096,\n", + " (2060, 12): 122.93814408779144},\n", + " 'window': {(2060, 1): 79.7134370803833,\n", + " (2060, 2): 22.0250186920166,\n", + " (2060, 3): 17.716933369636536,\n", + " (2060, 4): 24.71159517765045,\n", + " (2060, 5): 12.526257991790771,\n", + " (2060, 6): 5.7512863874435425,\n", + " (2060, 7): 8.678116202354431,\n", + " (2060, 8): 2.0626766681671143,\n", + " (2060, 9): 1.123965859413147,\n", + " (2060, 10): 1.4419366121292114,\n", + " (2060, 11): 14.503892421722412,\n", + " (2060, 12): 38.45936393737793}},\n", + " 67: {'monthly': {(2060, 1): 316.76981461048126,\n", + " (2060, 2): 56.90897214412689,\n", + " (2060, 3): 63.09960663318634,\n", + " (2060, 4): 38.9472873210907,\n", + " (2060, 5): 26.930855751037598,\n", + " (2060, 6): 14.426434755325317,\n", + " (2060, 7): 25.620975017547607,\n", + " (2060, 8): 2.0626766681671143,\n", + " (2060, 9): 1.123965859413147,\n", + " (2060, 10): 1.4419366121292114,\n", + " (2060, 11): 19.19044852256775,\n", + " (2060, 12): 111.81461441516876},\n", + " 'window': {(2060, 1): 86.39096164703369,\n", + " (2060, 2): 20.37047290802002,\n", + " (2060, 3): 17.866928219795227,\n", + " (2060, 4): 25.744431853294373,\n", + " (2060, 5): 11.684890747070312,\n", + " (2060, 6): 5.636223196983337,\n", + " (2060, 7): 10.62198281288147,\n", + " (2060, 8): 2.0626766681671143,\n", + " (2060, 9): 1.123965859413147,\n", + " (2060, 10): 1.4419366121292114,\n", + " (2060, 11): 11.54584527015686,\n", + " (2060, 12): 39.52672004699707}},\n", + " 68: {'monthly': {(2060, 1): 322.3554049730301,\n", + " (2060, 2): 62.581493735313416,\n", + " (2060, 3): 63.77372682094574,\n", + " (2060, 4): 37.02615809440613,\n", + " (2060, 5): 29.80863320827484,\n", + " (2060, 6): 14.650118827819824,\n", + " (2060, 7): 27.388354778289795,\n", + " (2060, 8): 2.0626766681671143,\n", + " (2060, 9): 1.123965859413147,\n", + " (2060, 10): 1.4419366121292114,\n", + " (2060, 11): 18.028217911720276,\n", + " (2060, 12): 109.98302471637726},\n", + " 'window': {(2060, 1): 92.82952213287354,\n", + " (2060, 2): 23.898328065872192,\n", + " (2060, 3): 19.627105712890625,\n", + " (2060, 4): 22.37584114074707,\n", + " (2060, 5): 12.316118717193604,\n", + " (2060, 6): 5.636223196983337,\n", + " (2060, 7): 12.323124051094055,\n", + " (2060, 8): 2.0626766681671143,\n", + " (2060, 9): 1.123965859413147,\n", + " (2060, 10): 1.4419366121292114,\n", + " (2060, 11): 9.03768002986908,\n", + " (2060, 12): 46.60901403427124}},\n", + " 69: {'monthly': {(2060, 1): 324.8189243078232,\n", + " (2060, 2): 55.95040559768677,\n", + " (2060, 3): 70.72991800308228,\n", + " (2060, 4): 33.54911279678345,\n", + " (2060, 5): 35.5138943195343,\n", + " (2060, 6): 14.84165632724762,\n", + " (2060, 7): 28.772228240966797,\n", + " (2060, 8): 2.0626766681671143,\n", + " (2060, 9): 1.123965859413147,\n", + " (2060, 10): 1.4419366121292114,\n", + " (2060, 11): 14.335809111595154,\n", + " (2060, 12): 126.17200827598572},\n", + " 'window': {(2060, 1): 91.49054431915283,\n", + " (2060, 2): 20.217908263206482,\n", + " (2060, 3): 20.39297604560852,\n", + " (2060, 4): 19.547980427742004,\n", + " (2060, 5): 13.250032782554626,\n", + " (2060, 6): 5.744196534156799,\n", + " (2060, 7): 12.905387282371521,\n", + " (2060, 8): 2.0626766681671143,\n", + " (2060, 9): 1.123965859413147,\n", + " (2060, 10): 1.4419366121292114,\n", + " (2060, 11): 9.382394552230835,\n", + " (2060, 12): 54.73699378967285}},\n", + " 70: {'monthly': {(2060, 1): 273.48149716854095,\n", + " (2060, 2): 71.21043074131012,\n", + " (2060, 3): 89.44484567642212,\n", + " (2060, 4): 58.11458194255829,\n", + " (2060, 5): 45.45301914215088,\n", + " (2060, 6): 17.846460342407227,\n", + " (2060, 7): 41.75258672237396,\n", + " (2060, 8): 2.3134970664978027,\n", + " (2060, 9): 2.456578493118286,\n", + " (2060, 10): 4.1994582414627075,\n", + " (2060, 11): 25.34469425678253,\n", + " (2060, 12): 141.88000082969666},\n", + " 'window': {(2060, 1): 68.95414924621582,\n", + " (2060, 2): 28.07396936416626,\n", + " (2060, 3): 20.62586760520935,\n", + " (2060, 4): 31.7016921043396,\n", + " (2060, 5): 19.999135494232178,\n", + " (2060, 6): 5.86623227596283,\n", + " (2060, 7): 17.870219826698303,\n", + " (2060, 8): 2.3134970664978027,\n", + " (2060, 9): 1.2673903703689575,\n", + " (2060, 10): 1.5223034620285034,\n", + " (2060, 11): 15.332367062568665,\n", + " (2060, 12): 56.66273736953735}},\n", + " 71: {'monthly': {(2060, 1): 319.5482647418976,\n", + " (2060, 2): 77.09079074859619,\n", + " (2060, 3): 100.95844376087189,\n", + " (2060, 4): 71.83154308795929,\n", + " (2060, 5): 55.0343142747879,\n", + " (2060, 6): 18.393476366996765,\n", + " (2060, 7): 52.83565032482147,\n", + " (2060, 8): 4.688014268875122,\n", + " (2060, 9): 1.2673903703689575,\n", + " (2060, 10): 2.7917709350585938,\n", + " (2060, 11): 20.346505165100098,\n", + " (2060, 12): 136.0959131717682},\n", + " 'window': {(2060, 1): 92.64527130126953,\n", + " (2060, 2): 27.503440141677856,\n", + " (2060, 3): 27.04041051864624,\n", + " (2060, 4): 38.4141263961792,\n", + " (2060, 5): 25.562686800956726,\n", + " (2060, 6): 5.86623227596283,\n", + " (2060, 7): 27.137770771980286,\n", + " (2060, 8): 2.6003055572509766,\n", + " (2060, 9): 1.2673903703689575,\n", + " (2060, 10): 2.7917709350585938,\n", + " (2060, 11): 11.462571501731873,\n", + " (2060, 12): 58.062453269958496}},\n", + " 72: {'monthly': {(2060, 1): 316.17099046707153,\n", + " (2060, 2): 78.97496008872986,\n", + " (2060, 3): 96.2623496055603,\n", + " (2060, 4): 66.1089096069336,\n", + " (2060, 5): 51.34284234046936,\n", + " (2060, 6): 17.77188217639923,\n", + " (2060, 7): 53.928178548812866,\n", + " (2060, 8): 2.5614521503448486,\n", + " (2060, 9): 1.2673903703689575,\n", + " (2060, 10): 1.5223034620285034,\n", + " (2060, 11): 23.40457773208618,\n", + " (2060, 12): 125.96637105941772},\n", + " 'window': {(2060, 1): 110.33886623382568,\n", + " (2060, 2): 24.333059549331665,\n", + " (2060, 3): 26.685064792633057,\n", + " (2060, 4): 34.44007182121277,\n", + " (2060, 5): 22.722108960151672,\n", + " (2060, 6): 5.86623227596283,\n", + " (2060, 7): 28.638453125953674,\n", + " (2060, 8): 2.5614521503448486,\n", + " (2060, 9): 1.2673903703689575,\n", + " (2060, 10): 1.5223034620285034,\n", + " (2060, 11): 11.349576234817505,\n", + " (2060, 12): 51.04387331008911}},\n", + " 73: {'monthly': {(2060, 1): 369.699627161026,\n", + " (2060, 2): 86.67124009132385,\n", + " (2060, 3): 118.17396032810211,\n", + " (2060, 4): 55.57394731044769,\n", + " (2060, 5): 45.394081115722656,\n", + " (2060, 6): 15.541659355163574,\n", + " (2060, 7): 44.04018700122833,\n", + " (2060, 8): 2.3134970664978027,\n", + " (2060, 9): 1.2673903703689575,\n", + " (2060, 10): 1.5223034620285034,\n", + " (2060, 11): 23.929792881011963,\n", + " (2060, 12): 154.37221360206604},\n", + " 'window': {(2060, 1): 128.4540843963623,\n", + " (2060, 2): 29.962133646011353,\n", + " (2060, 3): 41.01997637748718,\n", + " (2060, 4): 31.378995656967163,\n", + " (2060, 5): 17.312564730644226,\n", + " (2060, 6): 5.86623227596283,\n", + " (2060, 7): 21.556610941886902,\n", + " (2060, 8): 2.3134970664978027,\n", + " (2060, 9): 1.2673903703689575,\n", + " (2060, 10): 1.5223034620285034,\n", + " (2060, 11): 11.96220588684082,\n", + " (2060, 12): 56.252963066101074}},\n", + " 74: {'monthly': {(2060, 1): 388.9918305873871,\n", + " (2060, 2): 134.17182052135468,\n", + " (2060, 3): 126.3960348367691,\n", + " (2060, 4): 51.076454162597656,\n", + " (2060, 5): 91.84212839603424,\n", + " (2060, 6): 20.335734605789185,\n", + " (2060, 7): 37.60754585266113,\n", + " (2060, 8): 4.91690456867218,\n", + " (2060, 9): 3.564685344696045,\n", + " (2060, 10): 1.6158994436264038,\n", + " (2060, 11): 56.6979101896286,\n", + " (2060, 12): 228.15455400943756},\n", + " 'window': {(2060, 1): 109.09965324401855,\n", + " (2060, 2): 56.47064161300659,\n", + " (2060, 3): 38.70751190185547,\n", + " (2060, 4): 36.2473464012146,\n", + " (2060, 5): 36.52785134315491,\n", + " (2060, 6): 8.619094848632812,\n", + " (2060, 7): 14.343244552612305,\n", + " (2060, 8): 2.1939847469329834,\n", + " (2060, 9): 3.564685344696045,\n", + " (2060, 10): 1.6158994436264038,\n", + " (2060, 11): 42.87330448627472,\n", + " (2060, 12): 78.01604270935059}},\n", + " 75: {'monthly': {(2060, 1): 367.2069035768509,\n", + " (2060, 2): 131.86600852012634,\n", + " (2060, 3): 96.31517386436462,\n", + " (2060, 4): 53.26142418384552,\n", + " (2060, 5): 68.35181558132172,\n", + " (2060, 6): 14.457128286361694,\n", + " (2060, 7): 38.952268242836,\n", + " (2060, 8): 3.734847664833069,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 43.787002086639404,\n", + " (2060, 12): 209.79356408119202},\n", + " 'window': {(2060, 1): 92.27061080932617,\n", + " (2060, 2): 61.612040758132935,\n", + " (2060, 3): 28.250245809555054,\n", + " (2060, 4): 39.622140645980835,\n", + " (2060, 5): 27.701233625411987,\n", + " (2060, 6): 4.990707993507385,\n", + " (2060, 7): 14.304802179336548,\n", + " (2060, 8): 1.4897879362106323,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 34.588873744010925,\n", + " (2060, 12): 73.99304103851318}},\n", + " 76: {'monthly': {(2060, 1): 379.80610513687134,\n", + " (2060, 2): 134.55282390117645,\n", + " (2060, 3): 101.20725095272064,\n", + " (2060, 4): 59.58903205394745,\n", + " (2060, 5): 65.97609984874725,\n", + " (2060, 6): 16.80138599872589,\n", + " (2060, 7): 41.151153922080994,\n", + " (2060, 8): 4.569647312164307,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 1.9068387746810913,\n", + " (2060, 11): 47.5063111782074,\n", + " (2060, 12): 224.52323782444},\n", + " 'window': {(2060, 1): 99.97816276550293,\n", + " (2060, 2): 66.8801097869873,\n", + " (2060, 3): 29.628304958343506,\n", + " (2060, 4): 44.20674109458923,\n", + " (2060, 5): 25.050671815872192,\n", + " (2060, 6): 6.325380802154541,\n", + " (2060, 7): 16.162364721298218,\n", + " (2060, 8): 2.9563634395599365,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 1.9068387746810913,\n", + " (2060, 11): 35.852142691612244,\n", + " (2060, 12): 80.58587837219238}},\n", + " 77: {'monthly': {(2060, 1): 338.95785546302795,\n", + " (2060, 2): 123.3495522737503,\n", + " (2060, 3): 88.18939626216888,\n", + " (2060, 4): 57.59814095497131,\n", + " (2060, 5): 72.0820780992508,\n", + " (2060, 6): 20.115527391433716,\n", + " (2060, 7): 40.04071581363678,\n", + " (2060, 8): 4.684894919395447,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 46.856433510780334,\n", + " (2060, 12): 199.78466284275055},\n", + " 'window': {(2060, 1): 86.15724277496338,\n", + " (2060, 2): 60.38109302520752,\n", + " (2060, 3): 24.724022269248962,\n", + " (2060, 4): 42.53684616088867,\n", + " (2060, 5): 28.339208126068115,\n", + " (2060, 6): 5.144341826438904,\n", + " (2060, 7): 14.559879779815674,\n", + " (2060, 8): 2.9416805505752563,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 39.4331237077713,\n", + " (2060, 12): 74.09885549545288}},\n", + " 78: {'monthly': {(2060, 1): 479.0052785873413,\n", + " (2060, 2): 96.80853509902954,\n", + " (2060, 3): 69.51140129566193,\n", + " (2060, 4): 15.317222237586975,\n", + " (2060, 5): 20.524593353271484,\n", + " (2060, 6): 10.66771948337555,\n", + " (2060, 7): 20.299644231796265,\n", + " (2060, 8): 1.321013331413269,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 1.3135926723480225,\n", + " (2060, 11): 28.324092507362366,\n", + " (2060, 12): 133.91616702079773},\n", + " 'window': {(2060, 1): 187.89316749572754,\n", + " (2060, 2): 36.21365177631378,\n", + " (2060, 3): 22.47821569442749,\n", + " (2060, 4): 10.588765263557434,\n", + " (2060, 5): 6.619479060173035,\n", + " (2060, 6): 4.909204721450806,\n", + " (2060, 7): 6.865109443664551,\n", + " (2060, 8): 1.321013331413269,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 1.3135926723480225,\n", + " (2060, 11): 13.72850787639618,\n", + " (2060, 12): 86.08967328071594}},\n", + " 79: {'monthly': {(2060, 1): 317.1194314956665,\n", + " (2060, 2): 63.922648668289185,\n", + " (2060, 3): 67.60525476932526,\n", + " (2060, 4): 37.030288338661194,\n", + " (2060, 5): 26.40389621257782,\n", + " (2060, 6): 14.296127200126648,\n", + " (2060, 7): 22.495447874069214,\n", + " (2060, 8): 2.0626766681671143,\n", + " (2060, 9): 1.123965859413147,\n", + " (2060, 10): 1.4419366121292114,\n", + " (2060, 11): 16.245019912719727,\n", + " (2060, 12): 112.13282775878906},\n", + " 'window': {(2060, 1): 91.86346340179443,\n", + " (2060, 2): 25.845792770385742,\n", + " (2060, 3): 21.88513422012329,\n", + " (2060, 4): 25.0652437210083,\n", + " (2060, 5): 11.56886339187622,\n", + " (2060, 6): 5.636223196983337,\n", + " (2060, 7): 7.952935814857483,\n", + " (2060, 8): 2.0626766681671143,\n", + " (2060, 9): 1.123965859413147,\n", + " (2060, 10): 1.4419366121292114,\n", + " (2060, 11): 9.63930058479309,\n", + " (2060, 12): 49.02622699737549}},\n", + " 80: {'monthly': {(2060, 1): 318.23274970054626,\n", + " (2060, 2): 59.23455214500427,\n", + " (2060, 3): 67.64131247997284,\n", + " (2060, 4): 38.625646233558655,\n", + " (2060, 5): 30.21599316596985,\n", + " (2060, 6): 14.357846856117249,\n", + " (2060, 7): 24.656868934631348,\n", + " (2060, 8): 2.0626766681671143,\n", + " (2060, 9): 1.123965859413147,\n", + " (2060, 10): 1.4419366121292114,\n", + " (2060, 11): 16.156139731407166,\n", + " (2060, 12): 103.72131931781769},\n", + " 'window': {(2060, 1): 96.81490516662598,\n", + " (2060, 2): 24.367602109909058,\n", + " (2060, 3): 19.889241099357605,\n", + " (2060, 4): 25.908962726593018,\n", + " (2060, 5): 12.45184588432312,\n", + " (2060, 6): 5.636223196983337,\n", + " (2060, 7): 10.004213452339172,\n", + " (2060, 8): 2.0626766681671143,\n", + " (2060, 9): 1.123965859413147,\n", + " (2060, 10): 1.4419366121292114,\n", + " (2060, 11): 9.413218975067139,\n", + " (2060, 12): 41.61114192008972}},\n", + " 81: {'monthly': {(2060, 1): 350.5846199989319,\n", + " (2060, 2): 61.55046367645264,\n", + " (2060, 3): 77.11431789398193,\n", + " (2060, 4): 44.07606375217438,\n", + " (2060, 5): 37.87879729270935,\n", + " (2060, 6): 14.911463618278503,\n", + " (2060, 7): 35.15776979923248,\n", + " (2060, 8): 3.149235486984253,\n", + " (2060, 9): 1.123965859413147,\n", + " (2060, 10): 1.4419366121292114,\n", + " (2060, 11): 20.00441551208496,\n", + " (2060, 12): 122.06010508537292},\n", + " 'window': {(2060, 1): 105.89646434783936,\n", + " (2060, 2): 21.64918851852417,\n", + " (2060, 3): 24.228016138076782,\n", + " (2060, 4): 24.267539381980896,\n", + " (2060, 5): 15.133147239685059,\n", + " (2060, 6): 5.809334993362427,\n", + " (2060, 7): 15.843757033348083,\n", + " (2060, 8): 2.0626766681671143,\n", + " (2060, 9): 1.123965859413147,\n", + " (2060, 10): 1.4419366121292114,\n", + " (2060, 11): 12.667652368545532,\n", + " (2060, 12): 52.11162281036377}},\n", + " 82: {'monthly': {(2060, 1): 368.0686823129654,\n", + " (2060, 2): 64.5307469367981,\n", + " (2060, 3): 91.66552138328552,\n", + " (2060, 4): 44.940720558166504,\n", + " (2060, 5): 43.604971051216125,\n", + " (2060, 6): 17.431106686592102,\n", + " (2060, 7): 38.931607365608215,\n", + " (2060, 8): 2.0626766681671143,\n", + " (2060, 9): 1.1511561870574951,\n", + " (2060, 10): 1.4419366121292114,\n", + " (2060, 11): 22.737848162651062,\n", + " (2060, 12): 146.93475019931793},\n", + " 'window': {(2060, 1): 109.03694248199463,\n", + " (2060, 2): 22.223602414131165,\n", + " (2060, 3): 29.62155508995056,\n", + " (2060, 4): 22.792277693748474,\n", + " (2060, 5): 17.568761467933655,\n", + " (2060, 6): 5.715153932571411,\n", + " (2060, 7): 18.32393515110016,\n", + " (2060, 8): 2.0626766681671143,\n", + " (2060, 9): 1.1511561870574951,\n", + " (2060, 10): 1.4419366121292114,\n", + " (2060, 11): 13.077733397483826,\n", + " (2060, 12): 65.934814453125}},\n", + " 83: {'monthly': {(2060, 1): 328.6817362308502,\n", + " (2060, 2): 75.21770143508911,\n", + " (2060, 3): 113.64237594604492,\n", + " (2060, 4): 65.14501011371613,\n", + " (2060, 5): 52.81231653690338,\n", + " (2060, 6): 17.851176500320435,\n", + " (2060, 7): 44.32062542438507,\n", + " (2060, 8): 2.3611903190612793,\n", + " (2060, 9): 1.2673903703689575,\n", + " (2060, 10): 1.5223034620285034,\n", + " (2060, 11): 23.610796332359314,\n", + " (2060, 12): 150.48762321472168},\n", + " 'window': {(2060, 1): 92.72584438323975,\n", + " (2060, 2): 27.523765325546265,\n", + " (2060, 3): 29.17415714263916,\n", + " (2060, 4): 35.820679664611816,\n", + " (2060, 5): 22.55817997455597,\n", + " (2060, 6): 6.061040759086609,\n", + " (2060, 7): 20.530491948127747,\n", + " (2060, 8): 2.3611903190612793,\n", + " (2060, 9): 1.2673903703689575,\n", + " (2060, 10): 1.5223034620285034,\n", + " (2060, 11): 14.17027997970581,\n", + " (2060, 12): 56.83610391616821}},\n", + " 84: {'monthly': {(2060, 1): 383.7928560972214,\n", + " (2060, 2): 85.51665949821472,\n", + " (2060, 3): 114.45814776420593,\n", + " (2060, 4): 85.10443842411041,\n", + " (2060, 5): 64.51207220554352,\n", + " (2060, 6): 23.759783029556274,\n", + " (2060, 7): 66.81133997440338,\n", + " (2060, 8): 2.5552412271499634,\n", + " (2060, 9): 3.1704635620117188,\n", + " (2060, 10): 1.5223034620285034,\n", + " (2060, 11): 27.643977999687195,\n", + " (2060, 12): 153.8898881673813},\n", + " 'window': {(2060, 1): 120.80051231384277,\n", + " (2060, 2): 34.4380156993866,\n", + " (2060, 3): 34.70024919509888,\n", + " (2060, 4): 43.03343892097473,\n", + " (2060, 5): 28.670778632164,\n", + " (2060, 6): 7.712748050689697,\n", + " (2060, 7): 34.13818109035492,\n", + " (2060, 8): 2.5552412271499634,\n", + " (2060, 9): 3.1704635620117188,\n", + " (2060, 10): 1.5223034620285034,\n", + " (2060, 11): 16.744316339492798,\n", + " (2060, 12): 60.977970600128174}},\n", + " 85: {'monthly': {(2060, 1): 393.9501714706421,\n", + " (2060, 2): 78.96040213108063,\n", + " (2060, 3): 113.28188955783844,\n", + " (2060, 4): 77.68404591083527,\n", + " (2060, 5): 64.46553933620453,\n", + " (2060, 6): 20.5709468126297,\n", + " (2060, 7): 62.35176730155945,\n", + " (2060, 8): 2.8247629404067993,\n", + " (2060, 9): 1.5278953313827515,\n", + " (2060, 10): 1.5223034620285034,\n", + " (2060, 11): 20.422205328941345,\n", + " (2060, 12): 139.1814591884613},\n", + " 'window': {(2060, 1): 140.94253635406494,\n", + " (2060, 2): 32.57849979400635,\n", + " (2060, 3): 37.7205286026001,\n", + " (2060, 4): 40.12187743186951,\n", + " (2060, 5): 24.676626563072205,\n", + " (2060, 6): 7.101553678512573,\n", + " (2060, 7): 31.683209538459778,\n", + " (2060, 8): 2.8247629404067993,\n", + " (2060, 9): 1.5278953313827515,\n", + " (2060, 10): 1.5223034620285034,\n", + " (2060, 11): 13.026127099990845,\n", + " (2060, 12): 56.41943025588989}},\n", + " 86: {'monthly': {(2060, 1): 419.85595655441284,\n", + " (2060, 2): 79.49583899974823,\n", + " (2060, 3): 128.8248748779297,\n", + " (2060, 4): 62.50209045410156,\n", + " (2060, 5): 48.236103773117065,\n", + " (2060, 6): 19.38513672351837,\n", + " (2060, 7): 43.53088021278381,\n", + " (2060, 8): 2.655559539794922,\n", + " (2060, 9): 1.2673903703689575,\n", + " (2060, 10): 1.5223034620285034,\n", + " (2060, 11): 26.97444748878479,\n", + " (2060, 12): 154.82994329929352},\n", + " 'window': {(2060, 1): 150.73272132873535,\n", + " (2060, 2): 28.888832330703735,\n", + " (2060, 3): 45.87191653251648,\n", + " (2060, 4): 33.83315110206604,\n", + " (2060, 5): 16.29389798641205,\n", + " (2060, 6): 5.86623227596283,\n", + " (2060, 7): 18.76491105556488,\n", + " (2060, 8): 2.655559539794922,\n", + " (2060, 9): 1.2673903703689575,\n", + " (2060, 10): 1.5223034620285034,\n", + " (2060, 11): 14.000438213348389,\n", + " (2060, 12): 61.717763900756836}},\n", + " 87: {'monthly': {(2060, 1): 336.4901565313339,\n", + " (2060, 2): 104.28246462345123,\n", + " (2060, 3): 100.02395367622375,\n", + " (2060, 4): 44.85862934589386,\n", + " (2060, 5): 63.785207986831665,\n", + " (2060, 6): 11.611026406288147,\n", + " (2060, 7): 20.621999740600586,\n", + " (2060, 8): 1.2253988981246948,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 32.51282739639282,\n", + " (2060, 12): 175.019322514534},\n", + " 'window': {(2060, 1): 115.56608200073242,\n", + " (2060, 2): 47.715970516204834,\n", + " (2060, 3): 32.79811334609985,\n", + " (2060, 4): 34.170438289642334,\n", + " (2060, 5): 27.542779445648193,\n", + " (2060, 6): 5.101590633392334,\n", + " (2060, 7): 8.035584449768066,\n", + " (2060, 8): 1.2253988981246948,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 26.681792855262756,\n", + " (2060, 12): 56.939335346221924}},\n", + " 88: {'monthly': {(2060, 1): 297.4255585670471,\n", + " (2060, 2): 106.11028957366943,\n", + " (2060, 3): 76.89649724960327,\n", + " (2060, 4): 42.18607234954834,\n", + " (2060, 5): 51.69560194015503,\n", + " (2060, 6): 10.737209916114807,\n", + " (2060, 7): 18.08592712879181,\n", + " (2060, 8): 1.2253988981246948,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 23.56732201576233,\n", + " (2060, 12): 154.51429629325867},\n", + " 'window': {(2060, 1): 92.5840072631836,\n", + " (2060, 2): 50.584925532341,\n", + " (2060, 3): 24.20361852645874,\n", + " (2060, 4): 35.71366477012634,\n", + " (2060, 5): 21.24505650997162,\n", + " (2060, 6): 4.990707993507385,\n", + " (2060, 7): 8.169375777244568,\n", + " (2060, 8): 1.2253988981246948,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 19.800487399101257,\n", + " (2060, 12): 51.745620250701904}},\n", + " 89: {'monthly': {(2060, 1): 290.22751331329346,\n", + " (2060, 2): 106.82257676124573,\n", + " (2060, 3): 76.08569490909576,\n", + " (2060, 4): 40.8287593126297,\n", + " (2060, 5): 40.08099615573883,\n", + " (2060, 6): 10.737209916114807,\n", + " (2060, 7): 19.353006601333618,\n", + " (2060, 8): 1.2253988981246948,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 20.912856221199036,\n", + " (2060, 12): 166.16331672668457},\n", + " 'window': {(2060, 1): 83.71950626373291,\n", + " (2060, 2): 55.03159761428833,\n", + " (2060, 3): 24.595417618751526,\n", + " (2060, 4): 34.73405599594116,\n", + " (2060, 5): 14.825575351715088,\n", + " (2060, 6): 4.990707993507385,\n", + " (2060, 7): 8.80367112159729,\n", + " (2060, 8): 1.2253988981246948,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 17.61918079853058,\n", + " (2060, 12): 58.785332679748535}},\n", + " 90: {'monthly': {(2060, 1): 277.87755250930786,\n", + " (2060, 2): 102.81260240077972,\n", + " (2060, 3): 67.39397430419922,\n", + " (2060, 4): 40.793168783187866,\n", + " (2060, 5): 40.87345468997955,\n", + " (2060, 6): 10.737209916114807,\n", + " (2060, 7): 19.000905632972717,\n", + " (2060, 8): 1.2253988981246948,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 28.202972531318665,\n", + " (2060, 12): 168.5834163427353},\n", + " 'window': {(2060, 1): 81.47146129608154,\n", + " (2060, 2): 56.85957956314087,\n", + " (2060, 3): 21.839052200317383,\n", + " (2060, 4): 33.158947229385376,\n", + " (2060, 5): 15.471238374710083,\n", + " (2060, 6): 4.990707993507385,\n", + " (2060, 7): 8.760943412780762,\n", + " (2060, 8): 1.2253988981246948,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 22.790839314460754,\n", + " (2060, 12): 59.97518825531006}},\n", + " 91: {'monthly': {(2060, 1): 463.4113487005234,\n", + " (2060, 2): 96.06723153591156,\n", + " (2060, 3): 73.22126412391663,\n", + " (2060, 4): 13.483752608299255,\n", + " (2060, 5): 20.602303504943848,\n", + " (2060, 6): 9.286963701248169,\n", + " (2060, 7): 19.830249905586243,\n", + " (2060, 8): 1.321013331413269,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 1.3135926723480225,\n", + " (2060, 11): 27.234530448913574,\n", + " (2060, 12): 172.6963014602661},\n", + " 'window': {(2060, 1): 201.45910263061523,\n", + " (2060, 2): 34.423466205596924,\n", + " (2060, 3): 25.111954927444458,\n", + " (2060, 4): 8.75462818145752,\n", + " (2060, 5): 6.382740497589111,\n", + " (2060, 6): 3.808173656463623,\n", + " (2060, 7): 6.865109443664551,\n", + " (2060, 8): 1.321013331413269,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 1.3135926723480225,\n", + " (2060, 11): 14.377599239349365,\n", + " (2060, 12): 112.7610719203949}},\n", + " 92: {'monthly': {(2060, 1): 349.1822053194046,\n", + " (2060, 2): 65.12733817100525,\n", + " (2060, 3): 67.83465242385864,\n", + " (2060, 4): 31.39475393295288,\n", + " (2060, 5): 27.938594698905945,\n", + " (2060, 6): 14.382491111755371,\n", + " (2060, 7): 20.648213028907776,\n", + " (2060, 8): 2.0626766681671143,\n", + " (2060, 9): 1.123965859413147,\n", + " (2060, 10): 1.4419366121292114,\n", + " (2060, 11): 19.026275038719177,\n", + " (2060, 12): 112.53922629356384},\n", + " 'window': {(2060, 1): 123.80176830291748,\n", + " (2060, 2): 25.47572886943817,\n", + " (2060, 3): 21.31007695198059,\n", + " (2060, 4): 21.17769968509674,\n", + " (2060, 5): 12.996211647987366,\n", + " (2060, 6): 5.636223196983337,\n", + " (2060, 7): 7.016363501548767,\n", + " (2060, 8): 2.0626766681671143,\n", + " (2060, 9): 1.123965859413147,\n", + " (2060, 10): 1.4419366121292114,\n", + " (2060, 11): 11.861252307891846,\n", + " (2060, 12): 48.31288194656372}},\n", + " 93: {'monthly': {(2060, 1): 354.81332981586456,\n", + " (2060, 2): 64.41723811626434,\n", + " (2060, 3): 73.41302442550659,\n", + " (2060, 4): 34.20954096317291,\n", + " (2060, 5): 30.57427752017975,\n", + " (2060, 6): 14.851759672164917,\n", + " (2060, 7): 23.351036310195923,\n", + " (2060, 8): 2.0626766681671143,\n", + " (2060, 9): 1.123965859413147,\n", + " (2060, 10): 1.4419366121292114,\n", + " (2060, 11): 17.49626851081848,\n", + " (2060, 12): 125.83943510055542},\n", + " 'window': {(2060, 1): 130.89419746398926,\n", + " (2060, 2): 24.420170545578003,\n", + " (2060, 3): 24.089011669158936,\n", + " (2060, 4): 21.918984174728394,\n", + " (2060, 5): 13.73715364933014,\n", + " (2060, 6): 5.636223196983337,\n", + " (2060, 7): 8.961331963539124,\n", + " (2060, 8): 2.0626766681671143,\n", + " (2060, 9): 1.123965859413147,\n", + " (2060, 10): 1.4419366121292114,\n", + " (2060, 11): 10.896298289299011,\n", + " (2060, 12): 48.16676568984985}},\n", + " 94: {'monthly': {(2060, 1): 421.9370194673538,\n", + " (2060, 2): 73.38902723789215,\n", + " (2060, 3): 106.57652235031128,\n", + " (2060, 4): 49.315309166908264,\n", + " (2060, 5): 46.35106122493744,\n", + " (2060, 6): 16.010488033294678,\n", + " (2060, 7): 43.166913986206055,\n", + " (2060, 8): 2.0626766681671143,\n", + " (2060, 9): 2.5492119789123535,\n", + " (2060, 10): 1.4419366121292114,\n", + " (2060, 11): 24.029298067092896,\n", + " (2060, 12): 159.94412076473236},\n", + " 'window': {(2060, 1): 143.62085342407227,\n", + " (2060, 2): 26.3014919757843,\n", + " (2060, 3): 35.61183428764343,\n", + " (2060, 4): 24.708812713623047,\n", + " (2060, 5): 17.549870491027832,\n", + " (2060, 6): 6.206125974655151,\n", + " (2060, 7): 21.106102108955383,\n", + " (2060, 8): 2.0626766681671143,\n", + " (2060, 9): 1.4252461194992065,\n", + " (2060, 10): 1.4419366121292114,\n", + " (2060, 11): 14.932323336601257,\n", + " (2060, 12): 63.50431251525879}},\n", + " 95: {'monthly': {(2060, 1): 429.28397476673126,\n", + " (2060, 2): 72.47148525714874,\n", + " (2060, 3): 121.06057739257812,\n", + " (2060, 4): 51.50081777572632,\n", + " (2060, 5): 51.62354600429535,\n", + " (2060, 6): 18.254459261894226,\n", + " (2060, 7): 47.412702322006226,\n", + " (2060, 8): 2.0626766681671143,\n", + " (2060, 9): 2.6531325578689575,\n", + " (2060, 10): 3.1614946126937866,\n", + " (2060, 11): 27.3854957818985,\n", + " (2060, 12): 178.5531598329544},\n", + " 'window': {(2060, 1): 143.6856346130371,\n", + " (2060, 2): 27.105239152908325,\n", + " (2060, 3): 40.09090518951416,\n", + " (2060, 4): 25.462261080741882,\n", + " (2060, 5): 19.430429935455322,\n", + " (2060, 6): 6.915640711784363,\n", + " (2060, 7): 23.643585801124573,\n", + " (2060, 8): 2.0626766681671143,\n", + " (2060, 9): 2.6531325578689575,\n", + " (2060, 10): 1.7195580005645752,\n", + " (2060, 11): 12.381380200386047,\n", + " (2060, 12): 71.49668407440186}},\n", + " 96: {'monthly': {(2060, 1): 352.7899634838104,\n", + " (2060, 2): 88.59532988071442,\n", + " (2060, 3): 104.49126052856445,\n", + " (2060, 4): 57.611284494400024,\n", + " (2060, 5): 47.54294419288635,\n", + " (2060, 6): 15.912310242652893,\n", + " (2060, 7): 44.53313088417053,\n", + " (2060, 8): 3.709206223487854,\n", + " (2060, 9): 1.2673903703689575,\n", + " (2060, 10): 1.5223034620285034,\n", + " (2060, 11): 22.640748143196106,\n", + " (2060, 12): 167.9428344964981},\n", + " 'window': {(2060, 1): 100.7104263305664,\n", + " (2060, 2): 29.294162392616272,\n", + " (2060, 3): 27.832655906677246,\n", + " (2060, 4): 33.618375301361084,\n", + " (2060, 5): 18.815945506095886,\n", + " (2060, 6): 5.86623227596283,\n", + " (2060, 7): 19.021694779396057,\n", + " (2060, 8): 2.6743505001068115,\n", + " (2060, 9): 1.2673903703689575,\n", + " (2060, 10): 1.5223034620285034,\n", + " (2060, 11): 14.802052617073059,\n", + " (2060, 12): 59.41940355300903}},\n", + " 97: {'monthly': {(2060, 1): 423.0829076766968,\n", + " (2060, 2): 99.40169155597687,\n", + " (2060, 3): 125.31066417694092,\n", + " (2060, 4): 71.11595785617828,\n", + " (2060, 5): 56.92600333690643,\n", + " (2060, 6): 19.795478343963623,\n", + " (2060, 7): 59.18360197544098,\n", + " (2060, 8): 3.6297510862350464,\n", + " (2060, 9): 1.769248127937317,\n", + " (2060, 10): 1.5223034620285034,\n", + " (2060, 11): 28.033342242240906,\n", + " (2060, 12): 194.99396097660065},\n", + " 'window': {(2060, 1): 119.64074802398682,\n", + " (2060, 2): 34.589433789253235,\n", + " (2060, 3): 35.65897512435913,\n", + " (2060, 4): 36.43531537055969,\n", + " (2060, 5): 21.53912341594696,\n", + " (2060, 6): 6.407122850418091,\n", + " (2060, 7): 26.482715010643005,\n", + " (2060, 8): 2.59743070602417,\n", + " (2060, 9): 1.769248127937317,\n", + " (2060, 10): 1.5223034620285034,\n", + " (2060, 11): 18.064305782318115,\n", + " (2060, 12): 70.48747444152832}},\n", + " 98: {'monthly': {(2060, 1): 449.4318759441376,\n", + " (2060, 2): 95.25327467918396,\n", + " (2060, 3): 131.9243677854538,\n", + " (2060, 4): 76.65350484848022,\n", + " (2060, 5): 57.82006847858429,\n", + " (2060, 6): 24.218266129493713,\n", + " (2060, 7): 64.9749584197998,\n", + " (2060, 8): 2.493152618408203,\n", + " (2060, 9): 1.2673903703689575,\n", + " (2060, 10): 2.953827381134033,\n", + " (2060, 11): 25.845147013664246,\n", + " (2060, 12): 192.3759274482727},\n", + " 'window': {(2060, 1): 138.06682014465332,\n", + " (2060, 2): 33.364089012145996,\n", + " (2060, 3): 41.571351051330566,\n", + " (2060, 4): 38.55204772949219,\n", + " (2060, 5): 20.87331521511078,\n", + " (2060, 6): 8.365351676940918,\n", + " (2060, 7): 28.51797902584076,\n", + " (2060, 8): 2.493152618408203,\n", + " (2060, 9): 1.2673903703689575,\n", + " (2060, 10): 1.5223034620285034,\n", + " (2060, 11): 16.915120124816895,\n", + " (2060, 12): 74.45194149017334}},\n", + " 99: {'monthly': {(2060, 1): 391.67688608169556,\n", + " (2060, 2): 76.42369616031647,\n", + " (2060, 3): 107.04146146774292,\n", + " (2060, 4): 55.350674986839294,\n", + " (2060, 5): 39.11813259124756,\n", + " (2060, 6): 15.929315209388733,\n", + " (2060, 7): 36.86646044254303,\n", + " (2060, 8): 2.3134970664978027,\n", + " (2060, 9): 1.2673903703689575,\n", + " (2060, 10): 1.5223034620285034,\n", + " (2060, 11): 19.440048336982727,\n", + " (2060, 12): 156.08574318885803},\n", + " 'window': {(2060, 1): 127.61261653900146,\n", + " (2060, 2): 24.674513339996338,\n", + " (2060, 3): 35.11529588699341,\n", + " (2060, 4): 34.44607055187225,\n", + " (2060, 5): 14.266376376152039,\n", + " (2060, 6): 6.036371469497681,\n", + " (2060, 7): 15.362324714660645,\n", + " (2060, 8): 2.3134970664978027,\n", + " (2060, 9): 1.2673903703689575,\n", + " (2060, 10): 1.5223034620285034,\n", + " (2060, 11): 10.533748269081116,\n", + " (2060, 12): 66.1814661026001}},\n", + " 100: {'monthly': {(2060, 1): 346.23657965660095,\n", + " (2060, 2): 115.24026083946228,\n", + " (2060, 3): 92.11984550952911,\n", + " (2060, 4): 39.149778604507446,\n", + " (2060, 5): 53.55998504161835,\n", + " (2060, 6): 10.737209916114807,\n", + " (2060, 7): 18.396928071975708,\n", + " (2060, 8): 1.2253988981246948,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 26.82351064682007,\n", + " (2060, 12): 173.12817704677582},\n", + " 'window': {(2060, 1): 119.2985725402832,\n", + " (2060, 2): 49.9421763420105,\n", + " (2060, 3): 33.98824381828308,\n", + " (2060, 4): 33.24574422836304,\n", + " (2060, 5): 22.204967737197876,\n", + " (2060, 6): 4.990707993507385,\n", + " (2060, 7): 7.774371266365051,\n", + " (2060, 8): 1.2253988981246948,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 21.494866490364075,\n", + " (2060, 12): 56.13541030883789}},\n", + " 101: {'monthly': {(2060, 1): 349.90011978149414,\n", + " (2060, 2): 122.16595947742462,\n", + " (2060, 3): 88.83498799800873,\n", + " (2060, 4): 42.698251605033875,\n", + " (2060, 5): 60.85842967033386,\n", + " (2060, 6): 11.757982611656189,\n", + " (2060, 7): 18.986244082450867,\n", + " (2060, 8): 1.2253988981246948,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 23.86400592327118,\n", + " (2060, 12): 178.52454006671906},\n", + " 'window': {(2060, 1): 115.80019760131836,\n", + " (2060, 2): 56.79935574531555,\n", + " (2060, 3): 31.526460647583008,\n", + " (2060, 4): 37.14680886268616,\n", + " (2060, 5): 26.685794591903687,\n", + " (2060, 6): 6.011480689048767,\n", + " (2060, 7): 8.060877799987793,\n", + " (2060, 8): 1.2253988981246948,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 20.614326119422913,\n", + " (2060, 12): 63.986401081085205}},\n", + " 102: {'monthly': {(2060, 1): 319.5013589859009,\n", + " (2060, 2): 112.83527135848999,\n", + " (2060, 3): 89.94485259056091,\n", + " (2060, 4): 41.47650933265686,\n", + " (2060, 5): 46.9607959985733,\n", + " (2060, 6): 10.737209916114807,\n", + " (2060, 7): 19.8553626537323,\n", + " (2060, 8): 1.2253988981246948,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 21.132503986358643,\n", + " (2060, 12): 188.97411179542542},\n", + " 'window': {(2060, 1): 102.54212284088135,\n", + " (2060, 2): 55.52021360397339,\n", + " (2060, 3): 30.740293741226196,\n", + " (2060, 4): 35.87820017337799,\n", + " (2060, 5): 19.180613160133362,\n", + " (2060, 6): 4.990707993507385,\n", + " (2060, 7): 8.709739208221436,\n", + " (2060, 8): 1.2253988981246948,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 17.080882906913757,\n", + " (2060, 12): 74.86490726470947}},\n", + " 103: {'monthly': {(2060, 1): 295.21724700927734,\n", + " (2060, 2): 101.64878499507904,\n", + " (2060, 3): 76.02180671691895,\n", + " (2060, 4): 40.20543360710144,\n", + " (2060, 5): 36.069650650024414,\n", + " (2060, 6): 10.737209916114807,\n", + " (2060, 7): 18.26148498058319,\n", + " (2060, 8): 1.2253988981246948,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 23.56083309650421,\n", + " (2060, 12): 189.04961907863617},\n", + " 'window': {(2060, 1): 94.32566452026367,\n", + " (2060, 2): 54.26530838012695,\n", + " (2060, 3): 28.86735463142395,\n", + " (2060, 4): 33.94156813621521,\n", + " (2060, 5): 12.319239854812622,\n", + " (2060, 6): 4.990707993507385,\n", + " (2060, 7): 7.9300055503845215,\n", + " (2060, 8): 1.2253988981246948,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 18.593409657478333,\n", + " (2060, 12): 70.85122871398926}},\n", + " 104: {'monthly': {(2060, 1): 407.95460057258606,\n", + " (2060, 2): 96.86546611785889,\n", + " (2060, 3): 83.84810733795166,\n", + " (2060, 4): 16.36186420917511,\n", + " (2060, 5): 21.20138931274414,\n", + " (2060, 6): 9.322126150131226,\n", + " (2060, 7): 18.51058781147003,\n", + " (2060, 8): 1.321013331413269,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 2.443474292755127,\n", + " (2060, 11): 30.528780817985535,\n", + " (2060, 12): 214.67350161075592},\n", + " 'window': {(2060, 1): 147.7291088104248,\n", + " (2060, 2): 37.544578075408936,\n", + " (2060, 3): 27.268686294555664,\n", + " (2060, 4): 11.701242089271545,\n", + " (2060, 5): 7.876853942871094,\n", + " (2060, 6): 3.808173656463623,\n", + " (2060, 7): 6.865109443664551,\n", + " (2060, 8): 1.321013331413269,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 1.3135926723480225,\n", + " (2060, 11): 17.892728328704834,\n", + " (2060, 12): 138.75796127319336}},\n", + " 105: {'monthly': {(2060, 1): 360.58968782424927,\n", + " (2060, 2): 74.18283772468567,\n", + " (2060, 3): 85.23425364494324,\n", + " (2060, 4): 34.62935721874237,\n", + " (2060, 5): 29.216607928276062,\n", + " (2060, 6): 14.382491111755371,\n", + " (2060, 7): 21.693007469177246,\n", + " (2060, 8): 2.0626766681671143,\n", + " (2060, 9): 1.123965859413147,\n", + " (2060, 10): 1.4419366121292114,\n", + " (2060, 11): 20.760058999061584,\n", + " (2060, 12): 122.69893300533295},\n", + " 'window': {(2060, 1): 138.02874183654785,\n", + " (2060, 2): 26.636324167251587,\n", + " (2060, 3): 24.99161720275879,\n", + " (2060, 4): 21.781128644943237,\n", + " (2060, 5): 14.773335456848145,\n", + " (2060, 6): 5.636223196983337,\n", + " (2060, 7): 7.900975584983826,\n", + " (2060, 8): 2.0626766681671143,\n", + " (2060, 9): 1.123965859413147,\n", + " (2060, 10): 1.4419366121292114,\n", + " (2060, 11): 11.648479580879211,\n", + " (2060, 12): 48.52114677429199}},\n", + " 106: {'monthly': {(2060, 1): 394.5765436887741,\n", + " (2060, 2): 82.10198605060577,\n", + " (2060, 3): 111.64265179634094,\n", + " (2060, 4): 39.00225758552551,\n", + " (2060, 5): 32.675551414489746,\n", + " (2060, 6): 14.15730369091034,\n", + " (2060, 7): 27.447945594787598,\n", + " (2060, 8): 2.0626766681671143,\n", + " (2060, 9): 1.123965859413147,\n", + " (2060, 10): 3.743174433708191,\n", + " (2060, 11): 21.597458481788635,\n", + " (2060, 12): 173.0455572605133},\n", + " 'window': {(2060, 1): 153.90116119384766,\n", + " (2060, 2): 27.76982307434082,\n", + " (2060, 3): 34.09263849258423,\n", + " (2060, 4): 21.822115898132324,\n", + " (2060, 5): 15.303587794303894,\n", + " (2060, 6): 5.636223196983337,\n", + " (2060, 7): 9.488157153129578,\n", + " (2060, 8): 2.0626766681671143,\n", + " (2060, 9): 1.123965859413147,\n", + " (2060, 10): 2.3012378215789795,\n", + " (2060, 11): 11.259883642196655,\n", + " (2060, 12): 62.7207555770874}},\n", + " 107: {'monthly': {(2060, 1): 479.35110545158386,\n", + " (2060, 2): 84.70585751533508,\n", + " (2060, 3): 134.91230952739716,\n", + " (2060, 4): 46.19641625881195,\n", + " (2060, 5): 47.085986733436584,\n", + " (2060, 6): 16.35627031326294,\n", + " (2060, 7): 40.99521362781525,\n", + " (2060, 8): 2.0626766681671143,\n", + " (2060, 9): 2.530571699142456,\n", + " (2060, 10): 3.7062705755233765,\n", + " (2060, 11): 33.05326569080353,\n", + " (2060, 12): 215.3409719467163},\n", + " 'window': {(2060, 1): 172.13108444213867,\n", + " (2060, 2): 29.598541736602783,\n", + " (2060, 3): 41.91778373718262,\n", + " (2060, 4): 22.620279550552368,\n", + " (2060, 5): 17.596295833587646,\n", + " (2060, 6): 6.433686017990112,\n", + " (2060, 7): 20.415731549263,\n", + " (2060, 8): 2.0626766681671143,\n", + " (2060, 9): 2.530571699142456,\n", + " (2060, 10): 2.264333963394165,\n", + " (2060, 11): 17.319698929786682,\n", + " (2060, 12): 78.0708703994751}},\n", + " 108: {'monthly': {(2060, 1): 465.7275460958481,\n", + " (2060, 2): 83.65554511547089,\n", + " (2060, 3): 150.60970628261566,\n", + " (2060, 4): 46.48762035369873,\n", + " (2060, 5): 48.194143533706665,\n", + " (2060, 6): 20.079076170921326,\n", + " (2060, 7): 44.389448404312134,\n", + " (2060, 8): 2.0626766681671143,\n", + " (2060, 9): 1.123965859413147,\n", + " (2060, 10): 4.183503031730652,\n", + " (2060, 11): 22.633455276489258,\n", + " (2060, 12): 198.03995490074158},\n", + " 'window': {(2060, 1): 172.89882278442383,\n", + " (2060, 2): 30.75741672515869,\n", + " (2060, 3): 45.30311918258667,\n", + " (2060, 4): 21.84697198867798,\n", + " (2060, 5): 18.415679454803467,\n", + " (2060, 6): 6.0585631132125854,\n", + " (2060, 7): 22.438853859901428,\n", + " (2060, 8): 2.0626766681671143,\n", + " (2060, 9): 1.123965859413147,\n", + " (2060, 10): 2.829234004020691,\n", + " (2060, 11): 14.032723784446716,\n", + " (2060, 12): 71.16131401062012}},\n", + " 109: {'monthly': {(2060, 1): 343.92627120018005,\n", + " (2060, 2): 87.37233543395996,\n", + " (2060, 3): 105.2634756565094,\n", + " (2060, 4): 49.61333978176117,\n", + " (2060, 5): 37.5579137802124,\n", + " (2060, 6): 15.87598717212677,\n", + " (2060, 7): 40.86406874656677,\n", + " (2060, 8): 2.3134970664978027,\n", + " (2060, 9): 1.2673903703689575,\n", + " (2060, 10): 2.586630702018738,\n", + " (2060, 11): 21.53614604473114,\n", + " (2060, 12): 163.12770891189575},\n", + " 'window': {(2060, 1): 102.49728965759277,\n", + " (2060, 2): 27.973085403442383,\n", + " (2060, 3): 29.82864737510681,\n", + " (2060, 4): 27.871565461158752,\n", + " (2060, 5): 16.116827368736267,\n", + " (2060, 6): 5.86623227596283,\n", + " (2060, 7): 15.346297144889832,\n", + " (2060, 8): 2.3134970664978027,\n", + " (2060, 9): 1.2673903703689575,\n", + " (2060, 10): 2.586630702018738,\n", + " (2060, 11): 11.430338978767395,\n", + " (2060, 12): 54.279325008392334}},\n", + " 110: {'monthly': {(2060, 1): 404.8652262687683,\n", + " (2060, 2): 106.95866274833679,\n", + " (2060, 3): 129.079155087471,\n", + " (2060, 4): 48.4066002368927,\n", + " (2060, 5): 40.091264963150024,\n", + " (2060, 6): 15.873462557792664,\n", + " (2060, 7): 42.36872708797455,\n", + " (2060, 8): 3.4911744594573975,\n", + " (2060, 9): 1.2673903703689575,\n", + " (2060, 10): 3.826534390449524,\n", + " (2060, 11): 29.42207407951355,\n", + " (2060, 12): 211.8794788122177},\n", + " 'window': {(2060, 1): 108.36867904663086,\n", + " (2060, 2): 32.82860600948334,\n", + " (2060, 3): 39.50145101547241,\n", + " (2060, 4): 27.36704730987549,\n", + " (2060, 5): 16.04546630382538,\n", + " (2060, 6): 5.86623227596283,\n", + " (2060, 7): 15.813272356987,\n", + " (2060, 8): 2.3659744262695312,\n", + " (2060, 9): 1.2673903703689575,\n", + " (2060, 10): 2.3042309284210205,\n", + " (2060, 11): 17.26029920578003,\n", + " (2060, 12): 70.48323822021484}},\n", + " 111: {'monthly': {(2060, 1): 462.1331686973572,\n", + " (2060, 2): 109.48963189125061,\n", + " (2060, 3): 150.84433352947235,\n", + " (2060, 4): 62.379676818847656,\n", + " (2060, 5): 45.56064701080322,\n", + " (2060, 6): 16.55554175376892,\n", + " (2060, 7): 44.104257345199585,\n", + " (2060, 8): 2.3134970664978027,\n", + " (2060, 9): 3.5748766660690308,\n", + " (2060, 10): 9.536153674125671,\n", + " (2060, 11): 38.90598666667938,\n", + " (2060, 12): 226.63394165039062},\n", + " 'window': {(2060, 1): 119.10615158081055,\n", + " (2060, 2): 33.15450835227966,\n", + " (2060, 3): 43.77429676055908,\n", + " (2060, 4): 33.76323974132538,\n", + " (2060, 5): 18.265411376953125,\n", + " (2060, 6): 5.86623227596283,\n", + " (2060, 7): 16.885692477226257,\n", + " (2060, 8): 2.3134970664978027,\n", + " (2060, 9): 2.3074862957000732,\n", + " (2060, 10): 5.158761382102966,\n", + " (2060, 11): 22.531094312667847,\n", + " (2060, 12): 80.55769538879395}},\n", + " 112: {'monthly': {(2060, 1): 399.7131608724594,\n", + " (2060, 2): 80.18583798408508,\n", + " (2060, 3): 103.72445476055145,\n", + " (2060, 4): 49.91864597797394,\n", + " (2060, 5): 32.826704144477844,\n", + " (2060, 6): 16.73643124103546,\n", + " (2060, 7): 26.253862857818604,\n", + " (2060, 8): 2.3134970664978027,\n", + " (2060, 9): 1.2673903703689575,\n", + " (2060, 10): 2.6058125495910645,\n", + " (2060, 11): 22.78432536125183,\n", + " (2060, 12): 162.38969922065735},\n", + " 'window': {(2060, 1): 112.76259326934814,\n", + " (2060, 2): 23.314667582511902,\n", + " (2060, 3): 27.72321915626526,\n", + " (2060, 4): 32.990127086639404,\n", + " (2060, 5): 11.629144430160522,\n", + " (2060, 6): 5.86623227596283,\n", + " (2060, 7): 10.15340542793274,\n", + " (2060, 8): 2.3134970664978027,\n", + " (2060, 9): 1.2673903703689575,\n", + " (2060, 10): 2.6058125495910645,\n", + " (2060, 11): 11.206248998641968,\n", + " (2060, 12): 67.26001453399658}},\n", + " 113: {'monthly': {(2060, 1): 343.6748014688492,\n", + " (2060, 2): 116.34928858280182,\n", + " (2060, 3): 86.21060240268707,\n", + " (2060, 4): 36.22039532661438,\n", + " (2060, 5): 45.84084761142731,\n", + " (2060, 6): 10.737209916114807,\n", + " (2060, 7): 17.909698605537415,\n", + " (2060, 8): 1.2253988981246948,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 20.967733144760132,\n", + " (2060, 12): 161.33118617534637},\n", + " 'window': {(2060, 1): 119.59949588775635,\n", + " (2060, 2): 50.97277092933655,\n", + " (2060, 3): 31.851691961288452,\n", + " (2060, 4): 29.73025155067444,\n", + " (2060, 5): 17.86822533607483,\n", + " (2060, 6): 4.990707993507385,\n", + " (2060, 7): 7.5985952615737915,\n", + " (2060, 8): 1.2253988981246948,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 17.792675852775574,\n", + " (2060, 12): 54.049511432647705}},\n", + " 114: {'monthly': {(2060, 1): 363.35000371932983,\n", + " (2060, 2): 137.5985562801361,\n", + " (2060, 3): 98.76722705364227,\n", + " (2060, 4): 38.0235470533371,\n", + " (2060, 5): 52.813050508499146,\n", + " (2060, 6): 10.737209916114807,\n", + " (2060, 7): 18.251886010169983,\n", + " (2060, 8): 1.2253988981246948,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 25.137531280517578,\n", + " (2060, 12): 189.50423777103424},\n", + " 'window': {(2060, 1): 125.37717056274414,\n", + " (2060, 2): 57.90111970901489,\n", + " (2060, 3): 38.201064586639404,\n", + " (2060, 4): 31.39781963825226,\n", + " (2060, 5): 22.099992752075195,\n", + " (2060, 6): 4.990707993507385,\n", + " (2060, 7): 7.780395030975342,\n", + " (2060, 8): 1.2253988981246948,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 18.486921787261963,\n", + " (2060, 12): 70.14760875701904}},\n", + " 115: {'monthly': {(2060, 1): 331.3134825229645,\n", + " (2060, 2): 120.46425139904022,\n", + " (2060, 3): 97.95618557929993,\n", + " (2060, 4): 30.973863124847412,\n", + " (2060, 5): 46.7463059425354,\n", + " (2060, 6): 10.737209916114807,\n", + " (2060, 7): 18.244349122047424,\n", + " (2060, 8): 1.2253988981246948,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 21.11982274055481,\n", + " (2060, 12): 204.0979005098343},\n", + " 'window': {(2060, 1): 110.55718326568604,\n", + " (2060, 2): 52.442177057266235,\n", + " (2060, 3): 35.52075791358948,\n", + " (2060, 4): 26.19022846221924,\n", + " (2060, 5): 19.13084626197815,\n", + " (2060, 6): 4.990707993507385,\n", + " (2060, 7): 7.930033445358276,\n", + " (2060, 8): 1.2253988981246948,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 15.94070565700531,\n", + " (2060, 12): 77.44490623474121}},\n", + " 116: {'monthly': {(2060, 1): 317.90583086013794,\n", + " (2060, 2): 102.65343356132507,\n", + " (2060, 3): 89.52171635627747,\n", + " (2060, 4): 29.121840119361877,\n", + " (2060, 5): 42.6735053062439,\n", + " (2060, 6): 10.737209916114807,\n", + " (2060, 7): 16.361290216445923,\n", + " (2060, 8): 1.2253988981246948,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 26.045686721801758,\n", + " (2060, 12): 198.77740514278412},\n", + " 'window': {(2060, 1): 101.12226295471191,\n", + " (2060, 2): 49.65871453285217,\n", + " (2060, 3): 36.51204705238342,\n", + " (2060, 4): 22.674139976501465,\n", + " (2060, 5): 16.116384267807007,\n", + " (2060, 6): 4.990707993507385,\n", + " (2060, 7): 7.522854328155518,\n", + " (2060, 8): 1.2253988981246948,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 20.88944697380066,\n", + " (2060, 12): 77.31076240539551}},\n", + " 117: {'monthly': {(2060, 1): 510.4098947048187,\n", + " (2060, 2): 87.49692058563232,\n", + " (2060, 3): 102.56909239292145,\n", + " (2060, 4): 49.491947889328,\n", + " (2060, 5): 18.087695598602295,\n", + " (2060, 6): 8.094635844230652,\n", + " (2060, 7): 10.455269455909729,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 4.266306400299072,\n", + " (2060, 11): 64.82731282711029,\n", + " (2060, 12): 164.64981365203857},\n", + " 'window': {(2060, 1): 150.2458152770996,\n", + " (2060, 2): 29.334582805633545,\n", + " (2060, 3): 31.10702621936798,\n", + " (2060, 4): 35.21836519241333,\n", + " (2060, 5): 10.162387371063232,\n", + " (2060, 6): 2.9090415239334106,\n", + " (2060, 7): 2.942115902900696,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 4.266306400299072,\n", + " (2060, 11): 34.671786069869995,\n", + " (2060, 12): 66.97276306152344}},\n", + " 118: {'monthly': {(2060, 1): 557.8866236209869,\n", + " (2060, 2): 128.13135182857513,\n", + " (2060, 3): 140.3464162349701,\n", + " (2060, 4): 45.57662832736969,\n", + " (2060, 5): 16.415945887565613,\n", + " (2060, 6): 8.047105312347412,\n", + " (2060, 7): 13.441797137260437,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.306508779525757,\n", + " (2060, 11): 36.88234877586365,\n", + " (2060, 12): 236.21530997753143},\n", + " 'window': {(2060, 1): 221.24639511108398,\n", + " (2060, 2): 42.0278844833374,\n", + " (2060, 3): 64.86773729324341,\n", + " (2060, 4): 39.71260869503021,\n", + " (2060, 5): 9.094529509544373,\n", + " (2060, 6): 5.011563539505005,\n", + " (2060, 7): 4.3381829261779785,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.306508779525757,\n", + " (2060, 11): 19.84249770641327,\n", + " (2060, 12): 97.38131809234619}},\n", + " 119: {'monthly': {(2060, 1): 644.3098742961884,\n", + " (2060, 2): 142.64763271808624,\n", + " (2060, 3): 134.9455602169037,\n", + " (2060, 4): 60.415714144706726,\n", + " (2060, 5): 19.061378598213196,\n", + " (2060, 6): 9.152392029762268,\n", + " (2060, 7): 14.45812439918518,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 4.931285977363586,\n", + " (2060, 11): 50.540574073791504,\n", + " (2060, 12): 291.711643576622},\n", + " 'window': {(2060, 1): 239.30809783935547,\n", + " (2060, 2): 52.503711223602295,\n", + " (2060, 3): 58.5741400718689,\n", + " (2060, 4): 55.27925443649292,\n", + " (2060, 5): 10.101752042770386,\n", + " (2060, 6): 5.011563539505005,\n", + " (2060, 7): 4.656983494758606,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.306508779525757,\n", + " (2060, 11): 27.414522409439087,\n", + " (2060, 12): 126.69195365905762}},\n", + " 120: {'monthly': {(2060, 1): 706.5408275127411,\n", + " (2060, 2): 159.36862993240356,\n", + " (2060, 3): 140.98377788066864,\n", + " (2060, 4): 63.541441798210144,\n", + " (2060, 5): 20.694462776184082,\n", + " (2060, 6): 11.548849821090698,\n", + " (2060, 7): 23.87806475162506,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 3.0362112522125244,\n", + " (2060, 10): 3.306508779525757,\n", + " (2060, 11): 47.28317928314209,\n", + " (2060, 12): 311.04827880859375},\n", + " 'window': {(2060, 1): 280.08428382873535,\n", + " (2060, 2): 51.344417095184326,\n", + " (2060, 3): 53.86126232147217,\n", + " (2060, 4): 56.93182706832886,\n", + " (2060, 5): 11.276231288909912,\n", + " (2060, 6): 6.085543394088745,\n", + " (2060, 7): 9.946051239967346,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 3.0362112522125244,\n", + " (2060, 10): 3.306508779525757,\n", + " (2060, 11): 27.322734475135803,\n", + " (2060, 12): 139.36362266540527}},\n", + " 121: {'monthly': {(2060, 1): 667.4431693553925,\n", + " (2060, 2): 136.43020927906036,\n", + " (2060, 3): 115.14472329616547,\n", + " (2060, 4): 58.6288868188858,\n", + " (2060, 5): 15.05299186706543,\n", + " (2060, 6): 10.637265920639038,\n", + " (2060, 7): 24.813424944877625,\n", + " (2060, 8): 1.2884067296981812,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 5.952113747596741,\n", + " (2060, 11): 40.983696937561035,\n", + " (2060, 12): 254.7919305562973},\n", + " 'window': {(2060, 1): 289.6412887573242,\n", + " (2060, 2): 41.63046884536743,\n", + " (2060, 3): 38.96283292770386,\n", + " (2060, 4): 48.3566632270813,\n", + " (2060, 5): 8.431670665740967,\n", + " (2060, 6): 6.239339113235474,\n", + " (2060, 7): 9.858242630958557,\n", + " (2060, 8): 1.2884067296981812,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.306508779525757,\n", + " (2060, 11): 23.754318356513977,\n", + " (2060, 12): 114.55213832855225}},\n", + " 122: {'monthly': {(2060, 1): 569.7496087551117,\n", + " (2060, 2): 123.77409279346466,\n", + " (2060, 3): 91.8580093383789,\n", + " (2060, 4): 32.72150754928589,\n", + " (2060, 5): 16.235630869865417,\n", + " (2060, 6): 9.762237310409546,\n", + " (2060, 7): 21.505573391914368,\n", + " (2060, 8): 2.2416694164276123,\n", + " (2060, 9): 2.787316083908081,\n", + " (2060, 10): 6.906312942504883,\n", + " (2060, 11): 38.74012577533722,\n", + " (2060, 12): 217.8193690776825},\n", + " 'window': {(2060, 1): 229.92680549621582,\n", + " (2060, 2): 43.31287240982056,\n", + " (2060, 3): 33.4460666179657,\n", + " (2060, 4): 25.500521898269653,\n", + " (2060, 5): 8.484235286712646,\n", + " (2060, 6): 4.980204701423645,\n", + " (2060, 7): 6.766346216201782,\n", + " (2060, 8): 1.1782773733139038,\n", + " (2060, 9): 1.534010887145996,\n", + " (2060, 10): 3.3917908668518066,\n", + " (2060, 11): 21.463642239570618,\n", + " (2060, 12): 94.14852809906006}},\n", + " 123: {'monthly': {(2060, 1): 582.0229775905609,\n", + " (2060, 2): 135.25760567188263,\n", + " (2060, 3): 102.12856674194336,\n", + " (2060, 4): 33.91528308391571,\n", + " (2060, 5): 20.01930022239685,\n", + " (2060, 6): 13.64232087135315,\n", + " (2060, 7): 15.634902954101562,\n", + " (2060, 8): 1.0577040910720825,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 5.165388226509094,\n", + " (2060, 11): 36.465656995773315,\n", + " (2060, 12): 220.90574622154236},\n", + " 'window': {(2060, 1): 248.59711265563965,\n", + " (2060, 2): 40.01663327217102,\n", + " (2060, 3): 36.14659929275513,\n", + " (2060, 4): 26.73956823348999,\n", + " (2060, 5): 9.416933059692383,\n", + " (2060, 6): 5.994066119194031,\n", + " (2060, 7): 5.225795745849609,\n", + " (2060, 8): 1.0577040910720825,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.9456480741500854,\n", + " (2060, 11): 21.93647027015686,\n", + " (2060, 12): 103.68998432159424}},\n", + " 124: {'monthly': {(2060, 1): 632.3904068470001,\n", + " (2060, 2): 145.28400909900665,\n", + " (2060, 3): 100.38850009441376,\n", + " (2060, 4): 42.64017832279205,\n", + " (2060, 5): 25.669744968414307,\n", + " (2060, 6): 9.334441184997559,\n", + " (2060, 7): 17.61014175415039,\n", + " (2060, 8): 1.5491949319839478,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 8.241070747375488,\n", + " (2060, 11): 36.79388189315796,\n", + " (2060, 12): 237.030215382576},\n", + " 'window': {(2060, 1): 244.83649063110352,\n", + " (2060, 2): 44.04545545578003,\n", + " (2060, 3): 34.0287652015686,\n", + " (2060, 4): 36.37992703914642,\n", + " (2060, 5): 11.296199560165405,\n", + " (2060, 6): 5.977229714393616,\n", + " (2060, 7): 5.945600152015686,\n", + " (2060, 8): 1.5491949319839478,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.612400770187378,\n", + " (2060, 11): 23.00423502922058,\n", + " (2060, 12): 114.64002799987793}},\n", + " 125: {'monthly': {(2060, 1): 615.7446393966675,\n", + " (2060, 2): 113.01238000392914,\n", + " (2060, 3): 86.84487044811249,\n", + " (2060, 4): 44.410459876060486,\n", + " (2060, 5): 22.38048803806305,\n", + " (2060, 6): 7.963107585906982,\n", + " (2060, 7): 12.051601886749268,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.3917908668518066,\n", + " (2060, 11): 32.904370069503784,\n", + " (2060, 12): 191.92615520954132},\n", + " 'window': {(2060, 1): 221.1103057861328,\n", + " (2060, 2): 37.537296295166016,\n", + " (2060, 3): 27.584089756011963,\n", + " (2060, 4): 40.005894780159,\n", + " (2060, 5): 9.205323338508606,\n", + " (2060, 6): 4.980204701423645,\n", + " (2060, 7): 3.941878318786621,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.3917908668518066,\n", + " (2060, 11): 19.47388792037964,\n", + " (2060, 12): 98.55441284179688}},\n", + " 126: {'monthly': {(2060, 1): 371.2189083099365,\n", + " (2060, 2): 164.38460624217987,\n", + " (2060, 3): 87.0060784816742,\n", + " (2060, 4): 31.050194025039673,\n", + " (2060, 5): 18.281853437423706,\n", + " (2060, 6): 4.758296966552734,\n", + " (2060, 7): 8.060628771781921,\n", + " (2060, 8): 5.000177025794983,\n", + " (2060, 9): 5.203696131706238,\n", + " (2060, 10): 1.0873280763626099,\n", + " (2060, 11): 17.42879366874695,\n", + " (2060, 12): 244.5464462041855},\n", + " 'window': {(2060, 1): 164.70499420166016,\n", + " (2060, 2): 56.10796618461609,\n", + " (2060, 3): 35.575673937797546,\n", + " (2060, 4): 31.050194025039673,\n", + " (2060, 5): 7.314716935157776,\n", + " (2060, 6): 2.420486330986023,\n", + " (2060, 7): 4.300221085548401,\n", + " (2060, 8): 2.56423020362854,\n", + " (2060, 9): 2.5077195167541504,\n", + " (2060, 10): 1.0873280763626099,\n", + " (2060, 11): 15.268750548362732,\n", + " (2060, 12): 102.85420036315918}},\n", + " 127: {'monthly': {(2060, 1): 381.8864574432373,\n", + " (2060, 2): 183.42506647109985,\n", + " (2060, 3): 89.87234592437744,\n", + " (2060, 4): 33.00077176094055,\n", + " (2060, 5): 19.115713000297546,\n", + " (2060, 6): 4.738733291625977,\n", + " (2060, 7): 8.060628771781921,\n", + " (2060, 8): 3.724740982055664,\n", + " (2060, 9): 4.502957820892334,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 17.812392115592957,\n", + " (2060, 12): 266.5228408575058},\n", + " 'window': {(2060, 1): 163.10307693481445,\n", + " (2060, 2): 60.87312293052673,\n", + " (2060, 3): 37.421162128448486,\n", + " (2060, 4): 33.00077176094055,\n", + " (2060, 5): 7.249300122261047,\n", + " (2060, 6): 2.420486330986023,\n", + " (2060, 7): 4.300221085548401,\n", + " (2060, 8): 2.435946822166443,\n", + " (2060, 9): 3.2628742456436157,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 13.235727310180664,\n", + " (2060, 12): 132.73469829559326}},\n", + " 128: {'monthly': {(2060, 1): 366.9783955812454,\n", + " (2060, 2): 185.8719186782837,\n", + " (2060, 3): 78.39760303497314,\n", + " (2060, 4): 29.880679607391357,\n", + " (2060, 5): 18.239283323287964,\n", + " (2060, 6): 5.758107781410217,\n", + " (2060, 7): 8.060628771781921,\n", + " (2060, 8): 4.882692098617554,\n", + " (2060, 9): 4.340728998184204,\n", + " (2060, 10): 2.3364381790161133,\n", + " (2060, 11): 10.688073515892029,\n", + " (2060, 12): 287.6135541200638},\n", + " 'window': {(2060, 1): 159.00813484191895,\n", + " (2060, 2): 62.84865617752075,\n", + " (2060, 3): 28.91441059112549,\n", + " (2060, 4): 29.880679607391357,\n", + " (2060, 5): 7.299867272377014,\n", + " (2060, 6): 3.42473828792572,\n", + " (2060, 7): 4.300221085548401,\n", + " (2060, 8): 2.446745276451111,\n", + " (2060, 9): 3.100645422935486,\n", + " (2060, 10): 2.3364381790161133,\n", + " (2060, 11): 9.670246005058289,\n", + " (2060, 12): 158.11721992492676}},\n", + " 129: {'monthly': {(2060, 1): 387.9808659553528,\n", + " (2060, 2): 169.72064089775085,\n", + " (2060, 3): 80.8459347486496,\n", + " (2060, 4): 22.51471745967865,\n", + " (2060, 5): 18.356791496276855,\n", + " (2060, 6): 8.113657474517822,\n", + " (2060, 7): 10.399242997169495,\n", + " (2060, 8): 5.417973160743713,\n", + " (2060, 9): 4.194663047790527,\n", + " (2060, 10): 2.325004458427429,\n", + " (2060, 11): 9.95607852935791,\n", + " (2060, 12): 301.1328650712967},\n", + " 'window': {(2060, 1): 160.79176330566406,\n", + " (2060, 2): 58.67996382713318,\n", + " (2060, 3): 23.761495351791382,\n", + " (2060, 4): 22.51471745967865,\n", + " (2060, 5): 7.340857625007629,\n", + " (2060, 6): 3.4485201835632324,\n", + " (2060, 7): 4.300221085548401,\n", + " (2060, 8): 4.129179000854492,\n", + " (2060, 9): 2.954579472541809,\n", + " (2060, 10): 1.2839518785476685,\n", + " (2060, 11): 8.93825101852417,\n", + " (2060, 12): 170.5989179611206}},\n", + " 130: {'monthly': {(2060, 1): 547.4507088661194,\n", + " (2060, 2): 96.4872111082077,\n", + " (2060, 3): 141.01596331596375,\n", + " (2060, 4): 58.513633131980896,\n", + " (2060, 5): 20.543678998947144,\n", + " (2060, 6): 8.094635844230652,\n", + " (2060, 7): 9.222147941589355,\n", + " (2060, 8): 1.1885805130004883,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.556956648826599,\n", + " (2060, 11): 73.24884593486786,\n", + " (2060, 12): 191.766583442688},\n", + " 'window': {(2060, 1): 159.23157215118408,\n", + " (2060, 2): 29.21120595932007,\n", + " (2060, 3): 45.35967302322388,\n", + " (2060, 4): 44.23543679714203,\n", + " (2060, 5): 11.143696308135986,\n", + " (2060, 6): 2.9090415239334106,\n", + " (2060, 7): 3.181272029876709,\n", + " (2060, 8): 1.1885805130004883,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.556956648826599,\n", + " (2060, 11): 39.60639750957489,\n", + " (2060, 12): 73.67405891418457}},\n", + " 131: {'monthly': {(2060, 1): 571.1600413322449,\n", + " (2060, 2): 150.99121236801147,\n", + " (2060, 3): 163.97011578083038,\n", + " (2060, 4): 60.95484018325806,\n", + " (2060, 5): 20.514278650283813,\n", + " (2060, 6): 8.142430424690247,\n", + " (2060, 7): 13.540735125541687,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 5.804660201072693,\n", + " (2060, 11): 51.32000923156738,\n", + " (2060, 12): 265.845468044281},\n", + " 'window': {(2060, 1): 217.02537727355957,\n", + " (2060, 2): 52.81081819534302,\n", + " (2060, 3): 70.85829734802246,\n", + " (2060, 4): 53.07941293716431,\n", + " (2060, 5): 10.346323251724243,\n", + " (2060, 6): 5.106888651847839,\n", + " (2060, 7): 4.767492771148682,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.308659315109253,\n", + " (2060, 11): 28.583679795265198,\n", + " (2060, 12): 118.93056678771973}},\n", + " 132: {'monthly': {(2060, 1): 663.6872843503952,\n", + " (2060, 2): 154.58636724948883,\n", + " (2060, 3): 152.54886972904205,\n", + " (2060, 4): 65.92971527576447,\n", + " (2060, 5): 21.860713958740234,\n", + " (2060, 6): 8.047105312347412,\n", + " (2060, 7): 15.508212685585022,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 4.480633735656738,\n", + " (2060, 11): 56.65355908870697,\n", + " (2060, 12): 325.2453066110611},\n", + " 'window': {(2060, 1): 245.66313934326172,\n", + " (2060, 2): 54.35894584655762,\n", + " (2060, 3): 62.45850086212158,\n", + " (2060, 4): 59.978156089782715,\n", + " (2060, 5): 11.335855722427368,\n", + " (2060, 6): 5.011563539505005,\n", + " (2060, 7): 6.087433576583862,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.306508779525757,\n", + " (2060, 11): 35.95221412181854,\n", + " (2060, 12): 143.93274688720703}},\n", + " 133: {'monthly': {(2060, 1): 668.7502009868622,\n", + " (2060, 2): 157.23129737377167,\n", + " (2060, 3): 128.32983577251434,\n", + " (2060, 4): 61.86507046222687,\n", + " (2060, 5): 19.949262261390686,\n", + " (2060, 6): 9.121004223823547,\n", + " (2060, 7): 14.969991445541382,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.306508779525757,\n", + " (2060, 11): 47.08038127422333,\n", + " (2060, 12): 301.8952672481537},\n", + " 'window': {(2060, 1): 269.3583221435547,\n", + " (2060, 2): 46.390183448791504,\n", + " (2060, 3): 48.33936643600464,\n", + " (2060, 4): 54.93529033660889,\n", + " (2060, 5): 11.45088529586792,\n", + " (2060, 6): 5.011563539505005,\n", + " (2060, 7): 5.808553576469421,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.306508779525757,\n", + " (2060, 11): 26.92254936695099,\n", + " (2060, 12): 133.96298599243164}},\n", + " 134: {'monthly': {(2060, 1): 615.7598674297333,\n", + " (2060, 2): 133.57276320457458,\n", + " (2060, 3): 103.49830853939056,\n", + " (2060, 4): 50.21421253681183,\n", + " (2060, 5): 13.546697854995728,\n", + " (2060, 6): 8.122024774551392,\n", + " (2060, 7): 13.990452766418457,\n", + " (2060, 8): 2.4245959520339966,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 4.529220938682556,\n", + " (2060, 11): 39.44850254058838,\n", + " (2060, 12): 238.57067441940308},\n", + " 'window': {(2060, 1): 271.4773597717285,\n", + " (2060, 2): 44.92897605895996,\n", + " (2060, 3): 34.126988768577576,\n", + " (2060, 4): 45.80044770240784,\n", + " (2060, 5): 7.433480739593506,\n", + " (2060, 6): 5.011563539505005,\n", + " (2060, 7): 5.217408061027527,\n", + " (2060, 8): 2.4245959520339966,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.40899121761322,\n", + " (2060, 11): 23.98985993862152,\n", + " (2060, 12): 105.68150615692139}},\n", + " 135: {'monthly': {(2060, 1): 566.1471562385559,\n", + " (2060, 2): 125.03873789310455,\n", + " (2060, 3): 99.24975323677063,\n", + " (2060, 4): 39.884559988975525,\n", + " (2060, 5): 20.847150683403015,\n", + " (2060, 6): 8.120797514915466,\n", + " (2060, 7): 15.120272755622864,\n", + " (2060, 8): 1.0843865871429443,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.3917908668518066,\n", + " (2060, 11): 35.10725247859955,\n", + " (2060, 12): 222.84378838539124},\n", + " 'window': {(2060, 1): 221.94258308410645,\n", + " (2060, 2): 41.30516338348389,\n", + " (2060, 3): 37.61681127548218,\n", + " (2060, 4): 32.34832191467285,\n", + " (2060, 5): 9.995591640472412,\n", + " (2060, 6): 5.137894630432129,\n", + " (2060, 7): 5.620180130004883,\n", + " (2060, 8): 1.0843865871429443,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.3917908668518066,\n", + " (2060, 11): 20.423540830612183,\n", + " (2060, 12): 103.91804122924805}},\n", + " 136: {'monthly': {(2060, 1): 598.2886204719543,\n", + " (2060, 2): 135.67602014541626,\n", + " (2060, 3): 97.5796924829483,\n", + " (2060, 4): 41.534685254096985,\n", + " (2060, 5): 27.175332903862,\n", + " (2060, 6): 7.963107585906982,\n", + " (2060, 7): 13.885337114334106,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 4.829080820083618,\n", + " (2060, 11): 35.82414722442627,\n", + " (2060, 12): 221.85898458957672},\n", + " 'window': {(2060, 1): 238.72622871398926,\n", + " (2060, 2): 39.935463666915894,\n", + " (2060, 3): 39.896719455718994,\n", + " (2060, 4): 36.0637412071228,\n", + " (2060, 5): 12.669905424118042,\n", + " (2060, 6): 4.980204701423645,\n", + " (2060, 7): 4.650796413421631,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.7012375593185425,\n", + " (2060, 11): 21.36343550682068,\n", + " (2060, 12): 111.9016523361206}},\n", + " 137: {'monthly': {(2060, 1): 602.9091939926147,\n", + " (2060, 2): 136.70659375190735,\n", + " (2060, 3): 89.37092518806458,\n", + " (2060, 4): 44.07920265197754,\n", + " (2060, 5): 23.720986008644104,\n", + " (2060, 6): 7.963107585906982,\n", + " (2060, 7): 10.160049319267273,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 1.01644766330719,\n", + " (2060, 10): 3.5457684993743896,\n", + " (2060, 11): 30.525636196136475,\n", + " (2060, 12): 199.53403186798096},\n", + " 'window': {(2060, 1): 243.05580520629883,\n", + " (2060, 2): 36.94036817550659,\n", + " (2060, 3): 35.298019886016846,\n", + " (2060, 4): 39.92199432849884,\n", + " (2060, 5): 10.533711791038513,\n", + " (2060, 6): 4.980204701423645,\n", + " (2060, 7): 2.732165575027466,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 1.01644766330719,\n", + " (2060, 10): 3.5457684993743896,\n", + " (2060, 11): 17.836025714874268,\n", + " (2060, 12): 110.20589065551758}},\n", + " 138: {'monthly': {(2060, 1): 615.48432970047,\n", + " (2060, 2): 110.75643992424011,\n", + " (2060, 3): 83.67919540405273,\n", + " (2060, 4): 42.779574275016785,\n", + " (2060, 5): 17.932651042938232,\n", + " (2060, 6): 7.963107585906982,\n", + " (2060, 7): 8.798253893852234,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 1.3668831586837769,\n", + " (2060, 10): 3.3917908668518066,\n", + " (2060, 11): 30.940833926200867,\n", + " (2060, 12): 192.38009130954742},\n", + " 'window': {(2060, 1): 242.0129280090332,\n", + " (2060, 2): 31.45430040359497,\n", + " (2060, 3): 28.118874073028564,\n", + " (2060, 4): 39.39931786060333,\n", + " (2060, 5): 7.704861164093018,\n", + " (2060, 6): 4.980204701423645,\n", + " (2060, 7): 2.674770712852478,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 1.3668831586837769,\n", + " (2060, 10): 3.3917908668518066,\n", + " (2060, 11): 20.33214259147644,\n", + " (2060, 12): 89.32629299163818}},\n", + " 139: {'monthly': {(2060, 1): 427.92627334594727,\n", + " (2060, 2): 159.89586770534515,\n", + " (2060, 3): 94.46454882621765,\n", + " (2060, 4): 39.77324676513672,\n", + " (2060, 5): 18.795655727386475,\n", + " (2060, 6): 4.8118976354599,\n", + " (2060, 7): 8.060628771781921,\n", + " (2060, 8): 3.724740982055664,\n", + " (2060, 9): 3.879706621170044,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 19.399330615997314,\n", + " (2060, 12): 249.74890506267548},\n", + " 'window': {(2060, 1): 196.4100456237793,\n", + " (2060, 2): 53.35791492462158,\n", + " (2060, 3): 41.25281572341919,\n", + " (2060, 4): 39.77324676513672,\n", + " (2060, 5): 7.493947148323059,\n", + " (2060, 6): 2.420486330986023,\n", + " (2060, 7): 4.300221085548401,\n", + " (2060, 8): 2.435946822166443,\n", + " (2060, 9): 2.6396230459213257,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 18.381503105163574,\n", + " (2060, 12): 109.54104232788086}},\n", + " 140: {'monthly': {(2060, 1): 476.69633626937866,\n", + " (2060, 2): 184.9047166109085,\n", + " (2060, 3): 99.61826539039612,\n", + " (2060, 4): 46.97837579250336,\n", + " (2060, 5): 22.42714488506317,\n", + " (2060, 6): 4.9265124797821045,\n", + " (2060, 7): 8.060628771781921,\n", + " (2060, 8): 3.724740982055664,\n", + " (2060, 9): 4.523668050765991,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 19.141424894332886,\n", + " (2060, 12): 295.59869635105133},\n", + " 'window': {(2060, 1): 210.8937168121338,\n", + " (2060, 2): 60.400949478149414,\n", + " (2060, 3): 41.94523286819458,\n", + " (2060, 4): 45.93201947212219,\n", + " (2060, 5): 9.392773747444153,\n", + " (2060, 6): 2.420486330986023,\n", + " (2060, 7): 4.300221085548401,\n", + " (2060, 8): 2.435946822166443,\n", + " (2060, 9): 3.283584475517273,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 18.123597383499146,\n", + " (2060, 12): 145.40058517456055}},\n", + " 141: {'monthly': {(2060, 1): 479.50259280204773,\n", + " (2060, 2): 187.97148418426514,\n", + " (2060, 3): 82.33440852165222,\n", + " (2060, 4): 45.34663224220276,\n", + " (2060, 5): 23.30478012561798,\n", + " (2060, 6): 6.328974366188049,\n", + " (2060, 7): 9.686584949493408,\n", + " (2060, 8): 3.724740982055664,\n", + " (2060, 9): 4.538181781768799,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 13.60216748714447,\n", + " (2060, 12): 312.75586318969727},\n", + " 'window': {(2060, 1): 229.30839729309082,\n", + " (2060, 2): 71.23172283172607,\n", + " (2060, 3): 29.100484132766724,\n", + " (2060, 4): 45.34663224220276,\n", + " (2060, 5): 10.106266736984253,\n", + " (2060, 6): 3.633682131767273,\n", + " (2060, 7): 4.463454365730286,\n", + " (2060, 8): 2.435946822166443,\n", + " (2060, 9): 3.2980982065200806,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 12.58433997631073,\n", + " (2060, 12): 177.21335792541504}},\n", + " 142: {'monthly': {(2060, 1): 460.35742127895355,\n", + " (2060, 2): 165.1048468351364,\n", + " (2060, 3): 74.58501696586609,\n", + " (2060, 4): 32.43116593360901,\n", + " (2060, 5): 22.079272270202637,\n", + " (2060, 6): 7.271823763847351,\n", + " (2060, 7): 9.937751770019531,\n", + " (2060, 8): 3.724740982055664,\n", + " (2060, 9): 4.334549903869629,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 11.054158806800842,\n", + " (2060, 12): 314.90782368183136},\n", + " 'window': {(2060, 1): 229.1731834411621,\n", + " (2060, 2): 64.59935569763184,\n", + " (2060, 3): 24.762013912200928,\n", + " (2060, 4): 32.43116593360901,\n", + " (2060, 5): 8.647878289222717,\n", + " (2060, 6): 3.514581799507141,\n", + " (2060, 7): 4.300221085548401,\n", + " (2060, 8): 2.435946822166443,\n", + " (2060, 9): 3.0944663286209106,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 10.036331295967102,\n", + " (2060, 12): 176.71612739562988}},\n", + " 143: {'monthly': {(2060, 1): 506.7146122455597,\n", + " (2060, 2): 110.53980016708374,\n", + " (2060, 3): 178.08575093746185,\n", + " (2060, 4): 68.98869001865387,\n", + " (2060, 5): 19.422414183616638,\n", + " (2060, 6): 8.094635844230652,\n", + " (2060, 7): 10.361401677131653,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 4.5186896324157715,\n", + " (2060, 11): 78.93315184116364,\n", + " (2060, 12): 225.8941947221756},\n", + " 'window': {(2060, 1): 164.81800174713135,\n", + " (2060, 2): 29.041869282722473,\n", + " (2060, 3): 59.29143524169922,\n", + " (2060, 4): 49.09294950962067,\n", + " (2060, 5): 11.41849160194397,\n", + " (2060, 6): 2.9090415239334106,\n", + " (2060, 7): 2.8972361087799072,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 4.5186896324157715,\n", + " (2060, 11): 41.655176639556885,\n", + " (2060, 12): 75.36013221740723}},\n", + " 144: {'monthly': {(2060, 1): 548.1857719421387,\n", + " (2060, 2): 149.78410184383392,\n", + " (2060, 3): 176.4488492012024,\n", + " (2060, 4): 56.44916641712189,\n", + " (2060, 5): 22.24891173839569,\n", + " (2060, 6): 8.047105312347412,\n", + " (2060, 7): 13.740213513374329,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.306508779525757,\n", + " (2060, 11): 53.19077658653259,\n", + " (2060, 12): 279.78320384025574},\n", + " 'window': {(2060, 1): 205.08880996704102,\n", + " (2060, 2): 47.30531978607178,\n", + " (2060, 3): 64.36999940872192,\n", + " (2060, 4): 49.921536445617676,\n", + " (2060, 5): 9.714518427848816,\n", + " (2060, 6): 5.011563539505005,\n", + " (2060, 7): 4.592558026313782,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.306508779525757,\n", + " (2060, 11): 36.92058539390564,\n", + " (2060, 12): 118.69038581848145}},\n", + " 145: {'monthly': {(2060, 1): 631.7578530311584,\n", + " (2060, 2): 170.38327407836914,\n", + " (2060, 3): 169.2770837545395,\n", + " (2060, 4): 60.09351027011871,\n", + " (2060, 5): 20.436394929885864,\n", + " (2060, 6): 8.047105312347412,\n", + " (2060, 7): 12.919082880020142,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.306508779525757,\n", + " (2060, 11): 52.33293402194977,\n", + " (2060, 12): 320.61297607421875},\n", + " 'window': {(2060, 1): 231.8756980895996,\n", + " (2060, 2): 50.77475595474243,\n", + " (2060, 3): 59.219637870788574,\n", + " (2060, 4): 52.664851665496826,\n", + " (2060, 5): 10.352755784988403,\n", + " (2060, 6): 5.011563539505005,\n", + " (2060, 7): 4.306565880775452,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.306508779525757,\n", + " (2060, 11): 32.63076174259186,\n", + " (2060, 12): 130.7786569595337}},\n", + " 146: {'monthly': {(2060, 1): 594.892816066742,\n", + " (2060, 2): 152.29956793785095,\n", + " (2060, 3): 130.88317048549652,\n", + " (2060, 4): 45.40497076511383,\n", + " (2060, 5): 16.43554651737213,\n", + " (2060, 6): 8.047105312347412,\n", + " (2060, 7): 11.345490097999573,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 2.337212324142456,\n", + " (2060, 10): 4.732383489608765,\n", + " (2060, 11): 37.605896949768066,\n", + " (2060, 12): 257.28044390678406},\n", + " 'window': {(2060, 1): 239.12189102172852,\n", + " (2060, 2): 47.51843547821045,\n", + " (2060, 3): 43.6026611328125,\n", + " (2060, 4): 40.00069618225098,\n", + " (2060, 5): 9.501826405525208,\n", + " (2060, 6): 5.011563539505005,\n", + " (2060, 7): 3.377794861793518,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 2.337212324142456,\n", + " (2060, 10): 3.632529139518738,\n", + " (2060, 11): 24.075408697128296,\n", + " (2060, 12): 105.43822288513184}},\n", + " 147: {'monthly': {(2060, 1): 559.9497981071472,\n", + " (2060, 2): 137.97131204605103,\n", + " (2060, 3): 110.50351428985596,\n", + " (2060, 4): 38.93370735645294,\n", + " (2060, 5): 11.727835536003113,\n", + " (2060, 6): 8.047105312347412,\n", + " (2060, 7): 11.192602038383484,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 1.068038821220398,\n", + " (2060, 10): 4.340419292449951,\n", + " (2060, 11): 34.39472222328186,\n", + " (2060, 12): 208.79788637161255},\n", + " 'window': {(2060, 1): 240.53192901611328,\n", + " (2060, 2): 42.04910445213318,\n", + " (2060, 3): 33.52293348312378,\n", + " (2060, 4): 34.01312446594238,\n", + " (2060, 5): 6.351813197135925,\n", + " (2060, 6): 5.011563539505005,\n", + " (2060, 7): 3.4193196296691895,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 1.068038821220398,\n", + " (2060, 10): 3.306508779525757,\n", + " (2060, 11): 17.463005781173706,\n", + " (2060, 12): 84.48878383636475}},\n", + " 148: {'monthly': {(2060, 1): 604.3646717071533,\n", + " (2060, 2): 151.91352546215057,\n", + " (2060, 3): 126.7895519733429,\n", + " (2060, 4): 52.570987820625305,\n", + " (2060, 5): 21.614653825759888,\n", + " (2060, 6): 7.963107585906982,\n", + " (2060, 7): 12.571847200393677,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.3917908668518066,\n", + " (2060, 11): 43.96746075153351,\n", + " (2060, 12): 257.7748085260391},\n", + " 'window': {(2060, 1): 231.5086898803711,\n", + " (2060, 2): 48.38065147399902,\n", + " (2060, 3): 51.445624351501465,\n", + " (2060, 4): 46.895301818847656,\n", + " (2060, 5): 10.405417680740356,\n", + " (2060, 6): 4.980204701423645,\n", + " (2060, 7): 4.211694955825806,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.3917908668518066,\n", + " (2060, 11): 20.59616208076477,\n", + " (2060, 12): 116.30028629302979}},\n", + " 149: {'monthly': {(2060, 1): 645.1791279315948,\n", + " (2060, 2): 165.97894537448883,\n", + " (2060, 3): 121.38528835773468,\n", + " (2060, 4): 50.27321529388428,\n", + " (2060, 5): 32.79390823841095,\n", + " (2060, 6): 7.963107585906982,\n", + " (2060, 7): 13.224380731582642,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 1.0784639120101929,\n", + " (2060, 10): 3.3917908668518066,\n", + " (2060, 11): 37.63751018047333,\n", + " (2060, 12): 250.09060204029083},\n", + " 'window': {(2060, 1): 235.10860443115234,\n", + " (2060, 2): 47.85704326629639,\n", + " (2060, 3): 54.26810598373413,\n", + " (2060, 4): 45.39660978317261,\n", + " (2060, 5): 16.19385075569153,\n", + " (2060, 6): 4.980204701423645,\n", + " (2060, 7): 4.252476692199707,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 1.0784639120101929,\n", + " (2060, 10): 3.3917908668518066,\n", + " (2060, 11): 21.534427642822266,\n", + " (2060, 12): 125.32210922241211}},\n", + " 150: {'monthly': {(2060, 1): 628.2978479862213,\n", + " (2060, 2): 148.3349301815033,\n", + " (2060, 3): 95.51983261108398,\n", + " (2060, 4): 50.320013642311096,\n", + " (2060, 5): 25.413307785987854,\n", + " (2060, 6): 7.963107585906982,\n", + " (2060, 7): 9.39979600906372,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.3917908668518066,\n", + " (2060, 11): 27.818561553955078,\n", + " (2060, 12): 201.84606957435608},\n", + " 'window': {(2060, 1): 234.2224578857422,\n", + " (2060, 2): 43.80603003501892,\n", + " (2060, 3): 38.46089506149292,\n", + " (2060, 4): 45.8143208026886,\n", + " (2060, 5): 11.174822926521301,\n", + " (2060, 6): 4.980204701423645,\n", + " (2060, 7): 3.244193196296692,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.3917908668518066,\n", + " (2060, 11): 16.0010244846344,\n", + " (2060, 12): 104.09573268890381}},\n", + " 151: {'monthly': {(2060, 1): 620.8021562099457,\n", + " (2060, 2): 112.56339943408966,\n", + " (2060, 3): 92.12151181697845,\n", + " (2060, 4): 43.650938749313354,\n", + " (2060, 5): 14.470364093780518,\n", + " (2060, 6): 7.963107585906982,\n", + " (2060, 7): 8.435335278511047,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.3917908668518066,\n", + " (2060, 11): 29.150977611541748,\n", + " (2060, 12): 192.822016954422},\n", + " 'window': {(2060, 1): 243.21150588989258,\n", + " (2060, 2): 33.20365357398987,\n", + " (2060, 3): 28.88232111930847,\n", + " (2060, 4): 39.5869779586792,\n", + " (2060, 5): 6.757672429084778,\n", + " (2060, 6): 4.980204701423645,\n", + " (2060, 7): 3.2855485677719116,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.3917908668518066,\n", + " (2060, 11): 17.35000443458557,\n", + " (2060, 12): 86.7116174697876}},\n", + " 152: {'monthly': {(2060, 1): 467.3408098220825,\n", + " (2060, 2): 166.31438207626343,\n", + " (2060, 3): 112.82327818870544,\n", + " (2060, 4): 40.85188031196594,\n", + " (2060, 5): 20.127455234527588,\n", + " (2060, 6): 4.8149508237838745,\n", + " (2060, 7): 8.060628771781921,\n", + " (2060, 8): 3.724740982055664,\n", + " (2060, 9): 3.9064046144485474,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 20.13737964630127,\n", + " (2060, 12): 264.90735852718353},\n", + " 'window': {(2060, 1): 209.07866859436035,\n", + " (2060, 2): 56.3311562538147,\n", + " (2060, 3): 41.6882746219635,\n", + " (2060, 4): 40.85188031196594,\n", + " (2060, 5): 7.504156231880188,\n", + " (2060, 6): 2.420486330986023,\n", + " (2060, 7): 4.300221085548401,\n", + " (2060, 8): 2.435946822166443,\n", + " (2060, 9): 2.666321039199829,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 19.11955213546753,\n", + " (2060, 12): 120.58591842651367}},\n", + " 153: {'monthly': {(2060, 1): 544.6104371547699,\n", + " (2060, 2): 215.23403096199036,\n", + " (2060, 3): 124.00178575515747,\n", + " (2060, 4): 50.215081453323364,\n", + " (2060, 5): 25.91333508491516,\n", + " (2060, 6): 7.438228964805603,\n", + " (2060, 7): 10.831429719924927,\n", + " (2060, 8): 4.729918599128723,\n", + " (2060, 9): 4.376833438873291,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 24.834824681282043,\n", + " (2060, 12): 324.11718106269836},\n", + " 'window': {(2060, 1): 233.21190643310547,\n", + " (2060, 2): 73.04850387573242,\n", + " (2060, 3): 45.87752151489258,\n", + " (2060, 4): 50.215081453323364,\n", + " (2060, 5): 10.606816172599792,\n", + " (2060, 6): 3.4925485849380493,\n", + " (2060, 7): 4.300221085548401,\n", + " (2060, 8): 2.435946822166443,\n", + " (2060, 9): 3.1367498636245728,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 23.816997170448303,\n", + " (2060, 12): 158.4347438812256}},\n", + " 154: {'monthly': {(2060, 1): 575.1244916915894,\n", + " (2060, 2): 224.38608920574188,\n", + " (2060, 3): 104.43615257740021,\n", + " (2060, 4): 55.246620655059814,\n", + " (2060, 5): 28.063321948051453,\n", + " (2060, 6): 7.0058112144470215,\n", + " (2060, 7): 9.924159169197083,\n", + " (2060, 8): 4.8364903926849365,\n", + " (2060, 9): 4.480561017990112,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 18.51421058177948,\n", + " (2060, 12): 327.46167039871216},\n", + " 'window': {(2060, 1): 279.6168441772461,\n", + " (2060, 2): 85.52055263519287,\n", + " (2060, 3): 34.29657030105591,\n", + " (2060, 4): 54.151129484176636,\n", + " (2060, 5): 11.8150954246521,\n", + " (2060, 6): 3.8219343423843384,\n", + " (2060, 7): 4.447750926017761,\n", + " (2060, 8): 3.5476962327957153,\n", + " (2060, 9): 3.240477442741394,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 17.49638307094574,\n", + " (2060, 12): 185.88535118103027}},\n", + " 155: {'monthly': {(2060, 1): 539.3107025623322,\n", + " (2060, 2): 178.0865559577942,\n", + " (2060, 3): 88.478156208992,\n", + " (2060, 4): 41.39406335353851,\n", + " (2060, 5): 26.385444045066833,\n", + " (2060, 6): 7.7990381717681885,\n", + " (2060, 7): 10.050246238708496,\n", + " (2060, 8): 3.724740982055664,\n", + " (2060, 9): 4.196112751960754,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 14.667012333869934,\n", + " (2060, 12): 294.4691479206085},\n", + " 'window': {(2060, 1): 288.03248023986816,\n", + " (2060, 2): 69.59409713745117,\n", + " (2060, 3): 27.123789072036743,\n", + " (2060, 4): 41.39406335353851,\n", + " (2060, 5): 11.211339235305786,\n", + " (2060, 6): 3.48790180683136,\n", + " (2060, 7): 4.300221085548401,\n", + " (2060, 8): 2.435946822166443,\n", + " (2060, 9): 2.956029176712036,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 13.649184823036194,\n", + " (2060, 12): 165.10726642608643}},\n", + " 156: {'monthly': {(2060, 1): 463.8175914287567,\n", + " (2060, 2): 114.76507651805878,\n", + " (2060, 3): 186.59984683990479,\n", + " (2060, 4): 66.47606456279755,\n", + " (2060, 5): 17.840253472328186,\n", + " (2060, 6): 8.094635844230652,\n", + " (2060, 7): 10.49191665649414,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 9.589590311050415,\n", + " (2060, 11): 75.8117184638977,\n", + " (2060, 12): 238.56864762306213},\n", + " 'window': {(2060, 1): 150.82674503326416,\n", + " (2060, 2): 29.345274925231934,\n", + " (2060, 3): 65.25421237945557,\n", + " (2060, 4): 42.125547885894775,\n", + " (2060, 5): 10.287072896957397,\n", + " (2060, 6): 2.9090415239334106,\n", + " (2060, 7): 3.24590265750885,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 5.666674017906189,\n", + " (2060, 11): 36.566338539123535,\n", + " (2060, 12): 76.04715538024902}},\n", + " 157: {'monthly': {(2060, 1): 445.5108299255371,\n", + " (2060, 2): 137.74211084842682,\n", + " (2060, 3): 143.97659599781036,\n", + " (2060, 4): 45.66780638694763,\n", + " (2060, 5): 16.342001080513,\n", + " (2060, 6): 8.047105312347412,\n", + " (2060, 7): 11.513828992843628,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.306508779525757,\n", + " (2060, 11): 39.23605036735535,\n", + " (2060, 12): 238.68454933166504},\n", + " 'window': {(2060, 1): 177.19201469421387,\n", + " (2060, 2): 44.930880308151245,\n", + " (2060, 3): 48.26083326339722,\n", + " (2060, 4): 39.0357084274292,\n", + " (2060, 5): 8.425317525863647,\n", + " (2060, 6): 5.011563539505005,\n", + " (2060, 7): 3.444610834121704,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.306508779525757,\n", + " (2060, 11): 24.872433304786682,\n", + " (2060, 12): 92.66023254394531}},\n", + " 158: {'monthly': {(2060, 1): 508.199538230896,\n", + " (2060, 2): 146.10861229896545,\n", + " (2060, 3): 150.79600644111633,\n", + " (2060, 4): 47.98918271064758,\n", + " (2060, 5): 16.505216002464294,\n", + " (2060, 6): 8.047105312347412,\n", + " (2060, 7): 10.662788271903992,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 4.631542205810547,\n", + " (2060, 11): 39.04755961894989,\n", + " (2060, 12): 257.0893337726593},\n", + " 'window': {(2060, 1): 200.11415672302246,\n", + " (2060, 2): 41.082892656326294,\n", + " (2060, 3): 44.37072539329529,\n", + " (2060, 4): 41.4025559425354,\n", + " (2060, 5): 7.854450583457947,\n", + " (2060, 6): 5.011563539505005,\n", + " (2060, 7): 4.0721495151519775,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.601518750190735,\n", + " (2060, 11): 24.319149494171143,\n", + " (2060, 12): 97.07602024078369}},\n", + " 159: {'monthly': {(2060, 1): 475.5495002269745,\n", + " (2060, 2): 127.80867207050323,\n", + " (2060, 3): 115.0802493095398,\n", + " (2060, 4): 36.43700611591339,\n", + " (2060, 5): 12.393890500068665,\n", + " (2060, 6): 9.135425329208374,\n", + " (2060, 7): 9.876981139183044,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.9625778198242188,\n", + " (2060, 11): 33.560656666755676,\n", + " (2060, 12): 198.35782718658447},\n", + " 'window': {(2060, 1): 193.26773834228516,\n", + " (2060, 2): 39.20485997200012,\n", + " (2060, 3): 34.99464511871338,\n", + " (2060, 4): 29.872126817703247,\n", + " (2060, 5): 6.741479754447937,\n", + " (2060, 6): 5.011563539505005,\n", + " (2060, 7): 3.2863423824310303,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.9625778198242188,\n", + " (2060, 11): 21.208625078201294,\n", + " (2060, 12): 75.17016792297363}},\n", + " 160: {'monthly': {(2060, 1): 467.2062494754791,\n", + " (2060, 2): 133.52259409427643,\n", + " (2060, 3): 108.98066568374634,\n", + " (2060, 4): 23.98950183391571,\n", + " (2060, 5): 9.674503922462463,\n", + " (2060, 6): 9.095479488372803,\n", + " (2060, 7): 7.626797080039978,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.306508779525757,\n", + " (2060, 11): 33.279420137405396,\n", + " (2060, 12): 175.39110231399536},\n", + " 'window': {(2060, 1): 189.98137283325195,\n", + " (2060, 2): 37.55669903755188,\n", + " (2060, 3): 37.487526655197144,\n", + " (2060, 4): 19.742302656173706,\n", + " (2060, 5): 5.15053927898407,\n", + " (2060, 6): 5.011563539505005,\n", + " (2060, 7): 2.7263057231903076,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.306508779525757,\n", + " (2060, 11): 20.82107937335968,\n", + " (2060, 12): 62.41847038269043}},\n", + " 161: {'monthly': {(2060, 1): 565.223915714616,\n", + " (2060, 2): 158.11182463169098,\n", + " (2060, 3): 130.915123462677,\n", + " (2060, 4): 51.02925181388855,\n", + " (2060, 5): 17.528724789619446,\n", + " (2060, 6): 7.963107585906982,\n", + " (2060, 7): 11.038378596305847,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 1.0411758422851562,\n", + " (2060, 10): 3.3917908668518066,\n", + " (2060, 11): 35.32120990753174,\n", + " (2060, 12): 247.7245466709137},\n", + " 'window': {(2060, 1): 212.8940035289471,\n", + " (2060, 2): 47.37472629547119,\n", + " (2060, 3): 56.69211196899414,\n", + " (2060, 4): 47.30654764175415,\n", + " (2060, 5): 8.02337896823883,\n", + " (2060, 6): 4.980204701423645,\n", + " (2060, 7): 3.557786226272583,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 1.0411758422851562,\n", + " (2060, 10): 3.3917908668518066,\n", + " (2060, 11): 17.92144227027893,\n", + " (2060, 12): 111.06937980651855}},\n", + " 162: {'monthly': {(2060, 1): 639.5122224201051,\n", + " (2060, 2): 184.33773565292358,\n", + " (2060, 3): 136.3620994091034,\n", + " (2060, 4): 51.995134115219116,\n", + " (2060, 5): 26.852630615234375,\n", + " (2060, 6): 7.963107585906982,\n", + " (2060, 7): 9.286041021347046,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.3917908668518066,\n", + " (2060, 11): 28.37576115131378,\n", + " (2060, 12): 240.14594495296478},\n", + " 'window': {(2060, 1): 215.69339574469006,\n", + " (2060, 2): 61.68908333778381,\n", + " (2060, 3): 58.49646186828613,\n", + " (2060, 4): 45.944661140441895,\n", + " (2060, 5): 12.772626042366028,\n", + " (2060, 6): 4.980204701423645,\n", + " (2060, 7): 2.972941756248474,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.3917908668518066,\n", + " (2060, 11): 15.555755138397217,\n", + " (2060, 12): 118.71782112121582}},\n", + " 163: {'monthly': {(2060, 1): 689.4888419705046,\n", + " (2060, 2): 164.22910010814667,\n", + " (2060, 3): 114.84975385665894,\n", + " (2060, 4): 54.110827565193176,\n", + " (2060, 5): 24.509538650512695,\n", + " (2060, 6): 7.963107585906982,\n", + " (2060, 7): 8.41568410396576,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.3917908668518066,\n", + " (2060, 11): 31.676334142684937,\n", + " (2060, 12): 228.28842520713806},\n", + " 'window': {(2060, 1): 262.857626636566,\n", + " (2060, 2): 55.66867470741272,\n", + " (2060, 3): 43.93050932884216,\n", + " (2060, 4): 49.23559331893921,\n", + " (2060, 5): 11.634418606758118,\n", + " (2060, 6): 4.980204701423645,\n", + " (2060, 7): 3.2658973932266235,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.3917908668518066,\n", + " (2060, 11): 18.955174684524536,\n", + " (2060, 12): 108.42728042602539}},\n", + " 164: {'monthly': {(2060, 1): 703.5734467506409,\n", + " (2060, 2): 138.86306059360504,\n", + " (2060, 3): 121.05509626865387,\n", + " (2060, 4): 52.200483202934265,\n", + " (2060, 5): 19.944064140319824,\n", + " (2060, 6): 9.021228671073914,\n", + " (2060, 7): 9.587644577026367,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.3917908668518066,\n", + " (2060, 11): 26.55596351623535,\n", + " (2060, 12): 235.7708294391632},\n", + " 'window': {(2060, 1): 293.93906593322754,\n", + " (2060, 2): 48.78366315364838,\n", + " (2060, 3): 39.95149850845337,\n", + " (2060, 4): 45.26901912689209,\n", + " (2060, 5): 9.416640400886536,\n", + " (2060, 6): 4.980204701423645,\n", + " (2060, 7): 4.4378578662872314,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.3917908668518066,\n", + " (2060, 11): 16.865971446037292,\n", + " (2060, 12): 104.30511569976807}},\n", + " 165: {'monthly': {(2060, 1): 491.4772412776947,\n", + " (2060, 2): 195.91738986968994,\n", + " (2060, 3): 144.90502297878265,\n", + " (2060, 4): 37.79078495502472,\n", + " (2060, 5): 25.440772533416748,\n", + " (2060, 6): 9.271228313446045,\n", + " (2060, 7): 9.373435378074646,\n", + " (2060, 8): 3.724740982055664,\n", + " (2060, 9): 3.990866184234619,\n", + " (2060, 10): 1.0318998098373413,\n", + " (2060, 11): 21.745880842208862,\n", + " (2060, 12): 301.3002278804779},\n", + " 'window': {(2060, 1): 218.55953407287598,\n", + " (2060, 2): 58.472350120544434,\n", + " (2060, 3): 43.59434723854065,\n", + " (2060, 4): 36.76918697357178,\n", + " (2060, 5): 9.280464768409729,\n", + " (2060, 6): 5.329821705818176,\n", + " (2060, 7): 4.60762083530426,\n", + " (2060, 8): 2.435946822166443,\n", + " (2060, 9): 2.750782608985901,\n", + " (2060, 10): 1.0318998098373413,\n", + " (2060, 11): 19.39120852947235,\n", + " (2060, 12): 132.91931533813477}},\n", + " 166: {'monthly': {(2060, 1): 534.2101745605469,\n", + " (2060, 2): 242.63611924648285,\n", + " (2060, 3): 146.4498221874237,\n", + " (2060, 4): 44.790350675582886,\n", + " (2060, 5): 34.44154489040375,\n", + " (2060, 6): 9.449797630310059,\n", + " (2060, 7): 9.653993725776672,\n", + " (2060, 8): 3.724740982055664,\n", + " (2060, 9): 4.367807865142822,\n", + " (2060, 10): 1.0837409496307373,\n", + " (2060, 11): 26.596923112869263,\n", + " (2060, 12): 318.84148013591766},\n", + " 'window': {(2060, 1): 219.0299472808838,\n", + " (2060, 2): 72.482177734375,\n", + " (2060, 3): 46.967514514923096,\n", + " (2060, 4): 41.520403146743774,\n", + " (2060, 5): 13.284638285636902,\n", + " (2060, 6): 4.675109624862671,\n", + " (2060, 7): 4.300221085548401,\n", + " (2060, 8): 2.435946822166443,\n", + " (2060, 9): 3.127724289894104,\n", + " (2060, 10): 1.0837409496307373,\n", + " (2060, 11): 24.52204155921936,\n", + " (2060, 12): 152.4080810546875}},\n", + " 167: {'monthly': {(2060, 1): 553.5301396846771,\n", + " (2060, 2): 259.5726568698883,\n", + " (2060, 3): 114.79242014884949,\n", + " (2060, 4): 43.78909921646118,\n", + " (2060, 5): 31.613327980041504,\n", + " (2060, 6): 9.55726945400238,\n", + " (2060, 7): 9.81840717792511,\n", + " (2060, 8): 3.724740982055664,\n", + " (2060, 9): 4.229665637016296,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 19.81907093524933,\n", + " (2060, 12): 313.30940186977386},\n", + " 'window': {(2060, 1): 248.92206573486328,\n", + " (2060, 2): 88.70847702026367,\n", + " (2060, 3): 37.167367935180664,\n", + " (2060, 4): 43.78909921646118,\n", + " (2060, 5): 12.177411675453186,\n", + " (2060, 6): 3.769272804260254,\n", + " (2060, 7): 4.300221085548401,\n", + " (2060, 8): 2.435946822166443,\n", + " (2060, 9): 2.989582061767578,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 18.80124342441559,\n", + " (2060, 12): 174.07167625427246}},\n", + " 168: {'monthly': {(2060, 1): 507.4827492237091,\n", + " (2060, 2): 192.77526688575745,\n", + " (2060, 3): 94.72853350639343,\n", + " (2060, 4): 40.32822299003601,\n", + " (2060, 5): 27.072498083114624,\n", + " (2060, 6): 5.675352096557617,\n", + " (2060, 7): 9.305126667022705,\n", + " (2060, 8): 3.724740982055664,\n", + " (2060, 9): 4.076937556266785,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 16.762393832206726,\n", + " (2060, 12): 268.0553960800171},\n", + " 'window': {(2060, 1): 261.0039234161377,\n", + " (2060, 2): 67.60743141174316,\n", + " (2060, 3): 29.80318260192871,\n", + " (2060, 4): 37.07877051830292,\n", + " (2060, 5): 10.954896569252014,\n", + " (2060, 6): 2.420486330986023,\n", + " (2060, 7): 4.300221085548401,\n", + " (2060, 8): 2.435946822166443,\n", + " (2060, 9): 2.8368539810180664,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 15.744566321372986,\n", + " (2060, 12): 149.61017036437988}},\n", + " 169: {'monthly': {(2060, 1): 433.3210600614548,\n", + " (2060, 2): 124.86576128005981,\n", + " (2060, 3): 139.96077752113342,\n", + " (2060, 4): 48.07671642303467,\n", + " (2060, 5): 11.279325246810913,\n", + " (2060, 6): 4.076462268829346,\n", + " (2060, 7): 6.096834063529968,\n", + " (2060, 8): 1.8466986417770386,\n", + " (2060, 9): 2.37607479095459,\n", + " (2060, 10): 3.6148860454559326,\n", + " (2060, 11): 55.7458518743515,\n", + " (2060, 12): 222.96572065353394},\n", + " 'window': {(2060, 1): 108.38686656951904,\n", + " (2060, 2): 36.78160095214844,\n", + " (2060, 3): 47.96235752105713,\n", + " (2060, 4): 34.6370552778244,\n", + " (2060, 5): 5.13140344619751,\n", + " (2060, 6): 4.076462268829346,\n", + " (2060, 7): 2.7373101711273193,\n", + " (2060, 8): 1.8466986417770386,\n", + " (2060, 9): 1.3261799812316895,\n", + " (2060, 10): 2.5250110626220703,\n", + " (2060, 11): 22.96978533267975,\n", + " (2060, 12): 80.55756568908691}},\n", + " 170: {'monthly': {(2060, 1): 404.89933264255524,\n", + " (2060, 2): 181.18919503688812,\n", + " (2060, 3): 144.7589386701584,\n", + " (2060, 4): 44.84254801273346,\n", + " (2060, 5): 22.080283522605896,\n", + " (2060, 6): 6.7379865646362305,\n", + " (2060, 7): 4.303999423980713,\n", + " (2060, 8): 2.47005558013916,\n", + " (2060, 9): 1.2781932353973389,\n", + " (2060, 10): 4.805362701416016,\n", + " (2060, 11): 30.86307418346405,\n", + " (2060, 12): 209.41005182266235},\n", + " 'window': {(2060, 1): 117.49062156677246,\n", + " (2060, 2): 53.06289529800415,\n", + " (2060, 3): 56.57902717590332,\n", + " (2060, 4): 38.929309010505676,\n", + " (2060, 5): 10.568870067596436,\n", + " (2060, 6): 3.8782328367233276,\n", + " (2060, 7): 2.9877573251724243,\n", + " (2060, 8): 2.47005558013916,\n", + " (2060, 9): 1.2781932353973389,\n", + " (2060, 10): 3.7240233421325684,\n", + " (2060, 11): 24.074130415916443,\n", + " (2060, 12): 110.17433452606201}},\n", + " 171: {'monthly': {(2060, 1): 404.4457914829254,\n", + " (2060, 2): 159.9511135816574,\n", + " (2060, 3): 127.25025510787964,\n", + " (2060, 4): 47.67215573787689,\n", + " (2060, 5): 20.331368327140808,\n", + " (2060, 6): 6.7379865646362305,\n", + " (2060, 7): 4.303999423980713,\n", + " (2060, 8): 2.47005558013916,\n", + " (2060, 9): 1.2781932353973389,\n", + " (2060, 10): 6.628361225128174,\n", + " (2060, 11): 38.94187819957733,\n", + " (2060, 12): 208.38894045352936},\n", + " 'window': {(2060, 1): 120.27606010437012,\n", + " (2060, 2): 50.045090675354004,\n", + " (2060, 3): 48.71772241592407,\n", + " (2060, 4): 40.482062220573425,\n", + " (2060, 5): 9.94093668460846,\n", + " (2060, 6): 3.8782328367233276,\n", + " (2060, 7): 2.9877573251724243,\n", + " (2060, 8): 2.47005558013916,\n", + " (2060, 9): 1.2781932353973389,\n", + " (2060, 10): 5.078392744064331,\n", + " (2060, 11): 27.37696647644043,\n", + " (2060, 12): 115.6985034942627}},\n", + " 172: {'monthly': {(2060, 1): 391.70141184329987,\n", + " (2060, 2): 147.6609525680542,\n", + " (2060, 3): 109.62588310241699,\n", + " (2060, 4): 49.474047899246216,\n", + " (2060, 5): 15.682674050331116,\n", + " (2060, 6): 6.7379865646362305,\n", + " (2060, 7): 4.303999423980713,\n", + " (2060, 8): 2.47005558013916,\n", + " (2060, 9): 1.2781932353973389,\n", + " (2060, 10): 2.8441531658172607,\n", + " (2060, 11): 29.458752632141113,\n", + " (2060, 12): 210.0579401254654},\n", + " 'window': {(2060, 1): 127.33689498901367,\n", + " (2060, 2): 46.592326641082764,\n", + " (2060, 3): 44.437650203704834,\n", + " (2060, 4): 43.23923051357269,\n", + " (2060, 5): 8.131774544715881,\n", + " (2060, 6): 3.8782328367233276,\n", + " (2060, 7): 2.9877573251724243,\n", + " (2060, 8): 2.47005558013916,\n", + " (2060, 9): 1.2781932353973389,\n", + " (2060, 10): 2.8441531658172607,\n", + " (2060, 11): 23.342105984687805,\n", + " (2060, 12): 113.7997236251831}},\n", + " 173: {'monthly': {(2060, 1): 425.51972138881683,\n", + " (2060, 2): 158.6221764087677,\n", + " (2060, 3): 107.79366290569305,\n", + " (2060, 4): 53.641563057899475,\n", + " (2060, 5): 12.246930718421936,\n", + " (2060, 6): 8.188737511634827,\n", + " (2060, 7): 5.574302792549133,\n", + " (2060, 8): 2.47005558013916,\n", + " (2060, 9): 1.2781932353973389,\n", + " (2060, 10): 3.887343168258667,\n", + " (2060, 11): 25.00710380077362,\n", + " (2060, 12): 215.6530042886734},\n", + " 'window': {(2060, 1): 145.2794952392578,\n", + " (2060, 2): 45.12789726257324,\n", + " (2060, 3): 45.14041996002197,\n", + " (2060, 4): 47.55679929256439,\n", + " (2060, 5): 6.480376362800598,\n", + " (2060, 6): 3.8782328367233276,\n", + " (2060, 7): 2.9877573251724243,\n", + " (2060, 8): 2.47005558013916,\n", + " (2060, 9): 1.2781932353973389,\n", + " (2060, 10): 2.8441531658172607,\n", + " (2060, 11): 20.937688946723938,\n", + " (2060, 12): 117.17482948303223}},\n", + " 174: {'monthly': {(2060, 1): 496.2138330936432,\n", + " (2060, 2): 215.77780532836914,\n", + " (2060, 3): 128.52353930473328,\n", + " (2060, 4): 69.4588680267334,\n", + " (2060, 5): 8.201274514198303,\n", + " (2060, 6): 6.740338921546936,\n", + " (2060, 7): 4.3274606466293335,\n", + " (2060, 8): 2.5208728313446045,\n", + " (2060, 9): 1.3040574789047241,\n", + " (2060, 10): 3.930637240409851,\n", + " (2060, 11): 29.002832174301147,\n", + " (2060, 12): 245.47423183918},\n", + " 'window': {(2060, 1): 155.98570728302002,\n", + " (2060, 2): 65.96364879608154,\n", + " (2060, 3): 37.771923542022705,\n", + " (2060, 4): 60.970356702804565,\n", + " (2060, 5): 3.745055317878723,\n", + " (2060, 6): 3.875940203666687,\n", + " (2060, 7): 2.9816426038742065,\n", + " (2060, 8): 2.5208728313446045,\n", + " (2060, 9): 1.3040574789047241,\n", + " (2060, 10): 3.930637240409851,\n", + " (2060, 11): 18.311312794685364,\n", + " (2060, 12): 129.86513900756836}},\n", + " 175: {'monthly': {(2060, 1): 563.3781534433365,\n", + " (2060, 2): 212.954984664917,\n", + " (2060, 3): 126.57059407234192,\n", + " (2060, 4): 86.20504605770111,\n", + " (2060, 5): 8.866072058677673,\n", + " (2060, 6): 6.740338921546936,\n", + " (2060, 7): 4.3274606466293335,\n", + " (2060, 8): 2.5208728313446045,\n", + " (2060, 9): 1.3040574789047241,\n", + " (2060, 10): 3.930637240409851,\n", + " (2060, 11): 24.298937559127808,\n", + " (2060, 12): 270.80613470077515},\n", + " 'window': {(2060, 1): 171.2141933441162,\n", + " (2060, 2): 72.80364608764648,\n", + " (2060, 3): 42.0101957321167,\n", + " (2060, 4): 78.03071546554565,\n", + " (2060, 5): 4.064038872718811,\n", + " (2060, 6): 3.875940203666687,\n", + " (2060, 7): 2.9816426038742065,\n", + " (2060, 8): 2.5208728313446045,\n", + " (2060, 9): 1.3040574789047241,\n", + " (2060, 10): 3.930637240409851,\n", + " (2060, 11): 18.181456208229065,\n", + " (2060, 12): 159.3554229736328}},\n", + " 176: {'monthly': {(2060, 1): 612.4284174442291,\n", + " (2060, 2): 221.30492556095123,\n", + " (2060, 3): 142.92271900177002,\n", + " (2060, 4): 108.82803928852081,\n", + " (2060, 5): 10.968544125556946,\n", + " (2060, 6): 6.740338921546936,\n", + " (2060, 7): 4.602813363075256,\n", + " (2060, 8): 2.5208728313446045,\n", + " (2060, 9): 1.3040574789047241,\n", + " (2060, 10): 3.930637240409851,\n", + " (2060, 11): 25.25548255443573,\n", + " (2060, 12): 316.99953496456146},\n", + " 'window': {(2060, 1): 199.54974365234375,\n", + " (2060, 2): 72.30061769485474,\n", + " (2060, 3): 48.6369423866272,\n", + " (2060, 4): 97.95365226268768,\n", + " (2060, 5): 5.072848439216614,\n", + " (2060, 6): 3.875940203666687,\n", + " (2060, 7): 3.2569953203201294,\n", + " (2060, 8): 2.5208728313446045,\n", + " (2060, 9): 1.3040574789047241,\n", + " (2060, 10): 3.930637240409851,\n", + " (2060, 11): 19.794592261314392,\n", + " (2060, 12): 201.73933029174805}},\n", + " 177: {'monthly': {(2060, 1): 592.388561964035,\n", + " (2060, 2): 210.3623481988907,\n", + " (2060, 3): 144.89045894145966,\n", + " (2060, 4): 106.92061638832092,\n", + " (2060, 5): 11.997749209403992,\n", + " (2060, 6): 6.740338921546936,\n", + " (2060, 7): 5.873659253120422,\n", + " (2060, 8): 2.5208728313446045,\n", + " (2060, 9): 1.3040574789047241,\n", + " (2060, 10): 3.930637240409851,\n", + " (2060, 11): 28.594520807266235,\n", + " (2060, 12): 325.4349226951599},\n", + " 'window': {(2060, 1): 199.83579635620117,\n", + " (2060, 2): 72.72619318962097,\n", + " (2060, 3): 49.3179931640625,\n", + " (2060, 4): 95.42072415351868,\n", + " (2060, 5): 5.56668221950531,\n", + " (2060, 6): 3.875940203666687,\n", + " (2060, 7): 3.4456844329833984,\n", + " (2060, 8): 2.5208728313446045,\n", + " (2060, 9): 1.3040574789047241,\n", + " (2060, 10): 3.930637240409851,\n", + " (2060, 11): 22.519856572151184,\n", + " (2060, 12): 201.87748908996582}},\n", + " 178: {'monthly': {(2060, 1): 543.9809947013855,\n", + " (2060, 2): 259.36223578453064,\n", + " (2060, 3): 163.39790451526642,\n", + " (2060, 4): 48.27225303649902,\n", + " (2060, 5): 14.929511785507202,\n", + " (2060, 6): 8.283711671829224,\n", + " (2060, 7): 7.506377577781677,\n", + " (2060, 8): 5.827641844749451,\n", + " (2060, 9): 4.551493167877197,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 38.90728199481964,\n", + " (2060, 12): 298.67132329940796},\n", + " 'window': {(2060, 1): 244.03939247131348,\n", + " (2060, 2): 71.7292537689209,\n", + " (2060, 3): 53.041993618011475,\n", + " (2060, 4): 41.78885471820831,\n", + " (2060, 5): 6.733692169189453,\n", + " (2060, 6): 3.388978958129883,\n", + " (2060, 7): 3.630094051361084,\n", + " (2060, 8): 3.5004416704177856,\n", + " (2060, 9): 1.2823882102966309,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 30.068946361541748,\n", + " (2060, 12): 125.12987422943115}},\n", + " 179: {'monthly': {(2060, 1): 625.8229532241821,\n", + " (2060, 2): 306.4394884109497,\n", + " (2060, 3): 148.64886355400085,\n", + " (2060, 4): 60.008862137794495,\n", + " (2060, 5): 16.296876788139343,\n", + " (2060, 6): 7.417203783988953,\n", + " (2060, 7): 7.605239033699036,\n", + " (2060, 8): 7.647725343704224,\n", + " (2060, 9): 5.358657479286194,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 36.778788685798645,\n", + " (2060, 12): 307.45755314826965},\n", + " 'window': {(2060, 1): 316.5361518859863,\n", + " (2060, 2): 88.41947555541992,\n", + " (2060, 3): 47.63106679916382,\n", + " (2060, 4): 55.26478672027588,\n", + " (2060, 5): 7.355627417564392,\n", + " (2060, 6): 3.388978958129883,\n", + " (2060, 7): 3.630094051361084,\n", + " (2060, 8): 5.320525169372559,\n", + " (2060, 9): 3.1279066801071167,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 25.313725471496582,\n", + " (2060, 12): 144.18492889404297}},\n", + " 180: {'monthly': {(2060, 1): 672.832441329956,\n", + " (2060, 2): 317.80841422080994,\n", + " (2060, 3): 116.37390553951263,\n", + " (2060, 4): 70.758913397789,\n", + " (2060, 5): 15.91000759601593,\n", + " (2060, 6): 7.583552360534668,\n", + " (2060, 7): 6.754104971885681,\n", + " (2060, 8): 7.177797555923462,\n", + " (2060, 9): 3.513139009475708,\n", + " (2060, 10): 2.009666681289673,\n", + " (2060, 11): 36.33926486968994,\n", + " (2060, 12): 280.2600975036621},\n", + " 'window': {(2060, 1): 381.65076637268066,\n", + " (2060, 2): 97.55902671813965,\n", + " (2060, 3): 38.84680795669556,\n", + " (2060, 4): 65.22104668617249,\n", + " (2060, 5): 6.662021636962891,\n", + " (2060, 6): 3.388978958129883,\n", + " (2060, 7): 3.630094051361084,\n", + " (2060, 8): 4.850597381591797,\n", + " (2060, 9): 1.2823882102966309,\n", + " (2060, 10): 2.009666681289673,\n", + " (2060, 11): 26.953388810157776,\n", + " (2060, 12): 139.53970336914062}},\n", + " 181: {'monthly': {(2060, 1): 652.1872477531433,\n", + " (2060, 2): 256.2237331867218,\n", + " (2060, 3): 106.07407116889954,\n", + " (2060, 4): 92.04533612728119,\n", + " (2060, 5): 12.587363839149475,\n", + " (2060, 6): 7.342294931411743,\n", + " (2060, 7): 5.7028772830963135,\n", + " (2060, 8): 5.827641844749451,\n", + " (2060, 9): 3.513139009475708,\n", + " (2060, 10): 1.2340120077133179,\n", + " (2060, 11): 22.55231547355652,\n", + " (2060, 12): 231.8488734960556},\n", + " 'window': {(2060, 1): 394.88218879699707,\n", + " (2060, 2): 74.93708324432373,\n", + " (2060, 3): 33.20337176322937,\n", + " (2060, 4): 87.20618748664856,\n", + " (2060, 5): 6.205767393112183,\n", + " (2060, 6): 3.388978958129883,\n", + " (2060, 7): 3.630094051361084,\n", + " (2060, 8): 3.5004416704177856,\n", + " (2060, 9): 1.2823882102966309,\n", + " (2060, 10): 1.2340120077133179,\n", + " (2060, 11): 16.506348848342896,\n", + " (2060, 12): 114.28431224822998}},\n", + " 182: {'monthly': {(2060, 1): 405.77519512176514,\n", + " (2060, 2): 136.03984582424164,\n", + " (2060, 3): 151.52858448028564,\n", + " (2060, 4): 39.01797533035278,\n", + " (2060, 5): 8.549841046333313,\n", + " (2060, 6): 4.076462268829346,\n", + " (2060, 7): 6.096834063529968,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 1.0498948097229004,\n", + " (2060, 10): 1.3706409931182861,\n", + " (2060, 11): 45.368114709854126,\n", + " (2060, 12): 208.27693855762482},\n", + " 'window': {(2060, 1): 113.39015674591064,\n", + " (2060, 2): 39.53985595703125,\n", + " (2060, 3): 60.72334289550781,\n", + " (2060, 4): 28.052588939666748,\n", + " (2060, 5): 3.8868887424468994,\n", + " (2060, 6): 4.076462268829346,\n", + " (2060, 7): 2.7373101711273193,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 1.0498948097229004,\n", + " (2060, 10): 1.3706409931182861,\n", + " (2060, 11): 21.898704409599304,\n", + " (2060, 12): 87.70970249176025}},\n", + " 183: {'monthly': {(2060, 1): 369.88528883457184,\n", + " (2060, 2): 144.67017221450806,\n", + " (2060, 3): 119.76149559020996,\n", + " (2060, 4): 61.14673697948456,\n", + " (2060, 5): 16.54300332069397,\n", + " (2060, 6): 6.7379865646362305,\n", + " (2060, 7): 4.303999423980713,\n", + " (2060, 8): 2.47005558013916,\n", + " (2060, 9): 2.7569934129714966,\n", + " (2060, 10): 3.85209059715271,\n", + " (2060, 11): 22.895681977272034,\n", + " (2060, 12): 192.11981236934662},\n", + " 'window': {(2060, 1): 121.12446022033691,\n", + " (2060, 2): 47.756664991378784,\n", + " (2060, 3): 43.11520004272461,\n", + " (2060, 4): 53.913745641708374,\n", + " (2060, 5): 8.547401666641235,\n", + " (2060, 6): 3.8782328367233276,\n", + " (2060, 7): 2.9877573251724243,\n", + " (2060, 8): 2.47005558013916,\n", + " (2060, 9): 2.7569934129714966,\n", + " (2060, 10): 3.85209059715271,\n", + " (2060, 11): 16.643622636795044,\n", + " (2060, 12): 106.24199676513672}},\n", + " 184: {'monthly': {(2060, 1): 355.6031981706619,\n", + " (2060, 2): 129.67078578472137,\n", + " (2060, 3): 103.14015519618988,\n", + " (2060, 4): 52.44886016845703,\n", + " (2060, 5): 13.811297059059143,\n", + " (2060, 6): 6.7379865646362305,\n", + " (2060, 7): 4.303999423980713,\n", + " (2060, 8): 2.47005558013916,\n", + " (2060, 9): 1.2781932353973389,\n", + " (2060, 10): 2.8441531658172607,\n", + " (2060, 11): 23.889975666999817,\n", + " (2060, 12): 184.1714073419571},\n", + " 'window': {(2060, 1): 120.3980827331543,\n", + " (2060, 2): 43.56775498390198,\n", + " (2060, 3): 37.164753437042236,\n", + " (2060, 4): 45.352816462516785,\n", + " (2060, 5): 7.2322927713394165,\n", + " (2060, 6): 3.8782328367233276,\n", + " (2060, 7): 2.9877573251724243,\n", + " (2060, 8): 2.47005558013916,\n", + " (2060, 9): 1.2781932353973389,\n", + " (2060, 10): 2.8441531658172607,\n", + " (2060, 11): 17.793630242347717,\n", + " (2060, 12): 106.31522178649902}},\n", + " 185: {'monthly': {(2060, 1): 397.27421617507935,\n", + " (2060, 2): 146.68269562721252,\n", + " (2060, 3): 105.63034975528717,\n", + " (2060, 4): 48.238969922065735,\n", + " (2060, 5): 13.246874451637268,\n", + " (2060, 6): 6.7379865646362305,\n", + " (2060, 7): 5.694689750671387,\n", + " (2060, 8): 2.47005558013916,\n", + " (2060, 9): 1.2781932353973389,\n", + " (2060, 10): 2.8848899602890015,\n", + " (2060, 11): 26.918259739875793,\n", + " (2060, 12): 208.72003734111786},\n", + " 'window': {(2060, 1): 132.46563529968262,\n", + " (2060, 2): 48.783474922180176,\n", + " (2060, 3): 39.3299298286438,\n", + " (2060, 4): 42.340017199516296,\n", + " (2060, 5): 6.961001515388489,\n", + " (2060, 6): 3.8782328367233276,\n", + " (2060, 7): 2.9877573251724243,\n", + " (2060, 8): 2.47005558013916,\n", + " (2060, 9): 1.2781932353973389,\n", + " (2060, 10): 2.8848899602890015,\n", + " (2060, 11): 19.637941241264343,\n", + " (2060, 12): 121.34596157073975}},\n", + " 186: {'monthly': {(2060, 1): 469.72188997268677,\n", + " (2060, 2): 177.04165184497833,\n", + " (2060, 3): 127.85494446754456,\n", + " (2060, 4): 58.95134139060974,\n", + " (2060, 5): 12.372617840766907,\n", + " (2060, 6): 7.9018378257751465,\n", + " (2060, 7): 6.196806192398071,\n", + " (2060, 8): 2.47005558013916,\n", + " (2060, 9): 2.458106517791748,\n", + " (2060, 10): 5.228024959564209,\n", + " (2060, 11): 27.820285081863403,\n", + " (2060, 12): 237.9046585559845},\n", + " 'window': {(2060, 1): 145.2359161376953,\n", + " (2060, 2): 55.15373492240906,\n", + " (2060, 3): 46.54995536804199,\n", + " (2060, 4): 51.3986850976944,\n", + " (2060, 5): 6.540788292884827,\n", + " (2060, 6): 3.8782328367233276,\n", + " (2060, 7): 3.209048867225647,\n", + " (2060, 8): 2.47005558013916,\n", + " (2060, 9): 1.2781932353973389,\n", + " (2060, 10): 4.0480886697769165,\n", + " (2060, 11): 21.26867711544037,\n", + " (2060, 12): 132.96415042877197}},\n", + " 187: {'monthly': {(2060, 1): 542.399400472641,\n", + " (2060, 2): 225.80084574222565,\n", + " (2060, 3): 134.29978358745575,\n", + " (2060, 4): 82.93935644626617,\n", + " (2060, 5): 11.787306308746338,\n", + " (2060, 6): 7.764914631843567,\n", + " (2060, 7): 7.092933535575867,\n", + " (2060, 8): 2.5208728313446045,\n", + " (2060, 9): 1.3040574789047241,\n", + " (2060, 10): 4.9943296909332275,\n", + " (2060, 11): 27.15666949748993,\n", + " (2060, 12): 258.29983139038086},\n", + " 'window': {(2060, 1): 167.7555274963379,\n", + " (2060, 2): 67.10184001922607,\n", + " (2060, 3): 39.93478345870972,\n", + " (2060, 4): 71.20936715602875,\n", + " (2060, 5): 5.016523122787476,\n", + " (2060, 6): 3.875940203666687,\n", + " (2060, 7): 4.11129093170166,\n", + " (2060, 8): 2.5208728313446045,\n", + " (2060, 9): 1.3040574789047241,\n", + " (2060, 10): 3.930637240409851,\n", + " (2060, 11): 20.111359119415283,\n", + " (2060, 12): 133.3361349105835}},\n", + " 188: {'monthly': {(2060, 1): 598.7887225151062,\n", + " (2060, 2): 218.7007406949997,\n", + " (2060, 3): 145.41692197322845,\n", + " (2060, 4): 99.52171218395233,\n", + " (2060, 5): 11.03626263141632,\n", + " (2060, 6): 6.740338921546936,\n", + " (2060, 7): 4.3274606466293335,\n", + " (2060, 8): 3.775202751159668,\n", + " (2060, 9): 1.3040574789047241,\n", + " (2060, 10): 4.93518340587616,\n", + " (2060, 11): 28.248595237731934,\n", + " (2060, 12): 280.4544018507004},\n", + " 'window': {(2060, 1): 190.31160926818848,\n", + " (2060, 2): 66.86510372161865,\n", + " (2060, 3): 47.508249282836914,\n", + " (2060, 4): 91.03409075737,\n", + " (2060, 5): 5.122410535812378,\n", + " (2060, 6): 3.875940203666687,\n", + " (2060, 7): 2.9816426038742065,\n", + " (2060, 8): 2.756471872329712,\n", + " (2060, 9): 1.3040574789047241,\n", + " (2060, 10): 3.930637240409851,\n", + " (2060, 11): 22.028297543525696,\n", + " (2060, 12): 160.07634735107422}},\n", + " 189: {'monthly': {(2060, 1): 658.3256549835205,\n", + " (2060, 2): 220.38838756084442,\n", + " (2060, 3): 182.7681449651718,\n", + " (2060, 4): 113.77284824848175,\n", + " (2060, 5): 15.409147024154663,\n", + " (2060, 6): 7.775402188301086,\n", + " (2060, 7): 5.4611053466796875,\n", + " (2060, 8): 2.5208728313446045,\n", + " (2060, 9): 1.3040574789047241,\n", + " (2060, 10): 3.930637240409851,\n", + " (2060, 11): 39.078264236450195,\n", + " (2060, 12): 329.9988250732422},\n", + " 'window': {(2060, 1): 231.4576072692871,\n", + " (2060, 2): 76.87682437896729,\n", + " (2060, 3): 63.00089740753174,\n", + " (2060, 4): 101.57303476333618,\n", + " (2060, 5): 6.241260766983032,\n", + " (2060, 6): 4.911003470420837,\n", + " (2060, 7): 2.9816426038742065,\n", + " (2060, 8): 2.5208728313446045,\n", + " (2060, 9): 1.3040574789047241,\n", + " (2060, 10): 3.930637240409851,\n", + " (2060, 11): 29.440078616142273,\n", + " (2060, 12): 192.80319213867188}},\n", + " 190: {'monthly': {(2060, 1): 594.7845485210419,\n", + " (2060, 2): 209.18859493732452,\n", + " (2060, 3): 168.0527310371399,\n", + " (2060, 4): 99.98551154136658,\n", + " (2060, 5): 14.886727333068848,\n", + " (2060, 6): 6.740338921546936,\n", + " (2060, 7): 4.3274606466293335,\n", + " (2060, 8): 2.5208728313446045,\n", + " (2060, 9): 2.309889554977417,\n", + " (2060, 10): 5.095697641372681,\n", + " (2060, 11): 43.751283168792725,\n", + " (2060, 12): 311.10115218162537},\n", + " 'window': {(2060, 1): 222.89159774780273,\n", + " (2060, 2): 76.33026838302612,\n", + " (2060, 3): 58.53102111816406,\n", + " (2060, 4): 89.59948265552521,\n", + " (2060, 5): 6.376741051673889,\n", + " (2060, 6): 3.875940203666687,\n", + " (2060, 7): 2.9816426038742065,\n", + " (2060, 8): 2.5208728313446045,\n", + " (2060, 9): 2.309889554977417,\n", + " (2060, 10): 3.930637240409851,\n", + " (2060, 11): 31.752236485481262,\n", + " (2060, 12): 173.9225254058838}},\n", + " 191: {'monthly': {(2060, 1): 429.0180253982544,\n", + " (2060, 2): 260.3347978591919,\n", + " (2060, 3): 166.0340427160263,\n", + " (2060, 4): 42.43610239028931,\n", + " (2060, 5): 14.584099531173706,\n", + " (2060, 6): 7.709660768508911,\n", + " (2060, 7): 5.7028772830963135,\n", + " (2060, 8): 5.827641844749451,\n", + " (2060, 9): 3.513139009475708,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 41.08675718307495,\n", + " (2060, 12): 285.38672935962677},\n", + " 'window': {(2060, 1): 143.2229232788086,\n", + " (2060, 2): 76.91568279266357,\n", + " (2060, 3): 59.49692249298096,\n", + " (2060, 4): 37.97916758060455,\n", + " (2060, 5): 6.776343941688538,\n", + " (2060, 6): 3.388978958129883,\n", + " (2060, 7): 3.630094051361084,\n", + " (2060, 8): 3.5004416704177856,\n", + " (2060, 9): 1.2823882102966309,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 30.051523685455322,\n", + " (2060, 12): 117.26972675323486}},\n", + " 192: {'monthly': {(2060, 1): 482.9482275247574,\n", + " (2060, 2): 288.5353276729584,\n", + " (2060, 3): 137.93345737457275,\n", + " (2060, 4): 53.26291835308075,\n", + " (2060, 5): 14.786027908325195,\n", + " (2060, 6): 10.166098594665527,\n", + " (2060, 7): 7.151646137237549,\n", + " (2060, 8): 7.500858664512634,\n", + " (2060, 9): 4.671425938606262,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 33.903533697128296,\n", + " (2060, 12): 290.3533147573471},\n", + " 'window': {(2060, 1): 194.5729579925537,\n", + " (2060, 2): 87.24868297576904,\n", + " (2060, 3): 48.432597637176514,\n", + " (2060, 4): 48.399938464164734,\n", + " (2060, 5): 7.948891282081604,\n", + " (2060, 6): 5.701723217964172,\n", + " (2060, 7): 3.630094051361084,\n", + " (2060, 8): 5.173658490180969,\n", + " (2060, 9): 2.440675139427185,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 26.61022973060608,\n", + " (2060, 12): 135.84403610229492}},\n", + " 193: {'monthly': {(2060, 1): 497.11389565467834,\n", + " (2060, 2): 299.22304904460907,\n", + " (2060, 3): 119.69936156272888,\n", + " (2060, 4): 64.755162358284,\n", + " (2060, 5): 16.561893105506897,\n", + " (2060, 6): 9.058958888053894,\n", + " (2060, 7): 6.726546049118042,\n", + " (2060, 8): 7.009900689125061,\n", + " (2060, 9): 3.513139009475708,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 29.26912569999695,\n", + " (2060, 12): 262.99337005615234},\n", + " 'window': {(2060, 1): 224.87947273254395,\n", + " (2060, 2): 98.51296997070312,\n", + " (2060, 3): 42.7988486289978,\n", + " (2060, 4): 58.77699279785156,\n", + " (2060, 5): 8.306566953659058,\n", + " (2060, 6): 4.40580415725708,\n", + " (2060, 7): 3.630094051361084,\n", + " (2060, 8): 4.682700514793396,\n", + " (2060, 9): 1.2823882102966309,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 22.25585377216339,\n", + " (2060, 12): 134.28459548950195}},\n", + " 194: {'monthly': {(2060, 1): 478.1591730117798,\n", + " (2060, 2): 258.5283114910126,\n", + " (2060, 3): 118.20888018608093,\n", + " (2060, 4): 87.14998579025269,\n", + " (2060, 5): 15.6897292137146,\n", + " (2060, 6): 7.72283673286438,\n", + " (2060, 7): 5.7028772830963135,\n", + " (2060, 8): 6.9546051025390625,\n", + " (2060, 9): 3.513139009475708,\n", + " (2060, 10): 1.0174150466918945,\n", + " (2060, 11): 23.8537780046463,\n", + " (2060, 12): 209.07546210289001},\n", + " 'window': {(2060, 1): 228.15144538879395,\n", + " (2060, 2): 79.53662586212158,\n", + " (2060, 3): 39.94540548324585,\n", + " (2060, 4): 79.53063428401947,\n", + " (2060, 5): 7.426748037338257,\n", + " (2060, 6): 3.388978958129883,\n", + " (2060, 7): 3.630094051361084,\n", + " (2060, 8): 3.5004416704177856,\n", + " (2060, 9): 1.2823882102966309,\n", + " (2060, 10): 1.0174150466918945,\n", + " (2060, 11): 16.49541699886322,\n", + " (2060, 12): 107.07840728759766}},\n", + " 195: {'monthly': {(2060, 1): 374.4840040206909,\n", + " (2060, 2): 125.37308466434479,\n", + " (2060, 3): 136.3642704486847,\n", + " (2060, 4): 32.797993659973145,\n", + " (2060, 5): 7.571933031082153,\n", + " (2060, 6): 4.076462268829346,\n", + " (2060, 7): 6.096834063529968,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 1.0498948097229004,\n", + " (2060, 10): 2.4071625471115112,\n", + " (2060, 11): 37.27567720413208,\n", + " (2060, 12): 170.37739086151123},\n", + " 'window': {(2060, 1): 106.57716178894043,\n", + " (2060, 2): 40.057897090911865,\n", + " (2060, 3): 56.675594329833984,\n", + " (2060, 4): 24.79636311531067,\n", + " (2060, 5): 2.9089807271957397,\n", + " (2060, 6): 4.076462268829346,\n", + " (2060, 7): 2.7373101711273193,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 1.0498948097229004,\n", + " (2060, 10): 2.4071625471115112,\n", + " (2060, 11): 18.008982062339783,\n", + " (2060, 12): 76.72204685211182}},\n", + " 196: {'monthly': {(2060, 1): 354.89252412319183,\n", + " (2060, 2): 131.89079701900482,\n", + " (2060, 3): 89.77245366573334,\n", + " (2060, 4): 74.4503800868988,\n", + " (2060, 5): 11.708215832710266,\n", + " (2060, 6): 6.7379865646362305,\n", + " (2060, 7): 4.303999423980713,\n", + " (2060, 8): 2.47005558013916,\n", + " (2060, 9): 1.2781932353973389,\n", + " (2060, 10): 2.8441531658172607,\n", + " (2060, 11): 15.683065414428711,\n", + " (2060, 12): 180.20955407619476},\n", + " 'window': {(2060, 1): 110.05516910552979,\n", + " (2060, 2): 44.00772261619568,\n", + " (2060, 3): 33.22860765457153,\n", + " (2060, 4): 68.53714108467102,\n", + " (2060, 5): 6.221441864967346,\n", + " (2060, 6): 3.8782328367233276,\n", + " (2060, 7): 2.9877573251724243,\n", + " (2060, 8): 2.47005558013916,\n", + " (2060, 9): 1.2781932353973389,\n", + " (2060, 10): 2.8441531658172607,\n", + " (2060, 11): 9.957370281219482,\n", + " (2060, 12): 102.68110752105713}},\n", + " 197: {'monthly': {(2060, 1): 335.7428449392319,\n", + " (2060, 2): 116.06043946743011,\n", + " (2060, 3): 82.8690778017044,\n", + " (2060, 4): 57.492225766181946,\n", + " (2060, 5): 8.998030543327332,\n", + " (2060, 6): 6.7379865646362305,\n", + " (2060, 7): 4.303999423980713,\n", + " (2060, 8): 2.47005558013916,\n", + " (2060, 9): 1.2781932353973389,\n", + " (2060, 10): 2.8441531658172607,\n", + " (2060, 11): 16.128978490829468,\n", + " (2060, 12): 178.36972987651825},\n", + " 'window': {(2060, 1): 106.90642929077148,\n", + " (2060, 2): 41.07484245300293,\n", + " (2060, 3): 30.024447917938232,\n", + " (2060, 4): 51.57898676395416,\n", + " (2060, 5): 4.918784976005554,\n", + " (2060, 6): 3.8782328367233276,\n", + " (2060, 7): 2.9877573251724243,\n", + " (2060, 8): 2.47005558013916,\n", + " (2060, 9): 1.2781932353973389,\n", + " (2060, 10): 2.8441531658172607,\n", + " (2060, 11): 11.465025067329407,\n", + " (2060, 12): 107.01951599121094}},\n", + " 198: {'monthly': {(2060, 1): 386.21834993362427,\n", + " (2060, 2): 140.55676519870758,\n", + " (2060, 3): 102.21738123893738,\n", + " (2060, 4): 50.53726017475128,\n", + " (2060, 5): 8.477314114570618,\n", + " (2060, 6): 6.7379865646362305,\n", + " (2060, 7): 4.303999423980713,\n", + " (2060, 8): 2.47005558013916,\n", + " (2060, 9): 1.2781932353973389,\n", + " (2060, 10): 3.866417646408081,\n", + " (2060, 11): 20.383090257644653,\n", + " (2060, 12): 211.74513912200928},\n", + " 'window': {(2060, 1): 121.1511697769165,\n", + " (2060, 2): 49.700071811676025,\n", + " (2060, 3): 33.11327028274536,\n", + " (2060, 4): 44.18315637111664,\n", + " (2060, 5): 4.668501257896423,\n", + " (2060, 6): 3.8782328367233276,\n", + " (2060, 7): 2.9877573251724243,\n", + " (2060, 8): 2.47005558013916,\n", + " (2060, 9): 1.2781932353973389,\n", + " (2060, 10): 3.866417646408081,\n", + " (2060, 11): 15.198614716529846,\n", + " (2060, 12): 134.88151359558105}},\n", + " 199: {'monthly': {(2060, 1): 472.5200822353363,\n", + " (2060, 2): 183.25842893123627,\n", + " (2060, 3): 138.36029243469238,\n", + " (2060, 4): 66.45625424385071,\n", + " (2060, 5): 11.682928442955017,\n", + " (2060, 6): 6.7379865646362305,\n", + " (2060, 7): 5.398420095443726,\n", + " (2060, 8): 2.47005558013916,\n", + " (2060, 9): 2.7165151834487915,\n", + " (2060, 10): 2.8441531658172607,\n", + " (2060, 11): 25.382609128952026,\n", + " (2060, 12): 253.13002908229828},\n", + " 'window': {(2060, 1): 139.06139183044434,\n", + " (2060, 2): 57.8249192237854,\n", + " (2060, 3): 42.33917427062988,\n", + " (2060, 4): 54.28379511833191,\n", + " (2060, 5): 6.655989170074463,\n", + " (2060, 6): 3.8782328367233276,\n", + " (2060, 7): 2.9877573251724243,\n", + " (2060, 8): 2.47005558013916,\n", + " (2060, 9): 1.4383219480514526,\n", + " (2060, 10): 2.8441531658172607,\n", + " (2060, 11): 19.205920815467834,\n", + " (2060, 12): 155.69376182556152}},\n", + " 200: {'monthly': {(2060, 1): 557.3896522521973,\n", + " (2060, 2): 232.4627479314804,\n", + " (2060, 3): 140.53877127170563,\n", + " (2060, 4): 94.70384156703949,\n", + " (2060, 5): 11.431853294372559,\n", + " (2060, 6): 6.740338921546936,\n", + " (2060, 7): 6.670431971549988,\n", + " (2060, 8): 2.5208728313446045,\n", + " (2060, 9): 1.3040574789047241,\n", + " (2060, 10): 4.5849515199661255,\n", + " (2060, 11): 26.606457233428955,\n", + " (2060, 12): 266.3844220638275},\n", + " 'window': {(2060, 1): 151.0474147796631,\n", + " (2060, 2): 66.3919620513916,\n", + " (2060, 3): 41.21497058868408,\n", + " (2060, 4): 82.72357988357544,\n", + " (2060, 5): 5.8182196617126465,\n", + " (2060, 6): 3.875940203666687,\n", + " (2060, 7): 2.9816426038742065,\n", + " (2060, 8): 2.5208728313446045,\n", + " (2060, 9): 1.3040574789047241,\n", + " (2060, 10): 4.5849515199661255,\n", + " (2060, 11): 19.512661814689636,\n", + " (2060, 12): 143.52185249328613}},\n", + " 201: {'monthly': {(2060, 1): 567.6395021677017,\n", + " (2060, 2): 223.97430896759033,\n", + " (2060, 3): 176.29856729507446,\n", + " (2060, 4): 121.80291759967804,\n", + " (2060, 5): 15.538689017295837,\n", + " (2060, 6): 7.847352027893066,\n", + " (2060, 7): 5.3639891147613525,\n", + " (2060, 8): 2.5208728313446045,\n", + " (2060, 9): 1.3040574789047241,\n", + " (2060, 10): 3.930637240409851,\n", + " (2060, 11): 33.30408263206482,\n", + " (2060, 12): 305.28134191036224},\n", + " 'window': {(2060, 1): 170.30436897277832,\n", + " (2060, 2): 69.79757976531982,\n", + " (2060, 3): 51.86715602874756,\n", + " (2060, 4): 108.82129108905792,\n", + " (2060, 5): 7.416134357452393,\n", + " (2060, 6): 4.982953310012817,\n", + " (2060, 7): 2.9816426038742065,\n", + " (2060, 8): 2.5208728313446045,\n", + " (2060, 9): 1.3040574789047241,\n", + " (2060, 10): 3.930637240409851,\n", + " (2060, 11): 26.25387465953827,\n", + " (2060, 12): 176.66675186157227}},\n", + " 202: {'monthly': {(2060, 1): 615.7421615123749,\n", + " (2060, 2): 231.07851564884186,\n", + " (2060, 3): 219.16408336162567,\n", + " (2060, 4): 124.96345019340515,\n", + " (2060, 5): 16.65072751045227,\n", + " (2060, 6): 8.536651968955994,\n", + " (2060, 7): 6.6346917152404785,\n", + " (2060, 8): 2.5208728313446045,\n", + " (2060, 9): 1.3040574789047241,\n", + " (2060, 10): 3.930637240409851,\n", + " (2060, 11): 39.643455386161804,\n", + " (2060, 12): 352.9398720264435},\n", + " 'window': {(2060, 1): 207.28921699523926,\n", + " (2060, 2): 82.86310195922852,\n", + " (2060, 3): 68.9524040222168,\n", + " (2060, 4): 110.8219792842865,\n", + " (2060, 5): 7.1233614683151245,\n", + " (2060, 6): 4.452599287033081,\n", + " (2060, 7): 4.136105895042419,\n", + " (2060, 8): 2.5208728313446045,\n", + " (2060, 9): 1.3040574789047241,\n", + " (2060, 10): 3.930637240409851,\n", + " (2060, 11): 32.27578926086426,\n", + " (2060, 12): 206.4161148071289}},\n", + " 203: {'monthly': {(2060, 1): 579.9386594295502,\n", + " (2060, 2): 202.1736741065979,\n", + " (2060, 3): 182.60514426231384,\n", + " (2060, 4): 86.76946318149567,\n", + " (2060, 5): 15.354466557502747,\n", + " (2060, 6): 6.740338921546936,\n", + " (2060, 7): 5.787852764129639,\n", + " (2060, 8): 2.5208728313446045,\n", + " (2060, 9): 1.3040574789047241,\n", + " (2060, 10): 4.042377233505249,\n", + " (2060, 11): 52.50965178012848,\n", + " (2060, 12): 286.543253660202},\n", + " 'window': {(2060, 1): 217.76895141601562,\n", + " (2060, 2): 75.46228694915771,\n", + " (2060, 3): 61.51104164123535,\n", + " (2060, 4): 75.76329851150513,\n", + " (2060, 5): 6.579756855964661,\n", + " (2060, 6): 3.875940203666687,\n", + " (2060, 7): 2.9816426038742065,\n", + " (2060, 8): 2.5208728313446045,\n", + " (2060, 9): 1.3040574789047241,\n", + " (2060, 10): 4.042377233505249,\n", + " (2060, 11): 31.740838766098022,\n", + " (2060, 12): 149.73518562316895}},\n", + " 204: {'monthly': {(2060, 1): 353.48863208293915,\n", + " (2060, 2): 244.140216588974,\n", + " (2060, 3): 166.3900065422058,\n", + " (2060, 4): 48.971272706985474,\n", + " (2060, 5): 16.0102459192276,\n", + " (2060, 6): 8.967739343643188,\n", + " (2060, 7): 6.967377662658691,\n", + " (2060, 8): 7.27789831161499,\n", + " (2060, 9): 3.513139009475708,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 50.461137890815735,\n", + " (2060, 12): 286.22304570674896},\n", + " 'window': {(2060, 1): 88.95380115509033,\n", + " (2060, 2): 66.74332237243652,\n", + " (2060, 3): 54.685415267944336,\n", + " (2060, 4): 40.01933825016022,\n", + " (2060, 5): 7.367315888404846,\n", + " (2060, 6): 4.469879984855652,\n", + " (2060, 7): 3.638877749443054,\n", + " (2060, 8): 4.950698137283325,\n", + " (2060, 9): 1.2823882102966309,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 32.18065905570984,\n", + " (2060, 12): 108.39305305480957}},\n", + " 205: {'monthly': {(2060, 1): 368.31146132946014,\n", + " (2060, 2): 244.8832869529724,\n", + " (2060, 3): 131.86404860019684,\n", + " (2060, 4): 44.770501494407654,\n", + " (2060, 5): 17.50290024280548,\n", + " (2060, 6): 10.139119267463684,\n", + " (2060, 7): 6.9177405834198,\n", + " (2060, 8): 7.297986149787903,\n", + " (2060, 9): 4.6000577211380005,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 34.745595932006836,\n", + " (2060, 12): 268.23171532154083},\n", + " 'window': {(2060, 1): 110.46039867401123,\n", + " (2060, 2): 70.13629245758057,\n", + " (2060, 3): 47.04891014099121,\n", + " (2060, 4): 38.69580674171448,\n", + " (2060, 5): 9.161261439323425,\n", + " (2060, 6): 4.942087173461914,\n", + " (2060, 7): 3.630094051361084,\n", + " (2060, 8): 4.970785975456238,\n", + " (2060, 9): 2.3693069219589233,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 25.333256244659424,\n", + " (2060, 12): 114.85593223571777}},\n", + " 206: {'monthly': {(2060, 1): 380.0651047229767,\n", + " (2060, 2): 267.2028373479843,\n", + " (2060, 3): 131.43940114974976,\n", + " (2060, 4): 54.76072895526886,\n", + " (2060, 5): 19.725674033164978,\n", + " (2060, 6): 10.250135064125061,\n", + " (2060, 7): 6.826310992240906,\n", + " (2060, 8): 7.118493437767029,\n", + " (2060, 9): 3.513139009475708,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 27.110626816749573,\n", + " (2060, 12): 249.4008241891861},\n", + " 'window': {(2060, 1): 131.81301307678223,\n", + " (2060, 2): 83.0746078491211,\n", + " (2060, 3): 48.13265562057495,\n", + " (2060, 4): 46.90607666969299,\n", + " (2060, 5): 10.34093689918518,\n", + " (2060, 6): 4.695354223251343,\n", + " (2060, 7): 3.630094051361084,\n", + " (2060, 8): 4.791293263435364,\n", + " (2060, 9): 1.2823882102966309,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 20.371899366378784,\n", + " (2060, 12): 114.83451271057129}},\n", + " 207: {'monthly': {(2060, 1): 375.1491801738739,\n", + " (2060, 2): 265.67341351509094,\n", + " (2060, 3): 135.78475546836853,\n", + " (2060, 4): 75.10178196430206,\n", + " (2060, 5): 19.431332230567932,\n", + " (2060, 6): 9.783690214157104,\n", + " (2060, 7): 5.7028772830963135,\n", + " (2060, 8): 8.55688488483429,\n", + " (2060, 9): 3.742014765739441,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 27.163177847862244,\n", + " (2060, 12): 211.9345064163208},\n", + " 'window': {(2060, 1): 146.48918533325195,\n", + " (2060, 2): 75.71609401702881,\n", + " (2060, 3): 49.00738286972046,\n", + " (2060, 4): 66.4505033493042,\n", + " (2060, 5): 9.246601343154907,\n", + " (2060, 6): 4.704332947731018,\n", + " (2060, 7): 3.630094051361084,\n", + " (2060, 8): 3.5004416704177856,\n", + " (2060, 9): 1.5112639665603638,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 19.07714295387268,\n", + " (2060, 12): 97.30646133422852}},\n", + " 208: {'monthly': {(2060, 1): 394.62786519527435,\n", + " (2060, 2): 136.8865545988083,\n", + " (2060, 3): 163.457861661911,\n", + " (2060, 4): 38.14574682712555,\n", + " (2060, 5): 7.203360557556152,\n", + " (2060, 6): 4.076462268829346,\n", + " (2060, 7): 6.096834063529968,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 1.0498948097229004,\n", + " (2060, 10): 1.3706409931182861,\n", + " (2060, 11): 35.876235604286194,\n", + " (2060, 12): 180.5025337934494},\n", + " 'window': {(2060, 1): 121.5498046875,\n", + " (2060, 2): 42.474868059158325,\n", + " (2060, 3): 57.639342308044434,\n", + " (2060, 4): 30.99551296234131,\n", + " (2060, 5): 2.5404082536697388,\n", + " (2060, 6): 4.076462268829346,\n", + " (2060, 7): 2.7373101711273193,\n", + " (2060, 8): 0.0,\n", + " (2060, 9): 1.0498948097229004,\n", + " (2060, 10): 1.3706409931182861,\n", + " (2060, 11): 17.650860905647278,\n", + " (2060, 12): 74.31878280639648}},\n", + " 209: {'monthly': {(2060, 1): 336.83829498291016,\n", + " (2060, 2): 134.4273101091385,\n", + " (2060, 3): 94.83284854888916,\n", + " (2060, 4): 61.82174861431122,\n", + " (2060, 5): 8.573670983314514,\n", + " (2060, 6): 6.7379865646362305,\n", + " (2060, 7): 4.303999423980713,\n", + " (2060, 8): 2.47005558013916,\n", + " (2060, 9): 2.6296366453170776,\n", + " (2060, 10): 2.8441531658172607,\n", + " (2060, 11): 19.779247045516968,\n", + " (2060, 12): 190.4882904291153},\n", + " 'window': {(2060, 1): 93.49320888519287,\n", + " (2060, 2): 48.42318296432495,\n", + " (2060, 3): 36.026485443115234,\n", + " (2060, 4): 55.908509612083435,\n", + " (2060, 5): 4.7148154973983765,\n", + " (2060, 6): 3.8782328367233276,\n", + " (2060, 7): 2.9877573251724243,\n", + " (2060, 8): 2.47005558013916,\n", + " (2060, 9): 2.6296366453170776,\n", + " (2060, 10): 2.8441531658172607,\n", + " (2060, 11): 14.562557578086853,\n", + " (2060, 12): 116.68146419525146}},\n", + " 210: {'monthly': {(2060, 1): 312.33860421180725,\n", + " (2060, 2): 112.63404500484467,\n", + " (2060, 3): 92.69208681583405,\n", + " (2060, 4): 49.1583708524704,\n", + " (2060, 5): 5.880947232246399,\n", + " (2060, 6): 6.7379865646362305,\n", + " (2060, 7): 4.303999423980713,\n", + " (2060, 8): 2.47005558013916,\n", + " (2060, 9): 1.2781932353973389,\n", + " (2060, 10): 2.8441531658172607,\n", + " (2060, 11): 17.439926505088806,\n", + " (2060, 12): 174.97681558132172},\n", + " 'window': {(2060, 1): 94.97287082672119,\n", + " (2060, 2): 41.00346827507019,\n", + " (2060, 3): 30.382957458496094,\n", + " (2060, 4): 43.245131850242615,\n", + " (2060, 5): 3.4205514192581177,\n", + " (2060, 6): 3.8782328367233276,\n", + " (2060, 7): 2.9877573251724243,\n", + " (2060, 8): 2.47005558013916,\n", + " (2060, 9): 1.2781932353973389,\n", + " (2060, 10): 2.8441531658172607,\n", + " (2060, 11): 12.031814694404602,\n", + " (2060, 12): 111.06949043273926}},\n", + " 211: {'monthly': {(2060, 1): 339.6903109550476,\n", + " (2060, 2): 127.5163745880127,\n", + " (2060, 3): 100.5117267370224,\n", + " (2060, 4): 51.043524384498596,\n", + " (2060, 5): 6.864469647407532,\n", + " (2060, 6): 6.7379865646362305,\n", + " (2060, 7): 4.303999423980713,\n", + " (2060, 8): 3.5301421880722046,\n", + " (2060, 9): 1.2781932353973389,\n", + " (2060, 10): 2.8441531658172607,\n", + " (2060, 11): 17.86720848083496,\n", + " (2060, 12): 196.97343349456787},\n", + " 'window': {(2060, 1): 98.20476627349854,\n", + " (2060, 2): 46.17201614379883,\n", + " (2060, 3): 29.47404670715332,\n", + " (2060, 4): 42.88674521446228,\n", + " (2060, 5): 3.656379222869873,\n", + " (2060, 6): 3.8782328367233276,\n", + " (2060, 7): 2.9877573251724243,\n", + " (2060, 8): 2.47005558013916,\n", + " (2060, 9): 1.2781932353973389,\n", + " (2060, 10): 2.8441531658172607,\n", + " (2060, 11): 12.134162068367004,\n", + " (2060, 12): 130.85356044769287}},\n", + " 212: {'monthly': {(2060, 1): 431.61327600479126,\n", + " (2060, 2): 188.59613239765167,\n", + " (2060, 3): 137.7254695892334,\n", + " (2060, 4): 66.75317943096161,\n", + " (2060, 5): 6.825161099433899,\n", + " (2060, 6): 8.124030947685242,\n", + " (2060, 7): 4.303999423980713,\n", + " (2060, 8): 2.47005558013916,\n", + " (2060, 9): 1.2781932353973389,\n", + " (2060, 10): 2.8441531658172607,\n", + " (2060, 11): 22.921685457229614,\n", + " (2060, 12): 231.395303606987},\n", + " 'window': {(2060, 1): 114.23321151733398,\n", + " (2060, 2): 58.063926696777344,\n", + " (2060, 3): 36.798505783081055,\n", + " (2060, 4): 58.38405358791351,\n", + " (2060, 5): 3.8743900060653687,\n", + " (2060, 6): 4.051278471946716,\n", + " (2060, 7): 2.9877573251724243,\n", + " (2060, 8): 2.47005558013916,\n", + " (2060, 9): 1.2781932353973389,\n", + " (2060, 10): 2.8441531658172607,\n", + " (2060, 11): 16.556212067604065,\n", + " (2060, 12): 148.9920539855957}},\n", + " 213: {'monthly': {(2060, 1): 560.08085501194,\n", + " (2060, 2): 228.38406026363373,\n", + " (2060, 3): 160.24936997890472,\n", + " (2060, 4): 114.744136095047,\n", + " (2060, 5): 12.626690745353699,\n", + " (2060, 6): 6.740338921546936,\n", + " (2060, 7): 5.783263087272644,\n", + " (2060, 8): 2.5208728313446045,\n", + " (2060, 9): 1.3040574789047241,\n", + " (2060, 10): 4.509192705154419,\n", + " (2060, 11): 24.796844005584717,\n", + " (2060, 12): 256.78797590732574},\n", + " 'window': {(2060, 1): 147.42227172851562,\n", + " (2060, 2): 65.89814758300781,\n", + " (2060, 3): 45.38749933242798,\n", + " (2060, 4): 96.15527868270874,\n", + " (2060, 5): 5.114237546920776,\n", + " (2060, 6): 3.875940203666687,\n", + " (2060, 7): 2.9816426038742065,\n", + " (2060, 8): 2.5208728313446045,\n", + " (2060, 9): 1.3040574789047241,\n", + " (2060, 10): 4.509192705154419,\n", + " (2060, 11): 17.626189351081848,\n", + " (2060, 12): 136.5290937423706}},\n", + " 214: {'monthly': {(2060, 1): 570.5007348060608,\n", + " (2060, 2): 245.41159772872925,\n", + " (2060, 3): 221.0741925239563,\n", + " (2060, 4): 146.90728163719177,\n", + " (2060, 5): 17.0137939453125,\n", + " (2060, 6): 8.910274982452393,\n", + " (2060, 7): 4.341799378395081,\n", + " (2060, 8): 2.5208728313446045,\n", + " (2060, 9): 1.3040574789047241,\n", + " (2060, 10): 3.930637240409851,\n", + " (2060, 11): 39.84182620048523,\n", + " (2060, 12): 331.7657104730606},\n", + " 'window': {(2060, 1): 154.35585594177246,\n", + " (2060, 2): 75.85742902755737,\n", + " (2060, 3): 61.57986831665039,\n", + " (2060, 4): 124.91766285896301,\n", + " (2060, 5): 6.675601363182068,\n", + " (2060, 6): 4.652658820152283,\n", + " (2060, 7): 2.9959813356399536,\n", + " (2060, 8): 2.5208728313446045,\n", + " (2060, 9): 1.3040574789047241,\n", + " (2060, 10): 3.930637240409851,\n", + " (2060, 11): 27.180907130241394,\n", + " (2060, 12): 185.6527214050293}},\n", + " 215: {'monthly': {(2060, 1): 592.0124859809875,\n", + " (2060, 2): 266.955451130867,\n", + " (2060, 3): 301.03673708438873,\n", + " (2060, 4): 135.37293779850006,\n", + " (2060, 5): 15.580661654472351,\n", + " (2060, 6): 6.740338921546936,\n", + " (2060, 7): 5.586045622825623,\n", + " (2060, 8): 2.5208728313446045,\n", + " (2060, 9): 3.8930758237838745,\n", + " (2060, 10): 5.158972263336182,\n", + " (2060, 11): 51.13579261302948,\n", + " (2060, 12): 398.3176393508911},\n", + " 'window': {(2060, 1): 173.71811485290527,\n", + " (2060, 2): 94.03275728225708,\n", + " (2060, 3): 81.99207592010498,\n", + " (2060, 4): 110.35845494270325,\n", + " (2060, 5): 6.550917267799377,\n", + " (2060, 6): 3.875940203666687,\n", + " (2060, 7): 2.9816426038742065,\n", + " (2060, 8): 2.5208728313446045,\n", + " (2060, 9): 2.5890183448791504,\n", + " (2060, 10): 3.930637240409851,\n", + " (2060, 11): 36.346835136413574,\n", + " (2060, 12): 219.26538467407227}},\n", + " 216: {'monthly': {(2060, 1): 535.2144050598145,\n", + " (2060, 2): 246.20839023590088,\n", + " (2060, 3): 261.7204682826996,\n", + " (2060, 4): 97.08268022537231,\n", + " (2060, 5): 18.983394265174866,\n", + " (2060, 6): 6.740338921546936,\n", + " (2060, 7): 7.290918946266174,\n", + " (2060, 8): 2.5208728313446045,\n", + " (2060, 9): 1.3040574789047241,\n", + " (2060, 10): 7.239003777503967,\n", + " (2060, 11): 73.25291740894318,\n", + " (2060, 12): 348.32166397571564},\n", + " 'window': {(2060, 1): 176.55512046813965,\n", + " (2060, 2): 87.76384735107422,\n", + " (2060, 3): 77.94848442077637,\n", + " (2060, 4): 73.33860921859741,\n", + " (2060, 5): 11.248322010040283,\n", + " (2060, 6): 3.875940203666687,\n", + " (2060, 7): 4.309276342391968,\n", + " (2060, 8): 2.5208728313446045,\n", + " (2060, 9): 1.3040574789047241,\n", + " (2060, 10): 5.073935866355896,\n", + " (2060, 11): 42.673322916030884,\n", + " (2060, 12): 165.11110496520996}},\n", + " 217: {'monthly': {(2060, 1): 299.23923110961914,\n", + " (2060, 2): 227.7969651222229,\n", + " (2060, 3): 174.45155811309814,\n", + " (2060, 4): 45.99983096122742,\n", + " (2060, 5): 16.499038457870483,\n", + " (2060, 6): 8.858599305152893,\n", + " (2060, 7): 8.08249282836914,\n", + " (2060, 8): 10.12415862083435,\n", + " (2060, 9): 3.513139009475708,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 48.05096089839935,\n", + " (2060, 12): 278.22852194309235},\n", + " 'window': {(2060, 1): 73.60547924041748,\n", + " (2060, 2): 59.448079109191895,\n", + " (2060, 3): 52.73848485946655,\n", + " (2060, 4): 35.29727387428284,\n", + " (2060, 5): 6.989143013954163,\n", + " (2060, 6): 4.5852038860321045,\n", + " (2060, 7): 3.630094051361084,\n", + " (2060, 8): 6.248715043067932,\n", + " (2060, 9): 1.2823882102966309,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 33.88631582260132,\n", + " (2060, 12): 95.1023759841919}},\n", + " 218: {'monthly': {(2060, 1): 289.50220704078674,\n", + " (2060, 2): 218.49730587005615,\n", + " (2060, 3): 130.61024844646454,\n", + " (2060, 4): 38.71856141090393,\n", + " (2060, 5): 18.914740920066833,\n", + " (2060, 6): 9.58632779121399,\n", + " (2060, 7): 8.544598460197449,\n", + " (2060, 8): 7.7478896379470825,\n", + " (2060, 9): 3.513139009475708,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 32.49875295162201,\n", + " (2060, 12): 243.79526031017303},\n", + " 'window': {(2060, 1): 76.9999828338623,\n", + " (2060, 2): 56.377092361450195,\n", + " (2060, 3): 43.79261302947998,\n", + " (2060, 4): 30.32246160507202,\n", + " (2060, 5): 9.237234115600586,\n", + " (2060, 6): 4.6812664270401,\n", + " (2060, 7): 3.630094051361084,\n", + " (2060, 8): 5.4206894636154175,\n", + " (2060, 9): 1.2823882102966309,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 21.93886363506317,\n", + " (2060, 12): 95.95066833496094}},\n", + " 219: {'monthly': {(2060, 1): 316.3593189716339,\n", + " (2060, 2): 244.01118993759155,\n", + " (2060, 3): 139.14010512828827,\n", + " (2060, 4): 44.26783847808838,\n", + " (2060, 5): 20.032697558403015,\n", + " (2060, 6): 11.801868438720703,\n", + " (2060, 7): 7.5562556982040405,\n", + " (2060, 8): 7.9621652364730835,\n", + " (2060, 9): 3.513139009475708,\n", + " (2060, 10): 1.2815990447998047,\n", + " (2060, 11): 33.96522772312164,\n", + " (2060, 12): 245.57814824581146},\n", + " 'window': {(2060, 1): 89.2182207107544,\n", + " (2060, 2): 64.64538669586182,\n", + " (2060, 3): 48.77815103530884,\n", + " (2060, 4): 33.35209035873413,\n", + " (2060, 5): 10.126321077346802,\n", + " (2060, 6): 4.871135711669922,\n", + " (2060, 7): 3.630094051361084,\n", + " (2060, 8): 5.6349650621414185,\n", + " (2060, 9): 1.2823882102966309,\n", + " (2060, 10): 1.2815990447998047,\n", + " (2060, 11): 22.397515535354614,\n", + " (2060, 12): 99.31969451904297}},\n", + " 220: {'monthly': {(2060, 1): 328.3621156215668,\n", + " (2060, 2): 281.94035959243774,\n", + " (2060, 3): 144.09836292266846,\n", + " (2060, 4): 58.62090528011322,\n", + " (2060, 5): 20.9795583486557,\n", + " (2060, 6): 10.177258849143982,\n", + " (2060, 7): 7.665494322776794,\n", + " (2060, 8): 7.733073711395264,\n", + " (2060, 9): 3.513139009475708,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 31.335688591003418,\n", + " (2060, 12): 230.97580814361572},\n", + " 'window': {(2060, 1): 102.92852592468262,\n", + " (2060, 2): 68.64352035522461,\n", + " (2060, 3): 52.10161828994751,\n", + " (2060, 4): 45.20348024368286,\n", + " (2060, 5): 9.880962371826172,\n", + " (2060, 6): 4.884138345718384,\n", + " (2060, 7): 3.630094051361084,\n", + " (2060, 8): 5.405873537063599,\n", + " (2060, 9): 1.2823882102966309,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 21.88038969039917,\n", + " (2060, 12): 95.38702964782715}},\n", + " 221: {'monthly': {(2060, 1): 316.5495318174362,\n", + " (2060, 2): 163.79652106761932,\n", + " (2060, 3): 159.7055070400238,\n", + " (2060, 4): 45.158668518066406,\n", + " (2060, 5): 2.0351860523223877,\n", + " (2060, 6): 5.834451675415039,\n", + " (2060, 7): 4.537563681602478,\n", + " (2060, 8): 1.1109524965286255,\n", + " (2060, 9): 2.787585973739624,\n", + " (2060, 10): 2.6299314498901367,\n", + " (2060, 11): 41.93499219417572,\n", + " (2060, 12): 199.3920089006424},\n", + " 'window': {(2060, 1): 97.82756423950195,\n", + " (2060, 2): 59.047348976135254,\n", + " (2060, 3): 57.52852249145508,\n", + " (2060, 4): 33.99998939037323,\n", + " (2060, 5): 2.0351860523223877,\n", + " (2060, 6): 4.728754878044128,\n", + " (2060, 7): 3.5211403369903564,\n", + " (2060, 8): 1.1109524965286255,\n", + " (2060, 9): 2.787585973739624,\n", + " (2060, 10): 2.6299314498901367,\n", + " (2060, 11): 20.400492906570435,\n", + " (2060, 12): 91.54469203948975}},\n", + " 222: {'monthly': {(2060, 1): 286.7188801765442,\n", + " (2060, 2): 193.4387217760086,\n", + " (2060, 3): 114.55826258659363,\n", + " (2060, 4): 53.32284498214722,\n", + " (2060, 5): 5.244473934173584,\n", + " (2060, 6): 7.754246950149536,\n", + " (2060, 7): 7.597278833389282,\n", + " (2060, 8): 1.6667790412902832,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.7639505863189697,\n", + " (2060, 11): 22.846080422401428,\n", + " (2060, 12): 232.46982181072235},\n", + " 'window': {(2060, 1): 83.03756904602051,\n", + " (2060, 2): 55.12324142456055,\n", + " (2060, 3): 39.82958793640137,\n", + " (2060, 4): 42.08452880382538,\n", + " (2060, 5): 2.2562087774276733,\n", + " (2060, 6): 5.419857025146484,\n", + " (2060, 7): 2.8089256286621094,\n", + " (2060, 8): 1.6667790412902832,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 2.6418973207473755,\n", + " (2060, 11): 13.114137291908264,\n", + " (2060, 12): 147.37273597717285}},\n", + " 223: {'monthly': {(2060, 1): 247.9439992904663,\n", + " (2060, 2): 156.15332400798798,\n", + " (2060, 3): 98.20893692970276,\n", + " (2060, 4): 56.82243239879608,\n", + " (2060, 5): 5.244473934173584,\n", + " (2060, 6): 8.037908554077148,\n", + " (2060, 7): 7.597278833389282,\n", + " (2060, 8): 1.6667790412902832,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.7639505863189697,\n", + " (2060, 11): 21.051292896270752,\n", + " (2060, 12): 191.4189258813858},\n", + " 'window': {(2060, 1): 75.78982639312744,\n", + " (2060, 2): 45.23530626296997,\n", + " (2060, 3): 34.52584457397461,\n", + " (2060, 4): 45.628764390945435,\n", + " (2060, 5): 2.2562087774276733,\n", + " (2060, 6): 5.703518629074097,\n", + " (2060, 7): 2.8089256286621094,\n", + " (2060, 8): 1.6667790412902832,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 2.6418973207473755,\n", + " (2060, 11): 11.364859223365784,\n", + " (2060, 12): 123.57270050048828}},\n", + " 224: {'monthly': {(2060, 1): 272.5575497150421,\n", + " (2060, 2): 172.36112523078918,\n", + " (2060, 3): 104.88159656524658,\n", + " (2060, 4): 70.40344715118408,\n", + " (2060, 5): 8.336728692054749,\n", + " (2060, 6): 9.49299156665802,\n", + " (2060, 7): 9.842581510543823,\n", + " (2060, 8): 1.6667790412902832,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.7639505863189697,\n", + " (2060, 11): 24.61869478225708,\n", + " (2060, 12): 199.1220189332962},\n", + " 'window': {(2060, 1): 80.43617057800293,\n", + " (2060, 2): 49.4808144569397,\n", + " (2060, 3): 31.291868686676025,\n", + " (2060, 4): 59.428306341171265,\n", + " (2060, 5): 4.102593302726746,\n", + " (2060, 6): 5.779909133911133,\n", + " (2060, 7): 3.5565969944000244,\n", + " (2060, 8): 1.6667790412902832,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 2.6418973207473755,\n", + " (2060, 11): 15.900068998336792,\n", + " (2060, 12): 129.50356674194336}},\n", + " 225: {'monthly': {(2060, 1): 351.41291522979736,\n", + " (2060, 2): 231.03395235538483,\n", + " (2060, 3): 141.12008368968964,\n", + " (2060, 4): 93.5483627319336,\n", + " (2060, 5): 8.349603176116943,\n", + " (2060, 6): 11.357394695281982,\n", + " (2060, 7): 7.597278833389282,\n", + " (2060, 8): 2.6940572261810303,\n", + " (2060, 9): 1.2371759414672852,\n", + " (2060, 10): 5.055647253990173,\n", + " (2060, 11): 52.93451976776123,\n", + " (2060, 12): 254.34065425395966},\n", + " 'window': {(2060, 1): 104.6001615524292,\n", + " (2060, 2): 72.07115459442139,\n", + " (2060, 3): 36.80739879608154,\n", + " (2060, 4): 73.103018283844,\n", + " (2060, 5): 4.47337281703949,\n", + " (2060, 6): 6.281670808792114,\n", + " (2060, 7): 2.8089256286621094,\n", + " (2060, 8): 2.6940572261810303,\n", + " (2060, 9): 1.2371759414672852,\n", + " (2060, 10): 3.721748113632202,\n", + " (2060, 11): 34.14424800872803,\n", + " (2060, 12): 168.70030212402344}},\n", + " 226: {'monthly': {(2060, 1): 404.3257521390915,\n", + " (2060, 2): 291.55276238918304,\n", + " (2060, 3): 184.43806779384613,\n", + " (2060, 4): 121.93401885032654,\n", + " (2060, 5): 13.750080943107605,\n", + " (2060, 6): 12.741978406906128,\n", + " (2060, 7): 9.108573913574219,\n", + " (2060, 8): 3.1460007429122925,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 6.056826114654541,\n", + " (2060, 11): 53.4703232049942,\n", + " (2060, 12): 282.8678011894226},\n", + " 'window': {(2060, 1): 99.69723606109619,\n", + " (2060, 2): 79.2328634262085,\n", + " (2060, 3): 57.22185754776001,\n", + " (2060, 4): 93.90196561813354,\n", + " (2060, 5): 5.878618955612183,\n", + " (2060, 6): 5.01056170463562,\n", + " (2060, 7): 2.8617007732391357,\n", + " (2060, 8): 3.1460007429122925,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.707000970840454,\n", + " (2060, 11): 27.39746856689453,\n", + " (2060, 12): 167.23110389709473}},\n", + " 227: {'monthly': {(2060, 1): 424.14760065078735,\n", + " (2060, 2): 336.88803911209106,\n", + " (2060, 3): 258.50537502765656,\n", + " (2060, 4): 172.41662681102753,\n", + " (2060, 5): 15.835752487182617,\n", + " (2060, 6): 12.32256555557251,\n", + " (2060, 7): 11.070789217948914,\n", + " (2060, 8): 1.5907464027404785,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 4.837348818778992,\n", + " (2060, 11): 57.38819086551666,\n", + " (2060, 12): 391.0909662246704},\n", + " 'window': {(2060, 1): 105.94361686706543,\n", + " (2060, 2): 101.13309860229492,\n", + " (2060, 3): 74.6061143875122,\n", + " (2060, 4): 140.29170942306519,\n", + " (2060, 5): 7.261408090591431,\n", + " (2060, 6): 5.083161354064941,\n", + " (2060, 7): 2.8617007732391357,\n", + " (2060, 8): 1.5907464027404785,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.707000970840454,\n", + " (2060, 11): 31.578346014022827,\n", + " (2060, 12): 229.45904922485352}},\n", + " 228: {'monthly': {(2060, 1): 391.6374365091324,\n", + " (2060, 2): 314.73097705841064,\n", + " (2060, 3): 297.54196870326996,\n", + " (2060, 4): 168.40616047382355,\n", + " (2060, 5): 15.842498660087585,\n", + " (2060, 6): 12.187280058860779,\n", + " (2060, 7): 7.70267653465271,\n", + " (2060, 8): 3.832448720932007,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 4.837348818778992,\n", + " (2060, 11): 68.4288477897644,\n", + " (2060, 12): 381.85155069828033},\n", + " 'window': {(2060, 1): 101.00914859771729,\n", + " (2060, 2): 105.78291988372803,\n", + " (2060, 3): 76.59458065032959,\n", + " (2060, 4): 133.71015882492065,\n", + " (2060, 5): 6.142821550369263,\n", + " (2060, 6): 5.44087278842926,\n", + " (2060, 7): 2.8617007732391357,\n", + " (2060, 8): 3.832448720932007,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.707000970840454,\n", + " (2060, 11): 32.48719310760498,\n", + " (2060, 12): 218.47637939453125}},\n", + " 229: {'monthly': {(2060, 1): 394.53993690013885,\n", + " (2060, 2): 290.93204748630524,\n", + " (2060, 3): 297.9490671157837,\n", + " (2060, 4): 137.76132011413574,\n", + " (2060, 5): 17.58623194694519,\n", + " (2060, 6): 12.519333839416504,\n", + " (2060, 7): 7.70267653465271,\n", + " (2060, 8): 8.05724847316742,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 7.717754125595093,\n", + " (2060, 11): 88.24982273578644,\n", + " (2060, 12): 366.9570279121399},\n", + " 'window': {(2060, 1): 92.29856777191162,\n", + " (2060, 2): 91.99999618530273,\n", + " (2060, 3): 70.66948556900024,\n", + " (2060, 4): 106.14171385765076,\n", + " (2060, 5): 7.447606325149536,\n", + " (2060, 6): 5.293558120727539,\n", + " (2060, 7): 2.8617007732391357,\n", + " (2060, 8): 8.05724847316742,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.707000970840454,\n", + " (2060, 11): 43.663733959198,\n", + " (2060, 12): 192.93284797668457}},\n", + " 230: {'monthly': {(2060, 1): 325.4231685400009,\n", + " (2060, 2): 306.81351351737976,\n", + " (2060, 3): 225.4608520269394,\n", + " (2060, 4): 59.3400958776474,\n", + " (2060, 5): 9.716264843940735,\n", + " (2060, 6): 10.85846197605133,\n", + " (2060, 7): 3.648893117904663,\n", + " (2060, 8): 8.527151346206665,\n", + " (2060, 9): 6.609716892242432,\n", + " (2060, 10): 2.67285418510437,\n", + " (2060, 11): 55.30030357837677,\n", + " (2060, 12): 260.83774530887604},\n", + " 'window': {(2060, 1): 76.8566312789917,\n", + " (2060, 2): 74.82472324371338,\n", + " (2060, 3): 57.83366680145264,\n", + " (2060, 4): 44.90087163448334,\n", + " (2060, 5): 4.95712149143219,\n", + " (2060, 6): 5.526522517204285,\n", + " (2060, 7): 1.3729429244995117,\n", + " (2060, 8): 7.432196736335754,\n", + " (2060, 9): 3.048906087875366,\n", + " (2060, 10): 2.67285418510437,\n", + " (2060, 11): 41.47859859466553,\n", + " (2060, 12): 84.96430206298828}},\n", + " 231: {'monthly': {(2060, 1): 279.76616859436035,\n", + " (2060, 2): 240.620499253273,\n", + " (2060, 3): 170.5444277524948,\n", + " (2060, 4): 41.87413680553436,\n", + " (2060, 5): 7.7131431102752686,\n", + " (2060, 6): 8.745586633682251,\n", + " (2060, 7): 4.834814429283142,\n", + " (2060, 8): 7.34782874584198,\n", + " (2060, 9): 6.20304548740387,\n", + " (2060, 10): 2.064605236053467,\n", + " (2060, 11): 34.69075286388397,\n", + " (2060, 12): 226.21916496753693},\n", + " 'window': {(2060, 1): 65.52560520172119,\n", + " (2060, 2): 58.64149570465088,\n", + " (2060, 3): 48.39522171020508,\n", + " (2060, 4): 32.420092940330505,\n", + " (2060, 5): 2.9581578969955444,\n", + " (2060, 6): 3.1927260160446167,\n", + " (2060, 7): 2.1963284015655518,\n", + " (2060, 8): 6.252874135971069,\n", + " (2060, 9): 2.59496009349823,\n", + " (2060, 10): 1.056647777557373,\n", + " (2060, 11): 27.126652598381042,\n", + " (2060, 12): 91.86338710784912}},\n", + " 232: {'monthly': {(2060, 1): 310.4474079608917,\n", + " (2060, 2): 256.3540713787079,\n", + " (2060, 3): 179.7001210451126,\n", + " (2060, 4): 45.29095137119293,\n", + " (2060, 5): 7.82551634311676,\n", + " (2060, 6): 10.299569129943848,\n", + " (2060, 7): 3.648893117904663,\n", + " (2060, 8): 7.425516843795776,\n", + " (2060, 9): 7.7524837255477905,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 38.891292452812195,\n", + " (2060, 12): 266.26769161224365},\n", + " 'window': {(2060, 1): 75.4096326828003,\n", + " (2060, 2): 62.90841579437256,\n", + " (2060, 3): 58.56253623962402,\n", + " (2060, 4): 32.462616324424744,\n", + " (2060, 5): 2.780347466468811,\n", + " (2060, 6): 4.282000184059143,\n", + " (2060, 7): 1.3729429244995117,\n", + " (2060, 8): 6.330562233924866,\n", + " (2060, 9): 2.954715847969055,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 28.068976879119873,\n", + " (2060, 12): 126.39871215820312}},\n", + " 233: {'monthly': {(2060, 1): 330.635155916214,\n", + " (2060, 2): 268.0582854747772,\n", + " (2060, 3): 182.37564170360565,\n", + " (2060, 4): 49.958321928977966,\n", + " (2060, 5): 10.945462703704834,\n", + " (2060, 6): 8.447560548782349,\n", + " (2060, 7): 3.648893117904663,\n", + " (2060, 8): 8.245688199996948,\n", + " (2060, 9): 8.436866760253906,\n", + " (2060, 10): 3.5996344089508057,\n", + " (2060, 11): 42.74925100803375,\n", + " (2060, 12): 284.7328267097473},\n", + " 'window': {(2060, 1): 77.71791648864746,\n", + " (2060, 2): 63.24791717529297,\n", + " (2060, 3): 60.51531648635864,\n", + " (2060, 4): 38.77171325683594,\n", + " (2060, 5): 3.8871521949768066,\n", + " (2060, 6): 3.1927260160446167,\n", + " (2060, 7): 1.3729429244995117,\n", + " (2060, 8): 6.055496096611023,\n", + " (2060, 9): 3.47173273563385,\n", + " (2060, 10): 2.5123268365859985,\n", + " (2060, 11): 33.02826249599457,\n", + " (2060, 12): 140.3540096282959}},\n", + " 234: {'monthly': {(2060, 1): 329.48289012908936,\n", + " (2060, 2): 177.70654296875,\n", + " (2060, 3): 166.2012026309967,\n", + " (2060, 4): 57.19308960437775,\n", + " (2060, 5): 2.0351860523223877,\n", + " (2060, 6): 5.834451675415039,\n", + " (2060, 7): 4.537563681602478,\n", + " (2060, 8): 1.1109524965286255,\n", + " (2060, 9): 2.7190566062927246,\n", + " (2060, 10): 5.366301655769348,\n", + " (2060, 11): 50.808825731277466,\n", + " (2060, 12): 179.24560129642487},\n", + " 'window': {(2060, 1): 94.52604007720947,\n", + " (2060, 2): 68.32741594314575,\n", + " (2060, 3): 61.44065046310425,\n", + " (2060, 4): 43.57875609397888,\n", + " (2060, 5): 2.0351860523223877,\n", + " (2060, 6): 4.728754878044128,\n", + " (2060, 7): 3.5211403369903564,\n", + " (2060, 8): 1.1109524965286255,\n", + " (2060, 9): 2.7190566062927246,\n", + " (2060, 10): 4.0476274490356445,\n", + " (2060, 11): 23.255940198898315,\n", + " (2060, 12): 76.14838409423828}},\n", + " 235: {'monthly': {(2060, 1): 296.3386503458023,\n", + " (2060, 2): 204.6965845823288,\n", + " (2060, 3): 122.31154131889343,\n", + " (2060, 4): 67.33493459224701,\n", + " (2060, 5): 5.244473934173584,\n", + " (2060, 6): 7.433748722076416,\n", + " (2060, 7): 7.597278833389282,\n", + " (2060, 8): 1.6667790412902832,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.7639505863189697,\n", + " (2060, 11): 24.424567341804504,\n", + " (2060, 12): 244.18359351158142},\n", + " 'window': {(2060, 1): 77.57512092590332,\n", + " (2060, 2): 55.930354833602905,\n", + " (2060, 3): 45.092313289642334,\n", + " (2060, 4): 53.75095295906067,\n", + " (2060, 5): 2.2562087774276733,\n", + " (2060, 6): 5.099358797073364,\n", + " (2060, 7): 2.8089256286621094,\n", + " (2060, 8): 1.6667790412902832,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 2.6418973207473755,\n", + " (2060, 11): 13.329374074935913,\n", + " (2060, 12): 161.9382839202881}},\n", + " 236: {'monthly': {(2060, 1): 247.61055839061737,\n", + " (2060, 2): 153.87586796283722,\n", + " (2060, 3): 100.48477125167847,\n", + " (2060, 4): 85.11459863185883,\n", + " (2060, 5): 5.183251619338989,\n", + " (2060, 6): 7.871787905693054,\n", + " (2060, 7): 7.597278833389282,\n", + " (2060, 8): 1.6667790412902832,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.7639505863189697,\n", + " (2060, 11): 29.067933678627014,\n", + " (2060, 12): 206.28848350048065},\n", + " 'window': {(2060, 1): 68.48639297485352,\n", + " (2060, 2): 45.42704391479492,\n", + " (2060, 3): 38.54718255996704,\n", + " (2060, 4): 73.49638760089874,\n", + " (2060, 5): 2.1870758533477783,\n", + " (2060, 6): 5.537397980690002,\n", + " (2060, 7): 2.8089256286621094,\n", + " (2060, 8): 1.6667790412902832,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 2.6418973207473755,\n", + " (2060, 11): 18.089956402778625,\n", + " (2060, 12): 135.71497535705566}},\n", + " 237: {'monthly': {(2060, 1): 267.68347918987274,\n", + " (2060, 2): 176.5481960773468,\n", + " (2060, 3): 122.51536536216736,\n", + " (2060, 4): 118.04493815889334,\n", + " (2060, 5): 9.409947514533997,\n", + " (2060, 6): 11.638230562210083,\n", + " (2060, 7): 7.597278833389282,\n", + " (2060, 8): 3.334563970565796,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.856133222579956,\n", + " (2060, 11): 29.462121844291687,\n", + " (2060, 12): 207.65783154964447},\n", + " 'window': {(2060, 1): 72.5063943862915,\n", + " (2060, 2): 53.34857749938965,\n", + " (2060, 3): 36.115291595458984,\n", + " (2060, 4): 103.33169145574546,\n", + " (2060, 5): 3.925763726234436,\n", + " (2060, 6): 5.700016617774963,\n", + " (2060, 7): 2.8089256286621094,\n", + " (2060, 8): 3.334563970565796,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 2.6418973207473755,\n", + " (2060, 11): 17.34905469417572,\n", + " (2060, 12): 134.74011039733887}},\n", + " 238: {'monthly': {(2060, 1): 341.4727609157562,\n", + " (2060, 2): 253.2848688364029,\n", + " (2060, 3): 148.2226116657257,\n", + " (2060, 4): 141.97987364054177,\n", + " (2060, 5): 12.885583639144897,\n", + " (2060, 6): 12.489084243774414,\n", + " (2060, 7): 8.660772204399109,\n", + " (2060, 8): 3.266741156578064,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 5.281569242477417,\n", + " (2060, 11): 45.75287580490112,\n", + " (2060, 12): 273.9510484933853},\n", + " 'window': {(2060, 1): 96.84399127960205,\n", + " (2060, 2): 82.39582681655884,\n", + " (2060, 3): 37.528446197509766,\n", + " (2060, 4): 119.47638974905465,\n", + " (2060, 5): 5.670786023139954,\n", + " (2060, 6): 6.460819959640503,\n", + " (2060, 7): 3.872418999671936,\n", + " (2060, 8): 3.266741156578064,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.1460890769958496,\n", + " (2060, 11): 29.791865587234497,\n", + " (2060, 12): 178.42082405090332}},\n", + " 239: {'monthly': {(2060, 1): 425.31383204460144,\n", + " (2060, 2): 307.0801776647568,\n", + " (2060, 3): 215.91744899749756,\n", + " (2060, 4): 159.03998637199402,\n", + " (2060, 5): 19.209930181503296,\n", + " (2060, 6): 12.213683009147644,\n", + " (2060, 7): 7.70267653465271,\n", + " (2060, 8): 2.5974701642990112,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 6.935801267623901,\n", + " (2060, 11): 62.37401735782623,\n", + " (2060, 12): 316.299595952034},\n", + " 'window': {(2060, 1): 108.20076560974121,\n", + " (2060, 2): 86.31406879425049,\n", + " (2060, 3): 63.40322780609131,\n", + " (2060, 4): 123.7771782875061,\n", + " (2060, 5): 7.926289200782776,\n", + " (2060, 6): 5.216951251029968,\n", + " (2060, 7): 2.8617007732391357,\n", + " (2060, 8): 1.5907464027404785,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.707000970840454,\n", + " (2060, 11): 37.7338330745697,\n", + " (2060, 12): 187.06102180480957}},\n", + " 240: {'monthly': {(2060, 1): 463.26687002182007,\n", + " (2060, 2): 342.36477756500244,\n", + " (2060, 3): 305.71066212654114,\n", + " (2060, 4): 224.79961693286896,\n", + " (2060, 5): 19.557199120521545,\n", + " (2060, 6): 15.021350145339966,\n", + " (2060, 7): 8.982990384101868,\n", + " (2060, 8): 2.9745620489120483,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 6.303921818733215,\n", + " (2060, 11): 69.51023995876312,\n", + " (2060, 12): 441.00643241405487},\n", + " 'window': {(2060, 1): 126.40459251403809,\n", + " (2060, 2): 103.67523765563965,\n", + " (2060, 3): 84.67656135559082,\n", + " (2060, 4): 184.36490631103516,\n", + " (2060, 5): 8.536141633987427,\n", + " (2060, 6): 6.812103033065796,\n", + " (2060, 7): 2.8617007732391357,\n", + " (2060, 8): 2.9745620489120483,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 4.1280198097229,\n", + " (2060, 11): 41.707765340805054,\n", + " (2060, 12): 260.61883544921875}},\n", + " 241: {'monthly': {(2060, 1): 402.0193291902542,\n", + " (2060, 2): 296.8126564025879,\n", + " (2060, 3): 289.56838524341583,\n", + " (2060, 4): 197.0525177717209,\n", + " (2060, 5): 16.974929213523865,\n", + " (2060, 6): 13.350624680519104,\n", + " (2060, 7): 7.70267653465271,\n", + " (2060, 8): 4.738208532333374,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 5.858602523803711,\n", + " (2060, 11): 69.21943938732147,\n", + " (2060, 12): 377.5272057056427},\n", + " 'window': {(2060, 1): 102.10392570495605,\n", + " (2060, 2): 102.95262336730957,\n", + " (2060, 3): 79.70628833770752,\n", + " (2060, 4): 159.22400856018066,\n", + " (2060, 5): 7.46962571144104,\n", + " (2060, 6): 5.980738520622253,\n", + " (2060, 7): 2.8617007732391357,\n", + " (2060, 8): 4.738208532333374,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 4.728254675865173,\n", + " (2060, 11): 39.4121949672699,\n", + " (2060, 12): 228.7029514312744}},\n", + " 242: {'monthly': {(2060, 1): 366.1567784547806,\n", + " (2060, 2): 254.57566106319427,\n", + " (2060, 3): 273.58119785785675,\n", + " (2060, 4): 167.81970977783203,\n", + " (2060, 5): 16.022366881370544,\n", + " (2060, 6): 12.03289246559143,\n", + " (2060, 7): 7.70267653465271,\n", + " (2060, 8): 8.596846103668213,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 5.8618035316467285,\n", + " (2060, 11): 75.47713601589203,\n", + " (2060, 12): 331.1759043931961},\n", + " 'window': {(2060, 1): 93.7931957244873,\n", + " (2060, 2): 84.20943641662598,\n", + " (2060, 3): 69.2587194442749,\n", + " (2060, 4): 135.7114713191986,\n", + " (2060, 5): 5.4399741888046265,\n", + " (2060, 6): 5.633728861808777,\n", + " (2060, 7): 2.8617007732391357,\n", + " (2060, 8): 8.596846103668213,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.707000970840454,\n", + " (2060, 11): 42.46599054336548,\n", + " (2060, 12): 188.34451866149902}},\n", + " 243: {'monthly': {(2060, 1): 330.1261829137802,\n", + " (2060, 2): 312.0205010175705,\n", + " (2060, 3): 221.63809299468994,\n", + " (2060, 4): 82.5235390663147,\n", + " (2060, 5): 9.512797832489014,\n", + " (2060, 6): 8.598510265350342,\n", + " (2060, 7): 4.7795116901397705,\n", + " (2060, 8): 9.223830699920654,\n", + " (2060, 9): 7.502900958061218,\n", + " (2060, 10): 1.7296664714813232,\n", + " (2060, 11): 50.37690854072571,\n", + " (2060, 12): 238.31440615653992},\n", + " 'window': {(2060, 1): 92.02000141143799,\n", + " (2060, 2): 79.10768032073975,\n", + " (2060, 3): 56.71427536010742,\n", + " (2060, 4): 67.93433034420013,\n", + " (2060, 5): 4.060440301895142,\n", + " (2060, 6): 3.1927260160446167,\n", + " (2060, 7): 2.503561496734619,\n", + " (2060, 8): 8.128876090049744,\n", + " (2060, 9): 2.853169083595276,\n", + " (2060, 10): 1.7296664714813232,\n", + " (2060, 11): 38.16574716567993,\n", + " (2060, 12): 80.51753854751587}},\n", + " 244: {'monthly': {(2060, 1): 279.32066202163696,\n", + " (2060, 2): 251.47896432876587,\n", + " (2060, 3): 153.1331968307495,\n", + " (2060, 4): 67.25873935222626,\n", + " (2060, 5): 7.517054438591003,\n", + " (2060, 6): 6.885195374488831,\n", + " (2060, 7): 4.708090901374817,\n", + " (2060, 8): 7.639653205871582,\n", + " (2060, 9): 6.155770897865295,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 34.86618185043335,\n", + " (2060, 12): 204.75748455524445},\n", + " 'window': {(2060, 1): 82.13380813598633,\n", + " (2060, 2): 62.6193265914917,\n", + " (2060, 3): 44.657164573669434,\n", + " (2060, 4): 58.77636420726776,\n", + " (2060, 5): 2.901818871498108,\n", + " (2060, 6): 3.1927260160446167,\n", + " (2060, 7): 1.3729429244995117,\n", + " (2060, 8): 6.544698596000671,\n", + " (2060, 9): 2.59496009349823,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 26.82891607284546,\n", + " (2060, 12): 84.24661350250244}},\n", + " 245: {'monthly': {(2060, 1): 301.38805961608887,\n", + " (2060, 2): 259.75681042671204,\n", + " (2060, 3): 164.95790255069733,\n", + " (2060, 4): 64.95864868164062,\n", + " (2060, 5): 7.697551608085632,\n", + " (2060, 6): 6.745112180709839,\n", + " (2060, 7): 3.661398768424988,\n", + " (2060, 8): 7.581775188446045,\n", + " (2060, 9): 6.155770897865295,\n", + " (2060, 10): 2.1230400800704956,\n", + " (2060, 11): 36.96739339828491,\n", + " (2060, 12): 238.67562794685364},\n", + " 'window': {(2060, 1): 85.44826221466064,\n", + " (2060, 2): 68.08456039428711,\n", + " (2060, 3): 50.8645133972168,\n", + " (2060, 4): 54.71794354915619,\n", + " (2060, 5): 2.643889307975769,\n", + " (2060, 6): 3.1927260160446167,\n", + " (2060, 7): 1.3854485750198364,\n", + " (2060, 8): 6.486820578575134,\n", + " (2060, 9): 2.59496009349823,\n", + " (2060, 10): 1.1157251596450806,\n", + " (2060, 11): 28.01068949699402,\n", + " (2060, 12): 114.75274562835693}},\n", + " 246: {'monthly': {(2060, 1): 319.3725949525833,\n", + " (2060, 2): 259.0164853334427,\n", + " (2060, 3): 162.13825798034668,\n", + " (2060, 4): 56.38690006732941,\n", + " (2060, 5): 8.581257104873657,\n", + " (2060, 6): 7.009292960166931,\n", + " (2060, 7): 3.6899147033691406,\n", + " (2060, 8): 6.973991870880127,\n", + " (2060, 9): 6.155770897865295,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 37.807841777801514,\n", + " (2060, 12): 247.91688525676727},\n", + " 'window': {(2060, 1): 86.87829113006592,\n", + " (2060, 2): 68.86786365509033,\n", + " (2060, 3): 52.99404239654541,\n", + " (2060, 4): 47.91120707988739,\n", + " (2060, 5): 3.256787061691284,\n", + " (2060, 6): 3.1927260160446167,\n", + " (2060, 7): 1.4139645099639893,\n", + " (2060, 8): 5.879037261009216,\n", + " (2060, 9): 2.59496009349823,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 30.556424021720886,\n", + " (2060, 12): 123.64857006072998}},\n", + " 247: {'monthly': {(2060, 1): 316.4037992954254,\n", + " (2060, 2): 172.68630588054657,\n", + " (2060, 3): 169.24985468387604,\n", + " (2060, 4): 61.7144296169281,\n", + " (2060, 5): 2.0351860523223877,\n", + " (2060, 6): 5.834451675415039,\n", + " (2060, 7): 4.537563681602478,\n", + " (2060, 8): 1.1109524965286255,\n", + " (2060, 9): 2.2230465412139893,\n", + " (2060, 10): 4.3632917404174805,\n", + " (2060, 11): 48.2270085811615,\n", + " (2060, 12): 157.59592390060425},\n", + " 'window': {(2060, 1): 84.7638292312622,\n", + " (2060, 2): 62.61708307266235,\n", + " (2060, 3): 64.19352102279663,\n", + " (2060, 4): 46.108320355415344,\n", + " (2060, 5): 2.0351860523223877,\n", + " (2060, 6): 4.728754878044128,\n", + " (2060, 7): 3.5211403369903564,\n", + " (2060, 8): 1.1109524965286255,\n", + " (2060, 9): 2.2230465412139893,\n", + " (2060, 10): 4.3632917404174805,\n", + " (2060, 11): 23.217742919921875,\n", + " (2060, 12): 62.9211540222168}},\n", + " 248: {'monthly': {(2060, 1): 285.80449759960175,\n", + " (2060, 2): 195.28539776802063,\n", + " (2060, 3): 120.81078243255615,\n", + " (2060, 4): 64.36447370052338,\n", + " (2060, 5): 5.244473934173584,\n", + " (2060, 6): 6.16657829284668,\n", + " (2060, 7): 7.597278833389282,\n", + " (2060, 8): 2.829188823699951,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.7639505863189697,\n", + " (2060, 11): 29.8273983001709,\n", + " (2060, 12): 211.13868474960327},\n", + " 'window': {(2060, 1): 69.67073440551758,\n", + " (2060, 2): 58.55665636062622,\n", + " (2060, 3): 41.07175064086914,\n", + " (2060, 4): 52.802756547927856,\n", + " (2060, 5): 2.2562087774276733,\n", + " (2060, 6): 3.832188367843628,\n", + " (2060, 7): 2.8089256286621094,\n", + " (2060, 8): 2.829188823699951,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 2.6418973207473755,\n", + " (2060, 11): 17.213820338249207,\n", + " (2060, 12): 143.46751594543457}},\n", + " 249: {'monthly': {(2060, 1): 244.27544677257538,\n", + " (2060, 2): 170.03231477737427,\n", + " (2060, 3): 114.86611068248749,\n", + " (2060, 4): 90.7220070362091,\n", + " (2060, 5): 5.321720242500305,\n", + " (2060, 6): 8.562741041183472,\n", + " (2060, 7): 7.597278833389282,\n", + " (2060, 8): 1.6667790412902832,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.7639505863189697,\n", + " (2060, 11): 29.140042901039124,\n", + " (2060, 12): 195.3003660440445},\n", + " 'window': {(2060, 1): 65.2995023727417,\n", + " (2060, 2): 51.21680974960327,\n", + " (2060, 3): 39.4745078086853,\n", + " (2060, 4): 80.56554746627808,\n", + " (2060, 5): 2.3255444765090942,\n", + " (2060, 6): 5.195611119270325,\n", + " (2060, 7): 2.8089256286621094,\n", + " (2060, 8): 1.6667790412902832,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 2.6418973207473755,\n", + " (2060, 11): 18.072838068008423,\n", + " (2060, 12): 124.77197456359863}},\n", + " 250: {'monthly': {(2060, 1): 275.70897912979126,\n", + " (2060, 2): 201.504292845726,\n", + " (2060, 3): 151.56360042095184,\n", + " (2060, 4): 141.47467556144537,\n", + " (2060, 5): 11.306487679481506,\n", + " (2060, 6): 17.33072555065155,\n", + " (2060, 7): 7.597278833389282,\n", + " (2060, 8): 5.04828941822052,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.7639505863189697,\n", + " (2060, 11): 41.49972629547119,\n", + " (2060, 12): 208.0569303035736},\n", + " 'window': {(2060, 1): 68.3688154220581,\n", + " (2060, 2): 62.4681715965271,\n", + " (2060, 3): 43.005868434906006,\n", + " (2060, 4): 119.63918056632818,\n", + " (2060, 5): 4.462056040763855,\n", + " (2060, 6): 7.310787200927734,\n", + " (2060, 7): 2.8089256286621094,\n", + " (2060, 8): 4.017894744873047,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 2.6418973207473755,\n", + " (2060, 11): 21.122785806655884,\n", + " (2060, 12): 125.59120845794678}},\n", + " 251: {'monthly': {(2060, 1): 371.11887764930725,\n", + " (2060, 2): 290.64024817943573,\n", + " (2060, 3): 181.28253889083862,\n", + " (2060, 4): 170.79262389062046,\n", + " (2060, 5): 18.850451231002808,\n", + " (2060, 6): 23.821374773979187,\n", + " (2060, 7): 9.052908182144165,\n", + " (2060, 8): 6.8891414403915405,\n", + " (2060, 9): 4.879442811012268,\n", + " (2060, 10): 6.01810896396637,\n", + " (2060, 11): 54.92240250110626,\n", + " (2060, 12): 279.36247849464417},\n", + " 'window': {(2060, 1): 98.4852180480957,\n", + " (2060, 2): 93.1309289932251,\n", + " (2060, 3): 47.116154193878174,\n", + " (2060, 4): 137.40173531888126,\n", + " (2060, 5): 7.897663831710815,\n", + " (2060, 6): 8.193779349327087,\n", + " (2060, 7): 3.9092202186584473,\n", + " (2060, 8): 5.854952454566956,\n", + " (2060, 9): 1.9150738716125488,\n", + " (2060, 10): 3.7120296955108643,\n", + " (2060, 11): 26.40241026878357,\n", + " (2060, 12): 175.5646800994873}},\n", + " 252: {'monthly': {(2060, 1): 496.52668142318726,\n", + " (2060, 2): 335.37156915664673,\n", + " (2060, 3): 251.56207132339478,\n", + " (2060, 4): 194.59240460395813,\n", + " (2060, 5): 27.403299808502197,\n", + " (2060, 6): 17.24149751663208,\n", + " (2060, 7): 9.859021782875061,\n", + " (2060, 8): 2.678863763809204,\n", + " (2060, 9): 1.3974521160125732,\n", + " (2060, 10): 9.102944135665894,\n", + " (2060, 11): 71.59830486774445,\n", + " (2060, 12): 369.1806219816208},\n", + " 'window': {(2060, 1): 118.10778617858887,\n", + " (2060, 2): 97.15814208984375,\n", + " (2060, 3): 69.62819862365723,\n", + " (2060, 4): 148.4245285987854,\n", + " (2060, 5): 9.340882301330566,\n", + " (2060, 6): 5.933640360832214,\n", + " (2060, 7): 3.5198158025741577,\n", + " (2060, 8): 2.678863763809204,\n", + " (2060, 9): 1.3974521160125732,\n", + " (2060, 10): 4.986202120780945,\n", + " (2060, 11): 44.307079911231995,\n", + " (2060, 12): 215.6035614013672}},\n", + " 253: {'monthly': {(2060, 1): 532.8579639196396,\n", + " (2060, 2): 354.61907505989075,\n", + " (2060, 3): 361.19212532043457,\n", + " (2060, 4): 247.92105723468407,\n", + " (2060, 5): 28.173843383789062,\n", + " (2060, 6): 16.076064109802246,\n", + " (2060, 7): 7.847085952758789,\n", + " (2060, 8): 3.225572943687439,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 4.837348818778992,\n", + " (2060, 11): 90.3651340007782,\n", + " (2060, 12): 498.08390522003174},\n", + " 'window': {(2060, 1): 161.22019004821777,\n", + " (2060, 2): 106.7734603881836,\n", + " (2060, 3): 105.62549781799316,\n", + " (2060, 4): 198.68452776519402,\n", + " (2060, 5): 11.926429033279419,\n", + " (2060, 6): 6.584919571876526,\n", + " (2060, 7): 2.8617007732391357,\n", + " (2060, 8): 3.225572943687439,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.707000970840454,\n", + " (2060, 11): 56.65453505516052,\n", + " (2060, 12): 289.4801254272461}},\n", + " 254: {'monthly': {(2060, 1): 458.47293066978455,\n", + " (2060, 2): 310.13632345199585,\n", + " (2060, 3): 301.56771528720856,\n", + " (2060, 4): 215.43825512490838,\n", + " (2060, 5): 18.884196281433105,\n", + " (2060, 6): 13.612558007240295,\n", + " (2060, 7): 8.038841366767883,\n", + " (2060, 8): 5.003441095352173,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 4.837348818778992,\n", + " (2060, 11): 69.49678039550781,\n", + " (2060, 12): 410.397096157074},\n", + " 'window': {(2060, 1): 116.16430473327637,\n", + " (2060, 2): 107.02851486206055,\n", + " (2060, 3): 79.23326206207275,\n", + " (2060, 4): 178.54311376176446,\n", + " (2060, 5): 9.49773097038269,\n", + " (2060, 6): 6.529386639595032,\n", + " (2060, 7): 3.197865605354309,\n", + " (2060, 8): 5.003441095352173,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.707000970840454,\n", + " (2060, 11): 42.73634147644043,\n", + " (2060, 12): 256.21223640441895}},\n", + " 255: {'monthly': {(2060, 1): 344.3292578458786,\n", + " (2060, 2): 228.19740784168243,\n", + " (2060, 3): 224.58076357841492,\n", + " (2060, 4): 187.7056210618419,\n", + " (2060, 5): 15.559300541877747,\n", + " (2060, 6): 12.897316932678223,\n", + " (2060, 7): 7.853879809379578,\n", + " (2060, 8): 8.247969150543213,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 4.837348818778992,\n", + " (2060, 11): 51.5317280292511,\n", + " (2060, 12): 306.4633619785309},\n", + " 'window': {(2060, 1): 89.25451850891113,\n", + " (2060, 2): 79.04703950881958,\n", + " (2060, 3): 53.4452018737793,\n", + " (2060, 4): 151.85730331949418,\n", + " (2060, 5): 6.9774086475372314,\n", + " (2060, 6): 5.783080339431763,\n", + " (2060, 7): 2.8617007732391357,\n", + " (2060, 8): 8.247969150543213,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.707000970840454,\n", + " (2060, 11): 30.83710753917694,\n", + " (2060, 12): 197.95832920074463}},\n", + " 256: {'monthly': {(2060, 1): 318.26297533512115,\n", + " (2060, 2): 288.2025144100189,\n", + " (2060, 3): 186.11666631698608,\n", + " (2060, 4): 110.36223697662354,\n", + " (2060, 5): 7.43183434009552,\n", + " (2060, 6): 9.284491658210754,\n", + " (2060, 7): 4.729854106903076,\n", + " (2060, 8): 9.06748342514038,\n", + " (2060, 9): 6.155770897865295,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 38.1324417591095,\n", + " (2060, 12): 196.18602788448334},\n", + " 'window': {(2060, 1): 104.06925201416016,\n", + " (2060, 2): 77.83072090148926,\n", + " (2060, 3): 52.97581386566162,\n", + " (2060, 4): 98.99728095531464,\n", + " (2060, 5): 2.750327229499817,\n", + " (2060, 6): 3.1927260160446167,\n", + " (2060, 7): 2.453903913497925,\n", + " (2060, 8): 7.97252881526947,\n", + " (2060, 9): 2.59496009349823,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 30.06726098060608,\n", + " (2060, 12): 77.02295017242432}},\n", + " 257: {'monthly': {(2060, 1): 287.6006486415863,\n", + " (2060, 2): 255.68109273910522,\n", + " (2060, 3): 145.14661073684692,\n", + " (2060, 4): 90.40479636192322,\n", + " (2060, 5): 7.7467933893203735,\n", + " (2060, 6): 7.5584986209869385,\n", + " (2060, 7): 3.648893117904663,\n", + " (2060, 8): 7.854115724563599,\n", + " (2060, 9): 6.155770897865295,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 30.497986674308777,\n", + " (2060, 12): 189.08202505111694},\n", + " 'window': {(2060, 1): 98.61031150817871,\n", + " (2060, 2): 69.21092319488525,\n", + " (2060, 3): 43.55532503128052,\n", + " (2060, 4): 82.000683426857,\n", + " (2060, 5): 3.060458183288574,\n", + " (2060, 6): 3.1927260160446167,\n", + " (2060, 7): 1.3729429244995117,\n", + " (2060, 8): 6.759161114692688,\n", + " (2060, 9): 2.59496009349823,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 24.21482563018799,\n", + " (2060, 12): 84.2072114944458}},\n", + " 258: {'monthly': {(2060, 1): 313.2577705383301,\n", + " (2060, 2): 266.06694412231445,\n", + " (2060, 3): 161.5007448196411,\n", + " (2060, 4): 74.50957679748535,\n", + " (2060, 5): 7.658151745796204,\n", + " (2060, 6): 6.965321779251099,\n", + " (2060, 7): 3.648893117904663,\n", + " (2060, 8): 7.592580795288086,\n", + " (2060, 9): 7.3465341329574585,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 32.47984266281128,\n", + " (2060, 12): 223.05463671684265},\n", + " 'window': {(2060, 1): 96.60777950286865,\n", + " (2060, 2): 75.14299297332764,\n", + " (2060, 3): 48.93126201629639,\n", + " (2060, 4): 64.0339572429657,\n", + " (2060, 5): 2.5851352214813232,\n", + " (2060, 6): 3.1927260160446167,\n", + " (2060, 7): 1.3729429244995117,\n", + " (2060, 8): 6.497626185417175,\n", + " (2060, 9): 2.59496009349823,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 26.024231672286987,\n", + " (2060, 12): 108.0525016784668}},\n", + " 259: {'monthly': {(2060, 1): 316.9749187231064,\n", + " (2060, 2): 254.76062989234924,\n", + " (2060, 3): 145.13089501857758,\n", + " (2060, 4): 56.92955660820007,\n", + " (2060, 5): 8.345656156539917,\n", + " (2060, 6): 6.5824748277664185,\n", + " (2060, 7): 3.648893117904663,\n", + " (2060, 8): 6.751854419708252,\n", + " (2060, 9): 6.155770897865295,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 31.15902543067932,\n", + " (2060, 12): 217.2523432970047},\n", + " 'window': {(2060, 1): 94.95539379119873,\n", + " (2060, 2): 75.00810146331787,\n", + " (2060, 3): 50.99852514266968,\n", + " (2060, 4): 48.275654911994934,\n", + " (2060, 5): 3.3232460021972656,\n", + " (2060, 6): 3.1927260160446167,\n", + " (2060, 7): 1.3729429244995117,\n", + " (2060, 8): 5.656899809837341,\n", + " (2060, 9): 2.59496009349823,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 24.184714794158936,\n", + " (2060, 12): 111.12551879882812}},\n", + " 260: {'monthly': {(2060, 1): 319.60094118118286,\n", + " (2060, 2): 172.93310844898224,\n", + " (2060, 3): 188.71645891666412,\n", + " (2060, 4): 63.231823325157166,\n", + " (2060, 5): 3.132406711578369,\n", + " (2060, 6): 5.834451675415039,\n", + " (2060, 7): 4.537563681602478,\n", + " (2060, 8): 1.1109524965286255,\n", + " (2060, 9): 1.8435282707214355,\n", + " (2060, 10): 3.225322723388672,\n", + " (2060, 11): 48.929383873939514,\n", + " (2060, 12): 150.78765106201172},\n", + " 'window': {(2060, 1): 77.81227207183838,\n", + " (2060, 2): 53.646719217300415,\n", + " (2060, 3): 65.31185626983643,\n", + " (2060, 4): 44.436670422554016,\n", + " (2060, 5): 2.103094458580017,\n", + " (2060, 6): 4.728754878044128,\n", + " (2060, 7): 3.5211403369903564,\n", + " (2060, 8): 1.1109524965286255,\n", + " (2060, 9): 1.8435282707214355,\n", + " (2060, 10): 3.225322723388672,\n", + " (2060, 11): 22.19495165348053,\n", + " (2060, 12): 62.72420406341553}},\n", + " 261: {'monthly': {(2060, 1): 262.1648519039154,\n", + " (2060, 2): 197.89499926567078,\n", + " (2060, 3): 127.2901200056076,\n", + " (2060, 4): 54.54578518867493,\n", + " (2060, 5): 5.244473934173584,\n", + " (2060, 6): 8.175934314727783,\n", + " (2060, 7): 7.597278833389282,\n", + " (2060, 8): 2.829188823699951,\n", + " (2060, 9): 1.0357788801193237,\n", + " (2060, 10): 3.7639505863189697,\n", + " (2060, 11): 43.229376792907715,\n", + " (2060, 12): 171.81432962417603},\n", + " 'window': {(2060, 1): 59.98404884338379,\n", + " (2060, 2): 69.74584770202637,\n", + " (2060, 3): 39.10727047920227,\n", + " (2060, 4): 42.9572970867157,\n", + " (2060, 5): 2.2562087774276733,\n", + " (2060, 6): 5.8415443897247314,\n", + " (2060, 7): 2.8089256286621094,\n", + " (2060, 8): 2.829188823699951,\n", + " (2060, 9): 1.0357788801193237,\n", + " (2060, 10): 2.6418973207473755,\n", + " (2060, 11): 28.509860157966614,\n", + " (2060, 12): 107.3920316696167}},\n", + " 262: {'monthly': {(2060, 1): 237.32292139530182,\n", + " (2060, 2): 167.2325930595398,\n", + " (2060, 3): 123.04855871200562,\n", + " (2060, 4): 76.99921369552612,\n", + " (2060, 5): 6.260178446769714,\n", + " (2060, 6): 7.2071027755737305,\n", + " (2060, 7): 7.597278833389282,\n", + " (2060, 8): 2.829188823699951,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 4.970601439476013,\n", + " (2060, 11): 31.37356996536255,\n", + " (2060, 12): 161.27754151821136},\n", + " 'window': {(2060, 1): 53.85971403121948,\n", + " (2060, 2): 56.10446619987488,\n", + " (2060, 3): 37.69997596740723,\n", + " (2060, 4): 64.20160984992981,\n", + " (2060, 5): 2.196187138557434,\n", + " (2060, 6): 4.872712850570679,\n", + " (2060, 7): 2.8089256286621094,\n", + " (2060, 8): 2.829188823699951,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.848548173904419,\n", + " (2060, 11): 15.819462656974792,\n", + " (2060, 12): 96.78182411193848}},\n", + " 263: {'monthly': {(2060, 1): 296.59861493110657,\n", + " (2060, 2): 237.57294690608978,\n", + " (2060, 3): 176.1080549955368,\n", + " (2060, 4): 121.89718627929688,\n", + " (2060, 5): 15.580625534057617,\n", + " (2060, 6): 17.20192015171051,\n", + " (2060, 7): 9.922564029693604,\n", + " (2060, 8): 3.8912179470062256,\n", + " (2060, 9): 5.037164330482483,\n", + " (2060, 10): 6.033025741577148,\n", + " (2060, 11): 45.05492556095123,\n", + " (2060, 12): 201.49557173252106},\n", + " 'window': {(2060, 1): 72.66750049591064,\n", + " (2060, 2): 73.9744348526001,\n", + " (2060, 3): 47.5335955619812,\n", + " (2060, 4): 94.76855230331421,\n", + " (2060, 5): 6.613649845123291,\n", + " (2060, 6): 7.357819437980652,\n", + " (2060, 7): 3.747179865837097,\n", + " (2060, 8): 3.8912179470062256,\n", + " (2060, 9): 3.520709991455078,\n", + " (2060, 10): 2.6418973207473755,\n", + " (2060, 11): 24.33761954307556,\n", + " (2060, 12): 111.57761478424072}},\n", + " 264: {'monthly': {(2060, 1): 420.47118532657623,\n", + " (2060, 2): 327.6845191717148,\n", + " (2060, 3): 207.73395788669586,\n", + " (2060, 4): 170.12671118696608,\n", + " (2060, 5): 34.53610169887543,\n", + " (2060, 6): 36.464248180389404,\n", + " (2060, 7): 26.876800417900085,\n", + " (2060, 8): 17.572771191596985,\n", + " (2060, 9): 6.857671856880188,\n", + " (2060, 10): 7.3981053829193115,\n", + " (2060, 11): 61.78438925743103,\n", + " (2060, 12): 284.23697233200073},\n", + " 'window': {(2060, 1): 106.57636833190918,\n", + " (2060, 2): 98.7048921585083,\n", + " (2060, 3): 51.320138931274414,\n", + " (2060, 4): 123.85340779741682,\n", + " (2060, 5): 12.824184775352478,\n", + " (2060, 6): 8.847403883934021,\n", + " (2060, 7): 8.717565894126892,\n", + " (2060, 8): 8.619832634925842,\n", + " (2060, 9): 3.5655254125595093,\n", + " (2060, 10): 2.656917452812195,\n", + " (2060, 11): 29.494773149490356,\n", + " (2060, 12): 163.15185546875}},\n", + " 265: {'monthly': {(2060, 1): 552.8010412454605,\n", + " (2060, 2): 349.89074516296387,\n", + " (2060, 3): 296.1245666742325,\n", + " (2060, 4): 215.32133571672375,\n", + " (2060, 5): 37.55260479450226,\n", + " (2060, 6): 26.74069380760193,\n", + " (2060, 7): 14.87657618522644,\n", + " (2060, 8): 5.3379517793655396,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 8.868850111961365,\n", + " (2060, 11): 83.15762150287628,\n", + " (2060, 12): 408.7636789083481},\n", + " 'window': {(2060, 1): 128.81034088134766,\n", + " (2060, 2): 104.9013090133667,\n", + " (2060, 3): 73.6851806640625,\n", + " (2060, 4): 150.77592448759015,\n", + " (2060, 5): 14.05696964263916,\n", + " (2060, 6): 8.560317158699036,\n", + " (2060, 7): 5.322749137878418,\n", + " (2060, 8): 5.3379517793655396,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 4.088224172592163,\n", + " (2060, 11): 46.5310583114624,\n", + " (2060, 12): 242.58731269836426}},\n", + " 266: {'monthly': {(2060, 1): 597.1529250144958,\n", + " (2060, 2): 379.1772229671478,\n", + " (2060, 3): 422.9780390262604,\n", + " (2060, 4): 274.19170396626924,\n", + " (2060, 5): 41.779523849487305,\n", + " (2060, 6): 22.55896294116974,\n", + " (2060, 7): 15.698120594024658,\n", + " (2060, 8): 4.272467136383057,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 4.837348818778992,\n", + " (2060, 11): 108.7338057756424,\n", + " (2060, 12): 531.6082910299301},\n", + " 'window': {(2060, 1): 183.8798999786377,\n", + " (2060, 2): 114.89447116851807,\n", + " (2060, 3): 122.88232707977295,\n", + " (2060, 4): 201.93462138474916,\n", + " (2060, 5): 17.76712203025818,\n", + " (2060, 6): 7.406968712806702,\n", + " (2060, 7): 4.893697142601013,\n", + " (2060, 8): 3.2445757389068604,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.707000970840454,\n", + " (2060, 11): 67.91172790527344,\n", + " (2060, 12): 301.31614875793457}},\n", + " 267: {'monthly': {(2060, 1): 528.5280255079269,\n", + " (2060, 2): 359.00812673568726,\n", + " (2060, 3): 349.8440850973129,\n", + " (2060, 4): 215.3594843936985,\n", + " (2060, 5): 24.582966327667236,\n", + " (2060, 6): 19.732748866081238,\n", + " (2060, 7): 7.70267653465271,\n", + " (2060, 8): 5.72909414768219,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 4.837348818778992,\n", + " (2060, 11): 76.4083468914032,\n", + " (2060, 12): 446.0109746456146},\n", + " 'window': {(2060, 1): 132.1556396484375,\n", + " (2060, 2): 119.3975076675415,\n", + " (2060, 3): 84.61052513122559,\n", + " (2060, 4): 172.55707593689613,\n", + " (2060, 5): 12.560920238494873,\n", + " (2060, 6): 6.809584259986877,\n", + " (2060, 7): 2.8617007732391357,\n", + " (2060, 8): 4.440470218658447,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.707000970840454,\n", + " (2060, 11): 45.260730266571045,\n", + " (2060, 12): 275.17230796813965}},\n", + " 268: {'monthly': {(2060, 1): 361.2921234369278,\n", + " (2060, 2): 222.8084396123886,\n", + " (2060, 3): 229.1819680929184,\n", + " (2060, 4): 179.42224746716943,\n", + " (2060, 5): 15.944024085998535,\n", + " (2060, 6): 14.143036246299744,\n", + " (2060, 7): 7.70267653465271,\n", + " (2060, 8): 6.128108978271484,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 5.01155698299408,\n", + " (2060, 11): 52.23296141624451,\n", + " (2060, 12): 300.2287893295288},\n", + " 'window': {(2060, 1): 88.5531234741211,\n", + " (2060, 2): 82.32919836044312,\n", + " (2060, 3): 53.7646689414978,\n", + " (2060, 4): 149.48284536374535,\n", + " (2060, 5): 8.727167844772339,\n", + " (2060, 6): 5.893077969551086,\n", + " (2060, 7): 2.8617007732391357,\n", + " (2060, 8): 6.128108978271484,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.881209135055542,\n", + " (2060, 11): 28.071882724761963,\n", + " (2060, 12): 206.6638298034668}},\n", + " 269: {'monthly': {(2060, 1): 306.56378293037415,\n", + " (2060, 2): 263.5218892097473,\n", + " (2060, 3): 181.21390616893768,\n", + " (2060, 4): 98.02914249897003,\n", + " (2060, 5): 7.536941409111023,\n", + " (2060, 6): 9.391801118850708,\n", + " (2060, 7): 3.648893117904663,\n", + " (2060, 8): 8.17453384399414,\n", + " (2060, 9): 6.155770897865295,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 34.48573660850525,\n", + " (2060, 12): 182.00355100631714},\n", + " 'window': {(2060, 1): 115.8544864654541,\n", + " (2060, 2): 72.0941972732544,\n", + " (2060, 3): 52.491658210754395,\n", + " (2060, 4): 88.6507693529129,\n", + " (2060, 5): 2.9084439277648926,\n", + " (2060, 6): 4.059861660003662,\n", + " (2060, 7): 1.3729429244995117,\n", + " (2060, 8): 7.07957923412323,\n", + " (2060, 9): 2.59496009349823,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 27.20770835876465,\n", + " (2060, 12): 86.17699718475342}},\n", + " 270: {'monthly': {(2060, 1): 294.61305582523346,\n", + " (2060, 2): 247.30507683753967,\n", + " (2060, 3): 147.75903153419495,\n", + " (2060, 4): 81.43450891971588,\n", + " (2060, 5): 7.520111083984375,\n", + " (2060, 6): 8.997598648071289,\n", + " (2060, 7): 3.648893117904663,\n", + " (2060, 8): 7.6847593784332275,\n", + " (2060, 9): 6.155770897865295,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 26.690870761871338,\n", + " (2060, 12): 188.08086669445038},\n", + " 'window': {(2060, 1): 113.00857830047607,\n", + " (2060, 2): 70.111572265625,\n", + " (2060, 3): 44.35943937301636,\n", + " (2060, 4): 71.68083417415619,\n", + " (2060, 5): 2.880706310272217,\n", + " (2060, 6): 3.665659189224243,\n", + " (2060, 7): 1.3729429244995117,\n", + " (2060, 8): 6.589804768562317,\n", + " (2060, 9): 2.59496009349823,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 22.735325574874878,\n", + " (2060, 12): 91.489182472229}},\n", + " 271: {'monthly': {(2060, 1): 325.98186326026917,\n", + " (2060, 2): 265.50992345809937,\n", + " (2060, 3): 174.6498497724533,\n", + " (2060, 4): 61.42799997329712,\n", + " (2060, 5): 7.388349652290344,\n", + " (2060, 6): 8.403891324996948,\n", + " (2060, 7): 3.648893117904663,\n", + " (2060, 8): 7.278117060661316,\n", + " (2060, 9): 6.155770897865295,\n", + " (2060, 10): 1.0235161781311035,\n", + " (2060, 11): 30.461305499076843,\n", + " (2060, 12): 227.19547867774963},\n", + " 'window': {(2060, 1): 112.11464786529541,\n", + " (2060, 2): 79.35369110107422,\n", + " (2060, 3): 48.94155550003052,\n", + " (2060, 4): 49.2091509103775,\n", + " (2060, 5): 2.511051297187805,\n", + " (2060, 6): 3.1927260160446167,\n", + " (2060, 7): 1.3729429244995117,\n", + " (2060, 8): 6.183162450790405,\n", + " (2060, 9): 2.59496009349823,\n", + " (2060, 10): 1.0235161781311035,\n", + " (2060, 11): 24.31968641281128,\n", + " (2060, 12): 110.77163314819336}},\n", + " 272: {'monthly': {(2060, 1): 330.4050781726837,\n", + " (2060, 2): 255.17492365837097,\n", + " (2060, 3): 151.32258701324463,\n", + " (2060, 4): 43.95049011707306,\n", + " (2060, 5): 9.26224172115326,\n", + " (2060, 6): 7.229494333267212,\n", + " (2060, 7): 3.648893117904663,\n", + " (2060, 8): 5.6640660762786865,\n", + " (2060, 9): 6.155770897865295,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 28.565257668495178,\n", + " (2060, 12): 226.28698694705963},\n", + " 'window': {(2060, 1): 106.94531059265137,\n", + " (2060, 2): 72.4198694229126,\n", + " (2060, 3): 50.637136936187744,\n", + " (2060, 4): 33.41529130935669,\n", + " (2060, 5): 3.0459470748901367,\n", + " (2060, 6): 3.1927260160446167,\n", + " (2060, 7): 1.3729429244995117,\n", + " (2060, 8): 4.569111466407776,\n", + " (2060, 9): 2.59496009349823,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 22.740628838539124,\n", + " (2060, 12): 116.44982051849365}},\n", + " 273: {'monthly': {(2060, 1): 250.64715838432312,\n", + " (2060, 2): 245.48224413394928,\n", + " (2060, 3): 204.46247565746307,\n", + " (2060, 4): 38.765894174575806,\n", + " (2060, 5): 5.240600109100342,\n", + " (2060, 6): 0.0,\n", + " (2060, 7): 1.1818259954452515,\n", + " (2060, 8): 3.6678138971328735,\n", + " (2060, 9): 4.55378270149231,\n", + " (2060, 10): 12.777472972869873,\n", + " (2060, 11): 36.23033428192139,\n", + " (2060, 12): 184.29877996444702},\n", + " 'window': {(2060, 1): 53.5350604057312,\n", + " (2060, 2): 62.90051078796387,\n", + " (2060, 3): 51.0702223777771,\n", + " (2060, 4): 19.947062492370605,\n", + " (2060, 5): 2.2900381088256836,\n", + " (2060, 6): 0.0,\n", + " (2060, 7): 1.1818259954452515,\n", + " (2060, 8): 3.6678138971328735,\n", + " (2060, 9): 2.9441583156585693,\n", + " (2060, 10): 9.44057297706604,\n", + " (2060, 11): 18.49140763282776,\n", + " (2060, 12): 83.28571796417236}},\n", + " 274: {'monthly': {(2060, 1): 202.1481363773346,\n", + " (2060, 2): 240.95759773254395,\n", + " (2060, 3): 176.90822100639343,\n", + " (2060, 4): 32.528223276138306,\n", + " (2060, 5): 2.2575716972351074,\n", + " (2060, 6): 2.3992990255355835,\n", + " (2060, 7): 2.258692502975464,\n", + " (2060, 8): 8.626851797103882,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 4.071798086166382,\n", + " (2060, 11): 43.679727435112,\n", + " (2060, 12): 201.3738250732422},\n", + " 'window': {(2060, 1): 54.28602695465088,\n", + " (2060, 2): 63.5795841217041,\n", + " (2060, 3): 46.82486534118652,\n", + " (2060, 4): 19.611440181732178,\n", + " (2060, 5): 1.2167506217956543,\n", + " (2060, 6): 1.2717193365097046,\n", + " (2060, 7): 1.2382659912109375,\n", + " (2060, 8): 6.286520004272461,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 2.9002057313919067,\n", + " (2060, 11): 23.66166377067566,\n", + " (2060, 12): 91.42366361618042}},\n", + " 275: {'monthly': {(2060, 1): 188.9342999458313,\n", + " (2060, 2): 219.16459584236145,\n", + " (2060, 3): 138.23318552970886,\n", + " (2060, 4): 32.778876423835754,\n", + " (2060, 5): 2.5462745428085327,\n", + " (2060, 6): 2.3992990255355835,\n", + " (2060, 7): 2.258692502975464,\n", + " (2060, 8): 7.913874506950378,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.66260826587677,\n", + " (2060, 11): 38.54490327835083,\n", + " (2060, 12): 196.19454061985016},\n", + " 'window': {(2060, 1): 56.193785667419434,\n", + " (2060, 2): 57.07875347137451,\n", + " (2060, 3): 34.331191539764404,\n", + " (2060, 4): 22.131305694580078,\n", + " (2060, 5): 1.5054534673690796,\n", + " (2060, 6): 1.2717193365097046,\n", + " (2060, 7): 1.2382659912109375,\n", + " (2060, 8): 5.5735427141189575,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 2.491015911102295,\n", + " (2060, 11): 22.03794527053833,\n", + " (2060, 12): 99.76544427871704}},\n", + " 276: {'monthly': {(2060, 1): 261.10482108592987,\n", + " (2060, 2): 274.88150465488434,\n", + " (2060, 3): 192.63463020324707,\n", + " (2060, 4): 67.92880415916443,\n", + " (2060, 5): 5.986621141433716,\n", + " (2060, 6): 4.212859511375427,\n", + " (2060, 7): 3.3232442140579224,\n", + " (2060, 8): 9.82966136932373,\n", + " (2060, 9): 2.252705454826355,\n", + " (2060, 10): 8.371089339256287,\n", + " (2060, 11): 56.374675989151,\n", + " (2060, 12): 295.74742436408997},\n", + " 'window': {(2060, 1): 71.57211971282959,\n", + " (2060, 2): 67.43015575408936,\n", + " (2060, 3): 43.61384201049805,\n", + " (2060, 4): 39.76958882808685,\n", + " (2060, 5): 3.6871590614318848,\n", + " (2060, 6): 1.8135604858398438,\n", + " (2060, 7): 1.2382659912109375,\n", + " (2060, 8): 7.48932957649231,\n", + " (2060, 9): 1.1522417068481445,\n", + " (2060, 10): 3.6574671268463135,\n", + " (2060, 11): 30.908519983291626,\n", + " (2060, 12): 155.1047191619873}},\n", + " 277: {'monthly': {(2060, 1): 330.86331391334534,\n", + " (2060, 2): 355.0861793756485,\n", + " (2060, 3): 262.8192650079727,\n", + " (2060, 4): 125.63546514511108,\n", + " (2060, 5): 24.143322587013245,\n", + " (2060, 6): 21.017499208450317,\n", + " (2060, 7): 12.590503811836243,\n", + " (2060, 8): 13.69922661781311,\n", + " (2060, 9): 7.840793490409851,\n", + " (2060, 10): 19.30341672897339,\n", + " (2060, 11): 76.16075074672699,\n", + " (2060, 12): 339.3919174671173},\n", + " 'window': {(2060, 1): 80.02444458007812,\n", + " (2060, 2): 92.28601932525635,\n", + " (2060, 3): 68.94701766967773,\n", + " (2060, 4): 77.29726243019104,\n", + " (2060, 5): 13.002723693847656,\n", + " (2060, 6): 7.409507155418396,\n", + " (2060, 7): 4.228013396263123,\n", + " (2060, 8): 11.280029773712158,\n", + " (2060, 9): 3.2351646423339844,\n", + " (2060, 10): 9.665526151657104,\n", + " (2060, 11): 36.60802149772644,\n", + " (2060, 12): 163.3670825958252}},\n", + " 278: {'monthly': {(2060, 1): 327.97847533226013,\n", + " (2060, 2): 381.3611658811569,\n", + " (2060, 3): 400.85040521621704,\n", + " (2060, 4): 173.1959934234619,\n", + " (2060, 5): 28.990357279777527,\n", + " (2060, 6): 26.265400648117065,\n", + " (2060, 7): 15.561176300048828,\n", + " (2060, 8): 18.09122908115387,\n", + " (2060, 9): 5.83366322517395,\n", + " (2060, 10): 8.412497639656067,\n", + " (2060, 11): 113.77406311035156,\n", + " (2060, 12): 413.91616213321686},\n", + " 'window': {(2060, 1): 77.47867012023926,\n", + " (2060, 2): 98.88286304473877,\n", + " (2060, 3): 94.85804653167725,\n", + " (2060, 4): 99.89056921005249,\n", + " (2060, 5): 19.437586665153503,\n", + " (2060, 6): 11.74343740940094,\n", + " (2060, 7): 6.327032804489136,\n", + " (2060, 8): 15.543925166130066,\n", + " (2060, 9): 4.714042067527771,\n", + " (2060, 10): 7.1155253648757935,\n", + " (2060, 11): 58.459808349609375,\n", + " (2060, 12): 154.06966590881348}},\n", + " 279: {'monthly': {(2060, 1): 369.8488698005676,\n", + " (2060, 2): 492.2385507822037,\n", + " (2060, 3): 547.0389657020569,\n", + " (2060, 4): 225.85501515865326,\n", + " (2060, 5): 36.79653239250183,\n", + " (2060, 6): 31.810413599014282,\n", + " (2060, 7): 18.3887779712677,\n", + " (2060, 8): 18.286468744277954,\n", + " (2060, 9): 5.935857772827148,\n", + " (2060, 10): 12.417531967163086,\n", + " (2060, 11): 166.73317456245422,\n", + " (2060, 12): 550.313892364502},\n", + " 'window': {(2060, 1): 88.37924194335938,\n", + " (2060, 2): 140.30486297607422,\n", + " (2060, 3): 137.37254524230957,\n", + " (2060, 4): 124.93175172805786,\n", + " (2060, 5): 24.15145218372345,\n", + " (2060, 6): 17.29554271697998,\n", + " (2060, 7): 6.157450914382935,\n", + " (2060, 8): 14.39061152935028,\n", + " (2060, 9): 5.935857772827148,\n", + " (2060, 10): 9.804187893867493,\n", + " (2060, 11): 82.99624729156494,\n", + " (2060, 12): 192.24921226501465}},\n", + " 280: {'monthly': {(2060, 1): 369.73603796958923,\n", + " (2060, 2): 479.36721777915955,\n", + " (2060, 3): 438.06075286865234,\n", + " (2060, 4): 152.5454043149948,\n", + " (2060, 5): 27.302899599075317,\n", + " (2060, 6): 20.069793105125427,\n", + " (2060, 7): 12.809409976005554,\n", + " (2060, 8): 12.998341679573059,\n", + " (2060, 9): 5.775176644325256,\n", + " (2060, 10): 8.872601509094238,\n", + " (2060, 11): 154.488560795784,\n", + " (2060, 12): 484.9553598165512},\n", + " 'window': {(2060, 1): 89.23777675628662,\n", + " (2060, 2): 134.7678747177124,\n", + " (2060, 3): 105.16179180145264,\n", + " (2060, 4): 86.2781331539154,\n", + " (2060, 5): 17.945239305496216,\n", + " (2060, 6): 11.692538261413574,\n", + " (2060, 7): 4.208318710327148,\n", + " (2060, 8): 10.451037764549255,\n", + " (2060, 9): 5.775176644325256,\n", + " (2060, 10): 7.575629234313965,\n", + " (2060, 11): 74.12103080749512,\n", + " (2060, 12): 178.6612663269043}},\n", + " 281: {'monthly': {(2060, 1): 282.1253023147583,\n", + " (2060, 2): 368.13819193840027,\n", + " (2060, 3): 269.2547399997711,\n", + " (2060, 4): 105.45567715167999,\n", + " (2060, 5): 22.96463704109192,\n", + " (2060, 6): 24.36797261238098,\n", + " (2060, 7): 12.79484760761261,\n", + " (2060, 8): 11.248621344566345,\n", + " (2060, 9): 4.963808298110962,\n", + " (2060, 10): 8.662757873535156,\n", + " (2060, 11): 121.49924194812775,\n", + " (2060, 12): 314.5602421760559},\n", + " 'window': {(2060, 1): 65.93494033813477,\n", + " (2060, 2): 103.00091648101807,\n", + " (2060, 3): 63.05338191986084,\n", + " (2060, 4): 57.008251428604126,\n", + " (2060, 5): 13.744433164596558,\n", + " (2060, 6): 10.061506271362305,\n", + " (2060, 7): 5.0404521226882935,\n", + " (2060, 8): 8.701317429542542,\n", + " (2060, 9): 4.963808298110962,\n", + " (2060, 10): 6.215651273727417,\n", + " (2060, 11): 66.31491804122925,\n", + " (2060, 12): 118.28147029876709}},\n", + " 282: {'monthly': {(2060, 1): 244.6848326921463,\n", + " (2060, 2): 273.99865078926086,\n", + " (2060, 3): 176.85901165008545,\n", + " (2060, 4): 45.805737257003784,\n", + " (2060, 5): 8.213672518730164,\n", + " (2060, 6): 10.303918242454529,\n", + " (2060, 7): 7.010338664054871,\n", + " (2060, 8): 9.822864413261414,\n", + " (2060, 9): 6.1145840883255005,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 57.948495864868164,\n", + " (2060, 12): 230.38296377658844},\n", + " 'window': {(2060, 1): 65.40737915039062,\n", + " (2060, 2): 86.54500484466553,\n", + " (2060, 3): 38.572632789611816,\n", + " (2060, 4): 31.97424030303955,\n", + " (2060, 5): 7.20013689994812,\n", + " (2060, 6): 7.843185663223267,\n", + " (2060, 7): 3.5801315307617188,\n", + " (2060, 8): 8.550485253334045,\n", + " (2060, 9): 4.983400583267212,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 37.7425377368927,\n", + " (2060, 12): 86.99042892456055}},\n", + " 283: {'monthly': {(2060, 1): 219.0244356393814,\n", + " (2060, 2): 253.25896728038788,\n", + " (2060, 3): 177.2306923866272,\n", + " (2060, 4): 43.68654143810272,\n", + " (2060, 5): 9.65729558467865,\n", + " (2060, 6): 10.91953694820404,\n", + " (2060, 7): 7.010338664054871,\n", + " (2060, 8): 9.822864413261414,\n", + " (2060, 9): 3.8625177145004272,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 48.439029812812805,\n", + " (2060, 12): 212.07850909233093},\n", + " 'window': {(2060, 1): 64.66326904296875,\n", + " (2060, 2): 71.13658428192139,\n", + " (2060, 3): 38.20770788192749,\n", + " (2060, 4): 29.75643742084503,\n", + " (2060, 5): 7.5967090129852295,\n", + " (2060, 6): 8.458804368972778,\n", + " (2060, 7): 3.5801315307617188,\n", + " (2060, 8): 8.550485253334045,\n", + " (2060, 9): 2.7313342094421387,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 33.37341022491455,\n", + " (2060, 12): 84.63204860687256}},\n", + " 284: {'monthly': {(2060, 1): 239.33512699604034,\n", + " (2060, 2): 283.7481598854065,\n", + " (2060, 3): 201.93693506717682,\n", + " (2060, 4): 44.409937620162964,\n", + " (2060, 5): 7.489858031272888,\n", + " (2060, 6): 9.180303692817688,\n", + " (2060, 7): 7.010338664054871,\n", + " (2060, 8): 9.822864413261414,\n", + " (2060, 9): 5.071811556816101,\n", + " (2060, 10): 1.4752005338668823,\n", + " (2060, 11): 60.44459855556488,\n", + " (2060, 12): 252.87853682041168},\n", + " 'window': {(2060, 1): 71.9550256729126,\n", + " (2060, 2): 76.56347942352295,\n", + " (2060, 3): 44.52830362319946,\n", + " (2060, 4): 29.822691679000854,\n", + " (2060, 5): 6.476322412490845,\n", + " (2060, 6): 6.719571113586426,\n", + " (2060, 7): 3.5801315307617188,\n", + " (2060, 8): 8.550485253334045,\n", + " (2060, 9): 2.7313342094421387,\n", + " (2060, 10): 1.4752005338668823,\n", + " (2060, 11): 43.681904315948486,\n", + " (2060, 12): 94.79739570617676}},\n", + " 285: {'monthly': {(2060, 1): 235.67325735092163,\n", + " (2060, 2): 303.0094002485275,\n", + " (2060, 3): 212.1528743505478,\n", + " (2060, 4): 42.13543653488159,\n", + " (2060, 5): 7.432999968528748,\n", + " (2060, 6): 7.247230172157288,\n", + " (2060, 7): 7.010338664054871,\n", + " (2060, 8): 9.822864413261414,\n", + " (2060, 9): 8.14247727394104,\n", + " (2060, 10): 1.21963632106781,\n", + " (2060, 11): 63.78882122039795,\n", + " (2060, 12): 247.44371330738068},\n", + " 'window': {(2060, 1): 73.0792236328125,\n", + " (2060, 2): 81.53742218017578,\n", + " (2060, 3): 47.438623905181885,\n", + " (2060, 4): 28.8593327999115,\n", + " (2060, 5): 5.231067180633545,\n", + " (2060, 6): 4.786497592926025,\n", + " (2060, 7): 3.5801315307617188,\n", + " (2060, 8): 8.550485253334045,\n", + " (2060, 9): 5.934567928314209,\n", + " (2060, 10): 1.21963632106781,\n", + " (2060, 11): 44.896769523620605,\n", + " (2060, 12): 94.42313003540039}},\n", + " 286: {'monthly': {(2060, 1): 212.9824447631836,\n", + " (2060, 2): 222.16475176811218,\n", + " (2060, 3): 186.84216952323914,\n", + " (2060, 4): 38.401179790496826,\n", + " (2060, 5): 3.292080879211426,\n", + " (2060, 6): 0.0,\n", + " (2060, 7): 1.1818259954452515,\n", + " (2060, 8): 3.6678138971328735,\n", + " (2060, 9): 4.160870313644409,\n", + " (2060, 10): 8.339627027511597,\n", + " (2060, 11): 36.909741282463074,\n", + " (2060, 12): 172.69861435890198},\n", + " 'window': {(2060, 1): 49.34910011291504,\n", + " (2060, 2): 59.48219013214111,\n", + " (2060, 3): 43.55940389633179,\n", + " (2060, 4): 20.02315044403076,\n", + " (2060, 5): 2.2900381088256836,\n", + " (2060, 6): 0.0,\n", + " (2060, 7): 1.1818259954452515,\n", + " (2060, 8): 3.6678138971328735,\n", + " (2060, 9): 2.551245927810669,\n", + " (2060, 10): 8.339627027511597,\n", + " (2060, 11): 19.289527416229248,\n", + " (2060, 12): 79.69157218933105}},\n", + " 287: {'monthly': {(2060, 1): 194.3700132369995,\n", + " (2060, 2): 263.53945767879486,\n", + " (2060, 3): 180.35098016262054,\n", + " (2060, 4): 36.54633688926697,\n", + " (2060, 5): 2.401662588119507,\n", + " (2060, 6): 2.3992990255355835,\n", + " (2060, 7): 2.258692502975464,\n", + " (2060, 8): 8.626851797103882,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 6.494547963142395,\n", + " (2060, 11): 47.83089196681976,\n", + " (2060, 12): 214.6172354221344},\n", + " 'window': {(2060, 1): 55.80312442779541,\n", + " (2060, 2): 71.0849256515503,\n", + " (2060, 3): 47.97212219238281,\n", + " (2060, 4): 24.290818333625793,\n", + " (2060, 5): 1.3608415126800537,\n", + " (2060, 6): 1.2717193365097046,\n", + " (2060, 7): 1.2382659912109375,\n", + " (2060, 8): 6.286520004272461,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 5.32295560836792,\n", + " (2060, 11): 28.50161051750183,\n", + " (2060, 12): 101.51147508621216}},\n", + " 288: {'monthly': {(2060, 1): 189.94058299064636,\n", + " (2060, 2): 233.86027669906616,\n", + " (2060, 3): 146.904904961586,\n", + " (2060, 4): 37.03212881088257,\n", + " (2060, 5): 2.7289613485336304,\n", + " (2060, 6): 2.3992990255355835,\n", + " (2060, 7): 2.258692502975464,\n", + " (2060, 8): 8.010579466819763,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 4.628726124763489,\n", + " (2060, 11): 42.39926362037659,\n", + " (2060, 12): 218.58169829845428},\n", + " 'window': {(2060, 1): 51.79250240325928,\n", + " (2060, 2): 63.13421821594238,\n", + " (2060, 3): 39.58002185821533,\n", + " (2060, 4): 24.893687844276428,\n", + " (2060, 5): 1.6881402730941772,\n", + " (2060, 6): 1.2717193365097046,\n", + " (2060, 7): 1.2382659912109375,\n", + " (2060, 8): 5.670247673988342,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.4571337699890137,\n", + " (2060, 11): 22.969584941864014,\n", + " (2060, 12): 112.43907451629639}},\n", + " 289: {'monthly': {(2060, 1): 209.68105745315552,\n", + " (2060, 2): 258.8639488220215,\n", + " (2060, 3): 165.19312572479248,\n", + " (2060, 4): 53.55957746505737,\n", + " (2060, 5): 3.7774850130081177,\n", + " (2060, 6): 3.688859462738037,\n", + " (2060, 7): 2.258692502975464,\n", + " (2060, 8): 9.180863618850708,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.6685227155685425,\n", + " (2060, 11): 46.26161479949951,\n", + " (2060, 12): 266.35152447223663},\n", + " 'window': {(2060, 1): 52.63975429534912,\n", + " (2060, 2): 65.47720623016357,\n", + " (2060, 3): 44.699657917022705,\n", + " (2060, 4): 37.366345047950745,\n", + " (2060, 5): 2.621811866760254,\n", + " (2060, 6): 1.2895604372024536,\n", + " (2060, 7): 1.2382659912109375,\n", + " (2060, 8): 5.824708580970764,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 2.3982726335525513,\n", + " (2060, 11): 26.688957452774048,\n", + " (2060, 12): 145.53408479690552}},\n", + " 290: {'monthly': {(2060, 1): 278.49811351299286,\n", + " (2060, 2): 315.2948662042618,\n", + " (2060, 3): 220.8441195487976,\n", + " (2060, 4): 111.55693066120148,\n", + " (2060, 5): 13.77240002155304,\n", + " (2060, 6): 13.528334736824036,\n", + " (2060, 7): 6.2740254402160645,\n", + " (2060, 8): 14.32671570777893,\n", + " (2060, 9): 1.2315737009048462,\n", + " (2060, 10): 11.372812986373901,\n", + " (2060, 11): 69.88608121871948,\n", + " (2060, 12): 293.1069587469101},\n", + " 'window': {(2060, 1): 67.12419033050537,\n", + " (2060, 2): 88.11312294006348,\n", + " (2060, 3): 50.68101167678833,\n", + " (2060, 4): 69.24207592010498,\n", + " (2060, 5): 8.037078261375427,\n", + " (2060, 6): 6.02851939201355,\n", + " (2060, 7): 3.7570064067840576,\n", + " (2060, 8): 9.269162654876709,\n", + " (2060, 9): 1.2315737009048462,\n", + " (2060, 10): 7.535316824913025,\n", + " (2060, 11): 34.04280209541321,\n", + " (2060, 12): 146.38379859924316}},\n", + " 291: {'monthly': {(2060, 1): 286.4560081958771,\n", + " (2060, 2): 352.1943836212158,\n", + " (2060, 3): 378.66679191589355,\n", + " (2060, 4): 186.69843208789825,\n", + " (2060, 5): 32.60053253173828,\n", + " (2060, 6): 27.660024523735046,\n", + " (2060, 7): 16.83817183971405,\n", + " (2060, 8): 18.25704562664032,\n", + " (2060, 9): 7.281902313232422,\n", + " (2060, 10): 12.083991646766663,\n", + " (2060, 11): 116.51404750347137,\n", + " (2060, 12): 401.4395172595978},\n", + " 'window': {(2060, 1): 71.8088150024414,\n", + " (2060, 2): 84.17150497436523,\n", + " (2060, 3): 96.69306945800781,\n", + " (2060, 4): 102.14092063903809,\n", + " (2060, 5): 17.457882523536682,\n", + " (2060, 6): 12.671860694885254,\n", + " (2060, 7): 7.123161435127258,\n", + " (2060, 8): 15.709741711616516,\n", + " (2060, 9): 6.052022576332092,\n", + " (2060, 10): 9.045084238052368,\n", + " (2060, 11): 61.669612884521484,\n", + " (2060, 12): 164.8600196838379}},\n", + " 292: {'monthly': {(2060, 1): 349.0924081802368,\n", + " (2060, 2): 477.39856576919556,\n", + " (2060, 3): 539.2233939170837,\n", + " (2060, 4): 244.16894924640656,\n", + " (2060, 5): 36.49190962314606,\n", + " (2060, 6): 32.87833118438721,\n", + " (2060, 7): 19.833068370819092,\n", + " (2060, 8): 17.79358160495758,\n", + " (2060, 9): 6.614946365356445,\n", + " (2060, 10): 15.858542680740356,\n", + " (2060, 11): 182.28687119483948,\n", + " (2060, 12): 589.9659240245819},\n", + " 'window': {(2060, 1): 78.09229850769043,\n", + " (2060, 2): 129.32460594177246,\n", + " (2060, 3): 142.4814567565918,\n", + " (2060, 4): 134.26920127868652,\n", + " (2060, 5): 22.416889309883118,\n", + " (2060, 6): 11.932302594184875,\n", + " (2060, 7): 6.830312371253967,\n", + " (2060, 8): 15.246277689933777,\n", + " (2060, 9): 6.614946365356445,\n", + " (2060, 10): 13.052146434783936,\n", + " (2060, 11): 89.15970993041992,\n", + " (2060, 12): 245.76898193359375}},\n", + " 293: {'monthly': {(2060, 1): 353.92125272750854,\n", + " (2060, 2): 494.5641635656357,\n", + " (2060, 3): 469.9206566810608,\n", + " (2060, 4): 185.92732524871826,\n", + " (2060, 5): 28.283726692199707,\n", + " (2060, 6): 26.190886616706848,\n", + " (2060, 7): 18.35683536529541,\n", + " (2060, 8): 13.497167468070984,\n", + " (2060, 9): 5.1070685386657715,\n", + " (2060, 10): 10.295199513435364,\n", + " (2060, 11): 189.35727155208588,\n", + " (2060, 12): 537.9628672599792},\n", + " 'window': {(2060, 1): 77.8918228149414,\n", + " (2060, 2): 139.19175148010254,\n", + " (2060, 3): 107.49295234680176,\n", + " (2060, 4): 99.89750289916992,\n", + " (2060, 5): 16.227331042289734,\n", + " (2060, 6): 10.530211925506592,\n", + " (2060, 7): 6.650483846664429,\n", + " (2060, 8): 10.94986355304718,\n", + " (2060, 9): 5.1070685386657715,\n", + " (2060, 10): 8.99822723865509,\n", + " (2060, 11): 86.5686845779419,\n", + " (2060, 12): 217.0316982269287}},\n", + " 294: {'monthly': {(2060, 1): 291.5857101678848,\n", + " (2060, 2): 402.0289623737335,\n", + " (2060, 3): 320.308345079422,\n", + " (2060, 4): 123.53567910194397,\n", + " (2060, 5): 23.90632200241089,\n", + " (2060, 6): 24.247234225273132,\n", + " (2060, 7): 12.555969953536987,\n", + " (2060, 8): 11.272897601127625,\n", + " (2060, 9): 6.4275946617126465,\n", + " (2060, 10): 9.253091931343079,\n", + " (2060, 11): 157.2156240940094,\n", + " (2060, 12): 371.08502662181854},\n", + " 'window': {(2060, 1): 61.913909912109375,\n", + " (2060, 2): 114.79311561584473,\n", + " (2060, 3): 74.501145362854,\n", + " (2060, 4): 62.2232346534729,\n", + " (2060, 5): 12.243579745292664,\n", + " (2060, 6): 9.752799034118652,\n", + " (2060, 7): 5.292864441871643,\n", + " (2060, 8): 8.72559368610382,\n", + " (2060, 9): 5.380030989646912,\n", + " (2060, 10): 6.817427158355713,\n", + " (2060, 11): 84.69071531295776,\n", + " (2060, 12): 148.28900337219238}},\n", + " 295: {'monthly': {(2060, 1): 284.1167402267456,\n", + " (2060, 2): 312.32931911945343,\n", + " (2060, 3): 200.03718531131744,\n", + " (2060, 4): 63.015374541282654,\n", + " (2060, 5): 10.110085010528564,\n", + " (2060, 6): 12.195336103439331,\n", + " (2060, 7): 7.010338664054871,\n", + " (2060, 8): 13.423810839653015,\n", + " (2060, 9): 5.933136701583862,\n", + " (2060, 10): 1.0744940042495728,\n", + " (2060, 11): 71.03193819522858,\n", + " (2060, 12): 263.5773870944977},\n", + " 'window': {(2060, 1): 68.83203315734863,\n", + " (2060, 2): 97.34447956085205,\n", + " (2060, 3): 41.08051586151123,\n", + " (2060, 4): 43.65781497955322,\n", + " (2060, 5): 6.664398193359375,\n", + " (2060, 6): 6.513287782669067,\n", + " (2060, 7): 3.5801315307617188,\n", + " (2060, 8): 9.100850939750671,\n", + " (2060, 9): 4.801953196525574,\n", + " (2060, 10): 1.0744940042495728,\n", + " (2060, 11): 43.393962144851685,\n", + " (2060, 12): 84.02052402496338}},\n", + " 296: {'monthly': {(2060, 1): 248.36198234558105,\n", + " (2060, 2): 287.1254141330719,\n", + " (2060, 3): 201.75259637832642,\n", + " (2060, 4): 66.52695870399475,\n", + " (2060, 5): 8.271929144859314,\n", + " (2060, 6): 10.394352793693542,\n", + " (2060, 7): 7.010338664054871,\n", + " (2060, 8): 9.822864413261414,\n", + " (2060, 9): 7.000096440315247,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 51.41369140148163,\n", + " (2060, 12): 236.82114434242249},\n", + " 'window': {(2060, 1): 68.56517267227173,\n", + " (2060, 2): 78.52660369873047,\n", + " (2060, 3): 41.61316204071045,\n", + " (2060, 4): 47.77272391319275,\n", + " (2060, 5): 7.2583935260772705,\n", + " (2060, 6): 7.93362021446228,\n", + " (2060, 7): 3.5801315307617188,\n", + " (2060, 8): 8.550485253334045,\n", + " (2060, 9): 5.868912935256958,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 36.181626081466675,\n", + " (2060, 12): 82.24021053314209}},\n", + " 297: {'monthly': {(2060, 1): 222.70254802703857,\n", + " (2060, 2): 268.80679738521576,\n", + " (2060, 3): 206.03956055641174,\n", + " (2060, 4): 64.36299705505371,\n", + " (2060, 5): 6.560515999794006,\n", + " (2060, 6): 7.737638711929321,\n", + " (2060, 7): 7.010338664054871,\n", + " (2060, 8): 9.822864413261414,\n", + " (2060, 9): 7.621119260787964,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 55.510706067085266,\n", + " (2060, 12): 242.25676953792572},\n", + " 'window': {(2060, 1): 67.03868675231934,\n", + " (2060, 2): 72.14301872253418,\n", + " (2060, 3): 45.89143753051758,\n", + " (2060, 4): 47.612290143966675,\n", + " (2060, 5): 5.546980381011963,\n", + " (2060, 6): 5.276906132698059,\n", + " (2060, 7): 3.5801315307617188,\n", + " (2060, 8): 8.550485253334045,\n", + " (2060, 9): 6.489935755729675,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 39.56480693817139,\n", + " (2060, 12): 86.57310104370117}},\n", + " 298: {'monthly': {(2060, 1): 224.8115746974945,\n", + " (2060, 2): 287.1875332593918,\n", + " (2060, 3): 215.41685485839844,\n", + " (2060, 4): 62.97270739078522,\n", + " (2060, 5): 6.662723660469055,\n", + " (2060, 6): 6.223147392272949,\n", + " (2060, 7): 7.010338664054871,\n", + " (2060, 8): 9.822864413261414,\n", + " (2060, 9): 8.990198016166687,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 61.305317640304565,\n", + " (2060, 12): 248.48381912708282},\n", + " 'window': {(2060, 1): 66.3544225692749,\n", + " (2060, 2): 78.54612636566162,\n", + " (2060, 3): 47.64126491546631,\n", + " (2060, 4): 47.531736850738525,\n", + " (2060, 5): 4.571369171142578,\n", + " (2060, 6): 3.762414813041687,\n", + " (2060, 7): 3.5801315307617188,\n", + " (2060, 8): 8.550485253334045,\n", + " (2060, 9): 7.859014511108398,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 42.06153345108032,\n", + " (2060, 12): 88.7524356842041}},\n", + " 299: {'monthly': {(2060, 1): 185.96750402450562,\n", + " (2060, 2): 211.40797364711761,\n", + " (2060, 3): 174.9561449289322,\n", + " (2060, 4): 36.8174147605896,\n", + " (2060, 5): 3.292080879211426,\n", + " (2060, 6): 0.0,\n", + " (2060, 7): 1.1818259954452515,\n", + " (2060, 8): 3.6678138971328735,\n", + " (2060, 9): 2.7209075689315796,\n", + " (2060, 10): 5.511987686157227,\n", + " (2060, 11): 45.11414396762848,\n", + " (2060, 12): 142.75430929660797},\n", + " 'window': {(2060, 1): 43.579739809036255,\n", + " (2060, 2): 54.35509920120239,\n", + " (2060, 3): 45.67604112625122,\n", + " (2060, 4): 18.890052556991577,\n", + " (2060, 5): 2.2900381088256836,\n", + " (2060, 6): 0.0,\n", + " (2060, 7): 1.1818259954452515,\n", + " (2060, 8): 3.6678138971328735,\n", + " (2060, 9): 1.6096243858337402,\n", + " (2060, 10): 5.511987686157227,\n", + " (2060, 11): 30.31050205230713,\n", + " (2060, 12): 75.44825077056885}},\n", + " 300: {'monthly': {(2060, 1): 192.28769659996033,\n", + " (2060, 2): 269.20401406288147,\n", + " (2060, 3): 194.6529768705368,\n", + " (2060, 4): 47.957080602645874,\n", + " (2060, 5): 2.9140249490737915,\n", + " (2060, 6): 2.3992990255355835,\n", + " (2060, 7): 2.258692502975464,\n", + " (2060, 8): 8.626851797103882,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 2.4418424367904663,\n", + " (2060, 11): 42.47283232212067,\n", + " (2060, 12): 204.96729183197021},\n", + " 'window': {(2060, 1): 51.83346462249756,\n", + " (2060, 2): 77.4365725517273,\n", + " (2060, 3): 53.1937689781189,\n", + " (2060, 4): 33.905452847480774,\n", + " (2060, 5): 1.8732038736343384,\n", + " (2060, 6): 1.2717193365097046,\n", + " (2060, 7): 1.2382659912109375,\n", + " (2060, 8): 6.286520004272461,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 1.2702500820159912,\n", + " (2060, 11): 24.601597785949707,\n", + " (2060, 12): 98.45725345611572}},\n", + " 301: {'monthly': {(2060, 1): 159.432781457901,\n", + " (2060, 2): 242.84446346759796,\n", + " (2060, 3): 137.34026098251343,\n", + " (2060, 4): 43.24192774295807,\n", + " (2060, 5): 4.259430885314941,\n", + " (2060, 6): 3.9823997020721436,\n", + " (2060, 7): 2.258692502975464,\n", + " (2060, 8): 8.626851797103882,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.5853527784347534,\n", + " (2060, 11): 39.52237069606781,\n", + " (2060, 12): 200.2691330909729},\n", + " 'window': {(2060, 1): 38.80760622024536,\n", + " (2060, 2): 75.02466011047363,\n", + " (2060, 3): 39.62159729003906,\n", + " (2060, 4): 31.347317337989807,\n", + " (2060, 5): 3.2186098098754883,\n", + " (2060, 6): 1.58310067653656,\n", + " (2060, 7): 1.2382659912109375,\n", + " (2060, 8): 6.286520004272461,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 2.4137604236602783,\n", + " (2060, 11): 23.389134883880615,\n", + " (2060, 12): 105.45851993560791}},\n", + " 302: {'monthly': {(2060, 1): 143.7444610595703,\n", + " (2060, 2): 232.4283493757248,\n", + " (2060, 3): 123.26553809642792,\n", + " (2060, 4): 47.376118540763855,\n", + " (2060, 5): 5.202957630157471,\n", + " (2060, 6): 4.446481347084045,\n", + " (2060, 7): 2.258692502975464,\n", + " (2060, 8): 8.406559705734253,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 3.561463236808777,\n", + " (2060, 11): 40.464364528656006,\n", + " (2060, 12): 199.46105015277863},\n", + " 'window': {(2060, 1): 33.29625654220581,\n", + " (2060, 2): 65.78070878982544,\n", + " (2060, 3): 32.89823389053345,\n", + " (2060, 4): 35.73164117336273,\n", + " (2060, 5): 4.162136554718018,\n", + " (2060, 6): 2.047182321548462,\n", + " (2060, 7): 1.2382659912109375,\n", + " (2060, 8): 6.066227912902832,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 2.3898708820343018,\n", + " (2060, 11): 24.125253677368164,\n", + " (2060, 12): 108.84042167663574}},\n", + " 303: {'monthly': {(2060, 1): 229.5492159128189,\n", + " (2060, 2): 276.69907534122467,\n", + " (2060, 3): 195.18038392066956,\n", + " (2060, 4): 101.50505018234253,\n", + " (2060, 5): 19.343570709228516,\n", + " (2060, 6): 11.087067008018494,\n", + " (2060, 7): 8.703584432601929,\n", + " (2060, 8): 14.485116124153137,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 10.68213975429535,\n", + " (2060, 11): 71.13867688179016,\n", + " (2060, 12): 241.29037070274353},\n", + " 'window': {(2060, 1): 66.23390817642212,\n", + " (2060, 2): 81.47225856781006,\n", + " (2060, 3): 41.89821767807007,\n", + " (2060, 4): 60.37638306617737,\n", + " (2060, 5): 11.663575530052185,\n", + " (2060, 6): 5.471638083457947,\n", + " (2060, 7): 3.2808117866516113,\n", + " (2060, 8): 8.850505352020264,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 5.67237401008606,\n", + " (2060, 11): 37.51217818260193,\n", + " (2060, 12): 111.44307231903076}},\n", + " 304: {'monthly': {(2060, 1): 286.3049873113632,\n", + " (2060, 2): 368.16447389125824,\n", + " (2060, 3): 385.85055899620056,\n", + " (2060, 4): 198.99863183498383,\n", + " (2060, 5): 32.821502447128296,\n", + " (2060, 6): 33.06886088848114,\n", + " (2060, 7): 19.562201619148254,\n", + " (2060, 8): 18.467347741127014,\n", + " (2060, 9): 12.977737307548523,\n", + " (2060, 10): 16.902153611183167,\n", + " (2060, 11): 128.72115087509155,\n", + " (2060, 12): 380.98357379436493},\n", + " 'window': {(2060, 1): 67.45153617858887,\n", + " (2060, 2): 98.13108539581299,\n", + " (2060, 3): 97.29019451141357,\n", + " (2060, 4): 96.95727682113647,\n", + " (2060, 5): 19.607909083366394,\n", + " (2060, 6): 12.076756954193115,\n", + " (2060, 7): 6.254428386688232,\n", + " (2060, 8): 15.92004382610321,\n", + " (2060, 9): 9.19075632095337,\n", + " (2060, 10): 11.90873110294342,\n", + " (2060, 11): 70.70736646652222,\n", + " (2060, 12): 165.5000400543213}},\n", + " 305: {'monthly': {(2060, 1): 345.4643483161926,\n", + " (2060, 2): 477.98455905914307,\n", + " (2060, 3): 524.5392971038818,\n", + " (2060, 4): 254.4755915403366,\n", + " (2060, 5): 39.17512118816376,\n", + " (2060, 6): 36.305203557014465,\n", + " (2060, 7): 22.36782479286194,\n", + " (2060, 8): 19.21171474456787,\n", + " (2060, 9): 9.918609976768494,\n", + " (2060, 10): 17.437370657920837,\n", + " (2060, 11): 182.29109716415405,\n", + " (2060, 12): 582.7370662689209},\n", + " 'window': {(2060, 1): 82.7620439529419,\n", + " (2060, 2): 141.27897262573242,\n", + " (2060, 3): 135.0885829925537,\n", + " (2060, 4): 134.29288721084595,\n", + " (2060, 5): 23.04376995563507,\n", + " (2060, 6): 13.577804803848267,\n", + " (2060, 7): 7.515873551368713,\n", + " (2060, 8): 15.507704615592957,\n", + " (2060, 9): 8.813008785247803,\n", + " (2060, 10): 14.23676609992981,\n", + " (2060, 11): 92.89720630645752,\n", + " (2060, 12): 266.4029369354248}},\n", + " 306: {'monthly': {(2060, 1): 356.5360565185547,\n", + " (2060, 2): 503.9673571586609,\n", + " (2060, 3): 499.95370054244995,\n", + " (2060, 4): 226.0541731119156,\n", + " (2060, 5): 28.517894744873047,\n", + " (2060, 6): 33.422006726264954,\n", + " (2060, 7): 22.057823419570923,\n", + " (2060, 8): 17.096804976463318,\n", + " (2060, 9): 6.953632950782776,\n", + " (2060, 10): 15.14041292667389,\n", + " (2060, 11): 202.3492956161499,\n", + " (2060, 12): 569.2568917274475},\n", + " 'window': {(2060, 1): 75.86386299133301,\n", + " (2060, 2): 159.41707038879395,\n", + " (2060, 3): 110.55237579345703,\n", + " (2060, 4): 115.60181188583374,\n", + " (2060, 5): 16.924604892730713,\n", + " (2060, 6): 12.744750022888184,\n", + " (2060, 7): 8.527568578720093,\n", + " (2060, 8): 11.73672091960907,\n", + " (2060, 9): 6.953632950782776,\n", + " (2060, 10): 11.429115056991577,\n", + " (2060, 11): 93.69571876525879,\n", + " (2060, 12): 243.78331470489502}},\n", + " 307: {'monthly': {(2060, 1): 374.32205963134766,\n", + " (2060, 2): 420.27388060092926,\n", + " (2060, 3): 376.09175992012024,\n", + " (2060, 4): 153.51423394680023,\n", + " (2060, 5): 30.334295630455017,\n", + " (2060, 6): 30.355931758880615,\n", + " (2060, 7): 19.145443439483643,\n", + " (2060, 8): 14.901206016540527,\n", + " (2060, 9): 3.5222620964050293,\n", + " (2060, 10): 9.79495656490326,\n", + " (2060, 11): 164.95454037189484,\n", + " (2060, 12): 413.12501668930054},\n", + " 'window': {(2060, 1): 79.61287117004395,\n", + " (2060, 2): 113.38627052307129,\n", + " (2060, 3): 74.28894996643066,\n", + " (2060, 4): 80.15976548194885,\n", + " (2060, 5): 12.79208779335022,\n", + " (2060, 6): 11.584104418754578,\n", + " (2060, 7): 7.999499559402466,\n", + " (2060, 8): 11.130141139030457,\n", + " (2060, 9): 3.5222620964050293,\n", + " (2060, 10): 7.465259790420532,\n", + " (2060, 11): 78.79061698913574,\n", + " (2060, 12): 164.3145513534546}},\n", + " 308: {'monthly': {(2060, 1): 324.08762514591217,\n", + " (2060, 2): 355.6747155189514,\n", + " (2060, 3): 237.8030767440796,\n", + " (2060, 4): 81.39760088920593,\n", + " (2060, 5): 19.897865176200867,\n", + " (2060, 6): 16.91952610015869,\n", + " (2060, 7): 11.48007619380951,\n", + " (2060, 8): 12.75532054901123,\n", + " (2060, 9): 7.411181926727295,\n", + " (2060, 10): 1.124501347541809,\n", + " (2060, 11): 65.523881316185,\n", + " (2060, 12): 300.5798771381378},\n", + " 'window': {(2060, 1): 78.87037992477417,\n", + " (2060, 2): 102.46298313140869,\n", + " (2060, 3): 54.07354164123535,\n", + " (2060, 4): 45.70363807678223,\n", + " (2060, 5): 7.689757585525513,\n", + " (2060, 6): 5.885278820991516,\n", + " (2060, 7): 4.2723517417907715,\n", + " (2060, 8): 8.677401423454285,\n", + " (2060, 9): 4.968779921531677,\n", + " (2060, 10): 1.124501347541809,\n", + " (2060, 11): 44.99549722671509,\n", + " (2060, 12): 85.31803703308105}},\n", + " 309: {'monthly': {(2060, 1): 252.30229449272156,\n", + " (2060, 2): 287.7807631492615,\n", + " (2060, 3): 211.60944879055023,\n", + " (2060, 4): 67.52161157131195,\n", + " (2060, 5): 8.043611526489258,\n", + " (2060, 6): 7.7573665380477905,\n", + " (2060, 7): 7.010338664054871,\n", + " (2060, 8): 10.04865550994873,\n", + " (2060, 9): 8.159376978874207,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 51.81781768798828,\n", + " (2060, 12): 251.63340651988983},\n", + " 'window': {(2060, 1): 63.48879623413086,\n", + " (2060, 2): 79.5995740890503,\n", + " (2060, 3): 45.241783142089844,\n", + " (2060, 4): 46.56393313407898,\n", + " (2060, 5): 5.735715627670288,\n", + " (2060, 6): 5.296633958816528,\n", + " (2060, 7): 3.5801315307617188,\n", + " (2060, 8): 8.776276350021362,\n", + " (2060, 9): 7.028193473815918,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 35.479352712631226,\n", + " (2060, 12): 75.77218723297119}},\n", + " 310: {'monthly': {(2060, 1): 214.68865489959717,\n", + " (2060, 2): 251.58649945259094,\n", + " (2060, 3): 205.33158445358276,\n", + " (2060, 4): 68.54109847545624,\n", + " (2060, 5): 6.715879678726196,\n", + " (2060, 6): 6.16838526725769,\n", + " (2060, 7): 7.010338664054871,\n", + " (2060, 8): 9.822864413261414,\n", + " (2060, 9): 10.07574737071991,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 52.740705728530884,\n", + " (2060, 12): 236.95231866836548},\n", + " 'window': {(2060, 1): 56.46764945983887,\n", + " (2060, 2): 72.80794048309326,\n", + " (2060, 3): 44.36585760116577,\n", + " (2060, 4): 48.76756477355957,\n", + " (2060, 5): 4.529953718185425,\n", + " (2060, 6): 3.6981234550476074,\n", + " (2060, 7): 3.5801315307617188,\n", + " (2060, 8): 8.550485253334045,\n", + " (2060, 9): 8.944563865661621,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 35.87619614601135,\n", + " (2060, 12): 75.88614654541016}},\n", + " 311: {'monthly': {(2060, 1): 234.83245420455933,\n", + " (2060, 2): 267.63527739048004,\n", + " (2060, 3): 214.11063158512115,\n", + " (2060, 4): 67.46564984321594,\n", + " (2060, 5): 5.092434525489807,\n", + " (2060, 6): 4.494784235954285,\n", + " (2060, 7): 7.010338664054871,\n", + " (2060, 8): 9.822864413261414,\n", + " (2060, 9): 11.60684883594513,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 56.43745005130768,\n", + " (2060, 12): 237.45928120613098},\n", + " 'window': {(2060, 1): 59.0307674407959,\n", + " (2060, 2): 84.35773277282715,\n", + " (2060, 3): 45.98740100860596,\n", + " (2060, 4): 49.07197093963623,\n", + " (2060, 5): 4.078898906707764,\n", + " (2060, 6): 2.460732579231262,\n", + " (2060, 7): 3.5801315307617188,\n", + " (2060, 8): 8.550485253334045,\n", + " (2060, 9): 10.47566533088684,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 39.340442180633545,\n", + " (2060, 12): 77.19342994689941}},\n", + " 312: {'monthly': {(2060, 1): 231.85411155223846,\n", + " (2060, 2): 267.8768970966339,\n", + " (2060, 3): 189.6846684217453,\n", + " (2060, 4): 48.80300426483154,\n", + " (2060, 5): 3.292080879211426,\n", + " (2060, 6): 0.0,\n", + " (2060, 7): 1.1818259954452515,\n", + " (2060, 8): 3.6678138971328735,\n", + " (2060, 9): 2.7209075689315796,\n", + " (2060, 10): 6.021319270133972,\n", + " (2060, 11): 47.624624133110046,\n", + " (2060, 12): 172.26119923591614},\n", + " 'window': {(2060, 1): 55.56057262420654,\n", + " (2060, 2): 68.45817637443542,\n", + " (2060, 3): 45.738462924957275,\n", + " (2060, 4): 26.363823413848877,\n", + " (2060, 5): 2.2900381088256836,\n", + " (2060, 6): 0.0,\n", + " (2060, 7): 1.1818259954452515,\n", + " (2060, 8): 3.6678138971328735,\n", + " (2060, 9): 1.6096243858337402,\n", + " (2060, 10): 6.021319270133972,\n", + " (2060, 11): 31.14918565750122,\n", + " (2060, 12): 77.3136796951294}},\n", + " 313: {'monthly': {(2060, 1): 235.1071718931198,\n", + " (2060, 2): 311.5002361536026,\n", + " (2060, 3): 235.78783094882965,\n", + " (2060, 4): 78.87877357006073,\n", + " (2060, 5): 3.599635362625122,\n", + " (2060, 6): 3.6578736305236816,\n", + " (2060, 7): 2.258692502975464,\n", + " (2060, 8): 8.626851797103882,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 4.002659797668457,\n", + " (2060, 11): 50.982998967170715,\n", + " (2060, 12): 216.04162991046906},\n", + " 'window': {(2060, 1): 75.48440933227539,\n", + " (2060, 2): 90.32378482818604,\n", + " (2060, 3): 63.4071307182312,\n", + " (2060, 4): 60.0803028345108,\n", + " (2060, 5): 2.558814287185669,\n", + " (2060, 6): 1.2717193365097046,\n", + " (2060, 7): 1.2382659912109375,\n", + " (2060, 8): 6.286520004272461,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 2.831067442893982,\n", + " (2060, 11): 27.277641773223877,\n", + " (2060, 12): 91.14862823486328}},\n", + " 314: {'monthly': {(2060, 1): 187.02880716323853,\n", + " (2060, 2): 266.47056210041046,\n", + " (2060, 3): 163.27308917045593,\n", + " (2060, 4): 73.701491355896,\n", + " (2060, 5): 5.606431007385254,\n", + " (2060, 6): 4.644933104515076,\n", + " (2060, 7): 2.258692502975464,\n", + " (2060, 8): 8.626851797103882,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 4.117628455162048,\n", + " (2060, 11): 48.98021650314331,\n", + " (2060, 12): 199.93300247192383},\n", + " 'window': {(2060, 1): 48.002370834350586,\n", + " (2060, 2): 81.05459403991699,\n", + " (2060, 3): 41.80525875091553,\n", + " (2060, 4): 56.95696699619293,\n", + " (2060, 5): 4.565609931945801,\n", + " (2060, 6): 2.245634078979492,\n", + " (2060, 7): 1.2382659912109375,\n", + " (2060, 8): 6.286520004272461,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 2.9460361003875732,\n", + " (2060, 11): 26.889230012893677,\n", + " (2060, 12): 88.10031509399414}},\n", + " 315: {'monthly': {(2060, 1): 156.15814018249512,\n", + " (2060, 2): 229.92984557151794,\n", + " (2060, 3): 141.39503455162048,\n", + " (2060, 4): 80.42218041419983,\n", + " (2060, 5): 8.188782453536987,\n", + " (2060, 6): 5.352041840553284,\n", + " (2060, 7): 2.258692502975464,\n", + " (2060, 8): 7.815626263618469,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 5.198745608329773,\n", + " (2060, 11): 46.03838336467743,\n", + " (2060, 12): 197.27219212055206},\n", + " 'window': {(2060, 1): 38.07924222946167,\n", + " (2060, 2): 65.86176490783691,\n", + " (2060, 3): 30.658414363861084,\n", + " (2060, 4): 64.26833951473236,\n", + " (2060, 5): 6.003236293792725,\n", + " (2060, 6): 2.9527428150177,\n", + " (2060, 7): 1.2382659912109375,\n", + " (2060, 8): 5.475294470787048,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 4.027153253555298,\n", + " (2060, 11): 26.952005624771118,\n", + " (2060, 12): 89.5875129699707}},\n", + " 316: {'monthly': {(2060, 1): 242.48321652412415,\n", + " (2060, 2): 290.6327086687088,\n", + " (2060, 3): 213.42889261245728,\n", + " (2060, 4): 126.31227934360504,\n", + " (2060, 5): 34.59924042224884,\n", + " (2060, 6): 15.79365336894989,\n", + " (2060, 7): 10.483021259307861,\n", + " (2060, 8): 13.718164086341858,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 10.335256934165955,\n", + " (2060, 11): 73.09085786342621,\n", + " (2060, 12): 280.1888357400894},\n", + " 'window': {(2060, 1): 61.67488098144531,\n", + " (2060, 2): 80.2793378829956,\n", + " (2060, 3): 44.61563777923584,\n", + " (2060, 4): 80.05251348018646,\n", + " (2060, 5): 12.88011384010315,\n", + " (2060, 6): 7.31502890586853,\n", + " (2060, 7): 3.3550719022750854,\n", + " (2060, 8): 9.802739143371582,\n", + " (2060, 9): 0.0,\n", + " (2060, 10): 6.887852907180786,\n", + " (2060, 11): 39.34543585777283,\n", + " (2060, 12): 127.39465713500977}},\n", + " 317: {'monthly': {(2060, 1): 323.76948142051697,\n", + " (2060, 2): 388.57100903987885,\n", + " (2060, 3): 374.77672719955444,\n", + " (2060, 4): 203.80471003055573,\n", + " (2060, 5): 36.620814085006714,\n", + " (2060, 6): 30.417839646339417,\n", + " (2060, 7): 19.68389141559601,\n", + " (2060, 8): 21.083872079849243,\n", + " (2060, 9): 10.379504799842834,\n", + " (2060, 10): 12.978933811187744,\n", + " (2060, 11): 126.31453514099121,\n", + " (2060, 12): 343.5784600973129},\n", + " 'window': {(2060, 1): 77.2700080871582,\n", + " (2060, 2): 111.37731075286865,\n", + " (2060, 3): 97.51545810699463,\n", + " (2060, 4): 113.90575313568115,\n", + " (2060, 5): 21.010846972465515,\n", + " (2060, 6): 12.847699165344238,\n", + " (2060, 7): 7.514625072479248,\n", + " (2060, 8): 16.8264479637146,\n", + " (2060, 9): 7.724217891693115,\n", + " (2060, 10): 11.68196153640747,\n", + " (2060, 11): 63.0115327835083,\n", + " (2060, 12): 147.3129940032959}},\n", + " 318: {'monthly': {(2060, 1): 361.10884714126587,\n", + " (2060, 2): 495.1886291503906,\n", + " (2060, 3): 486.4710006713867,\n", + " (2060, 4): 261.85610592365265,\n", + " (2060, 5): 38.07160186767578,\n", + " (2060, 6): 35.716832637786865,\n", + " (2060, 7): 18.858518719673157,\n", + " (2060, 8): 17.88309919834137,\n", + " (2060, 9): 9.602959752082825,\n", + " (2060, 10): 20.554896235466003,\n", + " (2060, 11): 145.39918220043182,\n", + " (2060, 12): 493.17704701423645},\n", + " 'window': {(2060, 1): 94.31044483184814,\n", + " (2060, 2): 156.71536445617676,\n", + " (2060, 3): 125.48072052001953,\n", + " (2060, 4): 154.84210300445557,\n", + " (2060, 5): 21.39246141910553,\n", + " (2060, 6): 16.12726664543152,\n", + " (2060, 7): 7.261463522911072,\n", + " (2060, 8): 15.335795283317566,\n", + " (2060, 9): 6.882046818733215,\n", + " (2060, 10): 14.404793500900269,\n", + " (2060, 11): 78.47064208984375,\n", + " (2060, 12): 229.49969863891602}},\n", + " 319: {'monthly': {(2060, 1): 414.6603744029999,\n", + " (2060, 2): 543.4001120328903,\n", + " (2060, 3): 611.299156665802,\n", + " (2060, 4): 370.06138849258423,\n", + " (2060, 5): 39.9959214925766,\n", + " (2060, 6): 43.53111910820007,\n", + " (2060, 7): 27.353806257247925,\n", + " (2060, 8): 24.21929395198822,\n", + " (2060, 9): 12.317183256149292,\n", + " (2060, 10): 24.542168974876404,\n", + " (2060, 11): 196.79199874401093,\n", + " (2060, 12): 573.713045835495},\n", + " 'window': {(2060, 1): 86.5131664276123,\n", + " (2060, 2): 181.28362655639648,\n", + " (2060, 3): 139.15266799926758,\n", + " (2060, 4): 195.57330131530762,\n", + " (2060, 5): 20.178810477256775,\n", + " (2060, 6): 16.35908079147339,\n", + " (2060, 7): 9.279421925544739,\n", + " (2060, 8): 14.987094163894653,\n", + " (2060, 9): 9.723015427589417,\n", + " (2060, 10): 13.9184410572052,\n", + " (2060, 11): 88.05908584594727,\n", + " (2060, 12): 218.2049903869629}},\n", + " 320: {'monthly': {(2060, 1): 447.5650408267975,\n", + " (2060, 2): 455.98753547668457,\n", + " (2060, 3): 484.0131165981293,\n", + " (2060, 4): 280.180123090744,\n", + " (2060, 5): 36.772677063941956,\n", + " (2060, 6): 37.084500789642334,\n", + " (2060, 7): 22.61902403831482,\n", + " (2060, 8): 18.78800368309021,\n", + " (2060, 9): 11.461910486221313,\n", + " (2060, 10): 11.462186694145203,\n", + " (2060, 11): 158.9477537870407,\n", + " (2060, 12): 420.6478387117386},\n", + " 'window': {(2060, 1): 102.83336925506592,\n", + " (2060, 2): 127.29962730407715,\n", + " (2060, 3): 94.38322639465332,\n", + " (2060, 4): 156.42361879348755,\n", + " (2060, 5): 13.80662488937378,\n", + " (2060, 6): 13.62432873249054,\n", + " (2060, 7): 7.936240196228027,\n", + " (2060, 8): 13.941397547721863,\n", + " (2060, 9): 7.3772953748703,\n", + " (2060, 10): 7.377317309379578,\n", + " (2060, 11): 71.12933731079102,\n", + " (2060, 12): 144.11049461364746}},\n", + " 321: {'monthly': {(2060, 1): 318.3745404481888,\n", + " (2060, 2): 336.4817819595337,\n", + " (2060, 3): 260.083132982254,\n", + " (2060, 4): 81.76292133331299,\n", + " (2060, 5): 18.456592202186584,\n", + " (2060, 6): 9.98252522945404,\n", + " (2060, 7): 14.849759936332703,\n", + " (2060, 8): 16.542168140411377,\n", + " (2060, 9): 6.62043821811676,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 69.37199795246124,\n", + " (2060, 12): 297.42467737197876},\n", + " 'window': {(2060, 1): 78.91654205322266,\n", + " (2060, 2): 88.24513816833496,\n", + " (2060, 3): 59.431867599487305,\n", + " (2060, 4): 39.61622476577759,\n", + " (2060, 5): 9.175816416740417,\n", + " (2060, 6): 4.241950869560242,\n", + " (2060, 7): 5.531574726104736,\n", + " (2060, 8): 8.57720959186554,\n", + " (2060, 9): 5.351680517196655,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 43.06766939163208,\n", + " (2060, 12): 77.0624008178711}},\n", + " 322: {'monthly': {(2060, 1): 257.52895998954773,\n", + " (2060, 2): 282.8089334964752,\n", + " (2060, 3): 225.6688847541809,\n", + " (2060, 4): 61.32001864910126,\n", + " (2060, 5): 6.969274163246155,\n", + " (2060, 6): 6.04094934463501,\n", + " (2060, 7): 7.010338664054871,\n", + " (2060, 8): 9.849279403686523,\n", + " (2060, 9): 8.343949675559998,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 53.74708008766174,\n", + " (2060, 12): 252.6119086742401},\n", + " 'window': {(2060, 1): 67.97977542877197,\n", + " (2060, 2): 76.89173030853271,\n", + " (2060, 3): 48.686495304107666,\n", + " (2060, 4): 38.77082395553589,\n", + " (2060, 5): 4.815142393112183,\n", + " (2060, 6): 3.5802167654037476,\n", + " (2060, 7): 3.5801315307617188,\n", + " (2060, 8): 8.550485253334045,\n", + " (2060, 9): 7.212766170501709,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 35.074363470077515,\n", + " (2060, 12): 67.75899505615234}},\n", + " 323: {'monthly': {(2060, 1): 250.84036302566528,\n", + " (2060, 2): 277.95685338974,\n", + " (2060, 3): 238.2347857952118,\n", + " (2060, 4): 76.9826432466507,\n", + " (2060, 5): 9.056820273399353,\n", + " (2060, 6): 7.632060647010803,\n", + " (2060, 7): 7.010338664054871,\n", + " (2060, 8): 9.822864413261414,\n", + " (2060, 9): 12.893023371696472,\n", + " (2060, 10): 1.0671669244766235,\n", + " (2060, 11): 53.39226758480072,\n", + " (2060, 12): 237.1059854030609},\n", + " 'window': {(2060, 1): 64.32609939575195,\n", + " (2060, 2): 83.9614953994751,\n", + " (2060, 3): 48.83942890167236,\n", + " (2060, 4): 44.42813730239868,\n", + " (2060, 5): 5.447580337524414,\n", + " (2060, 6): 5.122602105140686,\n", + " (2060, 7): 3.5801315307617188,\n", + " (2060, 8): 8.550485253334045,\n", + " (2060, 9): 11.55569076538086,\n", + " (2060, 10): 1.0671669244766235,\n", + " (2060, 11): 34.47470211982727,\n", + " (2060, 12): 64.99096202850342}},\n", + " 324: {'monthly': {(2060, 1): 261.2565141916275,\n", + " (2060, 2): 274.5338225364685,\n", + " (2060, 3): 216.11802637577057,\n", + " (2060, 4): 65.4229542016983,\n", + " (2060, 5): 7.334280490875244,\n", + " (2060, 6): 6.930915355682373,\n", + " (2060, 7): 7.010338664054871,\n", + " (2060, 8): 9.822864413261414,\n", + " (2060, 9): 14.61353862285614,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 50.72331213951111,\n", + " (2060, 12): 207.98114264011383},\n", + " 'window': {(2060, 1): 64.53420829772949,\n", + " (2060, 2): 85.45580101013184,\n", + " (2060, 3): 45.63752841949463,\n", + " (2060, 4): 39.9321346282959,\n", + " (2060, 5): 5.027302265167236,\n", + " (2060, 6): 4.470182776451111,\n", + " (2060, 7): 3.5801315307617188,\n", + " (2060, 8): 8.550485253334045,\n", + " (2060, 9): 13.482355117797852,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 32.33515214920044,\n", + " (2060, 12): 65.45744514465332}},\n", + " 325: {'monthly': {(2060, 1): 204.06694984436035,\n", + " (2060, 2): 240.01872885227203,\n", + " (2060, 3): 249.32794606685638,\n", + " (2060, 4): 73.47641050815582,\n", + " (2060, 5): 1.1718651056289673,\n", + " (2060, 6): 1.522081732749939,\n", + " (2060, 7): 3.6192963123321533,\n", + " (2060, 8): 4.0284528732299805,\n", + " (2060, 9): 1.0813854932785034,\n", + " (2060, 10): 4.884735584259033,\n", + " (2060, 11): 36.5224426984787,\n", + " (2060, 12): 209.9024921655655},\n", + " 'window': {(2060, 1): 50.90989923477173,\n", + " (2060, 2): 81.84484052658081,\n", + " (2060, 3): 82.97240447998047,\n", + " (2060, 4): 42.52574348449707,\n", + " (2060, 5): 1.1718651056289673,\n", + " (2060, 6): 1.522081732749939,\n", + " (2060, 7): 2.2391775846481323,\n", + " (2060, 8): 4.0284528732299805,\n", + " (2060, 9): 1.0813854932785034,\n", + " (2060, 10): 4.884735584259033,\n", + " (2060, 11): 20.221129775047302,\n", + " (2060, 12): 81.39108943939209}},\n", + " 326: {'monthly': {(2060, 1): 239.92245745658875,\n", + " (2060, 2): 250.52308583259583,\n", + " (2060, 3): 278.4651598930359,\n", + " (2060, 4): 78.76438999176025,\n", + " (2060, 5): 2.621748685836792,\n", + " (2060, 6): 2.718304991722107,\n", + " (2060, 7): 4.785010933876038,\n", + " (2060, 8): 9.910064220428467,\n", + " (2060, 9): 1.0253710746765137,\n", + " (2060, 10): 5.807175278663635,\n", + " (2060, 11): 99.55683600902557,\n", + " (2060, 12): 258.1148302555084},\n", + " 'window': {(2060, 1): 57.91945552825928,\n", + " (2060, 2): 62.72000694274902,\n", + " (2060, 3): 66.04140567779541,\n", + " (2060, 4): 34.63269591331482,\n", + " (2060, 5): 1.61881422996521,\n", + " (2060, 6): 1.6488581895828247,\n", + " (2060, 7): 2.56003201007843,\n", + " (2060, 8): 6.730392694473267,\n", + " (2060, 9): 1.0253710746765137,\n", + " (2060, 10): 3.5159581899642944,\n", + " (2060, 11): 55.48629713058472,\n", + " (2060, 12): 66.44921016693115}},\n", + " 327: {'monthly': {(2060, 1): 230.52750062942505,\n", + " (2060, 2): 330.4089665412903,\n", + " (2060, 3): 330.5433895587921,\n", + " (2060, 4): 100.26279437541962,\n", + " (2060, 5): 3.7861801385879517,\n", + " (2060, 6): 2.718304991722107,\n", + " (2060, 7): 4.785010933876038,\n", + " (2060, 8): 9.606390476226807,\n", + " (2060, 9): 2.1960357427597046,\n", + " (2060, 10): 3.33668053150177,\n", + " (2060, 11): 92.68077671527863,\n", + " (2060, 12): 279.06420052051544},\n", + " 'window': {(2060, 1): 49.91779708862305,\n", + " (2060, 2): 92.54422664642334,\n", + " (2060, 3): 80.53018856048584,\n", + " (2060, 4): 51.53351831436157,\n", + " (2060, 5): 1.61881422996521,\n", + " (2060, 6): 1.6488581895828247,\n", + " (2060, 7): 2.56003201007843,\n", + " (2060, 8): 6.4267189502716064,\n", + " (2060, 9): 2.1960357427597046,\n", + " (2060, 10): 2.326836347579956,\n", + " (2060, 11): 52.5392861366272,\n", + " (2060, 12): 86.54827785491943}},\n", + " 328: {'monthly': {(2060, 1): 261.81486082077026,\n", + " (2060, 2): 467.42894995212555,\n", + " (2060, 3): 410.07945013046265,\n", + " (2060, 4): 118.74841129779816,\n", + " (2060, 5): 2.621748685836792,\n", + " (2060, 6): 3.364638328552246,\n", + " (2060, 7): 4.785010933876038,\n", + " (2060, 8): 9.428947806358337,\n", + " (2060, 9): 2.3461174964904785,\n", + " (2060, 10): 3.8417261838912964,\n", + " (2060, 11): 92.99109256267548,\n", + " (2060, 12): 346.28338384628296},\n", + " 'window': {(2060, 1): 55.14768886566162,\n", + " (2060, 2): 146.82424354553223,\n", + " (2060, 3): 129.0033187866211,\n", + " (2060, 4): 68.72570705413818,\n", + " (2060, 5): 1.61881422996521,\n", + " (2060, 6): 2.295191526412964,\n", + " (2060, 7): 2.56003201007843,\n", + " (2060, 8): 6.249276280403137,\n", + " (2060, 9): 2.3461174964904785,\n", + " (2060, 10): 2.8318819999694824,\n", + " (2060, 11): 49.815393924713135,\n", + " (2060, 12): 128.3949155807495}},\n", + " 329: {'monthly': {(2060, 1): 346.5860562324524,\n", + " (2060, 2): 512.2330849170685,\n", + " (2060, 3): 453.5737929344177,\n", + " (2060, 4): 129.885679602623,\n", + " (2060, 5): 14.622605443000793,\n", + " (2060, 6): 4.06402850151062,\n", + " (2060, 7): 9.399706244468689,\n", + " (2060, 8): 14.503178358078003,\n", + " (2060, 9): 4.37141478061676,\n", + " (2060, 10): 14.643278241157532,\n", + " (2060, 11): 98.85794293880463,\n", + " (2060, 12): 404.11642158031464},\n", + " 'window': {(2060, 1): 83.61321258544922,\n", + " (2060, 2): 152.2334327697754,\n", + " (2060, 3): 141.650484085083,\n", + " (2060, 4): 67.41584539413452,\n", + " (2060, 5): 7.5846110582351685,\n", + " (2060, 6): 1.546673059463501,\n", + " (2060, 7): 3.3970965147018433,\n", + " (2060, 8): 8.96994423866272,\n", + " (2060, 9): 2.403505563735962,\n", + " (2060, 10): 6.184636354446411,\n", + " (2060, 11): 50.86743116378784,\n", + " (2060, 12): 139.36726474761963}},\n", + " 330: {'monthly': {(2060, 1): 409.1156177520752,\n", + " (2060, 2): 461.80810129642487,\n", + " (2060, 3): 466.9783866405487,\n", + " (2060, 4): 180.76808202266693,\n", + " (2060, 5): 25.597835183143616,\n", + " (2060, 6): 26.483270287513733,\n", + " (2060, 7): 17.64481222629547,\n", + " (2060, 8): 21.699496388435364,\n", + " (2060, 9): 6.142277479171753,\n", + " (2060, 10): 12.709834814071655,\n", + " (2060, 11): 118.11068546772003,\n", + " (2060, 12): 462.3707537651062},\n", + " 'window': {(2060, 1): 90.0973572731018,\n", + " (2060, 2): 116.8556957244873,\n", + " (2060, 3): 115.18067169189453,\n", + " (2060, 4): 90.97726273536682,\n", + " (2060, 5): 14.416706085205078,\n", + " (2060, 6): 11.238561987876892,\n", + " (2060, 7): 6.940089225769043,\n", + " (2060, 8): 15.60996425151825,\n", + " (2060, 9): 6.142277479171753,\n", + " (2060, 10): 8.914602279663086,\n", + " (2060, 11): 58.7033166885376,\n", + " (2060, 12): 188.50382041931152}},\n", + " 331: {'monthly': {(2060, 1): 313.1787374019623,\n", + " (2060, 2): 517.4224714040756,\n", + " (2060, 3): 604.8676421642303,\n", + " (2060, 4): 249.03461027145386,\n", + " (2060, 5): 31.402528524398804,\n", + " (2060, 6): 28.944404363632202,\n", + " (2060, 7): 19.14192545413971,\n", + " (2060, 8): 28.09856867790222,\n", + " (2060, 9): 7.833306193351746,\n", + " (2060, 10): 7.014308929443359,\n", + " (2060, 11): 135.14713084697723,\n", + " (2060, 12): 405.1510201692581},\n", + " 'window': {(2060, 1): 78.95142078399658,\n", + " (2060, 2): 135.93392658233643,\n", + " (2060, 3): 169.5727882385254,\n", + " (2060, 4): 131.98358631134033,\n", + " (2060, 5): 18.35032033920288,\n", + " (2060, 6): 10.81991183757782,\n", + " (2060, 7): 7.524036288261414,\n", + " (2060, 8): 16.6131854057312,\n", + " (2060, 9): 6.770453095436096,\n", + " (2060, 10): 4.851834774017334,\n", + " (2060, 11): 80.72745943069458,\n", + " (2060, 12): 155.74342155456543}},\n", + " 332: {'monthly': {(2060, 1): 345.6642884016037,\n", + " (2060, 2): 683.9787583351135,\n", + " (2060, 3): 796.3106722831726,\n", + " (2060, 4): 352.48460125923157,\n", + " (2060, 5): 53.93716096878052,\n", + " (2060, 6): 40.95262956619263,\n", + " (2060, 7): 33.82294416427612,\n", + " (2060, 8): 35.13508653640747,\n", + " (2060, 9): 27.83629024028778,\n", + " (2060, 10): 18.67145800590515,\n", + " (2060, 11): 238.70536398887634,\n", + " (2060, 12): 531.365382194519},\n", + " 'window': {(2060, 1): 92.33676624298096,\n", + " (2060, 2): 195.34413719177246,\n", + " (2060, 3): 192.51289558410645,\n", + " (2060, 4): 167.4296236038208,\n", + " (2060, 5): 24.86332654953003,\n", + " (2060, 6): 14.235512018203735,\n", + " (2060, 7): 11.547027468681335,\n", + " (2060, 8): 17.871357679367065,\n", + " (2060, 9): 16.01571774482727,\n", + " (2060, 10): 9.197280645370483,\n", + " (2060, 11): 134.46505451202393,\n", + " (2060, 12): 209.33059787750244}},\n", + " 333: {'monthly': {(2060, 1): 327.15588426589966,\n", + " (2060, 2): 470.0541898012161,\n", + " (2060, 3): 515.0862054824829,\n", + " (2060, 4): 221.25350546836853,\n", + " (2060, 5): 21.969499707221985,\n", + " (2060, 6): 17.763790011405945,\n", + " (2060, 7): 15.249377250671387,\n", + " (2060, 8): 21.167276859283447,\n", + " (2060, 9): 8.722000122070312,\n", + " (2060, 10): 9.812302350997925,\n", + " (2060, 11): 155.4708821773529,\n", + " (2060, 12): 427.7384841442108},\n", + " 'window': {(2060, 1): 70.78561401367188,\n", + " (2060, 2): 129.68968677520752,\n", + " (2060, 3): 119.34992790222168,\n", + " (2060, 4): 109.39538383483887,\n", + " (2060, 5): 12.388228178024292,\n", + " (2060, 6): 7.695016026496887,\n", + " (2060, 7): 5.818512678146362,\n", + " (2060, 8): 13.009060382843018,\n", + " (2060, 9): 7.660650968551636,\n", + " (2060, 10): 5.06686794757843,\n", + " (2060, 11): 87.7480640411377,\n", + " (2060, 12): 150.92417240142822}},\n", + " 334: {'monthly': {(2060, 1): 289.04424476623535,\n", + " (2060, 2): 294.56524658203125,\n", + " (2060, 3): 268.7170696258545,\n", + " (2060, 4): 73.80542397499084,\n", + " (2060, 5): 6.809992551803589,\n", + " (2060, 6): 3.136237859725952,\n", + " (2060, 7): 6.136355638504028,\n", + " (2060, 8): 7.928725719451904,\n", + " (2060, 9): 4.012435793876648,\n", + " (2060, 10): 2.854219079017639,\n", + " (2060, 11): 68.00390338897705,\n", + " (2060, 12): 230.82492351531982},\n", + " 'window': {(2060, 1): 73.02273273468018,\n", + " (2060, 2): 71.00387001037598,\n", + " (2060, 3): 55.70867681503296,\n", + " (2060, 4): 31.23416495323181,\n", + " (2060, 5): 2.8258938789367676,\n", + " (2060, 6): 1.7710520029067993,\n", + " (2060, 7): 3.304356336593628,\n", + " (2060, 8): 6.652172565460205,\n", + " (2060, 9): 4.012435793876648,\n", + " (2060, 10): 1.6034822463989258,\n", + " (2060, 11): 49.781275272369385,\n", + " (2060, 12): 71.35575485229492}},\n", + " 335: {'monthly': {(2060, 1): 246.25443410873413,\n", + " (2060, 2): 274.3319265842438,\n", + " (2060, 3): 256.34422850608826,\n", + " (2060, 4): 68.63920640945435,\n", + " (2060, 5): 5.948955774307251,\n", + " (2060, 6): 3.2573732137680054,\n", + " (2060, 7): 6.136355638504028,\n", + " (2060, 8): 7.979179382324219,\n", + " (2060, 9): 6.017698287963867,\n", + " (2060, 10): 1.0318509340286255,\n", + " (2060, 11): 59.43894445896149,\n", + " (2060, 12): 240.88771796226501},\n", + " 'window': {(2060, 1): 66.13899230957031,\n", + " (2060, 2): 68.36352252960205,\n", + " (2060, 3): 51.35929203033447,\n", + " (2060, 4): 31.865230083465576,\n", + " (2060, 5): 2.5017313957214355,\n", + " (2060, 6): 1.8921873569488525,\n", + " (2060, 7): 3.304356336593628,\n", + " (2060, 8): 6.652172565460205,\n", + " (2060, 9): 4.96204936504364,\n", + " (2060, 10): 1.0318509340286255,\n", + " (2060, 11): 45.646907806396484,\n", + " (2060, 12): 76.75045585632324}},\n", + " 336: {'monthly': {(2060, 1): 238.73774552345276,\n", + " (2060, 2): 286.8435094356537,\n", + " (2060, 3): 260.4265646934509,\n", + " (2060, 4): 82.80564987659454,\n", + " (2060, 5): 6.472376704216003,\n", + " (2060, 6): 4.322830319404602,\n", + " (2060, 7): 8.550599813461304,\n", + " (2060, 8): 8.1443589925766,\n", + " (2060, 9): 7.461447358131409,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 59.57136332988739,\n", + " (2060, 12): 266.36584091186523},\n", + " 'window': {(2060, 1): 64.12857437133789,\n", + " (2060, 2): 69.62133312225342,\n", + " (2060, 3): 51.792179107666016,\n", + " (2060, 4): 43.736928939819336,\n", + " (2060, 5): 2.689188241958618,\n", + " (2060, 6): 2.957644462585449,\n", + " (2060, 7): 4.475854754447937,\n", + " (2060, 8): 6.652172565460205,\n", + " (2060, 9): 7.461447358131409,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 47.7737398147583,\n", + " (2060, 12): 84.74117088317871}},\n", + " 337: {'monthly': {(2060, 1): 199.68462228775024,\n", + " (2060, 2): 274.7426315546036,\n", + " (2060, 3): 214.5858039855957,\n", + " (2060, 4): 80.36691224575043,\n", + " (2060, 5): 6.914445877075195,\n", + " (2060, 6): 4.108893990516663,\n", + " (2060, 7): 6.136355638504028,\n", + " (2060, 8): 7.928725719451904,\n", + " (2060, 9): 8.192137837409973,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 54.13109624385834,\n", + " (2060, 12): 242.082324385643},\n", + " 'window': {(2060, 1): 59.648988246917725,\n", + " (2060, 2): 86.2151288986206,\n", + " (2060, 3): 42.09515047073364,\n", + " (2060, 4): 52.24559211730957,\n", + " (2060, 5): 3.6492840051651,\n", + " (2060, 6): 2.7437081336975098,\n", + " (2060, 7): 3.304356336593628,\n", + " (2060, 8): 6.652172565460205,\n", + " (2060, 9): 8.192137837409973,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 43.532368659973145,\n", + " (2060, 12): 89.1660041809082}},\n", + " 338: {'monthly': {(2060, 1): 196.6614979505539,\n", + " (2060, 2): 243.6486999988556,\n", + " (2060, 3): 247.80265390872955,\n", + " (2060, 4): 76.94487118721008,\n", + " (2060, 5): 1.1718651056289673,\n", + " (2060, 6): 4.499007344245911,\n", + " (2060, 7): 3.6192963123321533,\n", + " (2060, 8): 4.0284528732299805,\n", + " (2060, 9): 1.0813854932785034,\n", + " (2060, 10): 6.018144965171814,\n", + " (2060, 11): 42.610841274261475,\n", + " (2060, 12): 204.6569401025772},\n", + " 'window': {(2060, 1): 41.948808431625366,\n", + " (2060, 2): 76.2960901260376,\n", + " (2060, 3): 73.76784038543701,\n", + " (2060, 4): 40.44823503494263,\n", + " (2060, 5): 1.1718651056289673,\n", + " (2060, 6): 3.102579951286316,\n", + " (2060, 7): 2.2391775846481323,\n", + " (2060, 8): 4.0284528732299805,\n", + " (2060, 9): 1.0813854932785034,\n", + " (2060, 10): 4.854893684387207,\n", + " (2060, 11): 21.923693895339966,\n", + " (2060, 12): 71.19762134552002}},\n", + " 339: {'monthly': {(2060, 1): 236.07335948944092,\n", + " (2060, 2): 248.09150457382202,\n", + " (2060, 3): 320.25356137752533,\n", + " (2060, 4): 123.82892417907715,\n", + " (2060, 5): 5.7799025774002075,\n", + " (2060, 6): 3.718465805053711,\n", + " (2060, 7): 4.785010933876038,\n", + " (2060, 8): 10.006234765052795,\n", + " (2060, 9): 1.0253710746765137,\n", + " (2060, 10): 4.712992906570435,\n", + " (2060, 11): 106.8265733718872,\n", + " (2060, 12): 283.2943550348282},\n", + " 'window': {(2060, 1): 60.173171520233154,\n", + " (2060, 2): 73.41222906112671,\n", + " (2060, 3): 72.81140804290771,\n", + " (2060, 4): 50.34809160232544,\n", + " (2060, 5): 1.6331837177276611,\n", + " (2060, 6): 2.6490190029144287,\n", + " (2060, 7): 2.56003201007843,\n", + " (2060, 8): 6.826563239097595,\n", + " (2060, 9): 1.0253710746765137,\n", + " (2060, 10): 3.7031487226486206,\n", + " (2060, 11): 55.09556865692139,\n", + " (2060, 12): 78.98067951202393}},\n", + " 340: {'monthly': {(2060, 1): 252.75798559188843,\n", + " (2060, 2): 416.01734805107117,\n", + " (2060, 3): 430.0748291015625,\n", + " (2060, 4): 147.02836978435516,\n", + " (2060, 5): 5.236335754394531,\n", + " (2060, 6): 4.39518404006958,\n", + " (2060, 7): 4.785010933876038,\n", + " (2060, 8): 9.668643951416016,\n", + " (2060, 9): 2.171023726463318,\n", + " (2060, 10): 5.650490164756775,\n", + " (2060, 11): 101.91759812831879,\n", + " (2060, 12): 335.6700849533081},\n", + " 'window': {(2060, 1): 56.080939292907715,\n", + " (2060, 2): 119.72209548950195,\n", + " (2060, 3): 121.42315101623535,\n", + " (2060, 4): 74.02804350852966,\n", + " (2060, 5): 2.9314340353012085,\n", + " (2060, 6): 2.018141508102417,\n", + " (2060, 7): 2.56003201007843,\n", + " (2060, 8): 6.488972425460815,\n", + " (2060, 9): 2.171023726463318,\n", + " (2060, 10): 3.390233635902405,\n", + " (2060, 11): 46.71034288406372,\n", + " (2060, 12): 120.82652187347412}},\n", + " 341: {'monthly': {(2060, 1): 355.86118364334106,\n", + " (2060, 2): 786.2856066226959,\n", + " (2060, 3): 697.528959274292,\n", + " (2060, 4): 219.775524020195,\n", + " (2060, 5): 8.067979574203491,\n", + " (2060, 6): 3.3074634075164795,\n", + " (2060, 7): 7.0876030921936035,\n", + " (2060, 8): 10.791634559631348,\n", + " (2060, 9): 2.9865834712982178,\n", + " (2060, 10): 8.059059739112854,\n", + " (2060, 11): 110.28496706485748,\n", + " (2060, 12): 538.8304561376572},\n", + " 'window': {(2060, 1): 85.89471435546875,\n", + " (2060, 2): 234.66506385803223,\n", + " (2060, 3): 287.06797790527344,\n", + " (2060, 4): 141.66243243217468,\n", + " (2060, 5): 3.0978310108184814,\n", + " (2060, 6): 1.1079045534133911,\n", + " (2060, 7): 3.775046467781067,\n", + " (2060, 8): 7.2404985427856445,\n", + " (2060, 9): 2.9865834712982178,\n", + " (2060, 10): 3.650738835334778,\n", + " (2060, 11): 51.986403942108154,\n", + " (2060, 12): 246.6108808517456}},\n", + " 342: {'monthly': {(2060, 1): 466.0975613594055,\n", + " (2060, 2): 846.9576933383942,\n", + " (2060, 3): 724.6536550521851,\n", + " (2060, 4): 214.8248815536499,\n", + " (2060, 5): 11.467145800590515,\n", + " (2060, 6): 11.990765810012817,\n", + " (2060, 7): 9.723935723304749,\n", + " (2060, 8): 16.645569801330566,\n", + " (2060, 9): 3.1247708797454834,\n", + " (2060, 10): 12.058597445487976,\n", + " (2060, 11): 107.39870691299438,\n", + " (2060, 12): 575.9961448907852},\n", + " 'window': {(2060, 1): 106.63678550720215,\n", + " (2060, 2): 234.47161674499512,\n", + " (2060, 3): 290.09761810302734,\n", + " (2060, 4): 131.5552260875702,\n", + " (2060, 5): 5.89457631111145,\n", + " (2060, 6): 5.286166071891785,\n", + " (2060, 7): 2.712918281555176,\n", + " (2060, 8): 10.308837056159973,\n", + " (2060, 9): 3.1247708797454834,\n", + " (2060, 10): 6.746284365653992,\n", + " (2060, 11): 54.66837024688721,\n", + " (2060, 12): 248.2869997024536}},\n", + " 343: {'monthly': {(2060, 1): 450.8669788837433,\n", + " (2060, 2): 592.7310566902161,\n", + " (2060, 3): 510.27507877349854,\n", + " (2060, 4): 153.8138850927353,\n", + " (2060, 5): 22.477348685264587,\n", + " (2060, 6): 24.410553812980652,\n", + " (2060, 7): 15.35745656490326,\n", + " (2060, 8): 20.038983464241028,\n", + " (2060, 9): 3.4818226099014282,\n", + " (2060, 10): 9.962348461151123,\n", + " (2060, 11): 100.51250064373016,\n", + " (2060, 12): 447.8894225358963},\n", + " 'window': {(2060, 1): 92.38302803039551,\n", + " (2060, 2): 196.21366786956787,\n", + " (2060, 3): 102.4187364578247,\n", + " (2060, 4): 68.31791543960571,\n", + " (2060, 5): 10.469895362854004,\n", + " (2060, 6): 10.335931658744812,\n", + " (2060, 7): 6.449223041534424,\n", + " (2060, 8): 13.583222389221191,\n", + " (2060, 9): 3.4818226099014282,\n", + " (2060, 10): 7.876975059509277,\n", + " (2060, 11): 47.35104465484619,\n", + " (2060, 12): 162.48946380615234}},\n", + " 344: {'monthly': {(2060, 1): 237.12140882015228,\n", + " (2060, 2): 501.2726094722748,\n", + " (2060, 3): 515.3474974632263,\n", + " (2060, 4): 198.8787318468094,\n", + " (2060, 5): 24.92254626750946,\n", + " (2060, 6): 24.613888144493103,\n", + " (2060, 7): 18.883243918418884,\n", + " (2060, 8): 20.845913887023926,\n", + " (2060, 9): 6.02359664440155,\n", + " (2060, 10): 5.0641255378723145,\n", + " (2060, 11): 99.56899666786194,\n", + " (2060, 12): 319.08381152153015},\n", + " 'window': {(2060, 1): 55.59299182891846,\n", + " (2060, 2): 139.58880043029785,\n", + " (2060, 3): 129.98376083374023,\n", + " (2060, 4): 97.98012375831604,\n", + " (2060, 5): 13.354044198989868,\n", + " (2060, 6): 10.044302225112915,\n", + " (2060, 7): 7.165194869041443,\n", + " (2060, 8): 15.240394234657288,\n", + " (2060, 9): 6.02359664440155,\n", + " (2060, 10): 4.024730443954468,\n", + " (2060, 11): 55.72497606277466,\n", + " (2060, 12): 126.46408271789551}},\n", + " 345: {'monthly': {(2060, 1): 259.2843728065491,\n", + " (2060, 2): 567.5823719501495,\n", + " (2060, 3): 607.22043800354,\n", + " (2060, 4): 272.8128105401993,\n", + " (2060, 5): 43.36185157299042,\n", + " (2060, 6): 42.97807991504669,\n", + " (2060, 7): 29.43623638153076,\n", + " (2060, 8): 41.81048560142517,\n", + " (2060, 9): 14.639759182929993,\n", + " (2060, 10): 11.362563729286194,\n", + " (2060, 11): 161.5791016817093,\n", + " (2060, 12): 392.10189151763916},\n", + " 'window': {(2060, 1): 62.184505462646484,\n", + " (2060, 2): 153.79089164733887,\n", + " (2060, 3): 153.3303565979004,\n", + " (2060, 4): 115.34127044677734,\n", + " (2060, 5): 18.21294069290161,\n", + " (2060, 6): 13.205578923225403,\n", + " (2060, 7): 11.902432799339294,\n", + " (2060, 8): 24.067588686943054,\n", + " (2060, 9): 9.210487127304077,\n", + " (2060, 10): 7.546357274055481,\n", + " (2060, 11): 83.39533567428589,\n", + " (2060, 12): 156.66726303100586}},\n", + " 346: {'monthly': {(2060, 1): 215.94798839092255,\n", + " (2060, 2): 357.53733372688293,\n", + " (2060, 3): 370.85581254959106,\n", + " (2060, 4): 152.21030807495117,\n", + " (2060, 5): 19.615840911865234,\n", + " (2060, 6): 16.128671169281006,\n", + " (2060, 7): 11.19538962841034,\n", + " (2060, 8): 17.8241468667984,\n", + " (2060, 9): 3.720525026321411,\n", + " (2060, 10): 5.8543795347213745,\n", + " (2060, 11): 104.3204197883606,\n", + " (2060, 12): 299.6629407405853},\n", + " 'window': {(2060, 1): 52.95824480056763,\n", + " (2060, 2): 99.89531326293945,\n", + " (2060, 3): 92.64968776702881,\n", + " (2060, 4): 67.06588411331177,\n", + " (2060, 5): 10.687390446662903,\n", + " (2060, 6): 5.663832783699036,\n", + " (2060, 7): 4.606552720069885,\n", + " (2060, 8): 13.057415962219238,\n", + " (2060, 9): 3.720525026321411,\n", + " (2060, 10): 3.7438268661499023,\n", + " (2060, 11): 53.77382564544678,\n", + " (2060, 12): 106.7774019241333}},\n", + " 347: {'monthly': {(2060, 1): 203.14503943920135,\n", + " (2060, 2): 248.66547775268555,\n", + " (2060, 3): 255.84123826026917,\n", + " (2060, 4): 67.45600020885468,\n", + " (2060, 5): 6.122791171073914,\n", + " (2060, 6): 3.173011302947998,\n", + " (2060, 7): 6.136355638504028,\n", + " (2060, 8): 7.993001341819763,\n", + " (2060, 9): 4.0907673835754395,\n", + " (2060, 10): 1.8497676849365234,\n", + " (2060, 11): 55.23644685745239,\n", + " (2060, 12): 189.13391613960266},\n", + " 'window': {(2060, 1): 59.824031829833984,\n", + " (2060, 2): 65.13785076141357,\n", + " (2060, 3): 49.42529058456421,\n", + " (2060, 4): 29.151182413101196,\n", + " (2060, 5): 2.560256838798523,\n", + " (2060, 6): 1.8078254461288452,\n", + " (2060, 7): 3.304356336593628,\n", + " (2060, 8): 6.652172565460205,\n", + " (2060, 9): 4.0907673835754395,\n", + " (2060, 10): 1.8497676849365234,\n", + " (2060, 11): 43.617690563201904,\n", + " (2060, 12): 62.79994010925293}},\n", + " 348: {'monthly': {(2060, 1): 202.58319699764252,\n", + " (2060, 2): 269.18113362789154,\n", + " (2060, 3): 291.4840512275696,\n", + " (2060, 4): 76.81268548965454,\n", + " (2060, 5): 6.5208083391189575,\n", + " (2060, 6): 3.521318554878235,\n", + " (2060, 7): 6.136355638504028,\n", + " (2060, 8): 7.928725719451904,\n", + " (2060, 9): 4.858142733573914,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 59.68911921977997,\n", + " (2060, 12): 222.94053745269775},\n", + " 'window': {(2060, 1): 57.35749435424805,\n", + " (2060, 2): 69.11109828948975,\n", + " (2060, 3): 56.121110916137695,\n", + " (2060, 4): 33.28881859779358,\n", + " (2060, 5): 2.698847770690918,\n", + " (2060, 6): 2.156132698059082,\n", + " (2060, 7): 3.304356336593628,\n", + " (2060, 8): 6.652172565460205,\n", + " (2060, 9): 4.858142733573914,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 46.997836112976074,\n", + " (2060, 12): 71.75605392456055}},\n", + " 349: {'monthly': {(2060, 1): 194.59171307086945,\n", + " (2060, 2): 288.0841221809387,\n", + " (2060, 3): 273.24060583114624,\n", + " (2060, 4): 81.0579879283905,\n", + " (2060, 5): 7.397412061691284,\n", + " (2060, 6): 4.192243456840515,\n", + " (2060, 7): 7.506986737251282,\n", + " (2060, 8): 8.329573154449463,\n", + " (2060, 9): 5.863115191459656,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 57.833771109580994,\n", + " (2060, 12): 234.10630095005035},\n", + " 'window': {(2060, 1): 51.253068923950195,\n", + " (2060, 2): 77.76940774917603,\n", + " (2060, 3): 54.29460525512695,\n", + " (2060, 4): 41.77508044242859,\n", + " (2060, 5): 3.536524534225464,\n", + " (2060, 6): 2.8270576000213623,\n", + " (2060, 7): 4.322759985923767,\n", + " (2060, 8): 6.652172565460205,\n", + " (2060, 9): 5.863115191459656,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 46.381587505340576,\n", + " (2060, 12): 81.44210147857666}},\n", + " 350: {'monthly': {(2060, 1): 169.8663945198059,\n", + " (2060, 2): 277.88165390491486,\n", + " (2060, 3): 213.0350775718689,\n", + " (2060, 4): 78.07126879692078,\n", + " (2060, 5): 7.341100096702576,\n", + " (2060, 6): 3.982678174972534,\n", + " (2060, 7): 7.271059513092041,\n", + " (2060, 8): 7.934629559516907,\n", + " (2060, 9): 5.836790919303894,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 51.90357720851898,\n", + " (2060, 12): 209.56952321529388},\n", + " 'window': {(2060, 1): 56.91520023345947,\n", + " (2060, 2): 84.68766212463379,\n", + " (2060, 3): 40.44032573699951,\n", + " (2060, 4): 48.723527669906616,\n", + " (2060, 5): 3.4409881830215454,\n", + " (2060, 6): 2.4926552772521973,\n", + " (2060, 7): 3.304356336593628,\n", + " (2060, 8): 6.6580764055252075,\n", + " (2060, 9): 5.836790919303894,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 41.807677268981934,\n", + " (2060, 12): 84.38853454589844}},\n", + " 351: {'monthly': {(2060, 1): 182.6605886220932,\n", + " (2060, 2): 235.39930772781372,\n", + " (2060, 3): 220.55295062065125,\n", + " (2060, 4): 74.0026763677597,\n", + " (2060, 5): 3.352949023246765,\n", + " (2060, 6): 0.0,\n", + " (2060, 7): 3.6192963123321533,\n", + " (2060, 8): 4.0284528732299805,\n", + " (2060, 9): 1.0813854932785034,\n", + " (2060, 10): 5.405711650848389,\n", + " (2060, 11): 43.98092496395111,\n", + " (2060, 12): 182.06399619579315},\n", + " 'window': {(2060, 1): 41.41898822784424,\n", + " (2060, 2): 68.76912879943848,\n", + " (2060, 3): 60.22817087173462,\n", + " (2060, 4): 33.764031410217285,\n", + " (2060, 5): 3.352949023246765,\n", + " (2060, 6): 0.0,\n", + " (2060, 7): 2.2391775846481323,\n", + " (2060, 8): 4.0284528732299805,\n", + " (2060, 9): 1.0813854932785034,\n", + " (2060, 10): 5.405711650848389,\n", + " (2060, 11): 23.061594486236572,\n", + " (2060, 12): 59.17633390426636}},\n", + " 352: {'monthly': {(2060, 1): 219.07606959342957,\n", + " (2060, 2): 248.95531487464905,\n", + " (2060, 3): 322.9546446800232,\n", + " (2060, 4): 122.6921056509018,\n", + " (2060, 5): 6.77974534034729,\n", + " (2060, 6): 2.5416990518569946,\n", + " (2060, 7): 4.785010933876038,\n", + " (2060, 8): 11.718188881874084,\n", + " (2060, 9): 1.0253710746765137,\n", + " (2060, 10): 5.362150192260742,\n", + " (2060, 11): 105.21905541419983,\n", + " (2060, 12): 257.1291016340256},\n", + " 'window': {(2060, 1): 47.29774618148804,\n", + " (2060, 2): 69.13233995437622,\n", + " (2060, 3): 73.18449020385742,\n", + " (2060, 4): 48.42260432243347,\n", + " (2060, 5): 2.8975894451141357,\n", + " (2060, 6): 1.4722522497177124,\n", + " (2060, 7): 2.56003201007843,\n", + " (2060, 8): 8.538517355918884,\n", + " (2060, 9): 1.0253710746765137,\n", + " (2060, 10): 3.0983375310897827,\n", + " (2060, 11): 53.629202365875244,\n", + " (2060, 12): 83.33568572998047}},\n", + " 353: {'monthly': {(2060, 1): 245.62861275672913,\n", + " (2060, 2): 351.1972134113312,\n", + " (2060, 3): 385.06077241897583,\n", + " (2060, 4): 130.98281276226044,\n", + " (2060, 5): 6.163888692855835,\n", + " (2060, 6): 5.295844554901123,\n", + " (2060, 7): 4.785010933876038,\n", + " (2060, 8): 15.384746551513672,\n", + " (2060, 9): 1.0253710746765137,\n", + " (2060, 10): 4.535965442657471,\n", + " (2060, 11): 99.38018023967743,\n", + " (2060, 12): 299.62617897987366},\n", + " 'window': {(2060, 1): 51.707051277160645,\n", + " (2060, 2): 96.54552745819092,\n", + " (2060, 3): 110.60523509979248,\n", + " (2060, 4): 58.81190752983093,\n", + " (2060, 5): 3.077075481414795,\n", + " (2060, 6): 2.7023699283599854,\n", + " (2060, 7): 2.56003201007843,\n", + " (2060, 8): 11.659184575080872,\n", + " (2060, 9): 1.0253710746765137,\n", + " (2060, 10): 3.5261212587356567,\n", + " (2060, 11): 50.10359048843384,\n", + " (2060, 12): 107.21811103820801}},\n", + " 354: {'monthly': {(2060, 1): 288.39294970035553,\n", + " (2060, 2): 581.0870609283447,\n", + " (2060, 3): 542.3800930976868,\n", + " (2060, 4): 190.96818280220032,\n", + " (2060, 5): 11.009727120399475,\n", + " (2060, 6): 2.0784695148468018,\n", + " (2060, 7): 4.840107560157776,\n", + " (2060, 8): 15.439595580101013,\n", + " (2060, 9): 3.084095001220703,\n", + " (2060, 10): 5.564296007156372,\n", + " (2060, 11): 90.46374785900116,\n", + " (2060, 12): 403.0808701515198},\n", + " 'window': {(2060, 1): 71.86436748504639,\n", + " (2060, 2): 156.34907913208008,\n", + " (2060, 3): 212.91047859191895,\n", + " (2060, 4): 122.69961524009705,\n", + " (2060, 5): 6.043999552726746,\n", + " (2060, 6): 2.0784695148468018,\n", + " (2060, 7): 2.6151286363601685,\n", + " (2060, 8): 11.049073338508606,\n", + " (2060, 9): 2.0583328008651733,\n", + " (2060, 10): 4.256815791130066,\n", + " (2060, 11): 46.598533153533936,\n", + " (2060, 12): 175.78947639465332}},\n", + " 355: {'monthly': {(2060, 1): 337.81268429756165,\n", + " (2060, 2): 600.2015764713287,\n", + " (2060, 3): 526.962812423706,\n", + " (2060, 4): 175.98721194267273,\n", + " (2060, 5): 5.323371052742004,\n", + " (2060, 6): 7.291415572166443,\n", + " (2060, 7): 8.677201271057129,\n", + " (2060, 8): 11.904772639274597,\n", + " (2060, 9): 1.0253710746765137,\n", + " (2060, 10): 6.4637370109558105,\n", + " (2060, 11): 84.4029688835144,\n", + " (2060, 12): 393.5348536968231},\n", + " 'window': {(2060, 1): 79.63152027130127,\n", + " (2060, 2): 158.30975914001465,\n", + " (2060, 3): 203.43828582763672,\n", + " (2060, 4): 116.06853485107422,\n", + " (2060, 5): 4.320436596870422,\n", + " (2060, 6): 2.8946402072906494,\n", + " (2060, 7): 3.6700860261917114,\n", + " (2060, 8): 8.725101113319397,\n", + " (2060, 9): 1.0253710746765137,\n", + " (2060, 10): 2.8388134241104126,\n", + " (2060, 11): 42.775792598724365,\n", + " (2060, 12): 163.13669872283936}},\n", + " 356: {'monthly': {(2060, 1): 301.87683844566345,\n", + " (2060, 2): 438.84221744537354,\n", + " (2060, 3): 393.05931544303894,\n", + " (2060, 4): 97.06803238391876,\n", + " (2060, 5): 14.559457063674927,\n", + " (2060, 6): 16.421231269836426,\n", + " (2060, 7): 11.455554604530334,\n", + " (2060, 8): 17.021863102912903,\n", + " (2060, 9): 6.725084066390991,\n", + " (2060, 10): 5.438904523849487,\n", + " (2060, 11): 66.54305589199066,\n", + " (2060, 12): 298.8861417770386},\n", + " 'window': {(2060, 1): 67.89023494720459,\n", + " (2060, 2): 138.19604873657227,\n", + " (2060, 3): 86.85419654846191,\n", + " (2060, 4): 38.623475313186646,\n", + " (2060, 5): 6.139068126678467,\n", + " (2060, 6): 5.529691815376282,\n", + " (2060, 7): 4.399170279502869,\n", + " (2060, 8): 11.908767938613892,\n", + " (2060, 9): 6.725084066390991,\n", + " (2060, 10): 4.399509429931641,\n", + " (2060, 11): 28.818098306655884,\n", + " (2060, 12): 102.3089542388916}},\n", + " 357: {'monthly': {(2060, 1): 203.66830134391785,\n", + " (2060, 2): 397.7060925960541,\n", + " (2060, 3): 413.55915355682373,\n", + " (2060, 4): 130.69854307174683,\n", + " (2060, 5): 20.814133048057556,\n", + " (2060, 6): 19.888506412506104,\n", + " (2060, 7): 16.682551622390747,\n", + " (2060, 8): 21.551636695861816,\n", + " (2060, 9): 5.481376647949219,\n", + " (2060, 10): 3.9288707971572876,\n", + " (2060, 11): 89.87154293060303,\n", + " (2060, 12): 292.38003396987915},\n", + " 'window': {(2060, 1): 51.57046461105347,\n", + " (2060, 2): 119.68313503265381,\n", + " (2060, 3): 114.4658374786377,\n", + " (2060, 4): 53.80711650848389,\n", + " (2060, 5): 9.830094814300537,\n", + " (2060, 6): 8.236461639404297,\n", + " (2060, 7): 6.638162612915039,\n", + " (2060, 8): 16.48213529586792,\n", + " (2060, 9): 5.481376647949219,\n", + " (2060, 10): 2.889475703239441,\n", + " (2060, 11): 47.28731346130371,\n", + " (2060, 12): 109.37532234191895}},\n", + " 358: {'monthly': {(2060, 1): 264.1998338699341,\n", + " (2060, 2): 440.37795650959015,\n", + " (2060, 3): 462.6942720413208,\n", + " (2060, 4): 187.5033152103424,\n", + " (2060, 5): 43.563448905944824,\n", + " (2060, 6): 35.635459780693054,\n", + " (2060, 7): 41.50910151004791,\n", + " (2060, 8): 38.76936709880829,\n", + " (2060, 9): 12.383973717689514,\n", + " (2060, 10): 8.075505375862122,\n", + " (2060, 11): 134.39883613586426,\n", + " (2060, 12): 358.72053265571594},\n", + " 'window': {(2060, 1): 65.65271949768066,\n", + " (2060, 2): 114.9453010559082,\n", + " (2060, 3): 125.55118083953857,\n", + " (2060, 4): 60.51179027557373,\n", + " (2060, 5): 13.828957080841064,\n", + " (2060, 6): 11.43546187877655,\n", + " (2060, 7): 12.6837637424469,\n", + " (2060, 8): 28.205679774284363,\n", + " (2060, 9): 9.579094409942627,\n", + " (2060, 10): 3.7452075481414795,\n", + " (2060, 11): 67.08031463623047,\n", + " (2060, 12): 118.67788410186768}},\n", + " 359: {'monthly': {(2060, 1): 178.1333109140396,\n", + " (2060, 2): 283.2431175708771,\n", + " (2060, 3): 284.83617186546326,\n", + " (2060, 4): 103.23764991760254,\n", + " (2060, 5): 16.92825150489807,\n", + " (2060, 6): 15.875644564628601,\n", + " (2060, 7): 12.488359570503235,\n", + " (2060, 8): 18.967225551605225,\n", + " (2060, 9): 5.044026136398315,\n", + " (2060, 10): 4.701770782470703,\n", + " (2060, 11): 79.69813406467438,\n", + " (2060, 12): 238.7788770198822},\n", + " 'window': {(2060, 1): 43.797940731048584,\n", + " (2060, 2): 72.22228050231934,\n", + " (2060, 3): 73.86251544952393,\n", + " (2060, 4): 35.05984544754028,\n", + " (2060, 5): 8.623881578445435,\n", + " (2060, 6): 5.054239511489868,\n", + " (2060, 7): 4.255905389785767,\n", + " (2060, 8): 13.639139652252197,\n", + " (2060, 9): 5.044026136398315,\n", + " (2060, 10): 3.6623756885528564,\n", + " (2060, 11): 37.41058683395386,\n", + " (2060, 12): 74.5195665359497}},\n", + " 360: {'monthly': {(2060, 1): 144.231063246727,\n", + " (2060, 2): 216.33098304271698,\n", + " (2060, 3): 231.19734811782837,\n", + " (2060, 4): 55.80735468864441,\n", + " (2060, 5): 6.250277400016785,\n", + " (2060, 6): 2.989251136779785,\n", + " (2060, 7): 6.9541391134262085,\n", + " (2060, 8): 9.533425450325012,\n", + " (2060, 9): 7.83812952041626,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 41.43318712711334,\n", + " (2060, 12): 136.1825408935547},\n", + " 'window': {(2060, 1): 45.84461832046509,\n", + " (2060, 2): 71.99977922439575,\n", + " (2060, 3): 67.33181190490723,\n", + " (2060, 4): 25.451524257659912,\n", + " (2060, 5): 3.145875096321106,\n", + " (2060, 6): 1.6240652799606323,\n", + " (2060, 7): 3.6497827768325806,\n", + " (2060, 8): 7.238368034362793,\n", + " (2060, 9): 6.344486355781555,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 31.422049522399902,\n", + " (2060, 12): 49.700161933898926}},\n", + " 361: {'monthly': {(2060, 1): 156.94122874736786,\n", + " (2060, 2): 239.315265417099,\n", + " (2060, 3): 281.9130845069885,\n", + " (2060, 4): 63.60218036174774,\n", + " (2060, 5): 6.042468786239624,\n", + " (2060, 6): 3.197485089302063,\n", + " (2060, 7): 6.376499891281128,\n", + " (2060, 8): 8.068963527679443,\n", + " (2060, 9): 6.295173764228821,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 48.16404330730438,\n", + " (2060, 12): 157.9187433719635},\n", + " 'window': {(2060, 1): 44.132304668426514,\n", + " (2060, 2): 81.95422077178955,\n", + " (2060, 3): 80.81283664703369,\n", + " (2060, 4): 29.963093519210815,\n", + " (2060, 5): 2.3731513023376465,\n", + " (2060, 6): 1.8322992324829102,\n", + " (2060, 7): 3.304356336593628,\n", + " (2060, 8): 6.792410373687744,\n", + " (2060, 9): 6.295173764228821,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 36.85248041152954,\n", + " (2060, 12): 57.67494487762451}},\n", + " 362: {'monthly': {(2060, 1): 163.84347450733185,\n", + " (2060, 2): 274.66314792633057,\n", + " (2060, 3): 282.7161922454834,\n", + " (2060, 4): 66.07600450515747,\n", + " (2060, 5): 6.401293396949768,\n", + " (2060, 6): 3.1579171419143677,\n", + " (2060, 7): 6.136355638504028,\n", + " (2060, 8): 8.275298357009888,\n", + " (2060, 9): 5.072015404701233,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 49.05095052719116,\n", + " (2060, 12): 177.7322620153427},\n", + " 'window': {(2060, 1): 50.090293884277344,\n", + " (2060, 2): 89.5856351852417,\n", + " (2060, 3): 81.82722282409668,\n", + " (2060, 4): 35.50015950202942,\n", + " (2060, 5): 2.5949233770370483,\n", + " (2060, 6): 1.7927312850952148,\n", + " (2060, 7): 3.304356336593628,\n", + " (2060, 8): 6.652172565460205,\n", + " (2060, 9): 5.072015404701233,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 38.46434926986694,\n", + " (2060, 12): 67.87397956848145}},\n", + " 363: {'monthly': {(2060, 1): 165.97414541244507,\n", + " (2060, 2): 270.5400570631027,\n", + " (2060, 3): 236.1021852493286,\n", + " (2060, 4): 70.70338654518127,\n", + " (2060, 5): 5.712506055831909,\n", + " (2060, 6): 2.9294488430023193,\n", + " (2060, 7): 6.136355638504028,\n", + " (2060, 8): 7.928725719451904,\n", + " (2060, 9): 3.9716721773147583,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 47.313291907310486,\n", + " (2060, 12): 181.39650702476501},\n", + " 'window': {(2060, 1): 53.243648529052734,\n", + " (2060, 2): 87.51931858062744,\n", + " (2060, 3): 60.8726224899292,\n", + " (2060, 4): 43.6773955821991,\n", + " (2060, 5): 2.684832811355591,\n", + " (2060, 6): 1.5642629861831665,\n", + " (2060, 7): 3.304356336593628,\n", + " (2060, 8): 6.652172565460205,\n", + " (2060, 9): 3.9716721773147583,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 37.59663915634155,\n", + " (2060, 12): 81.1920051574707}},\n", + " 364: {'monthly': {(2060, 1): 166.34626495838165,\n", + " (2060, 2): 220.3690732717514,\n", + " (2060, 3): 192.0253701210022,\n", + " (2060, 4): 68.40841329097748,\n", + " (2060, 5): 1.1718651056289673,\n", + " (2060, 6): 0.0,\n", + " (2060, 7): 3.6192963123321533,\n", + " (2060, 8): 4.0284528732299805,\n", + " (2060, 9): 2.1650272607803345,\n", + " (2060, 10): 6.392921447753906,\n", + " (2060, 11): 49.24258375167847,\n", + " (2060, 12): 166.03872156143188},\n", + " 'window': {(2060, 1): 38.83311223983765,\n", + " (2060, 2): 58.49986219406128,\n", + " (2060, 3): 53.7948055267334,\n", + " (2060, 4): 31.430148363113403,\n", + " (2060, 5): 1.1718651056289673,\n", + " (2060, 6): 0.0,\n", + " (2060, 7): 2.2391775846481323,\n", + " (2060, 8): 4.0284528732299805,\n", + " (2060, 9): 1.083641767501831,\n", + " (2060, 10): 6.392921447753906,\n", + " (2060, 11): 26.178444981575012,\n", + " (2060, 12): 55.14943552017212}},\n", + " 365: {'monthly': {(2060, 1): 182.10686266422272,\n", + " (2060, 2): 233.61105024814606,\n", + " (2060, 3): 287.2898886203766,\n", + " (2060, 4): 95.88835942745209,\n", + " (2060, 5): 3.8210381269454956,\n", + " (2060, 6): 2.5997159481048584,\n", + " (2060, 7): 5.032007813453674,\n", + " (2060, 8): 12.449836134910583,\n", + " (2060, 9): 1.0253710746765137,\n", + " (2060, 10): 5.319395065307617,\n", + " (2060, 11): 88.14243352413177,\n", + " (2060, 12): 231.5383541584015},\n", + " 'window': {(2060, 1): 41.989378690719604,\n", + " (2060, 2): 62.09833765029907,\n", + " (2060, 3): 75.53278923034668,\n", + " (2060, 4): 41.2802472114563,\n", + " (2060, 5): 2.8181036710739136,\n", + " (2060, 6): 1.5302691459655762,\n", + " (2060, 7): 2.56003201007843,\n", + " (2060, 8): 9.270164608955383,\n", + " (2060, 9): 1.0253710746765137,\n", + " (2060, 10): 4.309550881385803,\n", + " (2060, 11): 47.18533658981323,\n", + " (2060, 12): 83.35262107849121}},\n", + " 366: {'monthly': {(2060, 1): 232.65787887573242,\n", + " (2060, 2): 279.3179839849472,\n", + " (2060, 3): 295.5669548511505,\n", + " (2060, 4): 89.84878635406494,\n", + " (2060, 5): 8.904881238937378,\n", + " (2060, 6): 3.6253193616867065,\n", + " (2060, 7): 4.785010933876038,\n", + " (2060, 8): 15.194651007652283,\n", + " (2060, 9): 1.0253710746765137,\n", + " (2060, 10): 5.949154019355774,\n", + " (2060, 11): 96.06230330467224,\n", + " (2060, 12): 254.55350530147552},\n", + " 'window': {(2060, 1): 51.60810708999634,\n", + " (2060, 2): 81.11182689666748,\n", + " (2060, 3): 77.84882259368896,\n", + " (2060, 4): 42.01062774658203,\n", + " (2060, 5): 5.539155602455139,\n", + " (2060, 6): 2.426335096359253,\n", + " (2060, 7): 2.56003201007843,\n", + " (2060, 8): 12.014979481697083,\n", + " (2060, 9): 1.0253710746765137,\n", + " (2060, 10): 3.217567801475525,\n", + " (2060, 11): 54.97837162017822,\n", + " (2060, 12): 88.60397624969482}},\n", + " 367: {'monthly': {(2060, 1): 249.38615083694458,\n", + " (2060, 2): 342.1434608697891,\n", + " (2060, 3): 320.9760513305664,\n", + " (2060, 4): 130.51267981529236,\n", + " (2060, 5): 12.40896189212799,\n", + " (2060, 6): 4.9963139295578,\n", + " (2060, 7): 4.785010933876038,\n", + " (2060, 8): 14.041459918022156,\n", + " (2060, 9): 1.0253710746765137,\n", + " (2060, 10): 3.8247705698013306,\n", + " (2060, 11): 86.06654059886932,\n", + " (2060, 12): 268.563112616539},\n", + " 'window': {(2060, 1): 57.43638610839844,\n", + " (2060, 2): 96.11994647979736,\n", + " (2060, 3): 91.09024620056152,\n", + " (2060, 4): 73.49055600166321,\n", + " (2060, 5): 7.423483490943909,\n", + " (2060, 6): 2.069274663925171,\n", + " (2060, 7): 2.56003201007843,\n", + " (2060, 8): 10.861788392066956,\n", + " (2060, 9): 1.0253710746765137,\n", + " (2060, 10): 2.8149263858795166,\n", + " (2060, 11): 50.24421787261963,\n", + " (2060, 12): 81.93220138549805}},\n", + " 368: {'monthly': {(2060, 1): 294.8989408016205,\n", + " (2060, 2): 340.99745404720306,\n", + " (2060, 3): 298.7412427663803,\n", + " (2060, 4): 102.12918615341187,\n", + " (2060, 5): 5.05357027053833,\n", + " (2060, 6): 6.714656829833984,\n", + " (2060, 7): 6.112763166427612,\n", + " (2060, 8): 11.339202523231506,\n", + " (2060, 9): 1.0253710746765137,\n", + " (2060, 10): 3.9316540956497192,\n", + " (2060, 11): 81.14651882648468,\n", + " (2060, 12): 226.52567088603973},\n", + " 'window': {(2060, 1): 61.02857971191406,\n", + " (2060, 2): 94.12771701812744,\n", + " (2060, 3): 85.38313293457031,\n", + " (2060, 4): 65.64057922363281,\n", + " (2060, 5): 1.61881422996521,\n", + " (2060, 6): 2.617959141731262,\n", + " (2060, 7): 2.56003201007843,\n", + " (2060, 8): 8.159530997276306,\n", + " (2060, 9): 1.0253710746765137,\n", + " (2060, 10): 2.9218099117279053,\n", + " (2060, 11): 41.88496971130371,\n", + " (2060, 12): 61.98970603942871}},\n", + " 369: {'monthly': {(2060, 1): 204.05772817134857,\n", + " (2060, 2): 296.7662752866745,\n", + " (2060, 3): 336.01029753685,\n", + " (2060, 4): 82.86447656154633,\n", + " (2060, 5): 12.68576717376709,\n", + " (2060, 6): 13.850563406944275,\n", + " (2060, 7): 11.591421723365784,\n", + " (2060, 8): 16.56989014148712,\n", + " (2060, 9): 4.346258044242859,\n", + " (2060, 10): 3.7939025163650513,\n", + " (2060, 11): 70.7224189043045,\n", + " (2060, 12): 228.6220873594284},\n", + " 'window': {(2060, 1): 52.83263659477234,\n", + " (2060, 2): 84.4668869972229,\n", + " (2060, 3): 100.33522510528564,\n", + " (2060, 4): 29.481672406196594,\n", + " (2060, 5): 4.193650245666504,\n", + " (2060, 6): 4.152397274971008,\n", + " (2060, 7): 4.3422006368637085,\n", + " (2060, 8): 11.45679497718811,\n", + " (2060, 9): 4.346258044242859,\n", + " (2060, 10): 2.7545074224472046,\n", + " (2060, 11): 37.765132427215576,\n", + " (2060, 12): 81.62792444229126}},\n", + " 370: {'monthly': {(2060, 1): 250.7633911371231,\n", + " (2060, 2): 388.13015139102936,\n", + " (2060, 3): 429.20004773139954,\n", + " (2060, 4): 121.01484537124634,\n", + " (2060, 5): 18.927573919296265,\n", + " (2060, 6): 16.416436910629272,\n", + " (2060, 7): 16.206777453422546,\n", + " (2060, 8): 21.148574948310852,\n", + " (2060, 9): 6.394774317741394,\n", + " (2060, 10): 4.101782321929932,\n", + " (2060, 11): 113.70261585712433,\n", + " (2060, 12): 359.1420124769211},\n", + " 'window': {(2060, 1): 66.65383958816528,\n", + " (2060, 2): 109.30014324188232,\n", + " (2060, 3): 136.10631370544434,\n", + " (2060, 4): 38.51203775405884,\n", + " (2060, 5): 8.177371740341187,\n", + " (2060, 6): 5.863957166671753,\n", + " (2060, 7): 7.64594030380249,\n", + " (2060, 8): 15.788182854652405,\n", + " (2060, 9): 6.394774317741394,\n", + " (2060, 10): 3.062387228012085,\n", + " (2060, 11): 67.40798759460449,\n", + " (2060, 12): 121.91678619384766}},\n", + " 371: {'monthly': {(2060, 1): 321.0069818496704,\n", + " (2060, 2): 396.87250328063965,\n", + " (2060, 3): 411.28923988342285,\n", + " (2060, 4): 138.94894325733185,\n", + " (2060, 5): 27.65811264514923,\n", + " (2060, 6): 25.01667332649231,\n", + " (2060, 7): 31.05210304260254,\n", + " (2060, 8): 31.094981908798218,\n", + " (2060, 9): 10.825179696083069,\n", + " (2060, 10): 5.973053455352783,\n", + " (2060, 11): 129.69430780410767,\n", + " (2060, 12): 395.0478494167328},\n", + " 'window': {(2060, 1): 87.41708183288574,\n", + " (2060, 2): 102.40510559082031,\n", + " (2060, 3): 116.62148666381836,\n", + " (2060, 4): 42.86701488494873,\n", + " (2060, 5): 11.07584810256958,\n", + " (2060, 6): 7.908582091331482,\n", + " (2060, 7): 11.923386096954346,\n", + " (2060, 8): 22.15704643726349,\n", + " (2060, 9): 8.058786869049072,\n", + " (2060, 10): 4.9336583614349365,\n", + " (2060, 11): 66.1063642501831,\n", + " (2060, 12): 105.96094226837158}},\n", + " 372: {'monthly': {(2060, 1): 243.9283537864685,\n", + " (2060, 2): 279.120085477829,\n", + " (2060, 3): 279.1301648616791,\n", + " (2060, 4): 93.50290632247925,\n", + " (2060, 5): 16.820484399795532,\n", + " (2060, 6): 14.330246925354004,\n", + " (2060, 7): 13.841667294502258,\n", + " (2060, 8): 19.752363324165344,\n", + " (2060, 9): 3.826420307159424,\n", + " (2060, 10): 4.01350998878479,\n", + " (2060, 11): 84.5606164932251,\n", + " (2060, 12): 293.2078412771225},\n", + " 'window': {(2060, 1): 71.06168985366821,\n", + " (2060, 2): 68.59465408325195,\n", + " (2060, 3): 67.65301609039307,\n", + " (2060, 4): 27.19639277458191,\n", + " (2060, 5): 6.185702681541443,\n", + " (2060, 6): 4.3633036613464355,\n", + " (2060, 7): 4.710237741470337,\n", + " (2060, 8): 14.639268159866333,\n", + " (2060, 9): 3.826420307159424,\n", + " (2060, 10): 2.9741148948669434,\n", + " (2060, 11): 37.15286827087402,\n", + " (2060, 12): 71.6466703414917}},\n", + " 373: {'monthly': {(2060, 1): 193.91320776939392,\n", + " (2060, 2): 252.53764986991882,\n", + " (2060, 3): 235.53720617294312,\n", + " (2060, 4): 59.146209359169006,\n", + " (2060, 5): 7.505447506904602,\n", + " (2060, 6): 3.026734232902527,\n", + " (2060, 7): 6.136355638504028,\n", + " (2060, 8): 7.928725719451904,\n", + " (2060, 9): 8.917001843452454,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 41.06522500514984,\n", + " (2060, 12): 156.1070466041565},\n", + " 'window': {(2060, 1): 54.569804191589355,\n", + " (2060, 2): 77.82296085357666,\n", + " (2060, 3): 58.43880271911621,\n", + " (2060, 4): 23.480927109718323,\n", + " (2060, 5): 3.2951360940933228,\n", + " (2060, 6): 1.661548376083374,\n", + " (2060, 7): 3.304356336593628,\n", + " (2060, 8): 6.652172565460205,\n", + " (2060, 9): 8.917001843452454,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 31.824718952178955,\n", + " (2060, 12): 57.96774339675903}},\n", + " 374: {'monthly': {(2060, 1): 168.20277619361877,\n", + " (2060, 2): 241.3882576227188,\n", + " (2060, 3): 250.0341546535492,\n", + " (2060, 4): 58.01311528682709,\n", + " (2060, 5): 6.919817209243774,\n", + " (2060, 6): 3.074926018714905,\n", + " (2060, 7): 6.136355638504028,\n", + " (2060, 8): 9.215181827545166,\n", + " (2060, 9): 7.931223511695862,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 45.00581872463226,\n", + " (2060, 12): 148.90686118602753},\n", + " 'window': {(2060, 1): 54.07213354110718,\n", + " (2060, 2): 80.74687671661377,\n", + " (2060, 3): 65.74259185791016,\n", + " (2060, 4): 26.531129360198975,\n", + " (2060, 5): 2.8836898803710938,\n", + " (2060, 6): 1.709740161895752,\n", + " (2060, 7): 3.304356336593628,\n", + " (2060, 8): 6.652172565460205,\n", + " (2060, 9): 7.931223511695862,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 35.032471656799316,\n", + " (2060, 12): 57.5262975692749}},\n", + " 375: {'monthly': {(2060, 1): 184.62992429733276,\n", + " (2060, 2): 264.91373884677887,\n", + " (2060, 3): 271.3550246953964,\n", + " (2060, 4): 58.302610993385315,\n", + " (2060, 5): 5.66555643081665,\n", + " (2060, 6): 3.7643896341323853,\n", + " (2060, 7): 6.136355638504028,\n", + " (2060, 8): 7.928725719451904,\n", + " (2060, 9): 4.9951053857803345,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 49.147919058799744,\n", + " (2060, 12): 171.96580922603607},\n", + " 'window': {(2060, 1): 60.6094765663147,\n", + " (2060, 2): 87.75706958770752,\n", + " (2060, 3): 69.01146984100342,\n", + " (2060, 4): 29.626229286193848,\n", + " (2060, 5): 2.6439743041992188,\n", + " (2060, 6): 1.3651858568191528,\n", + " (2060, 7): 3.304356336593628,\n", + " (2060, 8): 6.652172565460205,\n", + " (2060, 9): 4.9951053857803345,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 38.905505657196045,\n", + " (2060, 12): 68.53180027008057}},\n", + " 376: {'monthly': {(2060, 1): 180.20367431640625,\n", + " (2060, 2): 272.45594787597656,\n", + " (2060, 3): 246.63388991355896,\n", + " (2060, 4): 65.1923485994339,\n", + " (2060, 5): 6.144610643386841,\n", + " (2060, 6): 3.601706862449646,\n", + " (2060, 7): 6.136355638504028,\n", + " (2060, 8): 8.140652656555176,\n", + " (2060, 9): 3.385236144065857,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 47.70523154735565,\n", + " (2060, 12): 193.3783986568451},\n", + " 'window': {(2060, 1): 54.56692886352539,\n", + " (2060, 2): 80.63194274902344,\n", + " (2060, 3): 56.80373764038086,\n", + " (2060, 4): 35.29770255088806,\n", + " (2060, 5): 2.85686457157135,\n", + " (2060, 6): 2.3893678188323975,\n", + " (2060, 7): 3.304356336593628,\n", + " (2060, 8): 6.864099502563477,\n", + " (2060, 9): 3.385236144065857,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 37.331074237823486,\n", + " (2060, 12): 80.56596088409424}},\n", + " 377: {'monthly': {(2060, 1): 168.72258293628693,\n", + " (2060, 2): 225.66447710990906,\n", + " (2060, 3): 224.81525552272797,\n", + " (2060, 4): 49.109877586364746,\n", + " (2060, 5): 2.154682159423828,\n", + " (2060, 6): 4.671999573707581,\n", + " (2060, 7): 5.150723814964294,\n", + " (2060, 8): 3.693593382835388,\n", + " (2060, 9): 4.65442168712616,\n", + " (2060, 10): 11.092034220695496,\n", + " (2060, 11): 62.683056235313416,\n", + " (2060, 12): 207.42765855789185},\n", + " 'window': {(2060, 1): 37.5467164516449,\n", + " (2060, 2): 60.28683376312256,\n", + " (2060, 3): 96.85650634765625,\n", + " (2060, 4): 17.917935252189636,\n", + " (2060, 5): 1.095497488975525,\n", + " (2060, 6): 3.583376169204712,\n", + " (2060, 7): 2.690177321434021,\n", + " (2060, 8): 3.693593382835388,\n", + " (2060, 9): 3.1778981685638428,\n", + " (2060, 10): 11.092034220695496,\n", + " (2060, 11): 36.79406952857971,\n", + " (2060, 12): 56.768937826156616}},\n", + " 378: {'monthly': {(2060, 1): 183.89006340503693,\n", + " (2060, 2): 229.0984832048416,\n", + " (2060, 3): 252.703751206398,\n", + " (2060, 4): 104.13557040691376,\n", + " (2060, 5): 14.065146207809448,\n", + " (2060, 6): 13.224797010421753,\n", + " (2060, 7): 12.64035940170288,\n", + " (2060, 8): 12.13150930404663,\n", + " (2060, 9): 6.012876272201538,\n", + " (2060, 10): 8.558772206306458,\n", + " (2060, 11): 71.70966756343842,\n", + " (2060, 12): 226.5409905910492},\n", + " 'window': {(2060, 1): 48.66191053390503,\n", + " (2060, 2): 60.21333312988281,\n", + " (2060, 3): 76.65425872802734,\n", + " (2060, 4): 37.45549035072327,\n", + " (2060, 5): 6.597886562347412,\n", + " (2060, 6): 7.408227443695068,\n", + " (2060, 7): 5.834046721458435,\n", + " (2060, 8): 5.949543356895447,\n", + " (2060, 9): 3.217884063720703,\n", + " (2060, 10): 7.433558344841003,\n", + " (2060, 11): 26.092806100845337,\n", + " (2060, 12): 57.13832378387451}},\n", + " 379: {'monthly': {(2060, 1): 195.51022505760193,\n", + " (2060, 2): 285.1017994880676,\n", + " (2060, 3): 328.98690938949585,\n", + " (2060, 4): 92.00731182098389,\n", + " (2060, 5): 10.55418860912323,\n", + " (2060, 6): 12.335365176200867,\n", + " (2060, 7): 12.64035940170288,\n", + " (2060, 8): 12.992737650871277,\n", + " (2060, 9): 4.321966886520386,\n", + " (2060, 10): 3.7434016466140747,\n", + " (2060, 11): 113.95866620540619,\n", + " (2060, 12): 288.0956633090973},\n", + " 'window': {(2060, 1): 53.18430709838867,\n", + " (2060, 2): 65.9955587387085,\n", + " (2060, 3): 78.36417198181152,\n", + " (2060, 4): 33.85520040988922,\n", + " (2060, 5): 4.563319802284241,\n", + " (2060, 6): 6.518795609474182,\n", + " (2060, 7): 5.834046721458435,\n", + " (2060, 8): 7.5893625020980835,\n", + " (2060, 9): 3.217884063720703,\n", + " (2060, 10): 2.6181877851486206,\n", + " (2060, 11): 50.38206195831299,\n", + " (2060, 12): 77.25684118270874}},\n", + " 380: {'monthly': {(2060, 1): 298.51513481140137,\n", + " (2060, 2): 323.9600977897644,\n", + " (2060, 3): 327.7440357208252,\n", + " (2060, 4): 99.56636583805084,\n", + " (2060, 5): 11.184078097343445,\n", + " (2060, 6): 10.725985884666443,\n", + " (2060, 7): 12.828433990478516,\n", + " (2060, 8): 14.008373260498047,\n", + " (2060, 9): 4.321966886520386,\n", + " (2060, 10): 4.271755695343018,\n", + " (2060, 11): 87.19449591636658,\n", + " (2060, 12): 354.3440878391266},\n", + " 'window': {(2060, 1): 77.0308666229248,\n", + " (2060, 2): 84.37670803070068,\n", + " (2060, 3): 73.40827417373657,\n", + " (2060, 4): 31.459746599197388,\n", + " (2060, 5): 3.888566493988037,\n", + " (2060, 6): 5.458016872406006,\n", + " (2060, 7): 5.833905577659607,\n", + " (2060, 8): 8.008766293525696,\n", + " (2060, 9): 3.217884063720703,\n", + " (2060, 10): 3.1465418338775635,\n", + " (2060, 11): 38.56263065338135,\n", + " (2060, 12): 88.19429302215576}},\n", + " 381: {'monthly': {(2060, 1): 284.5288243293762,\n", + " (2060, 2): 314.9116690158844,\n", + " (2060, 3): 369.1858651638031,\n", + " (2060, 4): 128.81471574306488,\n", + " (2060, 5): 20.6155606508255,\n", + " (2060, 6): 15.210014343261719,\n", + " (2060, 7): 12.71425998210907,\n", + " (2060, 8): 15.828834772109985,\n", + " (2060, 9): 5.079553604125977,\n", + " (2060, 10): 4.39546799659729,\n", + " (2060, 11): 84.04179811477661,\n", + " (2060, 12): 304.3026200532913},\n", + " 'window': {(2060, 1): 73.96430253982544,\n", + " (2060, 2): 89.47660827636719,\n", + " (2060, 3): 92.26852226257324,\n", + " (2060, 4): 41.85691213607788,\n", + " (2060, 5): 8.151678085327148,\n", + " (2060, 6): 7.147527694702148,\n", + " (2060, 7): 5.759005904197693,\n", + " (2060, 8): 8.621779799461365,\n", + " (2060, 9): 2.847001314163208,\n", + " (2060, 10): 3.270254135131836,\n", + " (2060, 11): 30.410312175750732,\n", + " (2060, 12): 84.24227809906006}},\n", + " 382: {'monthly': {(2060, 1): 245.72071850299835,\n", + " (2060, 2): 422.4146544933319,\n", + " (2060, 3): 491.2512273788452,\n", + " (2060, 4): 184.92181706428528,\n", + " (2060, 5): 38.43340289592743,\n", + " (2060, 6): 27.64109718799591,\n", + " (2060, 7): 24.619238138198853,\n", + " (2060, 8): 26.8357093334198,\n", + " (2060, 9): 7.538404583930969,\n", + " (2060, 10): 8.060519933700562,\n", + " (2060, 11): 139.94905591011047,\n", + " (2060, 12): 333.443506360054},\n", + " 'window': {(2060, 1): 62.09790229797363,\n", + " (2060, 2): 126.58339786529541,\n", + " (2060, 3): 142.0317554473877,\n", + " (2060, 4): 58.98905801773071,\n", + " (2060, 5): 12.17837679386139,\n", + " (2060, 6): 8.598559856414795,\n", + " (2060, 7): 10.921966671943665,\n", + " (2060, 8): 15.719516515731812,\n", + " (2060, 9): 4.958504319190979,\n", + " (2060, 10): 5.588065147399902,\n", + " (2060, 11): 77.58835649490356,\n", + " (2060, 12): 83.40189743041992}},\n", + " 383: {'monthly': {(2060, 1): 333.0408617258072,\n", + " (2060, 2): 553.8174774646759,\n", + " (2060, 3): 623.7906270027161,\n", + " (2060, 4): 183.14194357395172,\n", + " (2060, 5): 36.81927239894867,\n", + " (2060, 6): 25.804607629776,\n", + " (2060, 7): 18.43522870540619,\n", + " (2060, 8): 27.349186539649963,\n", + " (2060, 9): 9.515154838562012,\n", + " (2060, 10): 8.709033250808716,\n", + " (2060, 11): 208.12935853004456,\n", + " (2060, 12): 446.285439491272},\n", + " 'window': {(2060, 1): 81.1829662322998,\n", + " (2060, 2): 146.87132930755615,\n", + " (2060, 3): 207.74162483215332,\n", + " (2060, 4): 59.31193542480469,\n", + " (2060, 5): 12.053408980369568,\n", + " (2060, 6): 8.467171549797058,\n", + " (2060, 7): 9.587490439414978,\n", + " (2060, 8): 14.340285778045654,\n", + " (2060, 9): 5.502827763557434,\n", + " (2060, 10): 5.39226770401001,\n", + " (2060, 11): 107.24258136749268,\n", + " (2060, 12): 96.04324913024902}},\n", + " 384: {'monthly': {(2060, 1): 405.18871879577637,\n", + " (2060, 2): 550.9571185112,\n", + " (2060, 3): 511.28173208236694,\n", + " (2060, 4): 135.59755957126617,\n", + " (2060, 5): 24.386338353157043,\n", + " (2060, 6): 17.12852907180786,\n", + " (2060, 7): 13.094897985458374,\n", + " (2060, 8): 25.071101903915405,\n", + " (2060, 9): 5.199883580207825,\n", + " (2060, 10): 5.421327710151672,\n", + " (2060, 11): 164.96277165412903,\n", + " (2060, 12): 456.180916428566},\n", + " 'window': {(2060, 1): 102.41054058074951,\n", + " (2060, 2): 146.62237071990967,\n", + " (2060, 3): 162.6156826019287,\n", + " (2060, 4): 39.80028963088989,\n", + " (2060, 5): 9.902860760688782,\n", + " (2060, 6): 5.873907566070557,\n", + " (2060, 7): 6.703943490982056,\n", + " (2060, 8): 13.418867826461792,\n", + " (2060, 9): 3.6929961442947388,\n", + " (2060, 10): 5.421327710151672,\n", + " (2060, 11): 69.97992825508118,\n", + " (2060, 12): 99.32099342346191}},\n", + " 385: {'monthly': {(2060, 1): 423.55770099163055,\n", + " (2060, 2): 351.49102425575256,\n", + " (2060, 3): 329.6173152923584,\n", + " (2060, 4): 123.15557849407196,\n", + " (2060, 5): 24.490737199783325,\n", + " (2060, 6): 17.189981818199158,\n", + " (2060, 7): 13.845078468322754,\n", + " (2060, 8): 23.065874338150024,\n", + " (2060, 9): 5.199883580207825,\n", + " (2060, 10): 6.104557275772095,\n", + " (2060, 11): 127.9006175994873,\n", + " (2060, 12): 341.9298987388611},\n", + " 'window': {(2060, 1): 127.18251132965088,\n", + " (2060, 2): 85.33151817321777,\n", + " (2060, 3): 70.61262893676758,\n", + " (2060, 4): 36.49405479431152,\n", + " (2060, 5): 8.6967134475708,\n", + " (2060, 6): 5.707547903060913,\n", + " (2060, 7): 6.425916790962219,\n", + " (2060, 8): 14.606455206871033,\n", + " (2060, 9): 3.6929961442947388,\n", + " (2060, 10): 4.66397500038147,\n", + " (2060, 11): 53.58917450904846,\n", + " (2060, 12): 88.69561386108398}},\n", + " 386: {'monthly': {(2060, 1): 251.83087873458862,\n", + " (2060, 2): 362.7614984512329,\n", + " (2060, 3): 419.6058702468872,\n", + " (2060, 4): 89.49929296970367,\n", + " (2060, 5): 7.3274500370025635,\n", + " (2060, 6): 5.693287253379822,\n", + " (2060, 7): 5.6086665391922,\n", + " (2060, 8): 16.575836658477783,\n", + " (2060, 9): 12.438502669334412,\n", + " (2060, 10): 1.022443175315857,\n", + " (2060, 11): 64.67064309120178,\n", + " (2060, 12): 218.97875344753265},\n", + " 'window': {(2060, 1): 77.7287654876709,\n", + " (2060, 2): 105.08432960510254,\n", + " (2060, 3): 159.62180709838867,\n", + " (2060, 4): 27.066538095474243,\n", + " (2060, 5): 3.712322950363159,\n", + " (2060, 6): 3.2304407358169556,\n", + " (2060, 7): 3.3676012754440308,\n", + " (2060, 8): 9.194929480552673,\n", + " (2060, 9): 10.498918175697327,\n", + " (2060, 10): 1.022443175315857,\n", + " (2060, 11): 47.3193793296814,\n", + " (2060, 12): 77.49810886383057}},\n", + " 387: {'monthly': {(2060, 1): 213.95052301883698,\n", + " (2060, 2): 329.2265352010727,\n", + " (2060, 3): 327.8579316139221,\n", + " (2060, 4): 79.46410155296326,\n", + " (2060, 5): 6.6305941343307495,\n", + " (2060, 6): 2.1947437524795532,\n", + " (2060, 7): 4.58988082408905,\n", + " (2060, 8): 15.985164999961853,\n", + " (2060, 9): 12.62716805934906,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 54.390645265579224,\n", + " (2060, 12): 189.83165609836578},\n", + " 'window': {(2060, 1): 66.89607191085815,\n", + " (2060, 2): 83.64367580413818,\n", + " (2060, 3): 85.84045124053955,\n", + " (2060, 4): 26.428195476531982,\n", + " (2060, 5): 3.4906036853790283,\n", + " (2060, 6): 1.1001338958740234,\n", + " (2060, 7): 3.3676012754440308,\n", + " (2060, 8): 10.005805969238281,\n", + " (2060, 9): 9.568324208259583,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 42.435200691223145,\n", + " (2060, 12): 68.39646100997925}},\n", + " 388: {'monthly': {(2060, 1): 195.6907113790512,\n", + " (2060, 2): 319.0086498260498,\n", + " (2060, 3): 325.47775888442993,\n", + " (2060, 4): 76.53937578201294,\n", + " (2060, 5): 5.239037036895752,\n", + " (2060, 6): 1.1001338958740234,\n", + " (2060, 7): 4.58988082408905,\n", + " (2060, 8): 17.95933699607849,\n", + " (2060, 9): 8.472065567970276,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 55.384071350097656,\n", + " (2060, 12): 191.22394573688507},\n", + " 'window': {(2060, 1): 65.473623752594,\n", + " (2060, 2): 84.4402379989624,\n", + " (2060, 3): 88.74025821685791,\n", + " (2060, 4): 26.041996598243713,\n", + " (2060, 5): 2.818236827850342,\n", + " (2060, 6): 1.1001338958740234,\n", + " (2060, 7): 3.3676012754440308,\n", + " (2060, 8): 11.272314071655273,\n", + " (2060, 9): 5.672576546669006,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 42.20364189147949,\n", + " (2060, 12): 66.63904094696045}},\n", + " 389: {'monthly': {(2060, 1): 184.35914623737335,\n", + " (2060, 2): 292.1955517530441,\n", + " (2060, 3): 293.06680941581726,\n", + " (2060, 4): 77.51762676239014,\n", + " (2060, 5): 3.645328164100647,\n", + " (2060, 6): 2.354953169822693,\n", + " (2060, 7): 4.58988082408905,\n", + " (2060, 8): 19.412689566612244,\n", + " (2060, 9): 5.132485628128052,\n", + " (2060, 10): 2.5531128644943237,\n", + " (2060, 11): 58.76792323589325,\n", + " (2060, 12): 193.66727757453918},\n", + " 'window': {(2060, 1): 54.281803131103516,\n", + " (2060, 2): 77.61125755310059,\n", + " (2060, 3): 65.78206539154053,\n", + " (2060, 4): 26.475059628486633,\n", + " (2060, 5): 2.312895894050598,\n", + " (2060, 6): 1.2548192739486694,\n", + " (2060, 7): 3.3676012754440308,\n", + " (2060, 8): 12.753625988960266,\n", + " (2060, 9): 3.0819287300109863,\n", + " (2060, 10): 1.3262019157409668,\n", + " (2060, 11): 47.9988317489624,\n", + " (2060, 12): 59.82745170593262}},\n", + " 390: {'monthly': {(2060, 1): 174.62095141410828,\n", + " (2060, 2): 231.62982189655304,\n", + " (2060, 3): 316.0894066317908,\n", + " (2060, 4): 43.785767912864685,\n", + " (2060, 5): 4.483926296234131,\n", + " (2060, 6): 3.583376169204712,\n", + " (2060, 7): 5.150723814964294,\n", + " (2060, 8): 3.693593382835388,\n", + " (2060, 9): 2.9961105585098267,\n", + " (2060, 10): 12.08284306526184,\n", + " (2060, 11): 71.00018429756165,\n", + " (2060, 12): 222.23119449615479},\n", + " 'window': {(2060, 1): 35.628868103027344,\n", + " (2060, 2): 56.769975662231445,\n", + " (2060, 3): 178.23470141729038,\n", + " (2060, 4): 15.40146541595459,\n", + " (2060, 5): 2.3902385234832764,\n", + " (2060, 6): 3.583376169204712,\n", + " (2060, 7): 2.690177321434021,\n", + " (2060, 8): 3.693593382835388,\n", + " (2060, 9): 1.5195870399475098,\n", + " (2060, 10): 12.08284306526184,\n", + " (2060, 11): 47.109920501708984,\n", + " (2060, 12): 60.22527265548706}},\n", + " 391: {'monthly': {(2060, 1): 181.40429496765137,\n", + " (2060, 2): 248.89680755138397,\n", + " (2060, 3): 372.06871807575226,\n", + " (2060, 4): 79.5608617067337,\n", + " (2060, 5): 9.395422101020813,\n", + " (2060, 6): 13.224797010421753,\n", + " (2060, 7): 12.64035940170288,\n", + " (2060, 8): 13.783410549163818,\n", + " (2060, 9): 7.22767972946167,\n", + " (2060, 10): 4.2711814641952515,\n", + " (2060, 11): 96.50427579879761,\n", + " (2060, 12): 243.23703634738922},\n", + " 'window': {(2060, 1): 55.440470695495605,\n", + " (2060, 2): 59.228331565856934,\n", + " (2060, 3): 141.62621974945068,\n", + " (2060, 4): 28.439859986305237,\n", + " (2060, 5): 3.4045532941818237,\n", + " (2060, 6): 7.408227443695068,\n", + " (2060, 7): 5.834046721458435,\n", + " (2060, 8): 7.601444602012634,\n", + " (2060, 9): 3.217884063720703,\n", + " (2060, 10): 3.1459676027297974,\n", + " (2060, 11): 36.84239149093628,\n", + " (2060, 12): 60.08789253234863}},\n", + " 392: {'monthly': {(2060, 1): 230.88375163078308,\n", + " (2060, 2): 364.74312591552734,\n", + " (2060, 3): 428.3998384475708,\n", + " (2060, 4): 107.93558263778687,\n", + " (2060, 5): 16.32062256336212,\n", + " (2060, 6): 11.775663137435913,\n", + " (2060, 7): 14.388250946998596,\n", + " (2060, 8): 14.7117018699646,\n", + " (2060, 9): 5.255762457847595,\n", + " (2060, 10): 5.226936340332031,\n", + " (2060, 11): 136.6473307609558,\n", + " (2060, 12): 322.7664008140564},\n", + " 'window': {(2060, 1): 60.62976694107056,\n", + " (2060, 2): 100.8755669593811,\n", + " (2060, 3): 159.4784450531006,\n", + " (2060, 4): 35.33745074272156,\n", + " (2060, 5): 7.444857358932495,\n", + " (2060, 6): 6.771263360977173,\n", + " (2060, 7): 5.2910685539245605,\n", + " (2060, 8): 9.527777791023254,\n", + " (2060, 9): 2.9245598316192627,\n", + " (2060, 10): 2.9949426651000977,\n", + " (2060, 11): 66.22648525238037,\n", + " (2060, 12): 84.02315855026245}},\n", + " 393: {'monthly': {(2060, 1): 297.5114572048187,\n", + " (2060, 2): 381.79082679748535,\n", + " (2060, 3): 426.2571425437927,\n", + " (2060, 4): 123.01057875156403,\n", + " (2060, 5): 20.104398131370544,\n", + " (2060, 6): 20.798863530158997,\n", + " (2060, 7): 18.488874316215515,\n", + " (2060, 8): 19.823193788528442,\n", + " (2060, 9): 4.960261583328247,\n", + " (2060, 10): 4.592769384384155,\n", + " (2060, 11): 117.69097316265106,\n", + " (2060, 12): 341.60817980766296},\n", + " 'window': {(2060, 1): 79.13844013214111,\n", + " (2060, 2): 98.11538791656494,\n", + " (2060, 3): 131.0134506225586,\n", + " (2060, 4): 39.61476755142212,\n", + " (2060, 5): 9.912413597106934,\n", + " (2060, 6): 9.005005478858948,\n", + " (2060, 7): 7.4053943157196045,\n", + " (2060, 8): 11.631844639778137,\n", + " (2060, 9): 3.8561787605285645,\n", + " (2060, 10): 3.467555522918701,\n", + " (2060, 11): 56.63601589202881,\n", + " (2060, 12): 77.3161473274231}},\n", + " 394: {'monthly': {(2060, 1): 331.88617300987244,\n", + " (2060, 2): 456.69967901706696,\n", + " (2060, 3): 558.4201402664185,\n", + " (2060, 4): 209.88000810146332,\n", + " (2060, 5): 56.3304443359375,\n", + " (2060, 6): 58.45019173622131,\n", + " (2060, 7): 38.635892033576965,\n", + " (2060, 8): 34.49405825138092,\n", + " (2060, 9): 12.829912662506104,\n", + " (2060, 10): 15.159885287284851,\n", + " (2060, 11): 157.57126009464264,\n", + " (2060, 12): 359.89550364017487},\n", + " 'window': {(2060, 1): 93.07376766204834,\n", + " (2060, 2): 132.18474864959717,\n", + " (2060, 3): 137.78375053405762,\n", + " (2060, 4): 61.75257205963135,\n", + " (2060, 5): 15.857987523078918,\n", + " (2060, 6): 18.464482307434082,\n", + " (2060, 7): 13.348755836486816,\n", + " (2060, 8): 18.392507433891296,\n", + " (2060, 9): 5.639367461204529,\n", + " (2060, 10): 9.235466003417969,\n", + " (2060, 11): 66.07911539077759,\n", + " (2060, 12): 80.3734540939331}},\n", + " 395: {'monthly': {(2060, 1): 314.1901071071625,\n", + " (2060, 2): 600.8389282226562,\n", + " (2060, 3): 760.7801389694214,\n", + " (2060, 4): 341.8340425491333,\n", + " (2060, 5): 84.6655513048172,\n", + " (2060, 6): 69.22471928596497,\n", + " (2060, 7): 66.58948135375977,\n", + " (2060, 8): 59.27952027320862,\n", + " (2060, 9): 19.12724483013153,\n", + " (2060, 10): 21.280980944633484,\n", + " (2060, 11): 265.71492862701416,\n", + " (2060, 12): 442.6804008483887},\n", + " 'window': {(2060, 1): 75.87714290618896,\n", + " (2060, 2): 176.9512906074524,\n", + " (2060, 3): 199.75774002075195,\n", + " (2060, 4): 100.13422727584839,\n", + " (2060, 5): 21.72761034965515,\n", + " (2060, 6): 16.215563416481018,\n", + " (2060, 7): 19.375946164131165,\n", + " (2060, 8): 29.44615340232849,\n", + " (2060, 9): 9.28117847442627,\n", + " (2060, 10): 11.331902027130127,\n", + " (2060, 11): 129.9756202697754,\n", + " (2060, 12): 104.59784317016602}},\n", + " 396: {'monthly': {(2060, 1): 383.56121039390564,\n", + " (2060, 2): 667.8527207374573,\n", + " (2060, 3): 712.6772513389587,\n", + " (2060, 4): 227.2806694507599,\n", + " (2060, 5): 65.9167069196701,\n", + " (2060, 6): 50.253986954689026,\n", + " (2060, 7): 44.86192429065704,\n", + " (2060, 8): 50.746062874794006,\n", + " (2060, 9): 17.6672523021698,\n", + " (2060, 10): 20.06515085697174,\n", + " (2060, 11): 218.32442843914032,\n", + " (2060, 12): 476.83087038993835},\n", + " 'window': {(2060, 1): 95.66722774505615,\n", + " (2060, 2): 173.6953296661377,\n", + " (2060, 3): 251.9608917236328,\n", + " (2060, 4): 69.43305492401123,\n", + " (2060, 5): 17.394917845726013,\n", + " (2060, 6): 13.157159805297852,\n", + " (2060, 7): 16.981104969978333,\n", + " (2060, 8): 22.63615655899048,\n", + " (2060, 9): 9.868545532226562,\n", + " (2060, 10): 8.194113373756409,\n", + " (2060, 11): 94.96924877166748,\n", + " (2060, 12): 100.24247169494629}},\n", + " 397: {'monthly': {(2060, 1): 401.36155581474304,\n", + " (2060, 2): 690.927262544632,\n", + " (2060, 3): 607.7005658149719,\n", + " (2060, 4): 125.77751231193542,\n", + " (2060, 5): 23.910840392112732,\n", + " (2060, 6): 17.65970730781555,\n", + " (2060, 7): 13.75852346420288,\n", + " (2060, 8): 20.828347086906433,\n", + " (2060, 9): 5.199883580207825,\n", + " (2060, 10): 6.462509989738464,\n", + " (2060, 11): 160.14627492427826,\n", + " (2060, 12): 444.58162105083466},\n", + " 'window': {(2060, 1): 108.54167556762695,\n", + " (2060, 2): 232.07282638549805,\n", + " (2060, 3): 228.75367546081543,\n", + " (2060, 4): 37.662800788879395,\n", + " (2060, 5): 9.653190612792969,\n", + " (2060, 6): 5.510650157928467,\n", + " (2060, 7): 6.899542570114136,\n", + " (2060, 8): 11.845513463020325,\n", + " (2060, 9): 3.6929961442947388,\n", + " (2060, 10): 4.117847442626953,\n", + " (2060, 11): 80.31592559814453,\n", + " (2060, 12): 96.08648300170898}},\n", + " 398: {'monthly': {(2060, 1): 386.75860810279846,\n", + " (2060, 2): 427.1723647117615,\n", + " (2060, 3): 381.59524488449097,\n", + " (2060, 4): 120.32357668876648,\n", + " (2060, 5): 25.05068063735962,\n", + " (2060, 6): 17.829830527305603,\n", + " (2060, 7): 15.043785691261292,\n", + " (2060, 8): 21.105697989463806,\n", + " (2060, 9): 6.3442288637161255,\n", + " (2060, 10): 8.331496596336365,\n", + " (2060, 11): 91.58041989803314,\n", + " (2060, 12): 327.0328302383423},\n", + " 'window': {(2060, 1): 102.9858512878418,\n", + " (2060, 2): 124.03274536132812,\n", + " (2060, 3): 106.45507907867432,\n", + " (2060, 4): 36.778788805007935,\n", + " (2060, 5): 9.60598087310791,\n", + " (2060, 6): 6.203958749771118,\n", + " (2060, 7): 7.624624013900757,\n", + " (2060, 8): 13.68772304058075,\n", + " (2060, 9): 4.8373414278030396,\n", + " (2060, 10): 5.878787159919739,\n", + " (2060, 11): 37.20308828353882,\n", + " (2060, 12): 77.83739995956421}},\n", + " 399: {'monthly': {(2060, 1): 245.70601892471313,\n", + " (2060, 2): 413.47299790382385,\n", + " (2060, 3): 508.2695655822754,\n", + " (2060, 4): 102.24265897274017,\n", + " (2060, 5): 13.975409150123596,\n", + " (2060, 6): 5.561388969421387,\n", + " (2060, 7): 5.3613539934158325,\n", + " (2060, 8): 15.71300983428955,\n", + " (2060, 9): 11.62181842327118,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 71.51858794689178,\n", + " (2060, 12): 221.2993847131729},\n", + " 'window': {(2060, 1): 74.19295501708984,\n", + " (2060, 2): 142.76813793182373,\n", + " (2060, 3): 244.49824714660645,\n", + " (2060, 4): 29.844575881958008,\n", + " (2060, 5): 5.943202614784241,\n", + " (2060, 6): 3.1335614919662476,\n", + " (2060, 7): 4.139074444770813,\n", + " (2060, 8): 10.142621159553528,\n", + " (2060, 9): 9.377268433570862,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 49.69819498062134,\n", + " (2060, 12): 84.37740707397461}},\n", + " 400: {'monthly': {(2060, 1): 234.0209275484085,\n", + " (2060, 2): 408.09785771369934,\n", + " (2060, 3): 378.5128836631775,\n", + " (2060, 4): 94.26080524921417,\n", + " (2060, 5): 11.635520339012146,\n", + " (2060, 6): 2.7979520559310913,\n", + " (2060, 7): 4.934548020362854,\n", + " (2060, 8): 15.584167242050171,\n", + " (2060, 9): 13.62068259716034,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 58.419045209884644,\n", + " (2060, 12): 214.05052614212036},\n", + " 'window': {(2060, 1): 76.73259496688843,\n", + " (2060, 2): 117.3711748123169,\n", + " (2060, 3): 123.36674308776855,\n", + " (2060, 4): 28.810535669326782,\n", + " (2060, 5): 5.73104453086853,\n", + " (2060, 6): 1.6978181600570679,\n", + " (2060, 7): 3.7122684717178345,\n", + " (2060, 8): 10.582456588745117,\n", + " (2060, 9): 10.263890862464905,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 46.9905366897583,\n", + " (2060, 12): 82.02348041534424}},\n", + " 401: {'monthly': {(2060, 1): 182.53255367279053,\n", + " (2060, 2): 354.0712718963623,\n", + " (2060, 3): 341.4970989227295,\n", + " (2060, 4): 80.3007060289383,\n", + " (2060, 5): 7.215013146400452,\n", + " (2060, 6): 2.353039026260376,\n", + " (2060, 7): 4.544814467430115,\n", + " (2060, 8): 20.57498562335968,\n", + " (2060, 9): 10.0422922372818,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 58.45682907104492,\n", + " (2060, 12): 192.56854820251465},\n", + " 'window': {(2060, 1): 60.06119108200073,\n", + " (2060, 2): 105.36514616012573,\n", + " (2060, 3): 107.3717269897461,\n", + " (2060, 4): 26.8936425447464,\n", + " (2060, 5): 3.197645664215088,\n", + " (2060, 6): 1.2529051303863525,\n", + " (2060, 7): 3.322534918785095,\n", + " (2060, 8): 12.79876446723938,\n", + " (2060, 9): 7.3534733057022095,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 44.47119665145874,\n", + " (2060, 12): 68.29741191864014}},\n", + " 402: {'monthly': {(2060, 1): 180.40419614315033,\n", + " (2060, 2): 310.66334998607635,\n", + " (2060, 3): 339.30133152008057,\n", + " (2060, 4): 94.22539806365967,\n", + " (2060, 5): 5.011135578155518,\n", + " (2060, 6): 1.1001338958740234,\n", + " (2060, 7): 4.58988082408905,\n", + " (2060, 8): 23.42420721054077,\n", + " (2060, 9): 6.5219727754592896,\n", + " (2060, 10): 2.180383801460266,\n", + " (2060, 11): 79.86272585391998,\n", + " (2060, 12): 209.32002115249634},\n", + " 'window': {(2060, 1): 54.268592834472656,\n", + " (2060, 2): 88.99106407165527,\n", + " (2060, 3): 73.55516338348389,\n", + " (2060, 4): 31.009188652038574,\n", + " (2060, 5): 2.2252795696258545,\n", + " (2060, 6): 1.1001338958740234,\n", + " (2060, 7): 3.3676012754440308,\n", + " (2060, 8): 14.12121832370758,\n", + " (2060, 9): 4.326612591743469,\n", + " (2060, 10): 1.1275582313537598,\n", + " (2060, 11): 57.85994911193848,\n", + " (2060, 12): 60.12688732147217}},\n", + " 403: {'monthly': {(2060, 1): 196.3598129749298,\n", + " (2060, 2): 246.37176132202148,\n", + " (2060, 3): 483.29211859862517,\n", + " (2060, 4): 49.38131284713745,\n", + " (2060, 5): 2.154682159423828,\n", + " (2060, 6): 3.583376169204712,\n", + " (2060, 7): 5.150723814964294,\n", + " (2060, 8): 3.693593382835388,\n", + " (2060, 9): 2.9961105585098267,\n", + " (2060, 10): 12.861897587776184,\n", + " (2060, 11): 87.96863543987274,\n", + " (2060, 12): 288.2983100414276},\n", + " 'window': {(2060, 1): 39.65866565704346,\n", + " (2060, 2): 57.39243125915527,\n", + " (2060, 3): 298.29471438090513,\n", + " (2060, 4): 18.085238695144653,\n", + " (2060, 5): 1.095497488975525,\n", + " (2060, 6): 3.583376169204712,\n", + " (2060, 7): 2.690177321434021,\n", + " (2060, 8): 3.693593382835388,\n", + " (2060, 9): 1.5195870399475098,\n", + " (2060, 10): 11.799139738082886,\n", + " (2060, 11): 51.26972579956055,\n", + " (2060, 12): 68.86570072174072}},\n", + " 404: {'monthly': {(2060, 1): 238.7878541946411,\n", + " (2060, 2): 292.27020812034607,\n", + " (2060, 3): 479.9357976913452,\n", + " (2060, 4): 83.78089928627014,\n", + " (2060, 5): 9.395422101020813,\n", + " (2060, 6): 13.224797010421753,\n", + " (2060, 7): 12.64035940170288,\n", + " (2060, 8): 13.451868295669556,\n", + " (2060, 9): 5.810625076293945,\n", + " (2060, 10): 5.244746804237366,\n", + " (2060, 11): 124.66048514842987,\n", + " (2060, 12): 270.4815262556076},\n", + " 'window': {(2060, 1): 63.35719871520996,\n", + " (2060, 2): 70.49827003479004,\n", + " (2060, 3): 202.89666366577148,\n", + " (2060, 4): 28.10769557952881,\n", + " (2060, 5): 3.4045532941818237,\n", + " (2060, 6): 7.408227443695068,\n", + " (2060, 7): 5.834046721458435,\n", + " (2060, 8): 7.269902348518372,\n", + " (2060, 9): 3.217884063720703,\n", + " (2060, 10): 4.119532942771912,\n", + " (2060, 11): 53.5027494430542,\n", + " (2060, 12): 60.83675956726074}},\n", + " 405: {'monthly': {(2060, 1): 292.4732359647751,\n", + " (2060, 2): 382.6192411184311,\n", + " (2060, 3): 528.2872772216797,\n", + " (2060, 4): 108.56950843334198,\n", + " (2060, 5): 12.171101093292236,\n", + " (2060, 6): 13.22629189491272,\n", + " (2060, 7): 11.88454532623291,\n", + " (2060, 8): 14.461140155792236,\n", + " (2060, 9): 4.054514169692993,\n", + " (2060, 10): 4.793469548225403,\n", + " (2060, 11): 163.01872980594635,\n", + " (2060, 12): 357.3731589317322},\n", + " 'window': {(2060, 1): 87.32725429534912,\n", + " (2060, 2): 92.65578937530518,\n", + " (2060, 3): 211.7975368499756,\n", + " (2060, 4): 42.576441526412964,\n", + " (2060, 5): 6.069156169891357,\n", + " (2060, 6): 6.142275929450989,\n", + " (2060, 7): 5.359254479408264,\n", + " (2060, 8): 10.24174439907074,\n", + " (2060, 9): 2.9504313468933105,\n", + " (2060, 10): 3.6682556867599487,\n", + " (2060, 11): 85.35194778442383,\n", + " (2060, 12): 77.05051970481873}},\n", + " 406: {'monthly': {(2060, 1): 317.82204926013947,\n", + " (2060, 2): 463.4726142883301,\n", + " (2060, 3): 537.5396654605865,\n", + " (2060, 4): 152.02888524532318,\n", + " (2060, 5): 31.713175892829895,\n", + " (2060, 6): 28.972116231918335,\n", + " (2060, 7): 23.58301615715027,\n", + " (2060, 8): 26.029626607894897,\n", + " (2060, 9): 9.797928810119629,\n", + " (2060, 10): 8.11636996269226,\n", + " (2060, 11): 177.37964797019958,\n", + " (2060, 12): 373.1324019432068},\n", + " 'window': {(2060, 1): 97.14371585845947,\n", + " (2060, 2): 135.4565944671631,\n", + " (2060, 3): 189.29216766357422,\n", + " (2060, 4): 56.97385382652283,\n", + " (2060, 5): 13.392403721809387,\n", + " (2060, 6): 12.32433831691742,\n", + " (2060, 7): 9.048748970031738,\n", + " (2060, 8): 16.265652418136597,\n", + " (2060, 9): 5.336654186248779,\n", + " (2060, 10): 5.606100559234619,\n", + " (2060, 11): 88.3971471786499,\n", + " (2060, 12): 87.59915542602539}},\n", + " 407: {'monthly': {(2060, 1): 377.8040108680725,\n", + " (2060, 2): 774.203827381134,\n", + " (2060, 3): 688.7102947235107,\n", + " (2060, 4): 279.0478266477585,\n", + " (2060, 5): 61.81012487411499,\n", + " (2060, 6): 60.76754426956177,\n", + " (2060, 7): 48.65524399280548,\n", + " (2060, 8): 52.75159752368927,\n", + " (2060, 9): 34.2694753408432,\n", + " (2060, 10): 29.455424189567566,\n", + " (2060, 11): 362.5989394187927,\n", + " (2060, 12): 541.9798908233643},\n", + " 'window': {(2060, 1): 102.00224351882935,\n", + " (2060, 2): 250.88389587402344,\n", + " (2060, 3): 197.5661163330078,\n", + " (2060, 4): 97.6500129699707,\n", + " (2060, 5): 22.62512707710266,\n", + " (2060, 6): 19.007150173187256,\n", + " (2060, 7): 17.029131531715393,\n", + " (2060, 8): 23.17730677127838,\n", + " (2060, 9): 14.88995361328125,\n", + " (2060, 10): 15.120574951171875,\n", + " (2060, 11): 173.27826118469238,\n", + " (2060, 12): 127.08307075500488}},\n", + " 408: {'monthly': {(2060, 1): 431.3441972732544,\n", + " (2060, 2): 804.7721133232117,\n", + " (2060, 3): 957.2688627243042,\n", + " (2060, 4): 384.7500445842743,\n", + " (2060, 5): 74.12683534622192,\n", + " (2060, 6): 58.16435670852661,\n", + " (2060, 7): 47.66283357143402,\n", + " (2060, 8): 63.28366303443909,\n", + " (2060, 9): 30.677345395088196,\n", + " (2060, 10): 36.11995351314545,\n", + " (2060, 11): 482.91958475112915,\n", + " (2060, 12): 590.8008258342743},\n", + " 'window': {(2060, 1): 98.92491722106934,\n", + " (2060, 2): 223.77575302124023,\n", + " (2060, 3): 295.0255470275879,\n", + " (2060, 4): 109.60820388793945,\n", + " (2060, 5): 21.578359842300415,\n", + " (2060, 6): 16.933898448944092,\n", + " (2060, 7): 15.980869054794312,\n", + " (2060, 8): 31.91434097290039,\n", + " (2060, 9): 16.354255437850952,\n", + " (2060, 10): 16.497796893119812,\n", + " (2060, 11): 249.26858520507812,\n", + " (2060, 12): 140.91806316375732}},\n", + " 409: {'monthly': {(2060, 1): 383.6432566642761,\n", + " (2060, 2): 528.6054552793503,\n", + " (2060, 3): 509.03156042099,\n", + " (2060, 4): 158.3938615322113,\n", + " (2060, 5): 38.40198767185211,\n", + " (2060, 6): 29.96491241455078,\n", + " (2060, 7): 29.097022891044617,\n", + " (2060, 8): 34.097121715545654,\n", + " (2060, 9): 18.60576832294464,\n", + " (2060, 10): 7.726705312728882,\n", + " (2060, 11): 159.44412577152252,\n", + " (2060, 12): 408.3059034347534},\n", + " 'window': {(2060, 1): 99.06028175354004,\n", + " (2060, 2): 126.7251386642456,\n", + " (2060, 3): 119.1760482788086,\n", + " (2060, 4): 46.52912664413452,\n", + " (2060, 5): 11.382547497749329,\n", + " (2060, 6): 8.368535041809082,\n", + " (2060, 7): 11.073208928108215,\n", + " (2060, 8): 16.591158270835876,\n", + " (2060, 9): 9.902977585792542,\n", + " (2060, 10): 5.295559644699097,\n", + " (2060, 11): 72.62580394744873,\n", + " (2060, 12): 92.80438232421875}},\n", + " 410: {'monthly': {(2060, 1): 396.3887552022934,\n", + " (2060, 2): 488.77420127391815,\n", + " (2060, 3): 394.5746259689331,\n", + " (2060, 4): 100.49166095256805,\n", + " (2060, 5): 23.729541778564453,\n", + " (2060, 6): 16.239485502243042,\n", + " (2060, 7): 14.031019687652588,\n", + " (2060, 8): 19.023053288459778,\n", + " (2060, 9): 7.581433653831482,\n", + " (2060, 10): 5.980183005332947,\n", + " (2060, 11): 103.06668674945831,\n", + " (2060, 12): 317.96959018707275},\n", + " 'window': {(2060, 1): 89.62166023254395,\n", + " (2060, 2): 153.3630599975586,\n", + " (2060, 3): 127.13924026489258,\n", + " (2060, 4): 29.538582801818848,\n", + " (2060, 5): 8.084280014038086,\n", + " (2060, 6): 4.747771739959717,\n", + " (2060, 7): 6.611858010292053,\n", + " (2060, 8): 10.808509826660156,\n", + " (2060, 9): 6.056316494941711,\n", + " (2060, 10): 4.539600729942322,\n", + " (2060, 11): 49.19427132606506,\n", + " (2060, 12): 78.33022832870483}},\n", + " 411: {'monthly': {(2060, 1): 318.57862305641174,\n", + " (2060, 2): 388.48229598999023,\n", + " (2060, 3): 329.4960651397705,\n", + " (2060, 4): 102.12607395648956,\n", + " (2060, 5): 23.713073134422302,\n", + " (2060, 6): 16.996713876724243,\n", + " (2060, 7): 14.51868486404419,\n", + " (2060, 8): 18.732498168945312,\n", + " (2060, 9): 5.199883580207825,\n", + " (2060, 10): 7.161988258361816,\n", + " (2060, 11): 92.68513882160187,\n", + " (2060, 12): 275.14665138721466},\n", + " 'window': {(2060, 1): 81.4317855834961,\n", + " (2060, 2): 119.13172054290771,\n", + " (2060, 3): 104.27430725097656,\n", + " (2060, 4): 28.203325271606445,\n", + " (2060, 5): 8.427308201789856,\n", + " (2060, 6): 5.263314843177795,\n", + " (2060, 7): 7.099523186683655,\n", + " (2060, 8): 10.879189848899841,\n", + " (2060, 9): 3.6929961442947388,\n", + " (2060, 10): 4.716800570487976,\n", + " (2060, 11): 34.59502649307251,\n", + " (2060, 12): 72.55381512641907}},\n", + " 412: {'monthly': {(2060, 1): 222.95177721977234,\n", + " (2060, 2): 358.06726920604706,\n", + " (2060, 3): 347.0173704624176,\n", + " (2060, 4): 87.16961205005646,\n", + " (2060, 5): 12.909620881080627,\n", + " (2060, 6): 5.2972400188446045,\n", + " (2060, 7): 7.4396796226501465,\n", + " (2060, 8): 15.898763060569763,\n", + " (2060, 9): 8.967061877250671,\n", + " (2060, 10): 3.6281979084014893,\n", + " (2060, 11): 58.260279297828674,\n", + " (2060, 12): 191.42774665355682},\n", + " 'window': {(2060, 1): 64.14304733276367,\n", + " (2060, 2): 114.34648704528809,\n", + " (2060, 3): 113.39249420166016,\n", + " (2060, 4): 25.5884952545166,\n", + " (2060, 5): 5.754013657569885,\n", + " (2060, 6): 2.5933408737182617,\n", + " (2060, 7): 3.743940234184265,\n", + " (2060, 8): 9.544410467147827,\n", + " (2060, 9): 7.107293725013733,\n", + " (2060, 10): 1.299540400505066,\n", + " (2060, 11): 45.06333780288696,\n", + " (2060, 12): 68.73081874847412}},\n", + " 413: {'monthly': {(2060, 1): 236.56936275959015,\n", + " (2060, 2): 382.82111299037933,\n", + " (2060, 3): 325.90502882003784,\n", + " (2060, 4): 91.1471301317215,\n", + " (2060, 5): 7.443886995315552,\n", + " (2060, 6): 2.541271686553955,\n", + " (2060, 7): 6.82205867767334,\n", + " (2060, 8): 18.807412981987,\n", + " (2060, 9): 13.761752009391785,\n", + " (2060, 10): 3.9475055932998657,\n", + " (2060, 11): 61.41736054420471,\n", + " (2060, 12): 209.23910212516785},\n", + " 'window': {(2060, 1): 81.36568546295166,\n", + " (2060, 2): 110.4469518661499,\n", + " (2060, 3): 95.83870601654053,\n", + " (2060, 4): 27.79420495033264,\n", + " (2060, 5): 3.847191095352173,\n", + " (2060, 6): 1.4411377906799316,\n", + " (2060, 7): 3.5070899724960327,\n", + " (2060, 8): 10.321667432785034,\n", + " (2060, 9): 11.138159394264221,\n", + " (2060, 10): 2.699023127555847,\n", + " (2060, 11): 44.042598247528076,\n", + " (2060, 12): 79.86391115188599}},\n", + " 414: {'monthly': {(2060, 1): 177.36786544322968,\n", + " (2060, 2): 298.20360946655273,\n", + " (2060, 3): 294.2273712158203,\n", + " (2060, 4): 77.22987258434296,\n", + " (2060, 5): 5.911776185035706,\n", + " (2060, 6): 2.113629460334778,\n", + " (2060, 7): 4.58988082408905,\n", + " (2060, 8): 21.059462308883667,\n", + " (2060, 9): 10.599706411361694,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 57.396692514419556,\n", + " (2060, 12): 179.1745297908783},\n", + " 'window': {(2060, 1): 64.06430864334106,\n", + " (2060, 2): 93.3116545677185,\n", + " (2060, 3): 89.10060691833496,\n", + " (2060, 4): 23.9902845621109,\n", + " (2060, 5): 2.5210429430007935,\n", + " (2060, 6): 1.1001338958740234,\n", + " (2060, 7): 3.3676012754440308,\n", + " (2060, 8): 12.859148383140564,\n", + " (2060, 9): 8.444648504257202,\n", + " (2060, 10): 0.0,\n", + " (2060, 11): 44.4221248626709,\n", + " (2060, 12): 66.21320533752441}},\n", + " 415: {'monthly': {(2060, 1): 148.02130699157715,\n", + " (2060, 2): 230.60166609287262,\n", + " (2060, 3): 332.43688344955444,\n", + " (2060, 4): 118.33550751209259,\n", + " (2060, 5): 7.9455002546310425,\n", + " (2060, 6): 1.1001338958740234,\n", + " (2060, 7): 4.58988082408905,\n", + " (2060, 8): 24.35272526741028,\n", + " (2060, 9): 10.444849371910095,\n", + " (2060, 10): 1.0291311740875244,\n", + " (2060, 11): 73.86825597286224,\n", + " (2060, 12): 190.71734309196472},\n", + " 'window': {(2060, 1): 51.939881324768066,\n", + " (2060, 2): 69.68643999099731,\n", + " (2060, 3): 64.99771690368652,\n", + " (2060, 4): 38.55761957168579,\n", + " (2060, 5): 3.281296491622925,\n", + " (2060, 6): 1.1001338958740234,\n", + " (2060, 7): 3.3676012754440308,\n", + " (2060, 8): 14.7510085105896,\n", + " (2060, 9): 7.238506197929382,\n", + " (2060, 10): 1.0291311740875244,\n", + " (2060, 11): 59.883748054504395,\n", + " (2060, 12): 56.30603218078613}}}" ] }, - "execution_count": 14, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 14 + "execution_count": 20 }, { "metadata": { From 36cb13122ae6f60637cfc087869ee0a685b9349f Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 15 Jan 2025 16:21:25 +0000 Subject: [PATCH 200/291] Changed median to mean --- .../CIL_CMIP6_downscaling.ipynb | 16211 ++++------------ 1 file changed, 3779 insertions(+), 12432 deletions(-) diff --git a/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb b/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb index c82ab114a1..0c4fb48a79 100644 --- a/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb +++ b/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb @@ -9,8 +9,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-15T14:15:28.845008Z", - "start_time": "2025-01-15T14:15:28.804393Z" + "end_time": "2025-01-15T15:02:46.479922Z", + "start_time": "2025-01-15T15:02:44.703013Z" } }, "cell_type": "code", @@ -47,7 +47,7 @@ ], "id": "7b5963dac1c0b629", "outputs": [], - "execution_count": 15 + "execution_count": 1 }, { "metadata": { @@ -826,8 +826,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-15T14:15:38.758317Z", - "start_time": "2025-01-15T14:15:38.556568Z" + "end_time": "2025-01-15T15:02:49.730238Z", + "start_time": "2025-01-15T15:02:49.541667Z" } }, "cell_type": "code", @@ -856,18 +856,18 @@ "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/700573990.py:16: DtypeWarning: Columns (58,59,105,127,136,142,149,150,258,285,296,319,344,345,360,393,394,427,428,437,449,450,452,453,461,462,478,479,489,490,492,493,494,497,498,499,500,501,502,503,572,580,585,586,587,588,591,592,593,594,607,608,609,610,619,620,621,622,626,634,872,887,967,978,1066,1510) have mixed types. Specify dtype option on import or set low_memory=False.\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/700573990.py:16: DtypeWarning: Columns (58,59,105,127,136,142,149,150,258,285,296,319,344,345,360,393,394,427,428,437,449,450,452,453,461,462,478,479,489,490,492,493,494,497,498,499,500,501,502,503,572,580,585,586,587,588,591,592,593,594,607,608,609,610,619,620,621,622,626,634,872,887,967,978,1066,1510) have mixed types. Specify dtype option on import or set low_memory=False.\n", " facilities_with_lat_long = pd.read_csv(\n" ] } ], - "execution_count": 17 + "execution_count": 2 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-15T14:15:39.509853Z", - "start_time": "2025-01-15T14:15:39.504469Z" + "end_time": "2025-01-15T15:02:50.454125Z", + "start_time": "2025-01-15T15:02:50.446189Z" } }, "cell_type": "code", @@ -943,13 +943,13 @@ ], "id": "a9a92aa8bbb6b45a", "outputs": [], - "execution_count": 18 + "execution_count": 3 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-01-15T14:43:54.621320Z", - "start_time": "2025-01-15T14:37:49.608103Z" + "end_time": "2025-01-15T16:19:19.414006Z", + "start_time": "2025-01-15T15:44:39.681456Z" } }, "cell_type": "code", @@ -957,6 +957,7 @@ "base_dir = \"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/\"\n", "scenarios = [\"ssp245\", \"ssp585\"]\n", "scenarios = [\"ssp126\"]\n", + "scenarios = [\"ssp585\"]\n", "\n", "window_size = 5\n", "\n", @@ -991,18 +992,19 @@ " pr_aggregated = data_all_models.mean(dim=[\"lat\", \"lon\", \"time\"], skipna=True)\n", " min_model_object = pr_aggregated['pr'].idxmin(dim=\"model\")\n", " min_model = min_model_object.values.item()\n", - " sorted_models = pr_aggregated.sortby(\"model\")\n", - " n_models = len(pr_aggregated.model)\n", - " median_index = n_models // 2\n", - " median_model_object = sorted_models[\"model\"][median_index]\n", - " median_model = median_model_object.values.item()\n", + "\n", + " overall_mean = pr_aggregated['pr'].mean(dim=\"model\")\n", + " abs_diff = abs(pr_aggregated['pr'] - overall_mean)\n", + " mean_model_object = abs_diff.idxmin(dim=\"model\")\n", + " mean_model = mean_model_object.values.item()\n", + "\n", " max_model_object = pr_aggregated['pr'].idxmax(dim=\"model\")\n", " max_model = max_model_object.values.item()\n", "\n", - " models_of_interest = [min_model, median_model, max_model]\n", + " models_of_interest = [min_model, mean_model, max_model]\n", " print(\"Models of interest\", models_of_interest)\n", "\n", - " # Initialize cumulative storage for models of interest\n", + " #Initialize cumulative storage for models of interest\n", " cumulative_weather_dfs = {\n", " model: {\"monthly\": pd.DataFrame(), \"window\": pd.DataFrame()}\n", " for model in models_of_interest\n", @@ -1070,7 +1072,7 @@ " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", " model_categories = {\n", " min_model: \"lowest\",\n", - " median_model: \"median\",\n", + " mean_model: \"mean\",\n", " max_model: \"highest\"\n", "}\n", "\n", @@ -1090,9 +1092,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "Processing scenario: ssp126\n", - "Models of interest ['HadGEM3-GC31-LL', 'GFDL-CM4', 'INM-CM5-0']\n", - "Processing file: CIL_subset_ssp126_2024.nc\n", + "Processing scenario: ssp585\n", + "Models of interest ['HadGEM3-GC31-LL', 'UKESM1-0-LL', 'INM-CM5-0']\n", + "Processing file: CIL_subset_ssp585_2024.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2024, month 1\n", "Processing year 2024, month 2\n", @@ -1112,945 +1114,945 @@ "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" ] }, @@ -2058,8 +2060,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Model GFDL-CM4 not found in file CIL_subset_ssp126_2024.nc, skipping.\n", - "Processing model: INM-CM5-0\n", + "Processing model: UKESM1-0-LL\n", "Processing year 2024, month 1\n", "Processing year 2024, month 2\n", "Processing year 2024, month 3\n", @@ -2078,945 +2079,945 @@ "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:112: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_96725/2893613327.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" ] }, @@ -3024,11475 +3025,2821 @@ "name": "stdout", "output_type": "stream", "text": [ - "Processing file: CIL_subset_ssp126_2025.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2025, month 1\n", - "Processing year 2025, month 2\n", - "Processing year 2025, month 3\n", - "Processing year 2025, month 4\n", - "Processing year 2025, month 5\n", - "Processing year 2025, month 6\n", - "Processing year 2025, month 7\n", - "Processing year 2025, month 8\n", - "Processing year 2025, month 9\n", - "Processing year 2025, month 10\n", - "Processing year 2025, month 11\n", - "Processing year 2025, month 12\n", - "Model GFDL-CM4 not found in file CIL_subset_ssp126_2025.nc, skipping.\n", - "Processing model: INM-CM5-0\n", - "Processing year 2025, month 1\n", - "Processing year 2025, month 2\n", - "Processing year 2025, month 3\n", - "Processing year 2025, month 4\n", - "Processing year 2025, month 5\n", - "Processing year 2025, month 6\n", - "Processing year 2025, month 7\n", - "Processing year 2025, month 8\n", - "Processing year 2025, month 9\n", - "Processing year 2025, month 10\n", - "Processing year 2025, month 11\n", - "Processing year 2025, month 12\n", - "Processing file: CIL_subset_ssp126_2026.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2026, month 1\n", - "Processing year 2026, month 2\n", - "Processing year 2026, month 3\n", - "Processing year 2026, month 4\n", - "Processing year 2026, month 5\n", - "Processing year 2026, month 6\n", - "Processing year 2026, month 7\n", - "Processing year 2026, month 8\n", - "Processing year 2026, month 9\n", - "Processing year 2026, month 10\n", - "Processing year 2026, month 11\n", - "Processing year 2026, month 12\n", - "Model GFDL-CM4 not found in file CIL_subset_ssp126_2026.nc, skipping.\n", - "Processing model: INM-CM5-0\n", - "Processing year 2026, month 1\n", - "Processing year 2026, month 2\n", - "Processing year 2026, month 3\n", - "Processing year 2026, month 4\n", - "Processing year 2026, month 5\n", - "Processing year 2026, month 6\n", - "Processing year 2026, month 7\n", - "Processing year 2026, month 8\n", - "Processing year 2026, month 9\n", - "Processing year 2026, month 10\n", - "Processing year 2026, month 11\n", - "Processing year 2026, month 12\n", - "Processing file: CIL_subset_ssp126_2027.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2027, month 1\n", - "Processing year 2027, month 2\n", - "Processing year 2027, month 3\n", - "Processing year 2027, month 4\n", - "Processing year 2027, month 5\n", - "Processing year 2027, month 6\n", - "Processing year 2027, month 7\n", - "Processing year 2027, month 8\n", - "Processing year 2027, month 9\n", - "Processing year 2027, month 10\n", - "Processing year 2027, month 11\n", - "Processing year 2027, month 12\n", - "Model GFDL-CM4 not found in file CIL_subset_ssp126_2027.nc, skipping.\n", - "Processing model: INM-CM5-0\n", - "Processing year 2027, month 1\n", - "Processing year 2027, month 2\n", - "Processing year 2027, month 3\n", - "Processing year 2027, month 4\n", - "Processing year 2027, month 5\n", - "Processing year 2027, month 6\n", - "Processing year 2027, month 7\n", - "Processing year 2027, month 8\n", - "Processing year 2027, month 9\n", - "Processing year 2027, month 10\n", - "Processing year 2027, month 11\n", - "Processing year 2027, month 12\n", - "Processing file: CIL_subset_ssp126_2028.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2028, month 1\n", - "Processing year 2028, month 2\n", - "Processing year 2028, month 3\n", - "Processing year 2028, month 4\n", - "Processing year 2028, month 5\n", - "Processing year 2028, month 6\n", - "Processing year 2028, month 7\n", - "Processing year 2028, month 8\n", - "Processing year 2028, month 9\n", - "Processing year 2028, month 10\n", - "Processing year 2028, month 11\n", - "Processing year 2028, month 12\n", - "Model GFDL-CM4 not found in file CIL_subset_ssp126_2028.nc, skipping.\n", - "Processing model: INM-CM5-0\n", - "Processing year 2028, month 1\n", - "Processing year 2028, month 2\n", - "Processing year 2028, month 3\n", - "Processing year 2028, month 4\n", - "Processing year 2028, month 5\n", - "Processing year 2028, month 6\n", - "Processing year 2028, month 7\n", - "Processing year 2028, month 8\n", - "Processing year 2028, month 9\n", - "Processing year 2028, month 10\n", - "Processing year 2028, month 11\n", - "Processing year 2028, month 12\n", - "Processing file: CIL_subset_ssp126_2029.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2029, month 1\n", - "Processing year 2029, month 2\n", - "Processing year 2029, month 3\n", - "Processing year 2029, month 4\n", - "Processing year 2029, month 5\n", - "Processing year 2029, month 6\n", - "Processing year 2029, month 7\n", - "Processing year 2029, month 8\n", - "Processing year 2029, month 9\n", - "Processing year 2029, month 10\n", - "Processing year 2029, month 11\n", - "Processing year 2029, month 12\n", - "Model GFDL-CM4 not found in file CIL_subset_ssp126_2029.nc, skipping.\n", - "Processing model: INM-CM5-0\n", - "Processing year 2029, month 1\n", - "Processing year 2029, month 2\n", - "Processing year 2029, month 3\n", - "Processing year 2029, month 4\n", - "Processing year 2029, month 5\n", - "Processing year 2029, month 6\n", - "Processing year 2029, month 7\n", - "Processing year 2029, month 8\n", - "Processing year 2029, month 9\n", - "Processing year 2029, month 10\n", - "Processing year 2029, month 11\n", - "Processing year 2029, month 12\n", - "Processing file: CIL_subset_ssp126_2030.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2030, month 1\n", - "Processing year 2030, month 2\n", - "Processing year 2030, month 3\n", - "Processing year 2030, month 4\n", - "Processing year 2030, month 5\n", - "Processing year 2030, month 6\n", - "Processing year 2030, month 7\n", - "Processing year 2030, month 8\n", - "Processing year 2030, month 9\n", - "Processing year 2030, month 10\n", - "Processing year 2030, month 11\n", - "Processing year 2030, month 12\n", - "Model GFDL-CM4 not found in file CIL_subset_ssp126_2030.nc, skipping.\n", - "Processing model: INM-CM5-0\n", - "Processing year 2030, month 1\n", - "Processing year 2030, month 2\n", - "Processing year 2030, month 3\n", - "Processing year 2030, month 4\n", - "Processing year 2030, month 5\n", - "Processing year 2030, month 6\n", - "Processing year 2030, month 7\n", - "Processing year 2030, month 8\n", - "Processing year 2030, month 9\n", - "Processing year 2030, month 10\n", - "Processing year 2030, month 11\n", - "Processing year 2030, month 12\n", - "Processing file: CIL_subset_ssp126_2031.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2031, month 1\n", - "Processing year 2031, month 2\n", - "Processing year 2031, month 3\n", - "Processing year 2031, month 4\n", - "Processing year 2031, month 5\n", - "Processing year 2031, month 6\n", - "Processing year 2031, month 7\n", - "Processing year 2031, month 8\n", - "Processing year 2031, month 9\n", - "Processing year 2031, month 10\n", - "Processing year 2031, month 11\n", - "Processing year 2031, month 12\n", - "Model GFDL-CM4 not found in file CIL_subset_ssp126_2031.nc, skipping.\n", - "Processing model: INM-CM5-0\n", - "Processing year 2031, month 1\n", - "Processing year 2031, month 2\n", - "Processing year 2031, month 3\n", - "Processing year 2031, month 4\n", - "Processing year 2031, month 5\n", - "Processing year 2031, month 6\n", - "Processing year 2031, month 7\n", - "Processing year 2031, month 8\n", - "Processing year 2031, month 9\n", - "Processing year 2031, month 10\n", - "Processing year 2031, month 11\n", - "Processing year 2031, month 12\n", - "Processing file: CIL_subset_ssp126_2032.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2032, month 1\n", - "Processing year 2032, month 2\n", - "Processing year 2032, month 3\n", - "Processing year 2032, month 4\n", - "Processing year 2032, month 5\n", - "Processing year 2032, month 6\n", - "Processing year 2032, month 7\n", - "Processing year 2032, month 8\n", - "Processing year 2032, month 9\n", - "Processing year 2032, month 10\n", - "Processing year 2032, month 11\n", - "Processing year 2032, month 12\n", - "Model GFDL-CM4 not found in file CIL_subset_ssp126_2032.nc, skipping.\n", - "Processing model: INM-CM5-0\n", - "Processing year 2032, month 1\n", - "Processing year 2032, month 2\n", - "Processing year 2032, month 3\n", - "Processing year 2032, month 4\n", - "Processing year 2032, month 5\n", - "Processing year 2032, month 6\n", - "Processing year 2032, month 7\n", - "Processing year 2032, month 8\n", - "Processing year 2032, month 9\n", - "Processing year 2032, month 10\n", - "Processing year 2032, month 11\n", - "Processing year 2032, month 12\n", - "Processing file: CIL_subset_ssp126_2033.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2033, month 1\n", - "Processing year 2033, month 2\n", - "Processing year 2033, month 3\n", - "Processing year 2033, month 4\n", - "Processing year 2033, month 5\n", - "Processing year 2033, month 6\n", - "Processing year 2033, month 7\n", - "Processing year 2033, month 8\n", - "Processing year 2033, month 9\n", - "Processing year 2033, month 10\n", - "Processing year 2033, month 11\n", - "Processing year 2033, month 12\n", - "Model GFDL-CM4 not found in file CIL_subset_ssp126_2033.nc, skipping.\n", "Processing model: INM-CM5-0\n", - "Processing year 2033, month 1\n", - "Processing year 2033, month 2\n", - "Processing year 2033, month 3\n", - "Processing year 2033, month 4\n", - "Processing year 2033, month 5\n", - "Processing year 2033, month 6\n", - "Processing year 2033, month 7\n", - "Processing year 2033, month 8\n", - "Processing year 2033, month 9\n", - "Processing year 2033, month 10\n", - "Processing year 2033, month 11\n", - "Processing year 2033, month 12\n", - "Processing file: CIL_subset_ssp126_2034.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2034, month 1\n", - "Processing year 2034, month 2\n", - "Processing year 2034, month 3\n", - "Processing year 2034, month 4\n", - "Processing year 2034, month 5\n", - "Processing year 2034, month 6\n", - "Processing year 2034, month 7\n", - "Processing year 2034, month 8\n", - "Processing year 2034, month 9\n", - "Processing year 2034, month 10\n", - "Processing year 2034, month 11\n", - "Processing year 2034, month 12\n", - "Model GFDL-CM4 not found in file CIL_subset_ssp126_2034.nc, skipping.\n", - "Processing model: INM-CM5-0\n", - "Processing year 2034, month 1\n", - "Processing year 2034, month 2\n", - "Processing year 2034, month 3\n", - "Processing year 2034, month 4\n", - "Processing year 2034, month 5\n", - "Processing year 2034, month 6\n", - "Processing year 2034, month 7\n", - "Processing year 2034, month 8\n", - "Processing year 2034, month 9\n", - "Processing year 2034, month 10\n", - "Processing year 2034, month 11\n", - "Processing year 2034, month 12\n", - "Processing file: CIL_subset_ssp126_2035.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2035, month 1\n", - "Processing year 2035, month 2\n", - "Processing year 2035, month 3\n", - "Processing year 2035, month 4\n", - "Processing year 2035, month 5\n", - "Processing year 2035, month 6\n", - "Processing year 2035, month 7\n", - "Processing year 2035, month 8\n", - "Processing year 2035, month 9\n", - "Processing year 2035, month 10\n", - "Processing year 2035, month 11\n", - "Processing year 2035, month 12\n", - "Model GFDL-CM4 not found in file CIL_subset_ssp126_2035.nc, skipping.\n", - "Processing model: INM-CM5-0\n", - "Processing year 2035, month 1\n", - "Processing year 2035, month 2\n", - "Processing year 2035, month 3\n", - "Processing year 2035, month 4\n", - "Processing year 2035, month 5\n", - "Processing year 2035, month 6\n", - "Processing year 2035, month 7\n", - "Processing year 2035, month 8\n", - "Processing year 2035, month 9\n", - "Processing year 2035, month 10\n", - "Processing year 2035, month 11\n", - "Processing year 2035, month 12\n", - "Processing file: CIL_subset_ssp126_2036.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2036, month 1\n", - "Processing year 2036, month 2\n", - "Processing year 2036, month 3\n", - "Processing year 2036, month 4\n", - "Processing year 2036, month 5\n", - "Processing year 2036, month 6\n", - "Processing year 2036, month 7\n", - "Processing year 2036, month 8\n", - "Processing year 2036, month 9\n", - "Processing year 2036, month 10\n", - "Processing year 2036, month 11\n", - "Processing year 2036, month 12\n", - "Model GFDL-CM4 not found in file CIL_subset_ssp126_2036.nc, skipping.\n", - "Processing model: INM-CM5-0\n", - "Processing year 2036, month 1\n", - "Processing year 2036, month 2\n", - "Processing year 2036, month 3\n", - "Processing year 2036, month 4\n", - "Processing year 2036, month 5\n", - "Processing year 2036, month 6\n", - "Processing year 2036, month 7\n", - "Processing year 2036, month 8\n", - "Processing year 2036, month 9\n", - "Processing year 2036, month 10\n", - "Processing year 2036, month 11\n", - "Processing year 2036, month 12\n", - "Processing file: CIL_subset_ssp126_2037.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2037, month 1\n", - "Processing year 2037, month 2\n", - "Processing year 2037, month 3\n", - "Processing year 2037, month 4\n", - "Processing year 2037, month 5\n", - "Processing year 2037, month 6\n", - "Processing year 2037, month 7\n", - "Processing year 2037, month 8\n", - "Processing year 2037, month 9\n", - "Processing year 2037, month 10\n", - "Processing year 2037, month 11\n", - "Processing year 2037, month 12\n", - "Model GFDL-CM4 not found in file CIL_subset_ssp126_2037.nc, skipping.\n", - "Processing model: INM-CM5-0\n", - "Processing year 2037, month 1\n", - "Processing year 2037, month 2\n", - "Processing year 2037, month 3\n", - "Processing year 2037, month 4\n", - "Processing year 2037, month 5\n", - "Processing year 2037, month 6\n", - "Processing year 2037, month 7\n", - "Processing year 2037, month 8\n", - "Processing year 2037, month 9\n", - "Processing year 2037, month 10\n", - "Processing year 2037, month 11\n", - "Processing year 2037, month 12\n", - "Processing file: CIL_subset_ssp126_2038.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2038, month 1\n", - "Processing year 2038, month 2\n", - "Processing year 2038, month 3\n", - "Processing year 2038, month 4\n", - "Processing year 2038, month 5\n", - "Processing year 2038, month 6\n", - "Processing year 2038, month 7\n", - "Processing year 2038, month 8\n", - "Processing year 2038, month 9\n", - "Processing year 2038, month 10\n", - "Processing year 2038, month 11\n", - "Processing year 2038, month 12\n", - "Model GFDL-CM4 not found in file CIL_subset_ssp126_2038.nc, skipping.\n", - "Processing model: INM-CM5-0\n", - "Processing year 2038, month 1\n", - "Processing year 2038, month 2\n", - "Processing year 2038, month 3\n", - "Processing year 2038, month 4\n", - "Processing year 2038, month 5\n", - "Processing year 2038, month 6\n", - "Processing year 2038, month 7\n", - "Processing year 2038, month 8\n", - "Processing year 2038, month 9\n", - "Processing year 2038, month 10\n", - "Processing year 2038, month 11\n", - "Processing year 2038, month 12\n", - "Processing file: CIL_subset_ssp126_2039.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2039, month 1\n", - "Processing year 2039, month 2\n", - "Processing year 2039, month 3\n", - "Processing year 2039, month 4\n", - "Processing year 2039, month 5\n", - "Processing year 2039, month 6\n", - "Processing year 2039, month 7\n", - "Processing year 2039, month 8\n", - "Processing year 2039, month 9\n", - "Processing year 2039, month 10\n", - "Processing year 2039, month 11\n", - "Processing year 2039, month 12\n", - "Model GFDL-CM4 not found in file CIL_subset_ssp126_2039.nc, skipping.\n", - "Processing model: INM-CM5-0\n", - "Processing year 2039, month 1\n", - "Processing year 2039, month 2\n", - "Processing year 2039, month 3\n", - "Processing year 2039, month 4\n", - "Processing year 2039, month 5\n", - "Processing year 2039, month 6\n", - "Processing year 2039, month 7\n", - "Processing year 2039, month 8\n", - "Processing year 2039, month 9\n", - "Processing year 2039, month 10\n", - "Processing year 2039, month 11\n", - "Processing year 2039, month 12\n", - "Processing file: CIL_subset_ssp126_2040.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2040, month 1\n", - "Processing year 2040, month 2\n", - "Processing year 2040, month 3\n", - "Processing year 2040, month 4\n", - "Processing year 2040, month 5\n", - "Processing year 2040, month 6\n", - "Processing year 2040, month 7\n", - "Processing year 2040, month 8\n", - "Processing year 2040, month 9\n", - "Processing year 2040, month 10\n", - "Processing year 2040, month 11\n", - "Processing year 2040, month 12\n", - "Model GFDL-CM4 not found in file CIL_subset_ssp126_2040.nc, skipping.\n", - "Processing model: INM-CM5-0\n", - "Processing year 2040, month 1\n", - "Processing year 2040, month 2\n", - "Processing year 2040, month 3\n", - "Processing year 2040, month 4\n", - "Processing year 2040, month 5\n", - "Processing year 2040, month 6\n", - "Processing year 2040, month 7\n", - "Processing year 2040, month 8\n", - "Processing year 2040, month 9\n", - "Processing year 2040, month 10\n", - "Processing year 2040, month 11\n", - "Processing year 2040, month 12\n", - "Processing file: CIL_subset_ssp126_2041.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2041, month 1\n", - "Processing year 2041, month 2\n", - "Processing year 2041, month 3\n", - "Processing year 2041, month 4\n", - "Processing year 2041, month 5\n", - "Processing year 2041, month 6\n", - "Processing year 2041, month 7\n", - "Processing year 2041, month 8\n", - "Processing year 2041, month 9\n", - "Processing year 2041, month 10\n", - "Processing year 2041, month 11\n", - "Processing year 2041, month 12\n", - "Model GFDL-CM4 not found in file CIL_subset_ssp126_2041.nc, skipping.\n", - "Processing model: INM-CM5-0\n", - "Processing year 2041, month 1\n", - "Processing year 2041, month 2\n", - "Processing year 2041, month 3\n", - "Processing year 2041, month 4\n", - "Processing year 2041, month 5\n", - "Processing year 2041, month 6\n", - "Processing year 2041, month 7\n", - "Processing year 2041, month 8\n", - "Processing year 2041, month 9\n", - "Processing year 2041, month 10\n", - "Processing year 2041, month 11\n", - "Processing year 2041, month 12\n", - "Processing file: CIL_subset_ssp126_2042.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2042, month 1\n", - "Processing year 2042, month 2\n", - "Processing year 2042, month 3\n", - "Processing year 2042, month 4\n", - "Processing year 2042, month 5\n", - "Processing year 2042, month 6\n", - "Processing year 2042, month 7\n", - "Processing year 2042, month 8\n", - "Processing year 2042, month 9\n", - "Processing year 2042, month 10\n", - "Processing year 2042, month 11\n", - "Processing year 2042, month 12\n", - "Model GFDL-CM4 not found in file CIL_subset_ssp126_2042.nc, skipping.\n", - "Processing model: INM-CM5-0\n", - "Processing year 2042, month 1\n", - "Processing year 2042, month 2\n", - "Processing year 2042, month 3\n", - "Processing year 2042, month 4\n", - "Processing year 2042, month 5\n", - "Processing year 2042, month 6\n", - "Processing year 2042, month 7\n", - "Processing year 2042, month 8\n", - "Processing year 2042, month 9\n", - "Processing year 2042, month 10\n", - "Processing year 2042, month 11\n", - "Processing year 2042, month 12\n", - "Processing file: CIL_subset_ssp126_2043.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2043, month 1\n", - "Processing year 2043, month 2\n", - "Processing year 2043, month 3\n", - "Processing year 2043, month 4\n", - "Processing year 2043, month 5\n", - "Processing year 2043, month 6\n", - "Processing year 2043, month 7\n", - "Processing year 2043, month 8\n", - "Processing year 2043, month 9\n", - "Processing year 2043, month 10\n", - "Processing year 2043, month 11\n", - "Processing year 2043, month 12\n", - "Model GFDL-CM4 not found in file CIL_subset_ssp126_2043.nc, skipping.\n", - "Processing model: INM-CM5-0\n", - "Processing year 2043, month 1\n", - "Processing year 2043, month 2\n", - "Processing year 2043, month 3\n", - "Processing year 2043, month 4\n", - "Processing year 2043, month 5\n", - "Processing year 2043, month 6\n", - "Processing year 2043, month 7\n", - "Processing year 2043, month 8\n", - "Processing year 2043, month 9\n", - "Processing year 2043, month 10\n", - "Processing year 2043, month 11\n", - "Processing year 2043, month 12\n", - "Processing file: CIL_subset_ssp126_2044.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2044, month 1\n", - "Processing year 2044, month 2\n", - "Processing year 2044, month 3\n", - "Processing year 2044, month 4\n", - "Processing year 2044, month 5\n", - "Processing year 2044, month 6\n", - "Processing year 2044, month 7\n", - "Processing year 2044, month 8\n", - "Processing year 2044, month 9\n", - "Processing year 2044, month 10\n", - "Processing year 2044, month 11\n", - "Processing year 2044, month 12\n", - "Model GFDL-CM4 not found in file CIL_subset_ssp126_2044.nc, skipping.\n", - "Processing model: INM-CM5-0\n", - "Processing year 2044, month 1\n", - "Processing year 2044, month 2\n", - "Processing year 2044, month 3\n", - "Processing year 2044, month 4\n", - "Processing year 2044, month 5\n", - "Processing year 2044, month 6\n", - "Processing year 2044, month 7\n", - "Processing year 2044, month 8\n", - "Processing year 2044, month 9\n", - "Processing year 2044, month 10\n", - "Processing year 2044, month 11\n", - "Processing year 2044, month 12\n", - "Processing file: CIL_subset_ssp126_2045.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2045, month 1\n", - "Processing year 2045, month 2\n", - "Processing year 2045, month 3\n", - "Processing year 2045, month 4\n", - "Processing year 2045, month 5\n", - "Processing year 2045, month 6\n", - "Processing year 2045, month 7\n", - "Processing year 2045, month 8\n", - "Processing year 2045, month 9\n", - "Processing year 2045, month 10\n", - "Processing year 2045, month 11\n", - "Processing year 2045, month 12\n", - "Model GFDL-CM4 not found in file CIL_subset_ssp126_2045.nc, skipping.\n", - "Processing model: INM-CM5-0\n", - "Processing year 2045, month 1\n", - "Processing year 2045, month 2\n", - "Processing year 2045, month 3\n", - "Processing year 2045, month 4\n", - "Processing year 2045, month 5\n", - "Processing year 2045, month 6\n", - "Processing year 2045, month 7\n", - "Processing year 2045, month 8\n", - "Processing year 2045, month 9\n", - "Processing year 2045, month 10\n", - "Processing year 2045, month 11\n", - "Processing year 2045, month 12\n", - "Processing file: CIL_subset_ssp126_2046.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2046, month 1\n", - "Processing year 2046, month 2\n", - "Processing year 2046, month 3\n", - "Processing year 2046, month 4\n", - "Processing year 2046, month 5\n", - "Processing year 2046, month 6\n", - "Processing year 2046, month 7\n", - "Processing year 2046, month 8\n", - "Processing year 2046, month 9\n", - "Processing year 2046, month 10\n", - "Processing year 2046, month 11\n", - "Processing year 2046, month 12\n", - "Model GFDL-CM4 not found in file CIL_subset_ssp126_2046.nc, skipping.\n", - "Processing model: INM-CM5-0\n", - "Processing year 2046, month 1\n", - "Processing year 2046, month 2\n", - "Processing year 2046, month 3\n", - "Processing year 2046, month 4\n", - "Processing year 2046, month 5\n", - "Processing year 2046, month 6\n", - "Processing year 2046, month 7\n", - "Processing year 2046, month 8\n", - "Processing year 2046, month 9\n", - "Processing year 2046, month 10\n", - "Processing year 2046, month 11\n", - "Processing year 2046, month 12\n", - "Processing file: CIL_subset_ssp126_2047.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2047, month 1\n", - "Processing year 2047, month 2\n", - "Processing year 2047, month 3\n", - "Processing year 2047, month 4\n", - "Processing year 2047, month 5\n", - "Processing year 2047, month 6\n", - "Processing year 2047, month 7\n", - "Processing year 2047, month 8\n", - "Processing year 2047, month 9\n", - "Processing year 2047, month 10\n", - "Processing year 2047, month 11\n", - "Processing year 2047, month 12\n", - "Model GFDL-CM4 not found in file CIL_subset_ssp126_2047.nc, skipping.\n", - "Processing model: INM-CM5-0\n", - "Processing year 2047, month 1\n", - "Processing year 2047, month 2\n", - "Processing year 2047, month 3\n", - "Processing year 2047, month 4\n", - "Processing year 2047, month 5\n", - "Processing year 2047, month 6\n", - "Processing year 2047, month 7\n", - "Processing year 2047, month 8\n", - "Processing year 2047, month 9\n", - "Processing year 2047, month 10\n", - "Processing year 2047, month 11\n", - "Processing year 2047, month 12\n", - "Processing file: CIL_subset_ssp126_2048.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2048, month 1\n", - "Processing year 2048, month 2\n", - "Processing year 2048, month 3\n", - "Processing year 2048, month 4\n", - "Processing year 2048, month 5\n", - "Processing year 2048, month 6\n", - "Processing year 2048, month 7\n", - "Processing year 2048, month 8\n", - "Processing year 2048, month 9\n", - "Processing year 2048, month 10\n", - "Processing year 2048, month 11\n", - "Processing year 2048, month 12\n", - "Model GFDL-CM4 not found in file CIL_subset_ssp126_2048.nc, skipping.\n", - "Processing model: INM-CM5-0\n", - "Processing year 2048, month 1\n", - "Processing year 2048, month 2\n", - "Processing year 2048, month 3\n", - "Processing year 2048, month 4\n", - "Processing year 2048, month 5\n", - "Processing year 2048, month 6\n", - "Processing year 2048, month 7\n", - "Processing year 2048, month 8\n", - "Processing year 2048, month 9\n", - "Processing year 2048, month 10\n", - "Processing year 2048, month 11\n", - "Processing year 2048, month 12\n", - "Processing file: CIL_subset_ssp126_2049.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2049, month 1\n", - "Processing year 2049, month 2\n", - "Processing year 2049, month 3\n", - "Processing year 2049, month 4\n", - "Processing year 2049, month 5\n", - "Processing year 2049, month 6\n", - "Processing year 2049, month 7\n", - "Processing year 2049, month 8\n", - "Processing year 2049, month 9\n", - "Processing year 2049, month 10\n", - "Processing year 2049, month 11\n", - "Processing year 2049, month 12\n", - "Model GFDL-CM4 not found in file CIL_subset_ssp126_2049.nc, skipping.\n", - "Processing model: INM-CM5-0\n", - "Processing year 2049, month 1\n", - "Processing year 2049, month 2\n", - "Processing year 2049, month 3\n", - "Processing year 2049, month 4\n", - "Processing year 2049, month 5\n", - "Processing year 2049, month 6\n", - "Processing year 2049, month 7\n", - "Processing year 2049, month 8\n", - "Processing year 2049, month 9\n", - "Processing year 2049, month 10\n", - "Processing year 2049, month 11\n", - "Processing year 2049, month 12\n", - "Processing file: CIL_subset_ssp126_2050.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2050, month 1\n", - "Processing year 2050, month 2\n", - "Processing year 2050, month 3\n", - "Processing year 2050, month 4\n", - "Processing year 2050, month 5\n", - "Processing year 2050, month 6\n", - "Processing year 2050, month 7\n", - "Processing year 2050, month 8\n", - "Processing year 2050, month 9\n", - "Processing year 2050, month 10\n", - "Processing year 2050, month 11\n", - "Processing year 2050, month 12\n", - "Model GFDL-CM4 not found in file CIL_subset_ssp126_2050.nc, skipping.\n", - "Processing model: INM-CM5-0\n", - "Processing year 2050, month 1\n", - "Processing year 2050, month 2\n", - "Processing year 2050, month 3\n", - "Processing year 2050, month 4\n", - "Processing year 2050, month 5\n", - "Processing year 2050, month 6\n", - "Processing year 2050, month 7\n", - "Processing year 2050, month 8\n", - "Processing year 2050, month 9\n", - "Processing year 2050, month 10\n", - "Processing year 2050, month 11\n", - "Processing year 2050, month 12\n", - "Processing file: CIL_subset_ssp126_2051.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2051, month 1\n", - "Processing year 2051, month 2\n", - "Processing year 2051, month 3\n", - "Processing year 2051, month 4\n", - "Processing year 2051, month 5\n", - "Processing year 2051, month 6\n", - "Processing year 2051, month 7\n", - "Processing year 2051, month 8\n", - "Processing year 2051, month 9\n", - "Processing year 2051, month 10\n", - "Processing year 2051, month 11\n", - "Processing year 2051, month 12\n", - "Model GFDL-CM4 not found in file CIL_subset_ssp126_2051.nc, skipping.\n", - "Processing model: INM-CM5-0\n", - "Processing year 2051, month 1\n", - "Processing year 2051, month 2\n", - "Processing year 2051, month 3\n", - "Processing year 2051, month 4\n", - "Processing year 2051, month 5\n", - "Processing year 2051, month 6\n", - "Processing year 2051, month 7\n", - "Processing year 2051, month 8\n", - "Processing year 2051, month 9\n", - "Processing year 2051, month 10\n", - "Processing year 2051, month 11\n", - "Processing year 2051, month 12\n", - "Processing file: CIL_subset_ssp126_2052.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2052, month 1\n", - "Processing year 2052, month 2\n", - "Processing year 2052, month 3\n", - "Processing year 2052, month 4\n", - "Processing year 2052, month 5\n", - "Processing year 2052, month 6\n", - "Processing year 2052, month 7\n", - "Processing year 2052, month 8\n", - "Processing year 2052, month 9\n", - "Processing year 2052, month 10\n", - "Processing year 2052, month 11\n", - "Processing year 2052, month 12\n", - "Model GFDL-CM4 not found in file CIL_subset_ssp126_2052.nc, skipping.\n", - "Processing model: INM-CM5-0\n", - "Processing year 2052, month 1\n", - "Processing year 2052, month 2\n", - "Processing year 2052, month 3\n", - "Processing year 2052, month 4\n", - "Processing year 2052, month 5\n", - "Processing year 2052, month 6\n", - "Processing year 2052, month 7\n", - "Processing year 2052, month 8\n", - "Processing year 2052, month 9\n", - "Processing year 2052, month 10\n", - "Processing year 2052, month 11\n", - "Processing year 2052, month 12\n", - "Processing file: CIL_subset_ssp126_2053.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2053, month 1\n", - "Processing year 2053, month 2\n", - "Processing year 2053, month 3\n", - "Processing year 2053, month 4\n", - "Processing year 2053, month 5\n", - "Processing year 2053, month 6\n", - "Processing year 2053, month 7\n", - "Processing year 2053, month 8\n", - "Processing year 2053, month 9\n", - "Processing year 2053, month 10\n", - "Processing year 2053, month 11\n", - "Processing year 2053, month 12\n", - "Model GFDL-CM4 not found in file CIL_subset_ssp126_2053.nc, skipping.\n", - "Processing model: INM-CM5-0\n", - "Processing year 2053, month 1\n", - "Processing year 2053, month 2\n", - "Processing year 2053, month 3\n", - "Processing year 2053, month 4\n", - "Processing year 2053, month 5\n", - "Processing year 2053, month 6\n", - "Processing year 2053, month 7\n", - "Processing year 2053, month 8\n", - "Processing year 2053, month 9\n", - "Processing year 2053, month 10\n", - "Processing year 2053, month 11\n", - "Processing year 2053, month 12\n", - "Processing file: CIL_subset_ssp126_2054.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2054, month 1\n", - "Processing year 2054, month 2\n", - "Processing year 2054, month 3\n", - "Processing year 2054, month 4\n", - "Processing year 2054, month 5\n", - "Processing year 2054, month 6\n", - "Processing year 2054, month 7\n", - "Processing year 2054, month 8\n", - "Processing year 2054, month 9\n", - "Processing year 2054, month 10\n", - "Processing year 2054, month 11\n", - "Processing year 2054, month 12\n", - "Model GFDL-CM4 not found in file CIL_subset_ssp126_2054.nc, skipping.\n", - "Processing model: INM-CM5-0\n", - "Processing year 2054, month 1\n", - "Processing year 2054, month 2\n", - "Processing year 2054, month 3\n", - "Processing year 2054, month 4\n", - "Processing year 2054, month 5\n", - "Processing year 2054, month 6\n", - "Processing year 2054, month 7\n", - "Processing year 2054, month 8\n", - "Processing year 2054, month 9\n", - "Processing year 2054, month 10\n", - "Processing year 2054, month 11\n", - "Processing year 2054, month 12\n", - "Processing file: CIL_subset_ssp126_2055.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2055, month 1\n", - "Processing year 2055, month 2\n", - "Processing year 2055, month 3\n", - "Processing year 2055, month 4\n", - "Processing year 2055, month 5\n", - "Processing year 2055, month 6\n", - "Processing year 2055, month 7\n", - "Processing year 2055, month 8\n", - "Processing year 2055, month 9\n", - "Processing year 2055, month 10\n", - "Processing year 2055, month 11\n", - "Processing year 2055, month 12\n", - "Model GFDL-CM4 not found in file CIL_subset_ssp126_2055.nc, skipping.\n", - "Processing model: INM-CM5-0\n", - "Processing year 2055, month 1\n", - "Processing year 2055, month 2\n", - "Processing year 2055, month 3\n", - "Processing year 2055, month 4\n", - "Processing year 2055, month 5\n", - "Processing year 2055, month 6\n", - "Processing year 2055, month 7\n", - "Processing year 2055, month 8\n", - "Processing year 2055, month 9\n", - "Processing year 2055, month 10\n", - "Processing year 2055, month 11\n", - "Processing year 2055, month 12\n", - "Processing file: CIL_subset_ssp126_2056.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2056, month 1\n", - "Processing year 2056, month 2\n", - "Processing year 2056, month 3\n", - "Processing year 2056, month 4\n", - "Processing year 2056, month 5\n", - "Processing year 2056, month 6\n", - "Processing year 2056, month 7\n", - "Processing year 2056, month 8\n", - "Processing year 2056, month 9\n", - "Processing year 2056, month 10\n", - "Processing year 2056, month 11\n", - "Processing year 2056, month 12\n", - "Model GFDL-CM4 not found in file CIL_subset_ssp126_2056.nc, skipping.\n", - "Processing model: INM-CM5-0\n", - "Processing year 2056, month 1\n", - "Processing year 2056, month 2\n", - "Processing year 2056, month 3\n", - "Processing year 2056, month 4\n", - "Processing year 2056, month 5\n", - "Processing year 2056, month 6\n", - "Processing year 2056, month 7\n", - "Processing year 2056, month 8\n", - "Processing year 2056, month 9\n", - "Processing year 2056, month 10\n", - "Processing year 2056, month 11\n", - "Processing year 2056, month 12\n", - "Processing file: CIL_subset_ssp126_2057.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2057, month 1\n", - "Processing year 2057, month 2\n", - "Processing year 2057, month 3\n", - "Processing year 2057, month 4\n", - "Processing year 2057, month 5\n", - "Processing year 2057, month 6\n", - "Processing year 2057, month 7\n", - "Processing year 2057, month 8\n", - "Processing year 2057, month 9\n", - "Processing year 2057, month 10\n", - "Processing year 2057, month 11\n", - "Processing year 2057, month 12\n", - "Model GFDL-CM4 not found in file CIL_subset_ssp126_2057.nc, skipping.\n", - "Processing model: INM-CM5-0\n", - "Processing year 2057, month 1\n", - "Processing year 2057, month 2\n", - "Processing year 2057, month 3\n", - "Processing year 2057, month 4\n", - "Processing year 2057, month 5\n", - "Processing year 2057, month 6\n", - "Processing year 2057, month 7\n", - "Processing year 2057, month 8\n", - "Processing year 2057, month 9\n", - "Processing year 2057, month 10\n", - "Processing year 2057, month 11\n", - "Processing year 2057, month 12\n", - "Processing file: CIL_subset_ssp126_2058.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2058, month 1\n", - "Processing year 2058, month 2\n", - "Processing year 2058, month 3\n", - "Processing year 2058, month 4\n", - "Processing year 2058, month 5\n", - "Processing year 2058, month 6\n", - "Processing year 2058, month 7\n", - "Processing year 2058, month 8\n", - "Processing year 2058, month 9\n", - "Processing year 2058, month 10\n", - "Processing year 2058, month 11\n", - "Processing year 2058, month 12\n", - "Model GFDL-CM4 not found in file CIL_subset_ssp126_2058.nc, skipping.\n", - "Processing model: INM-CM5-0\n", - "Processing year 2058, month 1\n", - "Processing year 2058, month 2\n", - "Processing year 2058, month 3\n", - "Processing year 2058, month 4\n", - "Processing year 2058, month 5\n", - "Processing year 2058, month 6\n", - "Processing year 2058, month 7\n", - "Processing year 2058, month 8\n", - "Processing year 2058, month 9\n", - "Processing year 2058, month 10\n", - "Processing year 2058, month 11\n", - "Processing year 2058, month 12\n", - "Processing file: CIL_subset_ssp126_2059.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2059, month 1\n", - "Processing year 2059, month 2\n", - "Processing year 2059, month 3\n", - "Processing year 2059, month 4\n", - "Processing year 2059, month 5\n", - "Processing year 2059, month 6\n", - "Processing year 2059, month 7\n", - "Processing year 2059, month 8\n", - "Processing year 2059, month 9\n", - "Processing year 2059, month 10\n", - "Processing year 2059, month 11\n", - "Processing year 2059, month 12\n", - "Model GFDL-CM4 not found in file CIL_subset_ssp126_2059.nc, skipping.\n", - "Processing model: INM-CM5-0\n", - "Processing year 2059, month 1\n", - "Processing year 2059, month 2\n", - "Processing year 2059, month 3\n", - "Processing year 2059, month 4\n", - "Processing year 2059, month 5\n", - "Processing year 2059, month 6\n", - "Processing year 2059, month 7\n", - "Processing year 2059, month 8\n", - "Processing year 2059, month 9\n", - "Processing year 2059, month 10\n", - "Processing year 2059, month 11\n", - "Processing year 2059, month 12\n", - "Processing file: CIL_subset_ssp126_2060.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2060, month 1\n", - "Processing year 2060, month 2\n", - "Processing year 2060, month 3\n", - "Processing year 2060, month 4\n", - "Processing year 2060, month 5\n", - "Processing year 2060, month 6\n", - "Processing year 2060, month 7\n", - "Processing year 2060, month 8\n", - "Processing year 2060, month 9\n", - "Processing year 2060, month 10\n", - "Processing year 2060, month 11\n", - "Processing year 2060, month 12\n", - "Model GFDL-CM4 not found in file CIL_subset_ssp126_2060.nc, skipping.\n", - "Processing model: INM-CM5-0\n", - "Processing year 2060, month 1\n", - "Processing year 2060, month 2\n", - "Processing year 2060, month 3\n", - "Processing year 2060, month 4\n", - "Processing year 2060, month 5\n", - "Processing year 2060, month 6\n", - "Processing year 2060, month 7\n", - "Processing year 2060, month 8\n", - "Processing year 2060, month 9\n", - "Processing year 2060, month 10\n", - "Processing year 2060, month 11\n", - "Processing year 2060, month 12\n", - "Saved monthly data for lowest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp126/lowest_monthly_prediction_weather_by_facility.csv\n", - "Saved window data for lowest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp126/lowest_window_prediction_weather_by_facility.csv\n", - "Saved monthly data for median model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp126/median_monthly_prediction_weather_by_facility.csv\n", - "Saved window data for median model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp126/median_window_prediction_weather_by_facility.csv\n", - "Saved monthly data for highest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp126/highest_monthly_prediction_weather_by_facility.csv\n", - "Saved window data for highest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp126/highest_window_prediction_weather_by_facility.csv\n" - ] - } - ], - "execution_count": 21 - }, - { - "metadata": { - "ExecuteTime": { - "end_time": "2025-01-15T14:37:42.819759Z", - "start_time": "2025-01-15T14:37:42.664733Z" - } - }, - "cell_type": "code", - "source": "grid_precip_map", - "id": "219a94a3b9f041b0", - "outputs": [ - { - "data": { - "text/plain": [ - "{0: {'monthly': {(2060, 1): 226.96152710914612,\n", - " (2060, 2): 124.3744535446167,\n", - " (2060, 3): 90.96145176887512,\n", - " (2060, 4): 9.36989939212799,\n", - " (2060, 5): 25.046352744102478,\n", - " (2060, 6): 10.713938355445862,\n", - " (2060, 7): 18.632468700408936,\n", - " (2060, 8): 1.0678205490112305,\n", - " (2060, 9): 2.5074692964553833,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 26.961543679237366,\n", - " (2060, 12): 104.91223645210266},\n", - " 'window': {(2060, 1): 77.14203262329102,\n", - " (2060, 2): 79.23258972167969,\n", - " (2060, 3): 48.64540672302246,\n", - " (2060, 4): 4.174747824668884,\n", - " (2060, 5): 14.284469962120056,\n", - " (2060, 6): 6.319235682487488,\n", - " (2060, 7): 5.872297644615173,\n", - " (2060, 8): 1.0678205490112305,\n", - " (2060, 9): 2.5074692964553833,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 16.081406712532043,\n", - " (2060, 12): 58.407888531684875}},\n", - " 1: {'monthly': {(2060, 1): 232.35974085330963,\n", - " (2060, 2): 75.740971326828,\n", - " (2060, 3): 77.16537415981293,\n", - " (2060, 4): 35.2058801651001,\n", - " (2060, 5): 20.848549485206604,\n", - " (2060, 6): 18.671294331550598,\n", - " (2060, 7): 30.983839988708496,\n", - " (2060, 8): 2.125838279724121,\n", - " (2060, 9): 4.514179110527039,\n", - " (2060, 10): 1.1900677680969238,\n", - " (2060, 11): 17.78669571876526,\n", - " (2060, 12): 104.04975295066833},\n", - " 'window': {(2060, 1): 64.10760974884033,\n", - " (2060, 2): 43.244322299957275,\n", - " (2060, 3): 41.8435161113739,\n", - " (2060, 4): 24.879087805747986,\n", - " (2060, 5): 11.733335733413696,\n", - " (2060, 6): 5.289789438247681,\n", - " (2060, 7): 11.26254153251648,\n", - " (2060, 8): 2.125838279724121,\n", - " (2060, 9): 2.4989174604415894,\n", - " (2060, 10): 1.1900677680969238,\n", - " (2060, 11): 10.059302568435669,\n", - " (2060, 12): 57.6496262550354}},\n", - " 2: {'monthly': {(2060, 1): 215.54489529132843,\n", - " (2060, 2): 72.45866417884827,\n", - " (2060, 3): 76.15609204769135,\n", - " (2060, 4): 30.27928400039673,\n", - " (2060, 5): 19.188584446907043,\n", - " (2060, 6): 18.671294331550598,\n", - " (2060, 7): 28.5977041721344,\n", - " (2060, 8): 2.125838279724121,\n", - " (2060, 9): 4.514179110527039,\n", - " (2060, 10): 1.1900677680969238,\n", - " (2060, 11): 13.499667763710022,\n", - " (2060, 12): 94.55657601356506},\n", - " 'window': {(2060, 1): 56.223580837249756,\n", - " (2060, 2): 38.56722688674927,\n", - " (2060, 3): 36.09107220172882,\n", - " (2060, 4): 19.95258665084839,\n", - " (2060, 5): 10.073370695114136,\n", - " (2060, 6): 5.289789438247681,\n", - " (2060, 7): 10.401625633239746,\n", - " (2060, 8): 2.125838279724121,\n", - " (2060, 9): 2.4989174604415894,\n", - " (2060, 10): 1.1900677680969238,\n", - " (2060, 11): 9.91181218624115,\n", - " (2060, 12): 55.72283458709717}},\n", - " 3: {'monthly': {(2060, 1): 225.9303376674652,\n", - " (2060, 2): 75.87268960475922,\n", - " (2060, 3): 73.4968456029892,\n", - " (2060, 4): 27.31887149810791,\n", - " (2060, 5): 17.690482258796692,\n", - " (2060, 6): 18.671294331550598,\n", - " (2060, 7): 30.067601680755615,\n", - " (2060, 8): 3.1992900371551514,\n", - " (2060, 9): 4.514179110527039,\n", - " (2060, 10): 3.258257746696472,\n", - " (2060, 11): 12.724978566169739,\n", - " (2060, 12): 89.04957377910614},\n", - " 'window': {(2060, 1): 65.52614116668701,\n", - " (2060, 2): 35.17914915084839,\n", - " (2060, 3): 33.312012910842896,\n", - " (2060, 4): 16.511893033981323,\n", - " (2060, 5): 8.575268507003784,\n", - " (2060, 6): 5.289789438247681,\n", - " (2060, 7): 12.334270477294922,\n", - " (2060, 8): 3.1992900371551514,\n", - " (2060, 9): 2.4989174604415894,\n", - " (2060, 10): 2.0681899785995483,\n", - " (2060, 11): 9.347459435462952,\n", - " (2060, 12): 51.94138193130493}},\n", - " 4: {'monthly': {(2060, 1): 240.4055531024933,\n", - " (2060, 2): 69.19559860229492,\n", - " (2060, 3): 72.13977015018463,\n", - " (2060, 4): 31.818047404289246,\n", - " (2060, 5): 17.27072048187256,\n", - " (2060, 6): 19.70599889755249,\n", - " (2060, 7): 30.356138110160828,\n", - " (2060, 8): 2.125838279724121,\n", - " (2060, 9): 4.514179110527039,\n", - " (2060, 10): 1.1900677680969238,\n", - " (2060, 11): 15.067672848701477,\n", - " (2060, 12): 87.75210726261139},\n", - " 'window': {(2060, 1): 73.08864307403564,\n", - " (2060, 2): 34.44388198852539,\n", - " (2060, 3): 29.105742812156677,\n", - " (2060, 4): 20.24230408668518,\n", - " (2060, 5): 7.261478662490845,\n", - " (2060, 6): 5.289789438247681,\n", - " (2060, 7): 12.737078428268433,\n", - " (2060, 8): 2.125838279724121,\n", - " (2060, 9): 2.4989174604415894,\n", - " (2060, 10): 1.1900677680969238,\n", - " (2060, 11): 9.992488026618958,\n", - " (2060, 12): 44.10278558731079}},\n", - " 5: {'monthly': {(2060, 1): 233.85064482688904,\n", - " (2060, 2): 72.70675826072693,\n", - " (2060, 3): 75.96139395236969,\n", - " (2060, 4): 30.414944887161255,\n", - " (2060, 5): 18.32574450969696,\n", - " (2060, 6): 18.314934372901917,\n", - " (2060, 7): 33.44579017162323,\n", - " (2060, 8): 2.161451578140259,\n", - " (2060, 9): 2.526943325996399,\n", - " (2060, 10): 1.2444792985916138,\n", - " (2060, 11): 10.720296621322632,\n", - " (2060, 12): 92.92805922031403},\n", - " 'window': {(2060, 1): 68.39251899719238,\n", - " (2060, 2): 40.709330797195435,\n", - " (2060, 3): 29.49700164794922,\n", - " (2060, 4): 19.41972815990448,\n", - " (2060, 5): 5.4995410442352295,\n", - " (2060, 6): 5.356611490249634,\n", - " (2060, 7): 14.239262819290161,\n", - " (2060, 8): 2.161451578140259,\n", - " (2060, 9): 1.4979941844940186,\n", - " (2060, 10): 1.2444792985916138,\n", - " (2060, 11): 8.515749335289001,\n", - " (2060, 12): 63.367172956466675}},\n", - " 6: {'monthly': {(2060, 1): 216.01185750961304,\n", - " (2060, 2): 70.1438399553299,\n", - " (2060, 3): 81.87030816078186,\n", - " (2060, 4): 35.13857686519623,\n", - " (2060, 5): 17.00596594810486,\n", - " (2060, 6): 19.281175136566162,\n", - " (2060, 7): 33.60052418708801,\n", - " (2060, 8): 2.161451578140259,\n", - " (2060, 9): 2.526943325996399,\n", - " (2060, 10): 1.2444792985916138,\n", - " (2060, 11): 10.295323014259338,\n", - " (2060, 12): 81.7494101524353},\n", - " 'window': {(2060, 1): 60.72257375717163,\n", - " (2060, 2): 37.15285062789917,\n", - " (2060, 3): 37.07528257369995,\n", - " (2060, 4): 21.61951470375061,\n", - " (2060, 5): 5.4995410442352295,\n", - " (2060, 6): 5.356611490249634,\n", - " (2060, 7): 13.125999927520752,\n", - " (2060, 8): 2.161451578140259,\n", - " (2060, 9): 1.4979941844940186,\n", - " (2060, 10): 1.2444792985916138,\n", - " (2060, 11): 8.038140773773193,\n", - " (2060, 12): 52.07000279426575}},\n", - " 7: {'monthly': {(2060, 1): 204.01568126678467,\n", - " (2060, 2): 64.23091447353363,\n", - " (2060, 3): 85.9620064496994,\n", - " (2060, 4): 35.53431987762451,\n", - " (2060, 5): 16.917259097099304,\n", - " (2060, 6): 18.356149911880493,\n", - " (2060, 7): 30.19701051712036,\n", - " (2060, 8): 2.161451578140259,\n", - " (2060, 9): 2.526943325996399,\n", - " (2060, 10): 1.2444792985916138,\n", - " (2060, 11): 9.411099791526794,\n", - " (2060, 12): 69.83464550971985},\n", - " 'window': {(2060, 1): 58.430789947509766,\n", - " (2060, 2): 31.594899892807007,\n", - " (2060, 3): 39.89368534088135,\n", - " (2060, 4): 23.283489227294922,\n", - " (2060, 5): 5.4995410442352295,\n", - " (2060, 6): 5.356611490249634,\n", - " (2060, 7): 10.969779014587402,\n", - " (2060, 8): 2.161451578140259,\n", - " (2060, 9): 1.4979941844940186,\n", - " (2060, 10): 1.2444792985916138,\n", - " (2060, 11): 8.206862330436707,\n", - " (2060, 12): 39.95692443847656}},\n", - " 8: {'monthly': {(2060, 1): 218.36733281612396,\n", - " (2060, 2): 74.21986639499664,\n", - " (2060, 3): 84.8304101228714,\n", - " (2060, 4): 42.135818123817444,\n", - " (2060, 5): 25.29867374897003,\n", - " (2060, 6): 19.74134862422943,\n", - " (2060, 7): 35.075451135635376,\n", - " (2060, 8): 2.161451578140259,\n", - " (2060, 9): 2.526943325996399,\n", - " (2060, 10): 1.2444792985916138,\n", - " (2060, 11): 11.86556875705719,\n", - " (2060, 12): 91.18658149242401},\n", - " 'window': {(2060, 1): 70.33032321929932,\n", - " (2060, 2): 35.52470350265503,\n", - " (2060, 3): 36.038678884506226,\n", - " (2060, 4): 23.46430015563965,\n", - " (2060, 5): 7.597865104675293,\n", - " (2060, 6): 5.356611490249634,\n", - " (2060, 7): 13.836196064949036,\n", - " (2060, 8): 2.161451578140259,\n", - " (2060, 9): 1.4979941844940186,\n", - " (2060, 10): 1.2444792985916138,\n", - " (2060, 11): 8.26116955280304,\n", - " (2060, 12): 51.513901710510254}},\n", - " 9: {'monthly': {(2060, 1): 186.944664478302,\n", - " (2060, 2): 82.23486804962158,\n", - " (2060, 3): 74.69336688518524,\n", - " (2060, 4): 59.35540997982025,\n", - " (2060, 5): 43.03369903564453,\n", - " (2060, 6): 17.97312819957733,\n", - " (2060, 7): 31.327256560325623,\n", - " (2060, 8): 4.466005444526672,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 1.9822325706481934,\n", - " (2060, 11): 7.361091375350952,\n", - " (2060, 12): 131.29359698295593},\n", - " 'window': {(2060, 1): 60.14500570297241,\n", - " (2060, 2): 31.875240683555603,\n", - " (2060, 3): 31.9746150970459,\n", - " (2060, 4): 32.85644745826721,\n", - " (2060, 5): 14.801453113555908,\n", - " (2060, 6): 8.072823166847229,\n", - " (2060, 7): 10.759923934936523,\n", - " (2060, 8): 2.8704358339309692,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 1.9822325706481934,\n", - " (2060, 11): 5.724764108657837,\n", - " (2060, 12): 64.81610870361328}},\n", - " 10: {'monthly': {(2060, 1): 184.99872934818268,\n", - " (2060, 2): 78.02315509319305,\n", - " (2060, 3): 85.68857824802399,\n", - " (2060, 4): 51.53748035430908,\n", - " (2060, 5): 35.400421142578125,\n", - " (2060, 6): 15.918378114700317,\n", - " (2060, 7): 31.65065360069275,\n", - " (2060, 8): 4.560208201408386,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 1.9822325706481934,\n", - " (2060, 11): 6.825357675552368,\n", - " (2060, 12): 123.24709224700928},\n", - " 'window': {(2060, 1): 64.44441509246826,\n", - " (2060, 2): 30.62648856639862,\n", - " (2060, 3): 40.36911582946777,\n", - " (2060, 4): 28.241308331489563,\n", - " (2060, 5): 10.668944001197815,\n", - " (2060, 6): 6.219155430793762,\n", - " (2060, 7): 10.049416422843933,\n", - " (2060, 8): 2.964638590812683,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 1.9822325706481934,\n", - " (2060, 11): 4.051001310348511,\n", - " (2060, 12): 58.768288135528564}},\n", - " 11: {'monthly': {(2060, 1): 199.4795205593109,\n", - " (2060, 2): 80.32603764533997,\n", - " (2060, 3): 90.53969895839691,\n", - " (2060, 4): 52.29490578174591,\n", - " (2060, 5): 30.727615356445312,\n", - " (2060, 6): 19.210054636001587,\n", - " (2060, 7): 34.49882459640503,\n", - " (2060, 8): 6.046685218811035,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.1421722173690796,\n", - " (2060, 11): 15.280751943588257,\n", - " (2060, 12): 143.1884732246399},\n", - " 'window': {(2060, 1): 70.33573246002197,\n", - " (2060, 2): 30.435698986053467,\n", - " (2060, 3): 42.52820086479187,\n", - " (2060, 4): 30.338587164878845,\n", - " (2060, 5): 9.236226558685303,\n", - " (2060, 6): 7.1151416301727295,\n", - " (2060, 7): 10.624126076698303,\n", - " (2060, 8): 4.451115608215332,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.1421722173690796,\n", - " (2060, 11): 9.084230303764343,\n", - " (2060, 12): 58.41049289703369}},\n", - " 12: {'monthly': {(2060, 1): 222.52046716213226,\n", - " (2060, 2): 84.18927526473999,\n", - " (2060, 3): 92.82796204090118,\n", - " (2060, 4): 58.257102489471436,\n", - " (2060, 5): 34.70336365699768,\n", - " (2060, 6): 24.46960699558258,\n", - " (2060, 7): 37.35615885257721,\n", - " (2060, 8): 6.713040709495544,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 1.9822325706481934,\n", - " (2060, 11): 14.560459017753601,\n", - " (2060, 12): 149.9245229959488},\n", - " 'window': {(2060, 1): 62.479111671447754,\n", - " (2060, 2): 28.1489839553833,\n", - " (2060, 3): 33.8856098651886,\n", - " (2060, 4): 34.13823091983795,\n", - " (2060, 5): 8.685004949569702,\n", - " (2060, 6): 8.878517985343933,\n", - " (2060, 7): 11.719814419746399,\n", - " (2060, 8): 3.6593568325042725,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 1.9822325706481934,\n", - " (2060, 11): 6.67893385887146,\n", - " (2060, 12): 61.30430603027344}},\n", - " 13: {'monthly': {(2060, 1): 275.71551752090454,\n", - " (2060, 2): 104.31035888195038,\n", - " (2060, 3): 68.30848336219788,\n", - " (2060, 4): 4.832036972045898,\n", - " (2060, 5): 15.230712890625,\n", - " (2060, 6): 9.48189914226532,\n", - " (2060, 7): 19.5851309299469,\n", - " (2060, 8): 1.1758471727371216,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 1.1965882778167725,\n", - " (2060, 11): 19.68755352497101,\n", - " (2060, 12): 129.26710999011993},\n", - " 'window': {(2060, 1): 82.02347373962402,\n", - " (2060, 2): 59.94417667388916,\n", - " (2060, 3): 40.80641460418701,\n", - " (2060, 4): 2.7233306169509888,\n", - " (2060, 5): 5.893738031387329,\n", - " (2060, 6): 4.936112880706787,\n", - " (2060, 7): 7.216302394866943,\n", - " (2060, 8): 1.1758471727371216,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 1.1965882778167725,\n", - " (2060, 11): 12.162452816963196,\n", - " (2060, 12): 85.03817343711853}},\n", - " 14: {'monthly': {(2060, 1): 280.8995190858841,\n", - " (2060, 2): 76.77554202079773,\n", - " (2060, 3): 55.343388080596924,\n", - " (2060, 4): 12.358617186546326,\n", - " (2060, 5): 30.04008436203003,\n", - " (2060, 6): 15.26547646522522,\n", - " (2060, 7): 24.743809819221497,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 1.0435322523117065,\n", - " (2060, 11): 11.120004415512085,\n", - " (2060, 12): 95.79382359981537},\n", - " 'window': {(2060, 1): 83.27588558197021,\n", - " (2060, 2): 44.61265802383423,\n", - " (2060, 3): 23.891056656837463,\n", - " (2060, 4): 9.906206965446472,\n", - " (2060, 5): 13.106630802154541,\n", - " (2060, 6): 5.10566771030426,\n", - " (2060, 7): 8.732527613639832,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 1.0435322523117065,\n", - " (2060, 11): 7.640333294868469,\n", - " (2060, 12): 56.77288460731506}},\n", - " 15: {'monthly': {(2060, 1): 297.9669303894043,\n", - " (2060, 2): 71.68847596645355,\n", - " (2060, 3): 47.4288432598114,\n", - " (2060, 4): 13.303749442100525,\n", - " (2060, 5): 24.818320751190186,\n", - " (2060, 6): 15.26547646522522,\n", - " (2060, 7): 22.034451603889465,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 8.835997939109802,\n", - " (2060, 12): 86.48041224479675},\n", - " 'window': {(2060, 1): 94.3751049041748,\n", - " (2060, 2): 44.806376576423645,\n", - " (2060, 3): 18.837244153022766,\n", - " (2060, 4): 11.88423776626587,\n", - " (2060, 5): 9.971006393432617,\n", - " (2060, 6): 5.10566771030426,\n", - " (2060, 7): 7.372061133384705,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 6.238973259925842,\n", - " (2060, 12): 47.47452998161316}},\n", - " 16: {'monthly': {(2060, 1): 327.0283167362213,\n", - " (2060, 2): 69.149573802948,\n", - " (2060, 3): 52.6281476020813,\n", - " (2060, 4): 18.35203719139099,\n", - " (2060, 5): 22.02019166946411,\n", - " (2060, 6): 15.26547646522522,\n", - " (2060, 7): 20.036049127578735,\n", - " (2060, 8): 1.034966230392456,\n", - " (2060, 9): 1.047914743423462,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 7.13714075088501,\n", - " (2060, 12): 85.2325439453125},\n", - " 'window': {(2060, 1): 106.87643909454346,\n", - " (2060, 2): 41.4850949048996,\n", - " (2060, 3): 21.521435856819153,\n", - " (2060, 4): 15.799172401428223,\n", - " (2060, 5): 8.19351863861084,\n", - " (2060, 6): 5.10566771030426,\n", - " (2060, 7): 7.032817482948303,\n", - " (2060, 8): 1.034966230392456,\n", - " (2060, 9): 1.047914743423462,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 5.701374053955078,\n", - " (2060, 12): 49.90061545372009}},\n", - " 17: {'monthly': {(2060, 1): 337.77501368522644,\n", - " (2060, 2): 65.87799036502838,\n", - " (2060, 3): 54.104509353637695,\n", - " (2060, 4): 24.535561561584473,\n", - " (2060, 5): 20.250721335411072,\n", - " (2060, 6): 15.26547646522522,\n", - " (2060, 7): 22.933624982833862,\n", - " (2060, 8): 2.1315125226974487,\n", - " (2060, 9): 1.374363899230957,\n", - " (2060, 10): 2.294590711593628,\n", - " (2060, 11): 12.713541984558105,\n", - " (2060, 12): 75.46126532554626},\n", - " 'window': {(2060, 1): 114.07656478881836,\n", - " (2060, 2): 36.50031542778015,\n", - " (2060, 3): 21.648704767227173,\n", - " (2060, 4): 20.970149755477905,\n", - " (2060, 5): 7.081977009773254,\n", - " (2060, 6): 5.10566771030426,\n", - " (2060, 7): 8.925637364387512,\n", - " (2060, 8): 2.1315125226974487,\n", - " (2060, 9): 1.374363899230957,\n", - " (2060, 10): 1.2513712644577026,\n", - " (2060, 11): 8.276005864143372,\n", - " (2060, 12): 41.72475624084473}},\n", - " 18: {'monthly': {(2060, 1): 283.53866136074066,\n", - " (2060, 2): 57.88073492050171,\n", - " (2060, 3): 55.28987121582031,\n", - " (2060, 4): 42.37288987636566,\n", - " (2060, 5): 24.621315598487854,\n", - " (2060, 6): 20.361573219299316,\n", - " (2060, 7): 30.539228677749634,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 2.0700796842575073,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 16.218668222427368,\n", - " (2060, 12): 78.2343841791153},\n", - " 'window': {(2060, 1): 89.71606540679932,\n", - " (2060, 2): 26.57128381729126,\n", - " (2060, 3): 17.913177251815796,\n", - " (2060, 4): 26.214650630950928,\n", - " (2060, 5): 7.858853816986084,\n", - " (2060, 6): 5.147720813751221,\n", - " (2060, 7): 10.560983419418335,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 1.0696583986282349,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 10.842864871025085,\n", - " (2060, 12): 48.024280309677124}},\n", - " 19: {'monthly': {(2060, 1): 289.99115097522736,\n", - " (2060, 2): 59.80119717121124,\n", - " (2060, 3): 61.07085847854614,\n", - " (2060, 4): 45.245096921920776,\n", - " (2060, 5): 26.730894804000854,\n", - " (2060, 6): 20.133365869522095,\n", - " (2060, 7): 31.053078174591064,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 2.172034502029419,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 9.928079962730408,\n", - " (2060, 12): 71.47853910923004},\n", - " 'window': {(2060, 1): 105.30583238601685,\n", - " (2060, 2): 25.575934290885925,\n", - " (2060, 3): 23.178677558898926,\n", - " (2060, 4): 30.02705705165863,\n", - " (2060, 5): 8.661492824554443,\n", - " (2060, 6): 5.147720813751221,\n", - " (2060, 7): 11.611162662506104,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 1.102376103401184,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 8.67087459564209,\n", - " (2060, 12): 44.88334631919861}},\n", - " 20: {'monthly': {(2060, 1): 302.87652909755707,\n", - " (2060, 2): 54.842564702034,\n", - " (2060, 3): 60.318278193473816,\n", - " (2060, 4): 45.38412058353424,\n", - " (2060, 5): 27.30981969833374,\n", - " (2060, 6): 19.28374171257019,\n", - " (2060, 7): 32.507999777793884,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 2.0700796842575073,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 15.546087145805359,\n", - " (2060, 12): 71.2442227602005},\n", - " 'window': {(2060, 1): 119.7259578704834,\n", - " (2060, 2): 24.835559725761414,\n", - " (2060, 3): 19.047128677368164,\n", - " (2060, 4): 28.697428584098816,\n", - " (2060, 5): 8.851400017738342,\n", - " (2060, 6): 5.147720813751221,\n", - " (2060, 7): 12.947813987731934,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 1.0696583986282349,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 13.405994415283203,\n", - " (2060, 12): 44.04079484939575}},\n", - " 21: {'monthly': {(2060, 1): 324.27861273288727,\n", - " (2060, 2): 62.140079379081726,\n", - " (2060, 3): 76.96446585655212,\n", - " (2060, 4): 47.68307662010193,\n", - " (2060, 5): 28.956926345825195,\n", - " (2060, 6): 19.646801114082336,\n", - " (2060, 7): 38.32234442234039,\n", - " (2060, 8): 1.2039484977722168,\n", - " (2060, 9): 2.0745404958724976,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 21.834125518798828,\n", - " (2060, 12): 82.41578006744385},\n", - " 'window': {(2060, 1): 132.1976718902588,\n", - " (2060, 2): 31.405773282051086,\n", - " (2060, 3): 28.76563000679016,\n", - " (2060, 4): 25.0566463470459,\n", - " (2060, 5): 10.245465993881226,\n", - " (2060, 6): 5.147720813751221,\n", - " (2060, 7): 16.9343079328537,\n", - " (2060, 8): 1.2039484977722168,\n", - " (2060, 9): 1.074119210243225,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 17.65831768512726,\n", - " (2060, 12): 50.107163429260254}},\n", - " 22: {'monthly': {(2060, 1): 216.84882986545563,\n", - " (2060, 2): 79.51474297046661,\n", - " (2060, 3): 74.7057580947876,\n", - " (2060, 4): 48.15092611312866,\n", - " (2060, 5): 45.08745312690735,\n", - " (2060, 6): 21.81949758529663,\n", - " (2060, 7): 37.94841241836548,\n", - " (2060, 8): 3.3124797344207764,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 18.577101349830627,\n", - " (2060, 12): 137.43938148021698},\n", - " 'window': {(2060, 1): 54.70518159866333,\n", - " (2060, 2): 35.51257658004761,\n", - " (2060, 3): 21.77220928668976,\n", - " (2060, 4): 31.72324562072754,\n", - " (2060, 5): 12.371639251708984,\n", - " (2060, 6): 8.282130479812622,\n", - " (2060, 7): 14.402588248252869,\n", - " (2060, 8): 2.2932902574539185,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 10.238005518913269,\n", - " (2060, 12): 49.31591558456421}},\n", - " 23: {'monthly': {(2060, 1): 198.01714658737183,\n", - " (2060, 2): 75.50567328929901,\n", - " (2060, 3): 74.17715454101562,\n", - " (2060, 4): 62.87470293045044,\n", - " (2060, 5): 47.72959303855896,\n", - " (2060, 6): 20.466951370239258,\n", - " (2060, 7): 36.004900336265564,\n", - " (2060, 8): 3.363345146179199,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 17.98643136024475,\n", - " (2060, 12): 126.3448555469513},\n", - " 'window': {(2060, 1): 51.48584032058716,\n", - " (2060, 2): 33.519627928733826,\n", - " (2060, 3): 22.595688581466675,\n", - " (2060, 4): 42.45381140708923,\n", - " (2060, 5): 16.429280877113342,\n", - " (2060, 6): 7.708904147148132,\n", - " (2060, 7): 13.772684574127197,\n", - " (2060, 8): 2.3441556692123413,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 10.582186818122864,\n", - " (2060, 12): 53.937424659729004}},\n", - " 24: {'monthly': {(2060, 1): 212.755814909935,\n", - " (2060, 2): 77.83977007865906,\n", - " (2060, 3): 87.39669013023376,\n", - " (2060, 4): 74.842365026474,\n", - " (2060, 5): 54.39435911178589,\n", - " (2060, 6): 20.578118681907654,\n", - " (2060, 7): 51.68839085102081,\n", - " (2060, 8): 4.380195617675781,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 15.001265168190002,\n", - " (2060, 12): 132.21350872516632},\n", - " 'window': {(2060, 1): 57.95471954345703,\n", - " (2060, 2): 38.21384835243225,\n", - " (2060, 3): 25.031933307647705,\n", - " (2060, 4): 50.903972148895264,\n", - " (2060, 5): 19.315935850143433,\n", - " (2060, 6): 6.886984348297119,\n", - " (2060, 7): 18.79657471179962,\n", - " (2060, 8): 3.3610061407089233,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 9.960644602775574,\n", - " (2060, 12): 53.34445333480835}},\n", - " 25: {'monthly': {(2060, 1): 228.2965955734253,\n", - " (2060, 2): 89.62907814979553,\n", - " (2060, 3): 101.04309904575348,\n", - " (2060, 4): 73.51490819454193,\n", - " (2060, 5): 58.073058009147644,\n", - " (2060, 6): 21.70261299610138,\n", - " (2060, 7): 51.510161995887756,\n", - " (2060, 8): 6.478736877441406,\n", - " (2060, 9): 1.029809594154358,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 21.328635215759277,\n", - " (2060, 12): 149.80462884902954},\n", - " 'window': {(2060, 1): 71.0409574508667,\n", - " (2060, 2): 43.5347626209259,\n", - " (2060, 3): 29.93865728378296,\n", - " (2060, 4): 45.91067981719971,\n", - " (2060, 5): 18.1136953830719,\n", - " (2060, 6): 8.06552267074585,\n", - " (2060, 7): 19.014212369918823,\n", - " (2060, 8): 5.459547400474548,\n", - " (2060, 9): 1.029809594154358,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 11.479464411735535,\n", - " (2060, 12): 65.83091926574707}},\n", - " 26: {'monthly': {(2060, 1): 300.9923725128174,\n", - " (2060, 2): 106.11579370498657,\n", - " (2060, 3): 64.89023923873901,\n", - " (2060, 4): 7.041850924491882,\n", - " (2060, 5): 15.269606232643127,\n", - " (2060, 6): 9.48189914226532,\n", - " (2060, 7): 20.4096941947937,\n", - " (2060, 8): 1.1758471727371216,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 1.1965882778167725,\n", - " (2060, 11): 20.978981018066406,\n", - " (2060, 12): 110.30153834819794},\n", - " 'window': {(2060, 1): 109.57153511047363,\n", - " (2060, 2): 67.099374294281,\n", - " (2060, 3): 35.19744682312012,\n", - " (2060, 4): 3.605716109275818,\n", - " (2060, 5): 6.578789472579956,\n", - " (2060, 6): 4.936112880706787,\n", - " (2060, 7): 7.281499624252319,\n", - " (2060, 8): 1.1758471727371216,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 1.1965882778167725,\n", - " (2060, 11): 12.530943036079407,\n", - " (2060, 12): 73.25389003753662}},\n", - " 27: {'monthly': {(2060, 1): 285.9675942659378,\n", - " (2060, 2): 63.180262207984924,\n", - " (2060, 3): 55.756710052490234,\n", - " (2060, 4): 17.564688444137573,\n", - " (2060, 5): 30.04882049560547,\n", - " (2060, 6): 15.26547646522522,\n", - " (2060, 7): 25.65722382068634,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 10.897678256034851,\n", - " (2060, 12): 81.67393398284912},\n", - " 'window': {(2060, 1): 96.0301866531372,\n", - " (2060, 2): 30.811904311180115,\n", - " (2060, 3): 22.65938377380371,\n", - " (2060, 4): 14.007421970367432,\n", - " (2060, 5): 13.965339660644531,\n", - " (2060, 6): 5.10566771030426,\n", - " (2060, 7): 9.530768632888794,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 8.735248684883118,\n", - " (2060, 12): 50.40670609474182}},\n", - " 28: {'monthly': {(2060, 1): 322.1928827762604,\n", - " (2060, 2): 58.73407542705536,\n", - " (2060, 3): 51.3264422416687,\n", - " (2060, 4): 19.735199809074402,\n", - " (2060, 5): 23.96096396446228,\n", - " (2060, 6): 15.26547646522522,\n", - " (2060, 7): 23.913462042808533,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 9.096928119659424,\n", - " (2060, 12): 75.1400146484375},\n", - " 'window': {(2060, 1): 126.90206050872803,\n", - " (2060, 2): 30.60452401638031,\n", - " (2060, 3): 21.042474389076233,\n", - " (2060, 4): 17.241387844085693,\n", - " (2060, 5): 9.909919500350952,\n", - " (2060, 6): 5.10566771030426,\n", - " (2060, 7): 8.533485293388367,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 9.096928119659424,\n", - " (2060, 12): 44.57266020774841}},\n", - " 29: {'monthly': {(2060, 1): 334.69363033771515,\n", - " (2060, 2): 58.68753683567047,\n", - " (2060, 3): 51.84394323825836,\n", - " (2060, 4): 25.2209370136261,\n", - " (2060, 5): 19.99314570426941,\n", - " (2060, 6): 15.26547646522522,\n", - " (2060, 7): 21.729788303375244,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 8.592445611953735,\n", - " (2060, 12): 68.24425506591797},\n", - " 'window': {(2060, 1): 140.26044368743896,\n", - " (2060, 2): 29.94936490058899,\n", - " (2060, 3): 21.550683856010437,\n", - " (2060, 4): 22.290402054786682,\n", - " (2060, 5): 7.394083738327026,\n", - " (2060, 6): 5.10566771030426,\n", - " (2060, 7): 7.2805129289627075,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 7.490725994110107,\n", - " (2060, 12): 40.49748492240906}},\n", - " 30: {'monthly': {(2060, 1): 335.6134226322174,\n", - " (2060, 2): 63.06826615333557,\n", - " (2060, 3): 53.47462558746338,\n", - " (2060, 4): 32.777527928352356,\n", - " (2060, 5): 18.50051999092102,\n", - " (2060, 6): 15.515244126319885,\n", - " (2060, 7): 20.85115885734558,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 9.792150378227234,\n", - " (2060, 12): 68.15757250785828},\n", - " 'window': {(2060, 1): 136.64941215515137,\n", - " (2060, 2): 31.053982138633728,\n", - " (2060, 3): 21.455462098121643,\n", - " (2060, 4): 29.696712493896484,\n", - " (2060, 5): 6.330652356147766,\n", - " (2060, 6): 5.10566771030426,\n", - " (2060, 7): 9.182690262794495,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 8.281229734420776,\n", - " (2060, 12): 38.642252922058105}},\n", - " 31: {'monthly': {(2060, 1): 292.1636471748352,\n", - " (2060, 2): 62.630359292030334,\n", - " (2060, 3): 56.72766983509064,\n", - " (2060, 4): 50.720216035842896,\n", - " (2060, 5): 26.77993953227997,\n", - " (2060, 6): 20.07488512992859,\n", - " (2060, 7): 33.26974439620972,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 2.0700796842575073,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 13.495524048805237,\n", - " (2060, 12): 79.8779149055481},\n", - " 'window': {(2060, 1): 96.86238288879395,\n", - " (2060, 2): 30.406187176704407,\n", - " (2060, 3): 15.681460857391357,\n", - " (2060, 4): 34.43177795410156,\n", - " (2060, 5): 8.923270225524902,\n", - " (2060, 6): 5.147720813751221,\n", - " (2060, 7): 13.260712623596191,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 1.0696583986282349,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 10.683940529823303,\n", - " (2060, 12): 42.085524797439575}},\n", - " 32: {'monthly': {(2060, 1): 313.939089179039,\n", - " (2060, 2): 59.74389171600342,\n", - " (2060, 3): 69.36816716194153,\n", - " (2060, 4): 56.32128036022186,\n", - " (2060, 5): 30.154914617538452,\n", - " (2060, 6): 19.726469039916992,\n", - " (2060, 7): 39.15850210189819,\n", - " (2060, 8): 1.1209079027175903,\n", - " (2060, 9): 2.115904927253723,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 13.572490572929382,\n", - " (2060, 12): 81.46638894081116},\n", - " 'window': {(2060, 1): 110.7195634841919,\n", - " (2060, 2): 31.338606238365173,\n", - " (2060, 3): 24.410902976989746,\n", - " (2060, 4): 40.42978882789612,\n", - " (2060, 5): 9.348739385604858,\n", - " (2060, 6): 5.147720813751221,\n", - " (2060, 7): 16.471436977386475,\n", - " (2060, 8): 1.1209079027175903,\n", - " (2060, 9): 1.1154836416244507,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 11.323002219200134,\n", - " (2060, 12): 46.527843952178955}},\n", - " 33: {'monthly': {(2060, 1): 319.5274738073349,\n", - " (2060, 2): 59.354222536087036,\n", - " (2060, 3): 77.6412113904953,\n", - " (2060, 4): 57.725080609321594,\n", - " (2060, 5): 32.624388694763184,\n", - " (2060, 6): 20.055033922195435,\n", - " (2060, 7): 41.373685002326965,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 2.21674907207489,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 15.835336565971375,\n", - " (2060, 12): 78.10277485847473},\n", - " 'window': {(2060, 1): 121.05110359191895,\n", - " (2060, 2): 29.981885075569153,\n", - " (2060, 3): 28.08425807952881,\n", - " (2060, 4): 37.035592913627625,\n", - " (2060, 5): 10.675751686096191,\n", - " (2060, 6): 5.281996011734009,\n", - " (2060, 7): 17.97246539592743,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 1.2163277864456177,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 13.661487102508545,\n", - " (2060, 12): 47.269954204559326}},\n", - " 34: {'monthly': {(2060, 1): 314.3877409696579,\n", - " (2060, 2): 64.65623545646667,\n", - " (2060, 3): 90.66038620471954,\n", - " (2060, 4): 52.503979325294495,\n", - " (2060, 5): 36.33127248287201,\n", - " (2060, 6): 22.162110805511475,\n", - " (2060, 7): 51.9242844581604,\n", - " (2060, 8): 1.024043083190918,\n", - " (2060, 9): 2.2166507244110107,\n", - " (2060, 10): 1.0015662908554077,\n", - " (2060, 11): 21.986296772956848,\n", - " (2060, 12): 85.57814121246338},\n", - " 'window': {(2060, 1): 124.11465549468994,\n", - " (2060, 2): 32.42938280105591,\n", - " (2060, 3): 35.437742710113525,\n", - " (2060, 4): 29.31278121471405,\n", - " (2060, 5): 11.578647017478943,\n", - " (2060, 6): 5.467369437217712,\n", - " (2060, 7): 22.374963879585266,\n", - " (2060, 8): 1.024043083190918,\n", - " (2060, 9): 1.2162294387817383,\n", - " (2060, 10): 1.0015662908554077,\n", - " (2060, 11): 17.645082712173462,\n", - " (2060, 12): 48.46052694320679}},\n", - " 35: {'monthly': {(2060, 1): 220.57909893989563,\n", - " (2060, 2): 81.23381793498993,\n", - " (2060, 3): 70.66388010978699,\n", - " (2060, 4): 52.05650615692139,\n", - " (2060, 5): 55.09097182750702,\n", - " (2060, 6): 21.18526780605316,\n", - " (2060, 7): 39.863245248794556,\n", - " (2060, 8): 6.0618627071380615,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 20.67309880256653,\n", - " (2060, 12): 128.95277285575867},\n", - " 'window': {(2060, 1): 61.86612415313721,\n", - " (2060, 2): 41.45695877075195,\n", - " (2060, 3): 20.00838565826416,\n", - " (2060, 4): 35.031951546669006,\n", - " (2060, 5): 18.88022255897522,\n", - " (2060, 6): 6.704087018966675,\n", - " (2060, 7): 16.410173296928406,\n", - " (2060, 8): 5.042673230171204,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 11.787132620811462,\n", - " (2060, 12): 52.496760845184326}},\n", - " 36: {'monthly': {(2060, 1): 216.97652184963226,\n", - " (2060, 2): 77.6467000246048,\n", - " (2060, 3): 73.74719202518463,\n", - " (2060, 4): 69.26261603832245,\n", - " (2060, 5): 65.63064241409302,\n", - " (2060, 6): 24.683910846710205,\n", - " (2060, 7): 47.27613091468811,\n", - " (2060, 8): 3.992218017578125,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 16.92774987220764,\n", - " (2060, 12): 123.82927405834198},\n", - " 'window': {(2060, 1): 63.47757053375244,\n", - " (2060, 2): 39.74986004829407,\n", - " (2060, 3): 21.556602954864502,\n", - " (2060, 4): 48.67717504501343,\n", - " (2060, 5): 25.412168979644775,\n", - " (2060, 6): 8.842325091362,\n", - " (2060, 7): 17.720155119895935,\n", - " (2060, 8): 2.973028540611267,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 11.202586054801941,\n", - " (2060, 12): 52.04808712005615}},\n", - " 37: {'monthly': {(2060, 1): 256.3180900812149,\n", - " (2060, 2): 89.17130327224731,\n", - " (2060, 3): 100.5813010931015,\n", - " (2060, 4): 89.5719518661499,\n", - " (2060, 5): 81.90803587436676,\n", - " (2060, 6): 26.25433385372162,\n", - " (2060, 7): 68.79021334648132,\n", - " (2060, 8): 4.808828830718994,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 20.270294785499573,\n", - " (2060, 12): 155.0377138853073},\n", - " 'window': {(2060, 1): 75.49716281890869,\n", - " (2060, 2): 45.31098234653473,\n", - " (2060, 3): 27.468059420585632,\n", - " (2060, 4): 59.94999408721924,\n", - " (2060, 5): 31.84259033203125,\n", - " (2060, 6): 8.89030134677887,\n", - " (2060, 7): 29.806596517562866,\n", - " (2060, 8): 3.7896393537521362,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 12.998994708061218,\n", - " (2060, 12): 64.50573921203613}},\n", - " 38: {'monthly': {(2060, 1): 254.36921429634094,\n", - " (2060, 2): 100.66485917568207,\n", - " (2060, 3): 96.19198882579803,\n", - " (2060, 4): 87.02756667137146,\n", - " (2060, 5): 77.34562230110168,\n", - " (2060, 6): 26.229256868362427,\n", - " (2060, 7): 63.0741183757782,\n", - " (2060, 8): 5.499953508377075,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 1.788832187652588,\n", - " (2060, 11): 21.140050172805786,\n", - " (2060, 12): 161.59408152103424},\n", - " 'window': {(2060, 1): 80.32052803039551,\n", - " (2060, 2): 46.830082178115845,\n", - " (2060, 3): 25.191416263580322,\n", - " (2060, 4): 58.00192618370056,\n", - " (2060, 5): 28.35788106918335,\n", - " (2060, 6): 9.134818077087402,\n", - " (2060, 7): 26.94859290122986,\n", - " (2060, 8): 4.480764031410217,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 1.788832187652588,\n", - " (2060, 11): 12.929760456085205,\n", - " (2060, 12): 68.56751918792725}},\n", - " 39: {'monthly': {(2060, 1): 296.34627890586853,\n", - " (2060, 2): 106.02599656581879,\n", - " (2060, 3): 66.53966355323792,\n", - " (2060, 4): 4.872930526733398,\n", - " (2060, 5): 14.977654576301575,\n", - " (2060, 6): 10.490819811820984,\n", - " (2060, 7): 20.163483262062073,\n", - " (2060, 8): 1.1758471727371216,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 1.1965882778167725,\n", - " (2060, 11): 22.440502882003784,\n", - " (2060, 12): 101.86919367313385},\n", - " 'window': {(2060, 1): 106.1564769744873,\n", - " (2060, 2): 66.09535598754883,\n", - " (2060, 3): 35.5235755443573,\n", - " (2060, 4): 2.688153862953186,\n", - " (2060, 5): 6.6557347774505615,\n", - " (2060, 6): 4.936112880706787,\n", - " (2060, 7): 7.0487953424453735,\n", - " (2060, 8): 1.1758471727371216,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 1.1965882778167725,\n", - " (2060, 11): 11.939525127410889,\n", - " (2060, 12): 65.46726632118225}},\n", - " 40: {'monthly': {(2060, 1): 293.44141376018524,\n", - " (2060, 2): 63.1215763092041,\n", - " (2060, 3): 56.473179936409,\n", - " (2060, 4): 25.943652153015137,\n", - " (2060, 5): 27.41191554069519,\n", - " (2060, 6): 15.26547646522522,\n", - " (2060, 7): 25.399811625480652,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 10.54373574256897,\n", - " (2060, 12): 75.83462905883789},\n", - " 'window': {(2060, 1): 99.29912853240967,\n", - " (2060, 2): 32.747127652168274,\n", - " (2060, 3): 22.922966361045837,\n", - " (2060, 4): 21.010313749313354,\n", - " (2060, 5): 12.786853551864624,\n", - " (2060, 6): 5.10566771030426,\n", - " (2060, 7): 9.191073894500732,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 9.516861081123352,\n", - " (2060, 12): 40.26206588745117}},\n", - " 41: {'monthly': {(2060, 1): 312.1551994085312,\n", - " (2060, 2): 59.118239998817444,\n", - " (2060, 3): 56.35863268375397,\n", - " (2060, 4): 29.997666358947754,\n", - " (2060, 5): 21.863510847091675,\n", - " (2060, 6): 15.26547646522522,\n", - " (2060, 7): 25.356513500213623,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 11.32293152809143,\n", - " (2060, 12): 72.43608689308167},\n", - " 'window': {(2060, 1): 124.02936744689941,\n", - " (2060, 2): 31.41458761692047,\n", - " (2060, 3): 24.199498414993286,\n", - " (2060, 4): 26.912252187728882,\n", - " (2060, 5): 8.894617795944214,\n", - " (2060, 6): 5.10566771030426,\n", - " (2060, 7): 9.691251039505005,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 10.272989511489868,\n", - " (2060, 12): 40.635133504867554}},\n", - " 42: {'monthly': {(2060, 1): 302.9287323951721,\n", - " (2060, 2): 57.08472788333893,\n", - " (2060, 3): 56.8288209438324,\n", - " (2060, 4): 35.67411530017853,\n", - " (2060, 5): 18.65407705307007,\n", - " (2060, 6): 15.26547646522522,\n", - " (2060, 7): 23.033772230148315,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 9.466933488845825,\n", - " (2060, 12): 67.1070362329483},\n", - " 'window': {(2060, 1): 124.20862865447998,\n", - " (2060, 2): 28.935069918632507,\n", - " (2060, 3): 23.62764286994934,\n", - " (2060, 4): 31.938618421554565,\n", - " (2060, 5): 6.687414646148682,\n", - " (2060, 6): 5.10566771030426,\n", - " (2060, 7): 8.421351790428162,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 8.348963022232056,\n", - " (2060, 12): 37.56912398338318}},\n", - " 43: {'monthly': {(2060, 1): 297.01501405239105,\n", - " (2060, 2): 60.02446782588959,\n", - " (2060, 3): 59.921448945999146,\n", - " (2060, 4): 41.68176209926605,\n", - " (2060, 5): 18.838627576828003,\n", - " (2060, 6): 15.483638167381287,\n", - " (2060, 7): 19.101704716682434,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 1.1451897621154785,\n", - " (2060, 11): 11.980512022972107,\n", - " (2060, 12): 67.05636274814606},\n", - " 'window': {(2060, 1): 108.92272281646729,\n", - " (2060, 2): 31.343198657035828,\n", - " (2060, 3): 23.68299901485443,\n", - " (2060, 4): 35.69923543930054,\n", - " (2060, 5): 6.832783818244934,\n", - " (2060, 6): 5.10566771030426,\n", - " (2060, 7): 8.509528756141663,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 1.1451897621154785,\n", - " (2060, 11): 10.416757702827454,\n", - " (2060, 12): 33.76798367500305}},\n", - " 44: {'monthly': {(2060, 1): 310.572588801384,\n", - " (2060, 2): 66.20637154579163,\n", - " (2060, 3): 67.14249265193939,\n", - " (2060, 4): 50.98197638988495,\n", - " (2060, 5): 31.154293656349182,\n", - " (2060, 6): 19.781296014785767,\n", - " (2060, 7): 39.74087381362915,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 2.179506540298462,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 15.543122291564941,\n", - " (2060, 12): 91.31154823303223},\n", - " 'window': {(2060, 1): 106.13670253753662,\n", - " (2060, 2): 36.73829114437103,\n", - " (2060, 3): 24.392775535583496,\n", - " (2060, 4): 34.94693088531494,\n", - " (2060, 5): 10.81454348564148,\n", - " (2060, 6): 5.147720813751221,\n", - " (2060, 7): 15.423827648162842,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 1.1790852546691895,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 10.809877157211304,\n", - " (2060, 12): 47.75798273086548}},\n", - " 45: {'monthly': {(2060, 1): 338.05555379390717,\n", - " (2060, 2): 74.12038898468018,\n", - " (2060, 3): 87.50362753868103,\n", - " (2060, 4): 61.81269907951355,\n", - " (2060, 5): 37.02108919620514,\n", - " (2060, 6): 21.52884018421173,\n", - " (2060, 7): 51.25582206249237,\n", - " (2060, 8): 1.2169336080551147,\n", - " (2060, 9): 1.0004212856292725,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 14.514801144599915,\n", - " (2060, 12): 97.00152492523193},\n", - " 'window': {(2060, 1): 119.35415267944336,\n", - " (2060, 2): 40.48087024688721,\n", - " (2060, 3): 34.14340543746948,\n", - " (2060, 4): 38.44229733943939,\n", - " (2060, 5): 12.384299397468567,\n", - " (2060, 6): 5.24444580078125,\n", - " (2060, 7): 22.16848337650299,\n", - " (2060, 8): 1.2169336080551147,\n", - " (2060, 9): 1.0004212856292725,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 10.576711058616638,\n", - " (2060, 12): 49.71320962905884}},\n", - " 46: {'monthly': {(2060, 1): 323.9993249177933,\n", - " (2060, 2): 66.34102642536163,\n", - " (2060, 3): 92.5652767419815,\n", - " (2060, 4): 55.37121069431305,\n", - " (2060, 5): 41.89298105239868,\n", - " (2060, 6): 23.51865589618683,\n", - " (2060, 7): 56.55525732040405,\n", - " (2060, 8): 2.346856951713562,\n", - " (2060, 9): 2.1987487077713013,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 13.131214380264282,\n", - " (2060, 12): 85.30160176753998},\n", - " 'window': {(2060, 1): 120.87812328338623,\n", - " (2060, 2): 35.553818464279175,\n", - " (2060, 3): 37.55263113975525,\n", - " (2060, 4): 32.23172914981842,\n", - " (2060, 5): 13.936350226402283,\n", - " (2060, 6): 6.323542356491089,\n", - " (2060, 7): 23.068095803260803,\n", - " (2060, 8): 1.1995497941970825,\n", - " (2060, 9): 1.1983274221420288,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 10.302769303321838,\n", - " (2060, 12): 44.47944164276123}},\n", - " 47: {'monthly': {(2060, 1): 291.80711805820465,\n", - " (2060, 2): 66.82185900211334,\n", - " (2060, 3): 92.15792214870453,\n", - " (2060, 4): 47.38119912147522,\n", - " (2060, 5): 44.079264879226685,\n", - " (2060, 6): 24.032878756523132,\n", - " (2060, 7): 68.5338853597641,\n", - " (2060, 8): 1.1851654052734375,\n", - " (2060, 9): 2.473771095275879,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 18.487160325050354,\n", - " (2060, 12): 98.34291529655457},\n", - " 'window': {(2060, 1): 109.67722415924072,\n", - " (2060, 2): 34.88581192493439,\n", - " (2060, 3): 40.72154259681702,\n", - " (2060, 4): 23.35670793056488,\n", - " (2060, 5): 15.031364798545837,\n", - " (2060, 6): 6.084531545639038,\n", - " (2060, 7): 30.66501533985138,\n", - " (2060, 8): 1.1851654052734375,\n", - " (2060, 9): 1.4733498096466064,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 13.630132913589478,\n", - " (2060, 12): 52.23294687271118}},\n", - " 48: {'monthly': {(2060, 1): 232.86843287944794,\n", - " (2060, 2): 79.20909202098846,\n", - " (2060, 3): 74.777578830719,\n", - " (2060, 4): 46.5446480512619,\n", - " (2060, 5): 61.405011773109436,\n", - " (2060, 6): 22.42486083507538,\n", - " (2060, 7): 45.86200153827667,\n", - " (2060, 8): 6.049154162406921,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 20.72250521183014,\n", - " (2060, 12): 140.11458957195282},\n", - " 'window': {(2060, 1): 67.99775123596191,\n", - " (2060, 2): 41.35743045806885,\n", - " (2060, 3): 23.960975408554077,\n", - " (2060, 4): 33.193228006362915,\n", - " (2060, 5): 20.590067625045776,\n", - " (2060, 6): 8.250998854637146,\n", - " (2060, 7): 18.389763116836548,\n", - " (2060, 8): 2.8710052967071533,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 15.099194407463074,\n", - " (2060, 12): 58.4426212310791}},\n", - " 49: {'monthly': {(2060, 1): 260.52293598651886,\n", - " (2060, 2): 88.93400633335114,\n", - " (2060, 3): 87.91801726818085,\n", - " (2060, 4): 69.65221166610718,\n", - " (2060, 5): 76.21527993679047,\n", - " (2060, 6): 25.818598866462708,\n", - " (2060, 7): 61.71872842311859,\n", - " (2060, 8): 4.524521350860596,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 24.807042717933655,\n", - " (2060, 12): 158.91597938537598},\n", - " 'window': {(2060, 1): 78.7003984451294,\n", - " (2060, 2): 41.59111309051514,\n", - " (2060, 3): 27.146867275238037,\n", - " (2060, 4): 47.81881523132324,\n", - " (2060, 5): 27.432798862457275,\n", - " (2060, 6): 9.757168889045715,\n", - " (2060, 7): 26.740872144699097,\n", - " (2060, 8): 3.505331873893738,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 15.70863664150238,\n", - " (2060, 12): 66.44653129577637}},\n", - " 50: {'monthly': {(2060, 1): 305.56155347824097,\n", - " (2060, 2): 112.92953598499298,\n", - " (2060, 3): 108.7041906118393,\n", - " (2060, 4): 92.67277431488037,\n", - " (2060, 5): 98.37887167930603,\n", - " (2060, 6): 33.45290994644165,\n", - " (2060, 7): 82.38717007637024,\n", - " (2060, 8): 5.5008251667022705,\n", - " (2060, 9): 1.3174622058868408,\n", - " (2060, 10): 3.566159725189209,\n", - " (2060, 11): 26.148690462112427,\n", - " (2060, 12): 195.13830077648163},\n", - " 'window': {(2060, 1): 90.13490009307861,\n", - " (2060, 2): 44.961533546447754,\n", - " (2060, 3): 31.02476167678833,\n", - " (2060, 4): 57.912015438079834,\n", - " (2060, 5): 35.81250476837158,\n", - " (2060, 6): 12.259753704071045,\n", - " (2060, 7): 38.44519901275635,\n", - " (2060, 8): 4.481635689735413,\n", - " (2060, 9): 1.3174622058868408,\n", - " (2060, 10): 2.303812623023987,\n", - " (2060, 11): 16.67792010307312,\n", - " (2060, 12): 80.9930009841919}},\n", - " 51: {'monthly': {(2060, 1): 271.6168885231018,\n", - " (2060, 2): 103.74981260299683,\n", - " (2060, 3): 100.69607329368591,\n", - " (2060, 4): 85.75639688968658,\n", - " (2060, 5): 87.4586672782898,\n", - " (2060, 6): 29.670650601387024,\n", - " (2060, 7): 68.37385511398315,\n", - " (2060, 8): 5.560763359069824,\n", - " (2060, 9): 2.577396035194397,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 23.464828491210938,\n", - " (2060, 12): 181.35594391822815},\n", - " 'window': {(2060, 1): 85.2097339630127,\n", - " (2060, 2): 39.2038471698761,\n", - " (2060, 3): 30.043171405792236,\n", - " (2060, 4): 55.606667041778564,\n", - " (2060, 5): 31.737778782844543,\n", - " (2060, 6): 10.428610801696777,\n", - " (2060, 7): 30.850934982299805,\n", - " (2060, 8): 4.541573882102966,\n", - " (2060, 9): 1.3179986476898193,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 14.515791058540344,\n", - " (2060, 12): 80.35700416564941}},\n", - " 52: {'monthly': {(2060, 1): 269.23336243629456,\n", - " (2060, 2): 100.95813119411469,\n", - " (2060, 3): 76.843106508255,\n", - " (2060, 4): 8.69933557510376,\n", - " (2060, 5): 14.250001430511475,\n", - " (2060, 6): 9.48189914226532,\n", - " (2060, 7): 18.906371235847473,\n", - " (2060, 8): 1.1758471727371216,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 1.1965882778167725,\n", - " (2060, 11): 22.801262617111206,\n", - " (2060, 12): 88.78945195674896},\n", - " 'window': {(2060, 1): 75.22465515136719,\n", - " (2060, 2): 59.07730293273926,\n", - " (2060, 3): 43.351332664489746,\n", - " (2060, 4): 5.34756863117218,\n", - " (2060, 5): 6.071171998977661,\n", - " (2060, 6): 4.936112880706787,\n", - " (2060, 7): 7.0487953424453735,\n", - " (2060, 8): 1.1758471727371216,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 1.1965882778167725,\n", - " (2060, 11): 12.817956686019897,\n", - " (2060, 12): 51.88027000427246}},\n", - " 53: {'monthly': {(2060, 1): 271.574245929718,\n", - " (2060, 2): 64.07821762561798,\n", - " (2060, 3): 63.8915981054306,\n", - " (2060, 4): 32.86189270019531,\n", - " (2060, 5): 22.903871297836304,\n", - " (2060, 6): 17.832676649093628,\n", - " (2060, 7): 27.15268349647522,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 11.299611210823059,\n", - " (2060, 12): 86.25049686431885},\n", - " 'window': {(2060, 1): 64.22991275787354,\n", - " (2060, 2): 33.644176602363586,\n", - " (2060, 3): 26.31357741355896,\n", - " (2060, 4): 27.337915897369385,\n", - " (2060, 5): 10.871824979782104,\n", - " (2060, 6): 5.10566771030426,\n", - " (2060, 7): 10.00497579574585,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 9.318687915802002,\n", - " (2060, 12): 42.11281394958496}},\n", - " 54: {'monthly': {(2060, 1): 276.67508256435394,\n", - " (2060, 2): 62.4969801902771,\n", - " (2060, 3): 66.46016669273376,\n", - " (2060, 4): 38.3826961517334,\n", - " (2060, 5): 19.943756580352783,\n", - " (2060, 6): 15.26547646522522,\n", - " (2060, 7): 26.045981884002686,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 1.1605983972549438,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 11.695985078811646,\n", - " (2060, 12): 83.78844320774078},\n", - " 'window': {(2060, 1): 75.07154750823975,\n", - " (2060, 2): 30.190932631492615,\n", - " (2060, 3): 27.413180112838745,\n", - " (2060, 4): 30.423236846923828,\n", - " (2060, 5): 7.782383680343628,\n", - " (2060, 6): 5.10566771030426,\n", - " (2060, 7): 10.771381616592407,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 1.1605983972549438,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 8.668020009994507,\n", - " (2060, 12): 40.10166668891907}},\n", - " 55: {'monthly': {(2060, 1): 256.55820286273956,\n", - " (2060, 2): 64.56242799758911,\n", - " (2060, 3): 67.34674417972565,\n", - " (2060, 4): 40.11650240421295,\n", - " (2060, 5): 16.999387860298157,\n", - " (2060, 6): 16.498343229293823,\n", - " (2060, 7): 24.96134376525879,\n", - " (2060, 8): 1.0266549587249756,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 1.0812721252441406,\n", - " (2060, 11): 11.962963819503784,\n", - " (2060, 12): 72.541916847229},\n", - " 'window': {(2060, 1): 75.47796058654785,\n", - " (2060, 2): 31.543598294258118,\n", - " (2060, 3): 26.78738045692444,\n", - " (2060, 4): 32.83000457286835,\n", - " (2060, 5): 6.283385157585144,\n", - " (2060, 6): 5.10566771030426,\n", - " (2060, 7): 10.91094970703125,\n", - " (2060, 8): 1.0266549587249756,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 1.0812721252441406,\n", - " (2060, 11): 9.583699464797974,\n", - " (2060, 12): 34.68029713630676}},\n", - " 56: {'monthly': {(2060, 1): 257.0462359189987,\n", - " (2060, 2): 65.40068066120148,\n", - " (2060, 3): 59.88535284996033,\n", - " (2060, 4): 36.76952874660492,\n", - " (2060, 5): 17.226311206817627,\n", - " (2060, 6): 18.407957673072815,\n", - " (2060, 7): 22.947332620620728,\n", - " (2060, 8): 1.0269986391067505,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 11.929160714149475,\n", - " (2060, 12): 64.79909360408783},\n", - " 'window': {(2060, 1): 71.10840034484863,\n", - " (2060, 2): 33.15618133544922,\n", - " (2060, 3): 27.737991094589233,\n", - " (2060, 4): 32.075066804885864,\n", - " (2060, 5): 5.898266673088074,\n", - " (2060, 6): 6.118122816085815,\n", - " (2060, 7): 11.226681232452393,\n", - " (2060, 8): 1.0269986391067505,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 10.239583849906921,\n", - " (2060, 12): 29.841508865356445}},\n", - " 57: {'monthly': {(2060, 1): 282.7937602996826,\n", - " (2060, 2): 81.02010464668274,\n", - " (2060, 3): 74.17176043987274,\n", - " (2060, 4): 44.05560767650604,\n", - " (2060, 5): 37.076887130737305,\n", - " (2060, 6): 20.709493398666382,\n", - " (2060, 7): 42.1733455657959,\n", - " (2060, 8): 1.3837918043136597,\n", - " (2060, 9): 2.217339515686035,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 13.555376052856445,\n", - " (2060, 12): 96.42646145820618},\n", - " 'window': {(2060, 1): 76.16033267974854,\n", - " (2060, 2): 44.5261549949646,\n", - " (2060, 3): 28.00990867614746,\n", - " (2060, 4): 24.551158905029297,\n", - " (2060, 5): 13.080930709838867,\n", - " (2060, 6): 5.856213808059692,\n", - " (2060, 7): 16.94681739807129,\n", - " (2060, 8): 1.3837918043136597,\n", - " (2060, 9): 1.2169182300567627,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 8.620388746261597,\n", - " (2060, 12): 44.9322943687439}},\n", - " 58: {'monthly': {(2060, 1): 302.1357239484787,\n", - " (2060, 2): 87.6518737077713,\n", - " (2060, 3): 96.81672382354736,\n", - " (2060, 4): 49.37209236621857,\n", - " (2060, 5): 43.68092584609985,\n", - " (2060, 6): 25.714060187339783,\n", - " (2060, 7): 60.80825459957123,\n", - " (2060, 8): 2.5441832542419434,\n", - " (2060, 9): 2.4054065942764282,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 14.501908659934998,\n", - " (2060, 12): 99.73211181163788},\n", - " 'window': {(2060, 1): 85.13810539245605,\n", - " (2060, 2): 46.63560724258423,\n", - " (2060, 3): 39.568392515182495,\n", - " (2060, 4): 26.011451959609985,\n", - " (2060, 5): 15.48485517501831,\n", - " (2060, 6): 5.823116064071655,\n", - " (2060, 7): 24.86955201625824,\n", - " (2060, 8): 1.480594515800476,\n", - " (2060, 9): 1.4049853086471558,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 8.298777103424072,\n", - " (2060, 12): 47.08159923553467}},\n", - " 59: {'monthly': {(2060, 1): 280.5918091535568,\n", - " (2060, 2): 76.78378939628601,\n", - " (2060, 3): 103.15467810630798,\n", - " (2060, 4): 45.70095455646515,\n", - " (2060, 5): 46.743781208992004,\n", - " (2060, 6): 22.75943636894226,\n", - " (2060, 7): 66.77107536792755,\n", - " (2060, 8): 2.174009919166565,\n", - " (2060, 9): 2.788538098335266,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 15.498019933700562,\n", - " (2060, 12): 104.03657591342926},\n", - " 'window': {(2060, 1): 85.21144390106201,\n", - " (2060, 2): 39.69208884239197,\n", - " (2060, 3): 43.803524017333984,\n", - " (2060, 4): 22.774666905403137,\n", - " (2060, 5): 17.980945348739624,\n", - " (2060, 6): 6.0052220821380615,\n", - " (2060, 7): 30.459508299827576,\n", - " (2060, 8): 1.1018433570861816,\n", - " (2060, 9): 1.7881168127059937,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 9.594896912574768,\n", - " (2060, 12): 51.66110563278198}},\n", - " 60: {'monthly': {(2060, 1): 268.0081123113632,\n", - " (2060, 2): 85.52336835861206,\n", - " (2060, 3): 107.8065857887268,\n", - " (2060, 4): 40.294859409332275,\n", - " (2060, 5): 52.18461990356445,\n", - " (2060, 6): 25.9208664894104,\n", - " (2060, 7): 82.13771438598633,\n", - " (2060, 8): 1.968593716621399,\n", - " (2060, 9): 3.331012725830078,\n", - " (2060, 10): 1.9116733074188232,\n", - " (2060, 11): 24.26675319671631,\n", - " (2060, 12): 125.94556701183319},\n", - " 'window': {(2060, 1): 75.16982460021973,\n", - " (2060, 2): 49.43004250526428,\n", - " (2060, 3): 52.142391204833984,\n", - " (2060, 4): 17.15020263195038,\n", - " (2060, 5): 19.942180156707764,\n", - " (2060, 6): 8.78093671798706,\n", - " (2060, 7): 38.58820867538452,\n", - " (2060, 8): 1.968593716621399,\n", - " (2060, 9): 1.313759446144104,\n", - " (2060, 10): 1.9116733074188232,\n", - " (2060, 11): 15.726274013519287,\n", - " (2060, 12): 66.37209939956665}},\n", - " 61: {'monthly': {(2060, 1): 292.7888967990875,\n", - " (2060, 2): 109.16780197620392,\n", - " (2060, 3): 109.11694657802582,\n", - " (2060, 4): 48.500935792922974,\n", - " (2060, 5): 67.15955424308777,\n", - " (2060, 6): 25.905744552612305,\n", - " (2060, 7): 50.568225383758545,\n", - " (2060, 8): 5.09878945350647,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 1.8677104711532593,\n", - " (2060, 11): 34.522743344306946,\n", - " (2060, 12): 203.05811822414398},\n", - " 'window': {(2060, 1): 79.46556949615479,\n", - " (2060, 2): 45.08935594558716,\n", - " (2060, 3): 34.89474964141846,\n", - " (2060, 4): 26.052758932113647,\n", - " (2060, 5): 23.03054141998291,\n", - " (2060, 6): 11.202951908111572,\n", - " (2060, 7): 22.62111473083496,\n", - " (2060, 8): 4.079599976539612,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 1.8677104711532593,\n", - " (2060, 11): 19.993054032325745,\n", - " (2060, 12): 83.62812042236328}},\n", - " 62: {'monthly': {(2060, 1): 313.5308508872986,\n", - " (2060, 2): 123.57570147514343,\n", - " (2060, 3): 116.73240900039673,\n", - " (2060, 4): 61.57898247241974,\n", - " (2060, 5): 77.26106441020966,\n", - " (2060, 6): 29.3266783952713,\n", - " (2060, 7): 62.26579201221466,\n", - " (2060, 8): 5.637094259262085,\n", - " (2060, 9): 2.1040163040161133,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 33.75892102718353,\n", - " (2060, 12): 217.09416830539703},\n", - " 'window': {(2060, 1): 85.37635898590088,\n", - " (2060, 2): 43.62989282608032,\n", - " (2060, 3): 34.1554479598999,\n", - " (2060, 4): 36.99854898452759,\n", - " (2060, 5): 26.887775421142578,\n", - " (2060, 6): 13.242567658424377,\n", - " (2060, 7): 28.925058364868164,\n", - " (2060, 8): 4.617904782295227,\n", - " (2060, 9): 1.096472978591919,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 20.306493401527405,\n", - " (2060, 12): 94.40996360778809}},\n", - " 63: {'monthly': {(2060, 1): 333.19602513313293,\n", - " (2060, 2): 128.08823037147522,\n", - " (2060, 3): 126.83178520202637,\n", - " (2060, 4): 75.66251623630524,\n", - " (2060, 5): 95.61656475067139,\n", - " (2060, 6): 32.58041524887085,\n", - " (2060, 7): 77.56253051757812,\n", - " (2060, 8): 6.960810899734497,\n", - " (2060, 9): 4.214321136474609,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 32.24674463272095,\n", - " (2060, 12): 253.861119389534},\n", - " 'window': {(2060, 1): 89.35568904876709,\n", - " (2060, 2): 43.541112184524536,\n", - " (2060, 3): 39.29679727554321,\n", - " (2060, 4): 44.915099143981934,\n", - " (2060, 5): 37.04738163948059,\n", - " (2060, 6): 14.553873777389526,\n", - " (2060, 7): 36.055237770080566,\n", - " (2060, 8): 5.941621422767639,\n", - " (2060, 9): 1.7552034854888916,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 18.64852774143219,\n", - " (2060, 12): 105.69898223876953}},\n", - " 64: {'monthly': {(2060, 1): 285.6768088340759,\n", - " (2060, 2): 111.06377422809601,\n", - " (2060, 3): 104.3330717086792,\n", - " (2060, 4): 65.22247278690338,\n", - " (2060, 5): 93.03929150104523,\n", - " (2060, 6): 27.736902594566345,\n", - " (2060, 7): 63.00870990753174,\n", - " (2060, 8): 6.559736490249634,\n", - " (2060, 9): 1.4047093391418457,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 27.343021512031555,\n", - " (2060, 12): 226.40019130706787},\n", - " 'window': {(2060, 1): 76.66573810577393,\n", - " (2060, 2): 39.45415282249451,\n", - " (2060, 3): 34.79050064086914,\n", - " (2060, 4): 41.11890363693237,\n", - " (2060, 5): 37.210943818092346,\n", - " (2060, 6): 10.624871730804443,\n", - " (2060, 7): 29.069994688034058,\n", - " (2060, 8): 5.540547013282776,\n", - " (2060, 9): 1.4047093391418457,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 15.924410581588745,\n", - " (2060, 12): 98.20166873931885}},\n", - " 65: {'monthly': {(2060, 1): 440.82160449028015,\n", - " (2060, 2): 117.44339263439178,\n", - " (2060, 3): 69.91033148765564,\n", - " (2060, 4): 17.588761925697327,\n", - " (2060, 5): 19.851252555847168,\n", - " (2060, 6): 11.146860599517822,\n", - " (2060, 7): 22.507132053375244,\n", - " (2060, 8): 1.321013331413269,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 1.3135926723480225,\n", - " (2060, 11): 23.328718066215515,\n", - " (2060, 12): 134.64372944831848},\n", - " 'window': {(2060, 1): 168.71145725250244,\n", - " (2060, 2): 50.760831117630005,\n", - " (2060, 3): 22.366604804992676,\n", - " (2060, 4): 11.661816120147705,\n", - " (2060, 5): 7.053223013877869,\n", - " (2060, 6): 5.541702628135681,\n", - " (2060, 7): 7.036111116409302,\n", - " (2060, 8): 1.321013331413269,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 1.3135926723480225,\n", - " (2060, 11): 11.897464752197266,\n", - " (2060, 12): 76.34305763244629}},\n", - " 66: {'monthly': {(2060, 1): 312.22875893116,\n", - " (2060, 2): 61.02839779853821,\n", - " (2060, 3): 62.05899119377136,\n", - " (2060, 4): 37.73780298233032,\n", - " (2060, 5): 28.908432245254517,\n", - " (2060, 6): 14.497554302215576,\n", - " (2060, 7): 22.923054099082947,\n", - " (2060, 8): 2.0626766681671143,\n", - " (2060, 9): 1.123965859413147,\n", - " (2060, 10): 1.4419366121292114,\n", - " (2060, 11): 23.246323108673096,\n", - " (2060, 12): 122.93814408779144},\n", - " 'window': {(2060, 1): 79.7134370803833,\n", - " (2060, 2): 22.0250186920166,\n", - " (2060, 3): 17.716933369636536,\n", - " (2060, 4): 24.71159517765045,\n", - " (2060, 5): 12.526257991790771,\n", - " (2060, 6): 5.7512863874435425,\n", - " (2060, 7): 8.678116202354431,\n", - " (2060, 8): 2.0626766681671143,\n", - " (2060, 9): 1.123965859413147,\n", - " (2060, 10): 1.4419366121292114,\n", - " (2060, 11): 14.503892421722412,\n", - " (2060, 12): 38.45936393737793}},\n", - " 67: {'monthly': {(2060, 1): 316.76981461048126,\n", - " (2060, 2): 56.90897214412689,\n", - " (2060, 3): 63.09960663318634,\n", - " (2060, 4): 38.9472873210907,\n", - " (2060, 5): 26.930855751037598,\n", - " (2060, 6): 14.426434755325317,\n", - " (2060, 7): 25.620975017547607,\n", - " (2060, 8): 2.0626766681671143,\n", - " (2060, 9): 1.123965859413147,\n", - " (2060, 10): 1.4419366121292114,\n", - " (2060, 11): 19.19044852256775,\n", - " (2060, 12): 111.81461441516876},\n", - " 'window': {(2060, 1): 86.39096164703369,\n", - " (2060, 2): 20.37047290802002,\n", - " (2060, 3): 17.866928219795227,\n", - " (2060, 4): 25.744431853294373,\n", - " (2060, 5): 11.684890747070312,\n", - " (2060, 6): 5.636223196983337,\n", - " (2060, 7): 10.62198281288147,\n", - " (2060, 8): 2.0626766681671143,\n", - " (2060, 9): 1.123965859413147,\n", - " (2060, 10): 1.4419366121292114,\n", - " (2060, 11): 11.54584527015686,\n", - " (2060, 12): 39.52672004699707}},\n", - " 68: {'monthly': {(2060, 1): 322.3554049730301,\n", - " (2060, 2): 62.581493735313416,\n", - " (2060, 3): 63.77372682094574,\n", - " (2060, 4): 37.02615809440613,\n", - " (2060, 5): 29.80863320827484,\n", - " (2060, 6): 14.650118827819824,\n", - " (2060, 7): 27.388354778289795,\n", - " (2060, 8): 2.0626766681671143,\n", - " (2060, 9): 1.123965859413147,\n", - " (2060, 10): 1.4419366121292114,\n", - " (2060, 11): 18.028217911720276,\n", - " (2060, 12): 109.98302471637726},\n", - " 'window': {(2060, 1): 92.82952213287354,\n", - " (2060, 2): 23.898328065872192,\n", - " (2060, 3): 19.627105712890625,\n", - " (2060, 4): 22.37584114074707,\n", - " (2060, 5): 12.316118717193604,\n", - " (2060, 6): 5.636223196983337,\n", - " (2060, 7): 12.323124051094055,\n", - " (2060, 8): 2.0626766681671143,\n", - " (2060, 9): 1.123965859413147,\n", - " (2060, 10): 1.4419366121292114,\n", - " (2060, 11): 9.03768002986908,\n", - " (2060, 12): 46.60901403427124}},\n", - " 69: {'monthly': {(2060, 1): 324.8189243078232,\n", - " (2060, 2): 55.95040559768677,\n", - " (2060, 3): 70.72991800308228,\n", - " (2060, 4): 33.54911279678345,\n", - " (2060, 5): 35.5138943195343,\n", - " (2060, 6): 14.84165632724762,\n", - " (2060, 7): 28.772228240966797,\n", - " (2060, 8): 2.0626766681671143,\n", - " (2060, 9): 1.123965859413147,\n", - " (2060, 10): 1.4419366121292114,\n", - " (2060, 11): 14.335809111595154,\n", - " (2060, 12): 126.17200827598572},\n", - " 'window': {(2060, 1): 91.49054431915283,\n", - " (2060, 2): 20.217908263206482,\n", - " (2060, 3): 20.39297604560852,\n", - " (2060, 4): 19.547980427742004,\n", - " (2060, 5): 13.250032782554626,\n", - " (2060, 6): 5.744196534156799,\n", - " (2060, 7): 12.905387282371521,\n", - " (2060, 8): 2.0626766681671143,\n", - " (2060, 9): 1.123965859413147,\n", - " (2060, 10): 1.4419366121292114,\n", - " (2060, 11): 9.382394552230835,\n", - " (2060, 12): 54.73699378967285}},\n", - " 70: {'monthly': {(2060, 1): 273.48149716854095,\n", - " (2060, 2): 71.21043074131012,\n", - " (2060, 3): 89.44484567642212,\n", - " (2060, 4): 58.11458194255829,\n", - " (2060, 5): 45.45301914215088,\n", - " (2060, 6): 17.846460342407227,\n", - " (2060, 7): 41.75258672237396,\n", - " (2060, 8): 2.3134970664978027,\n", - " (2060, 9): 2.456578493118286,\n", - " (2060, 10): 4.1994582414627075,\n", - " (2060, 11): 25.34469425678253,\n", - " (2060, 12): 141.88000082969666},\n", - " 'window': {(2060, 1): 68.95414924621582,\n", - " (2060, 2): 28.07396936416626,\n", - " (2060, 3): 20.62586760520935,\n", - " (2060, 4): 31.7016921043396,\n", - " (2060, 5): 19.999135494232178,\n", - " (2060, 6): 5.86623227596283,\n", - " (2060, 7): 17.870219826698303,\n", - " (2060, 8): 2.3134970664978027,\n", - " (2060, 9): 1.2673903703689575,\n", - " (2060, 10): 1.5223034620285034,\n", - " (2060, 11): 15.332367062568665,\n", - " (2060, 12): 56.66273736953735}},\n", - " 71: {'monthly': {(2060, 1): 319.5482647418976,\n", - " (2060, 2): 77.09079074859619,\n", - " (2060, 3): 100.95844376087189,\n", - " (2060, 4): 71.83154308795929,\n", - " (2060, 5): 55.0343142747879,\n", - " (2060, 6): 18.393476366996765,\n", - " (2060, 7): 52.83565032482147,\n", - " (2060, 8): 4.688014268875122,\n", - " (2060, 9): 1.2673903703689575,\n", - " (2060, 10): 2.7917709350585938,\n", - " (2060, 11): 20.346505165100098,\n", - " (2060, 12): 136.0959131717682},\n", - " 'window': {(2060, 1): 92.64527130126953,\n", - " (2060, 2): 27.503440141677856,\n", - " (2060, 3): 27.04041051864624,\n", - " (2060, 4): 38.4141263961792,\n", - " (2060, 5): 25.562686800956726,\n", - " (2060, 6): 5.86623227596283,\n", - " (2060, 7): 27.137770771980286,\n", - " (2060, 8): 2.6003055572509766,\n", - " (2060, 9): 1.2673903703689575,\n", - " (2060, 10): 2.7917709350585938,\n", - " (2060, 11): 11.462571501731873,\n", - " (2060, 12): 58.062453269958496}},\n", - " 72: {'monthly': {(2060, 1): 316.17099046707153,\n", - " (2060, 2): 78.97496008872986,\n", - " (2060, 3): 96.2623496055603,\n", - " (2060, 4): 66.1089096069336,\n", - " (2060, 5): 51.34284234046936,\n", - " (2060, 6): 17.77188217639923,\n", - " (2060, 7): 53.928178548812866,\n", - " (2060, 8): 2.5614521503448486,\n", - " (2060, 9): 1.2673903703689575,\n", - " (2060, 10): 1.5223034620285034,\n", - " (2060, 11): 23.40457773208618,\n", - " (2060, 12): 125.96637105941772},\n", - " 'window': {(2060, 1): 110.33886623382568,\n", - " (2060, 2): 24.333059549331665,\n", - " (2060, 3): 26.685064792633057,\n", - " (2060, 4): 34.44007182121277,\n", - " (2060, 5): 22.722108960151672,\n", - " (2060, 6): 5.86623227596283,\n", - " (2060, 7): 28.638453125953674,\n", - " (2060, 8): 2.5614521503448486,\n", - " (2060, 9): 1.2673903703689575,\n", - " (2060, 10): 1.5223034620285034,\n", - " (2060, 11): 11.349576234817505,\n", - " (2060, 12): 51.04387331008911}},\n", - " 73: {'monthly': {(2060, 1): 369.699627161026,\n", - " (2060, 2): 86.67124009132385,\n", - " (2060, 3): 118.17396032810211,\n", - " (2060, 4): 55.57394731044769,\n", - " (2060, 5): 45.394081115722656,\n", - " (2060, 6): 15.541659355163574,\n", - " (2060, 7): 44.04018700122833,\n", - " (2060, 8): 2.3134970664978027,\n", - " (2060, 9): 1.2673903703689575,\n", - " (2060, 10): 1.5223034620285034,\n", - " (2060, 11): 23.929792881011963,\n", - " (2060, 12): 154.37221360206604},\n", - " 'window': {(2060, 1): 128.4540843963623,\n", - " (2060, 2): 29.962133646011353,\n", - " (2060, 3): 41.01997637748718,\n", - " (2060, 4): 31.378995656967163,\n", - " (2060, 5): 17.312564730644226,\n", - " (2060, 6): 5.86623227596283,\n", - " (2060, 7): 21.556610941886902,\n", - " (2060, 8): 2.3134970664978027,\n", - " (2060, 9): 1.2673903703689575,\n", - " (2060, 10): 1.5223034620285034,\n", - " (2060, 11): 11.96220588684082,\n", - " (2060, 12): 56.252963066101074}},\n", - " 74: {'monthly': {(2060, 1): 388.9918305873871,\n", - " (2060, 2): 134.17182052135468,\n", - " (2060, 3): 126.3960348367691,\n", - " (2060, 4): 51.076454162597656,\n", - " (2060, 5): 91.84212839603424,\n", - " (2060, 6): 20.335734605789185,\n", - " (2060, 7): 37.60754585266113,\n", - " (2060, 8): 4.91690456867218,\n", - " (2060, 9): 3.564685344696045,\n", - " (2060, 10): 1.6158994436264038,\n", - " (2060, 11): 56.6979101896286,\n", - " (2060, 12): 228.15455400943756},\n", - " 'window': {(2060, 1): 109.09965324401855,\n", - " (2060, 2): 56.47064161300659,\n", - " (2060, 3): 38.70751190185547,\n", - " (2060, 4): 36.2473464012146,\n", - " (2060, 5): 36.52785134315491,\n", - " (2060, 6): 8.619094848632812,\n", - " (2060, 7): 14.343244552612305,\n", - " (2060, 8): 2.1939847469329834,\n", - " (2060, 9): 3.564685344696045,\n", - " (2060, 10): 1.6158994436264038,\n", - " (2060, 11): 42.87330448627472,\n", - " (2060, 12): 78.01604270935059}},\n", - " 75: {'monthly': {(2060, 1): 367.2069035768509,\n", - " (2060, 2): 131.86600852012634,\n", - " (2060, 3): 96.31517386436462,\n", - " (2060, 4): 53.26142418384552,\n", - " (2060, 5): 68.35181558132172,\n", - " (2060, 6): 14.457128286361694,\n", - " (2060, 7): 38.952268242836,\n", - " (2060, 8): 3.734847664833069,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 43.787002086639404,\n", - " (2060, 12): 209.79356408119202},\n", - " 'window': {(2060, 1): 92.27061080932617,\n", - " (2060, 2): 61.612040758132935,\n", - " (2060, 3): 28.250245809555054,\n", - " (2060, 4): 39.622140645980835,\n", - " (2060, 5): 27.701233625411987,\n", - " (2060, 6): 4.990707993507385,\n", - " (2060, 7): 14.304802179336548,\n", - " (2060, 8): 1.4897879362106323,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 34.588873744010925,\n", - " (2060, 12): 73.99304103851318}},\n", - " 76: {'monthly': {(2060, 1): 379.80610513687134,\n", - " (2060, 2): 134.55282390117645,\n", - " (2060, 3): 101.20725095272064,\n", - " (2060, 4): 59.58903205394745,\n", - " (2060, 5): 65.97609984874725,\n", - " (2060, 6): 16.80138599872589,\n", - " (2060, 7): 41.151153922080994,\n", - " (2060, 8): 4.569647312164307,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 1.9068387746810913,\n", - " (2060, 11): 47.5063111782074,\n", - " (2060, 12): 224.52323782444},\n", - " 'window': {(2060, 1): 99.97816276550293,\n", - " (2060, 2): 66.8801097869873,\n", - " (2060, 3): 29.628304958343506,\n", - " (2060, 4): 44.20674109458923,\n", - " (2060, 5): 25.050671815872192,\n", - " (2060, 6): 6.325380802154541,\n", - " (2060, 7): 16.162364721298218,\n", - " (2060, 8): 2.9563634395599365,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 1.9068387746810913,\n", - " (2060, 11): 35.852142691612244,\n", - " (2060, 12): 80.58587837219238}},\n", - " 77: {'monthly': {(2060, 1): 338.95785546302795,\n", - " (2060, 2): 123.3495522737503,\n", - " (2060, 3): 88.18939626216888,\n", - " (2060, 4): 57.59814095497131,\n", - " (2060, 5): 72.0820780992508,\n", - " (2060, 6): 20.115527391433716,\n", - " (2060, 7): 40.04071581363678,\n", - " (2060, 8): 4.684894919395447,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 46.856433510780334,\n", - " (2060, 12): 199.78466284275055},\n", - " 'window': {(2060, 1): 86.15724277496338,\n", - " (2060, 2): 60.38109302520752,\n", - " (2060, 3): 24.724022269248962,\n", - " (2060, 4): 42.53684616088867,\n", - " (2060, 5): 28.339208126068115,\n", - " (2060, 6): 5.144341826438904,\n", - " (2060, 7): 14.559879779815674,\n", - " (2060, 8): 2.9416805505752563,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 39.4331237077713,\n", - " (2060, 12): 74.09885549545288}},\n", - " 78: {'monthly': {(2060, 1): 479.0052785873413,\n", - " (2060, 2): 96.80853509902954,\n", - " (2060, 3): 69.51140129566193,\n", - " (2060, 4): 15.317222237586975,\n", - " (2060, 5): 20.524593353271484,\n", - " (2060, 6): 10.66771948337555,\n", - " (2060, 7): 20.299644231796265,\n", - " (2060, 8): 1.321013331413269,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 1.3135926723480225,\n", - " (2060, 11): 28.324092507362366,\n", - " (2060, 12): 133.91616702079773},\n", - " 'window': {(2060, 1): 187.89316749572754,\n", - " (2060, 2): 36.21365177631378,\n", - " (2060, 3): 22.47821569442749,\n", - " (2060, 4): 10.588765263557434,\n", - " (2060, 5): 6.619479060173035,\n", - " (2060, 6): 4.909204721450806,\n", - " (2060, 7): 6.865109443664551,\n", - " (2060, 8): 1.321013331413269,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 1.3135926723480225,\n", - " (2060, 11): 13.72850787639618,\n", - " (2060, 12): 86.08967328071594}},\n", - " 79: {'monthly': {(2060, 1): 317.1194314956665,\n", - " (2060, 2): 63.922648668289185,\n", - " (2060, 3): 67.60525476932526,\n", - " (2060, 4): 37.030288338661194,\n", - " (2060, 5): 26.40389621257782,\n", - " (2060, 6): 14.296127200126648,\n", - " (2060, 7): 22.495447874069214,\n", - " (2060, 8): 2.0626766681671143,\n", - " (2060, 9): 1.123965859413147,\n", - " (2060, 10): 1.4419366121292114,\n", - " (2060, 11): 16.245019912719727,\n", - " (2060, 12): 112.13282775878906},\n", - " 'window': {(2060, 1): 91.86346340179443,\n", - " (2060, 2): 25.845792770385742,\n", - " (2060, 3): 21.88513422012329,\n", - " (2060, 4): 25.0652437210083,\n", - " (2060, 5): 11.56886339187622,\n", - " (2060, 6): 5.636223196983337,\n", - " (2060, 7): 7.952935814857483,\n", - " (2060, 8): 2.0626766681671143,\n", - " (2060, 9): 1.123965859413147,\n", - " (2060, 10): 1.4419366121292114,\n", - " (2060, 11): 9.63930058479309,\n", - " (2060, 12): 49.02622699737549}},\n", - " 80: {'monthly': {(2060, 1): 318.23274970054626,\n", - " (2060, 2): 59.23455214500427,\n", - " (2060, 3): 67.64131247997284,\n", - " (2060, 4): 38.625646233558655,\n", - " (2060, 5): 30.21599316596985,\n", - " (2060, 6): 14.357846856117249,\n", - " (2060, 7): 24.656868934631348,\n", - " (2060, 8): 2.0626766681671143,\n", - " (2060, 9): 1.123965859413147,\n", - " (2060, 10): 1.4419366121292114,\n", - " (2060, 11): 16.156139731407166,\n", - " (2060, 12): 103.72131931781769},\n", - " 'window': {(2060, 1): 96.81490516662598,\n", - " (2060, 2): 24.367602109909058,\n", - " (2060, 3): 19.889241099357605,\n", - " (2060, 4): 25.908962726593018,\n", - " (2060, 5): 12.45184588432312,\n", - " (2060, 6): 5.636223196983337,\n", - " (2060, 7): 10.004213452339172,\n", - " (2060, 8): 2.0626766681671143,\n", - " (2060, 9): 1.123965859413147,\n", - " (2060, 10): 1.4419366121292114,\n", - " (2060, 11): 9.413218975067139,\n", - " (2060, 12): 41.61114192008972}},\n", - " 81: {'monthly': {(2060, 1): 350.5846199989319,\n", - " (2060, 2): 61.55046367645264,\n", - " (2060, 3): 77.11431789398193,\n", - " (2060, 4): 44.07606375217438,\n", - " (2060, 5): 37.87879729270935,\n", - " (2060, 6): 14.911463618278503,\n", - " (2060, 7): 35.15776979923248,\n", - " (2060, 8): 3.149235486984253,\n", - " (2060, 9): 1.123965859413147,\n", - " (2060, 10): 1.4419366121292114,\n", - " (2060, 11): 20.00441551208496,\n", - " (2060, 12): 122.06010508537292},\n", - " 'window': {(2060, 1): 105.89646434783936,\n", - " (2060, 2): 21.64918851852417,\n", - " (2060, 3): 24.228016138076782,\n", - " (2060, 4): 24.267539381980896,\n", - " (2060, 5): 15.133147239685059,\n", - " (2060, 6): 5.809334993362427,\n", - " (2060, 7): 15.843757033348083,\n", - " (2060, 8): 2.0626766681671143,\n", - " (2060, 9): 1.123965859413147,\n", - " (2060, 10): 1.4419366121292114,\n", - " (2060, 11): 12.667652368545532,\n", - " (2060, 12): 52.11162281036377}},\n", - " 82: {'monthly': {(2060, 1): 368.0686823129654,\n", - " (2060, 2): 64.5307469367981,\n", - " (2060, 3): 91.66552138328552,\n", - " (2060, 4): 44.940720558166504,\n", - " (2060, 5): 43.604971051216125,\n", - " (2060, 6): 17.431106686592102,\n", - " (2060, 7): 38.931607365608215,\n", - " (2060, 8): 2.0626766681671143,\n", - " (2060, 9): 1.1511561870574951,\n", - " (2060, 10): 1.4419366121292114,\n", - " (2060, 11): 22.737848162651062,\n", - " (2060, 12): 146.93475019931793},\n", - " 'window': {(2060, 1): 109.03694248199463,\n", - " (2060, 2): 22.223602414131165,\n", - " (2060, 3): 29.62155508995056,\n", - " (2060, 4): 22.792277693748474,\n", - " (2060, 5): 17.568761467933655,\n", - " (2060, 6): 5.715153932571411,\n", - " (2060, 7): 18.32393515110016,\n", - " (2060, 8): 2.0626766681671143,\n", - " (2060, 9): 1.1511561870574951,\n", - " (2060, 10): 1.4419366121292114,\n", - " (2060, 11): 13.077733397483826,\n", - " (2060, 12): 65.934814453125}},\n", - " 83: {'monthly': {(2060, 1): 328.6817362308502,\n", - " (2060, 2): 75.21770143508911,\n", - " (2060, 3): 113.64237594604492,\n", - " (2060, 4): 65.14501011371613,\n", - " (2060, 5): 52.81231653690338,\n", - " (2060, 6): 17.851176500320435,\n", - " (2060, 7): 44.32062542438507,\n", - " (2060, 8): 2.3611903190612793,\n", - " (2060, 9): 1.2673903703689575,\n", - " (2060, 10): 1.5223034620285034,\n", - " (2060, 11): 23.610796332359314,\n", - " (2060, 12): 150.48762321472168},\n", - " 'window': {(2060, 1): 92.72584438323975,\n", - " (2060, 2): 27.523765325546265,\n", - " (2060, 3): 29.17415714263916,\n", - " (2060, 4): 35.820679664611816,\n", - " (2060, 5): 22.55817997455597,\n", - " (2060, 6): 6.061040759086609,\n", - " (2060, 7): 20.530491948127747,\n", - " (2060, 8): 2.3611903190612793,\n", - " (2060, 9): 1.2673903703689575,\n", - " (2060, 10): 1.5223034620285034,\n", - " (2060, 11): 14.17027997970581,\n", - " (2060, 12): 56.83610391616821}},\n", - " 84: {'monthly': {(2060, 1): 383.7928560972214,\n", - " (2060, 2): 85.51665949821472,\n", - " (2060, 3): 114.45814776420593,\n", - " (2060, 4): 85.10443842411041,\n", - " (2060, 5): 64.51207220554352,\n", - " (2060, 6): 23.759783029556274,\n", - " (2060, 7): 66.81133997440338,\n", - " (2060, 8): 2.5552412271499634,\n", - " (2060, 9): 3.1704635620117188,\n", - " (2060, 10): 1.5223034620285034,\n", - " (2060, 11): 27.643977999687195,\n", - " (2060, 12): 153.8898881673813},\n", - " 'window': {(2060, 1): 120.80051231384277,\n", - " (2060, 2): 34.4380156993866,\n", - " (2060, 3): 34.70024919509888,\n", - " (2060, 4): 43.03343892097473,\n", - " (2060, 5): 28.670778632164,\n", - " (2060, 6): 7.712748050689697,\n", - " (2060, 7): 34.13818109035492,\n", - " (2060, 8): 2.5552412271499634,\n", - " (2060, 9): 3.1704635620117188,\n", - " (2060, 10): 1.5223034620285034,\n", - " (2060, 11): 16.744316339492798,\n", - " (2060, 12): 60.977970600128174}},\n", - " 85: {'monthly': {(2060, 1): 393.9501714706421,\n", - " (2060, 2): 78.96040213108063,\n", - " (2060, 3): 113.28188955783844,\n", - " (2060, 4): 77.68404591083527,\n", - " (2060, 5): 64.46553933620453,\n", - " (2060, 6): 20.5709468126297,\n", - " (2060, 7): 62.35176730155945,\n", - " (2060, 8): 2.8247629404067993,\n", - " (2060, 9): 1.5278953313827515,\n", - " (2060, 10): 1.5223034620285034,\n", - " (2060, 11): 20.422205328941345,\n", - " (2060, 12): 139.1814591884613},\n", - " 'window': {(2060, 1): 140.94253635406494,\n", - " (2060, 2): 32.57849979400635,\n", - " (2060, 3): 37.7205286026001,\n", - " (2060, 4): 40.12187743186951,\n", - " (2060, 5): 24.676626563072205,\n", - " (2060, 6): 7.101553678512573,\n", - " (2060, 7): 31.683209538459778,\n", - " (2060, 8): 2.8247629404067993,\n", - " (2060, 9): 1.5278953313827515,\n", - " (2060, 10): 1.5223034620285034,\n", - " (2060, 11): 13.026127099990845,\n", - " (2060, 12): 56.41943025588989}},\n", - " 86: {'monthly': {(2060, 1): 419.85595655441284,\n", - " (2060, 2): 79.49583899974823,\n", - " (2060, 3): 128.8248748779297,\n", - " (2060, 4): 62.50209045410156,\n", - " (2060, 5): 48.236103773117065,\n", - " (2060, 6): 19.38513672351837,\n", - " (2060, 7): 43.53088021278381,\n", - " (2060, 8): 2.655559539794922,\n", - " (2060, 9): 1.2673903703689575,\n", - " (2060, 10): 1.5223034620285034,\n", - " (2060, 11): 26.97444748878479,\n", - " (2060, 12): 154.82994329929352},\n", - " 'window': {(2060, 1): 150.73272132873535,\n", - " (2060, 2): 28.888832330703735,\n", - " (2060, 3): 45.87191653251648,\n", - " (2060, 4): 33.83315110206604,\n", - " (2060, 5): 16.29389798641205,\n", - " (2060, 6): 5.86623227596283,\n", - " (2060, 7): 18.76491105556488,\n", - " (2060, 8): 2.655559539794922,\n", - " (2060, 9): 1.2673903703689575,\n", - " (2060, 10): 1.5223034620285034,\n", - " (2060, 11): 14.000438213348389,\n", - " (2060, 12): 61.717763900756836}},\n", - " 87: {'monthly': {(2060, 1): 336.4901565313339,\n", - " (2060, 2): 104.28246462345123,\n", - " (2060, 3): 100.02395367622375,\n", - " (2060, 4): 44.85862934589386,\n", - " (2060, 5): 63.785207986831665,\n", - " (2060, 6): 11.611026406288147,\n", - " (2060, 7): 20.621999740600586,\n", - " (2060, 8): 1.2253988981246948,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 32.51282739639282,\n", - " (2060, 12): 175.019322514534},\n", - " 'window': {(2060, 1): 115.56608200073242,\n", - " (2060, 2): 47.715970516204834,\n", - " (2060, 3): 32.79811334609985,\n", - " (2060, 4): 34.170438289642334,\n", - " (2060, 5): 27.542779445648193,\n", - " (2060, 6): 5.101590633392334,\n", - " (2060, 7): 8.035584449768066,\n", - " (2060, 8): 1.2253988981246948,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 26.681792855262756,\n", - " (2060, 12): 56.939335346221924}},\n", - " 88: {'monthly': {(2060, 1): 297.4255585670471,\n", - " (2060, 2): 106.11028957366943,\n", - " (2060, 3): 76.89649724960327,\n", - " (2060, 4): 42.18607234954834,\n", - " (2060, 5): 51.69560194015503,\n", - " (2060, 6): 10.737209916114807,\n", - " (2060, 7): 18.08592712879181,\n", - " (2060, 8): 1.2253988981246948,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 23.56732201576233,\n", - " (2060, 12): 154.51429629325867},\n", - " 'window': {(2060, 1): 92.5840072631836,\n", - " (2060, 2): 50.584925532341,\n", - " (2060, 3): 24.20361852645874,\n", - " (2060, 4): 35.71366477012634,\n", - " (2060, 5): 21.24505650997162,\n", - " (2060, 6): 4.990707993507385,\n", - " (2060, 7): 8.169375777244568,\n", - " (2060, 8): 1.2253988981246948,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 19.800487399101257,\n", - " (2060, 12): 51.745620250701904}},\n", - " 89: {'monthly': {(2060, 1): 290.22751331329346,\n", - " (2060, 2): 106.82257676124573,\n", - " (2060, 3): 76.08569490909576,\n", - " (2060, 4): 40.8287593126297,\n", - " (2060, 5): 40.08099615573883,\n", - " (2060, 6): 10.737209916114807,\n", - " (2060, 7): 19.353006601333618,\n", - " (2060, 8): 1.2253988981246948,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 20.912856221199036,\n", - " (2060, 12): 166.16331672668457},\n", - " 'window': {(2060, 1): 83.71950626373291,\n", - " (2060, 2): 55.03159761428833,\n", - " (2060, 3): 24.595417618751526,\n", - " (2060, 4): 34.73405599594116,\n", - " (2060, 5): 14.825575351715088,\n", - " (2060, 6): 4.990707993507385,\n", - " (2060, 7): 8.80367112159729,\n", - " (2060, 8): 1.2253988981246948,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 17.61918079853058,\n", - " (2060, 12): 58.785332679748535}},\n", - " 90: {'monthly': {(2060, 1): 277.87755250930786,\n", - " (2060, 2): 102.81260240077972,\n", - " (2060, 3): 67.39397430419922,\n", - " (2060, 4): 40.793168783187866,\n", - " (2060, 5): 40.87345468997955,\n", - " (2060, 6): 10.737209916114807,\n", - " (2060, 7): 19.000905632972717,\n", - " (2060, 8): 1.2253988981246948,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 28.202972531318665,\n", - " (2060, 12): 168.5834163427353},\n", - " 'window': {(2060, 1): 81.47146129608154,\n", - " (2060, 2): 56.85957956314087,\n", - " (2060, 3): 21.839052200317383,\n", - " (2060, 4): 33.158947229385376,\n", - " (2060, 5): 15.471238374710083,\n", - " (2060, 6): 4.990707993507385,\n", - " (2060, 7): 8.760943412780762,\n", - " (2060, 8): 1.2253988981246948,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 22.790839314460754,\n", - " (2060, 12): 59.97518825531006}},\n", - " 91: {'monthly': {(2060, 1): 463.4113487005234,\n", - " (2060, 2): 96.06723153591156,\n", - " (2060, 3): 73.22126412391663,\n", - " (2060, 4): 13.483752608299255,\n", - " (2060, 5): 20.602303504943848,\n", - " (2060, 6): 9.286963701248169,\n", - " (2060, 7): 19.830249905586243,\n", - " (2060, 8): 1.321013331413269,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 1.3135926723480225,\n", - " (2060, 11): 27.234530448913574,\n", - " (2060, 12): 172.6963014602661},\n", - " 'window': {(2060, 1): 201.45910263061523,\n", - " (2060, 2): 34.423466205596924,\n", - " (2060, 3): 25.111954927444458,\n", - " (2060, 4): 8.75462818145752,\n", - " (2060, 5): 6.382740497589111,\n", - " (2060, 6): 3.808173656463623,\n", - " (2060, 7): 6.865109443664551,\n", - " (2060, 8): 1.321013331413269,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 1.3135926723480225,\n", - " (2060, 11): 14.377599239349365,\n", - " (2060, 12): 112.7610719203949}},\n", - " 92: {'monthly': {(2060, 1): 349.1822053194046,\n", - " (2060, 2): 65.12733817100525,\n", - " (2060, 3): 67.83465242385864,\n", - " (2060, 4): 31.39475393295288,\n", - " (2060, 5): 27.938594698905945,\n", - " (2060, 6): 14.382491111755371,\n", - " (2060, 7): 20.648213028907776,\n", - " (2060, 8): 2.0626766681671143,\n", - " (2060, 9): 1.123965859413147,\n", - " (2060, 10): 1.4419366121292114,\n", - " (2060, 11): 19.026275038719177,\n", - " (2060, 12): 112.53922629356384},\n", - " 'window': {(2060, 1): 123.80176830291748,\n", - " (2060, 2): 25.47572886943817,\n", - " (2060, 3): 21.31007695198059,\n", - " (2060, 4): 21.17769968509674,\n", - " (2060, 5): 12.996211647987366,\n", - " (2060, 6): 5.636223196983337,\n", - " (2060, 7): 7.016363501548767,\n", - " (2060, 8): 2.0626766681671143,\n", - " (2060, 9): 1.123965859413147,\n", - " (2060, 10): 1.4419366121292114,\n", - " (2060, 11): 11.861252307891846,\n", - " (2060, 12): 48.31288194656372}},\n", - " 93: {'monthly': {(2060, 1): 354.81332981586456,\n", - " (2060, 2): 64.41723811626434,\n", - " (2060, 3): 73.41302442550659,\n", - " (2060, 4): 34.20954096317291,\n", - " (2060, 5): 30.57427752017975,\n", - " (2060, 6): 14.851759672164917,\n", - " (2060, 7): 23.351036310195923,\n", - " (2060, 8): 2.0626766681671143,\n", - " (2060, 9): 1.123965859413147,\n", - " (2060, 10): 1.4419366121292114,\n", - " (2060, 11): 17.49626851081848,\n", - " (2060, 12): 125.83943510055542},\n", - " 'window': {(2060, 1): 130.89419746398926,\n", - " (2060, 2): 24.420170545578003,\n", - " (2060, 3): 24.089011669158936,\n", - " (2060, 4): 21.918984174728394,\n", - " (2060, 5): 13.73715364933014,\n", - " (2060, 6): 5.636223196983337,\n", - " (2060, 7): 8.961331963539124,\n", - " (2060, 8): 2.0626766681671143,\n", - " (2060, 9): 1.123965859413147,\n", - " (2060, 10): 1.4419366121292114,\n", - " (2060, 11): 10.896298289299011,\n", - " (2060, 12): 48.16676568984985}},\n", - " 94: {'monthly': {(2060, 1): 421.9370194673538,\n", - " (2060, 2): 73.38902723789215,\n", - " (2060, 3): 106.57652235031128,\n", - " (2060, 4): 49.315309166908264,\n", - " (2060, 5): 46.35106122493744,\n", - " (2060, 6): 16.010488033294678,\n", - " (2060, 7): 43.166913986206055,\n", - " (2060, 8): 2.0626766681671143,\n", - " (2060, 9): 2.5492119789123535,\n", - " (2060, 10): 1.4419366121292114,\n", - " (2060, 11): 24.029298067092896,\n", - " (2060, 12): 159.94412076473236},\n", - " 'window': {(2060, 1): 143.62085342407227,\n", - " (2060, 2): 26.3014919757843,\n", - " (2060, 3): 35.61183428764343,\n", - " (2060, 4): 24.708812713623047,\n", - " (2060, 5): 17.549870491027832,\n", - " (2060, 6): 6.206125974655151,\n", - " (2060, 7): 21.106102108955383,\n", - " (2060, 8): 2.0626766681671143,\n", - " (2060, 9): 1.4252461194992065,\n", - " (2060, 10): 1.4419366121292114,\n", - " (2060, 11): 14.932323336601257,\n", - " (2060, 12): 63.50431251525879}},\n", - " 95: {'monthly': {(2060, 1): 429.28397476673126,\n", - " (2060, 2): 72.47148525714874,\n", - " (2060, 3): 121.06057739257812,\n", - " (2060, 4): 51.50081777572632,\n", - " (2060, 5): 51.62354600429535,\n", - " (2060, 6): 18.254459261894226,\n", - " (2060, 7): 47.412702322006226,\n", - " (2060, 8): 2.0626766681671143,\n", - " (2060, 9): 2.6531325578689575,\n", - " (2060, 10): 3.1614946126937866,\n", - " (2060, 11): 27.3854957818985,\n", - " (2060, 12): 178.5531598329544},\n", - " 'window': {(2060, 1): 143.6856346130371,\n", - " (2060, 2): 27.105239152908325,\n", - " (2060, 3): 40.09090518951416,\n", - " (2060, 4): 25.462261080741882,\n", - " (2060, 5): 19.430429935455322,\n", - " (2060, 6): 6.915640711784363,\n", - " (2060, 7): 23.643585801124573,\n", - " (2060, 8): 2.0626766681671143,\n", - " (2060, 9): 2.6531325578689575,\n", - " (2060, 10): 1.7195580005645752,\n", - " (2060, 11): 12.381380200386047,\n", - " (2060, 12): 71.49668407440186}},\n", - " 96: {'monthly': {(2060, 1): 352.7899634838104,\n", - " (2060, 2): 88.59532988071442,\n", - " (2060, 3): 104.49126052856445,\n", - " (2060, 4): 57.611284494400024,\n", - " (2060, 5): 47.54294419288635,\n", - " (2060, 6): 15.912310242652893,\n", - " (2060, 7): 44.53313088417053,\n", - " (2060, 8): 3.709206223487854,\n", - " (2060, 9): 1.2673903703689575,\n", - " (2060, 10): 1.5223034620285034,\n", - " (2060, 11): 22.640748143196106,\n", - " (2060, 12): 167.9428344964981},\n", - " 'window': {(2060, 1): 100.7104263305664,\n", - " (2060, 2): 29.294162392616272,\n", - " (2060, 3): 27.832655906677246,\n", - " (2060, 4): 33.618375301361084,\n", - " (2060, 5): 18.815945506095886,\n", - " (2060, 6): 5.86623227596283,\n", - " (2060, 7): 19.021694779396057,\n", - " (2060, 8): 2.6743505001068115,\n", - " (2060, 9): 1.2673903703689575,\n", - " (2060, 10): 1.5223034620285034,\n", - " (2060, 11): 14.802052617073059,\n", - " (2060, 12): 59.41940355300903}},\n", - " 97: {'monthly': {(2060, 1): 423.0829076766968,\n", - " (2060, 2): 99.40169155597687,\n", - " (2060, 3): 125.31066417694092,\n", - " (2060, 4): 71.11595785617828,\n", - " (2060, 5): 56.92600333690643,\n", - " (2060, 6): 19.795478343963623,\n", - " (2060, 7): 59.18360197544098,\n", - " (2060, 8): 3.6297510862350464,\n", - " (2060, 9): 1.769248127937317,\n", - " (2060, 10): 1.5223034620285034,\n", - " (2060, 11): 28.033342242240906,\n", - " (2060, 12): 194.99396097660065},\n", - " 'window': {(2060, 1): 119.64074802398682,\n", - " (2060, 2): 34.589433789253235,\n", - " (2060, 3): 35.65897512435913,\n", - " (2060, 4): 36.43531537055969,\n", - " (2060, 5): 21.53912341594696,\n", - " (2060, 6): 6.407122850418091,\n", - " (2060, 7): 26.482715010643005,\n", - " (2060, 8): 2.59743070602417,\n", - " (2060, 9): 1.769248127937317,\n", - " (2060, 10): 1.5223034620285034,\n", - " (2060, 11): 18.064305782318115,\n", - " (2060, 12): 70.48747444152832}},\n", - " 98: {'monthly': {(2060, 1): 449.4318759441376,\n", - " (2060, 2): 95.25327467918396,\n", - " (2060, 3): 131.9243677854538,\n", - " (2060, 4): 76.65350484848022,\n", - " (2060, 5): 57.82006847858429,\n", - " (2060, 6): 24.218266129493713,\n", - " (2060, 7): 64.9749584197998,\n", - " (2060, 8): 2.493152618408203,\n", - " (2060, 9): 1.2673903703689575,\n", - " (2060, 10): 2.953827381134033,\n", - " (2060, 11): 25.845147013664246,\n", - " (2060, 12): 192.3759274482727},\n", - " 'window': {(2060, 1): 138.06682014465332,\n", - " (2060, 2): 33.364089012145996,\n", - " (2060, 3): 41.571351051330566,\n", - " (2060, 4): 38.55204772949219,\n", - " (2060, 5): 20.87331521511078,\n", - " (2060, 6): 8.365351676940918,\n", - " (2060, 7): 28.51797902584076,\n", - " (2060, 8): 2.493152618408203,\n", - " (2060, 9): 1.2673903703689575,\n", - " (2060, 10): 1.5223034620285034,\n", - " (2060, 11): 16.915120124816895,\n", - " (2060, 12): 74.45194149017334}},\n", - " 99: {'monthly': {(2060, 1): 391.67688608169556,\n", - " (2060, 2): 76.42369616031647,\n", - " (2060, 3): 107.04146146774292,\n", - " (2060, 4): 55.350674986839294,\n", - " (2060, 5): 39.11813259124756,\n", - " (2060, 6): 15.929315209388733,\n", - " (2060, 7): 36.86646044254303,\n", - " (2060, 8): 2.3134970664978027,\n", - " (2060, 9): 1.2673903703689575,\n", - " (2060, 10): 1.5223034620285034,\n", - " (2060, 11): 19.440048336982727,\n", - " (2060, 12): 156.08574318885803},\n", - " 'window': {(2060, 1): 127.61261653900146,\n", - " (2060, 2): 24.674513339996338,\n", - " (2060, 3): 35.11529588699341,\n", - " (2060, 4): 34.44607055187225,\n", - " (2060, 5): 14.266376376152039,\n", - " (2060, 6): 6.036371469497681,\n", - " (2060, 7): 15.362324714660645,\n", - " (2060, 8): 2.3134970664978027,\n", - " (2060, 9): 1.2673903703689575,\n", - " (2060, 10): 1.5223034620285034,\n", - " (2060, 11): 10.533748269081116,\n", - " (2060, 12): 66.1814661026001}},\n", - " 100: {'monthly': {(2060, 1): 346.23657965660095,\n", - " (2060, 2): 115.24026083946228,\n", - " (2060, 3): 92.11984550952911,\n", - " (2060, 4): 39.149778604507446,\n", - " (2060, 5): 53.55998504161835,\n", - " (2060, 6): 10.737209916114807,\n", - " (2060, 7): 18.396928071975708,\n", - " (2060, 8): 1.2253988981246948,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 26.82351064682007,\n", - " (2060, 12): 173.12817704677582},\n", - " 'window': {(2060, 1): 119.2985725402832,\n", - " (2060, 2): 49.9421763420105,\n", - " (2060, 3): 33.98824381828308,\n", - " (2060, 4): 33.24574422836304,\n", - " (2060, 5): 22.204967737197876,\n", - " (2060, 6): 4.990707993507385,\n", - " (2060, 7): 7.774371266365051,\n", - " (2060, 8): 1.2253988981246948,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 21.494866490364075,\n", - " (2060, 12): 56.13541030883789}},\n", - " 101: {'monthly': {(2060, 1): 349.90011978149414,\n", - " (2060, 2): 122.16595947742462,\n", - " (2060, 3): 88.83498799800873,\n", - " (2060, 4): 42.698251605033875,\n", - " (2060, 5): 60.85842967033386,\n", - " (2060, 6): 11.757982611656189,\n", - " (2060, 7): 18.986244082450867,\n", - " (2060, 8): 1.2253988981246948,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 23.86400592327118,\n", - " (2060, 12): 178.52454006671906},\n", - " 'window': {(2060, 1): 115.80019760131836,\n", - " (2060, 2): 56.79935574531555,\n", - " (2060, 3): 31.526460647583008,\n", - " (2060, 4): 37.14680886268616,\n", - " (2060, 5): 26.685794591903687,\n", - " (2060, 6): 6.011480689048767,\n", - " (2060, 7): 8.060877799987793,\n", - " (2060, 8): 1.2253988981246948,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 20.614326119422913,\n", - " (2060, 12): 63.986401081085205}},\n", - " 102: {'monthly': {(2060, 1): 319.5013589859009,\n", - " (2060, 2): 112.83527135848999,\n", - " (2060, 3): 89.94485259056091,\n", - " (2060, 4): 41.47650933265686,\n", - " (2060, 5): 46.9607959985733,\n", - " (2060, 6): 10.737209916114807,\n", - " (2060, 7): 19.8553626537323,\n", - " (2060, 8): 1.2253988981246948,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 21.132503986358643,\n", - " (2060, 12): 188.97411179542542},\n", - " 'window': {(2060, 1): 102.54212284088135,\n", - " (2060, 2): 55.52021360397339,\n", - " (2060, 3): 30.740293741226196,\n", - " (2060, 4): 35.87820017337799,\n", - " (2060, 5): 19.180613160133362,\n", - " (2060, 6): 4.990707993507385,\n", - " (2060, 7): 8.709739208221436,\n", - " (2060, 8): 1.2253988981246948,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 17.080882906913757,\n", - " (2060, 12): 74.86490726470947}},\n", - " 103: {'monthly': {(2060, 1): 295.21724700927734,\n", - " (2060, 2): 101.64878499507904,\n", - " (2060, 3): 76.02180671691895,\n", - " (2060, 4): 40.20543360710144,\n", - " (2060, 5): 36.069650650024414,\n", - " (2060, 6): 10.737209916114807,\n", - " (2060, 7): 18.26148498058319,\n", - " (2060, 8): 1.2253988981246948,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 23.56083309650421,\n", - " (2060, 12): 189.04961907863617},\n", - " 'window': {(2060, 1): 94.32566452026367,\n", - " (2060, 2): 54.26530838012695,\n", - " (2060, 3): 28.86735463142395,\n", - " (2060, 4): 33.94156813621521,\n", - " (2060, 5): 12.319239854812622,\n", - " (2060, 6): 4.990707993507385,\n", - " (2060, 7): 7.9300055503845215,\n", - " (2060, 8): 1.2253988981246948,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 18.593409657478333,\n", - " (2060, 12): 70.85122871398926}},\n", - " 104: {'monthly': {(2060, 1): 407.95460057258606,\n", - " (2060, 2): 96.86546611785889,\n", - " (2060, 3): 83.84810733795166,\n", - " (2060, 4): 16.36186420917511,\n", - " (2060, 5): 21.20138931274414,\n", - " (2060, 6): 9.322126150131226,\n", - " (2060, 7): 18.51058781147003,\n", - " (2060, 8): 1.321013331413269,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 2.443474292755127,\n", - " (2060, 11): 30.528780817985535,\n", - " (2060, 12): 214.67350161075592},\n", - " 'window': {(2060, 1): 147.7291088104248,\n", - " (2060, 2): 37.544578075408936,\n", - " (2060, 3): 27.268686294555664,\n", - " (2060, 4): 11.701242089271545,\n", - " (2060, 5): 7.876853942871094,\n", - " (2060, 6): 3.808173656463623,\n", - " (2060, 7): 6.865109443664551,\n", - " (2060, 8): 1.321013331413269,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 1.3135926723480225,\n", - " (2060, 11): 17.892728328704834,\n", - " (2060, 12): 138.75796127319336}},\n", - " 105: {'monthly': {(2060, 1): 360.58968782424927,\n", - " (2060, 2): 74.18283772468567,\n", - " (2060, 3): 85.23425364494324,\n", - " (2060, 4): 34.62935721874237,\n", - " (2060, 5): 29.216607928276062,\n", - " (2060, 6): 14.382491111755371,\n", - " (2060, 7): 21.693007469177246,\n", - " (2060, 8): 2.0626766681671143,\n", - " (2060, 9): 1.123965859413147,\n", - " (2060, 10): 1.4419366121292114,\n", - " (2060, 11): 20.760058999061584,\n", - " (2060, 12): 122.69893300533295},\n", - " 'window': {(2060, 1): 138.02874183654785,\n", - " (2060, 2): 26.636324167251587,\n", - " (2060, 3): 24.99161720275879,\n", - " (2060, 4): 21.781128644943237,\n", - " (2060, 5): 14.773335456848145,\n", - " (2060, 6): 5.636223196983337,\n", - " (2060, 7): 7.900975584983826,\n", - " (2060, 8): 2.0626766681671143,\n", - " (2060, 9): 1.123965859413147,\n", - " (2060, 10): 1.4419366121292114,\n", - " (2060, 11): 11.648479580879211,\n", - " (2060, 12): 48.52114677429199}},\n", - " 106: {'monthly': {(2060, 1): 394.5765436887741,\n", - " (2060, 2): 82.10198605060577,\n", - " (2060, 3): 111.64265179634094,\n", - " (2060, 4): 39.00225758552551,\n", - " (2060, 5): 32.675551414489746,\n", - " (2060, 6): 14.15730369091034,\n", - " (2060, 7): 27.447945594787598,\n", - " (2060, 8): 2.0626766681671143,\n", - " (2060, 9): 1.123965859413147,\n", - " (2060, 10): 3.743174433708191,\n", - " (2060, 11): 21.597458481788635,\n", - " (2060, 12): 173.0455572605133},\n", - " 'window': {(2060, 1): 153.90116119384766,\n", - " (2060, 2): 27.76982307434082,\n", - " (2060, 3): 34.09263849258423,\n", - " (2060, 4): 21.822115898132324,\n", - " (2060, 5): 15.303587794303894,\n", - " (2060, 6): 5.636223196983337,\n", - " (2060, 7): 9.488157153129578,\n", - " (2060, 8): 2.0626766681671143,\n", - " (2060, 9): 1.123965859413147,\n", - " (2060, 10): 2.3012378215789795,\n", - " (2060, 11): 11.259883642196655,\n", - " (2060, 12): 62.7207555770874}},\n", - " 107: {'monthly': {(2060, 1): 479.35110545158386,\n", - " (2060, 2): 84.70585751533508,\n", - " (2060, 3): 134.91230952739716,\n", - " (2060, 4): 46.19641625881195,\n", - " (2060, 5): 47.085986733436584,\n", - " (2060, 6): 16.35627031326294,\n", - " (2060, 7): 40.99521362781525,\n", - " (2060, 8): 2.0626766681671143,\n", - " (2060, 9): 2.530571699142456,\n", - " (2060, 10): 3.7062705755233765,\n", - " (2060, 11): 33.05326569080353,\n", - " (2060, 12): 215.3409719467163},\n", - " 'window': {(2060, 1): 172.13108444213867,\n", - " (2060, 2): 29.598541736602783,\n", - " (2060, 3): 41.91778373718262,\n", - " (2060, 4): 22.620279550552368,\n", - " (2060, 5): 17.596295833587646,\n", - " (2060, 6): 6.433686017990112,\n", - " (2060, 7): 20.415731549263,\n", - " (2060, 8): 2.0626766681671143,\n", - " (2060, 9): 2.530571699142456,\n", - " (2060, 10): 2.264333963394165,\n", - " (2060, 11): 17.319698929786682,\n", - " (2060, 12): 78.0708703994751}},\n", - " 108: {'monthly': {(2060, 1): 465.7275460958481,\n", - " (2060, 2): 83.65554511547089,\n", - " (2060, 3): 150.60970628261566,\n", - " (2060, 4): 46.48762035369873,\n", - " (2060, 5): 48.194143533706665,\n", - " (2060, 6): 20.079076170921326,\n", - " (2060, 7): 44.389448404312134,\n", - " (2060, 8): 2.0626766681671143,\n", - " (2060, 9): 1.123965859413147,\n", - " (2060, 10): 4.183503031730652,\n", - " (2060, 11): 22.633455276489258,\n", - " (2060, 12): 198.03995490074158},\n", - " 'window': {(2060, 1): 172.89882278442383,\n", - " (2060, 2): 30.75741672515869,\n", - " (2060, 3): 45.30311918258667,\n", - " (2060, 4): 21.84697198867798,\n", - " (2060, 5): 18.415679454803467,\n", - " (2060, 6): 6.0585631132125854,\n", - " (2060, 7): 22.438853859901428,\n", - " (2060, 8): 2.0626766681671143,\n", - " (2060, 9): 1.123965859413147,\n", - " (2060, 10): 2.829234004020691,\n", - " (2060, 11): 14.032723784446716,\n", - " (2060, 12): 71.16131401062012}},\n", - " 109: {'monthly': {(2060, 1): 343.92627120018005,\n", - " (2060, 2): 87.37233543395996,\n", - " (2060, 3): 105.2634756565094,\n", - " (2060, 4): 49.61333978176117,\n", - " (2060, 5): 37.5579137802124,\n", - " (2060, 6): 15.87598717212677,\n", - " (2060, 7): 40.86406874656677,\n", - " (2060, 8): 2.3134970664978027,\n", - " (2060, 9): 1.2673903703689575,\n", - " (2060, 10): 2.586630702018738,\n", - " (2060, 11): 21.53614604473114,\n", - " (2060, 12): 163.12770891189575},\n", - " 'window': {(2060, 1): 102.49728965759277,\n", - " (2060, 2): 27.973085403442383,\n", - " (2060, 3): 29.82864737510681,\n", - " (2060, 4): 27.871565461158752,\n", - " (2060, 5): 16.116827368736267,\n", - " (2060, 6): 5.86623227596283,\n", - " (2060, 7): 15.346297144889832,\n", - " (2060, 8): 2.3134970664978027,\n", - " (2060, 9): 1.2673903703689575,\n", - " (2060, 10): 2.586630702018738,\n", - " (2060, 11): 11.430338978767395,\n", - " (2060, 12): 54.279325008392334}},\n", - " 110: {'monthly': {(2060, 1): 404.8652262687683,\n", - " (2060, 2): 106.95866274833679,\n", - " (2060, 3): 129.079155087471,\n", - " (2060, 4): 48.4066002368927,\n", - " (2060, 5): 40.091264963150024,\n", - " (2060, 6): 15.873462557792664,\n", - " (2060, 7): 42.36872708797455,\n", - " (2060, 8): 3.4911744594573975,\n", - " (2060, 9): 1.2673903703689575,\n", - " (2060, 10): 3.826534390449524,\n", - " (2060, 11): 29.42207407951355,\n", - " (2060, 12): 211.8794788122177},\n", - " 'window': {(2060, 1): 108.36867904663086,\n", - " (2060, 2): 32.82860600948334,\n", - " (2060, 3): 39.50145101547241,\n", - " (2060, 4): 27.36704730987549,\n", - " (2060, 5): 16.04546630382538,\n", - " (2060, 6): 5.86623227596283,\n", - " (2060, 7): 15.813272356987,\n", - " (2060, 8): 2.3659744262695312,\n", - " (2060, 9): 1.2673903703689575,\n", - " (2060, 10): 2.3042309284210205,\n", - " (2060, 11): 17.26029920578003,\n", - " (2060, 12): 70.48323822021484}},\n", - " 111: {'monthly': {(2060, 1): 462.1331686973572,\n", - " (2060, 2): 109.48963189125061,\n", - " (2060, 3): 150.84433352947235,\n", - " (2060, 4): 62.379676818847656,\n", - " (2060, 5): 45.56064701080322,\n", - " (2060, 6): 16.55554175376892,\n", - " (2060, 7): 44.104257345199585,\n", - " (2060, 8): 2.3134970664978027,\n", - " (2060, 9): 3.5748766660690308,\n", - " (2060, 10): 9.536153674125671,\n", - " (2060, 11): 38.90598666667938,\n", - " (2060, 12): 226.63394165039062},\n", - " 'window': {(2060, 1): 119.10615158081055,\n", - " (2060, 2): 33.15450835227966,\n", - " (2060, 3): 43.77429676055908,\n", - " (2060, 4): 33.76323974132538,\n", - " (2060, 5): 18.265411376953125,\n", - " (2060, 6): 5.86623227596283,\n", - " (2060, 7): 16.885692477226257,\n", - " (2060, 8): 2.3134970664978027,\n", - " (2060, 9): 2.3074862957000732,\n", - " (2060, 10): 5.158761382102966,\n", - " (2060, 11): 22.531094312667847,\n", - " (2060, 12): 80.55769538879395}},\n", - " 112: {'monthly': {(2060, 1): 399.7131608724594,\n", - " (2060, 2): 80.18583798408508,\n", - " (2060, 3): 103.72445476055145,\n", - " (2060, 4): 49.91864597797394,\n", - " (2060, 5): 32.826704144477844,\n", - " (2060, 6): 16.73643124103546,\n", - " (2060, 7): 26.253862857818604,\n", - " (2060, 8): 2.3134970664978027,\n", - " (2060, 9): 1.2673903703689575,\n", - " (2060, 10): 2.6058125495910645,\n", - " (2060, 11): 22.78432536125183,\n", - " (2060, 12): 162.38969922065735},\n", - " 'window': {(2060, 1): 112.76259326934814,\n", - " (2060, 2): 23.314667582511902,\n", - " (2060, 3): 27.72321915626526,\n", - " (2060, 4): 32.990127086639404,\n", - " (2060, 5): 11.629144430160522,\n", - " (2060, 6): 5.86623227596283,\n", - " (2060, 7): 10.15340542793274,\n", - " (2060, 8): 2.3134970664978027,\n", - " (2060, 9): 1.2673903703689575,\n", - " (2060, 10): 2.6058125495910645,\n", - " (2060, 11): 11.206248998641968,\n", - " (2060, 12): 67.26001453399658}},\n", - " 113: {'monthly': {(2060, 1): 343.6748014688492,\n", - " (2060, 2): 116.34928858280182,\n", - " (2060, 3): 86.21060240268707,\n", - " (2060, 4): 36.22039532661438,\n", - " (2060, 5): 45.84084761142731,\n", - " (2060, 6): 10.737209916114807,\n", - " (2060, 7): 17.909698605537415,\n", - " (2060, 8): 1.2253988981246948,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 20.967733144760132,\n", - " (2060, 12): 161.33118617534637},\n", - " 'window': {(2060, 1): 119.59949588775635,\n", - " (2060, 2): 50.97277092933655,\n", - " (2060, 3): 31.851691961288452,\n", - " (2060, 4): 29.73025155067444,\n", - " (2060, 5): 17.86822533607483,\n", - " (2060, 6): 4.990707993507385,\n", - " (2060, 7): 7.5985952615737915,\n", - " (2060, 8): 1.2253988981246948,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 17.792675852775574,\n", - " (2060, 12): 54.049511432647705}},\n", - " 114: {'monthly': {(2060, 1): 363.35000371932983,\n", - " (2060, 2): 137.5985562801361,\n", - " (2060, 3): 98.76722705364227,\n", - " (2060, 4): 38.0235470533371,\n", - " (2060, 5): 52.813050508499146,\n", - " (2060, 6): 10.737209916114807,\n", - " (2060, 7): 18.251886010169983,\n", - " (2060, 8): 1.2253988981246948,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 25.137531280517578,\n", - " (2060, 12): 189.50423777103424},\n", - " 'window': {(2060, 1): 125.37717056274414,\n", - " (2060, 2): 57.90111970901489,\n", - " (2060, 3): 38.201064586639404,\n", - " (2060, 4): 31.39781963825226,\n", - " (2060, 5): 22.099992752075195,\n", - " (2060, 6): 4.990707993507385,\n", - " (2060, 7): 7.780395030975342,\n", - " (2060, 8): 1.2253988981246948,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 18.486921787261963,\n", - " (2060, 12): 70.14760875701904}},\n", - " 115: {'monthly': {(2060, 1): 331.3134825229645,\n", - " (2060, 2): 120.46425139904022,\n", - " (2060, 3): 97.95618557929993,\n", - " (2060, 4): 30.973863124847412,\n", - " (2060, 5): 46.7463059425354,\n", - " (2060, 6): 10.737209916114807,\n", - " (2060, 7): 18.244349122047424,\n", - " (2060, 8): 1.2253988981246948,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 21.11982274055481,\n", - " (2060, 12): 204.0979005098343},\n", - " 'window': {(2060, 1): 110.55718326568604,\n", - " (2060, 2): 52.442177057266235,\n", - " (2060, 3): 35.52075791358948,\n", - " (2060, 4): 26.19022846221924,\n", - " (2060, 5): 19.13084626197815,\n", - " (2060, 6): 4.990707993507385,\n", - " (2060, 7): 7.930033445358276,\n", - " (2060, 8): 1.2253988981246948,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 15.94070565700531,\n", - " (2060, 12): 77.44490623474121}},\n", - " 116: {'monthly': {(2060, 1): 317.90583086013794,\n", - " (2060, 2): 102.65343356132507,\n", - " (2060, 3): 89.52171635627747,\n", - " (2060, 4): 29.121840119361877,\n", - " (2060, 5): 42.6735053062439,\n", - " (2060, 6): 10.737209916114807,\n", - " (2060, 7): 16.361290216445923,\n", - " (2060, 8): 1.2253988981246948,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 26.045686721801758,\n", - " (2060, 12): 198.77740514278412},\n", - " 'window': {(2060, 1): 101.12226295471191,\n", - " (2060, 2): 49.65871453285217,\n", - " (2060, 3): 36.51204705238342,\n", - " (2060, 4): 22.674139976501465,\n", - " (2060, 5): 16.116384267807007,\n", - " (2060, 6): 4.990707993507385,\n", - " (2060, 7): 7.522854328155518,\n", - " (2060, 8): 1.2253988981246948,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 20.88944697380066,\n", - " (2060, 12): 77.31076240539551}},\n", - " 117: {'monthly': {(2060, 1): 510.4098947048187,\n", - " (2060, 2): 87.49692058563232,\n", - " (2060, 3): 102.56909239292145,\n", - " (2060, 4): 49.491947889328,\n", - " (2060, 5): 18.087695598602295,\n", - " (2060, 6): 8.094635844230652,\n", - " (2060, 7): 10.455269455909729,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 4.266306400299072,\n", - " (2060, 11): 64.82731282711029,\n", - " (2060, 12): 164.64981365203857},\n", - " 'window': {(2060, 1): 150.2458152770996,\n", - " (2060, 2): 29.334582805633545,\n", - " (2060, 3): 31.10702621936798,\n", - " (2060, 4): 35.21836519241333,\n", - " (2060, 5): 10.162387371063232,\n", - " (2060, 6): 2.9090415239334106,\n", - " (2060, 7): 2.942115902900696,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 4.266306400299072,\n", - " (2060, 11): 34.671786069869995,\n", - " (2060, 12): 66.97276306152344}},\n", - " 118: {'monthly': {(2060, 1): 557.8866236209869,\n", - " (2060, 2): 128.13135182857513,\n", - " (2060, 3): 140.3464162349701,\n", - " (2060, 4): 45.57662832736969,\n", - " (2060, 5): 16.415945887565613,\n", - " (2060, 6): 8.047105312347412,\n", - " (2060, 7): 13.441797137260437,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.306508779525757,\n", - " (2060, 11): 36.88234877586365,\n", - " (2060, 12): 236.21530997753143},\n", - " 'window': {(2060, 1): 221.24639511108398,\n", - " (2060, 2): 42.0278844833374,\n", - " (2060, 3): 64.86773729324341,\n", - " (2060, 4): 39.71260869503021,\n", - " (2060, 5): 9.094529509544373,\n", - " (2060, 6): 5.011563539505005,\n", - " (2060, 7): 4.3381829261779785,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.306508779525757,\n", - " (2060, 11): 19.84249770641327,\n", - " (2060, 12): 97.38131809234619}},\n", - " 119: {'monthly': {(2060, 1): 644.3098742961884,\n", - " (2060, 2): 142.64763271808624,\n", - " (2060, 3): 134.9455602169037,\n", - " (2060, 4): 60.415714144706726,\n", - " (2060, 5): 19.061378598213196,\n", - " (2060, 6): 9.152392029762268,\n", - " (2060, 7): 14.45812439918518,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 4.931285977363586,\n", - " (2060, 11): 50.540574073791504,\n", - " (2060, 12): 291.711643576622},\n", - " 'window': {(2060, 1): 239.30809783935547,\n", - " (2060, 2): 52.503711223602295,\n", - " (2060, 3): 58.5741400718689,\n", - " (2060, 4): 55.27925443649292,\n", - " (2060, 5): 10.101752042770386,\n", - " (2060, 6): 5.011563539505005,\n", - " (2060, 7): 4.656983494758606,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.306508779525757,\n", - " (2060, 11): 27.414522409439087,\n", - " (2060, 12): 126.69195365905762}},\n", - " 120: {'monthly': {(2060, 1): 706.5408275127411,\n", - " (2060, 2): 159.36862993240356,\n", - " (2060, 3): 140.98377788066864,\n", - " (2060, 4): 63.541441798210144,\n", - " (2060, 5): 20.694462776184082,\n", - " (2060, 6): 11.548849821090698,\n", - " (2060, 7): 23.87806475162506,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 3.0362112522125244,\n", - " (2060, 10): 3.306508779525757,\n", - " (2060, 11): 47.28317928314209,\n", - " (2060, 12): 311.04827880859375},\n", - " 'window': {(2060, 1): 280.08428382873535,\n", - " (2060, 2): 51.344417095184326,\n", - " (2060, 3): 53.86126232147217,\n", - " (2060, 4): 56.93182706832886,\n", - " (2060, 5): 11.276231288909912,\n", - " (2060, 6): 6.085543394088745,\n", - " (2060, 7): 9.946051239967346,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 3.0362112522125244,\n", - " (2060, 10): 3.306508779525757,\n", - " (2060, 11): 27.322734475135803,\n", - " (2060, 12): 139.36362266540527}},\n", - " 121: {'monthly': {(2060, 1): 667.4431693553925,\n", - " (2060, 2): 136.43020927906036,\n", - " (2060, 3): 115.14472329616547,\n", - " (2060, 4): 58.6288868188858,\n", - " (2060, 5): 15.05299186706543,\n", - " (2060, 6): 10.637265920639038,\n", - " (2060, 7): 24.813424944877625,\n", - " (2060, 8): 1.2884067296981812,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 5.952113747596741,\n", - " (2060, 11): 40.983696937561035,\n", - " (2060, 12): 254.7919305562973},\n", - " 'window': {(2060, 1): 289.6412887573242,\n", - " (2060, 2): 41.63046884536743,\n", - " (2060, 3): 38.96283292770386,\n", - " (2060, 4): 48.3566632270813,\n", - " (2060, 5): 8.431670665740967,\n", - " (2060, 6): 6.239339113235474,\n", - " (2060, 7): 9.858242630958557,\n", - " (2060, 8): 1.2884067296981812,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.306508779525757,\n", - " (2060, 11): 23.754318356513977,\n", - " (2060, 12): 114.55213832855225}},\n", - " 122: {'monthly': {(2060, 1): 569.7496087551117,\n", - " (2060, 2): 123.77409279346466,\n", - " (2060, 3): 91.8580093383789,\n", - " (2060, 4): 32.72150754928589,\n", - " (2060, 5): 16.235630869865417,\n", - " (2060, 6): 9.762237310409546,\n", - " (2060, 7): 21.505573391914368,\n", - " (2060, 8): 2.2416694164276123,\n", - " (2060, 9): 2.787316083908081,\n", - " (2060, 10): 6.906312942504883,\n", - " (2060, 11): 38.74012577533722,\n", - " (2060, 12): 217.8193690776825},\n", - " 'window': {(2060, 1): 229.92680549621582,\n", - " (2060, 2): 43.31287240982056,\n", - " (2060, 3): 33.4460666179657,\n", - " (2060, 4): 25.500521898269653,\n", - " (2060, 5): 8.484235286712646,\n", - " (2060, 6): 4.980204701423645,\n", - " (2060, 7): 6.766346216201782,\n", - " (2060, 8): 1.1782773733139038,\n", - " (2060, 9): 1.534010887145996,\n", - " (2060, 10): 3.3917908668518066,\n", - " (2060, 11): 21.463642239570618,\n", - " (2060, 12): 94.14852809906006}},\n", - " 123: {'monthly': {(2060, 1): 582.0229775905609,\n", - " (2060, 2): 135.25760567188263,\n", - " (2060, 3): 102.12856674194336,\n", - " (2060, 4): 33.91528308391571,\n", - " (2060, 5): 20.01930022239685,\n", - " (2060, 6): 13.64232087135315,\n", - " (2060, 7): 15.634902954101562,\n", - " (2060, 8): 1.0577040910720825,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 5.165388226509094,\n", - " (2060, 11): 36.465656995773315,\n", - " (2060, 12): 220.90574622154236},\n", - " 'window': {(2060, 1): 248.59711265563965,\n", - " (2060, 2): 40.01663327217102,\n", - " (2060, 3): 36.14659929275513,\n", - " (2060, 4): 26.73956823348999,\n", - " (2060, 5): 9.416933059692383,\n", - " (2060, 6): 5.994066119194031,\n", - " (2060, 7): 5.225795745849609,\n", - " (2060, 8): 1.0577040910720825,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.9456480741500854,\n", - " (2060, 11): 21.93647027015686,\n", - " (2060, 12): 103.68998432159424}},\n", - " 124: {'monthly': {(2060, 1): 632.3904068470001,\n", - " (2060, 2): 145.28400909900665,\n", - " (2060, 3): 100.38850009441376,\n", - " (2060, 4): 42.64017832279205,\n", - " (2060, 5): 25.669744968414307,\n", - " (2060, 6): 9.334441184997559,\n", - " (2060, 7): 17.61014175415039,\n", - " (2060, 8): 1.5491949319839478,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 8.241070747375488,\n", - " (2060, 11): 36.79388189315796,\n", - " (2060, 12): 237.030215382576},\n", - " 'window': {(2060, 1): 244.83649063110352,\n", - " (2060, 2): 44.04545545578003,\n", - " (2060, 3): 34.0287652015686,\n", - " (2060, 4): 36.37992703914642,\n", - " (2060, 5): 11.296199560165405,\n", - " (2060, 6): 5.977229714393616,\n", - " (2060, 7): 5.945600152015686,\n", - " (2060, 8): 1.5491949319839478,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.612400770187378,\n", - " (2060, 11): 23.00423502922058,\n", - " (2060, 12): 114.64002799987793}},\n", - " 125: {'monthly': {(2060, 1): 615.7446393966675,\n", - " (2060, 2): 113.01238000392914,\n", - " (2060, 3): 86.84487044811249,\n", - " (2060, 4): 44.410459876060486,\n", - " (2060, 5): 22.38048803806305,\n", - " (2060, 6): 7.963107585906982,\n", - " (2060, 7): 12.051601886749268,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.3917908668518066,\n", - " (2060, 11): 32.904370069503784,\n", - " (2060, 12): 191.92615520954132},\n", - " 'window': {(2060, 1): 221.1103057861328,\n", - " (2060, 2): 37.537296295166016,\n", - " (2060, 3): 27.584089756011963,\n", - " (2060, 4): 40.005894780159,\n", - " (2060, 5): 9.205323338508606,\n", - " (2060, 6): 4.980204701423645,\n", - " (2060, 7): 3.941878318786621,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.3917908668518066,\n", - " (2060, 11): 19.47388792037964,\n", - " (2060, 12): 98.55441284179688}},\n", - " 126: {'monthly': {(2060, 1): 371.2189083099365,\n", - " (2060, 2): 164.38460624217987,\n", - " (2060, 3): 87.0060784816742,\n", - " (2060, 4): 31.050194025039673,\n", - " (2060, 5): 18.281853437423706,\n", - " (2060, 6): 4.758296966552734,\n", - " (2060, 7): 8.060628771781921,\n", - " (2060, 8): 5.000177025794983,\n", - " (2060, 9): 5.203696131706238,\n", - " (2060, 10): 1.0873280763626099,\n", - " (2060, 11): 17.42879366874695,\n", - " (2060, 12): 244.5464462041855},\n", - " 'window': {(2060, 1): 164.70499420166016,\n", - " (2060, 2): 56.10796618461609,\n", - " (2060, 3): 35.575673937797546,\n", - " (2060, 4): 31.050194025039673,\n", - " (2060, 5): 7.314716935157776,\n", - " (2060, 6): 2.420486330986023,\n", - " (2060, 7): 4.300221085548401,\n", - " (2060, 8): 2.56423020362854,\n", - " (2060, 9): 2.5077195167541504,\n", - " (2060, 10): 1.0873280763626099,\n", - " (2060, 11): 15.268750548362732,\n", - " (2060, 12): 102.85420036315918}},\n", - " 127: {'monthly': {(2060, 1): 381.8864574432373,\n", - " (2060, 2): 183.42506647109985,\n", - " (2060, 3): 89.87234592437744,\n", - " (2060, 4): 33.00077176094055,\n", - " (2060, 5): 19.115713000297546,\n", - " (2060, 6): 4.738733291625977,\n", - " (2060, 7): 8.060628771781921,\n", - " (2060, 8): 3.724740982055664,\n", - " (2060, 9): 4.502957820892334,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 17.812392115592957,\n", - " (2060, 12): 266.5228408575058},\n", - " 'window': {(2060, 1): 163.10307693481445,\n", - " (2060, 2): 60.87312293052673,\n", - " (2060, 3): 37.421162128448486,\n", - " (2060, 4): 33.00077176094055,\n", - " (2060, 5): 7.249300122261047,\n", - " (2060, 6): 2.420486330986023,\n", - " (2060, 7): 4.300221085548401,\n", - " (2060, 8): 2.435946822166443,\n", - " (2060, 9): 3.2628742456436157,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 13.235727310180664,\n", - " (2060, 12): 132.73469829559326}},\n", - " 128: {'monthly': {(2060, 1): 366.9783955812454,\n", - " (2060, 2): 185.8719186782837,\n", - " (2060, 3): 78.39760303497314,\n", - " (2060, 4): 29.880679607391357,\n", - " (2060, 5): 18.239283323287964,\n", - " (2060, 6): 5.758107781410217,\n", - " (2060, 7): 8.060628771781921,\n", - " (2060, 8): 4.882692098617554,\n", - " (2060, 9): 4.340728998184204,\n", - " (2060, 10): 2.3364381790161133,\n", - " (2060, 11): 10.688073515892029,\n", - " (2060, 12): 287.6135541200638},\n", - " 'window': {(2060, 1): 159.00813484191895,\n", - " (2060, 2): 62.84865617752075,\n", - " (2060, 3): 28.91441059112549,\n", - " (2060, 4): 29.880679607391357,\n", - " (2060, 5): 7.299867272377014,\n", - " (2060, 6): 3.42473828792572,\n", - " (2060, 7): 4.300221085548401,\n", - " (2060, 8): 2.446745276451111,\n", - " (2060, 9): 3.100645422935486,\n", - " (2060, 10): 2.3364381790161133,\n", - " (2060, 11): 9.670246005058289,\n", - " (2060, 12): 158.11721992492676}},\n", - " 129: {'monthly': {(2060, 1): 387.9808659553528,\n", - " (2060, 2): 169.72064089775085,\n", - " (2060, 3): 80.8459347486496,\n", - " (2060, 4): 22.51471745967865,\n", - " (2060, 5): 18.356791496276855,\n", - " (2060, 6): 8.113657474517822,\n", - " (2060, 7): 10.399242997169495,\n", - " (2060, 8): 5.417973160743713,\n", - " (2060, 9): 4.194663047790527,\n", - " (2060, 10): 2.325004458427429,\n", - " (2060, 11): 9.95607852935791,\n", - " (2060, 12): 301.1328650712967},\n", - " 'window': {(2060, 1): 160.79176330566406,\n", - " (2060, 2): 58.67996382713318,\n", - " (2060, 3): 23.761495351791382,\n", - " (2060, 4): 22.51471745967865,\n", - " (2060, 5): 7.340857625007629,\n", - " (2060, 6): 3.4485201835632324,\n", - " (2060, 7): 4.300221085548401,\n", - " (2060, 8): 4.129179000854492,\n", - " (2060, 9): 2.954579472541809,\n", - " (2060, 10): 1.2839518785476685,\n", - " (2060, 11): 8.93825101852417,\n", - " (2060, 12): 170.5989179611206}},\n", - " 130: {'monthly': {(2060, 1): 547.4507088661194,\n", - " (2060, 2): 96.4872111082077,\n", - " (2060, 3): 141.01596331596375,\n", - " (2060, 4): 58.513633131980896,\n", - " (2060, 5): 20.543678998947144,\n", - " (2060, 6): 8.094635844230652,\n", - " (2060, 7): 9.222147941589355,\n", - " (2060, 8): 1.1885805130004883,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.556956648826599,\n", - " (2060, 11): 73.24884593486786,\n", - " (2060, 12): 191.766583442688},\n", - " 'window': {(2060, 1): 159.23157215118408,\n", - " (2060, 2): 29.21120595932007,\n", - " (2060, 3): 45.35967302322388,\n", - " (2060, 4): 44.23543679714203,\n", - " (2060, 5): 11.143696308135986,\n", - " (2060, 6): 2.9090415239334106,\n", - " (2060, 7): 3.181272029876709,\n", - " (2060, 8): 1.1885805130004883,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.556956648826599,\n", - " (2060, 11): 39.60639750957489,\n", - " (2060, 12): 73.67405891418457}},\n", - " 131: {'monthly': {(2060, 1): 571.1600413322449,\n", - " (2060, 2): 150.99121236801147,\n", - " (2060, 3): 163.97011578083038,\n", - " (2060, 4): 60.95484018325806,\n", - " (2060, 5): 20.514278650283813,\n", - " (2060, 6): 8.142430424690247,\n", - " (2060, 7): 13.540735125541687,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 5.804660201072693,\n", - " (2060, 11): 51.32000923156738,\n", - " (2060, 12): 265.845468044281},\n", - " 'window': {(2060, 1): 217.02537727355957,\n", - " (2060, 2): 52.81081819534302,\n", - " (2060, 3): 70.85829734802246,\n", - " (2060, 4): 53.07941293716431,\n", - " (2060, 5): 10.346323251724243,\n", - " (2060, 6): 5.106888651847839,\n", - " (2060, 7): 4.767492771148682,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.308659315109253,\n", - " (2060, 11): 28.583679795265198,\n", - " (2060, 12): 118.93056678771973}},\n", - " 132: {'monthly': {(2060, 1): 663.6872843503952,\n", - " (2060, 2): 154.58636724948883,\n", - " (2060, 3): 152.54886972904205,\n", - " (2060, 4): 65.92971527576447,\n", - " (2060, 5): 21.860713958740234,\n", - " (2060, 6): 8.047105312347412,\n", - " (2060, 7): 15.508212685585022,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 4.480633735656738,\n", - " (2060, 11): 56.65355908870697,\n", - " (2060, 12): 325.2453066110611},\n", - " 'window': {(2060, 1): 245.66313934326172,\n", - " (2060, 2): 54.35894584655762,\n", - " (2060, 3): 62.45850086212158,\n", - " (2060, 4): 59.978156089782715,\n", - " (2060, 5): 11.335855722427368,\n", - " (2060, 6): 5.011563539505005,\n", - " (2060, 7): 6.087433576583862,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.306508779525757,\n", - " (2060, 11): 35.95221412181854,\n", - " (2060, 12): 143.93274688720703}},\n", - " 133: {'monthly': {(2060, 1): 668.7502009868622,\n", - " (2060, 2): 157.23129737377167,\n", - " (2060, 3): 128.32983577251434,\n", - " (2060, 4): 61.86507046222687,\n", - " (2060, 5): 19.949262261390686,\n", - " (2060, 6): 9.121004223823547,\n", - " (2060, 7): 14.969991445541382,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.306508779525757,\n", - " (2060, 11): 47.08038127422333,\n", - " (2060, 12): 301.8952672481537},\n", - " 'window': {(2060, 1): 269.3583221435547,\n", - " (2060, 2): 46.390183448791504,\n", - " (2060, 3): 48.33936643600464,\n", - " (2060, 4): 54.93529033660889,\n", - " (2060, 5): 11.45088529586792,\n", - " (2060, 6): 5.011563539505005,\n", - " (2060, 7): 5.808553576469421,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.306508779525757,\n", - " (2060, 11): 26.92254936695099,\n", - " (2060, 12): 133.96298599243164}},\n", - " 134: {'monthly': {(2060, 1): 615.7598674297333,\n", - " (2060, 2): 133.57276320457458,\n", - " (2060, 3): 103.49830853939056,\n", - " (2060, 4): 50.21421253681183,\n", - " (2060, 5): 13.546697854995728,\n", - " (2060, 6): 8.122024774551392,\n", - " (2060, 7): 13.990452766418457,\n", - " (2060, 8): 2.4245959520339966,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 4.529220938682556,\n", - " (2060, 11): 39.44850254058838,\n", - " (2060, 12): 238.57067441940308},\n", - " 'window': {(2060, 1): 271.4773597717285,\n", - " (2060, 2): 44.92897605895996,\n", - " (2060, 3): 34.126988768577576,\n", - " (2060, 4): 45.80044770240784,\n", - " (2060, 5): 7.433480739593506,\n", - " (2060, 6): 5.011563539505005,\n", - " (2060, 7): 5.217408061027527,\n", - " (2060, 8): 2.4245959520339966,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.40899121761322,\n", - " (2060, 11): 23.98985993862152,\n", - " (2060, 12): 105.68150615692139}},\n", - " 135: {'monthly': {(2060, 1): 566.1471562385559,\n", - " (2060, 2): 125.03873789310455,\n", - " (2060, 3): 99.24975323677063,\n", - " (2060, 4): 39.884559988975525,\n", - " (2060, 5): 20.847150683403015,\n", - " (2060, 6): 8.120797514915466,\n", - " (2060, 7): 15.120272755622864,\n", - " (2060, 8): 1.0843865871429443,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.3917908668518066,\n", - " (2060, 11): 35.10725247859955,\n", - " (2060, 12): 222.84378838539124},\n", - " 'window': {(2060, 1): 221.94258308410645,\n", - " (2060, 2): 41.30516338348389,\n", - " (2060, 3): 37.61681127548218,\n", - " (2060, 4): 32.34832191467285,\n", - " (2060, 5): 9.995591640472412,\n", - " (2060, 6): 5.137894630432129,\n", - " (2060, 7): 5.620180130004883,\n", - " (2060, 8): 1.0843865871429443,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.3917908668518066,\n", - " (2060, 11): 20.423540830612183,\n", - " (2060, 12): 103.91804122924805}},\n", - " 136: {'monthly': {(2060, 1): 598.2886204719543,\n", - " (2060, 2): 135.67602014541626,\n", - " (2060, 3): 97.5796924829483,\n", - " (2060, 4): 41.534685254096985,\n", - " (2060, 5): 27.175332903862,\n", - " (2060, 6): 7.963107585906982,\n", - " (2060, 7): 13.885337114334106,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 4.829080820083618,\n", - " (2060, 11): 35.82414722442627,\n", - " (2060, 12): 221.85898458957672},\n", - " 'window': {(2060, 1): 238.72622871398926,\n", - " (2060, 2): 39.935463666915894,\n", - " (2060, 3): 39.896719455718994,\n", - " (2060, 4): 36.0637412071228,\n", - " (2060, 5): 12.669905424118042,\n", - " (2060, 6): 4.980204701423645,\n", - " (2060, 7): 4.650796413421631,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.7012375593185425,\n", - " (2060, 11): 21.36343550682068,\n", - " (2060, 12): 111.9016523361206}},\n", - " 137: {'monthly': {(2060, 1): 602.9091939926147,\n", - " (2060, 2): 136.70659375190735,\n", - " (2060, 3): 89.37092518806458,\n", - " (2060, 4): 44.07920265197754,\n", - " (2060, 5): 23.720986008644104,\n", - " (2060, 6): 7.963107585906982,\n", - " (2060, 7): 10.160049319267273,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 1.01644766330719,\n", - " (2060, 10): 3.5457684993743896,\n", - " (2060, 11): 30.525636196136475,\n", - " (2060, 12): 199.53403186798096},\n", - " 'window': {(2060, 1): 243.05580520629883,\n", - " (2060, 2): 36.94036817550659,\n", - " (2060, 3): 35.298019886016846,\n", - " (2060, 4): 39.92199432849884,\n", - " (2060, 5): 10.533711791038513,\n", - " (2060, 6): 4.980204701423645,\n", - " (2060, 7): 2.732165575027466,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 1.01644766330719,\n", - " (2060, 10): 3.5457684993743896,\n", - " (2060, 11): 17.836025714874268,\n", - " (2060, 12): 110.20589065551758}},\n", - " 138: {'monthly': {(2060, 1): 615.48432970047,\n", - " (2060, 2): 110.75643992424011,\n", - " (2060, 3): 83.67919540405273,\n", - " (2060, 4): 42.779574275016785,\n", - " (2060, 5): 17.932651042938232,\n", - " (2060, 6): 7.963107585906982,\n", - " (2060, 7): 8.798253893852234,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 1.3668831586837769,\n", - " (2060, 10): 3.3917908668518066,\n", - " (2060, 11): 30.940833926200867,\n", - " (2060, 12): 192.38009130954742},\n", - " 'window': {(2060, 1): 242.0129280090332,\n", - " (2060, 2): 31.45430040359497,\n", - " (2060, 3): 28.118874073028564,\n", - " (2060, 4): 39.39931786060333,\n", - " (2060, 5): 7.704861164093018,\n", - " (2060, 6): 4.980204701423645,\n", - " (2060, 7): 2.674770712852478,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 1.3668831586837769,\n", - " (2060, 10): 3.3917908668518066,\n", - " (2060, 11): 20.33214259147644,\n", - " (2060, 12): 89.32629299163818}},\n", - " 139: {'monthly': {(2060, 1): 427.92627334594727,\n", - " (2060, 2): 159.89586770534515,\n", - " (2060, 3): 94.46454882621765,\n", - " (2060, 4): 39.77324676513672,\n", - " (2060, 5): 18.795655727386475,\n", - " (2060, 6): 4.8118976354599,\n", - " (2060, 7): 8.060628771781921,\n", - " (2060, 8): 3.724740982055664,\n", - " (2060, 9): 3.879706621170044,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 19.399330615997314,\n", - " (2060, 12): 249.74890506267548},\n", - " 'window': {(2060, 1): 196.4100456237793,\n", - " (2060, 2): 53.35791492462158,\n", - " (2060, 3): 41.25281572341919,\n", - " (2060, 4): 39.77324676513672,\n", - " (2060, 5): 7.493947148323059,\n", - " (2060, 6): 2.420486330986023,\n", - " (2060, 7): 4.300221085548401,\n", - " (2060, 8): 2.435946822166443,\n", - " (2060, 9): 2.6396230459213257,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 18.381503105163574,\n", - " (2060, 12): 109.54104232788086}},\n", - " 140: {'monthly': {(2060, 1): 476.69633626937866,\n", - " (2060, 2): 184.9047166109085,\n", - " (2060, 3): 99.61826539039612,\n", - " (2060, 4): 46.97837579250336,\n", - " (2060, 5): 22.42714488506317,\n", - " (2060, 6): 4.9265124797821045,\n", - " (2060, 7): 8.060628771781921,\n", - " (2060, 8): 3.724740982055664,\n", - " (2060, 9): 4.523668050765991,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 19.141424894332886,\n", - " (2060, 12): 295.59869635105133},\n", - " 'window': {(2060, 1): 210.8937168121338,\n", - " (2060, 2): 60.400949478149414,\n", - " (2060, 3): 41.94523286819458,\n", - " (2060, 4): 45.93201947212219,\n", - " (2060, 5): 9.392773747444153,\n", - " (2060, 6): 2.420486330986023,\n", - " (2060, 7): 4.300221085548401,\n", - " (2060, 8): 2.435946822166443,\n", - " (2060, 9): 3.283584475517273,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 18.123597383499146,\n", - " (2060, 12): 145.40058517456055}},\n", - " 141: {'monthly': {(2060, 1): 479.50259280204773,\n", - " (2060, 2): 187.97148418426514,\n", - " (2060, 3): 82.33440852165222,\n", - " (2060, 4): 45.34663224220276,\n", - " (2060, 5): 23.30478012561798,\n", - " (2060, 6): 6.328974366188049,\n", - " (2060, 7): 9.686584949493408,\n", - " (2060, 8): 3.724740982055664,\n", - " (2060, 9): 4.538181781768799,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 13.60216748714447,\n", - " (2060, 12): 312.75586318969727},\n", - " 'window': {(2060, 1): 229.30839729309082,\n", - " (2060, 2): 71.23172283172607,\n", - " (2060, 3): 29.100484132766724,\n", - " (2060, 4): 45.34663224220276,\n", - " (2060, 5): 10.106266736984253,\n", - " (2060, 6): 3.633682131767273,\n", - " (2060, 7): 4.463454365730286,\n", - " (2060, 8): 2.435946822166443,\n", - " (2060, 9): 3.2980982065200806,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 12.58433997631073,\n", - " (2060, 12): 177.21335792541504}},\n", - " 142: {'monthly': {(2060, 1): 460.35742127895355,\n", - " (2060, 2): 165.1048468351364,\n", - " (2060, 3): 74.58501696586609,\n", - " (2060, 4): 32.43116593360901,\n", - " (2060, 5): 22.079272270202637,\n", - " (2060, 6): 7.271823763847351,\n", - " (2060, 7): 9.937751770019531,\n", - " (2060, 8): 3.724740982055664,\n", - " (2060, 9): 4.334549903869629,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 11.054158806800842,\n", - " (2060, 12): 314.90782368183136},\n", - " 'window': {(2060, 1): 229.1731834411621,\n", - " (2060, 2): 64.59935569763184,\n", - " (2060, 3): 24.762013912200928,\n", - " (2060, 4): 32.43116593360901,\n", - " (2060, 5): 8.647878289222717,\n", - " (2060, 6): 3.514581799507141,\n", - " (2060, 7): 4.300221085548401,\n", - " (2060, 8): 2.435946822166443,\n", - " (2060, 9): 3.0944663286209106,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 10.036331295967102,\n", - " (2060, 12): 176.71612739562988}},\n", - " 143: {'monthly': {(2060, 1): 506.7146122455597,\n", - " (2060, 2): 110.53980016708374,\n", - " (2060, 3): 178.08575093746185,\n", - " (2060, 4): 68.98869001865387,\n", - " (2060, 5): 19.422414183616638,\n", - " (2060, 6): 8.094635844230652,\n", - " (2060, 7): 10.361401677131653,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 4.5186896324157715,\n", - " (2060, 11): 78.93315184116364,\n", - " (2060, 12): 225.8941947221756},\n", - " 'window': {(2060, 1): 164.81800174713135,\n", - " (2060, 2): 29.041869282722473,\n", - " (2060, 3): 59.29143524169922,\n", - " (2060, 4): 49.09294950962067,\n", - " (2060, 5): 11.41849160194397,\n", - " (2060, 6): 2.9090415239334106,\n", - " (2060, 7): 2.8972361087799072,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 4.5186896324157715,\n", - " (2060, 11): 41.655176639556885,\n", - " (2060, 12): 75.36013221740723}},\n", - " 144: {'monthly': {(2060, 1): 548.1857719421387,\n", - " (2060, 2): 149.78410184383392,\n", - " (2060, 3): 176.4488492012024,\n", - " (2060, 4): 56.44916641712189,\n", - " (2060, 5): 22.24891173839569,\n", - " (2060, 6): 8.047105312347412,\n", - " (2060, 7): 13.740213513374329,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.306508779525757,\n", - " (2060, 11): 53.19077658653259,\n", - " (2060, 12): 279.78320384025574},\n", - " 'window': {(2060, 1): 205.08880996704102,\n", - " (2060, 2): 47.30531978607178,\n", - " (2060, 3): 64.36999940872192,\n", - " (2060, 4): 49.921536445617676,\n", - " (2060, 5): 9.714518427848816,\n", - " (2060, 6): 5.011563539505005,\n", - " (2060, 7): 4.592558026313782,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.306508779525757,\n", - " (2060, 11): 36.92058539390564,\n", - " (2060, 12): 118.69038581848145}},\n", - " 145: {'monthly': {(2060, 1): 631.7578530311584,\n", - " (2060, 2): 170.38327407836914,\n", - " (2060, 3): 169.2770837545395,\n", - " (2060, 4): 60.09351027011871,\n", - " (2060, 5): 20.436394929885864,\n", - " (2060, 6): 8.047105312347412,\n", - " (2060, 7): 12.919082880020142,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.306508779525757,\n", - " (2060, 11): 52.33293402194977,\n", - " (2060, 12): 320.61297607421875},\n", - " 'window': {(2060, 1): 231.8756980895996,\n", - " (2060, 2): 50.77475595474243,\n", - " (2060, 3): 59.219637870788574,\n", - " (2060, 4): 52.664851665496826,\n", - " (2060, 5): 10.352755784988403,\n", - " (2060, 6): 5.011563539505005,\n", - " (2060, 7): 4.306565880775452,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.306508779525757,\n", - " (2060, 11): 32.63076174259186,\n", - " (2060, 12): 130.7786569595337}},\n", - " 146: {'monthly': {(2060, 1): 594.892816066742,\n", - " (2060, 2): 152.29956793785095,\n", - " (2060, 3): 130.88317048549652,\n", - " (2060, 4): 45.40497076511383,\n", - " (2060, 5): 16.43554651737213,\n", - " (2060, 6): 8.047105312347412,\n", - " (2060, 7): 11.345490097999573,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 2.337212324142456,\n", - " (2060, 10): 4.732383489608765,\n", - " (2060, 11): 37.605896949768066,\n", - " (2060, 12): 257.28044390678406},\n", - " 'window': {(2060, 1): 239.12189102172852,\n", - " (2060, 2): 47.51843547821045,\n", - " (2060, 3): 43.6026611328125,\n", - " (2060, 4): 40.00069618225098,\n", - " (2060, 5): 9.501826405525208,\n", - " (2060, 6): 5.011563539505005,\n", - " (2060, 7): 3.377794861793518,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 2.337212324142456,\n", - " (2060, 10): 3.632529139518738,\n", - " (2060, 11): 24.075408697128296,\n", - " (2060, 12): 105.43822288513184}},\n", - " 147: {'monthly': {(2060, 1): 559.9497981071472,\n", - " (2060, 2): 137.97131204605103,\n", - " (2060, 3): 110.50351428985596,\n", - " (2060, 4): 38.93370735645294,\n", - " (2060, 5): 11.727835536003113,\n", - " (2060, 6): 8.047105312347412,\n", - " (2060, 7): 11.192602038383484,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 1.068038821220398,\n", - " (2060, 10): 4.340419292449951,\n", - " (2060, 11): 34.39472222328186,\n", - " (2060, 12): 208.79788637161255},\n", - " 'window': {(2060, 1): 240.53192901611328,\n", - " (2060, 2): 42.04910445213318,\n", - " (2060, 3): 33.52293348312378,\n", - " (2060, 4): 34.01312446594238,\n", - " (2060, 5): 6.351813197135925,\n", - " (2060, 6): 5.011563539505005,\n", - " (2060, 7): 3.4193196296691895,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 1.068038821220398,\n", - " (2060, 10): 3.306508779525757,\n", - " (2060, 11): 17.463005781173706,\n", - " (2060, 12): 84.48878383636475}},\n", - " 148: {'monthly': {(2060, 1): 604.3646717071533,\n", - " (2060, 2): 151.91352546215057,\n", - " (2060, 3): 126.7895519733429,\n", - " (2060, 4): 52.570987820625305,\n", - " (2060, 5): 21.614653825759888,\n", - " (2060, 6): 7.963107585906982,\n", - " (2060, 7): 12.571847200393677,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.3917908668518066,\n", - " (2060, 11): 43.96746075153351,\n", - " (2060, 12): 257.7748085260391},\n", - " 'window': {(2060, 1): 231.5086898803711,\n", - " (2060, 2): 48.38065147399902,\n", - " (2060, 3): 51.445624351501465,\n", - " (2060, 4): 46.895301818847656,\n", - " (2060, 5): 10.405417680740356,\n", - " (2060, 6): 4.980204701423645,\n", - " (2060, 7): 4.211694955825806,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.3917908668518066,\n", - " (2060, 11): 20.59616208076477,\n", - " (2060, 12): 116.30028629302979}},\n", - " 149: {'monthly': {(2060, 1): 645.1791279315948,\n", - " (2060, 2): 165.97894537448883,\n", - " (2060, 3): 121.38528835773468,\n", - " (2060, 4): 50.27321529388428,\n", - " (2060, 5): 32.79390823841095,\n", - " (2060, 6): 7.963107585906982,\n", - " (2060, 7): 13.224380731582642,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 1.0784639120101929,\n", - " (2060, 10): 3.3917908668518066,\n", - " (2060, 11): 37.63751018047333,\n", - " (2060, 12): 250.09060204029083},\n", - " 'window': {(2060, 1): 235.10860443115234,\n", - " (2060, 2): 47.85704326629639,\n", - " (2060, 3): 54.26810598373413,\n", - " (2060, 4): 45.39660978317261,\n", - " (2060, 5): 16.19385075569153,\n", - " (2060, 6): 4.980204701423645,\n", - " (2060, 7): 4.252476692199707,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 1.0784639120101929,\n", - " (2060, 10): 3.3917908668518066,\n", - " (2060, 11): 21.534427642822266,\n", - " (2060, 12): 125.32210922241211}},\n", - " 150: {'monthly': {(2060, 1): 628.2978479862213,\n", - " (2060, 2): 148.3349301815033,\n", - " (2060, 3): 95.51983261108398,\n", - " (2060, 4): 50.320013642311096,\n", - " (2060, 5): 25.413307785987854,\n", - " (2060, 6): 7.963107585906982,\n", - " (2060, 7): 9.39979600906372,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.3917908668518066,\n", - " (2060, 11): 27.818561553955078,\n", - " (2060, 12): 201.84606957435608},\n", - " 'window': {(2060, 1): 234.2224578857422,\n", - " (2060, 2): 43.80603003501892,\n", - " (2060, 3): 38.46089506149292,\n", - " (2060, 4): 45.8143208026886,\n", - " (2060, 5): 11.174822926521301,\n", - " (2060, 6): 4.980204701423645,\n", - " (2060, 7): 3.244193196296692,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.3917908668518066,\n", - " (2060, 11): 16.0010244846344,\n", - " (2060, 12): 104.09573268890381}},\n", - " 151: {'monthly': {(2060, 1): 620.8021562099457,\n", - " (2060, 2): 112.56339943408966,\n", - " (2060, 3): 92.12151181697845,\n", - " (2060, 4): 43.650938749313354,\n", - " (2060, 5): 14.470364093780518,\n", - " (2060, 6): 7.963107585906982,\n", - " (2060, 7): 8.435335278511047,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.3917908668518066,\n", - " (2060, 11): 29.150977611541748,\n", - " (2060, 12): 192.822016954422},\n", - " 'window': {(2060, 1): 243.21150588989258,\n", - " (2060, 2): 33.20365357398987,\n", - " (2060, 3): 28.88232111930847,\n", - " (2060, 4): 39.5869779586792,\n", - " (2060, 5): 6.757672429084778,\n", - " (2060, 6): 4.980204701423645,\n", - " (2060, 7): 3.2855485677719116,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.3917908668518066,\n", - " (2060, 11): 17.35000443458557,\n", - " (2060, 12): 86.7116174697876}},\n", - " 152: {'monthly': {(2060, 1): 467.3408098220825,\n", - " (2060, 2): 166.31438207626343,\n", - " (2060, 3): 112.82327818870544,\n", - " (2060, 4): 40.85188031196594,\n", - " (2060, 5): 20.127455234527588,\n", - " (2060, 6): 4.8149508237838745,\n", - " (2060, 7): 8.060628771781921,\n", - " (2060, 8): 3.724740982055664,\n", - " (2060, 9): 3.9064046144485474,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 20.13737964630127,\n", - " (2060, 12): 264.90735852718353},\n", - " 'window': {(2060, 1): 209.07866859436035,\n", - " (2060, 2): 56.3311562538147,\n", - " (2060, 3): 41.6882746219635,\n", - " (2060, 4): 40.85188031196594,\n", - " (2060, 5): 7.504156231880188,\n", - " (2060, 6): 2.420486330986023,\n", - " (2060, 7): 4.300221085548401,\n", - " (2060, 8): 2.435946822166443,\n", - " (2060, 9): 2.666321039199829,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 19.11955213546753,\n", - " (2060, 12): 120.58591842651367}},\n", - " 153: {'monthly': {(2060, 1): 544.6104371547699,\n", - " (2060, 2): 215.23403096199036,\n", - " (2060, 3): 124.00178575515747,\n", - " (2060, 4): 50.215081453323364,\n", - " (2060, 5): 25.91333508491516,\n", - " (2060, 6): 7.438228964805603,\n", - " (2060, 7): 10.831429719924927,\n", - " (2060, 8): 4.729918599128723,\n", - " (2060, 9): 4.376833438873291,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 24.834824681282043,\n", - " (2060, 12): 324.11718106269836},\n", - " 'window': {(2060, 1): 233.21190643310547,\n", - " (2060, 2): 73.04850387573242,\n", - " (2060, 3): 45.87752151489258,\n", - " (2060, 4): 50.215081453323364,\n", - " (2060, 5): 10.606816172599792,\n", - " (2060, 6): 3.4925485849380493,\n", - " (2060, 7): 4.300221085548401,\n", - " (2060, 8): 2.435946822166443,\n", - " (2060, 9): 3.1367498636245728,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 23.816997170448303,\n", - " (2060, 12): 158.4347438812256}},\n", - " 154: {'monthly': {(2060, 1): 575.1244916915894,\n", - " (2060, 2): 224.38608920574188,\n", - " (2060, 3): 104.43615257740021,\n", - " (2060, 4): 55.246620655059814,\n", - " (2060, 5): 28.063321948051453,\n", - " (2060, 6): 7.0058112144470215,\n", - " (2060, 7): 9.924159169197083,\n", - " (2060, 8): 4.8364903926849365,\n", - " (2060, 9): 4.480561017990112,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 18.51421058177948,\n", - " (2060, 12): 327.46167039871216},\n", - " 'window': {(2060, 1): 279.6168441772461,\n", - " (2060, 2): 85.52055263519287,\n", - " (2060, 3): 34.29657030105591,\n", - " (2060, 4): 54.151129484176636,\n", - " (2060, 5): 11.8150954246521,\n", - " (2060, 6): 3.8219343423843384,\n", - " (2060, 7): 4.447750926017761,\n", - " (2060, 8): 3.5476962327957153,\n", - " (2060, 9): 3.240477442741394,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 17.49638307094574,\n", - " (2060, 12): 185.88535118103027}},\n", - " 155: {'monthly': {(2060, 1): 539.3107025623322,\n", - " (2060, 2): 178.0865559577942,\n", - " (2060, 3): 88.478156208992,\n", - " (2060, 4): 41.39406335353851,\n", - " (2060, 5): 26.385444045066833,\n", - " (2060, 6): 7.7990381717681885,\n", - " (2060, 7): 10.050246238708496,\n", - " (2060, 8): 3.724740982055664,\n", - " (2060, 9): 4.196112751960754,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 14.667012333869934,\n", - " (2060, 12): 294.4691479206085},\n", - " 'window': {(2060, 1): 288.03248023986816,\n", - " (2060, 2): 69.59409713745117,\n", - " (2060, 3): 27.123789072036743,\n", - " (2060, 4): 41.39406335353851,\n", - " (2060, 5): 11.211339235305786,\n", - " (2060, 6): 3.48790180683136,\n", - " (2060, 7): 4.300221085548401,\n", - " (2060, 8): 2.435946822166443,\n", - " (2060, 9): 2.956029176712036,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 13.649184823036194,\n", - " (2060, 12): 165.10726642608643}},\n", - " 156: {'monthly': {(2060, 1): 463.8175914287567,\n", - " (2060, 2): 114.76507651805878,\n", - " (2060, 3): 186.59984683990479,\n", - " (2060, 4): 66.47606456279755,\n", - " (2060, 5): 17.840253472328186,\n", - " (2060, 6): 8.094635844230652,\n", - " (2060, 7): 10.49191665649414,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 9.589590311050415,\n", - " (2060, 11): 75.8117184638977,\n", - " (2060, 12): 238.56864762306213},\n", - " 'window': {(2060, 1): 150.82674503326416,\n", - " (2060, 2): 29.345274925231934,\n", - " (2060, 3): 65.25421237945557,\n", - " (2060, 4): 42.125547885894775,\n", - " (2060, 5): 10.287072896957397,\n", - " (2060, 6): 2.9090415239334106,\n", - " (2060, 7): 3.24590265750885,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 5.666674017906189,\n", - " (2060, 11): 36.566338539123535,\n", - " (2060, 12): 76.04715538024902}},\n", - " 157: {'monthly': {(2060, 1): 445.5108299255371,\n", - " (2060, 2): 137.74211084842682,\n", - " (2060, 3): 143.97659599781036,\n", - " (2060, 4): 45.66780638694763,\n", - " (2060, 5): 16.342001080513,\n", - " (2060, 6): 8.047105312347412,\n", - " (2060, 7): 11.513828992843628,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.306508779525757,\n", - " (2060, 11): 39.23605036735535,\n", - " (2060, 12): 238.68454933166504},\n", - " 'window': {(2060, 1): 177.19201469421387,\n", - " (2060, 2): 44.930880308151245,\n", - " (2060, 3): 48.26083326339722,\n", - " (2060, 4): 39.0357084274292,\n", - " (2060, 5): 8.425317525863647,\n", - " (2060, 6): 5.011563539505005,\n", - " (2060, 7): 3.444610834121704,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.306508779525757,\n", - " (2060, 11): 24.872433304786682,\n", - " (2060, 12): 92.66023254394531}},\n", - " 158: {'monthly': {(2060, 1): 508.199538230896,\n", - " (2060, 2): 146.10861229896545,\n", - " (2060, 3): 150.79600644111633,\n", - " (2060, 4): 47.98918271064758,\n", - " (2060, 5): 16.505216002464294,\n", - " (2060, 6): 8.047105312347412,\n", - " (2060, 7): 10.662788271903992,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 4.631542205810547,\n", - " (2060, 11): 39.04755961894989,\n", - " (2060, 12): 257.0893337726593},\n", - " 'window': {(2060, 1): 200.11415672302246,\n", - " (2060, 2): 41.082892656326294,\n", - " (2060, 3): 44.37072539329529,\n", - " (2060, 4): 41.4025559425354,\n", - " (2060, 5): 7.854450583457947,\n", - " (2060, 6): 5.011563539505005,\n", - " (2060, 7): 4.0721495151519775,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.601518750190735,\n", - " (2060, 11): 24.319149494171143,\n", - " (2060, 12): 97.07602024078369}},\n", - " 159: {'monthly': {(2060, 1): 475.5495002269745,\n", - " (2060, 2): 127.80867207050323,\n", - " (2060, 3): 115.0802493095398,\n", - " (2060, 4): 36.43700611591339,\n", - " (2060, 5): 12.393890500068665,\n", - " (2060, 6): 9.135425329208374,\n", - " (2060, 7): 9.876981139183044,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.9625778198242188,\n", - " (2060, 11): 33.560656666755676,\n", - " (2060, 12): 198.35782718658447},\n", - " 'window': {(2060, 1): 193.26773834228516,\n", - " (2060, 2): 39.20485997200012,\n", - " (2060, 3): 34.99464511871338,\n", - " (2060, 4): 29.872126817703247,\n", - " (2060, 5): 6.741479754447937,\n", - " (2060, 6): 5.011563539505005,\n", - " (2060, 7): 3.2863423824310303,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.9625778198242188,\n", - " (2060, 11): 21.208625078201294,\n", - " (2060, 12): 75.17016792297363}},\n", - " 160: {'monthly': {(2060, 1): 467.2062494754791,\n", - " (2060, 2): 133.52259409427643,\n", - " (2060, 3): 108.98066568374634,\n", - " (2060, 4): 23.98950183391571,\n", - " (2060, 5): 9.674503922462463,\n", - " (2060, 6): 9.095479488372803,\n", - " (2060, 7): 7.626797080039978,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.306508779525757,\n", - " (2060, 11): 33.279420137405396,\n", - " (2060, 12): 175.39110231399536},\n", - " 'window': {(2060, 1): 189.98137283325195,\n", - " (2060, 2): 37.55669903755188,\n", - " (2060, 3): 37.487526655197144,\n", - " (2060, 4): 19.742302656173706,\n", - " (2060, 5): 5.15053927898407,\n", - " (2060, 6): 5.011563539505005,\n", - " (2060, 7): 2.7263057231903076,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.306508779525757,\n", - " (2060, 11): 20.82107937335968,\n", - " (2060, 12): 62.41847038269043}},\n", - " 161: {'monthly': {(2060, 1): 565.223915714616,\n", - " (2060, 2): 158.11182463169098,\n", - " (2060, 3): 130.915123462677,\n", - " (2060, 4): 51.02925181388855,\n", - " (2060, 5): 17.528724789619446,\n", - " (2060, 6): 7.963107585906982,\n", - " (2060, 7): 11.038378596305847,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 1.0411758422851562,\n", - " (2060, 10): 3.3917908668518066,\n", - " (2060, 11): 35.32120990753174,\n", - " (2060, 12): 247.7245466709137},\n", - " 'window': {(2060, 1): 212.8940035289471,\n", - " (2060, 2): 47.37472629547119,\n", - " (2060, 3): 56.69211196899414,\n", - " (2060, 4): 47.30654764175415,\n", - " (2060, 5): 8.02337896823883,\n", - " (2060, 6): 4.980204701423645,\n", - " (2060, 7): 3.557786226272583,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 1.0411758422851562,\n", - " (2060, 10): 3.3917908668518066,\n", - " (2060, 11): 17.92144227027893,\n", - " (2060, 12): 111.06937980651855}},\n", - " 162: {'monthly': {(2060, 1): 639.5122224201051,\n", - " (2060, 2): 184.33773565292358,\n", - " (2060, 3): 136.3620994091034,\n", - " (2060, 4): 51.995134115219116,\n", - " (2060, 5): 26.852630615234375,\n", - " (2060, 6): 7.963107585906982,\n", - " (2060, 7): 9.286041021347046,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.3917908668518066,\n", - " (2060, 11): 28.37576115131378,\n", - " (2060, 12): 240.14594495296478},\n", - " 'window': {(2060, 1): 215.69339574469006,\n", - " (2060, 2): 61.68908333778381,\n", - " (2060, 3): 58.49646186828613,\n", - " (2060, 4): 45.944661140441895,\n", - " (2060, 5): 12.772626042366028,\n", - " (2060, 6): 4.980204701423645,\n", - " (2060, 7): 2.972941756248474,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.3917908668518066,\n", - " (2060, 11): 15.555755138397217,\n", - " (2060, 12): 118.71782112121582}},\n", - " 163: {'monthly': {(2060, 1): 689.4888419705046,\n", - " (2060, 2): 164.22910010814667,\n", - " (2060, 3): 114.84975385665894,\n", - " (2060, 4): 54.110827565193176,\n", - " (2060, 5): 24.509538650512695,\n", - " (2060, 6): 7.963107585906982,\n", - " (2060, 7): 8.41568410396576,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.3917908668518066,\n", - " (2060, 11): 31.676334142684937,\n", - " (2060, 12): 228.28842520713806},\n", - " 'window': {(2060, 1): 262.857626636566,\n", - " (2060, 2): 55.66867470741272,\n", - " (2060, 3): 43.93050932884216,\n", - " (2060, 4): 49.23559331893921,\n", - " (2060, 5): 11.634418606758118,\n", - " (2060, 6): 4.980204701423645,\n", - " (2060, 7): 3.2658973932266235,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.3917908668518066,\n", - " (2060, 11): 18.955174684524536,\n", - " (2060, 12): 108.42728042602539}},\n", - " 164: {'monthly': {(2060, 1): 703.5734467506409,\n", - " (2060, 2): 138.86306059360504,\n", - " (2060, 3): 121.05509626865387,\n", - " (2060, 4): 52.200483202934265,\n", - " (2060, 5): 19.944064140319824,\n", - " (2060, 6): 9.021228671073914,\n", - " (2060, 7): 9.587644577026367,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.3917908668518066,\n", - " (2060, 11): 26.55596351623535,\n", - " (2060, 12): 235.7708294391632},\n", - " 'window': {(2060, 1): 293.93906593322754,\n", - " (2060, 2): 48.78366315364838,\n", - " (2060, 3): 39.95149850845337,\n", - " (2060, 4): 45.26901912689209,\n", - " (2060, 5): 9.416640400886536,\n", - " (2060, 6): 4.980204701423645,\n", - " (2060, 7): 4.4378578662872314,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.3917908668518066,\n", - " (2060, 11): 16.865971446037292,\n", - " (2060, 12): 104.30511569976807}},\n", - " 165: {'monthly': {(2060, 1): 491.4772412776947,\n", - " (2060, 2): 195.91738986968994,\n", - " (2060, 3): 144.90502297878265,\n", - " (2060, 4): 37.79078495502472,\n", - " (2060, 5): 25.440772533416748,\n", - " (2060, 6): 9.271228313446045,\n", - " (2060, 7): 9.373435378074646,\n", - " (2060, 8): 3.724740982055664,\n", - " (2060, 9): 3.990866184234619,\n", - " (2060, 10): 1.0318998098373413,\n", - " (2060, 11): 21.745880842208862,\n", - " (2060, 12): 301.3002278804779},\n", - " 'window': {(2060, 1): 218.55953407287598,\n", - " (2060, 2): 58.472350120544434,\n", - " (2060, 3): 43.59434723854065,\n", - " (2060, 4): 36.76918697357178,\n", - " (2060, 5): 9.280464768409729,\n", - " (2060, 6): 5.329821705818176,\n", - " (2060, 7): 4.60762083530426,\n", - " (2060, 8): 2.435946822166443,\n", - " (2060, 9): 2.750782608985901,\n", - " (2060, 10): 1.0318998098373413,\n", - " (2060, 11): 19.39120852947235,\n", - " (2060, 12): 132.91931533813477}},\n", - " 166: {'monthly': {(2060, 1): 534.2101745605469,\n", - " (2060, 2): 242.63611924648285,\n", - " (2060, 3): 146.4498221874237,\n", - " (2060, 4): 44.790350675582886,\n", - " (2060, 5): 34.44154489040375,\n", - " (2060, 6): 9.449797630310059,\n", - " (2060, 7): 9.653993725776672,\n", - " (2060, 8): 3.724740982055664,\n", - " (2060, 9): 4.367807865142822,\n", - " (2060, 10): 1.0837409496307373,\n", - " (2060, 11): 26.596923112869263,\n", - " (2060, 12): 318.84148013591766},\n", - " 'window': {(2060, 1): 219.0299472808838,\n", - " (2060, 2): 72.482177734375,\n", - " (2060, 3): 46.967514514923096,\n", - " (2060, 4): 41.520403146743774,\n", - " (2060, 5): 13.284638285636902,\n", - " (2060, 6): 4.675109624862671,\n", - " (2060, 7): 4.300221085548401,\n", - " (2060, 8): 2.435946822166443,\n", - " (2060, 9): 3.127724289894104,\n", - " (2060, 10): 1.0837409496307373,\n", - " (2060, 11): 24.52204155921936,\n", - " (2060, 12): 152.4080810546875}},\n", - " 167: {'monthly': {(2060, 1): 553.5301396846771,\n", - " (2060, 2): 259.5726568698883,\n", - " (2060, 3): 114.79242014884949,\n", - " (2060, 4): 43.78909921646118,\n", - " (2060, 5): 31.613327980041504,\n", - " (2060, 6): 9.55726945400238,\n", - " (2060, 7): 9.81840717792511,\n", - " (2060, 8): 3.724740982055664,\n", - " (2060, 9): 4.229665637016296,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 19.81907093524933,\n", - " (2060, 12): 313.30940186977386},\n", - " 'window': {(2060, 1): 248.92206573486328,\n", - " (2060, 2): 88.70847702026367,\n", - " (2060, 3): 37.167367935180664,\n", - " (2060, 4): 43.78909921646118,\n", - " (2060, 5): 12.177411675453186,\n", - " (2060, 6): 3.769272804260254,\n", - " (2060, 7): 4.300221085548401,\n", - " (2060, 8): 2.435946822166443,\n", - " (2060, 9): 2.989582061767578,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 18.80124342441559,\n", - " (2060, 12): 174.07167625427246}},\n", - " 168: {'monthly': {(2060, 1): 507.4827492237091,\n", - " (2060, 2): 192.77526688575745,\n", - " (2060, 3): 94.72853350639343,\n", - " (2060, 4): 40.32822299003601,\n", - " (2060, 5): 27.072498083114624,\n", - " (2060, 6): 5.675352096557617,\n", - " (2060, 7): 9.305126667022705,\n", - " (2060, 8): 3.724740982055664,\n", - " (2060, 9): 4.076937556266785,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 16.762393832206726,\n", - " (2060, 12): 268.0553960800171},\n", - " 'window': {(2060, 1): 261.0039234161377,\n", - " (2060, 2): 67.60743141174316,\n", - " (2060, 3): 29.80318260192871,\n", - " (2060, 4): 37.07877051830292,\n", - " (2060, 5): 10.954896569252014,\n", - " (2060, 6): 2.420486330986023,\n", - " (2060, 7): 4.300221085548401,\n", - " (2060, 8): 2.435946822166443,\n", - " (2060, 9): 2.8368539810180664,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 15.744566321372986,\n", - " (2060, 12): 149.61017036437988}},\n", - " 169: {'monthly': {(2060, 1): 433.3210600614548,\n", - " (2060, 2): 124.86576128005981,\n", - " (2060, 3): 139.96077752113342,\n", - " (2060, 4): 48.07671642303467,\n", - " (2060, 5): 11.279325246810913,\n", - " (2060, 6): 4.076462268829346,\n", - " (2060, 7): 6.096834063529968,\n", - " (2060, 8): 1.8466986417770386,\n", - " (2060, 9): 2.37607479095459,\n", - " (2060, 10): 3.6148860454559326,\n", - " (2060, 11): 55.7458518743515,\n", - " (2060, 12): 222.96572065353394},\n", - " 'window': {(2060, 1): 108.38686656951904,\n", - " (2060, 2): 36.78160095214844,\n", - " (2060, 3): 47.96235752105713,\n", - " (2060, 4): 34.6370552778244,\n", - " (2060, 5): 5.13140344619751,\n", - " (2060, 6): 4.076462268829346,\n", - " (2060, 7): 2.7373101711273193,\n", - " (2060, 8): 1.8466986417770386,\n", - " (2060, 9): 1.3261799812316895,\n", - " (2060, 10): 2.5250110626220703,\n", - " (2060, 11): 22.96978533267975,\n", - " (2060, 12): 80.55756568908691}},\n", - " 170: {'monthly': {(2060, 1): 404.89933264255524,\n", - " (2060, 2): 181.18919503688812,\n", - " (2060, 3): 144.7589386701584,\n", - " (2060, 4): 44.84254801273346,\n", - " (2060, 5): 22.080283522605896,\n", - " (2060, 6): 6.7379865646362305,\n", - " (2060, 7): 4.303999423980713,\n", - " (2060, 8): 2.47005558013916,\n", - " (2060, 9): 1.2781932353973389,\n", - " (2060, 10): 4.805362701416016,\n", - " (2060, 11): 30.86307418346405,\n", - " (2060, 12): 209.41005182266235},\n", - " 'window': {(2060, 1): 117.49062156677246,\n", - " (2060, 2): 53.06289529800415,\n", - " (2060, 3): 56.57902717590332,\n", - " (2060, 4): 38.929309010505676,\n", - " (2060, 5): 10.568870067596436,\n", - " (2060, 6): 3.8782328367233276,\n", - " (2060, 7): 2.9877573251724243,\n", - " (2060, 8): 2.47005558013916,\n", - " (2060, 9): 1.2781932353973389,\n", - " (2060, 10): 3.7240233421325684,\n", - " (2060, 11): 24.074130415916443,\n", - " (2060, 12): 110.17433452606201}},\n", - " 171: {'monthly': {(2060, 1): 404.4457914829254,\n", - " (2060, 2): 159.9511135816574,\n", - " (2060, 3): 127.25025510787964,\n", - " (2060, 4): 47.67215573787689,\n", - " (2060, 5): 20.331368327140808,\n", - " (2060, 6): 6.7379865646362305,\n", - " (2060, 7): 4.303999423980713,\n", - " (2060, 8): 2.47005558013916,\n", - " (2060, 9): 1.2781932353973389,\n", - " (2060, 10): 6.628361225128174,\n", - " (2060, 11): 38.94187819957733,\n", - " (2060, 12): 208.38894045352936},\n", - " 'window': {(2060, 1): 120.27606010437012,\n", - " (2060, 2): 50.045090675354004,\n", - " (2060, 3): 48.71772241592407,\n", - " (2060, 4): 40.482062220573425,\n", - " (2060, 5): 9.94093668460846,\n", - " (2060, 6): 3.8782328367233276,\n", - " (2060, 7): 2.9877573251724243,\n", - " (2060, 8): 2.47005558013916,\n", - " (2060, 9): 1.2781932353973389,\n", - " (2060, 10): 5.078392744064331,\n", - " (2060, 11): 27.37696647644043,\n", - " (2060, 12): 115.6985034942627}},\n", - " 172: {'monthly': {(2060, 1): 391.70141184329987,\n", - " (2060, 2): 147.6609525680542,\n", - " (2060, 3): 109.62588310241699,\n", - " (2060, 4): 49.474047899246216,\n", - " (2060, 5): 15.682674050331116,\n", - " (2060, 6): 6.7379865646362305,\n", - " (2060, 7): 4.303999423980713,\n", - " (2060, 8): 2.47005558013916,\n", - " (2060, 9): 1.2781932353973389,\n", - " (2060, 10): 2.8441531658172607,\n", - " (2060, 11): 29.458752632141113,\n", - " (2060, 12): 210.0579401254654},\n", - " 'window': {(2060, 1): 127.33689498901367,\n", - " (2060, 2): 46.592326641082764,\n", - " (2060, 3): 44.437650203704834,\n", - " (2060, 4): 43.23923051357269,\n", - " (2060, 5): 8.131774544715881,\n", - " (2060, 6): 3.8782328367233276,\n", - " (2060, 7): 2.9877573251724243,\n", - " (2060, 8): 2.47005558013916,\n", - " (2060, 9): 1.2781932353973389,\n", - " (2060, 10): 2.8441531658172607,\n", - " (2060, 11): 23.342105984687805,\n", - " (2060, 12): 113.7997236251831}},\n", - " 173: {'monthly': {(2060, 1): 425.51972138881683,\n", - " (2060, 2): 158.6221764087677,\n", - " (2060, 3): 107.79366290569305,\n", - " (2060, 4): 53.641563057899475,\n", - " (2060, 5): 12.246930718421936,\n", - " (2060, 6): 8.188737511634827,\n", - " (2060, 7): 5.574302792549133,\n", - " (2060, 8): 2.47005558013916,\n", - " (2060, 9): 1.2781932353973389,\n", - " (2060, 10): 3.887343168258667,\n", - " (2060, 11): 25.00710380077362,\n", - " (2060, 12): 215.6530042886734},\n", - " 'window': {(2060, 1): 145.2794952392578,\n", - " (2060, 2): 45.12789726257324,\n", - " (2060, 3): 45.14041996002197,\n", - " (2060, 4): 47.55679929256439,\n", - " (2060, 5): 6.480376362800598,\n", - " (2060, 6): 3.8782328367233276,\n", - " (2060, 7): 2.9877573251724243,\n", - " (2060, 8): 2.47005558013916,\n", - " (2060, 9): 1.2781932353973389,\n", - " (2060, 10): 2.8441531658172607,\n", - " (2060, 11): 20.937688946723938,\n", - " (2060, 12): 117.17482948303223}},\n", - " 174: {'monthly': {(2060, 1): 496.2138330936432,\n", - " (2060, 2): 215.77780532836914,\n", - " (2060, 3): 128.52353930473328,\n", - " (2060, 4): 69.4588680267334,\n", - " (2060, 5): 8.201274514198303,\n", - " (2060, 6): 6.740338921546936,\n", - " (2060, 7): 4.3274606466293335,\n", - " (2060, 8): 2.5208728313446045,\n", - " (2060, 9): 1.3040574789047241,\n", - " (2060, 10): 3.930637240409851,\n", - " (2060, 11): 29.002832174301147,\n", - " (2060, 12): 245.47423183918},\n", - " 'window': {(2060, 1): 155.98570728302002,\n", - " (2060, 2): 65.96364879608154,\n", - " (2060, 3): 37.771923542022705,\n", - " (2060, 4): 60.970356702804565,\n", - " (2060, 5): 3.745055317878723,\n", - " (2060, 6): 3.875940203666687,\n", - " (2060, 7): 2.9816426038742065,\n", - " (2060, 8): 2.5208728313446045,\n", - " (2060, 9): 1.3040574789047241,\n", - " (2060, 10): 3.930637240409851,\n", - " (2060, 11): 18.311312794685364,\n", - " (2060, 12): 129.86513900756836}},\n", - " 175: {'monthly': {(2060, 1): 563.3781534433365,\n", - " (2060, 2): 212.954984664917,\n", - " (2060, 3): 126.57059407234192,\n", - " (2060, 4): 86.20504605770111,\n", - " (2060, 5): 8.866072058677673,\n", - " (2060, 6): 6.740338921546936,\n", - " (2060, 7): 4.3274606466293335,\n", - " (2060, 8): 2.5208728313446045,\n", - " (2060, 9): 1.3040574789047241,\n", - " (2060, 10): 3.930637240409851,\n", - " (2060, 11): 24.298937559127808,\n", - " (2060, 12): 270.80613470077515},\n", - " 'window': {(2060, 1): 171.2141933441162,\n", - " (2060, 2): 72.80364608764648,\n", - " (2060, 3): 42.0101957321167,\n", - " (2060, 4): 78.03071546554565,\n", - " (2060, 5): 4.064038872718811,\n", - " (2060, 6): 3.875940203666687,\n", - " (2060, 7): 2.9816426038742065,\n", - " (2060, 8): 2.5208728313446045,\n", - " (2060, 9): 1.3040574789047241,\n", - " (2060, 10): 3.930637240409851,\n", - " (2060, 11): 18.181456208229065,\n", - " (2060, 12): 159.3554229736328}},\n", - " 176: {'monthly': {(2060, 1): 612.4284174442291,\n", - " (2060, 2): 221.30492556095123,\n", - " (2060, 3): 142.92271900177002,\n", - " (2060, 4): 108.82803928852081,\n", - " (2060, 5): 10.968544125556946,\n", - " (2060, 6): 6.740338921546936,\n", - " (2060, 7): 4.602813363075256,\n", - " (2060, 8): 2.5208728313446045,\n", - " (2060, 9): 1.3040574789047241,\n", - " (2060, 10): 3.930637240409851,\n", - " (2060, 11): 25.25548255443573,\n", - " (2060, 12): 316.99953496456146},\n", - " 'window': {(2060, 1): 199.54974365234375,\n", - " (2060, 2): 72.30061769485474,\n", - " (2060, 3): 48.6369423866272,\n", - " (2060, 4): 97.95365226268768,\n", - " (2060, 5): 5.072848439216614,\n", - " (2060, 6): 3.875940203666687,\n", - " (2060, 7): 3.2569953203201294,\n", - " (2060, 8): 2.5208728313446045,\n", - " (2060, 9): 1.3040574789047241,\n", - " (2060, 10): 3.930637240409851,\n", - " (2060, 11): 19.794592261314392,\n", - " (2060, 12): 201.73933029174805}},\n", - " 177: {'monthly': {(2060, 1): 592.388561964035,\n", - " (2060, 2): 210.3623481988907,\n", - " (2060, 3): 144.89045894145966,\n", - " (2060, 4): 106.92061638832092,\n", - " (2060, 5): 11.997749209403992,\n", - " (2060, 6): 6.740338921546936,\n", - " (2060, 7): 5.873659253120422,\n", - " (2060, 8): 2.5208728313446045,\n", - " (2060, 9): 1.3040574789047241,\n", - " (2060, 10): 3.930637240409851,\n", - " (2060, 11): 28.594520807266235,\n", - " (2060, 12): 325.4349226951599},\n", - " 'window': {(2060, 1): 199.83579635620117,\n", - " (2060, 2): 72.72619318962097,\n", - " (2060, 3): 49.3179931640625,\n", - " (2060, 4): 95.42072415351868,\n", - " (2060, 5): 5.56668221950531,\n", - " (2060, 6): 3.875940203666687,\n", - " (2060, 7): 3.4456844329833984,\n", - " (2060, 8): 2.5208728313446045,\n", - " (2060, 9): 1.3040574789047241,\n", - " (2060, 10): 3.930637240409851,\n", - " (2060, 11): 22.519856572151184,\n", - " (2060, 12): 201.87748908996582}},\n", - " 178: {'monthly': {(2060, 1): 543.9809947013855,\n", - " (2060, 2): 259.36223578453064,\n", - " (2060, 3): 163.39790451526642,\n", - " (2060, 4): 48.27225303649902,\n", - " (2060, 5): 14.929511785507202,\n", - " (2060, 6): 8.283711671829224,\n", - " (2060, 7): 7.506377577781677,\n", - " (2060, 8): 5.827641844749451,\n", - " (2060, 9): 4.551493167877197,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 38.90728199481964,\n", - " (2060, 12): 298.67132329940796},\n", - " 'window': {(2060, 1): 244.03939247131348,\n", - " (2060, 2): 71.7292537689209,\n", - " (2060, 3): 53.041993618011475,\n", - " (2060, 4): 41.78885471820831,\n", - " (2060, 5): 6.733692169189453,\n", - " (2060, 6): 3.388978958129883,\n", - " (2060, 7): 3.630094051361084,\n", - " (2060, 8): 3.5004416704177856,\n", - " (2060, 9): 1.2823882102966309,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 30.068946361541748,\n", - " (2060, 12): 125.12987422943115}},\n", - " 179: {'monthly': {(2060, 1): 625.8229532241821,\n", - " (2060, 2): 306.4394884109497,\n", - " (2060, 3): 148.64886355400085,\n", - " (2060, 4): 60.008862137794495,\n", - " (2060, 5): 16.296876788139343,\n", - " (2060, 6): 7.417203783988953,\n", - " (2060, 7): 7.605239033699036,\n", - " (2060, 8): 7.647725343704224,\n", - " (2060, 9): 5.358657479286194,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 36.778788685798645,\n", - " (2060, 12): 307.45755314826965},\n", - " 'window': {(2060, 1): 316.5361518859863,\n", - " (2060, 2): 88.41947555541992,\n", - " (2060, 3): 47.63106679916382,\n", - " (2060, 4): 55.26478672027588,\n", - " (2060, 5): 7.355627417564392,\n", - " (2060, 6): 3.388978958129883,\n", - " (2060, 7): 3.630094051361084,\n", - " (2060, 8): 5.320525169372559,\n", - " (2060, 9): 3.1279066801071167,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 25.313725471496582,\n", - " (2060, 12): 144.18492889404297}},\n", - " 180: {'monthly': {(2060, 1): 672.832441329956,\n", - " (2060, 2): 317.80841422080994,\n", - " (2060, 3): 116.37390553951263,\n", - " (2060, 4): 70.758913397789,\n", - " (2060, 5): 15.91000759601593,\n", - " (2060, 6): 7.583552360534668,\n", - " (2060, 7): 6.754104971885681,\n", - " (2060, 8): 7.177797555923462,\n", - " (2060, 9): 3.513139009475708,\n", - " (2060, 10): 2.009666681289673,\n", - " (2060, 11): 36.33926486968994,\n", - " (2060, 12): 280.2600975036621},\n", - " 'window': {(2060, 1): 381.65076637268066,\n", - " (2060, 2): 97.55902671813965,\n", - " (2060, 3): 38.84680795669556,\n", - " (2060, 4): 65.22104668617249,\n", - " (2060, 5): 6.662021636962891,\n", - " (2060, 6): 3.388978958129883,\n", - " (2060, 7): 3.630094051361084,\n", - " (2060, 8): 4.850597381591797,\n", - " (2060, 9): 1.2823882102966309,\n", - " (2060, 10): 2.009666681289673,\n", - " (2060, 11): 26.953388810157776,\n", - " (2060, 12): 139.53970336914062}},\n", - " 181: {'monthly': {(2060, 1): 652.1872477531433,\n", - " (2060, 2): 256.2237331867218,\n", - " (2060, 3): 106.07407116889954,\n", - " (2060, 4): 92.04533612728119,\n", - " (2060, 5): 12.587363839149475,\n", - " (2060, 6): 7.342294931411743,\n", - " (2060, 7): 5.7028772830963135,\n", - " (2060, 8): 5.827641844749451,\n", - " (2060, 9): 3.513139009475708,\n", - " (2060, 10): 1.2340120077133179,\n", - " (2060, 11): 22.55231547355652,\n", - " (2060, 12): 231.8488734960556},\n", - " 'window': {(2060, 1): 394.88218879699707,\n", - " (2060, 2): 74.93708324432373,\n", - " (2060, 3): 33.20337176322937,\n", - " (2060, 4): 87.20618748664856,\n", - " (2060, 5): 6.205767393112183,\n", - " (2060, 6): 3.388978958129883,\n", - " (2060, 7): 3.630094051361084,\n", - " (2060, 8): 3.5004416704177856,\n", - " (2060, 9): 1.2823882102966309,\n", - " (2060, 10): 1.2340120077133179,\n", - " (2060, 11): 16.506348848342896,\n", - " (2060, 12): 114.28431224822998}},\n", - " 182: {'monthly': {(2060, 1): 405.77519512176514,\n", - " (2060, 2): 136.03984582424164,\n", - " (2060, 3): 151.52858448028564,\n", - " (2060, 4): 39.01797533035278,\n", - " (2060, 5): 8.549841046333313,\n", - " (2060, 6): 4.076462268829346,\n", - " (2060, 7): 6.096834063529968,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 1.0498948097229004,\n", - " (2060, 10): 1.3706409931182861,\n", - " (2060, 11): 45.368114709854126,\n", - " (2060, 12): 208.27693855762482},\n", - " 'window': {(2060, 1): 113.39015674591064,\n", - " (2060, 2): 39.53985595703125,\n", - " (2060, 3): 60.72334289550781,\n", - " (2060, 4): 28.052588939666748,\n", - " (2060, 5): 3.8868887424468994,\n", - " (2060, 6): 4.076462268829346,\n", - " (2060, 7): 2.7373101711273193,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 1.0498948097229004,\n", - " (2060, 10): 1.3706409931182861,\n", - " (2060, 11): 21.898704409599304,\n", - " (2060, 12): 87.70970249176025}},\n", - " 183: {'monthly': {(2060, 1): 369.88528883457184,\n", - " (2060, 2): 144.67017221450806,\n", - " (2060, 3): 119.76149559020996,\n", - " (2060, 4): 61.14673697948456,\n", - " (2060, 5): 16.54300332069397,\n", - " (2060, 6): 6.7379865646362305,\n", - " (2060, 7): 4.303999423980713,\n", - " (2060, 8): 2.47005558013916,\n", - " (2060, 9): 2.7569934129714966,\n", - " (2060, 10): 3.85209059715271,\n", - " (2060, 11): 22.895681977272034,\n", - " (2060, 12): 192.11981236934662},\n", - " 'window': {(2060, 1): 121.12446022033691,\n", - " (2060, 2): 47.756664991378784,\n", - " (2060, 3): 43.11520004272461,\n", - " (2060, 4): 53.913745641708374,\n", - " (2060, 5): 8.547401666641235,\n", - " (2060, 6): 3.8782328367233276,\n", - " (2060, 7): 2.9877573251724243,\n", - " (2060, 8): 2.47005558013916,\n", - " (2060, 9): 2.7569934129714966,\n", - " (2060, 10): 3.85209059715271,\n", - " (2060, 11): 16.643622636795044,\n", - " (2060, 12): 106.24199676513672}},\n", - " 184: {'monthly': {(2060, 1): 355.6031981706619,\n", - " (2060, 2): 129.67078578472137,\n", - " (2060, 3): 103.14015519618988,\n", - " (2060, 4): 52.44886016845703,\n", - " (2060, 5): 13.811297059059143,\n", - " (2060, 6): 6.7379865646362305,\n", - " (2060, 7): 4.303999423980713,\n", - " (2060, 8): 2.47005558013916,\n", - " (2060, 9): 1.2781932353973389,\n", - " (2060, 10): 2.8441531658172607,\n", - " (2060, 11): 23.889975666999817,\n", - " (2060, 12): 184.1714073419571},\n", - " 'window': {(2060, 1): 120.3980827331543,\n", - " (2060, 2): 43.56775498390198,\n", - " (2060, 3): 37.164753437042236,\n", - " (2060, 4): 45.352816462516785,\n", - " (2060, 5): 7.2322927713394165,\n", - " (2060, 6): 3.8782328367233276,\n", - " (2060, 7): 2.9877573251724243,\n", - " (2060, 8): 2.47005558013916,\n", - " (2060, 9): 1.2781932353973389,\n", - " (2060, 10): 2.8441531658172607,\n", - " (2060, 11): 17.793630242347717,\n", - " (2060, 12): 106.31522178649902}},\n", - " 185: {'monthly': {(2060, 1): 397.27421617507935,\n", - " (2060, 2): 146.68269562721252,\n", - " (2060, 3): 105.63034975528717,\n", - " (2060, 4): 48.238969922065735,\n", - " (2060, 5): 13.246874451637268,\n", - " (2060, 6): 6.7379865646362305,\n", - " (2060, 7): 5.694689750671387,\n", - " (2060, 8): 2.47005558013916,\n", - " (2060, 9): 1.2781932353973389,\n", - " (2060, 10): 2.8848899602890015,\n", - " (2060, 11): 26.918259739875793,\n", - " (2060, 12): 208.72003734111786},\n", - " 'window': {(2060, 1): 132.46563529968262,\n", - " (2060, 2): 48.783474922180176,\n", - " (2060, 3): 39.3299298286438,\n", - " (2060, 4): 42.340017199516296,\n", - " (2060, 5): 6.961001515388489,\n", - " (2060, 6): 3.8782328367233276,\n", - " (2060, 7): 2.9877573251724243,\n", - " (2060, 8): 2.47005558013916,\n", - " (2060, 9): 1.2781932353973389,\n", - " (2060, 10): 2.8848899602890015,\n", - " (2060, 11): 19.637941241264343,\n", - " (2060, 12): 121.34596157073975}},\n", - " 186: {'monthly': {(2060, 1): 469.72188997268677,\n", - " (2060, 2): 177.04165184497833,\n", - " (2060, 3): 127.85494446754456,\n", - " (2060, 4): 58.95134139060974,\n", - " (2060, 5): 12.372617840766907,\n", - " (2060, 6): 7.9018378257751465,\n", - " (2060, 7): 6.196806192398071,\n", - " (2060, 8): 2.47005558013916,\n", - " (2060, 9): 2.458106517791748,\n", - " (2060, 10): 5.228024959564209,\n", - " (2060, 11): 27.820285081863403,\n", - " (2060, 12): 237.9046585559845},\n", - " 'window': {(2060, 1): 145.2359161376953,\n", - " (2060, 2): 55.15373492240906,\n", - " (2060, 3): 46.54995536804199,\n", - " (2060, 4): 51.3986850976944,\n", - " (2060, 5): 6.540788292884827,\n", - " (2060, 6): 3.8782328367233276,\n", - " (2060, 7): 3.209048867225647,\n", - " (2060, 8): 2.47005558013916,\n", - " (2060, 9): 1.2781932353973389,\n", - " (2060, 10): 4.0480886697769165,\n", - " (2060, 11): 21.26867711544037,\n", - " (2060, 12): 132.96415042877197}},\n", - " 187: {'monthly': {(2060, 1): 542.399400472641,\n", - " (2060, 2): 225.80084574222565,\n", - " (2060, 3): 134.29978358745575,\n", - " (2060, 4): 82.93935644626617,\n", - " (2060, 5): 11.787306308746338,\n", - " (2060, 6): 7.764914631843567,\n", - " (2060, 7): 7.092933535575867,\n", - " (2060, 8): 2.5208728313446045,\n", - " (2060, 9): 1.3040574789047241,\n", - " (2060, 10): 4.9943296909332275,\n", - " (2060, 11): 27.15666949748993,\n", - " (2060, 12): 258.29983139038086},\n", - " 'window': {(2060, 1): 167.7555274963379,\n", - " (2060, 2): 67.10184001922607,\n", - " (2060, 3): 39.93478345870972,\n", - " (2060, 4): 71.20936715602875,\n", - " (2060, 5): 5.016523122787476,\n", - " (2060, 6): 3.875940203666687,\n", - " (2060, 7): 4.11129093170166,\n", - " (2060, 8): 2.5208728313446045,\n", - " (2060, 9): 1.3040574789047241,\n", - " (2060, 10): 3.930637240409851,\n", - " (2060, 11): 20.111359119415283,\n", - " (2060, 12): 133.3361349105835}},\n", - " 188: {'monthly': {(2060, 1): 598.7887225151062,\n", - " (2060, 2): 218.7007406949997,\n", - " (2060, 3): 145.41692197322845,\n", - " (2060, 4): 99.52171218395233,\n", - " (2060, 5): 11.03626263141632,\n", - " (2060, 6): 6.740338921546936,\n", - " (2060, 7): 4.3274606466293335,\n", - " (2060, 8): 3.775202751159668,\n", - " (2060, 9): 1.3040574789047241,\n", - " (2060, 10): 4.93518340587616,\n", - " (2060, 11): 28.248595237731934,\n", - " (2060, 12): 280.4544018507004},\n", - " 'window': {(2060, 1): 190.31160926818848,\n", - " (2060, 2): 66.86510372161865,\n", - " (2060, 3): 47.508249282836914,\n", - " (2060, 4): 91.03409075737,\n", - " (2060, 5): 5.122410535812378,\n", - " (2060, 6): 3.875940203666687,\n", - " (2060, 7): 2.9816426038742065,\n", - " (2060, 8): 2.756471872329712,\n", - " (2060, 9): 1.3040574789047241,\n", - " (2060, 10): 3.930637240409851,\n", - " (2060, 11): 22.028297543525696,\n", - " (2060, 12): 160.07634735107422}},\n", - " 189: {'monthly': {(2060, 1): 658.3256549835205,\n", - " (2060, 2): 220.38838756084442,\n", - " (2060, 3): 182.7681449651718,\n", - " (2060, 4): 113.77284824848175,\n", - " (2060, 5): 15.409147024154663,\n", - " (2060, 6): 7.775402188301086,\n", - " (2060, 7): 5.4611053466796875,\n", - " (2060, 8): 2.5208728313446045,\n", - " (2060, 9): 1.3040574789047241,\n", - " (2060, 10): 3.930637240409851,\n", - " (2060, 11): 39.078264236450195,\n", - " (2060, 12): 329.9988250732422},\n", - " 'window': {(2060, 1): 231.4576072692871,\n", - " (2060, 2): 76.87682437896729,\n", - " (2060, 3): 63.00089740753174,\n", - " (2060, 4): 101.57303476333618,\n", - " (2060, 5): 6.241260766983032,\n", - " (2060, 6): 4.911003470420837,\n", - " (2060, 7): 2.9816426038742065,\n", - " (2060, 8): 2.5208728313446045,\n", - " (2060, 9): 1.3040574789047241,\n", - " (2060, 10): 3.930637240409851,\n", - " (2060, 11): 29.440078616142273,\n", - " (2060, 12): 192.80319213867188}},\n", - " 190: {'monthly': {(2060, 1): 594.7845485210419,\n", - " (2060, 2): 209.18859493732452,\n", - " (2060, 3): 168.0527310371399,\n", - " (2060, 4): 99.98551154136658,\n", - " (2060, 5): 14.886727333068848,\n", - " (2060, 6): 6.740338921546936,\n", - " (2060, 7): 4.3274606466293335,\n", - " (2060, 8): 2.5208728313446045,\n", - " (2060, 9): 2.309889554977417,\n", - " (2060, 10): 5.095697641372681,\n", - " (2060, 11): 43.751283168792725,\n", - " (2060, 12): 311.10115218162537},\n", - " 'window': {(2060, 1): 222.89159774780273,\n", - " (2060, 2): 76.33026838302612,\n", - " (2060, 3): 58.53102111816406,\n", - " (2060, 4): 89.59948265552521,\n", - " (2060, 5): 6.376741051673889,\n", - " (2060, 6): 3.875940203666687,\n", - " (2060, 7): 2.9816426038742065,\n", - " (2060, 8): 2.5208728313446045,\n", - " (2060, 9): 2.309889554977417,\n", - " (2060, 10): 3.930637240409851,\n", - " (2060, 11): 31.752236485481262,\n", - " (2060, 12): 173.9225254058838}},\n", - " 191: {'monthly': {(2060, 1): 429.0180253982544,\n", - " (2060, 2): 260.3347978591919,\n", - " (2060, 3): 166.0340427160263,\n", - " (2060, 4): 42.43610239028931,\n", - " (2060, 5): 14.584099531173706,\n", - " (2060, 6): 7.709660768508911,\n", - " (2060, 7): 5.7028772830963135,\n", - " (2060, 8): 5.827641844749451,\n", - " (2060, 9): 3.513139009475708,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 41.08675718307495,\n", - " (2060, 12): 285.38672935962677},\n", - " 'window': {(2060, 1): 143.2229232788086,\n", - " (2060, 2): 76.91568279266357,\n", - " (2060, 3): 59.49692249298096,\n", - " (2060, 4): 37.97916758060455,\n", - " (2060, 5): 6.776343941688538,\n", - " (2060, 6): 3.388978958129883,\n", - " (2060, 7): 3.630094051361084,\n", - " (2060, 8): 3.5004416704177856,\n", - " (2060, 9): 1.2823882102966309,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 30.051523685455322,\n", - " (2060, 12): 117.26972675323486}},\n", - " 192: {'monthly': {(2060, 1): 482.9482275247574,\n", - " (2060, 2): 288.5353276729584,\n", - " (2060, 3): 137.93345737457275,\n", - " (2060, 4): 53.26291835308075,\n", - " (2060, 5): 14.786027908325195,\n", - " (2060, 6): 10.166098594665527,\n", - " (2060, 7): 7.151646137237549,\n", - " (2060, 8): 7.500858664512634,\n", - " (2060, 9): 4.671425938606262,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 33.903533697128296,\n", - " (2060, 12): 290.3533147573471},\n", - " 'window': {(2060, 1): 194.5729579925537,\n", - " (2060, 2): 87.24868297576904,\n", - " (2060, 3): 48.432597637176514,\n", - " (2060, 4): 48.399938464164734,\n", - " (2060, 5): 7.948891282081604,\n", - " (2060, 6): 5.701723217964172,\n", - " (2060, 7): 3.630094051361084,\n", - " (2060, 8): 5.173658490180969,\n", - " (2060, 9): 2.440675139427185,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 26.61022973060608,\n", - " (2060, 12): 135.84403610229492}},\n", - " 193: {'monthly': {(2060, 1): 497.11389565467834,\n", - " (2060, 2): 299.22304904460907,\n", - " (2060, 3): 119.69936156272888,\n", - " (2060, 4): 64.755162358284,\n", - " (2060, 5): 16.561893105506897,\n", - " (2060, 6): 9.058958888053894,\n", - " (2060, 7): 6.726546049118042,\n", - " (2060, 8): 7.009900689125061,\n", - " (2060, 9): 3.513139009475708,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 29.26912569999695,\n", - " (2060, 12): 262.99337005615234},\n", - " 'window': {(2060, 1): 224.87947273254395,\n", - " (2060, 2): 98.51296997070312,\n", - " (2060, 3): 42.7988486289978,\n", - " (2060, 4): 58.77699279785156,\n", - " (2060, 5): 8.306566953659058,\n", - " (2060, 6): 4.40580415725708,\n", - " (2060, 7): 3.630094051361084,\n", - " (2060, 8): 4.682700514793396,\n", - " (2060, 9): 1.2823882102966309,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 22.25585377216339,\n", - " (2060, 12): 134.28459548950195}},\n", - " 194: {'monthly': {(2060, 1): 478.1591730117798,\n", - " (2060, 2): 258.5283114910126,\n", - " (2060, 3): 118.20888018608093,\n", - " (2060, 4): 87.14998579025269,\n", - " (2060, 5): 15.6897292137146,\n", - " (2060, 6): 7.72283673286438,\n", - " (2060, 7): 5.7028772830963135,\n", - " (2060, 8): 6.9546051025390625,\n", - " (2060, 9): 3.513139009475708,\n", - " (2060, 10): 1.0174150466918945,\n", - " (2060, 11): 23.8537780046463,\n", - " (2060, 12): 209.07546210289001},\n", - " 'window': {(2060, 1): 228.15144538879395,\n", - " (2060, 2): 79.53662586212158,\n", - " (2060, 3): 39.94540548324585,\n", - " (2060, 4): 79.53063428401947,\n", - " (2060, 5): 7.426748037338257,\n", - " (2060, 6): 3.388978958129883,\n", - " (2060, 7): 3.630094051361084,\n", - " (2060, 8): 3.5004416704177856,\n", - " (2060, 9): 1.2823882102966309,\n", - " (2060, 10): 1.0174150466918945,\n", - " (2060, 11): 16.49541699886322,\n", - " (2060, 12): 107.07840728759766}},\n", - " 195: {'monthly': {(2060, 1): 374.4840040206909,\n", - " (2060, 2): 125.37308466434479,\n", - " (2060, 3): 136.3642704486847,\n", - " (2060, 4): 32.797993659973145,\n", - " (2060, 5): 7.571933031082153,\n", - " (2060, 6): 4.076462268829346,\n", - " (2060, 7): 6.096834063529968,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 1.0498948097229004,\n", - " (2060, 10): 2.4071625471115112,\n", - " (2060, 11): 37.27567720413208,\n", - " (2060, 12): 170.37739086151123},\n", - " 'window': {(2060, 1): 106.57716178894043,\n", - " (2060, 2): 40.057897090911865,\n", - " (2060, 3): 56.675594329833984,\n", - " (2060, 4): 24.79636311531067,\n", - " (2060, 5): 2.9089807271957397,\n", - " (2060, 6): 4.076462268829346,\n", - " (2060, 7): 2.7373101711273193,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 1.0498948097229004,\n", - " (2060, 10): 2.4071625471115112,\n", - " (2060, 11): 18.008982062339783,\n", - " (2060, 12): 76.72204685211182}},\n", - " 196: {'monthly': {(2060, 1): 354.89252412319183,\n", - " (2060, 2): 131.89079701900482,\n", - " (2060, 3): 89.77245366573334,\n", - " (2060, 4): 74.4503800868988,\n", - " (2060, 5): 11.708215832710266,\n", - " (2060, 6): 6.7379865646362305,\n", - " (2060, 7): 4.303999423980713,\n", - " (2060, 8): 2.47005558013916,\n", - " (2060, 9): 1.2781932353973389,\n", - " (2060, 10): 2.8441531658172607,\n", - " (2060, 11): 15.683065414428711,\n", - " (2060, 12): 180.20955407619476},\n", - " 'window': {(2060, 1): 110.05516910552979,\n", - " (2060, 2): 44.00772261619568,\n", - " (2060, 3): 33.22860765457153,\n", - " (2060, 4): 68.53714108467102,\n", - " (2060, 5): 6.221441864967346,\n", - " (2060, 6): 3.8782328367233276,\n", - " (2060, 7): 2.9877573251724243,\n", - " (2060, 8): 2.47005558013916,\n", - " (2060, 9): 1.2781932353973389,\n", - " (2060, 10): 2.8441531658172607,\n", - " (2060, 11): 9.957370281219482,\n", - " (2060, 12): 102.68110752105713}},\n", - " 197: {'monthly': {(2060, 1): 335.7428449392319,\n", - " (2060, 2): 116.06043946743011,\n", - " (2060, 3): 82.8690778017044,\n", - " (2060, 4): 57.492225766181946,\n", - " (2060, 5): 8.998030543327332,\n", - " (2060, 6): 6.7379865646362305,\n", - " (2060, 7): 4.303999423980713,\n", - " (2060, 8): 2.47005558013916,\n", - " (2060, 9): 1.2781932353973389,\n", - " (2060, 10): 2.8441531658172607,\n", - " (2060, 11): 16.128978490829468,\n", - " (2060, 12): 178.36972987651825},\n", - " 'window': {(2060, 1): 106.90642929077148,\n", - " (2060, 2): 41.07484245300293,\n", - " (2060, 3): 30.024447917938232,\n", - " (2060, 4): 51.57898676395416,\n", - " (2060, 5): 4.918784976005554,\n", - " (2060, 6): 3.8782328367233276,\n", - " (2060, 7): 2.9877573251724243,\n", - " (2060, 8): 2.47005558013916,\n", - " (2060, 9): 1.2781932353973389,\n", - " (2060, 10): 2.8441531658172607,\n", - " (2060, 11): 11.465025067329407,\n", - " (2060, 12): 107.01951599121094}},\n", - " 198: {'monthly': {(2060, 1): 386.21834993362427,\n", - " (2060, 2): 140.55676519870758,\n", - " (2060, 3): 102.21738123893738,\n", - " (2060, 4): 50.53726017475128,\n", - " (2060, 5): 8.477314114570618,\n", - " (2060, 6): 6.7379865646362305,\n", - " (2060, 7): 4.303999423980713,\n", - " (2060, 8): 2.47005558013916,\n", - " (2060, 9): 1.2781932353973389,\n", - " (2060, 10): 3.866417646408081,\n", - " (2060, 11): 20.383090257644653,\n", - " (2060, 12): 211.74513912200928},\n", - " 'window': {(2060, 1): 121.1511697769165,\n", - " (2060, 2): 49.700071811676025,\n", - " (2060, 3): 33.11327028274536,\n", - " (2060, 4): 44.18315637111664,\n", - " (2060, 5): 4.668501257896423,\n", - " (2060, 6): 3.8782328367233276,\n", - " (2060, 7): 2.9877573251724243,\n", - " (2060, 8): 2.47005558013916,\n", - " (2060, 9): 1.2781932353973389,\n", - " (2060, 10): 3.866417646408081,\n", - " (2060, 11): 15.198614716529846,\n", - " (2060, 12): 134.88151359558105}},\n", - " 199: {'monthly': {(2060, 1): 472.5200822353363,\n", - " (2060, 2): 183.25842893123627,\n", - " (2060, 3): 138.36029243469238,\n", - " (2060, 4): 66.45625424385071,\n", - " (2060, 5): 11.682928442955017,\n", - " (2060, 6): 6.7379865646362305,\n", - " (2060, 7): 5.398420095443726,\n", - " (2060, 8): 2.47005558013916,\n", - " (2060, 9): 2.7165151834487915,\n", - " (2060, 10): 2.8441531658172607,\n", - " (2060, 11): 25.382609128952026,\n", - " (2060, 12): 253.13002908229828},\n", - " 'window': {(2060, 1): 139.06139183044434,\n", - " (2060, 2): 57.8249192237854,\n", - " (2060, 3): 42.33917427062988,\n", - " (2060, 4): 54.28379511833191,\n", - " (2060, 5): 6.655989170074463,\n", - " (2060, 6): 3.8782328367233276,\n", - " (2060, 7): 2.9877573251724243,\n", - " (2060, 8): 2.47005558013916,\n", - " (2060, 9): 1.4383219480514526,\n", - " (2060, 10): 2.8441531658172607,\n", - " (2060, 11): 19.205920815467834,\n", - " (2060, 12): 155.69376182556152}},\n", - " 200: {'monthly': {(2060, 1): 557.3896522521973,\n", - " (2060, 2): 232.4627479314804,\n", - " (2060, 3): 140.53877127170563,\n", - " (2060, 4): 94.70384156703949,\n", - " (2060, 5): 11.431853294372559,\n", - " (2060, 6): 6.740338921546936,\n", - " (2060, 7): 6.670431971549988,\n", - " (2060, 8): 2.5208728313446045,\n", - " (2060, 9): 1.3040574789047241,\n", - " (2060, 10): 4.5849515199661255,\n", - " (2060, 11): 26.606457233428955,\n", - " (2060, 12): 266.3844220638275},\n", - " 'window': {(2060, 1): 151.0474147796631,\n", - " (2060, 2): 66.3919620513916,\n", - " (2060, 3): 41.21497058868408,\n", - " (2060, 4): 82.72357988357544,\n", - " (2060, 5): 5.8182196617126465,\n", - " (2060, 6): 3.875940203666687,\n", - " (2060, 7): 2.9816426038742065,\n", - " (2060, 8): 2.5208728313446045,\n", - " (2060, 9): 1.3040574789047241,\n", - " (2060, 10): 4.5849515199661255,\n", - " (2060, 11): 19.512661814689636,\n", - " (2060, 12): 143.52185249328613}},\n", - " 201: {'monthly': {(2060, 1): 567.6395021677017,\n", - " (2060, 2): 223.97430896759033,\n", - " (2060, 3): 176.29856729507446,\n", - " (2060, 4): 121.80291759967804,\n", - " (2060, 5): 15.538689017295837,\n", - " (2060, 6): 7.847352027893066,\n", - " (2060, 7): 5.3639891147613525,\n", - " (2060, 8): 2.5208728313446045,\n", - " (2060, 9): 1.3040574789047241,\n", - " (2060, 10): 3.930637240409851,\n", - " (2060, 11): 33.30408263206482,\n", - " (2060, 12): 305.28134191036224},\n", - " 'window': {(2060, 1): 170.30436897277832,\n", - " (2060, 2): 69.79757976531982,\n", - " (2060, 3): 51.86715602874756,\n", - " (2060, 4): 108.82129108905792,\n", - " (2060, 5): 7.416134357452393,\n", - " (2060, 6): 4.982953310012817,\n", - " (2060, 7): 2.9816426038742065,\n", - " (2060, 8): 2.5208728313446045,\n", - " (2060, 9): 1.3040574789047241,\n", - " (2060, 10): 3.930637240409851,\n", - " (2060, 11): 26.25387465953827,\n", - " (2060, 12): 176.66675186157227}},\n", - " 202: {'monthly': {(2060, 1): 615.7421615123749,\n", - " (2060, 2): 231.07851564884186,\n", - " (2060, 3): 219.16408336162567,\n", - " (2060, 4): 124.96345019340515,\n", - " (2060, 5): 16.65072751045227,\n", - " (2060, 6): 8.536651968955994,\n", - " (2060, 7): 6.6346917152404785,\n", - " (2060, 8): 2.5208728313446045,\n", - " (2060, 9): 1.3040574789047241,\n", - " (2060, 10): 3.930637240409851,\n", - " (2060, 11): 39.643455386161804,\n", - " (2060, 12): 352.9398720264435},\n", - " 'window': {(2060, 1): 207.28921699523926,\n", - " (2060, 2): 82.86310195922852,\n", - " (2060, 3): 68.9524040222168,\n", - " (2060, 4): 110.8219792842865,\n", - " (2060, 5): 7.1233614683151245,\n", - " (2060, 6): 4.452599287033081,\n", - " (2060, 7): 4.136105895042419,\n", - " (2060, 8): 2.5208728313446045,\n", - " (2060, 9): 1.3040574789047241,\n", - " (2060, 10): 3.930637240409851,\n", - " (2060, 11): 32.27578926086426,\n", - " (2060, 12): 206.4161148071289}},\n", - " 203: {'monthly': {(2060, 1): 579.9386594295502,\n", - " (2060, 2): 202.1736741065979,\n", - " (2060, 3): 182.60514426231384,\n", - " (2060, 4): 86.76946318149567,\n", - " (2060, 5): 15.354466557502747,\n", - " (2060, 6): 6.740338921546936,\n", - " (2060, 7): 5.787852764129639,\n", - " (2060, 8): 2.5208728313446045,\n", - " (2060, 9): 1.3040574789047241,\n", - " (2060, 10): 4.042377233505249,\n", - " (2060, 11): 52.50965178012848,\n", - " (2060, 12): 286.543253660202},\n", - " 'window': {(2060, 1): 217.76895141601562,\n", - " (2060, 2): 75.46228694915771,\n", - " (2060, 3): 61.51104164123535,\n", - " (2060, 4): 75.76329851150513,\n", - " (2060, 5): 6.579756855964661,\n", - " (2060, 6): 3.875940203666687,\n", - " (2060, 7): 2.9816426038742065,\n", - " (2060, 8): 2.5208728313446045,\n", - " (2060, 9): 1.3040574789047241,\n", - " (2060, 10): 4.042377233505249,\n", - " (2060, 11): 31.740838766098022,\n", - " (2060, 12): 149.73518562316895}},\n", - " 204: {'monthly': {(2060, 1): 353.48863208293915,\n", - " (2060, 2): 244.140216588974,\n", - " (2060, 3): 166.3900065422058,\n", - " (2060, 4): 48.971272706985474,\n", - " (2060, 5): 16.0102459192276,\n", - " (2060, 6): 8.967739343643188,\n", - " (2060, 7): 6.967377662658691,\n", - " (2060, 8): 7.27789831161499,\n", - " (2060, 9): 3.513139009475708,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 50.461137890815735,\n", - " (2060, 12): 286.22304570674896},\n", - " 'window': {(2060, 1): 88.95380115509033,\n", - " (2060, 2): 66.74332237243652,\n", - " (2060, 3): 54.685415267944336,\n", - " (2060, 4): 40.01933825016022,\n", - " (2060, 5): 7.367315888404846,\n", - " (2060, 6): 4.469879984855652,\n", - " (2060, 7): 3.638877749443054,\n", - " (2060, 8): 4.950698137283325,\n", - " (2060, 9): 1.2823882102966309,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 32.18065905570984,\n", - " (2060, 12): 108.39305305480957}},\n", - " 205: {'monthly': {(2060, 1): 368.31146132946014,\n", - " (2060, 2): 244.8832869529724,\n", - " (2060, 3): 131.86404860019684,\n", - " (2060, 4): 44.770501494407654,\n", - " (2060, 5): 17.50290024280548,\n", - " (2060, 6): 10.139119267463684,\n", - " (2060, 7): 6.9177405834198,\n", - " (2060, 8): 7.297986149787903,\n", - " (2060, 9): 4.6000577211380005,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 34.745595932006836,\n", - " (2060, 12): 268.23171532154083},\n", - " 'window': {(2060, 1): 110.46039867401123,\n", - " (2060, 2): 70.13629245758057,\n", - " (2060, 3): 47.04891014099121,\n", - " (2060, 4): 38.69580674171448,\n", - " (2060, 5): 9.161261439323425,\n", - " (2060, 6): 4.942087173461914,\n", - " (2060, 7): 3.630094051361084,\n", - " (2060, 8): 4.970785975456238,\n", - " (2060, 9): 2.3693069219589233,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 25.333256244659424,\n", - " (2060, 12): 114.85593223571777}},\n", - " 206: {'monthly': {(2060, 1): 380.0651047229767,\n", - " (2060, 2): 267.2028373479843,\n", - " (2060, 3): 131.43940114974976,\n", - " (2060, 4): 54.76072895526886,\n", - " (2060, 5): 19.725674033164978,\n", - " (2060, 6): 10.250135064125061,\n", - " (2060, 7): 6.826310992240906,\n", - " (2060, 8): 7.118493437767029,\n", - " (2060, 9): 3.513139009475708,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 27.110626816749573,\n", - " (2060, 12): 249.4008241891861},\n", - " 'window': {(2060, 1): 131.81301307678223,\n", - " (2060, 2): 83.0746078491211,\n", - " (2060, 3): 48.13265562057495,\n", - " (2060, 4): 46.90607666969299,\n", - " (2060, 5): 10.34093689918518,\n", - " (2060, 6): 4.695354223251343,\n", - " (2060, 7): 3.630094051361084,\n", - " (2060, 8): 4.791293263435364,\n", - " (2060, 9): 1.2823882102966309,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 20.371899366378784,\n", - " (2060, 12): 114.83451271057129}},\n", - " 207: {'monthly': {(2060, 1): 375.1491801738739,\n", - " (2060, 2): 265.67341351509094,\n", - " (2060, 3): 135.78475546836853,\n", - " (2060, 4): 75.10178196430206,\n", - " (2060, 5): 19.431332230567932,\n", - " (2060, 6): 9.783690214157104,\n", - " (2060, 7): 5.7028772830963135,\n", - " (2060, 8): 8.55688488483429,\n", - " (2060, 9): 3.742014765739441,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 27.163177847862244,\n", - " (2060, 12): 211.9345064163208},\n", - " 'window': {(2060, 1): 146.48918533325195,\n", - " (2060, 2): 75.71609401702881,\n", - " (2060, 3): 49.00738286972046,\n", - " (2060, 4): 66.4505033493042,\n", - " (2060, 5): 9.246601343154907,\n", - " (2060, 6): 4.704332947731018,\n", - " (2060, 7): 3.630094051361084,\n", - " (2060, 8): 3.5004416704177856,\n", - " (2060, 9): 1.5112639665603638,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 19.07714295387268,\n", - " (2060, 12): 97.30646133422852}},\n", - " 208: {'monthly': {(2060, 1): 394.62786519527435,\n", - " (2060, 2): 136.8865545988083,\n", - " (2060, 3): 163.457861661911,\n", - " (2060, 4): 38.14574682712555,\n", - " (2060, 5): 7.203360557556152,\n", - " (2060, 6): 4.076462268829346,\n", - " (2060, 7): 6.096834063529968,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 1.0498948097229004,\n", - " (2060, 10): 1.3706409931182861,\n", - " (2060, 11): 35.876235604286194,\n", - " (2060, 12): 180.5025337934494},\n", - " 'window': {(2060, 1): 121.5498046875,\n", - " (2060, 2): 42.474868059158325,\n", - " (2060, 3): 57.639342308044434,\n", - " (2060, 4): 30.99551296234131,\n", - " (2060, 5): 2.5404082536697388,\n", - " (2060, 6): 4.076462268829346,\n", - " (2060, 7): 2.7373101711273193,\n", - " (2060, 8): 0.0,\n", - " (2060, 9): 1.0498948097229004,\n", - " (2060, 10): 1.3706409931182861,\n", - " (2060, 11): 17.650860905647278,\n", - " (2060, 12): 74.31878280639648}},\n", - " 209: {'monthly': {(2060, 1): 336.83829498291016,\n", - " (2060, 2): 134.4273101091385,\n", - " (2060, 3): 94.83284854888916,\n", - " (2060, 4): 61.82174861431122,\n", - " (2060, 5): 8.573670983314514,\n", - " (2060, 6): 6.7379865646362305,\n", - " (2060, 7): 4.303999423980713,\n", - " (2060, 8): 2.47005558013916,\n", - " (2060, 9): 2.6296366453170776,\n", - " (2060, 10): 2.8441531658172607,\n", - " (2060, 11): 19.779247045516968,\n", - " (2060, 12): 190.4882904291153},\n", - " 'window': {(2060, 1): 93.49320888519287,\n", - " (2060, 2): 48.42318296432495,\n", - " (2060, 3): 36.026485443115234,\n", - " (2060, 4): 55.908509612083435,\n", - " (2060, 5): 4.7148154973983765,\n", - " (2060, 6): 3.8782328367233276,\n", - " (2060, 7): 2.9877573251724243,\n", - " (2060, 8): 2.47005558013916,\n", - " (2060, 9): 2.6296366453170776,\n", - " (2060, 10): 2.8441531658172607,\n", - " (2060, 11): 14.562557578086853,\n", - " (2060, 12): 116.68146419525146}},\n", - " 210: {'monthly': {(2060, 1): 312.33860421180725,\n", - " (2060, 2): 112.63404500484467,\n", - " (2060, 3): 92.69208681583405,\n", - " (2060, 4): 49.1583708524704,\n", - " (2060, 5): 5.880947232246399,\n", - " (2060, 6): 6.7379865646362305,\n", - " (2060, 7): 4.303999423980713,\n", - " (2060, 8): 2.47005558013916,\n", - " (2060, 9): 1.2781932353973389,\n", - " (2060, 10): 2.8441531658172607,\n", - " (2060, 11): 17.439926505088806,\n", - " (2060, 12): 174.97681558132172},\n", - " 'window': {(2060, 1): 94.97287082672119,\n", - " (2060, 2): 41.00346827507019,\n", - " (2060, 3): 30.382957458496094,\n", - " (2060, 4): 43.245131850242615,\n", - " (2060, 5): 3.4205514192581177,\n", - " (2060, 6): 3.8782328367233276,\n", - " (2060, 7): 2.9877573251724243,\n", - " (2060, 8): 2.47005558013916,\n", - " (2060, 9): 1.2781932353973389,\n", - " (2060, 10): 2.8441531658172607,\n", - " (2060, 11): 12.031814694404602,\n", - " (2060, 12): 111.06949043273926}},\n", - " 211: {'monthly': {(2060, 1): 339.6903109550476,\n", - " (2060, 2): 127.5163745880127,\n", - " (2060, 3): 100.5117267370224,\n", - " (2060, 4): 51.043524384498596,\n", - " (2060, 5): 6.864469647407532,\n", - " (2060, 6): 6.7379865646362305,\n", - " (2060, 7): 4.303999423980713,\n", - " (2060, 8): 3.5301421880722046,\n", - " (2060, 9): 1.2781932353973389,\n", - " (2060, 10): 2.8441531658172607,\n", - " (2060, 11): 17.86720848083496,\n", - " (2060, 12): 196.97343349456787},\n", - " 'window': {(2060, 1): 98.20476627349854,\n", - " (2060, 2): 46.17201614379883,\n", - " (2060, 3): 29.47404670715332,\n", - " (2060, 4): 42.88674521446228,\n", - " (2060, 5): 3.656379222869873,\n", - " (2060, 6): 3.8782328367233276,\n", - " (2060, 7): 2.9877573251724243,\n", - " (2060, 8): 2.47005558013916,\n", - " (2060, 9): 1.2781932353973389,\n", - " (2060, 10): 2.8441531658172607,\n", - " (2060, 11): 12.134162068367004,\n", - " (2060, 12): 130.85356044769287}},\n", - " 212: {'monthly': {(2060, 1): 431.61327600479126,\n", - " (2060, 2): 188.59613239765167,\n", - " (2060, 3): 137.7254695892334,\n", - " (2060, 4): 66.75317943096161,\n", - " (2060, 5): 6.825161099433899,\n", - " (2060, 6): 8.124030947685242,\n", - " (2060, 7): 4.303999423980713,\n", - " (2060, 8): 2.47005558013916,\n", - " (2060, 9): 1.2781932353973389,\n", - " (2060, 10): 2.8441531658172607,\n", - " (2060, 11): 22.921685457229614,\n", - " (2060, 12): 231.395303606987},\n", - " 'window': {(2060, 1): 114.23321151733398,\n", - " (2060, 2): 58.063926696777344,\n", - " (2060, 3): 36.798505783081055,\n", - " (2060, 4): 58.38405358791351,\n", - " (2060, 5): 3.8743900060653687,\n", - " (2060, 6): 4.051278471946716,\n", - " (2060, 7): 2.9877573251724243,\n", - " (2060, 8): 2.47005558013916,\n", - " (2060, 9): 1.2781932353973389,\n", - " (2060, 10): 2.8441531658172607,\n", - " (2060, 11): 16.556212067604065,\n", - " (2060, 12): 148.9920539855957}},\n", - " 213: {'monthly': {(2060, 1): 560.08085501194,\n", - " (2060, 2): 228.38406026363373,\n", - " (2060, 3): 160.24936997890472,\n", - " (2060, 4): 114.744136095047,\n", - " (2060, 5): 12.626690745353699,\n", - " (2060, 6): 6.740338921546936,\n", - " (2060, 7): 5.783263087272644,\n", - " (2060, 8): 2.5208728313446045,\n", - " (2060, 9): 1.3040574789047241,\n", - " (2060, 10): 4.509192705154419,\n", - " (2060, 11): 24.796844005584717,\n", - " (2060, 12): 256.78797590732574},\n", - " 'window': {(2060, 1): 147.42227172851562,\n", - " (2060, 2): 65.89814758300781,\n", - " (2060, 3): 45.38749933242798,\n", - " (2060, 4): 96.15527868270874,\n", - " (2060, 5): 5.114237546920776,\n", - " (2060, 6): 3.875940203666687,\n", - " (2060, 7): 2.9816426038742065,\n", - " (2060, 8): 2.5208728313446045,\n", - " (2060, 9): 1.3040574789047241,\n", - " (2060, 10): 4.509192705154419,\n", - " (2060, 11): 17.626189351081848,\n", - " (2060, 12): 136.5290937423706}},\n", - " 214: {'monthly': {(2060, 1): 570.5007348060608,\n", - " (2060, 2): 245.41159772872925,\n", - " (2060, 3): 221.0741925239563,\n", - " (2060, 4): 146.90728163719177,\n", - " (2060, 5): 17.0137939453125,\n", - " (2060, 6): 8.910274982452393,\n", - " (2060, 7): 4.341799378395081,\n", - " (2060, 8): 2.5208728313446045,\n", - " (2060, 9): 1.3040574789047241,\n", - " (2060, 10): 3.930637240409851,\n", - " (2060, 11): 39.84182620048523,\n", - " (2060, 12): 331.7657104730606},\n", - " 'window': {(2060, 1): 154.35585594177246,\n", - " (2060, 2): 75.85742902755737,\n", - " (2060, 3): 61.57986831665039,\n", - " (2060, 4): 124.91766285896301,\n", - " (2060, 5): 6.675601363182068,\n", - " (2060, 6): 4.652658820152283,\n", - " (2060, 7): 2.9959813356399536,\n", - " (2060, 8): 2.5208728313446045,\n", - " (2060, 9): 1.3040574789047241,\n", - " (2060, 10): 3.930637240409851,\n", - " (2060, 11): 27.180907130241394,\n", - " (2060, 12): 185.6527214050293}},\n", - " 215: {'monthly': {(2060, 1): 592.0124859809875,\n", - " (2060, 2): 266.955451130867,\n", - " (2060, 3): 301.03673708438873,\n", - " (2060, 4): 135.37293779850006,\n", - " (2060, 5): 15.580661654472351,\n", - " (2060, 6): 6.740338921546936,\n", - " (2060, 7): 5.586045622825623,\n", - " (2060, 8): 2.5208728313446045,\n", - " (2060, 9): 3.8930758237838745,\n", - " (2060, 10): 5.158972263336182,\n", - " (2060, 11): 51.13579261302948,\n", - " (2060, 12): 398.3176393508911},\n", - " 'window': {(2060, 1): 173.71811485290527,\n", - " (2060, 2): 94.03275728225708,\n", - " (2060, 3): 81.99207592010498,\n", - " (2060, 4): 110.35845494270325,\n", - " (2060, 5): 6.550917267799377,\n", - " (2060, 6): 3.875940203666687,\n", - " (2060, 7): 2.9816426038742065,\n", - " (2060, 8): 2.5208728313446045,\n", - " (2060, 9): 2.5890183448791504,\n", - " (2060, 10): 3.930637240409851,\n", - " (2060, 11): 36.346835136413574,\n", - " (2060, 12): 219.26538467407227}},\n", - " 216: {'monthly': {(2060, 1): 535.2144050598145,\n", - " (2060, 2): 246.20839023590088,\n", - " (2060, 3): 261.7204682826996,\n", - " (2060, 4): 97.08268022537231,\n", - " (2060, 5): 18.983394265174866,\n", - " (2060, 6): 6.740338921546936,\n", - " (2060, 7): 7.290918946266174,\n", - " (2060, 8): 2.5208728313446045,\n", - " (2060, 9): 1.3040574789047241,\n", - " (2060, 10): 7.239003777503967,\n", - " (2060, 11): 73.25291740894318,\n", - " (2060, 12): 348.32166397571564},\n", - " 'window': {(2060, 1): 176.55512046813965,\n", - " (2060, 2): 87.76384735107422,\n", - " (2060, 3): 77.94848442077637,\n", - " (2060, 4): 73.33860921859741,\n", - " (2060, 5): 11.248322010040283,\n", - " (2060, 6): 3.875940203666687,\n", - " (2060, 7): 4.309276342391968,\n", - " (2060, 8): 2.5208728313446045,\n", - " (2060, 9): 1.3040574789047241,\n", - " (2060, 10): 5.073935866355896,\n", - " (2060, 11): 42.673322916030884,\n", - " (2060, 12): 165.11110496520996}},\n", - " 217: {'monthly': {(2060, 1): 299.23923110961914,\n", - " (2060, 2): 227.7969651222229,\n", - " (2060, 3): 174.45155811309814,\n", - " (2060, 4): 45.99983096122742,\n", - " (2060, 5): 16.499038457870483,\n", - " (2060, 6): 8.858599305152893,\n", - " (2060, 7): 8.08249282836914,\n", - " (2060, 8): 10.12415862083435,\n", - " (2060, 9): 3.513139009475708,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 48.05096089839935,\n", - " (2060, 12): 278.22852194309235},\n", - " 'window': {(2060, 1): 73.60547924041748,\n", - " (2060, 2): 59.448079109191895,\n", - " (2060, 3): 52.73848485946655,\n", - " (2060, 4): 35.29727387428284,\n", - " (2060, 5): 6.989143013954163,\n", - " (2060, 6): 4.5852038860321045,\n", - " (2060, 7): 3.630094051361084,\n", - " (2060, 8): 6.248715043067932,\n", - " (2060, 9): 1.2823882102966309,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 33.88631582260132,\n", - " (2060, 12): 95.1023759841919}},\n", - " 218: {'monthly': {(2060, 1): 289.50220704078674,\n", - " (2060, 2): 218.49730587005615,\n", - " (2060, 3): 130.61024844646454,\n", - " (2060, 4): 38.71856141090393,\n", - " (2060, 5): 18.914740920066833,\n", - " (2060, 6): 9.58632779121399,\n", - " (2060, 7): 8.544598460197449,\n", - " (2060, 8): 7.7478896379470825,\n", - " (2060, 9): 3.513139009475708,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 32.49875295162201,\n", - " (2060, 12): 243.79526031017303},\n", - " 'window': {(2060, 1): 76.9999828338623,\n", - " (2060, 2): 56.377092361450195,\n", - " (2060, 3): 43.79261302947998,\n", - " (2060, 4): 30.32246160507202,\n", - " (2060, 5): 9.237234115600586,\n", - " (2060, 6): 4.6812664270401,\n", - " (2060, 7): 3.630094051361084,\n", - " (2060, 8): 5.4206894636154175,\n", - " (2060, 9): 1.2823882102966309,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 21.93886363506317,\n", - " (2060, 12): 95.95066833496094}},\n", - " 219: {'monthly': {(2060, 1): 316.3593189716339,\n", - " (2060, 2): 244.01118993759155,\n", - " (2060, 3): 139.14010512828827,\n", - " (2060, 4): 44.26783847808838,\n", - " (2060, 5): 20.032697558403015,\n", - " (2060, 6): 11.801868438720703,\n", - " (2060, 7): 7.5562556982040405,\n", - " (2060, 8): 7.9621652364730835,\n", - " (2060, 9): 3.513139009475708,\n", - " (2060, 10): 1.2815990447998047,\n", - " (2060, 11): 33.96522772312164,\n", - " (2060, 12): 245.57814824581146},\n", - " 'window': {(2060, 1): 89.2182207107544,\n", - " (2060, 2): 64.64538669586182,\n", - " (2060, 3): 48.77815103530884,\n", - " (2060, 4): 33.35209035873413,\n", - " (2060, 5): 10.126321077346802,\n", - " (2060, 6): 4.871135711669922,\n", - " (2060, 7): 3.630094051361084,\n", - " (2060, 8): 5.6349650621414185,\n", - " (2060, 9): 1.2823882102966309,\n", - " (2060, 10): 1.2815990447998047,\n", - " (2060, 11): 22.397515535354614,\n", - " (2060, 12): 99.31969451904297}},\n", - " 220: {'monthly': {(2060, 1): 328.3621156215668,\n", - " (2060, 2): 281.94035959243774,\n", - " (2060, 3): 144.09836292266846,\n", - " (2060, 4): 58.62090528011322,\n", - " (2060, 5): 20.9795583486557,\n", - " (2060, 6): 10.177258849143982,\n", - " (2060, 7): 7.665494322776794,\n", - " (2060, 8): 7.733073711395264,\n", - " (2060, 9): 3.513139009475708,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 31.335688591003418,\n", - " (2060, 12): 230.97580814361572},\n", - " 'window': {(2060, 1): 102.92852592468262,\n", - " (2060, 2): 68.64352035522461,\n", - " (2060, 3): 52.10161828994751,\n", - " (2060, 4): 45.20348024368286,\n", - " (2060, 5): 9.880962371826172,\n", - " (2060, 6): 4.884138345718384,\n", - " (2060, 7): 3.630094051361084,\n", - " (2060, 8): 5.405873537063599,\n", - " (2060, 9): 1.2823882102966309,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 21.88038969039917,\n", - " (2060, 12): 95.38702964782715}},\n", - " 221: {'monthly': {(2060, 1): 316.5495318174362,\n", - " (2060, 2): 163.79652106761932,\n", - " (2060, 3): 159.7055070400238,\n", - " (2060, 4): 45.158668518066406,\n", - " (2060, 5): 2.0351860523223877,\n", - " (2060, 6): 5.834451675415039,\n", - " (2060, 7): 4.537563681602478,\n", - " (2060, 8): 1.1109524965286255,\n", - " (2060, 9): 2.787585973739624,\n", - " (2060, 10): 2.6299314498901367,\n", - " (2060, 11): 41.93499219417572,\n", - " (2060, 12): 199.3920089006424},\n", - " 'window': {(2060, 1): 97.82756423950195,\n", - " (2060, 2): 59.047348976135254,\n", - " (2060, 3): 57.52852249145508,\n", - " (2060, 4): 33.99998939037323,\n", - " (2060, 5): 2.0351860523223877,\n", - " (2060, 6): 4.728754878044128,\n", - " (2060, 7): 3.5211403369903564,\n", - " (2060, 8): 1.1109524965286255,\n", - " (2060, 9): 2.787585973739624,\n", - " (2060, 10): 2.6299314498901367,\n", - " (2060, 11): 20.400492906570435,\n", - " (2060, 12): 91.54469203948975}},\n", - " 222: {'monthly': {(2060, 1): 286.7188801765442,\n", - " (2060, 2): 193.4387217760086,\n", - " (2060, 3): 114.55826258659363,\n", - " (2060, 4): 53.32284498214722,\n", - " (2060, 5): 5.244473934173584,\n", - " (2060, 6): 7.754246950149536,\n", - " (2060, 7): 7.597278833389282,\n", - " (2060, 8): 1.6667790412902832,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.7639505863189697,\n", - " (2060, 11): 22.846080422401428,\n", - " (2060, 12): 232.46982181072235},\n", - " 'window': {(2060, 1): 83.03756904602051,\n", - " (2060, 2): 55.12324142456055,\n", - " (2060, 3): 39.82958793640137,\n", - " (2060, 4): 42.08452880382538,\n", - " (2060, 5): 2.2562087774276733,\n", - " (2060, 6): 5.419857025146484,\n", - " (2060, 7): 2.8089256286621094,\n", - " (2060, 8): 1.6667790412902832,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 2.6418973207473755,\n", - " (2060, 11): 13.114137291908264,\n", - " (2060, 12): 147.37273597717285}},\n", - " 223: {'monthly': {(2060, 1): 247.9439992904663,\n", - " (2060, 2): 156.15332400798798,\n", - " (2060, 3): 98.20893692970276,\n", - " (2060, 4): 56.82243239879608,\n", - " (2060, 5): 5.244473934173584,\n", - " (2060, 6): 8.037908554077148,\n", - " (2060, 7): 7.597278833389282,\n", - " (2060, 8): 1.6667790412902832,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.7639505863189697,\n", - " (2060, 11): 21.051292896270752,\n", - " (2060, 12): 191.4189258813858},\n", - " 'window': {(2060, 1): 75.78982639312744,\n", - " (2060, 2): 45.23530626296997,\n", - " (2060, 3): 34.52584457397461,\n", - " (2060, 4): 45.628764390945435,\n", - " (2060, 5): 2.2562087774276733,\n", - " (2060, 6): 5.703518629074097,\n", - " (2060, 7): 2.8089256286621094,\n", - " (2060, 8): 1.6667790412902832,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 2.6418973207473755,\n", - " (2060, 11): 11.364859223365784,\n", - " (2060, 12): 123.57270050048828}},\n", - " 224: {'monthly': {(2060, 1): 272.5575497150421,\n", - " (2060, 2): 172.36112523078918,\n", - " (2060, 3): 104.88159656524658,\n", - " (2060, 4): 70.40344715118408,\n", - " (2060, 5): 8.336728692054749,\n", - " (2060, 6): 9.49299156665802,\n", - " (2060, 7): 9.842581510543823,\n", - " (2060, 8): 1.6667790412902832,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.7639505863189697,\n", - " (2060, 11): 24.61869478225708,\n", - " (2060, 12): 199.1220189332962},\n", - " 'window': {(2060, 1): 80.43617057800293,\n", - " (2060, 2): 49.4808144569397,\n", - " (2060, 3): 31.291868686676025,\n", - " (2060, 4): 59.428306341171265,\n", - " (2060, 5): 4.102593302726746,\n", - " (2060, 6): 5.779909133911133,\n", - " (2060, 7): 3.5565969944000244,\n", - " (2060, 8): 1.6667790412902832,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 2.6418973207473755,\n", - " (2060, 11): 15.900068998336792,\n", - " (2060, 12): 129.50356674194336}},\n", - " 225: {'monthly': {(2060, 1): 351.41291522979736,\n", - " (2060, 2): 231.03395235538483,\n", - " (2060, 3): 141.12008368968964,\n", - " (2060, 4): 93.5483627319336,\n", - " (2060, 5): 8.349603176116943,\n", - " (2060, 6): 11.357394695281982,\n", - " (2060, 7): 7.597278833389282,\n", - " (2060, 8): 2.6940572261810303,\n", - " (2060, 9): 1.2371759414672852,\n", - " (2060, 10): 5.055647253990173,\n", - " (2060, 11): 52.93451976776123,\n", - " (2060, 12): 254.34065425395966},\n", - " 'window': {(2060, 1): 104.6001615524292,\n", - " (2060, 2): 72.07115459442139,\n", - " (2060, 3): 36.80739879608154,\n", - " (2060, 4): 73.103018283844,\n", - " (2060, 5): 4.47337281703949,\n", - " (2060, 6): 6.281670808792114,\n", - " (2060, 7): 2.8089256286621094,\n", - " (2060, 8): 2.6940572261810303,\n", - " (2060, 9): 1.2371759414672852,\n", - " (2060, 10): 3.721748113632202,\n", - " (2060, 11): 34.14424800872803,\n", - " (2060, 12): 168.70030212402344}},\n", - " 226: {'monthly': {(2060, 1): 404.3257521390915,\n", - " (2060, 2): 291.55276238918304,\n", - " (2060, 3): 184.43806779384613,\n", - " (2060, 4): 121.93401885032654,\n", - " (2060, 5): 13.750080943107605,\n", - " (2060, 6): 12.741978406906128,\n", - " (2060, 7): 9.108573913574219,\n", - " (2060, 8): 3.1460007429122925,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 6.056826114654541,\n", - " (2060, 11): 53.4703232049942,\n", - " (2060, 12): 282.8678011894226},\n", - " 'window': {(2060, 1): 99.69723606109619,\n", - " (2060, 2): 79.2328634262085,\n", - " (2060, 3): 57.22185754776001,\n", - " (2060, 4): 93.90196561813354,\n", - " (2060, 5): 5.878618955612183,\n", - " (2060, 6): 5.01056170463562,\n", - " (2060, 7): 2.8617007732391357,\n", - " (2060, 8): 3.1460007429122925,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.707000970840454,\n", - " (2060, 11): 27.39746856689453,\n", - " (2060, 12): 167.23110389709473}},\n", - " 227: {'monthly': {(2060, 1): 424.14760065078735,\n", - " (2060, 2): 336.88803911209106,\n", - " (2060, 3): 258.50537502765656,\n", - " (2060, 4): 172.41662681102753,\n", - " (2060, 5): 15.835752487182617,\n", - " (2060, 6): 12.32256555557251,\n", - " (2060, 7): 11.070789217948914,\n", - " (2060, 8): 1.5907464027404785,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 4.837348818778992,\n", - " (2060, 11): 57.38819086551666,\n", - " (2060, 12): 391.0909662246704},\n", - " 'window': {(2060, 1): 105.94361686706543,\n", - " (2060, 2): 101.13309860229492,\n", - " (2060, 3): 74.6061143875122,\n", - " (2060, 4): 140.29170942306519,\n", - " (2060, 5): 7.261408090591431,\n", - " (2060, 6): 5.083161354064941,\n", - " (2060, 7): 2.8617007732391357,\n", - " (2060, 8): 1.5907464027404785,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.707000970840454,\n", - " (2060, 11): 31.578346014022827,\n", - " (2060, 12): 229.45904922485352}},\n", - " 228: {'monthly': {(2060, 1): 391.6374365091324,\n", - " (2060, 2): 314.73097705841064,\n", - " (2060, 3): 297.54196870326996,\n", - " (2060, 4): 168.40616047382355,\n", - " (2060, 5): 15.842498660087585,\n", - " (2060, 6): 12.187280058860779,\n", - " (2060, 7): 7.70267653465271,\n", - " (2060, 8): 3.832448720932007,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 4.837348818778992,\n", - " (2060, 11): 68.4288477897644,\n", - " (2060, 12): 381.85155069828033},\n", - " 'window': {(2060, 1): 101.00914859771729,\n", - " (2060, 2): 105.78291988372803,\n", - " (2060, 3): 76.59458065032959,\n", - " (2060, 4): 133.71015882492065,\n", - " (2060, 5): 6.142821550369263,\n", - " (2060, 6): 5.44087278842926,\n", - " (2060, 7): 2.8617007732391357,\n", - " (2060, 8): 3.832448720932007,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.707000970840454,\n", - " (2060, 11): 32.48719310760498,\n", - " (2060, 12): 218.47637939453125}},\n", - " 229: {'monthly': {(2060, 1): 394.53993690013885,\n", - " (2060, 2): 290.93204748630524,\n", - " (2060, 3): 297.9490671157837,\n", - " (2060, 4): 137.76132011413574,\n", - " (2060, 5): 17.58623194694519,\n", - " (2060, 6): 12.519333839416504,\n", - " (2060, 7): 7.70267653465271,\n", - " (2060, 8): 8.05724847316742,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 7.717754125595093,\n", - " (2060, 11): 88.24982273578644,\n", - " (2060, 12): 366.9570279121399},\n", - " 'window': {(2060, 1): 92.29856777191162,\n", - " (2060, 2): 91.99999618530273,\n", - " (2060, 3): 70.66948556900024,\n", - " (2060, 4): 106.14171385765076,\n", - " (2060, 5): 7.447606325149536,\n", - " (2060, 6): 5.293558120727539,\n", - " (2060, 7): 2.8617007732391357,\n", - " (2060, 8): 8.05724847316742,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.707000970840454,\n", - " (2060, 11): 43.663733959198,\n", - " (2060, 12): 192.93284797668457}},\n", - " 230: {'monthly': {(2060, 1): 325.4231685400009,\n", - " (2060, 2): 306.81351351737976,\n", - " (2060, 3): 225.4608520269394,\n", - " (2060, 4): 59.3400958776474,\n", - " (2060, 5): 9.716264843940735,\n", - " (2060, 6): 10.85846197605133,\n", - " (2060, 7): 3.648893117904663,\n", - " (2060, 8): 8.527151346206665,\n", - " (2060, 9): 6.609716892242432,\n", - " (2060, 10): 2.67285418510437,\n", - " (2060, 11): 55.30030357837677,\n", - " (2060, 12): 260.83774530887604},\n", - " 'window': {(2060, 1): 76.8566312789917,\n", - " (2060, 2): 74.82472324371338,\n", - " (2060, 3): 57.83366680145264,\n", - " (2060, 4): 44.90087163448334,\n", - " (2060, 5): 4.95712149143219,\n", - " (2060, 6): 5.526522517204285,\n", - " (2060, 7): 1.3729429244995117,\n", - " (2060, 8): 7.432196736335754,\n", - " (2060, 9): 3.048906087875366,\n", - " (2060, 10): 2.67285418510437,\n", - " (2060, 11): 41.47859859466553,\n", - " (2060, 12): 84.96430206298828}},\n", - " 231: {'monthly': {(2060, 1): 279.76616859436035,\n", - " (2060, 2): 240.620499253273,\n", - " (2060, 3): 170.5444277524948,\n", - " (2060, 4): 41.87413680553436,\n", - " (2060, 5): 7.7131431102752686,\n", - " (2060, 6): 8.745586633682251,\n", - " (2060, 7): 4.834814429283142,\n", - " (2060, 8): 7.34782874584198,\n", - " (2060, 9): 6.20304548740387,\n", - " (2060, 10): 2.064605236053467,\n", - " (2060, 11): 34.69075286388397,\n", - " (2060, 12): 226.21916496753693},\n", - " 'window': {(2060, 1): 65.52560520172119,\n", - " (2060, 2): 58.64149570465088,\n", - " (2060, 3): 48.39522171020508,\n", - " (2060, 4): 32.420092940330505,\n", - " (2060, 5): 2.9581578969955444,\n", - " (2060, 6): 3.1927260160446167,\n", - " (2060, 7): 2.1963284015655518,\n", - " (2060, 8): 6.252874135971069,\n", - " (2060, 9): 2.59496009349823,\n", - " (2060, 10): 1.056647777557373,\n", - " (2060, 11): 27.126652598381042,\n", - " (2060, 12): 91.86338710784912}},\n", - " 232: {'monthly': {(2060, 1): 310.4474079608917,\n", - " (2060, 2): 256.3540713787079,\n", - " (2060, 3): 179.7001210451126,\n", - " (2060, 4): 45.29095137119293,\n", - " (2060, 5): 7.82551634311676,\n", - " (2060, 6): 10.299569129943848,\n", - " (2060, 7): 3.648893117904663,\n", - " (2060, 8): 7.425516843795776,\n", - " (2060, 9): 7.7524837255477905,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 38.891292452812195,\n", - " (2060, 12): 266.26769161224365},\n", - " 'window': {(2060, 1): 75.4096326828003,\n", - " (2060, 2): 62.90841579437256,\n", - " (2060, 3): 58.56253623962402,\n", - " (2060, 4): 32.462616324424744,\n", - " (2060, 5): 2.780347466468811,\n", - " (2060, 6): 4.282000184059143,\n", - " (2060, 7): 1.3729429244995117,\n", - " (2060, 8): 6.330562233924866,\n", - " (2060, 9): 2.954715847969055,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 28.068976879119873,\n", - " (2060, 12): 126.39871215820312}},\n", - " 233: {'monthly': {(2060, 1): 330.635155916214,\n", - " (2060, 2): 268.0582854747772,\n", - " (2060, 3): 182.37564170360565,\n", - " (2060, 4): 49.958321928977966,\n", - " (2060, 5): 10.945462703704834,\n", - " (2060, 6): 8.447560548782349,\n", - " (2060, 7): 3.648893117904663,\n", - " (2060, 8): 8.245688199996948,\n", - " (2060, 9): 8.436866760253906,\n", - " (2060, 10): 3.5996344089508057,\n", - " (2060, 11): 42.74925100803375,\n", - " (2060, 12): 284.7328267097473},\n", - " 'window': {(2060, 1): 77.71791648864746,\n", - " (2060, 2): 63.24791717529297,\n", - " (2060, 3): 60.51531648635864,\n", - " (2060, 4): 38.77171325683594,\n", - " (2060, 5): 3.8871521949768066,\n", - " (2060, 6): 3.1927260160446167,\n", - " (2060, 7): 1.3729429244995117,\n", - " (2060, 8): 6.055496096611023,\n", - " (2060, 9): 3.47173273563385,\n", - " (2060, 10): 2.5123268365859985,\n", - " (2060, 11): 33.02826249599457,\n", - " (2060, 12): 140.3540096282959}},\n", - " 234: {'monthly': {(2060, 1): 329.48289012908936,\n", - " (2060, 2): 177.70654296875,\n", - " (2060, 3): 166.2012026309967,\n", - " (2060, 4): 57.19308960437775,\n", - " (2060, 5): 2.0351860523223877,\n", - " (2060, 6): 5.834451675415039,\n", - " (2060, 7): 4.537563681602478,\n", - " (2060, 8): 1.1109524965286255,\n", - " (2060, 9): 2.7190566062927246,\n", - " (2060, 10): 5.366301655769348,\n", - " (2060, 11): 50.808825731277466,\n", - " (2060, 12): 179.24560129642487},\n", - " 'window': {(2060, 1): 94.52604007720947,\n", - " (2060, 2): 68.32741594314575,\n", - " (2060, 3): 61.44065046310425,\n", - " (2060, 4): 43.57875609397888,\n", - " (2060, 5): 2.0351860523223877,\n", - " (2060, 6): 4.728754878044128,\n", - " (2060, 7): 3.5211403369903564,\n", - " (2060, 8): 1.1109524965286255,\n", - " (2060, 9): 2.7190566062927246,\n", - " (2060, 10): 4.0476274490356445,\n", - " (2060, 11): 23.255940198898315,\n", - " (2060, 12): 76.14838409423828}},\n", - " 235: {'monthly': {(2060, 1): 296.3386503458023,\n", - " (2060, 2): 204.6965845823288,\n", - " (2060, 3): 122.31154131889343,\n", - " (2060, 4): 67.33493459224701,\n", - " (2060, 5): 5.244473934173584,\n", - " (2060, 6): 7.433748722076416,\n", - " (2060, 7): 7.597278833389282,\n", - " (2060, 8): 1.6667790412902832,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.7639505863189697,\n", - " (2060, 11): 24.424567341804504,\n", - " (2060, 12): 244.18359351158142},\n", - " 'window': {(2060, 1): 77.57512092590332,\n", - " (2060, 2): 55.930354833602905,\n", - " (2060, 3): 45.092313289642334,\n", - " (2060, 4): 53.75095295906067,\n", - " (2060, 5): 2.2562087774276733,\n", - " (2060, 6): 5.099358797073364,\n", - " (2060, 7): 2.8089256286621094,\n", - " (2060, 8): 1.6667790412902832,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 2.6418973207473755,\n", - " (2060, 11): 13.329374074935913,\n", - " (2060, 12): 161.9382839202881}},\n", - " 236: {'monthly': {(2060, 1): 247.61055839061737,\n", - " (2060, 2): 153.87586796283722,\n", - " (2060, 3): 100.48477125167847,\n", - " (2060, 4): 85.11459863185883,\n", - " (2060, 5): 5.183251619338989,\n", - " (2060, 6): 7.871787905693054,\n", - " (2060, 7): 7.597278833389282,\n", - " (2060, 8): 1.6667790412902832,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.7639505863189697,\n", - " (2060, 11): 29.067933678627014,\n", - " (2060, 12): 206.28848350048065},\n", - " 'window': {(2060, 1): 68.48639297485352,\n", - " (2060, 2): 45.42704391479492,\n", - " (2060, 3): 38.54718255996704,\n", - " (2060, 4): 73.49638760089874,\n", - " (2060, 5): 2.1870758533477783,\n", - " (2060, 6): 5.537397980690002,\n", - " (2060, 7): 2.8089256286621094,\n", - " (2060, 8): 1.6667790412902832,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 2.6418973207473755,\n", - " (2060, 11): 18.089956402778625,\n", - " (2060, 12): 135.71497535705566}},\n", - " 237: {'monthly': {(2060, 1): 267.68347918987274,\n", - " (2060, 2): 176.5481960773468,\n", - " (2060, 3): 122.51536536216736,\n", - " (2060, 4): 118.04493815889334,\n", - " (2060, 5): 9.409947514533997,\n", - " (2060, 6): 11.638230562210083,\n", - " (2060, 7): 7.597278833389282,\n", - " (2060, 8): 3.334563970565796,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.856133222579956,\n", - " (2060, 11): 29.462121844291687,\n", - " (2060, 12): 207.65783154964447},\n", - " 'window': {(2060, 1): 72.5063943862915,\n", - " (2060, 2): 53.34857749938965,\n", - " (2060, 3): 36.115291595458984,\n", - " (2060, 4): 103.33169145574546,\n", - " (2060, 5): 3.925763726234436,\n", - " (2060, 6): 5.700016617774963,\n", - " (2060, 7): 2.8089256286621094,\n", - " (2060, 8): 3.334563970565796,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 2.6418973207473755,\n", - " (2060, 11): 17.34905469417572,\n", - " (2060, 12): 134.74011039733887}},\n", - " 238: {'monthly': {(2060, 1): 341.4727609157562,\n", - " (2060, 2): 253.2848688364029,\n", - " (2060, 3): 148.2226116657257,\n", - " (2060, 4): 141.97987364054177,\n", - " (2060, 5): 12.885583639144897,\n", - " (2060, 6): 12.489084243774414,\n", - " (2060, 7): 8.660772204399109,\n", - " (2060, 8): 3.266741156578064,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 5.281569242477417,\n", - " (2060, 11): 45.75287580490112,\n", - " (2060, 12): 273.9510484933853},\n", - " 'window': {(2060, 1): 96.84399127960205,\n", - " (2060, 2): 82.39582681655884,\n", - " (2060, 3): 37.528446197509766,\n", - " (2060, 4): 119.47638974905465,\n", - " (2060, 5): 5.670786023139954,\n", - " (2060, 6): 6.460819959640503,\n", - " (2060, 7): 3.872418999671936,\n", - " (2060, 8): 3.266741156578064,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.1460890769958496,\n", - " (2060, 11): 29.791865587234497,\n", - " (2060, 12): 178.42082405090332}},\n", - " 239: {'monthly': {(2060, 1): 425.31383204460144,\n", - " (2060, 2): 307.0801776647568,\n", - " (2060, 3): 215.91744899749756,\n", - " (2060, 4): 159.03998637199402,\n", - " (2060, 5): 19.209930181503296,\n", - " (2060, 6): 12.213683009147644,\n", - " (2060, 7): 7.70267653465271,\n", - " (2060, 8): 2.5974701642990112,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 6.935801267623901,\n", - " (2060, 11): 62.37401735782623,\n", - " (2060, 12): 316.299595952034},\n", - " 'window': {(2060, 1): 108.20076560974121,\n", - " (2060, 2): 86.31406879425049,\n", - " (2060, 3): 63.40322780609131,\n", - " (2060, 4): 123.7771782875061,\n", - " (2060, 5): 7.926289200782776,\n", - " (2060, 6): 5.216951251029968,\n", - " (2060, 7): 2.8617007732391357,\n", - " (2060, 8): 1.5907464027404785,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.707000970840454,\n", - " (2060, 11): 37.7338330745697,\n", - " (2060, 12): 187.06102180480957}},\n", - " 240: {'monthly': {(2060, 1): 463.26687002182007,\n", - " (2060, 2): 342.36477756500244,\n", - " (2060, 3): 305.71066212654114,\n", - " (2060, 4): 224.79961693286896,\n", - " (2060, 5): 19.557199120521545,\n", - " (2060, 6): 15.021350145339966,\n", - " (2060, 7): 8.982990384101868,\n", - " (2060, 8): 2.9745620489120483,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 6.303921818733215,\n", - " (2060, 11): 69.51023995876312,\n", - " (2060, 12): 441.00643241405487},\n", - " 'window': {(2060, 1): 126.40459251403809,\n", - " (2060, 2): 103.67523765563965,\n", - " (2060, 3): 84.67656135559082,\n", - " (2060, 4): 184.36490631103516,\n", - " (2060, 5): 8.536141633987427,\n", - " (2060, 6): 6.812103033065796,\n", - " (2060, 7): 2.8617007732391357,\n", - " (2060, 8): 2.9745620489120483,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 4.1280198097229,\n", - " (2060, 11): 41.707765340805054,\n", - " (2060, 12): 260.61883544921875}},\n", - " 241: {'monthly': {(2060, 1): 402.0193291902542,\n", - " (2060, 2): 296.8126564025879,\n", - " (2060, 3): 289.56838524341583,\n", - " (2060, 4): 197.0525177717209,\n", - " (2060, 5): 16.974929213523865,\n", - " (2060, 6): 13.350624680519104,\n", - " (2060, 7): 7.70267653465271,\n", - " (2060, 8): 4.738208532333374,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 5.858602523803711,\n", - " (2060, 11): 69.21943938732147,\n", - " (2060, 12): 377.5272057056427},\n", - " 'window': {(2060, 1): 102.10392570495605,\n", - " (2060, 2): 102.95262336730957,\n", - " (2060, 3): 79.70628833770752,\n", - " (2060, 4): 159.22400856018066,\n", - " (2060, 5): 7.46962571144104,\n", - " (2060, 6): 5.980738520622253,\n", - " (2060, 7): 2.8617007732391357,\n", - " (2060, 8): 4.738208532333374,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 4.728254675865173,\n", - " (2060, 11): 39.4121949672699,\n", - " (2060, 12): 228.7029514312744}},\n", - " 242: {'monthly': {(2060, 1): 366.1567784547806,\n", - " (2060, 2): 254.57566106319427,\n", - " (2060, 3): 273.58119785785675,\n", - " (2060, 4): 167.81970977783203,\n", - " (2060, 5): 16.022366881370544,\n", - " (2060, 6): 12.03289246559143,\n", - " (2060, 7): 7.70267653465271,\n", - " (2060, 8): 8.596846103668213,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 5.8618035316467285,\n", - " (2060, 11): 75.47713601589203,\n", - " (2060, 12): 331.1759043931961},\n", - " 'window': {(2060, 1): 93.7931957244873,\n", - " (2060, 2): 84.20943641662598,\n", - " (2060, 3): 69.2587194442749,\n", - " (2060, 4): 135.7114713191986,\n", - " (2060, 5): 5.4399741888046265,\n", - " (2060, 6): 5.633728861808777,\n", - " (2060, 7): 2.8617007732391357,\n", - " (2060, 8): 8.596846103668213,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.707000970840454,\n", - " (2060, 11): 42.46599054336548,\n", - " (2060, 12): 188.34451866149902}},\n", - " 243: {'monthly': {(2060, 1): 330.1261829137802,\n", - " (2060, 2): 312.0205010175705,\n", - " (2060, 3): 221.63809299468994,\n", - " (2060, 4): 82.5235390663147,\n", - " (2060, 5): 9.512797832489014,\n", - " (2060, 6): 8.598510265350342,\n", - " (2060, 7): 4.7795116901397705,\n", - " (2060, 8): 9.223830699920654,\n", - " (2060, 9): 7.502900958061218,\n", - " (2060, 10): 1.7296664714813232,\n", - " (2060, 11): 50.37690854072571,\n", - " (2060, 12): 238.31440615653992},\n", - " 'window': {(2060, 1): 92.02000141143799,\n", - " (2060, 2): 79.10768032073975,\n", - " (2060, 3): 56.71427536010742,\n", - " (2060, 4): 67.93433034420013,\n", - " (2060, 5): 4.060440301895142,\n", - " (2060, 6): 3.1927260160446167,\n", - " (2060, 7): 2.503561496734619,\n", - " (2060, 8): 8.128876090049744,\n", - " (2060, 9): 2.853169083595276,\n", - " (2060, 10): 1.7296664714813232,\n", - " (2060, 11): 38.16574716567993,\n", - " (2060, 12): 80.51753854751587}},\n", - " 244: {'monthly': {(2060, 1): 279.32066202163696,\n", - " (2060, 2): 251.47896432876587,\n", - " (2060, 3): 153.1331968307495,\n", - " (2060, 4): 67.25873935222626,\n", - " (2060, 5): 7.517054438591003,\n", - " (2060, 6): 6.885195374488831,\n", - " (2060, 7): 4.708090901374817,\n", - " (2060, 8): 7.639653205871582,\n", - " (2060, 9): 6.155770897865295,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 34.86618185043335,\n", - " (2060, 12): 204.75748455524445},\n", - " 'window': {(2060, 1): 82.13380813598633,\n", - " (2060, 2): 62.6193265914917,\n", - " (2060, 3): 44.657164573669434,\n", - " (2060, 4): 58.77636420726776,\n", - " (2060, 5): 2.901818871498108,\n", - " (2060, 6): 3.1927260160446167,\n", - " (2060, 7): 1.3729429244995117,\n", - " (2060, 8): 6.544698596000671,\n", - " (2060, 9): 2.59496009349823,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 26.82891607284546,\n", - " (2060, 12): 84.24661350250244}},\n", - " 245: {'monthly': {(2060, 1): 301.38805961608887,\n", - " (2060, 2): 259.75681042671204,\n", - " (2060, 3): 164.95790255069733,\n", - " (2060, 4): 64.95864868164062,\n", - " (2060, 5): 7.697551608085632,\n", - " (2060, 6): 6.745112180709839,\n", - " (2060, 7): 3.661398768424988,\n", - " (2060, 8): 7.581775188446045,\n", - " (2060, 9): 6.155770897865295,\n", - " (2060, 10): 2.1230400800704956,\n", - " (2060, 11): 36.96739339828491,\n", - " (2060, 12): 238.67562794685364},\n", - " 'window': {(2060, 1): 85.44826221466064,\n", - " (2060, 2): 68.08456039428711,\n", - " (2060, 3): 50.8645133972168,\n", - " (2060, 4): 54.71794354915619,\n", - " (2060, 5): 2.643889307975769,\n", - " (2060, 6): 3.1927260160446167,\n", - " (2060, 7): 1.3854485750198364,\n", - " (2060, 8): 6.486820578575134,\n", - " (2060, 9): 2.59496009349823,\n", - " (2060, 10): 1.1157251596450806,\n", - " (2060, 11): 28.01068949699402,\n", - " (2060, 12): 114.75274562835693}},\n", - " 246: {'monthly': {(2060, 1): 319.3725949525833,\n", - " (2060, 2): 259.0164853334427,\n", - " (2060, 3): 162.13825798034668,\n", - " (2060, 4): 56.38690006732941,\n", - " (2060, 5): 8.581257104873657,\n", - " (2060, 6): 7.009292960166931,\n", - " (2060, 7): 3.6899147033691406,\n", - " (2060, 8): 6.973991870880127,\n", - " (2060, 9): 6.155770897865295,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 37.807841777801514,\n", - " (2060, 12): 247.91688525676727},\n", - " 'window': {(2060, 1): 86.87829113006592,\n", - " (2060, 2): 68.86786365509033,\n", - " (2060, 3): 52.99404239654541,\n", - " (2060, 4): 47.91120707988739,\n", - " (2060, 5): 3.256787061691284,\n", - " (2060, 6): 3.1927260160446167,\n", - " (2060, 7): 1.4139645099639893,\n", - " (2060, 8): 5.879037261009216,\n", - " (2060, 9): 2.59496009349823,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 30.556424021720886,\n", - " (2060, 12): 123.64857006072998}},\n", - " 247: {'monthly': {(2060, 1): 316.4037992954254,\n", - " (2060, 2): 172.68630588054657,\n", - " (2060, 3): 169.24985468387604,\n", - " (2060, 4): 61.7144296169281,\n", - " (2060, 5): 2.0351860523223877,\n", - " (2060, 6): 5.834451675415039,\n", - " (2060, 7): 4.537563681602478,\n", - " (2060, 8): 1.1109524965286255,\n", - " (2060, 9): 2.2230465412139893,\n", - " (2060, 10): 4.3632917404174805,\n", - " (2060, 11): 48.2270085811615,\n", - " (2060, 12): 157.59592390060425},\n", - " 'window': {(2060, 1): 84.7638292312622,\n", - " (2060, 2): 62.61708307266235,\n", - " (2060, 3): 64.19352102279663,\n", - " (2060, 4): 46.108320355415344,\n", - " (2060, 5): 2.0351860523223877,\n", - " (2060, 6): 4.728754878044128,\n", - " (2060, 7): 3.5211403369903564,\n", - " (2060, 8): 1.1109524965286255,\n", - " (2060, 9): 2.2230465412139893,\n", - " (2060, 10): 4.3632917404174805,\n", - " (2060, 11): 23.217742919921875,\n", - " (2060, 12): 62.9211540222168}},\n", - " 248: {'monthly': {(2060, 1): 285.80449759960175,\n", - " (2060, 2): 195.28539776802063,\n", - " (2060, 3): 120.81078243255615,\n", - " (2060, 4): 64.36447370052338,\n", - " (2060, 5): 5.244473934173584,\n", - " (2060, 6): 6.16657829284668,\n", - " (2060, 7): 7.597278833389282,\n", - " (2060, 8): 2.829188823699951,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.7639505863189697,\n", - " (2060, 11): 29.8273983001709,\n", - " (2060, 12): 211.13868474960327},\n", - " 'window': {(2060, 1): 69.67073440551758,\n", - " (2060, 2): 58.55665636062622,\n", - " (2060, 3): 41.07175064086914,\n", - " (2060, 4): 52.802756547927856,\n", - " (2060, 5): 2.2562087774276733,\n", - " (2060, 6): 3.832188367843628,\n", - " (2060, 7): 2.8089256286621094,\n", - " (2060, 8): 2.829188823699951,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 2.6418973207473755,\n", - " (2060, 11): 17.213820338249207,\n", - " (2060, 12): 143.46751594543457}},\n", - " 249: {'monthly': {(2060, 1): 244.27544677257538,\n", - " (2060, 2): 170.03231477737427,\n", - " (2060, 3): 114.86611068248749,\n", - " (2060, 4): 90.7220070362091,\n", - " (2060, 5): 5.321720242500305,\n", - " (2060, 6): 8.562741041183472,\n", - " (2060, 7): 7.597278833389282,\n", - " (2060, 8): 1.6667790412902832,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.7639505863189697,\n", - " (2060, 11): 29.140042901039124,\n", - " (2060, 12): 195.3003660440445},\n", - " 'window': {(2060, 1): 65.2995023727417,\n", - " (2060, 2): 51.21680974960327,\n", - " (2060, 3): 39.4745078086853,\n", - " (2060, 4): 80.56554746627808,\n", - " (2060, 5): 2.3255444765090942,\n", - " (2060, 6): 5.195611119270325,\n", - " (2060, 7): 2.8089256286621094,\n", - " (2060, 8): 1.6667790412902832,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 2.6418973207473755,\n", - " (2060, 11): 18.072838068008423,\n", - " (2060, 12): 124.77197456359863}},\n", - " 250: {'monthly': {(2060, 1): 275.70897912979126,\n", - " (2060, 2): 201.504292845726,\n", - " (2060, 3): 151.56360042095184,\n", - " (2060, 4): 141.47467556144537,\n", - " (2060, 5): 11.306487679481506,\n", - " (2060, 6): 17.33072555065155,\n", - " (2060, 7): 7.597278833389282,\n", - " (2060, 8): 5.04828941822052,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.7639505863189697,\n", - " (2060, 11): 41.49972629547119,\n", - " (2060, 12): 208.0569303035736},\n", - " 'window': {(2060, 1): 68.3688154220581,\n", - " (2060, 2): 62.4681715965271,\n", - " (2060, 3): 43.005868434906006,\n", - " (2060, 4): 119.63918056632818,\n", - " (2060, 5): 4.462056040763855,\n", - " (2060, 6): 7.310787200927734,\n", - " (2060, 7): 2.8089256286621094,\n", - " (2060, 8): 4.017894744873047,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 2.6418973207473755,\n", - " (2060, 11): 21.122785806655884,\n", - " (2060, 12): 125.59120845794678}},\n", - " 251: {'monthly': {(2060, 1): 371.11887764930725,\n", - " (2060, 2): 290.64024817943573,\n", - " (2060, 3): 181.28253889083862,\n", - " (2060, 4): 170.79262389062046,\n", - " (2060, 5): 18.850451231002808,\n", - " (2060, 6): 23.821374773979187,\n", - " (2060, 7): 9.052908182144165,\n", - " (2060, 8): 6.8891414403915405,\n", - " (2060, 9): 4.879442811012268,\n", - " (2060, 10): 6.01810896396637,\n", - " (2060, 11): 54.92240250110626,\n", - " (2060, 12): 279.36247849464417},\n", - " 'window': {(2060, 1): 98.4852180480957,\n", - " (2060, 2): 93.1309289932251,\n", - " (2060, 3): 47.116154193878174,\n", - " (2060, 4): 137.40173531888126,\n", - " (2060, 5): 7.897663831710815,\n", - " (2060, 6): 8.193779349327087,\n", - " (2060, 7): 3.9092202186584473,\n", - " (2060, 8): 5.854952454566956,\n", - " (2060, 9): 1.9150738716125488,\n", - " (2060, 10): 3.7120296955108643,\n", - " (2060, 11): 26.40241026878357,\n", - " (2060, 12): 175.5646800994873}},\n", - " 252: {'monthly': {(2060, 1): 496.52668142318726,\n", - " (2060, 2): 335.37156915664673,\n", - " (2060, 3): 251.56207132339478,\n", - " (2060, 4): 194.59240460395813,\n", - " (2060, 5): 27.403299808502197,\n", - " (2060, 6): 17.24149751663208,\n", - " (2060, 7): 9.859021782875061,\n", - " (2060, 8): 2.678863763809204,\n", - " (2060, 9): 1.3974521160125732,\n", - " (2060, 10): 9.102944135665894,\n", - " (2060, 11): 71.59830486774445,\n", - " (2060, 12): 369.1806219816208},\n", - " 'window': {(2060, 1): 118.10778617858887,\n", - " (2060, 2): 97.15814208984375,\n", - " (2060, 3): 69.62819862365723,\n", - " (2060, 4): 148.4245285987854,\n", - " (2060, 5): 9.340882301330566,\n", - " (2060, 6): 5.933640360832214,\n", - " (2060, 7): 3.5198158025741577,\n", - " (2060, 8): 2.678863763809204,\n", - " (2060, 9): 1.3974521160125732,\n", - " (2060, 10): 4.986202120780945,\n", - " (2060, 11): 44.307079911231995,\n", - " (2060, 12): 215.6035614013672}},\n", - " 253: {'monthly': {(2060, 1): 532.8579639196396,\n", - " (2060, 2): 354.61907505989075,\n", - " (2060, 3): 361.19212532043457,\n", - " (2060, 4): 247.92105723468407,\n", - " (2060, 5): 28.173843383789062,\n", - " (2060, 6): 16.076064109802246,\n", - " (2060, 7): 7.847085952758789,\n", - " (2060, 8): 3.225572943687439,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 4.837348818778992,\n", - " (2060, 11): 90.3651340007782,\n", - " (2060, 12): 498.08390522003174},\n", - " 'window': {(2060, 1): 161.22019004821777,\n", - " (2060, 2): 106.7734603881836,\n", - " (2060, 3): 105.62549781799316,\n", - " (2060, 4): 198.68452776519402,\n", - " (2060, 5): 11.926429033279419,\n", - " (2060, 6): 6.584919571876526,\n", - " (2060, 7): 2.8617007732391357,\n", - " (2060, 8): 3.225572943687439,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.707000970840454,\n", - " (2060, 11): 56.65453505516052,\n", - " (2060, 12): 289.4801254272461}},\n", - " 254: {'monthly': {(2060, 1): 458.47293066978455,\n", - " (2060, 2): 310.13632345199585,\n", - " (2060, 3): 301.56771528720856,\n", - " (2060, 4): 215.43825512490838,\n", - " (2060, 5): 18.884196281433105,\n", - " (2060, 6): 13.612558007240295,\n", - " (2060, 7): 8.038841366767883,\n", - " (2060, 8): 5.003441095352173,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 4.837348818778992,\n", - " (2060, 11): 69.49678039550781,\n", - " (2060, 12): 410.397096157074},\n", - " 'window': {(2060, 1): 116.16430473327637,\n", - " (2060, 2): 107.02851486206055,\n", - " (2060, 3): 79.23326206207275,\n", - " (2060, 4): 178.54311376176446,\n", - " (2060, 5): 9.49773097038269,\n", - " (2060, 6): 6.529386639595032,\n", - " (2060, 7): 3.197865605354309,\n", - " (2060, 8): 5.003441095352173,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.707000970840454,\n", - " (2060, 11): 42.73634147644043,\n", - " (2060, 12): 256.21223640441895}},\n", - " 255: {'monthly': {(2060, 1): 344.3292578458786,\n", - " (2060, 2): 228.19740784168243,\n", - " (2060, 3): 224.58076357841492,\n", - " (2060, 4): 187.7056210618419,\n", - " (2060, 5): 15.559300541877747,\n", - " (2060, 6): 12.897316932678223,\n", - " (2060, 7): 7.853879809379578,\n", - " (2060, 8): 8.247969150543213,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 4.837348818778992,\n", - " (2060, 11): 51.5317280292511,\n", - " (2060, 12): 306.4633619785309},\n", - " 'window': {(2060, 1): 89.25451850891113,\n", - " (2060, 2): 79.04703950881958,\n", - " (2060, 3): 53.4452018737793,\n", - " (2060, 4): 151.85730331949418,\n", - " (2060, 5): 6.9774086475372314,\n", - " (2060, 6): 5.783080339431763,\n", - " (2060, 7): 2.8617007732391357,\n", - " (2060, 8): 8.247969150543213,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.707000970840454,\n", - " (2060, 11): 30.83710753917694,\n", - " (2060, 12): 197.95832920074463}},\n", - " 256: {'monthly': {(2060, 1): 318.26297533512115,\n", - " (2060, 2): 288.2025144100189,\n", - " (2060, 3): 186.11666631698608,\n", - " (2060, 4): 110.36223697662354,\n", - " (2060, 5): 7.43183434009552,\n", - " (2060, 6): 9.284491658210754,\n", - " (2060, 7): 4.729854106903076,\n", - " (2060, 8): 9.06748342514038,\n", - " (2060, 9): 6.155770897865295,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 38.1324417591095,\n", - " (2060, 12): 196.18602788448334},\n", - " 'window': {(2060, 1): 104.06925201416016,\n", - " (2060, 2): 77.83072090148926,\n", - " (2060, 3): 52.97581386566162,\n", - " (2060, 4): 98.99728095531464,\n", - " (2060, 5): 2.750327229499817,\n", - " (2060, 6): 3.1927260160446167,\n", - " (2060, 7): 2.453903913497925,\n", - " (2060, 8): 7.97252881526947,\n", - " (2060, 9): 2.59496009349823,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 30.06726098060608,\n", - " (2060, 12): 77.02295017242432}},\n", - " 257: {'monthly': {(2060, 1): 287.6006486415863,\n", - " (2060, 2): 255.68109273910522,\n", - " (2060, 3): 145.14661073684692,\n", - " (2060, 4): 90.40479636192322,\n", - " (2060, 5): 7.7467933893203735,\n", - " (2060, 6): 7.5584986209869385,\n", - " (2060, 7): 3.648893117904663,\n", - " (2060, 8): 7.854115724563599,\n", - " (2060, 9): 6.155770897865295,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 30.497986674308777,\n", - " (2060, 12): 189.08202505111694},\n", - " 'window': {(2060, 1): 98.61031150817871,\n", - " (2060, 2): 69.21092319488525,\n", - " (2060, 3): 43.55532503128052,\n", - " (2060, 4): 82.000683426857,\n", - " (2060, 5): 3.060458183288574,\n", - " (2060, 6): 3.1927260160446167,\n", - " (2060, 7): 1.3729429244995117,\n", - " (2060, 8): 6.759161114692688,\n", - " (2060, 9): 2.59496009349823,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 24.21482563018799,\n", - " (2060, 12): 84.2072114944458}},\n", - " 258: {'monthly': {(2060, 1): 313.2577705383301,\n", - " (2060, 2): 266.06694412231445,\n", - " (2060, 3): 161.5007448196411,\n", - " (2060, 4): 74.50957679748535,\n", - " (2060, 5): 7.658151745796204,\n", - " (2060, 6): 6.965321779251099,\n", - " (2060, 7): 3.648893117904663,\n", - " (2060, 8): 7.592580795288086,\n", - " (2060, 9): 7.3465341329574585,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 32.47984266281128,\n", - " (2060, 12): 223.05463671684265},\n", - " 'window': {(2060, 1): 96.60777950286865,\n", - " (2060, 2): 75.14299297332764,\n", - " (2060, 3): 48.93126201629639,\n", - " (2060, 4): 64.0339572429657,\n", - " (2060, 5): 2.5851352214813232,\n", - " (2060, 6): 3.1927260160446167,\n", - " (2060, 7): 1.3729429244995117,\n", - " (2060, 8): 6.497626185417175,\n", - " (2060, 9): 2.59496009349823,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 26.024231672286987,\n", - " (2060, 12): 108.0525016784668}},\n", - " 259: {'monthly': {(2060, 1): 316.9749187231064,\n", - " (2060, 2): 254.76062989234924,\n", - " (2060, 3): 145.13089501857758,\n", - " (2060, 4): 56.92955660820007,\n", - " (2060, 5): 8.345656156539917,\n", - " (2060, 6): 6.5824748277664185,\n", - " (2060, 7): 3.648893117904663,\n", - " (2060, 8): 6.751854419708252,\n", - " (2060, 9): 6.155770897865295,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 31.15902543067932,\n", - " (2060, 12): 217.2523432970047},\n", - " 'window': {(2060, 1): 94.95539379119873,\n", - " (2060, 2): 75.00810146331787,\n", - " (2060, 3): 50.99852514266968,\n", - " (2060, 4): 48.275654911994934,\n", - " (2060, 5): 3.3232460021972656,\n", - " (2060, 6): 3.1927260160446167,\n", - " (2060, 7): 1.3729429244995117,\n", - " (2060, 8): 5.656899809837341,\n", - " (2060, 9): 2.59496009349823,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 24.184714794158936,\n", - " (2060, 12): 111.12551879882812}},\n", - " 260: {'monthly': {(2060, 1): 319.60094118118286,\n", - " (2060, 2): 172.93310844898224,\n", - " (2060, 3): 188.71645891666412,\n", - " (2060, 4): 63.231823325157166,\n", - " (2060, 5): 3.132406711578369,\n", - " (2060, 6): 5.834451675415039,\n", - " (2060, 7): 4.537563681602478,\n", - " (2060, 8): 1.1109524965286255,\n", - " (2060, 9): 1.8435282707214355,\n", - " (2060, 10): 3.225322723388672,\n", - " (2060, 11): 48.929383873939514,\n", - " (2060, 12): 150.78765106201172},\n", - " 'window': {(2060, 1): 77.81227207183838,\n", - " (2060, 2): 53.646719217300415,\n", - " (2060, 3): 65.31185626983643,\n", - " (2060, 4): 44.436670422554016,\n", - " (2060, 5): 2.103094458580017,\n", - " (2060, 6): 4.728754878044128,\n", - " (2060, 7): 3.5211403369903564,\n", - " (2060, 8): 1.1109524965286255,\n", - " (2060, 9): 1.8435282707214355,\n", - " (2060, 10): 3.225322723388672,\n", - " (2060, 11): 22.19495165348053,\n", - " (2060, 12): 62.72420406341553}},\n", - " 261: {'monthly': {(2060, 1): 262.1648519039154,\n", - " (2060, 2): 197.89499926567078,\n", - " (2060, 3): 127.2901200056076,\n", - " (2060, 4): 54.54578518867493,\n", - " (2060, 5): 5.244473934173584,\n", - " (2060, 6): 8.175934314727783,\n", - " (2060, 7): 7.597278833389282,\n", - " (2060, 8): 2.829188823699951,\n", - " (2060, 9): 1.0357788801193237,\n", - " (2060, 10): 3.7639505863189697,\n", - " (2060, 11): 43.229376792907715,\n", - " (2060, 12): 171.81432962417603},\n", - " 'window': {(2060, 1): 59.98404884338379,\n", - " (2060, 2): 69.74584770202637,\n", - " (2060, 3): 39.10727047920227,\n", - " (2060, 4): 42.9572970867157,\n", - " (2060, 5): 2.2562087774276733,\n", - " (2060, 6): 5.8415443897247314,\n", - " (2060, 7): 2.8089256286621094,\n", - " (2060, 8): 2.829188823699951,\n", - " (2060, 9): 1.0357788801193237,\n", - " (2060, 10): 2.6418973207473755,\n", - " (2060, 11): 28.509860157966614,\n", - " (2060, 12): 107.3920316696167}},\n", - " 262: {'monthly': {(2060, 1): 237.32292139530182,\n", - " (2060, 2): 167.2325930595398,\n", - " (2060, 3): 123.04855871200562,\n", - " (2060, 4): 76.99921369552612,\n", - " (2060, 5): 6.260178446769714,\n", - " (2060, 6): 7.2071027755737305,\n", - " (2060, 7): 7.597278833389282,\n", - " (2060, 8): 2.829188823699951,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 4.970601439476013,\n", - " (2060, 11): 31.37356996536255,\n", - " (2060, 12): 161.27754151821136},\n", - " 'window': {(2060, 1): 53.85971403121948,\n", - " (2060, 2): 56.10446619987488,\n", - " (2060, 3): 37.69997596740723,\n", - " (2060, 4): 64.20160984992981,\n", - " (2060, 5): 2.196187138557434,\n", - " (2060, 6): 4.872712850570679,\n", - " (2060, 7): 2.8089256286621094,\n", - " (2060, 8): 2.829188823699951,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.848548173904419,\n", - " (2060, 11): 15.819462656974792,\n", - " (2060, 12): 96.78182411193848}},\n", - " 263: {'monthly': {(2060, 1): 296.59861493110657,\n", - " (2060, 2): 237.57294690608978,\n", - " (2060, 3): 176.1080549955368,\n", - " (2060, 4): 121.89718627929688,\n", - " (2060, 5): 15.580625534057617,\n", - " (2060, 6): 17.20192015171051,\n", - " (2060, 7): 9.922564029693604,\n", - " (2060, 8): 3.8912179470062256,\n", - " (2060, 9): 5.037164330482483,\n", - " (2060, 10): 6.033025741577148,\n", - " (2060, 11): 45.05492556095123,\n", - " (2060, 12): 201.49557173252106},\n", - " 'window': {(2060, 1): 72.66750049591064,\n", - " (2060, 2): 73.9744348526001,\n", - " (2060, 3): 47.5335955619812,\n", - " (2060, 4): 94.76855230331421,\n", - " (2060, 5): 6.613649845123291,\n", - " (2060, 6): 7.357819437980652,\n", - " (2060, 7): 3.747179865837097,\n", - " (2060, 8): 3.8912179470062256,\n", - " (2060, 9): 3.520709991455078,\n", - " (2060, 10): 2.6418973207473755,\n", - " (2060, 11): 24.33761954307556,\n", - " (2060, 12): 111.57761478424072}},\n", - " 264: {'monthly': {(2060, 1): 420.47118532657623,\n", - " (2060, 2): 327.6845191717148,\n", - " (2060, 3): 207.73395788669586,\n", - " (2060, 4): 170.12671118696608,\n", - " (2060, 5): 34.53610169887543,\n", - " (2060, 6): 36.464248180389404,\n", - " (2060, 7): 26.876800417900085,\n", - " (2060, 8): 17.572771191596985,\n", - " (2060, 9): 6.857671856880188,\n", - " (2060, 10): 7.3981053829193115,\n", - " (2060, 11): 61.78438925743103,\n", - " (2060, 12): 284.23697233200073},\n", - " 'window': {(2060, 1): 106.57636833190918,\n", - " (2060, 2): 98.7048921585083,\n", - " (2060, 3): 51.320138931274414,\n", - " (2060, 4): 123.85340779741682,\n", - " (2060, 5): 12.824184775352478,\n", - " (2060, 6): 8.847403883934021,\n", - " (2060, 7): 8.717565894126892,\n", - " (2060, 8): 8.619832634925842,\n", - " (2060, 9): 3.5655254125595093,\n", - " (2060, 10): 2.656917452812195,\n", - " (2060, 11): 29.494773149490356,\n", - " (2060, 12): 163.15185546875}},\n", - " 265: {'monthly': {(2060, 1): 552.8010412454605,\n", - " (2060, 2): 349.89074516296387,\n", - " (2060, 3): 296.1245666742325,\n", - " (2060, 4): 215.32133571672375,\n", - " (2060, 5): 37.55260479450226,\n", - " (2060, 6): 26.74069380760193,\n", - " (2060, 7): 14.87657618522644,\n", - " (2060, 8): 5.3379517793655396,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 8.868850111961365,\n", - " (2060, 11): 83.15762150287628,\n", - " (2060, 12): 408.7636789083481},\n", - " 'window': {(2060, 1): 128.81034088134766,\n", - " (2060, 2): 104.9013090133667,\n", - " (2060, 3): 73.6851806640625,\n", - " (2060, 4): 150.77592448759015,\n", - " (2060, 5): 14.05696964263916,\n", - " (2060, 6): 8.560317158699036,\n", - " (2060, 7): 5.322749137878418,\n", - " (2060, 8): 5.3379517793655396,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 4.088224172592163,\n", - " (2060, 11): 46.5310583114624,\n", - " (2060, 12): 242.58731269836426}},\n", - " 266: {'monthly': {(2060, 1): 597.1529250144958,\n", - " (2060, 2): 379.1772229671478,\n", - " (2060, 3): 422.9780390262604,\n", - " (2060, 4): 274.19170396626924,\n", - " (2060, 5): 41.779523849487305,\n", - " (2060, 6): 22.55896294116974,\n", - " (2060, 7): 15.698120594024658,\n", - " (2060, 8): 4.272467136383057,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 4.837348818778992,\n", - " (2060, 11): 108.7338057756424,\n", - " (2060, 12): 531.6082910299301},\n", - " 'window': {(2060, 1): 183.8798999786377,\n", - " (2060, 2): 114.89447116851807,\n", - " (2060, 3): 122.88232707977295,\n", - " (2060, 4): 201.93462138474916,\n", - " (2060, 5): 17.76712203025818,\n", - " (2060, 6): 7.406968712806702,\n", - " (2060, 7): 4.893697142601013,\n", - " (2060, 8): 3.2445757389068604,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.707000970840454,\n", - " (2060, 11): 67.91172790527344,\n", - " (2060, 12): 301.31614875793457}},\n", - " 267: {'monthly': {(2060, 1): 528.5280255079269,\n", - " (2060, 2): 359.00812673568726,\n", - " (2060, 3): 349.8440850973129,\n", - " (2060, 4): 215.3594843936985,\n", - " (2060, 5): 24.582966327667236,\n", - " (2060, 6): 19.732748866081238,\n", - " (2060, 7): 7.70267653465271,\n", - " (2060, 8): 5.72909414768219,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 4.837348818778992,\n", - " (2060, 11): 76.4083468914032,\n", - " (2060, 12): 446.0109746456146},\n", - " 'window': {(2060, 1): 132.1556396484375,\n", - " (2060, 2): 119.3975076675415,\n", - " (2060, 3): 84.61052513122559,\n", - " (2060, 4): 172.55707593689613,\n", - " (2060, 5): 12.560920238494873,\n", - " (2060, 6): 6.809584259986877,\n", - " (2060, 7): 2.8617007732391357,\n", - " (2060, 8): 4.440470218658447,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.707000970840454,\n", - " (2060, 11): 45.260730266571045,\n", - " (2060, 12): 275.17230796813965}},\n", - " 268: {'monthly': {(2060, 1): 361.2921234369278,\n", - " (2060, 2): 222.8084396123886,\n", - " (2060, 3): 229.1819680929184,\n", - " (2060, 4): 179.42224746716943,\n", - " (2060, 5): 15.944024085998535,\n", - " (2060, 6): 14.143036246299744,\n", - " (2060, 7): 7.70267653465271,\n", - " (2060, 8): 6.128108978271484,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 5.01155698299408,\n", - " (2060, 11): 52.23296141624451,\n", - " (2060, 12): 300.2287893295288},\n", - " 'window': {(2060, 1): 88.5531234741211,\n", - " (2060, 2): 82.32919836044312,\n", - " (2060, 3): 53.7646689414978,\n", - " (2060, 4): 149.48284536374535,\n", - " (2060, 5): 8.727167844772339,\n", - " (2060, 6): 5.893077969551086,\n", - " (2060, 7): 2.8617007732391357,\n", - " (2060, 8): 6.128108978271484,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.881209135055542,\n", - " (2060, 11): 28.071882724761963,\n", - " (2060, 12): 206.6638298034668}},\n", - " 269: {'monthly': {(2060, 1): 306.56378293037415,\n", - " (2060, 2): 263.5218892097473,\n", - " (2060, 3): 181.21390616893768,\n", - " (2060, 4): 98.02914249897003,\n", - " (2060, 5): 7.536941409111023,\n", - " (2060, 6): 9.391801118850708,\n", - " (2060, 7): 3.648893117904663,\n", - " (2060, 8): 8.17453384399414,\n", - " (2060, 9): 6.155770897865295,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 34.48573660850525,\n", - " (2060, 12): 182.00355100631714},\n", - " 'window': {(2060, 1): 115.8544864654541,\n", - " (2060, 2): 72.0941972732544,\n", - " (2060, 3): 52.491658210754395,\n", - " (2060, 4): 88.6507693529129,\n", - " (2060, 5): 2.9084439277648926,\n", - " (2060, 6): 4.059861660003662,\n", - " (2060, 7): 1.3729429244995117,\n", - " (2060, 8): 7.07957923412323,\n", - " (2060, 9): 2.59496009349823,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 27.20770835876465,\n", - " (2060, 12): 86.17699718475342}},\n", - " 270: {'monthly': {(2060, 1): 294.61305582523346,\n", - " (2060, 2): 247.30507683753967,\n", - " (2060, 3): 147.75903153419495,\n", - " (2060, 4): 81.43450891971588,\n", - " (2060, 5): 7.520111083984375,\n", - " (2060, 6): 8.997598648071289,\n", - " (2060, 7): 3.648893117904663,\n", - " (2060, 8): 7.6847593784332275,\n", - " (2060, 9): 6.155770897865295,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 26.690870761871338,\n", - " (2060, 12): 188.08086669445038},\n", - " 'window': {(2060, 1): 113.00857830047607,\n", - " (2060, 2): 70.111572265625,\n", - " (2060, 3): 44.35943937301636,\n", - " (2060, 4): 71.68083417415619,\n", - " (2060, 5): 2.880706310272217,\n", - " (2060, 6): 3.665659189224243,\n", - " (2060, 7): 1.3729429244995117,\n", - " (2060, 8): 6.589804768562317,\n", - " (2060, 9): 2.59496009349823,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 22.735325574874878,\n", - " (2060, 12): 91.489182472229}},\n", - " 271: {'monthly': {(2060, 1): 325.98186326026917,\n", - " (2060, 2): 265.50992345809937,\n", - " (2060, 3): 174.6498497724533,\n", - " (2060, 4): 61.42799997329712,\n", - " (2060, 5): 7.388349652290344,\n", - " (2060, 6): 8.403891324996948,\n", - " (2060, 7): 3.648893117904663,\n", - " (2060, 8): 7.278117060661316,\n", - " (2060, 9): 6.155770897865295,\n", - " (2060, 10): 1.0235161781311035,\n", - " (2060, 11): 30.461305499076843,\n", - " (2060, 12): 227.19547867774963},\n", - " 'window': {(2060, 1): 112.11464786529541,\n", - " (2060, 2): 79.35369110107422,\n", - " (2060, 3): 48.94155550003052,\n", - " (2060, 4): 49.2091509103775,\n", - " (2060, 5): 2.511051297187805,\n", - " (2060, 6): 3.1927260160446167,\n", - " (2060, 7): 1.3729429244995117,\n", - " (2060, 8): 6.183162450790405,\n", - " (2060, 9): 2.59496009349823,\n", - " (2060, 10): 1.0235161781311035,\n", - " (2060, 11): 24.31968641281128,\n", - " (2060, 12): 110.77163314819336}},\n", - " 272: {'monthly': {(2060, 1): 330.4050781726837,\n", - " (2060, 2): 255.17492365837097,\n", - " (2060, 3): 151.32258701324463,\n", - " (2060, 4): 43.95049011707306,\n", - " (2060, 5): 9.26224172115326,\n", - " (2060, 6): 7.229494333267212,\n", - " (2060, 7): 3.648893117904663,\n", - " (2060, 8): 5.6640660762786865,\n", - " (2060, 9): 6.155770897865295,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 28.565257668495178,\n", - " (2060, 12): 226.28698694705963},\n", - " 'window': {(2060, 1): 106.94531059265137,\n", - " (2060, 2): 72.4198694229126,\n", - " (2060, 3): 50.637136936187744,\n", - " (2060, 4): 33.41529130935669,\n", - " (2060, 5): 3.0459470748901367,\n", - " (2060, 6): 3.1927260160446167,\n", - " (2060, 7): 1.3729429244995117,\n", - " (2060, 8): 4.569111466407776,\n", - " (2060, 9): 2.59496009349823,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 22.740628838539124,\n", - " (2060, 12): 116.44982051849365}},\n", - " 273: {'monthly': {(2060, 1): 250.64715838432312,\n", - " (2060, 2): 245.48224413394928,\n", - " (2060, 3): 204.46247565746307,\n", - " (2060, 4): 38.765894174575806,\n", - " (2060, 5): 5.240600109100342,\n", - " (2060, 6): 0.0,\n", - " (2060, 7): 1.1818259954452515,\n", - " (2060, 8): 3.6678138971328735,\n", - " (2060, 9): 4.55378270149231,\n", - " (2060, 10): 12.777472972869873,\n", - " (2060, 11): 36.23033428192139,\n", - " (2060, 12): 184.29877996444702},\n", - " 'window': {(2060, 1): 53.5350604057312,\n", - " (2060, 2): 62.90051078796387,\n", - " (2060, 3): 51.0702223777771,\n", - " (2060, 4): 19.947062492370605,\n", - " (2060, 5): 2.2900381088256836,\n", - " (2060, 6): 0.0,\n", - " (2060, 7): 1.1818259954452515,\n", - " (2060, 8): 3.6678138971328735,\n", - " (2060, 9): 2.9441583156585693,\n", - " (2060, 10): 9.44057297706604,\n", - " (2060, 11): 18.49140763282776,\n", - " (2060, 12): 83.28571796417236}},\n", - " 274: {'monthly': {(2060, 1): 202.1481363773346,\n", - " (2060, 2): 240.95759773254395,\n", - " (2060, 3): 176.90822100639343,\n", - " (2060, 4): 32.528223276138306,\n", - " (2060, 5): 2.2575716972351074,\n", - " (2060, 6): 2.3992990255355835,\n", - " (2060, 7): 2.258692502975464,\n", - " (2060, 8): 8.626851797103882,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 4.071798086166382,\n", - " (2060, 11): 43.679727435112,\n", - " (2060, 12): 201.3738250732422},\n", - " 'window': {(2060, 1): 54.28602695465088,\n", - " (2060, 2): 63.5795841217041,\n", - " (2060, 3): 46.82486534118652,\n", - " (2060, 4): 19.611440181732178,\n", - " (2060, 5): 1.2167506217956543,\n", - " (2060, 6): 1.2717193365097046,\n", - " (2060, 7): 1.2382659912109375,\n", - " (2060, 8): 6.286520004272461,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 2.9002057313919067,\n", - " (2060, 11): 23.66166377067566,\n", - " (2060, 12): 91.42366361618042}},\n", - " 275: {'monthly': {(2060, 1): 188.9342999458313,\n", - " (2060, 2): 219.16459584236145,\n", - " (2060, 3): 138.23318552970886,\n", - " (2060, 4): 32.778876423835754,\n", - " (2060, 5): 2.5462745428085327,\n", - " (2060, 6): 2.3992990255355835,\n", - " (2060, 7): 2.258692502975464,\n", - " (2060, 8): 7.913874506950378,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.66260826587677,\n", - " (2060, 11): 38.54490327835083,\n", - " (2060, 12): 196.19454061985016},\n", - " 'window': {(2060, 1): 56.193785667419434,\n", - " (2060, 2): 57.07875347137451,\n", - " (2060, 3): 34.331191539764404,\n", - " (2060, 4): 22.131305694580078,\n", - " (2060, 5): 1.5054534673690796,\n", - " (2060, 6): 1.2717193365097046,\n", - " (2060, 7): 1.2382659912109375,\n", - " (2060, 8): 5.5735427141189575,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 2.491015911102295,\n", - " (2060, 11): 22.03794527053833,\n", - " (2060, 12): 99.76544427871704}},\n", - " 276: {'monthly': {(2060, 1): 261.10482108592987,\n", - " (2060, 2): 274.88150465488434,\n", - " (2060, 3): 192.63463020324707,\n", - " (2060, 4): 67.92880415916443,\n", - " (2060, 5): 5.986621141433716,\n", - " (2060, 6): 4.212859511375427,\n", - " (2060, 7): 3.3232442140579224,\n", - " (2060, 8): 9.82966136932373,\n", - " (2060, 9): 2.252705454826355,\n", - " (2060, 10): 8.371089339256287,\n", - " (2060, 11): 56.374675989151,\n", - " (2060, 12): 295.74742436408997},\n", - " 'window': {(2060, 1): 71.57211971282959,\n", - " (2060, 2): 67.43015575408936,\n", - " (2060, 3): 43.61384201049805,\n", - " (2060, 4): 39.76958882808685,\n", - " (2060, 5): 3.6871590614318848,\n", - " (2060, 6): 1.8135604858398438,\n", - " (2060, 7): 1.2382659912109375,\n", - " (2060, 8): 7.48932957649231,\n", - " (2060, 9): 1.1522417068481445,\n", - " (2060, 10): 3.6574671268463135,\n", - " (2060, 11): 30.908519983291626,\n", - " (2060, 12): 155.1047191619873}},\n", - " 277: {'monthly': {(2060, 1): 330.86331391334534,\n", - " (2060, 2): 355.0861793756485,\n", - " (2060, 3): 262.8192650079727,\n", - " (2060, 4): 125.63546514511108,\n", - " (2060, 5): 24.143322587013245,\n", - " (2060, 6): 21.017499208450317,\n", - " (2060, 7): 12.590503811836243,\n", - " (2060, 8): 13.69922661781311,\n", - " (2060, 9): 7.840793490409851,\n", - " (2060, 10): 19.30341672897339,\n", - " (2060, 11): 76.16075074672699,\n", - " (2060, 12): 339.3919174671173},\n", - " 'window': {(2060, 1): 80.02444458007812,\n", - " (2060, 2): 92.28601932525635,\n", - " (2060, 3): 68.94701766967773,\n", - " (2060, 4): 77.29726243019104,\n", - " (2060, 5): 13.002723693847656,\n", - " (2060, 6): 7.409507155418396,\n", - " (2060, 7): 4.228013396263123,\n", - " (2060, 8): 11.280029773712158,\n", - " (2060, 9): 3.2351646423339844,\n", - " (2060, 10): 9.665526151657104,\n", - " (2060, 11): 36.60802149772644,\n", - " (2060, 12): 163.3670825958252}},\n", - " 278: {'monthly': {(2060, 1): 327.97847533226013,\n", - " (2060, 2): 381.3611658811569,\n", - " (2060, 3): 400.85040521621704,\n", - " (2060, 4): 173.1959934234619,\n", - " (2060, 5): 28.990357279777527,\n", - " (2060, 6): 26.265400648117065,\n", - " (2060, 7): 15.561176300048828,\n", - " (2060, 8): 18.09122908115387,\n", - " (2060, 9): 5.83366322517395,\n", - " (2060, 10): 8.412497639656067,\n", - " (2060, 11): 113.77406311035156,\n", - " (2060, 12): 413.91616213321686},\n", - " 'window': {(2060, 1): 77.47867012023926,\n", - " (2060, 2): 98.88286304473877,\n", - " (2060, 3): 94.85804653167725,\n", - " (2060, 4): 99.89056921005249,\n", - " (2060, 5): 19.437586665153503,\n", - " (2060, 6): 11.74343740940094,\n", - " (2060, 7): 6.327032804489136,\n", - " (2060, 8): 15.543925166130066,\n", - " (2060, 9): 4.714042067527771,\n", - " (2060, 10): 7.1155253648757935,\n", - " (2060, 11): 58.459808349609375,\n", - " (2060, 12): 154.06966590881348}},\n", - " 279: {'monthly': {(2060, 1): 369.8488698005676,\n", - " (2060, 2): 492.2385507822037,\n", - " (2060, 3): 547.0389657020569,\n", - " (2060, 4): 225.85501515865326,\n", - " (2060, 5): 36.79653239250183,\n", - " (2060, 6): 31.810413599014282,\n", - " (2060, 7): 18.3887779712677,\n", - " (2060, 8): 18.286468744277954,\n", - " (2060, 9): 5.935857772827148,\n", - " (2060, 10): 12.417531967163086,\n", - " (2060, 11): 166.73317456245422,\n", - " (2060, 12): 550.313892364502},\n", - " 'window': {(2060, 1): 88.37924194335938,\n", - " (2060, 2): 140.30486297607422,\n", - " (2060, 3): 137.37254524230957,\n", - " (2060, 4): 124.93175172805786,\n", - " (2060, 5): 24.15145218372345,\n", - " (2060, 6): 17.29554271697998,\n", - " (2060, 7): 6.157450914382935,\n", - " (2060, 8): 14.39061152935028,\n", - " (2060, 9): 5.935857772827148,\n", - " (2060, 10): 9.804187893867493,\n", - " (2060, 11): 82.99624729156494,\n", - " (2060, 12): 192.24921226501465}},\n", - " 280: {'monthly': {(2060, 1): 369.73603796958923,\n", - " (2060, 2): 479.36721777915955,\n", - " (2060, 3): 438.06075286865234,\n", - " (2060, 4): 152.5454043149948,\n", - " (2060, 5): 27.302899599075317,\n", - " (2060, 6): 20.069793105125427,\n", - " (2060, 7): 12.809409976005554,\n", - " (2060, 8): 12.998341679573059,\n", - " (2060, 9): 5.775176644325256,\n", - " (2060, 10): 8.872601509094238,\n", - " (2060, 11): 154.488560795784,\n", - " (2060, 12): 484.9553598165512},\n", - " 'window': {(2060, 1): 89.23777675628662,\n", - " (2060, 2): 134.7678747177124,\n", - " (2060, 3): 105.16179180145264,\n", - " (2060, 4): 86.2781331539154,\n", - " (2060, 5): 17.945239305496216,\n", - " (2060, 6): 11.692538261413574,\n", - " (2060, 7): 4.208318710327148,\n", - " (2060, 8): 10.451037764549255,\n", - " (2060, 9): 5.775176644325256,\n", - " (2060, 10): 7.575629234313965,\n", - " (2060, 11): 74.12103080749512,\n", - " (2060, 12): 178.6612663269043}},\n", - " 281: {'monthly': {(2060, 1): 282.1253023147583,\n", - " (2060, 2): 368.13819193840027,\n", - " (2060, 3): 269.2547399997711,\n", - " (2060, 4): 105.45567715167999,\n", - " (2060, 5): 22.96463704109192,\n", - " (2060, 6): 24.36797261238098,\n", - " (2060, 7): 12.79484760761261,\n", - " (2060, 8): 11.248621344566345,\n", - " (2060, 9): 4.963808298110962,\n", - " (2060, 10): 8.662757873535156,\n", - " (2060, 11): 121.49924194812775,\n", - " (2060, 12): 314.5602421760559},\n", - " 'window': {(2060, 1): 65.93494033813477,\n", - " (2060, 2): 103.00091648101807,\n", - " (2060, 3): 63.05338191986084,\n", - " (2060, 4): 57.008251428604126,\n", - " (2060, 5): 13.744433164596558,\n", - " (2060, 6): 10.061506271362305,\n", - " (2060, 7): 5.0404521226882935,\n", - " (2060, 8): 8.701317429542542,\n", - " (2060, 9): 4.963808298110962,\n", - " (2060, 10): 6.215651273727417,\n", - " (2060, 11): 66.31491804122925,\n", - " (2060, 12): 118.28147029876709}},\n", - " 282: {'monthly': {(2060, 1): 244.6848326921463,\n", - " (2060, 2): 273.99865078926086,\n", - " (2060, 3): 176.85901165008545,\n", - " (2060, 4): 45.805737257003784,\n", - " (2060, 5): 8.213672518730164,\n", - " (2060, 6): 10.303918242454529,\n", - " (2060, 7): 7.010338664054871,\n", - " (2060, 8): 9.822864413261414,\n", - " (2060, 9): 6.1145840883255005,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 57.948495864868164,\n", - " (2060, 12): 230.38296377658844},\n", - " 'window': {(2060, 1): 65.40737915039062,\n", - " (2060, 2): 86.54500484466553,\n", - " (2060, 3): 38.572632789611816,\n", - " (2060, 4): 31.97424030303955,\n", - " (2060, 5): 7.20013689994812,\n", - " (2060, 6): 7.843185663223267,\n", - " (2060, 7): 3.5801315307617188,\n", - " (2060, 8): 8.550485253334045,\n", - " (2060, 9): 4.983400583267212,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 37.7425377368927,\n", - " (2060, 12): 86.99042892456055}},\n", - " 283: {'monthly': {(2060, 1): 219.0244356393814,\n", - " (2060, 2): 253.25896728038788,\n", - " (2060, 3): 177.2306923866272,\n", - " (2060, 4): 43.68654143810272,\n", - " (2060, 5): 9.65729558467865,\n", - " (2060, 6): 10.91953694820404,\n", - " (2060, 7): 7.010338664054871,\n", - " (2060, 8): 9.822864413261414,\n", - " (2060, 9): 3.8625177145004272,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 48.439029812812805,\n", - " (2060, 12): 212.07850909233093},\n", - " 'window': {(2060, 1): 64.66326904296875,\n", - " (2060, 2): 71.13658428192139,\n", - " (2060, 3): 38.20770788192749,\n", - " (2060, 4): 29.75643742084503,\n", - " (2060, 5): 7.5967090129852295,\n", - " (2060, 6): 8.458804368972778,\n", - " (2060, 7): 3.5801315307617188,\n", - " (2060, 8): 8.550485253334045,\n", - " (2060, 9): 2.7313342094421387,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 33.37341022491455,\n", - " (2060, 12): 84.63204860687256}},\n", - " 284: {'monthly': {(2060, 1): 239.33512699604034,\n", - " (2060, 2): 283.7481598854065,\n", - " (2060, 3): 201.93693506717682,\n", - " (2060, 4): 44.409937620162964,\n", - " (2060, 5): 7.489858031272888,\n", - " (2060, 6): 9.180303692817688,\n", - " (2060, 7): 7.010338664054871,\n", - " (2060, 8): 9.822864413261414,\n", - " (2060, 9): 5.071811556816101,\n", - " (2060, 10): 1.4752005338668823,\n", - " (2060, 11): 60.44459855556488,\n", - " (2060, 12): 252.87853682041168},\n", - " 'window': {(2060, 1): 71.9550256729126,\n", - " (2060, 2): 76.56347942352295,\n", - " (2060, 3): 44.52830362319946,\n", - " (2060, 4): 29.822691679000854,\n", - " (2060, 5): 6.476322412490845,\n", - " (2060, 6): 6.719571113586426,\n", - " (2060, 7): 3.5801315307617188,\n", - " (2060, 8): 8.550485253334045,\n", - " (2060, 9): 2.7313342094421387,\n", - " (2060, 10): 1.4752005338668823,\n", - " (2060, 11): 43.681904315948486,\n", - " (2060, 12): 94.79739570617676}},\n", - " 285: {'monthly': {(2060, 1): 235.67325735092163,\n", - " (2060, 2): 303.0094002485275,\n", - " (2060, 3): 212.1528743505478,\n", - " (2060, 4): 42.13543653488159,\n", - " (2060, 5): 7.432999968528748,\n", - " (2060, 6): 7.247230172157288,\n", - " (2060, 7): 7.010338664054871,\n", - " (2060, 8): 9.822864413261414,\n", - " (2060, 9): 8.14247727394104,\n", - " (2060, 10): 1.21963632106781,\n", - " (2060, 11): 63.78882122039795,\n", - " (2060, 12): 247.44371330738068},\n", - " 'window': {(2060, 1): 73.0792236328125,\n", - " (2060, 2): 81.53742218017578,\n", - " (2060, 3): 47.438623905181885,\n", - " (2060, 4): 28.8593327999115,\n", - " (2060, 5): 5.231067180633545,\n", - " (2060, 6): 4.786497592926025,\n", - " (2060, 7): 3.5801315307617188,\n", - " (2060, 8): 8.550485253334045,\n", - " (2060, 9): 5.934567928314209,\n", - " (2060, 10): 1.21963632106781,\n", - " (2060, 11): 44.896769523620605,\n", - " (2060, 12): 94.42313003540039}},\n", - " 286: {'monthly': {(2060, 1): 212.9824447631836,\n", - " (2060, 2): 222.16475176811218,\n", - " (2060, 3): 186.84216952323914,\n", - " (2060, 4): 38.401179790496826,\n", - " (2060, 5): 3.292080879211426,\n", - " (2060, 6): 0.0,\n", - " (2060, 7): 1.1818259954452515,\n", - " (2060, 8): 3.6678138971328735,\n", - " (2060, 9): 4.160870313644409,\n", - " (2060, 10): 8.339627027511597,\n", - " (2060, 11): 36.909741282463074,\n", - " (2060, 12): 172.69861435890198},\n", - " 'window': {(2060, 1): 49.34910011291504,\n", - " (2060, 2): 59.48219013214111,\n", - " (2060, 3): 43.55940389633179,\n", - " (2060, 4): 20.02315044403076,\n", - " (2060, 5): 2.2900381088256836,\n", - " (2060, 6): 0.0,\n", - " (2060, 7): 1.1818259954452515,\n", - " (2060, 8): 3.6678138971328735,\n", - " (2060, 9): 2.551245927810669,\n", - " (2060, 10): 8.339627027511597,\n", - " (2060, 11): 19.289527416229248,\n", - " (2060, 12): 79.69157218933105}},\n", - " 287: {'monthly': {(2060, 1): 194.3700132369995,\n", - " (2060, 2): 263.53945767879486,\n", - " (2060, 3): 180.35098016262054,\n", - " (2060, 4): 36.54633688926697,\n", - " (2060, 5): 2.401662588119507,\n", - " (2060, 6): 2.3992990255355835,\n", - " (2060, 7): 2.258692502975464,\n", - " (2060, 8): 8.626851797103882,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 6.494547963142395,\n", - " (2060, 11): 47.83089196681976,\n", - " (2060, 12): 214.6172354221344},\n", - " 'window': {(2060, 1): 55.80312442779541,\n", - " (2060, 2): 71.0849256515503,\n", - " (2060, 3): 47.97212219238281,\n", - " (2060, 4): 24.290818333625793,\n", - " (2060, 5): 1.3608415126800537,\n", - " (2060, 6): 1.2717193365097046,\n", - " (2060, 7): 1.2382659912109375,\n", - " (2060, 8): 6.286520004272461,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 5.32295560836792,\n", - " (2060, 11): 28.50161051750183,\n", - " (2060, 12): 101.51147508621216}},\n", - " 288: {'monthly': {(2060, 1): 189.94058299064636,\n", - " (2060, 2): 233.86027669906616,\n", - " (2060, 3): 146.904904961586,\n", - " (2060, 4): 37.03212881088257,\n", - " (2060, 5): 2.7289613485336304,\n", - " (2060, 6): 2.3992990255355835,\n", - " (2060, 7): 2.258692502975464,\n", - " (2060, 8): 8.010579466819763,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 4.628726124763489,\n", - " (2060, 11): 42.39926362037659,\n", - " (2060, 12): 218.58169829845428},\n", - " 'window': {(2060, 1): 51.79250240325928,\n", - " (2060, 2): 63.13421821594238,\n", - " (2060, 3): 39.58002185821533,\n", - " (2060, 4): 24.893687844276428,\n", - " (2060, 5): 1.6881402730941772,\n", - " (2060, 6): 1.2717193365097046,\n", - " (2060, 7): 1.2382659912109375,\n", - " (2060, 8): 5.670247673988342,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.4571337699890137,\n", - " (2060, 11): 22.969584941864014,\n", - " (2060, 12): 112.43907451629639}},\n", - " 289: {'monthly': {(2060, 1): 209.68105745315552,\n", - " (2060, 2): 258.8639488220215,\n", - " (2060, 3): 165.19312572479248,\n", - " (2060, 4): 53.55957746505737,\n", - " (2060, 5): 3.7774850130081177,\n", - " (2060, 6): 3.688859462738037,\n", - " (2060, 7): 2.258692502975464,\n", - " (2060, 8): 9.180863618850708,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.6685227155685425,\n", - " (2060, 11): 46.26161479949951,\n", - " (2060, 12): 266.35152447223663},\n", - " 'window': {(2060, 1): 52.63975429534912,\n", - " (2060, 2): 65.47720623016357,\n", - " (2060, 3): 44.699657917022705,\n", - " (2060, 4): 37.366345047950745,\n", - " (2060, 5): 2.621811866760254,\n", - " (2060, 6): 1.2895604372024536,\n", - " (2060, 7): 1.2382659912109375,\n", - " (2060, 8): 5.824708580970764,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 2.3982726335525513,\n", - " (2060, 11): 26.688957452774048,\n", - " (2060, 12): 145.53408479690552}},\n", - " 290: {'monthly': {(2060, 1): 278.49811351299286,\n", - " (2060, 2): 315.2948662042618,\n", - " (2060, 3): 220.8441195487976,\n", - " (2060, 4): 111.55693066120148,\n", - " (2060, 5): 13.77240002155304,\n", - " (2060, 6): 13.528334736824036,\n", - " (2060, 7): 6.2740254402160645,\n", - " (2060, 8): 14.32671570777893,\n", - " (2060, 9): 1.2315737009048462,\n", - " (2060, 10): 11.372812986373901,\n", - " (2060, 11): 69.88608121871948,\n", - " (2060, 12): 293.1069587469101},\n", - " 'window': {(2060, 1): 67.12419033050537,\n", - " (2060, 2): 88.11312294006348,\n", - " (2060, 3): 50.68101167678833,\n", - " (2060, 4): 69.24207592010498,\n", - " (2060, 5): 8.037078261375427,\n", - " (2060, 6): 6.02851939201355,\n", - " (2060, 7): 3.7570064067840576,\n", - " (2060, 8): 9.269162654876709,\n", - " (2060, 9): 1.2315737009048462,\n", - " (2060, 10): 7.535316824913025,\n", - " (2060, 11): 34.04280209541321,\n", - " (2060, 12): 146.38379859924316}},\n", - " 291: {'monthly': {(2060, 1): 286.4560081958771,\n", - " (2060, 2): 352.1943836212158,\n", - " (2060, 3): 378.66679191589355,\n", - " (2060, 4): 186.69843208789825,\n", - " (2060, 5): 32.60053253173828,\n", - " (2060, 6): 27.660024523735046,\n", - " (2060, 7): 16.83817183971405,\n", - " (2060, 8): 18.25704562664032,\n", - " (2060, 9): 7.281902313232422,\n", - " (2060, 10): 12.083991646766663,\n", - " (2060, 11): 116.51404750347137,\n", - " (2060, 12): 401.4395172595978},\n", - " 'window': {(2060, 1): 71.8088150024414,\n", - " (2060, 2): 84.17150497436523,\n", - " (2060, 3): 96.69306945800781,\n", - " (2060, 4): 102.14092063903809,\n", - " (2060, 5): 17.457882523536682,\n", - " (2060, 6): 12.671860694885254,\n", - " (2060, 7): 7.123161435127258,\n", - " (2060, 8): 15.709741711616516,\n", - " (2060, 9): 6.052022576332092,\n", - " (2060, 10): 9.045084238052368,\n", - " (2060, 11): 61.669612884521484,\n", - " (2060, 12): 164.8600196838379}},\n", - " 292: {'monthly': {(2060, 1): 349.0924081802368,\n", - " (2060, 2): 477.39856576919556,\n", - " (2060, 3): 539.2233939170837,\n", - " (2060, 4): 244.16894924640656,\n", - " (2060, 5): 36.49190962314606,\n", - " (2060, 6): 32.87833118438721,\n", - " (2060, 7): 19.833068370819092,\n", - " (2060, 8): 17.79358160495758,\n", - " (2060, 9): 6.614946365356445,\n", - " (2060, 10): 15.858542680740356,\n", - " (2060, 11): 182.28687119483948,\n", - " (2060, 12): 589.9659240245819},\n", - " 'window': {(2060, 1): 78.09229850769043,\n", - " (2060, 2): 129.32460594177246,\n", - " (2060, 3): 142.4814567565918,\n", - " (2060, 4): 134.26920127868652,\n", - " (2060, 5): 22.416889309883118,\n", - " (2060, 6): 11.932302594184875,\n", - " (2060, 7): 6.830312371253967,\n", - " (2060, 8): 15.246277689933777,\n", - " (2060, 9): 6.614946365356445,\n", - " (2060, 10): 13.052146434783936,\n", - " (2060, 11): 89.15970993041992,\n", - " (2060, 12): 245.76898193359375}},\n", - " 293: {'monthly': {(2060, 1): 353.92125272750854,\n", - " (2060, 2): 494.5641635656357,\n", - " (2060, 3): 469.9206566810608,\n", - " (2060, 4): 185.92732524871826,\n", - " (2060, 5): 28.283726692199707,\n", - " (2060, 6): 26.190886616706848,\n", - " (2060, 7): 18.35683536529541,\n", - " (2060, 8): 13.497167468070984,\n", - " (2060, 9): 5.1070685386657715,\n", - " (2060, 10): 10.295199513435364,\n", - " (2060, 11): 189.35727155208588,\n", - " (2060, 12): 537.9628672599792},\n", - " 'window': {(2060, 1): 77.8918228149414,\n", - " (2060, 2): 139.19175148010254,\n", - " (2060, 3): 107.49295234680176,\n", - " (2060, 4): 99.89750289916992,\n", - " (2060, 5): 16.227331042289734,\n", - " (2060, 6): 10.530211925506592,\n", - " (2060, 7): 6.650483846664429,\n", - " (2060, 8): 10.94986355304718,\n", - " (2060, 9): 5.1070685386657715,\n", - " (2060, 10): 8.99822723865509,\n", - " (2060, 11): 86.5686845779419,\n", - " (2060, 12): 217.0316982269287}},\n", - " 294: {'monthly': {(2060, 1): 291.5857101678848,\n", - " (2060, 2): 402.0289623737335,\n", - " (2060, 3): 320.308345079422,\n", - " (2060, 4): 123.53567910194397,\n", - " (2060, 5): 23.90632200241089,\n", - " (2060, 6): 24.247234225273132,\n", - " (2060, 7): 12.555969953536987,\n", - " (2060, 8): 11.272897601127625,\n", - " (2060, 9): 6.4275946617126465,\n", - " (2060, 10): 9.253091931343079,\n", - " (2060, 11): 157.2156240940094,\n", - " (2060, 12): 371.08502662181854},\n", - " 'window': {(2060, 1): 61.913909912109375,\n", - " (2060, 2): 114.79311561584473,\n", - " (2060, 3): 74.501145362854,\n", - " (2060, 4): 62.2232346534729,\n", - " (2060, 5): 12.243579745292664,\n", - " (2060, 6): 9.752799034118652,\n", - " (2060, 7): 5.292864441871643,\n", - " (2060, 8): 8.72559368610382,\n", - " (2060, 9): 5.380030989646912,\n", - " (2060, 10): 6.817427158355713,\n", - " (2060, 11): 84.69071531295776,\n", - " (2060, 12): 148.28900337219238}},\n", - " 295: {'monthly': {(2060, 1): 284.1167402267456,\n", - " (2060, 2): 312.32931911945343,\n", - " (2060, 3): 200.03718531131744,\n", - " (2060, 4): 63.015374541282654,\n", - " (2060, 5): 10.110085010528564,\n", - " (2060, 6): 12.195336103439331,\n", - " (2060, 7): 7.010338664054871,\n", - " (2060, 8): 13.423810839653015,\n", - " (2060, 9): 5.933136701583862,\n", - " (2060, 10): 1.0744940042495728,\n", - " (2060, 11): 71.03193819522858,\n", - " (2060, 12): 263.5773870944977},\n", - " 'window': {(2060, 1): 68.83203315734863,\n", - " (2060, 2): 97.34447956085205,\n", - " (2060, 3): 41.08051586151123,\n", - " (2060, 4): 43.65781497955322,\n", - " (2060, 5): 6.664398193359375,\n", - " (2060, 6): 6.513287782669067,\n", - " (2060, 7): 3.5801315307617188,\n", - " (2060, 8): 9.100850939750671,\n", - " (2060, 9): 4.801953196525574,\n", - " (2060, 10): 1.0744940042495728,\n", - " (2060, 11): 43.393962144851685,\n", - " (2060, 12): 84.02052402496338}},\n", - " 296: {'monthly': {(2060, 1): 248.36198234558105,\n", - " (2060, 2): 287.1254141330719,\n", - " (2060, 3): 201.75259637832642,\n", - " (2060, 4): 66.52695870399475,\n", - " (2060, 5): 8.271929144859314,\n", - " (2060, 6): 10.394352793693542,\n", - " (2060, 7): 7.010338664054871,\n", - " (2060, 8): 9.822864413261414,\n", - " (2060, 9): 7.000096440315247,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 51.41369140148163,\n", - " (2060, 12): 236.82114434242249},\n", - " 'window': {(2060, 1): 68.56517267227173,\n", - " (2060, 2): 78.52660369873047,\n", - " (2060, 3): 41.61316204071045,\n", - " (2060, 4): 47.77272391319275,\n", - " (2060, 5): 7.2583935260772705,\n", - " (2060, 6): 7.93362021446228,\n", - " (2060, 7): 3.5801315307617188,\n", - " (2060, 8): 8.550485253334045,\n", - " (2060, 9): 5.868912935256958,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 36.181626081466675,\n", - " (2060, 12): 82.24021053314209}},\n", - " 297: {'monthly': {(2060, 1): 222.70254802703857,\n", - " (2060, 2): 268.80679738521576,\n", - " (2060, 3): 206.03956055641174,\n", - " (2060, 4): 64.36299705505371,\n", - " (2060, 5): 6.560515999794006,\n", - " (2060, 6): 7.737638711929321,\n", - " (2060, 7): 7.010338664054871,\n", - " (2060, 8): 9.822864413261414,\n", - " (2060, 9): 7.621119260787964,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 55.510706067085266,\n", - " (2060, 12): 242.25676953792572},\n", - " 'window': {(2060, 1): 67.03868675231934,\n", - " (2060, 2): 72.14301872253418,\n", - " (2060, 3): 45.89143753051758,\n", - " (2060, 4): 47.612290143966675,\n", - " (2060, 5): 5.546980381011963,\n", - " (2060, 6): 5.276906132698059,\n", - " (2060, 7): 3.5801315307617188,\n", - " (2060, 8): 8.550485253334045,\n", - " (2060, 9): 6.489935755729675,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 39.56480693817139,\n", - " (2060, 12): 86.57310104370117}},\n", - " 298: {'monthly': {(2060, 1): 224.8115746974945,\n", - " (2060, 2): 287.1875332593918,\n", - " (2060, 3): 215.41685485839844,\n", - " (2060, 4): 62.97270739078522,\n", - " (2060, 5): 6.662723660469055,\n", - " (2060, 6): 6.223147392272949,\n", - " (2060, 7): 7.010338664054871,\n", - " (2060, 8): 9.822864413261414,\n", - " (2060, 9): 8.990198016166687,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 61.305317640304565,\n", - " (2060, 12): 248.48381912708282},\n", - " 'window': {(2060, 1): 66.3544225692749,\n", - " (2060, 2): 78.54612636566162,\n", - " (2060, 3): 47.64126491546631,\n", - " (2060, 4): 47.531736850738525,\n", - " (2060, 5): 4.571369171142578,\n", - " (2060, 6): 3.762414813041687,\n", - " (2060, 7): 3.5801315307617188,\n", - " (2060, 8): 8.550485253334045,\n", - " (2060, 9): 7.859014511108398,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 42.06153345108032,\n", - " (2060, 12): 88.7524356842041}},\n", - " 299: {'monthly': {(2060, 1): 185.96750402450562,\n", - " (2060, 2): 211.40797364711761,\n", - " (2060, 3): 174.9561449289322,\n", - " (2060, 4): 36.8174147605896,\n", - " (2060, 5): 3.292080879211426,\n", - " (2060, 6): 0.0,\n", - " (2060, 7): 1.1818259954452515,\n", - " (2060, 8): 3.6678138971328735,\n", - " (2060, 9): 2.7209075689315796,\n", - " (2060, 10): 5.511987686157227,\n", - " (2060, 11): 45.11414396762848,\n", - " (2060, 12): 142.75430929660797},\n", - " 'window': {(2060, 1): 43.579739809036255,\n", - " (2060, 2): 54.35509920120239,\n", - " (2060, 3): 45.67604112625122,\n", - " (2060, 4): 18.890052556991577,\n", - " (2060, 5): 2.2900381088256836,\n", - " (2060, 6): 0.0,\n", - " (2060, 7): 1.1818259954452515,\n", - " (2060, 8): 3.6678138971328735,\n", - " (2060, 9): 1.6096243858337402,\n", - " (2060, 10): 5.511987686157227,\n", - " (2060, 11): 30.31050205230713,\n", - " (2060, 12): 75.44825077056885}},\n", - " 300: {'monthly': {(2060, 1): 192.28769659996033,\n", - " (2060, 2): 269.20401406288147,\n", - " (2060, 3): 194.6529768705368,\n", - " (2060, 4): 47.957080602645874,\n", - " (2060, 5): 2.9140249490737915,\n", - " (2060, 6): 2.3992990255355835,\n", - " (2060, 7): 2.258692502975464,\n", - " (2060, 8): 8.626851797103882,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 2.4418424367904663,\n", - " (2060, 11): 42.47283232212067,\n", - " (2060, 12): 204.96729183197021},\n", - " 'window': {(2060, 1): 51.83346462249756,\n", - " (2060, 2): 77.4365725517273,\n", - " (2060, 3): 53.1937689781189,\n", - " (2060, 4): 33.905452847480774,\n", - " (2060, 5): 1.8732038736343384,\n", - " (2060, 6): 1.2717193365097046,\n", - " (2060, 7): 1.2382659912109375,\n", - " (2060, 8): 6.286520004272461,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 1.2702500820159912,\n", - " (2060, 11): 24.601597785949707,\n", - " (2060, 12): 98.45725345611572}},\n", - " 301: {'monthly': {(2060, 1): 159.432781457901,\n", - " (2060, 2): 242.84446346759796,\n", - " (2060, 3): 137.34026098251343,\n", - " (2060, 4): 43.24192774295807,\n", - " (2060, 5): 4.259430885314941,\n", - " (2060, 6): 3.9823997020721436,\n", - " (2060, 7): 2.258692502975464,\n", - " (2060, 8): 8.626851797103882,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.5853527784347534,\n", - " (2060, 11): 39.52237069606781,\n", - " (2060, 12): 200.2691330909729},\n", - " 'window': {(2060, 1): 38.80760622024536,\n", - " (2060, 2): 75.02466011047363,\n", - " (2060, 3): 39.62159729003906,\n", - " (2060, 4): 31.347317337989807,\n", - " (2060, 5): 3.2186098098754883,\n", - " (2060, 6): 1.58310067653656,\n", - " (2060, 7): 1.2382659912109375,\n", - " (2060, 8): 6.286520004272461,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 2.4137604236602783,\n", - " (2060, 11): 23.389134883880615,\n", - " (2060, 12): 105.45851993560791}},\n", - " 302: {'monthly': {(2060, 1): 143.7444610595703,\n", - " (2060, 2): 232.4283493757248,\n", - " (2060, 3): 123.26553809642792,\n", - " (2060, 4): 47.376118540763855,\n", - " (2060, 5): 5.202957630157471,\n", - " (2060, 6): 4.446481347084045,\n", - " (2060, 7): 2.258692502975464,\n", - " (2060, 8): 8.406559705734253,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 3.561463236808777,\n", - " (2060, 11): 40.464364528656006,\n", - " (2060, 12): 199.46105015277863},\n", - " 'window': {(2060, 1): 33.29625654220581,\n", - " (2060, 2): 65.78070878982544,\n", - " (2060, 3): 32.89823389053345,\n", - " (2060, 4): 35.73164117336273,\n", - " (2060, 5): 4.162136554718018,\n", - " (2060, 6): 2.047182321548462,\n", - " (2060, 7): 1.2382659912109375,\n", - " (2060, 8): 6.066227912902832,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 2.3898708820343018,\n", - " (2060, 11): 24.125253677368164,\n", - " (2060, 12): 108.84042167663574}},\n", - " 303: {'monthly': {(2060, 1): 229.5492159128189,\n", - " (2060, 2): 276.69907534122467,\n", - " (2060, 3): 195.18038392066956,\n", - " (2060, 4): 101.50505018234253,\n", - " (2060, 5): 19.343570709228516,\n", - " (2060, 6): 11.087067008018494,\n", - " (2060, 7): 8.703584432601929,\n", - " (2060, 8): 14.485116124153137,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 10.68213975429535,\n", - " (2060, 11): 71.13867688179016,\n", - " (2060, 12): 241.29037070274353},\n", - " 'window': {(2060, 1): 66.23390817642212,\n", - " (2060, 2): 81.47225856781006,\n", - " (2060, 3): 41.89821767807007,\n", - " (2060, 4): 60.37638306617737,\n", - " (2060, 5): 11.663575530052185,\n", - " (2060, 6): 5.471638083457947,\n", - " (2060, 7): 3.2808117866516113,\n", - " (2060, 8): 8.850505352020264,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 5.67237401008606,\n", - " (2060, 11): 37.51217818260193,\n", - " (2060, 12): 111.44307231903076}},\n", - " 304: {'monthly': {(2060, 1): 286.3049873113632,\n", - " (2060, 2): 368.16447389125824,\n", - " (2060, 3): 385.85055899620056,\n", - " (2060, 4): 198.99863183498383,\n", - " (2060, 5): 32.821502447128296,\n", - " (2060, 6): 33.06886088848114,\n", - " (2060, 7): 19.562201619148254,\n", - " (2060, 8): 18.467347741127014,\n", - " (2060, 9): 12.977737307548523,\n", - " (2060, 10): 16.902153611183167,\n", - " (2060, 11): 128.72115087509155,\n", - " (2060, 12): 380.98357379436493},\n", - " 'window': {(2060, 1): 67.45153617858887,\n", - " (2060, 2): 98.13108539581299,\n", - " (2060, 3): 97.29019451141357,\n", - " (2060, 4): 96.95727682113647,\n", - " (2060, 5): 19.607909083366394,\n", - " (2060, 6): 12.076756954193115,\n", - " (2060, 7): 6.254428386688232,\n", - " (2060, 8): 15.92004382610321,\n", - " (2060, 9): 9.19075632095337,\n", - " (2060, 10): 11.90873110294342,\n", - " (2060, 11): 70.70736646652222,\n", - " (2060, 12): 165.5000400543213}},\n", - " 305: {'monthly': {(2060, 1): 345.4643483161926,\n", - " (2060, 2): 477.98455905914307,\n", - " (2060, 3): 524.5392971038818,\n", - " (2060, 4): 254.4755915403366,\n", - " (2060, 5): 39.17512118816376,\n", - " (2060, 6): 36.305203557014465,\n", - " (2060, 7): 22.36782479286194,\n", - " (2060, 8): 19.21171474456787,\n", - " (2060, 9): 9.918609976768494,\n", - " (2060, 10): 17.437370657920837,\n", - " (2060, 11): 182.29109716415405,\n", - " (2060, 12): 582.7370662689209},\n", - " 'window': {(2060, 1): 82.7620439529419,\n", - " (2060, 2): 141.27897262573242,\n", - " (2060, 3): 135.0885829925537,\n", - " (2060, 4): 134.29288721084595,\n", - " (2060, 5): 23.04376995563507,\n", - " (2060, 6): 13.577804803848267,\n", - " (2060, 7): 7.515873551368713,\n", - " (2060, 8): 15.507704615592957,\n", - " (2060, 9): 8.813008785247803,\n", - " (2060, 10): 14.23676609992981,\n", - " (2060, 11): 92.89720630645752,\n", - " (2060, 12): 266.4029369354248}},\n", - " 306: {'monthly': {(2060, 1): 356.5360565185547,\n", - " (2060, 2): 503.9673571586609,\n", - " (2060, 3): 499.95370054244995,\n", - " (2060, 4): 226.0541731119156,\n", - " (2060, 5): 28.517894744873047,\n", - " (2060, 6): 33.422006726264954,\n", - " (2060, 7): 22.057823419570923,\n", - " (2060, 8): 17.096804976463318,\n", - " (2060, 9): 6.953632950782776,\n", - " (2060, 10): 15.14041292667389,\n", - " (2060, 11): 202.3492956161499,\n", - " (2060, 12): 569.2568917274475},\n", - " 'window': {(2060, 1): 75.86386299133301,\n", - " (2060, 2): 159.41707038879395,\n", - " (2060, 3): 110.55237579345703,\n", - " (2060, 4): 115.60181188583374,\n", - " (2060, 5): 16.924604892730713,\n", - " (2060, 6): 12.744750022888184,\n", - " (2060, 7): 8.527568578720093,\n", - " (2060, 8): 11.73672091960907,\n", - " (2060, 9): 6.953632950782776,\n", - " (2060, 10): 11.429115056991577,\n", - " (2060, 11): 93.69571876525879,\n", - " (2060, 12): 243.78331470489502}},\n", - " 307: {'monthly': {(2060, 1): 374.32205963134766,\n", - " (2060, 2): 420.27388060092926,\n", - " (2060, 3): 376.09175992012024,\n", - " (2060, 4): 153.51423394680023,\n", - " (2060, 5): 30.334295630455017,\n", - " (2060, 6): 30.355931758880615,\n", - " (2060, 7): 19.145443439483643,\n", - " (2060, 8): 14.901206016540527,\n", - " (2060, 9): 3.5222620964050293,\n", - " (2060, 10): 9.79495656490326,\n", - " (2060, 11): 164.95454037189484,\n", - " (2060, 12): 413.12501668930054},\n", - " 'window': {(2060, 1): 79.61287117004395,\n", - " (2060, 2): 113.38627052307129,\n", - " (2060, 3): 74.28894996643066,\n", - " (2060, 4): 80.15976548194885,\n", - " (2060, 5): 12.79208779335022,\n", - " (2060, 6): 11.584104418754578,\n", - " (2060, 7): 7.999499559402466,\n", - " (2060, 8): 11.130141139030457,\n", - " (2060, 9): 3.5222620964050293,\n", - " (2060, 10): 7.465259790420532,\n", - " (2060, 11): 78.79061698913574,\n", - " (2060, 12): 164.3145513534546}},\n", - " 308: {'monthly': {(2060, 1): 324.08762514591217,\n", - " (2060, 2): 355.6747155189514,\n", - " (2060, 3): 237.8030767440796,\n", - " (2060, 4): 81.39760088920593,\n", - " (2060, 5): 19.897865176200867,\n", - " (2060, 6): 16.91952610015869,\n", - " (2060, 7): 11.48007619380951,\n", - " (2060, 8): 12.75532054901123,\n", - " (2060, 9): 7.411181926727295,\n", - " (2060, 10): 1.124501347541809,\n", - " (2060, 11): 65.523881316185,\n", - " (2060, 12): 300.5798771381378},\n", - " 'window': {(2060, 1): 78.87037992477417,\n", - " (2060, 2): 102.46298313140869,\n", - " (2060, 3): 54.07354164123535,\n", - " (2060, 4): 45.70363807678223,\n", - " (2060, 5): 7.689757585525513,\n", - " (2060, 6): 5.885278820991516,\n", - " (2060, 7): 4.2723517417907715,\n", - " (2060, 8): 8.677401423454285,\n", - " (2060, 9): 4.968779921531677,\n", - " (2060, 10): 1.124501347541809,\n", - " (2060, 11): 44.99549722671509,\n", - " (2060, 12): 85.31803703308105}},\n", - " 309: {'monthly': {(2060, 1): 252.30229449272156,\n", - " (2060, 2): 287.7807631492615,\n", - " (2060, 3): 211.60944879055023,\n", - " (2060, 4): 67.52161157131195,\n", - " (2060, 5): 8.043611526489258,\n", - " (2060, 6): 7.7573665380477905,\n", - " (2060, 7): 7.010338664054871,\n", - " (2060, 8): 10.04865550994873,\n", - " (2060, 9): 8.159376978874207,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 51.81781768798828,\n", - " (2060, 12): 251.63340651988983},\n", - " 'window': {(2060, 1): 63.48879623413086,\n", - " (2060, 2): 79.5995740890503,\n", - " (2060, 3): 45.241783142089844,\n", - " (2060, 4): 46.56393313407898,\n", - " (2060, 5): 5.735715627670288,\n", - " (2060, 6): 5.296633958816528,\n", - " (2060, 7): 3.5801315307617188,\n", - " (2060, 8): 8.776276350021362,\n", - " (2060, 9): 7.028193473815918,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 35.479352712631226,\n", - " (2060, 12): 75.77218723297119}},\n", - " 310: {'monthly': {(2060, 1): 214.68865489959717,\n", - " (2060, 2): 251.58649945259094,\n", - " (2060, 3): 205.33158445358276,\n", - " (2060, 4): 68.54109847545624,\n", - " (2060, 5): 6.715879678726196,\n", - " (2060, 6): 6.16838526725769,\n", - " (2060, 7): 7.010338664054871,\n", - " (2060, 8): 9.822864413261414,\n", - " (2060, 9): 10.07574737071991,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 52.740705728530884,\n", - " (2060, 12): 236.95231866836548},\n", - " 'window': {(2060, 1): 56.46764945983887,\n", - " (2060, 2): 72.80794048309326,\n", - " (2060, 3): 44.36585760116577,\n", - " (2060, 4): 48.76756477355957,\n", - " (2060, 5): 4.529953718185425,\n", - " (2060, 6): 3.6981234550476074,\n", - " (2060, 7): 3.5801315307617188,\n", - " (2060, 8): 8.550485253334045,\n", - " (2060, 9): 8.944563865661621,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 35.87619614601135,\n", - " (2060, 12): 75.88614654541016}},\n", - " 311: {'monthly': {(2060, 1): 234.83245420455933,\n", - " (2060, 2): 267.63527739048004,\n", - " (2060, 3): 214.11063158512115,\n", - " (2060, 4): 67.46564984321594,\n", - " (2060, 5): 5.092434525489807,\n", - " (2060, 6): 4.494784235954285,\n", - " (2060, 7): 7.010338664054871,\n", - " (2060, 8): 9.822864413261414,\n", - " (2060, 9): 11.60684883594513,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 56.43745005130768,\n", - " (2060, 12): 237.45928120613098},\n", - " 'window': {(2060, 1): 59.0307674407959,\n", - " (2060, 2): 84.35773277282715,\n", - " (2060, 3): 45.98740100860596,\n", - " (2060, 4): 49.07197093963623,\n", - " (2060, 5): 4.078898906707764,\n", - " (2060, 6): 2.460732579231262,\n", - " (2060, 7): 3.5801315307617188,\n", - " (2060, 8): 8.550485253334045,\n", - " (2060, 9): 10.47566533088684,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 39.340442180633545,\n", - " (2060, 12): 77.19342994689941}},\n", - " 312: {'monthly': {(2060, 1): 231.85411155223846,\n", - " (2060, 2): 267.8768970966339,\n", - " (2060, 3): 189.6846684217453,\n", - " (2060, 4): 48.80300426483154,\n", - " (2060, 5): 3.292080879211426,\n", - " (2060, 6): 0.0,\n", - " (2060, 7): 1.1818259954452515,\n", - " (2060, 8): 3.6678138971328735,\n", - " (2060, 9): 2.7209075689315796,\n", - " (2060, 10): 6.021319270133972,\n", - " (2060, 11): 47.624624133110046,\n", - " (2060, 12): 172.26119923591614},\n", - " 'window': {(2060, 1): 55.56057262420654,\n", - " (2060, 2): 68.45817637443542,\n", - " (2060, 3): 45.738462924957275,\n", - " (2060, 4): 26.363823413848877,\n", - " (2060, 5): 2.2900381088256836,\n", - " (2060, 6): 0.0,\n", - " (2060, 7): 1.1818259954452515,\n", - " (2060, 8): 3.6678138971328735,\n", - " (2060, 9): 1.6096243858337402,\n", - " (2060, 10): 6.021319270133972,\n", - " (2060, 11): 31.14918565750122,\n", - " (2060, 12): 77.3136796951294}},\n", - " 313: {'monthly': {(2060, 1): 235.1071718931198,\n", - " (2060, 2): 311.5002361536026,\n", - " (2060, 3): 235.78783094882965,\n", - " (2060, 4): 78.87877357006073,\n", - " (2060, 5): 3.599635362625122,\n", - " (2060, 6): 3.6578736305236816,\n", - " (2060, 7): 2.258692502975464,\n", - " (2060, 8): 8.626851797103882,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 4.002659797668457,\n", - " (2060, 11): 50.982998967170715,\n", - " (2060, 12): 216.04162991046906},\n", - " 'window': {(2060, 1): 75.48440933227539,\n", - " (2060, 2): 90.32378482818604,\n", - " (2060, 3): 63.4071307182312,\n", - " (2060, 4): 60.0803028345108,\n", - " (2060, 5): 2.558814287185669,\n", - " (2060, 6): 1.2717193365097046,\n", - " (2060, 7): 1.2382659912109375,\n", - " (2060, 8): 6.286520004272461,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 2.831067442893982,\n", - " (2060, 11): 27.277641773223877,\n", - " (2060, 12): 91.14862823486328}},\n", - " 314: {'monthly': {(2060, 1): 187.02880716323853,\n", - " (2060, 2): 266.47056210041046,\n", - " (2060, 3): 163.27308917045593,\n", - " (2060, 4): 73.701491355896,\n", - " (2060, 5): 5.606431007385254,\n", - " (2060, 6): 4.644933104515076,\n", - " (2060, 7): 2.258692502975464,\n", - " (2060, 8): 8.626851797103882,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 4.117628455162048,\n", - " (2060, 11): 48.98021650314331,\n", - " (2060, 12): 199.93300247192383},\n", - " 'window': {(2060, 1): 48.002370834350586,\n", - " (2060, 2): 81.05459403991699,\n", - " (2060, 3): 41.80525875091553,\n", - " (2060, 4): 56.95696699619293,\n", - " (2060, 5): 4.565609931945801,\n", - " (2060, 6): 2.245634078979492,\n", - " (2060, 7): 1.2382659912109375,\n", - " (2060, 8): 6.286520004272461,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 2.9460361003875732,\n", - " (2060, 11): 26.889230012893677,\n", - " (2060, 12): 88.10031509399414}},\n", - " 315: {'monthly': {(2060, 1): 156.15814018249512,\n", - " (2060, 2): 229.92984557151794,\n", - " (2060, 3): 141.39503455162048,\n", - " (2060, 4): 80.42218041419983,\n", - " (2060, 5): 8.188782453536987,\n", - " (2060, 6): 5.352041840553284,\n", - " (2060, 7): 2.258692502975464,\n", - " (2060, 8): 7.815626263618469,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 5.198745608329773,\n", - " (2060, 11): 46.03838336467743,\n", - " (2060, 12): 197.27219212055206},\n", - " 'window': {(2060, 1): 38.07924222946167,\n", - " (2060, 2): 65.86176490783691,\n", - " (2060, 3): 30.658414363861084,\n", - " (2060, 4): 64.26833951473236,\n", - " (2060, 5): 6.003236293792725,\n", - " (2060, 6): 2.9527428150177,\n", - " (2060, 7): 1.2382659912109375,\n", - " (2060, 8): 5.475294470787048,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 4.027153253555298,\n", - " (2060, 11): 26.952005624771118,\n", - " (2060, 12): 89.5875129699707}},\n", - " 316: {'monthly': {(2060, 1): 242.48321652412415,\n", - " (2060, 2): 290.6327086687088,\n", - " (2060, 3): 213.42889261245728,\n", - " (2060, 4): 126.31227934360504,\n", - " (2060, 5): 34.59924042224884,\n", - " (2060, 6): 15.79365336894989,\n", - " (2060, 7): 10.483021259307861,\n", - " (2060, 8): 13.718164086341858,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 10.335256934165955,\n", - " (2060, 11): 73.09085786342621,\n", - " (2060, 12): 280.1888357400894},\n", - " 'window': {(2060, 1): 61.67488098144531,\n", - " (2060, 2): 80.2793378829956,\n", - " (2060, 3): 44.61563777923584,\n", - " (2060, 4): 80.05251348018646,\n", - " (2060, 5): 12.88011384010315,\n", - " (2060, 6): 7.31502890586853,\n", - " (2060, 7): 3.3550719022750854,\n", - " (2060, 8): 9.802739143371582,\n", - " (2060, 9): 0.0,\n", - " (2060, 10): 6.887852907180786,\n", - " (2060, 11): 39.34543585777283,\n", - " (2060, 12): 127.39465713500977}},\n", - " 317: {'monthly': {(2060, 1): 323.76948142051697,\n", - " (2060, 2): 388.57100903987885,\n", - " (2060, 3): 374.77672719955444,\n", - " (2060, 4): 203.80471003055573,\n", - " (2060, 5): 36.620814085006714,\n", - " (2060, 6): 30.417839646339417,\n", - " (2060, 7): 19.68389141559601,\n", - " (2060, 8): 21.083872079849243,\n", - " (2060, 9): 10.379504799842834,\n", - " (2060, 10): 12.978933811187744,\n", - " (2060, 11): 126.31453514099121,\n", - " (2060, 12): 343.5784600973129},\n", - " 'window': {(2060, 1): 77.2700080871582,\n", - " (2060, 2): 111.37731075286865,\n", - " (2060, 3): 97.51545810699463,\n", - " (2060, 4): 113.90575313568115,\n", - " (2060, 5): 21.010846972465515,\n", - " (2060, 6): 12.847699165344238,\n", - " (2060, 7): 7.514625072479248,\n", - " (2060, 8): 16.8264479637146,\n", - " (2060, 9): 7.724217891693115,\n", - " (2060, 10): 11.68196153640747,\n", - " (2060, 11): 63.0115327835083,\n", - " (2060, 12): 147.3129940032959}},\n", - " 318: {'monthly': {(2060, 1): 361.10884714126587,\n", - " (2060, 2): 495.1886291503906,\n", - " (2060, 3): 486.4710006713867,\n", - " (2060, 4): 261.85610592365265,\n", - " (2060, 5): 38.07160186767578,\n", - " (2060, 6): 35.716832637786865,\n", - " (2060, 7): 18.858518719673157,\n", - " (2060, 8): 17.88309919834137,\n", - " (2060, 9): 9.602959752082825,\n", - " (2060, 10): 20.554896235466003,\n", - " (2060, 11): 145.39918220043182,\n", - " (2060, 12): 493.17704701423645},\n", - " 'window': {(2060, 1): 94.31044483184814,\n", - " (2060, 2): 156.71536445617676,\n", - " (2060, 3): 125.48072052001953,\n", - " (2060, 4): 154.84210300445557,\n", - " (2060, 5): 21.39246141910553,\n", - " (2060, 6): 16.12726664543152,\n", - " (2060, 7): 7.261463522911072,\n", - " (2060, 8): 15.335795283317566,\n", - " (2060, 9): 6.882046818733215,\n", - " (2060, 10): 14.404793500900269,\n", - " (2060, 11): 78.47064208984375,\n", - " (2060, 12): 229.49969863891602}},\n", - " 319: {'monthly': {(2060, 1): 414.6603744029999,\n", - " (2060, 2): 543.4001120328903,\n", - " (2060, 3): 611.299156665802,\n", - " (2060, 4): 370.06138849258423,\n", - " (2060, 5): 39.9959214925766,\n", - " (2060, 6): 43.53111910820007,\n", - " (2060, 7): 27.353806257247925,\n", - " (2060, 8): 24.21929395198822,\n", - " (2060, 9): 12.317183256149292,\n", - " (2060, 10): 24.542168974876404,\n", - " (2060, 11): 196.79199874401093,\n", - " (2060, 12): 573.713045835495},\n", - " 'window': {(2060, 1): 86.5131664276123,\n", - " (2060, 2): 181.28362655639648,\n", - " (2060, 3): 139.15266799926758,\n", - " (2060, 4): 195.57330131530762,\n", - " (2060, 5): 20.178810477256775,\n", - " (2060, 6): 16.35908079147339,\n", - " (2060, 7): 9.279421925544739,\n", - " (2060, 8): 14.987094163894653,\n", - " (2060, 9): 9.723015427589417,\n", - " (2060, 10): 13.9184410572052,\n", - " (2060, 11): 88.05908584594727,\n", - " (2060, 12): 218.2049903869629}},\n", - " 320: {'monthly': {(2060, 1): 447.5650408267975,\n", - " (2060, 2): 455.98753547668457,\n", - " (2060, 3): 484.0131165981293,\n", - " (2060, 4): 280.180123090744,\n", - " (2060, 5): 36.772677063941956,\n", - " (2060, 6): 37.084500789642334,\n", - " (2060, 7): 22.61902403831482,\n", - " (2060, 8): 18.78800368309021,\n", - " (2060, 9): 11.461910486221313,\n", - " (2060, 10): 11.462186694145203,\n", - " (2060, 11): 158.9477537870407,\n", - " (2060, 12): 420.6478387117386},\n", - " 'window': {(2060, 1): 102.83336925506592,\n", - " (2060, 2): 127.29962730407715,\n", - " (2060, 3): 94.38322639465332,\n", - " (2060, 4): 156.42361879348755,\n", - " (2060, 5): 13.80662488937378,\n", - " (2060, 6): 13.62432873249054,\n", - " (2060, 7): 7.936240196228027,\n", - " (2060, 8): 13.941397547721863,\n", - " (2060, 9): 7.3772953748703,\n", - " (2060, 10): 7.377317309379578,\n", - " (2060, 11): 71.12933731079102,\n", - " (2060, 12): 144.11049461364746}},\n", - " 321: {'monthly': {(2060, 1): 318.3745404481888,\n", - " (2060, 2): 336.4817819595337,\n", - " (2060, 3): 260.083132982254,\n", - " (2060, 4): 81.76292133331299,\n", - " (2060, 5): 18.456592202186584,\n", - " (2060, 6): 9.98252522945404,\n", - " (2060, 7): 14.849759936332703,\n", - " (2060, 8): 16.542168140411377,\n", - " (2060, 9): 6.62043821811676,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 69.37199795246124,\n", - " (2060, 12): 297.42467737197876},\n", - " 'window': {(2060, 1): 78.91654205322266,\n", - " (2060, 2): 88.24513816833496,\n", - " (2060, 3): 59.431867599487305,\n", - " (2060, 4): 39.61622476577759,\n", - " (2060, 5): 9.175816416740417,\n", - " (2060, 6): 4.241950869560242,\n", - " (2060, 7): 5.531574726104736,\n", - " (2060, 8): 8.57720959186554,\n", - " (2060, 9): 5.351680517196655,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 43.06766939163208,\n", - " (2060, 12): 77.0624008178711}},\n", - " 322: {'monthly': {(2060, 1): 257.52895998954773,\n", - " (2060, 2): 282.8089334964752,\n", - " (2060, 3): 225.6688847541809,\n", - " (2060, 4): 61.32001864910126,\n", - " (2060, 5): 6.969274163246155,\n", - " (2060, 6): 6.04094934463501,\n", - " (2060, 7): 7.010338664054871,\n", - " (2060, 8): 9.849279403686523,\n", - " (2060, 9): 8.343949675559998,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 53.74708008766174,\n", - " (2060, 12): 252.6119086742401},\n", - " 'window': {(2060, 1): 67.97977542877197,\n", - " (2060, 2): 76.89173030853271,\n", - " (2060, 3): 48.686495304107666,\n", - " (2060, 4): 38.77082395553589,\n", - " (2060, 5): 4.815142393112183,\n", - " (2060, 6): 3.5802167654037476,\n", - " (2060, 7): 3.5801315307617188,\n", - " (2060, 8): 8.550485253334045,\n", - " (2060, 9): 7.212766170501709,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 35.074363470077515,\n", - " (2060, 12): 67.75899505615234}},\n", - " 323: {'monthly': {(2060, 1): 250.84036302566528,\n", - " (2060, 2): 277.95685338974,\n", - " (2060, 3): 238.2347857952118,\n", - " (2060, 4): 76.9826432466507,\n", - " (2060, 5): 9.056820273399353,\n", - " (2060, 6): 7.632060647010803,\n", - " (2060, 7): 7.010338664054871,\n", - " (2060, 8): 9.822864413261414,\n", - " (2060, 9): 12.893023371696472,\n", - " (2060, 10): 1.0671669244766235,\n", - " (2060, 11): 53.39226758480072,\n", - " (2060, 12): 237.1059854030609},\n", - " 'window': {(2060, 1): 64.32609939575195,\n", - " (2060, 2): 83.9614953994751,\n", - " (2060, 3): 48.83942890167236,\n", - " (2060, 4): 44.42813730239868,\n", - " (2060, 5): 5.447580337524414,\n", - " (2060, 6): 5.122602105140686,\n", - " (2060, 7): 3.5801315307617188,\n", - " (2060, 8): 8.550485253334045,\n", - " (2060, 9): 11.55569076538086,\n", - " (2060, 10): 1.0671669244766235,\n", - " (2060, 11): 34.47470211982727,\n", - " (2060, 12): 64.99096202850342}},\n", - " 324: {'monthly': {(2060, 1): 261.2565141916275,\n", - " (2060, 2): 274.5338225364685,\n", - " (2060, 3): 216.11802637577057,\n", - " (2060, 4): 65.4229542016983,\n", - " (2060, 5): 7.334280490875244,\n", - " (2060, 6): 6.930915355682373,\n", - " (2060, 7): 7.010338664054871,\n", - " (2060, 8): 9.822864413261414,\n", - " (2060, 9): 14.61353862285614,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 50.72331213951111,\n", - " (2060, 12): 207.98114264011383},\n", - " 'window': {(2060, 1): 64.53420829772949,\n", - " (2060, 2): 85.45580101013184,\n", - " (2060, 3): 45.63752841949463,\n", - " (2060, 4): 39.9321346282959,\n", - " (2060, 5): 5.027302265167236,\n", - " (2060, 6): 4.470182776451111,\n", - " (2060, 7): 3.5801315307617188,\n", - " (2060, 8): 8.550485253334045,\n", - " (2060, 9): 13.482355117797852,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 32.33515214920044,\n", - " (2060, 12): 65.45744514465332}},\n", - " 325: {'monthly': {(2060, 1): 204.06694984436035,\n", - " (2060, 2): 240.01872885227203,\n", - " (2060, 3): 249.32794606685638,\n", - " (2060, 4): 73.47641050815582,\n", - " (2060, 5): 1.1718651056289673,\n", - " (2060, 6): 1.522081732749939,\n", - " (2060, 7): 3.6192963123321533,\n", - " (2060, 8): 4.0284528732299805,\n", - " (2060, 9): 1.0813854932785034,\n", - " (2060, 10): 4.884735584259033,\n", - " (2060, 11): 36.5224426984787,\n", - " (2060, 12): 209.9024921655655},\n", - " 'window': {(2060, 1): 50.90989923477173,\n", - " (2060, 2): 81.84484052658081,\n", - " (2060, 3): 82.97240447998047,\n", - " (2060, 4): 42.52574348449707,\n", - " (2060, 5): 1.1718651056289673,\n", - " (2060, 6): 1.522081732749939,\n", - " (2060, 7): 2.2391775846481323,\n", - " (2060, 8): 4.0284528732299805,\n", - " (2060, 9): 1.0813854932785034,\n", - " (2060, 10): 4.884735584259033,\n", - " (2060, 11): 20.221129775047302,\n", - " (2060, 12): 81.39108943939209}},\n", - " 326: {'monthly': {(2060, 1): 239.92245745658875,\n", - " (2060, 2): 250.52308583259583,\n", - " (2060, 3): 278.4651598930359,\n", - " (2060, 4): 78.76438999176025,\n", - " (2060, 5): 2.621748685836792,\n", - " (2060, 6): 2.718304991722107,\n", - " (2060, 7): 4.785010933876038,\n", - " (2060, 8): 9.910064220428467,\n", - " (2060, 9): 1.0253710746765137,\n", - " (2060, 10): 5.807175278663635,\n", - " (2060, 11): 99.55683600902557,\n", - " (2060, 12): 258.1148302555084},\n", - " 'window': {(2060, 1): 57.91945552825928,\n", - " (2060, 2): 62.72000694274902,\n", - " (2060, 3): 66.04140567779541,\n", - " (2060, 4): 34.63269591331482,\n", - " (2060, 5): 1.61881422996521,\n", - " (2060, 6): 1.6488581895828247,\n", - " (2060, 7): 2.56003201007843,\n", - " (2060, 8): 6.730392694473267,\n", - " (2060, 9): 1.0253710746765137,\n", - " (2060, 10): 3.5159581899642944,\n", - " (2060, 11): 55.48629713058472,\n", - " (2060, 12): 66.44921016693115}},\n", - " 327: {'monthly': {(2060, 1): 230.52750062942505,\n", - " (2060, 2): 330.4089665412903,\n", - " (2060, 3): 330.5433895587921,\n", - " (2060, 4): 100.26279437541962,\n", - " (2060, 5): 3.7861801385879517,\n", - " (2060, 6): 2.718304991722107,\n", - " (2060, 7): 4.785010933876038,\n", - " (2060, 8): 9.606390476226807,\n", - " (2060, 9): 2.1960357427597046,\n", - " (2060, 10): 3.33668053150177,\n", - " (2060, 11): 92.68077671527863,\n", - " (2060, 12): 279.06420052051544},\n", - " 'window': {(2060, 1): 49.91779708862305,\n", - " (2060, 2): 92.54422664642334,\n", - " (2060, 3): 80.53018856048584,\n", - " (2060, 4): 51.53351831436157,\n", - " (2060, 5): 1.61881422996521,\n", - " (2060, 6): 1.6488581895828247,\n", - " (2060, 7): 2.56003201007843,\n", - " (2060, 8): 6.4267189502716064,\n", - " (2060, 9): 2.1960357427597046,\n", - " (2060, 10): 2.326836347579956,\n", - " (2060, 11): 52.5392861366272,\n", - " (2060, 12): 86.54827785491943}},\n", - " 328: {'monthly': {(2060, 1): 261.81486082077026,\n", - " (2060, 2): 467.42894995212555,\n", - " (2060, 3): 410.07945013046265,\n", - " (2060, 4): 118.74841129779816,\n", - " (2060, 5): 2.621748685836792,\n", - " (2060, 6): 3.364638328552246,\n", - " (2060, 7): 4.785010933876038,\n", - " (2060, 8): 9.428947806358337,\n", - " (2060, 9): 2.3461174964904785,\n", - " (2060, 10): 3.8417261838912964,\n", - " (2060, 11): 92.99109256267548,\n", - " (2060, 12): 346.28338384628296},\n", - " 'window': {(2060, 1): 55.14768886566162,\n", - " (2060, 2): 146.82424354553223,\n", - " (2060, 3): 129.0033187866211,\n", - " (2060, 4): 68.72570705413818,\n", - " (2060, 5): 1.61881422996521,\n", - " (2060, 6): 2.295191526412964,\n", - " (2060, 7): 2.56003201007843,\n", - " (2060, 8): 6.249276280403137,\n", - " (2060, 9): 2.3461174964904785,\n", - " (2060, 10): 2.8318819999694824,\n", - " (2060, 11): 49.815393924713135,\n", - " (2060, 12): 128.3949155807495}},\n", - " 329: {'monthly': {(2060, 1): 346.5860562324524,\n", - " (2060, 2): 512.2330849170685,\n", - " (2060, 3): 453.5737929344177,\n", - " (2060, 4): 129.885679602623,\n", - " (2060, 5): 14.622605443000793,\n", - " (2060, 6): 4.06402850151062,\n", - " (2060, 7): 9.399706244468689,\n", - " (2060, 8): 14.503178358078003,\n", - " (2060, 9): 4.37141478061676,\n", - " (2060, 10): 14.643278241157532,\n", - " (2060, 11): 98.85794293880463,\n", - " (2060, 12): 404.11642158031464},\n", - " 'window': {(2060, 1): 83.61321258544922,\n", - " (2060, 2): 152.2334327697754,\n", - " (2060, 3): 141.650484085083,\n", - " (2060, 4): 67.41584539413452,\n", - " (2060, 5): 7.5846110582351685,\n", - " (2060, 6): 1.546673059463501,\n", - " (2060, 7): 3.3970965147018433,\n", - " (2060, 8): 8.96994423866272,\n", - " (2060, 9): 2.403505563735962,\n", - " (2060, 10): 6.184636354446411,\n", - " (2060, 11): 50.86743116378784,\n", - " (2060, 12): 139.36726474761963}},\n", - " 330: {'monthly': {(2060, 1): 409.1156177520752,\n", - " (2060, 2): 461.80810129642487,\n", - " (2060, 3): 466.9783866405487,\n", - " (2060, 4): 180.76808202266693,\n", - " (2060, 5): 25.597835183143616,\n", - " (2060, 6): 26.483270287513733,\n", - " (2060, 7): 17.64481222629547,\n", - " (2060, 8): 21.699496388435364,\n", - " (2060, 9): 6.142277479171753,\n", - " (2060, 10): 12.709834814071655,\n", - " (2060, 11): 118.11068546772003,\n", - " (2060, 12): 462.3707537651062},\n", - " 'window': {(2060, 1): 90.0973572731018,\n", - " (2060, 2): 116.8556957244873,\n", - " (2060, 3): 115.18067169189453,\n", - " (2060, 4): 90.97726273536682,\n", - " (2060, 5): 14.416706085205078,\n", - " (2060, 6): 11.238561987876892,\n", - " (2060, 7): 6.940089225769043,\n", - " (2060, 8): 15.60996425151825,\n", - " (2060, 9): 6.142277479171753,\n", - " (2060, 10): 8.914602279663086,\n", - " (2060, 11): 58.7033166885376,\n", - " (2060, 12): 188.50382041931152}},\n", - " 331: {'monthly': {(2060, 1): 313.1787374019623,\n", - " (2060, 2): 517.4224714040756,\n", - " (2060, 3): 604.8676421642303,\n", - " (2060, 4): 249.03461027145386,\n", - " (2060, 5): 31.402528524398804,\n", - " (2060, 6): 28.944404363632202,\n", - " (2060, 7): 19.14192545413971,\n", - " (2060, 8): 28.09856867790222,\n", - " (2060, 9): 7.833306193351746,\n", - " (2060, 10): 7.014308929443359,\n", - " (2060, 11): 135.14713084697723,\n", - " (2060, 12): 405.1510201692581},\n", - " 'window': {(2060, 1): 78.95142078399658,\n", - " (2060, 2): 135.93392658233643,\n", - " (2060, 3): 169.5727882385254,\n", - " (2060, 4): 131.98358631134033,\n", - " (2060, 5): 18.35032033920288,\n", - " (2060, 6): 10.81991183757782,\n", - " (2060, 7): 7.524036288261414,\n", - " (2060, 8): 16.6131854057312,\n", - " (2060, 9): 6.770453095436096,\n", - " (2060, 10): 4.851834774017334,\n", - " (2060, 11): 80.72745943069458,\n", - " (2060, 12): 155.74342155456543}},\n", - " 332: {'monthly': {(2060, 1): 345.6642884016037,\n", - " (2060, 2): 683.9787583351135,\n", - " (2060, 3): 796.3106722831726,\n", - " (2060, 4): 352.48460125923157,\n", - " (2060, 5): 53.93716096878052,\n", - " (2060, 6): 40.95262956619263,\n", - " (2060, 7): 33.82294416427612,\n", - " (2060, 8): 35.13508653640747,\n", - " (2060, 9): 27.83629024028778,\n", - " (2060, 10): 18.67145800590515,\n", - " (2060, 11): 238.70536398887634,\n", - " (2060, 12): 531.365382194519},\n", - " 'window': {(2060, 1): 92.33676624298096,\n", - " (2060, 2): 195.34413719177246,\n", - " (2060, 3): 192.51289558410645,\n", - " (2060, 4): 167.4296236038208,\n", - " (2060, 5): 24.86332654953003,\n", - " (2060, 6): 14.235512018203735,\n", - " (2060, 7): 11.547027468681335,\n", - " (2060, 8): 17.871357679367065,\n", - " (2060, 9): 16.01571774482727,\n", - " (2060, 10): 9.197280645370483,\n", - " (2060, 11): 134.46505451202393,\n", - " (2060, 12): 209.33059787750244}},\n", - " 333: {'monthly': {(2060, 1): 327.15588426589966,\n", - " (2060, 2): 470.0541898012161,\n", - " (2060, 3): 515.0862054824829,\n", - " (2060, 4): 221.25350546836853,\n", - " (2060, 5): 21.969499707221985,\n", - " (2060, 6): 17.763790011405945,\n", - " (2060, 7): 15.249377250671387,\n", - " (2060, 8): 21.167276859283447,\n", - " (2060, 9): 8.722000122070312,\n", - " (2060, 10): 9.812302350997925,\n", - " (2060, 11): 155.4708821773529,\n", - " (2060, 12): 427.7384841442108},\n", - " 'window': {(2060, 1): 70.78561401367188,\n", - " (2060, 2): 129.68968677520752,\n", - " (2060, 3): 119.34992790222168,\n", - " (2060, 4): 109.39538383483887,\n", - " (2060, 5): 12.388228178024292,\n", - " (2060, 6): 7.695016026496887,\n", - " (2060, 7): 5.818512678146362,\n", - " (2060, 8): 13.009060382843018,\n", - " (2060, 9): 7.660650968551636,\n", - " (2060, 10): 5.06686794757843,\n", - " (2060, 11): 87.7480640411377,\n", - " (2060, 12): 150.92417240142822}},\n", - " 334: {'monthly': {(2060, 1): 289.04424476623535,\n", - " (2060, 2): 294.56524658203125,\n", - " (2060, 3): 268.7170696258545,\n", - " (2060, 4): 73.80542397499084,\n", - " (2060, 5): 6.809992551803589,\n", - " (2060, 6): 3.136237859725952,\n", - " (2060, 7): 6.136355638504028,\n", - " (2060, 8): 7.928725719451904,\n", - " (2060, 9): 4.012435793876648,\n", - " (2060, 10): 2.854219079017639,\n", - " (2060, 11): 68.00390338897705,\n", - " (2060, 12): 230.82492351531982},\n", - " 'window': {(2060, 1): 73.02273273468018,\n", - " (2060, 2): 71.00387001037598,\n", - " (2060, 3): 55.70867681503296,\n", - " (2060, 4): 31.23416495323181,\n", - " (2060, 5): 2.8258938789367676,\n", - " (2060, 6): 1.7710520029067993,\n", - " (2060, 7): 3.304356336593628,\n", - " (2060, 8): 6.652172565460205,\n", - " (2060, 9): 4.012435793876648,\n", - " (2060, 10): 1.6034822463989258,\n", - " (2060, 11): 49.781275272369385,\n", - " (2060, 12): 71.35575485229492}},\n", - " 335: {'monthly': {(2060, 1): 246.25443410873413,\n", - " (2060, 2): 274.3319265842438,\n", - " (2060, 3): 256.34422850608826,\n", - " (2060, 4): 68.63920640945435,\n", - " (2060, 5): 5.948955774307251,\n", - " (2060, 6): 3.2573732137680054,\n", - " (2060, 7): 6.136355638504028,\n", - " (2060, 8): 7.979179382324219,\n", - " (2060, 9): 6.017698287963867,\n", - " (2060, 10): 1.0318509340286255,\n", - " (2060, 11): 59.43894445896149,\n", - " (2060, 12): 240.88771796226501},\n", - " 'window': {(2060, 1): 66.13899230957031,\n", - " (2060, 2): 68.36352252960205,\n", - " (2060, 3): 51.35929203033447,\n", - " (2060, 4): 31.865230083465576,\n", - " (2060, 5): 2.5017313957214355,\n", - " (2060, 6): 1.8921873569488525,\n", - " (2060, 7): 3.304356336593628,\n", - " (2060, 8): 6.652172565460205,\n", - " (2060, 9): 4.96204936504364,\n", - " (2060, 10): 1.0318509340286255,\n", - " (2060, 11): 45.646907806396484,\n", - " (2060, 12): 76.75045585632324}},\n", - " 336: {'monthly': {(2060, 1): 238.73774552345276,\n", - " (2060, 2): 286.8435094356537,\n", - " (2060, 3): 260.4265646934509,\n", - " (2060, 4): 82.80564987659454,\n", - " (2060, 5): 6.472376704216003,\n", - " (2060, 6): 4.322830319404602,\n", - " (2060, 7): 8.550599813461304,\n", - " (2060, 8): 8.1443589925766,\n", - " (2060, 9): 7.461447358131409,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 59.57136332988739,\n", - " (2060, 12): 266.36584091186523},\n", - " 'window': {(2060, 1): 64.12857437133789,\n", - " (2060, 2): 69.62133312225342,\n", - " (2060, 3): 51.792179107666016,\n", - " (2060, 4): 43.736928939819336,\n", - " (2060, 5): 2.689188241958618,\n", - " (2060, 6): 2.957644462585449,\n", - " (2060, 7): 4.475854754447937,\n", - " (2060, 8): 6.652172565460205,\n", - " (2060, 9): 7.461447358131409,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 47.7737398147583,\n", - " (2060, 12): 84.74117088317871}},\n", - " 337: {'monthly': {(2060, 1): 199.68462228775024,\n", - " (2060, 2): 274.7426315546036,\n", - " (2060, 3): 214.5858039855957,\n", - " (2060, 4): 80.36691224575043,\n", - " (2060, 5): 6.914445877075195,\n", - " (2060, 6): 4.108893990516663,\n", - " (2060, 7): 6.136355638504028,\n", - " (2060, 8): 7.928725719451904,\n", - " (2060, 9): 8.192137837409973,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 54.13109624385834,\n", - " (2060, 12): 242.082324385643},\n", - " 'window': {(2060, 1): 59.648988246917725,\n", - " (2060, 2): 86.2151288986206,\n", - " (2060, 3): 42.09515047073364,\n", - " (2060, 4): 52.24559211730957,\n", - " (2060, 5): 3.6492840051651,\n", - " (2060, 6): 2.7437081336975098,\n", - " (2060, 7): 3.304356336593628,\n", - " (2060, 8): 6.652172565460205,\n", - " (2060, 9): 8.192137837409973,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 43.532368659973145,\n", - " (2060, 12): 89.1660041809082}},\n", - " 338: {'monthly': {(2060, 1): 196.6614979505539,\n", - " (2060, 2): 243.6486999988556,\n", - " (2060, 3): 247.80265390872955,\n", - " (2060, 4): 76.94487118721008,\n", - " (2060, 5): 1.1718651056289673,\n", - " (2060, 6): 4.499007344245911,\n", - " (2060, 7): 3.6192963123321533,\n", - " (2060, 8): 4.0284528732299805,\n", - " (2060, 9): 1.0813854932785034,\n", - " (2060, 10): 6.018144965171814,\n", - " (2060, 11): 42.610841274261475,\n", - " (2060, 12): 204.6569401025772},\n", - " 'window': {(2060, 1): 41.948808431625366,\n", - " (2060, 2): 76.2960901260376,\n", - " (2060, 3): 73.76784038543701,\n", - " (2060, 4): 40.44823503494263,\n", - " (2060, 5): 1.1718651056289673,\n", - " (2060, 6): 3.102579951286316,\n", - " (2060, 7): 2.2391775846481323,\n", - " (2060, 8): 4.0284528732299805,\n", - " (2060, 9): 1.0813854932785034,\n", - " (2060, 10): 4.854893684387207,\n", - " (2060, 11): 21.923693895339966,\n", - " (2060, 12): 71.19762134552002}},\n", - " 339: {'monthly': {(2060, 1): 236.07335948944092,\n", - " (2060, 2): 248.09150457382202,\n", - " (2060, 3): 320.25356137752533,\n", - " (2060, 4): 123.82892417907715,\n", - " (2060, 5): 5.7799025774002075,\n", - " (2060, 6): 3.718465805053711,\n", - " (2060, 7): 4.785010933876038,\n", - " (2060, 8): 10.006234765052795,\n", - " (2060, 9): 1.0253710746765137,\n", - " (2060, 10): 4.712992906570435,\n", - " (2060, 11): 106.8265733718872,\n", - " (2060, 12): 283.2943550348282},\n", - " 'window': {(2060, 1): 60.173171520233154,\n", - " (2060, 2): 73.41222906112671,\n", - " (2060, 3): 72.81140804290771,\n", - " (2060, 4): 50.34809160232544,\n", - " (2060, 5): 1.6331837177276611,\n", - " (2060, 6): 2.6490190029144287,\n", - " (2060, 7): 2.56003201007843,\n", - " (2060, 8): 6.826563239097595,\n", - " (2060, 9): 1.0253710746765137,\n", - " (2060, 10): 3.7031487226486206,\n", - " (2060, 11): 55.09556865692139,\n", - " (2060, 12): 78.98067951202393}},\n", - " 340: {'monthly': {(2060, 1): 252.75798559188843,\n", - " (2060, 2): 416.01734805107117,\n", - " (2060, 3): 430.0748291015625,\n", - " (2060, 4): 147.02836978435516,\n", - " (2060, 5): 5.236335754394531,\n", - " (2060, 6): 4.39518404006958,\n", - " (2060, 7): 4.785010933876038,\n", - " (2060, 8): 9.668643951416016,\n", - " (2060, 9): 2.171023726463318,\n", - " (2060, 10): 5.650490164756775,\n", - " (2060, 11): 101.91759812831879,\n", - " (2060, 12): 335.6700849533081},\n", - " 'window': {(2060, 1): 56.080939292907715,\n", - " (2060, 2): 119.72209548950195,\n", - " (2060, 3): 121.42315101623535,\n", - " (2060, 4): 74.02804350852966,\n", - " (2060, 5): 2.9314340353012085,\n", - " (2060, 6): 2.018141508102417,\n", - " (2060, 7): 2.56003201007843,\n", - " (2060, 8): 6.488972425460815,\n", - " (2060, 9): 2.171023726463318,\n", - " (2060, 10): 3.390233635902405,\n", - " (2060, 11): 46.71034288406372,\n", - " (2060, 12): 120.82652187347412}},\n", - " 341: {'monthly': {(2060, 1): 355.86118364334106,\n", - " (2060, 2): 786.2856066226959,\n", - " (2060, 3): 697.528959274292,\n", - " (2060, 4): 219.775524020195,\n", - " (2060, 5): 8.067979574203491,\n", - " (2060, 6): 3.3074634075164795,\n", - " (2060, 7): 7.0876030921936035,\n", - " (2060, 8): 10.791634559631348,\n", - " (2060, 9): 2.9865834712982178,\n", - " (2060, 10): 8.059059739112854,\n", - " (2060, 11): 110.28496706485748,\n", - " (2060, 12): 538.8304561376572},\n", - " 'window': {(2060, 1): 85.89471435546875,\n", - " (2060, 2): 234.66506385803223,\n", - " (2060, 3): 287.06797790527344,\n", - " (2060, 4): 141.66243243217468,\n", - " (2060, 5): 3.0978310108184814,\n", - " (2060, 6): 1.1079045534133911,\n", - " (2060, 7): 3.775046467781067,\n", - " (2060, 8): 7.2404985427856445,\n", - " (2060, 9): 2.9865834712982178,\n", - " (2060, 10): 3.650738835334778,\n", - " (2060, 11): 51.986403942108154,\n", - " (2060, 12): 246.6108808517456}},\n", - " 342: {'monthly': {(2060, 1): 466.0975613594055,\n", - " (2060, 2): 846.9576933383942,\n", - " (2060, 3): 724.6536550521851,\n", - " (2060, 4): 214.8248815536499,\n", - " (2060, 5): 11.467145800590515,\n", - " (2060, 6): 11.990765810012817,\n", - " (2060, 7): 9.723935723304749,\n", - " (2060, 8): 16.645569801330566,\n", - " (2060, 9): 3.1247708797454834,\n", - " (2060, 10): 12.058597445487976,\n", - " (2060, 11): 107.39870691299438,\n", - " (2060, 12): 575.9961448907852},\n", - " 'window': {(2060, 1): 106.63678550720215,\n", - " (2060, 2): 234.47161674499512,\n", - " (2060, 3): 290.09761810302734,\n", - " (2060, 4): 131.5552260875702,\n", - " (2060, 5): 5.89457631111145,\n", - " (2060, 6): 5.286166071891785,\n", - " (2060, 7): 2.712918281555176,\n", - " (2060, 8): 10.308837056159973,\n", - " (2060, 9): 3.1247708797454834,\n", - " (2060, 10): 6.746284365653992,\n", - " (2060, 11): 54.66837024688721,\n", - " (2060, 12): 248.2869997024536}},\n", - " 343: {'monthly': {(2060, 1): 450.8669788837433,\n", - " (2060, 2): 592.7310566902161,\n", - " (2060, 3): 510.27507877349854,\n", - " (2060, 4): 153.8138850927353,\n", - " (2060, 5): 22.477348685264587,\n", - " (2060, 6): 24.410553812980652,\n", - " (2060, 7): 15.35745656490326,\n", - " (2060, 8): 20.038983464241028,\n", - " (2060, 9): 3.4818226099014282,\n", - " (2060, 10): 9.962348461151123,\n", - " (2060, 11): 100.51250064373016,\n", - " (2060, 12): 447.8894225358963},\n", - " 'window': {(2060, 1): 92.38302803039551,\n", - " (2060, 2): 196.21366786956787,\n", - " (2060, 3): 102.4187364578247,\n", - " (2060, 4): 68.31791543960571,\n", - " (2060, 5): 10.469895362854004,\n", - " (2060, 6): 10.335931658744812,\n", - " (2060, 7): 6.449223041534424,\n", - " (2060, 8): 13.583222389221191,\n", - " (2060, 9): 3.4818226099014282,\n", - " (2060, 10): 7.876975059509277,\n", - " (2060, 11): 47.35104465484619,\n", - " (2060, 12): 162.48946380615234}},\n", - " 344: {'monthly': {(2060, 1): 237.12140882015228,\n", - " (2060, 2): 501.2726094722748,\n", - " (2060, 3): 515.3474974632263,\n", - " (2060, 4): 198.8787318468094,\n", - " (2060, 5): 24.92254626750946,\n", - " (2060, 6): 24.613888144493103,\n", - " (2060, 7): 18.883243918418884,\n", - " (2060, 8): 20.845913887023926,\n", - " (2060, 9): 6.02359664440155,\n", - " (2060, 10): 5.0641255378723145,\n", - " (2060, 11): 99.56899666786194,\n", - " (2060, 12): 319.08381152153015},\n", - " 'window': {(2060, 1): 55.59299182891846,\n", - " (2060, 2): 139.58880043029785,\n", - " (2060, 3): 129.98376083374023,\n", - " (2060, 4): 97.98012375831604,\n", - " (2060, 5): 13.354044198989868,\n", - " (2060, 6): 10.044302225112915,\n", - " (2060, 7): 7.165194869041443,\n", - " (2060, 8): 15.240394234657288,\n", - " (2060, 9): 6.02359664440155,\n", - " (2060, 10): 4.024730443954468,\n", - " (2060, 11): 55.72497606277466,\n", - " (2060, 12): 126.46408271789551}},\n", - " 345: {'monthly': {(2060, 1): 259.2843728065491,\n", - " (2060, 2): 567.5823719501495,\n", - " (2060, 3): 607.22043800354,\n", - " (2060, 4): 272.8128105401993,\n", - " (2060, 5): 43.36185157299042,\n", - " (2060, 6): 42.97807991504669,\n", - " (2060, 7): 29.43623638153076,\n", - " (2060, 8): 41.81048560142517,\n", - " (2060, 9): 14.639759182929993,\n", - " (2060, 10): 11.362563729286194,\n", - " (2060, 11): 161.5791016817093,\n", - " (2060, 12): 392.10189151763916},\n", - " 'window': {(2060, 1): 62.184505462646484,\n", - " (2060, 2): 153.79089164733887,\n", - " (2060, 3): 153.3303565979004,\n", - " (2060, 4): 115.34127044677734,\n", - " (2060, 5): 18.21294069290161,\n", - " (2060, 6): 13.205578923225403,\n", - " (2060, 7): 11.902432799339294,\n", - " (2060, 8): 24.067588686943054,\n", - " (2060, 9): 9.210487127304077,\n", - " (2060, 10): 7.546357274055481,\n", - " (2060, 11): 83.39533567428589,\n", - " (2060, 12): 156.66726303100586}},\n", - " 346: {'monthly': {(2060, 1): 215.94798839092255,\n", - " (2060, 2): 357.53733372688293,\n", - " (2060, 3): 370.85581254959106,\n", - " (2060, 4): 152.21030807495117,\n", - " (2060, 5): 19.615840911865234,\n", - " (2060, 6): 16.128671169281006,\n", - " (2060, 7): 11.19538962841034,\n", - " (2060, 8): 17.8241468667984,\n", - " (2060, 9): 3.720525026321411,\n", - " (2060, 10): 5.8543795347213745,\n", - " (2060, 11): 104.3204197883606,\n", - " (2060, 12): 299.6629407405853},\n", - " 'window': {(2060, 1): 52.95824480056763,\n", - " (2060, 2): 99.89531326293945,\n", - " (2060, 3): 92.64968776702881,\n", - " (2060, 4): 67.06588411331177,\n", - " (2060, 5): 10.687390446662903,\n", - " (2060, 6): 5.663832783699036,\n", - " (2060, 7): 4.606552720069885,\n", - " (2060, 8): 13.057415962219238,\n", - " (2060, 9): 3.720525026321411,\n", - " (2060, 10): 3.7438268661499023,\n", - " (2060, 11): 53.77382564544678,\n", - " (2060, 12): 106.7774019241333}},\n", - " 347: {'monthly': {(2060, 1): 203.14503943920135,\n", - " (2060, 2): 248.66547775268555,\n", - " (2060, 3): 255.84123826026917,\n", - " (2060, 4): 67.45600020885468,\n", - " (2060, 5): 6.122791171073914,\n", - " (2060, 6): 3.173011302947998,\n", - " (2060, 7): 6.136355638504028,\n", - " (2060, 8): 7.993001341819763,\n", - " (2060, 9): 4.0907673835754395,\n", - " (2060, 10): 1.8497676849365234,\n", - " (2060, 11): 55.23644685745239,\n", - " (2060, 12): 189.13391613960266},\n", - " 'window': {(2060, 1): 59.824031829833984,\n", - " (2060, 2): 65.13785076141357,\n", - " (2060, 3): 49.42529058456421,\n", - " (2060, 4): 29.151182413101196,\n", - " (2060, 5): 2.560256838798523,\n", - " (2060, 6): 1.8078254461288452,\n", - " (2060, 7): 3.304356336593628,\n", - " (2060, 8): 6.652172565460205,\n", - " (2060, 9): 4.0907673835754395,\n", - " (2060, 10): 1.8497676849365234,\n", - " (2060, 11): 43.617690563201904,\n", - " (2060, 12): 62.79994010925293}},\n", - " 348: {'monthly': {(2060, 1): 202.58319699764252,\n", - " (2060, 2): 269.18113362789154,\n", - " (2060, 3): 291.4840512275696,\n", - " (2060, 4): 76.81268548965454,\n", - " (2060, 5): 6.5208083391189575,\n", - " (2060, 6): 3.521318554878235,\n", - " (2060, 7): 6.136355638504028,\n", - " (2060, 8): 7.928725719451904,\n", - " (2060, 9): 4.858142733573914,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 59.68911921977997,\n", - " (2060, 12): 222.94053745269775},\n", - " 'window': {(2060, 1): 57.35749435424805,\n", - " (2060, 2): 69.11109828948975,\n", - " (2060, 3): 56.121110916137695,\n", - " (2060, 4): 33.28881859779358,\n", - " (2060, 5): 2.698847770690918,\n", - " (2060, 6): 2.156132698059082,\n", - " (2060, 7): 3.304356336593628,\n", - " (2060, 8): 6.652172565460205,\n", - " (2060, 9): 4.858142733573914,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 46.997836112976074,\n", - " (2060, 12): 71.75605392456055}},\n", - " 349: {'monthly': {(2060, 1): 194.59171307086945,\n", - " (2060, 2): 288.0841221809387,\n", - " (2060, 3): 273.24060583114624,\n", - " (2060, 4): 81.0579879283905,\n", - " (2060, 5): 7.397412061691284,\n", - " (2060, 6): 4.192243456840515,\n", - " (2060, 7): 7.506986737251282,\n", - " (2060, 8): 8.329573154449463,\n", - " (2060, 9): 5.863115191459656,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 57.833771109580994,\n", - " (2060, 12): 234.10630095005035},\n", - " 'window': {(2060, 1): 51.253068923950195,\n", - " (2060, 2): 77.76940774917603,\n", - " (2060, 3): 54.29460525512695,\n", - " (2060, 4): 41.77508044242859,\n", - " (2060, 5): 3.536524534225464,\n", - " (2060, 6): 2.8270576000213623,\n", - " (2060, 7): 4.322759985923767,\n", - " (2060, 8): 6.652172565460205,\n", - " (2060, 9): 5.863115191459656,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 46.381587505340576,\n", - " (2060, 12): 81.44210147857666}},\n", - " 350: {'monthly': {(2060, 1): 169.8663945198059,\n", - " (2060, 2): 277.88165390491486,\n", - " (2060, 3): 213.0350775718689,\n", - " (2060, 4): 78.07126879692078,\n", - " (2060, 5): 7.341100096702576,\n", - " (2060, 6): 3.982678174972534,\n", - " (2060, 7): 7.271059513092041,\n", - " (2060, 8): 7.934629559516907,\n", - " (2060, 9): 5.836790919303894,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 51.90357720851898,\n", - " (2060, 12): 209.56952321529388},\n", - " 'window': {(2060, 1): 56.91520023345947,\n", - " (2060, 2): 84.68766212463379,\n", - " (2060, 3): 40.44032573699951,\n", - " (2060, 4): 48.723527669906616,\n", - " (2060, 5): 3.4409881830215454,\n", - " (2060, 6): 2.4926552772521973,\n", - " (2060, 7): 3.304356336593628,\n", - " (2060, 8): 6.6580764055252075,\n", - " (2060, 9): 5.836790919303894,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 41.807677268981934,\n", - " (2060, 12): 84.38853454589844}},\n", - " 351: {'monthly': {(2060, 1): 182.6605886220932,\n", - " (2060, 2): 235.39930772781372,\n", - " (2060, 3): 220.55295062065125,\n", - " (2060, 4): 74.0026763677597,\n", - " (2060, 5): 3.352949023246765,\n", - " (2060, 6): 0.0,\n", - " (2060, 7): 3.6192963123321533,\n", - " (2060, 8): 4.0284528732299805,\n", - " (2060, 9): 1.0813854932785034,\n", - " (2060, 10): 5.405711650848389,\n", - " (2060, 11): 43.98092496395111,\n", - " (2060, 12): 182.06399619579315},\n", - " 'window': {(2060, 1): 41.41898822784424,\n", - " (2060, 2): 68.76912879943848,\n", - " (2060, 3): 60.22817087173462,\n", - " (2060, 4): 33.764031410217285,\n", - " (2060, 5): 3.352949023246765,\n", - " (2060, 6): 0.0,\n", - " (2060, 7): 2.2391775846481323,\n", - " (2060, 8): 4.0284528732299805,\n", - " (2060, 9): 1.0813854932785034,\n", - " (2060, 10): 5.405711650848389,\n", - " (2060, 11): 23.061594486236572,\n", - " (2060, 12): 59.17633390426636}},\n", - " 352: {'monthly': {(2060, 1): 219.07606959342957,\n", - " (2060, 2): 248.95531487464905,\n", - " (2060, 3): 322.9546446800232,\n", - " (2060, 4): 122.6921056509018,\n", - " (2060, 5): 6.77974534034729,\n", - " (2060, 6): 2.5416990518569946,\n", - " (2060, 7): 4.785010933876038,\n", - " (2060, 8): 11.718188881874084,\n", - " (2060, 9): 1.0253710746765137,\n", - " (2060, 10): 5.362150192260742,\n", - " (2060, 11): 105.21905541419983,\n", - " (2060, 12): 257.1291016340256},\n", - " 'window': {(2060, 1): 47.29774618148804,\n", - " (2060, 2): 69.13233995437622,\n", - " (2060, 3): 73.18449020385742,\n", - " (2060, 4): 48.42260432243347,\n", - " (2060, 5): 2.8975894451141357,\n", - " (2060, 6): 1.4722522497177124,\n", - " (2060, 7): 2.56003201007843,\n", - " (2060, 8): 8.538517355918884,\n", - " (2060, 9): 1.0253710746765137,\n", - " (2060, 10): 3.0983375310897827,\n", - " (2060, 11): 53.629202365875244,\n", - " (2060, 12): 83.33568572998047}},\n", - " 353: {'monthly': {(2060, 1): 245.62861275672913,\n", - " (2060, 2): 351.1972134113312,\n", - " (2060, 3): 385.06077241897583,\n", - " (2060, 4): 130.98281276226044,\n", - " (2060, 5): 6.163888692855835,\n", - " (2060, 6): 5.295844554901123,\n", - " (2060, 7): 4.785010933876038,\n", - " (2060, 8): 15.384746551513672,\n", - " (2060, 9): 1.0253710746765137,\n", - " (2060, 10): 4.535965442657471,\n", - " (2060, 11): 99.38018023967743,\n", - " (2060, 12): 299.62617897987366},\n", - " 'window': {(2060, 1): 51.707051277160645,\n", - " (2060, 2): 96.54552745819092,\n", - " (2060, 3): 110.60523509979248,\n", - " (2060, 4): 58.81190752983093,\n", - " (2060, 5): 3.077075481414795,\n", - " (2060, 6): 2.7023699283599854,\n", - " (2060, 7): 2.56003201007843,\n", - " (2060, 8): 11.659184575080872,\n", - " (2060, 9): 1.0253710746765137,\n", - " (2060, 10): 3.5261212587356567,\n", - " (2060, 11): 50.10359048843384,\n", - " (2060, 12): 107.21811103820801}},\n", - " 354: {'monthly': {(2060, 1): 288.39294970035553,\n", - " (2060, 2): 581.0870609283447,\n", - " (2060, 3): 542.3800930976868,\n", - " (2060, 4): 190.96818280220032,\n", - " (2060, 5): 11.009727120399475,\n", - " (2060, 6): 2.0784695148468018,\n", - " (2060, 7): 4.840107560157776,\n", - " (2060, 8): 15.439595580101013,\n", - " (2060, 9): 3.084095001220703,\n", - " (2060, 10): 5.564296007156372,\n", - " (2060, 11): 90.46374785900116,\n", - " (2060, 12): 403.0808701515198},\n", - " 'window': {(2060, 1): 71.86436748504639,\n", - " (2060, 2): 156.34907913208008,\n", - " (2060, 3): 212.91047859191895,\n", - " (2060, 4): 122.69961524009705,\n", - " (2060, 5): 6.043999552726746,\n", - " (2060, 6): 2.0784695148468018,\n", - " (2060, 7): 2.6151286363601685,\n", - " (2060, 8): 11.049073338508606,\n", - " (2060, 9): 2.0583328008651733,\n", - " (2060, 10): 4.256815791130066,\n", - " (2060, 11): 46.598533153533936,\n", - " (2060, 12): 175.78947639465332}},\n", - " 355: {'monthly': {(2060, 1): 337.81268429756165,\n", - " (2060, 2): 600.2015764713287,\n", - " (2060, 3): 526.962812423706,\n", - " (2060, 4): 175.98721194267273,\n", - " (2060, 5): 5.323371052742004,\n", - " (2060, 6): 7.291415572166443,\n", - " (2060, 7): 8.677201271057129,\n", - " (2060, 8): 11.904772639274597,\n", - " (2060, 9): 1.0253710746765137,\n", - " (2060, 10): 6.4637370109558105,\n", - " (2060, 11): 84.4029688835144,\n", - " (2060, 12): 393.5348536968231},\n", - " 'window': {(2060, 1): 79.63152027130127,\n", - " (2060, 2): 158.30975914001465,\n", - " (2060, 3): 203.43828582763672,\n", - " (2060, 4): 116.06853485107422,\n", - " (2060, 5): 4.320436596870422,\n", - " (2060, 6): 2.8946402072906494,\n", - " (2060, 7): 3.6700860261917114,\n", - " (2060, 8): 8.725101113319397,\n", - " (2060, 9): 1.0253710746765137,\n", - " (2060, 10): 2.8388134241104126,\n", - " (2060, 11): 42.775792598724365,\n", - " (2060, 12): 163.13669872283936}},\n", - " 356: {'monthly': {(2060, 1): 301.87683844566345,\n", - " (2060, 2): 438.84221744537354,\n", - " (2060, 3): 393.05931544303894,\n", - " (2060, 4): 97.06803238391876,\n", - " (2060, 5): 14.559457063674927,\n", - " (2060, 6): 16.421231269836426,\n", - " (2060, 7): 11.455554604530334,\n", - " (2060, 8): 17.021863102912903,\n", - " (2060, 9): 6.725084066390991,\n", - " (2060, 10): 5.438904523849487,\n", - " (2060, 11): 66.54305589199066,\n", - " (2060, 12): 298.8861417770386},\n", - " 'window': {(2060, 1): 67.89023494720459,\n", - " (2060, 2): 138.19604873657227,\n", - " (2060, 3): 86.85419654846191,\n", - " (2060, 4): 38.623475313186646,\n", - " (2060, 5): 6.139068126678467,\n", - " (2060, 6): 5.529691815376282,\n", - " (2060, 7): 4.399170279502869,\n", - " (2060, 8): 11.908767938613892,\n", - " (2060, 9): 6.725084066390991,\n", - " (2060, 10): 4.399509429931641,\n", - " (2060, 11): 28.818098306655884,\n", - " (2060, 12): 102.3089542388916}},\n", - " 357: {'monthly': {(2060, 1): 203.66830134391785,\n", - " (2060, 2): 397.7060925960541,\n", - " (2060, 3): 413.55915355682373,\n", - " (2060, 4): 130.69854307174683,\n", - " (2060, 5): 20.814133048057556,\n", - " (2060, 6): 19.888506412506104,\n", - " (2060, 7): 16.682551622390747,\n", - " (2060, 8): 21.551636695861816,\n", - " (2060, 9): 5.481376647949219,\n", - " (2060, 10): 3.9288707971572876,\n", - " (2060, 11): 89.87154293060303,\n", - " (2060, 12): 292.38003396987915},\n", - " 'window': {(2060, 1): 51.57046461105347,\n", - " (2060, 2): 119.68313503265381,\n", - " (2060, 3): 114.4658374786377,\n", - " (2060, 4): 53.80711650848389,\n", - " (2060, 5): 9.830094814300537,\n", - " (2060, 6): 8.236461639404297,\n", - " (2060, 7): 6.638162612915039,\n", - " (2060, 8): 16.48213529586792,\n", - " (2060, 9): 5.481376647949219,\n", - " (2060, 10): 2.889475703239441,\n", - " (2060, 11): 47.28731346130371,\n", - " (2060, 12): 109.37532234191895}},\n", - " 358: {'monthly': {(2060, 1): 264.1998338699341,\n", - " (2060, 2): 440.37795650959015,\n", - " (2060, 3): 462.6942720413208,\n", - " (2060, 4): 187.5033152103424,\n", - " (2060, 5): 43.563448905944824,\n", - " (2060, 6): 35.635459780693054,\n", - " (2060, 7): 41.50910151004791,\n", - " (2060, 8): 38.76936709880829,\n", - " (2060, 9): 12.383973717689514,\n", - " (2060, 10): 8.075505375862122,\n", - " (2060, 11): 134.39883613586426,\n", - " (2060, 12): 358.72053265571594},\n", - " 'window': {(2060, 1): 65.65271949768066,\n", - " (2060, 2): 114.9453010559082,\n", - " (2060, 3): 125.55118083953857,\n", - " (2060, 4): 60.51179027557373,\n", - " (2060, 5): 13.828957080841064,\n", - " (2060, 6): 11.43546187877655,\n", - " (2060, 7): 12.6837637424469,\n", - " (2060, 8): 28.205679774284363,\n", - " (2060, 9): 9.579094409942627,\n", - " (2060, 10): 3.7452075481414795,\n", - " (2060, 11): 67.08031463623047,\n", - " (2060, 12): 118.67788410186768}},\n", - " 359: {'monthly': {(2060, 1): 178.1333109140396,\n", - " (2060, 2): 283.2431175708771,\n", - " (2060, 3): 284.83617186546326,\n", - " (2060, 4): 103.23764991760254,\n", - " (2060, 5): 16.92825150489807,\n", - " (2060, 6): 15.875644564628601,\n", - " (2060, 7): 12.488359570503235,\n", - " (2060, 8): 18.967225551605225,\n", - " (2060, 9): 5.044026136398315,\n", - " (2060, 10): 4.701770782470703,\n", - " (2060, 11): 79.69813406467438,\n", - " (2060, 12): 238.7788770198822},\n", - " 'window': {(2060, 1): 43.797940731048584,\n", - " (2060, 2): 72.22228050231934,\n", - " (2060, 3): 73.86251544952393,\n", - " (2060, 4): 35.05984544754028,\n", - " (2060, 5): 8.623881578445435,\n", - " (2060, 6): 5.054239511489868,\n", - " (2060, 7): 4.255905389785767,\n", - " (2060, 8): 13.639139652252197,\n", - " (2060, 9): 5.044026136398315,\n", - " (2060, 10): 3.6623756885528564,\n", - " (2060, 11): 37.41058683395386,\n", - " (2060, 12): 74.5195665359497}},\n", - " 360: {'monthly': {(2060, 1): 144.231063246727,\n", - " (2060, 2): 216.33098304271698,\n", - " (2060, 3): 231.19734811782837,\n", - " (2060, 4): 55.80735468864441,\n", - " (2060, 5): 6.250277400016785,\n", - " (2060, 6): 2.989251136779785,\n", - " (2060, 7): 6.9541391134262085,\n", - " (2060, 8): 9.533425450325012,\n", - " (2060, 9): 7.83812952041626,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 41.43318712711334,\n", - " (2060, 12): 136.1825408935547},\n", - " 'window': {(2060, 1): 45.84461832046509,\n", - " (2060, 2): 71.99977922439575,\n", - " (2060, 3): 67.33181190490723,\n", - " (2060, 4): 25.451524257659912,\n", - " (2060, 5): 3.145875096321106,\n", - " (2060, 6): 1.6240652799606323,\n", - " (2060, 7): 3.6497827768325806,\n", - " (2060, 8): 7.238368034362793,\n", - " (2060, 9): 6.344486355781555,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 31.422049522399902,\n", - " (2060, 12): 49.700161933898926}},\n", - " 361: {'monthly': {(2060, 1): 156.94122874736786,\n", - " (2060, 2): 239.315265417099,\n", - " (2060, 3): 281.9130845069885,\n", - " (2060, 4): 63.60218036174774,\n", - " (2060, 5): 6.042468786239624,\n", - " (2060, 6): 3.197485089302063,\n", - " (2060, 7): 6.376499891281128,\n", - " (2060, 8): 8.068963527679443,\n", - " (2060, 9): 6.295173764228821,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 48.16404330730438,\n", - " (2060, 12): 157.9187433719635},\n", - " 'window': {(2060, 1): 44.132304668426514,\n", - " (2060, 2): 81.95422077178955,\n", - " (2060, 3): 80.81283664703369,\n", - " (2060, 4): 29.963093519210815,\n", - " (2060, 5): 2.3731513023376465,\n", - " (2060, 6): 1.8322992324829102,\n", - " (2060, 7): 3.304356336593628,\n", - " (2060, 8): 6.792410373687744,\n", - " (2060, 9): 6.295173764228821,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 36.85248041152954,\n", - " (2060, 12): 57.67494487762451}},\n", - " 362: {'monthly': {(2060, 1): 163.84347450733185,\n", - " (2060, 2): 274.66314792633057,\n", - " (2060, 3): 282.7161922454834,\n", - " (2060, 4): 66.07600450515747,\n", - " (2060, 5): 6.401293396949768,\n", - " (2060, 6): 3.1579171419143677,\n", - " (2060, 7): 6.136355638504028,\n", - " (2060, 8): 8.275298357009888,\n", - " (2060, 9): 5.072015404701233,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 49.05095052719116,\n", - " (2060, 12): 177.7322620153427},\n", - " 'window': {(2060, 1): 50.090293884277344,\n", - " (2060, 2): 89.5856351852417,\n", - " (2060, 3): 81.82722282409668,\n", - " (2060, 4): 35.50015950202942,\n", - " (2060, 5): 2.5949233770370483,\n", - " (2060, 6): 1.7927312850952148,\n", - " (2060, 7): 3.304356336593628,\n", - " (2060, 8): 6.652172565460205,\n", - " (2060, 9): 5.072015404701233,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 38.46434926986694,\n", - " (2060, 12): 67.87397956848145}},\n", - " 363: {'monthly': {(2060, 1): 165.97414541244507,\n", - " (2060, 2): 270.5400570631027,\n", - " (2060, 3): 236.1021852493286,\n", - " (2060, 4): 70.70338654518127,\n", - " (2060, 5): 5.712506055831909,\n", - " (2060, 6): 2.9294488430023193,\n", - " (2060, 7): 6.136355638504028,\n", - " (2060, 8): 7.928725719451904,\n", - " (2060, 9): 3.9716721773147583,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 47.313291907310486,\n", - " (2060, 12): 181.39650702476501},\n", - " 'window': {(2060, 1): 53.243648529052734,\n", - " (2060, 2): 87.51931858062744,\n", - " (2060, 3): 60.8726224899292,\n", - " (2060, 4): 43.6773955821991,\n", - " (2060, 5): 2.684832811355591,\n", - " (2060, 6): 1.5642629861831665,\n", - " (2060, 7): 3.304356336593628,\n", - " (2060, 8): 6.652172565460205,\n", - " (2060, 9): 3.9716721773147583,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 37.59663915634155,\n", - " (2060, 12): 81.1920051574707}},\n", - " 364: {'monthly': {(2060, 1): 166.34626495838165,\n", - " (2060, 2): 220.3690732717514,\n", - " (2060, 3): 192.0253701210022,\n", - " (2060, 4): 68.40841329097748,\n", - " (2060, 5): 1.1718651056289673,\n", - " (2060, 6): 0.0,\n", - " (2060, 7): 3.6192963123321533,\n", - " (2060, 8): 4.0284528732299805,\n", - " (2060, 9): 2.1650272607803345,\n", - " (2060, 10): 6.392921447753906,\n", - " (2060, 11): 49.24258375167847,\n", - " (2060, 12): 166.03872156143188},\n", - " 'window': {(2060, 1): 38.83311223983765,\n", - " (2060, 2): 58.49986219406128,\n", - " (2060, 3): 53.7948055267334,\n", - " (2060, 4): 31.430148363113403,\n", - " (2060, 5): 1.1718651056289673,\n", - " (2060, 6): 0.0,\n", - " (2060, 7): 2.2391775846481323,\n", - " (2060, 8): 4.0284528732299805,\n", - " (2060, 9): 1.083641767501831,\n", - " (2060, 10): 6.392921447753906,\n", - " (2060, 11): 26.178444981575012,\n", - " (2060, 12): 55.14943552017212}},\n", - " 365: {'monthly': {(2060, 1): 182.10686266422272,\n", - " (2060, 2): 233.61105024814606,\n", - " (2060, 3): 287.2898886203766,\n", - " (2060, 4): 95.88835942745209,\n", - " (2060, 5): 3.8210381269454956,\n", - " (2060, 6): 2.5997159481048584,\n", - " (2060, 7): 5.032007813453674,\n", - " (2060, 8): 12.449836134910583,\n", - " (2060, 9): 1.0253710746765137,\n", - " (2060, 10): 5.319395065307617,\n", - " (2060, 11): 88.14243352413177,\n", - " (2060, 12): 231.5383541584015},\n", - " 'window': {(2060, 1): 41.989378690719604,\n", - " (2060, 2): 62.09833765029907,\n", - " (2060, 3): 75.53278923034668,\n", - " (2060, 4): 41.2802472114563,\n", - " (2060, 5): 2.8181036710739136,\n", - " (2060, 6): 1.5302691459655762,\n", - " (2060, 7): 2.56003201007843,\n", - " (2060, 8): 9.270164608955383,\n", - " (2060, 9): 1.0253710746765137,\n", - " (2060, 10): 4.309550881385803,\n", - " (2060, 11): 47.18533658981323,\n", - " (2060, 12): 83.35262107849121}},\n", - " 366: {'monthly': {(2060, 1): 232.65787887573242,\n", - " (2060, 2): 279.3179839849472,\n", - " (2060, 3): 295.5669548511505,\n", - " (2060, 4): 89.84878635406494,\n", - " (2060, 5): 8.904881238937378,\n", - " (2060, 6): 3.6253193616867065,\n", - " (2060, 7): 4.785010933876038,\n", - " (2060, 8): 15.194651007652283,\n", - " (2060, 9): 1.0253710746765137,\n", - " (2060, 10): 5.949154019355774,\n", - " (2060, 11): 96.06230330467224,\n", - " (2060, 12): 254.55350530147552},\n", - " 'window': {(2060, 1): 51.60810708999634,\n", - " (2060, 2): 81.11182689666748,\n", - " (2060, 3): 77.84882259368896,\n", - " (2060, 4): 42.01062774658203,\n", - " (2060, 5): 5.539155602455139,\n", - " (2060, 6): 2.426335096359253,\n", - " (2060, 7): 2.56003201007843,\n", - " (2060, 8): 12.014979481697083,\n", - " (2060, 9): 1.0253710746765137,\n", - " (2060, 10): 3.217567801475525,\n", - " (2060, 11): 54.97837162017822,\n", - " (2060, 12): 88.60397624969482}},\n", - " 367: {'monthly': {(2060, 1): 249.38615083694458,\n", - " (2060, 2): 342.1434608697891,\n", - " (2060, 3): 320.9760513305664,\n", - " (2060, 4): 130.51267981529236,\n", - " (2060, 5): 12.40896189212799,\n", - " (2060, 6): 4.9963139295578,\n", - " (2060, 7): 4.785010933876038,\n", - " (2060, 8): 14.041459918022156,\n", - " (2060, 9): 1.0253710746765137,\n", - " (2060, 10): 3.8247705698013306,\n", - " (2060, 11): 86.06654059886932,\n", - " (2060, 12): 268.563112616539},\n", - " 'window': {(2060, 1): 57.43638610839844,\n", - " (2060, 2): 96.11994647979736,\n", - " (2060, 3): 91.09024620056152,\n", - " (2060, 4): 73.49055600166321,\n", - " (2060, 5): 7.423483490943909,\n", - " (2060, 6): 2.069274663925171,\n", - " (2060, 7): 2.56003201007843,\n", - " (2060, 8): 10.861788392066956,\n", - " (2060, 9): 1.0253710746765137,\n", - " (2060, 10): 2.8149263858795166,\n", - " (2060, 11): 50.24421787261963,\n", - " (2060, 12): 81.93220138549805}},\n", - " 368: {'monthly': {(2060, 1): 294.8989408016205,\n", - " (2060, 2): 340.99745404720306,\n", - " (2060, 3): 298.7412427663803,\n", - " (2060, 4): 102.12918615341187,\n", - " (2060, 5): 5.05357027053833,\n", - " (2060, 6): 6.714656829833984,\n", - " (2060, 7): 6.112763166427612,\n", - " (2060, 8): 11.339202523231506,\n", - " (2060, 9): 1.0253710746765137,\n", - " (2060, 10): 3.9316540956497192,\n", - " (2060, 11): 81.14651882648468,\n", - " (2060, 12): 226.52567088603973},\n", - " 'window': {(2060, 1): 61.02857971191406,\n", - " (2060, 2): 94.12771701812744,\n", - " (2060, 3): 85.38313293457031,\n", - " (2060, 4): 65.64057922363281,\n", - " (2060, 5): 1.61881422996521,\n", - " (2060, 6): 2.617959141731262,\n", - " (2060, 7): 2.56003201007843,\n", - " (2060, 8): 8.159530997276306,\n", - " (2060, 9): 1.0253710746765137,\n", - " (2060, 10): 2.9218099117279053,\n", - " (2060, 11): 41.88496971130371,\n", - " (2060, 12): 61.98970603942871}},\n", - " 369: {'monthly': {(2060, 1): 204.05772817134857,\n", - " (2060, 2): 296.7662752866745,\n", - " (2060, 3): 336.01029753685,\n", - " (2060, 4): 82.86447656154633,\n", - " (2060, 5): 12.68576717376709,\n", - " (2060, 6): 13.850563406944275,\n", - " (2060, 7): 11.591421723365784,\n", - " (2060, 8): 16.56989014148712,\n", - " (2060, 9): 4.346258044242859,\n", - " (2060, 10): 3.7939025163650513,\n", - " (2060, 11): 70.7224189043045,\n", - " (2060, 12): 228.6220873594284},\n", - " 'window': {(2060, 1): 52.83263659477234,\n", - " (2060, 2): 84.4668869972229,\n", - " (2060, 3): 100.33522510528564,\n", - " (2060, 4): 29.481672406196594,\n", - " (2060, 5): 4.193650245666504,\n", - " (2060, 6): 4.152397274971008,\n", - " (2060, 7): 4.3422006368637085,\n", - " (2060, 8): 11.45679497718811,\n", - " (2060, 9): 4.346258044242859,\n", - " (2060, 10): 2.7545074224472046,\n", - " (2060, 11): 37.765132427215576,\n", - " (2060, 12): 81.62792444229126}},\n", - " 370: {'monthly': {(2060, 1): 250.7633911371231,\n", - " (2060, 2): 388.13015139102936,\n", - " (2060, 3): 429.20004773139954,\n", - " (2060, 4): 121.01484537124634,\n", - " (2060, 5): 18.927573919296265,\n", - " (2060, 6): 16.416436910629272,\n", - " (2060, 7): 16.206777453422546,\n", - " (2060, 8): 21.148574948310852,\n", - " (2060, 9): 6.394774317741394,\n", - " (2060, 10): 4.101782321929932,\n", - " (2060, 11): 113.70261585712433,\n", - " (2060, 12): 359.1420124769211},\n", - " 'window': {(2060, 1): 66.65383958816528,\n", - " (2060, 2): 109.30014324188232,\n", - " (2060, 3): 136.10631370544434,\n", - " (2060, 4): 38.51203775405884,\n", - " (2060, 5): 8.177371740341187,\n", - " (2060, 6): 5.863957166671753,\n", - " (2060, 7): 7.64594030380249,\n", - " (2060, 8): 15.788182854652405,\n", - " (2060, 9): 6.394774317741394,\n", - " (2060, 10): 3.062387228012085,\n", - " (2060, 11): 67.40798759460449,\n", - " (2060, 12): 121.91678619384766}},\n", - " 371: {'monthly': {(2060, 1): 321.0069818496704,\n", - " (2060, 2): 396.87250328063965,\n", - " (2060, 3): 411.28923988342285,\n", - " (2060, 4): 138.94894325733185,\n", - " (2060, 5): 27.65811264514923,\n", - " (2060, 6): 25.01667332649231,\n", - " (2060, 7): 31.05210304260254,\n", - " (2060, 8): 31.094981908798218,\n", - " (2060, 9): 10.825179696083069,\n", - " (2060, 10): 5.973053455352783,\n", - " (2060, 11): 129.69430780410767,\n", - " (2060, 12): 395.0478494167328},\n", - " 'window': {(2060, 1): 87.41708183288574,\n", - " (2060, 2): 102.40510559082031,\n", - " (2060, 3): 116.62148666381836,\n", - " (2060, 4): 42.86701488494873,\n", - " (2060, 5): 11.07584810256958,\n", - " (2060, 6): 7.908582091331482,\n", - " (2060, 7): 11.923386096954346,\n", - " (2060, 8): 22.15704643726349,\n", - " (2060, 9): 8.058786869049072,\n", - " (2060, 10): 4.9336583614349365,\n", - " (2060, 11): 66.1063642501831,\n", - " (2060, 12): 105.96094226837158}},\n", - " 372: {'monthly': {(2060, 1): 243.9283537864685,\n", - " (2060, 2): 279.120085477829,\n", - " (2060, 3): 279.1301648616791,\n", - " (2060, 4): 93.50290632247925,\n", - " (2060, 5): 16.820484399795532,\n", - " (2060, 6): 14.330246925354004,\n", - " (2060, 7): 13.841667294502258,\n", - " (2060, 8): 19.752363324165344,\n", - " (2060, 9): 3.826420307159424,\n", - " (2060, 10): 4.01350998878479,\n", - " (2060, 11): 84.5606164932251,\n", - " (2060, 12): 293.2078412771225},\n", - " 'window': {(2060, 1): 71.06168985366821,\n", - " (2060, 2): 68.59465408325195,\n", - " (2060, 3): 67.65301609039307,\n", - " (2060, 4): 27.19639277458191,\n", - " (2060, 5): 6.185702681541443,\n", - " (2060, 6): 4.3633036613464355,\n", - " (2060, 7): 4.710237741470337,\n", - " (2060, 8): 14.639268159866333,\n", - " (2060, 9): 3.826420307159424,\n", - " (2060, 10): 2.9741148948669434,\n", - " (2060, 11): 37.15286827087402,\n", - " (2060, 12): 71.6466703414917}},\n", - " 373: {'monthly': {(2060, 1): 193.91320776939392,\n", - " (2060, 2): 252.53764986991882,\n", - " (2060, 3): 235.53720617294312,\n", - " (2060, 4): 59.146209359169006,\n", - " (2060, 5): 7.505447506904602,\n", - " (2060, 6): 3.026734232902527,\n", - " (2060, 7): 6.136355638504028,\n", - " (2060, 8): 7.928725719451904,\n", - " (2060, 9): 8.917001843452454,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 41.06522500514984,\n", - " (2060, 12): 156.1070466041565},\n", - " 'window': {(2060, 1): 54.569804191589355,\n", - " (2060, 2): 77.82296085357666,\n", - " (2060, 3): 58.43880271911621,\n", - " (2060, 4): 23.480927109718323,\n", - " (2060, 5): 3.2951360940933228,\n", - " (2060, 6): 1.661548376083374,\n", - " (2060, 7): 3.304356336593628,\n", - " (2060, 8): 6.652172565460205,\n", - " (2060, 9): 8.917001843452454,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 31.824718952178955,\n", - " (2060, 12): 57.96774339675903}},\n", - " 374: {'monthly': {(2060, 1): 168.20277619361877,\n", - " (2060, 2): 241.3882576227188,\n", - " (2060, 3): 250.0341546535492,\n", - " (2060, 4): 58.01311528682709,\n", - " (2060, 5): 6.919817209243774,\n", - " (2060, 6): 3.074926018714905,\n", - " (2060, 7): 6.136355638504028,\n", - " (2060, 8): 9.215181827545166,\n", - " (2060, 9): 7.931223511695862,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 45.00581872463226,\n", - " (2060, 12): 148.90686118602753},\n", - " 'window': {(2060, 1): 54.07213354110718,\n", - " (2060, 2): 80.74687671661377,\n", - " (2060, 3): 65.74259185791016,\n", - " (2060, 4): 26.531129360198975,\n", - " (2060, 5): 2.8836898803710938,\n", - " (2060, 6): 1.709740161895752,\n", - " (2060, 7): 3.304356336593628,\n", - " (2060, 8): 6.652172565460205,\n", - " (2060, 9): 7.931223511695862,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 35.032471656799316,\n", - " (2060, 12): 57.5262975692749}},\n", - " 375: {'monthly': {(2060, 1): 184.62992429733276,\n", - " (2060, 2): 264.91373884677887,\n", - " (2060, 3): 271.3550246953964,\n", - " (2060, 4): 58.302610993385315,\n", - " (2060, 5): 5.66555643081665,\n", - " (2060, 6): 3.7643896341323853,\n", - " (2060, 7): 6.136355638504028,\n", - " (2060, 8): 7.928725719451904,\n", - " (2060, 9): 4.9951053857803345,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 49.147919058799744,\n", - " (2060, 12): 171.96580922603607},\n", - " 'window': {(2060, 1): 60.6094765663147,\n", - " (2060, 2): 87.75706958770752,\n", - " (2060, 3): 69.01146984100342,\n", - " (2060, 4): 29.626229286193848,\n", - " (2060, 5): 2.6439743041992188,\n", - " (2060, 6): 1.3651858568191528,\n", - " (2060, 7): 3.304356336593628,\n", - " (2060, 8): 6.652172565460205,\n", - " (2060, 9): 4.9951053857803345,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 38.905505657196045,\n", - " (2060, 12): 68.53180027008057}},\n", - " 376: {'monthly': {(2060, 1): 180.20367431640625,\n", - " (2060, 2): 272.45594787597656,\n", - " (2060, 3): 246.63388991355896,\n", - " (2060, 4): 65.1923485994339,\n", - " (2060, 5): 6.144610643386841,\n", - " (2060, 6): 3.601706862449646,\n", - " (2060, 7): 6.136355638504028,\n", - " (2060, 8): 8.140652656555176,\n", - " (2060, 9): 3.385236144065857,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 47.70523154735565,\n", - " (2060, 12): 193.3783986568451},\n", - " 'window': {(2060, 1): 54.56692886352539,\n", - " (2060, 2): 80.63194274902344,\n", - " (2060, 3): 56.80373764038086,\n", - " (2060, 4): 35.29770255088806,\n", - " (2060, 5): 2.85686457157135,\n", - " (2060, 6): 2.3893678188323975,\n", - " (2060, 7): 3.304356336593628,\n", - " (2060, 8): 6.864099502563477,\n", - " (2060, 9): 3.385236144065857,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 37.331074237823486,\n", - " (2060, 12): 80.56596088409424}},\n", - " 377: {'monthly': {(2060, 1): 168.72258293628693,\n", - " (2060, 2): 225.66447710990906,\n", - " (2060, 3): 224.81525552272797,\n", - " (2060, 4): 49.109877586364746,\n", - " (2060, 5): 2.154682159423828,\n", - " (2060, 6): 4.671999573707581,\n", - " (2060, 7): 5.150723814964294,\n", - " (2060, 8): 3.693593382835388,\n", - " (2060, 9): 4.65442168712616,\n", - " (2060, 10): 11.092034220695496,\n", - " (2060, 11): 62.683056235313416,\n", - " (2060, 12): 207.42765855789185},\n", - " 'window': {(2060, 1): 37.5467164516449,\n", - " (2060, 2): 60.28683376312256,\n", - " (2060, 3): 96.85650634765625,\n", - " (2060, 4): 17.917935252189636,\n", - " (2060, 5): 1.095497488975525,\n", - " (2060, 6): 3.583376169204712,\n", - " (2060, 7): 2.690177321434021,\n", - " (2060, 8): 3.693593382835388,\n", - " (2060, 9): 3.1778981685638428,\n", - " (2060, 10): 11.092034220695496,\n", - " (2060, 11): 36.79406952857971,\n", - " (2060, 12): 56.768937826156616}},\n", - " 378: {'monthly': {(2060, 1): 183.89006340503693,\n", - " (2060, 2): 229.0984832048416,\n", - " (2060, 3): 252.703751206398,\n", - " (2060, 4): 104.13557040691376,\n", - " (2060, 5): 14.065146207809448,\n", - " (2060, 6): 13.224797010421753,\n", - " (2060, 7): 12.64035940170288,\n", - " (2060, 8): 12.13150930404663,\n", - " (2060, 9): 6.012876272201538,\n", - " (2060, 10): 8.558772206306458,\n", - " (2060, 11): 71.70966756343842,\n", - " (2060, 12): 226.5409905910492},\n", - " 'window': {(2060, 1): 48.66191053390503,\n", - " (2060, 2): 60.21333312988281,\n", - " (2060, 3): 76.65425872802734,\n", - " (2060, 4): 37.45549035072327,\n", - " (2060, 5): 6.597886562347412,\n", - " (2060, 6): 7.408227443695068,\n", - " (2060, 7): 5.834046721458435,\n", - " (2060, 8): 5.949543356895447,\n", - " (2060, 9): 3.217884063720703,\n", - " (2060, 10): 7.433558344841003,\n", - " (2060, 11): 26.092806100845337,\n", - " (2060, 12): 57.13832378387451}},\n", - " 379: {'monthly': {(2060, 1): 195.51022505760193,\n", - " (2060, 2): 285.1017994880676,\n", - " (2060, 3): 328.98690938949585,\n", - " (2060, 4): 92.00731182098389,\n", - " (2060, 5): 10.55418860912323,\n", - " (2060, 6): 12.335365176200867,\n", - " (2060, 7): 12.64035940170288,\n", - " (2060, 8): 12.992737650871277,\n", - " (2060, 9): 4.321966886520386,\n", - " (2060, 10): 3.7434016466140747,\n", - " (2060, 11): 113.95866620540619,\n", - " (2060, 12): 288.0956633090973},\n", - " 'window': {(2060, 1): 53.18430709838867,\n", - " (2060, 2): 65.9955587387085,\n", - " (2060, 3): 78.36417198181152,\n", - " (2060, 4): 33.85520040988922,\n", - " (2060, 5): 4.563319802284241,\n", - " (2060, 6): 6.518795609474182,\n", - " (2060, 7): 5.834046721458435,\n", - " (2060, 8): 7.5893625020980835,\n", - " (2060, 9): 3.217884063720703,\n", - " (2060, 10): 2.6181877851486206,\n", - " (2060, 11): 50.38206195831299,\n", - " (2060, 12): 77.25684118270874}},\n", - " 380: {'monthly': {(2060, 1): 298.51513481140137,\n", - " (2060, 2): 323.9600977897644,\n", - " (2060, 3): 327.7440357208252,\n", - " (2060, 4): 99.56636583805084,\n", - " (2060, 5): 11.184078097343445,\n", - " (2060, 6): 10.725985884666443,\n", - " (2060, 7): 12.828433990478516,\n", - " (2060, 8): 14.008373260498047,\n", - " (2060, 9): 4.321966886520386,\n", - " (2060, 10): 4.271755695343018,\n", - " (2060, 11): 87.19449591636658,\n", - " (2060, 12): 354.3440878391266},\n", - " 'window': {(2060, 1): 77.0308666229248,\n", - " (2060, 2): 84.37670803070068,\n", - " (2060, 3): 73.40827417373657,\n", - " (2060, 4): 31.459746599197388,\n", - " (2060, 5): 3.888566493988037,\n", - " (2060, 6): 5.458016872406006,\n", - " (2060, 7): 5.833905577659607,\n", - " (2060, 8): 8.008766293525696,\n", - " (2060, 9): 3.217884063720703,\n", - " (2060, 10): 3.1465418338775635,\n", - " (2060, 11): 38.56263065338135,\n", - " (2060, 12): 88.19429302215576}},\n", - " 381: {'monthly': {(2060, 1): 284.5288243293762,\n", - " (2060, 2): 314.9116690158844,\n", - " (2060, 3): 369.1858651638031,\n", - " (2060, 4): 128.81471574306488,\n", - " (2060, 5): 20.6155606508255,\n", - " (2060, 6): 15.210014343261719,\n", - " (2060, 7): 12.71425998210907,\n", - " (2060, 8): 15.828834772109985,\n", - " (2060, 9): 5.079553604125977,\n", - " (2060, 10): 4.39546799659729,\n", - " (2060, 11): 84.04179811477661,\n", - " (2060, 12): 304.3026200532913},\n", - " 'window': {(2060, 1): 73.96430253982544,\n", - " (2060, 2): 89.47660827636719,\n", - " (2060, 3): 92.26852226257324,\n", - " (2060, 4): 41.85691213607788,\n", - " (2060, 5): 8.151678085327148,\n", - " (2060, 6): 7.147527694702148,\n", - " (2060, 7): 5.759005904197693,\n", - " (2060, 8): 8.621779799461365,\n", - " (2060, 9): 2.847001314163208,\n", - " (2060, 10): 3.270254135131836,\n", - " (2060, 11): 30.410312175750732,\n", - " (2060, 12): 84.24227809906006}},\n", - " 382: {'monthly': {(2060, 1): 245.72071850299835,\n", - " (2060, 2): 422.4146544933319,\n", - " (2060, 3): 491.2512273788452,\n", - " (2060, 4): 184.92181706428528,\n", - " (2060, 5): 38.43340289592743,\n", - " (2060, 6): 27.64109718799591,\n", - " (2060, 7): 24.619238138198853,\n", - " (2060, 8): 26.8357093334198,\n", - " (2060, 9): 7.538404583930969,\n", - " (2060, 10): 8.060519933700562,\n", - " (2060, 11): 139.94905591011047,\n", - " (2060, 12): 333.443506360054},\n", - " 'window': {(2060, 1): 62.09790229797363,\n", - " (2060, 2): 126.58339786529541,\n", - " (2060, 3): 142.0317554473877,\n", - " (2060, 4): 58.98905801773071,\n", - " (2060, 5): 12.17837679386139,\n", - " (2060, 6): 8.598559856414795,\n", - " (2060, 7): 10.921966671943665,\n", - " (2060, 8): 15.719516515731812,\n", - " (2060, 9): 4.958504319190979,\n", - " (2060, 10): 5.588065147399902,\n", - " (2060, 11): 77.58835649490356,\n", - " (2060, 12): 83.40189743041992}},\n", - " 383: {'monthly': {(2060, 1): 333.0408617258072,\n", - " (2060, 2): 553.8174774646759,\n", - " (2060, 3): 623.7906270027161,\n", - " (2060, 4): 183.14194357395172,\n", - " (2060, 5): 36.81927239894867,\n", - " (2060, 6): 25.804607629776,\n", - " (2060, 7): 18.43522870540619,\n", - " (2060, 8): 27.349186539649963,\n", - " (2060, 9): 9.515154838562012,\n", - " (2060, 10): 8.709033250808716,\n", - " (2060, 11): 208.12935853004456,\n", - " (2060, 12): 446.285439491272},\n", - " 'window': {(2060, 1): 81.1829662322998,\n", - " (2060, 2): 146.87132930755615,\n", - " (2060, 3): 207.74162483215332,\n", - " (2060, 4): 59.31193542480469,\n", - " (2060, 5): 12.053408980369568,\n", - " (2060, 6): 8.467171549797058,\n", - " (2060, 7): 9.587490439414978,\n", - " (2060, 8): 14.340285778045654,\n", - " (2060, 9): 5.502827763557434,\n", - " (2060, 10): 5.39226770401001,\n", - " (2060, 11): 107.24258136749268,\n", - " (2060, 12): 96.04324913024902}},\n", - " 384: {'monthly': {(2060, 1): 405.18871879577637,\n", - " (2060, 2): 550.9571185112,\n", - " (2060, 3): 511.28173208236694,\n", - " (2060, 4): 135.59755957126617,\n", - " (2060, 5): 24.386338353157043,\n", - " (2060, 6): 17.12852907180786,\n", - " (2060, 7): 13.094897985458374,\n", - " (2060, 8): 25.071101903915405,\n", - " (2060, 9): 5.199883580207825,\n", - " (2060, 10): 5.421327710151672,\n", - " (2060, 11): 164.96277165412903,\n", - " (2060, 12): 456.180916428566},\n", - " 'window': {(2060, 1): 102.41054058074951,\n", - " (2060, 2): 146.62237071990967,\n", - " (2060, 3): 162.6156826019287,\n", - " (2060, 4): 39.80028963088989,\n", - " (2060, 5): 9.902860760688782,\n", - " (2060, 6): 5.873907566070557,\n", - " (2060, 7): 6.703943490982056,\n", - " (2060, 8): 13.418867826461792,\n", - " (2060, 9): 3.6929961442947388,\n", - " (2060, 10): 5.421327710151672,\n", - " (2060, 11): 69.97992825508118,\n", - " (2060, 12): 99.32099342346191}},\n", - " 385: {'monthly': {(2060, 1): 423.55770099163055,\n", - " (2060, 2): 351.49102425575256,\n", - " (2060, 3): 329.6173152923584,\n", - " (2060, 4): 123.15557849407196,\n", - " (2060, 5): 24.490737199783325,\n", - " (2060, 6): 17.189981818199158,\n", - " (2060, 7): 13.845078468322754,\n", - " (2060, 8): 23.065874338150024,\n", - " (2060, 9): 5.199883580207825,\n", - " (2060, 10): 6.104557275772095,\n", - " (2060, 11): 127.9006175994873,\n", - " (2060, 12): 341.9298987388611},\n", - " 'window': {(2060, 1): 127.18251132965088,\n", - " (2060, 2): 85.33151817321777,\n", - " (2060, 3): 70.61262893676758,\n", - " (2060, 4): 36.49405479431152,\n", - " (2060, 5): 8.6967134475708,\n", - " (2060, 6): 5.707547903060913,\n", - " (2060, 7): 6.425916790962219,\n", - " (2060, 8): 14.606455206871033,\n", - " (2060, 9): 3.6929961442947388,\n", - " (2060, 10): 4.66397500038147,\n", - " (2060, 11): 53.58917450904846,\n", - " (2060, 12): 88.69561386108398}},\n", - " 386: {'monthly': {(2060, 1): 251.83087873458862,\n", - " (2060, 2): 362.7614984512329,\n", - " (2060, 3): 419.6058702468872,\n", - " (2060, 4): 89.49929296970367,\n", - " (2060, 5): 7.3274500370025635,\n", - " (2060, 6): 5.693287253379822,\n", - " (2060, 7): 5.6086665391922,\n", - " (2060, 8): 16.575836658477783,\n", - " (2060, 9): 12.438502669334412,\n", - " (2060, 10): 1.022443175315857,\n", - " (2060, 11): 64.67064309120178,\n", - " (2060, 12): 218.97875344753265},\n", - " 'window': {(2060, 1): 77.7287654876709,\n", - " (2060, 2): 105.08432960510254,\n", - " (2060, 3): 159.62180709838867,\n", - " (2060, 4): 27.066538095474243,\n", - " (2060, 5): 3.712322950363159,\n", - " (2060, 6): 3.2304407358169556,\n", - " (2060, 7): 3.3676012754440308,\n", - " (2060, 8): 9.194929480552673,\n", - " (2060, 9): 10.498918175697327,\n", - " (2060, 10): 1.022443175315857,\n", - " (2060, 11): 47.3193793296814,\n", - " (2060, 12): 77.49810886383057}},\n", - " 387: {'monthly': {(2060, 1): 213.95052301883698,\n", - " (2060, 2): 329.2265352010727,\n", - " (2060, 3): 327.8579316139221,\n", - " (2060, 4): 79.46410155296326,\n", - " (2060, 5): 6.6305941343307495,\n", - " (2060, 6): 2.1947437524795532,\n", - " (2060, 7): 4.58988082408905,\n", - " (2060, 8): 15.985164999961853,\n", - " (2060, 9): 12.62716805934906,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 54.390645265579224,\n", - " (2060, 12): 189.83165609836578},\n", - " 'window': {(2060, 1): 66.89607191085815,\n", - " (2060, 2): 83.64367580413818,\n", - " (2060, 3): 85.84045124053955,\n", - " (2060, 4): 26.428195476531982,\n", - " (2060, 5): 3.4906036853790283,\n", - " (2060, 6): 1.1001338958740234,\n", - " (2060, 7): 3.3676012754440308,\n", - " (2060, 8): 10.005805969238281,\n", - " (2060, 9): 9.568324208259583,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 42.435200691223145,\n", - " (2060, 12): 68.39646100997925}},\n", - " 388: {'monthly': {(2060, 1): 195.6907113790512,\n", - " (2060, 2): 319.0086498260498,\n", - " (2060, 3): 325.47775888442993,\n", - " (2060, 4): 76.53937578201294,\n", - " (2060, 5): 5.239037036895752,\n", - " (2060, 6): 1.1001338958740234,\n", - " (2060, 7): 4.58988082408905,\n", - " (2060, 8): 17.95933699607849,\n", - " (2060, 9): 8.472065567970276,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 55.384071350097656,\n", - " (2060, 12): 191.22394573688507},\n", - " 'window': {(2060, 1): 65.473623752594,\n", - " (2060, 2): 84.4402379989624,\n", - " (2060, 3): 88.74025821685791,\n", - " (2060, 4): 26.041996598243713,\n", - " (2060, 5): 2.818236827850342,\n", - " (2060, 6): 1.1001338958740234,\n", - " (2060, 7): 3.3676012754440308,\n", - " (2060, 8): 11.272314071655273,\n", - " (2060, 9): 5.672576546669006,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 42.20364189147949,\n", - " (2060, 12): 66.63904094696045}},\n", - " 389: {'monthly': {(2060, 1): 184.35914623737335,\n", - " (2060, 2): 292.1955517530441,\n", - " (2060, 3): 293.06680941581726,\n", - " (2060, 4): 77.51762676239014,\n", - " (2060, 5): 3.645328164100647,\n", - " (2060, 6): 2.354953169822693,\n", - " (2060, 7): 4.58988082408905,\n", - " (2060, 8): 19.412689566612244,\n", - " (2060, 9): 5.132485628128052,\n", - " (2060, 10): 2.5531128644943237,\n", - " (2060, 11): 58.76792323589325,\n", - " (2060, 12): 193.66727757453918},\n", - " 'window': {(2060, 1): 54.281803131103516,\n", - " (2060, 2): 77.61125755310059,\n", - " (2060, 3): 65.78206539154053,\n", - " (2060, 4): 26.475059628486633,\n", - " (2060, 5): 2.312895894050598,\n", - " (2060, 6): 1.2548192739486694,\n", - " (2060, 7): 3.3676012754440308,\n", - " (2060, 8): 12.753625988960266,\n", - " (2060, 9): 3.0819287300109863,\n", - " (2060, 10): 1.3262019157409668,\n", - " (2060, 11): 47.9988317489624,\n", - " (2060, 12): 59.82745170593262}},\n", - " 390: {'monthly': {(2060, 1): 174.62095141410828,\n", - " (2060, 2): 231.62982189655304,\n", - " (2060, 3): 316.0894066317908,\n", - " (2060, 4): 43.785767912864685,\n", - " (2060, 5): 4.483926296234131,\n", - " (2060, 6): 3.583376169204712,\n", - " (2060, 7): 5.150723814964294,\n", - " (2060, 8): 3.693593382835388,\n", - " (2060, 9): 2.9961105585098267,\n", - " (2060, 10): 12.08284306526184,\n", - " (2060, 11): 71.00018429756165,\n", - " (2060, 12): 222.23119449615479},\n", - " 'window': {(2060, 1): 35.628868103027344,\n", - " (2060, 2): 56.769975662231445,\n", - " (2060, 3): 178.23470141729038,\n", - " (2060, 4): 15.40146541595459,\n", - " (2060, 5): 2.3902385234832764,\n", - " (2060, 6): 3.583376169204712,\n", - " (2060, 7): 2.690177321434021,\n", - " (2060, 8): 3.693593382835388,\n", - " (2060, 9): 1.5195870399475098,\n", - " (2060, 10): 12.08284306526184,\n", - " (2060, 11): 47.109920501708984,\n", - " (2060, 12): 60.22527265548706}},\n", - " 391: {'monthly': {(2060, 1): 181.40429496765137,\n", - " (2060, 2): 248.89680755138397,\n", - " (2060, 3): 372.06871807575226,\n", - " (2060, 4): 79.5608617067337,\n", - " (2060, 5): 9.395422101020813,\n", - " (2060, 6): 13.224797010421753,\n", - " (2060, 7): 12.64035940170288,\n", - " (2060, 8): 13.783410549163818,\n", - " (2060, 9): 7.22767972946167,\n", - " (2060, 10): 4.2711814641952515,\n", - " (2060, 11): 96.50427579879761,\n", - " (2060, 12): 243.23703634738922},\n", - " 'window': {(2060, 1): 55.440470695495605,\n", - " (2060, 2): 59.228331565856934,\n", - " (2060, 3): 141.62621974945068,\n", - " (2060, 4): 28.439859986305237,\n", - " (2060, 5): 3.4045532941818237,\n", - " (2060, 6): 7.408227443695068,\n", - " (2060, 7): 5.834046721458435,\n", - " (2060, 8): 7.601444602012634,\n", - " (2060, 9): 3.217884063720703,\n", - " (2060, 10): 3.1459676027297974,\n", - " (2060, 11): 36.84239149093628,\n", - " (2060, 12): 60.08789253234863}},\n", - " 392: {'monthly': {(2060, 1): 230.88375163078308,\n", - " (2060, 2): 364.74312591552734,\n", - " (2060, 3): 428.3998384475708,\n", - " (2060, 4): 107.93558263778687,\n", - " (2060, 5): 16.32062256336212,\n", - " (2060, 6): 11.775663137435913,\n", - " (2060, 7): 14.388250946998596,\n", - " (2060, 8): 14.7117018699646,\n", - " (2060, 9): 5.255762457847595,\n", - " (2060, 10): 5.226936340332031,\n", - " (2060, 11): 136.6473307609558,\n", - " (2060, 12): 322.7664008140564},\n", - " 'window': {(2060, 1): 60.62976694107056,\n", - " (2060, 2): 100.8755669593811,\n", - " (2060, 3): 159.4784450531006,\n", - " (2060, 4): 35.33745074272156,\n", - " (2060, 5): 7.444857358932495,\n", - " (2060, 6): 6.771263360977173,\n", - " (2060, 7): 5.2910685539245605,\n", - " (2060, 8): 9.527777791023254,\n", - " (2060, 9): 2.9245598316192627,\n", - " (2060, 10): 2.9949426651000977,\n", - " (2060, 11): 66.22648525238037,\n", - " (2060, 12): 84.02315855026245}},\n", - " 393: {'monthly': {(2060, 1): 297.5114572048187,\n", - " (2060, 2): 381.79082679748535,\n", - " (2060, 3): 426.2571425437927,\n", - " (2060, 4): 123.01057875156403,\n", - " (2060, 5): 20.104398131370544,\n", - " (2060, 6): 20.798863530158997,\n", - " (2060, 7): 18.488874316215515,\n", - " (2060, 8): 19.823193788528442,\n", - " (2060, 9): 4.960261583328247,\n", - " (2060, 10): 4.592769384384155,\n", - " (2060, 11): 117.69097316265106,\n", - " (2060, 12): 341.60817980766296},\n", - " 'window': {(2060, 1): 79.13844013214111,\n", - " (2060, 2): 98.11538791656494,\n", - " (2060, 3): 131.0134506225586,\n", - " (2060, 4): 39.61476755142212,\n", - " (2060, 5): 9.912413597106934,\n", - " (2060, 6): 9.005005478858948,\n", - " (2060, 7): 7.4053943157196045,\n", - " (2060, 8): 11.631844639778137,\n", - " (2060, 9): 3.8561787605285645,\n", - " (2060, 10): 3.467555522918701,\n", - " (2060, 11): 56.63601589202881,\n", - " (2060, 12): 77.3161473274231}},\n", - " 394: {'monthly': {(2060, 1): 331.88617300987244,\n", - " (2060, 2): 456.69967901706696,\n", - " (2060, 3): 558.4201402664185,\n", - " (2060, 4): 209.88000810146332,\n", - " (2060, 5): 56.3304443359375,\n", - " (2060, 6): 58.45019173622131,\n", - " (2060, 7): 38.635892033576965,\n", - " (2060, 8): 34.49405825138092,\n", - " (2060, 9): 12.829912662506104,\n", - " (2060, 10): 15.159885287284851,\n", - " (2060, 11): 157.57126009464264,\n", - " (2060, 12): 359.89550364017487},\n", - " 'window': {(2060, 1): 93.07376766204834,\n", - " (2060, 2): 132.18474864959717,\n", - " (2060, 3): 137.78375053405762,\n", - " (2060, 4): 61.75257205963135,\n", - " (2060, 5): 15.857987523078918,\n", - " (2060, 6): 18.464482307434082,\n", - " (2060, 7): 13.348755836486816,\n", - " (2060, 8): 18.392507433891296,\n", - " (2060, 9): 5.639367461204529,\n", - " (2060, 10): 9.235466003417969,\n", - " (2060, 11): 66.07911539077759,\n", - " (2060, 12): 80.3734540939331}},\n", - " 395: {'monthly': {(2060, 1): 314.1901071071625,\n", - " (2060, 2): 600.8389282226562,\n", - " (2060, 3): 760.7801389694214,\n", - " (2060, 4): 341.8340425491333,\n", - " (2060, 5): 84.6655513048172,\n", - " (2060, 6): 69.22471928596497,\n", - " (2060, 7): 66.58948135375977,\n", - " (2060, 8): 59.27952027320862,\n", - " (2060, 9): 19.12724483013153,\n", - " (2060, 10): 21.280980944633484,\n", - " (2060, 11): 265.71492862701416,\n", - " (2060, 12): 442.6804008483887},\n", - " 'window': {(2060, 1): 75.87714290618896,\n", - " (2060, 2): 176.9512906074524,\n", - " (2060, 3): 199.75774002075195,\n", - " (2060, 4): 100.13422727584839,\n", - " (2060, 5): 21.72761034965515,\n", - " (2060, 6): 16.215563416481018,\n", - " (2060, 7): 19.375946164131165,\n", - " (2060, 8): 29.44615340232849,\n", - " (2060, 9): 9.28117847442627,\n", - " (2060, 10): 11.331902027130127,\n", - " (2060, 11): 129.9756202697754,\n", - " (2060, 12): 104.59784317016602}},\n", - " 396: {'monthly': {(2060, 1): 383.56121039390564,\n", - " (2060, 2): 667.8527207374573,\n", - " (2060, 3): 712.6772513389587,\n", - " (2060, 4): 227.2806694507599,\n", - " (2060, 5): 65.9167069196701,\n", - " (2060, 6): 50.253986954689026,\n", - " (2060, 7): 44.86192429065704,\n", - " (2060, 8): 50.746062874794006,\n", - " (2060, 9): 17.6672523021698,\n", - " (2060, 10): 20.06515085697174,\n", - " (2060, 11): 218.32442843914032,\n", - " (2060, 12): 476.83087038993835},\n", - " 'window': {(2060, 1): 95.66722774505615,\n", - " (2060, 2): 173.6953296661377,\n", - " (2060, 3): 251.9608917236328,\n", - " (2060, 4): 69.43305492401123,\n", - " (2060, 5): 17.394917845726013,\n", - " (2060, 6): 13.157159805297852,\n", - " (2060, 7): 16.981104969978333,\n", - " (2060, 8): 22.63615655899048,\n", - " (2060, 9): 9.868545532226562,\n", - " (2060, 10): 8.194113373756409,\n", - " (2060, 11): 94.96924877166748,\n", - " (2060, 12): 100.24247169494629}},\n", - " 397: {'monthly': {(2060, 1): 401.36155581474304,\n", - " (2060, 2): 690.927262544632,\n", - " (2060, 3): 607.7005658149719,\n", - " (2060, 4): 125.77751231193542,\n", - " (2060, 5): 23.910840392112732,\n", - " (2060, 6): 17.65970730781555,\n", - " (2060, 7): 13.75852346420288,\n", - " (2060, 8): 20.828347086906433,\n", - " (2060, 9): 5.199883580207825,\n", - " (2060, 10): 6.462509989738464,\n", - " (2060, 11): 160.14627492427826,\n", - " (2060, 12): 444.58162105083466},\n", - " 'window': {(2060, 1): 108.54167556762695,\n", - " (2060, 2): 232.07282638549805,\n", - " (2060, 3): 228.75367546081543,\n", - " (2060, 4): 37.662800788879395,\n", - " (2060, 5): 9.653190612792969,\n", - " (2060, 6): 5.510650157928467,\n", - " (2060, 7): 6.899542570114136,\n", - " (2060, 8): 11.845513463020325,\n", - " (2060, 9): 3.6929961442947388,\n", - " (2060, 10): 4.117847442626953,\n", - " (2060, 11): 80.31592559814453,\n", - " (2060, 12): 96.08648300170898}},\n", - " 398: {'monthly': {(2060, 1): 386.75860810279846,\n", - " (2060, 2): 427.1723647117615,\n", - " (2060, 3): 381.59524488449097,\n", - " (2060, 4): 120.32357668876648,\n", - " (2060, 5): 25.05068063735962,\n", - " (2060, 6): 17.829830527305603,\n", - " (2060, 7): 15.043785691261292,\n", - " (2060, 8): 21.105697989463806,\n", - " (2060, 9): 6.3442288637161255,\n", - " (2060, 10): 8.331496596336365,\n", - " (2060, 11): 91.58041989803314,\n", - " (2060, 12): 327.0328302383423},\n", - " 'window': {(2060, 1): 102.9858512878418,\n", - " (2060, 2): 124.03274536132812,\n", - " (2060, 3): 106.45507907867432,\n", - " (2060, 4): 36.778788805007935,\n", - " (2060, 5): 9.60598087310791,\n", - " (2060, 6): 6.203958749771118,\n", - " (2060, 7): 7.624624013900757,\n", - " (2060, 8): 13.68772304058075,\n", - " (2060, 9): 4.8373414278030396,\n", - " (2060, 10): 5.878787159919739,\n", - " (2060, 11): 37.20308828353882,\n", - " (2060, 12): 77.83739995956421}},\n", - " 399: {'monthly': {(2060, 1): 245.70601892471313,\n", - " (2060, 2): 413.47299790382385,\n", - " (2060, 3): 508.2695655822754,\n", - " (2060, 4): 102.24265897274017,\n", - " (2060, 5): 13.975409150123596,\n", - " (2060, 6): 5.561388969421387,\n", - " (2060, 7): 5.3613539934158325,\n", - " (2060, 8): 15.71300983428955,\n", - " (2060, 9): 11.62181842327118,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 71.51858794689178,\n", - " (2060, 12): 221.2993847131729},\n", - " 'window': {(2060, 1): 74.19295501708984,\n", - " (2060, 2): 142.76813793182373,\n", - " (2060, 3): 244.49824714660645,\n", - " (2060, 4): 29.844575881958008,\n", - " (2060, 5): 5.943202614784241,\n", - " (2060, 6): 3.1335614919662476,\n", - " (2060, 7): 4.139074444770813,\n", - " (2060, 8): 10.142621159553528,\n", - " (2060, 9): 9.377268433570862,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 49.69819498062134,\n", - " (2060, 12): 84.37740707397461}},\n", - " 400: {'monthly': {(2060, 1): 234.0209275484085,\n", - " (2060, 2): 408.09785771369934,\n", - " (2060, 3): 378.5128836631775,\n", - " (2060, 4): 94.26080524921417,\n", - " (2060, 5): 11.635520339012146,\n", - " (2060, 6): 2.7979520559310913,\n", - " (2060, 7): 4.934548020362854,\n", - " (2060, 8): 15.584167242050171,\n", - " (2060, 9): 13.62068259716034,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 58.419045209884644,\n", - " (2060, 12): 214.05052614212036},\n", - " 'window': {(2060, 1): 76.73259496688843,\n", - " (2060, 2): 117.3711748123169,\n", - " (2060, 3): 123.36674308776855,\n", - " (2060, 4): 28.810535669326782,\n", - " (2060, 5): 5.73104453086853,\n", - " (2060, 6): 1.6978181600570679,\n", - " (2060, 7): 3.7122684717178345,\n", - " (2060, 8): 10.582456588745117,\n", - " (2060, 9): 10.263890862464905,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 46.9905366897583,\n", - " (2060, 12): 82.02348041534424}},\n", - " 401: {'monthly': {(2060, 1): 182.53255367279053,\n", - " (2060, 2): 354.0712718963623,\n", - " (2060, 3): 341.4970989227295,\n", - " (2060, 4): 80.3007060289383,\n", - " (2060, 5): 7.215013146400452,\n", - " (2060, 6): 2.353039026260376,\n", - " (2060, 7): 4.544814467430115,\n", - " (2060, 8): 20.57498562335968,\n", - " (2060, 9): 10.0422922372818,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 58.45682907104492,\n", - " (2060, 12): 192.56854820251465},\n", - " 'window': {(2060, 1): 60.06119108200073,\n", - " (2060, 2): 105.36514616012573,\n", - " (2060, 3): 107.3717269897461,\n", - " (2060, 4): 26.8936425447464,\n", - " (2060, 5): 3.197645664215088,\n", - " (2060, 6): 1.2529051303863525,\n", - " (2060, 7): 3.322534918785095,\n", - " (2060, 8): 12.79876446723938,\n", - " (2060, 9): 7.3534733057022095,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 44.47119665145874,\n", - " (2060, 12): 68.29741191864014}},\n", - " 402: {'monthly': {(2060, 1): 180.40419614315033,\n", - " (2060, 2): 310.66334998607635,\n", - " (2060, 3): 339.30133152008057,\n", - " (2060, 4): 94.22539806365967,\n", - " (2060, 5): 5.011135578155518,\n", - " (2060, 6): 1.1001338958740234,\n", - " (2060, 7): 4.58988082408905,\n", - " (2060, 8): 23.42420721054077,\n", - " (2060, 9): 6.5219727754592896,\n", - " (2060, 10): 2.180383801460266,\n", - " (2060, 11): 79.86272585391998,\n", - " (2060, 12): 209.32002115249634},\n", - " 'window': {(2060, 1): 54.268592834472656,\n", - " (2060, 2): 88.99106407165527,\n", - " (2060, 3): 73.55516338348389,\n", - " (2060, 4): 31.009188652038574,\n", - " (2060, 5): 2.2252795696258545,\n", - " (2060, 6): 1.1001338958740234,\n", - " (2060, 7): 3.3676012754440308,\n", - " (2060, 8): 14.12121832370758,\n", - " (2060, 9): 4.326612591743469,\n", - " (2060, 10): 1.1275582313537598,\n", - " (2060, 11): 57.85994911193848,\n", - " (2060, 12): 60.12688732147217}},\n", - " 403: {'monthly': {(2060, 1): 196.3598129749298,\n", - " (2060, 2): 246.37176132202148,\n", - " (2060, 3): 483.29211859862517,\n", - " (2060, 4): 49.38131284713745,\n", - " (2060, 5): 2.154682159423828,\n", - " (2060, 6): 3.583376169204712,\n", - " (2060, 7): 5.150723814964294,\n", - " (2060, 8): 3.693593382835388,\n", - " (2060, 9): 2.9961105585098267,\n", - " (2060, 10): 12.861897587776184,\n", - " (2060, 11): 87.96863543987274,\n", - " (2060, 12): 288.2983100414276},\n", - " 'window': {(2060, 1): 39.65866565704346,\n", - " (2060, 2): 57.39243125915527,\n", - " (2060, 3): 298.29471438090513,\n", - " (2060, 4): 18.085238695144653,\n", - " (2060, 5): 1.095497488975525,\n", - " (2060, 6): 3.583376169204712,\n", - " (2060, 7): 2.690177321434021,\n", - " (2060, 8): 3.693593382835388,\n", - " (2060, 9): 1.5195870399475098,\n", - " (2060, 10): 11.799139738082886,\n", - " (2060, 11): 51.26972579956055,\n", - " (2060, 12): 68.86570072174072}},\n", - " 404: {'monthly': {(2060, 1): 238.7878541946411,\n", - " (2060, 2): 292.27020812034607,\n", - " (2060, 3): 479.9357976913452,\n", - " (2060, 4): 83.78089928627014,\n", - " (2060, 5): 9.395422101020813,\n", - " (2060, 6): 13.224797010421753,\n", - " (2060, 7): 12.64035940170288,\n", - " (2060, 8): 13.451868295669556,\n", - " (2060, 9): 5.810625076293945,\n", - " (2060, 10): 5.244746804237366,\n", - " (2060, 11): 124.66048514842987,\n", - " (2060, 12): 270.4815262556076},\n", - " 'window': {(2060, 1): 63.35719871520996,\n", - " (2060, 2): 70.49827003479004,\n", - " (2060, 3): 202.89666366577148,\n", - " (2060, 4): 28.10769557952881,\n", - " (2060, 5): 3.4045532941818237,\n", - " (2060, 6): 7.408227443695068,\n", - " (2060, 7): 5.834046721458435,\n", - " (2060, 8): 7.269902348518372,\n", - " (2060, 9): 3.217884063720703,\n", - " (2060, 10): 4.119532942771912,\n", - " (2060, 11): 53.5027494430542,\n", - " (2060, 12): 60.83675956726074}},\n", - " 405: {'monthly': {(2060, 1): 292.4732359647751,\n", - " (2060, 2): 382.6192411184311,\n", - " (2060, 3): 528.2872772216797,\n", - " (2060, 4): 108.56950843334198,\n", - " (2060, 5): 12.171101093292236,\n", - " (2060, 6): 13.22629189491272,\n", - " (2060, 7): 11.88454532623291,\n", - " (2060, 8): 14.461140155792236,\n", - " (2060, 9): 4.054514169692993,\n", - " (2060, 10): 4.793469548225403,\n", - " (2060, 11): 163.01872980594635,\n", - " (2060, 12): 357.3731589317322},\n", - " 'window': {(2060, 1): 87.32725429534912,\n", - " (2060, 2): 92.65578937530518,\n", - " (2060, 3): 211.7975368499756,\n", - " (2060, 4): 42.576441526412964,\n", - " (2060, 5): 6.069156169891357,\n", - " (2060, 6): 6.142275929450989,\n", - " (2060, 7): 5.359254479408264,\n", - " (2060, 8): 10.24174439907074,\n", - " (2060, 9): 2.9504313468933105,\n", - " (2060, 10): 3.6682556867599487,\n", - " (2060, 11): 85.35194778442383,\n", - " (2060, 12): 77.05051970481873}},\n", - " 406: {'monthly': {(2060, 1): 317.82204926013947,\n", - " (2060, 2): 463.4726142883301,\n", - " (2060, 3): 537.5396654605865,\n", - " (2060, 4): 152.02888524532318,\n", - " (2060, 5): 31.713175892829895,\n", - " (2060, 6): 28.972116231918335,\n", - " (2060, 7): 23.58301615715027,\n", - " (2060, 8): 26.029626607894897,\n", - " (2060, 9): 9.797928810119629,\n", - " (2060, 10): 8.11636996269226,\n", - " (2060, 11): 177.37964797019958,\n", - " (2060, 12): 373.1324019432068},\n", - " 'window': {(2060, 1): 97.14371585845947,\n", - " (2060, 2): 135.4565944671631,\n", - " (2060, 3): 189.29216766357422,\n", - " (2060, 4): 56.97385382652283,\n", - " (2060, 5): 13.392403721809387,\n", - " (2060, 6): 12.32433831691742,\n", - " (2060, 7): 9.048748970031738,\n", - " (2060, 8): 16.265652418136597,\n", - " (2060, 9): 5.336654186248779,\n", - " (2060, 10): 5.606100559234619,\n", - " (2060, 11): 88.3971471786499,\n", - " (2060, 12): 87.59915542602539}},\n", - " 407: {'monthly': {(2060, 1): 377.8040108680725,\n", - " (2060, 2): 774.203827381134,\n", - " (2060, 3): 688.7102947235107,\n", - " (2060, 4): 279.0478266477585,\n", - " (2060, 5): 61.81012487411499,\n", - " (2060, 6): 60.76754426956177,\n", - " (2060, 7): 48.65524399280548,\n", - " (2060, 8): 52.75159752368927,\n", - " (2060, 9): 34.2694753408432,\n", - " (2060, 10): 29.455424189567566,\n", - " (2060, 11): 362.5989394187927,\n", - " (2060, 12): 541.9798908233643},\n", - " 'window': {(2060, 1): 102.00224351882935,\n", - " (2060, 2): 250.88389587402344,\n", - " (2060, 3): 197.5661163330078,\n", - " (2060, 4): 97.6500129699707,\n", - " (2060, 5): 22.62512707710266,\n", - " (2060, 6): 19.007150173187256,\n", - " (2060, 7): 17.029131531715393,\n", - " (2060, 8): 23.17730677127838,\n", - " (2060, 9): 14.88995361328125,\n", - " (2060, 10): 15.120574951171875,\n", - " (2060, 11): 173.27826118469238,\n", - " (2060, 12): 127.08307075500488}},\n", - " 408: {'monthly': {(2060, 1): 431.3441972732544,\n", - " (2060, 2): 804.7721133232117,\n", - " (2060, 3): 957.2688627243042,\n", - " (2060, 4): 384.7500445842743,\n", - " (2060, 5): 74.12683534622192,\n", - " (2060, 6): 58.16435670852661,\n", - " (2060, 7): 47.66283357143402,\n", - " (2060, 8): 63.28366303443909,\n", - " (2060, 9): 30.677345395088196,\n", - " (2060, 10): 36.11995351314545,\n", - " (2060, 11): 482.91958475112915,\n", - " (2060, 12): 590.8008258342743},\n", - " 'window': {(2060, 1): 98.92491722106934,\n", - " (2060, 2): 223.77575302124023,\n", - " (2060, 3): 295.0255470275879,\n", - " (2060, 4): 109.60820388793945,\n", - " (2060, 5): 21.578359842300415,\n", - " (2060, 6): 16.933898448944092,\n", - " (2060, 7): 15.980869054794312,\n", - " (2060, 8): 31.91434097290039,\n", - " (2060, 9): 16.354255437850952,\n", - " (2060, 10): 16.497796893119812,\n", - " (2060, 11): 249.26858520507812,\n", - " (2060, 12): 140.91806316375732}},\n", - " 409: {'monthly': {(2060, 1): 383.6432566642761,\n", - " (2060, 2): 528.6054552793503,\n", - " (2060, 3): 509.03156042099,\n", - " (2060, 4): 158.3938615322113,\n", - " (2060, 5): 38.40198767185211,\n", - " (2060, 6): 29.96491241455078,\n", - " (2060, 7): 29.097022891044617,\n", - " (2060, 8): 34.097121715545654,\n", - " (2060, 9): 18.60576832294464,\n", - " (2060, 10): 7.726705312728882,\n", - " (2060, 11): 159.44412577152252,\n", - " (2060, 12): 408.3059034347534},\n", - " 'window': {(2060, 1): 99.06028175354004,\n", - " (2060, 2): 126.7251386642456,\n", - " (2060, 3): 119.1760482788086,\n", - " (2060, 4): 46.52912664413452,\n", - " (2060, 5): 11.382547497749329,\n", - " (2060, 6): 8.368535041809082,\n", - " (2060, 7): 11.073208928108215,\n", - " (2060, 8): 16.591158270835876,\n", - " (2060, 9): 9.902977585792542,\n", - " (2060, 10): 5.295559644699097,\n", - " (2060, 11): 72.62580394744873,\n", - " (2060, 12): 92.80438232421875}},\n", - " 410: {'monthly': {(2060, 1): 396.3887552022934,\n", - " (2060, 2): 488.77420127391815,\n", - " (2060, 3): 394.5746259689331,\n", - " (2060, 4): 100.49166095256805,\n", - " (2060, 5): 23.729541778564453,\n", - " (2060, 6): 16.239485502243042,\n", - " (2060, 7): 14.031019687652588,\n", - " (2060, 8): 19.023053288459778,\n", - " (2060, 9): 7.581433653831482,\n", - " (2060, 10): 5.980183005332947,\n", - " (2060, 11): 103.06668674945831,\n", - " (2060, 12): 317.96959018707275},\n", - " 'window': {(2060, 1): 89.62166023254395,\n", - " (2060, 2): 153.3630599975586,\n", - " (2060, 3): 127.13924026489258,\n", - " (2060, 4): 29.538582801818848,\n", - " (2060, 5): 8.084280014038086,\n", - " (2060, 6): 4.747771739959717,\n", - " (2060, 7): 6.611858010292053,\n", - " (2060, 8): 10.808509826660156,\n", - " (2060, 9): 6.056316494941711,\n", - " (2060, 10): 4.539600729942322,\n", - " (2060, 11): 49.19427132606506,\n", - " (2060, 12): 78.33022832870483}},\n", - " 411: {'monthly': {(2060, 1): 318.57862305641174,\n", - " (2060, 2): 388.48229598999023,\n", - " (2060, 3): 329.4960651397705,\n", - " (2060, 4): 102.12607395648956,\n", - " (2060, 5): 23.713073134422302,\n", - " (2060, 6): 16.996713876724243,\n", - " (2060, 7): 14.51868486404419,\n", - " (2060, 8): 18.732498168945312,\n", - " (2060, 9): 5.199883580207825,\n", - " (2060, 10): 7.161988258361816,\n", - " (2060, 11): 92.68513882160187,\n", - " (2060, 12): 275.14665138721466},\n", - " 'window': {(2060, 1): 81.4317855834961,\n", - " (2060, 2): 119.13172054290771,\n", - " (2060, 3): 104.27430725097656,\n", - " (2060, 4): 28.203325271606445,\n", - " (2060, 5): 8.427308201789856,\n", - " (2060, 6): 5.263314843177795,\n", - " (2060, 7): 7.099523186683655,\n", - " (2060, 8): 10.879189848899841,\n", - " (2060, 9): 3.6929961442947388,\n", - " (2060, 10): 4.716800570487976,\n", - " (2060, 11): 34.59502649307251,\n", - " (2060, 12): 72.55381512641907}},\n", - " 412: {'monthly': {(2060, 1): 222.95177721977234,\n", - " (2060, 2): 358.06726920604706,\n", - " (2060, 3): 347.0173704624176,\n", - " (2060, 4): 87.16961205005646,\n", - " (2060, 5): 12.909620881080627,\n", - " (2060, 6): 5.2972400188446045,\n", - " (2060, 7): 7.4396796226501465,\n", - " (2060, 8): 15.898763060569763,\n", - " (2060, 9): 8.967061877250671,\n", - " (2060, 10): 3.6281979084014893,\n", - " (2060, 11): 58.260279297828674,\n", - " (2060, 12): 191.42774665355682},\n", - " 'window': {(2060, 1): 64.14304733276367,\n", - " (2060, 2): 114.34648704528809,\n", - " (2060, 3): 113.39249420166016,\n", - " (2060, 4): 25.5884952545166,\n", - " (2060, 5): 5.754013657569885,\n", - " (2060, 6): 2.5933408737182617,\n", - " (2060, 7): 3.743940234184265,\n", - " (2060, 8): 9.544410467147827,\n", - " (2060, 9): 7.107293725013733,\n", - " (2060, 10): 1.299540400505066,\n", - " (2060, 11): 45.06333780288696,\n", - " (2060, 12): 68.73081874847412}},\n", - " 413: {'monthly': {(2060, 1): 236.56936275959015,\n", - " (2060, 2): 382.82111299037933,\n", - " (2060, 3): 325.90502882003784,\n", - " (2060, 4): 91.1471301317215,\n", - " (2060, 5): 7.443886995315552,\n", - " (2060, 6): 2.541271686553955,\n", - " (2060, 7): 6.82205867767334,\n", - " (2060, 8): 18.807412981987,\n", - " (2060, 9): 13.761752009391785,\n", - " (2060, 10): 3.9475055932998657,\n", - " (2060, 11): 61.41736054420471,\n", - " (2060, 12): 209.23910212516785},\n", - " 'window': {(2060, 1): 81.36568546295166,\n", - " (2060, 2): 110.4469518661499,\n", - " (2060, 3): 95.83870601654053,\n", - " (2060, 4): 27.79420495033264,\n", - " (2060, 5): 3.847191095352173,\n", - " (2060, 6): 1.4411377906799316,\n", - " (2060, 7): 3.5070899724960327,\n", - " (2060, 8): 10.321667432785034,\n", - " (2060, 9): 11.138159394264221,\n", - " (2060, 10): 2.699023127555847,\n", - " (2060, 11): 44.042598247528076,\n", - " (2060, 12): 79.86391115188599}},\n", - " 414: {'monthly': {(2060, 1): 177.36786544322968,\n", - " (2060, 2): 298.20360946655273,\n", - " (2060, 3): 294.2273712158203,\n", - " (2060, 4): 77.22987258434296,\n", - " (2060, 5): 5.911776185035706,\n", - " (2060, 6): 2.113629460334778,\n", - " (2060, 7): 4.58988082408905,\n", - " (2060, 8): 21.059462308883667,\n", - " (2060, 9): 10.599706411361694,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 57.396692514419556,\n", - " (2060, 12): 179.1745297908783},\n", - " 'window': {(2060, 1): 64.06430864334106,\n", - " (2060, 2): 93.3116545677185,\n", - " (2060, 3): 89.10060691833496,\n", - " (2060, 4): 23.9902845621109,\n", - " (2060, 5): 2.5210429430007935,\n", - " (2060, 6): 1.1001338958740234,\n", - " (2060, 7): 3.3676012754440308,\n", - " (2060, 8): 12.859148383140564,\n", - " (2060, 9): 8.444648504257202,\n", - " (2060, 10): 0.0,\n", - " (2060, 11): 44.4221248626709,\n", - " (2060, 12): 66.21320533752441}},\n", - " 415: {'monthly': {(2060, 1): 148.02130699157715,\n", - " (2060, 2): 230.60166609287262,\n", - " (2060, 3): 332.43688344955444,\n", - " (2060, 4): 118.33550751209259,\n", - " (2060, 5): 7.9455002546310425,\n", - " (2060, 6): 1.1001338958740234,\n", - " (2060, 7): 4.58988082408905,\n", - " (2060, 8): 24.35272526741028,\n", - " (2060, 9): 10.444849371910095,\n", - " (2060, 10): 1.0291311740875244,\n", - " (2060, 11): 73.86825597286224,\n", - " (2060, 12): 190.71734309196472},\n", - " 'window': {(2060, 1): 51.939881324768066,\n", - " (2060, 2): 69.68643999099731,\n", - " (2060, 3): 64.99771690368652,\n", - " (2060, 4): 38.55761957168579,\n", - " (2060, 5): 3.281296491622925,\n", - " (2060, 6): 1.1001338958740234,\n", - " (2060, 7): 3.3676012754440308,\n", - " (2060, 8): 14.7510085105896,\n", - " (2060, 9): 7.238506197929382,\n", - " (2060, 10): 1.0291311740875244,\n", - " (2060, 11): 59.883748054504395,\n", - " (2060, 12): 56.30603218078613}}}" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], - "execution_count": 20 - }, - { - "metadata": { - "ExecuteTime": { - "end_time": "2025-01-08T16:10:16.943894Z", - "start_time": "2025-01-08T16:10:16.931660Z" - } - }, - "cell_type": "code", - "source": "closest_grid_index", - "id": "bac0e63a52c2236", - "outputs": [ - { - "data": { - "text/plain": [ - "array([74])" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "execution_count": 13 - }, - { - "metadata": { - "ExecuteTime": { - "end_time": "2025-01-06T10:16:03.168255Z", - "start_time": "2025-01-06T10:16:01.594780Z" - } - }, - "cell_type": "code", - "source": "data_all_models.mean(dim=[\"lat\", \"lon\", \"time\"], skipna=True)", - "id": "b49522beae4dffc8", - "outputs": [ - { - "data": { - "text/plain": [ - " Size: 2kB\n", - "Dimensions: (model: 22)\n", - "Coordinates:\n", - " * model (model) \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.Dataset> Size: 2kB\n",
-       "Dimensions:  (model: 22)\n",
-       "Coordinates:\n",
-       "  * model    (model) <U16 1kB 'NESM3' 'GFDL-ESM4' ... 'FGOALS-g3' 'BCC-CSM2-MR'\n",
-       "Data variables:\n",
-       "    pr       (model) float64 176B nan nan nan nan nan ... nan nan nan nan nan
" - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" + "Processing year 2024, month 1\n", + "Processing year 2024, month 2\n", + "Processing year 2024, month 3\n", + "Processing year 2024, month 4\n", + "Processing year 2024, month 5\n", + "Processing year 2024, month 6\n", + "Processing year 2024, month 7\n", + "Processing year 2024, month 8\n", + "Processing year 2024, month 9\n", + "Processing year 2024, month 10\n", + "Processing year 2024, month 11\n", + "Processing year 2024, month 12\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing file: CIL_subset_ssp585_2025.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2025, month 1\n", + "Processing year 2025, month 2\n", + "Processing year 2025, month 3\n", + "Processing year 2025, month 4\n", + "Processing year 2025, month 5\n", + "Processing year 2025, month 6\n", + "Processing year 2025, month 7\n", + "Processing year 2025, month 8\n", + "Processing year 2025, month 9\n", + "Processing year 2025, month 10\n", + "Processing year 2025, month 11\n", + "Processing year 2025, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2025, month 1\n", + "Processing year 2025, month 2\n", + "Processing year 2025, month 3\n", + "Processing year 2025, month 4\n", + "Processing year 2025, month 5\n", + "Processing year 2025, month 6\n", + "Processing year 2025, month 7\n", + "Processing year 2025, month 8\n", + "Processing year 2025, month 9\n", + "Processing year 2025, month 10\n", + "Processing year 2025, month 11\n", + "Processing year 2025, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2025, month 1\n", + "Processing year 2025, month 2\n", + "Processing year 2025, month 3\n", + "Processing year 2025, month 4\n", + "Processing year 2025, month 5\n", + "Processing year 2025, month 6\n", + "Processing year 2025, month 7\n", + "Processing year 2025, month 8\n", + "Processing year 2025, month 9\n", + "Processing year 2025, month 10\n", + "Processing year 2025, month 11\n", + "Processing year 2025, month 12\n", + "Processing file: CIL_subset_ssp585_2026.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2026, month 1\n", + "Processing year 2026, month 2\n", + "Processing year 2026, month 3\n", + "Processing year 2026, month 4\n", + "Processing year 2026, month 5\n", + "Processing year 2026, month 6\n", + "Processing year 2026, month 7\n", + "Processing year 2026, month 8\n", + "Processing year 2026, month 9\n", + "Processing year 2026, month 10\n", + "Processing year 2026, month 11\n", + "Processing year 2026, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2026, month 1\n", + "Processing year 2026, month 2\n", + "Processing year 2026, month 3\n", + "Processing year 2026, month 4\n", + "Processing year 2026, month 5\n", + "Processing year 2026, month 6\n", + "Processing year 2026, month 7\n", + "Processing year 2026, month 8\n", + "Processing year 2026, month 9\n", + "Processing year 2026, month 10\n", + "Processing year 2026, month 11\n", + "Processing year 2026, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2026, month 1\n", + "Processing year 2026, month 2\n", + "Processing year 2026, month 3\n", + "Processing year 2026, month 4\n", + "Processing year 2026, month 5\n", + "Processing year 2026, month 6\n", + "Processing year 2026, month 7\n", + "Processing year 2026, month 8\n", + "Processing year 2026, month 9\n", + "Processing year 2026, month 10\n", + "Processing year 2026, month 11\n", + "Processing year 2026, month 12\n", + "Processing file: CIL_subset_ssp585_2027.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2027, month 1\n", + "Processing year 2027, month 2\n", + "Processing year 2027, month 3\n", + "Processing year 2027, month 4\n", + "Processing year 2027, month 5\n", + "Processing year 2027, month 6\n", + "Processing year 2027, month 7\n", + "Processing year 2027, month 8\n", + "Processing year 2027, month 9\n", + "Processing year 2027, month 10\n", + "Processing year 2027, month 11\n", + "Processing year 2027, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2027, month 1\n", + "Processing year 2027, month 2\n", + "Processing year 2027, month 3\n", + "Processing year 2027, month 4\n", + "Processing year 2027, month 5\n", + "Processing year 2027, month 6\n", + "Processing year 2027, month 7\n", + "Processing year 2027, month 8\n", + "Processing year 2027, month 9\n", + "Processing year 2027, month 10\n", + "Processing year 2027, month 11\n", + "Processing year 2027, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2027, month 1\n", + "Processing year 2027, month 2\n", + "Processing year 2027, month 3\n", + "Processing year 2027, month 4\n", + "Processing year 2027, month 5\n", + "Processing year 2027, month 6\n", + "Processing year 2027, month 7\n", + "Processing year 2027, month 8\n", + "Processing year 2027, month 9\n", + "Processing year 2027, month 10\n", + "Processing year 2027, month 11\n", + "Processing year 2027, month 12\n", + "Processing file: CIL_subset_ssp585_2028.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2028, month 1\n", + "Processing year 2028, month 2\n", + "Processing year 2028, month 3\n", + "Processing year 2028, month 4\n", + "Processing year 2028, month 5\n", + "Processing year 2028, month 6\n", + "Processing year 2028, month 7\n", + "Processing year 2028, month 8\n", + "Processing year 2028, month 9\n", + "Processing year 2028, month 10\n", + "Processing year 2028, month 11\n", + "Processing year 2028, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2028, month 1\n", + "Processing year 2028, month 2\n", + "Processing year 2028, month 3\n", + "Processing year 2028, month 4\n", + "Processing year 2028, month 5\n", + "Processing year 2028, month 6\n", + "Processing year 2028, month 7\n", + "Processing year 2028, month 8\n", + "Processing year 2028, month 9\n", + "Processing year 2028, month 10\n", + "Processing year 2028, month 11\n", + "Processing year 2028, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2028, month 1\n", + "Processing year 2028, month 2\n", + "Processing year 2028, month 3\n", + "Processing year 2028, month 4\n", + "Processing year 2028, month 5\n", + "Processing year 2028, month 6\n", + "Processing year 2028, month 7\n", + "Processing year 2028, month 8\n", + "Processing year 2028, month 9\n", + "Processing year 2028, month 10\n", + "Processing year 2028, month 11\n", + "Processing year 2028, month 12\n", + "Processing file: CIL_subset_ssp585_2029.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2029, month 1\n", + "Processing year 2029, month 2\n", + "Processing year 2029, month 3\n", + "Processing year 2029, month 4\n", + "Processing year 2029, month 5\n", + "Processing year 2029, month 6\n", + "Processing year 2029, month 7\n", + "Processing year 2029, month 8\n", + "Processing year 2029, month 9\n", + "Processing year 2029, month 10\n", + "Processing year 2029, month 11\n", + "Processing year 2029, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2029, month 1\n", + "Processing year 2029, month 2\n", + "Processing year 2029, month 3\n", + "Processing year 2029, month 4\n", + "Processing year 2029, month 5\n", + "Processing year 2029, month 6\n", + "Processing year 2029, month 7\n", + "Processing year 2029, month 8\n", + "Processing year 2029, month 9\n", + "Processing year 2029, month 10\n", + "Processing year 2029, month 11\n", + "Processing year 2029, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2029, month 1\n", + "Processing year 2029, month 2\n", + "Processing year 2029, month 3\n", + "Processing year 2029, month 4\n", + "Processing year 2029, month 5\n", + "Processing year 2029, month 6\n", + "Processing year 2029, month 7\n", + "Processing year 2029, month 8\n", + "Processing year 2029, month 9\n", + "Processing year 2029, month 10\n", + "Processing year 2029, month 11\n", + "Processing year 2029, month 12\n", + "Processing file: CIL_subset_ssp585_2030.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2030, month 1\n", + "Processing year 2030, month 2\n", + "Processing year 2030, month 3\n", + "Processing year 2030, month 4\n", + "Processing year 2030, month 5\n", + "Processing year 2030, month 6\n", + "Processing year 2030, month 7\n", + "Processing year 2030, month 8\n", + "Processing year 2030, month 9\n", + "Processing year 2030, month 10\n", + "Processing year 2030, month 11\n", + "Processing year 2030, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2030, month 1\n", + "Processing year 2030, month 2\n", + "Processing year 2030, month 3\n", + "Processing year 2030, month 4\n", + "Processing year 2030, month 5\n", + "Processing year 2030, month 6\n", + "Processing year 2030, month 7\n", + "Processing year 2030, month 8\n", + "Processing year 2030, month 9\n", + "Processing year 2030, month 10\n", + "Processing year 2030, month 11\n", + "Processing year 2030, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2030, month 1\n", + "Processing year 2030, month 2\n", + "Processing year 2030, month 3\n", + "Processing year 2030, month 4\n", + "Processing year 2030, month 5\n", + "Processing year 2030, month 6\n", + "Processing year 2030, month 7\n", + "Processing year 2030, month 8\n", + "Processing year 2030, month 9\n", + "Processing year 2030, month 10\n", + "Processing year 2030, month 11\n", + "Processing year 2030, month 12\n", + "Processing file: CIL_subset_ssp585_2031.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2031, month 1\n", + "Processing year 2031, month 2\n", + "Processing year 2031, month 3\n", + "Processing year 2031, month 4\n", + "Processing year 2031, month 5\n", + "Processing year 2031, month 6\n", + "Processing year 2031, month 7\n", + "Processing year 2031, month 8\n", + "Processing year 2031, month 9\n", + "Processing year 2031, month 10\n", + "Processing year 2031, month 11\n", + "Processing year 2031, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2031, month 1\n", + "Processing year 2031, month 2\n", + "Processing year 2031, month 3\n", + "Processing year 2031, month 4\n", + "Processing year 2031, month 5\n", + "Processing year 2031, month 6\n", + "Processing year 2031, month 7\n", + "Processing year 2031, month 8\n", + "Processing year 2031, month 9\n", + "Processing year 2031, month 10\n", + "Processing year 2031, month 11\n", + "Processing year 2031, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2031, month 1\n", + "Processing year 2031, month 2\n", + "Processing year 2031, month 3\n", + "Processing year 2031, month 4\n", + "Processing year 2031, month 5\n", + "Processing year 2031, month 6\n", + "Processing year 2031, month 7\n", + "Processing year 2031, month 8\n", + "Processing year 2031, month 9\n", + "Processing year 2031, month 10\n", + "Processing year 2031, month 11\n", + "Processing year 2031, month 12\n", + "Processing file: CIL_subset_ssp585_2032.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2032, month 1\n", + "Processing year 2032, month 2\n", + "Processing year 2032, month 3\n", + "Processing year 2032, month 4\n", + "Processing year 2032, month 5\n", + "Processing year 2032, month 6\n", + "Processing year 2032, month 7\n", + "Processing year 2032, month 8\n", + "Processing year 2032, month 9\n", + "Processing year 2032, month 10\n", + "Processing year 2032, month 11\n", + "Processing year 2032, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2032, month 1\n", + "Processing year 2032, month 2\n", + "Processing year 2032, month 3\n", + "Processing year 2032, month 4\n", + "Processing year 2032, month 5\n", + "Processing year 2032, month 6\n", + "Processing year 2032, month 7\n", + "Processing year 2032, month 8\n", + "Processing year 2032, month 9\n", + "Processing year 2032, month 10\n", + "Processing year 2032, month 11\n", + "Processing year 2032, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2032, month 1\n", + "Processing year 2032, month 2\n", + "Processing year 2032, month 3\n", + "Processing year 2032, month 4\n", + "Processing year 2032, month 5\n", + "Processing year 2032, month 6\n", + "Processing year 2032, month 7\n", + "Processing year 2032, month 8\n", + "Processing year 2032, month 9\n", + "Processing year 2032, month 10\n", + "Processing year 2032, month 11\n", + "Processing year 2032, month 12\n", + "Processing file: CIL_subset_ssp585_2033.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2033, month 1\n", + "Processing year 2033, month 2\n", + "Processing year 2033, month 3\n", + "Processing year 2033, month 4\n", + "Processing year 2033, month 5\n", + "Processing year 2033, month 6\n", + "Processing year 2033, month 7\n", + "Processing year 2033, month 8\n", + "Processing year 2033, month 9\n", + "Processing year 2033, month 10\n", + "Processing year 2033, month 11\n", + "Processing year 2033, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2033, month 1\n", + "Processing year 2033, month 2\n", + "Processing year 2033, month 3\n", + "Processing year 2033, month 4\n", + "Processing year 2033, month 5\n", + "Processing year 2033, month 6\n", + "Processing year 2033, month 7\n", + "Processing year 2033, month 8\n", + "Processing year 2033, month 9\n", + "Processing year 2033, month 10\n", + "Processing year 2033, month 11\n", + "Processing year 2033, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2033, month 1\n", + "Processing year 2033, month 2\n", + "Processing year 2033, month 3\n", + "Processing year 2033, month 4\n", + "Processing year 2033, month 5\n", + "Processing year 2033, month 6\n", + "Processing year 2033, month 7\n", + "Processing year 2033, month 8\n", + "Processing year 2033, month 9\n", + "Processing year 2033, month 10\n", + "Processing year 2033, month 11\n", + "Processing year 2033, month 12\n", + "Processing file: CIL_subset_ssp585_2034.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2034, month 1\n", + "Processing year 2034, month 2\n", + "Processing year 2034, month 3\n", + "Processing year 2034, month 4\n", + "Processing year 2034, month 5\n", + "Processing year 2034, month 6\n", + "Processing year 2034, month 7\n", + "Processing year 2034, month 8\n", + "Processing year 2034, month 9\n", + "Processing year 2034, month 10\n", + "Processing year 2034, month 11\n", + "Processing year 2034, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2034, month 1\n", + "Processing year 2034, month 2\n", + "Processing year 2034, month 3\n", + "Processing year 2034, month 4\n", + "Processing year 2034, month 5\n", + "Processing year 2034, month 6\n", + "Processing year 2034, month 7\n", + "Processing year 2034, month 8\n", + "Processing year 2034, month 9\n", + "Processing year 2034, month 10\n", + "Processing year 2034, month 11\n", + "Processing year 2034, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2034, month 1\n", + "Processing year 2034, month 2\n", + "Processing year 2034, month 3\n", + "Processing year 2034, month 4\n", + "Processing year 2034, month 5\n", + "Processing year 2034, month 6\n", + "Processing year 2034, month 7\n", + "Processing year 2034, month 8\n", + "Processing year 2034, month 9\n", + "Processing year 2034, month 10\n", + "Processing year 2034, month 11\n", + "Processing year 2034, month 12\n", + "Processing file: CIL_subset_ssp585_2035.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2035, month 1\n", + "Processing year 2035, month 2\n", + "Processing year 2035, month 3\n", + "Processing year 2035, month 4\n", + "Processing year 2035, month 5\n", + "Processing year 2035, month 6\n", + "Processing year 2035, month 7\n", + "Processing year 2035, month 8\n", + "Processing year 2035, month 9\n", + "Processing year 2035, month 10\n", + "Processing year 2035, month 11\n", + "Processing year 2035, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2035, month 1\n", + "Processing year 2035, month 2\n", + "Processing year 2035, month 3\n", + "Processing year 2035, month 4\n", + "Processing year 2035, month 5\n", + "Processing year 2035, month 6\n", + "Processing year 2035, month 7\n", + "Processing year 2035, month 8\n", + "Processing year 2035, month 9\n", + "Processing year 2035, month 10\n", + "Processing year 2035, month 11\n", + "Processing year 2035, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2035, month 1\n", + "Processing year 2035, month 2\n", + "Processing year 2035, month 3\n", + "Processing year 2035, month 4\n", + "Processing year 2035, month 5\n", + "Processing year 2035, month 6\n", + "Processing year 2035, month 7\n", + "Processing year 2035, month 8\n", + "Processing year 2035, month 9\n", + "Processing year 2035, month 10\n", + "Processing year 2035, month 11\n", + "Processing year 2035, month 12\n", + "Processing file: CIL_subset_ssp585_2036.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2036, month 1\n", + "Processing year 2036, month 2\n", + "Processing year 2036, month 3\n", + "Processing year 2036, month 4\n", + "Processing year 2036, month 5\n", + "Processing year 2036, month 6\n", + "Processing year 2036, month 7\n", + "Processing year 2036, month 8\n", + "Processing year 2036, month 9\n", + "Processing year 2036, month 10\n", + "Processing year 2036, month 11\n", + "Processing year 2036, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2036, month 1\n", + "Processing year 2036, month 2\n", + "Processing year 2036, month 3\n", + "Processing year 2036, month 4\n", + "Processing year 2036, month 5\n", + "Processing year 2036, month 6\n", + "Processing year 2036, month 7\n", + "Processing year 2036, month 8\n", + "Processing year 2036, month 9\n", + "Processing year 2036, month 10\n", + "Processing year 2036, month 11\n", + "Processing year 2036, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2036, month 1\n", + "Processing year 2036, month 2\n", + "Processing year 2036, month 3\n", + "Processing year 2036, month 4\n", + "Processing year 2036, month 5\n", + "Processing year 2036, month 6\n", + "Processing year 2036, month 7\n", + "Processing year 2036, month 8\n", + "Processing year 2036, month 9\n", + "Processing year 2036, month 10\n", + "Processing year 2036, month 11\n", + "Processing year 2036, month 12\n", + "Processing file: CIL_subset_ssp585_2037.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2037, month 1\n", + "Processing year 2037, month 2\n", + "Processing year 2037, month 3\n", + "Processing year 2037, month 4\n", + "Processing year 2037, month 5\n", + "Processing year 2037, month 6\n", + "Processing year 2037, month 7\n", + "Processing year 2037, month 8\n", + "Processing year 2037, month 9\n", + "Processing year 2037, month 10\n", + "Processing year 2037, month 11\n", + "Processing year 2037, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2037, month 1\n", + "Processing year 2037, month 2\n", + "Processing year 2037, month 3\n", + "Processing year 2037, month 4\n", + "Processing year 2037, month 5\n", + "Processing year 2037, month 6\n", + "Processing year 2037, month 7\n", + "Processing year 2037, month 8\n", + "Processing year 2037, month 9\n", + "Processing year 2037, month 10\n", + "Processing year 2037, month 11\n", + "Processing year 2037, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2037, month 1\n", + "Processing year 2037, month 2\n", + "Processing year 2037, month 3\n", + "Processing year 2037, month 4\n", + "Processing year 2037, month 5\n", + "Processing year 2037, month 6\n", + "Processing year 2037, month 7\n", + "Processing year 2037, month 8\n", + "Processing year 2037, month 9\n", + "Processing year 2037, month 10\n", + "Processing year 2037, month 11\n", + "Processing year 2037, month 12\n", + "Processing file: CIL_subset_ssp585_2038.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2038, month 1\n", + "Processing year 2038, month 2\n", + "Processing year 2038, month 3\n", + "Processing year 2038, month 4\n", + "Processing year 2038, month 5\n", + "Processing year 2038, month 6\n", + "Processing year 2038, month 7\n", + "Processing year 2038, month 8\n", + "Processing year 2038, month 9\n", + "Processing year 2038, month 10\n", + "Processing year 2038, month 11\n", + "Processing year 2038, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2038, month 1\n", + "Processing year 2038, month 2\n", + "Processing year 2038, month 3\n", + "Processing year 2038, month 4\n", + "Processing year 2038, month 5\n", + "Processing year 2038, month 6\n", + "Processing year 2038, month 7\n", + "Processing year 2038, month 8\n", + "Processing year 2038, month 9\n", + "Processing year 2038, month 10\n", + "Processing year 2038, month 11\n", + "Processing year 2038, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2038, month 1\n", + "Processing year 2038, month 2\n", + "Processing year 2038, month 3\n", + "Processing year 2038, month 4\n", + "Processing year 2038, month 5\n", + "Processing year 2038, month 6\n", + "Processing year 2038, month 7\n", + "Processing year 2038, month 8\n", + "Processing year 2038, month 9\n", + "Processing year 2038, month 10\n", + "Processing year 2038, month 11\n", + "Processing year 2038, month 12\n", + "Processing file: CIL_subset_ssp585_2039.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2039, month 1\n", + "Processing year 2039, month 2\n", + "Processing year 2039, month 3\n", + "Processing year 2039, month 4\n", + "Processing year 2039, month 5\n", + "Processing year 2039, month 6\n", + "Processing year 2039, month 7\n", + "Processing year 2039, month 8\n", + "Processing year 2039, month 9\n", + "Processing year 2039, month 10\n", + "Processing year 2039, month 11\n", + "Processing year 2039, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2039, month 1\n", + "Processing year 2039, month 2\n", + "Processing year 2039, month 3\n", + "Processing year 2039, month 4\n", + "Processing year 2039, month 5\n", + "Processing year 2039, month 6\n", + "Processing year 2039, month 7\n", + "Processing year 2039, month 8\n", + "Processing year 2039, month 9\n", + "Processing year 2039, month 10\n", + "Processing year 2039, month 11\n", + "Processing year 2039, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2039, month 1\n", + "Processing year 2039, month 2\n", + "Processing year 2039, month 3\n", + "Processing year 2039, month 4\n", + "Processing year 2039, month 5\n", + "Processing year 2039, month 6\n", + "Processing year 2039, month 7\n", + "Processing year 2039, month 8\n", + "Processing year 2039, month 9\n", + "Processing year 2039, month 10\n", + "Processing year 2039, month 11\n", + "Processing year 2039, month 12\n", + "Processing file: CIL_subset_ssp585_2040.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2040, month 1\n", + "Processing year 2040, month 2\n", + "Processing year 2040, month 3\n", + "Processing year 2040, month 4\n", + "Processing year 2040, month 5\n", + "Processing year 2040, month 6\n", + "Processing year 2040, month 7\n", + "Processing year 2040, month 8\n", + "Processing year 2040, month 9\n", + "Processing year 2040, month 10\n", + "Processing year 2040, month 11\n", + "Processing year 2040, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2040, month 1\n", + "Processing year 2040, month 2\n", + "Processing year 2040, month 3\n", + "Processing year 2040, month 4\n", + "Processing year 2040, month 5\n", + "Processing year 2040, month 6\n", + "Processing year 2040, month 7\n", + "Processing year 2040, month 8\n", + "Processing year 2040, month 9\n", + "Processing year 2040, month 10\n", + "Processing year 2040, month 11\n", + "Processing year 2040, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2040, month 1\n", + "Processing year 2040, month 2\n", + "Processing year 2040, month 3\n", + "Processing year 2040, month 4\n", + "Processing year 2040, month 5\n", + "Processing year 2040, month 6\n", + "Processing year 2040, month 7\n", + "Processing year 2040, month 8\n", + "Processing year 2040, month 9\n", + "Processing year 2040, month 10\n", + "Processing year 2040, month 11\n", + "Processing year 2040, month 12\n", + "Processing file: CIL_subset_ssp585_2041.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2041, month 1\n", + "Processing year 2041, month 2\n", + "Processing year 2041, month 3\n", + "Processing year 2041, month 4\n", + "Processing year 2041, month 5\n", + "Processing year 2041, month 6\n", + "Processing year 2041, month 7\n", + "Processing year 2041, month 8\n", + "Processing year 2041, month 9\n", + "Processing year 2041, month 10\n", + "Processing year 2041, month 11\n", + "Processing year 2041, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2041, month 1\n", + "Processing year 2041, month 2\n", + "Processing year 2041, month 3\n", + "Processing year 2041, month 4\n", + "Processing year 2041, month 5\n", + "Processing year 2041, month 6\n", + "Processing year 2041, month 7\n", + "Processing year 2041, month 8\n", + "Processing year 2041, month 9\n", + "Processing year 2041, month 10\n", + "Processing year 2041, month 11\n", + "Processing year 2041, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2041, month 1\n", + "Processing year 2041, month 2\n", + "Processing year 2041, month 3\n", + "Processing year 2041, month 4\n", + "Processing year 2041, month 5\n", + "Processing year 2041, month 6\n", + "Processing year 2041, month 7\n", + "Processing year 2041, month 8\n", + "Processing year 2041, month 9\n", + "Processing year 2041, month 10\n", + "Processing year 2041, month 11\n", + "Processing year 2041, month 12\n", + "Processing file: CIL_subset_ssp585_2042.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2042, month 1\n", + "Processing year 2042, month 2\n", + "Processing year 2042, month 3\n", + "Processing year 2042, month 4\n", + "Processing year 2042, month 5\n", + "Processing year 2042, month 6\n", + "Processing year 2042, month 7\n", + "Processing year 2042, month 8\n", + "Processing year 2042, month 9\n", + "Processing year 2042, month 10\n", + "Processing year 2042, month 11\n", + "Processing year 2042, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2042, month 1\n", + "Processing year 2042, month 2\n", + "Processing year 2042, month 3\n", + "Processing year 2042, month 4\n", + "Processing year 2042, month 5\n", + "Processing year 2042, month 6\n", + "Processing year 2042, month 7\n", + "Processing year 2042, month 8\n", + "Processing year 2042, month 9\n", + "Processing year 2042, month 10\n", + "Processing year 2042, month 11\n", + "Processing year 2042, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2042, month 1\n", + "Processing year 2042, month 2\n", + "Processing year 2042, month 3\n", + "Processing year 2042, month 4\n", + "Processing year 2042, month 5\n", + "Processing year 2042, month 6\n", + "Processing year 2042, month 7\n", + "Processing year 2042, month 8\n", + "Processing year 2042, month 9\n", + "Processing year 2042, month 10\n", + "Processing year 2042, month 11\n", + "Processing year 2042, month 12\n", + "Processing file: CIL_subset_ssp585_2043.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2043, month 1\n", + "Processing year 2043, month 2\n", + "Processing year 2043, month 3\n", + "Processing year 2043, month 4\n", + "Processing year 2043, month 5\n", + "Processing year 2043, month 6\n", + "Processing year 2043, month 7\n", + "Processing year 2043, month 8\n", + "Processing year 2043, month 9\n", + "Processing year 2043, month 10\n", + "Processing year 2043, month 11\n", + "Processing year 2043, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2043, month 1\n", + "Processing year 2043, month 2\n", + "Processing year 2043, month 3\n", + "Processing year 2043, month 4\n", + "Processing year 2043, month 5\n", + "Processing year 2043, month 6\n", + "Processing year 2043, month 7\n", + "Processing year 2043, month 8\n", + "Processing year 2043, month 9\n", + "Processing year 2043, month 10\n", + "Processing year 2043, month 11\n", + "Processing year 2043, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2043, month 1\n", + "Processing year 2043, month 2\n", + "Processing year 2043, month 3\n", + "Processing year 2043, month 4\n", + "Processing year 2043, month 5\n", + "Processing year 2043, month 6\n", + "Processing year 2043, month 7\n", + "Processing year 2043, month 8\n", + "Processing year 2043, month 9\n", + "Processing year 2043, month 10\n", + "Processing year 2043, month 11\n", + "Processing year 2043, month 12\n", + "Processing file: CIL_subset_ssp585_2044.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2044, month 1\n", + "Processing year 2044, month 2\n", + "Processing year 2044, month 3\n", + "Processing year 2044, month 4\n", + "Processing year 2044, month 5\n", + "Processing year 2044, month 6\n", + "Processing year 2044, month 7\n", + "Processing year 2044, month 8\n", + "Processing year 2044, month 9\n", + "Processing year 2044, month 10\n", + "Processing year 2044, month 11\n", + "Processing year 2044, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2044, month 1\n", + "Processing year 2044, month 2\n", + "Processing year 2044, month 3\n", + "Processing year 2044, month 4\n", + "Processing year 2044, month 5\n", + "Processing year 2044, month 6\n", + "Processing year 2044, month 7\n", + "Processing year 2044, month 8\n", + "Processing year 2044, month 9\n", + "Processing year 2044, month 10\n", + "Processing year 2044, month 11\n", + "Processing year 2044, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2044, month 1\n", + "Processing year 2044, month 2\n", + "Processing year 2044, month 3\n", + "Processing year 2044, month 4\n", + "Processing year 2044, month 5\n", + "Processing year 2044, month 6\n", + "Processing year 2044, month 7\n", + "Processing year 2044, month 8\n", + "Processing year 2044, month 9\n", + "Processing year 2044, month 10\n", + "Processing year 2044, month 11\n", + "Processing year 2044, month 12\n", + "Processing file: CIL_subset_ssp585_2045.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2045, month 1\n", + "Processing year 2045, month 2\n", + "Processing year 2045, month 3\n", + "Processing year 2045, month 4\n", + "Processing year 2045, month 5\n", + "Processing year 2045, month 6\n", + "Processing year 2045, month 7\n", + "Processing year 2045, month 8\n", + "Processing year 2045, month 9\n", + "Processing year 2045, month 10\n", + "Processing year 2045, month 11\n", + "Processing year 2045, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2045, month 1\n", + "Processing year 2045, month 2\n", + "Processing year 2045, month 3\n", + "Processing year 2045, month 4\n", + "Processing year 2045, month 5\n", + "Processing year 2045, month 6\n", + "Processing year 2045, month 7\n", + "Processing year 2045, month 8\n", + "Processing year 2045, month 9\n", + "Processing year 2045, month 10\n", + "Processing year 2045, month 11\n", + "Processing year 2045, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2045, month 1\n", + "Processing year 2045, month 2\n", + "Processing year 2045, month 3\n", + "Processing year 2045, month 4\n", + "Processing year 2045, month 5\n", + "Processing year 2045, month 6\n", + "Processing year 2045, month 7\n", + "Processing year 2045, month 8\n", + "Processing year 2045, month 9\n", + "Processing year 2045, month 10\n", + "Processing year 2045, month 11\n", + "Processing year 2045, month 12\n", + "Processing file: CIL_subset_ssp585_2046.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2046, month 1\n", + "Processing year 2046, month 2\n", + "Processing year 2046, month 3\n", + "Processing year 2046, month 4\n", + "Processing year 2046, month 5\n", + "Processing year 2046, month 6\n", + "Processing year 2046, month 7\n", + "Processing year 2046, month 8\n", + "Processing year 2046, month 9\n", + "Processing year 2046, month 10\n", + "Processing year 2046, month 11\n", + "Processing year 2046, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2046, month 1\n", + "Processing year 2046, month 2\n", + "Processing year 2046, month 3\n", + "Processing year 2046, month 4\n", + "Processing year 2046, month 5\n", + "Processing year 2046, month 6\n", + "Processing year 2046, month 7\n", + "Processing year 2046, month 8\n", + "Processing year 2046, month 9\n", + "Processing year 2046, month 10\n", + "Processing year 2046, month 11\n", + "Processing year 2046, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2046, month 1\n", + "Processing year 2046, month 2\n", + "Processing year 2046, month 3\n", + "Processing year 2046, month 4\n", + "Processing year 2046, month 5\n", + "Processing year 2046, month 6\n", + "Processing year 2046, month 7\n", + "Processing year 2046, month 8\n", + "Processing year 2046, month 9\n", + "Processing year 2046, month 10\n", + "Processing year 2046, month 11\n", + "Processing year 2046, month 12\n", + "Processing file: CIL_subset_ssp585_2047.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2047, month 1\n", + "Processing year 2047, month 2\n", + "Processing year 2047, month 3\n", + "Processing year 2047, month 4\n", + "Processing year 2047, month 5\n", + "Processing year 2047, month 6\n", + "Processing year 2047, month 7\n", + "Processing year 2047, month 8\n", + "Processing year 2047, month 9\n", + "Processing year 2047, month 10\n", + "Processing year 2047, month 11\n", + "Processing year 2047, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2047, month 1\n", + "Processing year 2047, month 2\n", + "Processing year 2047, month 3\n", + "Processing year 2047, month 4\n", + "Processing year 2047, month 5\n", + "Processing year 2047, month 6\n", + "Processing year 2047, month 7\n", + "Processing year 2047, month 8\n", + "Processing year 2047, month 9\n", + "Processing year 2047, month 10\n", + "Processing year 2047, month 11\n", + "Processing year 2047, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2047, month 1\n", + "Processing year 2047, month 2\n", + "Processing year 2047, month 3\n", + "Processing year 2047, month 4\n", + "Processing year 2047, month 5\n", + "Processing year 2047, month 6\n", + "Processing year 2047, month 7\n", + "Processing year 2047, month 8\n", + "Processing year 2047, month 9\n", + "Processing year 2047, month 10\n", + "Processing year 2047, month 11\n", + "Processing year 2047, month 12\n", + "Processing file: CIL_subset_ssp585_2048.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2048, month 1\n", + "Processing year 2048, month 2\n", + "Processing year 2048, month 3\n", + "Processing year 2048, month 4\n", + "Processing year 2048, month 5\n", + "Processing year 2048, month 6\n", + "Processing year 2048, month 7\n", + "Processing year 2048, month 8\n", + "Processing year 2048, month 9\n", + "Processing year 2048, month 10\n", + "Processing year 2048, month 11\n", + "Processing year 2048, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2048, month 1\n", + "Processing year 2048, month 2\n", + "Processing year 2048, month 3\n", + "Processing year 2048, month 4\n", + "Processing year 2048, month 5\n", + "Processing year 2048, month 6\n", + "Processing year 2048, month 7\n", + "Processing year 2048, month 8\n", + "Processing year 2048, month 9\n", + "Processing year 2048, month 10\n", + "Processing year 2048, month 11\n", + "Processing year 2048, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2048, month 1\n", + "Processing year 2048, month 2\n", + "Processing year 2048, month 3\n", + "Processing year 2048, month 4\n", + "Processing year 2048, month 5\n", + "Processing year 2048, month 6\n", + "Processing year 2048, month 7\n", + "Processing year 2048, month 8\n", + "Processing year 2048, month 9\n", + "Processing year 2048, month 10\n", + "Processing year 2048, month 11\n", + "Processing year 2048, month 12\n", + "Processing file: CIL_subset_ssp585_2049.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2049, month 1\n", + "Processing year 2049, month 2\n", + "Processing year 2049, month 3\n", + "Processing year 2049, month 4\n", + "Processing year 2049, month 5\n", + "Processing year 2049, month 6\n", + "Processing year 2049, month 7\n", + "Processing year 2049, month 8\n", + "Processing year 2049, month 9\n", + "Processing year 2049, month 10\n", + "Processing year 2049, month 11\n", + "Processing year 2049, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2049, month 1\n", + "Processing year 2049, month 2\n", + "Processing year 2049, month 3\n", + "Processing year 2049, month 4\n", + "Processing year 2049, month 5\n", + "Processing year 2049, month 6\n", + "Processing year 2049, month 7\n", + "Processing year 2049, month 8\n", + "Processing year 2049, month 9\n", + "Processing year 2049, month 10\n", + "Processing year 2049, month 11\n", + "Processing year 2049, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2049, month 1\n", + "Processing year 2049, month 2\n", + "Processing year 2049, month 3\n", + "Processing year 2049, month 4\n", + "Processing year 2049, month 5\n", + "Processing year 2049, month 6\n", + "Processing year 2049, month 7\n", + "Processing year 2049, month 8\n", + "Processing year 2049, month 9\n", + "Processing year 2049, month 10\n", + "Processing year 2049, month 11\n", + "Processing year 2049, month 12\n", + "Processing file: CIL_subset_ssp585_2050.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2050, month 1\n", + "Processing year 2050, month 2\n", + "Processing year 2050, month 3\n", + "Processing year 2050, month 4\n", + "Processing year 2050, month 5\n", + "Processing year 2050, month 6\n", + "Processing year 2050, month 7\n", + "Processing year 2050, month 8\n", + "Processing year 2050, month 9\n", + "Processing year 2050, month 10\n", + "Processing year 2050, month 11\n", + "Processing year 2050, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2050, month 1\n", + "Processing year 2050, month 2\n", + "Processing year 2050, month 3\n", + "Processing year 2050, month 4\n", + "Processing year 2050, month 5\n", + "Processing year 2050, month 6\n", + "Processing year 2050, month 7\n", + "Processing year 2050, month 8\n", + "Processing year 2050, month 9\n", + "Processing year 2050, month 10\n", + "Processing year 2050, month 11\n", + "Processing year 2050, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2050, month 1\n", + "Processing year 2050, month 2\n", + "Processing year 2050, month 3\n", + "Processing year 2050, month 4\n", + "Processing year 2050, month 5\n", + "Processing year 2050, month 6\n", + "Processing year 2050, month 7\n", + "Processing year 2050, month 8\n", + "Processing year 2050, month 9\n", + "Processing year 2050, month 10\n", + "Processing year 2050, month 11\n", + "Processing year 2050, month 12\n", + "Processing file: CIL_subset_ssp585_2051.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2051, month 1\n", + "Processing year 2051, month 2\n", + "Processing year 2051, month 3\n", + "Processing year 2051, month 4\n", + "Processing year 2051, month 5\n", + "Processing year 2051, month 6\n", + "Processing year 2051, month 7\n", + "Processing year 2051, month 8\n", + "Processing year 2051, month 9\n", + "Processing year 2051, month 10\n", + "Processing year 2051, month 11\n", + "Processing year 2051, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2051, month 1\n", + "Processing year 2051, month 2\n", + "Processing year 2051, month 3\n", + "Processing year 2051, month 4\n", + "Processing year 2051, month 5\n", + "Processing year 2051, month 6\n", + "Processing year 2051, month 7\n", + "Processing year 2051, month 8\n", + "Processing year 2051, month 9\n", + "Processing year 2051, month 10\n", + "Processing year 2051, month 11\n", + "Processing year 2051, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2051, month 1\n", + "Processing year 2051, month 2\n", + "Processing year 2051, month 3\n", + "Processing year 2051, month 4\n", + "Processing year 2051, month 5\n", + "Processing year 2051, month 6\n", + "Processing year 2051, month 7\n", + "Processing year 2051, month 8\n", + "Processing year 2051, month 9\n", + "Processing year 2051, month 10\n", + "Processing year 2051, month 11\n", + "Processing year 2051, month 12\n", + "Processing file: CIL_subset_ssp585_2052.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2052, month 1\n", + "Processing year 2052, month 2\n", + "Processing year 2052, month 3\n", + "Processing year 2052, month 4\n", + "Processing year 2052, month 5\n", + "Processing year 2052, month 6\n", + "Processing year 2052, month 7\n", + "Processing year 2052, month 8\n", + "Processing year 2052, month 9\n", + "Processing year 2052, month 10\n", + "Processing year 2052, month 11\n", + "Processing year 2052, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2052, month 1\n", + "Processing year 2052, month 2\n", + "Processing year 2052, month 3\n", + "Processing year 2052, month 4\n", + "Processing year 2052, month 5\n", + "Processing year 2052, month 6\n", + "Processing year 2052, month 7\n", + "Processing year 2052, month 8\n", + "Processing year 2052, month 9\n", + "Processing year 2052, month 10\n", + "Processing year 2052, month 11\n", + "Processing year 2052, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2052, month 1\n", + "Processing year 2052, month 2\n", + "Processing year 2052, month 3\n", + "Processing year 2052, month 4\n", + "Processing year 2052, month 5\n", + "Processing year 2052, month 6\n", + "Processing year 2052, month 7\n", + "Processing year 2052, month 8\n", + "Processing year 2052, month 9\n", + "Processing year 2052, month 10\n", + "Processing year 2052, month 11\n", + "Processing year 2052, month 12\n", + "Processing file: CIL_subset_ssp585_2053.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2053, month 1\n", + "Processing year 2053, month 2\n", + "Processing year 2053, month 3\n", + "Processing year 2053, month 4\n", + "Processing year 2053, month 5\n", + "Processing year 2053, month 6\n", + "Processing year 2053, month 7\n", + "Processing year 2053, month 8\n", + "Processing year 2053, month 9\n", + "Processing year 2053, month 10\n", + "Processing year 2053, month 11\n", + "Processing year 2053, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2053, month 1\n", + "Processing year 2053, month 2\n", + "Processing year 2053, month 3\n", + "Processing year 2053, month 4\n", + "Processing year 2053, month 5\n", + "Processing year 2053, month 6\n", + "Processing year 2053, month 7\n", + "Processing year 2053, month 8\n", + "Processing year 2053, month 9\n", + "Processing year 2053, month 10\n", + "Processing year 2053, month 11\n", + "Processing year 2053, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2053, month 1\n", + "Processing year 2053, month 2\n", + "Processing year 2053, month 3\n", + "Processing year 2053, month 4\n", + "Processing year 2053, month 5\n", + "Processing year 2053, month 6\n", + "Processing year 2053, month 7\n", + "Processing year 2053, month 8\n", + "Processing year 2053, month 9\n", + "Processing year 2053, month 10\n", + "Processing year 2053, month 11\n", + "Processing year 2053, month 12\n", + "Processing file: CIL_subset_ssp585_2054.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2054, month 1\n", + "Processing year 2054, month 2\n", + "Processing year 2054, month 3\n", + "Processing year 2054, month 4\n", + "Processing year 2054, month 5\n", + "Processing year 2054, month 6\n", + "Processing year 2054, month 7\n", + "Processing year 2054, month 8\n", + "Processing year 2054, month 9\n", + "Processing year 2054, month 10\n", + "Processing year 2054, month 11\n", + "Processing year 2054, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2054, month 1\n", + "Processing year 2054, month 2\n", + "Processing year 2054, month 3\n", + "Processing year 2054, month 4\n", + "Processing year 2054, month 5\n", + "Processing year 2054, month 6\n", + "Processing year 2054, month 7\n", + "Processing year 2054, month 8\n", + "Processing year 2054, month 9\n", + "Processing year 2054, month 10\n", + "Processing year 2054, month 11\n", + "Processing year 2054, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2054, month 1\n", + "Processing year 2054, month 2\n", + "Processing year 2054, month 3\n", + "Processing year 2054, month 4\n", + "Processing year 2054, month 5\n", + "Processing year 2054, month 6\n", + "Processing year 2054, month 7\n", + "Processing year 2054, month 8\n", + "Processing year 2054, month 9\n", + "Processing year 2054, month 10\n", + "Processing year 2054, month 11\n", + "Processing year 2054, month 12\n", + "Processing file: CIL_subset_ssp585_2055.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2055, month 1\n", + "Processing year 2055, month 2\n", + "Processing year 2055, month 3\n", + "Processing year 2055, month 4\n", + "Processing year 2055, month 5\n", + "Processing year 2055, month 6\n", + "Processing year 2055, month 7\n", + "Processing year 2055, month 8\n", + "Processing year 2055, month 9\n", + "Processing year 2055, month 10\n", + "Processing year 2055, month 11\n", + "Processing year 2055, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2055, month 1\n", + "Processing year 2055, month 2\n", + "Processing year 2055, month 3\n", + "Processing year 2055, month 4\n", + "Processing year 2055, month 5\n", + "Processing year 2055, month 6\n", + "Processing year 2055, month 7\n", + "Processing year 2055, month 8\n", + "Processing year 2055, month 9\n", + "Processing year 2055, month 10\n", + "Processing year 2055, month 11\n", + "Processing year 2055, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2055, month 1\n", + "Processing year 2055, month 2\n", + "Processing year 2055, month 3\n", + "Processing year 2055, month 4\n", + "Processing year 2055, month 5\n", + "Processing year 2055, month 6\n", + "Processing year 2055, month 7\n", + "Processing year 2055, month 8\n", + "Processing year 2055, month 9\n", + "Processing year 2055, month 10\n", + "Processing year 2055, month 11\n", + "Processing year 2055, month 12\n", + "Processing file: CIL_subset_ssp585_2056.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2056, month 1\n", + "Processing year 2056, month 2\n", + "Processing year 2056, month 3\n", + "Processing year 2056, month 4\n", + "Processing year 2056, month 5\n", + "Processing year 2056, month 6\n", + "Processing year 2056, month 7\n", + "Processing year 2056, month 8\n", + "Processing year 2056, month 9\n", + "Processing year 2056, month 10\n", + "Processing year 2056, month 11\n", + "Processing year 2056, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2056, month 1\n", + "Processing year 2056, month 2\n", + "Processing year 2056, month 3\n", + "Processing year 2056, month 4\n", + "Processing year 2056, month 5\n", + "Processing year 2056, month 6\n", + "Processing year 2056, month 7\n", + "Processing year 2056, month 8\n", + "Processing year 2056, month 9\n", + "Processing year 2056, month 10\n", + "Processing year 2056, month 11\n", + "Processing year 2056, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2056, month 1\n", + "Processing year 2056, month 2\n", + "Processing year 2056, month 3\n", + "Processing year 2056, month 4\n", + "Processing year 2056, month 5\n", + "Processing year 2056, month 6\n", + "Processing year 2056, month 7\n", + "Processing year 2056, month 8\n", + "Processing year 2056, month 9\n", + "Processing year 2056, month 10\n", + "Processing year 2056, month 11\n", + "Processing year 2056, month 12\n", + "Processing file: CIL_subset_ssp585_2057.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2057, month 1\n", + "Processing year 2057, month 2\n", + "Processing year 2057, month 3\n", + "Processing year 2057, month 4\n", + "Processing year 2057, month 5\n", + "Processing year 2057, month 6\n", + "Processing year 2057, month 7\n", + "Processing year 2057, month 8\n", + "Processing year 2057, month 9\n", + "Processing year 2057, month 10\n", + "Processing year 2057, month 11\n", + "Processing year 2057, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2057, month 1\n", + "Processing year 2057, month 2\n", + "Processing year 2057, month 3\n", + "Processing year 2057, month 4\n", + "Processing year 2057, month 5\n", + "Processing year 2057, month 6\n", + "Processing year 2057, month 7\n", + "Processing year 2057, month 8\n", + "Processing year 2057, month 9\n", + "Processing year 2057, month 10\n", + "Processing year 2057, month 11\n", + "Processing year 2057, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2057, month 1\n", + "Processing year 2057, month 2\n", + "Processing year 2057, month 3\n", + "Processing year 2057, month 4\n", + "Processing year 2057, month 5\n", + "Processing year 2057, month 6\n", + "Processing year 2057, month 7\n", + "Processing year 2057, month 8\n", + "Processing year 2057, month 9\n", + "Processing year 2057, month 10\n", + "Processing year 2057, month 11\n", + "Processing year 2057, month 12\n", + "Processing file: CIL_subset_ssp585_2058.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2058, month 1\n", + "Processing year 2058, month 2\n", + "Processing year 2058, month 3\n", + "Processing year 2058, month 4\n", + "Processing year 2058, month 5\n", + "Processing year 2058, month 6\n", + "Processing year 2058, month 7\n", + "Processing year 2058, month 8\n", + "Processing year 2058, month 9\n", + "Processing year 2058, month 10\n", + "Processing year 2058, month 11\n", + "Processing year 2058, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2058, month 1\n", + "Processing year 2058, month 2\n", + "Processing year 2058, month 3\n", + "Processing year 2058, month 4\n", + "Processing year 2058, month 5\n", + "Processing year 2058, month 6\n", + "Processing year 2058, month 7\n", + "Processing year 2058, month 8\n", + "Processing year 2058, month 9\n", + "Processing year 2058, month 10\n", + "Processing year 2058, month 11\n", + "Processing year 2058, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2058, month 1\n", + "Processing year 2058, month 2\n", + "Processing year 2058, month 3\n", + "Processing year 2058, month 4\n", + "Processing year 2058, month 5\n", + "Processing year 2058, month 6\n", + "Processing year 2058, month 7\n", + "Processing year 2058, month 8\n", + "Processing year 2058, month 9\n", + "Processing year 2058, month 10\n", + "Processing year 2058, month 11\n", + "Processing year 2058, month 12\n", + "Processing file: CIL_subset_ssp585_2059.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2059, month 1\n", + "Processing year 2059, month 2\n", + "Processing year 2059, month 3\n", + "Processing year 2059, month 4\n", + "Processing year 2059, month 5\n", + "Processing year 2059, month 6\n", + "Processing year 2059, month 7\n", + "Processing year 2059, month 8\n", + "Processing year 2059, month 9\n", + "Processing year 2059, month 10\n", + "Processing year 2059, month 11\n", + "Processing year 2059, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2059, month 1\n", + "Processing year 2059, month 2\n", + "Processing year 2059, month 3\n", + "Processing year 2059, month 4\n", + "Processing year 2059, month 5\n", + "Processing year 2059, month 6\n", + "Processing year 2059, month 7\n", + "Processing year 2059, month 8\n", + "Processing year 2059, month 9\n", + "Processing year 2059, month 10\n", + "Processing year 2059, month 11\n", + "Processing year 2059, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2059, month 1\n", + "Processing year 2059, month 2\n", + "Processing year 2059, month 3\n", + "Processing year 2059, month 4\n", + "Processing year 2059, month 5\n", + "Processing year 2059, month 6\n", + "Processing year 2059, month 7\n", + "Processing year 2059, month 8\n", + "Processing year 2059, month 9\n", + "Processing year 2059, month 10\n", + "Processing year 2059, month 11\n", + "Processing year 2059, month 12\n", + "Processing file: CIL_subset_ssp585_2060.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2060, month 1\n", + "Processing year 2060, month 2\n", + "Processing year 2060, month 3\n", + "Processing year 2060, month 4\n", + "Processing year 2060, month 5\n", + "Processing year 2060, month 6\n", + "Processing year 2060, month 7\n", + "Processing year 2060, month 8\n", + "Processing year 2060, month 9\n", + "Processing year 2060, month 10\n", + "Processing year 2060, month 11\n", + "Processing year 2060, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2060, month 1\n", + "Processing year 2060, month 2\n", + "Processing year 2060, month 3\n", + "Processing year 2060, month 4\n", + "Processing year 2060, month 5\n", + "Processing year 2060, month 6\n", + "Processing year 2060, month 7\n", + "Processing year 2060, month 8\n", + "Processing year 2060, month 9\n", + "Processing year 2060, month 10\n", + "Processing year 2060, month 11\n", + "Processing year 2060, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2060, month 1\n", + "Processing year 2060, month 2\n", + "Processing year 2060, month 3\n", + "Processing year 2060, month 4\n", + "Processing year 2060, month 5\n", + "Processing year 2060, month 6\n", + "Processing year 2060, month 7\n", + "Processing year 2060, month 8\n", + "Processing year 2060, month 9\n", + "Processing year 2060, month 10\n", + "Processing year 2060, month 11\n", + "Processing year 2060, month 12\n", + "Processing file: CIL_subset_ssp585_2061.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2061, month 1\n", + "Processing year 2061, month 2\n", + "Processing year 2061, month 3\n", + "Processing year 2061, month 4\n", + "Processing year 2061, month 5\n", + "Processing year 2061, month 6\n", + "Processing year 2061, month 7\n", + "Processing year 2061, month 8\n", + "Processing year 2061, month 9\n", + "Processing year 2061, month 10\n", + "Processing year 2061, month 11\n", + "Processing year 2061, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2061, month 1\n", + "Processing year 2061, month 2\n", + "Processing year 2061, month 3\n", + "Processing year 2061, month 4\n", + "Processing year 2061, month 5\n", + "Processing year 2061, month 6\n", + "Processing year 2061, month 7\n", + "Processing year 2061, month 8\n", + "Processing year 2061, month 9\n", + "Processing year 2061, month 10\n", + "Processing year 2061, month 11\n", + "Processing year 2061, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2061, month 1\n", + "Processing year 2061, month 2\n", + "Processing year 2061, month 3\n", + "Processing year 2061, month 4\n", + "Processing year 2061, month 5\n", + "Processing year 2061, month 6\n", + "Processing year 2061, month 7\n", + "Processing year 2061, month 8\n", + "Processing year 2061, month 9\n", + "Processing year 2061, month 10\n", + "Processing year 2061, month 11\n", + "Processing year 2061, month 12\n", + "Processing file: CIL_subset_ssp585_2062.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2062, month 1\n", + "Processing year 2062, month 2\n", + "Processing year 2062, month 3\n", + "Processing year 2062, month 4\n", + "Processing year 2062, month 5\n", + "Processing year 2062, month 6\n", + "Processing year 2062, month 7\n", + "Processing year 2062, month 8\n", + "Processing year 2062, month 9\n", + "Processing year 2062, month 10\n", + "Processing year 2062, month 11\n", + "Processing year 2062, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2062, month 1\n", + "Processing year 2062, month 2\n", + "Processing year 2062, month 3\n", + "Processing year 2062, month 4\n", + "Processing year 2062, month 5\n", + "Processing year 2062, month 6\n", + "Processing year 2062, month 7\n", + "Processing year 2062, month 8\n", + "Processing year 2062, month 9\n", + "Processing year 2062, month 10\n", + "Processing year 2062, month 11\n", + "Processing year 2062, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2062, month 1\n", + "Processing year 2062, month 2\n", + "Processing year 2062, month 3\n", + "Processing year 2062, month 4\n", + "Processing year 2062, month 5\n", + "Processing year 2062, month 6\n", + "Processing year 2062, month 7\n", + "Processing year 2062, month 8\n", + "Processing year 2062, month 9\n", + "Processing year 2062, month 10\n", + "Processing year 2062, month 11\n", + "Processing year 2062, month 12\n", + "Processing file: CIL_subset_ssp585_2063.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2063, month 1\n", + "Processing year 2063, month 2\n", + "Processing year 2063, month 3\n", + "Processing year 2063, month 4\n", + "Processing year 2063, month 5\n", + "Processing year 2063, month 6\n", + "Processing year 2063, month 7\n", + "Processing year 2063, month 8\n", + "Processing year 2063, month 9\n", + "Processing year 2063, month 10\n", + "Processing year 2063, month 11\n", + "Processing year 2063, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2063, month 1\n", + "Processing year 2063, month 2\n", + "Processing year 2063, month 3\n", + "Processing year 2063, month 4\n", + "Processing year 2063, month 5\n", + "Processing year 2063, month 6\n", + "Processing year 2063, month 7\n", + "Processing year 2063, month 8\n", + "Processing year 2063, month 9\n", + "Processing year 2063, month 10\n", + "Processing year 2063, month 11\n", + "Processing year 2063, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2063, month 1\n", + "Processing year 2063, month 2\n", + "Processing year 2063, month 3\n", + "Processing year 2063, month 4\n", + "Processing year 2063, month 5\n", + "Processing year 2063, month 6\n", + "Processing year 2063, month 7\n", + "Processing year 2063, month 8\n", + "Processing year 2063, month 9\n", + "Processing year 2063, month 10\n", + "Processing year 2063, month 11\n", + "Processing year 2063, month 12\n", + "Processing file: CIL_subset_ssp585_2064.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2064, month 1\n", + "Processing year 2064, month 2\n", + "Processing year 2064, month 3\n", + "Processing year 2064, month 4\n", + "Processing year 2064, month 5\n", + "Processing year 2064, month 6\n", + "Processing year 2064, month 7\n", + "Processing year 2064, month 8\n", + "Processing year 2064, month 9\n", + "Processing year 2064, month 10\n", + "Processing year 2064, month 11\n", + "Processing year 2064, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2064, month 1\n", + "Processing year 2064, month 2\n", + "Processing year 2064, month 3\n", + "Processing year 2064, month 4\n", + "Processing year 2064, month 5\n", + "Processing year 2064, month 6\n", + "Processing year 2064, month 7\n", + "Processing year 2064, month 8\n", + "Processing year 2064, month 9\n", + "Processing year 2064, month 10\n", + "Processing year 2064, month 11\n", + "Processing year 2064, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2064, month 1\n", + "Processing year 2064, month 2\n", + "Processing year 2064, month 3\n", + "Processing year 2064, month 4\n", + "Processing year 2064, month 5\n", + "Processing year 2064, month 6\n", + "Processing year 2064, month 7\n", + "Processing year 2064, month 8\n", + "Processing year 2064, month 9\n", + "Processing year 2064, month 10\n", + "Processing year 2064, month 11\n", + "Processing year 2064, month 12\n", + "Processing file: CIL_subset_ssp585_2065.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2065, month 1\n", + "Processing year 2065, month 2\n", + "Processing year 2065, month 3\n", + "Processing year 2065, month 4\n", + "Processing year 2065, month 5\n", + "Processing year 2065, month 6\n", + "Processing year 2065, month 7\n", + "Processing year 2065, month 8\n", + "Processing year 2065, month 9\n", + "Processing year 2065, month 10\n", + "Processing year 2065, month 11\n", + "Processing year 2065, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2065, month 1\n", + "Processing year 2065, month 2\n", + "Processing year 2065, month 3\n", + "Processing year 2065, month 4\n", + "Processing year 2065, month 5\n", + "Processing year 2065, month 6\n", + "Processing year 2065, month 7\n", + "Processing year 2065, month 8\n", + "Processing year 2065, month 9\n", + "Processing year 2065, month 10\n", + "Processing year 2065, month 11\n", + "Processing year 2065, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2065, month 1\n", + "Processing year 2065, month 2\n", + "Processing year 2065, month 3\n", + "Processing year 2065, month 4\n", + "Processing year 2065, month 5\n", + "Processing year 2065, month 6\n", + "Processing year 2065, month 7\n", + "Processing year 2065, month 8\n", + "Processing year 2065, month 9\n", + "Processing year 2065, month 10\n", + "Processing year 2065, month 11\n", + "Processing year 2065, month 12\n", + "Processing file: CIL_subset_ssp585_2066.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2066, month 1\n", + "Processing year 2066, month 2\n", + "Processing year 2066, month 3\n", + "Processing year 2066, month 4\n", + "Processing year 2066, month 5\n", + "Processing year 2066, month 6\n", + "Processing year 2066, month 7\n", + "Processing year 2066, month 8\n", + "Processing year 2066, month 9\n", + "Processing year 2066, month 10\n", + "Processing year 2066, month 11\n", + "Processing year 2066, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2066, month 1\n", + "Processing year 2066, month 2\n", + "Processing year 2066, month 3\n", + "Processing year 2066, month 4\n", + "Processing year 2066, month 5\n", + "Processing year 2066, month 6\n", + "Processing year 2066, month 7\n", + "Processing year 2066, month 8\n", + "Processing year 2066, month 9\n", + "Processing year 2066, month 10\n", + "Processing year 2066, month 11\n", + "Processing year 2066, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2066, month 1\n", + "Processing year 2066, month 2\n", + "Processing year 2066, month 3\n", + "Processing year 2066, month 4\n", + "Processing year 2066, month 5\n", + "Processing year 2066, month 6\n", + "Processing year 2066, month 7\n", + "Processing year 2066, month 8\n", + "Processing year 2066, month 9\n", + "Processing year 2066, month 10\n", + "Processing year 2066, month 11\n", + "Processing year 2066, month 12\n", + "Processing file: CIL_subset_ssp585_2067.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2067, month 1\n", + "Processing year 2067, month 2\n", + "Processing year 2067, month 3\n", + "Processing year 2067, month 4\n", + "Processing year 2067, month 5\n", + "Processing year 2067, month 6\n", + "Processing year 2067, month 7\n", + "Processing year 2067, month 8\n", + "Processing year 2067, month 9\n", + "Processing year 2067, month 10\n", + "Processing year 2067, month 11\n", + "Processing year 2067, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2067, month 1\n", + "Processing year 2067, month 2\n", + "Processing year 2067, month 3\n", + "Processing year 2067, month 4\n", + "Processing year 2067, month 5\n", + "Processing year 2067, month 6\n", + "Processing year 2067, month 7\n", + "Processing year 2067, month 8\n", + "Processing year 2067, month 9\n", + "Processing year 2067, month 10\n", + "Processing year 2067, month 11\n", + "Processing year 2067, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2067, month 1\n", + "Processing year 2067, month 2\n", + "Processing year 2067, month 3\n", + "Processing year 2067, month 4\n", + "Processing year 2067, month 5\n", + "Processing year 2067, month 6\n", + "Processing year 2067, month 7\n", + "Processing year 2067, month 8\n", + "Processing year 2067, month 9\n", + "Processing year 2067, month 10\n", + "Processing year 2067, month 11\n", + "Processing year 2067, month 12\n", + "Processing file: CIL_subset_ssp585_2068.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2068, month 1\n", + "Processing year 2068, month 2\n", + "Processing year 2068, month 3\n", + "Processing year 2068, month 4\n", + "Processing year 2068, month 5\n", + "Processing year 2068, month 6\n", + "Processing year 2068, month 7\n", + "Processing year 2068, month 8\n", + "Processing year 2068, month 9\n", + "Processing year 2068, month 10\n", + "Processing year 2068, month 11\n", + "Processing year 2068, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2068, month 1\n", + "Processing year 2068, month 2\n", + "Processing year 2068, month 3\n", + "Processing year 2068, month 4\n", + "Processing year 2068, month 5\n", + "Processing year 2068, month 6\n", + "Processing year 2068, month 7\n", + "Processing year 2068, month 8\n", + "Processing year 2068, month 9\n", + "Processing year 2068, month 10\n", + "Processing year 2068, month 11\n", + "Processing year 2068, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2068, month 1\n", + "Processing year 2068, month 2\n", + "Processing year 2068, month 3\n", + "Processing year 2068, month 4\n", + "Processing year 2068, month 5\n", + "Processing year 2068, month 6\n", + "Processing year 2068, month 7\n", + "Processing year 2068, month 8\n", + "Processing year 2068, month 9\n", + "Processing year 2068, month 10\n", + "Processing year 2068, month 11\n", + "Processing year 2068, month 12\n", + "Processing file: CIL_subset_ssp585_2069.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2069, month 1\n", + "Processing year 2069, month 2\n", + "Processing year 2069, month 3\n", + "Processing year 2069, month 4\n", + "Processing year 2069, month 5\n", + "Processing year 2069, month 6\n", + "Processing year 2069, month 7\n", + "Processing year 2069, month 8\n", + "Processing year 2069, month 9\n", + "Processing year 2069, month 10\n", + "Processing year 2069, month 11\n", + "Processing year 2069, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2069, month 1\n", + "Processing year 2069, month 2\n", + "Processing year 2069, month 3\n", + "Processing year 2069, month 4\n", + "Processing year 2069, month 5\n", + "Processing year 2069, month 6\n", + "Processing year 2069, month 7\n", + "Processing year 2069, month 8\n", + "Processing year 2069, month 9\n", + "Processing year 2069, month 10\n", + "Processing year 2069, month 11\n", + "Processing year 2069, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2069, month 1\n", + "Processing year 2069, month 2\n", + "Processing year 2069, month 3\n", + "Processing year 2069, month 4\n", + "Processing year 2069, month 5\n", + "Processing year 2069, month 6\n", + "Processing year 2069, month 7\n", + "Processing year 2069, month 8\n", + "Processing year 2069, month 9\n", + "Processing year 2069, month 10\n", + "Processing year 2069, month 11\n", + "Processing year 2069, month 12\n", + "Processing file: CIL_subset_ssp585_2070.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2070, month 1\n", + "Processing year 2070, month 2\n", + "Processing year 2070, month 3\n", + "Processing year 2070, month 4\n", + "Processing year 2070, month 5\n", + "Processing year 2070, month 6\n", + "Processing year 2070, month 7\n", + "Processing year 2070, month 8\n", + "Processing year 2070, month 9\n", + "Processing year 2070, month 10\n", + "Processing year 2070, month 11\n", + "Processing year 2070, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2070, month 1\n", + "Processing year 2070, month 2\n", + "Processing year 2070, month 3\n", + "Processing year 2070, month 4\n", + "Processing year 2070, month 5\n", + "Processing year 2070, month 6\n", + "Processing year 2070, month 7\n", + "Processing year 2070, month 8\n", + "Processing year 2070, month 9\n", + "Processing year 2070, month 10\n", + "Processing year 2070, month 11\n", + "Processing year 2070, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2070, month 1\n", + "Processing year 2070, month 2\n", + "Processing year 2070, month 3\n", + "Processing year 2070, month 4\n", + "Processing year 2070, month 5\n", + "Processing year 2070, month 6\n", + "Processing year 2070, month 7\n", + "Processing year 2070, month 8\n", + "Processing year 2070, month 9\n", + "Processing year 2070, month 10\n", + "Processing year 2070, month 11\n", + "Processing year 2070, month 12\n", + "Saved monthly data for lowest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/lowest_monthly_prediction_weather_by_facility.csv\n", + "Saved window data for lowest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/lowest_window_prediction_weather_by_facility.csv\n", + "Saved monthly data for mean model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/mean_monthly_prediction_weather_by_facility.csv\n", + "Saved window data for mean model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/mean_window_prediction_weather_by_facility.csv\n", + "Saved monthly data for highest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/highest_monthly_prediction_weather_by_facility.csv\n", + "Saved window data for highest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/highest_window_prediction_weather_by_facility.csv\n" + ] } ], - "execution_count": 27 + "execution_count": 13 }, { "metadata": {}, @@ -14500,7 +5847,7 @@ "outputs": [], "execution_count": null, "source": "", - "id": "4d60f3606b689dd2" + "id": "f0a57d0d924da84e" } ], "metadata": { From 58b4f7ba724610f7c48a98e51dc72e6e5e67eea5 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 16 Jan 2025 09:02:38 +0000 Subject: [PATCH 201/291] Added conversion factor of births to pregnancies (1.4) --- src/scripts/climate_change/cohort_model.py | 542 +++++++++------------ 1 file changed, 241 insertions(+), 301 deletions(-) diff --git a/src/scripts/climate_change/cohort_model.py b/src/scripts/climate_change/cohort_model.py index 56d1285bef..c8cf743778 100644 --- a/src/scripts/climate_change/cohort_model.py +++ b/src/scripts/climate_change/cohort_model.py @@ -60,248 +60,248 @@ malawi_admin2['ADM2_EN'] = malawi_admin2['ADM2_EN'].replace('Mzuzu City', 'Mzuzu') malawi_admin2['ADM2_EN'] = malawi_admin2['ADM2_EN'].replace('Lilongwe City', 'Lilongwe') -# difference_lat = lat_data[1] - lat_data[0] -# difference_long = long_data[1] - long_data[0] -# -# # # Get expected disturbance from the model +difference_lat = lat_data[1] - lat_data[0] +difference_long = long_data[1] - long_data[0] -# results_list = [] -# -# #Loop through scenarios and model types -# for scenario in scenarios: -# for model_type in model_types: -# predictions_from_cmip = pd.read_csv( -# f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' -# ) -# predictions_from_cmip_sum = predictions_from_cmip.groupby('Year').sum().reset_index() -# predictions_from_cmip_sum['Percentage_Difference'] = ( -# predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum[ -# 'Predicted_No_Weather_Model']) -# # Match birth results and predictions -# matching_rows = min(len(births_model_subset), len(predictions_from_cmip_sum)) -# multiplied_values = births_model_subset.head(matching_rows).iloc[:, 1].values * predictions_from_cmip_sum[ -# 'Percentage_Difference'].head(matching_rows).values -# births_model_subset['Multiplied_Values'] = multiplied_values -# -# # Plot the results -# plt.plot(year_range, multiplied_values) -# plt.ylabel("Change ANC cases due to weather") -# plt.axhline(y=0, color='black', linestyle='--') -# plt.plot(year_range, predictions_from_cmip_sum.iloc[0:36, -1] * 100) -# plt.xlabel("Percentage Change in ANC cases due to weather") -# plt.axhline(y=0, color='black', linestyle='--') -# plt.ylim(-12000,0) -# # Check for negative values (missed cases?) -# negative_sum = np.sum(multiplied_values[multiplied_values < 0]) -# -# result_df = pd.DataFrame({ -# "Scenario": [scenario], -# "Model_Type": [model_type], -# "Negative_Sum": [negative_sum], -# "Negative_Percentage": [negative_sum / births_model_subset['Model_mean'].sum() * 100] -# }) -# -# results_list.append(result_df) -# # Plot by zone -# predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'Zone']).sum().reset_index() -# plt.figure(figsize=(10, 6)) -# for zone in predictions_from_cmip_sum['Zone'].unique(): -# zone_data = predictions_from_cmip_sum[predictions_from_cmip_sum['Zone'] == zone] -# zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data[ -# 'Predicted_No_Weather_Model']) * 100 -# plt.plot(zone_data['Year'], zone_data['Percentage_Difference'], label=f'Zone {zone}') -# plt.xlabel("Year") -# plt.ylabel("Change ANC cases due to weather") -# plt.axhline(y=0, color='black', linestyle='--') -# plt.ylim(-1.5, 0) -# plt.legend(title='Zones') -# -# # Plot by district -# predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'District']).sum().reset_index() -# plt.figure(figsize=(10, 6)) -# for district in predictions_from_cmip_sum['District'].unique(): -# district_data = predictions_from_cmip_sum[predictions_from_cmip_sum['District'] == district] -# district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data[ -# 'Predicted_No_Weather_Model']) * 100 -# plt.plot(district_data['Year'], district_data['Percentage_Difference'], label=f'{district}') -# plt.xlabel("Year") -# plt.ylabel("Change ANC cases due to weather") -# plt.axhline(y=0, color='black', linestyle='--') -# plt.ylim(-2.5, 0) -# plt.legend(title='Districts') -# -# # Generate district map visualization -# predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( -# {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"}) -# polygons = [ -# Polygon( -# [(x, y), (x + difference_long, y), (x + difference_long, y + difference_lat), (x, y + difference_lat)]) -# for x in long_data for y in lat_data -# ] -# grid = gpd.GeoDataFrame({'geometry': polygons}, crs=malawi.crs) -# grid_clipped_ADM2 = gpd.overlay(grid, malawi_admin2, how='intersection') -# predictions_from_cmip_sum['Percentage_Difference'] = (predictions_from_cmip_sum['Difference_in_Expectation'] / -# predictions_from_cmip_sum[ -# 'Predicted_No_Weather_Model']) * 100 -# percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() -# malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) -# malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 -# -# # Plot map -# fig, ax = plt.subplots(figsize=(12, 12)) -# #malawi_admin2.plot(ax=ax, edgecolor='white', color='white') -# malawi_admin2.dropna(subset=['Percentage_Difference']).plot( -# ax=ax, -# column='Percentage_Difference', -# cmap='Blues_r', -# edgecolor='black', -# alpha=1, -# legend=False -# ) -# sm = plt.cm.ScalarMappable(cmap='Blues_r', -# norm=mcolors.Normalize(vmin=malawi_admin2['Percentage_Difference'].min(), -# vmax=malawi_admin2['Percentage_Difference'].max())) -# sm.set_array([]) -# cbar = plt.colorbar(sm, ax=ax, orientation="vertical", shrink=0.7) -# cbar.set_label("Percentage Difference (%)", fontsize=12) -# plt.xlabel("Longitude", fontsize=14) -# plt.ylabel("Latitude", fontsize=14) -# plt.title(f"{scenario}: {model_type}", fontsize=16) -# plt.tight_layout() -# plt.savefig(results_folder_to_save / f'{scenario}_{model_type}_map_Malawi_cumulative_difference.png') -# # Save multiplied values by model and scenario -# multiplied_values_df = pd.DataFrame({ -# 'Year': year_range[:matching_rows], -# 'Scenario': scenario, -# 'Model_Type': model_type, -# 'Multiplied_Values': multiplied_values -# }) -# multiplied_values_df.to_csv(results_folder_to_save/f'multiplied_values_{scenario}_{model_type}.csv', index=False) -# -# final_results = pd.concat(results_list, ignore_index=True) -# final_results.to_csv('/Users/rem76/Desktop/Climate_change_health/Results/ANC_disruptions/negative_sums_and_percentages.csv', index=False) -# -# # Get unique districts from both sources -# adm2_districts = set(grid_clipped_ADM2['ADM2_EN'].unique()) -# prediction_districts = set(predictions_from_cmip_sum['District'].unique()) -# -# # Districts in ADM2 but not in predictions -# missing_in_predictions = adm2_districts - prediction_districts -# print("Districts in ADM2 but not in predictions:", missing_in_predictions) -# -# # Districts in predictions but not in ADM2 -# missing_in_adm2 = prediction_districts - adm2_districts -# print("Districts in predictions but not in ADM2:", missing_in_adm2) -# -# -# -# -# ## now all grids -# fig, axes = plt.subplots(2, 3, figsize=(18, 12), constrained_layout=True) -# -# global_min = float('inf') -# global_max = float('-inf') -# -# for scenario in scenarios: -# for model_type in model_types: -# predictions_from_cmip = pd.read_csv( -# f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' -# ) -# predictions_from_cmip_sum = predictions_from_cmip.groupby('District').sum().reset_index() -# predictions_from_cmip_sum['Percentage_Difference'] = ( -# predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model'] -# ) * 100 -# -# predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( -# {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} -# ) -# percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() -# malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) -# malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 -# -# local_min = malawi_admin2['Percentage_Difference'].min() -# local_max = malawi_admin2['Percentage_Difference'].max() -# global_min = min(global_min, local_min) -# global_max = max(global_max, local_max) -# -# for i, scenario in enumerate(scenarios): -# for j, model_type in enumerate(model_types): -# predictions_from_cmip = pd.read_csv( -# f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' -# ) -# predictions_from_cmip_sum = predictions_from_cmip.groupby('District').sum().reset_index() -# predictions_from_cmip_sum['Percentage_Difference'] = ( -# predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model'] -# ) * 100 -# -# predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( -# {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} -# ) -# percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() -# print(percentage_diff_by_district) -# malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) -# malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 -# -# ax = axes[i, j] -# malawi_admin2.dropna(subset=['Percentage_Difference']).plot( -# ax=ax, -# column='Percentage_Difference', -# cmap='Blues_r', -# edgecolor='black', -# alpha=1, -# legend=False, -# vmin=global_min, -# vmax=global_max -# ) -# -# ax.set_title(f"{scenario}: {model_type}", fontsize=14) -# -# if i != 1: -# ax.set_xlabel("") -# if j != 0: -# ax.set_ylabel("") -# else: -# ax.set_ylabel("Latitude", fontsize=10) -# -# if i == 1: -# ax.set_xlabel("Longitude", fontsize=10) -# -# sm = plt.cm.ScalarMappable( -# cmap='Blues_r', -# norm=mcolors.Normalize(vmin=global_min, vmax=global_max) -# ) -# sm.set_array([]) -# fig.colorbar(sm, ax=axes, orientation="vertical", shrink=0.8, label="Percentage Difference (%)") -# plt.suptitle("Percentage Difference Maps by Scenario and Model Type", fontsize=16, y=1.02) -# # plt.savefig(results_folder_to_save / 'percentage_difference_maps_grid.png') -# plt.show() -# -# -# -# significant_results_year = [] -# # -# # Assuming 'district' is a column in your data -# for scenario in scenarios: -# for model_type in model_types: -# predictions_from_cmip = pd.read_csv( -# f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' -# ) -# predictions_from_cmip_sum = predictions_from_cmip.groupby(['District', 'Year']).sum().reset_index() -# for district in predictions_from_cmip_sum['District'].unique(): -# district_values = predictions_from_cmip_sum[predictions_from_cmip_sum['District'] == district] -# no_weather_model = district_values['Predicted_No_Weather_Model'].values -# weather_model = district_values['Predicted_Weather_Model'].values -# -# # Calculate the difference -# difference = no_weather_model - weather_model +# # Get expected disturbance from the model + +results_list = [] + +#Loop through scenarios and model types +for scenario in scenarios: + for model_type in model_types: + predictions_from_cmip = pd.read_csv( + f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' + ) + predictions_from_cmip_sum = predictions_from_cmip.groupby('Year').sum().reset_index() + predictions_from_cmip_sum['Percentage_Difference'] = ( + predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum[ + 'Predicted_No_Weather_Model']) + # Match birth results and predictions + matching_rows = min(len(births_model_subset), len(predictions_from_cmip_sum)) + multiplied_values = births_model_subset.head(matching_rows).iloc[:, 1].values * predictions_from_cmip_sum[ + 'Percentage_Difference'].head(matching_rows).values + births_model_subset['Multiplied_Values'] = multiplied_values + + # Plot the results + plt.plot(year_range, multiplied_values) + plt.ylabel("Change ANC cases due to weather") + plt.axhline(y=0, color='black', linestyle='--') + plt.plot(year_range, predictions_from_cmip_sum.iloc[0:36, -1] * 100) + plt.xlabel("Percentage Change in ANC cases due to weather") + plt.axhline(y=0, color='black', linestyle='--') + plt.ylim(-12000,0) + # Check for negative values (missed cases?) + negative_sum = np.sum(multiplied_values[multiplied_values < 0]) + + result_df = pd.DataFrame({ + "Scenario": [scenario], + "Model_Type": [model_type], + "Negative_Sum": [negative_sum], + "Negative_Percentage": [negative_sum / births_model_subset['Model_mean'].sum() * 100] + }) + + results_list.append(result_df) + # Plot by zone + predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'Zone']).sum().reset_index() + plt.figure(figsize=(10, 6)) + for zone in predictions_from_cmip_sum['Zone'].unique(): + zone_data = predictions_from_cmip_sum[predictions_from_cmip_sum['Zone'] == zone] + zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data[ + 'Predicted_No_Weather_Model']) * 100 + plt.plot(zone_data['Year'], zone_data['Percentage_Difference'], label=f'Zone {zone}') + plt.xlabel("Year") + plt.ylabel("Change ANC cases due to weather") + plt.axhline(y=0, color='black', linestyle='--') + plt.ylim(-1.5, 0) + plt.legend(title='Zones') + + # Plot by district + predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'District']).sum().reset_index() + plt.figure(figsize=(10, 6)) + for district in predictions_from_cmip_sum['District'].unique(): + district_data = predictions_from_cmip_sum[predictions_from_cmip_sum['District'] == district] + district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data[ + 'Predicted_No_Weather_Model']) * 100 + plt.plot(district_data['Year'], district_data['Percentage_Difference'], label=f'{district}') + plt.xlabel("Year") + plt.ylabel("Change ANC cases due to weather") + plt.axhline(y=0, color='black', linestyle='--') + plt.ylim(-2.5, 0) + plt.legend(title='Districts') + + # Generate district map visualization + predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( + {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"}) + polygons = [ + Polygon( + [(x, y), (x + difference_long, y), (x + difference_long, y + difference_lat), (x, y + difference_lat)]) + for x in long_data for y in lat_data + ] + grid = gpd.GeoDataFrame({'geometry': polygons}, crs=malawi.crs) + grid_clipped_ADM2 = gpd.overlay(grid, malawi_admin2, how='intersection') + predictions_from_cmip_sum['Percentage_Difference'] = (predictions_from_cmip_sum['Difference_in_Expectation'] / + predictions_from_cmip_sum[ + 'Predicted_No_Weather_Model']) * 100 + percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() + malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) + malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 + + # Plot map + fig, ax = plt.subplots(figsize=(12, 12)) + #malawi_admin2.plot(ax=ax, edgecolor='white', color='white') + malawi_admin2.dropna(subset=['Percentage_Difference']).plot( + ax=ax, + column='Percentage_Difference', + cmap='Blues_r', + edgecolor='black', + alpha=1, + legend=False + ) + sm = plt.cm.ScalarMappable(cmap='Blues_r', + norm=mcolors.Normalize(vmin=malawi_admin2['Percentage_Difference'].min(), + vmax=malawi_admin2['Percentage_Difference'].max())) + sm.set_array([]) + cbar = plt.colorbar(sm, ax=ax, orientation="vertical", shrink=0.7) + cbar.set_label("Percentage Difference (%)", fontsize=12) + plt.xlabel("Longitude", fontsize=14) + plt.ylabel("Latitude", fontsize=14) + plt.title(f"{scenario}: {model_type}", fontsize=16) + plt.tight_layout() + plt.savefig(results_folder_to_save / f'{scenario}_{model_type}_map_Malawi_cumulative_difference.png') + # Save multiplied values by model and scenario + multiplied_values_df = pd.DataFrame({ + 'Year': year_range[:matching_rows], + 'Scenario': scenario, + 'Model_Type': model_type, + 'Multiplied_Values': multiplied_values + }) + multiplied_values_df.to_csv(results_folder_to_save/f'multiplied_values_{scenario}_{model_type}.csv', index=False) + +final_results = pd.concat(results_list, ignore_index=True) +final_results.to_csv('/Users/rem76/Desktop/Climate_change_health/Results/ANC_disruptions/negative_sums_and_percentages.csv', index=False) + +# Get unique districts from both sources +adm2_districts = set(grid_clipped_ADM2['ADM2_EN'].unique()) +prediction_districts = set(predictions_from_cmip_sum['District'].unique()) + +# Districts in ADM2 but not in predictions +missing_in_predictions = adm2_districts - prediction_districts +print("Districts in ADM2 but not in predictions:", missing_in_predictions) + +# Districts in predictions but not in ADM2 +missing_in_adm2 = prediction_districts - adm2_districts +print("Districts in predictions but not in ADM2:", missing_in_adm2) + + + + +## now all grids +fig, axes = plt.subplots(2, 3, figsize=(18, 12), constrained_layout=True) + +global_min = float('inf') +global_max = float('-inf') + +for scenario in scenarios: + for model_type in model_types: + predictions_from_cmip = pd.read_csv( + f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' + ) + predictions_from_cmip_sum = predictions_from_cmip.groupby('District').sum().reset_index() + predictions_from_cmip_sum['Percentage_Difference'] = ( + predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model'] + ) * 100 + + predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( + {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} + ) + percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() + malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) + malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 + + local_min = malawi_admin2['Percentage_Difference'].min() + local_max = malawi_admin2['Percentage_Difference'].max() + global_min = min(global_min, local_min) + global_max = max(global_max, local_max) + +for i, scenario in enumerate(scenarios): + for j, model_type in enumerate(model_types): + predictions_from_cmip = pd.read_csv( + f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' + ) + predictions_from_cmip_sum = predictions_from_cmip.groupby('District').sum().reset_index() + predictions_from_cmip_sum['Percentage_Difference'] = ( + predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model'] + ) * 100 + + predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( + {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} + ) + percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() + print(percentage_diff_by_district) + malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) + malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 + + ax = axes[i, j] + malawi_admin2.dropna(subset=['Percentage_Difference']).plot( + ax=ax, + column='Percentage_Difference', + cmap='Blues_r', + edgecolor='black', + alpha=1, + legend=False, + vmin=global_min, + vmax=global_max + ) + + ax.set_title(f"{scenario}: {model_type}", fontsize=14) + + if i != 1: + ax.set_xlabel("") + if j != 0: + ax.set_ylabel("") + else: + ax.set_ylabel("Latitude", fontsize=10) + + if i == 1: + ax.set_xlabel("Longitude", fontsize=10) + +sm = plt.cm.ScalarMappable( + cmap='Blues_r', + norm=mcolors.Normalize(vmin=global_min, vmax=global_max) +) +sm.set_array([]) +fig.colorbar(sm, ax=axes, orientation="vertical", shrink=0.8, label="Percentage Difference (%)") +plt.suptitle("Percentage Difference Maps by Scenario and Model Type", fontsize=16, y=1.02) +# plt.savefig(results_folder_to_save / 'percentage_difference_maps_grid.png') +plt.show() + + + +significant_results_year = [] # -# # Perform a one-sample t-test assuming 0 as the null hypothesis mean -# t_stat, p_value = ttest_1samp(difference, popmean=0) -# # Print results if p-value is below 0.05 (statistically significant) -# if p_value < 0.05: -# print(f"Scenario: {scenario}, Model Type: {model_type}, District: {district}, " -# f"t-stat: {t_stat:.2f}, p-value: {p_value:.4f}") -# ## now all grids +# Assuming 'district' is a column in your data +for scenario in scenarios: + for model_type in model_types: + predictions_from_cmip = pd.read_csv( + f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' + ) + predictions_from_cmip_sum = predictions_from_cmip.groupby(['District', 'Year']).sum().reset_index() + for district in predictions_from_cmip_sum['District'].unique(): + district_values = predictions_from_cmip_sum[predictions_from_cmip_sum['District'] == district] + no_weather_model = district_values['Predicted_No_Weather_Model'].values + weather_model = district_values['Predicted_Weather_Model'].values + + # Calculate the difference + difference = no_weather_model - weather_model + + # Perform a one-sample t-test assuming 0 as the null hypothesis mean + t_stat, p_value = ttest_1samp(difference, popmean=0) + # Print results if p-value is below 0.05 (statistically significant) + if p_value < 0.05: + print(f"Scenario: {scenario}, Model Type: {model_type}, District: {district}, " + f"t-stat: {t_stat:.2f}, p-value: {p_value:.4f}") +## now all grids #### Now do number of births based on the TLO model and 2018 census population_file = "/Users/rem76/PycharmProjects/TLOmodel/resources/demography/ResourceFile_PopulationSize_2018Census.csv" @@ -355,7 +355,7 @@ percentage_diff_by_year_district[year] = {} if district not in percentage_diff_by_year_district[year]: percentage_diff_by_year_district[year][district] = 0 - percentage_diff_by_year_district[year][district] += (percentage_diff * number_of_births) + percentage_diff_by_year_district[year][district] += (percentage_diff * number_of_births) * 1.4 # 1.4 is conversion factor between births and pregancies data_for_plot = pd.DataFrame.from_dict(percentage_diff_by_year_district, orient='index').fillna(0) y_min = min(y_min, data_for_plot.min().min()) @@ -379,63 +379,3 @@ plt.show() # # - -# Create the figure and axes grid -fig, axes = plt.subplots(2, 3, figsize=(18, 12), constrained_layout=True) - -y_min = float('inf') -y_max = float('-inf') -for i, scenario in enumerate(scenarios): - for j, model_type in enumerate(model_types): - percentage_diff_by_year_district = {} - - predictions_from_cmip = pd.read_csv( - f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' - ) - - predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'District']).sum().reset_index() - predictions_from_cmip_sum = predictions_from_cmip_sum[predictions_from_cmip_sum['Year'] <= 2060] - predictions_from_cmip_sum['Percentage_Difference'] = (predictions_from_cmip_sum[ - 'Difference_in_Expectation'] / - predictions_from_cmip_sum['Predicted_No_Weather_Model'] - ) * 100 - predictions_from_cmip_sum.loc[ - predictions_from_cmip_sum['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 - predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( - {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} - ) - - for year in year_groupings: - subset = predictions_from_cmip_sum[ - (predictions_from_cmip_sum['Year'] >= year) & - (predictions_from_cmip_sum['Year'] <= year + 5) - ] - for _, row in subset.iterrows(): - district = row['District'] - row_index = births_model_subset.index.get_loc(year) - - number_of_births = population_proportion[district] * births_model.iloc[row_index]["Model_mean"] - if year not in percentage_diff_by_year_district: - percentage_diff_by_year_district[year] = {} - if district not in percentage_diff_by_year_district[year]: - percentage_diff_by_year_district[year][district] = 0 - percentage_diff_by_year_district[year][district] += (number_of_births) - - data_for_plot = pd.DataFrame.from_dict(percentage_diff_by_year_district, orient='index').fillna(0) - y_min = min(y_min, data_for_plot.min().min()) - y_max = max(y_max, data_for_plot.max().max()) - - ax = axes[i, j] - data_for_plot.plot(kind='bar', stacked=True, ax=ax, cmap='tab20', legend=False) - ax.set_title(f"{scenario}: {model_type}", fontsize=10) - if i == len(scenarios) - 1: - ax.set_xlabel('Period (5 years)', fontsize=10) - if j == 0: - ax.set_ylabel('Deficit of ANC services', fontsize=10) - if (i == 0) & (j == 2): - ax.legend(title="Districts", fontsize=8, title_fontsize=10, bbox_to_anchor=(1.09, 1)) - - -plt.tight_layout() -# plt.savefig(results_folder_to_save / 'stacked_bar_percentage_difference_5_years_grid_single_legend_with_births.png') -plt.show() From bba3ea4b922c902fe3c3547ffa184e8fd7b2d1d4 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 16 Jan 2025 09:02:50 +0000 Subject: [PATCH 202/291] Added ssp126 --- .../CIL_CMIP6_downscaling.ipynb | 2939 ++++++++--------- 1 file changed, 1468 insertions(+), 1471 deletions(-) diff --git a/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb b/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb index 0c4fb48a79..5dd9545109 100644 --- a/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb +++ b/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb @@ -948,17 +948,14 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-15T16:19:19.414006Z", - "start_time": "2025-01-15T15:44:39.681456Z" + "end_time": "2025-01-16T09:01:09.883037Z", + "start_time": "2025-01-16T08:50:46.687380Z" } }, "cell_type": "code", "source": [ "base_dir = \"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/\"\n", - "scenarios = [\"ssp245\", \"ssp585\"]\n", - "scenarios = [\"ssp126\"]\n", - "scenarios = [\"ssp585\"]\n", - "\n", + "scenarios = [\"ssp126\",\"ssp245\", \"ssp585\"]\n", "window_size = 5\n", "\n", "data_by_model_and_grid = {}\n", @@ -1092,9 +1089,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "Processing scenario: ssp585\n", + "Processing scenario: ssp126\n", "Models of interest ['HadGEM3-GC31-LL', 'UKESM1-0-LL', 'INM-CM5-0']\n", - "Processing file: CIL_subset_ssp585_2024.nc\n", + "Processing file: CIL_subset_ssp126_2024.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2024, month 1\n", "Processing year 2024, month 2\n", @@ -1114,945 +1111,945 @@ "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" ] }, @@ -2079,945 +2076,945 @@ "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" ] }, @@ -3044,945 +3041,945 @@ "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:114: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/915138296.py:116: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" ] }, @@ -3990,7 +3987,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Processing file: CIL_subset_ssp585_2025.nc\n", + "Processing file: CIL_subset_ssp126_2025.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2025, month 1\n", "Processing year 2025, month 2\n", @@ -4030,7 +4027,7 @@ "Processing year 2025, month 10\n", "Processing year 2025, month 11\n", "Processing year 2025, month 12\n", - "Processing file: CIL_subset_ssp585_2026.nc\n", + "Processing file: CIL_subset_ssp126_2026.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2026, month 1\n", "Processing year 2026, month 2\n", @@ -4070,7 +4067,7 @@ "Processing year 2026, month 10\n", "Processing year 2026, month 11\n", "Processing year 2026, month 12\n", - "Processing file: CIL_subset_ssp585_2027.nc\n", + "Processing file: CIL_subset_ssp126_2027.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2027, month 1\n", "Processing year 2027, month 2\n", @@ -4110,7 +4107,7 @@ "Processing year 2027, month 10\n", "Processing year 2027, month 11\n", "Processing year 2027, month 12\n", - "Processing file: CIL_subset_ssp585_2028.nc\n", + "Processing file: CIL_subset_ssp126_2028.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2028, month 1\n", "Processing year 2028, month 2\n", @@ -4150,7 +4147,7 @@ "Processing year 2028, month 10\n", "Processing year 2028, month 11\n", "Processing year 2028, month 12\n", - "Processing file: CIL_subset_ssp585_2029.nc\n", + "Processing file: CIL_subset_ssp126_2029.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2029, month 1\n", "Processing year 2029, month 2\n", @@ -4190,7 +4187,7 @@ "Processing year 2029, month 10\n", "Processing year 2029, month 11\n", "Processing year 2029, month 12\n", - "Processing file: CIL_subset_ssp585_2030.nc\n", + "Processing file: CIL_subset_ssp126_2030.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2030, month 1\n", "Processing year 2030, month 2\n", @@ -4230,7 +4227,7 @@ "Processing year 2030, month 10\n", "Processing year 2030, month 11\n", "Processing year 2030, month 12\n", - "Processing file: CIL_subset_ssp585_2031.nc\n", + "Processing file: CIL_subset_ssp126_2031.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2031, month 1\n", "Processing year 2031, month 2\n", @@ -4270,7 +4267,7 @@ "Processing year 2031, month 10\n", "Processing year 2031, month 11\n", "Processing year 2031, month 12\n", - "Processing file: CIL_subset_ssp585_2032.nc\n", + "Processing file: CIL_subset_ssp126_2032.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2032, month 1\n", "Processing year 2032, month 2\n", @@ -4310,7 +4307,7 @@ "Processing year 2032, month 10\n", "Processing year 2032, month 11\n", "Processing year 2032, month 12\n", - "Processing file: CIL_subset_ssp585_2033.nc\n", + "Processing file: CIL_subset_ssp126_2033.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2033, month 1\n", "Processing year 2033, month 2\n", @@ -4350,7 +4347,7 @@ "Processing year 2033, month 10\n", "Processing year 2033, month 11\n", "Processing year 2033, month 12\n", - "Processing file: CIL_subset_ssp585_2034.nc\n", + "Processing file: CIL_subset_ssp126_2034.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2034, month 1\n", "Processing year 2034, month 2\n", @@ -4390,7 +4387,7 @@ "Processing year 2034, month 10\n", "Processing year 2034, month 11\n", "Processing year 2034, month 12\n", - "Processing file: CIL_subset_ssp585_2035.nc\n", + "Processing file: CIL_subset_ssp126_2035.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2035, month 1\n", "Processing year 2035, month 2\n", @@ -4430,7 +4427,7 @@ "Processing year 2035, month 10\n", "Processing year 2035, month 11\n", "Processing year 2035, month 12\n", - "Processing file: CIL_subset_ssp585_2036.nc\n", + "Processing file: CIL_subset_ssp126_2036.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2036, month 1\n", "Processing year 2036, month 2\n", @@ -4470,7 +4467,7 @@ "Processing year 2036, month 10\n", "Processing year 2036, month 11\n", "Processing year 2036, month 12\n", - "Processing file: CIL_subset_ssp585_2037.nc\n", + "Processing file: CIL_subset_ssp126_2037.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2037, month 1\n", "Processing year 2037, month 2\n", @@ -4510,7 +4507,7 @@ "Processing year 2037, month 10\n", "Processing year 2037, month 11\n", "Processing year 2037, month 12\n", - "Processing file: CIL_subset_ssp585_2038.nc\n", + "Processing file: CIL_subset_ssp126_2038.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2038, month 1\n", "Processing year 2038, month 2\n", @@ -4550,7 +4547,7 @@ "Processing year 2038, month 10\n", "Processing year 2038, month 11\n", "Processing year 2038, month 12\n", - "Processing file: CIL_subset_ssp585_2039.nc\n", + "Processing file: CIL_subset_ssp126_2039.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2039, month 1\n", "Processing year 2039, month 2\n", @@ -4590,7 +4587,7 @@ "Processing year 2039, month 10\n", "Processing year 2039, month 11\n", "Processing year 2039, month 12\n", - "Processing file: CIL_subset_ssp585_2040.nc\n", + "Processing file: CIL_subset_ssp126_2040.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2040, month 1\n", "Processing year 2040, month 2\n", @@ -4630,7 +4627,7 @@ "Processing year 2040, month 10\n", "Processing year 2040, month 11\n", "Processing year 2040, month 12\n", - "Processing file: CIL_subset_ssp585_2041.nc\n", + "Processing file: CIL_subset_ssp126_2041.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2041, month 1\n", "Processing year 2041, month 2\n", @@ -4670,7 +4667,7 @@ "Processing year 2041, month 10\n", "Processing year 2041, month 11\n", "Processing year 2041, month 12\n", - "Processing file: CIL_subset_ssp585_2042.nc\n", + "Processing file: CIL_subset_ssp126_2042.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2042, month 1\n", "Processing year 2042, month 2\n", @@ -4710,7 +4707,7 @@ "Processing year 2042, month 10\n", "Processing year 2042, month 11\n", "Processing year 2042, month 12\n", - "Processing file: CIL_subset_ssp585_2043.nc\n", + "Processing file: CIL_subset_ssp126_2043.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2043, month 1\n", "Processing year 2043, month 2\n", @@ -4750,7 +4747,7 @@ "Processing year 2043, month 10\n", "Processing year 2043, month 11\n", "Processing year 2043, month 12\n", - "Processing file: CIL_subset_ssp585_2044.nc\n", + "Processing file: CIL_subset_ssp126_2044.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2044, month 1\n", "Processing year 2044, month 2\n", @@ -4790,7 +4787,7 @@ "Processing year 2044, month 10\n", "Processing year 2044, month 11\n", "Processing year 2044, month 12\n", - "Processing file: CIL_subset_ssp585_2045.nc\n", + "Processing file: CIL_subset_ssp126_2045.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2045, month 1\n", "Processing year 2045, month 2\n", @@ -4830,7 +4827,7 @@ "Processing year 2045, month 10\n", "Processing year 2045, month 11\n", "Processing year 2045, month 12\n", - "Processing file: CIL_subset_ssp585_2046.nc\n", + "Processing file: CIL_subset_ssp126_2046.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2046, month 1\n", "Processing year 2046, month 2\n", @@ -4870,7 +4867,7 @@ "Processing year 2046, month 10\n", "Processing year 2046, month 11\n", "Processing year 2046, month 12\n", - "Processing file: CIL_subset_ssp585_2047.nc\n", + "Processing file: CIL_subset_ssp126_2047.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2047, month 1\n", "Processing year 2047, month 2\n", @@ -4910,7 +4907,7 @@ "Processing year 2047, month 10\n", "Processing year 2047, month 11\n", "Processing year 2047, month 12\n", - "Processing file: CIL_subset_ssp585_2048.nc\n", + "Processing file: CIL_subset_ssp126_2048.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2048, month 1\n", "Processing year 2048, month 2\n", @@ -4950,7 +4947,7 @@ "Processing year 2048, month 10\n", "Processing year 2048, month 11\n", "Processing year 2048, month 12\n", - "Processing file: CIL_subset_ssp585_2049.nc\n", + "Processing file: CIL_subset_ssp126_2049.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2049, month 1\n", "Processing year 2049, month 2\n", @@ -4990,7 +4987,7 @@ "Processing year 2049, month 10\n", "Processing year 2049, month 11\n", "Processing year 2049, month 12\n", - "Processing file: CIL_subset_ssp585_2050.nc\n", + "Processing file: CIL_subset_ssp126_2050.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2050, month 1\n", "Processing year 2050, month 2\n", @@ -5030,7 +5027,7 @@ "Processing year 2050, month 10\n", "Processing year 2050, month 11\n", "Processing year 2050, month 12\n", - "Processing file: CIL_subset_ssp585_2051.nc\n", + "Processing file: CIL_subset_ssp126_2051.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2051, month 1\n", "Processing year 2051, month 2\n", @@ -5070,7 +5067,7 @@ "Processing year 2051, month 10\n", "Processing year 2051, month 11\n", "Processing year 2051, month 12\n", - "Processing file: CIL_subset_ssp585_2052.nc\n", + "Processing file: CIL_subset_ssp126_2052.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2052, month 1\n", "Processing year 2052, month 2\n", @@ -5110,7 +5107,7 @@ "Processing year 2052, month 10\n", "Processing year 2052, month 11\n", "Processing year 2052, month 12\n", - "Processing file: CIL_subset_ssp585_2053.nc\n", + "Processing file: CIL_subset_ssp126_2053.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2053, month 1\n", "Processing year 2053, month 2\n", @@ -5150,7 +5147,7 @@ "Processing year 2053, month 10\n", "Processing year 2053, month 11\n", "Processing year 2053, month 12\n", - "Processing file: CIL_subset_ssp585_2054.nc\n", + "Processing file: CIL_subset_ssp126_2054.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2054, month 1\n", "Processing year 2054, month 2\n", @@ -5190,7 +5187,7 @@ "Processing year 2054, month 10\n", "Processing year 2054, month 11\n", "Processing year 2054, month 12\n", - "Processing file: CIL_subset_ssp585_2055.nc\n", + "Processing file: CIL_subset_ssp126_2055.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2055, month 1\n", "Processing year 2055, month 2\n", @@ -5230,7 +5227,7 @@ "Processing year 2055, month 10\n", "Processing year 2055, month 11\n", "Processing year 2055, month 12\n", - "Processing file: CIL_subset_ssp585_2056.nc\n", + "Processing file: CIL_subset_ssp126_2056.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2056, month 1\n", "Processing year 2056, month 2\n", @@ -5270,7 +5267,7 @@ "Processing year 2056, month 10\n", "Processing year 2056, month 11\n", "Processing year 2056, month 12\n", - "Processing file: CIL_subset_ssp585_2057.nc\n", + "Processing file: CIL_subset_ssp126_2057.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2057, month 1\n", "Processing year 2057, month 2\n", @@ -5310,7 +5307,7 @@ "Processing year 2057, month 10\n", "Processing year 2057, month 11\n", "Processing year 2057, month 12\n", - "Processing file: CIL_subset_ssp585_2058.nc\n", + "Processing file: CIL_subset_ssp126_2058.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2058, month 1\n", "Processing year 2058, month 2\n", @@ -5350,7 +5347,7 @@ "Processing year 2058, month 10\n", "Processing year 2058, month 11\n", "Processing year 2058, month 12\n", - "Processing file: CIL_subset_ssp585_2059.nc\n", + "Processing file: CIL_subset_ssp126_2059.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2059, month 1\n", "Processing year 2059, month 2\n", @@ -5390,7 +5387,7 @@ "Processing year 2059, month 10\n", "Processing year 2059, month 11\n", "Processing year 2059, month 12\n", - "Processing file: CIL_subset_ssp585_2060.nc\n", + "Processing file: CIL_subset_ssp126_2060.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2060, month 1\n", "Processing year 2060, month 2\n", @@ -5430,7 +5427,7 @@ "Processing year 2060, month 10\n", "Processing year 2060, month 11\n", "Processing year 2060, month 12\n", - "Processing file: CIL_subset_ssp585_2061.nc\n", + "Processing file: CIL_subset_ssp126_2061.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2061, month 1\n", "Processing year 2061, month 2\n", @@ -5470,7 +5467,7 @@ "Processing year 2061, month 10\n", "Processing year 2061, month 11\n", "Processing year 2061, month 12\n", - "Processing file: CIL_subset_ssp585_2062.nc\n", + "Processing file: CIL_subset_ssp126_2062.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2062, month 1\n", "Processing year 2062, month 2\n", @@ -5510,7 +5507,7 @@ "Processing year 2062, month 10\n", "Processing year 2062, month 11\n", "Processing year 2062, month 12\n", - "Processing file: CIL_subset_ssp585_2063.nc\n", + "Processing file: CIL_subset_ssp126_2063.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2063, month 1\n", "Processing year 2063, month 2\n", @@ -5550,7 +5547,7 @@ "Processing year 2063, month 10\n", "Processing year 2063, month 11\n", "Processing year 2063, month 12\n", - "Processing file: CIL_subset_ssp585_2064.nc\n", + "Processing file: CIL_subset_ssp126_2064.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2064, month 1\n", "Processing year 2064, month 2\n", @@ -5590,7 +5587,7 @@ "Processing year 2064, month 10\n", "Processing year 2064, month 11\n", "Processing year 2064, month 12\n", - "Processing file: CIL_subset_ssp585_2065.nc\n", + "Processing file: CIL_subset_ssp126_2065.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2065, month 1\n", "Processing year 2065, month 2\n", @@ -5630,7 +5627,7 @@ "Processing year 2065, month 10\n", "Processing year 2065, month 11\n", "Processing year 2065, month 12\n", - "Processing file: CIL_subset_ssp585_2066.nc\n", + "Processing file: CIL_subset_ssp126_2066.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2066, month 1\n", "Processing year 2066, month 2\n", @@ -5670,7 +5667,7 @@ "Processing year 2066, month 10\n", "Processing year 2066, month 11\n", "Processing year 2066, month 12\n", - "Processing file: CIL_subset_ssp585_2067.nc\n", + "Processing file: CIL_subset_ssp126_2067.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2067, month 1\n", "Processing year 2067, month 2\n", @@ -5710,7 +5707,7 @@ "Processing year 2067, month 10\n", "Processing year 2067, month 11\n", "Processing year 2067, month 12\n", - "Processing file: CIL_subset_ssp585_2068.nc\n", + "Processing file: CIL_subset_ssp126_2068.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2068, month 1\n", "Processing year 2068, month 2\n", @@ -5750,7 +5747,7 @@ "Processing year 2068, month 10\n", "Processing year 2068, month 11\n", "Processing year 2068, month 12\n", - "Processing file: CIL_subset_ssp585_2069.nc\n", + "Processing file: CIL_subset_ssp126_2069.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2069, month 1\n", "Processing year 2069, month 2\n", @@ -5790,7 +5787,7 @@ "Processing year 2069, month 10\n", "Processing year 2069, month 11\n", "Processing year 2069, month 12\n", - "Processing file: CIL_subset_ssp585_2070.nc\n", + "Processing file: CIL_subset_ssp126_2070.nc\n", "Processing model: HadGEM3-GC31-LL\n", "Processing year 2070, month 1\n", "Processing year 2070, month 2\n", @@ -5830,16 +5827,16 @@ "Processing year 2070, month 10\n", "Processing year 2070, month 11\n", "Processing year 2070, month 12\n", - "Saved monthly data for lowest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/lowest_monthly_prediction_weather_by_facility.csv\n", - "Saved window data for lowest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/lowest_window_prediction_weather_by_facility.csv\n", - "Saved monthly data for mean model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/mean_monthly_prediction_weather_by_facility.csv\n", - "Saved window data for mean model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/mean_window_prediction_weather_by_facility.csv\n", - "Saved monthly data for highest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/highest_monthly_prediction_weather_by_facility.csv\n", - "Saved window data for highest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/highest_window_prediction_weather_by_facility.csv\n" + "Saved monthly data for lowest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp126/lowest_monthly_prediction_weather_by_facility.csv\n", + "Saved window data for lowest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp126/lowest_window_prediction_weather_by_facility.csv\n", + "Saved monthly data for mean model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp126/mean_monthly_prediction_weather_by_facility.csv\n", + "Saved window data for mean model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp126/mean_window_prediction_weather_by_facility.csv\n", + "Saved monthly data for highest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp126/highest_monthly_prediction_weather_by_facility.csv\n", + "Saved window data for highest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp126/highest_window_prediction_weather_by_facility.csv\n" ] } ], - "execution_count": 13 + "execution_count": 14 }, { "metadata": {}, From e25ea801e0a8b942bb09444dff49b8299df1f332 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 16 Jan 2025 09:03:20 +0000 Subject: [PATCH 203/291] Changed median to mean --- ..._model_historical_realtionship_reporting_precipitation.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index f189359117..44dbe3d2bf 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -570,7 +570,7 @@ def get_weather_data(ssp_scenario, model_type): columns=zero_sum_columns) return weather_data_prediction_five_day_cumulative_df, weather_data_prediction_monthly_df -model_types = ['lowest', 'median', 'highest'] +model_types = ['lowest', 'mean', 'highest'] # Configuration and constants min_year_for_analysis = 2025 absolute_min_year = 2024 @@ -578,7 +578,7 @@ def get_weather_data(ssp_scenario, model_type): data_path = "/Users/rem76/Desktop/Climate_change_health/Data/" # Define SSP scenario -ssp_scenarios = ["ssp245", "ssp585"] +ssp_scenarios = ["ssp126","ssp245", "ssp585"] # Load and preprocess weather data for ssp_scenario in ssp_scenarios: @@ -586,7 +586,6 @@ def get_weather_data(ssp_scenario, model_type): print(ssp_scenario, model_type) weather_data_prediction_five_day_cumulative_df, weather_data_prediction_monthly_df = get_weather_data(ssp_scenario, model_type) - lag_1_month_prediction = weather_data_prediction_monthly_df.shift(1).values lag_2_month_prediction = weather_data_prediction_monthly_df.shift(2).values lag_3_month_prediction = weather_data_prediction_monthly_df.shift(3).values From 1605f46ee1a47e58b21f28ad2c393f6658799fa3 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 16 Jan 2025 10:13:07 +0000 Subject: [PATCH 204/291] Ensured that the cumulative numbers were also pregnancies. --- src/scripts/climate_change/cohort_model.py | 86 +++++++++++----------- 1 file changed, 44 insertions(+), 42 deletions(-) diff --git a/src/scripts/climate_change/cohort_model.py b/src/scripts/climate_change/cohort_model.py index c8cf743778..178f9b04a0 100644 --- a/src/scripts/climate_change/cohort_model.py +++ b/src/scripts/climate_change/cohort_model.py @@ -19,8 +19,8 @@ min_year = 2025 max_year = 2061 -scenarios = ['ssp245', 'ssp585'] -model_types = ['lowest', 'median', 'highest'] +scenarios = ['ssp126', 'ssp245', 'ssp585'] +model_types = ['lowest', 'mean', 'highest'] year_range = range(min_year, max_year) ## Get birth results results_folder_to_save = Path('/Users/rem76/Desktop/Climate_change_health/Results/ANC_disruptions') @@ -54,11 +54,12 @@ malawi = gpd.read_file("/Users/rem76/PycharmProjects/TLOmodel/resources/mapping/ResourceFile_mwi_admbnda_adm0_nso_20181016.shp") malawi_admin2 = gpd.read_file("/Users/rem76/PycharmProjects/TLOmodel/resources/mapping/ResourceFile_mwi_admbnda_adm2_nso_20181016.shp") - +# # change names of some districts for consistency malawi_admin2['ADM2_EN'] = malawi_admin2['ADM2_EN'].replace('Blantyre City', 'Blantyre') malawi_admin2['ADM2_EN'] = malawi_admin2['ADM2_EN'].replace('Mzuzu City', 'Mzuzu') malawi_admin2['ADM2_EN'] = malawi_admin2['ADM2_EN'].replace('Lilongwe City', 'Lilongwe') +malawi_admin2['ADM2_EN'] = malawi_admin2['ADM2_EN'].replace('Zomba City', 'Zomba') difference_lat = lat_data[1] - lat_data[0] difference_long = long_data[1] - long_data[0] @@ -80,7 +81,7 @@ # Match birth results and predictions matching_rows = min(len(births_model_subset), len(predictions_from_cmip_sum)) multiplied_values = births_model_subset.head(matching_rows).iloc[:, 1].values * predictions_from_cmip_sum[ - 'Percentage_Difference'].head(matching_rows).values + 'Percentage_Difference'].head(matching_rows).values * 1.4 # 1.4 is conversion from births to pregnacnies births_model_subset['Multiplied_Values'] = multiplied_values # Plot the results @@ -98,23 +99,23 @@ "Scenario": [scenario], "Model_Type": [model_type], "Negative_Sum": [negative_sum], - "Negative_Percentage": [negative_sum / births_model_subset['Model_mean'].sum() * 100] + "Negative_Percentage": [negative_sum / (births_model_subset['Model_mean'].sum() * 1.4) * 100] }) results_list.append(result_df) # Plot by zone predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'Zone']).sum().reset_index() - plt.figure(figsize=(10, 6)) - for zone in predictions_from_cmip_sum['Zone'].unique(): - zone_data = predictions_from_cmip_sum[predictions_from_cmip_sum['Zone'] == zone] - zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data[ - 'Predicted_No_Weather_Model']) * 100 - plt.plot(zone_data['Year'], zone_data['Percentage_Difference'], label=f'Zone {zone}') - plt.xlabel("Year") - plt.ylabel("Change ANC cases due to weather") - plt.axhline(y=0, color='black', linestyle='--') - plt.ylim(-1.5, 0) - plt.legend(title='Zones') + # plt.figure(figsize=(10, 6)) + # for zone in predictions_from_cmip_sum['Zone'].unique(): + # zone_data = predictions_from_cmip_sum[predictions_from_cmip_sum['Zone'] == zone] + # zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data[ + # 'Predicted_No_Weather_Model']) * 100 + # plt.plot(zone_data['Year'], zone_data['Percentage_Difference'], label=f'Zone {zone}') + # plt.xlabel("Year") + # plt.ylabel("Change ANC cases due to weather") + # plt.axhline(y=0, color='black', linestyle='--') + # plt.ylim(-1.5, 0) + # plt.legend(title='Zones') # Plot by district predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'District']).sum().reset_index() @@ -123,12 +124,12 @@ district_data = predictions_from_cmip_sum[predictions_from_cmip_sum['District'] == district] district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data[ 'Predicted_No_Weather_Model']) * 100 - plt.plot(district_data['Year'], district_data['Percentage_Difference'], label=f'{district}') - plt.xlabel("Year") - plt.ylabel("Change ANC cases due to weather") - plt.axhline(y=0, color='black', linestyle='--') - plt.ylim(-2.5, 0) - plt.legend(title='Districts') + # plt.plot(district_data['Year'], district_data['Percentage_Difference'], label=f'{district}') + # plt.xlabel("Year") + # plt.ylabel("Change ANC cases due to weather") + # plt.axhline(y=0, color='black', linestyle='--') + # plt.ylim(-2.5, 0) + # plt.legend(title='Districts') # Generate district map visualization predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( @@ -161,14 +162,14 @@ sm = plt.cm.ScalarMappable(cmap='Blues_r', norm=mcolors.Normalize(vmin=malawi_admin2['Percentage_Difference'].min(), vmax=malawi_admin2['Percentage_Difference'].max())) - sm.set_array([]) - cbar = plt.colorbar(sm, ax=ax, orientation="vertical", shrink=0.7) - cbar.set_label("Percentage Difference (%)", fontsize=12) - plt.xlabel("Longitude", fontsize=14) - plt.ylabel("Latitude", fontsize=14) - plt.title(f"{scenario}: {model_type}", fontsize=16) - plt.tight_layout() - plt.savefig(results_folder_to_save / f'{scenario}_{model_type}_map_Malawi_cumulative_difference.png') + # sm.set_array([]) + # cbar = plt.colorbar(sm, ax=ax, orientation="vertical", shrink=0.7) + # cbar.set_label("Percentage Difference (%)", fontsize=12) + # plt.xlabel("Longitude", fontsize=14) + # plt.ylabel("Latitude", fontsize=14) + # plt.title(f"{scenario}: {model_type}", fontsize=16) + # plt.tight_layout() + # plt.savefig(results_folder_to_save / f'{scenario}_{model_type}_map_Malawi_cumulative_difference.png') # Save multiplied values by model and scenario multiplied_values_df = pd.DataFrame({ 'Year': year_range[:matching_rows], @@ -197,7 +198,7 @@ ## now all grids -fig, axes = plt.subplots(2, 3, figsize=(18, 12), constrained_layout=True) +fig, axes = plt.subplots(3, 3, figsize=(18, 18),) global_min = float('inf') global_max = float('-inf') @@ -238,7 +239,6 @@ {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} ) percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() - print(percentage_diff_by_district) malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 @@ -273,7 +273,7 @@ sm.set_array([]) fig.colorbar(sm, ax=axes, orientation="vertical", shrink=0.8, label="Percentage Difference (%)") plt.suptitle("Percentage Difference Maps by Scenario and Model Type", fontsize=16, y=1.02) -# plt.savefig(results_folder_to_save / 'percentage_difference_maps_grid.png') +plt.savefig(results_folder_to_save / 'percentage_difference_maps_grid.png') plt.show() @@ -312,10 +312,11 @@ population_proportion = population_data_grouped / total_population # Create the figure and axes grid -fig, axes = plt.subplots(2, 3, figsize=(18, 12), constrained_layout=True) -print(births_model_subset) +fig, axes = plt.subplots(3, 3, figsize=(18, 18)) y_min = float('inf') y_max = float('-inf') +x_min = float('inf') +x_max = float('-inf') year_groupings = range(2025, 2060, 5) for i, scenario in enumerate(scenarios): for j, model_type in enumerate(model_types): @@ -346,11 +347,9 @@ for _, row in subset.iterrows(): district = row['District'] percentage_diff = row['Percentage_Difference'] - #print(percentage_diff) row_index = births_model_subset.index.get_loc(year) number_of_births = population_proportion[district] * births_model_subset.iloc[row_index]["Model_mean"] - #print(percentage_diff * number_of_births) if year not in percentage_diff_by_year_district: percentage_diff_by_year_district[year] = {} if district not in percentage_diff_by_year_district[year]: @@ -360,20 +359,23 @@ data_for_plot = pd.DataFrame.from_dict(percentage_diff_by_year_district, orient='index').fillna(0) y_min = min(y_min, data_for_plot.min().min()) y_max = max(y_max, data_for_plot.max().max()) + x_min = min(x_min, data_for_plot.index.min()) + x_max = max(x_max, data_for_plot.index.max()) ax = axes[i, j] data_for_plot.plot(kind='bar', stacked=True, ax=ax, cmap='tab20', legend=False) ax.set_title(f"{scenario}: {model_type}", fontsize=10) if i == len(scenarios) - 1: - ax.set_xlabel('Period (5 years)', fontsize=10) + ax.set_xlabel('Year', fontsize=12) if j == 0: - ax.set_ylabel('Deficit of ANC services', fontsize=10) + ax.set_ylabel('Deficit of ANC services', fontsize=12) if (i == 0) & (j == 2): - ax.legend(title="Districts", fontsize=8, title_fontsize=10, bbox_to_anchor=(1.09, 1)) + ax.legend(title="Districts", fontsize=10, title_fontsize=10, bbox_to_anchor=(1., 1)) for ax in axes.flatten(): - ax.set_ylim(y_min*7, y_max) - + ax.set_ylim(y_min*9, y_max) +handles, labels = ax.get_legend_handles_labels() +fig.legend(handles, labels, bbox_to_anchor=(1, -10), loc = "center right", fontsize=10, title="Districts") plt.tight_layout() plt.savefig(results_folder_to_save / 'stacked_bar_percentage_difference_5_years_grid_single_legend_with_births.png') plt.show() From c580b598c181d3e6c2be1abcb244b5eda2259b27 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 16 Jan 2025 12:53:24 +0000 Subject: [PATCH 205/291] tidied --- src/scripts/climate_change/grid_malawi_CMIP6.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/scripts/climate_change/grid_malawi_CMIP6.py b/src/scripts/climate_change/grid_malawi_CMIP6.py index 29988e9f01..b545c6dccf 100644 --- a/src/scripts/climate_change/grid_malawi_CMIP6.py +++ b/src/scripts/climate_change/grid_malawi_CMIP6.py @@ -66,7 +66,7 @@ ### SSP25 model grid base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/" -scenarios = ["ssp2_4_5"] +scenarios = ["ssp126", "ssp245", "ssp585"] file_list = glob.glob(os.path.join(base_dir, "*.nc")) colors = cm.get_cmap("tab20", 20) @@ -134,7 +134,7 @@ sm = plt.cm.ScalarMappable(cmap=cmap_facilities, norm=norm) sm.set_array([]) cbar = plt.colorbar(sm, ax=ax, orientation='vertical', fraction=0.03, pad=0.04) -cbar.set_label('Average Precipitation') +cbar.set_label('Mean Monthly Precipitation (mm)') plt.xlabel("Longitude") plt.ylabel("Latitude") From e4ff7623b92ee64fd0dd3e37cb30619a8bdaf531 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 16 Jan 2025 12:54:22 +0000 Subject: [PATCH 206/291] Added map of historical weather --- .../plot_raw_reanalysis_data.py | 178 ++++++++++-------- 1 file changed, 100 insertions(+), 78 deletions(-) diff --git a/src/scripts/climate_change/plot_raw_reanalysis_data.py b/src/scripts/climate_change/plot_raw_reanalysis_data.py index 82657979bd..fdf7cd2cfd 100644 --- a/src/scripts/climate_change/plot_raw_reanalysis_data.py +++ b/src/scripts/climate_change/plot_raw_reanalysis_data.py @@ -1,87 +1,109 @@ +import glob +import os +import re + import geopandas as gpd +import matplotlib.cm as cm import matplotlib.pyplot as plt import numpy as np import pandas as pd +from matplotlib import colors as mcolors from netCDF4 import Dataset +from shapely.geometry import Polygon # Load the dataset and the variable -file_path = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/monthly_data/724bab97773bb7ba4e1635356ad0d12.nc" -dataset = Dataset(file_path, mode='r') -pr_data = dataset.variables['tp'][:] -time_data = dataset.variables['date'][:] -lat_data = dataset.variables['latitude'][:] -long_data = dataset.variables['longitude'][:] - -## Initial plot -for i in range(len(lat_data)): - for j in range(len(long_data)): - pr_data_time_series_grid_1 = pr_data[:, i, j] - pr_data_time_series_grid_1 *= 1000 # to get to days - plt.plot(pr_data_time_series_grid_1) - -plt.title('Average Precipitation Over Time - Grid ') -plt.ylabel('Precip (mm)') -plt.xlabel('Time') -plt.show() +file_path_historical_data = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/2011/60ab007aa16d679a32f9c3e186d2f744.nc" +dataset = Dataset(file_path_historical_data, mode='r') +print(dataset.variables.keys()) +pr_data = dataset.variables['tp'][:] # ['pr'][:] pr for projections, tp for historical +lat_data = dataset.variables['latitude'][:] # ['lat'][:] +long_data = dataset.variables['longitude'][:] # ['lon'][:] +meshgrid_from_netCDF = np.meshgrid(long_data, lat_data) + +# Load Malawi shapefile +malawi = gpd.read_file( + "/Users/rem76/PycharmProjects/TLOmodel/resources/mapping/ResourceFile_mwi_admbnda_adm0_nso_20181016.shp") +malawi_admin1 = gpd.read_file( + "/Users/rem76/PycharmProjects/TLOmodel/resources/mapping/ResourceFile_mwi_admbnda_adm1_nso_20181016.shp") +malawi_admin2 = gpd.read_file( + "/Users/rem76/PycharmProjects/TLOmodel/resources/mapping/ResourceFile_mwi_admbnda_adm2_nso_20181016.shp") + +difference_lat = lat_data[1] - lat_data[0] # as is a grid, the difference is the same for all sequential coordinates +difference_long = long_data[1] - long_data[0] + +polygons = [] +for x in long_data: + for y in lat_data: + bottom_left = (x, y) + bottom_right = (x + difference_long, y) + top_right = (x + difference_long, y + difference_lat) + top_left = (x, y + difference_lat) + polygon = Polygon([bottom_left, bottom_right, top_right, top_left]) + polygons.append(polygon) + +grid = gpd.GeoDataFrame({'geometry': polygons}, crs=malawi.crs) +grid_clipped = gpd.overlay(grid, malawi, how='intersection') # for graphing +grid_clipped_ADM1 = gpd.overlay(grid, malawi_admin1, how='intersection') # for graphing +grid_clipped_ADM2 = gpd.overlay(grid, malawi_admin2, how='intersection') # for graphing + +# Setup color map for plotting grid lines +colors = cm.get_cmap("tab20", 20) + +# Corrected part for processing model files +nc_file_directory = "/path/to/your/nc_files" # Define this correctly +fig, ax = plt.subplots(figsize=(10, 10)) # Ensure you create the axis before plotting +for idx, file in enumerate(glob.glob(os.path.join(nc_file_directory, "*.nc"))): + data_per_model = Dataset(file, mode='r') + pr_data_model = data_per_model.variables['pr'][:] # in kg m-2 s-1 = mm s-1 x 86400 to get to day + lat_data_model = data_per_model.variables['lat'][:] + long_data_model = data_per_model.variables['lon'][:] + + # Plot grid lines for this model file + for lon in long_data_model: + ax.axvline(x=lon, color=colors(idx), linestyle='--', linewidth=0.5) + for lat in lat_data_model: + ax.axhline(y=lat, color=colors(idx), linestyle='--', linewidth=0.5) +# Add in facility information +expanded_facility_info = pd.read_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_with_ANC.csv", + index_col=0 +) -weather_data_historical = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facility_lm.csv", index_col=0) - -for i in range(len(weather_data_historical.columns)): - plt.plot(weather_data_historical.iloc[:, i], label = weather_data_historical.columns[i]) - -plt.title('Average Precipitation Over Time - Facility ') -plt.ylabel('Precip (mm)') -plt.xlabel('Time') -plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) -#plt.show() - -# -# -# monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm.csv", index_col=0) -# -# for i in range(len(monthly_reporting_by_facility.columns)): -# plt.plot(monthly_reporting_by_facility.iloc[:, i], label = monthly_reporting_by_facility.columns[i]) -# -# plt.title('Average Reprting Over Time - Facility ') -# plt.ylabel('Reporting (%)') -# plt.xlabel('Time') -# plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) -# #plt.show() -# -# -# for i in range(len(monthly_reporting_by_facility.columns)): -# for j in range(len(monthly_reporting_by_facility.iloc[:, i])): -# if weather_data_historical.iloc[j, i] > 1000: -# plt.scatter(weather_data_historical.iloc[j, i], monthly_reporting_by_facility.iloc[j, i]) -# -# plt.title('Average Reprting Over Time - Facility ') -# plt.ylabel('Reporting(%)') -# plt.xlabel('Precip (mm)') -# plt.xlim(1000,4000) -# plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.) -# #plt.show() - - -# -# ########### Plot daily maximum data - why is it so high? ########## -# -# file_path = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_maximum/2011/d7caf4e3506d13b9726aa4f77589c384.nc" -# dataset = Dataset(file_path, mode='r') -# pr_data = dataset.variables['tp'][:] # m per day, so multiply by 1000 to get mm per day -# time_data = dataset.variables['valid_time'][:] -# lat_data = dataset.variables['latitude'][:] -# long_data = dataset.variables['longitude'][:] -# -# ## Initial plot -# for i in range(len(lat_data)): -# for j in range(len(long_data)): -# pr_data_time_series_grid = pr_data[:, i, j] -# pr_data_time_series_grid *= 1000 # to get to mm -# plt.plot(pr_data_time_series_grid) -# -# plt.title('Daily Maximum Precipitation Over Time - Grid ') -# plt.ylabel('Precip (mm)') -# plt.xlabel('Time') -# plt.show() -# +long_format = expanded_facility_info.T.reset_index() +long_format.columns = [ + 'Facility', 'Zonename', 'Resid', 'Dist', 'A105', 'A109__Altitude', 'Ftype', + 'A109__Latitude', 'A109__Longitude', 'minimum_distance', 'average_precipitation' +] + +long_format = long_format.dropna(subset=['A109__Latitude']) + +facilities_gdf = gpd.GeoDataFrame( + long_format, + geometry=gpd.points_from_xy(long_format['A109__Longitude'], long_format['A109__Latitude']), + crs="EPSG:4326" +) + +facilities_gdf['average_precipitation'] = pd.to_numeric(facilities_gdf['average_precipitation'], errors='coerce') + +norm = mcolors.Normalize(vmin=facilities_gdf['average_precipitation'].min(), + vmax=facilities_gdf['average_precipitation'].max()) +cmap_facilities = plt.cm.YlOrBr +facilities_gdf['color'] = facilities_gdf['average_precipitation'].apply(lambda x: cmap_facilities(norm(x))) + +# Plotting facilities on the map +malawi_admin2.plot(ax=ax, edgecolor='black', color='white') +grid_clipped_ADM2.plot(ax=ax, edgecolor='#1C6E8C', alpha=0.4) +grid_clipped_ADM1.plot(column='ADM1_EN', ax=ax, cmap=colors, edgecolor='#1C6E8C', alpha=0.7) + +facilities_gdf.plot(ax=ax, color=facilities_gdf['color'], markersize=10) + +sm = plt.cm.ScalarMappable(cmap=cmap_facilities, norm=norm) +sm.set_array([]) +cbar = plt.colorbar(sm, ax=ax, orientation='vertical', fraction=0.03, pad=0.04) +cbar.set_label('Mean Monthly Precipitation (mm)') +plt.xlabel("Longitude") +plt.ylabel("Latitude") +plt.savefig('/Users/rem76/Desktop/Climate_change_health/Results/ANC_disruptions/historical_weather.png') + +plt.show() From a582531ee18788166fb1dc1432dee1f949534572 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 17 Jan 2025 09:29:23 +0000 Subject: [PATCH 207/291] Updated to aggregate over all years, and ensure that only the negative differences are being used. (Effect was diminished by fact that +ve values were included.) --- src/scripts/climate_change/cohort_model.py | 413 +++++++++++---------- 1 file changed, 221 insertions(+), 192 deletions(-) diff --git a/src/scripts/climate_change/cohort_model.py b/src/scripts/climate_change/cohort_model.py index 178f9b04a0..27054309ae 100644 --- a/src/scripts/climate_change/cohort_model.py +++ b/src/scripts/climate_change/cohort_model.py @@ -74,7 +74,10 @@ predictions_from_cmip = pd.read_csv( f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' ) + predictions_from_cmip = predictions_from_cmip.loc[predictions_from_cmip['Difference_in_Expectation'] < 0] predictions_from_cmip_sum = predictions_from_cmip.groupby('Year').sum().reset_index() + predictions_from_cmip_sum = predictions_from_cmip_sum[predictions_from_cmip_sum['Year'] <= 2061] + predictions_from_cmip_sum['Percentage_Difference'] = ( predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum[ 'Predicted_No_Weather_Model']) @@ -83,17 +86,13 @@ multiplied_values = births_model_subset.head(matching_rows).iloc[:, 1].values * predictions_from_cmip_sum[ 'Percentage_Difference'].head(matching_rows).values * 1.4 # 1.4 is conversion from births to pregnacnies births_model_subset['Multiplied_Values'] = multiplied_values - - # Plot the results - plt.plot(year_range, multiplied_values) - plt.ylabel("Change ANC cases due to weather") - plt.axhline(y=0, color='black', linestyle='--') - plt.plot(year_range, predictions_from_cmip_sum.iloc[0:36, -1] * 100) - plt.xlabel("Percentage Change in ANC cases due to weather") - plt.axhline(y=0, color='black', linestyle='--') - plt.ylim(-12000,0) # Check for negative values (missed cases?) negative_sum = np.sum(multiplied_values[multiplied_values < 0]) + #print(negative_sum) + total_negative_difference = predictions_from_cmip.loc[predictions_from_cmip['Difference_in_Expectation'] < 0, 'Difference_in_Expectation'].sum() + total_percentage_negative_difference = total_negative_difference/ predictions_from_cmip['Predicted_No_Weather_Model'].sum() + total_expected_difference = total_percentage_negative_difference * (births_model_subset['Model_mean'].sum() * 1.4) + #print(total_expected_difference) result_df = pd.DataFrame({ "Scenario": [scenario], @@ -103,73 +102,15 @@ }) results_list.append(result_df) - # Plot by zone - predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'Zone']).sum().reset_index() - # plt.figure(figsize=(10, 6)) - # for zone in predictions_from_cmip_sum['Zone'].unique(): - # zone_data = predictions_from_cmip_sum[predictions_from_cmip_sum['Zone'] == zone] - # zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data[ - # 'Predicted_No_Weather_Model']) * 100 - # plt.plot(zone_data['Year'], zone_data['Percentage_Difference'], label=f'Zone {zone}') - # plt.xlabel("Year") - # plt.ylabel("Change ANC cases due to weather") - # plt.axhline(y=0, color='black', linestyle='--') - # plt.ylim(-1.5, 0) - # plt.legend(title='Zones') - - # Plot by district - predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'District']).sum().reset_index() - plt.figure(figsize=(10, 6)) - for district in predictions_from_cmip_sum['District'].unique(): - district_data = predictions_from_cmip_sum[predictions_from_cmip_sum['District'] == district] - district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data[ - 'Predicted_No_Weather_Model']) * 100 - # plt.plot(district_data['Year'], district_data['Percentage_Difference'], label=f'{district}') - # plt.xlabel("Year") - # plt.ylabel("Change ANC cases due to weather") - # plt.axhline(y=0, color='black', linestyle='--') - # plt.ylim(-2.5, 0) - # plt.legend(title='Districts') - # Generate district map visualization predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"}) - polygons = [ - Polygon( - [(x, y), (x + difference_long, y), (x + difference_long, y + difference_lat), (x, y + difference_lat)]) - for x in long_data for y in lat_data - ] - grid = gpd.GeoDataFrame({'geometry': polygons}, crs=malawi.crs) - grid_clipped_ADM2 = gpd.overlay(grid, malawi_admin2, how='intersection') + predictions_from_cmip_sum['Percentage_Difference'] = (predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum[ 'Predicted_No_Weather_Model']) * 100 percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() - malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) - malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 - - # Plot map - fig, ax = plt.subplots(figsize=(12, 12)) - #malawi_admin2.plot(ax=ax, edgecolor='white', color='white') - malawi_admin2.dropna(subset=['Percentage_Difference']).plot( - ax=ax, - column='Percentage_Difference', - cmap='Blues_r', - edgecolor='black', - alpha=1, - legend=False - ) - sm = plt.cm.ScalarMappable(cmap='Blues_r', - norm=mcolors.Normalize(vmin=malawi_admin2['Percentage_Difference'].min(), - vmax=malawi_admin2['Percentage_Difference'].max())) - # sm.set_array([]) - # cbar = plt.colorbar(sm, ax=ax, orientation="vertical", shrink=0.7) - # cbar.set_label("Percentage Difference (%)", fontsize=12) - # plt.xlabel("Longitude", fontsize=14) - # plt.ylabel("Latitude", fontsize=14) - # plt.title(f"{scenario}: {model_type}", fontsize=16) - # plt.tight_layout() - # plt.savefig(results_folder_to_save / f'{scenario}_{model_type}_map_Malawi_cumulative_difference.png') + # Save multiplied values by model and scenario multiplied_values_df = pd.DataFrame({ 'Year': year_range[:matching_rows], @@ -182,128 +123,116 @@ final_results = pd.concat(results_list, ignore_index=True) final_results.to_csv('/Users/rem76/Desktop/Climate_change_health/Results/ANC_disruptions/negative_sums_and_percentages.csv', index=False) -# Get unique districts from both sources -adm2_districts = set(grid_clipped_ADM2['ADM2_EN'].unique()) -prediction_districts = set(predictions_from_cmip_sum['District'].unique()) - -# Districts in ADM2 but not in predictions -missing_in_predictions = adm2_districts - prediction_districts -print("Districts in ADM2 but not in predictions:", missing_in_predictions) - -# Districts in predictions but not in ADM2 -missing_in_adm2 = prediction_districts - adm2_districts -print("Districts in predictions but not in ADM2:", missing_in_adm2) - - - - -## now all grids -fig, axes = plt.subplots(3, 3, figsize=(18, 18),) - -global_min = float('inf') -global_max = float('-inf') - -for scenario in scenarios: - for model_type in model_types: - predictions_from_cmip = pd.read_csv( - f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' - ) - predictions_from_cmip_sum = predictions_from_cmip.groupby('District').sum().reset_index() - predictions_from_cmip_sum['Percentage_Difference'] = ( - predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model'] - ) * 100 - - predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( - {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} - ) - percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() - malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) - malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 - - local_min = malawi_admin2['Percentage_Difference'].min() - local_max = malawi_admin2['Percentage_Difference'].max() - global_min = min(global_min, local_min) - global_max = max(global_max, local_max) - -for i, scenario in enumerate(scenarios): - for j, model_type in enumerate(model_types): - predictions_from_cmip = pd.read_csv( - f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' - ) - predictions_from_cmip_sum = predictions_from_cmip.groupby('District').sum().reset_index() - predictions_from_cmip_sum['Percentage_Difference'] = ( - predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model'] - ) * 100 - - predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( - {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} - ) - percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() - malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) - malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 - - ax = axes[i, j] - malawi_admin2.dropna(subset=['Percentage_Difference']).plot( - ax=ax, - column='Percentage_Difference', - cmap='Blues_r', - edgecolor='black', - alpha=1, - legend=False, - vmin=global_min, - vmax=global_max - ) - - ax.set_title(f"{scenario}: {model_type}", fontsize=14) - - if i != 1: - ax.set_xlabel("") - if j != 0: - ax.set_ylabel("") - else: - ax.set_ylabel("Latitude", fontsize=10) - - if i == 1: - ax.set_xlabel("Longitude", fontsize=10) - -sm = plt.cm.ScalarMappable( - cmap='Blues_r', - norm=mcolors.Normalize(vmin=global_min, vmax=global_max) -) -sm.set_array([]) -fig.colorbar(sm, ax=axes, orientation="vertical", shrink=0.8, label="Percentage Difference (%)") -plt.suptitle("Percentage Difference Maps by Scenario and Model Type", fontsize=16, y=1.02) -plt.savefig(results_folder_to_save / 'percentage_difference_maps_grid.png') -plt.show() - - -significant_results_year = [] # -# Assuming 'district' is a column in your data -for scenario in scenarios: - for model_type in model_types: - predictions_from_cmip = pd.read_csv( - f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' - ) - predictions_from_cmip_sum = predictions_from_cmip.groupby(['District', 'Year']).sum().reset_index() - for district in predictions_from_cmip_sum['District'].unique(): - district_values = predictions_from_cmip_sum[predictions_from_cmip_sum['District'] == district] - no_weather_model = district_values['Predicted_No_Weather_Model'].values - weather_model = district_values['Predicted_Weather_Model'].values - - # Calculate the difference - difference = no_weather_model - weather_model - - # Perform a one-sample t-test assuming 0 as the null hypothesis mean - t_stat, p_value = ttest_1samp(difference, popmean=0) - # Print results if p-value is below 0.05 (statistically significant) - if p_value < 0.05: - print(f"Scenario: {scenario}, Model Type: {model_type}, District: {district}, " - f"t-stat: {t_stat:.2f}, p-value: {p_value:.4f}") -## now all grids - -#### Now do number of births based on the TLO model and 2018 census +# +# ## now all grids +# fig, axes = plt.subplots(3, 3, figsize=(18, 18),) +# +# global_min = float('inf') +# global_max = float('-inf') +# +# for scenario in scenarios: +# for model_type in model_types: +# predictions_from_cmip = pd.read_csv( +# f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' +# ) +# predictions_from_cmip_sum = predictions_from_cmip.groupby('District').sum().reset_index() +# predictions_from_cmip_sum['Percentage_Difference'] = ( +# predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model'] +# ) * 100 +# +# predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( +# {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} +# ) +# percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() +# malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) +# malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 +# +# local_min = malawi_admin2['Percentage_Difference'].min() +# local_max = malawi_admin2['Percentage_Difference'].max() +# global_min = min(global_min, local_min) +# global_max = max(global_max, local_max) +# +# for i, scenario in enumerate(scenarios): +# for j, model_type in enumerate(model_types): +# predictions_from_cmip = pd.read_csv( +# f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' +# ) +# predictions_from_cmip_sum = predictions_from_cmip.groupby('District').sum().reset_index() +# predictions_from_cmip_sum['Percentage_Difference'] = ( +# predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model'] +# ) * 100 +# +# predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( +# {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} +# ) +# percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() +# malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) +# malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 +# +# ax = axes[i, j] +# malawi_admin2.dropna(subset=['Percentage_Difference']).plot( +# ax=ax, +# column='Percentage_Difference', +# cmap='Blues_r', +# edgecolor='black', +# alpha=1, +# legend=False, +# vmin=global_min, +# vmax=global_max +# ) +# +# ax.set_title(f"{scenario}: {model_type}", fontsize=14) +# +# if i != 1: +# ax.set_xlabel("") +# if j != 0: +# ax.set_ylabel("") +# else: +# ax.set_ylabel("Latitude", fontsize=10) +# +# if i == 1: +# ax.set_xlabel("Longitude", fontsize=10) +# +# sm = plt.cm.ScalarMappable( +# cmap='Blues_r', +# norm=mcolors.Normalize(vmin=global_min, vmax=global_max) +# ) +# sm.set_array([]) +# fig.colorbar(sm, ax=axes, orientation="vertical", shrink=0.8, label="Percentage Difference (%)") +# plt.suptitle("Percentage Difference Maps by Scenario and Model Type", fontsize=16, y=1.02) +# plt.savefig(results_folder_to_save / 'percentage_difference_maps_grid.png') +# plt.show() +# +# +# +# significant_results_year = [] +# # +# # Assuming 'district' is a column in your data +# for scenario in scenarios: +# for model_type in model_types: +# predictions_from_cmip = pd.read_csv( +# f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' +# ) +# predictions_from_cmip_sum = predictions_from_cmip.groupby(['District', 'Year']).sum().reset_index() +# for district in predictions_from_cmip_sum['District'].unique(): +# district_values = predictions_from_cmip_sum[predictions_from_cmip_sum['District'] == district] +# no_weather_model = district_values['Predicted_No_Weather_Model'].values +# weather_model = district_values['Predicted_Weather_Model'].values +# +# # Calculate the difference +# difference = no_weather_model - weather_model +# +# # Perform a one-sample t-test assuming 0 as the null hypothesis mean +# t_stat, p_value = ttest_1samp(difference, popmean=0) +# # Print results if p-value is below 0.05 (statistically significant) +# if p_value < 0.05: +# print(f"Scenario: {scenario}, Model Type: {model_type}, District: {district}, " +# f"t-stat: {t_stat:.2f}, p-value: {p_value:.4f}") +# ## now all grids +# +# #### Now do number of births based on the TLO model and 2018 census population_file = "/Users/rem76/PycharmProjects/TLOmodel/resources/demography/ResourceFile_PopulationSize_2018Census.csv" population_data = pd.read_csv(population_file) @@ -317,9 +246,18 @@ y_max = float('-inf') x_min = float('inf') x_max = float('-inf') +percentage_diff_by_year_district_all = {} +percentage_diff_by_year_district_scenario = {} year_groupings = range(2025, 2060, 5) for i, scenario in enumerate(scenarios): + percentage_diff_by_year_district_all[scenario] = {} + percentage_diff_by_year_district_scenario[scenario] = {} + for j, model_type in enumerate(model_types): + percentage_diff_by_year_district_all[scenario][model_type] = {} + percentage_diff_by_year_district_scenario[scenario][model_type] = {} + percentage_diff_by_year_district_scenario[scenario][model_type] = 0 + percentage_diff_by_year_district = {} predictions_from_cmip = pd.read_csv( @@ -355,6 +293,7 @@ if district not in percentage_diff_by_year_district[year]: percentage_diff_by_year_district[year][district] = 0 percentage_diff_by_year_district[year][district] += (percentage_diff * number_of_births) * 1.4 # 1.4 is conversion factor between births and pregancies + percentage_diff_by_year_district_scenario[scenario][model_type] = (percentage_diff * number_of_births) * 1.4 data_for_plot = pd.DataFrame.from_dict(percentage_diff_by_year_district, orient='index').fillna(0) y_min = min(y_min, data_for_plot.min().min()) @@ -371,13 +310,103 @@ ax.set_ylabel('Deficit of ANC services', fontsize=12) if (i == 0) & (j == 2): ax.legend(title="Districts", fontsize=10, title_fontsize=10, bbox_to_anchor=(1., 1)) - + percentage_diff_by_year_district_all[scenario][model_type] = percentage_diff_by_year_district for ax in axes.flatten(): ax.set_ylim(y_min*9, y_max) handles, labels = ax.get_legend_handles_labels() fig.legend(handles, labels, bbox_to_anchor=(1, -10), loc = "center right", fontsize=10, title="Districts") plt.tight_layout() -plt.savefig(results_folder_to_save / 'stacked_bar_percentage_difference_5_years_grid_single_legend_with_births.png') -plt.show() +#plt.savefig(results_folder_to_save / 'stacked_bar_percentage_difference_5_years_grid_single_legend_with_births.png') +#plt.show() # # + +## % of cases that occur due to being in the top 10 percet? +fig, axes = plt.subplots(3, 3, figsize=(18, 18)) +y_min = float('inf') +y_max = float('-inf') +x_min = float('inf') +x_max = float('-inf') +year_groupings = range(2025, 2060, 5) +percentage_diff_by_year_district_top_10_all = {} +percentage_diff_by_year_district_top_10_scenario = {} + +for i, scenario in enumerate(scenarios): + percentage_diff_by_year_district_top_10_all[scenario] = {} + percentage_diff_by_year_district_top_10_scenario[scenario] = {} + for j, model_type in enumerate(model_types): + percentage_diff_by_year_district_top_10_all[scenario][model_type] = {} + + percentage_diff_by_year_district_top_10 = {} + percentage_diff_by_year_district_top_10_scenario[scenario][model_type] = { + + } + percentage_diff_by_year_district_top_10_scenario[scenario][model_type] = 0 + + predictions_from_cmip_sum = pd.read_csv( + f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' + ) + + predictions_from_cmip_sum = predictions_from_cmip_sum[predictions_from_cmip_sum['Year'] <= 2060] + predictions_from_cmip_sum['Percentage_Difference'] = ( + predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model'] + ) + predictions_from_cmip_sum.loc[predictions_from_cmip_sum['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 + predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace({"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"}) + predictions_from_cmip_annual_sum = predictions_from_cmip_sum.groupby(['Year','District']).sum().reset_index() + + precipitation_threshold = predictions_from_cmip_sum['Precipitation'].quantile(0.9) + filtered_predictions = predictions_from_cmip_sum[predictions_from_cmip_sum['Precipitation'] >= precipitation_threshold] + for year in year_groupings: + subset_filtered = filtered_predictions[ + (filtered_predictions['Year'] >= year) & (filtered_predictions['Year'] <= year + 5) + ] + subset_total = predictions_from_cmip_annual_sum[ + (predictions_from_cmip_annual_sum['Year'] >= year) & (predictions_from_cmip_annual_sum['Year'] <= year + 5) + ] + for _, row in subset_filtered.iterrows(): + district = row['District'] + if pd.isna(district) or district == '': + continue + percentage_diff_filtered = row['Percentage_Difference'] + row_index = births_model_subset.index.get_loc(year) + population_proportion_for_district = population_proportion[district] + number_of_pregancies= (population_proportion_for_district * births_model_subset.iloc[row_index]["Model_mean"])/12 # cos for each month + if year not in percentage_diff_by_year_district_top_10: + percentage_diff_by_year_district_top_10[year] = {} + if district not in percentage_diff_by_year_district_top_10[year]: + percentage_diff_by_year_district_top_10[year][district] = 0 + percentage_diff_by_year_district_top_10[year][district] += (percentage_diff_filtered * number_of_pregancies) * 1.4 + percentage_diff_by_year_district_top_10_scenario[scenario][model_type] += (percentage_diff_filtered * number_of_pregancies) * 1.4 + percentage_diff_by_year_district_top_10_all[scenario][model_type] = percentage_diff_by_year_district_top_10 + data_for_plot = pd.DataFrame.from_dict(percentage_diff_by_year_district_top_10, orient='index').fillna(0) + y_min = min(y_min, data_for_plot.min().min()) + y_max = max(y_max, data_for_plot.max().max()) + x_min = min(x_min, data_for_plot.index.min()) + x_max = max(x_max, data_for_plot.index.max()) + + ax = axes[i, j] + data_for_plot.plot(kind='bar', stacked=True, ax=ax, cmap='tab20', legend=False) + ax.set_title(f"{scenario}: {model_type}", fontsize=10) + if i == len(scenarios) - 1: + ax.set_xlabel('Year', fontsize=12) + if j == 0: + ax.set_ylabel('Deficit of ANC services', fontsize=12) + if (i == 0) & (j == 2): + ax.legend(title="Districts", fontsize=10, title_fontsize=10, bbox_to_anchor=(1., 1)) + +for ax in axes.flatten(): + ax.set_ylim(y_min * 9, y_max) + +handles, labels = ax.get_legend_handles_labels() +fig.legend(handles, labels, bbox_to_anchor=(1, -10), loc="center right", fontsize=10, title="Districts") +plt.tight_layout() +#plt.savefig(results_folder_to_save / 'stacked_bar_percentage_difference_5_years_grid_single_legend_with_births.png') +plt.show() + +# percentage due to extreme events +print(percentage_diff_by_year_district_top_10_scenario) +print() + + + From 2888408843bbbfe18df4fe2aef69d01ec0224531 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 17 Jan 2025 10:21:31 +0000 Subject: [PATCH 208/291] Updated to aggregate over all years, and ensure that only the negative differences are being used. (Effect was diminished by fact that +ve values were included.) --- src/scripts/climate_change/cohort_model.py | 282 +++++++++++++-------- 1 file changed, 175 insertions(+), 107 deletions(-) diff --git a/src/scripts/climate_change/cohort_model.py b/src/scripts/climate_change/cohort_model.py index 27054309ae..f7ffc9357f 100644 --- a/src/scripts/climate_change/cohort_model.py +++ b/src/scripts/climate_change/cohort_model.py @@ -124,114 +124,123 @@ final_results.to_csv('/Users/rem76/Desktop/Climate_change_health/Results/ANC_disruptions/negative_sums_and_percentages.csv', index=False) + + +## now all grids +fig, axes = plt.subplots(3, 3, figsize=(18, 18),) + +global_min = float('inf') +global_max = float('-inf') + +for scenario in scenarios: + for model_type in model_types: + predictions_from_cmip = pd.read_csv( + f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' + ) + predictions_from_cmip = predictions_from_cmip.loc[predictions_from_cmip['Difference_in_Expectation'] < 0] + predictions_from_cmip_sum = predictions_from_cmip_sum[predictions_from_cmip_sum['Year'] <= 2061] + + predictions_from_cmip_sum = predictions_from_cmip.groupby('District').sum().reset_index() + predictions_from_cmip_sum['Percentage_Difference'] = ( + predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model'] + ) * 100 + + predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( + {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} + ) + percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() + malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) + malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 + + local_min = malawi_admin2['Percentage_Difference'].min() + local_max = malawi_admin2['Percentage_Difference'].max() + global_min = min(global_min, local_min) + global_max = max(global_max, local_max) + +for i, scenario in enumerate(scenarios): + for j, model_type in enumerate(model_types): + predictions_from_cmip = pd.read_csv( + f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' + ) + predictions_from_cmip = predictions_from_cmip.loc[predictions_from_cmip['Difference_in_Expectation'] < 0] + predictions_from_cmip_sum = predictions_from_cmip_sum[predictions_from_cmip_sum['Year'] <= 2061] + + predictions_from_cmip_sum = predictions_from_cmip.groupby('District').sum().reset_index() + predictions_from_cmip_sum['Percentage_Difference'] = ( + predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model'] + ) * 100 + + predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( + {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} + ) + percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() + malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) + malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 + + ax = axes[i, j] + malawi_admin2.dropna(subset=['Percentage_Difference']).plot( + ax=ax, + column='Percentage_Difference', + cmap='Blues_r', + edgecolor='black', + alpha=1, + legend=False, + vmin=global_min, + vmax=global_max + ) + + ax.set_title(f"{scenario}: {model_type}", fontsize=14) + + if i != 1: + ax.set_xlabel("") + if j != 0: + ax.set_ylabel("") + else: + ax.set_ylabel("Latitude", fontsize=10) + + if i == 1: + ax.set_xlabel("Longitude", fontsize=10) + +sm = plt.cm.ScalarMappable( + cmap='Blues_r', + norm=mcolors.Normalize(vmin=global_min, vmax=global_max) +) +sm.set_array([]) +fig.colorbar(sm, ax=axes, orientation="vertical", shrink=0.8, label="Percentage Difference (%)") +plt.suptitle("Percentage Difference Maps by Scenario and Model Type", fontsize=16, y=1.02) +plt.savefig(results_folder_to_save / 'percentage_difference_maps_grid.png') +plt.show() + + + +significant_results_year = [] # -# -# ## now all grids -# fig, axes = plt.subplots(3, 3, figsize=(18, 18),) -# -# global_min = float('inf') -# global_max = float('-inf') -# -# for scenario in scenarios: -# for model_type in model_types: -# predictions_from_cmip = pd.read_csv( -# f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' -# ) -# predictions_from_cmip_sum = predictions_from_cmip.groupby('District').sum().reset_index() -# predictions_from_cmip_sum['Percentage_Difference'] = ( -# predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model'] -# ) * 100 -# -# predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( -# {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} -# ) -# percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() -# malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) -# malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 -# -# local_min = malawi_admin2['Percentage_Difference'].min() -# local_max = malawi_admin2['Percentage_Difference'].max() -# global_min = min(global_min, local_min) -# global_max = max(global_max, local_max) -# -# for i, scenario in enumerate(scenarios): -# for j, model_type in enumerate(model_types): -# predictions_from_cmip = pd.read_csv( -# f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' -# ) -# predictions_from_cmip_sum = predictions_from_cmip.groupby('District').sum().reset_index() -# predictions_from_cmip_sum['Percentage_Difference'] = ( -# predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model'] -# ) * 100 -# -# predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( -# {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} -# ) -# percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() -# malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) -# malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 -# -# ax = axes[i, j] -# malawi_admin2.dropna(subset=['Percentage_Difference']).plot( -# ax=ax, -# column='Percentage_Difference', -# cmap='Blues_r', -# edgecolor='black', -# alpha=1, -# legend=False, -# vmin=global_min, -# vmax=global_max -# ) -# -# ax.set_title(f"{scenario}: {model_type}", fontsize=14) -# -# if i != 1: -# ax.set_xlabel("") -# if j != 0: -# ax.set_ylabel("") -# else: -# ax.set_ylabel("Latitude", fontsize=10) -# -# if i == 1: -# ax.set_xlabel("Longitude", fontsize=10) -# -# sm = plt.cm.ScalarMappable( -# cmap='Blues_r', -# norm=mcolors.Normalize(vmin=global_min, vmax=global_max) -# ) -# sm.set_array([]) -# fig.colorbar(sm, ax=axes, orientation="vertical", shrink=0.8, label="Percentage Difference (%)") -# plt.suptitle("Percentage Difference Maps by Scenario and Model Type", fontsize=16, y=1.02) -# plt.savefig(results_folder_to_save / 'percentage_difference_maps_grid.png') -# plt.show() -# -# -# -# significant_results_year = [] -# # -# # Assuming 'district' is a column in your data -# for scenario in scenarios: -# for model_type in model_types: -# predictions_from_cmip = pd.read_csv( -# f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' -# ) -# predictions_from_cmip_sum = predictions_from_cmip.groupby(['District', 'Year']).sum().reset_index() -# for district in predictions_from_cmip_sum['District'].unique(): -# district_values = predictions_from_cmip_sum[predictions_from_cmip_sum['District'] == district] -# no_weather_model = district_values['Predicted_No_Weather_Model'].values -# weather_model = district_values['Predicted_Weather_Model'].values -# -# # Calculate the difference -# difference = no_weather_model - weather_model -# -# # Perform a one-sample t-test assuming 0 as the null hypothesis mean -# t_stat, p_value = ttest_1samp(difference, popmean=0) -# # Print results if p-value is below 0.05 (statistically significant) -# if p_value < 0.05: -# print(f"Scenario: {scenario}, Model Type: {model_type}, District: {district}, " -# f"t-stat: {t_stat:.2f}, p-value: {p_value:.4f}") -# ## now all grids -# +# Assuming 'district' is a column in your data +for scenario in scenarios: + for model_type in model_types: + predictions_from_cmip = pd.read_csv( + f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' + ) + predictions_from_cmip = predictions_from_cmip.loc[predictions_from_cmip['Difference_in_Expectation'] < 0] + predictions_from_cmip_sum = predictions_from_cmip_sum[predictions_from_cmip_sum['Year'] <= 2061] + + predictions_from_cmip_sum = predictions_from_cmip.groupby(['District', 'Year']).sum().reset_index() + for district in predictions_from_cmip_sum['District'].unique(): + district_values = predictions_from_cmip_sum[predictions_from_cmip_sum['District'] == district] + no_weather_model = district_values['Predicted_No_Weather_Model'].values + weather_model = district_values['Predicted_Weather_Model'].values + + # Calculate the difference + difference = no_weather_model - weather_model + + # Perform a one-sample t-test assuming 0 as the null hypothesis mean + t_stat, p_value = ttest_1samp(difference, popmean=0) + # Print results if p-value is below 0.05 (statistically significant) + if p_value < 0.05: + print(f"Scenario: {scenario}, Model Type: {model_type}, District: {district}, " + f"t-stat: {t_stat:.2f}, p-value: {p_value:.4f}") +## now all grids + # #### Now do number of births based on the TLO model and 2018 census population_file = "/Users/rem76/PycharmProjects/TLOmodel/resources/demography/ResourceFile_PopulationSize_2018Census.csv" population_data = pd.read_csv(population_file) @@ -263,6 +272,8 @@ predictions_from_cmip = pd.read_csv( f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' ) + predictions_from_cmip = predictions_from_cmip.loc[predictions_from_cmip['Difference_in_Expectation'] < 0] + predictions_from_cmip_sum = predictions_from_cmip_sum[predictions_from_cmip_sum['Year'] <= 2061] predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'District']).sum().reset_index() predictions_from_cmip_sum = predictions_from_cmip_sum[predictions_from_cmip_sum['Year'] <= 2060] @@ -346,6 +357,7 @@ predictions_from_cmip_sum = pd.read_csv( f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' ) + predictions_from_cmip_sum = predictions_from_cmip.loc[predictions_from_cmip['Difference_in_Expectation'] < 0] predictions_from_cmip_sum = predictions_from_cmip_sum[predictions_from_cmip_sum['Year'] <= 2060] predictions_from_cmip_sum['Percentage_Difference'] = ( @@ -410,3 +422,59 @@ +results_list = [] + +#Loop through scenarios and model types +for scenario in scenarios: + for model_type in model_types: + predictions_from_cmip = pd.read_csv( + f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' + ) + predictions_from_cmip = predictions_from_cmip.loc[predictions_from_cmip['Difference_in_Expectation'] < 0] + predictions_from_cmip_sum = predictions_from_cmip.groupby('Year').sum().reset_index() + predictions_from_cmip_sum = predictions_from_cmip_sum[predictions_from_cmip_sum['Year'] <= 2061] + + predictions_from_cmip_sum['Percentage_Difference'] = ( + predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum[ + 'Predicted_No_Weather_Model']) + # Match birth results and predictions + matching_rows = min(len(births_model_subset), len(predictions_from_cmip_sum)) + multiplied_values = births_model_subset.head(matching_rows).iloc[:, 1].values * predictions_from_cmip_sum[ + 'Percentage_Difference'].head(matching_rows).values * 1.4 # 1.4 is conversion from births to pregnacnies + births_model_subset['Multiplied_Values'] = multiplied_values + # Check for negative values (missed cases?) + negative_sum = np.sum(multiplied_values[multiplied_values < 0]) + # below is check on calculation + # total_negative_difference = predictions_from_cmip.loc[predictions_from_cmip['Difference_in_Expectation'] < 0, 'Difference_in_Expectation'].sum() + # total_percentage_negative_difference = total_negative_difference/ predictions_from_cmip['Predicted_No_Weather_Model'].sum() + # total_expected_difference = total_percentage_negative_difference * (births_model_subset['Model_mean'].sum() * 1.4) + + result_df = pd.DataFrame({ + "Scenario": [scenario], + "Model_Type": [model_type], + "Negative_Sum": [negative_sum], + "Negative_Percentage": [negative_sum / (births_model_subset['Model_mean'].sum() * 1.4) * 100] + }) + + results_list.append(result_df) + # Generate district map visualization + predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( + {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"}) + + predictions_from_cmip_sum['Percentage_Difference'] = (predictions_from_cmip_sum['Difference_in_Expectation'] / + predictions_from_cmip_sum[ + 'Predicted_No_Weather_Model']) * 100 + percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() + + # Save multiplied values by model and scenario + multiplied_values_df = pd.DataFrame({ + 'Year': year_range[:matching_rows], + 'Scenario': scenario, + 'Model_Type': model_type, + 'Multiplied_Values': multiplied_values + }) + multiplied_values_df.to_csv(results_folder_to_save/f'multiplied_values_{scenario}_{model_type}.csv', index=False) + +final_results = pd.concat(results_list, ignore_index=True) +final_results.to_csv('/Users/rem76/Desktop/Climate_change_health/Results/ANC_disruptions/negative_sums_and_percentages.csv', index=False) + From f4b48ec4e4f7861eb191cbfcfec2ca9e1af91334 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 17 Jan 2025 11:02:01 +0000 Subject: [PATCH 209/291] Added in calculation of cases disrupted due to precip in top 10% --- src/scripts/climate_change/cohort_model.py | 101 +++++---------------- 1 file changed, 22 insertions(+), 79 deletions(-) diff --git a/src/scripts/climate_change/cohort_model.py b/src/scripts/climate_change/cohort_model.py index f7ffc9357f..471a6c9025 100644 --- a/src/scripts/climate_change/cohort_model.py +++ b/src/scripts/climate_change/cohort_model.py @@ -68,6 +68,8 @@ results_list = [] +results_list = [] + #Loop through scenarios and model types for scenario in scenarios: for model_type in model_types: @@ -75,9 +77,9 @@ f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' ) predictions_from_cmip = predictions_from_cmip.loc[predictions_from_cmip['Difference_in_Expectation'] < 0] + predictions_from_cmip = predictions_from_cmip[predictions_from_cmip['Year'] <= 2061] + # total disruptions predictions_from_cmip_sum = predictions_from_cmip.groupby('Year').sum().reset_index() - predictions_from_cmip_sum = predictions_from_cmip_sum[predictions_from_cmip_sum['Year'] <= 2061] - predictions_from_cmip_sum['Percentage_Difference'] = ( predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum[ 'Predicted_No_Weather_Model']) @@ -85,38 +87,38 @@ matching_rows = min(len(births_model_subset), len(predictions_from_cmip_sum)) multiplied_values = births_model_subset.head(matching_rows).iloc[:, 1].values * predictions_from_cmip_sum[ 'Percentage_Difference'].head(matching_rows).values * 1.4 # 1.4 is conversion from births to pregnacnies - births_model_subset['Multiplied_Values'] = multiplied_values + # Check for negative values (missed cases?) negative_sum = np.sum(multiplied_values[multiplied_values < 0]) - #print(negative_sum) - total_negative_difference = predictions_from_cmip.loc[predictions_from_cmip['Difference_in_Expectation'] < 0, 'Difference_in_Expectation'].sum() - total_percentage_negative_difference = total_negative_difference/ predictions_from_cmip['Predicted_No_Weather_Model'].sum() - total_expected_difference = total_percentage_negative_difference * (births_model_subset['Model_mean'].sum() * 1.4) - #print(total_expected_difference) + # now do extreme precipitation by district and year, use original dataframe to get monthly top 10% precip + precipitation_threshold = predictions_from_cmip['Precipitation'].quantile(0.9) + filtered_predictions = predictions_from_cmip_sum[predictions_from_cmip_sum['Precipitation'] >= precipitation_threshold] + filtered_predictions['Percentage_Difference'] = ( + filtered_predictions['Difference_in_Expectation'] / filtered_predictions[ + 'Predicted_No_Weather_Model']) + + multiplied_values_extreme_precip = births_model_subset.head(matching_rows).iloc[:, 1].values * filtered_predictions[ + 'Percentage_Difference'].head(matching_rows).values * 1.4 result_df = pd.DataFrame({ "Scenario": [scenario], "Model_Type": [model_type], "Negative_Sum": [negative_sum], - "Negative_Percentage": [negative_sum / (births_model_subset['Model_mean'].sum() * 1.4) * 100] + "Negative_Percentage": [negative_sum / (births_model_subset['Model_mean'].sum() * 1.4) * 100], + "Extreme_Precip": [multiplied_values_extreme_precip], + "Extreme_Precip_Percentage": [multiplied_values_extreme_precip / (births_model_subset['Model_mean'].sum() * 1.4) * 100] }) results_list.append(result_df) - # Generate district map visualization - predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( - {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"}) - - predictions_from_cmip_sum['Percentage_Difference'] = (predictions_from_cmip_sum['Difference_in_Expectation'] / - predictions_from_cmip_sum[ - 'Predicted_No_Weather_Model']) * 100 - percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() # Save multiplied values by model and scenario multiplied_values_df = pd.DataFrame({ 'Year': year_range[:matching_rows], 'Scenario': scenario, 'Model_Type': model_type, - 'Multiplied_Values': multiplied_values + 'Multiplied_Values': multiplied_values, + 'Multiplied_Values_extreme_precip': multiplied_values_extreme_precip + }) multiplied_values_df.to_csv(results_folder_to_save/f'multiplied_values_{scenario}_{model_type}.csv', index=False) @@ -327,7 +329,7 @@ handles, labels = ax.get_legend_handles_labels() fig.legend(handles, labels, bbox_to_anchor=(1, -10), loc = "center right", fontsize=10, title="Districts") plt.tight_layout() -#plt.savefig(results_folder_to_save / 'stacked_bar_percentage_difference_5_years_grid_single_legend_with_births.png') +plt.savefig(results_folder_to_save / 'stacked_bar_percentage_difference_5_years_grid_single_legend_with_births.png') #plt.show() # # @@ -413,68 +415,9 @@ handles, labels = ax.get_legend_handles_labels() fig.legend(handles, labels, bbox_to_anchor=(1, -10), loc="center right", fontsize=10, title="Districts") plt.tight_layout() -#plt.savefig(results_folder_to_save / 'stacked_bar_percentage_difference_5_years_grid_single_legend_with_births.png') +plt.savefig(results_folder_to_save / 'stacked_bar_percentage_difference_5_years_grid_single_legend_with_births_extreme_precip.png') plt.show() -# percentage due to extreme events print(percentage_diff_by_year_district_top_10_scenario) -print() - -results_list = [] - -#Loop through scenarios and model types -for scenario in scenarios: - for model_type in model_types: - predictions_from_cmip = pd.read_csv( - f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' - ) - predictions_from_cmip = predictions_from_cmip.loc[predictions_from_cmip['Difference_in_Expectation'] < 0] - predictions_from_cmip_sum = predictions_from_cmip.groupby('Year').sum().reset_index() - predictions_from_cmip_sum = predictions_from_cmip_sum[predictions_from_cmip_sum['Year'] <= 2061] - - predictions_from_cmip_sum['Percentage_Difference'] = ( - predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum[ - 'Predicted_No_Weather_Model']) - # Match birth results and predictions - matching_rows = min(len(births_model_subset), len(predictions_from_cmip_sum)) - multiplied_values = births_model_subset.head(matching_rows).iloc[:, 1].values * predictions_from_cmip_sum[ - 'Percentage_Difference'].head(matching_rows).values * 1.4 # 1.4 is conversion from births to pregnacnies - births_model_subset['Multiplied_Values'] = multiplied_values - # Check for negative values (missed cases?) - negative_sum = np.sum(multiplied_values[multiplied_values < 0]) - # below is check on calculation - # total_negative_difference = predictions_from_cmip.loc[predictions_from_cmip['Difference_in_Expectation'] < 0, 'Difference_in_Expectation'].sum() - # total_percentage_negative_difference = total_negative_difference/ predictions_from_cmip['Predicted_No_Weather_Model'].sum() - # total_expected_difference = total_percentage_negative_difference * (births_model_subset['Model_mean'].sum() * 1.4) - - result_df = pd.DataFrame({ - "Scenario": [scenario], - "Model_Type": [model_type], - "Negative_Sum": [negative_sum], - "Negative_Percentage": [negative_sum / (births_model_subset['Model_mean'].sum() * 1.4) * 100] - }) - - results_list.append(result_df) - # Generate district map visualization - predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( - {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"}) - - predictions_from_cmip_sum['Percentage_Difference'] = (predictions_from_cmip_sum['Difference_in_Expectation'] / - predictions_from_cmip_sum[ - 'Predicted_No_Weather_Model']) * 100 - percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() - - # Save multiplied values by model and scenario - multiplied_values_df = pd.DataFrame({ - 'Year': year_range[:matching_rows], - 'Scenario': scenario, - 'Model_Type': model_type, - 'Multiplied_Values': multiplied_values - }) - multiplied_values_df.to_csv(results_folder_to_save/f'multiplied_values_{scenario}_{model_type}.csv', index=False) - -final_results = pd.concat(results_list, ignore_index=True) -final_results.to_csv('/Users/rem76/Desktop/Climate_change_health/Results/ANC_disruptions/negative_sums_and_percentages.csv', index=False) - From ab553d2b1a86602a80148bf1ec401c52c78bc8f0 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 17 Jan 2025 11:11:09 +0000 Subject: [PATCH 210/291] graph aesthetics also reduced negative sum to single number --- src/scripts/climate_change/cohort_model.py | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/src/scripts/climate_change/cohort_model.py b/src/scripts/climate_change/cohort_model.py index 471a6c9025..3e182baca8 100644 --- a/src/scripts/climate_change/cohort_model.py +++ b/src/scripts/climate_change/cohort_model.py @@ -100,13 +100,14 @@ multiplied_values_extreme_precip = births_model_subset.head(matching_rows).iloc[:, 1].values * filtered_predictions[ 'Percentage_Difference'].head(matching_rows).values * 1.4 + negative_sum_extreme_precip = np.sum(multiplied_values_extreme_precip[multiplied_values_extreme_precip < 0]) result_df = pd.DataFrame({ "Scenario": [scenario], "Model_Type": [model_type], "Negative_Sum": [negative_sum], "Negative_Percentage": [negative_sum / (births_model_subset['Model_mean'].sum() * 1.4) * 100], - "Extreme_Precip": [multiplied_values_extreme_precip], - "Extreme_Precip_Percentage": [multiplied_values_extreme_precip / (births_model_subset['Model_mean'].sum() * 1.4) * 100] + "Extreme_Precip": [negative_sum_extreme_precip], + "Extreme_Precip_Percentage": [negative_sum_extreme_precip / (births_model_subset['Model_mean'].sum() * 1.4) * 100] }) results_list.append(result_df) @@ -321,11 +322,11 @@ ax.set_xlabel('Year', fontsize=12) if j == 0: ax.set_ylabel('Deficit of ANC services', fontsize=12) - if (i == 0) & (j == 2): - ax.legend(title="Districts", fontsize=10, title_fontsize=10, bbox_to_anchor=(1., 1)) + #if (i == 0) & (j == 2): + # ax.legend(title="Districts", fontsize=10, title_fontsize=10, bbox_to_anchor=(1., 1)) percentage_diff_by_year_district_all[scenario][model_type] = percentage_diff_by_year_district for ax in axes.flatten(): - ax.set_ylim(y_min*9, y_max) + ax.set_ylim(y_min*11, y_max) handles, labels = ax.get_legend_handles_labels() fig.legend(handles, labels, bbox_to_anchor=(1, -10), loc = "center right", fontsize=10, title="Districts") plt.tight_layout() From f107e03982a280e8f2fad38e2116ca5ffbb1117d Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 17 Jan 2025 11:52:30 +0000 Subject: [PATCH 211/291] typo --- src/scripts/climate_change/cohort_model.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/scripts/climate_change/cohort_model.py b/src/scripts/climate_change/cohort_model.py index 3e182baca8..93b9b2324a 100644 --- a/src/scripts/climate_change/cohort_model.py +++ b/src/scripts/climate_change/cohort_model.py @@ -93,7 +93,7 @@ # now do extreme precipitation by district and year, use original dataframe to get monthly top 10% precip precipitation_threshold = predictions_from_cmip['Precipitation'].quantile(0.9) - filtered_predictions = predictions_from_cmip_sum[predictions_from_cmip_sum['Precipitation'] >= precipitation_threshold] + filtered_predictions = predictions_from_cmip[predictions_from_cmip['Precipitation'] >= precipitation_threshold] filtered_predictions['Percentage_Difference'] = ( filtered_predictions['Difference_in_Expectation'] / filtered_predictions[ 'Predicted_No_Weather_Model']) From 366041e2411b697d65272b3465b37bacf52e5c9f Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 17 Jan 2025 13:09:40 +0000 Subject: [PATCH 212/291] mask for covid months caused issues with indexing also, saved the dataframe of historical estimated disruptions --- ...al_realtionship_reporting_precipitation.py | 75 ++++++++----------- 1 file changed, 30 insertions(+), 45 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 44dbe3d2bf..171588a8af 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -50,30 +50,6 @@ # # data is from 2011 - 2024 - for facility if ANC: monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_ANC_by_smaller_facility_lm.csv", index_col=0) - if daily_max: - if five_day: - if cumulative: - weather_data_historical = pd.read_csv( - "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/historical_daily_total_by_facilities_with_ANC_five_day_cumulative.csv", - index_col=0) - else: - weather_data_historical = pd.read_csv( - "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/historical_daily_total_by_facilities_with_ANC_five_day_average.csv", - index_col=0) - else: - weather_data_historical = pd.read_csv( - "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/historical_daily_total_by_facility_five_day_cumulative.csv", - index_col=0) - elif daily_total: - if five_day: - if cumulative: - weather_data_historical = pd.read_csv( - "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/historical_daily_total_by_facilities_with_ANC_five_day_cumulative.csv", - index_col=0) - else: - weather_data_historical = pd.read_csv( - "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_ANC_lm.csv", - index_col=0) def build_model(X, y, poisson=False, log_y=False, X_mask_mm=0, feature_selection=False, k_best=None): @@ -183,6 +159,8 @@ def repeat_info(info, num_facilities, year_range, historical): if use_all_weather: weather_data_monthly_df = weather_data_monthly_original.drop(columns=zero_sum_columns, errors='ignore') + nan_indices = np.isnan(weather_data_monthly_df) + weather_data_five_day_cumulative_df = weather_data_five_day_cumulative_original.drop(columns=zero_sum_columns, errors='ignore') weather_data_monthly_df = weather_data_monthly_df.drop(weather_data_monthly_df.index[-2:]) @@ -220,26 +198,16 @@ def repeat_info(info, num_facilities, year_range, historical): weather_data_monthly = weather_data_monthly_df # need to keep these seperate for the binary values later weather_data_five_day_cumulative = weather_data_five_day_cumulative_df - weather_data_monthly.loc[covid_months, :] = np.nan - weather_data_five_day_cumulative.loc[covid_months, :] = np.nan + #weather_data_monthly.loc[covid_months, :] = np.nan + #weather_data_five_day_cumulative.loc[covid_months, :] = np.nan # code if years need to be dropped - weather_data_monthly = weather_data_monthly.iloc[(min_year_for_analysis - absolute_min_year) * 12:] weather_data_five_day_cumulative = weather_data_five_day_cumulative.iloc[(min_year_for_analysis - absolute_min_year) * 12:] - weather_data_monthly_flattened = weather_data_monthly.values.flatten() weather_data_five_day_cumulative_flattened = weather_data_five_day_cumulative.values.flatten() weather_data = np.vstack((weather_data_monthly_flattened,weather_data_five_day_cumulative_flattened)).T -else: - if five_day:# Drop September 2024 - weather_data_historical = weather_data_historical.drop(weather_data_historical.index[-1:]) - else: # drop october for monthly data - weather_data_historical = weather_data_historical.drop(weather_data_historical.index[-2:]) - weather_data_historical = weather_data_historical.drop(columns=zero_sum_columns, errors='ignore') - weather_data_historical.loc[covid_months, :] = np.nan - weather_data = weather_data_historical.values.flatten() - -# Mask COVID-19 months for reporting + +# # Mask COVID-19 months for reporting monthly_reporting_by_facility.iloc[covid_months, :] = np.nan # Mask for missing data with Cyclone Freddy monthly_reporting_by_facility.loc[cyclone_freddy_months_phalombe, 'Phalombe Health Centre'] = 0 @@ -304,12 +272,6 @@ def repeat_info(info, num_facilities, year_range, historical): ftype_encoded = pd.get_dummies(ftype_info_each_month, drop_first=True) altitude = [float(x) for x in repeat_info(expanded_facility_info['A109__Altitude'], num_facilities, year_range, historical = True)] minimum_distance = [float(x) for x in repeat_info(expanded_facility_info['minimum_distance'], num_facilities, year_range, historical = True)] -# Lagged weather -if not use_all_weather: - lag_1_month = weather_data_historical.shift(1).values.flatten() - lag_2_month = weather_data_historical.shift(2).values.flatten() - lag_3_month = weather_data_historical.shift(3).values.flatten() - lag_4_month = weather_data_historical.shift(4).values.flatten() altitude = np.array(altitude) altitude = np.where(altitude < 0, np.nan, altitude) @@ -331,6 +293,7 @@ def repeat_info(info, num_facilities, year_range, historical): altitude, np.array(minimum_distance) ]) + X_categorical = np.column_stack([ resid_encoded, zone_encoded, @@ -368,7 +331,7 @@ def repeat_info(info, num_facilities, year_range, historical): # # # Compute the correlation matrix # correlation_matrix = df_combined.corr() -#correlation_matrix.to_csv('/Users/rem76/Desktop/Climate_change_health/Data/correlation_matrix_of_predictors.csv') +# correlation_matrix.to_csv('/Users/rem76/Desktop/Climate_change_health/Data/correlation_matrix_of_predictors.csv') # Display the correlation matrix coefficient_names = ["year", "month", "altitude", "minimum_distance"] + list(resid_encoded.columns) + list(zone_encoded.columns) + \ @@ -548,6 +511,28 @@ def repeat_info(info, num_facilities, year_range, historical): plt.show() +## save historical predictions +full_data_weather_predictions_historical = pd.DataFrame({ + 'Year': np.array(year_flattened)[mask_all_data], + 'Month': np.array(month_flattened)[mask_all_data], + 'Facility_ID': np.array(facility_flattened)[mask_all_data], + 'Altitude': np.array(altitude)[mask_all_data], + 'Zone': np.array(zone_info_each_month)[mask_all_data], + 'District': np.array(dist_info_each_month)[mask_all_data], + 'Resid': np.array(resid_info_each_month)[mask_all_data], + 'Owner': np.array(owner_info_each_month)[mask_all_data], + 'Facility_Type': np.array(ftype_info_each_month)[mask_all_data], + 'Precipitation': X_weather_standardized[mask_all_data,0], + 'Lag_1_Precipitation': np.array(lag_1_month)[mask_all_data], + 'Lag_2_Precipitation': np.array(lag_2_month)[mask_all_data], + 'Lag_3_Precipitation': np.array(lag_3_month)[mask_all_data], + 'Lag_4_Precipitation': np.array(lag_4_month)[mask_all_data], + 'Predicted_Weather_Model': np.exp(matched_y_pred_weather), + 'Predicted_No_Weather_Model': np.exp(matched_y_pred), + 'Difference_in_Expectation': np.exp(matched_y_pred_weather) - np.exp(matched_y_pred), +}) +full_data_weather_predictions_historical.to_csv('/Users/rem76/Desktop/Climate_change_health/Data/results_of_ANC_model_historical_predictions.csv') + ############### ADD IN CMIP DATA ########################### def get_weather_data(ssp_scenario, model_type): From f681d4a858b275a2065270b2f827dc6baef7fb49 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 17 Jan 2025 14:57:22 +0000 Subject: [PATCH 213/291] map of historical disruptions --- src/scripts/climate_change/cohort_model.py | 48 ++++++++++++++++++++++ 1 file changed, 48 insertions(+) diff --git a/src/scripts/climate_change/cohort_model.py b/src/scripts/climate_change/cohort_model.py index 93b9b2324a..264f4c1fe1 100644 --- a/src/scripts/climate_change/cohort_model.py +++ b/src/scripts/climate_change/cohort_model.py @@ -422,3 +422,51 @@ print(percentage_diff_by_year_district_top_10_scenario) +####### Historical disruptions ########## + + +historical_predictions = pd.read_csv('/Users/rem76/Desktop/Climate_change_health/Data/results_of_ANC_model_historical_predictions.csv') +historical_predictions = historical_predictions.loc[historical_predictions['Difference_in_Expectation'] < 0] + +historical_predictions_sum = historical_predictions.groupby('District').sum().reset_index() +historical_predictions_sum['Percentage_Difference'] = ( + historical_predictions_sum['Difference_in_Expectation'] / historical_predictions_sum['Predicted_No_Weather_Model'] +) * 100 + +historical_predictions_sum['District'] = historical_predictions_sum['District'].replace( + {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} +) + +percentage_diff_by_district_historical = historical_predictions_sum.groupby('District')['Percentage_Difference'].mean() +malawi_admin2['Percentage_Difference_historical'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district_historical) +malawi_admin2.loc[malawi_admin2['Percentage_Difference_historical'] > 0, 'Percentage_Difference_historical'] = 0 + +global_min = malawi_admin2['Percentage_Difference_historical'].min() +global_max = malawi_admin2['Percentage_Difference_historical'].max() +print(global_min) +fig, ax = plt.subplots(figsize=(10, 10)) + +malawi_admin2.dropna(subset=['Percentage_Difference_historical']).plot( + ax=ax, + column='Percentage_Difference_historical', + cmap='Blues_r', + edgecolor='black', + alpha=1, + legend=False, + vmin=global_min, + vmax=0 +) + +ax.set_ylabel("Latitude", fontsize=10) +ax.set_xlabel("Longitude", fontsize=10) + +sm = plt.cm.ScalarMappable( + cmap='Blues_r', + norm=mcolors.Normalize(vmin=global_min, vmax=global_max) +) +sm.set_array([]) +fig.colorbar(sm, ax=ax, orientation="vertical", shrink=0.8, label="Percentage Difference (%)") + +plt.title("", fontsize=16) +plt.savefig(results_folder_to_save / 'percentage_difference_map_historical.png') +plt.show() From a2bce9b20b8afef3f33eaa33e7f78d92245da720 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 17 Jan 2025 17:23:52 +0000 Subject: [PATCH 214/291] Changed so that all heatmaps were on the same scale for comparison --- src/scripts/climate_change/cohort_model.py | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-) diff --git a/src/scripts/climate_change/cohort_model.py b/src/scripts/climate_change/cohort_model.py index 264f4c1fe1..e7b78fd6fb 100644 --- a/src/scripts/climate_change/cohort_model.py +++ b/src/scripts/climate_change/cohort_model.py @@ -22,6 +22,9 @@ scenarios = ['ssp126', 'ssp245', 'ssp585'] model_types = ['lowest', 'mean', 'highest'] year_range = range(min_year, max_year) +# global min for all heatmaps for same scale +global_min = -5 +global_max = 0 ## Get birth results results_folder_to_save = Path('/Users/rem76/Desktop/Climate_change_health/Results/ANC_disruptions') results_folder_for_births = Path("/Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-09-25T110820Z") @@ -132,8 +135,6 @@ ## now all grids fig, axes = plt.subplots(3, 3, figsize=(18, 18),) -global_min = float('inf') -global_max = float('-inf') for scenario in scenarios: for model_type in model_types: @@ -155,10 +156,6 @@ malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 - local_min = malawi_admin2['Percentage_Difference'].min() - local_max = malawi_admin2['Percentage_Difference'].max() - global_min = min(global_min, local_min) - global_max = max(global_max, local_max) for i, scenario in enumerate(scenarios): for j, model_type in enumerate(model_types): @@ -441,8 +438,7 @@ malawi_admin2['Percentage_Difference_historical'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district_historical) malawi_admin2.loc[malawi_admin2['Percentage_Difference_historical'] > 0, 'Percentage_Difference_historical'] = 0 -global_min = malawi_admin2['Percentage_Difference_historical'].min() -global_max = malawi_admin2['Percentage_Difference_historical'].max() + print(global_min) fig, ax = plt.subplots(figsize=(10, 10)) From 3593e437c7a95d0fe60fe55c7245c8abb260de6d Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 20 Jan 2025 10:20:55 +0000 Subject: [PATCH 215/291] Changed so that the threshold for historical precip is 90th percentile of historical precip --- src/scripts/climate_change/cohort_model.py | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/src/scripts/climate_change/cohort_model.py b/src/scripts/climate_change/cohort_model.py index e7b78fd6fb..35d9461ba4 100644 --- a/src/scripts/climate_change/cohort_model.py +++ b/src/scripts/climate_change/cohort_model.py @@ -29,6 +29,9 @@ results_folder_to_save = Path('/Users/rem76/Desktop/Climate_change_health/Results/ANC_disruptions') results_folder_for_births = Path("/Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-09-25T110820Z") resourcefilepath = Path("/Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-09-25T110820Z") +historical_predictions = pd.read_csv('/Users/rem76/Desktop/Climate_change_health/Data/results_of_ANC_model_historical_predictions.csv') +precipitation_threshold = historical_predictions['Precipitation'].quantile(0.9) +print(precipitation_threshold) agegrps, agegrplookup = make_age_grp_lookup() calperiods, calperiodlookup = make_calendar_period_lookup() births_results = extract_results( @@ -95,7 +98,6 @@ negative_sum = np.sum(multiplied_values[multiplied_values < 0]) # now do extreme precipitation by district and year, use original dataframe to get monthly top 10% precip - precipitation_threshold = predictions_from_cmip['Precipitation'].quantile(0.9) filtered_predictions = predictions_from_cmip[predictions_from_cmip['Precipitation'] >= precipitation_threshold] filtered_predictions['Percentage_Difference'] = ( filtered_predictions['Difference_in_Expectation'] / filtered_predictions[ @@ -176,7 +178,6 @@ percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 - ax = axes[i, j] malawi_admin2.dropna(subset=['Percentage_Difference']).plot( ax=ax, @@ -367,7 +368,6 @@ predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace({"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"}) predictions_from_cmip_annual_sum = predictions_from_cmip_sum.groupby(['Year','District']).sum().reset_index() - precipitation_threshold = predictions_from_cmip_sum['Precipitation'].quantile(0.9) filtered_predictions = predictions_from_cmip_sum[predictions_from_cmip_sum['Precipitation'] >= precipitation_threshold] for year in year_groupings: subset_filtered = filtered_predictions[ @@ -416,7 +416,6 @@ plt.savefig(results_folder_to_save / 'stacked_bar_percentage_difference_5_years_grid_single_legend_with_births_extreme_precip.png') plt.show() -print(percentage_diff_by_year_district_top_10_scenario) ####### Historical disruptions ########## @@ -439,7 +438,6 @@ malawi_admin2.loc[malawi_admin2['Percentage_Difference_historical'] > 0, 'Percentage_Difference_historical'] = 0 -print(global_min) fig, ax = plt.subplots(figsize=(10, 10)) malawi_admin2.dropna(subset=['Percentage_Difference_historical']).plot( From 08df36ba5f80ed2adebbb2d482099008223fe512 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 20 Jan 2025 15:00:28 +0000 Subject: [PATCH 216/291] Changed to be overall percent affected due to extreme climate events, not the percent change within a month that has an extreme climate event --- src/scripts/climate_change/cohort_model.py | 114 +++++++++++---------- 1 file changed, 60 insertions(+), 54 deletions(-) diff --git a/src/scripts/climate_change/cohort_model.py b/src/scripts/climate_change/cohort_model.py index 35d9461ba4..22b60ec8a8 100644 --- a/src/scripts/climate_change/cohort_model.py +++ b/src/scripts/climate_change/cohort_model.py @@ -99,12 +99,10 @@ # now do extreme precipitation by district and year, use original dataframe to get monthly top 10% precip filtered_predictions = predictions_from_cmip[predictions_from_cmip['Precipitation'] >= precipitation_threshold] - filtered_predictions['Percentage_Difference'] = ( - filtered_predictions['Difference_in_Expectation'] / filtered_predictions[ - 'Predicted_No_Weather_Model']) + filtered_predictions_sum = filtered_predictions.groupby('Year').sum().reset_index() + percent_due_to_extreme = filtered_predictions_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model'] - multiplied_values_extreme_precip = births_model_subset.head(matching_rows).iloc[:, 1].values * filtered_predictions[ - 'Percentage_Difference'].head(matching_rows).values * 1.4 + multiplied_values_extreme_precip = births_model_subset.head(matching_rows).iloc[:, 1].values * percent_due_to_extreme.head(matching_rows).values * 1.4 negative_sum_extreme_precip = np.sum(multiplied_values_extreme_precip[multiplied_values_extreme_precip < 0]) result_df = pd.DataFrame({ "Scenario": [scenario], @@ -112,7 +110,7 @@ "Negative_Sum": [negative_sum], "Negative_Percentage": [negative_sum / (births_model_subset['Model_mean'].sum() * 1.4) * 100], "Extreme_Precip": [negative_sum_extreme_precip], - "Extreme_Precip_Percentage": [negative_sum_extreme_precip / (births_model_subset['Model_mean'].sum() * 1.4) * 100] + "Extreme_Precip_Percentage": [(negative_sum_extreme_precip / negative_sum) * 100] }) results_list.append(result_df) @@ -129,6 +127,7 @@ multiplied_values_df.to_csv(results_folder_to_save/f'multiplied_values_{scenario}_{model_type}.csv', index=False) final_results = pd.concat(results_list, ignore_index=True) +print(final_results) final_results.to_csv('/Users/rem76/Desktop/Climate_change_health/Results/ANC_disruptions/negative_sums_and_percentages.csv', index=False) @@ -334,64 +333,72 @@ # ## % of cases that occur due to being in the top 10 percet? +# #### Now do number of births based on the TLO model and 2018 census +population_file = "/Users/rem76/PycharmProjects/TLOmodel/resources/demography/ResourceFile_PopulationSize_2018Census.csv" +population_data = pd.read_csv(population_file) + +population_data_grouped = population_data.groupby("District")["Count"].sum() +total_population = population_data_grouped.sum() +population_proportion = population_data_grouped / total_population + +# Create the figure and axes grid fig, axes = plt.subplots(3, 3, figsize=(18, 18)) y_min = float('inf') y_max = float('-inf') x_min = float('inf') x_max = float('-inf') +percentage_diff_by_year_district_all = {} +percentage_diff_by_year_district_scenario = {} year_groupings = range(2025, 2060, 5) -percentage_diff_by_year_district_top_10_all = {} -percentage_diff_by_year_district_top_10_scenario = {} - for i, scenario in enumerate(scenarios): - percentage_diff_by_year_district_top_10_all[scenario] = {} - percentage_diff_by_year_district_top_10_scenario[scenario] = {} - for j, model_type in enumerate(model_types): - percentage_diff_by_year_district_top_10_all[scenario][model_type] = {} + percentage_diff_by_year_district_all[scenario] = {} + percentage_diff_by_year_district_scenario[scenario] = {} - percentage_diff_by_year_district_top_10 = {} - percentage_diff_by_year_district_top_10_scenario[scenario][model_type] = { + for j, model_type in enumerate(model_types): + percentage_diff_by_year_district_all[scenario][model_type] = {} + percentage_diff_by_year_district_scenario[scenario][model_type] = {} + percentage_diff_by_year_district_scenario[scenario][model_type] = 0 - } - percentage_diff_by_year_district_top_10_scenario[scenario][model_type] = 0 + percentage_diff_by_year_district = {} - predictions_from_cmip_sum = pd.read_csv( + predictions_from_cmip = pd.read_csv( f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' ) - predictions_from_cmip_sum = predictions_from_cmip.loc[predictions_from_cmip['Difference_in_Expectation'] < 0] + predictions_from_cmip = predictions_from_cmip.loc[predictions_from_cmip['Difference_in_Expectation'] < 0] + predictions_from_cmip_sum = predictions_from_cmip_sum[predictions_from_cmip_sum['Year'] <= 2061] + predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'District']).sum().reset_index() predictions_from_cmip_sum = predictions_from_cmip_sum[predictions_from_cmip_sum['Year'] <= 2060] predictions_from_cmip_sum['Percentage_Difference'] = ( - predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model'] + predictions_from_cmip_sum[ + 'Difference_in_Expectation'] / + predictions_from_cmip_sum['Predicted_No_Weather_Model'] + ) + predictions_from_cmip_sum.loc[ + predictions_from_cmip_sum['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 + predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( + {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} ) - predictions_from_cmip_sum.loc[predictions_from_cmip_sum['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 - predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace({"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"}) - predictions_from_cmip_annual_sum = predictions_from_cmip_sum.groupby(['Year','District']).sum().reset_index() - filtered_predictions = predictions_from_cmip_sum[predictions_from_cmip_sum['Precipitation'] >= precipitation_threshold] for year in year_groupings: - subset_filtered = filtered_predictions[ - (filtered_predictions['Year'] >= year) & (filtered_predictions['Year'] <= year + 5) - ] - subset_total = predictions_from_cmip_annual_sum[ - (predictions_from_cmip_annual_sum['Year'] >= year) & (predictions_from_cmip_annual_sum['Year'] <= year + 5) - ] - for _, row in subset_filtered.iterrows(): + subset = predictions_from_cmip_sum[ + (predictions_from_cmip_sum['Year'] >= year) & + (predictions_from_cmip_sum['Year'] <= year + 5) + ] + for _, row in subset.iterrows(): district = row['District'] - if pd.isna(district) or district == '': - continue - percentage_diff_filtered = row['Percentage_Difference'] + percentage_diff = row['Percentage_Difference'] row_index = births_model_subset.index.get_loc(year) - population_proportion_for_district = population_proportion[district] - number_of_pregancies= (population_proportion_for_district * births_model_subset.iloc[row_index]["Model_mean"])/12 # cos for each month - if year not in percentage_diff_by_year_district_top_10: - percentage_diff_by_year_district_top_10[year] = {} - if district not in percentage_diff_by_year_district_top_10[year]: - percentage_diff_by_year_district_top_10[year][district] = 0 - percentage_diff_by_year_district_top_10[year][district] += (percentage_diff_filtered * number_of_pregancies) * 1.4 - percentage_diff_by_year_district_top_10_scenario[scenario][model_type] += (percentage_diff_filtered * number_of_pregancies) * 1.4 - percentage_diff_by_year_district_top_10_all[scenario][model_type] = percentage_diff_by_year_district_top_10 - data_for_plot = pd.DataFrame.from_dict(percentage_diff_by_year_district_top_10, orient='index').fillna(0) + + number_of_births = population_proportion[district] * births_model_subset.iloc[row_index]["Model_mean"] + if year not in percentage_diff_by_year_district: + percentage_diff_by_year_district[year] = {} + if district not in percentage_diff_by_year_district[year]: + percentage_diff_by_year_district[year][district] = 0 + percentage_diff_by_year_district[year][district] += ((percentage_diff * number_of_births) * 1.4)/(number_of_births*1.4) * 1000 # 1.4 is conversion factor between births and pregancies + percentage_diff_by_year_district_scenario[scenario][model_type] = (percentage_diff * number_of_births) * 1.4 + + data_for_plot = pd.DataFrame.from_dict(percentage_diff_by_year_district, orient='index').fillna(0) y_min = min(y_min, data_for_plot.min().min()) y_max = max(y_max, data_for_plot.max().max()) x_min = min(x_min, data_for_plot.index.min()) @@ -404,19 +411,18 @@ ax.set_xlabel('Year', fontsize=12) if j == 0: ax.set_ylabel('Deficit of ANC services', fontsize=12) - if (i == 0) & (j == 2): - ax.legend(title="Districts", fontsize=10, title_fontsize=10, bbox_to_anchor=(1., 1)) - + #if (i == 0) & (j == 2): + # ax.legend(title="Districts", fontsize=10, title_fontsize=10, bbox_to_anchor=(1., 1)) + percentage_diff_by_year_district_all[scenario][model_type] = percentage_diff_by_year_district for ax in axes.flatten(): - ax.set_ylim(y_min * 9, y_max) - + ax.set_ylim(y_min*15, y_max) handles, labels = ax.get_legend_handles_labels() -fig.legend(handles, labels, bbox_to_anchor=(1, -10), loc="center right", fontsize=10, title="Districts") +fig.legend(handles, labels, bbox_to_anchor=(1, -10), loc = "center right", fontsize=10, title="Districts") plt.tight_layout() -plt.savefig(results_folder_to_save / 'stacked_bar_percentage_difference_5_years_grid_single_legend_with_births_extreme_precip.png') -plt.show() - - +plt.savefig(results_folder_to_save / 'stacked_bar_percentage_difference_5_years_grid_single_legend_with_births_per_1000.png') +#plt.show() +# +# ####### Historical disruptions ########## From 043e6780b831403e11ff758985a9b177551c17c4 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 21 Jan 2025 12:43:34 +0000 Subject: [PATCH 217/291] Annual summary of precip by model for scenario --- .../plotting_heavy_precipitation.py | 229 ++++++++++++------ 1 file changed, 161 insertions(+), 68 deletions(-) diff --git a/src/scripts/climate_change/plotting_heavy_precipitation.py b/src/scripts/climate_change/plotting_heavy_precipitation.py index 17f57a3a98..3799bccd71 100644 --- a/src/scripts/climate_change/plotting_heavy_precipitation.py +++ b/src/scripts/climate_change/plotting_heavy_precipitation.py @@ -17,77 +17,170 @@ days_in_month = dates.to_series().dt.days_in_month era5_data_xr_until_2024 = era5_data_xr_until_2024 * days_in_month.values era5_precipitation_data = era5_data_xr_until_2024['tp'].resample(date='Y').sum('date') -print(era5_precipitation_data) -# Plot ERA5 annual precipitation data -plt.plot(era5_precipitation_data * 1000, color="blue", linewidth=2, linestyle='--', marker='s', markersize=4, label='ERA5') -plt.show() -# +# print(era5_precipitation_data) +# # Plot ERA5 annual precipitation data +# plt.plot(era5_precipitation_data * 1000, color="blue", linewidth=2, linestyle='--', marker='s', markersize=4, label='ERA5') +# plt.show() +# # # Load CMIP6 downscaled data base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data" -scenario = "ssp585" -scenario_directory = os.path.join(base_dir, scenario) -file_path_downscaled = f"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/CIL_subsetted_all_model_{scenario}.nc" -data_all_models = xr.open_dataset(file_path_downscaled) - -pr_aggregated = data_all_models.mean(dim=["model", 'lat', 'lon'], skipna=True) -pr_aggregated_annual = pr_aggregated['pr'].resample(time='Y').sum('time') - -std_pr = pr_aggregated_annual.std(dim=["model", 'lat', 'lon'], skipna=True) -std_pr_annual = std_pr['pr'].resample(time='Y').sum('time') - -# Print results -upper_bound = pr_aggregated_annual + std_pr_annual -lower_bound = pr_aggregated_annual - std_pr_annual +scenarios = ["ssp126", "ssp245", "ssp585"] -# Plot annual precipitation with confidence interval -plt.figure(figsize=(10, 6)) -plt.plot(pr_aggregated_annual, color="blue", linewidth=2, linestyle='--', marker='s', markersize=4, label='Annual Precipitation') -plt.fill_between(range(0,len(pr_aggregated_annual)), lower_bound.values, upper_bound.values, color="blue", alpha=0.2, label="95% Confidence Interval") +for scenario in scenarios: + scenario_directory = os.path.join(base_dir, scenario) + file_path_downscaled = f"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/CIL_combined_{scenario}_2025_2070.nc" + data_all_models = xr.open_dataset(file_path_downscaled) -# Labels and title -plt.xlabel("Time") -plt.ylabel("Annual Precipitation (mm)") -plt.title(f"Annual Precipitation for {scenario} (with 95% Confidence Interval)") -plt.legend() -plt.show() + plt.figure(figsize=(12, 8)) -## Plot together -plt.figure(figsize=(12, 7)) - -plt.plot( - range(0, len(era5_precipitation_data)), - era5_precipitation_data * 1000, - color="#1C6E8C", - linewidth=2, - linestyle='--', - marker='o', - markersize=6, - label='ERA5 Precipitation', -) - -plt.plot( - range(len(era5_precipitation_data) , len(era5_precipitation_data) + len(pr_aggregated_annual) - 1), - pr_aggregated_annual[:-1], - color="#9AC4F8", - linewidth=2, - linestyle='-', - marker='s', - markersize=6, - label=f'CMIP6 Scenario {scenario}', -) - -plt.fill_between( - range(len(era5_precipitation_data), len(era5_precipitation_data) + len(pr_aggregated_annual)), - lower_bound.values, - upper_bound.values, - color="#9AC4F8", - alpha=0.3, -) -years = np.arange(2011, 2071, 5) # Array of years from 2011 to 2070 -plt.xticks(np.linspace(0, len(era5_precipitation_data) + len(pr_aggregated_annual) - 1, len(years)), years) -plt.xlabel("Time (Years)", fontsize=14, labelpad=10) -plt.ylabel("Annual Precipitation (mm)", fontsize=14, labelpad=10) -plt.legend(loc="upper left", fontsize=12, frameon=True, shadow=True, fancybox=True) -plt.tight_layout() -plt.show() + for model in data_all_models['model'].values: + model_data = data_all_models.sel(model=model) + pr_aggregated = model_data.mean(dim=['lat', 'lon'], skipna=True) + model_annual_precip = pr_aggregated['pr'].resample(time='YE').sum('time') + plt.plot(range(len(model_annual_precip)), model_annual_precip, alpha=0.5, label=f'{model}') + plt.legend() + plt.show() +# +# pr_aggregated = data_all_models.mean(dim=['lat', 'lon','model'], skipna=True) +# pr_aggregated_annual = pr_aggregated['pr'].resample(time='YE').sum('time') +# std_pr = data_all_models.std(dim=['lat', 'lon',"model"], skipna=True) +# std_pr_annual = std_pr['pr'].resample(time='YE').sum('time') +# +# +# # Print results +# upper_bound = pr_aggregated_annual + std_pr_annual +# lower_bound = pr_aggregated_annual - std_pr_annual +# +# # Plot annual precipitation with confidence interval +# plt.plot(pr_aggregated_annual, color="black", linewidth=2, linestyle='--', marker='s', markersize=4, label='Annual Precipitation') +# #plt.fill_between(range(0,len(pr_aggregated_annual)), lower_bound.values, upper_bound.values, color="blue", alpha=0.2, label="95% Confidence Interval") +# +# # Labels and title +# plt.xlabel("Time") +# plt.ylabel("Annual Precipitation (mm)") +# plt.title(f"Annual Precipitation for {scenario} (with 95% Confidence Interval)") +# plt.legend() +# plt.show() +# +# ## Plot together +# plt.figure(figsize=(12, 7)) +# +# plt.plot( +# range(0, len(era5_precipitation_data)), +# era5_precipitation_data * 1000, +# color="#1C6E8C", +# linewidth=2, +# linestyle='--', +# marker='o', +# markersize=6, +# label='ERA5 Precipitation', +# ) +# +# plt.plot( +# range(len(era5_precipitation_data) , len(era5_precipitation_data) + len(pr_aggregated_annual) - 1), +# pr_aggregated_annual[:-1], +# color="#9AC4F8", +# linewidth=2, +# linestyle='-', +# marker='s', +# markersize=6, +# label=f'CMIP6 Scenario {scenario}', +# ) +# +# plt.fill_between( +# range(len(era5_precipitation_data), len(era5_precipitation_data) + len(pr_aggregated_annual)), +# lower_bound.values, +# upper_bound.values, +# color="#9AC4F8", +# alpha=0.3, +# ) +# years = np.arange(2011, 2071, 5) # Array of years from 2011 to 2070 +# plt.xticks(np.linspace(0, len(era5_precipitation_data) + len(pr_aggregated_annual) - 1, len(years)), years) +# plt.xlabel("Time (Years)", fontsize=14, labelpad=10) +# plt.ylabel("Annual Precipitation (mm)", fontsize=14, labelpad=10) +# plt.legend(loc="upper left", fontsize=12, frameon=True, shadow=True, fancybox=True) +# plt.tight_layout() +# plt.show() +# +# +# #### Now plot all +# +# base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/" +# +# scenarios = ["ssp129", "ssp245", "ssp585"] +# # Put all into one csv file +# file_list = glob.glob(os.path.join(base_dir, "*.nc")) +# data_by_model_and_grid = {} +# +# for scenario in scenarios: +# print(scenario) +# scenario_directory = os.path.join(base_dir, scenario) +# nc_file_directory = os.path.join(scenario_directory, 'nc_files') +# grid_centroids = {} +# for file in glob.glob(os.path.join(nc_file_directory, "*.nc")): +# model = re.search(r'pr_day_(.*?)_' + scenario.replace('_', ''), file).group(1) +# data_per_model = Dataset(file, mode='r') +# pr_aggregated = data_all_models.mean(dim=['lat', 'lon', 'model'], skipna=True) +# pr_aggregated_annual = pr_aggregated['pr'].resample(time='YE').sum('time') +# std_pr = data_all_models.std(dim=['lat', 'lon', "model"], skipna=True) +# std_pr_annual = std_pr['pr'].resample(time='Y').sum('time') +# +# # Print results +# upper_bound = pr_aggregated_annual + std_pr_annual +# lower_bound = pr_aggregated_annual - std_pr_annual +# +# # Plot annual precipitation with confidence interval +# plt.figure(figsize=(10, 6)) +# plt.plot(pr_aggregated_annual, color="blue", linewidth=2, linestyle='--', marker='s', markersize=4, +# label='Annual Precipitation') +# plt.fill_between(range(0, len(pr_aggregated_annual)), lower_bound.values, upper_bound.values, color="blue", +# alpha=0.2, label="95% Confidence Interval") +# +# # Labels and title +# plt.xlabel("Time") +# plt.ylabel("Annual Precipitation (mm)") +# plt.title(f"Annual Precipitation for {scenario} (with 95% Confidence Interval)") +# plt.legend() +# plt.show() +# +# ## Plot together +# plt.figure(figsize=(12, 7)) +# +# plt.plot( +# range(0, len(era5_precipitation_data)), +# era5_precipitation_data * 1000, +# color="#1C6E8C", +# linewidth=2, +# linestyle='--', +# marker='o', +# markersize=6, +# label='ERA5 Precipitation', +# ) +# +# plt.plot( +# range(len(era5_precipitation_data), len(era5_precipitation_data) + len(pr_aggregated_annual) - 1), +# pr_aggregated_annual[:-1], +# color="#9AC4F8", +# linewidth=2, +# linestyle='-', +# marker='s', +# markersize=6, +# label=f'CMIP6 Scenario {scenario}', +# ) +# +# plt.fill_between( +# range(len(era5_precipitation_data), len(era5_precipitation_data) + len(pr_aggregated_annual)), +# lower_bound.values, +# upper_bound.values, +# color="#9AC4F8", +# alpha=0.3, +# ) +# years = np.arange(2011, 2071, 5) # Array of years from 2011 to 2070 +# plt.xticks(np.linspace(0, len(era5_precipitation_data) + len(pr_aggregated_annual) - 1, len(years)), years) +# plt.xlabel("Time (Years)", fontsize=14, labelpad=10) +# plt.ylabel("Annual Precipitation (mm)", fontsize=14, labelpad=10) +# plt.legend(loc="upper left", fontsize=12, frameon=True, shadow=True, fancybox=True) +# plt.tight_layout() +# plt.show() +# From 93d0938b5d00dadfc912bb586a8ba092e317082a Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 21 Jan 2025 12:43:55 +0000 Subject: [PATCH 218/291] Added column --- src/scripts/climate_change/grid_malawi_CMIP6.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/scripts/climate_change/grid_malawi_CMIP6.py b/src/scripts/climate_change/grid_malawi_CMIP6.py index b545c6dccf..00c7a6855d 100644 --- a/src/scripts/climate_change/grid_malawi_CMIP6.py +++ b/src/scripts/climate_change/grid_malawi_CMIP6.py @@ -82,7 +82,6 @@ pr_data = data_per_model.variables['pr'][:] # in kg m-2 s-1 = mm s-1 x 86400 to get to day lat_data = data_per_model.variables['lat'][:] long_data = data_per_model.variables['lon'][:] - print(colors(idx)) for lon in long_data: ax.axvline(x=lon, color=colors(idx), linestyle='--', linewidth=0.5) for lat in lat_data: @@ -93,7 +92,7 @@ ax.set_ylabel('Latitude') -#plt.show() +plt.show() # Add in facility information @@ -104,7 +103,7 @@ long_format = expanded_facility_info.T.reset_index() long_format.columns = [ - 'Facility', 'Zonename', 'Resid', 'A105', 'A109__Altitude', 'Ftype', + 'Facility', 'Zonename', 'Dist', 'Resid', 'A105', 'A109__Altitude', 'Ftype', 'A109__Latitude', 'A109__Longitude', 'minimum_distance', 'average_precipitation' ] From c70555dc3b94755ebb9e0dc292e3e2e193486f44 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 21 Jan 2025 15:09:34 +0000 Subject: [PATCH 219/291] Added plot of all models over years --- .../plotting_heavy_precipitation.py | 245 +++++++----------- 1 file changed, 94 insertions(+), 151 deletions(-) diff --git a/src/scripts/climate_change/plotting_heavy_precipitation.py b/src/scripts/climate_change/plotting_heavy_precipitation.py index 3799bccd71..7a7d8465a4 100644 --- a/src/scripts/climate_change/plotting_heavy_precipitation.py +++ b/src/scripts/climate_change/plotting_heavy_precipitation.py @@ -25,162 +25,105 @@ # Load CMIP6 downscaled data base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data" scenarios = ["ssp126", "ssp245", "ssp585"] +# +# for scenario in scenarios: +# scenario_directory = os.path.join(base_dir, scenario) +# file_path_downscaled = f"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/CIL_combined_{scenario}_2024_2070.nc" +# data_all_models = xr.open_dataset(file_path_downscaled) +# +# plt.figure(figsize=(12, 8)) +# +# for model in data_all_models['model'].values: +# model_data = data_all_models.sel(model=model) +# pr_aggregated = model_data.mean(dim=['lat', 'lon'], skipna=True) +# model_annual_precip = pr_aggregated['pr'].resample(time='YE').sum('time') +# plt.plot(range(len(model_annual_precip)), model_annual_precip, alpha=0.5, label=f'{model}') +# plt.legend() +# plt.show() -for scenario in scenarios: + +fig, axes = plt.subplots(1, 3, figsize=(18, 6), sharex=True, sharey=True) +axes = axes.flatten() + +for i, scenario in enumerate(scenarios): scenario_directory = os.path.join(base_dir, scenario) - file_path_downscaled = f"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/CIL_combined_{scenario}_2025_2070.nc" + file_path_downscaled = f"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/CIL_combined_{scenario}_2024_2070.nc" data_all_models = xr.open_dataset(file_path_downscaled) - - plt.figure(figsize=(12, 8)) + pr_aggregated_mean = data_all_models.mean(dim=['lat', 'lon', 'model'], skipna=True) + model_annual_precip = pr_aggregated_mean['pr'].resample(time='YE').sum('time') for model in data_all_models['model'].values: model_data = data_all_models.sel(model=model) pr_aggregated = model_data.mean(dim=['lat', 'lon'], skipna=True) - model_annual_precip = pr_aggregated['pr'].resample(time='YE').sum('time') - plt.plot(range(len(model_annual_precip)), model_annual_precip, alpha=0.5, label=f'{model}') - plt.legend() - plt.show() -# -# pr_aggregated = data_all_models.mean(dim=['lat', 'lon','model'], skipna=True) -# pr_aggregated_annual = pr_aggregated['pr'].resample(time='YE').sum('time') -# std_pr = data_all_models.std(dim=['lat', 'lon',"model"], skipna=True) -# std_pr_annual = std_pr['pr'].resample(time='YE').sum('time') -# -# -# # Print results -# upper_bound = pr_aggregated_annual + std_pr_annual -# lower_bound = pr_aggregated_annual - std_pr_annual -# -# # Plot annual precipitation with confidence interval -# plt.plot(pr_aggregated_annual, color="black", linewidth=2, linestyle='--', marker='s', markersize=4, label='Annual Precipitation') -# #plt.fill_between(range(0,len(pr_aggregated_annual)), lower_bound.values, upper_bound.values, color="blue", alpha=0.2, label="95% Confidence Interval") -# -# # Labels and title -# plt.xlabel("Time") -# plt.ylabel("Annual Precipitation (mm)") -# plt.title(f"Annual Precipitation for {scenario} (with 95% Confidence Interval)") -# plt.legend() -# plt.show() -# -# ## Plot together -# plt.figure(figsize=(12, 7)) -# -# plt.plot( -# range(0, len(era5_precipitation_data)), -# era5_precipitation_data * 1000, -# color="#1C6E8C", -# linewidth=2, -# linestyle='--', -# marker='o', -# markersize=6, -# label='ERA5 Precipitation', -# ) -# -# plt.plot( -# range(len(era5_precipitation_data) , len(era5_precipitation_data) + len(pr_aggregated_annual) - 1), -# pr_aggregated_annual[:-1], -# color="#9AC4F8", -# linewidth=2, -# linestyle='-', -# marker='s', -# markersize=6, -# label=f'CMIP6 Scenario {scenario}', -# ) -# -# plt.fill_between( -# range(len(era5_precipitation_data), len(era5_precipitation_data) + len(pr_aggregated_annual)), -# lower_bound.values, -# upper_bound.values, -# color="#9AC4F8", -# alpha=0.3, -# ) -# years = np.arange(2011, 2071, 5) # Array of years from 2011 to 2070 -# plt.xticks(np.linspace(0, len(era5_precipitation_data) + len(pr_aggregated_annual) - 1, len(years)), years) -# plt.xlabel("Time (Years)", fontsize=14, labelpad=10) -# plt.ylabel("Annual Precipitation (mm)", fontsize=14, labelpad=10) -# plt.legend(loc="upper left", fontsize=12, frameon=True, shadow=True, fancybox=True) -# plt.tight_layout() -# plt.show() -# -# -# #### Now plot all -# -# base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/" -# -# scenarios = ["ssp129", "ssp245", "ssp585"] -# # Put all into one csv file -# file_list = glob.glob(os.path.join(base_dir, "*.nc")) -# data_by_model_and_grid = {} -# -# for scenario in scenarios: -# print(scenario) -# scenario_directory = os.path.join(base_dir, scenario) -# nc_file_directory = os.path.join(scenario_directory, 'nc_files') -# grid_centroids = {} -# for file in glob.glob(os.path.join(nc_file_directory, "*.nc")): -# model = re.search(r'pr_day_(.*?)_' + scenario.replace('_', ''), file).group(1) -# data_per_model = Dataset(file, mode='r') -# pr_aggregated = data_all_models.mean(dim=['lat', 'lon', 'model'], skipna=True) -# pr_aggregated_annual = pr_aggregated['pr'].resample(time='YE').sum('time') -# std_pr = data_all_models.std(dim=['lat', 'lon', "model"], skipna=True) -# std_pr_annual = std_pr['pr'].resample(time='Y').sum('time') -# -# # Print results -# upper_bound = pr_aggregated_annual + std_pr_annual -# lower_bound = pr_aggregated_annual - std_pr_annual -# -# # Plot annual precipitation with confidence interval -# plt.figure(figsize=(10, 6)) -# plt.plot(pr_aggregated_annual, color="blue", linewidth=2, linestyle='--', marker='s', markersize=4, -# label='Annual Precipitation') -# plt.fill_between(range(0, len(pr_aggregated_annual)), lower_bound.values, upper_bound.values, color="blue", -# alpha=0.2, label="95% Confidence Interval") -# -# # Labels and title -# plt.xlabel("Time") -# plt.ylabel("Annual Precipitation (mm)") -# plt.title(f"Annual Precipitation for {scenario} (with 95% Confidence Interval)") -# plt.legend() -# plt.show() -# -# ## Plot together -# plt.figure(figsize=(12, 7)) -# -# plt.plot( -# range(0, len(era5_precipitation_data)), -# era5_precipitation_data * 1000, -# color="#1C6E8C", -# linewidth=2, -# linestyle='--', -# marker='o', -# markersize=6, -# label='ERA5 Precipitation', -# ) -# -# plt.plot( -# range(len(era5_precipitation_data), len(era5_precipitation_data) + len(pr_aggregated_annual) - 1), -# pr_aggregated_annual[:-1], -# color="#9AC4F8", -# linewidth=2, -# linestyle='-', -# marker='s', -# markersize=6, -# label=f'CMIP6 Scenario {scenario}', -# ) -# -# plt.fill_between( -# range(len(era5_precipitation_data), len(era5_precipitation_data) + len(pr_aggregated_annual)), -# lower_bound.values, -# upper_bound.values, -# color="#9AC4F8", -# alpha=0.3, -# ) -# years = np.arange(2011, 2071, 5) # Array of years from 2011 to 2070 -# plt.xticks(np.linspace(0, len(era5_precipitation_data) + len(pr_aggregated_annual) - 1, len(years)), years) -# plt.xlabel("Time (Years)", fontsize=14, labelpad=10) -# plt.ylabel("Annual Precipitation (mm)", fontsize=14, labelpad=10) -# plt.legend(loc="upper left", fontsize=12, frameon=True, shadow=True, fancybox=True) -# plt.tight_layout() -# plt.show() -# + axes[i].plot( + range(len(model_annual_precip)), + model_annual_precip, + alpha=0.5, + label=f'{model}' + ) + + axes[i].plot( + range(len(model_annual_precip)), + model_annual_precip, + label="Mean", + color = 'black' + ) + axes[i].set_title(scenario.upper()) + axes[i].set_xlabel('Year') + #axes[i].legend(fontsize='small') + +fig.text(0.04, 0.5, 'Annual Precipitation (mm)', va='center', rotation='vertical') + +plt.tight_layout() +plt.show() + +## Plot 95% CI + +fig, axes = plt.subplots(1, 3, figsize=(18, 6), sharex=True, sharey=True) +axes = axes.flatten() + +for i, scenario in enumerate(scenarios): + scenario_directory = os.path.join(base_dir, scenario) + file_path_downscaled = f"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/CIL_combined_{scenario}_2024_2070.nc" + data_all_models = xr.open_dataset(file_path_downscaled) + pr_aggregated_mean = data_all_models.mean(dim=['lat', 'lon', 'model'], skipna=True) + model_annual_precip = pr_aggregated_mean['pr'].resample(time='YE').sum('time') + std_pr = data_all_models.std(dim=['lat', 'lon', "model"], skipna=True) + print(std_pr) + std_pr_annual = std_pr['pr'].resample(time='YE').sum('time') + upper_bound = model_annual_precip + std_pr_annual + lower_bound = model_annual_precip - std_pr_annual + + axes[i].plot( + range(0, len(era5_precipitation_data)), + era5_precipitation_data * 1000, + color="#1C6E8C", + linewidth=2, + linestyle='--', + marker='o', + markersize=6, + label='ERA5 Precipitation', + ) + + axes[i].plot( + range(len(era5_precipitation_data),len(era5_precipitation_data) +len(model_annual_precip)), + model_annual_precip, + label="Ensemble mean", + color = 'black' + ) + axes[i].fill_between( + range(len(era5_precipitation_data), len(era5_precipitation_data) + len(model_annual_precip)), + lower_bound.values, + upper_bound.values, + color="#9AC4F8", + alpha=0.3, +) + axes[i].set_title(scenario.upper()) + axes[i].set_xlabel('Year') + #axes[i].legend(fontsize='small') + +fig.text(0.04, 0.5, 'Annual Precipitation (mm)', va='center', rotation='vertical') + +plt.tight_layout() +plt.show() From 496c1f94af751608ae942cb78c2245e6194cee0f Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 22 Jan 2025 09:41:51 +0000 Subject: [PATCH 220/291] Ensured now from 2024 Also reduced the printing frequency --- .../CIL_CMIP6_downscaling.ipynb | 11185 +++++++++++----- 1 file changed, 8014 insertions(+), 3171 deletions(-) diff --git a/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb b/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb index 5dd9545109..4bd1e2f66a 100644 --- a/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb +++ b/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb @@ -9,8 +9,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-15T15:02:46.479922Z", - "start_time": "2025-01-15T15:02:44.703013Z" + "end_time": "2025-01-21T15:25:44.967657Z", + "start_time": "2025-01-21T15:25:43.119103Z" } }, "cell_type": "code", @@ -826,8 +826,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-15T15:02:49.730238Z", - "start_time": "2025-01-15T15:02:49.541667Z" + "end_time": "2025-01-21T15:25:47.737030Z", + "start_time": "2025-01-21T15:25:47.501189Z" } }, "cell_type": "code", @@ -856,7 +856,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/700573990.py:16: DtypeWarning: Columns (58,59,105,127,136,142,149,150,258,285,296,319,344,345,360,393,394,427,428,437,449,450,452,453,461,462,478,479,489,490,492,493,494,497,498,499,500,501,502,503,572,580,585,586,587,588,591,592,593,594,607,608,609,610,619,620,621,622,626,634,872,887,967,978,1066,1510) have mixed types. Specify dtype option on import or set low_memory=False.\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/3940996484.py:16: DtypeWarning: Columns (58,59,105,127,136,142,149,150,258,285,296,319,344,345,360,393,394,427,428,437,449,450,452,453,461,462,478,479,489,490,492,493,494,497,498,499,500,501,502,503,572,580,585,586,587,588,591,592,593,594,607,608,609,610,619,620,621,622,626,634,872,887,967,978,1066,1510) have mixed types. Specify dtype option on import or set low_memory=False.\n", " facilities_with_lat_long = pd.read_csv(\n" ] } @@ -866,8 +866,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-15T15:02:50.454125Z", - "start_time": "2025-01-15T15:02:50.446189Z" + "end_time": "2025-01-21T15:25:48.382454Z", + "start_time": "2025-01-21T15:25:48.377103Z" } }, "cell_type": "code", @@ -948,8 +948,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-16T09:01:09.883037Z", - "start_time": "2025-01-16T08:50:46.687380Z" + "end_time": "2025-01-21T16:52:30.692579Z", + "start_time": "2025-01-21T15:25:49.979744Z" } }, "cell_type": "code", @@ -1090,966 +1090,956 @@ "output_type": "stream", "text": [ "Processing scenario: ssp126\n", - "Models of interest ['HadGEM3-GC31-LL', 'UKESM1-0-LL', 'INM-CM5-0']\n", + "Saved combined dataset for ssp126 to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/CIL_combined_ssp126_2024_2070.nc\n", + "Models of interest ['HadGEM3-GC31-LL', 'MPI-ESM1-2-LR', 'INM-CM5-0']\n", "Processing file: CIL_subset_ssp126_2024.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2024, month 1\n", - "Processing year 2024, month 2\n", - "Processing year 2024, month 3\n", - "Processing year 2024, month 4\n", - "Processing year 2024, month 5\n", - "Processing year 2024, month 6\n", - "Processing year 2024, month 7\n", - "Processing year 2024, month 8\n", - "Processing year 2024, month 9\n", - "Processing year 2024, month 10\n", - "Processing year 2024, month 11\n", - "Processing year 2024, month 12\n" + "Processing year 2024\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" ] }, @@ -2057,964 +2047,953 @@ "name": "stdout", "output_type": "stream", "text": [ - "Processing model: UKESM1-0-LL\n", - "Processing year 2024, month 1\n", - "Processing year 2024, month 2\n", - "Processing year 2024, month 3\n", - "Processing year 2024, month 4\n", - "Processing year 2024, month 5\n", - "Processing year 2024, month 6\n", - "Processing year 2024, month 7\n", - "Processing year 2024, month 8\n", - "Processing year 2024, month 9\n", - "Processing year 2024, month 10\n", - "Processing year 2024, month 11\n", - "Processing year 2024, month 12\n" + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2024\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" ] }, @@ -3023,963 +3002,952 @@ "output_type": "stream", "text": [ "Processing model: INM-CM5-0\n", - "Processing year 2024, month 1\n", - "Processing year 2024, month 2\n", - "Processing year 2024, month 3\n", - "Processing year 2024, month 4\n", - "Processing year 2024, month 5\n", - "Processing year 2024, month 6\n", - "Processing year 2024, month 7\n", - "Processing year 2024, month 8\n", - "Processing year 2024, month 9\n", - "Processing year 2024, month 10\n", - "Processing year 2024, month 11\n", - "Processing year 2024, month 12\n" + "Processing year 2024\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_2374/2113464848.py:115: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" ] }, @@ -3989,1862 +3957,6737 @@ "text": [ "Processing file: CIL_subset_ssp126_2025.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2025, month 1\n", - "Processing year 2025, month 2\n", - "Processing year 2025, month 3\n", - "Processing year 2025, month 4\n", - "Processing year 2025, month 5\n", - "Processing year 2025, month 6\n", - "Processing year 2025, month 7\n", - "Processing year 2025, month 8\n", - "Processing year 2025, month 9\n", - "Processing year 2025, month 10\n", - "Processing year 2025, month 11\n", - "Processing year 2025, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2025, month 1\n", - "Processing year 2025, month 2\n", - "Processing year 2025, month 3\n", - "Processing year 2025, month 4\n", - "Processing year 2025, month 5\n", - "Processing year 2025, month 6\n", - "Processing year 2025, month 7\n", - "Processing year 2025, month 8\n", - "Processing year 2025, month 9\n", - "Processing year 2025, month 10\n", - "Processing year 2025, month 11\n", - "Processing year 2025, month 12\n", + "Processing year 2025\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2025\n", "Processing model: INM-CM5-0\n", - "Processing year 2025, month 1\n", - "Processing year 2025, month 2\n", - "Processing year 2025, month 3\n", - "Processing year 2025, month 4\n", - "Processing year 2025, month 5\n", - "Processing year 2025, month 6\n", - "Processing year 2025, month 7\n", - "Processing year 2025, month 8\n", - "Processing year 2025, month 9\n", - "Processing year 2025, month 10\n", - "Processing year 2025, month 11\n", - "Processing year 2025, month 12\n", + "Processing year 2025\n", "Processing file: CIL_subset_ssp126_2026.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2026, month 1\n", - "Processing year 2026, month 2\n", - "Processing year 2026, month 3\n", - "Processing year 2026, month 4\n", - "Processing year 2026, month 5\n", - "Processing year 2026, month 6\n", - "Processing year 2026, month 7\n", - "Processing year 2026, month 8\n", - "Processing year 2026, month 9\n", - "Processing year 2026, month 10\n", - "Processing year 2026, month 11\n", - "Processing year 2026, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2026, month 1\n", - "Processing year 2026, month 2\n", - "Processing year 2026, month 3\n", - "Processing year 2026, month 4\n", - "Processing year 2026, month 5\n", - "Processing year 2026, month 6\n", - "Processing year 2026, month 7\n", - "Processing year 2026, month 8\n", - "Processing year 2026, month 9\n", - "Processing year 2026, month 10\n", - "Processing year 2026, month 11\n", - "Processing year 2026, month 12\n", + "Processing year 2026\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2026\n", "Processing model: INM-CM5-0\n", - "Processing year 2026, month 1\n", - "Processing year 2026, month 2\n", - "Processing year 2026, month 3\n", - "Processing year 2026, month 4\n", - "Processing year 2026, month 5\n", - "Processing year 2026, month 6\n", - "Processing year 2026, month 7\n", - "Processing year 2026, month 8\n", - "Processing year 2026, month 9\n", - "Processing year 2026, month 10\n", - "Processing year 2026, month 11\n", - "Processing year 2026, month 12\n", + "Processing year 2026\n", "Processing file: CIL_subset_ssp126_2027.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2027, month 1\n", - "Processing year 2027, month 2\n", - "Processing year 2027, month 3\n", - "Processing year 2027, month 4\n", - "Processing year 2027, month 5\n", - "Processing year 2027, month 6\n", - "Processing year 2027, month 7\n", - "Processing year 2027, month 8\n", - "Processing year 2027, month 9\n", - "Processing year 2027, month 10\n", - "Processing year 2027, month 11\n", - "Processing year 2027, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2027, month 1\n", - "Processing year 2027, month 2\n", - "Processing year 2027, month 3\n", - "Processing year 2027, month 4\n", - "Processing year 2027, month 5\n", - "Processing year 2027, month 6\n", - "Processing year 2027, month 7\n", - "Processing year 2027, month 8\n", - "Processing year 2027, month 9\n", - "Processing year 2027, month 10\n", - "Processing year 2027, month 11\n", - "Processing year 2027, month 12\n", + "Processing year 2027\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2027\n", "Processing model: INM-CM5-0\n", - "Processing year 2027, month 1\n", - "Processing year 2027, month 2\n", - "Processing year 2027, month 3\n", - "Processing year 2027, month 4\n", - "Processing year 2027, month 5\n", - "Processing year 2027, month 6\n", - "Processing year 2027, month 7\n", - "Processing year 2027, month 8\n", - "Processing year 2027, month 9\n", - "Processing year 2027, month 10\n", - "Processing year 2027, month 11\n", - "Processing year 2027, month 12\n", + "Processing year 2027\n", "Processing file: CIL_subset_ssp126_2028.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2028, month 1\n", - "Processing year 2028, month 2\n", - "Processing year 2028, month 3\n", - "Processing year 2028, month 4\n", - "Processing year 2028, month 5\n", - "Processing year 2028, month 6\n", - "Processing year 2028, month 7\n", - "Processing year 2028, month 8\n", - "Processing year 2028, month 9\n", - "Processing year 2028, month 10\n", - "Processing year 2028, month 11\n", - "Processing year 2028, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2028, month 1\n", - "Processing year 2028, month 2\n", - "Processing year 2028, month 3\n", - "Processing year 2028, month 4\n", - "Processing year 2028, month 5\n", - "Processing year 2028, month 6\n", - "Processing year 2028, month 7\n", - "Processing year 2028, month 8\n", - "Processing year 2028, month 9\n", - "Processing year 2028, month 10\n", - "Processing year 2028, month 11\n", - "Processing year 2028, month 12\n", + "Processing year 2028\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2028\n", "Processing model: INM-CM5-0\n", - "Processing year 2028, month 1\n", - "Processing year 2028, month 2\n", - "Processing year 2028, month 3\n", - "Processing year 2028, month 4\n", - "Processing year 2028, month 5\n", - "Processing year 2028, month 6\n", - "Processing year 2028, month 7\n", - "Processing year 2028, month 8\n", - "Processing year 2028, month 9\n", - "Processing year 2028, month 10\n", - "Processing year 2028, month 11\n", - "Processing year 2028, month 12\n", + "Processing year 2028\n", "Processing file: CIL_subset_ssp126_2029.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2029, month 1\n", - "Processing year 2029, month 2\n", - "Processing year 2029, month 3\n", - "Processing year 2029, month 4\n", - "Processing year 2029, month 5\n", - "Processing year 2029, month 6\n", - "Processing year 2029, month 7\n", - "Processing year 2029, month 8\n", - "Processing year 2029, month 9\n", - "Processing year 2029, month 10\n", - "Processing year 2029, month 11\n", - "Processing year 2029, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2029, month 1\n", - "Processing year 2029, month 2\n", - "Processing year 2029, month 3\n", - "Processing year 2029, month 4\n", - "Processing year 2029, month 5\n", - "Processing year 2029, month 6\n", - "Processing year 2029, month 7\n", - "Processing year 2029, month 8\n", - "Processing year 2029, month 9\n", - "Processing year 2029, month 10\n", - "Processing year 2029, month 11\n", - "Processing year 2029, month 12\n", + "Processing year 2029\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2029\n", "Processing model: INM-CM5-0\n", - "Processing year 2029, month 1\n", - "Processing year 2029, month 2\n", - "Processing year 2029, month 3\n", - "Processing year 2029, month 4\n", - "Processing year 2029, month 5\n", - "Processing year 2029, month 6\n", - "Processing year 2029, month 7\n", - "Processing year 2029, month 8\n", - "Processing year 2029, month 9\n", - "Processing year 2029, month 10\n", - "Processing year 2029, month 11\n", - "Processing year 2029, month 12\n", + "Processing year 2029\n", "Processing file: CIL_subset_ssp126_2030.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2030, month 1\n", - "Processing year 2030, month 2\n", - "Processing year 2030, month 3\n", - "Processing year 2030, month 4\n", - "Processing year 2030, month 5\n", - "Processing year 2030, month 6\n", - "Processing year 2030, month 7\n", - "Processing year 2030, month 8\n", - "Processing year 2030, month 9\n", - "Processing year 2030, month 10\n", - "Processing year 2030, month 11\n", - "Processing year 2030, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2030, month 1\n", - "Processing year 2030, month 2\n", - "Processing year 2030, month 3\n", - "Processing year 2030, month 4\n", - "Processing year 2030, month 5\n", - "Processing year 2030, month 6\n", - "Processing year 2030, month 7\n", - "Processing year 2030, month 8\n", - "Processing year 2030, month 9\n", - "Processing year 2030, month 10\n", - "Processing year 2030, month 11\n", - "Processing year 2030, month 12\n", + "Processing year 2030\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2030\n", "Processing model: INM-CM5-0\n", - "Processing year 2030, month 1\n", - "Processing year 2030, month 2\n", - "Processing year 2030, month 3\n", - "Processing year 2030, month 4\n", - "Processing year 2030, month 5\n", - "Processing year 2030, month 6\n", - "Processing year 2030, month 7\n", - "Processing year 2030, month 8\n", - "Processing year 2030, month 9\n", - "Processing year 2030, month 10\n", - "Processing year 2030, month 11\n", - "Processing year 2030, month 12\n", + "Processing year 2030\n", "Processing file: CIL_subset_ssp126_2031.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2031, month 1\n", - "Processing year 2031, month 2\n", - "Processing year 2031, month 3\n", - "Processing year 2031, month 4\n", - "Processing year 2031, month 5\n", - "Processing year 2031, month 6\n", - "Processing year 2031, month 7\n", - "Processing year 2031, month 8\n", - "Processing year 2031, month 9\n", - "Processing year 2031, month 10\n", - "Processing year 2031, month 11\n", - "Processing year 2031, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2031, month 1\n", - "Processing year 2031, month 2\n", - "Processing year 2031, month 3\n", - "Processing year 2031, month 4\n", - "Processing year 2031, month 5\n", - "Processing year 2031, month 6\n", - "Processing year 2031, month 7\n", - "Processing year 2031, month 8\n", - "Processing year 2031, month 9\n", - "Processing year 2031, month 10\n", - "Processing year 2031, month 11\n", - "Processing year 2031, month 12\n", + "Processing year 2031\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2031\n", "Processing model: INM-CM5-0\n", - "Processing year 2031, month 1\n", - "Processing year 2031, month 2\n", - "Processing year 2031, month 3\n", - "Processing year 2031, month 4\n", - "Processing year 2031, month 5\n", - "Processing year 2031, month 6\n", - "Processing year 2031, month 7\n", - "Processing year 2031, month 8\n", - "Processing year 2031, month 9\n", - "Processing year 2031, month 10\n", - "Processing year 2031, month 11\n", - "Processing year 2031, month 12\n", + "Processing year 2031\n", "Processing file: CIL_subset_ssp126_2032.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2032, month 1\n", - "Processing year 2032, month 2\n", - "Processing year 2032, month 3\n", - "Processing year 2032, month 4\n", - "Processing year 2032, month 5\n", - "Processing year 2032, month 6\n", - "Processing year 2032, month 7\n", - "Processing year 2032, month 8\n", - "Processing year 2032, month 9\n", - "Processing year 2032, month 10\n", - "Processing year 2032, month 11\n", - "Processing year 2032, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2032, month 1\n", - "Processing year 2032, month 2\n", - "Processing year 2032, month 3\n", - "Processing year 2032, month 4\n", - "Processing year 2032, month 5\n", - "Processing year 2032, month 6\n", - "Processing year 2032, month 7\n", - "Processing year 2032, month 8\n", - "Processing year 2032, month 9\n", - "Processing year 2032, month 10\n", - "Processing year 2032, month 11\n", - "Processing year 2032, month 12\n", + "Processing year 2032\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2032\n", "Processing model: INM-CM5-0\n", - "Processing year 2032, month 1\n", - "Processing year 2032, month 2\n", - "Processing year 2032, month 3\n", - "Processing year 2032, month 4\n", - "Processing year 2032, month 5\n", - "Processing year 2032, month 6\n", - "Processing year 2032, month 7\n", - "Processing year 2032, month 8\n", - "Processing year 2032, month 9\n", - "Processing year 2032, month 10\n", - "Processing year 2032, month 11\n", - "Processing year 2032, month 12\n", + "Processing year 2032\n", "Processing file: CIL_subset_ssp126_2033.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2033, month 1\n", - "Processing year 2033, month 2\n", - "Processing year 2033, month 3\n", - "Processing year 2033, month 4\n", - "Processing year 2033, month 5\n", - "Processing year 2033, month 6\n", - "Processing year 2033, month 7\n", - "Processing year 2033, month 8\n", - "Processing year 2033, month 9\n", - "Processing year 2033, month 10\n", - "Processing year 2033, month 11\n", - "Processing year 2033, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2033, month 1\n", - "Processing year 2033, month 2\n", - "Processing year 2033, month 3\n", - "Processing year 2033, month 4\n", - "Processing year 2033, month 5\n", - "Processing year 2033, month 6\n", - "Processing year 2033, month 7\n", - "Processing year 2033, month 8\n", - "Processing year 2033, month 9\n", - "Processing year 2033, month 10\n", - "Processing year 2033, month 11\n", - "Processing year 2033, month 12\n", + "Processing year 2033\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2033\n", "Processing model: INM-CM5-0\n", - "Processing year 2033, month 1\n", - "Processing year 2033, month 2\n", - "Processing year 2033, month 3\n", - "Processing year 2033, month 4\n", - "Processing year 2033, month 5\n", - "Processing year 2033, month 6\n", - "Processing year 2033, month 7\n", - "Processing year 2033, month 8\n", - "Processing year 2033, month 9\n", - "Processing year 2033, month 10\n", - "Processing year 2033, month 11\n", - "Processing year 2033, month 12\n", + "Processing year 2033\n", "Processing file: CIL_subset_ssp126_2034.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2034, month 1\n", - "Processing year 2034, month 2\n", - "Processing year 2034, month 3\n", - "Processing year 2034, month 4\n", - "Processing year 2034, month 5\n", - "Processing year 2034, month 6\n", - "Processing year 2034, month 7\n", - "Processing year 2034, month 8\n", - "Processing year 2034, month 9\n", - "Processing year 2034, month 10\n", - "Processing year 2034, month 11\n", - "Processing year 2034, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2034, month 1\n", - "Processing year 2034, month 2\n", - "Processing year 2034, month 3\n", - "Processing year 2034, month 4\n", - "Processing year 2034, month 5\n", - "Processing year 2034, month 6\n", - "Processing year 2034, month 7\n", - "Processing year 2034, month 8\n", - "Processing year 2034, month 9\n", - "Processing year 2034, month 10\n", - "Processing year 2034, month 11\n", - "Processing year 2034, month 12\n", + "Processing year 2034\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2034\n", "Processing model: INM-CM5-0\n", - "Processing year 2034, month 1\n", - "Processing year 2034, month 2\n", - "Processing year 2034, month 3\n", - "Processing year 2034, month 4\n", - "Processing year 2034, month 5\n", - "Processing year 2034, month 6\n", - "Processing year 2034, month 7\n", - "Processing year 2034, month 8\n", - "Processing year 2034, month 9\n", - "Processing year 2034, month 10\n", - "Processing year 2034, month 11\n", - "Processing year 2034, month 12\n", + "Processing year 2034\n", "Processing file: CIL_subset_ssp126_2035.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2035, month 1\n", - "Processing year 2035, month 2\n", - "Processing year 2035, month 3\n", - "Processing year 2035, month 4\n", - "Processing year 2035, month 5\n", - "Processing year 2035, month 6\n", - "Processing year 2035, month 7\n", - "Processing year 2035, month 8\n", - "Processing year 2035, month 9\n", - "Processing year 2035, month 10\n", - "Processing year 2035, month 11\n", - "Processing year 2035, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2035, month 1\n", - "Processing year 2035, month 2\n", - "Processing year 2035, month 3\n", - "Processing year 2035, month 4\n", - "Processing year 2035, month 5\n", - "Processing year 2035, month 6\n", - "Processing year 2035, month 7\n", - "Processing year 2035, month 8\n", - "Processing year 2035, month 9\n", - "Processing year 2035, month 10\n", - "Processing year 2035, month 11\n", - "Processing year 2035, month 12\n", + "Processing year 2035\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2035\n", "Processing model: INM-CM5-0\n", - "Processing year 2035, month 1\n", - "Processing year 2035, month 2\n", - "Processing year 2035, month 3\n", - "Processing year 2035, month 4\n", - "Processing year 2035, month 5\n", - "Processing year 2035, month 6\n", - "Processing year 2035, month 7\n", - "Processing year 2035, month 8\n", - "Processing year 2035, month 9\n", - "Processing year 2035, month 10\n", - "Processing year 2035, month 11\n", - "Processing year 2035, month 12\n", + "Processing year 2035\n", "Processing file: CIL_subset_ssp126_2036.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2036, month 1\n", - "Processing year 2036, month 2\n", - "Processing year 2036, month 3\n", - "Processing year 2036, month 4\n", - "Processing year 2036, month 5\n", - "Processing year 2036, month 6\n", - "Processing year 2036, month 7\n", - "Processing year 2036, month 8\n", - "Processing year 2036, month 9\n", - "Processing year 2036, month 10\n", - "Processing year 2036, month 11\n", - "Processing year 2036, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2036, month 1\n", - "Processing year 2036, month 2\n", - "Processing year 2036, month 3\n", - "Processing year 2036, month 4\n", - "Processing year 2036, month 5\n", - "Processing year 2036, month 6\n", - "Processing year 2036, month 7\n", - "Processing year 2036, month 8\n", - "Processing year 2036, month 9\n", - "Processing year 2036, month 10\n", - "Processing year 2036, month 11\n", - "Processing year 2036, month 12\n", + "Processing year 2036\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2036\n", "Processing model: INM-CM5-0\n", - "Processing year 2036, month 1\n", - "Processing year 2036, month 2\n", - "Processing year 2036, month 3\n", - "Processing year 2036, month 4\n", - "Processing year 2036, month 5\n", - "Processing year 2036, month 6\n", - "Processing year 2036, month 7\n", - "Processing year 2036, month 8\n", - "Processing year 2036, month 9\n", - "Processing year 2036, month 10\n", - "Processing year 2036, month 11\n", - "Processing year 2036, month 12\n", + "Processing year 2036\n", "Processing file: CIL_subset_ssp126_2037.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2037, month 1\n", - "Processing year 2037, month 2\n", - "Processing year 2037, month 3\n", - "Processing year 2037, month 4\n", - "Processing year 2037, month 5\n", - "Processing year 2037, month 6\n", - "Processing year 2037, month 7\n", - "Processing year 2037, month 8\n", - "Processing year 2037, month 9\n", - "Processing year 2037, month 10\n", - "Processing year 2037, month 11\n", - "Processing year 2037, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2037, month 1\n", - "Processing year 2037, month 2\n", - "Processing year 2037, month 3\n", - "Processing year 2037, month 4\n", - "Processing year 2037, month 5\n", - "Processing year 2037, month 6\n", - "Processing year 2037, month 7\n", - "Processing year 2037, month 8\n", - "Processing year 2037, month 9\n", - "Processing year 2037, month 10\n", - "Processing year 2037, month 11\n", - "Processing year 2037, month 12\n", + "Processing year 2037\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2037\n", "Processing model: INM-CM5-0\n", - "Processing year 2037, month 1\n", - "Processing year 2037, month 2\n", - "Processing year 2037, month 3\n", - "Processing year 2037, month 4\n", - "Processing year 2037, month 5\n", - "Processing year 2037, month 6\n", - "Processing year 2037, month 7\n", - "Processing year 2037, month 8\n", - "Processing year 2037, month 9\n", - "Processing year 2037, month 10\n", - "Processing year 2037, month 11\n", - "Processing year 2037, month 12\n", + "Processing year 2037\n", "Processing file: CIL_subset_ssp126_2038.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2038, month 1\n", - "Processing year 2038, month 2\n", - "Processing year 2038, month 3\n", - "Processing year 2038, month 4\n", - "Processing year 2038, month 5\n", - "Processing year 2038, month 6\n", - "Processing year 2038, month 7\n", - "Processing year 2038, month 8\n", - "Processing year 2038, month 9\n", - "Processing year 2038, month 10\n", - "Processing year 2038, month 11\n", - "Processing year 2038, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2038, month 1\n", - "Processing year 2038, month 2\n", - "Processing year 2038, month 3\n", - "Processing year 2038, month 4\n", - "Processing year 2038, month 5\n", - "Processing year 2038, month 6\n", - "Processing year 2038, month 7\n", - "Processing year 2038, month 8\n", - "Processing year 2038, month 9\n", - "Processing year 2038, month 10\n", - "Processing year 2038, month 11\n", - "Processing year 2038, month 12\n", + "Processing year 2038\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2038\n", "Processing model: INM-CM5-0\n", - "Processing year 2038, month 1\n", - "Processing year 2038, month 2\n", - "Processing year 2038, month 3\n", - "Processing year 2038, month 4\n", - "Processing year 2038, month 5\n", - "Processing year 2038, month 6\n", - "Processing year 2038, month 7\n", - "Processing year 2038, month 8\n", - "Processing year 2038, month 9\n", - "Processing year 2038, month 10\n", - "Processing year 2038, month 11\n", - "Processing year 2038, month 12\n", + "Processing year 2038\n", "Processing file: CIL_subset_ssp126_2039.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2039, month 1\n", - "Processing year 2039, month 2\n", - "Processing year 2039, month 3\n", - "Processing year 2039, month 4\n", - "Processing year 2039, month 5\n", - "Processing year 2039, month 6\n", - "Processing year 2039, month 7\n", - "Processing year 2039, month 8\n", - "Processing year 2039, month 9\n", - "Processing year 2039, month 10\n", - "Processing year 2039, month 11\n", - "Processing year 2039, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2039, month 1\n", - "Processing year 2039, month 2\n", - "Processing year 2039, month 3\n", - "Processing year 2039, month 4\n", - "Processing year 2039, month 5\n", - "Processing year 2039, month 6\n", - "Processing year 2039, month 7\n", - "Processing year 2039, month 8\n", - "Processing year 2039, month 9\n", - "Processing year 2039, month 10\n", - "Processing year 2039, month 11\n", - "Processing year 2039, month 12\n", + "Processing year 2039\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2039\n", "Processing model: INM-CM5-0\n", - "Processing year 2039, month 1\n", - "Processing year 2039, month 2\n", - "Processing year 2039, month 3\n", - "Processing year 2039, month 4\n", - "Processing year 2039, month 5\n", - "Processing year 2039, month 6\n", - "Processing year 2039, month 7\n", - "Processing year 2039, month 8\n", - "Processing year 2039, month 9\n", - "Processing year 2039, month 10\n", - "Processing year 2039, month 11\n", - "Processing year 2039, month 12\n", + "Processing year 2039\n", "Processing file: CIL_subset_ssp126_2040.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2040, month 1\n", - "Processing year 2040, month 2\n", - "Processing year 2040, month 3\n", - "Processing year 2040, month 4\n", - "Processing year 2040, month 5\n", - "Processing year 2040, month 6\n", - "Processing year 2040, month 7\n", - "Processing year 2040, month 8\n", - "Processing year 2040, month 9\n", - "Processing year 2040, month 10\n", - "Processing year 2040, month 11\n", - "Processing year 2040, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2040, month 1\n", - "Processing year 2040, month 2\n", - "Processing year 2040, month 3\n", - "Processing year 2040, month 4\n", - "Processing year 2040, month 5\n", - "Processing year 2040, month 6\n", - "Processing year 2040, month 7\n", - "Processing year 2040, month 8\n", - "Processing year 2040, month 9\n", - "Processing year 2040, month 10\n", - "Processing year 2040, month 11\n", - "Processing year 2040, month 12\n", + "Processing year 2040\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2040\n", "Processing model: INM-CM5-0\n", - "Processing year 2040, month 1\n", - "Processing year 2040, month 2\n", - "Processing year 2040, month 3\n", - "Processing year 2040, month 4\n", - "Processing year 2040, month 5\n", - "Processing year 2040, month 6\n", - "Processing year 2040, month 7\n", - "Processing year 2040, month 8\n", - "Processing year 2040, month 9\n", - "Processing year 2040, month 10\n", - "Processing year 2040, month 11\n", - "Processing year 2040, month 12\n", + "Processing year 2040\n", "Processing file: CIL_subset_ssp126_2041.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2041, month 1\n", - "Processing year 2041, month 2\n", - "Processing year 2041, month 3\n", - "Processing year 2041, month 4\n", - "Processing year 2041, month 5\n", - "Processing year 2041, month 6\n", - "Processing year 2041, month 7\n", - "Processing year 2041, month 8\n", - "Processing year 2041, month 9\n", - "Processing year 2041, month 10\n", - "Processing year 2041, month 11\n", - "Processing year 2041, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2041, month 1\n", - "Processing year 2041, month 2\n", - "Processing year 2041, month 3\n", - "Processing year 2041, month 4\n", - "Processing year 2041, month 5\n", - "Processing year 2041, month 6\n", - "Processing year 2041, month 7\n", - "Processing year 2041, month 8\n", - "Processing year 2041, month 9\n", - "Processing year 2041, month 10\n", - "Processing year 2041, month 11\n", - "Processing year 2041, month 12\n", + "Processing year 2041\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2041\n", "Processing model: INM-CM5-0\n", - "Processing year 2041, month 1\n", - "Processing year 2041, month 2\n", - "Processing year 2041, month 3\n", - "Processing year 2041, month 4\n", - "Processing year 2041, month 5\n", - "Processing year 2041, month 6\n", - "Processing year 2041, month 7\n", - "Processing year 2041, month 8\n", - "Processing year 2041, month 9\n", - "Processing year 2041, month 10\n", - "Processing year 2041, month 11\n", - "Processing year 2041, month 12\n", + "Processing year 2041\n", "Processing file: CIL_subset_ssp126_2042.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2042, month 1\n", - "Processing year 2042, month 2\n", - "Processing year 2042, month 3\n", - "Processing year 2042, month 4\n", - "Processing year 2042, month 5\n", - "Processing year 2042, month 6\n", - "Processing year 2042, month 7\n", - "Processing year 2042, month 8\n", - "Processing year 2042, month 9\n", - "Processing year 2042, month 10\n", - "Processing year 2042, month 11\n", - "Processing year 2042, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2042, month 1\n", - "Processing year 2042, month 2\n", - "Processing year 2042, month 3\n", - "Processing year 2042, month 4\n", - "Processing year 2042, month 5\n", - "Processing year 2042, month 6\n", - "Processing year 2042, month 7\n", - "Processing year 2042, month 8\n", - "Processing year 2042, month 9\n", - "Processing year 2042, month 10\n", - "Processing year 2042, month 11\n", - "Processing year 2042, month 12\n", + "Processing year 2042\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2042\n", "Processing model: INM-CM5-0\n", - "Processing year 2042, month 1\n", - "Processing year 2042, month 2\n", - "Processing year 2042, month 3\n", - "Processing year 2042, month 4\n", - "Processing year 2042, month 5\n", - "Processing year 2042, month 6\n", - "Processing year 2042, month 7\n", - "Processing year 2042, month 8\n", - "Processing year 2042, month 9\n", - "Processing year 2042, month 10\n", - "Processing year 2042, month 11\n", - "Processing year 2042, month 12\n", + "Processing year 2042\n", "Processing file: CIL_subset_ssp126_2043.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2043, month 1\n", - "Processing year 2043, month 2\n", - "Processing year 2043, month 3\n", - "Processing year 2043, month 4\n", - "Processing year 2043, month 5\n", - "Processing year 2043, month 6\n", - "Processing year 2043, month 7\n", - "Processing year 2043, month 8\n", - "Processing year 2043, month 9\n", - "Processing year 2043, month 10\n", - "Processing year 2043, month 11\n", - "Processing year 2043, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2043, month 1\n", - "Processing year 2043, month 2\n", - "Processing year 2043, month 3\n", - "Processing year 2043, month 4\n", - "Processing year 2043, month 5\n", - "Processing year 2043, month 6\n", - "Processing year 2043, month 7\n", - "Processing year 2043, month 8\n", - "Processing year 2043, month 9\n", - "Processing year 2043, month 10\n", - "Processing year 2043, month 11\n", - "Processing year 2043, month 12\n", + "Processing year 2043\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2043\n", "Processing model: INM-CM5-0\n", - "Processing year 2043, month 1\n", - "Processing year 2043, month 2\n", - "Processing year 2043, month 3\n", - "Processing year 2043, month 4\n", - "Processing year 2043, month 5\n", - "Processing year 2043, month 6\n", - "Processing year 2043, month 7\n", - "Processing year 2043, month 8\n", - "Processing year 2043, month 9\n", - "Processing year 2043, month 10\n", - "Processing year 2043, month 11\n", - "Processing year 2043, month 12\n", + "Processing year 2043\n", "Processing file: CIL_subset_ssp126_2044.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2044, month 1\n", - "Processing year 2044, month 2\n", - "Processing year 2044, month 3\n", - "Processing year 2044, month 4\n", - "Processing year 2044, month 5\n", - "Processing year 2044, month 6\n", - "Processing year 2044, month 7\n", - "Processing year 2044, month 8\n", - "Processing year 2044, month 9\n", - "Processing year 2044, month 10\n", - "Processing year 2044, month 11\n", - "Processing year 2044, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2044, month 1\n", - "Processing year 2044, month 2\n", - "Processing year 2044, month 3\n", - "Processing year 2044, month 4\n", - "Processing year 2044, month 5\n", - "Processing year 2044, month 6\n", - "Processing year 2044, month 7\n", - "Processing year 2044, month 8\n", - "Processing year 2044, month 9\n", - "Processing year 2044, month 10\n", - "Processing year 2044, month 11\n", - "Processing year 2044, month 12\n", + "Processing year 2044\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2044\n", "Processing model: INM-CM5-0\n", - "Processing year 2044, month 1\n", - "Processing year 2044, month 2\n", - "Processing year 2044, month 3\n", - "Processing year 2044, month 4\n", - "Processing year 2044, month 5\n", - "Processing year 2044, month 6\n", - "Processing year 2044, month 7\n", - "Processing year 2044, month 8\n", - "Processing year 2044, month 9\n", - "Processing year 2044, month 10\n", - "Processing year 2044, month 11\n", - "Processing year 2044, month 12\n", + "Processing year 2044\n", "Processing file: CIL_subset_ssp126_2045.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2045, month 1\n", - "Processing year 2045, month 2\n", - "Processing year 2045, month 3\n", - "Processing year 2045, month 4\n", - "Processing year 2045, month 5\n", - "Processing year 2045, month 6\n", - "Processing year 2045, month 7\n", - "Processing year 2045, month 8\n", - "Processing year 2045, month 9\n", - "Processing year 2045, month 10\n", - "Processing year 2045, month 11\n", - "Processing year 2045, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2045, month 1\n", - "Processing year 2045, month 2\n", - "Processing year 2045, month 3\n", - "Processing year 2045, month 4\n", - "Processing year 2045, month 5\n", - "Processing year 2045, month 6\n", - "Processing year 2045, month 7\n", - "Processing year 2045, month 8\n", - "Processing year 2045, month 9\n", - "Processing year 2045, month 10\n", - "Processing year 2045, month 11\n", - "Processing year 2045, month 12\n", + "Processing year 2045\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2045\n", "Processing model: INM-CM5-0\n", - "Processing year 2045, month 1\n", - "Processing year 2045, month 2\n", - "Processing year 2045, month 3\n", - "Processing year 2045, month 4\n", - "Processing year 2045, month 5\n", - "Processing year 2045, month 6\n", - "Processing year 2045, month 7\n", - "Processing year 2045, month 8\n", - "Processing year 2045, month 9\n", - "Processing year 2045, month 10\n", - "Processing year 2045, month 11\n", - "Processing year 2045, month 12\n", + "Processing year 2045\n", "Processing file: CIL_subset_ssp126_2046.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2046, month 1\n", - "Processing year 2046, month 2\n", - "Processing year 2046, month 3\n", - "Processing year 2046, month 4\n", - "Processing year 2046, month 5\n", - "Processing year 2046, month 6\n", - "Processing year 2046, month 7\n", - "Processing year 2046, month 8\n", - "Processing year 2046, month 9\n", - "Processing year 2046, month 10\n", - "Processing year 2046, month 11\n", - "Processing year 2046, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2046, month 1\n", - "Processing year 2046, month 2\n", - "Processing year 2046, month 3\n", - "Processing year 2046, month 4\n", - "Processing year 2046, month 5\n", - "Processing year 2046, month 6\n", - "Processing year 2046, month 7\n", - "Processing year 2046, month 8\n", - "Processing year 2046, month 9\n", - "Processing year 2046, month 10\n", - "Processing year 2046, month 11\n", - "Processing year 2046, month 12\n", + "Processing year 2046\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2046\n", "Processing model: INM-CM5-0\n", - "Processing year 2046, month 1\n", - "Processing year 2046, month 2\n", - "Processing year 2046, month 3\n", - "Processing year 2046, month 4\n", - "Processing year 2046, month 5\n", - "Processing year 2046, month 6\n", - "Processing year 2046, month 7\n", - "Processing year 2046, month 8\n", - "Processing year 2046, month 9\n", - "Processing year 2046, month 10\n", - "Processing year 2046, month 11\n", - "Processing year 2046, month 12\n", + "Processing year 2046\n", "Processing file: CIL_subset_ssp126_2047.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2047, month 1\n", - "Processing year 2047, month 2\n", - "Processing year 2047, month 3\n", - "Processing year 2047, month 4\n", - "Processing year 2047, month 5\n", - "Processing year 2047, month 6\n", - "Processing year 2047, month 7\n", - "Processing year 2047, month 8\n", - "Processing year 2047, month 9\n", - "Processing year 2047, month 10\n", - "Processing year 2047, month 11\n", - "Processing year 2047, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2047, month 1\n", - "Processing year 2047, month 2\n", - "Processing year 2047, month 3\n", - "Processing year 2047, month 4\n", - "Processing year 2047, month 5\n", - "Processing year 2047, month 6\n", - "Processing year 2047, month 7\n", - "Processing year 2047, month 8\n", - "Processing year 2047, month 9\n", - "Processing year 2047, month 10\n", - "Processing year 2047, month 11\n", - "Processing year 2047, month 12\n", + "Processing year 2047\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2047\n", "Processing model: INM-CM5-0\n", - "Processing year 2047, month 1\n", - "Processing year 2047, month 2\n", - "Processing year 2047, month 3\n", - "Processing year 2047, month 4\n", - "Processing year 2047, month 5\n", - "Processing year 2047, month 6\n", - "Processing year 2047, month 7\n", - "Processing year 2047, month 8\n", - "Processing year 2047, month 9\n", - "Processing year 2047, month 10\n", - "Processing year 2047, month 11\n", - "Processing year 2047, month 12\n", + "Processing year 2047\n", "Processing file: CIL_subset_ssp126_2048.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2048, month 1\n", - "Processing year 2048, month 2\n", - "Processing year 2048, month 3\n", - "Processing year 2048, month 4\n", - "Processing year 2048, month 5\n", - "Processing year 2048, month 6\n", - "Processing year 2048, month 7\n", - "Processing year 2048, month 8\n", - "Processing year 2048, month 9\n", - "Processing year 2048, month 10\n", - "Processing year 2048, month 11\n", - "Processing year 2048, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2048, month 1\n", - "Processing year 2048, month 2\n", - "Processing year 2048, month 3\n", - "Processing year 2048, month 4\n", - "Processing year 2048, month 5\n", - "Processing year 2048, month 6\n", - "Processing year 2048, month 7\n", - "Processing year 2048, month 8\n", - "Processing year 2048, month 9\n", - "Processing year 2048, month 10\n", - "Processing year 2048, month 11\n", - "Processing year 2048, month 12\n", + "Processing year 2048\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2048\n", "Processing model: INM-CM5-0\n", - "Processing year 2048, month 1\n", - "Processing year 2048, month 2\n", - "Processing year 2048, month 3\n", - "Processing year 2048, month 4\n", - "Processing year 2048, month 5\n", - "Processing year 2048, month 6\n", - "Processing year 2048, month 7\n", - "Processing year 2048, month 8\n", - "Processing year 2048, month 9\n", - "Processing year 2048, month 10\n", - "Processing year 2048, month 11\n", - "Processing year 2048, month 12\n", + "Processing year 2048\n", "Processing file: CIL_subset_ssp126_2049.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2049, month 1\n", - "Processing year 2049, month 2\n", - "Processing year 2049, month 3\n", - "Processing year 2049, month 4\n", - "Processing year 2049, month 5\n", - "Processing year 2049, month 6\n", - "Processing year 2049, month 7\n", - "Processing year 2049, month 8\n", - "Processing year 2049, month 9\n", - "Processing year 2049, month 10\n", - "Processing year 2049, month 11\n", - "Processing year 2049, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2049, month 1\n", - "Processing year 2049, month 2\n", - "Processing year 2049, month 3\n", - "Processing year 2049, month 4\n", - "Processing year 2049, month 5\n", - "Processing year 2049, month 6\n", - "Processing year 2049, month 7\n", - "Processing year 2049, month 8\n", - "Processing year 2049, month 9\n", - "Processing year 2049, month 10\n", - "Processing year 2049, month 11\n", - "Processing year 2049, month 12\n", + "Processing year 2049\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2049\n", "Processing model: INM-CM5-0\n", - "Processing year 2049, month 1\n", - "Processing year 2049, month 2\n", - "Processing year 2049, month 3\n", - "Processing year 2049, month 4\n", - "Processing year 2049, month 5\n", - "Processing year 2049, month 6\n", - "Processing year 2049, month 7\n", - "Processing year 2049, month 8\n", - "Processing year 2049, month 9\n", - "Processing year 2049, month 10\n", - "Processing year 2049, month 11\n", - "Processing year 2049, month 12\n", + "Processing year 2049\n", "Processing file: CIL_subset_ssp126_2050.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2050, month 1\n", - "Processing year 2050, month 2\n", - "Processing year 2050, month 3\n", - "Processing year 2050, month 4\n", - "Processing year 2050, month 5\n", - "Processing year 2050, month 6\n", - "Processing year 2050, month 7\n", - "Processing year 2050, month 8\n", - "Processing year 2050, month 9\n", - "Processing year 2050, month 10\n", - "Processing year 2050, month 11\n", - "Processing year 2050, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2050, month 1\n", - "Processing year 2050, month 2\n", - "Processing year 2050, month 3\n", - "Processing year 2050, month 4\n", - "Processing year 2050, month 5\n", - "Processing year 2050, month 6\n", - "Processing year 2050, month 7\n", - "Processing year 2050, month 8\n", - "Processing year 2050, month 9\n", - "Processing year 2050, month 10\n", - "Processing year 2050, month 11\n", - "Processing year 2050, month 12\n", + "Processing year 2050\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2050\n", "Processing model: INM-CM5-0\n", - "Processing year 2050, month 1\n", - "Processing year 2050, month 2\n", - "Processing year 2050, month 3\n", - "Processing year 2050, month 4\n", - "Processing year 2050, month 5\n", - "Processing year 2050, month 6\n", - "Processing year 2050, month 7\n", - "Processing year 2050, month 8\n", - "Processing year 2050, month 9\n", - "Processing year 2050, month 10\n", - "Processing year 2050, month 11\n", - "Processing year 2050, month 12\n", + "Processing year 2050\n", "Processing file: CIL_subset_ssp126_2051.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2051, month 1\n", - "Processing year 2051, month 2\n", - "Processing year 2051, month 3\n", - "Processing year 2051, month 4\n", - "Processing year 2051, month 5\n", - "Processing year 2051, month 6\n", - "Processing year 2051, month 7\n", - "Processing year 2051, month 8\n", - "Processing year 2051, month 9\n", - "Processing year 2051, month 10\n", - "Processing year 2051, month 11\n", - "Processing year 2051, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2051, month 1\n", - "Processing year 2051, month 2\n", - "Processing year 2051, month 3\n", - "Processing year 2051, month 4\n", - "Processing year 2051, month 5\n", - "Processing year 2051, month 6\n", - "Processing year 2051, month 7\n", - "Processing year 2051, month 8\n", - "Processing year 2051, month 9\n", - "Processing year 2051, month 10\n", - "Processing year 2051, month 11\n", - "Processing year 2051, month 12\n", + "Processing year 2051\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2051\n", "Processing model: INM-CM5-0\n", - "Processing year 2051, month 1\n", - "Processing year 2051, month 2\n", - "Processing year 2051, month 3\n", - "Processing year 2051, month 4\n", - "Processing year 2051, month 5\n", - "Processing year 2051, month 6\n", - "Processing year 2051, month 7\n", - "Processing year 2051, month 8\n", - "Processing year 2051, month 9\n", - "Processing year 2051, month 10\n", - "Processing year 2051, month 11\n", - "Processing year 2051, month 12\n", + "Processing year 2051\n", "Processing file: CIL_subset_ssp126_2052.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2052, month 1\n", - "Processing year 2052, month 2\n", - "Processing year 2052, month 3\n", - "Processing year 2052, month 4\n", - "Processing year 2052, month 5\n", - "Processing year 2052, month 6\n", - "Processing year 2052, month 7\n", - "Processing year 2052, month 8\n", - "Processing year 2052, month 9\n", - "Processing year 2052, month 10\n", - "Processing year 2052, month 11\n", - "Processing year 2052, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2052, month 1\n", - "Processing year 2052, month 2\n", - "Processing year 2052, month 3\n", - "Processing year 2052, month 4\n", - "Processing year 2052, month 5\n", - "Processing year 2052, month 6\n", - "Processing year 2052, month 7\n", - "Processing year 2052, month 8\n", - "Processing year 2052, month 9\n", - "Processing year 2052, month 10\n", - "Processing year 2052, month 11\n", - "Processing year 2052, month 12\n", + "Processing year 2052\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2052\n", "Processing model: INM-CM5-0\n", - "Processing year 2052, month 1\n", - "Processing year 2052, month 2\n", - "Processing year 2052, month 3\n", - "Processing year 2052, month 4\n", - "Processing year 2052, month 5\n", - "Processing year 2052, month 6\n", - "Processing year 2052, month 7\n", - "Processing year 2052, month 8\n", - "Processing year 2052, month 9\n", - "Processing year 2052, month 10\n", - "Processing year 2052, month 11\n", - "Processing year 2052, month 12\n", + "Processing year 2052\n", "Processing file: CIL_subset_ssp126_2053.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2053, month 1\n", - "Processing year 2053, month 2\n", - "Processing year 2053, month 3\n", - "Processing year 2053, month 4\n", - "Processing year 2053, month 5\n", - "Processing year 2053, month 6\n", - "Processing year 2053, month 7\n", - "Processing year 2053, month 8\n", - "Processing year 2053, month 9\n", - "Processing year 2053, month 10\n", - "Processing year 2053, month 11\n", - "Processing year 2053, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2053, month 1\n", - "Processing year 2053, month 2\n", - "Processing year 2053, month 3\n", - "Processing year 2053, month 4\n", - "Processing year 2053, month 5\n", - "Processing year 2053, month 6\n", - "Processing year 2053, month 7\n", - "Processing year 2053, month 8\n", - "Processing year 2053, month 9\n", - "Processing year 2053, month 10\n", - "Processing year 2053, month 11\n", - "Processing year 2053, month 12\n", + "Processing year 2053\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2053\n", "Processing model: INM-CM5-0\n", - "Processing year 2053, month 1\n", - "Processing year 2053, month 2\n", - "Processing year 2053, month 3\n", - "Processing year 2053, month 4\n", - "Processing year 2053, month 5\n", - "Processing year 2053, month 6\n", - "Processing year 2053, month 7\n", - "Processing year 2053, month 8\n", - "Processing year 2053, month 9\n", - "Processing year 2053, month 10\n", - "Processing year 2053, month 11\n", - "Processing year 2053, month 12\n", + "Processing year 2053\n", "Processing file: CIL_subset_ssp126_2054.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2054, month 1\n", - "Processing year 2054, month 2\n", - "Processing year 2054, month 3\n", - "Processing year 2054, month 4\n", - "Processing year 2054, month 5\n", - "Processing year 2054, month 6\n", - "Processing year 2054, month 7\n", - "Processing year 2054, month 8\n", - "Processing year 2054, month 9\n", - "Processing year 2054, month 10\n", - "Processing year 2054, month 11\n", - "Processing year 2054, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2054, month 1\n", - "Processing year 2054, month 2\n", - "Processing year 2054, month 3\n", - "Processing year 2054, month 4\n", - "Processing year 2054, month 5\n", - "Processing year 2054, month 6\n", - "Processing year 2054, month 7\n", - "Processing year 2054, month 8\n", - "Processing year 2054, month 9\n", - "Processing year 2054, month 10\n", - "Processing year 2054, month 11\n", - "Processing year 2054, month 12\n", + "Processing year 2054\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2054\n", "Processing model: INM-CM5-0\n", - "Processing year 2054, month 1\n", - "Processing year 2054, month 2\n", - "Processing year 2054, month 3\n", - "Processing year 2054, month 4\n", - "Processing year 2054, month 5\n", - "Processing year 2054, month 6\n", - "Processing year 2054, month 7\n", - "Processing year 2054, month 8\n", - "Processing year 2054, month 9\n", - "Processing year 2054, month 10\n", - "Processing year 2054, month 11\n", - "Processing year 2054, month 12\n", + "Processing year 2054\n", "Processing file: CIL_subset_ssp126_2055.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2055, month 1\n", - "Processing year 2055, month 2\n", - "Processing year 2055, month 3\n", - "Processing year 2055, month 4\n", - "Processing year 2055, month 5\n", - "Processing year 2055, month 6\n", - "Processing year 2055, month 7\n", - "Processing year 2055, month 8\n", - "Processing year 2055, month 9\n", - "Processing year 2055, month 10\n", - "Processing year 2055, month 11\n", - "Processing year 2055, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2055, month 1\n", - "Processing year 2055, month 2\n", - "Processing year 2055, month 3\n", - "Processing year 2055, month 4\n", - "Processing year 2055, month 5\n", - "Processing year 2055, month 6\n", - "Processing year 2055, month 7\n", - "Processing year 2055, month 8\n", - "Processing year 2055, month 9\n", - "Processing year 2055, month 10\n", - "Processing year 2055, month 11\n", - "Processing year 2055, month 12\n", + "Processing year 2055\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2055\n", "Processing model: INM-CM5-0\n", - "Processing year 2055, month 1\n", - "Processing year 2055, month 2\n", - "Processing year 2055, month 3\n", - "Processing year 2055, month 4\n", - "Processing year 2055, month 5\n", - "Processing year 2055, month 6\n", - "Processing year 2055, month 7\n", - "Processing year 2055, month 8\n", - "Processing year 2055, month 9\n", - "Processing year 2055, month 10\n", - "Processing year 2055, month 11\n", - "Processing year 2055, month 12\n", + "Processing year 2055\n", "Processing file: CIL_subset_ssp126_2056.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2056, month 1\n", - "Processing year 2056, month 2\n", - "Processing year 2056, month 3\n", - "Processing year 2056, month 4\n", - "Processing year 2056, month 5\n", - "Processing year 2056, month 6\n", - "Processing year 2056, month 7\n", - "Processing year 2056, month 8\n", - "Processing year 2056, month 9\n", - "Processing year 2056, month 10\n", - "Processing year 2056, month 11\n", - "Processing year 2056, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2056, month 1\n", - "Processing year 2056, month 2\n", - "Processing year 2056, month 3\n", - "Processing year 2056, month 4\n", - "Processing year 2056, month 5\n", - "Processing year 2056, month 6\n", - "Processing year 2056, month 7\n", - "Processing year 2056, month 8\n", - "Processing year 2056, month 9\n", - "Processing year 2056, month 10\n", - "Processing year 2056, month 11\n", - "Processing year 2056, month 12\n", + "Processing year 2056\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2056\n", "Processing model: INM-CM5-0\n", - "Processing year 2056, month 1\n", - "Processing year 2056, month 2\n", - "Processing year 2056, month 3\n", - "Processing year 2056, month 4\n", - "Processing year 2056, month 5\n", - "Processing year 2056, month 6\n", - "Processing year 2056, month 7\n", - "Processing year 2056, month 8\n", - "Processing year 2056, month 9\n", - "Processing year 2056, month 10\n", - "Processing year 2056, month 11\n", - "Processing year 2056, month 12\n", + "Processing year 2056\n", "Processing file: CIL_subset_ssp126_2057.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2057, month 1\n", - "Processing year 2057, month 2\n", - "Processing year 2057, month 3\n", - "Processing year 2057, month 4\n", - "Processing year 2057, month 5\n", - "Processing year 2057, month 6\n", - "Processing year 2057, month 7\n", - "Processing year 2057, month 8\n", - "Processing year 2057, month 9\n", - "Processing year 2057, month 10\n", - "Processing year 2057, month 11\n", - "Processing year 2057, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2057, month 1\n", - "Processing year 2057, month 2\n", - "Processing year 2057, month 3\n", - "Processing year 2057, month 4\n", - "Processing year 2057, month 5\n", - "Processing year 2057, month 6\n", - "Processing year 2057, month 7\n", - "Processing year 2057, month 8\n", - "Processing year 2057, month 9\n", - "Processing year 2057, month 10\n", - "Processing year 2057, month 11\n", - "Processing year 2057, month 12\n", + "Processing year 2057\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2057\n", "Processing model: INM-CM5-0\n", - "Processing year 2057, month 1\n", - "Processing year 2057, month 2\n", - "Processing year 2057, month 3\n", - "Processing year 2057, month 4\n", - "Processing year 2057, month 5\n", - "Processing year 2057, month 6\n", - "Processing year 2057, month 7\n", - "Processing year 2057, month 8\n", - "Processing year 2057, month 9\n", - "Processing year 2057, month 10\n", - "Processing year 2057, month 11\n", - "Processing year 2057, month 12\n", + "Processing year 2057\n", "Processing file: CIL_subset_ssp126_2058.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2058, month 1\n", - "Processing year 2058, month 2\n", - "Processing year 2058, month 3\n", - "Processing year 2058, month 4\n", - "Processing year 2058, month 5\n", - "Processing year 2058, month 6\n", - "Processing year 2058, month 7\n", - "Processing year 2058, month 8\n", - "Processing year 2058, month 9\n", - "Processing year 2058, month 10\n", - "Processing year 2058, month 11\n", - "Processing year 2058, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2058, month 1\n", - "Processing year 2058, month 2\n", - "Processing year 2058, month 3\n", - "Processing year 2058, month 4\n", - "Processing year 2058, month 5\n", - "Processing year 2058, month 6\n", - "Processing year 2058, month 7\n", - "Processing year 2058, month 8\n", - "Processing year 2058, month 9\n", - "Processing year 2058, month 10\n", - "Processing year 2058, month 11\n", - "Processing year 2058, month 12\n", + "Processing year 2058\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2058\n", "Processing model: INM-CM5-0\n", - "Processing year 2058, month 1\n", - "Processing year 2058, month 2\n", - "Processing year 2058, month 3\n", - "Processing year 2058, month 4\n", - "Processing year 2058, month 5\n", - "Processing year 2058, month 6\n", - "Processing year 2058, month 7\n", - "Processing year 2058, month 8\n", - "Processing year 2058, month 9\n", - "Processing year 2058, month 10\n", - "Processing year 2058, month 11\n", - "Processing year 2058, month 12\n", + "Processing year 2058\n", "Processing file: CIL_subset_ssp126_2059.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2059, month 1\n", - "Processing year 2059, month 2\n", - "Processing year 2059, month 3\n", - "Processing year 2059, month 4\n", - "Processing year 2059, month 5\n", - "Processing year 2059, month 6\n", - "Processing year 2059, month 7\n", - "Processing year 2059, month 8\n", - "Processing year 2059, month 9\n", - "Processing year 2059, month 10\n", - "Processing year 2059, month 11\n", - "Processing year 2059, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2059, month 1\n", - "Processing year 2059, month 2\n", - "Processing year 2059, month 3\n", - "Processing year 2059, month 4\n", - "Processing year 2059, month 5\n", - "Processing year 2059, month 6\n", - "Processing year 2059, month 7\n", - "Processing year 2059, month 8\n", - "Processing year 2059, month 9\n", - "Processing year 2059, month 10\n", - "Processing year 2059, month 11\n", - "Processing year 2059, month 12\n", + "Processing year 2059\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2059\n", "Processing model: INM-CM5-0\n", - "Processing year 2059, month 1\n", - "Processing year 2059, month 2\n", - "Processing year 2059, month 3\n", - "Processing year 2059, month 4\n", - "Processing year 2059, month 5\n", - "Processing year 2059, month 6\n", - "Processing year 2059, month 7\n", - "Processing year 2059, month 8\n", - "Processing year 2059, month 9\n", - "Processing year 2059, month 10\n", - "Processing year 2059, month 11\n", - "Processing year 2059, month 12\n", + "Processing year 2059\n", "Processing file: CIL_subset_ssp126_2060.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2060, month 1\n", - "Processing year 2060, month 2\n", - "Processing year 2060, month 3\n", - "Processing year 2060, month 4\n", - "Processing year 2060, month 5\n", - "Processing year 2060, month 6\n", - "Processing year 2060, month 7\n", - "Processing year 2060, month 8\n", - "Processing year 2060, month 9\n", - "Processing year 2060, month 10\n", - "Processing year 2060, month 11\n", - "Processing year 2060, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2060, month 1\n", - "Processing year 2060, month 2\n", - "Processing year 2060, month 3\n", - "Processing year 2060, month 4\n", - "Processing year 2060, month 5\n", - "Processing year 2060, month 6\n", - "Processing year 2060, month 7\n", - "Processing year 2060, month 8\n", - "Processing year 2060, month 9\n", - "Processing year 2060, month 10\n", - "Processing year 2060, month 11\n", - "Processing year 2060, month 12\n", + "Processing year 2060\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2060\n", "Processing model: INM-CM5-0\n", - "Processing year 2060, month 1\n", - "Processing year 2060, month 2\n", - "Processing year 2060, month 3\n", - "Processing year 2060, month 4\n", - "Processing year 2060, month 5\n", - "Processing year 2060, month 6\n", - "Processing year 2060, month 7\n", - "Processing year 2060, month 8\n", - "Processing year 2060, month 9\n", - "Processing year 2060, month 10\n", - "Processing year 2060, month 11\n", - "Processing year 2060, month 12\n", + "Processing year 2060\n", "Processing file: CIL_subset_ssp126_2061.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2061, month 1\n", - "Processing year 2061, month 2\n", - "Processing year 2061, month 3\n", - "Processing year 2061, month 4\n", - "Processing year 2061, month 5\n", - "Processing year 2061, month 6\n", - "Processing year 2061, month 7\n", - "Processing year 2061, month 8\n", - "Processing year 2061, month 9\n", - "Processing year 2061, month 10\n", - "Processing year 2061, month 11\n", - "Processing year 2061, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2061, month 1\n", - "Processing year 2061, month 2\n", - "Processing year 2061, month 3\n", - "Processing year 2061, month 4\n", - "Processing year 2061, month 5\n", - "Processing year 2061, month 6\n", - "Processing year 2061, month 7\n", - "Processing year 2061, month 8\n", - "Processing year 2061, month 9\n", - "Processing year 2061, month 10\n", - "Processing year 2061, month 11\n", - "Processing year 2061, month 12\n", + "Processing year 2061\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2061\n", "Processing model: INM-CM5-0\n", - "Processing year 2061, month 1\n", - "Processing year 2061, month 2\n", - "Processing year 2061, month 3\n", - "Processing year 2061, month 4\n", - "Processing year 2061, month 5\n", - "Processing year 2061, month 6\n", - "Processing year 2061, month 7\n", - "Processing year 2061, month 8\n", - "Processing year 2061, month 9\n", - "Processing year 2061, month 10\n", - "Processing year 2061, month 11\n", - "Processing year 2061, month 12\n", + "Processing year 2061\n", "Processing file: CIL_subset_ssp126_2062.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2062, month 1\n", - "Processing year 2062, month 2\n", - "Processing year 2062, month 3\n", - "Processing year 2062, month 4\n", - "Processing year 2062, month 5\n", - "Processing year 2062, month 6\n", - "Processing year 2062, month 7\n", - "Processing year 2062, month 8\n", - "Processing year 2062, month 9\n", - "Processing year 2062, month 10\n", - "Processing year 2062, month 11\n", - "Processing year 2062, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2062, month 1\n", - "Processing year 2062, month 2\n", - "Processing year 2062, month 3\n", - "Processing year 2062, month 4\n", - "Processing year 2062, month 5\n", - "Processing year 2062, month 6\n", - "Processing year 2062, month 7\n", - "Processing year 2062, month 8\n", - "Processing year 2062, month 9\n", - "Processing year 2062, month 10\n", - "Processing year 2062, month 11\n", - "Processing year 2062, month 12\n", + "Processing year 2062\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2062\n", "Processing model: INM-CM5-0\n", - "Processing year 2062, month 1\n", - "Processing year 2062, month 2\n", - "Processing year 2062, month 3\n", - "Processing year 2062, month 4\n", - "Processing year 2062, month 5\n", - "Processing year 2062, month 6\n", - "Processing year 2062, month 7\n", - "Processing year 2062, month 8\n", - "Processing year 2062, month 9\n", - "Processing year 2062, month 10\n", - "Processing year 2062, month 11\n", - "Processing year 2062, month 12\n", + "Processing year 2062\n", "Processing file: CIL_subset_ssp126_2063.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2063, month 1\n", - "Processing year 2063, month 2\n", - "Processing year 2063, month 3\n", - "Processing year 2063, month 4\n", - "Processing year 2063, month 5\n", - "Processing year 2063, month 6\n", - "Processing year 2063, month 7\n", - "Processing year 2063, month 8\n", - "Processing year 2063, month 9\n", - "Processing year 2063, month 10\n", - "Processing year 2063, month 11\n", - "Processing year 2063, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2063, month 1\n", - "Processing year 2063, month 2\n", - "Processing year 2063, month 3\n", - "Processing year 2063, month 4\n", - "Processing year 2063, month 5\n", - "Processing year 2063, month 6\n", - "Processing year 2063, month 7\n", - "Processing year 2063, month 8\n", - "Processing year 2063, month 9\n", - "Processing year 2063, month 10\n", - "Processing year 2063, month 11\n", - "Processing year 2063, month 12\n", + "Processing year 2063\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2063\n", "Processing model: INM-CM5-0\n", - "Processing year 2063, month 1\n", - "Processing year 2063, month 2\n", - "Processing year 2063, month 3\n", - "Processing year 2063, month 4\n", - "Processing year 2063, month 5\n", - "Processing year 2063, month 6\n", - "Processing year 2063, month 7\n", - "Processing year 2063, month 8\n", - "Processing year 2063, month 9\n", - "Processing year 2063, month 10\n", - "Processing year 2063, month 11\n", - "Processing year 2063, month 12\n", + "Processing year 2063\n", "Processing file: CIL_subset_ssp126_2064.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2064, month 1\n", - "Processing year 2064, month 2\n", - "Processing year 2064, month 3\n", - "Processing year 2064, month 4\n", - "Processing year 2064, month 5\n", - "Processing year 2064, month 6\n", - "Processing year 2064, month 7\n", - "Processing year 2064, month 8\n", - "Processing year 2064, month 9\n", - "Processing year 2064, month 10\n", - "Processing year 2064, month 11\n", - "Processing year 2064, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2064, month 1\n", - "Processing year 2064, month 2\n", - "Processing year 2064, month 3\n", - "Processing year 2064, month 4\n", - "Processing year 2064, month 5\n", - "Processing year 2064, month 6\n", - "Processing year 2064, month 7\n", - "Processing year 2064, month 8\n", - "Processing year 2064, month 9\n", - "Processing year 2064, month 10\n", - "Processing year 2064, month 11\n", - "Processing year 2064, month 12\n", + "Processing year 2064\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2064\n", "Processing model: INM-CM5-0\n", - "Processing year 2064, month 1\n", - "Processing year 2064, month 2\n", - "Processing year 2064, month 3\n", - "Processing year 2064, month 4\n", - "Processing year 2064, month 5\n", - "Processing year 2064, month 6\n", - "Processing year 2064, month 7\n", - "Processing year 2064, month 8\n", - "Processing year 2064, month 9\n", - "Processing year 2064, month 10\n", - "Processing year 2064, month 11\n", - "Processing year 2064, month 12\n", + "Processing year 2064\n", "Processing file: CIL_subset_ssp126_2065.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2065, month 1\n", - "Processing year 2065, month 2\n", - "Processing year 2065, month 3\n", - "Processing year 2065, month 4\n", - "Processing year 2065, month 5\n", - "Processing year 2065, month 6\n", - "Processing year 2065, month 7\n", - "Processing year 2065, month 8\n", - "Processing year 2065, month 9\n", - "Processing year 2065, month 10\n", - "Processing year 2065, month 11\n", - "Processing year 2065, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2065, month 1\n", - "Processing year 2065, month 2\n", - "Processing year 2065, month 3\n", - "Processing year 2065, month 4\n", - "Processing year 2065, month 5\n", - "Processing year 2065, month 6\n", - "Processing year 2065, month 7\n", - "Processing year 2065, month 8\n", - "Processing year 2065, month 9\n", - "Processing year 2065, month 10\n", - "Processing year 2065, month 11\n", - "Processing year 2065, month 12\n", + "Processing year 2065\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2065\n", "Processing model: INM-CM5-0\n", - "Processing year 2065, month 1\n", - "Processing year 2065, month 2\n", - "Processing year 2065, month 3\n", - "Processing year 2065, month 4\n", - "Processing year 2065, month 5\n", - "Processing year 2065, month 6\n", - "Processing year 2065, month 7\n", - "Processing year 2065, month 8\n", - "Processing year 2065, month 9\n", - "Processing year 2065, month 10\n", - "Processing year 2065, month 11\n", - "Processing year 2065, month 12\n", + "Processing year 2065\n", "Processing file: CIL_subset_ssp126_2066.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2066, month 1\n", - "Processing year 2066, month 2\n", - "Processing year 2066, month 3\n", - "Processing year 2066, month 4\n", - "Processing year 2066, month 5\n", - "Processing year 2066, month 6\n", - "Processing year 2066, month 7\n", - "Processing year 2066, month 8\n", - "Processing year 2066, month 9\n", - "Processing year 2066, month 10\n", - "Processing year 2066, month 11\n", - "Processing year 2066, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2066, month 1\n", - "Processing year 2066, month 2\n", - "Processing year 2066, month 3\n", - "Processing year 2066, month 4\n", - "Processing year 2066, month 5\n", - "Processing year 2066, month 6\n", - "Processing year 2066, month 7\n", - "Processing year 2066, month 8\n", - "Processing year 2066, month 9\n", - "Processing year 2066, month 10\n", - "Processing year 2066, month 11\n", - "Processing year 2066, month 12\n", + "Processing year 2066\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2066\n", "Processing model: INM-CM5-0\n", - "Processing year 2066, month 1\n", - "Processing year 2066, month 2\n", - "Processing year 2066, month 3\n", - "Processing year 2066, month 4\n", - "Processing year 2066, month 5\n", - "Processing year 2066, month 6\n", - "Processing year 2066, month 7\n", - "Processing year 2066, month 8\n", - "Processing year 2066, month 9\n", - "Processing year 2066, month 10\n", - "Processing year 2066, month 11\n", - "Processing year 2066, month 12\n", + "Processing year 2066\n", "Processing file: CIL_subset_ssp126_2067.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2067, month 1\n", - "Processing year 2067, month 2\n", - "Processing year 2067, month 3\n", - "Processing year 2067, month 4\n", - "Processing year 2067, month 5\n", - "Processing year 2067, month 6\n", - "Processing year 2067, month 7\n", - "Processing year 2067, month 8\n", - "Processing year 2067, month 9\n", - "Processing year 2067, month 10\n", - "Processing year 2067, month 11\n", - "Processing year 2067, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2067, month 1\n", - "Processing year 2067, month 2\n", - "Processing year 2067, month 3\n", - "Processing year 2067, month 4\n", - "Processing year 2067, month 5\n", - "Processing year 2067, month 6\n", - "Processing year 2067, month 7\n", - "Processing year 2067, month 8\n", - "Processing year 2067, month 9\n", - "Processing year 2067, month 10\n", - "Processing year 2067, month 11\n", - "Processing year 2067, month 12\n", + "Processing year 2067\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2067\n", "Processing model: INM-CM5-0\n", - "Processing year 2067, month 1\n", - "Processing year 2067, month 2\n", - "Processing year 2067, month 3\n", - "Processing year 2067, month 4\n", - "Processing year 2067, month 5\n", - "Processing year 2067, month 6\n", - "Processing year 2067, month 7\n", - "Processing year 2067, month 8\n", - "Processing year 2067, month 9\n", - "Processing year 2067, month 10\n", - "Processing year 2067, month 11\n", - "Processing year 2067, month 12\n", + "Processing year 2067\n", "Processing file: CIL_subset_ssp126_2068.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2068, month 1\n", - "Processing year 2068, month 2\n", - "Processing year 2068, month 3\n", - "Processing year 2068, month 4\n", - "Processing year 2068, month 5\n", - "Processing year 2068, month 6\n", - "Processing year 2068, month 7\n", - "Processing year 2068, month 8\n", - "Processing year 2068, month 9\n", - "Processing year 2068, month 10\n", - "Processing year 2068, month 11\n", - "Processing year 2068, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2068, month 1\n", - "Processing year 2068, month 2\n", - "Processing year 2068, month 3\n", - "Processing year 2068, month 4\n", - "Processing year 2068, month 5\n", - "Processing year 2068, month 6\n", - "Processing year 2068, month 7\n", - "Processing year 2068, month 8\n", - "Processing year 2068, month 9\n", - "Processing year 2068, month 10\n", - "Processing year 2068, month 11\n", - "Processing year 2068, month 12\n", + "Processing year 2068\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2068\n", "Processing model: INM-CM5-0\n", - "Processing year 2068, month 1\n", - "Processing year 2068, month 2\n", - "Processing year 2068, month 3\n", - "Processing year 2068, month 4\n", - "Processing year 2068, month 5\n", - "Processing year 2068, month 6\n", - "Processing year 2068, month 7\n", - "Processing year 2068, month 8\n", - "Processing year 2068, month 9\n", - "Processing year 2068, month 10\n", - "Processing year 2068, month 11\n", - "Processing year 2068, month 12\n", + "Processing year 2068\n", "Processing file: CIL_subset_ssp126_2069.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2069, month 1\n", - "Processing year 2069, month 2\n", - "Processing year 2069, month 3\n", - "Processing year 2069, month 4\n", - "Processing year 2069, month 5\n", - "Processing year 2069, month 6\n", - "Processing year 2069, month 7\n", - "Processing year 2069, month 8\n", - "Processing year 2069, month 9\n", - "Processing year 2069, month 10\n", - "Processing year 2069, month 11\n", - "Processing year 2069, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2069, month 1\n", - "Processing year 2069, month 2\n", - "Processing year 2069, month 3\n", - "Processing year 2069, month 4\n", - "Processing year 2069, month 5\n", - "Processing year 2069, month 6\n", - "Processing year 2069, month 7\n", - "Processing year 2069, month 8\n", - "Processing year 2069, month 9\n", - "Processing year 2069, month 10\n", - "Processing year 2069, month 11\n", - "Processing year 2069, month 12\n", + "Processing year 2069\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2069\n", "Processing model: INM-CM5-0\n", - "Processing year 2069, month 1\n", - "Processing year 2069, month 2\n", - "Processing year 2069, month 3\n", - "Processing year 2069, month 4\n", - "Processing year 2069, month 5\n", - "Processing year 2069, month 6\n", - "Processing year 2069, month 7\n", - "Processing year 2069, month 8\n", - "Processing year 2069, month 9\n", - "Processing year 2069, month 10\n", - "Processing year 2069, month 11\n", - "Processing year 2069, month 12\n", + "Processing year 2069\n", "Processing file: CIL_subset_ssp126_2070.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2070, month 1\n", - "Processing year 2070, month 2\n", - "Processing year 2070, month 3\n", - "Processing year 2070, month 4\n", - "Processing year 2070, month 5\n", - "Processing year 2070, month 6\n", - "Processing year 2070, month 7\n", - "Processing year 2070, month 8\n", - "Processing year 2070, month 9\n", - "Processing year 2070, month 10\n", - "Processing year 2070, month 11\n", - "Processing year 2070, month 12\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2070, month 1\n", - "Processing year 2070, month 2\n", - "Processing year 2070, month 3\n", - "Processing year 2070, month 4\n", - "Processing year 2070, month 5\n", - "Processing year 2070, month 6\n", - "Processing year 2070, month 7\n", - "Processing year 2070, month 8\n", - "Processing year 2070, month 9\n", - "Processing year 2070, month 10\n", - "Processing year 2070, month 11\n", - "Processing year 2070, month 12\n", + "Processing year 2070\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2070\n", "Processing model: INM-CM5-0\n", - "Processing year 2070, month 1\n", - "Processing year 2070, month 2\n", - "Processing year 2070, month 3\n", - "Processing year 2070, month 4\n", - "Processing year 2070, month 5\n", - "Processing year 2070, month 6\n", - "Processing year 2070, month 7\n", - "Processing year 2070, month 8\n", - "Processing year 2070, month 9\n", - "Processing year 2070, month 10\n", - "Processing year 2070, month 11\n", - "Processing year 2070, month 12\n", + "Processing year 2070\n", "Saved monthly data for lowest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp126/lowest_monthly_prediction_weather_by_facility.csv\n", "Saved window data for lowest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp126/lowest_window_prediction_weather_by_facility.csv\n", "Saved monthly data for mean model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp126/mean_monthly_prediction_weather_by_facility.csv\n", "Saved window data for mean model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp126/mean_window_prediction_weather_by_facility.csv\n", "Saved monthly data for highest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp126/highest_monthly_prediction_weather_by_facility.csv\n", - "Saved window data for highest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp126/highest_window_prediction_weather_by_facility.csv\n" + "Saved window data for highest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp126/highest_window_prediction_weather_by_facility.csv\n", + "Processing scenario: ssp245\n", + "Saved combined dataset for ssp245 to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/CIL_combined_ssp245_2024_2070.nc\n", + "Models of interest ['HadGEM3-GC31-LL', 'UKESM1-0-LL', 'INM-CM5-0']\n", + "Processing file: CIL_subset_ssp245_2024.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2024\n" ] - } - ], - "execution_count": 14 - }, - { - "metadata": {}, - "cell_type": "code", - "outputs": [], - "execution_count": null, - "source": "", - "id": "f0a57d0d924da84e" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing model: UKESM1-0-LL\n", + "Processing year 2024\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing model: INM-CM5-0\n", + "Processing year 2024\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing file: CIL_subset_ssp245_2025.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2025\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2025\n", + "Processing model: INM-CM5-0\n", + "Processing year 2025\n", + "Processing file: CIL_subset_ssp245_2026.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2026\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2026\n", + "Processing model: INM-CM5-0\n", + "Processing year 2026\n", + "Processing file: CIL_subset_ssp245_2027.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2027\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2027\n", + "Processing model: INM-CM5-0\n", + "Processing year 2027\n", + "Processing file: CIL_subset_ssp245_2028.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2028\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2028\n", + "Processing model: INM-CM5-0\n", + "Processing year 2028\n", + "Processing file: CIL_subset_ssp245_2029.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2029\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2029\n", + "Processing model: INM-CM5-0\n", + "Processing year 2029\n", + "Processing file: CIL_subset_ssp245_2030.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2030\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2030\n", + "Processing model: INM-CM5-0\n", + "Processing year 2030\n", + "Processing file: CIL_subset_ssp245_2031.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2031\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2031\n", + "Processing model: INM-CM5-0\n", + "Processing year 2031\n", + "Processing file: CIL_subset_ssp245_2032.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2032\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2032\n", + "Processing model: INM-CM5-0\n", + "Processing year 2032\n", + "Processing file: CIL_subset_ssp245_2033.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2033\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2033\n", + "Processing model: INM-CM5-0\n", + "Processing year 2033\n", + "Processing file: CIL_subset_ssp245_2034.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2034\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2034\n", + "Processing model: INM-CM5-0\n", + "Processing year 2034\n", + "Processing file: CIL_subset_ssp245_2035.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2035\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2035\n", + "Processing model: INM-CM5-0\n", + "Processing year 2035\n", + "Processing file: CIL_subset_ssp245_2036.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2036\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2036\n", + "Processing model: INM-CM5-0\n", + "Processing year 2036\n", + "Processing file: CIL_subset_ssp245_2037.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2037\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2037\n", + "Processing model: INM-CM5-0\n", + "Processing year 2037\n", + "Processing file: CIL_subset_ssp245_2038.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2038\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2038\n", + "Processing model: INM-CM5-0\n", + "Processing year 2038\n", + "Processing file: CIL_subset_ssp245_2039.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2039\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2039\n", + "Processing model: INM-CM5-0\n", + "Processing year 2039\n", + "Processing file: CIL_subset_ssp245_2040.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2040\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2040\n", + "Processing model: INM-CM5-0\n", + "Processing year 2040\n", + "Processing file: CIL_subset_ssp245_2041.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2041\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2041\n", + "Processing model: INM-CM5-0\n", + "Processing year 2041\n", + "Processing file: CIL_subset_ssp245_2042.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2042\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2042\n", + "Processing model: INM-CM5-0\n", + "Processing year 2042\n", + "Processing file: CIL_subset_ssp245_2043.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2043\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2043\n", + "Processing model: INM-CM5-0\n", + "Processing year 2043\n", + "Processing file: CIL_subset_ssp245_2044.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2044\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2044\n", + "Processing model: INM-CM5-0\n", + "Processing year 2044\n", + "Processing file: CIL_subset_ssp245_2045.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2045\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2045\n", + "Processing model: INM-CM5-0\n", + "Processing year 2045\n", + "Processing file: CIL_subset_ssp245_2046.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2046\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2046\n", + "Processing model: INM-CM5-0\n", + "Processing year 2046\n", + "Processing file: CIL_subset_ssp245_2047.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2047\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2047\n", + "Processing model: INM-CM5-0\n", + "Processing year 2047\n", + "Processing file: CIL_subset_ssp245_2048.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2048\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2048\n", + "Processing model: INM-CM5-0\n", + "Processing year 2048\n", + "Processing file: CIL_subset_ssp245_2049.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2049\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2049\n", + "Processing model: INM-CM5-0\n", + "Processing year 2049\n", + "Processing file: CIL_subset_ssp245_2050.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2050\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2050\n", + "Processing model: INM-CM5-0\n", + "Processing year 2050\n", + "Processing file: CIL_subset_ssp245_2051.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2051\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2051\n", + "Processing model: INM-CM5-0\n", + "Processing year 2051\n", + "Processing file: CIL_subset_ssp245_2052.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2052\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2052\n", + "Processing model: INM-CM5-0\n", + "Processing year 2052\n", + "Processing file: CIL_subset_ssp245_2053.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2053\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2053\n", + "Processing model: INM-CM5-0\n", + "Processing year 2053\n", + "Processing file: CIL_subset_ssp245_2054.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2054\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2054\n", + "Processing model: INM-CM5-0\n", + "Processing year 2054\n", + "Processing file: CIL_subset_ssp245_2055.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2055\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2055\n", + "Processing model: INM-CM5-0\n", + "Processing year 2055\n", + "Processing file: CIL_subset_ssp245_2056.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2056\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2056\n", + "Processing model: INM-CM5-0\n", + "Processing year 2056\n", + "Processing file: CIL_subset_ssp245_2057.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2057\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2057\n", + "Processing model: INM-CM5-0\n", + "Processing year 2057\n", + "Processing file: CIL_subset_ssp245_2058.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2058\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2058\n", + "Processing model: INM-CM5-0\n", + "Processing year 2058\n", + "Processing file: CIL_subset_ssp245_2059.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2059\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2059\n", + "Processing model: INM-CM5-0\n", + "Processing year 2059\n", + "Processing file: CIL_subset_ssp245_2060.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2060\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2060\n", + "Processing model: INM-CM5-0\n", + "Processing year 2060\n", + "Processing file: CIL_subset_ssp245_2061.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2061\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2061\n", + "Processing model: INM-CM5-0\n", + "Processing year 2061\n", + "Processing file: CIL_subset_ssp245_2062.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2062\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2062\n", + "Processing model: INM-CM5-0\n", + "Processing year 2062\n", + "Processing file: CIL_subset_ssp245_2063.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2063\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2063\n", + "Processing model: INM-CM5-0\n", + "Processing year 2063\n", + "Processing file: CIL_subset_ssp245_2064.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2064\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2064\n", + "Processing model: INM-CM5-0\n", + "Processing year 2064\n", + "Processing file: CIL_subset_ssp245_2065.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2065\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2065\n", + "Processing model: INM-CM5-0\n", + "Processing year 2065\n", + "Processing file: CIL_subset_ssp245_2066.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2066\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2066\n", + "Processing model: INM-CM5-0\n", + "Processing year 2066\n", + "Processing file: CIL_subset_ssp245_2067.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2067\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2067\n", + "Processing model: INM-CM5-0\n", + "Processing year 2067\n", + "Processing file: CIL_subset_ssp245_2068.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2068\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2068\n", + "Processing model: INM-CM5-0\n", + "Processing year 2068\n", + "Processing file: CIL_subset_ssp245_2069.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2069\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2069\n", + "Processing model: INM-CM5-0\n", + "Processing year 2069\n", + "Processing file: CIL_subset_ssp245_2070.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2070\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2070\n", + "Processing model: INM-CM5-0\n", + "Processing year 2070\n", + "Saved monthly data for lowest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp245/lowest_monthly_prediction_weather_by_facility.csv\n", + "Saved window data for lowest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp245/lowest_window_prediction_weather_by_facility.csv\n", + "Saved monthly data for mean model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp245/mean_monthly_prediction_weather_by_facility.csv\n", + "Saved window data for mean model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp245/mean_window_prediction_weather_by_facility.csv\n", + "Saved monthly data for highest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp245/highest_monthly_prediction_weather_by_facility.csv\n", + "Saved window data for highest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp245/highest_window_prediction_weather_by_facility.csv\n", + "Processing scenario: ssp585\n", + "Saved combined dataset for ssp585 to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/CIL_combined_ssp585_2024_2070.nc\n", + "Models of interest ['HadGEM3-GC31-LL', 'EC-Earth3-CC', 'CMCC-CM2-SR5']\n", + "Processing file: CIL_subset_ssp585_2024.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2024\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing model: EC-Earth3-CC\n", + "Processing year 2024\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2024\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing file: CIL_subset_ssp585_2025.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2025\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2025\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2025\n", + "Processing file: CIL_subset_ssp585_2026.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2026\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2026\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2026\n", + "Processing file: CIL_subset_ssp585_2027.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2027\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2027\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2027\n", + "Processing file: CIL_subset_ssp585_2028.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2028\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2028\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2028\n", + "Processing file: CIL_subset_ssp585_2029.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2029\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2029\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2029\n", + "Processing file: CIL_subset_ssp585_2030.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2030\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2030\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2030\n", + "Processing file: CIL_subset_ssp585_2031.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2031\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2031\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2031\n", + "Processing file: CIL_subset_ssp585_2032.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2032\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2032\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2032\n", + "Processing file: CIL_subset_ssp585_2033.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2033\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2033\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2033\n", + "Processing file: CIL_subset_ssp585_2034.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2034\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2034\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2034\n", + "Processing file: CIL_subset_ssp585_2035.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2035\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2035\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2035\n", + "Processing file: CIL_subset_ssp585_2036.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2036\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2036\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2036\n", + "Processing file: CIL_subset_ssp585_2037.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2037\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2037\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2037\n", + "Processing file: CIL_subset_ssp585_2038.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2038\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2038\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2038\n", + "Processing file: CIL_subset_ssp585_2039.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2039\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2039\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2039\n", + "Processing file: CIL_subset_ssp585_2040.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2040\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2040\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2040\n", + "Processing file: CIL_subset_ssp585_2041.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2041\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2041\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2041\n", + "Processing file: CIL_subset_ssp585_2042.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2042\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2042\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2042\n", + "Processing file: CIL_subset_ssp585_2043.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2043\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2043\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2043\n", + "Processing file: CIL_subset_ssp585_2044.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2044\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2044\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2044\n", + "Processing file: CIL_subset_ssp585_2045.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2045\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2045\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2045\n", + "Processing file: CIL_subset_ssp585_2046.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2046\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2046\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2046\n", + "Processing file: CIL_subset_ssp585_2047.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2047\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2047\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2047\n", + "Processing file: CIL_subset_ssp585_2048.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2048\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2048\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2048\n", + "Processing file: CIL_subset_ssp585_2049.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2049\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2049\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2049\n", + "Processing file: CIL_subset_ssp585_2050.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2050\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2050\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2050\n", + "Processing file: CIL_subset_ssp585_2051.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2051\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2051\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2051\n", + "Processing file: CIL_subset_ssp585_2052.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2052\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2052\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2052\n", + "Processing file: CIL_subset_ssp585_2053.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2053\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2053\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2053\n", + "Processing file: CIL_subset_ssp585_2054.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2054\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2054\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2054\n", + "Processing file: CIL_subset_ssp585_2055.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2055\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2055\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2055\n", + "Processing file: CIL_subset_ssp585_2056.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2056\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2056\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2056\n", + "Processing file: CIL_subset_ssp585_2057.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2057\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2057\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2057\n", + "Processing file: CIL_subset_ssp585_2058.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2058\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2058\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2058\n", + "Processing file: CIL_subset_ssp585_2059.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2059\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2059\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2059\n", + "Processing file: CIL_subset_ssp585_2060.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2060\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2060\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2060\n", + "Processing file: CIL_subset_ssp585_2061.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2061\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2061\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2061\n", + "Processing file: CIL_subset_ssp585_2062.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2062\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2062\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2062\n", + "Processing file: CIL_subset_ssp585_2063.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2063\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2063\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2063\n", + "Processing file: CIL_subset_ssp585_2064.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2064\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2064\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2064\n", + "Processing file: CIL_subset_ssp585_2065.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2065\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2065\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2065\n", + "Processing file: CIL_subset_ssp585_2066.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2066\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2066\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2066\n", + "Processing file: CIL_subset_ssp585_2067.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2067\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2067\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2067\n", + "Processing file: CIL_subset_ssp585_2068.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2068\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2068\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2068\n", + "Processing file: CIL_subset_ssp585_2069.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2069\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2069\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2069\n", + "Processing file: CIL_subset_ssp585_2070.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2070\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2070\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2070\n", + "Saved monthly data for lowest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/lowest_monthly_prediction_weather_by_facility.csv\n", + "Saved window data for lowest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/lowest_window_prediction_weather_by_facility.csv\n", + "Saved monthly data for mean model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/mean_monthly_prediction_weather_by_facility.csv\n", + "Saved window data for mean model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/mean_window_prediction_weather_by_facility.csv\n", + "Saved monthly data for highest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/highest_monthly_prediction_weather_by_facility.csv\n", + "Saved window data for highest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/highest_window_prediction_weather_by_facility.csv\n" + ] + } + ], + "execution_count": 4 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-21T14:38:51.031147Z", + "start_time": "2025-01-21T14:38:51.027546Z" + } + }, + "cell_type": "code", + "source": "", + "id": "f0a57d0d924da84e", + "outputs": [], + "execution_count": 16 } ], "metadata": { From c5b910ade2f3507258e7a2a0fb38758d8202b145 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 22 Jan 2025 10:22:05 +0000 Subject: [PATCH 221/291] Joint graph of historical and future precip --- .../plotting_heavy_precipitation.py | 123 ++++++++++-------- 1 file changed, 68 insertions(+), 55 deletions(-) diff --git a/src/scripts/climate_change/plotting_heavy_precipitation.py b/src/scripts/climate_change/plotting_heavy_precipitation.py index 7a7d8465a4..57e4768051 100644 --- a/src/scripts/climate_change/plotting_heavy_precipitation.py +++ b/src/scripts/climate_change/plotting_heavy_precipitation.py @@ -50,80 +50,93 @@ file_path_downscaled = f"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/CIL_combined_{scenario}_2024_2070.nc" data_all_models = xr.open_dataset(file_path_downscaled) pr_aggregated_mean = data_all_models.mean(dim=['lat', 'lon', 'model'], skipna=True) + pr_aggregated_median = data_all_models.median(dim='model', skipna=True) + pr_aggregated_median = pr_aggregated_median.mean(dim=['lat', 'lon'], skipna=True) + model_annual_precip = pr_aggregated_mean['pr'].resample(time='YE').sum('time') + #model_annual_precip_median = pr_aggregated_median['pr'].resample(time='YE').sum('time') for model in data_all_models['model'].values: model_data = data_all_models.sel(model=model) pr_aggregated = model_data.mean(dim=['lat', 'lon'], skipna=True) model_annual_precip = pr_aggregated['pr'].resample(time='YE').sum('time') axes[i].plot( - range(len(model_annual_precip)), + range(len(era5_precipitation_data), len(era5_precipitation_data) + len(model_annual_precip)), model_annual_precip, alpha=0.5, - label=f'{model}' + #label=f'{model}' ) + axes[i].plot(range(len(era5_precipitation_data)), era5_precipitation_data * 1000, color="#312F2F", linewidth=2, linestyle='--', label='ERA5') axes[i].plot( - range(len(model_annual_precip)), + range(len(era5_precipitation_data), len(era5_precipitation_data) + len(model_annual_precip)), model_annual_precip, - label="Mean", + label="Mean of CMIP6", color = 'black' ) + # axes[i].plot( + # range(len(era5_precipitation_data), len(era5_precipitation_data) + len(model_annual_precip)), + # model_annual_precip_median, + # label="Median", + # color='black' + # ) + axes[i].set_xticklabels(range(2025,2071)) axes[i].set_title(scenario.upper()) axes[i].set_xlabel('Year') - #axes[i].legend(fontsize='small') - -fig.text(0.04, 0.5, 'Annual Precipitation (mm)', va='center', rotation='vertical') + if i == 0: + axes[i].set_ylabel('Annual Precipitation (mm)') + axes[i].legend() plt.tight_layout() plt.show() +plt.savefig('/Users/rem76/Desktop/Climate_change_health/Results/ANC_disruptions/histroical_future_precip_annual.png') ## Plot 95% CI - -fig, axes = plt.subplots(1, 3, figsize=(18, 6), sharex=True, sharey=True) -axes = axes.flatten() - -for i, scenario in enumerate(scenarios): - scenario_directory = os.path.join(base_dir, scenario) - file_path_downscaled = f"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/CIL_combined_{scenario}_2024_2070.nc" - data_all_models = xr.open_dataset(file_path_downscaled) - pr_aggregated_mean = data_all_models.mean(dim=['lat', 'lon', 'model'], skipna=True) - model_annual_precip = pr_aggregated_mean['pr'].resample(time='YE').sum('time') - std_pr = data_all_models.std(dim=['lat', 'lon', "model"], skipna=True) - print(std_pr) - std_pr_annual = std_pr['pr'].resample(time='YE').sum('time') - upper_bound = model_annual_precip + std_pr_annual - lower_bound = model_annual_precip - std_pr_annual - - axes[i].plot( - range(0, len(era5_precipitation_data)), - era5_precipitation_data * 1000, - color="#1C6E8C", - linewidth=2, - linestyle='--', - marker='o', - markersize=6, - label='ERA5 Precipitation', - ) - - axes[i].plot( - range(len(era5_precipitation_data),len(era5_precipitation_data) +len(model_annual_precip)), - model_annual_precip, - label="Ensemble mean", - color = 'black' - ) - axes[i].fill_between( - range(len(era5_precipitation_data), len(era5_precipitation_data) + len(model_annual_precip)), - lower_bound.values, - upper_bound.values, - color="#9AC4F8", - alpha=0.3, -) - axes[i].set_title(scenario.upper()) - axes[i].set_xlabel('Year') - #axes[i].legend(fontsize='small') - -fig.text(0.04, 0.5, 'Annual Precipitation (mm)', va='center', rotation='vertical') - -plt.tight_layout() -plt.show() +# +# fig, axes = plt.subplots(1, 3, figsize=(18, 6), sharex=True, sharey=True) +# axes = axes.flatten() +# +# for i, scenario in enumerate(scenarios): +# scenario_directory = os.path.join(base_dir, scenario) +# file_path_downscaled = f"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/CIL_combined_{scenario}_2024_2070.nc" +# data_all_models = xr.open_dataset(file_path_downscaled) +# model_annual_precip = data_all_models.mean(dim=['lat', 'lon', 'model'], skipna=True) +# #model_annual_precip = pr_aggregated_mean['pr'].resample(time='YE').sum('time') +# std_pr_annual = data_all_models.std(dim=['lat', 'lon', "model"], skipna=True) +# #std_pr_annual = std_pr['pr'].resample(time='YE').sum('time') +# print(model_annual_precip) +# print(len(model_annual_precip)) +# upper_bound = model_annual_precip['pr'] + std_pr_annual['pr'] +# lower_bound = model_annual_precip['pr'] - std_pr_annual['pr'] +# axes[i].plot( +# range(0, len(era5_precipitation_data)), +# era5_precipitation_data * 1000, +# color="#1C6E8C", +# linewidth=2, +# linestyle='--', +# marker='o', +# markersize=6, +# label='ERA5 Precipitation', +# ) +# +# axes[i].plot( +# range(len(era5_precipitation_data),len(era5_precipitation_data) +len(model_annual_precip)), +# model_annual_precip.to_dataarray(), +# label="Ensemble mean", +# color = 'black' +# ) +# axes[i].fill_between( +# range(len(era5_precipitation_data), len(era5_precipitation_data) + len(model_annual_precip)), +# lower_bound, +# upper_bound, +# color="#9AC4F8", +# alpha=0.3, +# ) +# axes[i].set_title(scenario.upper()) +# axes[i].set_xlabel('Year') +# #axes[i].legend(fontsize='small') +# +# fig.text(0.04, 0.5, 'Annual Precipitation (mm)', va='center', rotation='vertical') +# +# plt.tight_layout() +# plt.show() From 132aa8fa6ce630b556bc5be7d9a05f2b22245de9 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 23 Jan 2025 10:52:58 +0000 Subject: [PATCH 222/291] aesthetics --- src/scripts/climate_change/cohort_model.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/scripts/climate_change/cohort_model.py b/src/scripts/climate_change/cohort_model.py index 22b60ec8a8..d25957e5c8 100644 --- a/src/scripts/climate_change/cohort_model.py +++ b/src/scripts/climate_change/cohort_model.py @@ -415,7 +415,7 @@ # ax.legend(title="Districts", fontsize=10, title_fontsize=10, bbox_to_anchor=(1., 1)) percentage_diff_by_year_district_all[scenario][model_type] = percentage_diff_by_year_district for ax in axes.flatten(): - ax.set_ylim(y_min*15, y_max) + ax.set_ylim(y_min*18, y_max) handles, labels = ax.get_legend_handles_labels() fig.legend(handles, labels, bbox_to_anchor=(1, -10), loc = "center right", fontsize=10, title="Districts") plt.tight_layout() From b31f80eae8df5696cb97ac8c19902b9c5861f39a Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 23 Jan 2025 11:41:44 +0000 Subject: [PATCH 223/291] Made model slection not based on p value --- ...al_realtionship_reporting_precipitation.py | 46 +++++++++++-------- 1 file changed, 28 insertions(+), 18 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 171588a8af..95be102417 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -107,9 +107,8 @@ def stepwise_selection(X, y, log_y, poisson, p_value_threshold=0.05): new_aic = pd.Series(index=excluded, dtype=float) for new_column in excluded: subset_X = X[:, included + [new_column]] - results, _, _ = build_model(subset_X, y, poisson, log_y=log_y, X_mask_mm=mask_threshold) - if results.pvalues[-1] < p_value_threshold: - new_aic[new_column] = results.aic + results, y_pred, mask_ANC_data, _ = build_model(subset_X, y, poisson, log_y=log_y, X_mask_mm=mask_threshold) + new_aic[new_column] = results.aic # Add the predictor with the best AIC if it's better than the current model's AIC if not new_aic.empty and new_aic.min() < current_aic: @@ -123,8 +122,8 @@ def stepwise_selection(X, y, log_y, poisson, p_value_threshold=0.05): # Exit if no changes were made in this iteration if not changed: break - - return included + included.sort() + return included, results, y_pred, mask_ANC_data def calculate_vif(X): vif_data = pd.DataFrame() @@ -337,7 +336,13 @@ def repeat_info(info, num_facilities, year_range, historical): coefficient_names = ["year", "month", "altitude", "minimum_distance"] + list(resid_encoded.columns) + list(zone_encoded.columns) + \ list(owner_encoded.columns) coefficient_names = pd.Series(coefficient_names) -results, y_pred, mask_ANC_data, selected_features = build_model(X_ANC_standardized , y, poisson = poisson, log_y=log_y, X_mask_mm=mask_threshold, feature_selection = feature_selection) +#results, y_pred, mask_ANC_data, selected_features = build_model(X_ANC_standardized , y, poisson = poisson, log_y=log_y, X_mask_mm=mask_threshold, feature_selection = feature_selection) + +included, results, y_pred, mask_ANC_data = stepwise_selection(X_ANC_standardized , y, poisson = poisson, log_y=log_y,) +coefficients = results.params +print(coefficient_names[included]) +print(coefficient_names) + coefficients = results.params coefficients_df = pd.DataFrame(coefficients, columns=['coefficients']) continuous_coefficients = coefficients[:len(X_continuous_scaled[0])] @@ -449,8 +454,9 @@ def repeat_info(info, num_facilities, year_range, historical): X_weather_standardized = np.column_stack([X_continuous_scaled, X_categorical]) -results_of_weather_model, y_pred_weather, mask_all_data, selected_features = build_model(X_weather_standardized, y, poisson = poisson, log_y=log_y, - X_mask_mm=mask_threshold, feature_selection = feature_selection) +# results_of_weather_model, y_pred_weather, mask_all_data, selected_features = build_model(X_weather_standardized, y, poisson = poisson, log_y=log_y, +# X_mask_mm=mask_threshold, feature_selection = feature_selection) +included_weather, results_of_weather_model, y_pred_weather, mask_all_data = stepwise_selection(X_weather_standardized , y, poisson = poisson, log_y=log_y,) coefficient_names_weather = ["precip_monthly_total", "precip_5_day_max", "year", "month", "lag_1_month", "lag_2_month", "lag_3_month", "lag_4_month", "lag_9_month", @@ -459,18 +465,21 @@ def repeat_info(info, num_facilities, year_range, historical): list(resid_encoded.columns) + list(zone_encoded.columns) + \ list(owner_encoded.columns) coefficient_names_weather = pd.Series(coefficient_names_weather) +print(coefficient_names_weather[included_weather]) +print(coefficient_names_weather) + coefficients_weather = results_of_weather_model.params coefficients_weather_df = pd.DataFrame(coefficients_weather, columns=['coefficients']) #rescale coefficients -continuous_coefficients = coefficients_weather[:len(X_continuous_scaled[0])] -categorical_coefficients = coefficients_weather[len(X_continuous_scaled[0]):] -means = scaler.mean_ -scales = scaler.scale_ -rescaled_continuous_coefficients = continuous_coefficients * scales -rescaled_coefficients_weather = np.concatenate([rescaled_continuous_coefficients, categorical_coefficients]) -rescaled_coefficients_weather = np.concatenate([continuous_coefficients, categorical_coefficients]) - -rescaled_coefficients_df = pd.DataFrame(rescaled_coefficients_weather, columns=['rescaled coefficients']) +# continuous_coefficients = coefficients_weather[:len(X_continuous_scaled[0])] +# categorical_coefficients = coefficients_weather[len(X_continuous_scaled[0]):] +# means = scaler.mean_ +# scales = scaler.scale_ +# rescaled_continuous_coefficients = continuous_coefficients * scales +# rescaled_coefficients_weather = np.concatenate([rescaled_continuous_coefficients, categorical_coefficients]) +# rescaled_coefficients_weather = np.concatenate([continuous_coefficients, categorical_coefficients]) +# +# rescaled_coefficients_df = pd.DataFrame(rescaled_coefficients_weather, columns=['rescaled coefficients']) p_values_weather = results_of_weather_model.pvalues p_values_weather_df = pd.DataFrame(p_values_weather, columns=['p_values']) @@ -678,6 +687,7 @@ def get_weather_data(ssp_scenario, model_type): X_basis_weather = np.column_stack([X_continuous_weather_scaled, X_categorical_weather]) X_basis_weather_filtered = X_basis_weather[X_basis_weather[:, 0] > mask_threshold] + X_basis_weather_filtered = X_basis_weather_filtered[included_weather] # account for model selection in previous steps # format output year_month_labels = np.array([f"{y}-{m}" for y, m in zip(X_basis_weather_filtered[:, 2], X_basis_weather[:, 3])]) predictions_weather = results_of_weather_model.predict(X_basis_weather_filtered) @@ -709,7 +719,7 @@ def get_weather_data(ssp_scenario, model_type): X_continuous_ANC_scaled = X_continuous_ANC X_bases_ANC_standardized = np.column_stack([X_continuous_ANC_scaled, X_categorical_ANC]) - + X_bases_ANC_standardized = X_bases_ANC_standardized[included] # account for model selection in previous steps y_pred_ANC = results.predict(X_bases_ANC_standardized) predictions = np.exp(predictions_weather) - np.exp(y_pred_ANC[X_basis_weather[:, 0] > mask_threshold]) data_weather_predictions['y_pred_no_weather'] = np.exp(y_pred_ANC[X_basis_weather[:, 0] > mask_threshold]) From 23b389de5771582797d359b1d9990de80113edd6 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 23 Jan 2025 11:57:47 +0000 Subject: [PATCH 224/291] Made clearer which coefficients were included --- ...al_realtionship_reporting_precipitation.py | 32 +++++++------------ 1 file changed, 11 insertions(+), 21 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 95be102417..dd668ef71e 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -123,6 +123,8 @@ def stepwise_selection(X, y, log_y, poisson, p_value_threshold=0.05): if not changed: break included.sort() + results, y_pred, mask_ANC_data, _ = build_model(X[:, included], y, poisson, log_y=log_y, X_mask_mm=mask_threshold) + return included, results, y_pred, mask_ANC_data def calculate_vif(X): @@ -333,17 +335,16 @@ def repeat_info(info, num_facilities, year_range, historical): # correlation_matrix.to_csv('/Users/rem76/Desktop/Climate_change_health/Data/correlation_matrix_of_predictors.csv') # Display the correlation matrix -coefficient_names = ["year", "month", "altitude", "minimum_distance"] + list(resid_encoded.columns) + list(zone_encoded.columns) + \ - list(owner_encoded.columns) -coefficient_names = pd.Series(coefficient_names) + #results, y_pred, mask_ANC_data, selected_features = build_model(X_ANC_standardized , y, poisson = poisson, log_y=log_y, X_mask_mm=mask_threshold, feature_selection = feature_selection) included, results, y_pred, mask_ANC_data = stepwise_selection(X_ANC_standardized , y, poisson = poisson, log_y=log_y,) coefficients = results.params -print(coefficient_names[included]) -print(coefficient_names) -coefficients = results.params +coefficient_names = ["year", "month", "altitude", "minimum_distance"] + list(resid_encoded.columns) + list(zone_encoded.columns) + \ + list(owner_encoded.columns) +coefficient_names = pd.Series(coefficient_names) +coefficient_names = coefficient_names[included] coefficients_df = pd.DataFrame(coefficients, columns=['coefficients']) continuous_coefficients = coefficients[:len(X_continuous_scaled[0])] categorical_coefficients = coefficients[len(X_continuous_scaled[0]):] @@ -354,7 +355,6 @@ def repeat_info(info, num_facilities, year_range, historical): rescaled_coefficients_df = pd.DataFrame(rescaled_coefficients, columns=['rescaled coefficients']) p_values = results.pvalues p_values_df = pd.DataFrame(p_values, columns=['p_values']) -#results_df = pd.concat([coefficient_names, coefficients_df, p_values_df, rescaled_coefficients_df], axis=1) results_df = pd.concat([coefficient_names, coefficients_df, p_values_df], axis=1) results_df.to_csv('/Users/rem76/Desktop/Climate_change_health/Data/results_of_model_historical.csv') @@ -465,21 +465,10 @@ def repeat_info(info, num_facilities, year_range, historical): list(resid_encoded.columns) + list(zone_encoded.columns) + \ list(owner_encoded.columns) coefficient_names_weather = pd.Series(coefficient_names_weather) -print(coefficient_names_weather[included_weather]) -print(coefficient_names_weather) +coefficient_names_weather = coefficient_names_weather[included_weather] coefficients_weather = results_of_weather_model.params coefficients_weather_df = pd.DataFrame(coefficients_weather, columns=['coefficients']) -#rescale coefficients -# continuous_coefficients = coefficients_weather[:len(X_continuous_scaled[0])] -# categorical_coefficients = coefficients_weather[len(X_continuous_scaled[0]):] -# means = scaler.mean_ -# scales = scaler.scale_ -# rescaled_continuous_coefficients = continuous_coefficients * scales -# rescaled_coefficients_weather = np.concatenate([rescaled_continuous_coefficients, categorical_coefficients]) -# rescaled_coefficients_weather = np.concatenate([continuous_coefficients, categorical_coefficients]) -# -# rescaled_coefficients_df = pd.DataFrame(rescaled_coefficients_weather, columns=['rescaled coefficients']) p_values_weather = results_of_weather_model.pvalues p_values_weather_df = pd.DataFrame(p_values_weather, columns=['p_values']) @@ -687,7 +676,8 @@ def get_weather_data(ssp_scenario, model_type): X_basis_weather = np.column_stack([X_continuous_weather_scaled, X_categorical_weather]) X_basis_weather_filtered = X_basis_weather[X_basis_weather[:, 0] > mask_threshold] - X_basis_weather_filtered = X_basis_weather_filtered[included_weather] # account for model selection in previous steps + + X_basis_weather_filtered = X_basis_weather_filtered[:,included_weather] # account for model selection in previous steps # format output year_month_labels = np.array([f"{y}-{m}" for y, m in zip(X_basis_weather_filtered[:, 2], X_basis_weather[:, 3])]) predictions_weather = results_of_weather_model.predict(X_basis_weather_filtered) @@ -719,7 +709,7 @@ def get_weather_data(ssp_scenario, model_type): X_continuous_ANC_scaled = X_continuous_ANC X_bases_ANC_standardized = np.column_stack([X_continuous_ANC_scaled, X_categorical_ANC]) - X_bases_ANC_standardized = X_bases_ANC_standardized[included] # account for model selection in previous steps + X_bases_ANC_standardized = X_bases_ANC_standardized[:,included] # account for model selection in previous steps y_pred_ANC = results.predict(X_bases_ANC_standardized) predictions = np.exp(predictions_weather) - np.exp(y_pred_ANC[X_basis_weather[:, 0] > mask_threshold]) data_weather_predictions['y_pred_no_weather'] = np.exp(y_pred_ANC[X_basis_weather[:, 0] > mask_threshold]) From 5b9d95df1ff5bb6d36873985e7ac4f716e1fd211 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 24 Jan 2025 10:15:23 +0000 Subject: [PATCH 225/291] Added annual and monthly precipitation for clinics --- .../plotting_heavy_precipitation.py | 109 ++++++++++-------- 1 file changed, 60 insertions(+), 49 deletions(-) diff --git a/src/scripts/climate_change/plotting_heavy_precipitation.py b/src/scripts/climate_change/plotting_heavy_precipitation.py index 57e4768051..37afda047c 100644 --- a/src/scripts/climate_change/plotting_heavy_precipitation.py +++ b/src/scripts/climate_change/plotting_heavy_precipitation.py @@ -91,52 +91,63 @@ plt.show() plt.savefig('/Users/rem76/Desktop/Climate_change_health/Results/ANC_disruptions/histroical_future_precip_annual.png') -## Plot 95% CI -# -# fig, axes = plt.subplots(1, 3, figsize=(18, 6), sharex=True, sharey=True) -# axes = axes.flatten() -# -# for i, scenario in enumerate(scenarios): -# scenario_directory = os.path.join(base_dir, scenario) -# file_path_downscaled = f"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/CIL_combined_{scenario}_2024_2070.nc" -# data_all_models = xr.open_dataset(file_path_downscaled) -# model_annual_precip = data_all_models.mean(dim=['lat', 'lon', 'model'], skipna=True) -# #model_annual_precip = pr_aggregated_mean['pr'].resample(time='YE').sum('time') -# std_pr_annual = data_all_models.std(dim=['lat', 'lon', "model"], skipna=True) -# #std_pr_annual = std_pr['pr'].resample(time='YE').sum('time') -# print(model_annual_precip) -# print(len(model_annual_precip)) -# upper_bound = model_annual_precip['pr'] + std_pr_annual['pr'] -# lower_bound = model_annual_precip['pr'] - std_pr_annual['pr'] -# axes[i].plot( -# range(0, len(era5_precipitation_data)), -# era5_precipitation_data * 1000, -# color="#1C6E8C", -# linewidth=2, -# linestyle='--', -# marker='o', -# markersize=6, -# label='ERA5 Precipitation', -# ) -# -# axes[i].plot( -# range(len(era5_precipitation_data),len(era5_precipitation_data) +len(model_annual_precip)), -# model_annual_precip.to_dataarray(), -# label="Ensemble mean", -# color = 'black' -# ) -# axes[i].fill_between( -# range(len(era5_precipitation_data), len(era5_precipitation_data) + len(model_annual_precip)), -# lower_bound, -# upper_bound, -# color="#9AC4F8", -# alpha=0.3, -# ) -# axes[i].set_title(scenario.upper()) -# axes[i].set_xlabel('Year') -# #axes[i].legend(fontsize='small') -# -# fig.text(0.04, 0.5, 'Annual Precipitation (mm)', va='center', rotation='vertical') -# -# plt.tight_layout() -# plt.show() +## now do model ensembles + +model_types = ['lowest', 'mean', 'highest'] +# Configuration and constants +min_year_for_analysis = 2025 +absolute_min_year = 2024 +max_year_for_analysis = 2071 +data_path = "/Users/rem76/Desktop/Climate_change_health/Data/" + +# Define SSP scenario +ssp_scenarios = ["ssp126", "ssp245", "ssp585"] + +fig, axes = plt.subplots(1, 3, figsize=(18, 6), sharex=True, sharey=True) +axes = axes.flatten() +historical_weather = pd.read_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_ANC_lm.csv", + index_col=0) +print(historical_weather) +historical_weather = historical_weather.mean(axis = 1) +historical_weather = historical_weather.to_frame(name='mean_precipitation') +historical_weather.reset_index() +historical_weather_sum = historical_weather.groupby(historical_weather.index // 12).sum() +print(historical_weather_sum) +for i, ssp_scenario in enumerate(ssp_scenarios): + axes[i].plot( + range(len(historical_weather_sum)), + historical_weather_sum, + color="#312F2F", + linewidth=2, + linestyle='--', + label='ERA5' + ) + for model in model_types: + weather_data_prediction_monthly_original = pd.read_csv( + f"{data_path}Precipitation_data/Downscaled_CMIP6_data_CIL/{ssp_scenario}/{model}_monthly_prediction_weather_by_facility.csv", + dtype={'column_name': 'float64'}, index_col=0 + ) + + y_data = weather_data_prediction_monthly_original.mean(axis = 1) + y_data = y_data.to_frame(name='mean_precipitation') + y_data.reset_index(inplace=True) + y_data = y_data.groupby( + y_data.index // 12 + ).sum() + axes[i].plot( + range(len(historical_weather_sum), len(historical_weather_sum) + len(y_data)), + y_data['mean_precipitation'], + label=f"{model}", + ) + + # Fix xticks and labels + axes[i].set_xticklabels(range(2024, 2071, 5)) + axes[i].set_title(ssp_scenario.upper()) + axes[i].set_xlabel('Year') + if i == 0: + axes[i].set_ylabel('Annual Precipitation (mm)') + axes[i].legend() + +plt.tight_layout() +plt.show() From f77998d4c2d09ca2d11d2943bb4b30ec6a38a449 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 24 Jan 2025 17:19:29 +0000 Subject: [PATCH 226/291] Added average historical disruption --- src/scripts/climate_change/cohort_model.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/scripts/climate_change/cohort_model.py b/src/scripts/climate_change/cohort_model.py index d25957e5c8..055c55e572 100644 --- a/src/scripts/climate_change/cohort_model.py +++ b/src/scripts/climate_change/cohort_model.py @@ -442,7 +442,8 @@ percentage_diff_by_district_historical = historical_predictions_sum.groupby('District')['Percentage_Difference'].mean() malawi_admin2['Percentage_Difference_historical'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district_historical) malawi_admin2.loc[malawi_admin2['Percentage_Difference_historical'] > 0, 'Percentage_Difference_historical'] = 0 - +percentage_diff_by_district_historical_average = historical_predictions_sum['Percentage_Difference'].mean() +print(percentage_diff_by_district_historical_average) fig, ax = plt.subplots(figsize=(10, 10)) From f491e1c577f0b59dbbb201ed0e7457abfd0f3264 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 28 Jan 2025 09:51:59 +0000 Subject: [PATCH 227/291] Fixed the axes --- .../climate_change/plotting_heavy_precipitation.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/scripts/climate_change/plotting_heavy_precipitation.py b/src/scripts/climate_change/plotting_heavy_precipitation.py index 37afda047c..6a161a8959 100644 --- a/src/scripts/climate_change/plotting_heavy_precipitation.py +++ b/src/scripts/climate_change/plotting_heavy_precipitation.py @@ -80,7 +80,8 @@ # label="Median", # color='black' # ) - axes[i].set_xticklabels(range(2025,2071)) + axes[i].set_xticks(range(0, len(era5_precipitation_data) + len(model_annual_precip), 10)) + axes[i].set_xticklabels(range(2010, 2071, 10)) axes[i].set_title(scenario.upper()) axes[i].set_xlabel('Year') if i == 0: @@ -108,12 +109,10 @@ historical_weather = pd.read_csv( "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_ANC_lm.csv", index_col=0) -print(historical_weather) historical_weather = historical_weather.mean(axis = 1) historical_weather = historical_weather.to_frame(name='mean_precipitation') historical_weather.reset_index() historical_weather_sum = historical_weather.groupby(historical_weather.index // 12).sum() -print(historical_weather_sum) for i, ssp_scenario in enumerate(ssp_scenarios): axes[i].plot( range(len(historical_weather_sum)), @@ -142,7 +141,8 @@ ) # Fix xticks and labels - axes[i].set_xticklabels(range(2024, 2071, 5)) + axes[i].set_xticks(range(0,len(historical_weather_sum) + len(y_data), 10)) + axes[i].set_xticklabels(range(2010, 2071, 10)) axes[i].set_title(ssp_scenario.upper()) axes[i].set_xlabel('Year') if i == 0: From b89531f40433507e82b64d2e7e17b1bcfced3694 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 28 Jan 2025 09:53:08 +0000 Subject: [PATCH 228/291] Fixed the saving --- src/scripts/climate_change/plotting_heavy_precipitation.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/scripts/climate_change/plotting_heavy_precipitation.py b/src/scripts/climate_change/plotting_heavy_precipitation.py index 6a161a8959..5a8a4516c2 100644 --- a/src/scripts/climate_change/plotting_heavy_precipitation.py +++ b/src/scripts/climate_change/plotting_heavy_precipitation.py @@ -89,7 +89,6 @@ axes[i].legend() plt.tight_layout() -plt.show() plt.savefig('/Users/rem76/Desktop/Climate_change_health/Results/ANC_disruptions/histroical_future_precip_annual.png') ## now do model ensembles @@ -150,4 +149,4 @@ axes[i].legend() plt.tight_layout() -plt.show() +plt.savefig('/Users/rem76/Desktop/Climate_change_health/Results/ANC_disruptions/histroical_future_precip_annual_selected_models.png') From b0f681d785ea1f1de71dd5b6e89ae5f492e35674 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 29 Jan 2025 12:12:36 +0000 Subject: [PATCH 229/291] Added difference between models --- ...al_realtionship_reporting_precipitation.py | 33 ++++++++++++++++++- 1 file changed, 32 insertions(+), 1 deletion(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index dd668ef71e..c654fb3bf1 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -482,7 +482,6 @@ def repeat_info(info, num_facilities, year_range, historical): fig, axs = plt.subplots(1, 2, figsize=(10, 6)) - indices_ANC_data = np.where(mask_ANC_data)[0] indices_all_data = np.where(mask_all_data)[0] common_indices = np.intersect1d(indices_ANC_data, indices_all_data) @@ -507,8 +506,40 @@ def repeat_info(info, num_facilities, year_range, historical): axs[0].legend(loc='upper left', borderaxespad=0.) +plt.show() +## average of predictions + +data_weather_predictions = pd.DataFrame({ + 'Year': np.array(year_flattened)[mask_all_data], + 'Year_Month': year_month_labels_filtered, + 'y_pred_weather': np.exp(matched_y_pred_weather), + 'y_pred_no_weather': np.exp(matched_y_pred), + 'difference': np.exp(matched_y_pred) - np.exp(matched_y_pred_weather) +}) + +data_weather_predictions_grouped = data_weather_predictions.groupby('Year', as_index=False).sum() + +fig, ax = plt.subplots(figsize=(7, 7)) + +ax.scatter(data_weather_predictions_grouped['Year'], + data_weather_predictions_grouped['difference'], + color='#823038', alpha=0.7, label='Difference ANC services predicted by non-weather and weather models') + +ax.axhline(y=0, color='black', linestyle='--', linewidth=1) + +y_max = max(abs(data_weather_predictions_grouped['difference'])) + 50 +ax.set_ylim(-y_max, y_max) + +ax.set_xlabel('Year') +ax.set_ylabel('Mean monthly ANC services provided') +ax.set_xticks(data_weather_predictions_grouped['Year']) +ax.set_xticklabels(data_weather_predictions_grouped['Year'], rotation=45, ha='right') +ax.legend(loc='upper left') + plt.show() +plt.tight_layout() +plt.show() ## save historical predictions full_data_weather_predictions_historical = pd.DataFrame({ 'Year': np.array(year_flattened)[mask_all_data], From cf657254410840fc12fd3673ff9d21b4c9827edf Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 29 Jan 2025 12:14:03 +0000 Subject: [PATCH 230/291] changed axis label --- ...ear_model_historical_realtionship_reporting_precipitation.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index c654fb3bf1..9ec8e0f00a 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -523,7 +523,7 @@ def repeat_info(info, num_facilities, year_range, historical): ax.scatter(data_weather_predictions_grouped['Year'], data_weather_predictions_grouped['difference'], - color='#823038', alpha=0.7, label='Difference ANC services predicted by non-weather and weather models') + color='#823038', alpha=0.7, label='Difference in Predicted ANC Services (Without vs. With Precipitation)') ax.axhline(y=0, color='black', linestyle='--', linewidth=1) From 5a2c12b5d377a6ec49a5904df203c314b33c21e5 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 29 Jan 2025 13:20:43 +0000 Subject: [PATCH 231/291] changed axis label --- ...model_historical_realtionship_reporting_precipitation.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 9ec8e0f00a..af534b2a02 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -523,7 +523,7 @@ def repeat_info(info, num_facilities, year_range, historical): ax.scatter(data_weather_predictions_grouped['Year'], data_weather_predictions_grouped['difference'], - color='#823038', alpha=0.7, label='Difference in Predicted ANC Services (Without vs. With Precipitation)') + color='#823038', alpha=0.7,) ax.axhline(y=0, color='black', linestyle='--', linewidth=1) @@ -531,10 +531,10 @@ def repeat_info(info, num_facilities, year_range, historical): ax.set_ylim(-y_max, y_max) ax.set_xlabel('Year') -ax.set_ylabel('Mean monthly ANC services provided') +ax.set_ylabel('Difference in Predicted ANC Services (Without vs. With Precipitation)') ax.set_xticks(data_weather_predictions_grouped['Year']) ax.set_xticklabels(data_weather_predictions_grouped['Year'], rotation=45, ha='right') -ax.legend(loc='upper left') +#ax.legend(loc='upper left') plt.show() From 8fe462438eb0fc494be85e17304fddb9e22418e1 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 30 Jan 2025 20:49:15 +0000 Subject: [PATCH 232/291] added squares --- ...model_historical_realtionship_reporting_precipitation.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index af534b2a02..3b1ddeee00 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -422,6 +422,8 @@ def repeat_info(info, num_facilities, year_range, historical): # Continuous columns that need to be standardized (weather_data, lag variables, altitude, minimum_distance) X_continuous = np.column_stack([ weather_data, + weather_data[:,0]*weather_data[:,0], + weather_data[:,1] * weather_data[:,1], np.array(year_flattened), np.array(month_flattened), lag_1_month, @@ -458,7 +460,7 @@ def repeat_info(info, num_facilities, year_range, historical): # X_mask_mm=mask_threshold, feature_selection = feature_selection) included_weather, results_of_weather_model, y_pred_weather, mask_all_data = stepwise_selection(X_weather_standardized , y, poisson = poisson, log_y=log_y,) -coefficient_names_weather = ["precip_monthly_total", "precip_5_day_max", "year", "month", +coefficient_names_weather = ["precip_monthly_total", "precip_5_day_max", "precip_monthly_total_2", "precip_5_day_max_2", "year", "month", "lag_1_month", "lag_2_month", "lag_3_month", "lag_4_month", "lag_9_month", "lag_1_5_day", "lag_2_5_day", "lag_3_5_day", "lag_4_5_day", "lag_9_month", "altitude", "minimum_distance"] + \ @@ -466,7 +468,7 @@ def repeat_info(info, num_facilities, year_range, historical): list(owner_encoded.columns) coefficient_names_weather = pd.Series(coefficient_names_weather) coefficient_names_weather = coefficient_names_weather[included_weather] - +print(coefficient_names_weather) coefficients_weather = results_of_weather_model.params coefficients_weather_df = pd.DataFrame(coefficients_weather, columns=['coefficients']) From df7e88c4d40b0803b804b98bb6aa871b309cf5eb Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 31 Jan 2025 11:17:35 +0000 Subject: [PATCH 233/291] added squares --- ...model_historical_realtionship_reporting_precipitation.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 3b1ddeee00..61d9b63453 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -424,6 +424,9 @@ def repeat_info(info, num_facilities, year_range, historical): weather_data, weather_data[:,0]*weather_data[:,0], weather_data[:,1] * weather_data[:,1], + weather_data[:, 0] * weather_data[:, 0] * weather_data[:, 0], + weather_data[:, 1] * weather_data[:, 1] * weather_data[:, 1], + weather_data[:, 1] * weather_data[:,0], np.array(year_flattened), np.array(month_flattened), lag_1_month, @@ -460,7 +463,8 @@ def repeat_info(info, num_facilities, year_range, historical): # X_mask_mm=mask_threshold, feature_selection = feature_selection) included_weather, results_of_weather_model, y_pred_weather, mask_all_data = stepwise_selection(X_weather_standardized , y, poisson = poisson, log_y=log_y,) -coefficient_names_weather = ["precip_monthly_total", "precip_5_day_max", "precip_monthly_total_2", "precip_5_day_max_2", "year", "month", +coefficient_names_weather = ["precip_monthly_total", "precip_5_day_max", "precip_monthly_total_2", "precip_5_day_max_2", + "precip_monthly_total_3", "precip_5_day_max_3", "5_day_monthly", "year", "month", "lag_1_month", "lag_2_month", "lag_3_month", "lag_4_month", "lag_9_month", "lag_1_5_day", "lag_2_5_day", "lag_3_5_day", "lag_4_5_day", "lag_9_month", "altitude", "minimum_distance"] + \ From 9486b6636367ba1f0fb694a9b1ab66368fe18ca9 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 31 Jan 2025 12:14:02 +0000 Subject: [PATCH 234/291] Added inpatient data --- .../process_daily_total_historical_data.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/scripts/climate_change/process_daily_total_historical_data.py b/src/scripts/climate_change/process_daily_total_historical_data.py index 8405293f98..4e4e1129da 100644 --- a/src/scripts/climate_change/process_daily_total_historical_data.py +++ b/src/scripts/climate_change/process_daily_total_historical_data.py @@ -7,7 +7,7 @@ import pandas as pd from netCDF4 import Dataset -ANC = True +ANC = False # facility data multiplier = 1000 five_day = True @@ -31,7 +31,7 @@ if ANC: reporting_data = pd.read_csv('/Users/rem76/Desktop/Climate_change_health/Data/ANC_data/ANC_data_2011_2024.csv') #January 2011 - January 2024 else: - reporting_data = pd.read_csv('/Users/rem76/Desktop/Climate_change_health/Data/Reporting_Rate/Reporting_Rate_by_smaller_facilities_2011_2024.csv') #January 2011 - January 2024 + reporting_data = pd.read_csv('/Users/rem76/Desktop/Climate_change_health/Data/Inpatient_Data/HMIS_Total_Number_Admissions.csv') #January 2011 - January 2024 # ANALYSIS DONE IN OCTOBER 2024 - so drop October, November, December 2024 columns_to_drop = reporting_data.columns[reporting_data.columns.str.endswith(('October 2024', 'November 2024', 'December 2024'))] reporting_data = reporting_data.drop(columns=columns_to_drop) @@ -151,14 +151,14 @@ if ANC: df_of_facilities.to_csv(Path(base_dir) / "historical_daily_total_by_facilities_with_ANC_five_day_cumulative.csv") else: - df_of_facilities.to_csv(Path(base_dir) / "historical_daily_total_by_facility_five_day_cumulative.csv") + df_of_facilities.to_csv(Path(base_dir) / "historical_daily_total_by_facility_five_day_cumulative_inpatient.csv") else: if ANC: df_of_facilities.to_csv(Path(base_dir) / "historical_daily_total_by_facilities_with_ANC_five_day_average.csv") else: - df_of_facilities.to_csv(Path(base_dir) / "historical_daily_total_by_facility_five_day_average.csv") + df_of_facilities.to_csv(Path(base_dir) / "historical_daily_total_by_facility_five_day_average_inpatient.csv") else: if ANC: df_of_facilities.to_csv(Path(base_dir) / "historical_daily_total_by_facilities_with_ANC.csv") else: - df_of_facilities.to_csv(Path(base_dir) / "historical_daily_total_by_facility.csv") + df_of_facilities.to_csv(Path(base_dir) / "historical_daily_total_by_facility_inpatient.csv") From 92e604f10a64c7e10f0ac2e6771f38392254b33d Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 31 Jan 2025 15:37:14 +0000 Subject: [PATCH 235/291] Made more cohesive for inpatient data --- .../process_daily_total_historical_data.py | 9 ++++++++- ...ng_and_monthly_weather_data_small_facilities.py | 14 +++++++++----- 2 files changed, 17 insertions(+), 6 deletions(-) diff --git a/src/scripts/climate_change/process_daily_total_historical_data.py b/src/scripts/climate_change/process_daily_total_historical_data.py index 4e4e1129da..bbdb9543d4 100644 --- a/src/scripts/climate_change/process_daily_total_historical_data.py +++ b/src/scripts/climate_change/process_daily_total_historical_data.py @@ -10,7 +10,7 @@ ANC = False # facility data multiplier = 1000 -five_day = True +five_day = False cumulative = True general_facilities = gpd.read_file("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_districts.shp") @@ -111,6 +111,10 @@ for reporting_facility in monthly_reporting_by_facility["facility"]: matching_facility_name = difflib.get_close_matches(reporting_facility, facilities_with_lat_long['Fname'], n=3, cutoff=0.90) + + if (reporting_facility == "Central Hospital"): + matching_facility_name = "Lilongwe City Assembly Chinsapo" + if matching_facility_name: match_name = matching_facility_name[0] # Access the string directly # Initialize facility key if not already @@ -140,6 +144,9 @@ max_average_by_facility[reporting_facility].append(max_moving_average * multiplier) begin_day += month_length + + + # df_of_facilities = pd.DataFrame.from_dict(max_average_by_facility, orient='index') df_of_facilities = df_of_facilities.iloc[:, :-3] ## THESE ARE OCT/NOV/DEC OF 2024, and for moment don't have that reporting data diff --git a/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py b/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py index 7d2ae146ff..10fd5e3f02 100644 --- a/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py +++ b/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py @@ -9,8 +9,8 @@ # Data accessed from https://dhis2.health.gov.mw/dhis-web-data-visualizer/#/YiQK65skxjz # Reporting rate is expected reporting vs actual reporting -ANC = True -Inpatient = False +ANC = False +Inpatient = True multiplier = 1000 if ANC: reporting_data = pd.read_csv('/Users/rem76/Desktop/Climate_change_health/Data/ANC_data/ANC_data_2011_2024.csv') @@ -32,13 +32,12 @@ months = set(col.split("HMIS Total # of Admissions (including Maternity) ")[1] for col in reporting_data.columns if "HMIS Total # of Admissions (including Maternity) " in col) else: months = set(col.split(" - Reporting rate ")[1] for col in reporting_data.columns if " - Reporting rate " in col) -months = set(col.split("HMIS Total Antenatal Visits ")[1] for col in reporting_data.columns if "HMIS Total Antenatal Visits " in col) +#months = set(col.split("HMIS Total Antenatal Visits ")[1] for col in reporting_data.columns if "HMIS Total Antenatal Visits " in col) # put in order months = [date.strip() for date in months] # extra spaces?? dates = pd.to_datetime(months, format='%B %Y', errors='coerce') months = dates.sort_values().strftime('%B %Y').tolist() # puts them in ascending order -print(months) for month in months: columns_of_interest_all_metrics = [reporting_data.columns[1]] + reporting_data.columns[reporting_data.columns.str.endswith(month)].tolist() data_of_interest_by_month = reporting_data[columns_of_interest_all_metrics] @@ -93,7 +92,6 @@ general_facilities = gpd.read_file("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_districts.shp") facilities_with_lat_long = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_lat_long_region.csv") -print(facilities_with_lat_long.columns) weather_data_by_facility = {} facilities_with_location = [] for reporting_facility in monthly_reporting_by_facility["facility"]: @@ -124,9 +122,11 @@ elif reporting_facility == "Central East Zone": grid = general_facilities[general_facilities["District"] == "Nkhotakota"]["Grid_Index"].iloc[0] # furtherst east zone weather_data_by_facility[reporting_facility] = weather_by_grid[grid] + facilities_with_location.append(reporting_facility) elif (reporting_facility == "Central Hospital"): grid = general_facilities[general_facilities["District"] == "Lilongwe City"]["Grid_Index"].iloc[0] # all labelled X City will be in the same grid weather_data_by_facility[reporting_facility] = weather_by_grid[grid] + facilities_with_location.append(reporting_facility) else: continue @@ -153,11 +153,15 @@ weather_df.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facility_lm.csv") +for facility in facilities_with_location: + print(facility) ## Get additional data - e.g. which zone it is in, altitude included_facilities_with_lat_long = facilities_with_lat_long[ facilities_with_lat_long["Fname"].isin(facilities_with_location) ] +unique_columns = set(facilities_with_location) - set(included_facilities_with_lat_long) +print(unique_columns) additional_rows = ["Zonename", "Resid", "Dist", "A105", "A109__Altitude", "Ftype", 'A109__Latitude', 'A109__Longitude'] expanded_facility_info = included_facilities_with_lat_long[["Fname"] + additional_rows] expanded_facility_info['Dist'] = expanded_facility_info['Dist'].replace("Blanytyre", "Blantyre") From 467619890e198125e7a6f1093edf7648ccba72ce Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 3 Feb 2025 09:57:49 +0000 Subject: [PATCH 236/291] Removed x mask from build model as it was getting it wrong when doing the model selection. moved to after setting up all the variables. --- ...al_realtionship_reporting_precipitation.py | 100 ++++++++++++------ 1 file changed, 69 insertions(+), 31 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 61d9b63453..7c860ed6e6 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -10,6 +10,11 @@ from sklearn.feature_selection import SelectKBest, f_regression ANC = True +Inpatient = False +if ANC: + service = 'ANC' +if Inpatient: + service = 'Inpatient' daily_max = False daily_total = False if daily_total: @@ -23,7 +28,8 @@ min_year_for_analysis = 2012 absolute_min_year = 2011 mask_threshold = -np.inf # accounts for scaling -use_percentile_mask_threshold = False +#mask_threshold = 50 +use_percentile_mask_threshold = True poisson = False log_y = True @@ -50,9 +56,10 @@ # # data is from 2011 - 2024 - for facility if ANC: monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_ANC_by_smaller_facility_lm.csv", index_col=0) +elif Inpatient: + monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_Inpatient_by_smaller_facility_lm.csv", index_col=0) - -def build_model(X, y, poisson=False, log_y=False, X_mask_mm=0, feature_selection=False, k_best=None): +def build_model(X, y, poisson=False, log_y=False, feature_selection=False, k_best=None): epsilon = 1 # Log-transform y with clipping for positivity @@ -60,8 +67,7 @@ def build_model(X, y, poisson=False, log_y=False, X_mask_mm=0, feature_selection y = np.log(np.clip(y, epsilon, None)) # Apply mask to filter valid data - mask = (~np.isnan(X).any(axis=1) & ~np.isnan(y) & - (X[:, 0] >= X_mask_mm) & (y <= 1e4)) + mask = (~np.isnan(X).any(axis=1) & ~np.isnan(y) & (y <= 1e4)) X_filtered, y_filtered = X[mask], y[mask] # Feature selection step (optional) @@ -107,7 +113,7 @@ def stepwise_selection(X, y, log_y, poisson, p_value_threshold=0.05): new_aic = pd.Series(index=excluded, dtype=float) for new_column in excluded: subset_X = X[:, included + [new_column]] - results, y_pred, mask_ANC_data, _ = build_model(subset_X, y, poisson, log_y=log_y, X_mask_mm=mask_threshold) + results, y_pred, mask_ANC_data, _ = build_model(subset_X, y, poisson, log_y=log_y) new_aic[new_column] = results.aic # Add the predictor with the best AIC if it's better than the current model's AIC @@ -123,7 +129,7 @@ def stepwise_selection(X, y, log_y, poisson, p_value_threshold=0.05): if not changed: break included.sort() - results, y_pred, mask_ANC_data, _ = build_model(X[:, included], y, poisson, log_y=log_y, X_mask_mm=mask_threshold) + results, y_pred, mask_ANC_data, _ = build_model(X[:, included], y, poisson, log_y=log_y) return included, results, y_pred, mask_ANC_data @@ -144,13 +150,22 @@ def repeat_info(info, num_facilities, year_range, historical): # ### Try combine weather variables ## if use_all_weather: - weather_data_monthly_original = pd.read_csv( - "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_ANC_lm.csv", - index_col=0) - - weather_data_five_day_cumulative_original = pd.read_csv( - "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/historical_daily_total_by_facilities_with_ANC_five_day_cumulative.csv", - index_col=0) + if ANC: + weather_data_monthly_original = pd.read_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_ANC_lm.csv", + index_col=0) + + weather_data_five_day_cumulative_original = pd.read_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/historical_daily_total_by_facilities_with_ANC_five_day_cumulative.csv", + index_col=0) + if Inpatient: + weather_data_monthly_original = pd.read_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_Inpatient_lm.csv", + index_col=0) + + weather_data_five_day_cumulative_original = pd.read_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/historical_daily_total_by_facility_five_day_cumulative_inpatient.csv", + index_col=0) ############################################################################################## ########################## STEP 0: Tidy data ########################## ############################################################################################## @@ -166,7 +181,6 @@ def repeat_info(info, num_facilities, year_range, historical): weather_data_monthly_df = weather_data_monthly_df.drop(weather_data_monthly_df.index[-2:]) weather_data_five_day_cumulative_df = weather_data_five_day_cumulative_df.drop(weather_data_five_day_cumulative_df.index[-1:]) - lag_1_month = weather_data_monthly_df.shift(1).values lag_2_month = weather_data_monthly_df.shift(2).values lag_3_month = weather_data_monthly_df.shift(3).values @@ -206,6 +220,8 @@ def repeat_info(info, num_facilities, year_range, historical): weather_data_five_day_cumulative = weather_data_five_day_cumulative.iloc[(min_year_for_analysis - absolute_min_year) * 12:] weather_data_monthly_flattened = weather_data_monthly.values.flatten() weather_data_five_day_cumulative_flattened = weather_data_five_day_cumulative.values.flatten() + print(len(weather_data_five_day_cumulative_flattened)) + weather_data = np.vstack((weather_data_monthly_flattened,weather_data_five_day_cumulative_flattened)).T # # Mask COVID-19 months for reporting @@ -240,9 +256,6 @@ def repeat_info(info, num_facilities, year_range, historical): if np.nanmin(y) < 1: y += 1 # Shift to ensure positivity as taking log y[y > 4e3] = np.nan -if use_percentile_mask_threshold: - mask_threshold = np.nanpercentile(weather_data, 90) - print(mask_threshold) # One-hot encode facilities facility_encoded = pd.get_dummies(facility_flattened, drop_first=True) @@ -255,8 +268,9 @@ def repeat_info(info, num_facilities, year_range, historical): # Prepare additional facility info if ANC: expanded_facility_info = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_with_ANC.csv", index_col=0) -else: - expanded_facility_info = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm.csv", index_col=0) +elif Inpatient: + expanded_facility_info = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_with_inpatient_days.csv", index_col=0) + expanded_facility_info = expanded_facility_info.drop(columns=zero_sum_columns) expanded_facility_info = expanded_facility_info.T.reindex(columns=expanded_facility_info.index) @@ -357,7 +371,8 @@ def repeat_info(info, num_facilities, year_range, historical): p_values_df = pd.DataFrame(p_values, columns=['p_values']) results_df = pd.concat([coefficient_names, coefficients_df, p_values_df], axis=1) -results_df.to_csv('/Users/rem76/Desktop/Climate_change_health/Data/results_of_model_historical.csv') +results_df.to_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/results_of_model_historical_{service}.csv') + y_weather = np.exp(y_pred) @@ -393,8 +408,14 @@ def repeat_info(info, num_facilities, year_range, historical): axs[0].set_xticks(xticks) axs[0].set_xticklabels(xticks, rotation=45, ha='right') axs[0].set_xlabel('Year') -axs[0].set_ylabel('Number of ANC visits') -axs[0].set_title('A: Monthly ANC Visits vs. Precipitation') +axs[0].set_ylabel(f'Number of {service} visits') +axs[0].set_title(f'A: Monthly {service} Visits vs. Precipitation') + + + + + + axs[0].legend(loc='upper left') # Panel B: Residuals @@ -458,6 +479,13 @@ def repeat_info(info, num_facilities, year_range, historical): X_continuous_scaled = X_continuous X_weather_standardized = np.column_stack([X_continuous_scaled, X_categorical]) +if use_percentile_mask_threshold: + mask_threshold = np.nanpercentile(X_weather_standardized[:,0], 5) + print(mask_threshold) + X_weather_standardized[:, 0] = np.where( + X_weather_standardized[:, 0] < mask_threshold, np.nan, X_weather_standardized[:, 0] + ) + print(X_weather_standardized[:, 0] ) # results_of_weather_model, y_pred_weather, mask_all_data, selected_features = build_model(X_weather_standardized, y, poisson = poisson, log_y=log_y, # X_mask_mm=mask_threshold, feature_selection = feature_selection) @@ -479,7 +507,7 @@ def repeat_info(info, num_facilities, year_range, historical): p_values_weather = results_of_weather_model.pvalues p_values_weather_df = pd.DataFrame(p_values_weather, columns=['p_values']) results_weather_df = pd.concat([coefficient_names_weather, coefficients_weather_df, p_values_weather_df, rescaled_coefficients_df], axis=1) -results_weather_df.to_csv('/Users/rem76/Desktop/Climate_change_health/Data/results_of_weather_model_historical.csv') +results_weather_df.to_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/results_of_weather_model_historical{service}.csv') print("All predictors", results_of_weather_model.summary()) # @@ -500,7 +528,9 @@ def repeat_info(info, num_facilities, year_range, historical): axs[0].hlines(y = 0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color = 'black', linestyle = '--') axs[0].scatter(X_filtered[:, 0], np.exp(y_pred_weather), label='Weather model', color="blue", alpha = 0.5) axs[0].hlines(y=0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color='black', linestyle='--') -axs[0].set_ylabel('ANC visits') +axs[0].set_ylabel(f'{service} visits') + + axs[1].scatter(monthly_weather_predictions, np.exp(matched_y_pred_weather) - np.exp(matched_y_pred), color='red', alpha=0.5, label = 'Residuals') axs[1].hlines(y = 0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color = 'black', linestyle = '--') @@ -537,7 +567,10 @@ def repeat_info(info, num_facilities, year_range, historical): ax.set_ylim(-y_max, y_max) ax.set_xlabel('Year') -ax.set_ylabel('Difference in Predicted ANC Services (Without vs. With Precipitation)') +ax.set_ylabel(f'Difference in Predicted {service} Services (Without vs. With Precipitation)') + + + ax.set_xticks(data_weather_predictions_grouped['Year']) ax.set_xticklabels(data_weather_predictions_grouped['Year'], rotation=45, ha='right') #ax.legend(loc='upper left') @@ -566,7 +599,7 @@ def repeat_info(info, num_facilities, year_range, historical): 'Predicted_No_Weather_Model': np.exp(matched_y_pred), 'Difference_in_Expectation': np.exp(matched_y_pred_weather) - np.exp(matched_y_pred), }) -full_data_weather_predictions_historical.to_csv('/Users/rem76/Desktop/Climate_change_health/Data/results_of_ANC_model_historical_predictions.csv') +full_data_weather_predictions_historical.to_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/results_of_model_historical_predictions_{service}.csv') ############### ADD IN CMIP DATA ########################### @@ -682,6 +715,11 @@ def get_weather_data(ssp_scenario, model_type): X_continuous_weather = np.column_stack([ weather_data_prediction_flatten, + weather_data_prediction_flatten[:,0]*weather_data_prediction_flatten[:,0], + weather_data_prediction_flatten[:,1] * weather_data_prediction_flatten[:,1], + weather_data_prediction_flatten[:, 0] * weather_data_prediction_flatten[:, 0] * weather_data_prediction_flatten[:, 0], + weather_data_prediction_flatten[:, 1] * weather_data_prediction_flatten[:, 1] * weather_data_prediction_flatten[:, 1], + weather_data_prediction_flatten[:, 1] * weather_data_prediction_flatten[:,0], np.array(year_flattened_prediction), np.array(month_flattened_prediction), lag_1_month_prediction, @@ -763,7 +801,7 @@ def get_weather_data(ssp_scenario, model_type): xticks = data_weather_predictions['Year_Month'][::len(year_range) * 12 * num_facilities] axs[0].set_xticks(xticks) axs[0].set_xticklabels(xticks, rotation=45, ha='right') - axs[0].set_ylabel('Difference Predicted ANC visits due to rainfall') + axs[0].set_ylabel(f'Difference Predicted {service} visits due to rainfall') axs[0].legend(loc='upper left') plt.show() @@ -773,7 +811,7 @@ def get_weather_data(ssp_scenario, model_type): label='Predictions') axs[0].set_xlabel('Precipitation (mm)') - axs[0].set_ylabel('Difference in of ANC visits between weather and non-weather model') + axs[0].set_ylabel(f'Difference in of {service} visits between weather and non-weather model') plt.tight_layout() plt.show() @@ -799,9 +837,9 @@ def get_weather_data(ssp_scenario, model_type): }) #Save the results - full_data_weather_predictions.to_csv(f"{data_path}weather_predictions_with_X_{ssp_scenario}_{model_type}.csv", index=False) + full_data_weather_predictions.to_csv(f"{data_path}weather_predictions_with_X_{ssp_scenario}_{model_type}_{service}.csv", index=False) X_basis_weather_filtered = pd.DataFrame(X_basis_weather_filtered) # Save to CSV - X_basis_weather_filtered.to_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/X_basis_weather_filtered_predictions_{ssp_scenario}_{model_type}.csv', index=False) + X_basis_weather_filtered.to_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/X_basis_weather_filtered_predictions_{ssp_scenario}_{model_type}_{service}.csv', index=False) From 7ecc0238fb8442be3db4ce0e5de8d28290b91d3c Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 3 Feb 2025 09:58:01 +0000 Subject: [PATCH 237/291] Added in Inpatient services --- .../CIL_CMIP6_downscaling.ipynb | 9643 +++-------------- .../process_CMIP6_data_KDBall.py | 10 +- 2 files changed, 1513 insertions(+), 8140 deletions(-) diff --git a/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb b/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb index 4bd1e2f66a..16e1f68a13 100644 --- a/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb +++ b/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb @@ -9,8 +9,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-21T15:25:44.967657Z", - "start_time": "2025-01-21T15:25:43.119103Z" + "end_time": "2025-02-03T09:24:35.512924Z", + "start_time": "2025-02-03T09:24:34.693722Z" } }, "cell_type": "code", @@ -826,8 +826,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-21T15:25:47.737030Z", - "start_time": "2025-01-21T15:25:47.501189Z" + "end_time": "2025-02-03T09:24:38.516334Z", + "start_time": "2025-02-03T09:24:38.327240Z" } }, "cell_type": "code", @@ -856,7 +856,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/3940996484.py:16: DtypeWarning: Columns (58,59,105,127,136,142,149,150,258,285,296,319,344,345,360,393,394,427,428,437,449,450,452,453,461,462,478,479,489,490,492,493,494,497,498,499,500,501,502,503,572,580,585,586,587,588,591,592,593,594,607,608,609,610,619,620,621,622,626,634,872,887,967,978,1066,1510) have mixed types. Specify dtype option on import or set low_memory=False.\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/795972135.py:19: DtypeWarning: Columns (58,59,105,127,136,142,149,150,258,285,296,319,344,345,360,393,394,427,428,437,449,450,452,453,461,462,478,479,489,490,492,493,494,497,498,499,500,501,502,503,572,580,585,586,587,588,591,592,593,594,607,608,609,610,619,620,621,622,626,634,872,887,967,978,1066,1510) have mixed types. Specify dtype option on import or set low_memory=False.\n", " facilities_with_lat_long = pd.read_csv(\n" ] } @@ -866,8 +866,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-21T15:25:48.382454Z", - "start_time": "2025-01-21T15:25:48.377103Z" + "end_time": "2025-02-03T09:24:44.148767Z", + "start_time": "2025-02-03T09:24:44.142505Z" } }, "cell_type": "code", @@ -947,9 +947,11 @@ }, { "metadata": { + "jupyter": { + "is_executing": true + }, "ExecuteTime": { - "end_time": "2025-01-21T16:52:30.692579Z", - "start_time": "2025-01-21T15:25:49.979744Z" + "start_time": "2025-02-03T09:54:19.740895Z" } }, "cell_type": "code", @@ -1090,956 +1092,974 @@ "output_type": "stream", "text": [ "Processing scenario: ssp126\n", - "Saved combined dataset for ssp126 to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/CIL_combined_ssp126_2024_2070.nc\n", "Models of interest ['HadGEM3-GC31-LL', 'MPI-ESM1-2-LR', 'INM-CM5-0']\n", "Processing file: CIL_subset_ssp126_2024.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2024\n" + "Processing year 2024, month 1\n", + "Processing year 2024, month 2\n", + "Processing year 2024, month 3\n", + "Processing year 2024, month 4\n", + "Processing year 2024, month 5\n", + "Processing year 2024, month 6\n", + "Processing year 2024, month 7\n", + "Processing year 2024, month 8\n", + "Processing year 2024, month 9\n", + "Processing year 2024, month 10\n", + "Processing year 2024, month 11\n", + "Processing year 2024, month 12\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" ] }, @@ -2048,952 +2068,971 @@ "output_type": "stream", "text": [ "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2024\n" + "Processing year 2024, month 1\n", + "Processing year 2024, month 2\n", + "Processing year 2024, month 3\n", + "Processing year 2024, month 4\n", + "Processing year 2024, month 5\n", + "Processing year 2024, month 6\n", + "Processing year 2024, month 7\n", + "Processing year 2024, month 8\n", + "Processing year 2024, month 9\n", + "Processing year 2024, month 10\n", + "Processing year 2024, month 11\n", + "Processing year 2024, month 12\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" ] }, @@ -3002,952 +3041,971 @@ "output_type": "stream", "text": [ "Processing model: INM-CM5-0\n", - "Processing year 2024\n" + "Processing year 2024, month 1\n", + "Processing year 2024, month 2\n", + "Processing year 2024, month 3\n", + "Processing year 2024, month 4\n", + "Processing year 2024, month 5\n", + "Processing year 2024, month 6\n", + "Processing year 2024, month 7\n", + "Processing year 2024, month 8\n", + "Processing year 2024, month 9\n", + "Processing year 2024, month 10\n", + "Processing year 2024, month 11\n", + "Processing year 2024, month 12\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" ] }, @@ -3957,6724 +4015,35 @@ "text": [ "Processing file: CIL_subset_ssp126_2025.nc\n", "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2025\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2025\n", - "Processing model: INM-CM5-0\n", - "Processing year 2025\n", - "Processing file: CIL_subset_ssp126_2026.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2026\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2026\n", - "Processing model: INM-CM5-0\n", - "Processing year 2026\n", - "Processing file: CIL_subset_ssp126_2027.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2027\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2027\n", - "Processing model: INM-CM5-0\n", - "Processing year 2027\n", - "Processing file: CIL_subset_ssp126_2028.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2028\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2028\n", - "Processing model: INM-CM5-0\n", - "Processing year 2028\n", - "Processing file: CIL_subset_ssp126_2029.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2029\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2029\n", - "Processing model: INM-CM5-0\n", - "Processing year 2029\n", - "Processing file: CIL_subset_ssp126_2030.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2030\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2030\n", - "Processing model: INM-CM5-0\n", - "Processing year 2030\n", - "Processing file: CIL_subset_ssp126_2031.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2031\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2031\n", - "Processing model: INM-CM5-0\n", - "Processing year 2031\n", - "Processing file: CIL_subset_ssp126_2032.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2032\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2032\n", - "Processing model: INM-CM5-0\n", - "Processing year 2032\n", - "Processing file: CIL_subset_ssp126_2033.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2033\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2033\n", - "Processing model: INM-CM5-0\n", - "Processing year 2033\n", - "Processing file: CIL_subset_ssp126_2034.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2034\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2034\n", - "Processing model: INM-CM5-0\n", - "Processing year 2034\n", - "Processing file: CIL_subset_ssp126_2035.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2035\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2035\n", - "Processing model: INM-CM5-0\n", - "Processing year 2035\n", - "Processing file: CIL_subset_ssp126_2036.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2036\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2036\n", - "Processing model: INM-CM5-0\n", - "Processing year 2036\n", - "Processing file: CIL_subset_ssp126_2037.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2037\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2037\n", - "Processing model: INM-CM5-0\n", - "Processing year 2037\n", - "Processing file: CIL_subset_ssp126_2038.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2038\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2038\n", - "Processing model: INM-CM5-0\n", - "Processing year 2038\n", - "Processing file: CIL_subset_ssp126_2039.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2039\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2039\n", - "Processing model: INM-CM5-0\n", - "Processing year 2039\n", - "Processing file: CIL_subset_ssp126_2040.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2040\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2040\n", - "Processing model: INM-CM5-0\n", - "Processing year 2040\n", - "Processing file: CIL_subset_ssp126_2041.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2041\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2041\n", - "Processing model: INM-CM5-0\n", - "Processing year 2041\n", - "Processing file: CIL_subset_ssp126_2042.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2042\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2042\n", - "Processing model: INM-CM5-0\n", - "Processing year 2042\n", - "Processing file: CIL_subset_ssp126_2043.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2043\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2043\n", - "Processing model: INM-CM5-0\n", - "Processing year 2043\n", - "Processing file: CIL_subset_ssp126_2044.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2044\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2044\n", - "Processing model: INM-CM5-0\n", - "Processing year 2044\n", - "Processing file: CIL_subset_ssp126_2045.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2045\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2045\n", - "Processing model: INM-CM5-0\n", - "Processing year 2045\n", - "Processing file: CIL_subset_ssp126_2046.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2046\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2046\n", - "Processing model: INM-CM5-0\n", - "Processing year 2046\n", - "Processing file: CIL_subset_ssp126_2047.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2047\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2047\n", - "Processing model: INM-CM5-0\n", - "Processing year 2047\n", - "Processing file: CIL_subset_ssp126_2048.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2048\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2048\n", - "Processing model: INM-CM5-0\n", - "Processing year 2048\n", - "Processing file: CIL_subset_ssp126_2049.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2049\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2049\n", - "Processing model: INM-CM5-0\n", - "Processing year 2049\n", - "Processing file: CIL_subset_ssp126_2050.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2050\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2050\n", - "Processing model: INM-CM5-0\n", - "Processing year 2050\n", - "Processing file: CIL_subset_ssp126_2051.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2051\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2051\n", - "Processing model: INM-CM5-0\n", - "Processing year 2051\n", - "Processing file: CIL_subset_ssp126_2052.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2052\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2052\n", - "Processing model: INM-CM5-0\n", - "Processing year 2052\n", - "Processing file: CIL_subset_ssp126_2053.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2053\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2053\n", - "Processing model: INM-CM5-0\n", - "Processing year 2053\n", - "Processing file: CIL_subset_ssp126_2054.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2054\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2054\n", - "Processing model: INM-CM5-0\n", - "Processing year 2054\n", - "Processing file: CIL_subset_ssp126_2055.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2055\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2055\n", - "Processing model: INM-CM5-0\n", - "Processing year 2055\n", - "Processing file: CIL_subset_ssp126_2056.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2056\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2056\n", - "Processing model: INM-CM5-0\n", - "Processing year 2056\n", - "Processing file: CIL_subset_ssp126_2057.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2057\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2057\n", - "Processing model: INM-CM5-0\n", - "Processing year 2057\n", - "Processing file: CIL_subset_ssp126_2058.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2058\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2058\n", - "Processing model: INM-CM5-0\n", - "Processing year 2058\n", - "Processing file: CIL_subset_ssp126_2059.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2059\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2059\n", - "Processing model: INM-CM5-0\n", - "Processing year 2059\n", - "Processing file: CIL_subset_ssp126_2060.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2060\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2060\n", - "Processing model: INM-CM5-0\n", - "Processing year 2060\n", - "Processing file: CIL_subset_ssp126_2061.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2061\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2061\n", - "Processing model: INM-CM5-0\n", - "Processing year 2061\n", - "Processing file: CIL_subset_ssp126_2062.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2062\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2062\n", - "Processing model: INM-CM5-0\n", - "Processing year 2062\n", - "Processing file: CIL_subset_ssp126_2063.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2063\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2063\n", - "Processing model: INM-CM5-0\n", - "Processing year 2063\n", - "Processing file: CIL_subset_ssp126_2064.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2064\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2064\n", - "Processing model: INM-CM5-0\n", - "Processing year 2064\n", - "Processing file: CIL_subset_ssp126_2065.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2065\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2065\n", - "Processing model: INM-CM5-0\n", - "Processing year 2065\n", - "Processing file: CIL_subset_ssp126_2066.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2066\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2066\n", - "Processing model: INM-CM5-0\n", - "Processing year 2066\n", - "Processing file: CIL_subset_ssp126_2067.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2067\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2067\n", - "Processing model: INM-CM5-0\n", - "Processing year 2067\n", - "Processing file: CIL_subset_ssp126_2068.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2068\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2068\n", - "Processing model: INM-CM5-0\n", - "Processing year 2068\n", - "Processing file: CIL_subset_ssp126_2069.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2069\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2069\n", - "Processing model: INM-CM5-0\n", - "Processing year 2069\n", - "Processing file: CIL_subset_ssp126_2070.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2070\n", + "Processing year 2025, month 1\n", + "Processing year 2025, month 2\n", + "Processing year 2025, month 3\n", + "Processing year 2025, month 4\n", + "Processing year 2025, month 5\n", + "Processing year 2025, month 6\n", + "Processing year 2025, month 7\n", + "Processing year 2025, month 8\n", + "Processing year 2025, month 9\n", + "Processing year 2025, month 10\n", + "Processing year 2025, month 11\n", + "Processing year 2025, month 12\n", "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2070\n", - "Processing model: INM-CM5-0\n", - "Processing year 2070\n", - "Saved monthly data for lowest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp126/lowest_monthly_prediction_weather_by_facility.csv\n", - "Saved window data for lowest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp126/lowest_window_prediction_weather_by_facility.csv\n", - "Saved monthly data for mean model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp126/mean_monthly_prediction_weather_by_facility.csv\n", - "Saved window data for mean model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp126/mean_window_prediction_weather_by_facility.csv\n", - "Saved monthly data for highest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp126/highest_monthly_prediction_weather_by_facility.csv\n", - "Saved window data for highest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp126/highest_window_prediction_weather_by_facility.csv\n", - "Processing scenario: ssp245\n", - "Saved combined dataset for ssp245 to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/CIL_combined_ssp245_2024_2070.nc\n", - "Models of interest ['HadGEM3-GC31-LL', 'UKESM1-0-LL', 'INM-CM5-0']\n", - "Processing file: CIL_subset_ssp245_2024.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2024\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Processing model: UKESM1-0-LL\n", - "Processing year 2024\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Processing model: INM-CM5-0\n", - "Processing year 2024\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Processing file: CIL_subset_ssp245_2025.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2025\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2025\n", - "Processing model: INM-CM5-0\n", - "Processing year 2025\n", - "Processing file: CIL_subset_ssp245_2026.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2026\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2026\n", - "Processing model: INM-CM5-0\n", - "Processing year 2026\n", - "Processing file: CIL_subset_ssp245_2027.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2027\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2027\n", - "Processing model: INM-CM5-0\n", - "Processing year 2027\n", - "Processing file: CIL_subset_ssp245_2028.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2028\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2028\n", - "Processing model: INM-CM5-0\n", - "Processing year 2028\n", - "Processing file: CIL_subset_ssp245_2029.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2029\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2029\n", - "Processing model: INM-CM5-0\n", - "Processing year 2029\n", - "Processing file: CIL_subset_ssp245_2030.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2030\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2030\n", - "Processing model: INM-CM5-0\n", - "Processing year 2030\n", - "Processing file: CIL_subset_ssp245_2031.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2031\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2031\n", - "Processing model: INM-CM5-0\n", - "Processing year 2031\n", - "Processing file: CIL_subset_ssp245_2032.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2032\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2032\n", - "Processing model: INM-CM5-0\n", - "Processing year 2032\n", - "Processing file: CIL_subset_ssp245_2033.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2033\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2033\n", - "Processing model: INM-CM5-0\n", - "Processing year 2033\n", - "Processing file: CIL_subset_ssp245_2034.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2034\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2034\n", - "Processing model: INM-CM5-0\n", - "Processing year 2034\n", - "Processing file: CIL_subset_ssp245_2035.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2035\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2035\n", - "Processing model: INM-CM5-0\n", - "Processing year 2035\n", - "Processing file: CIL_subset_ssp245_2036.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2036\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2036\n", - "Processing model: INM-CM5-0\n", - "Processing year 2036\n", - "Processing file: CIL_subset_ssp245_2037.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2037\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2037\n", - "Processing model: INM-CM5-0\n", - "Processing year 2037\n", - "Processing file: CIL_subset_ssp245_2038.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2038\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2038\n", - "Processing model: INM-CM5-0\n", - "Processing year 2038\n", - "Processing file: CIL_subset_ssp245_2039.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2039\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2039\n", - "Processing model: INM-CM5-0\n", - "Processing year 2039\n", - "Processing file: CIL_subset_ssp245_2040.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2040\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2040\n", - "Processing model: INM-CM5-0\n", - "Processing year 2040\n", - "Processing file: CIL_subset_ssp245_2041.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2041\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2041\n", - "Processing model: INM-CM5-0\n", - "Processing year 2041\n", - "Processing file: CIL_subset_ssp245_2042.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2042\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2042\n", - "Processing model: INM-CM5-0\n", - "Processing year 2042\n", - "Processing file: CIL_subset_ssp245_2043.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2043\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2043\n", - "Processing model: INM-CM5-0\n", - "Processing year 2043\n", - "Processing file: CIL_subset_ssp245_2044.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2044\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2044\n", - "Processing model: INM-CM5-0\n", - "Processing year 2044\n", - "Processing file: CIL_subset_ssp245_2045.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2045\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2045\n", - "Processing model: INM-CM5-0\n", - "Processing year 2045\n", - "Processing file: CIL_subset_ssp245_2046.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2046\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2046\n", - "Processing model: INM-CM5-0\n", - "Processing year 2046\n", - "Processing file: CIL_subset_ssp245_2047.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2047\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2047\n", - "Processing model: INM-CM5-0\n", - "Processing year 2047\n", - "Processing file: CIL_subset_ssp245_2048.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2048\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2048\n", - "Processing model: INM-CM5-0\n", - "Processing year 2048\n", - "Processing file: CIL_subset_ssp245_2049.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2049\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2049\n", - "Processing model: INM-CM5-0\n", - "Processing year 2049\n", - "Processing file: CIL_subset_ssp245_2050.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2050\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2050\n", - "Processing model: INM-CM5-0\n", - "Processing year 2050\n", - "Processing file: CIL_subset_ssp245_2051.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2051\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2051\n", - "Processing model: INM-CM5-0\n", - "Processing year 2051\n", - "Processing file: CIL_subset_ssp245_2052.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2052\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2052\n", - "Processing model: INM-CM5-0\n", - "Processing year 2052\n", - "Processing file: CIL_subset_ssp245_2053.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2053\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2053\n", - "Processing model: INM-CM5-0\n", - "Processing year 2053\n", - "Processing file: CIL_subset_ssp245_2054.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2054\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2054\n", - "Processing model: INM-CM5-0\n", - "Processing year 2054\n", - "Processing file: CIL_subset_ssp245_2055.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2055\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2055\n", - "Processing model: INM-CM5-0\n", - "Processing year 2055\n", - "Processing file: CIL_subset_ssp245_2056.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2056\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2056\n", - "Processing model: INM-CM5-0\n", - "Processing year 2056\n", - "Processing file: CIL_subset_ssp245_2057.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2057\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2057\n", - "Processing model: INM-CM5-0\n", - "Processing year 2057\n", - "Processing file: CIL_subset_ssp245_2058.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2058\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2058\n", - "Processing model: INM-CM5-0\n", - "Processing year 2058\n", - "Processing file: CIL_subset_ssp245_2059.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2059\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2059\n", - "Processing model: INM-CM5-0\n", - "Processing year 2059\n", - "Processing file: CIL_subset_ssp245_2060.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2060\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2060\n", - "Processing model: INM-CM5-0\n", - "Processing year 2060\n", - "Processing file: CIL_subset_ssp245_2061.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2061\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2061\n", - "Processing model: INM-CM5-0\n", - "Processing year 2061\n", - "Processing file: CIL_subset_ssp245_2062.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2062\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2062\n", - "Processing model: INM-CM5-0\n", - "Processing year 2062\n", - "Processing file: CIL_subset_ssp245_2063.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2063\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2063\n", - "Processing model: INM-CM5-0\n", - "Processing year 2063\n", - "Processing file: CIL_subset_ssp245_2064.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2064\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2064\n", - "Processing model: INM-CM5-0\n", - "Processing year 2064\n", - "Processing file: CIL_subset_ssp245_2065.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2065\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2065\n", - "Processing model: INM-CM5-0\n", - "Processing year 2065\n", - "Processing file: CIL_subset_ssp245_2066.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2066\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2066\n", - "Processing model: INM-CM5-0\n", - "Processing year 2066\n", - "Processing file: CIL_subset_ssp245_2067.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2067\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2067\n", - "Processing model: INM-CM5-0\n", - "Processing year 2067\n", - "Processing file: CIL_subset_ssp245_2068.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2068\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2068\n", - "Processing model: INM-CM5-0\n", - "Processing year 2068\n", - "Processing file: CIL_subset_ssp245_2069.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2069\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2069\n", - "Processing model: INM-CM5-0\n", - "Processing year 2069\n", - "Processing file: CIL_subset_ssp245_2070.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2070\n", - "Processing model: UKESM1-0-LL\n", - "Processing year 2070\n", - "Processing model: INM-CM5-0\n", - "Processing year 2070\n", - "Saved monthly data for lowest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp245/lowest_monthly_prediction_weather_by_facility.csv\n", - "Saved window data for lowest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp245/lowest_window_prediction_weather_by_facility.csv\n", - "Saved monthly data for mean model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp245/mean_monthly_prediction_weather_by_facility.csv\n", - "Saved window data for mean model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp245/mean_window_prediction_weather_by_facility.csv\n", - "Saved monthly data for highest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp245/highest_monthly_prediction_weather_by_facility.csv\n", - "Saved window data for highest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp245/highest_window_prediction_weather_by_facility.csv\n", - "Processing scenario: ssp585\n", - "Saved combined dataset for ssp585 to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/CIL_combined_ssp585_2024_2070.nc\n", - "Models of interest ['HadGEM3-GC31-LL', 'EC-Earth3-CC', 'CMCC-CM2-SR5']\n", - "Processing file: CIL_subset_ssp585_2024.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2024\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Processing model: EC-Earth3-CC\n", - "Processing year 2024\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2024\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:117: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_61276/1680046981.py:119: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Processing file: CIL_subset_ssp585_2025.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2025\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2025\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2025\n", - "Processing file: CIL_subset_ssp585_2026.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2026\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2026\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2026\n", - "Processing file: CIL_subset_ssp585_2027.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2027\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2027\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2027\n", - "Processing file: CIL_subset_ssp585_2028.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2028\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2028\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2028\n", - "Processing file: CIL_subset_ssp585_2029.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2029\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2029\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2029\n", - "Processing file: CIL_subset_ssp585_2030.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2030\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2030\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2030\n", - "Processing file: CIL_subset_ssp585_2031.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2031\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2031\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2031\n", - "Processing file: CIL_subset_ssp585_2032.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2032\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2032\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2032\n", - "Processing file: CIL_subset_ssp585_2033.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2033\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2033\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2033\n", - "Processing file: CIL_subset_ssp585_2034.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2034\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2034\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2034\n", - "Processing file: CIL_subset_ssp585_2035.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2035\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2035\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2035\n", - "Processing file: CIL_subset_ssp585_2036.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2036\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2036\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2036\n", - "Processing file: CIL_subset_ssp585_2037.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2037\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2037\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2037\n", - "Processing file: CIL_subset_ssp585_2038.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2038\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2038\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2038\n", - "Processing file: CIL_subset_ssp585_2039.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2039\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2039\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2039\n", - "Processing file: CIL_subset_ssp585_2040.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2040\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2040\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2040\n", - "Processing file: CIL_subset_ssp585_2041.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2041\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2041\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2041\n", - "Processing file: CIL_subset_ssp585_2042.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2042\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2042\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2042\n", - "Processing file: CIL_subset_ssp585_2043.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2043\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2043\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2043\n", - "Processing file: CIL_subset_ssp585_2044.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2044\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2044\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2044\n", - "Processing file: CIL_subset_ssp585_2045.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2045\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2045\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2045\n", - "Processing file: CIL_subset_ssp585_2046.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2046\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2046\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2046\n", - "Processing file: CIL_subset_ssp585_2047.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2047\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2047\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2047\n", - "Processing file: CIL_subset_ssp585_2048.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2048\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2048\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2048\n", - "Processing file: CIL_subset_ssp585_2049.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2049\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2049\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2049\n", - "Processing file: CIL_subset_ssp585_2050.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2050\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2050\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2050\n", - "Processing file: CIL_subset_ssp585_2051.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2051\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2051\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2051\n", - "Processing file: CIL_subset_ssp585_2052.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2052\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2052\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2052\n", - "Processing file: CIL_subset_ssp585_2053.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2053\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2053\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2053\n", - "Processing file: CIL_subset_ssp585_2054.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2054\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2054\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2054\n", - "Processing file: CIL_subset_ssp585_2055.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2055\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2055\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2055\n", - "Processing file: CIL_subset_ssp585_2056.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2056\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2056\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2056\n", - "Processing file: CIL_subset_ssp585_2057.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2057\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2057\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2057\n", - "Processing file: CIL_subset_ssp585_2058.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2058\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2058\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2058\n", - "Processing file: CIL_subset_ssp585_2059.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2059\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2059\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2059\n", - "Processing file: CIL_subset_ssp585_2060.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2060\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2060\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2060\n", - "Processing file: CIL_subset_ssp585_2061.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2061\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2061\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2061\n", - "Processing file: CIL_subset_ssp585_2062.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2062\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2062\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2062\n", - "Processing file: CIL_subset_ssp585_2063.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2063\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2063\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2063\n", - "Processing file: CIL_subset_ssp585_2064.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2064\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2064\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2064\n", - "Processing file: CIL_subset_ssp585_2065.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2065\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2065\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2065\n", - "Processing file: CIL_subset_ssp585_2066.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2066\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2066\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2066\n", - "Processing file: CIL_subset_ssp585_2067.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2067\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2067\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2067\n", - "Processing file: CIL_subset_ssp585_2068.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2068\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2068\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2068\n", - "Processing file: CIL_subset_ssp585_2069.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2069\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2069\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2069\n", - "Processing file: CIL_subset_ssp585_2070.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2070\n", - "Processing model: EC-Earth3-CC\n", - "Processing year 2070\n", - "Processing model: CMCC-CM2-SR5\n", - "Processing year 2070\n", - "Saved monthly data for lowest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/lowest_monthly_prediction_weather_by_facility.csv\n", - "Saved window data for lowest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/lowest_window_prediction_weather_by_facility.csv\n", - "Saved monthly data for mean model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/mean_monthly_prediction_weather_by_facility.csv\n", - "Saved window data for mean model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/mean_window_prediction_weather_by_facility.csv\n", - "Saved monthly data for highest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/highest_monthly_prediction_weather_by_facility.csv\n", - "Saved window data for highest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/highest_window_prediction_weather_by_facility.csv\n" + "Processing year 2025, month 1\n", + "Processing year 2025, month 2\n", + "Processing year 2025, month 3\n", + "Processing year 2025, month 4\n", + "Processing year 2025, month 5\n", + "Processing year 2025, month 6\n", + "Processing year 2025, month 7\n", + "Processing year 2025, month 8\n", + "Processing year 2025, month 9\n", + "Processing year 2025, month 10\n", + "Processing year 2025, month 11\n", + "Processing year 2025, month 12\n" ] } ], - "execution_count": 4 + "execution_count": null }, { "metadata": { diff --git a/src/scripts/climate_change/process_CMIP6_data_KDBall.py b/src/scripts/climate_change/process_CMIP6_data_KDBall.py index fa713905d5..c1a519b51c 100644 --- a/src/scripts/climate_change/process_CMIP6_data_KDBall.py +++ b/src/scripts/climate_change/process_CMIP6_data_KDBall.py @@ -12,8 +12,12 @@ from netCDF4 import Dataset from scipy.spatial import KDTree -ANC = True -Inpatient = False +ANC = False +Inpatient = True +if ANC: + service = 'ANC' +if Inpatient: + service = 'Inpatient' monthly_cumulative = False multiplier = 86400 years = range(2015, 2100) @@ -156,7 +160,7 @@ def extract_nc_files_from_unzipped_folders(directory): na_values = data_by_model_and_grid_same_length.isna() na_values_count = na_values.sum() data_by_model_and_grid_same_length = data_by_model_and_grid_same_length.dropna(axis=0) - data_by_model_and_grid_same_length.to_csv(Path(scenario_directory)/"data_by_model_and_grid_modal_resolution.csv", index = True) + data_by_model_and_grid_same_length.to_csv(Path(scenario_directory)/f"data_by_model_and_grid_modal_resolution_{service}.csv", index = True) # Now loop over facilities to locate each one in a grid cell for each model facilities_with_location = [] From 34493afaf3d5e3309777a85aae2c12a662953fd4 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 3 Feb 2025 10:00:22 +0000 Subject: [PATCH 238/291] Different percentiles --- ...ear_model_historical_realtionship_reporting_precipitation.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 7c860ed6e6..267a0fdd76 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -480,7 +480,7 @@ def repeat_info(info, num_facilities, year_range, historical): X_weather_standardized = np.column_stack([X_continuous_scaled, X_categorical]) if use_percentile_mask_threshold: - mask_threshold = np.nanpercentile(X_weather_standardized[:,0], 5) + mask_threshold = np.nanpercentile(X_weather_standardized[:,0], 0) print(mask_threshold) X_weather_standardized[:, 0] = np.where( X_weather_standardized[:, 0] < mask_threshold, np.nan, X_weather_standardized[:, 0] From 085c867579fdcf5370ad83e4168db2c7ee4f83cc Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 3 Feb 2025 10:41:24 +0000 Subject: [PATCH 239/291] Added in felxibility for changing between services --- .../CIL_CMIP6_downscaling.ipynb | 2966 +---------------- src/scripts/climate_change/cohort_model.py | 29 +- ...al_realtionship_reporting_precipitation.py | 10 +- 3 files changed, 34 insertions(+), 2971 deletions(-) diff --git a/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb b/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb index 16e1f68a13..0e9f6debd7 100644 --- a/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb +++ b/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb @@ -826,8 +826,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-02-03T09:24:38.516334Z", - "start_time": "2025-02-03T09:24:38.327240Z" + "end_time": "2025-02-03T10:34:02.271015Z", + "start_time": "2025-02-03T10:34:01.855387Z" } }, "cell_type": "code", @@ -856,18 +856,18 @@ "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/795972135.py:19: DtypeWarning: Columns (58,59,105,127,136,142,149,150,258,285,296,319,344,345,360,393,394,427,428,437,449,450,452,453,461,462,478,479,489,490,492,493,494,497,498,499,500,501,502,503,572,580,585,586,587,588,591,592,593,594,607,608,609,610,619,620,621,622,626,634,872,887,967,978,1066,1510) have mixed types. Specify dtype option on import or set low_memory=False.\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/649359019.py:19: DtypeWarning: Columns (58,59,105,127,136,142,149,150,258,285,296,319,344,345,360,393,394,427,428,437,449,450,452,453,461,462,478,479,489,490,492,493,494,497,498,499,500,501,502,503,572,580,585,586,587,588,591,592,593,594,607,608,609,610,619,620,621,622,626,634,872,887,967,978,1066,1510) have mixed types. Specify dtype option on import or set low_memory=False.\n", " facilities_with_lat_long = pd.read_csv(\n" ] } ], - "execution_count": 2 + "execution_count": 6 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-02-03T09:24:44.148767Z", - "start_time": "2025-02-03T09:24:44.142505Z" + "end_time": "2025-02-03T10:34:02.390132Z", + "start_time": "2025-02-03T10:34:02.379685Z" } }, "cell_type": "code", @@ -943,7 +943,7 @@ ], "id": "a9a92aa8bbb6b45a", "outputs": [], - "execution_count": 3 + "execution_count": 7 }, { "metadata": { @@ -951,7 +951,7 @@ "is_executing": true }, "ExecuteTime": { - "start_time": "2025-02-03T09:54:19.740895Z" + "start_time": "2025-02-03T10:34:03.143882Z" } }, "cell_type": "code", @@ -1091,2955 +1091,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Processing scenario: ssp126\n", - "Models of interest ['HadGEM3-GC31-LL', 'MPI-ESM1-2-LR', 'INM-CM5-0']\n", - "Processing file: CIL_subset_ssp126_2024.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2024, month 1\n", - "Processing year 2024, month 2\n", - "Processing year 2024, month 3\n", - "Processing year 2024, month 4\n", - "Processing year 2024, month 5\n", - "Processing year 2024, month 6\n", - "Processing year 2024, month 7\n", - "Processing year 2024, month 8\n", - "Processing year 2024, month 9\n", - "Processing year 2024, month 10\n", - "Processing year 2024, month 11\n", - "Processing year 2024, month 12\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2024, month 1\n", - "Processing year 2024, month 2\n", - "Processing year 2024, month 3\n", - "Processing year 2024, month 4\n", - "Processing year 2024, month 5\n", - "Processing year 2024, month 6\n", - "Processing year 2024, month 7\n", - "Processing year 2024, month 8\n", - "Processing year 2024, month 9\n", - "Processing year 2024, month 10\n", - "Processing year 2024, month 11\n", - "Processing year 2024, month 12\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Processing model: INM-CM5-0\n", - "Processing year 2024, month 1\n", - "Processing year 2024, month 2\n", - "Processing year 2024, month 3\n", - "Processing year 2024, month 4\n", - "Processing year 2024, month 5\n", - "Processing year 2024, month 6\n", - "Processing year 2024, month 7\n", - "Processing year 2024, month 8\n", - "Processing year 2024, month 9\n", - "Processing year 2024, month 10\n", - "Processing year 2024, month 11\n", - "Processing year 2024, month 12\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", - " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Processing file: CIL_subset_ssp126_2025.nc\n", - "Processing model: HadGEM3-GC31-LL\n", - "Processing year 2025, month 1\n", - "Processing year 2025, month 2\n", - "Processing year 2025, month 3\n", - "Processing year 2025, month 4\n", - "Processing year 2025, month 5\n", - "Processing year 2025, month 6\n", - "Processing year 2025, month 7\n", - "Processing year 2025, month 8\n", - "Processing year 2025, month 9\n", - "Processing year 2025, month 10\n", - "Processing year 2025, month 11\n", - "Processing year 2025, month 12\n", - "Processing model: MPI-ESM1-2-LR\n", - "Processing year 2025, month 1\n", - "Processing year 2025, month 2\n", - "Processing year 2025, month 3\n", - "Processing year 2025, month 4\n", - "Processing year 2025, month 5\n", - "Processing year 2025, month 6\n", - "Processing year 2025, month 7\n", - "Processing year 2025, month 8\n", - "Processing year 2025, month 9\n", - "Processing year 2025, month 10\n", - "Processing year 2025, month 11\n", - "Processing year 2025, month 12\n" + "Processing scenario: ssp126\n" ] } ], diff --git a/src/scripts/climate_change/cohort_model.py b/src/scripts/climate_change/cohort_model.py index 055c55e572..ddb540ccc5 100644 --- a/src/scripts/climate_change/cohort_model.py +++ b/src/scripts/climate_change/cohort_model.py @@ -25,11 +25,18 @@ # global min for all heatmaps for same scale global_min = -5 global_max = 0 +# service +ANC = False +Inpatient = True +if ANC: + service = 'ANC' +if Inpatient: + service = 'Inpatient' ## Get birth results -results_folder_to_save = Path('/Users/rem76/Desktop/Climate_change_health/Results/ANC_disruptions') +results_folder_to_save = Path(f'/Users/rem76/Desktop/Climate_change_health/Results/{service}_disruptions') results_folder_for_births = Path("/Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-09-25T110820Z") resourcefilepath = Path("/Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-09-25T110820Z") -historical_predictions = pd.read_csv('/Users/rem76/Desktop/Climate_change_health/Data/results_of_ANC_model_historical_predictions.csv') +historical_predictions = pd.read_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/results_of_model_historical_predictions_{service}.csv') precipitation_threshold = historical_predictions['Precipitation'].quantile(0.9) print(precipitation_threshold) agegrps, agegrplookup = make_age_grp_lookup() @@ -101,7 +108,7 @@ filtered_predictions = predictions_from_cmip[predictions_from_cmip['Precipitation'] >= precipitation_threshold] filtered_predictions_sum = filtered_predictions.groupby('Year').sum().reset_index() percent_due_to_extreme = filtered_predictions_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model'] - + print(percent_due_to_extreme) multiplied_values_extreme_precip = births_model_subset.head(matching_rows).iloc[:, 1].values * percent_due_to_extreme.head(matching_rows).values * 1.4 negative_sum_extreme_precip = np.sum(multiplied_values_extreme_precip[multiplied_values_extreme_precip < 0]) result_df = pd.DataFrame({ @@ -128,7 +135,7 @@ final_results = pd.concat(results_list, ignore_index=True) print(final_results) -final_results.to_csv('/Users/rem76/Desktop/Climate_change_health/Results/ANC_disruptions/negative_sums_and_percentages.csv', index=False) +final_results.to_csv(f'/Users/rem76/Desktop/Climate_change_health/Results/{service}_disruptions/negative_sums_and_percentages.csv', index=False) @@ -318,7 +325,7 @@ if i == len(scenarios) - 1: ax.set_xlabel('Year', fontsize=12) if j == 0: - ax.set_ylabel('Deficit of ANC services', fontsize=12) + ax.set_ylabel(f'Deficit of {service} services', fontsize=12) #if (i == 0) & (j == 2): # ax.legend(title="Districts", fontsize=10, title_fontsize=10, bbox_to_anchor=(1., 1)) percentage_diff_by_year_district_all[scenario][model_type] = percentage_diff_by_year_district @@ -410,7 +417,7 @@ if i == len(scenarios) - 1: ax.set_xlabel('Year', fontsize=12) if j == 0: - ax.set_ylabel('Deficit of ANC services', fontsize=12) + ax.set_ylabel(f'Deficit of {service} services', fontsize=12) #if (i == 0) & (j == 2): # ax.legend(title="Districts", fontsize=10, title_fontsize=10, bbox_to_anchor=(1., 1)) percentage_diff_by_year_district_all[scenario][model_type] = percentage_diff_by_year_district @@ -427,7 +434,7 @@ ####### Historical disruptions ########## -historical_predictions = pd.read_csv('/Users/rem76/Desktop/Climate_change_health/Data/results_of_ANC_model_historical_predictions.csv') +historical_predictions = pd.read_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/results_of_{service}_model_historical_predictions.csv') historical_predictions = historical_predictions.loc[historical_predictions['Difference_in_Expectation'] < 0] historical_predictions_sum = historical_predictions.groupby('District').sum().reset_index() @@ -443,8 +450,12 @@ malawi_admin2['Percentage_Difference_historical'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district_historical) malawi_admin2.loc[malawi_admin2['Percentage_Difference_historical'] > 0, 'Percentage_Difference_historical'] = 0 percentage_diff_by_district_historical_average = historical_predictions_sum['Percentage_Difference'].mean() -print(percentage_diff_by_district_historical_average) - +print(malawi_admin2) +filtered_predictions = historical_predictions[historical_predictions['Precipitation'] >= precipitation_threshold] +filtered_predictions_sum = filtered_predictions.groupby('Year').sum().reset_index() +percent_due_to_extreme = filtered_predictions_sum['Difference_in_Expectation'].sum() +percent_due_to_extreme = percent_due_to_extreme/historical_predictions['Difference_in_Expectation'].sum() +print(percent_due_to_extreme) fig, ax = plt.subplots(figsize=(10, 10)) malawi_admin2.dropna(subset=['Percentage_Difference_historical']).plot( diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 267a0fdd76..a6941870a8 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -9,8 +9,8 @@ from statsmodels.stats.outliers_influence import variance_inflation_factor from sklearn.feature_selection import SelectKBest, f_regression -ANC = True -Inpatient = False +ANC = False +Inpatient = True if ANC: service = 'ANC' if Inpatient: @@ -507,7 +507,7 @@ def repeat_info(info, num_facilities, year_range, historical): p_values_weather = results_of_weather_model.pvalues p_values_weather_df = pd.DataFrame(p_values_weather, columns=['p_values']) results_weather_df = pd.concat([coefficient_names_weather, coefficients_weather_df, p_values_weather_df, rescaled_coefficients_df], axis=1) -results_weather_df.to_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/results_of_weather_model_historical{service}.csv') +results_weather_df.to_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/results_of_weather_model_historical_{service}.csv') print("All predictors", results_of_weather_model.summary()) # @@ -605,14 +605,14 @@ def repeat_info(info, num_facilities, year_range, historical): ############### ADD IN CMIP DATA ########################### def get_weather_data(ssp_scenario, model_type): weather_data_prediction_five_day_cumulative_original = pd.read_csv( - f"{data_path}Precipitation_data/Downscaled_CMIP6_data_CIL/{ssp_scenario}/{model_type}_window_prediction_weather_by_facility.csv", + f"{data_path}Precipitation_data/Downscaled_CMIP6_data_CIL/{ssp_scenario}/{model_type}_window_prediction_weather_by_facility_{service}.csv", dtype={'column_name': 'float64'} ) weather_data_prediction_five_day_cumulative_original = weather_data_prediction_five_day_cumulative_original.drop( weather_data_prediction_five_day_cumulative_original.columns[0], axis=1 ) # first column are date/months weather_data_prediction_monthly_original = pd.read_csv( - f"{data_path}Precipitation_data/Downscaled_CMIP6_data_CIL/{ssp_scenario}/{model_type}_monthly_prediction_weather_by_facility.csv", + f"{data_path}Precipitation_data/Downscaled_CMIP6_data_CIL/{ssp_scenario}/{model_type}_monthly_prediction_weather_by_facility_{service}.csv", dtype={'column_name': 'float64'} ) weather_data_prediction_monthly_original = weather_data_prediction_monthly_original.drop( From 964d3fa0ee14c3b0af0f5af909dc67653327c905 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 4 Feb 2025 08:09:56 +0000 Subject: [PATCH 240/291] Added in felxibility for changing between services --- .../CIL_CMIP6_downscaling.ipynb | 14239 +++++++++++++++- 1 file changed, 14234 insertions(+), 5 deletions(-) diff --git a/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb b/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb index 0e9f6debd7..2015403c2c 100644 --- a/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb +++ b/src/scripts/climate_change/CIL_CMIP6_downscaling.ipynb @@ -947,10 +947,8 @@ }, { "metadata": { - "jupyter": { - "is_executing": true - }, "ExecuteTime": { + "end_time": "2025-02-03T11:02:31.952273Z", "start_time": "2025-02-03T10:34:03.143882Z" } }, @@ -1091,11 +1089,14242 @@ "name": "stdout", "output_type": "stream", "text": [ - "Processing scenario: ssp126\n" + "Processing scenario: ssp126\n", + "Models of interest ['HadGEM3-GC31-LL', 'MPI-ESM1-2-LR', 'INM-CM5-0']\n", + "Processing file: CIL_subset_ssp126_2024.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2024, month 1\n", + "Processing year 2024, month 2\n", + "Processing year 2024, month 3\n", + "Processing year 2024, month 4\n", + "Processing year 2024, month 5\n", + "Processing year 2024, month 6\n", + "Processing year 2024, month 7\n", + "Processing year 2024, month 8\n", + "Processing year 2024, month 9\n", + "Processing year 2024, month 10\n", + "Processing year 2024, month 11\n", + "Processing year 2024, month 12\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2024, month 1\n", + "Processing year 2024, month 2\n", + "Processing year 2024, month 3\n", + "Processing year 2024, month 4\n", + "Processing year 2024, month 5\n", + "Processing year 2024, month 6\n", + "Processing year 2024, month 7\n", + "Processing year 2024, month 8\n", + "Processing year 2024, month 9\n", + "Processing year 2024, month 10\n", + "Processing year 2024, month 11\n", + "Processing year 2024, month 12\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing model: INM-CM5-0\n", + "Processing year 2024, month 1\n", + "Processing year 2024, month 2\n", + "Processing year 2024, month 3\n", + "Processing year 2024, month 4\n", + "Processing year 2024, month 5\n", + "Processing year 2024, month 6\n", + "Processing year 2024, month 7\n", + "Processing year 2024, month 8\n", + "Processing year 2024, month 9\n", + "Processing year 2024, month 10\n", + "Processing year 2024, month 11\n", + "Processing year 2024, month 12\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing file: CIL_subset_ssp126_2025.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2025, month 1\n", + "Processing year 2025, month 2\n", + "Processing year 2025, month 3\n", + "Processing year 2025, month 4\n", + "Processing year 2025, month 5\n", + "Processing year 2025, month 6\n", + "Processing year 2025, month 7\n", + "Processing year 2025, month 8\n", + "Processing year 2025, month 9\n", + "Processing year 2025, month 10\n", + "Processing year 2025, month 11\n", + "Processing year 2025, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2025, month 1\n", + "Processing year 2025, month 2\n", + "Processing year 2025, month 3\n", + "Processing year 2025, month 4\n", + "Processing year 2025, month 5\n", + "Processing year 2025, month 6\n", + "Processing year 2025, month 7\n", + "Processing year 2025, month 8\n", + "Processing year 2025, month 9\n", + "Processing year 2025, month 10\n", + "Processing year 2025, month 11\n", + "Processing year 2025, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2025, month 1\n", + "Processing year 2025, month 2\n", + "Processing year 2025, month 3\n", + "Processing year 2025, month 4\n", + "Processing year 2025, month 5\n", + "Processing year 2025, month 6\n", + "Processing year 2025, month 7\n", + "Processing year 2025, month 8\n", + "Processing year 2025, month 9\n", + "Processing year 2025, month 10\n", + "Processing year 2025, month 11\n", + "Processing year 2025, month 12\n", + "Processing file: CIL_subset_ssp126_2026.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2026, month 1\n", + "Processing year 2026, month 2\n", + "Processing year 2026, month 3\n", + "Processing year 2026, month 4\n", + "Processing year 2026, month 5\n", + "Processing year 2026, month 6\n", + "Processing year 2026, month 7\n", + "Processing year 2026, month 8\n", + "Processing year 2026, month 9\n", + "Processing year 2026, month 10\n", + "Processing year 2026, month 11\n", + "Processing year 2026, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2026, month 1\n", + "Processing year 2026, month 2\n", + "Processing year 2026, month 3\n", + "Processing year 2026, month 4\n", + "Processing year 2026, month 5\n", + "Processing year 2026, month 6\n", + "Processing year 2026, month 7\n", + "Processing year 2026, month 8\n", + "Processing year 2026, month 9\n", + "Processing year 2026, month 10\n", + "Processing year 2026, month 11\n", + "Processing year 2026, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2026, month 1\n", + "Processing year 2026, month 2\n", + "Processing year 2026, month 3\n", + "Processing year 2026, month 4\n", + "Processing year 2026, month 5\n", + "Processing year 2026, month 6\n", + "Processing year 2026, month 7\n", + "Processing year 2026, month 8\n", + "Processing year 2026, month 9\n", + "Processing year 2026, month 10\n", + "Processing year 2026, month 11\n", + "Processing year 2026, month 12\n", + "Processing file: CIL_subset_ssp126_2027.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2027, month 1\n", + "Processing year 2027, month 2\n", + "Processing year 2027, month 3\n", + "Processing year 2027, month 4\n", + "Processing year 2027, month 5\n", + "Processing year 2027, month 6\n", + "Processing year 2027, month 7\n", + "Processing year 2027, month 8\n", + "Processing year 2027, month 9\n", + "Processing year 2027, month 10\n", + "Processing year 2027, month 11\n", + "Processing year 2027, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2027, month 1\n", + "Processing year 2027, month 2\n", + "Processing year 2027, month 3\n", + "Processing year 2027, month 4\n", + "Processing year 2027, month 5\n", + "Processing year 2027, month 6\n", + "Processing year 2027, month 7\n", + "Processing year 2027, month 8\n", + "Processing year 2027, month 9\n", + "Processing year 2027, month 10\n", + "Processing year 2027, month 11\n", + "Processing year 2027, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2027, month 1\n", + "Processing year 2027, month 2\n", + "Processing year 2027, month 3\n", + "Processing year 2027, month 4\n", + "Processing year 2027, month 5\n", + "Processing year 2027, month 6\n", + "Processing year 2027, month 7\n", + "Processing year 2027, month 8\n", + "Processing year 2027, month 9\n", + "Processing year 2027, month 10\n", + "Processing year 2027, month 11\n", + "Processing year 2027, month 12\n", + "Processing file: CIL_subset_ssp126_2028.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2028, month 1\n", + "Processing year 2028, month 2\n", + "Processing year 2028, month 3\n", + "Processing year 2028, month 4\n", + "Processing year 2028, month 5\n", + "Processing year 2028, month 6\n", + "Processing year 2028, month 7\n", + "Processing year 2028, month 8\n", + "Processing year 2028, month 9\n", + "Processing year 2028, month 10\n", + "Processing year 2028, month 11\n", + "Processing year 2028, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2028, month 1\n", + "Processing year 2028, month 2\n", + "Processing year 2028, month 3\n", + "Processing year 2028, month 4\n", + "Processing year 2028, month 5\n", + "Processing year 2028, month 6\n", + "Processing year 2028, month 7\n", + "Processing year 2028, month 8\n", + "Processing year 2028, month 9\n", + "Processing year 2028, month 10\n", + "Processing year 2028, month 11\n", + "Processing year 2028, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2028, month 1\n", + "Processing year 2028, month 2\n", + "Processing year 2028, month 3\n", + "Processing year 2028, month 4\n", + "Processing year 2028, month 5\n", + "Processing year 2028, month 6\n", + "Processing year 2028, month 7\n", + "Processing year 2028, month 8\n", + "Processing year 2028, month 9\n", + "Processing year 2028, month 10\n", + "Processing year 2028, month 11\n", + "Processing year 2028, month 12\n", + "Processing file: CIL_subset_ssp126_2029.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2029, month 1\n", + "Processing year 2029, month 2\n", + "Processing year 2029, month 3\n", + "Processing year 2029, month 4\n", + "Processing year 2029, month 5\n", + "Processing year 2029, month 6\n", + "Processing year 2029, month 7\n", + "Processing year 2029, month 8\n", + "Processing year 2029, month 9\n", + "Processing year 2029, month 10\n", + "Processing year 2029, month 11\n", + "Processing year 2029, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2029, month 1\n", + "Processing year 2029, month 2\n", + "Processing year 2029, month 3\n", + "Processing year 2029, month 4\n", + "Processing year 2029, month 5\n", + "Processing year 2029, month 6\n", + "Processing year 2029, month 7\n", + "Processing year 2029, month 8\n", + "Processing year 2029, month 9\n", + "Processing year 2029, month 10\n", + "Processing year 2029, month 11\n", + "Processing year 2029, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2029, month 1\n", + "Processing year 2029, month 2\n", + "Processing year 2029, month 3\n", + "Processing year 2029, month 4\n", + "Processing year 2029, month 5\n", + "Processing year 2029, month 6\n", + "Processing year 2029, month 7\n", + "Processing year 2029, month 8\n", + "Processing year 2029, month 9\n", + "Processing year 2029, month 10\n", + "Processing year 2029, month 11\n", + "Processing year 2029, month 12\n", + "Processing file: CIL_subset_ssp126_2030.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2030, month 1\n", + "Processing year 2030, month 2\n", + "Processing year 2030, month 3\n", + "Processing year 2030, month 4\n", + "Processing year 2030, month 5\n", + "Processing year 2030, month 6\n", + "Processing year 2030, month 7\n", + "Processing year 2030, month 8\n", + "Processing year 2030, month 9\n", + "Processing year 2030, month 10\n", + "Processing year 2030, month 11\n", + "Processing year 2030, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2030, month 1\n", + "Processing year 2030, month 2\n", + "Processing year 2030, month 3\n", + "Processing year 2030, month 4\n", + "Processing year 2030, month 5\n", + "Processing year 2030, month 6\n", + "Processing year 2030, month 7\n", + "Processing year 2030, month 8\n", + "Processing year 2030, month 9\n", + "Processing year 2030, month 10\n", + "Processing year 2030, month 11\n", + "Processing year 2030, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2030, month 1\n", + "Processing year 2030, month 2\n", + "Processing year 2030, month 3\n", + "Processing year 2030, month 4\n", + "Processing year 2030, month 5\n", + "Processing year 2030, month 6\n", + "Processing year 2030, month 7\n", + "Processing year 2030, month 8\n", + "Processing year 2030, month 9\n", + "Processing year 2030, month 10\n", + "Processing year 2030, month 11\n", + "Processing year 2030, month 12\n", + "Processing file: CIL_subset_ssp126_2031.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2031, month 1\n", + "Processing year 2031, month 2\n", + "Processing year 2031, month 3\n", + "Processing year 2031, month 4\n", + "Processing year 2031, month 5\n", + "Processing year 2031, month 6\n", + "Processing year 2031, month 7\n", + "Processing year 2031, month 8\n", + "Processing year 2031, month 9\n", + "Processing year 2031, month 10\n", + "Processing year 2031, month 11\n", + "Processing year 2031, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2031, month 1\n", + "Processing year 2031, month 2\n", + "Processing year 2031, month 3\n", + "Processing year 2031, month 4\n", + "Processing year 2031, month 5\n", + "Processing year 2031, month 6\n", + "Processing year 2031, month 7\n", + "Processing year 2031, month 8\n", + "Processing year 2031, month 9\n", + "Processing year 2031, month 10\n", + "Processing year 2031, month 11\n", + "Processing year 2031, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2031, month 1\n", + "Processing year 2031, month 2\n", + "Processing year 2031, month 3\n", + "Processing year 2031, month 4\n", + "Processing year 2031, month 5\n", + "Processing year 2031, month 6\n", + "Processing year 2031, month 7\n", + "Processing year 2031, month 8\n", + "Processing year 2031, month 9\n", + "Processing year 2031, month 10\n", + "Processing year 2031, month 11\n", + "Processing year 2031, month 12\n", + "Processing file: CIL_subset_ssp126_2032.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2032, month 1\n", + "Processing year 2032, month 2\n", + "Processing year 2032, month 3\n", + "Processing year 2032, month 4\n", + "Processing year 2032, month 5\n", + "Processing year 2032, month 6\n", + "Processing year 2032, month 7\n", + "Processing year 2032, month 8\n", + "Processing year 2032, month 9\n", + "Processing year 2032, month 10\n", + "Processing year 2032, month 11\n", + "Processing year 2032, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2032, month 1\n", + "Processing year 2032, month 2\n", + "Processing year 2032, month 3\n", + "Processing year 2032, month 4\n", + "Processing year 2032, month 5\n", + "Processing year 2032, month 6\n", + "Processing year 2032, month 7\n", + "Processing year 2032, month 8\n", + "Processing year 2032, month 9\n", + "Processing year 2032, month 10\n", + "Processing year 2032, month 11\n", + "Processing year 2032, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2032, month 1\n", + "Processing year 2032, month 2\n", + "Processing year 2032, month 3\n", + "Processing year 2032, month 4\n", + "Processing year 2032, month 5\n", + "Processing year 2032, month 6\n", + "Processing year 2032, month 7\n", + "Processing year 2032, month 8\n", + "Processing year 2032, month 9\n", + "Processing year 2032, month 10\n", + "Processing year 2032, month 11\n", + "Processing year 2032, month 12\n", + "Processing file: CIL_subset_ssp126_2033.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2033, month 1\n", + "Processing year 2033, month 2\n", + "Processing year 2033, month 3\n", + "Processing year 2033, month 4\n", + "Processing year 2033, month 5\n", + "Processing year 2033, month 6\n", + "Processing year 2033, month 7\n", + "Processing year 2033, month 8\n", + "Processing year 2033, month 9\n", + "Processing year 2033, month 10\n", + "Processing year 2033, month 11\n", + "Processing year 2033, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2033, month 1\n", + "Processing year 2033, month 2\n", + "Processing year 2033, month 3\n", + "Processing year 2033, month 4\n", + "Processing year 2033, month 5\n", + "Processing year 2033, month 6\n", + "Processing year 2033, month 7\n", + "Processing year 2033, month 8\n", + "Processing year 2033, month 9\n", + "Processing year 2033, month 10\n", + "Processing year 2033, month 11\n", + "Processing year 2033, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2033, month 1\n", + "Processing year 2033, month 2\n", + "Processing year 2033, month 3\n", + "Processing year 2033, month 4\n", + "Processing year 2033, month 5\n", + "Processing year 2033, month 6\n", + "Processing year 2033, month 7\n", + "Processing year 2033, month 8\n", + "Processing year 2033, month 9\n", + "Processing year 2033, month 10\n", + "Processing year 2033, month 11\n", + "Processing year 2033, month 12\n", + "Processing file: CIL_subset_ssp126_2034.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2034, month 1\n", + "Processing year 2034, month 2\n", + "Processing year 2034, month 3\n", + "Processing year 2034, month 4\n", + "Processing year 2034, month 5\n", + "Processing year 2034, month 6\n", + "Processing year 2034, month 7\n", + "Processing year 2034, month 8\n", + "Processing year 2034, month 9\n", + "Processing year 2034, month 10\n", + "Processing year 2034, month 11\n", + "Processing year 2034, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2034, month 1\n", + "Processing year 2034, month 2\n", + "Processing year 2034, month 3\n", + "Processing year 2034, month 4\n", + "Processing year 2034, month 5\n", + "Processing year 2034, month 6\n", + "Processing year 2034, month 7\n", + "Processing year 2034, month 8\n", + "Processing year 2034, month 9\n", + "Processing year 2034, month 10\n", + "Processing year 2034, month 11\n", + "Processing year 2034, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2034, month 1\n", + "Processing year 2034, month 2\n", + "Processing year 2034, month 3\n", + "Processing year 2034, month 4\n", + "Processing year 2034, month 5\n", + "Processing year 2034, month 6\n", + "Processing year 2034, month 7\n", + "Processing year 2034, month 8\n", + "Processing year 2034, month 9\n", + "Processing year 2034, month 10\n", + "Processing year 2034, month 11\n", + "Processing year 2034, month 12\n", + "Processing file: CIL_subset_ssp126_2035.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2035, month 1\n", + "Processing year 2035, month 2\n", + "Processing year 2035, month 3\n", + "Processing year 2035, month 4\n", + "Processing year 2035, month 5\n", + "Processing year 2035, month 6\n", + "Processing year 2035, month 7\n", + "Processing year 2035, month 8\n", + "Processing year 2035, month 9\n", + "Processing year 2035, month 10\n", + "Processing year 2035, month 11\n", + "Processing year 2035, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2035, month 1\n", + "Processing year 2035, month 2\n", + "Processing year 2035, month 3\n", + "Processing year 2035, month 4\n", + "Processing year 2035, month 5\n", + "Processing year 2035, month 6\n", + "Processing year 2035, month 7\n", + "Processing year 2035, month 8\n", + "Processing year 2035, month 9\n", + "Processing year 2035, month 10\n", + "Processing year 2035, month 11\n", + "Processing year 2035, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2035, month 1\n", + "Processing year 2035, month 2\n", + "Processing year 2035, month 3\n", + "Processing year 2035, month 4\n", + "Processing year 2035, month 5\n", + "Processing year 2035, month 6\n", + "Processing year 2035, month 7\n", + "Processing year 2035, month 8\n", + "Processing year 2035, month 9\n", + "Processing year 2035, month 10\n", + "Processing year 2035, month 11\n", + "Processing year 2035, month 12\n", + "Processing file: CIL_subset_ssp126_2036.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2036, month 1\n", + "Processing year 2036, month 2\n", + "Processing year 2036, month 3\n", + "Processing year 2036, month 4\n", + "Processing year 2036, month 5\n", + "Processing year 2036, month 6\n", + "Processing year 2036, month 7\n", + "Processing year 2036, month 8\n", + "Processing year 2036, month 9\n", + "Processing year 2036, month 10\n", + "Processing year 2036, month 11\n", + "Processing year 2036, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2036, month 1\n", + "Processing year 2036, month 2\n", + "Processing year 2036, month 3\n", + "Processing year 2036, month 4\n", + "Processing year 2036, month 5\n", + "Processing year 2036, month 6\n", + "Processing year 2036, month 7\n", + "Processing year 2036, month 8\n", + "Processing year 2036, month 9\n", + "Processing year 2036, month 10\n", + "Processing year 2036, month 11\n", + "Processing year 2036, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2036, month 1\n", + "Processing year 2036, month 2\n", + "Processing year 2036, month 3\n", + "Processing year 2036, month 4\n", + "Processing year 2036, month 5\n", + "Processing year 2036, month 6\n", + "Processing year 2036, month 7\n", + "Processing year 2036, month 8\n", + "Processing year 2036, month 9\n", + "Processing year 2036, month 10\n", + "Processing year 2036, month 11\n", + "Processing year 2036, month 12\n", + "Processing file: CIL_subset_ssp126_2037.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2037, month 1\n", + "Processing year 2037, month 2\n", + "Processing year 2037, month 3\n", + "Processing year 2037, month 4\n", + "Processing year 2037, month 5\n", + "Processing year 2037, month 6\n", + "Processing year 2037, month 7\n", + "Processing year 2037, month 8\n", + "Processing year 2037, month 9\n", + "Processing year 2037, month 10\n", + "Processing year 2037, month 11\n", + "Processing year 2037, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2037, month 1\n", + "Processing year 2037, month 2\n", + "Processing year 2037, month 3\n", + "Processing year 2037, month 4\n", + "Processing year 2037, month 5\n", + "Processing year 2037, month 6\n", + "Processing year 2037, month 7\n", + "Processing year 2037, month 8\n", + "Processing year 2037, month 9\n", + "Processing year 2037, month 10\n", + "Processing year 2037, month 11\n", + "Processing year 2037, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2037, month 1\n", + "Processing year 2037, month 2\n", + "Processing year 2037, month 3\n", + "Processing year 2037, month 4\n", + "Processing year 2037, month 5\n", + "Processing year 2037, month 6\n", + "Processing year 2037, month 7\n", + "Processing year 2037, month 8\n", + "Processing year 2037, month 9\n", + "Processing year 2037, month 10\n", + "Processing year 2037, month 11\n", + "Processing year 2037, month 12\n", + "Processing file: CIL_subset_ssp126_2038.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2038, month 1\n", + "Processing year 2038, month 2\n", + "Processing year 2038, month 3\n", + "Processing year 2038, month 4\n", + "Processing year 2038, month 5\n", + "Processing year 2038, month 6\n", + "Processing year 2038, month 7\n", + "Processing year 2038, month 8\n", + "Processing year 2038, month 9\n", + "Processing year 2038, month 10\n", + "Processing year 2038, month 11\n", + "Processing year 2038, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2038, month 1\n", + "Processing year 2038, month 2\n", + "Processing year 2038, month 3\n", + "Processing year 2038, month 4\n", + "Processing year 2038, month 5\n", + "Processing year 2038, month 6\n", + "Processing year 2038, month 7\n", + "Processing year 2038, month 8\n", + "Processing year 2038, month 9\n", + "Processing year 2038, month 10\n", + "Processing year 2038, month 11\n", + "Processing year 2038, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2038, month 1\n", + "Processing year 2038, month 2\n", + "Processing year 2038, month 3\n", + "Processing year 2038, month 4\n", + "Processing year 2038, month 5\n", + "Processing year 2038, month 6\n", + "Processing year 2038, month 7\n", + "Processing year 2038, month 8\n", + "Processing year 2038, month 9\n", + "Processing year 2038, month 10\n", + "Processing year 2038, month 11\n", + "Processing year 2038, month 12\n", + "Processing file: CIL_subset_ssp126_2039.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2039, month 1\n", + "Processing year 2039, month 2\n", + "Processing year 2039, month 3\n", + "Processing year 2039, month 4\n", + "Processing year 2039, month 5\n", + "Processing year 2039, month 6\n", + "Processing year 2039, month 7\n", + "Processing year 2039, month 8\n", + "Processing year 2039, month 9\n", + "Processing year 2039, month 10\n", + "Processing year 2039, month 11\n", + "Processing year 2039, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2039, month 1\n", + "Processing year 2039, month 2\n", + "Processing year 2039, month 3\n", + "Processing year 2039, month 4\n", + "Processing year 2039, month 5\n", + "Processing year 2039, month 6\n", + "Processing year 2039, month 7\n", + "Processing year 2039, month 8\n", + "Processing year 2039, month 9\n", + "Processing year 2039, month 10\n", + "Processing year 2039, month 11\n", + "Processing year 2039, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2039, month 1\n", + "Processing year 2039, month 2\n", + "Processing year 2039, month 3\n", + "Processing year 2039, month 4\n", + "Processing year 2039, month 5\n", + "Processing year 2039, month 6\n", + "Processing year 2039, month 7\n", + "Processing year 2039, month 8\n", + "Processing year 2039, month 9\n", + "Processing year 2039, month 10\n", + "Processing year 2039, month 11\n", + "Processing year 2039, month 12\n", + "Processing file: CIL_subset_ssp126_2040.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2040, month 1\n", + "Processing year 2040, month 2\n", + "Processing year 2040, month 3\n", + "Processing year 2040, month 4\n", + "Processing year 2040, month 5\n", + "Processing year 2040, month 6\n", + "Processing year 2040, month 7\n", + "Processing year 2040, month 8\n", + "Processing year 2040, month 9\n", + "Processing year 2040, month 10\n", + "Processing year 2040, month 11\n", + "Processing year 2040, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2040, month 1\n", + "Processing year 2040, month 2\n", + "Processing year 2040, month 3\n", + "Processing year 2040, month 4\n", + "Processing year 2040, month 5\n", + "Processing year 2040, month 6\n", + "Processing year 2040, month 7\n", + "Processing year 2040, month 8\n", + "Processing year 2040, month 9\n", + "Processing year 2040, month 10\n", + "Processing year 2040, month 11\n", + "Processing year 2040, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2040, month 1\n", + "Processing year 2040, month 2\n", + "Processing year 2040, month 3\n", + "Processing year 2040, month 4\n", + "Processing year 2040, month 5\n", + "Processing year 2040, month 6\n", + "Processing year 2040, month 7\n", + "Processing year 2040, month 8\n", + "Processing year 2040, month 9\n", + "Processing year 2040, month 10\n", + "Processing year 2040, month 11\n", + "Processing year 2040, month 12\n", + "Processing file: CIL_subset_ssp126_2041.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2041, month 1\n", + "Processing year 2041, month 2\n", + "Processing year 2041, month 3\n", + "Processing year 2041, month 4\n", + "Processing year 2041, month 5\n", + "Processing year 2041, month 6\n", + "Processing year 2041, month 7\n", + "Processing year 2041, month 8\n", + "Processing year 2041, month 9\n", + "Processing year 2041, month 10\n", + "Processing year 2041, month 11\n", + "Processing year 2041, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2041, month 1\n", + "Processing year 2041, month 2\n", + "Processing year 2041, month 3\n", + "Processing year 2041, month 4\n", + "Processing year 2041, month 5\n", + "Processing year 2041, month 6\n", + "Processing year 2041, month 7\n", + "Processing year 2041, month 8\n", + "Processing year 2041, month 9\n", + "Processing year 2041, month 10\n", + "Processing year 2041, month 11\n", + "Processing year 2041, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2041, month 1\n", + "Processing year 2041, month 2\n", + "Processing year 2041, month 3\n", + "Processing year 2041, month 4\n", + "Processing year 2041, month 5\n", + "Processing year 2041, month 6\n", + "Processing year 2041, month 7\n", + "Processing year 2041, month 8\n", + "Processing year 2041, month 9\n", + "Processing year 2041, month 10\n", + "Processing year 2041, month 11\n", + "Processing year 2041, month 12\n", + "Processing file: CIL_subset_ssp126_2042.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2042, month 1\n", + "Processing year 2042, month 2\n", + "Processing year 2042, month 3\n", + "Processing year 2042, month 4\n", + "Processing year 2042, month 5\n", + "Processing year 2042, month 6\n", + "Processing year 2042, month 7\n", + "Processing year 2042, month 8\n", + "Processing year 2042, month 9\n", + "Processing year 2042, month 10\n", + "Processing year 2042, month 11\n", + "Processing year 2042, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2042, month 1\n", + "Processing year 2042, month 2\n", + "Processing year 2042, month 3\n", + "Processing year 2042, month 4\n", + "Processing year 2042, month 5\n", + "Processing year 2042, month 6\n", + "Processing year 2042, month 7\n", + "Processing year 2042, month 8\n", + "Processing year 2042, month 9\n", + "Processing year 2042, month 10\n", + "Processing year 2042, month 11\n", + "Processing year 2042, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2042, month 1\n", + "Processing year 2042, month 2\n", + "Processing year 2042, month 3\n", + "Processing year 2042, month 4\n", + "Processing year 2042, month 5\n", + "Processing year 2042, month 6\n", + "Processing year 2042, month 7\n", + "Processing year 2042, month 8\n", + "Processing year 2042, month 9\n", + "Processing year 2042, month 10\n", + "Processing year 2042, month 11\n", + "Processing year 2042, month 12\n", + "Processing file: CIL_subset_ssp126_2043.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2043, month 1\n", + "Processing year 2043, month 2\n", + "Processing year 2043, month 3\n", + "Processing year 2043, month 4\n", + "Processing year 2043, month 5\n", + "Processing year 2043, month 6\n", + "Processing year 2043, month 7\n", + "Processing year 2043, month 8\n", + "Processing year 2043, month 9\n", + "Processing year 2043, month 10\n", + "Processing year 2043, month 11\n", + "Processing year 2043, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2043, month 1\n", + "Processing year 2043, month 2\n", + "Processing year 2043, month 3\n", + "Processing year 2043, month 4\n", + "Processing year 2043, month 5\n", + "Processing year 2043, month 6\n", + "Processing year 2043, month 7\n", + "Processing year 2043, month 8\n", + "Processing year 2043, month 9\n", + "Processing year 2043, month 10\n", + "Processing year 2043, month 11\n", + "Processing year 2043, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2043, month 1\n", + "Processing year 2043, month 2\n", + "Processing year 2043, month 3\n", + "Processing year 2043, month 4\n", + "Processing year 2043, month 5\n", + "Processing year 2043, month 6\n", + "Processing year 2043, month 7\n", + "Processing year 2043, month 8\n", + "Processing year 2043, month 9\n", + "Processing year 2043, month 10\n", + "Processing year 2043, month 11\n", + "Processing year 2043, month 12\n", + "Processing file: CIL_subset_ssp126_2044.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2044, month 1\n", + "Processing year 2044, month 2\n", + "Processing year 2044, month 3\n", + "Processing year 2044, month 4\n", + "Processing year 2044, month 5\n", + "Processing year 2044, month 6\n", + "Processing year 2044, month 7\n", + "Processing year 2044, month 8\n", + "Processing year 2044, month 9\n", + "Processing year 2044, month 10\n", + "Processing year 2044, month 11\n", + "Processing year 2044, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2044, month 1\n", + "Processing year 2044, month 2\n", + "Processing year 2044, month 3\n", + "Processing year 2044, month 4\n", + "Processing year 2044, month 5\n", + "Processing year 2044, month 6\n", + "Processing year 2044, month 7\n", + "Processing year 2044, month 8\n", + "Processing year 2044, month 9\n", + "Processing year 2044, month 10\n", + "Processing year 2044, month 11\n", + "Processing year 2044, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2044, month 1\n", + "Processing year 2044, month 2\n", + "Processing year 2044, month 3\n", + "Processing year 2044, month 4\n", + "Processing year 2044, month 5\n", + "Processing year 2044, month 6\n", + "Processing year 2044, month 7\n", + "Processing year 2044, month 8\n", + "Processing year 2044, month 9\n", + "Processing year 2044, month 10\n", + "Processing year 2044, month 11\n", + "Processing year 2044, month 12\n", + "Processing file: CIL_subset_ssp126_2045.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2045, month 1\n", + "Processing year 2045, month 2\n", + "Processing year 2045, month 3\n", + "Processing year 2045, month 4\n", + "Processing year 2045, month 5\n", + "Processing year 2045, month 6\n", + "Processing year 2045, month 7\n", + "Processing year 2045, month 8\n", + "Processing year 2045, month 9\n", + "Processing year 2045, month 10\n", + "Processing year 2045, month 11\n", + "Processing year 2045, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2045, month 1\n", + "Processing year 2045, month 2\n", + "Processing year 2045, month 3\n", + "Processing year 2045, month 4\n", + "Processing year 2045, month 5\n", + "Processing year 2045, month 6\n", + "Processing year 2045, month 7\n", + "Processing year 2045, month 8\n", + "Processing year 2045, month 9\n", + "Processing year 2045, month 10\n", + "Processing year 2045, month 11\n", + "Processing year 2045, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2045, month 1\n", + "Processing year 2045, month 2\n", + "Processing year 2045, month 3\n", + "Processing year 2045, month 4\n", + "Processing year 2045, month 5\n", + "Processing year 2045, month 6\n", + "Processing year 2045, month 7\n", + "Processing year 2045, month 8\n", + "Processing year 2045, month 9\n", + "Processing year 2045, month 10\n", + "Processing year 2045, month 11\n", + "Processing year 2045, month 12\n", + "Processing file: CIL_subset_ssp126_2046.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2046, month 1\n", + "Processing year 2046, month 2\n", + "Processing year 2046, month 3\n", + "Processing year 2046, month 4\n", + "Processing year 2046, month 5\n", + "Processing year 2046, month 6\n", + "Processing year 2046, month 7\n", + "Processing year 2046, month 8\n", + "Processing year 2046, month 9\n", + "Processing year 2046, month 10\n", + "Processing year 2046, month 11\n", + "Processing year 2046, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2046, month 1\n", + "Processing year 2046, month 2\n", + "Processing year 2046, month 3\n", + "Processing year 2046, month 4\n", + "Processing year 2046, month 5\n", + "Processing year 2046, month 6\n", + "Processing year 2046, month 7\n", + "Processing year 2046, month 8\n", + "Processing year 2046, month 9\n", + "Processing year 2046, month 10\n", + "Processing year 2046, month 11\n", + "Processing year 2046, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2046, month 1\n", + "Processing year 2046, month 2\n", + "Processing year 2046, month 3\n", + "Processing year 2046, month 4\n", + "Processing year 2046, month 5\n", + "Processing year 2046, month 6\n", + "Processing year 2046, month 7\n", + "Processing year 2046, month 8\n", + "Processing year 2046, month 9\n", + "Processing year 2046, month 10\n", + "Processing year 2046, month 11\n", + "Processing year 2046, month 12\n", + "Processing file: CIL_subset_ssp126_2047.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2047, month 1\n", + "Processing year 2047, month 2\n", + "Processing year 2047, month 3\n", + "Processing year 2047, month 4\n", + "Processing year 2047, month 5\n", + "Processing year 2047, month 6\n", + "Processing year 2047, month 7\n", + "Processing year 2047, month 8\n", + "Processing year 2047, month 9\n", + "Processing year 2047, month 10\n", + "Processing year 2047, month 11\n", + "Processing year 2047, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2047, month 1\n", + "Processing year 2047, month 2\n", + "Processing year 2047, month 3\n", + "Processing year 2047, month 4\n", + "Processing year 2047, month 5\n", + "Processing year 2047, month 6\n", + "Processing year 2047, month 7\n", + "Processing year 2047, month 8\n", + "Processing year 2047, month 9\n", + "Processing year 2047, month 10\n", + "Processing year 2047, month 11\n", + "Processing year 2047, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2047, month 1\n", + "Processing year 2047, month 2\n", + "Processing year 2047, month 3\n", + "Processing year 2047, month 4\n", + "Processing year 2047, month 5\n", + "Processing year 2047, month 6\n", + "Processing year 2047, month 7\n", + "Processing year 2047, month 8\n", + "Processing year 2047, month 9\n", + "Processing year 2047, month 10\n", + "Processing year 2047, month 11\n", + "Processing year 2047, month 12\n", + "Processing file: CIL_subset_ssp126_2048.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2048, month 1\n", + "Processing year 2048, month 2\n", + "Processing year 2048, month 3\n", + "Processing year 2048, month 4\n", + "Processing year 2048, month 5\n", + "Processing year 2048, month 6\n", + "Processing year 2048, month 7\n", + "Processing year 2048, month 8\n", + "Processing year 2048, month 9\n", + "Processing year 2048, month 10\n", + "Processing year 2048, month 11\n", + "Processing year 2048, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2048, month 1\n", + "Processing year 2048, month 2\n", + "Processing year 2048, month 3\n", + "Processing year 2048, month 4\n", + "Processing year 2048, month 5\n", + "Processing year 2048, month 6\n", + "Processing year 2048, month 7\n", + "Processing year 2048, month 8\n", + "Processing year 2048, month 9\n", + "Processing year 2048, month 10\n", + "Processing year 2048, month 11\n", + "Processing year 2048, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2048, month 1\n", + "Processing year 2048, month 2\n", + "Processing year 2048, month 3\n", + "Processing year 2048, month 4\n", + "Processing year 2048, month 5\n", + "Processing year 2048, month 6\n", + "Processing year 2048, month 7\n", + "Processing year 2048, month 8\n", + "Processing year 2048, month 9\n", + "Processing year 2048, month 10\n", + "Processing year 2048, month 11\n", + "Processing year 2048, month 12\n", + "Processing file: CIL_subset_ssp126_2049.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2049, month 1\n", + "Processing year 2049, month 2\n", + "Processing year 2049, month 3\n", + "Processing year 2049, month 4\n", + "Processing year 2049, month 5\n", + "Processing year 2049, month 6\n", + "Processing year 2049, month 7\n", + "Processing year 2049, month 8\n", + "Processing year 2049, month 9\n", + "Processing year 2049, month 10\n", + "Processing year 2049, month 11\n", + "Processing year 2049, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2049, month 1\n", + "Processing year 2049, month 2\n", + "Processing year 2049, month 3\n", + "Processing year 2049, month 4\n", + "Processing year 2049, month 5\n", + "Processing year 2049, month 6\n", + "Processing year 2049, month 7\n", + "Processing year 2049, month 8\n", + "Processing year 2049, month 9\n", + "Processing year 2049, month 10\n", + "Processing year 2049, month 11\n", + "Processing year 2049, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2049, month 1\n", + "Processing year 2049, month 2\n", + "Processing year 2049, month 3\n", + "Processing year 2049, month 4\n", + "Processing year 2049, month 5\n", + "Processing year 2049, month 6\n", + "Processing year 2049, month 7\n", + "Processing year 2049, month 8\n", + "Processing year 2049, month 9\n", + "Processing year 2049, month 10\n", + "Processing year 2049, month 11\n", + "Processing year 2049, month 12\n", + "Processing file: CIL_subset_ssp126_2050.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2050, month 1\n", + "Processing year 2050, month 2\n", + "Processing year 2050, month 3\n", + "Processing year 2050, month 4\n", + "Processing year 2050, month 5\n", + "Processing year 2050, month 6\n", + "Processing year 2050, month 7\n", + "Processing year 2050, month 8\n", + "Processing year 2050, month 9\n", + "Processing year 2050, month 10\n", + "Processing year 2050, month 11\n", + "Processing year 2050, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2050, month 1\n", + "Processing year 2050, month 2\n", + "Processing year 2050, month 3\n", + "Processing year 2050, month 4\n", + "Processing year 2050, month 5\n", + "Processing year 2050, month 6\n", + "Processing year 2050, month 7\n", + "Processing year 2050, month 8\n", + "Processing year 2050, month 9\n", + "Processing year 2050, month 10\n", + "Processing year 2050, month 11\n", + "Processing year 2050, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2050, month 1\n", + "Processing year 2050, month 2\n", + "Processing year 2050, month 3\n", + "Processing year 2050, month 4\n", + "Processing year 2050, month 5\n", + "Processing year 2050, month 6\n", + "Processing year 2050, month 7\n", + "Processing year 2050, month 8\n", + "Processing year 2050, month 9\n", + "Processing year 2050, month 10\n", + "Processing year 2050, month 11\n", + "Processing year 2050, month 12\n", + "Processing file: CIL_subset_ssp126_2051.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2051, month 1\n", + "Processing year 2051, month 2\n", + "Processing year 2051, month 3\n", + "Processing year 2051, month 4\n", + "Processing year 2051, month 5\n", + "Processing year 2051, month 6\n", + "Processing year 2051, month 7\n", + "Processing year 2051, month 8\n", + "Processing year 2051, month 9\n", + "Processing year 2051, month 10\n", + "Processing year 2051, month 11\n", + "Processing year 2051, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2051, month 1\n", + "Processing year 2051, month 2\n", + "Processing year 2051, month 3\n", + "Processing year 2051, month 4\n", + "Processing year 2051, month 5\n", + "Processing year 2051, month 6\n", + "Processing year 2051, month 7\n", + "Processing year 2051, month 8\n", + "Processing year 2051, month 9\n", + "Processing year 2051, month 10\n", + "Processing year 2051, month 11\n", + "Processing year 2051, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2051, month 1\n", + "Processing year 2051, month 2\n", + "Processing year 2051, month 3\n", + "Processing year 2051, month 4\n", + "Processing year 2051, month 5\n", + "Processing year 2051, month 6\n", + "Processing year 2051, month 7\n", + "Processing year 2051, month 8\n", + "Processing year 2051, month 9\n", + "Processing year 2051, month 10\n", + "Processing year 2051, month 11\n", + "Processing year 2051, month 12\n", + "Processing file: CIL_subset_ssp126_2052.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2052, month 1\n", + "Processing year 2052, month 2\n", + "Processing year 2052, month 3\n", + "Processing year 2052, month 4\n", + "Processing year 2052, month 5\n", + "Processing year 2052, month 6\n", + "Processing year 2052, month 7\n", + "Processing year 2052, month 8\n", + "Processing year 2052, month 9\n", + "Processing year 2052, month 10\n", + "Processing year 2052, month 11\n", + "Processing year 2052, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2052, month 1\n", + "Processing year 2052, month 2\n", + "Processing year 2052, month 3\n", + "Processing year 2052, month 4\n", + "Processing year 2052, month 5\n", + "Processing year 2052, month 6\n", + "Processing year 2052, month 7\n", + "Processing year 2052, month 8\n", + "Processing year 2052, month 9\n", + "Processing year 2052, month 10\n", + "Processing year 2052, month 11\n", + "Processing year 2052, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2052, month 1\n", + "Processing year 2052, month 2\n", + "Processing year 2052, month 3\n", + "Processing year 2052, month 4\n", + "Processing year 2052, month 5\n", + "Processing year 2052, month 6\n", + "Processing year 2052, month 7\n", + "Processing year 2052, month 8\n", + "Processing year 2052, month 9\n", + "Processing year 2052, month 10\n", + "Processing year 2052, month 11\n", + "Processing year 2052, month 12\n", + "Processing file: CIL_subset_ssp126_2053.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2053, month 1\n", + "Processing year 2053, month 2\n", + "Processing year 2053, month 3\n", + "Processing year 2053, month 4\n", + "Processing year 2053, month 5\n", + "Processing year 2053, month 6\n", + "Processing year 2053, month 7\n", + "Processing year 2053, month 8\n", + "Processing year 2053, month 9\n", + "Processing year 2053, month 10\n", + "Processing year 2053, month 11\n", + "Processing year 2053, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2053, month 1\n", + "Processing year 2053, month 2\n", + "Processing year 2053, month 3\n", + "Processing year 2053, month 4\n", + "Processing year 2053, month 5\n", + "Processing year 2053, month 6\n", + "Processing year 2053, month 7\n", + "Processing year 2053, month 8\n", + "Processing year 2053, month 9\n", + "Processing year 2053, month 10\n", + "Processing year 2053, month 11\n", + "Processing year 2053, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2053, month 1\n", + "Processing year 2053, month 2\n", + "Processing year 2053, month 3\n", + "Processing year 2053, month 4\n", + "Processing year 2053, month 5\n", + "Processing year 2053, month 6\n", + "Processing year 2053, month 7\n", + "Processing year 2053, month 8\n", + "Processing year 2053, month 9\n", + "Processing year 2053, month 10\n", + "Processing year 2053, month 11\n", + "Processing year 2053, month 12\n", + "Processing file: CIL_subset_ssp126_2054.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2054, month 1\n", + "Processing year 2054, month 2\n", + "Processing year 2054, month 3\n", + "Processing year 2054, month 4\n", + "Processing year 2054, month 5\n", + "Processing year 2054, month 6\n", + "Processing year 2054, month 7\n", + "Processing year 2054, month 8\n", + "Processing year 2054, month 9\n", + "Processing year 2054, month 10\n", + "Processing year 2054, month 11\n", + "Processing year 2054, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2054, month 1\n", + "Processing year 2054, month 2\n", + "Processing year 2054, month 3\n", + "Processing year 2054, month 4\n", + "Processing year 2054, month 5\n", + "Processing year 2054, month 6\n", + "Processing year 2054, month 7\n", + "Processing year 2054, month 8\n", + "Processing year 2054, month 9\n", + "Processing year 2054, month 10\n", + "Processing year 2054, month 11\n", + "Processing year 2054, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2054, month 1\n", + "Processing year 2054, month 2\n", + "Processing year 2054, month 3\n", + "Processing year 2054, month 4\n", + "Processing year 2054, month 5\n", + "Processing year 2054, month 6\n", + "Processing year 2054, month 7\n", + "Processing year 2054, month 8\n", + "Processing year 2054, month 9\n", + "Processing year 2054, month 10\n", + "Processing year 2054, month 11\n", + "Processing year 2054, month 12\n", + "Processing file: CIL_subset_ssp126_2055.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2055, month 1\n", + "Processing year 2055, month 2\n", + "Processing year 2055, month 3\n", + "Processing year 2055, month 4\n", + "Processing year 2055, month 5\n", + "Processing year 2055, month 6\n", + "Processing year 2055, month 7\n", + "Processing year 2055, month 8\n", + "Processing year 2055, month 9\n", + "Processing year 2055, month 10\n", + "Processing year 2055, month 11\n", + "Processing year 2055, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2055, month 1\n", + "Processing year 2055, month 2\n", + "Processing year 2055, month 3\n", + "Processing year 2055, month 4\n", + "Processing year 2055, month 5\n", + "Processing year 2055, month 6\n", + "Processing year 2055, month 7\n", + "Processing year 2055, month 8\n", + "Processing year 2055, month 9\n", + "Processing year 2055, month 10\n", + "Processing year 2055, month 11\n", + "Processing year 2055, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2055, month 1\n", + "Processing year 2055, month 2\n", + "Processing year 2055, month 3\n", + "Processing year 2055, month 4\n", + "Processing year 2055, month 5\n", + "Processing year 2055, month 6\n", + "Processing year 2055, month 7\n", + "Processing year 2055, month 8\n", + "Processing year 2055, month 9\n", + "Processing year 2055, month 10\n", + "Processing year 2055, month 11\n", + "Processing year 2055, month 12\n", + "Processing file: CIL_subset_ssp126_2056.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2056, month 1\n", + "Processing year 2056, month 2\n", + "Processing year 2056, month 3\n", + "Processing year 2056, month 4\n", + "Processing year 2056, month 5\n", + "Processing year 2056, month 6\n", + "Processing year 2056, month 7\n", + "Processing year 2056, month 8\n", + "Processing year 2056, month 9\n", + "Processing year 2056, month 10\n", + "Processing year 2056, month 11\n", + "Processing year 2056, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2056, month 1\n", + "Processing year 2056, month 2\n", + "Processing year 2056, month 3\n", + "Processing year 2056, month 4\n", + "Processing year 2056, month 5\n", + "Processing year 2056, month 6\n", + "Processing year 2056, month 7\n", + "Processing year 2056, month 8\n", + "Processing year 2056, month 9\n", + "Processing year 2056, month 10\n", + "Processing year 2056, month 11\n", + "Processing year 2056, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2056, month 1\n", + "Processing year 2056, month 2\n", + "Processing year 2056, month 3\n", + "Processing year 2056, month 4\n", + "Processing year 2056, month 5\n", + "Processing year 2056, month 6\n", + "Processing year 2056, month 7\n", + "Processing year 2056, month 8\n", + "Processing year 2056, month 9\n", + "Processing year 2056, month 10\n", + "Processing year 2056, month 11\n", + "Processing year 2056, month 12\n", + "Processing file: CIL_subset_ssp126_2057.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2057, month 1\n", + "Processing year 2057, month 2\n", + "Processing year 2057, month 3\n", + "Processing year 2057, month 4\n", + "Processing year 2057, month 5\n", + "Processing year 2057, month 6\n", + "Processing year 2057, month 7\n", + "Processing year 2057, month 8\n", + "Processing year 2057, month 9\n", + "Processing year 2057, month 10\n", + "Processing year 2057, month 11\n", + "Processing year 2057, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2057, month 1\n", + "Processing year 2057, month 2\n", + "Processing year 2057, month 3\n", + "Processing year 2057, month 4\n", + "Processing year 2057, month 5\n", + "Processing year 2057, month 6\n", + "Processing year 2057, month 7\n", + "Processing year 2057, month 8\n", + "Processing year 2057, month 9\n", + "Processing year 2057, month 10\n", + "Processing year 2057, month 11\n", + "Processing year 2057, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2057, month 1\n", + "Processing year 2057, month 2\n", + "Processing year 2057, month 3\n", + "Processing year 2057, month 4\n", + "Processing year 2057, month 5\n", + "Processing year 2057, month 6\n", + "Processing year 2057, month 7\n", + "Processing year 2057, month 8\n", + "Processing year 2057, month 9\n", + "Processing year 2057, month 10\n", + "Processing year 2057, month 11\n", + "Processing year 2057, month 12\n", + "Processing file: CIL_subset_ssp126_2058.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2058, month 1\n", + "Processing year 2058, month 2\n", + "Processing year 2058, month 3\n", + "Processing year 2058, month 4\n", + "Processing year 2058, month 5\n", + "Processing year 2058, month 6\n", + "Processing year 2058, month 7\n", + "Processing year 2058, month 8\n", + "Processing year 2058, month 9\n", + "Processing year 2058, month 10\n", + "Processing year 2058, month 11\n", + "Processing year 2058, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2058, month 1\n", + "Processing year 2058, month 2\n", + "Processing year 2058, month 3\n", + "Processing year 2058, month 4\n", + "Processing year 2058, month 5\n", + "Processing year 2058, month 6\n", + "Processing year 2058, month 7\n", + "Processing year 2058, month 8\n", + "Processing year 2058, month 9\n", + "Processing year 2058, month 10\n", + "Processing year 2058, month 11\n", + "Processing year 2058, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2058, month 1\n", + "Processing year 2058, month 2\n", + "Processing year 2058, month 3\n", + "Processing year 2058, month 4\n", + "Processing year 2058, month 5\n", + "Processing year 2058, month 6\n", + "Processing year 2058, month 7\n", + "Processing year 2058, month 8\n", + "Processing year 2058, month 9\n", + "Processing year 2058, month 10\n", + "Processing year 2058, month 11\n", + "Processing year 2058, month 12\n", + "Processing file: CIL_subset_ssp126_2059.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2059, month 1\n", + "Processing year 2059, month 2\n", + "Processing year 2059, month 3\n", + "Processing year 2059, month 4\n", + "Processing year 2059, month 5\n", + "Processing year 2059, month 6\n", + "Processing year 2059, month 7\n", + "Processing year 2059, month 8\n", + "Processing year 2059, month 9\n", + "Processing year 2059, month 10\n", + "Processing year 2059, month 11\n", + "Processing year 2059, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2059, month 1\n", + "Processing year 2059, month 2\n", + "Processing year 2059, month 3\n", + "Processing year 2059, month 4\n", + "Processing year 2059, month 5\n", + "Processing year 2059, month 6\n", + "Processing year 2059, month 7\n", + "Processing year 2059, month 8\n", + "Processing year 2059, month 9\n", + "Processing year 2059, month 10\n", + "Processing year 2059, month 11\n", + "Processing year 2059, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2059, month 1\n", + "Processing year 2059, month 2\n", + "Processing year 2059, month 3\n", + "Processing year 2059, month 4\n", + "Processing year 2059, month 5\n", + "Processing year 2059, month 6\n", + "Processing year 2059, month 7\n", + "Processing year 2059, month 8\n", + "Processing year 2059, month 9\n", + "Processing year 2059, month 10\n", + "Processing year 2059, month 11\n", + "Processing year 2059, month 12\n", + "Processing file: CIL_subset_ssp126_2060.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2060, month 1\n", + "Processing year 2060, month 2\n", + "Processing year 2060, month 3\n", + "Processing year 2060, month 4\n", + "Processing year 2060, month 5\n", + "Processing year 2060, month 6\n", + "Processing year 2060, month 7\n", + "Processing year 2060, month 8\n", + "Processing year 2060, month 9\n", + "Processing year 2060, month 10\n", + "Processing year 2060, month 11\n", + "Processing year 2060, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2060, month 1\n", + "Processing year 2060, month 2\n", + "Processing year 2060, month 3\n", + "Processing year 2060, month 4\n", + "Processing year 2060, month 5\n", + "Processing year 2060, month 6\n", + "Processing year 2060, month 7\n", + "Processing year 2060, month 8\n", + "Processing year 2060, month 9\n", + "Processing year 2060, month 10\n", + "Processing year 2060, month 11\n", + "Processing year 2060, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2060, month 1\n", + "Processing year 2060, month 2\n", + "Processing year 2060, month 3\n", + "Processing year 2060, month 4\n", + "Processing year 2060, month 5\n", + "Processing year 2060, month 6\n", + "Processing year 2060, month 7\n", + "Processing year 2060, month 8\n", + "Processing year 2060, month 9\n", + "Processing year 2060, month 10\n", + "Processing year 2060, month 11\n", + "Processing year 2060, month 12\n", + "Processing file: CIL_subset_ssp126_2061.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2061, month 1\n", + "Processing year 2061, month 2\n", + "Processing year 2061, month 3\n", + "Processing year 2061, month 4\n", + "Processing year 2061, month 5\n", + "Processing year 2061, month 6\n", + "Processing year 2061, month 7\n", + "Processing year 2061, month 8\n", + "Processing year 2061, month 9\n", + "Processing year 2061, month 10\n", + "Processing year 2061, month 11\n", + "Processing year 2061, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2061, month 1\n", + "Processing year 2061, month 2\n", + "Processing year 2061, month 3\n", + "Processing year 2061, month 4\n", + "Processing year 2061, month 5\n", + "Processing year 2061, month 6\n", + "Processing year 2061, month 7\n", + "Processing year 2061, month 8\n", + "Processing year 2061, month 9\n", + "Processing year 2061, month 10\n", + "Processing year 2061, month 11\n", + "Processing year 2061, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2061, month 1\n", + "Processing year 2061, month 2\n", + "Processing year 2061, month 3\n", + "Processing year 2061, month 4\n", + "Processing year 2061, month 5\n", + "Processing year 2061, month 6\n", + "Processing year 2061, month 7\n", + "Processing year 2061, month 8\n", + "Processing year 2061, month 9\n", + "Processing year 2061, month 10\n", + "Processing year 2061, month 11\n", + "Processing year 2061, month 12\n", + "Processing file: CIL_subset_ssp126_2062.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2062, month 1\n", + "Processing year 2062, month 2\n", + "Processing year 2062, month 3\n", + "Processing year 2062, month 4\n", + "Processing year 2062, month 5\n", + "Processing year 2062, month 6\n", + "Processing year 2062, month 7\n", + "Processing year 2062, month 8\n", + "Processing year 2062, month 9\n", + "Processing year 2062, month 10\n", + "Processing year 2062, month 11\n", + "Processing year 2062, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2062, month 1\n", + "Processing year 2062, month 2\n", + "Processing year 2062, month 3\n", + "Processing year 2062, month 4\n", + "Processing year 2062, month 5\n", + "Processing year 2062, month 6\n", + "Processing year 2062, month 7\n", + "Processing year 2062, month 8\n", + "Processing year 2062, month 9\n", + "Processing year 2062, month 10\n", + "Processing year 2062, month 11\n", + "Processing year 2062, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2062, month 1\n", + "Processing year 2062, month 2\n", + "Processing year 2062, month 3\n", + "Processing year 2062, month 4\n", + "Processing year 2062, month 5\n", + "Processing year 2062, month 6\n", + "Processing year 2062, month 7\n", + "Processing year 2062, month 8\n", + "Processing year 2062, month 9\n", + "Processing year 2062, month 10\n", + "Processing year 2062, month 11\n", + "Processing year 2062, month 12\n", + "Processing file: CIL_subset_ssp126_2063.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2063, month 1\n", + "Processing year 2063, month 2\n", + "Processing year 2063, month 3\n", + "Processing year 2063, month 4\n", + "Processing year 2063, month 5\n", + "Processing year 2063, month 6\n", + "Processing year 2063, month 7\n", + "Processing year 2063, month 8\n", + "Processing year 2063, month 9\n", + "Processing year 2063, month 10\n", + "Processing year 2063, month 11\n", + "Processing year 2063, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2063, month 1\n", + "Processing year 2063, month 2\n", + "Processing year 2063, month 3\n", + "Processing year 2063, month 4\n", + "Processing year 2063, month 5\n", + "Processing year 2063, month 6\n", + "Processing year 2063, month 7\n", + "Processing year 2063, month 8\n", + "Processing year 2063, month 9\n", + "Processing year 2063, month 10\n", + "Processing year 2063, month 11\n", + "Processing year 2063, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2063, month 1\n", + "Processing year 2063, month 2\n", + "Processing year 2063, month 3\n", + "Processing year 2063, month 4\n", + "Processing year 2063, month 5\n", + "Processing year 2063, month 6\n", + "Processing year 2063, month 7\n", + "Processing year 2063, month 8\n", + "Processing year 2063, month 9\n", + "Processing year 2063, month 10\n", + "Processing year 2063, month 11\n", + "Processing year 2063, month 12\n", + "Processing file: CIL_subset_ssp126_2064.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2064, month 1\n", + "Processing year 2064, month 2\n", + "Processing year 2064, month 3\n", + "Processing year 2064, month 4\n", + "Processing year 2064, month 5\n", + "Processing year 2064, month 6\n", + "Processing year 2064, month 7\n", + "Processing year 2064, month 8\n", + "Processing year 2064, month 9\n", + "Processing year 2064, month 10\n", + "Processing year 2064, month 11\n", + "Processing year 2064, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2064, month 1\n", + "Processing year 2064, month 2\n", + "Processing year 2064, month 3\n", + "Processing year 2064, month 4\n", + "Processing year 2064, month 5\n", + "Processing year 2064, month 6\n", + "Processing year 2064, month 7\n", + "Processing year 2064, month 8\n", + "Processing year 2064, month 9\n", + "Processing year 2064, month 10\n", + "Processing year 2064, month 11\n", + "Processing year 2064, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2064, month 1\n", + "Processing year 2064, month 2\n", + "Processing year 2064, month 3\n", + "Processing year 2064, month 4\n", + "Processing year 2064, month 5\n", + "Processing year 2064, month 6\n", + "Processing year 2064, month 7\n", + "Processing year 2064, month 8\n", + "Processing year 2064, month 9\n", + "Processing year 2064, month 10\n", + "Processing year 2064, month 11\n", + "Processing year 2064, month 12\n", + "Processing file: CIL_subset_ssp126_2065.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2065, month 1\n", + "Processing year 2065, month 2\n", + "Processing year 2065, month 3\n", + "Processing year 2065, month 4\n", + "Processing year 2065, month 5\n", + "Processing year 2065, month 6\n", + "Processing year 2065, month 7\n", + "Processing year 2065, month 8\n", + "Processing year 2065, month 9\n", + "Processing year 2065, month 10\n", + "Processing year 2065, month 11\n", + "Processing year 2065, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2065, month 1\n", + "Processing year 2065, month 2\n", + "Processing year 2065, month 3\n", + "Processing year 2065, month 4\n", + "Processing year 2065, month 5\n", + "Processing year 2065, month 6\n", + "Processing year 2065, month 7\n", + "Processing year 2065, month 8\n", + "Processing year 2065, month 9\n", + "Processing year 2065, month 10\n", + "Processing year 2065, month 11\n", + "Processing year 2065, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2065, month 1\n", + "Processing year 2065, month 2\n", + "Processing year 2065, month 3\n", + "Processing year 2065, month 4\n", + "Processing year 2065, month 5\n", + "Processing year 2065, month 6\n", + "Processing year 2065, month 7\n", + "Processing year 2065, month 8\n", + "Processing year 2065, month 9\n", + "Processing year 2065, month 10\n", + "Processing year 2065, month 11\n", + "Processing year 2065, month 12\n", + "Processing file: CIL_subset_ssp126_2066.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2066, month 1\n", + "Processing year 2066, month 2\n", + "Processing year 2066, month 3\n", + "Processing year 2066, month 4\n", + "Processing year 2066, month 5\n", + "Processing year 2066, month 6\n", + "Processing year 2066, month 7\n", + "Processing year 2066, month 8\n", + "Processing year 2066, month 9\n", + "Processing year 2066, month 10\n", + "Processing year 2066, month 11\n", + "Processing year 2066, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2066, month 1\n", + "Processing year 2066, month 2\n", + "Processing year 2066, month 3\n", + "Processing year 2066, month 4\n", + "Processing year 2066, month 5\n", + "Processing year 2066, month 6\n", + "Processing year 2066, month 7\n", + "Processing year 2066, month 8\n", + "Processing year 2066, month 9\n", + "Processing year 2066, month 10\n", + "Processing year 2066, month 11\n", + "Processing year 2066, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2066, month 1\n", + "Processing year 2066, month 2\n", + "Processing year 2066, month 3\n", + "Processing year 2066, month 4\n", + "Processing year 2066, month 5\n", + "Processing year 2066, month 6\n", + "Processing year 2066, month 7\n", + "Processing year 2066, month 8\n", + "Processing year 2066, month 9\n", + "Processing year 2066, month 10\n", + "Processing year 2066, month 11\n", + "Processing year 2066, month 12\n", + "Processing file: CIL_subset_ssp126_2067.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2067, month 1\n", + "Processing year 2067, month 2\n", + "Processing year 2067, month 3\n", + "Processing year 2067, month 4\n", + "Processing year 2067, month 5\n", + "Processing year 2067, month 6\n", + "Processing year 2067, month 7\n", + "Processing year 2067, month 8\n", + "Processing year 2067, month 9\n", + "Processing year 2067, month 10\n", + "Processing year 2067, month 11\n", + "Processing year 2067, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2067, month 1\n", + "Processing year 2067, month 2\n", + "Processing year 2067, month 3\n", + "Processing year 2067, month 4\n", + "Processing year 2067, month 5\n", + "Processing year 2067, month 6\n", + "Processing year 2067, month 7\n", + "Processing year 2067, month 8\n", + "Processing year 2067, month 9\n", + "Processing year 2067, month 10\n", + "Processing year 2067, month 11\n", + "Processing year 2067, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2067, month 1\n", + "Processing year 2067, month 2\n", + "Processing year 2067, month 3\n", + "Processing year 2067, month 4\n", + "Processing year 2067, month 5\n", + "Processing year 2067, month 6\n", + "Processing year 2067, month 7\n", + "Processing year 2067, month 8\n", + "Processing year 2067, month 9\n", + "Processing year 2067, month 10\n", + "Processing year 2067, month 11\n", + "Processing year 2067, month 12\n", + "Processing file: CIL_subset_ssp126_2068.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2068, month 1\n", + "Processing year 2068, month 2\n", + "Processing year 2068, month 3\n", + "Processing year 2068, month 4\n", + "Processing year 2068, month 5\n", + "Processing year 2068, month 6\n", + "Processing year 2068, month 7\n", + "Processing year 2068, month 8\n", + "Processing year 2068, month 9\n", + "Processing year 2068, month 10\n", + "Processing year 2068, month 11\n", + "Processing year 2068, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2068, month 1\n", + "Processing year 2068, month 2\n", + "Processing year 2068, month 3\n", + "Processing year 2068, month 4\n", + "Processing year 2068, month 5\n", + "Processing year 2068, month 6\n", + "Processing year 2068, month 7\n", + "Processing year 2068, month 8\n", + "Processing year 2068, month 9\n", + "Processing year 2068, month 10\n", + "Processing year 2068, month 11\n", + "Processing year 2068, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2068, month 1\n", + "Processing year 2068, month 2\n", + "Processing year 2068, month 3\n", + "Processing year 2068, month 4\n", + "Processing year 2068, month 5\n", + "Processing year 2068, month 6\n", + "Processing year 2068, month 7\n", + "Processing year 2068, month 8\n", + "Processing year 2068, month 9\n", + "Processing year 2068, month 10\n", + "Processing year 2068, month 11\n", + "Processing year 2068, month 12\n", + "Processing file: CIL_subset_ssp126_2069.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2069, month 1\n", + "Processing year 2069, month 2\n", + "Processing year 2069, month 3\n", + "Processing year 2069, month 4\n", + "Processing year 2069, month 5\n", + "Processing year 2069, month 6\n", + "Processing year 2069, month 7\n", + "Processing year 2069, month 8\n", + "Processing year 2069, month 9\n", + "Processing year 2069, month 10\n", + "Processing year 2069, month 11\n", + "Processing year 2069, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2069, month 1\n", + "Processing year 2069, month 2\n", + "Processing year 2069, month 3\n", + "Processing year 2069, month 4\n", + "Processing year 2069, month 5\n", + "Processing year 2069, month 6\n", + "Processing year 2069, month 7\n", + "Processing year 2069, month 8\n", + "Processing year 2069, month 9\n", + "Processing year 2069, month 10\n", + "Processing year 2069, month 11\n", + "Processing year 2069, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2069, month 1\n", + "Processing year 2069, month 2\n", + "Processing year 2069, month 3\n", + "Processing year 2069, month 4\n", + "Processing year 2069, month 5\n", + "Processing year 2069, month 6\n", + "Processing year 2069, month 7\n", + "Processing year 2069, month 8\n", + "Processing year 2069, month 9\n", + "Processing year 2069, month 10\n", + "Processing year 2069, month 11\n", + "Processing year 2069, month 12\n", + "Processing file: CIL_subset_ssp126_2070.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2070, month 1\n", + "Processing year 2070, month 2\n", + "Processing year 2070, month 3\n", + "Processing year 2070, month 4\n", + "Processing year 2070, month 5\n", + "Processing year 2070, month 6\n", + "Processing year 2070, month 7\n", + "Processing year 2070, month 8\n", + "Processing year 2070, month 9\n", + "Processing year 2070, month 10\n", + "Processing year 2070, month 11\n", + "Processing year 2070, month 12\n", + "Processing model: MPI-ESM1-2-LR\n", + "Processing year 2070, month 1\n", + "Processing year 2070, month 2\n", + "Processing year 2070, month 3\n", + "Processing year 2070, month 4\n", + "Processing year 2070, month 5\n", + "Processing year 2070, month 6\n", + "Processing year 2070, month 7\n", + "Processing year 2070, month 8\n", + "Processing year 2070, month 9\n", + "Processing year 2070, month 10\n", + "Processing year 2070, month 11\n", + "Processing year 2070, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2070, month 1\n", + "Processing year 2070, month 2\n", + "Processing year 2070, month 3\n", + "Processing year 2070, month 4\n", + "Processing year 2070, month 5\n", + "Processing year 2070, month 6\n", + "Processing year 2070, month 7\n", + "Processing year 2070, month 8\n", + "Processing year 2070, month 9\n", + "Processing year 2070, month 10\n", + "Processing year 2070, month 11\n", + "Processing year 2070, month 12\n", + "Saved monthly data for lowest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp126/lowest_monthly_prediction_weather_by_facility_ANC.csv\n", + "Saved window data for lowest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp126/lowest_window_prediction_weather_by_facility_ANC.csv\n", + "Saved monthly data for mean model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp126/mean_monthly_prediction_weather_by_facility_ANC.csv\n", + "Saved window data for mean model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp126/mean_window_prediction_weather_by_facility_ANC.csv\n", + "Saved monthly data for highest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp126/highest_monthly_prediction_weather_by_facility_ANC.csv\n", + "Saved window data for highest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp126/highest_window_prediction_weather_by_facility_ANC.csv\n", + "Processing scenario: ssp245\n", + "Models of interest ['HadGEM3-GC31-LL', 'UKESM1-0-LL', 'INM-CM5-0']\n", + "Processing file: CIL_subset_ssp245_2024.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2024, month 1\n", + "Processing year 2024, month 2\n", + "Processing year 2024, month 3\n", + "Processing year 2024, month 4\n", + "Processing year 2024, month 5\n", + "Processing year 2024, month 6\n", + "Processing year 2024, month 7\n", + "Processing year 2024, month 8\n", + "Processing year 2024, month 9\n", + "Processing year 2024, month 10\n", + "Processing year 2024, month 11\n", + "Processing year 2024, month 12\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing model: UKESM1-0-LL\n", + "Processing year 2024, month 1\n", + "Processing year 2024, month 2\n", + "Processing year 2024, month 3\n", + "Processing year 2024, month 4\n", + "Processing year 2024, month 5\n", + "Processing year 2024, month 6\n", + "Processing year 2024, month 7\n", + "Processing year 2024, month 8\n", + "Processing year 2024, month 9\n", + "Processing year 2024, month 10\n", + "Processing year 2024, month 11\n", + "Processing year 2024, month 12\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing model: INM-CM5-0\n", + "Processing year 2024, month 1\n", + "Processing year 2024, month 2\n", + "Processing year 2024, month 3\n", + "Processing year 2024, month 4\n", + "Processing year 2024, month 5\n", + "Processing year 2024, month 6\n", + "Processing year 2024, month 7\n", + "Processing year 2024, month 8\n", + "Processing year 2024, month 9\n", + "Processing year 2024, month 10\n", + "Processing year 2024, month 11\n", + "Processing year 2024, month 12\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing file: CIL_subset_ssp245_2025.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2025, month 1\n", + "Processing year 2025, month 2\n", + "Processing year 2025, month 3\n", + "Processing year 2025, month 4\n", + "Processing year 2025, month 5\n", + "Processing year 2025, month 6\n", + "Processing year 2025, month 7\n", + "Processing year 2025, month 8\n", + "Processing year 2025, month 9\n", + "Processing year 2025, month 10\n", + "Processing year 2025, month 11\n", + "Processing year 2025, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2025, month 1\n", + "Processing year 2025, month 2\n", + "Processing year 2025, month 3\n", + "Processing year 2025, month 4\n", + "Processing year 2025, month 5\n", + "Processing year 2025, month 6\n", + "Processing year 2025, month 7\n", + "Processing year 2025, month 8\n", + "Processing year 2025, month 9\n", + "Processing year 2025, month 10\n", + "Processing year 2025, month 11\n", + "Processing year 2025, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2025, month 1\n", + "Processing year 2025, month 2\n", + "Processing year 2025, month 3\n", + "Processing year 2025, month 4\n", + "Processing year 2025, month 5\n", + "Processing year 2025, month 6\n", + "Processing year 2025, month 7\n", + "Processing year 2025, month 8\n", + "Processing year 2025, month 9\n", + "Processing year 2025, month 10\n", + "Processing year 2025, month 11\n", + "Processing year 2025, month 12\n", + "Processing file: CIL_subset_ssp245_2026.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2026, month 1\n", + "Processing year 2026, month 2\n", + "Processing year 2026, month 3\n", + "Processing year 2026, month 4\n", + "Processing year 2026, month 5\n", + "Processing year 2026, month 6\n", + "Processing year 2026, month 7\n", + "Processing year 2026, month 8\n", + "Processing year 2026, month 9\n", + "Processing year 2026, month 10\n", + "Processing year 2026, month 11\n", + "Processing year 2026, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2026, month 1\n", + "Processing year 2026, month 2\n", + "Processing year 2026, month 3\n", + "Processing year 2026, month 4\n", + "Processing year 2026, month 5\n", + "Processing year 2026, month 6\n", + "Processing year 2026, month 7\n", + "Processing year 2026, month 8\n", + "Processing year 2026, month 9\n", + "Processing year 2026, month 10\n", + "Processing year 2026, month 11\n", + "Processing year 2026, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2026, month 1\n", + "Processing year 2026, month 2\n", + "Processing year 2026, month 3\n", + "Processing year 2026, month 4\n", + "Processing year 2026, month 5\n", + "Processing year 2026, month 6\n", + "Processing year 2026, month 7\n", + "Processing year 2026, month 8\n", + "Processing year 2026, month 9\n", + "Processing year 2026, month 10\n", + "Processing year 2026, month 11\n", + "Processing year 2026, month 12\n", + "Processing file: CIL_subset_ssp245_2027.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2027, month 1\n", + "Processing year 2027, month 2\n", + "Processing year 2027, month 3\n", + "Processing year 2027, month 4\n", + "Processing year 2027, month 5\n", + "Processing year 2027, month 6\n", + "Processing year 2027, month 7\n", + "Processing year 2027, month 8\n", + "Processing year 2027, month 9\n", + "Processing year 2027, month 10\n", + "Processing year 2027, month 11\n", + "Processing year 2027, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2027, month 1\n", + "Processing year 2027, month 2\n", + "Processing year 2027, month 3\n", + "Processing year 2027, month 4\n", + "Processing year 2027, month 5\n", + "Processing year 2027, month 6\n", + "Processing year 2027, month 7\n", + "Processing year 2027, month 8\n", + "Processing year 2027, month 9\n", + "Processing year 2027, month 10\n", + "Processing year 2027, month 11\n", + "Processing year 2027, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2027, month 1\n", + "Processing year 2027, month 2\n", + "Processing year 2027, month 3\n", + "Processing year 2027, month 4\n", + "Processing year 2027, month 5\n", + "Processing year 2027, month 6\n", + "Processing year 2027, month 7\n", + "Processing year 2027, month 8\n", + "Processing year 2027, month 9\n", + "Processing year 2027, month 10\n", + "Processing year 2027, month 11\n", + "Processing year 2027, month 12\n", + "Processing file: CIL_subset_ssp245_2028.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2028, month 1\n", + "Processing year 2028, month 2\n", + "Processing year 2028, month 3\n", + "Processing year 2028, month 4\n", + "Processing year 2028, month 5\n", + "Processing year 2028, month 6\n", + "Processing year 2028, month 7\n", + "Processing year 2028, month 8\n", + "Processing year 2028, month 9\n", + "Processing year 2028, month 10\n", + "Processing year 2028, month 11\n", + "Processing year 2028, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2028, month 1\n", + "Processing year 2028, month 2\n", + "Processing year 2028, month 3\n", + "Processing year 2028, month 4\n", + "Processing year 2028, month 5\n", + "Processing year 2028, month 6\n", + "Processing year 2028, month 7\n", + "Processing year 2028, month 8\n", + "Processing year 2028, month 9\n", + "Processing year 2028, month 10\n", + "Processing year 2028, month 11\n", + "Processing year 2028, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2028, month 1\n", + "Processing year 2028, month 2\n", + "Processing year 2028, month 3\n", + "Processing year 2028, month 4\n", + "Processing year 2028, month 5\n", + "Processing year 2028, month 6\n", + "Processing year 2028, month 7\n", + "Processing year 2028, month 8\n", + "Processing year 2028, month 9\n", + "Processing year 2028, month 10\n", + "Processing year 2028, month 11\n", + "Processing year 2028, month 12\n", + "Processing file: CIL_subset_ssp245_2029.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2029, month 1\n", + "Processing year 2029, month 2\n", + "Processing year 2029, month 3\n", + "Processing year 2029, month 4\n", + "Processing year 2029, month 5\n", + "Processing year 2029, month 6\n", + "Processing year 2029, month 7\n", + "Processing year 2029, month 8\n", + "Processing year 2029, month 9\n", + "Processing year 2029, month 10\n", + "Processing year 2029, month 11\n", + "Processing year 2029, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2029, month 1\n", + "Processing year 2029, month 2\n", + "Processing year 2029, month 3\n", + "Processing year 2029, month 4\n", + "Processing year 2029, month 5\n", + "Processing year 2029, month 6\n", + "Processing year 2029, month 7\n", + "Processing year 2029, month 8\n", + "Processing year 2029, month 9\n", + "Processing year 2029, month 10\n", + "Processing year 2029, month 11\n", + "Processing year 2029, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2029, month 1\n", + "Processing year 2029, month 2\n", + "Processing year 2029, month 3\n", + "Processing year 2029, month 4\n", + "Processing year 2029, month 5\n", + "Processing year 2029, month 6\n", + "Processing year 2029, month 7\n", + "Processing year 2029, month 8\n", + "Processing year 2029, month 9\n", + "Processing year 2029, month 10\n", + "Processing year 2029, month 11\n", + "Processing year 2029, month 12\n", + "Processing file: CIL_subset_ssp245_2030.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2030, month 1\n", + "Processing year 2030, month 2\n", + "Processing year 2030, month 3\n", + "Processing year 2030, month 4\n", + "Processing year 2030, month 5\n", + "Processing year 2030, month 6\n", + "Processing year 2030, month 7\n", + "Processing year 2030, month 8\n", + "Processing year 2030, month 9\n", + "Processing year 2030, month 10\n", + "Processing year 2030, month 11\n", + "Processing year 2030, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2030, month 1\n", + "Processing year 2030, month 2\n", + "Processing year 2030, month 3\n", + "Processing year 2030, month 4\n", + "Processing year 2030, month 5\n", + "Processing year 2030, month 6\n", + "Processing year 2030, month 7\n", + "Processing year 2030, month 8\n", + "Processing year 2030, month 9\n", + "Processing year 2030, month 10\n", + "Processing year 2030, month 11\n", + "Processing year 2030, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2030, month 1\n", + "Processing year 2030, month 2\n", + "Processing year 2030, month 3\n", + "Processing year 2030, month 4\n", + "Processing year 2030, month 5\n", + "Processing year 2030, month 6\n", + "Processing year 2030, month 7\n", + "Processing year 2030, month 8\n", + "Processing year 2030, month 9\n", + "Processing year 2030, month 10\n", + "Processing year 2030, month 11\n", + "Processing year 2030, month 12\n", + "Processing file: CIL_subset_ssp245_2031.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2031, month 1\n", + "Processing year 2031, month 2\n", + "Processing year 2031, month 3\n", + "Processing year 2031, month 4\n", + "Processing year 2031, month 5\n", + "Processing year 2031, month 6\n", + "Processing year 2031, month 7\n", + "Processing year 2031, month 8\n", + "Processing year 2031, month 9\n", + "Processing year 2031, month 10\n", + "Processing year 2031, month 11\n", + "Processing year 2031, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2031, month 1\n", + "Processing year 2031, month 2\n", + "Processing year 2031, month 3\n", + "Processing year 2031, month 4\n", + "Processing year 2031, month 5\n", + "Processing year 2031, month 6\n", + "Processing year 2031, month 7\n", + "Processing year 2031, month 8\n", + "Processing year 2031, month 9\n", + "Processing year 2031, month 10\n", + "Processing year 2031, month 11\n", + "Processing year 2031, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2031, month 1\n", + "Processing year 2031, month 2\n", + "Processing year 2031, month 3\n", + "Processing year 2031, month 4\n", + "Processing year 2031, month 5\n", + "Processing year 2031, month 6\n", + "Processing year 2031, month 7\n", + "Processing year 2031, month 8\n", + "Processing year 2031, month 9\n", + "Processing year 2031, month 10\n", + "Processing year 2031, month 11\n", + "Processing year 2031, month 12\n", + "Processing file: CIL_subset_ssp245_2032.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2032, month 1\n", + "Processing year 2032, month 2\n", + "Processing year 2032, month 3\n", + "Processing year 2032, month 4\n", + "Processing year 2032, month 5\n", + "Processing year 2032, month 6\n", + "Processing year 2032, month 7\n", + "Processing year 2032, month 8\n", + "Processing year 2032, month 9\n", + "Processing year 2032, month 10\n", + "Processing year 2032, month 11\n", + "Processing year 2032, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2032, month 1\n", + "Processing year 2032, month 2\n", + "Processing year 2032, month 3\n", + "Processing year 2032, month 4\n", + "Processing year 2032, month 5\n", + "Processing year 2032, month 6\n", + "Processing year 2032, month 7\n", + "Processing year 2032, month 8\n", + "Processing year 2032, month 9\n", + "Processing year 2032, month 10\n", + "Processing year 2032, month 11\n", + "Processing year 2032, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2032, month 1\n", + "Processing year 2032, month 2\n", + "Processing year 2032, month 3\n", + "Processing year 2032, month 4\n", + "Processing year 2032, month 5\n", + "Processing year 2032, month 6\n", + "Processing year 2032, month 7\n", + "Processing year 2032, month 8\n", + "Processing year 2032, month 9\n", + "Processing year 2032, month 10\n", + "Processing year 2032, month 11\n", + "Processing year 2032, month 12\n", + "Processing file: CIL_subset_ssp245_2033.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2033, month 1\n", + "Processing year 2033, month 2\n", + "Processing year 2033, month 3\n", + "Processing year 2033, month 4\n", + "Processing year 2033, month 5\n", + "Processing year 2033, month 6\n", + "Processing year 2033, month 7\n", + "Processing year 2033, month 8\n", + "Processing year 2033, month 9\n", + "Processing year 2033, month 10\n", + "Processing year 2033, month 11\n", + "Processing year 2033, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2033, month 1\n", + "Processing year 2033, month 2\n", + "Processing year 2033, month 3\n", + "Processing year 2033, month 4\n", + "Processing year 2033, month 5\n", + "Processing year 2033, month 6\n", + "Processing year 2033, month 7\n", + "Processing year 2033, month 8\n", + "Processing year 2033, month 9\n", + "Processing year 2033, month 10\n", + "Processing year 2033, month 11\n", + "Processing year 2033, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2033, month 1\n", + "Processing year 2033, month 2\n", + "Processing year 2033, month 3\n", + "Processing year 2033, month 4\n", + "Processing year 2033, month 5\n", + "Processing year 2033, month 6\n", + "Processing year 2033, month 7\n", + "Processing year 2033, month 8\n", + "Processing year 2033, month 9\n", + "Processing year 2033, month 10\n", + "Processing year 2033, month 11\n", + "Processing year 2033, month 12\n", + "Processing file: CIL_subset_ssp245_2034.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2034, month 1\n", + "Processing year 2034, month 2\n", + "Processing year 2034, month 3\n", + "Processing year 2034, month 4\n", + "Processing year 2034, month 5\n", + "Processing year 2034, month 6\n", + "Processing year 2034, month 7\n", + "Processing year 2034, month 8\n", + "Processing year 2034, month 9\n", + "Processing year 2034, month 10\n", + "Processing year 2034, month 11\n", + "Processing year 2034, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2034, month 1\n", + "Processing year 2034, month 2\n", + "Processing year 2034, month 3\n", + "Processing year 2034, month 4\n", + "Processing year 2034, month 5\n", + "Processing year 2034, month 6\n", + "Processing year 2034, month 7\n", + "Processing year 2034, month 8\n", + "Processing year 2034, month 9\n", + "Processing year 2034, month 10\n", + "Processing year 2034, month 11\n", + "Processing year 2034, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2034, month 1\n", + "Processing year 2034, month 2\n", + "Processing year 2034, month 3\n", + "Processing year 2034, month 4\n", + "Processing year 2034, month 5\n", + "Processing year 2034, month 6\n", + "Processing year 2034, month 7\n", + "Processing year 2034, month 8\n", + "Processing year 2034, month 9\n", + "Processing year 2034, month 10\n", + "Processing year 2034, month 11\n", + "Processing year 2034, month 12\n", + "Processing file: CIL_subset_ssp245_2035.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2035, month 1\n", + "Processing year 2035, month 2\n", + "Processing year 2035, month 3\n", + "Processing year 2035, month 4\n", + "Processing year 2035, month 5\n", + "Processing year 2035, month 6\n", + "Processing year 2035, month 7\n", + "Processing year 2035, month 8\n", + "Processing year 2035, month 9\n", + "Processing year 2035, month 10\n", + "Processing year 2035, month 11\n", + "Processing year 2035, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2035, month 1\n", + "Processing year 2035, month 2\n", + "Processing year 2035, month 3\n", + "Processing year 2035, month 4\n", + "Processing year 2035, month 5\n", + "Processing year 2035, month 6\n", + "Processing year 2035, month 7\n", + "Processing year 2035, month 8\n", + "Processing year 2035, month 9\n", + "Processing year 2035, month 10\n", + "Processing year 2035, month 11\n", + "Processing year 2035, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2035, month 1\n", + "Processing year 2035, month 2\n", + "Processing year 2035, month 3\n", + "Processing year 2035, month 4\n", + "Processing year 2035, month 5\n", + "Processing year 2035, month 6\n", + "Processing year 2035, month 7\n", + "Processing year 2035, month 8\n", + "Processing year 2035, month 9\n", + "Processing year 2035, month 10\n", + "Processing year 2035, month 11\n", + "Processing year 2035, month 12\n", + "Processing file: CIL_subset_ssp245_2036.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2036, month 1\n", + "Processing year 2036, month 2\n", + "Processing year 2036, month 3\n", + "Processing year 2036, month 4\n", + "Processing year 2036, month 5\n", + "Processing year 2036, month 6\n", + "Processing year 2036, month 7\n", + "Processing year 2036, month 8\n", + "Processing year 2036, month 9\n", + "Processing year 2036, month 10\n", + "Processing year 2036, month 11\n", + "Processing year 2036, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2036, month 1\n", + "Processing year 2036, month 2\n", + "Processing year 2036, month 3\n", + "Processing year 2036, month 4\n", + "Processing year 2036, month 5\n", + "Processing year 2036, month 6\n", + "Processing year 2036, month 7\n", + "Processing year 2036, month 8\n", + "Processing year 2036, month 9\n", + "Processing year 2036, month 10\n", + "Processing year 2036, month 11\n", + "Processing year 2036, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2036, month 1\n", + "Processing year 2036, month 2\n", + "Processing year 2036, month 3\n", + "Processing year 2036, month 4\n", + "Processing year 2036, month 5\n", + "Processing year 2036, month 6\n", + "Processing year 2036, month 7\n", + "Processing year 2036, month 8\n", + "Processing year 2036, month 9\n", + "Processing year 2036, month 10\n", + "Processing year 2036, month 11\n", + "Processing year 2036, month 12\n", + "Processing file: CIL_subset_ssp245_2037.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2037, month 1\n", + "Processing year 2037, month 2\n", + "Processing year 2037, month 3\n", + "Processing year 2037, month 4\n", + "Processing year 2037, month 5\n", + "Processing year 2037, month 6\n", + "Processing year 2037, month 7\n", + "Processing year 2037, month 8\n", + "Processing year 2037, month 9\n", + "Processing year 2037, month 10\n", + "Processing year 2037, month 11\n", + "Processing year 2037, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2037, month 1\n", + "Processing year 2037, month 2\n", + "Processing year 2037, month 3\n", + "Processing year 2037, month 4\n", + "Processing year 2037, month 5\n", + "Processing year 2037, month 6\n", + "Processing year 2037, month 7\n", + "Processing year 2037, month 8\n", + "Processing year 2037, month 9\n", + "Processing year 2037, month 10\n", + "Processing year 2037, month 11\n", + "Processing year 2037, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2037, month 1\n", + "Processing year 2037, month 2\n", + "Processing year 2037, month 3\n", + "Processing year 2037, month 4\n", + "Processing year 2037, month 5\n", + "Processing year 2037, month 6\n", + "Processing year 2037, month 7\n", + "Processing year 2037, month 8\n", + "Processing year 2037, month 9\n", + "Processing year 2037, month 10\n", + "Processing year 2037, month 11\n", + "Processing year 2037, month 12\n", + "Processing file: CIL_subset_ssp245_2038.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2038, month 1\n", + "Processing year 2038, month 2\n", + "Processing year 2038, month 3\n", + "Processing year 2038, month 4\n", + "Processing year 2038, month 5\n", + "Processing year 2038, month 6\n", + "Processing year 2038, month 7\n", + "Processing year 2038, month 8\n", + "Processing year 2038, month 9\n", + "Processing year 2038, month 10\n", + "Processing year 2038, month 11\n", + "Processing year 2038, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2038, month 1\n", + "Processing year 2038, month 2\n", + "Processing year 2038, month 3\n", + "Processing year 2038, month 4\n", + "Processing year 2038, month 5\n", + "Processing year 2038, month 6\n", + "Processing year 2038, month 7\n", + "Processing year 2038, month 8\n", + "Processing year 2038, month 9\n", + "Processing year 2038, month 10\n", + "Processing year 2038, month 11\n", + "Processing year 2038, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2038, month 1\n", + "Processing year 2038, month 2\n", + "Processing year 2038, month 3\n", + "Processing year 2038, month 4\n", + "Processing year 2038, month 5\n", + "Processing year 2038, month 6\n", + "Processing year 2038, month 7\n", + "Processing year 2038, month 8\n", + "Processing year 2038, month 9\n", + "Processing year 2038, month 10\n", + "Processing year 2038, month 11\n", + "Processing year 2038, month 12\n", + "Processing file: CIL_subset_ssp245_2039.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2039, month 1\n", + "Processing year 2039, month 2\n", + "Processing year 2039, month 3\n", + "Processing year 2039, month 4\n", + "Processing year 2039, month 5\n", + "Processing year 2039, month 6\n", + "Processing year 2039, month 7\n", + "Processing year 2039, month 8\n", + "Processing year 2039, month 9\n", + "Processing year 2039, month 10\n", + "Processing year 2039, month 11\n", + "Processing year 2039, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2039, month 1\n", + "Processing year 2039, month 2\n", + "Processing year 2039, month 3\n", + "Processing year 2039, month 4\n", + "Processing year 2039, month 5\n", + "Processing year 2039, month 6\n", + "Processing year 2039, month 7\n", + "Processing year 2039, month 8\n", + "Processing year 2039, month 9\n", + "Processing year 2039, month 10\n", + "Processing year 2039, month 11\n", + "Processing year 2039, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2039, month 1\n", + "Processing year 2039, month 2\n", + "Processing year 2039, month 3\n", + "Processing year 2039, month 4\n", + "Processing year 2039, month 5\n", + "Processing year 2039, month 6\n", + "Processing year 2039, month 7\n", + "Processing year 2039, month 8\n", + "Processing year 2039, month 9\n", + "Processing year 2039, month 10\n", + "Processing year 2039, month 11\n", + "Processing year 2039, month 12\n", + "Processing file: CIL_subset_ssp245_2040.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2040, month 1\n", + "Processing year 2040, month 2\n", + "Processing year 2040, month 3\n", + "Processing year 2040, month 4\n", + "Processing year 2040, month 5\n", + "Processing year 2040, month 6\n", + "Processing year 2040, month 7\n", + "Processing year 2040, month 8\n", + "Processing year 2040, month 9\n", + "Processing year 2040, month 10\n", + "Processing year 2040, month 11\n", + "Processing year 2040, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2040, month 1\n", + "Processing year 2040, month 2\n", + "Processing year 2040, month 3\n", + "Processing year 2040, month 4\n", + "Processing year 2040, month 5\n", + "Processing year 2040, month 6\n", + "Processing year 2040, month 7\n", + "Processing year 2040, month 8\n", + "Processing year 2040, month 9\n", + "Processing year 2040, month 10\n", + "Processing year 2040, month 11\n", + "Processing year 2040, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2040, month 1\n", + "Processing year 2040, month 2\n", + "Processing year 2040, month 3\n", + "Processing year 2040, month 4\n", + "Processing year 2040, month 5\n", + "Processing year 2040, month 6\n", + "Processing year 2040, month 7\n", + "Processing year 2040, month 8\n", + "Processing year 2040, month 9\n", + "Processing year 2040, month 10\n", + "Processing year 2040, month 11\n", + "Processing year 2040, month 12\n", + "Processing file: CIL_subset_ssp245_2041.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2041, month 1\n", + "Processing year 2041, month 2\n", + "Processing year 2041, month 3\n", + "Processing year 2041, month 4\n", + "Processing year 2041, month 5\n", + "Processing year 2041, month 6\n", + "Processing year 2041, month 7\n", + "Processing year 2041, month 8\n", + "Processing year 2041, month 9\n", + "Processing year 2041, month 10\n", + "Processing year 2041, month 11\n", + "Processing year 2041, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2041, month 1\n", + "Processing year 2041, month 2\n", + "Processing year 2041, month 3\n", + "Processing year 2041, month 4\n", + "Processing year 2041, month 5\n", + "Processing year 2041, month 6\n", + "Processing year 2041, month 7\n", + "Processing year 2041, month 8\n", + "Processing year 2041, month 9\n", + "Processing year 2041, month 10\n", + "Processing year 2041, month 11\n", + "Processing year 2041, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2041, month 1\n", + "Processing year 2041, month 2\n", + "Processing year 2041, month 3\n", + "Processing year 2041, month 4\n", + "Processing year 2041, month 5\n", + "Processing year 2041, month 6\n", + "Processing year 2041, month 7\n", + "Processing year 2041, month 8\n", + "Processing year 2041, month 9\n", + "Processing year 2041, month 10\n", + "Processing year 2041, month 11\n", + "Processing year 2041, month 12\n", + "Processing file: CIL_subset_ssp245_2042.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2042, month 1\n", + "Processing year 2042, month 2\n", + "Processing year 2042, month 3\n", + "Processing year 2042, month 4\n", + "Processing year 2042, month 5\n", + "Processing year 2042, month 6\n", + "Processing year 2042, month 7\n", + "Processing year 2042, month 8\n", + "Processing year 2042, month 9\n", + "Processing year 2042, month 10\n", + "Processing year 2042, month 11\n", + "Processing year 2042, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2042, month 1\n", + "Processing year 2042, month 2\n", + "Processing year 2042, month 3\n", + "Processing year 2042, month 4\n", + "Processing year 2042, month 5\n", + "Processing year 2042, month 6\n", + "Processing year 2042, month 7\n", + "Processing year 2042, month 8\n", + "Processing year 2042, month 9\n", + "Processing year 2042, month 10\n", + "Processing year 2042, month 11\n", + "Processing year 2042, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2042, month 1\n", + "Processing year 2042, month 2\n", + "Processing year 2042, month 3\n", + "Processing year 2042, month 4\n", + "Processing year 2042, month 5\n", + "Processing year 2042, month 6\n", + "Processing year 2042, month 7\n", + "Processing year 2042, month 8\n", + "Processing year 2042, month 9\n", + "Processing year 2042, month 10\n", + "Processing year 2042, month 11\n", + "Processing year 2042, month 12\n", + "Processing file: CIL_subset_ssp245_2043.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2043, month 1\n", + "Processing year 2043, month 2\n", + "Processing year 2043, month 3\n", + "Processing year 2043, month 4\n", + "Processing year 2043, month 5\n", + "Processing year 2043, month 6\n", + "Processing year 2043, month 7\n", + "Processing year 2043, month 8\n", + "Processing year 2043, month 9\n", + "Processing year 2043, month 10\n", + "Processing year 2043, month 11\n", + "Processing year 2043, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2043, month 1\n", + "Processing year 2043, month 2\n", + "Processing year 2043, month 3\n", + "Processing year 2043, month 4\n", + "Processing year 2043, month 5\n", + "Processing year 2043, month 6\n", + "Processing year 2043, month 7\n", + "Processing year 2043, month 8\n", + "Processing year 2043, month 9\n", + "Processing year 2043, month 10\n", + "Processing year 2043, month 11\n", + "Processing year 2043, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2043, month 1\n", + "Processing year 2043, month 2\n", + "Processing year 2043, month 3\n", + "Processing year 2043, month 4\n", + "Processing year 2043, month 5\n", + "Processing year 2043, month 6\n", + "Processing year 2043, month 7\n", + "Processing year 2043, month 8\n", + "Processing year 2043, month 9\n", + "Processing year 2043, month 10\n", + "Processing year 2043, month 11\n", + "Processing year 2043, month 12\n", + "Processing file: CIL_subset_ssp245_2044.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2044, month 1\n", + "Processing year 2044, month 2\n", + "Processing year 2044, month 3\n", + "Processing year 2044, month 4\n", + "Processing year 2044, month 5\n", + "Processing year 2044, month 6\n", + "Processing year 2044, month 7\n", + "Processing year 2044, month 8\n", + "Processing year 2044, month 9\n", + "Processing year 2044, month 10\n", + "Processing year 2044, month 11\n", + "Processing year 2044, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2044, month 1\n", + "Processing year 2044, month 2\n", + "Processing year 2044, month 3\n", + "Processing year 2044, month 4\n", + "Processing year 2044, month 5\n", + "Processing year 2044, month 6\n", + "Processing year 2044, month 7\n", + "Processing year 2044, month 8\n", + "Processing year 2044, month 9\n", + "Processing year 2044, month 10\n", + "Processing year 2044, month 11\n", + "Processing year 2044, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2044, month 1\n", + "Processing year 2044, month 2\n", + "Processing year 2044, month 3\n", + "Processing year 2044, month 4\n", + "Processing year 2044, month 5\n", + "Processing year 2044, month 6\n", + "Processing year 2044, month 7\n", + "Processing year 2044, month 8\n", + "Processing year 2044, month 9\n", + "Processing year 2044, month 10\n", + "Processing year 2044, month 11\n", + "Processing year 2044, month 12\n", + "Processing file: CIL_subset_ssp245_2045.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2045, month 1\n", + "Processing year 2045, month 2\n", + "Processing year 2045, month 3\n", + "Processing year 2045, month 4\n", + "Processing year 2045, month 5\n", + "Processing year 2045, month 6\n", + "Processing year 2045, month 7\n", + "Processing year 2045, month 8\n", + "Processing year 2045, month 9\n", + "Processing year 2045, month 10\n", + "Processing year 2045, month 11\n", + "Processing year 2045, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2045, month 1\n", + "Processing year 2045, month 2\n", + "Processing year 2045, month 3\n", + "Processing year 2045, month 4\n", + "Processing year 2045, month 5\n", + "Processing year 2045, month 6\n", + "Processing year 2045, month 7\n", + "Processing year 2045, month 8\n", + "Processing year 2045, month 9\n", + "Processing year 2045, month 10\n", + "Processing year 2045, month 11\n", + "Processing year 2045, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2045, month 1\n", + "Processing year 2045, month 2\n", + "Processing year 2045, month 3\n", + "Processing year 2045, month 4\n", + "Processing year 2045, month 5\n", + "Processing year 2045, month 6\n", + "Processing year 2045, month 7\n", + "Processing year 2045, month 8\n", + "Processing year 2045, month 9\n", + "Processing year 2045, month 10\n", + "Processing year 2045, month 11\n", + "Processing year 2045, month 12\n", + "Processing file: CIL_subset_ssp245_2046.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2046, month 1\n", + "Processing year 2046, month 2\n", + "Processing year 2046, month 3\n", + "Processing year 2046, month 4\n", + "Processing year 2046, month 5\n", + "Processing year 2046, month 6\n", + "Processing year 2046, month 7\n", + "Processing year 2046, month 8\n", + "Processing year 2046, month 9\n", + "Processing year 2046, month 10\n", + "Processing year 2046, month 11\n", + "Processing year 2046, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2046, month 1\n", + "Processing year 2046, month 2\n", + "Processing year 2046, month 3\n", + "Processing year 2046, month 4\n", + "Processing year 2046, month 5\n", + "Processing year 2046, month 6\n", + "Processing year 2046, month 7\n", + "Processing year 2046, month 8\n", + "Processing year 2046, month 9\n", + "Processing year 2046, month 10\n", + "Processing year 2046, month 11\n", + "Processing year 2046, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2046, month 1\n", + "Processing year 2046, month 2\n", + "Processing year 2046, month 3\n", + "Processing year 2046, month 4\n", + "Processing year 2046, month 5\n", + "Processing year 2046, month 6\n", + "Processing year 2046, month 7\n", + "Processing year 2046, month 8\n", + "Processing year 2046, month 9\n", + "Processing year 2046, month 10\n", + "Processing year 2046, month 11\n", + "Processing year 2046, month 12\n", + "Processing file: CIL_subset_ssp245_2047.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2047, month 1\n", + "Processing year 2047, month 2\n", + "Processing year 2047, month 3\n", + "Processing year 2047, month 4\n", + "Processing year 2047, month 5\n", + "Processing year 2047, month 6\n", + "Processing year 2047, month 7\n", + "Processing year 2047, month 8\n", + "Processing year 2047, month 9\n", + "Processing year 2047, month 10\n", + "Processing year 2047, month 11\n", + "Processing year 2047, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2047, month 1\n", + "Processing year 2047, month 2\n", + "Processing year 2047, month 3\n", + "Processing year 2047, month 4\n", + "Processing year 2047, month 5\n", + "Processing year 2047, month 6\n", + "Processing year 2047, month 7\n", + "Processing year 2047, month 8\n", + "Processing year 2047, month 9\n", + "Processing year 2047, month 10\n", + "Processing year 2047, month 11\n", + "Processing year 2047, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2047, month 1\n", + "Processing year 2047, month 2\n", + "Processing year 2047, month 3\n", + "Processing year 2047, month 4\n", + "Processing year 2047, month 5\n", + "Processing year 2047, month 6\n", + "Processing year 2047, month 7\n", + "Processing year 2047, month 8\n", + "Processing year 2047, month 9\n", + "Processing year 2047, month 10\n", + "Processing year 2047, month 11\n", + "Processing year 2047, month 12\n", + "Processing file: CIL_subset_ssp245_2048.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2048, month 1\n", + "Processing year 2048, month 2\n", + "Processing year 2048, month 3\n", + "Processing year 2048, month 4\n", + "Processing year 2048, month 5\n", + "Processing year 2048, month 6\n", + "Processing year 2048, month 7\n", + "Processing year 2048, month 8\n", + "Processing year 2048, month 9\n", + "Processing year 2048, month 10\n", + "Processing year 2048, month 11\n", + "Processing year 2048, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2048, month 1\n", + "Processing year 2048, month 2\n", + "Processing year 2048, month 3\n", + "Processing year 2048, month 4\n", + "Processing year 2048, month 5\n", + "Processing year 2048, month 6\n", + "Processing year 2048, month 7\n", + "Processing year 2048, month 8\n", + "Processing year 2048, month 9\n", + "Processing year 2048, month 10\n", + "Processing year 2048, month 11\n", + "Processing year 2048, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2048, month 1\n", + "Processing year 2048, month 2\n", + "Processing year 2048, month 3\n", + "Processing year 2048, month 4\n", + "Processing year 2048, month 5\n", + "Processing year 2048, month 6\n", + "Processing year 2048, month 7\n", + "Processing year 2048, month 8\n", + "Processing year 2048, month 9\n", + "Processing year 2048, month 10\n", + "Processing year 2048, month 11\n", + "Processing year 2048, month 12\n", + "Processing file: CIL_subset_ssp245_2049.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2049, month 1\n", + "Processing year 2049, month 2\n", + "Processing year 2049, month 3\n", + "Processing year 2049, month 4\n", + "Processing year 2049, month 5\n", + "Processing year 2049, month 6\n", + "Processing year 2049, month 7\n", + "Processing year 2049, month 8\n", + "Processing year 2049, month 9\n", + "Processing year 2049, month 10\n", + "Processing year 2049, month 11\n", + "Processing year 2049, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2049, month 1\n", + "Processing year 2049, month 2\n", + "Processing year 2049, month 3\n", + "Processing year 2049, month 4\n", + "Processing year 2049, month 5\n", + "Processing year 2049, month 6\n", + "Processing year 2049, month 7\n", + "Processing year 2049, month 8\n", + "Processing year 2049, month 9\n", + "Processing year 2049, month 10\n", + "Processing year 2049, month 11\n", + "Processing year 2049, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2049, month 1\n", + "Processing year 2049, month 2\n", + "Processing year 2049, month 3\n", + "Processing year 2049, month 4\n", + "Processing year 2049, month 5\n", + "Processing year 2049, month 6\n", + "Processing year 2049, month 7\n", + "Processing year 2049, month 8\n", + "Processing year 2049, month 9\n", + "Processing year 2049, month 10\n", + "Processing year 2049, month 11\n", + "Processing year 2049, month 12\n", + "Processing file: CIL_subset_ssp245_2050.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2050, month 1\n", + "Processing year 2050, month 2\n", + "Processing year 2050, month 3\n", + "Processing year 2050, month 4\n", + "Processing year 2050, month 5\n", + "Processing year 2050, month 6\n", + "Processing year 2050, month 7\n", + "Processing year 2050, month 8\n", + "Processing year 2050, month 9\n", + "Processing year 2050, month 10\n", + "Processing year 2050, month 11\n", + "Processing year 2050, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2050, month 1\n", + "Processing year 2050, month 2\n", + "Processing year 2050, month 3\n", + "Processing year 2050, month 4\n", + "Processing year 2050, month 5\n", + "Processing year 2050, month 6\n", + "Processing year 2050, month 7\n", + "Processing year 2050, month 8\n", + "Processing year 2050, month 9\n", + "Processing year 2050, month 10\n", + "Processing year 2050, month 11\n", + "Processing year 2050, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2050, month 1\n", + "Processing year 2050, month 2\n", + "Processing year 2050, month 3\n", + "Processing year 2050, month 4\n", + "Processing year 2050, month 5\n", + "Processing year 2050, month 6\n", + "Processing year 2050, month 7\n", + "Processing year 2050, month 8\n", + "Processing year 2050, month 9\n", + "Processing year 2050, month 10\n", + "Processing year 2050, month 11\n", + "Processing year 2050, month 12\n", + "Processing file: CIL_subset_ssp245_2051.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2051, month 1\n", + "Processing year 2051, month 2\n", + "Processing year 2051, month 3\n", + "Processing year 2051, month 4\n", + "Processing year 2051, month 5\n", + "Processing year 2051, month 6\n", + "Processing year 2051, month 7\n", + "Processing year 2051, month 8\n", + "Processing year 2051, month 9\n", + "Processing year 2051, month 10\n", + "Processing year 2051, month 11\n", + "Processing year 2051, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2051, month 1\n", + "Processing year 2051, month 2\n", + "Processing year 2051, month 3\n", + "Processing year 2051, month 4\n", + "Processing year 2051, month 5\n", + "Processing year 2051, month 6\n", + "Processing year 2051, month 7\n", + "Processing year 2051, month 8\n", + "Processing year 2051, month 9\n", + "Processing year 2051, month 10\n", + "Processing year 2051, month 11\n", + "Processing year 2051, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2051, month 1\n", + "Processing year 2051, month 2\n", + "Processing year 2051, month 3\n", + "Processing year 2051, month 4\n", + "Processing year 2051, month 5\n", + "Processing year 2051, month 6\n", + "Processing year 2051, month 7\n", + "Processing year 2051, month 8\n", + "Processing year 2051, month 9\n", + "Processing year 2051, month 10\n", + "Processing year 2051, month 11\n", + "Processing year 2051, month 12\n", + "Processing file: CIL_subset_ssp245_2052.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2052, month 1\n", + "Processing year 2052, month 2\n", + "Processing year 2052, month 3\n", + "Processing year 2052, month 4\n", + "Processing year 2052, month 5\n", + "Processing year 2052, month 6\n", + "Processing year 2052, month 7\n", + "Processing year 2052, month 8\n", + "Processing year 2052, month 9\n", + "Processing year 2052, month 10\n", + "Processing year 2052, month 11\n", + "Processing year 2052, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2052, month 1\n", + "Processing year 2052, month 2\n", + "Processing year 2052, month 3\n", + "Processing year 2052, month 4\n", + "Processing year 2052, month 5\n", + "Processing year 2052, month 6\n", + "Processing year 2052, month 7\n", + "Processing year 2052, month 8\n", + "Processing year 2052, month 9\n", + "Processing year 2052, month 10\n", + "Processing year 2052, month 11\n", + "Processing year 2052, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2052, month 1\n", + "Processing year 2052, month 2\n", + "Processing year 2052, month 3\n", + "Processing year 2052, month 4\n", + "Processing year 2052, month 5\n", + "Processing year 2052, month 6\n", + "Processing year 2052, month 7\n", + "Processing year 2052, month 8\n", + "Processing year 2052, month 9\n", + "Processing year 2052, month 10\n", + "Processing year 2052, month 11\n", + "Processing year 2052, month 12\n", + "Processing file: CIL_subset_ssp245_2053.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2053, month 1\n", + "Processing year 2053, month 2\n", + "Processing year 2053, month 3\n", + "Processing year 2053, month 4\n", + "Processing year 2053, month 5\n", + "Processing year 2053, month 6\n", + "Processing year 2053, month 7\n", + "Processing year 2053, month 8\n", + "Processing year 2053, month 9\n", + "Processing year 2053, month 10\n", + "Processing year 2053, month 11\n", + "Processing year 2053, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2053, month 1\n", + "Processing year 2053, month 2\n", + "Processing year 2053, month 3\n", + "Processing year 2053, month 4\n", + "Processing year 2053, month 5\n", + "Processing year 2053, month 6\n", + "Processing year 2053, month 7\n", + "Processing year 2053, month 8\n", + "Processing year 2053, month 9\n", + "Processing year 2053, month 10\n", + "Processing year 2053, month 11\n", + "Processing year 2053, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2053, month 1\n", + "Processing year 2053, month 2\n", + "Processing year 2053, month 3\n", + "Processing year 2053, month 4\n", + "Processing year 2053, month 5\n", + "Processing year 2053, month 6\n", + "Processing year 2053, month 7\n", + "Processing year 2053, month 8\n", + "Processing year 2053, month 9\n", + "Processing year 2053, month 10\n", + "Processing year 2053, month 11\n", + "Processing year 2053, month 12\n", + "Processing file: CIL_subset_ssp245_2054.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2054, month 1\n", + "Processing year 2054, month 2\n", + "Processing year 2054, month 3\n", + "Processing year 2054, month 4\n", + "Processing year 2054, month 5\n", + "Processing year 2054, month 6\n", + "Processing year 2054, month 7\n", + "Processing year 2054, month 8\n", + "Processing year 2054, month 9\n", + "Processing year 2054, month 10\n", + "Processing year 2054, month 11\n", + "Processing year 2054, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2054, month 1\n", + "Processing year 2054, month 2\n", + "Processing year 2054, month 3\n", + "Processing year 2054, month 4\n", + "Processing year 2054, month 5\n", + "Processing year 2054, month 6\n", + "Processing year 2054, month 7\n", + "Processing year 2054, month 8\n", + "Processing year 2054, month 9\n", + "Processing year 2054, month 10\n", + "Processing year 2054, month 11\n", + "Processing year 2054, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2054, month 1\n", + "Processing year 2054, month 2\n", + "Processing year 2054, month 3\n", + "Processing year 2054, month 4\n", + "Processing year 2054, month 5\n", + "Processing year 2054, month 6\n", + "Processing year 2054, month 7\n", + "Processing year 2054, month 8\n", + "Processing year 2054, month 9\n", + "Processing year 2054, month 10\n", + "Processing year 2054, month 11\n", + "Processing year 2054, month 12\n", + "Processing file: CIL_subset_ssp245_2055.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2055, month 1\n", + "Processing year 2055, month 2\n", + "Processing year 2055, month 3\n", + "Processing year 2055, month 4\n", + "Processing year 2055, month 5\n", + "Processing year 2055, month 6\n", + "Processing year 2055, month 7\n", + "Processing year 2055, month 8\n", + "Processing year 2055, month 9\n", + "Processing year 2055, month 10\n", + "Processing year 2055, month 11\n", + "Processing year 2055, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2055, month 1\n", + "Processing year 2055, month 2\n", + "Processing year 2055, month 3\n", + "Processing year 2055, month 4\n", + "Processing year 2055, month 5\n", + "Processing year 2055, month 6\n", + "Processing year 2055, month 7\n", + "Processing year 2055, month 8\n", + "Processing year 2055, month 9\n", + "Processing year 2055, month 10\n", + "Processing year 2055, month 11\n", + "Processing year 2055, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2055, month 1\n", + "Processing year 2055, month 2\n", + "Processing year 2055, month 3\n", + "Processing year 2055, month 4\n", + "Processing year 2055, month 5\n", + "Processing year 2055, month 6\n", + "Processing year 2055, month 7\n", + "Processing year 2055, month 8\n", + "Processing year 2055, month 9\n", + "Processing year 2055, month 10\n", + "Processing year 2055, month 11\n", + "Processing year 2055, month 12\n", + "Processing file: CIL_subset_ssp245_2056.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2056, month 1\n", + "Processing year 2056, month 2\n", + "Processing year 2056, month 3\n", + "Processing year 2056, month 4\n", + "Processing year 2056, month 5\n", + "Processing year 2056, month 6\n", + "Processing year 2056, month 7\n", + "Processing year 2056, month 8\n", + "Processing year 2056, month 9\n", + "Processing year 2056, month 10\n", + "Processing year 2056, month 11\n", + "Processing year 2056, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2056, month 1\n", + "Processing year 2056, month 2\n", + "Processing year 2056, month 3\n", + "Processing year 2056, month 4\n", + "Processing year 2056, month 5\n", + "Processing year 2056, month 6\n", + "Processing year 2056, month 7\n", + "Processing year 2056, month 8\n", + "Processing year 2056, month 9\n", + "Processing year 2056, month 10\n", + "Processing year 2056, month 11\n", + "Processing year 2056, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2056, month 1\n", + "Processing year 2056, month 2\n", + "Processing year 2056, month 3\n", + "Processing year 2056, month 4\n", + "Processing year 2056, month 5\n", + "Processing year 2056, month 6\n", + "Processing year 2056, month 7\n", + "Processing year 2056, month 8\n", + "Processing year 2056, month 9\n", + "Processing year 2056, month 10\n", + "Processing year 2056, month 11\n", + "Processing year 2056, month 12\n", + "Processing file: CIL_subset_ssp245_2057.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2057, month 1\n", + "Processing year 2057, month 2\n", + "Processing year 2057, month 3\n", + "Processing year 2057, month 4\n", + "Processing year 2057, month 5\n", + "Processing year 2057, month 6\n", + "Processing year 2057, month 7\n", + "Processing year 2057, month 8\n", + "Processing year 2057, month 9\n", + "Processing year 2057, month 10\n", + "Processing year 2057, month 11\n", + "Processing year 2057, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2057, month 1\n", + "Processing year 2057, month 2\n", + "Processing year 2057, month 3\n", + "Processing year 2057, month 4\n", + "Processing year 2057, month 5\n", + "Processing year 2057, month 6\n", + "Processing year 2057, month 7\n", + "Processing year 2057, month 8\n", + "Processing year 2057, month 9\n", + "Processing year 2057, month 10\n", + "Processing year 2057, month 11\n", + "Processing year 2057, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2057, month 1\n", + "Processing year 2057, month 2\n", + "Processing year 2057, month 3\n", + "Processing year 2057, month 4\n", + "Processing year 2057, month 5\n", + "Processing year 2057, month 6\n", + "Processing year 2057, month 7\n", + "Processing year 2057, month 8\n", + "Processing year 2057, month 9\n", + "Processing year 2057, month 10\n", + "Processing year 2057, month 11\n", + "Processing year 2057, month 12\n", + "Processing file: CIL_subset_ssp245_2058.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2058, month 1\n", + "Processing year 2058, month 2\n", + "Processing year 2058, month 3\n", + "Processing year 2058, month 4\n", + "Processing year 2058, month 5\n", + "Processing year 2058, month 6\n", + "Processing year 2058, month 7\n", + "Processing year 2058, month 8\n", + "Processing year 2058, month 9\n", + "Processing year 2058, month 10\n", + "Processing year 2058, month 11\n", + "Processing year 2058, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2058, month 1\n", + "Processing year 2058, month 2\n", + "Processing year 2058, month 3\n", + "Processing year 2058, month 4\n", + "Processing year 2058, month 5\n", + "Processing year 2058, month 6\n", + "Processing year 2058, month 7\n", + "Processing year 2058, month 8\n", + "Processing year 2058, month 9\n", + "Processing year 2058, month 10\n", + "Processing year 2058, month 11\n", + "Processing year 2058, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2058, month 1\n", + "Processing year 2058, month 2\n", + "Processing year 2058, month 3\n", + "Processing year 2058, month 4\n", + "Processing year 2058, month 5\n", + "Processing year 2058, month 6\n", + "Processing year 2058, month 7\n", + "Processing year 2058, month 8\n", + "Processing year 2058, month 9\n", + "Processing year 2058, month 10\n", + "Processing year 2058, month 11\n", + "Processing year 2058, month 12\n", + "Processing file: CIL_subset_ssp245_2059.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2059, month 1\n", + "Processing year 2059, month 2\n", + "Processing year 2059, month 3\n", + "Processing year 2059, month 4\n", + "Processing year 2059, month 5\n", + "Processing year 2059, month 6\n", + "Processing year 2059, month 7\n", + "Processing year 2059, month 8\n", + "Processing year 2059, month 9\n", + "Processing year 2059, month 10\n", + "Processing year 2059, month 11\n", + "Processing year 2059, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2059, month 1\n", + "Processing year 2059, month 2\n", + "Processing year 2059, month 3\n", + "Processing year 2059, month 4\n", + "Processing year 2059, month 5\n", + "Processing year 2059, month 6\n", + "Processing year 2059, month 7\n", + "Processing year 2059, month 8\n", + "Processing year 2059, month 9\n", + "Processing year 2059, month 10\n", + "Processing year 2059, month 11\n", + "Processing year 2059, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2059, month 1\n", + "Processing year 2059, month 2\n", + "Processing year 2059, month 3\n", + "Processing year 2059, month 4\n", + "Processing year 2059, month 5\n", + "Processing year 2059, month 6\n", + "Processing year 2059, month 7\n", + "Processing year 2059, month 8\n", + "Processing year 2059, month 9\n", + "Processing year 2059, month 10\n", + "Processing year 2059, month 11\n", + "Processing year 2059, month 12\n", + "Processing file: CIL_subset_ssp245_2060.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2060, month 1\n", + "Processing year 2060, month 2\n", + "Processing year 2060, month 3\n", + "Processing year 2060, month 4\n", + "Processing year 2060, month 5\n", + "Processing year 2060, month 6\n", + "Processing year 2060, month 7\n", + "Processing year 2060, month 8\n", + "Processing year 2060, month 9\n", + "Processing year 2060, month 10\n", + "Processing year 2060, month 11\n", + "Processing year 2060, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2060, month 1\n", + "Processing year 2060, month 2\n", + "Processing year 2060, month 3\n", + "Processing year 2060, month 4\n", + "Processing year 2060, month 5\n", + "Processing year 2060, month 6\n", + "Processing year 2060, month 7\n", + "Processing year 2060, month 8\n", + "Processing year 2060, month 9\n", + "Processing year 2060, month 10\n", + "Processing year 2060, month 11\n", + "Processing year 2060, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2060, month 1\n", + "Processing year 2060, month 2\n", + "Processing year 2060, month 3\n", + "Processing year 2060, month 4\n", + "Processing year 2060, month 5\n", + "Processing year 2060, month 6\n", + "Processing year 2060, month 7\n", + "Processing year 2060, month 8\n", + "Processing year 2060, month 9\n", + "Processing year 2060, month 10\n", + "Processing year 2060, month 11\n", + "Processing year 2060, month 12\n", + "Processing file: CIL_subset_ssp245_2061.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2061, month 1\n", + "Processing year 2061, month 2\n", + "Processing year 2061, month 3\n", + "Processing year 2061, month 4\n", + "Processing year 2061, month 5\n", + "Processing year 2061, month 6\n", + "Processing year 2061, month 7\n", + "Processing year 2061, month 8\n", + "Processing year 2061, month 9\n", + "Processing year 2061, month 10\n", + "Processing year 2061, month 11\n", + "Processing year 2061, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2061, month 1\n", + "Processing year 2061, month 2\n", + "Processing year 2061, month 3\n", + "Processing year 2061, month 4\n", + "Processing year 2061, month 5\n", + "Processing year 2061, month 6\n", + "Processing year 2061, month 7\n", + "Processing year 2061, month 8\n", + "Processing year 2061, month 9\n", + "Processing year 2061, month 10\n", + "Processing year 2061, month 11\n", + "Processing year 2061, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2061, month 1\n", + "Processing year 2061, month 2\n", + "Processing year 2061, month 3\n", + "Processing year 2061, month 4\n", + "Processing year 2061, month 5\n", + "Processing year 2061, month 6\n", + "Processing year 2061, month 7\n", + "Processing year 2061, month 8\n", + "Processing year 2061, month 9\n", + "Processing year 2061, month 10\n", + "Processing year 2061, month 11\n", + "Processing year 2061, month 12\n", + "Processing file: CIL_subset_ssp245_2062.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2062, month 1\n", + "Processing year 2062, month 2\n", + "Processing year 2062, month 3\n", + "Processing year 2062, month 4\n", + "Processing year 2062, month 5\n", + "Processing year 2062, month 6\n", + "Processing year 2062, month 7\n", + "Processing year 2062, month 8\n", + "Processing year 2062, month 9\n", + "Processing year 2062, month 10\n", + "Processing year 2062, month 11\n", + "Processing year 2062, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2062, month 1\n", + "Processing year 2062, month 2\n", + "Processing year 2062, month 3\n", + "Processing year 2062, month 4\n", + "Processing year 2062, month 5\n", + "Processing year 2062, month 6\n", + "Processing year 2062, month 7\n", + "Processing year 2062, month 8\n", + "Processing year 2062, month 9\n", + "Processing year 2062, month 10\n", + "Processing year 2062, month 11\n", + "Processing year 2062, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2062, month 1\n", + "Processing year 2062, month 2\n", + "Processing year 2062, month 3\n", + "Processing year 2062, month 4\n", + "Processing year 2062, month 5\n", + "Processing year 2062, month 6\n", + "Processing year 2062, month 7\n", + "Processing year 2062, month 8\n", + "Processing year 2062, month 9\n", + "Processing year 2062, month 10\n", + "Processing year 2062, month 11\n", + "Processing year 2062, month 12\n", + "Processing file: CIL_subset_ssp245_2063.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2063, month 1\n", + "Processing year 2063, month 2\n", + "Processing year 2063, month 3\n", + "Processing year 2063, month 4\n", + "Processing year 2063, month 5\n", + "Processing year 2063, month 6\n", + "Processing year 2063, month 7\n", + "Processing year 2063, month 8\n", + "Processing year 2063, month 9\n", + "Processing year 2063, month 10\n", + "Processing year 2063, month 11\n", + "Processing year 2063, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2063, month 1\n", + "Processing year 2063, month 2\n", + "Processing year 2063, month 3\n", + "Processing year 2063, month 4\n", + "Processing year 2063, month 5\n", + "Processing year 2063, month 6\n", + "Processing year 2063, month 7\n", + "Processing year 2063, month 8\n", + "Processing year 2063, month 9\n", + "Processing year 2063, month 10\n", + "Processing year 2063, month 11\n", + "Processing year 2063, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2063, month 1\n", + "Processing year 2063, month 2\n", + "Processing year 2063, month 3\n", + "Processing year 2063, month 4\n", + "Processing year 2063, month 5\n", + "Processing year 2063, month 6\n", + "Processing year 2063, month 7\n", + "Processing year 2063, month 8\n", + "Processing year 2063, month 9\n", + "Processing year 2063, month 10\n", + "Processing year 2063, month 11\n", + "Processing year 2063, month 12\n", + "Processing file: CIL_subset_ssp245_2064.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2064, month 1\n", + "Processing year 2064, month 2\n", + "Processing year 2064, month 3\n", + "Processing year 2064, month 4\n", + "Processing year 2064, month 5\n", + "Processing year 2064, month 6\n", + "Processing year 2064, month 7\n", + "Processing year 2064, month 8\n", + "Processing year 2064, month 9\n", + "Processing year 2064, month 10\n", + "Processing year 2064, month 11\n", + "Processing year 2064, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2064, month 1\n", + "Processing year 2064, month 2\n", + "Processing year 2064, month 3\n", + "Processing year 2064, month 4\n", + "Processing year 2064, month 5\n", + "Processing year 2064, month 6\n", + "Processing year 2064, month 7\n", + "Processing year 2064, month 8\n", + "Processing year 2064, month 9\n", + "Processing year 2064, month 10\n", + "Processing year 2064, month 11\n", + "Processing year 2064, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2064, month 1\n", + "Processing year 2064, month 2\n", + "Processing year 2064, month 3\n", + "Processing year 2064, month 4\n", + "Processing year 2064, month 5\n", + "Processing year 2064, month 6\n", + "Processing year 2064, month 7\n", + "Processing year 2064, month 8\n", + "Processing year 2064, month 9\n", + "Processing year 2064, month 10\n", + "Processing year 2064, month 11\n", + "Processing year 2064, month 12\n", + "Processing file: CIL_subset_ssp245_2065.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2065, month 1\n", + "Processing year 2065, month 2\n", + "Processing year 2065, month 3\n", + "Processing year 2065, month 4\n", + "Processing year 2065, month 5\n", + "Processing year 2065, month 6\n", + "Processing year 2065, month 7\n", + "Processing year 2065, month 8\n", + "Processing year 2065, month 9\n", + "Processing year 2065, month 10\n", + "Processing year 2065, month 11\n", + "Processing year 2065, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2065, month 1\n", + "Processing year 2065, month 2\n", + "Processing year 2065, month 3\n", + "Processing year 2065, month 4\n", + "Processing year 2065, month 5\n", + "Processing year 2065, month 6\n", + "Processing year 2065, month 7\n", + "Processing year 2065, month 8\n", + "Processing year 2065, month 9\n", + "Processing year 2065, month 10\n", + "Processing year 2065, month 11\n", + "Processing year 2065, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2065, month 1\n", + "Processing year 2065, month 2\n", + "Processing year 2065, month 3\n", + "Processing year 2065, month 4\n", + "Processing year 2065, month 5\n", + "Processing year 2065, month 6\n", + "Processing year 2065, month 7\n", + "Processing year 2065, month 8\n", + "Processing year 2065, month 9\n", + "Processing year 2065, month 10\n", + "Processing year 2065, month 11\n", + "Processing year 2065, month 12\n", + "Processing file: CIL_subset_ssp245_2066.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2066, month 1\n", + "Processing year 2066, month 2\n", + "Processing year 2066, month 3\n", + "Processing year 2066, month 4\n", + "Processing year 2066, month 5\n", + "Processing year 2066, month 6\n", + "Processing year 2066, month 7\n", + "Processing year 2066, month 8\n", + "Processing year 2066, month 9\n", + "Processing year 2066, month 10\n", + "Processing year 2066, month 11\n", + "Processing year 2066, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2066, month 1\n", + "Processing year 2066, month 2\n", + "Processing year 2066, month 3\n", + "Processing year 2066, month 4\n", + "Processing year 2066, month 5\n", + "Processing year 2066, month 6\n", + "Processing year 2066, month 7\n", + "Processing year 2066, month 8\n", + "Processing year 2066, month 9\n", + "Processing year 2066, month 10\n", + "Processing year 2066, month 11\n", + "Processing year 2066, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2066, month 1\n", + "Processing year 2066, month 2\n", + "Processing year 2066, month 3\n", + "Processing year 2066, month 4\n", + "Processing year 2066, month 5\n", + "Processing year 2066, month 6\n", + "Processing year 2066, month 7\n", + "Processing year 2066, month 8\n", + "Processing year 2066, month 9\n", + "Processing year 2066, month 10\n", + "Processing year 2066, month 11\n", + "Processing year 2066, month 12\n", + "Processing file: CIL_subset_ssp245_2067.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2067, month 1\n", + "Processing year 2067, month 2\n", + "Processing year 2067, month 3\n", + "Processing year 2067, month 4\n", + "Processing year 2067, month 5\n", + "Processing year 2067, month 6\n", + "Processing year 2067, month 7\n", + "Processing year 2067, month 8\n", + "Processing year 2067, month 9\n", + "Processing year 2067, month 10\n", + "Processing year 2067, month 11\n", + "Processing year 2067, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2067, month 1\n", + "Processing year 2067, month 2\n", + "Processing year 2067, month 3\n", + "Processing year 2067, month 4\n", + "Processing year 2067, month 5\n", + "Processing year 2067, month 6\n", + "Processing year 2067, month 7\n", + "Processing year 2067, month 8\n", + "Processing year 2067, month 9\n", + "Processing year 2067, month 10\n", + "Processing year 2067, month 11\n", + "Processing year 2067, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2067, month 1\n", + "Processing year 2067, month 2\n", + "Processing year 2067, month 3\n", + "Processing year 2067, month 4\n", + "Processing year 2067, month 5\n", + "Processing year 2067, month 6\n", + "Processing year 2067, month 7\n", + "Processing year 2067, month 8\n", + "Processing year 2067, month 9\n", + "Processing year 2067, month 10\n", + "Processing year 2067, month 11\n", + "Processing year 2067, month 12\n", + "Processing file: CIL_subset_ssp245_2068.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2068, month 1\n", + "Processing year 2068, month 2\n", + "Processing year 2068, month 3\n", + "Processing year 2068, month 4\n", + "Processing year 2068, month 5\n", + "Processing year 2068, month 6\n", + "Processing year 2068, month 7\n", + "Processing year 2068, month 8\n", + "Processing year 2068, month 9\n", + "Processing year 2068, month 10\n", + "Processing year 2068, month 11\n", + "Processing year 2068, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2068, month 1\n", + "Processing year 2068, month 2\n", + "Processing year 2068, month 3\n", + "Processing year 2068, month 4\n", + "Processing year 2068, month 5\n", + "Processing year 2068, month 6\n", + "Processing year 2068, month 7\n", + "Processing year 2068, month 8\n", + "Processing year 2068, month 9\n", + "Processing year 2068, month 10\n", + "Processing year 2068, month 11\n", + "Processing year 2068, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2068, month 1\n", + "Processing year 2068, month 2\n", + "Processing year 2068, month 3\n", + "Processing year 2068, month 4\n", + "Processing year 2068, month 5\n", + "Processing year 2068, month 6\n", + "Processing year 2068, month 7\n", + "Processing year 2068, month 8\n", + "Processing year 2068, month 9\n", + "Processing year 2068, month 10\n", + "Processing year 2068, month 11\n", + "Processing year 2068, month 12\n", + "Processing file: CIL_subset_ssp245_2069.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2069, month 1\n", + "Processing year 2069, month 2\n", + "Processing year 2069, month 3\n", + "Processing year 2069, month 4\n", + "Processing year 2069, month 5\n", + "Processing year 2069, month 6\n", + "Processing year 2069, month 7\n", + "Processing year 2069, month 8\n", + "Processing year 2069, month 9\n", + "Processing year 2069, month 10\n", + "Processing year 2069, month 11\n", + "Processing year 2069, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2069, month 1\n", + "Processing year 2069, month 2\n", + "Processing year 2069, month 3\n", + "Processing year 2069, month 4\n", + "Processing year 2069, month 5\n", + "Processing year 2069, month 6\n", + "Processing year 2069, month 7\n", + "Processing year 2069, month 8\n", + "Processing year 2069, month 9\n", + "Processing year 2069, month 10\n", + "Processing year 2069, month 11\n", + "Processing year 2069, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2069, month 1\n", + "Processing year 2069, month 2\n", + "Processing year 2069, month 3\n", + "Processing year 2069, month 4\n", + "Processing year 2069, month 5\n", + "Processing year 2069, month 6\n", + "Processing year 2069, month 7\n", + "Processing year 2069, month 8\n", + "Processing year 2069, month 9\n", + "Processing year 2069, month 10\n", + "Processing year 2069, month 11\n", + "Processing year 2069, month 12\n", + "Processing file: CIL_subset_ssp245_2070.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2070, month 1\n", + "Processing year 2070, month 2\n", + "Processing year 2070, month 3\n", + "Processing year 2070, month 4\n", + "Processing year 2070, month 5\n", + "Processing year 2070, month 6\n", + "Processing year 2070, month 7\n", + "Processing year 2070, month 8\n", + "Processing year 2070, month 9\n", + "Processing year 2070, month 10\n", + "Processing year 2070, month 11\n", + "Processing year 2070, month 12\n", + "Processing model: UKESM1-0-LL\n", + "Processing year 2070, month 1\n", + "Processing year 2070, month 2\n", + "Processing year 2070, month 3\n", + "Processing year 2070, month 4\n", + "Processing year 2070, month 5\n", + "Processing year 2070, month 6\n", + "Processing year 2070, month 7\n", + "Processing year 2070, month 8\n", + "Processing year 2070, month 9\n", + "Processing year 2070, month 10\n", + "Processing year 2070, month 11\n", + "Processing year 2070, month 12\n", + "Processing model: INM-CM5-0\n", + "Processing year 2070, month 1\n", + "Processing year 2070, month 2\n", + "Processing year 2070, month 3\n", + "Processing year 2070, month 4\n", + "Processing year 2070, month 5\n", + "Processing year 2070, month 6\n", + "Processing year 2070, month 7\n", + "Processing year 2070, month 8\n", + "Processing year 2070, month 9\n", + "Processing year 2070, month 10\n", + "Processing year 2070, month 11\n", + "Processing year 2070, month 12\n", + "Saved monthly data for lowest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp245/lowest_monthly_prediction_weather_by_facility_ANC.csv\n", + "Saved window data for lowest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp245/lowest_window_prediction_weather_by_facility_ANC.csv\n", + "Saved monthly data for mean model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp245/mean_monthly_prediction_weather_by_facility_ANC.csv\n", + "Saved window data for mean model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp245/mean_window_prediction_weather_by_facility_ANC.csv\n", + "Saved monthly data for highest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp245/highest_monthly_prediction_weather_by_facility_ANC.csv\n", + "Saved window data for highest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp245/highest_window_prediction_weather_by_facility_ANC.csv\n", + "Processing scenario: ssp585\n", + "Models of interest ['HadGEM3-GC31-LL', 'EC-Earth3-CC', 'CMCC-CM2-SR5']\n", + "Processing file: CIL_subset_ssp585_2024.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2024, month 1\n", + "Processing year 2024, month 2\n", + "Processing year 2024, month 3\n", + "Processing year 2024, month 4\n", + "Processing year 2024, month 5\n", + "Processing year 2024, month 6\n", + "Processing year 2024, month 7\n", + "Processing year 2024, month 8\n", + "Processing year 2024, month 9\n", + "Processing year 2024, month 10\n", + "Processing year 2024, month 11\n", + "Processing year 2024, month 12\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing model: EC-Earth3-CC\n", + "Processing year 2024, month 1\n", + "Processing year 2024, month 2\n", + "Processing year 2024, month 3\n", + "Processing year 2024, month 4\n", + "Processing year 2024, month 5\n", + "Processing year 2024, month 6\n", + "Processing year 2024, month 7\n", + "Processing year 2024, month 8\n", + "Processing year 2024, month 9\n", + "Processing year 2024, month 10\n", + "Processing year 2024, month 11\n", + "Processing year 2024, month 12\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2024, month 1\n", + "Processing year 2024, month 2\n", + "Processing year 2024, month 3\n", + "Processing year 2024, month 4\n", + "Processing year 2024, month 5\n", + "Processing year 2024, month 6\n", + "Processing year 2024, month 7\n", + "Processing year 2024, month 8\n", + "Processing year 2024, month 9\n", + "Processing year 2024, month 10\n", + "Processing year 2024, month 11\n", + "Processing year 2024, month 12\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:111: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"monthly\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n", + "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_75963/2333439789.py:113: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n", + " cumulative_weather_dfs[model][\"window\"].loc[f\"{year}-{month}\", reporting_facility] = metrics\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing file: CIL_subset_ssp585_2025.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2025, month 1\n", + "Processing year 2025, month 2\n", + "Processing year 2025, month 3\n", + "Processing year 2025, month 4\n", + "Processing year 2025, month 5\n", + "Processing year 2025, month 6\n", + "Processing year 2025, month 7\n", + "Processing year 2025, month 8\n", + "Processing year 2025, month 9\n", + "Processing year 2025, month 10\n", + "Processing year 2025, month 11\n", + "Processing year 2025, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2025, month 1\n", + "Processing year 2025, month 2\n", + "Processing year 2025, month 3\n", + "Processing year 2025, month 4\n", + "Processing year 2025, month 5\n", + "Processing year 2025, month 6\n", + "Processing year 2025, month 7\n", + "Processing year 2025, month 8\n", + "Processing year 2025, month 9\n", + "Processing year 2025, month 10\n", + "Processing year 2025, month 11\n", + "Processing year 2025, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2025, month 1\n", + "Processing year 2025, month 2\n", + "Processing year 2025, month 3\n", + "Processing year 2025, month 4\n", + "Processing year 2025, month 5\n", + "Processing year 2025, month 6\n", + "Processing year 2025, month 7\n", + "Processing year 2025, month 8\n", + "Processing year 2025, month 9\n", + "Processing year 2025, month 10\n", + "Processing year 2025, month 11\n", + "Processing year 2025, month 12\n", + "Processing file: CIL_subset_ssp585_2026.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2026, month 1\n", + "Processing year 2026, month 2\n", + "Processing year 2026, month 3\n", + "Processing year 2026, month 4\n", + "Processing year 2026, month 5\n", + "Processing year 2026, month 6\n", + "Processing year 2026, month 7\n", + "Processing year 2026, month 8\n", + "Processing year 2026, month 9\n", + "Processing year 2026, month 10\n", + "Processing year 2026, month 11\n", + "Processing year 2026, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2026, month 1\n", + "Processing year 2026, month 2\n", + "Processing year 2026, month 3\n", + "Processing year 2026, month 4\n", + "Processing year 2026, month 5\n", + "Processing year 2026, month 6\n", + "Processing year 2026, month 7\n", + "Processing year 2026, month 8\n", + "Processing year 2026, month 9\n", + "Processing year 2026, month 10\n", + "Processing year 2026, month 11\n", + "Processing year 2026, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2026, month 1\n", + "Processing year 2026, month 2\n", + "Processing year 2026, month 3\n", + "Processing year 2026, month 4\n", + "Processing year 2026, month 5\n", + "Processing year 2026, month 6\n", + "Processing year 2026, month 7\n", + "Processing year 2026, month 8\n", + "Processing year 2026, month 9\n", + "Processing year 2026, month 10\n", + "Processing year 2026, month 11\n", + "Processing year 2026, month 12\n", + "Processing file: CIL_subset_ssp585_2027.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2027, month 1\n", + "Processing year 2027, month 2\n", + "Processing year 2027, month 3\n", + "Processing year 2027, month 4\n", + "Processing year 2027, month 5\n", + "Processing year 2027, month 6\n", + "Processing year 2027, month 7\n", + "Processing year 2027, month 8\n", + "Processing year 2027, month 9\n", + "Processing year 2027, month 10\n", + "Processing year 2027, month 11\n", + "Processing year 2027, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2027, month 1\n", + "Processing year 2027, month 2\n", + "Processing year 2027, month 3\n", + "Processing year 2027, month 4\n", + "Processing year 2027, month 5\n", + "Processing year 2027, month 6\n", + "Processing year 2027, month 7\n", + "Processing year 2027, month 8\n", + "Processing year 2027, month 9\n", + "Processing year 2027, month 10\n", + "Processing year 2027, month 11\n", + "Processing year 2027, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2027, month 1\n", + "Processing year 2027, month 2\n", + "Processing year 2027, month 3\n", + "Processing year 2027, month 4\n", + "Processing year 2027, month 5\n", + "Processing year 2027, month 6\n", + "Processing year 2027, month 7\n", + "Processing year 2027, month 8\n", + "Processing year 2027, month 9\n", + "Processing year 2027, month 10\n", + "Processing year 2027, month 11\n", + "Processing year 2027, month 12\n", + "Processing file: CIL_subset_ssp585_2028.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2028, month 1\n", + "Processing year 2028, month 2\n", + "Processing year 2028, month 3\n", + "Processing year 2028, month 4\n", + "Processing year 2028, month 5\n", + "Processing year 2028, month 6\n", + "Processing year 2028, month 7\n", + "Processing year 2028, month 8\n", + "Processing year 2028, month 9\n", + "Processing year 2028, month 10\n", + "Processing year 2028, month 11\n", + "Processing year 2028, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2028, month 1\n", + "Processing year 2028, month 2\n", + "Processing year 2028, month 3\n", + "Processing year 2028, month 4\n", + "Processing year 2028, month 5\n", + "Processing year 2028, month 6\n", + "Processing year 2028, month 7\n", + "Processing year 2028, month 8\n", + "Processing year 2028, month 9\n", + "Processing year 2028, month 10\n", + "Processing year 2028, month 11\n", + "Processing year 2028, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2028, month 1\n", + "Processing year 2028, month 2\n", + "Processing year 2028, month 3\n", + "Processing year 2028, month 4\n", + "Processing year 2028, month 5\n", + "Processing year 2028, month 6\n", + "Processing year 2028, month 7\n", + "Processing year 2028, month 8\n", + "Processing year 2028, month 9\n", + "Processing year 2028, month 10\n", + "Processing year 2028, month 11\n", + "Processing year 2028, month 12\n", + "Processing file: CIL_subset_ssp585_2029.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2029, month 1\n", + "Processing year 2029, month 2\n", + "Processing year 2029, month 3\n", + "Processing year 2029, month 4\n", + "Processing year 2029, month 5\n", + "Processing year 2029, month 6\n", + "Processing year 2029, month 7\n", + "Processing year 2029, month 8\n", + "Processing year 2029, month 9\n", + "Processing year 2029, month 10\n", + "Processing year 2029, month 11\n", + "Processing year 2029, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2029, month 1\n", + "Processing year 2029, month 2\n", + "Processing year 2029, month 3\n", + "Processing year 2029, month 4\n", + "Processing year 2029, month 5\n", + "Processing year 2029, month 6\n", + "Processing year 2029, month 7\n", + "Processing year 2029, month 8\n", + "Processing year 2029, month 9\n", + "Processing year 2029, month 10\n", + "Processing year 2029, month 11\n", + "Processing year 2029, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2029, month 1\n", + "Processing year 2029, month 2\n", + "Processing year 2029, month 3\n", + "Processing year 2029, month 4\n", + "Processing year 2029, month 5\n", + "Processing year 2029, month 6\n", + "Processing year 2029, month 7\n", + "Processing year 2029, month 8\n", + "Processing year 2029, month 9\n", + "Processing year 2029, month 10\n", + "Processing year 2029, month 11\n", + "Processing year 2029, month 12\n", + "Processing file: CIL_subset_ssp585_2030.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2030, month 1\n", + "Processing year 2030, month 2\n", + "Processing year 2030, month 3\n", + "Processing year 2030, month 4\n", + "Processing year 2030, month 5\n", + "Processing year 2030, month 6\n", + "Processing year 2030, month 7\n", + "Processing year 2030, month 8\n", + "Processing year 2030, month 9\n", + "Processing year 2030, month 10\n", + "Processing year 2030, month 11\n", + "Processing year 2030, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2030, month 1\n", + "Processing year 2030, month 2\n", + "Processing year 2030, month 3\n", + "Processing year 2030, month 4\n", + "Processing year 2030, month 5\n", + "Processing year 2030, month 6\n", + "Processing year 2030, month 7\n", + "Processing year 2030, month 8\n", + "Processing year 2030, month 9\n", + "Processing year 2030, month 10\n", + "Processing year 2030, month 11\n", + "Processing year 2030, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2030, month 1\n", + "Processing year 2030, month 2\n", + "Processing year 2030, month 3\n", + "Processing year 2030, month 4\n", + "Processing year 2030, month 5\n", + "Processing year 2030, month 6\n", + "Processing year 2030, month 7\n", + "Processing year 2030, month 8\n", + "Processing year 2030, month 9\n", + "Processing year 2030, month 10\n", + "Processing year 2030, month 11\n", + "Processing year 2030, month 12\n", + "Processing file: CIL_subset_ssp585_2031.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2031, month 1\n", + "Processing year 2031, month 2\n", + "Processing year 2031, month 3\n", + "Processing year 2031, month 4\n", + "Processing year 2031, month 5\n", + "Processing year 2031, month 6\n", + "Processing year 2031, month 7\n", + "Processing year 2031, month 8\n", + "Processing year 2031, month 9\n", + "Processing year 2031, month 10\n", + "Processing year 2031, month 11\n", + "Processing year 2031, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2031, month 1\n", + "Processing year 2031, month 2\n", + "Processing year 2031, month 3\n", + "Processing year 2031, month 4\n", + "Processing year 2031, month 5\n", + "Processing year 2031, month 6\n", + "Processing year 2031, month 7\n", + "Processing year 2031, month 8\n", + "Processing year 2031, month 9\n", + "Processing year 2031, month 10\n", + "Processing year 2031, month 11\n", + "Processing year 2031, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2031, month 1\n", + "Processing year 2031, month 2\n", + "Processing year 2031, month 3\n", + "Processing year 2031, month 4\n", + "Processing year 2031, month 5\n", + "Processing year 2031, month 6\n", + "Processing year 2031, month 7\n", + "Processing year 2031, month 8\n", + "Processing year 2031, month 9\n", + "Processing year 2031, month 10\n", + "Processing year 2031, month 11\n", + "Processing year 2031, month 12\n", + "Processing file: CIL_subset_ssp585_2032.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2032, month 1\n", + "Processing year 2032, month 2\n", + "Processing year 2032, month 3\n", + "Processing year 2032, month 4\n", + "Processing year 2032, month 5\n", + "Processing year 2032, month 6\n", + "Processing year 2032, month 7\n", + "Processing year 2032, month 8\n", + "Processing year 2032, month 9\n", + "Processing year 2032, month 10\n", + "Processing year 2032, month 11\n", + "Processing year 2032, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2032, month 1\n", + "Processing year 2032, month 2\n", + "Processing year 2032, month 3\n", + "Processing year 2032, month 4\n", + "Processing year 2032, month 5\n", + "Processing year 2032, month 6\n", + "Processing year 2032, month 7\n", + "Processing year 2032, month 8\n", + "Processing year 2032, month 9\n", + "Processing year 2032, month 10\n", + "Processing year 2032, month 11\n", + "Processing year 2032, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2032, month 1\n", + "Processing year 2032, month 2\n", + "Processing year 2032, month 3\n", + "Processing year 2032, month 4\n", + "Processing year 2032, month 5\n", + "Processing year 2032, month 6\n", + "Processing year 2032, month 7\n", + "Processing year 2032, month 8\n", + "Processing year 2032, month 9\n", + "Processing year 2032, month 10\n", + "Processing year 2032, month 11\n", + "Processing year 2032, month 12\n", + "Processing file: CIL_subset_ssp585_2033.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2033, month 1\n", + "Processing year 2033, month 2\n", + "Processing year 2033, month 3\n", + "Processing year 2033, month 4\n", + "Processing year 2033, month 5\n", + "Processing year 2033, month 6\n", + "Processing year 2033, month 7\n", + "Processing year 2033, month 8\n", + "Processing year 2033, month 9\n", + "Processing year 2033, month 10\n", + "Processing year 2033, month 11\n", + "Processing year 2033, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2033, month 1\n", + "Processing year 2033, month 2\n", + "Processing year 2033, month 3\n", + "Processing year 2033, month 4\n", + "Processing year 2033, month 5\n", + "Processing year 2033, month 6\n", + "Processing year 2033, month 7\n", + "Processing year 2033, month 8\n", + "Processing year 2033, month 9\n", + "Processing year 2033, month 10\n", + "Processing year 2033, month 11\n", + "Processing year 2033, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2033, month 1\n", + "Processing year 2033, month 2\n", + "Processing year 2033, month 3\n", + "Processing year 2033, month 4\n", + "Processing year 2033, month 5\n", + "Processing year 2033, month 6\n", + "Processing year 2033, month 7\n", + "Processing year 2033, month 8\n", + "Processing year 2033, month 9\n", + "Processing year 2033, month 10\n", + "Processing year 2033, month 11\n", + "Processing year 2033, month 12\n", + "Processing file: CIL_subset_ssp585_2034.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2034, month 1\n", + "Processing year 2034, month 2\n", + "Processing year 2034, month 3\n", + "Processing year 2034, month 4\n", + "Processing year 2034, month 5\n", + "Processing year 2034, month 6\n", + "Processing year 2034, month 7\n", + "Processing year 2034, month 8\n", + "Processing year 2034, month 9\n", + "Processing year 2034, month 10\n", + "Processing year 2034, month 11\n", + "Processing year 2034, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2034, month 1\n", + "Processing year 2034, month 2\n", + "Processing year 2034, month 3\n", + "Processing year 2034, month 4\n", + "Processing year 2034, month 5\n", + "Processing year 2034, month 6\n", + "Processing year 2034, month 7\n", + "Processing year 2034, month 8\n", + "Processing year 2034, month 9\n", + "Processing year 2034, month 10\n", + "Processing year 2034, month 11\n", + "Processing year 2034, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2034, month 1\n", + "Processing year 2034, month 2\n", + "Processing year 2034, month 3\n", + "Processing year 2034, month 4\n", + "Processing year 2034, month 5\n", + "Processing year 2034, month 6\n", + "Processing year 2034, month 7\n", + "Processing year 2034, month 8\n", + "Processing year 2034, month 9\n", + "Processing year 2034, month 10\n", + "Processing year 2034, month 11\n", + "Processing year 2034, month 12\n", + "Processing file: CIL_subset_ssp585_2035.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2035, month 1\n", + "Processing year 2035, month 2\n", + "Processing year 2035, month 3\n", + "Processing year 2035, month 4\n", + "Processing year 2035, month 5\n", + "Processing year 2035, month 6\n", + "Processing year 2035, month 7\n", + "Processing year 2035, month 8\n", + "Processing year 2035, month 9\n", + "Processing year 2035, month 10\n", + "Processing year 2035, month 11\n", + "Processing year 2035, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2035, month 1\n", + "Processing year 2035, month 2\n", + "Processing year 2035, month 3\n", + "Processing year 2035, month 4\n", + "Processing year 2035, month 5\n", + "Processing year 2035, month 6\n", + "Processing year 2035, month 7\n", + "Processing year 2035, month 8\n", + "Processing year 2035, month 9\n", + "Processing year 2035, month 10\n", + "Processing year 2035, month 11\n", + "Processing year 2035, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2035, month 1\n", + "Processing year 2035, month 2\n", + "Processing year 2035, month 3\n", + "Processing year 2035, month 4\n", + "Processing year 2035, month 5\n", + "Processing year 2035, month 6\n", + "Processing year 2035, month 7\n", + "Processing year 2035, month 8\n", + "Processing year 2035, month 9\n", + "Processing year 2035, month 10\n", + "Processing year 2035, month 11\n", + "Processing year 2035, month 12\n", + "Processing file: CIL_subset_ssp585_2036.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2036, month 1\n", + "Processing year 2036, month 2\n", + "Processing year 2036, month 3\n", + "Processing year 2036, month 4\n", + "Processing year 2036, month 5\n", + "Processing year 2036, month 6\n", + "Processing year 2036, month 7\n", + "Processing year 2036, month 8\n", + "Processing year 2036, month 9\n", + "Processing year 2036, month 10\n", + "Processing year 2036, month 11\n", + "Processing year 2036, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2036, month 1\n", + "Processing year 2036, month 2\n", + "Processing year 2036, month 3\n", + "Processing year 2036, month 4\n", + "Processing year 2036, month 5\n", + "Processing year 2036, month 6\n", + "Processing year 2036, month 7\n", + "Processing year 2036, month 8\n", + "Processing year 2036, month 9\n", + "Processing year 2036, month 10\n", + "Processing year 2036, month 11\n", + "Processing year 2036, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2036, month 1\n", + "Processing year 2036, month 2\n", + "Processing year 2036, month 3\n", + "Processing year 2036, month 4\n", + "Processing year 2036, month 5\n", + "Processing year 2036, month 6\n", + "Processing year 2036, month 7\n", + "Processing year 2036, month 8\n", + "Processing year 2036, month 9\n", + "Processing year 2036, month 10\n", + "Processing year 2036, month 11\n", + "Processing year 2036, month 12\n", + "Processing file: CIL_subset_ssp585_2037.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2037, month 1\n", + "Processing year 2037, month 2\n", + "Processing year 2037, month 3\n", + "Processing year 2037, month 4\n", + "Processing year 2037, month 5\n", + "Processing year 2037, month 6\n", + "Processing year 2037, month 7\n", + "Processing year 2037, month 8\n", + "Processing year 2037, month 9\n", + "Processing year 2037, month 10\n", + "Processing year 2037, month 11\n", + "Processing year 2037, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2037, month 1\n", + "Processing year 2037, month 2\n", + "Processing year 2037, month 3\n", + "Processing year 2037, month 4\n", + "Processing year 2037, month 5\n", + "Processing year 2037, month 6\n", + "Processing year 2037, month 7\n", + "Processing year 2037, month 8\n", + "Processing year 2037, month 9\n", + "Processing year 2037, month 10\n", + "Processing year 2037, month 11\n", + "Processing year 2037, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2037, month 1\n", + "Processing year 2037, month 2\n", + "Processing year 2037, month 3\n", + "Processing year 2037, month 4\n", + "Processing year 2037, month 5\n", + "Processing year 2037, month 6\n", + "Processing year 2037, month 7\n", + "Processing year 2037, month 8\n", + "Processing year 2037, month 9\n", + "Processing year 2037, month 10\n", + "Processing year 2037, month 11\n", + "Processing year 2037, month 12\n", + "Processing file: CIL_subset_ssp585_2038.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2038, month 1\n", + "Processing year 2038, month 2\n", + "Processing year 2038, month 3\n", + "Processing year 2038, month 4\n", + "Processing year 2038, month 5\n", + "Processing year 2038, month 6\n", + "Processing year 2038, month 7\n", + "Processing year 2038, month 8\n", + "Processing year 2038, month 9\n", + "Processing year 2038, month 10\n", + "Processing year 2038, month 11\n", + "Processing year 2038, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2038, month 1\n", + "Processing year 2038, month 2\n", + "Processing year 2038, month 3\n", + "Processing year 2038, month 4\n", + "Processing year 2038, month 5\n", + "Processing year 2038, month 6\n", + "Processing year 2038, month 7\n", + "Processing year 2038, month 8\n", + "Processing year 2038, month 9\n", + "Processing year 2038, month 10\n", + "Processing year 2038, month 11\n", + "Processing year 2038, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2038, month 1\n", + "Processing year 2038, month 2\n", + "Processing year 2038, month 3\n", + "Processing year 2038, month 4\n", + "Processing year 2038, month 5\n", + "Processing year 2038, month 6\n", + "Processing year 2038, month 7\n", + "Processing year 2038, month 8\n", + "Processing year 2038, month 9\n", + "Processing year 2038, month 10\n", + "Processing year 2038, month 11\n", + "Processing year 2038, month 12\n", + "Processing file: CIL_subset_ssp585_2039.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2039, month 1\n", + "Processing year 2039, month 2\n", + "Processing year 2039, month 3\n", + "Processing year 2039, month 4\n", + "Processing year 2039, month 5\n", + "Processing year 2039, month 6\n", + "Processing year 2039, month 7\n", + "Processing year 2039, month 8\n", + "Processing year 2039, month 9\n", + "Processing year 2039, month 10\n", + "Processing year 2039, month 11\n", + "Processing year 2039, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2039, month 1\n", + "Processing year 2039, month 2\n", + "Processing year 2039, month 3\n", + "Processing year 2039, month 4\n", + "Processing year 2039, month 5\n", + "Processing year 2039, month 6\n", + "Processing year 2039, month 7\n", + "Processing year 2039, month 8\n", + "Processing year 2039, month 9\n", + "Processing year 2039, month 10\n", + "Processing year 2039, month 11\n", + "Processing year 2039, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2039, month 1\n", + "Processing year 2039, month 2\n", + "Processing year 2039, month 3\n", + "Processing year 2039, month 4\n", + "Processing year 2039, month 5\n", + "Processing year 2039, month 6\n", + "Processing year 2039, month 7\n", + "Processing year 2039, month 8\n", + "Processing year 2039, month 9\n", + "Processing year 2039, month 10\n", + "Processing year 2039, month 11\n", + "Processing year 2039, month 12\n", + "Processing file: CIL_subset_ssp585_2040.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2040, month 1\n", + "Processing year 2040, month 2\n", + "Processing year 2040, month 3\n", + "Processing year 2040, month 4\n", + "Processing year 2040, month 5\n", + "Processing year 2040, month 6\n", + "Processing year 2040, month 7\n", + "Processing year 2040, month 8\n", + "Processing year 2040, month 9\n", + "Processing year 2040, month 10\n", + "Processing year 2040, month 11\n", + "Processing year 2040, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2040, month 1\n", + "Processing year 2040, month 2\n", + "Processing year 2040, month 3\n", + "Processing year 2040, month 4\n", + "Processing year 2040, month 5\n", + "Processing year 2040, month 6\n", + "Processing year 2040, month 7\n", + "Processing year 2040, month 8\n", + "Processing year 2040, month 9\n", + "Processing year 2040, month 10\n", + "Processing year 2040, month 11\n", + "Processing year 2040, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2040, month 1\n", + "Processing year 2040, month 2\n", + "Processing year 2040, month 3\n", + "Processing year 2040, month 4\n", + "Processing year 2040, month 5\n", + "Processing year 2040, month 6\n", + "Processing year 2040, month 7\n", + "Processing year 2040, month 8\n", + "Processing year 2040, month 9\n", + "Processing year 2040, month 10\n", + "Processing year 2040, month 11\n", + "Processing year 2040, month 12\n", + "Processing file: CIL_subset_ssp585_2041.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2041, month 1\n", + "Processing year 2041, month 2\n", + "Processing year 2041, month 3\n", + "Processing year 2041, month 4\n", + "Processing year 2041, month 5\n", + "Processing year 2041, month 6\n", + "Processing year 2041, month 7\n", + "Processing year 2041, month 8\n", + "Processing year 2041, month 9\n", + "Processing year 2041, month 10\n", + "Processing year 2041, month 11\n", + "Processing year 2041, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2041, month 1\n", + "Processing year 2041, month 2\n", + "Processing year 2041, month 3\n", + "Processing year 2041, month 4\n", + "Processing year 2041, month 5\n", + "Processing year 2041, month 6\n", + "Processing year 2041, month 7\n", + "Processing year 2041, month 8\n", + "Processing year 2041, month 9\n", + "Processing year 2041, month 10\n", + "Processing year 2041, month 11\n", + "Processing year 2041, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2041, month 1\n", + "Processing year 2041, month 2\n", + "Processing year 2041, month 3\n", + "Processing year 2041, month 4\n", + "Processing year 2041, month 5\n", + "Processing year 2041, month 6\n", + "Processing year 2041, month 7\n", + "Processing year 2041, month 8\n", + "Processing year 2041, month 9\n", + "Processing year 2041, month 10\n", + "Processing year 2041, month 11\n", + "Processing year 2041, month 12\n", + "Processing file: CIL_subset_ssp585_2042.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2042, month 1\n", + "Processing year 2042, month 2\n", + "Processing year 2042, month 3\n", + "Processing year 2042, month 4\n", + "Processing year 2042, month 5\n", + "Processing year 2042, month 6\n", + "Processing year 2042, month 7\n", + "Processing year 2042, month 8\n", + "Processing year 2042, month 9\n", + "Processing year 2042, month 10\n", + "Processing year 2042, month 11\n", + "Processing year 2042, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2042, month 1\n", + "Processing year 2042, month 2\n", + "Processing year 2042, month 3\n", + "Processing year 2042, month 4\n", + "Processing year 2042, month 5\n", + "Processing year 2042, month 6\n", + "Processing year 2042, month 7\n", + "Processing year 2042, month 8\n", + "Processing year 2042, month 9\n", + "Processing year 2042, month 10\n", + "Processing year 2042, month 11\n", + "Processing year 2042, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2042, month 1\n", + "Processing year 2042, month 2\n", + "Processing year 2042, month 3\n", + "Processing year 2042, month 4\n", + "Processing year 2042, month 5\n", + "Processing year 2042, month 6\n", + "Processing year 2042, month 7\n", + "Processing year 2042, month 8\n", + "Processing year 2042, month 9\n", + "Processing year 2042, month 10\n", + "Processing year 2042, month 11\n", + "Processing year 2042, month 12\n", + "Processing file: CIL_subset_ssp585_2043.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2043, month 1\n", + "Processing year 2043, month 2\n", + "Processing year 2043, month 3\n", + "Processing year 2043, month 4\n", + "Processing year 2043, month 5\n", + "Processing year 2043, month 6\n", + "Processing year 2043, month 7\n", + "Processing year 2043, month 8\n", + "Processing year 2043, month 9\n", + "Processing year 2043, month 10\n", + "Processing year 2043, month 11\n", + "Processing year 2043, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2043, month 1\n", + "Processing year 2043, month 2\n", + "Processing year 2043, month 3\n", + "Processing year 2043, month 4\n", + "Processing year 2043, month 5\n", + "Processing year 2043, month 6\n", + "Processing year 2043, month 7\n", + "Processing year 2043, month 8\n", + "Processing year 2043, month 9\n", + "Processing year 2043, month 10\n", + "Processing year 2043, month 11\n", + "Processing year 2043, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2043, month 1\n", + "Processing year 2043, month 2\n", + "Processing year 2043, month 3\n", + "Processing year 2043, month 4\n", + "Processing year 2043, month 5\n", + "Processing year 2043, month 6\n", + "Processing year 2043, month 7\n", + "Processing year 2043, month 8\n", + "Processing year 2043, month 9\n", + "Processing year 2043, month 10\n", + "Processing year 2043, month 11\n", + "Processing year 2043, month 12\n", + "Processing file: CIL_subset_ssp585_2044.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2044, month 1\n", + "Processing year 2044, month 2\n", + "Processing year 2044, month 3\n", + "Processing year 2044, month 4\n", + "Processing year 2044, month 5\n", + "Processing year 2044, month 6\n", + "Processing year 2044, month 7\n", + "Processing year 2044, month 8\n", + "Processing year 2044, month 9\n", + "Processing year 2044, month 10\n", + "Processing year 2044, month 11\n", + "Processing year 2044, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2044, month 1\n", + "Processing year 2044, month 2\n", + "Processing year 2044, month 3\n", + "Processing year 2044, month 4\n", + "Processing year 2044, month 5\n", + "Processing year 2044, month 6\n", + "Processing year 2044, month 7\n", + "Processing year 2044, month 8\n", + "Processing year 2044, month 9\n", + "Processing year 2044, month 10\n", + "Processing year 2044, month 11\n", + "Processing year 2044, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2044, month 1\n", + "Processing year 2044, month 2\n", + "Processing year 2044, month 3\n", + "Processing year 2044, month 4\n", + "Processing year 2044, month 5\n", + "Processing year 2044, month 6\n", + "Processing year 2044, month 7\n", + "Processing year 2044, month 8\n", + "Processing year 2044, month 9\n", + "Processing year 2044, month 10\n", + "Processing year 2044, month 11\n", + "Processing year 2044, month 12\n", + "Processing file: CIL_subset_ssp585_2045.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2045, month 1\n", + "Processing year 2045, month 2\n", + "Processing year 2045, month 3\n", + "Processing year 2045, month 4\n", + "Processing year 2045, month 5\n", + "Processing year 2045, month 6\n", + "Processing year 2045, month 7\n", + "Processing year 2045, month 8\n", + "Processing year 2045, month 9\n", + "Processing year 2045, month 10\n", + "Processing year 2045, month 11\n", + "Processing year 2045, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2045, month 1\n", + "Processing year 2045, month 2\n", + "Processing year 2045, month 3\n", + "Processing year 2045, month 4\n", + "Processing year 2045, month 5\n", + "Processing year 2045, month 6\n", + "Processing year 2045, month 7\n", + "Processing year 2045, month 8\n", + "Processing year 2045, month 9\n", + "Processing year 2045, month 10\n", + "Processing year 2045, month 11\n", + "Processing year 2045, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2045, month 1\n", + "Processing year 2045, month 2\n", + "Processing year 2045, month 3\n", + "Processing year 2045, month 4\n", + "Processing year 2045, month 5\n", + "Processing year 2045, month 6\n", + "Processing year 2045, month 7\n", + "Processing year 2045, month 8\n", + "Processing year 2045, month 9\n", + "Processing year 2045, month 10\n", + "Processing year 2045, month 11\n", + "Processing year 2045, month 12\n", + "Processing file: CIL_subset_ssp585_2046.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2046, month 1\n", + "Processing year 2046, month 2\n", + "Processing year 2046, month 3\n", + "Processing year 2046, month 4\n", + "Processing year 2046, month 5\n", + "Processing year 2046, month 6\n", + "Processing year 2046, month 7\n", + "Processing year 2046, month 8\n", + "Processing year 2046, month 9\n", + "Processing year 2046, month 10\n", + "Processing year 2046, month 11\n", + "Processing year 2046, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2046, month 1\n", + "Processing year 2046, month 2\n", + "Processing year 2046, month 3\n", + "Processing year 2046, month 4\n", + "Processing year 2046, month 5\n", + "Processing year 2046, month 6\n", + "Processing year 2046, month 7\n", + "Processing year 2046, month 8\n", + "Processing year 2046, month 9\n", + "Processing year 2046, month 10\n", + "Processing year 2046, month 11\n", + "Processing year 2046, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2046, month 1\n", + "Processing year 2046, month 2\n", + "Processing year 2046, month 3\n", + "Processing year 2046, month 4\n", + "Processing year 2046, month 5\n", + "Processing year 2046, month 6\n", + "Processing year 2046, month 7\n", + "Processing year 2046, month 8\n", + "Processing year 2046, month 9\n", + "Processing year 2046, month 10\n", + "Processing year 2046, month 11\n", + "Processing year 2046, month 12\n", + "Processing file: CIL_subset_ssp585_2047.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2047, month 1\n", + "Processing year 2047, month 2\n", + "Processing year 2047, month 3\n", + "Processing year 2047, month 4\n", + "Processing year 2047, month 5\n", + "Processing year 2047, month 6\n", + "Processing year 2047, month 7\n", + "Processing year 2047, month 8\n", + "Processing year 2047, month 9\n", + "Processing year 2047, month 10\n", + "Processing year 2047, month 11\n", + "Processing year 2047, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2047, month 1\n", + "Processing year 2047, month 2\n", + "Processing year 2047, month 3\n", + "Processing year 2047, month 4\n", + "Processing year 2047, month 5\n", + "Processing year 2047, month 6\n", + "Processing year 2047, month 7\n", + "Processing year 2047, month 8\n", + "Processing year 2047, month 9\n", + "Processing year 2047, month 10\n", + "Processing year 2047, month 11\n", + "Processing year 2047, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2047, month 1\n", + "Processing year 2047, month 2\n", + "Processing year 2047, month 3\n", + "Processing year 2047, month 4\n", + "Processing year 2047, month 5\n", + "Processing year 2047, month 6\n", + "Processing year 2047, month 7\n", + "Processing year 2047, month 8\n", + "Processing year 2047, month 9\n", + "Processing year 2047, month 10\n", + "Processing year 2047, month 11\n", + "Processing year 2047, month 12\n", + "Processing file: CIL_subset_ssp585_2048.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2048, month 1\n", + "Processing year 2048, month 2\n", + "Processing year 2048, month 3\n", + "Processing year 2048, month 4\n", + "Processing year 2048, month 5\n", + "Processing year 2048, month 6\n", + "Processing year 2048, month 7\n", + "Processing year 2048, month 8\n", + "Processing year 2048, month 9\n", + "Processing year 2048, month 10\n", + "Processing year 2048, month 11\n", + "Processing year 2048, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2048, month 1\n", + "Processing year 2048, month 2\n", + "Processing year 2048, month 3\n", + "Processing year 2048, month 4\n", + "Processing year 2048, month 5\n", + "Processing year 2048, month 6\n", + "Processing year 2048, month 7\n", + "Processing year 2048, month 8\n", + "Processing year 2048, month 9\n", + "Processing year 2048, month 10\n", + "Processing year 2048, month 11\n", + "Processing year 2048, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2048, month 1\n", + "Processing year 2048, month 2\n", + "Processing year 2048, month 3\n", + "Processing year 2048, month 4\n", + "Processing year 2048, month 5\n", + "Processing year 2048, month 6\n", + "Processing year 2048, month 7\n", + "Processing year 2048, month 8\n", + "Processing year 2048, month 9\n", + "Processing year 2048, month 10\n", + "Processing year 2048, month 11\n", + "Processing year 2048, month 12\n", + "Processing file: CIL_subset_ssp585_2049.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2049, month 1\n", + "Processing year 2049, month 2\n", + "Processing year 2049, month 3\n", + "Processing year 2049, month 4\n", + "Processing year 2049, month 5\n", + "Processing year 2049, month 6\n", + "Processing year 2049, month 7\n", + "Processing year 2049, month 8\n", + "Processing year 2049, month 9\n", + "Processing year 2049, month 10\n", + "Processing year 2049, month 11\n", + "Processing year 2049, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2049, month 1\n", + "Processing year 2049, month 2\n", + "Processing year 2049, month 3\n", + "Processing year 2049, month 4\n", + "Processing year 2049, month 5\n", + "Processing year 2049, month 6\n", + "Processing year 2049, month 7\n", + "Processing year 2049, month 8\n", + "Processing year 2049, month 9\n", + "Processing year 2049, month 10\n", + "Processing year 2049, month 11\n", + "Processing year 2049, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2049, month 1\n", + "Processing year 2049, month 2\n", + "Processing year 2049, month 3\n", + "Processing year 2049, month 4\n", + "Processing year 2049, month 5\n", + "Processing year 2049, month 6\n", + "Processing year 2049, month 7\n", + "Processing year 2049, month 8\n", + "Processing year 2049, month 9\n", + "Processing year 2049, month 10\n", + "Processing year 2049, month 11\n", + "Processing year 2049, month 12\n", + "Processing file: CIL_subset_ssp585_2050.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2050, month 1\n", + "Processing year 2050, month 2\n", + "Processing year 2050, month 3\n", + "Processing year 2050, month 4\n", + "Processing year 2050, month 5\n", + "Processing year 2050, month 6\n", + "Processing year 2050, month 7\n", + "Processing year 2050, month 8\n", + "Processing year 2050, month 9\n", + "Processing year 2050, month 10\n", + "Processing year 2050, month 11\n", + "Processing year 2050, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2050, month 1\n", + "Processing year 2050, month 2\n", + "Processing year 2050, month 3\n", + "Processing year 2050, month 4\n", + "Processing year 2050, month 5\n", + "Processing year 2050, month 6\n", + "Processing year 2050, month 7\n", + "Processing year 2050, month 8\n", + "Processing year 2050, month 9\n", + "Processing year 2050, month 10\n", + "Processing year 2050, month 11\n", + "Processing year 2050, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2050, month 1\n", + "Processing year 2050, month 2\n", + "Processing year 2050, month 3\n", + "Processing year 2050, month 4\n", + "Processing year 2050, month 5\n", + "Processing year 2050, month 6\n", + "Processing year 2050, month 7\n", + "Processing year 2050, month 8\n", + "Processing year 2050, month 9\n", + "Processing year 2050, month 10\n", + "Processing year 2050, month 11\n", + "Processing year 2050, month 12\n", + "Processing file: CIL_subset_ssp585_2051.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2051, month 1\n", + "Processing year 2051, month 2\n", + "Processing year 2051, month 3\n", + "Processing year 2051, month 4\n", + "Processing year 2051, month 5\n", + "Processing year 2051, month 6\n", + "Processing year 2051, month 7\n", + "Processing year 2051, month 8\n", + "Processing year 2051, month 9\n", + "Processing year 2051, month 10\n", + "Processing year 2051, month 11\n", + "Processing year 2051, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2051, month 1\n", + "Processing year 2051, month 2\n", + "Processing year 2051, month 3\n", + "Processing year 2051, month 4\n", + "Processing year 2051, month 5\n", + "Processing year 2051, month 6\n", + "Processing year 2051, month 7\n", + "Processing year 2051, month 8\n", + "Processing year 2051, month 9\n", + "Processing year 2051, month 10\n", + "Processing year 2051, month 11\n", + "Processing year 2051, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2051, month 1\n", + "Processing year 2051, month 2\n", + "Processing year 2051, month 3\n", + "Processing year 2051, month 4\n", + "Processing year 2051, month 5\n", + "Processing year 2051, month 6\n", + "Processing year 2051, month 7\n", + "Processing year 2051, month 8\n", + "Processing year 2051, month 9\n", + "Processing year 2051, month 10\n", + "Processing year 2051, month 11\n", + "Processing year 2051, month 12\n", + "Processing file: CIL_subset_ssp585_2052.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2052, month 1\n", + "Processing year 2052, month 2\n", + "Processing year 2052, month 3\n", + "Processing year 2052, month 4\n", + "Processing year 2052, month 5\n", + "Processing year 2052, month 6\n", + "Processing year 2052, month 7\n", + "Processing year 2052, month 8\n", + "Processing year 2052, month 9\n", + "Processing year 2052, month 10\n", + "Processing year 2052, month 11\n", + "Processing year 2052, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2052, month 1\n", + "Processing year 2052, month 2\n", + "Processing year 2052, month 3\n", + "Processing year 2052, month 4\n", + "Processing year 2052, month 5\n", + "Processing year 2052, month 6\n", + "Processing year 2052, month 7\n", + "Processing year 2052, month 8\n", + "Processing year 2052, month 9\n", + "Processing year 2052, month 10\n", + "Processing year 2052, month 11\n", + "Processing year 2052, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2052, month 1\n", + "Processing year 2052, month 2\n", + "Processing year 2052, month 3\n", + "Processing year 2052, month 4\n", + "Processing year 2052, month 5\n", + "Processing year 2052, month 6\n", + "Processing year 2052, month 7\n", + "Processing year 2052, month 8\n", + "Processing year 2052, month 9\n", + "Processing year 2052, month 10\n", + "Processing year 2052, month 11\n", + "Processing year 2052, month 12\n", + "Processing file: CIL_subset_ssp585_2053.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2053, month 1\n", + "Processing year 2053, month 2\n", + "Processing year 2053, month 3\n", + "Processing year 2053, month 4\n", + "Processing year 2053, month 5\n", + "Processing year 2053, month 6\n", + "Processing year 2053, month 7\n", + "Processing year 2053, month 8\n", + "Processing year 2053, month 9\n", + "Processing year 2053, month 10\n", + "Processing year 2053, month 11\n", + "Processing year 2053, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2053, month 1\n", + "Processing year 2053, month 2\n", + "Processing year 2053, month 3\n", + "Processing year 2053, month 4\n", + "Processing year 2053, month 5\n", + "Processing year 2053, month 6\n", + "Processing year 2053, month 7\n", + "Processing year 2053, month 8\n", + "Processing year 2053, month 9\n", + "Processing year 2053, month 10\n", + "Processing year 2053, month 11\n", + "Processing year 2053, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2053, month 1\n", + "Processing year 2053, month 2\n", + "Processing year 2053, month 3\n", + "Processing year 2053, month 4\n", + "Processing year 2053, month 5\n", + "Processing year 2053, month 6\n", + "Processing year 2053, month 7\n", + "Processing year 2053, month 8\n", + "Processing year 2053, month 9\n", + "Processing year 2053, month 10\n", + "Processing year 2053, month 11\n", + "Processing year 2053, month 12\n", + "Processing file: CIL_subset_ssp585_2054.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2054, month 1\n", + "Processing year 2054, month 2\n", + "Processing year 2054, month 3\n", + "Processing year 2054, month 4\n", + "Processing year 2054, month 5\n", + "Processing year 2054, month 6\n", + "Processing year 2054, month 7\n", + "Processing year 2054, month 8\n", + "Processing year 2054, month 9\n", + "Processing year 2054, month 10\n", + "Processing year 2054, month 11\n", + "Processing year 2054, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2054, month 1\n", + "Processing year 2054, month 2\n", + "Processing year 2054, month 3\n", + "Processing year 2054, month 4\n", + "Processing year 2054, month 5\n", + "Processing year 2054, month 6\n", + "Processing year 2054, month 7\n", + "Processing year 2054, month 8\n", + "Processing year 2054, month 9\n", + "Processing year 2054, month 10\n", + "Processing year 2054, month 11\n", + "Processing year 2054, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2054, month 1\n", + "Processing year 2054, month 2\n", + "Processing year 2054, month 3\n", + "Processing year 2054, month 4\n", + "Processing year 2054, month 5\n", + "Processing year 2054, month 6\n", + "Processing year 2054, month 7\n", + "Processing year 2054, month 8\n", + "Processing year 2054, month 9\n", + "Processing year 2054, month 10\n", + "Processing year 2054, month 11\n", + "Processing year 2054, month 12\n", + "Processing file: CIL_subset_ssp585_2055.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2055, month 1\n", + "Processing year 2055, month 2\n", + "Processing year 2055, month 3\n", + "Processing year 2055, month 4\n", + "Processing year 2055, month 5\n", + "Processing year 2055, month 6\n", + "Processing year 2055, month 7\n", + "Processing year 2055, month 8\n", + "Processing year 2055, month 9\n", + "Processing year 2055, month 10\n", + "Processing year 2055, month 11\n", + "Processing year 2055, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2055, month 1\n", + "Processing year 2055, month 2\n", + "Processing year 2055, month 3\n", + "Processing year 2055, month 4\n", + "Processing year 2055, month 5\n", + "Processing year 2055, month 6\n", + "Processing year 2055, month 7\n", + "Processing year 2055, month 8\n", + "Processing year 2055, month 9\n", + "Processing year 2055, month 10\n", + "Processing year 2055, month 11\n", + "Processing year 2055, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2055, month 1\n", + "Processing year 2055, month 2\n", + "Processing year 2055, month 3\n", + "Processing year 2055, month 4\n", + "Processing year 2055, month 5\n", + "Processing year 2055, month 6\n", + "Processing year 2055, month 7\n", + "Processing year 2055, month 8\n", + "Processing year 2055, month 9\n", + "Processing year 2055, month 10\n", + "Processing year 2055, month 11\n", + "Processing year 2055, month 12\n", + "Processing file: CIL_subset_ssp585_2056.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2056, month 1\n", + "Processing year 2056, month 2\n", + "Processing year 2056, month 3\n", + "Processing year 2056, month 4\n", + "Processing year 2056, month 5\n", + "Processing year 2056, month 6\n", + "Processing year 2056, month 7\n", + "Processing year 2056, month 8\n", + "Processing year 2056, month 9\n", + "Processing year 2056, month 10\n", + "Processing year 2056, month 11\n", + "Processing year 2056, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2056, month 1\n", + "Processing year 2056, month 2\n", + "Processing year 2056, month 3\n", + "Processing year 2056, month 4\n", + "Processing year 2056, month 5\n", + "Processing year 2056, month 6\n", + "Processing year 2056, month 7\n", + "Processing year 2056, month 8\n", + "Processing year 2056, month 9\n", + "Processing year 2056, month 10\n", + "Processing year 2056, month 11\n", + "Processing year 2056, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2056, month 1\n", + "Processing year 2056, month 2\n", + "Processing year 2056, month 3\n", + "Processing year 2056, month 4\n", + "Processing year 2056, month 5\n", + "Processing year 2056, month 6\n", + "Processing year 2056, month 7\n", + "Processing year 2056, month 8\n", + "Processing year 2056, month 9\n", + "Processing year 2056, month 10\n", + "Processing year 2056, month 11\n", + "Processing year 2056, month 12\n", + "Processing file: CIL_subset_ssp585_2057.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2057, month 1\n", + "Processing year 2057, month 2\n", + "Processing year 2057, month 3\n", + "Processing year 2057, month 4\n", + "Processing year 2057, month 5\n", + "Processing year 2057, month 6\n", + "Processing year 2057, month 7\n", + "Processing year 2057, month 8\n", + "Processing year 2057, month 9\n", + "Processing year 2057, month 10\n", + "Processing year 2057, month 11\n", + "Processing year 2057, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2057, month 1\n", + "Processing year 2057, month 2\n", + "Processing year 2057, month 3\n", + "Processing year 2057, month 4\n", + "Processing year 2057, month 5\n", + "Processing year 2057, month 6\n", + "Processing year 2057, month 7\n", + "Processing year 2057, month 8\n", + "Processing year 2057, month 9\n", + "Processing year 2057, month 10\n", + "Processing year 2057, month 11\n", + "Processing year 2057, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2057, month 1\n", + "Processing year 2057, month 2\n", + "Processing year 2057, month 3\n", + "Processing year 2057, month 4\n", + "Processing year 2057, month 5\n", + "Processing year 2057, month 6\n", + "Processing year 2057, month 7\n", + "Processing year 2057, month 8\n", + "Processing year 2057, month 9\n", + "Processing year 2057, month 10\n", + "Processing year 2057, month 11\n", + "Processing year 2057, month 12\n", + "Processing file: CIL_subset_ssp585_2058.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2058, month 1\n", + "Processing year 2058, month 2\n", + "Processing year 2058, month 3\n", + "Processing year 2058, month 4\n", + "Processing year 2058, month 5\n", + "Processing year 2058, month 6\n", + "Processing year 2058, month 7\n", + "Processing year 2058, month 8\n", + "Processing year 2058, month 9\n", + "Processing year 2058, month 10\n", + "Processing year 2058, month 11\n", + "Processing year 2058, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2058, month 1\n", + "Processing year 2058, month 2\n", + "Processing year 2058, month 3\n", + "Processing year 2058, month 4\n", + "Processing year 2058, month 5\n", + "Processing year 2058, month 6\n", + "Processing year 2058, month 7\n", + "Processing year 2058, month 8\n", + "Processing year 2058, month 9\n", + "Processing year 2058, month 10\n", + "Processing year 2058, month 11\n", + "Processing year 2058, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2058, month 1\n", + "Processing year 2058, month 2\n", + "Processing year 2058, month 3\n", + "Processing year 2058, month 4\n", + "Processing year 2058, month 5\n", + "Processing year 2058, month 6\n", + "Processing year 2058, month 7\n", + "Processing year 2058, month 8\n", + "Processing year 2058, month 9\n", + "Processing year 2058, month 10\n", + "Processing year 2058, month 11\n", + "Processing year 2058, month 12\n", + "Processing file: CIL_subset_ssp585_2059.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2059, month 1\n", + "Processing year 2059, month 2\n", + "Processing year 2059, month 3\n", + "Processing year 2059, month 4\n", + "Processing year 2059, month 5\n", + "Processing year 2059, month 6\n", + "Processing year 2059, month 7\n", + "Processing year 2059, month 8\n", + "Processing year 2059, month 9\n", + "Processing year 2059, month 10\n", + "Processing year 2059, month 11\n", + "Processing year 2059, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2059, month 1\n", + "Processing year 2059, month 2\n", + "Processing year 2059, month 3\n", + "Processing year 2059, month 4\n", + "Processing year 2059, month 5\n", + "Processing year 2059, month 6\n", + "Processing year 2059, month 7\n", + "Processing year 2059, month 8\n", + "Processing year 2059, month 9\n", + "Processing year 2059, month 10\n", + "Processing year 2059, month 11\n", + "Processing year 2059, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2059, month 1\n", + "Processing year 2059, month 2\n", + "Processing year 2059, month 3\n", + "Processing year 2059, month 4\n", + "Processing year 2059, month 5\n", + "Processing year 2059, month 6\n", + "Processing year 2059, month 7\n", + "Processing year 2059, month 8\n", + "Processing year 2059, month 9\n", + "Processing year 2059, month 10\n", + "Processing year 2059, month 11\n", + "Processing year 2059, month 12\n", + "Processing file: CIL_subset_ssp585_2060.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2060, month 1\n", + "Processing year 2060, month 2\n", + "Processing year 2060, month 3\n", + "Processing year 2060, month 4\n", + "Processing year 2060, month 5\n", + "Processing year 2060, month 6\n", + "Processing year 2060, month 7\n", + "Processing year 2060, month 8\n", + "Processing year 2060, month 9\n", + "Processing year 2060, month 10\n", + "Processing year 2060, month 11\n", + "Processing year 2060, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2060, month 1\n", + "Processing year 2060, month 2\n", + "Processing year 2060, month 3\n", + "Processing year 2060, month 4\n", + "Processing year 2060, month 5\n", + "Processing year 2060, month 6\n", + "Processing year 2060, month 7\n", + "Processing year 2060, month 8\n", + "Processing year 2060, month 9\n", + "Processing year 2060, month 10\n", + "Processing year 2060, month 11\n", + "Processing year 2060, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2060, month 1\n", + "Processing year 2060, month 2\n", + "Processing year 2060, month 3\n", + "Processing year 2060, month 4\n", + "Processing year 2060, month 5\n", + "Processing year 2060, month 6\n", + "Processing year 2060, month 7\n", + "Processing year 2060, month 8\n", + "Processing year 2060, month 9\n", + "Processing year 2060, month 10\n", + "Processing year 2060, month 11\n", + "Processing year 2060, month 12\n", + "Processing file: CIL_subset_ssp585_2061.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2061, month 1\n", + "Processing year 2061, month 2\n", + "Processing year 2061, month 3\n", + "Processing year 2061, month 4\n", + "Processing year 2061, month 5\n", + "Processing year 2061, month 6\n", + "Processing year 2061, month 7\n", + "Processing year 2061, month 8\n", + "Processing year 2061, month 9\n", + "Processing year 2061, month 10\n", + "Processing year 2061, month 11\n", + "Processing year 2061, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2061, month 1\n", + "Processing year 2061, month 2\n", + "Processing year 2061, month 3\n", + "Processing year 2061, month 4\n", + "Processing year 2061, month 5\n", + "Processing year 2061, month 6\n", + "Processing year 2061, month 7\n", + "Processing year 2061, month 8\n", + "Processing year 2061, month 9\n", + "Processing year 2061, month 10\n", + "Processing year 2061, month 11\n", + "Processing year 2061, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2061, month 1\n", + "Processing year 2061, month 2\n", + "Processing year 2061, month 3\n", + "Processing year 2061, month 4\n", + "Processing year 2061, month 5\n", + "Processing year 2061, month 6\n", + "Processing year 2061, month 7\n", + "Processing year 2061, month 8\n", + "Processing year 2061, month 9\n", + "Processing year 2061, month 10\n", + "Processing year 2061, month 11\n", + "Processing year 2061, month 12\n", + "Processing file: CIL_subset_ssp585_2062.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2062, month 1\n", + "Processing year 2062, month 2\n", + "Processing year 2062, month 3\n", + "Processing year 2062, month 4\n", + "Processing year 2062, month 5\n", + "Processing year 2062, month 6\n", + "Processing year 2062, month 7\n", + "Processing year 2062, month 8\n", + "Processing year 2062, month 9\n", + "Processing year 2062, month 10\n", + "Processing year 2062, month 11\n", + "Processing year 2062, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2062, month 1\n", + "Processing year 2062, month 2\n", + "Processing year 2062, month 3\n", + "Processing year 2062, month 4\n", + "Processing year 2062, month 5\n", + "Processing year 2062, month 6\n", + "Processing year 2062, month 7\n", + "Processing year 2062, month 8\n", + "Processing year 2062, month 9\n", + "Processing year 2062, month 10\n", + "Processing year 2062, month 11\n", + "Processing year 2062, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2062, month 1\n", + "Processing year 2062, month 2\n", + "Processing year 2062, month 3\n", + "Processing year 2062, month 4\n", + "Processing year 2062, month 5\n", + "Processing year 2062, month 6\n", + "Processing year 2062, month 7\n", + "Processing year 2062, month 8\n", + "Processing year 2062, month 9\n", + "Processing year 2062, month 10\n", + "Processing year 2062, month 11\n", + "Processing year 2062, month 12\n", + "Processing file: CIL_subset_ssp585_2063.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2063, month 1\n", + "Processing year 2063, month 2\n", + "Processing year 2063, month 3\n", + "Processing year 2063, month 4\n", + "Processing year 2063, month 5\n", + "Processing year 2063, month 6\n", + "Processing year 2063, month 7\n", + "Processing year 2063, month 8\n", + "Processing year 2063, month 9\n", + "Processing year 2063, month 10\n", + "Processing year 2063, month 11\n", + "Processing year 2063, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2063, month 1\n", + "Processing year 2063, month 2\n", + "Processing year 2063, month 3\n", + "Processing year 2063, month 4\n", + "Processing year 2063, month 5\n", + "Processing year 2063, month 6\n", + "Processing year 2063, month 7\n", + "Processing year 2063, month 8\n", + "Processing year 2063, month 9\n", + "Processing year 2063, month 10\n", + "Processing year 2063, month 11\n", + "Processing year 2063, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2063, month 1\n", + "Processing year 2063, month 2\n", + "Processing year 2063, month 3\n", + "Processing year 2063, month 4\n", + "Processing year 2063, month 5\n", + "Processing year 2063, month 6\n", + "Processing year 2063, month 7\n", + "Processing year 2063, month 8\n", + "Processing year 2063, month 9\n", + "Processing year 2063, month 10\n", + "Processing year 2063, month 11\n", + "Processing year 2063, month 12\n", + "Processing file: CIL_subset_ssp585_2064.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2064, month 1\n", + "Processing year 2064, month 2\n", + "Processing year 2064, month 3\n", + "Processing year 2064, month 4\n", + "Processing year 2064, month 5\n", + "Processing year 2064, month 6\n", + "Processing year 2064, month 7\n", + "Processing year 2064, month 8\n", + "Processing year 2064, month 9\n", + "Processing year 2064, month 10\n", + "Processing year 2064, month 11\n", + "Processing year 2064, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2064, month 1\n", + "Processing year 2064, month 2\n", + "Processing year 2064, month 3\n", + "Processing year 2064, month 4\n", + "Processing year 2064, month 5\n", + "Processing year 2064, month 6\n", + "Processing year 2064, month 7\n", + "Processing year 2064, month 8\n", + "Processing year 2064, month 9\n", + "Processing year 2064, month 10\n", + "Processing year 2064, month 11\n", + "Processing year 2064, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2064, month 1\n", + "Processing year 2064, month 2\n", + "Processing year 2064, month 3\n", + "Processing year 2064, month 4\n", + "Processing year 2064, month 5\n", + "Processing year 2064, month 6\n", + "Processing year 2064, month 7\n", + "Processing year 2064, month 8\n", + "Processing year 2064, month 9\n", + "Processing year 2064, month 10\n", + "Processing year 2064, month 11\n", + "Processing year 2064, month 12\n", + "Processing file: CIL_subset_ssp585_2065.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2065, month 1\n", + "Processing year 2065, month 2\n", + "Processing year 2065, month 3\n", + "Processing year 2065, month 4\n", + "Processing year 2065, month 5\n", + "Processing year 2065, month 6\n", + "Processing year 2065, month 7\n", + "Processing year 2065, month 8\n", + "Processing year 2065, month 9\n", + "Processing year 2065, month 10\n", + "Processing year 2065, month 11\n", + "Processing year 2065, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2065, month 1\n", + "Processing year 2065, month 2\n", + "Processing year 2065, month 3\n", + "Processing year 2065, month 4\n", + "Processing year 2065, month 5\n", + "Processing year 2065, month 6\n", + "Processing year 2065, month 7\n", + "Processing year 2065, month 8\n", + "Processing year 2065, month 9\n", + "Processing year 2065, month 10\n", + "Processing year 2065, month 11\n", + "Processing year 2065, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2065, month 1\n", + "Processing year 2065, month 2\n", + "Processing year 2065, month 3\n", + "Processing year 2065, month 4\n", + "Processing year 2065, month 5\n", + "Processing year 2065, month 6\n", + "Processing year 2065, month 7\n", + "Processing year 2065, month 8\n", + "Processing year 2065, month 9\n", + "Processing year 2065, month 10\n", + "Processing year 2065, month 11\n", + "Processing year 2065, month 12\n", + "Processing file: CIL_subset_ssp585_2066.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2066, month 1\n", + "Processing year 2066, month 2\n", + "Processing year 2066, month 3\n", + "Processing year 2066, month 4\n", + "Processing year 2066, month 5\n", + "Processing year 2066, month 6\n", + "Processing year 2066, month 7\n", + "Processing year 2066, month 8\n", + "Processing year 2066, month 9\n", + "Processing year 2066, month 10\n", + "Processing year 2066, month 11\n", + "Processing year 2066, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2066, month 1\n", + "Processing year 2066, month 2\n", + "Processing year 2066, month 3\n", + "Processing year 2066, month 4\n", + "Processing year 2066, month 5\n", + "Processing year 2066, month 6\n", + "Processing year 2066, month 7\n", + "Processing year 2066, month 8\n", + "Processing year 2066, month 9\n", + "Processing year 2066, month 10\n", + "Processing year 2066, month 11\n", + "Processing year 2066, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2066, month 1\n", + "Processing year 2066, month 2\n", + "Processing year 2066, month 3\n", + "Processing year 2066, month 4\n", + "Processing year 2066, month 5\n", + "Processing year 2066, month 6\n", + "Processing year 2066, month 7\n", + "Processing year 2066, month 8\n", + "Processing year 2066, month 9\n", + "Processing year 2066, month 10\n", + "Processing year 2066, month 11\n", + "Processing year 2066, month 12\n", + "Processing file: CIL_subset_ssp585_2067.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2067, month 1\n", + "Processing year 2067, month 2\n", + "Processing year 2067, month 3\n", + "Processing year 2067, month 4\n", + "Processing year 2067, month 5\n", + "Processing year 2067, month 6\n", + "Processing year 2067, month 7\n", + "Processing year 2067, month 8\n", + "Processing year 2067, month 9\n", + "Processing year 2067, month 10\n", + "Processing year 2067, month 11\n", + "Processing year 2067, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2067, month 1\n", + "Processing year 2067, month 2\n", + "Processing year 2067, month 3\n", + "Processing year 2067, month 4\n", + "Processing year 2067, month 5\n", + "Processing year 2067, month 6\n", + "Processing year 2067, month 7\n", + "Processing year 2067, month 8\n", + "Processing year 2067, month 9\n", + "Processing year 2067, month 10\n", + "Processing year 2067, month 11\n", + "Processing year 2067, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2067, month 1\n", + "Processing year 2067, month 2\n", + "Processing year 2067, month 3\n", + "Processing year 2067, month 4\n", + "Processing year 2067, month 5\n", + "Processing year 2067, month 6\n", + "Processing year 2067, month 7\n", + "Processing year 2067, month 8\n", + "Processing year 2067, month 9\n", + "Processing year 2067, month 10\n", + "Processing year 2067, month 11\n", + "Processing year 2067, month 12\n", + "Processing file: CIL_subset_ssp585_2068.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2068, month 1\n", + "Processing year 2068, month 2\n", + "Processing year 2068, month 3\n", + "Processing year 2068, month 4\n", + "Processing year 2068, month 5\n", + "Processing year 2068, month 6\n", + "Processing year 2068, month 7\n", + "Processing year 2068, month 8\n", + "Processing year 2068, month 9\n", + "Processing year 2068, month 10\n", + "Processing year 2068, month 11\n", + "Processing year 2068, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2068, month 1\n", + "Processing year 2068, month 2\n", + "Processing year 2068, month 3\n", + "Processing year 2068, month 4\n", + "Processing year 2068, month 5\n", + "Processing year 2068, month 6\n", + "Processing year 2068, month 7\n", + "Processing year 2068, month 8\n", + "Processing year 2068, month 9\n", + "Processing year 2068, month 10\n", + "Processing year 2068, month 11\n", + "Processing year 2068, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2068, month 1\n", + "Processing year 2068, month 2\n", + "Processing year 2068, month 3\n", + "Processing year 2068, month 4\n", + "Processing year 2068, month 5\n", + "Processing year 2068, month 6\n", + "Processing year 2068, month 7\n", + "Processing year 2068, month 8\n", + "Processing year 2068, month 9\n", + "Processing year 2068, month 10\n", + "Processing year 2068, month 11\n", + "Processing year 2068, month 12\n", + "Processing file: CIL_subset_ssp585_2069.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2069, month 1\n", + "Processing year 2069, month 2\n", + "Processing year 2069, month 3\n", + "Processing year 2069, month 4\n", + "Processing year 2069, month 5\n", + "Processing year 2069, month 6\n", + "Processing year 2069, month 7\n", + "Processing year 2069, month 8\n", + "Processing year 2069, month 9\n", + "Processing year 2069, month 10\n", + "Processing year 2069, month 11\n", + "Processing year 2069, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2069, month 1\n", + "Processing year 2069, month 2\n", + "Processing year 2069, month 3\n", + "Processing year 2069, month 4\n", + "Processing year 2069, month 5\n", + "Processing year 2069, month 6\n", + "Processing year 2069, month 7\n", + "Processing year 2069, month 8\n", + "Processing year 2069, month 9\n", + "Processing year 2069, month 10\n", + "Processing year 2069, month 11\n", + "Processing year 2069, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2069, month 1\n", + "Processing year 2069, month 2\n", + "Processing year 2069, month 3\n", + "Processing year 2069, month 4\n", + "Processing year 2069, month 5\n", + "Processing year 2069, month 6\n", + "Processing year 2069, month 7\n", + "Processing year 2069, month 8\n", + "Processing year 2069, month 9\n", + "Processing year 2069, month 10\n", + "Processing year 2069, month 11\n", + "Processing year 2069, month 12\n", + "Processing file: CIL_subset_ssp585_2070.nc\n", + "Processing model: HadGEM3-GC31-LL\n", + "Processing year 2070, month 1\n", + "Processing year 2070, month 2\n", + "Processing year 2070, month 3\n", + "Processing year 2070, month 4\n", + "Processing year 2070, month 5\n", + "Processing year 2070, month 6\n", + "Processing year 2070, month 7\n", + "Processing year 2070, month 8\n", + "Processing year 2070, month 9\n", + "Processing year 2070, month 10\n", + "Processing year 2070, month 11\n", + "Processing year 2070, month 12\n", + "Processing model: EC-Earth3-CC\n", + "Processing year 2070, month 1\n", + "Processing year 2070, month 2\n", + "Processing year 2070, month 3\n", + "Processing year 2070, month 4\n", + "Processing year 2070, month 5\n", + "Processing year 2070, month 6\n", + "Processing year 2070, month 7\n", + "Processing year 2070, month 8\n", + "Processing year 2070, month 9\n", + "Processing year 2070, month 10\n", + "Processing year 2070, month 11\n", + "Processing year 2070, month 12\n", + "Processing model: CMCC-CM2-SR5\n", + "Processing year 2070, month 1\n", + "Processing year 2070, month 2\n", + "Processing year 2070, month 3\n", + "Processing year 2070, month 4\n", + "Processing year 2070, month 5\n", + "Processing year 2070, month 6\n", + "Processing year 2070, month 7\n", + "Processing year 2070, month 8\n", + "Processing year 2070, month 9\n", + "Processing year 2070, month 10\n", + "Processing year 2070, month 11\n", + "Processing year 2070, month 12\n", + "Saved monthly data for lowest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/lowest_monthly_prediction_weather_by_facility_ANC.csv\n", + "Saved window data for lowest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/lowest_window_prediction_weather_by_facility_ANC.csv\n", + "Saved monthly data for mean model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/mean_monthly_prediction_weather_by_facility_ANC.csv\n", + "Saved window data for mean model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/mean_window_prediction_weather_by_facility_ANC.csv\n", + "Saved monthly data for highest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/highest_monthly_prediction_weather_by_facility_ANC.csv\n", + "Saved window data for highest model to /Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL/ssp585/highest_window_prediction_weather_by_facility_ANC.csv\n" ] } ], - "execution_count": null + "execution_count": 8 }, { "metadata": { From 93f231c7f4c7e363a0ce3f902b32ad13875b112e Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 4 Feb 2025 08:34:02 +0000 Subject: [PATCH 241/291] Graphs for inpatient days. Could not use cohort model as that was for births --- .../climate_change/inpatient_projections.py | 360 ++++++++++++++++++ 1 file changed, 360 insertions(+) create mode 100644 src/scripts/climate_change/inpatient_projections.py diff --git a/src/scripts/climate_change/inpatient_projections.py b/src/scripts/climate_change/inpatient_projections.py new file mode 100644 index 0000000000..8abb4f530c --- /dev/null +++ b/src/scripts/climate_change/inpatient_projections.py @@ -0,0 +1,360 @@ +from pathlib import Path +from scipy.stats import ttest_rel, wilcoxon, shapiro +from scipy.stats import ttest_1samp + +import geopandas as gpd +from netCDF4 import Dataset +from shapely.geometry import Polygon +from matplotlib import colors as mcolors +import matplotlib.pyplot as plt +import pandas as pd +import numpy as np + +from tlo.analysis.utils import ( + extract_results, + make_age_grp_lookup, + make_calendar_period_lookup, + summarize, +) + +min_year = 2025 +max_year = 2061 +scenarios = ['ssp126', 'ssp245', 'ssp585'] +model_types = ['lowest', 'mean', 'highest'] +year_range = range(min_year, max_year) +# global min for all heatmaps for same scale +global_min = -5 +global_max = 0 +# service +Inpatient = True + +if Inpatient: + service = 'Inpatient' +results_folder_to_save = Path(f'/Users/rem76/Desktop/Climate_change_health/Results/{service}_disruptions') +resourcefilepath = Path("/Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-09-25T110820Z") +historical_predictions = pd.read_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/results_of_model_historical_predictions_{service}.csv') +precipitation_threshold = historical_predictions['Precipitation'].quantile(0.9) +print(precipitation_threshold) + +# Load map of Malawi for later +file_path_historical_data = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/2011/60ab007aa16d679a32f9c3e186d2f744.nc" +dataset = Dataset(file_path_historical_data, mode='r') +pr_data = dataset.variables['tp'][:] +lat_data = dataset.variables['latitude'][:] +long_data = dataset.variables['longitude'][:] +meshgrid_from_netCDF = np.meshgrid(long_data, lat_data) + +malawi = gpd.read_file("/Users/rem76/PycharmProjects/TLOmodel/resources/mapping/ResourceFile_mwi_admbnda_adm0_nso_20181016.shp") +malawi_admin2 = gpd.read_file("/Users/rem76/PycharmProjects/TLOmodel/resources/mapping/ResourceFile_mwi_admbnda_adm2_nso_20181016.shp") +# +# change names of some districts for consistency +malawi_admin2['ADM2_EN'] = malawi_admin2['ADM2_EN'].replace('Blantyre City', 'Blantyre') +malawi_admin2['ADM2_EN'] = malawi_admin2['ADM2_EN'].replace('Mzuzu City', 'Mzuzu') +malawi_admin2['ADM2_EN'] = malawi_admin2['ADM2_EN'].replace('Lilongwe City', 'Lilongwe') +malawi_admin2['ADM2_EN'] = malawi_admin2['ADM2_EN'].replace('Zomba City', 'Zomba') + +difference_lat = lat_data[1] - lat_data[0] +difference_long = long_data[1] - long_data[0] + +# # Get expected disturbance from the model + +results_list = [] + +results_list = [] + +#Loop through scenarios and model types +for scenario in scenarios: + for model_type in model_types: + predictions_from_cmip = pd.read_csv( + f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' + ) + predictions_from_cmip = predictions_from_cmip.loc[predictions_from_cmip['Difference_in_Expectation'] < 0] + predictions_from_cmip = predictions_from_cmip[predictions_from_cmip['Year'] <= 2061] + # total disruptions + predictions_from_cmip_sum = predictions_from_cmip.groupby('Year').sum().reset_index() + predictions_from_cmip_sum['Percentage_Difference'] = ( + predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum[ + 'Predicted_No_Weather_Model']) + percentage_difference = predictions_from_cmip_sum[ + 'Percentage_Difference'].values + + # Check for negative values (missed cases?) + negative_sum = np.sum(percentage_difference[percentage_difference < 0]) + + # now do extreme precipitation by district and year, use original dataframe to get monthly top 10% precip + filtered_predictions = predictions_from_cmip[predictions_from_cmip['Precipitation'] >= precipitation_threshold] + filtered_predictions_sum = filtered_predictions.groupby('Year').sum().reset_index() + percent_due_to_extreme = filtered_predictions_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model'] + values_extreme_precip = percent_due_to_extreme.values + negative_sum_extreme_precip = np.sum(values_extreme_precip[values_extreme_precip < 0]) + result_df = pd.DataFrame({ + "Scenario": [scenario], + "Model_Type": [model_type], + "Negative_Sum": [negative_sum], + "Negative_Percentage": [negative_sum ], + "Extreme_Precip": [negative_sum_extreme_precip], + "Extreme_Precip_Percentage": [(negative_sum_extreme_precip / negative_sum) * 100] + }) + + results_list.append(result_df) + + # Save multiplied values by model and scenario + # multiplied_values_df = pd.DataFrame({ + # 'Year': year_range, + # 'Scenario': scenario, + # 'Model_Type': model_type, + # 'Multiplied_Values': multiplied_values, + # 'Multiplied_Values_extreme_precip': multiplied_values_extreme_precip + # + # }) + # multiplied_values_df.to_csv(results_folder_to_save/f'multiplied_values_{scenario}_{model_type}.csv', index=False) + +final_results = pd.concat(results_list, ignore_index=True) +print(final_results) +final_results.to_csv(f'/Users/rem76/Desktop/Climate_change_health/Results/{service}_disruptions/negative_sums_and_percentages.csv', index=False) + + + + +## now all grids +fig, axes = plt.subplots(3, 3, figsize=(18, 18),) + + +for scenario in scenarios: + for model_type in model_types: + predictions_from_cmip = pd.read_csv( + f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' + ) + predictions_from_cmip = predictions_from_cmip.loc[predictions_from_cmip['Difference_in_Expectation'] < 0] + predictions_from_cmip_sum = predictions_from_cmip_sum[predictions_from_cmip_sum['Year'] <= 2061] + + predictions_from_cmip_sum = predictions_from_cmip.groupby('District').sum().reset_index() + predictions_from_cmip_sum['Percentage_Difference'] = ( + predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model'] + ) * 100 + + predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( + {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} + ) + percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() + malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) + malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 + + +for i, scenario in enumerate(scenarios): + for j, model_type in enumerate(model_types): + predictions_from_cmip = pd.read_csv( + f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' + ) + predictions_from_cmip = predictions_from_cmip.loc[predictions_from_cmip['Difference_in_Expectation'] < 0] + predictions_from_cmip_sum = predictions_from_cmip_sum[predictions_from_cmip_sum['Year'] <= 2061] + + predictions_from_cmip_sum = predictions_from_cmip.groupby('District').sum().reset_index() + predictions_from_cmip_sum['Percentage_Difference'] = ( + predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model'] + ) * 100 + + predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( + {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} + ) + percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() + malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) + malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 + ax = axes[i, j] + malawi_admin2.dropna(subset=['Percentage_Difference']).plot( + ax=ax, + column='Percentage_Difference', + cmap='Blues_r', + edgecolor='black', + alpha=1, + legend=False, + vmin=global_min, + vmax=global_max + ) + + ax.set_title(f"{scenario}: {model_type}", fontsize=14) + + if i != 1: + ax.set_xlabel("") + if j != 0: + ax.set_ylabel("") + else: + ax.set_ylabel("Latitude", fontsize=10) + + if i == 1: + ax.set_xlabel("Longitude", fontsize=10) + +sm = plt.cm.ScalarMappable( + cmap='Blues_r', + norm=mcolors.Normalize(vmin=global_min, vmax=global_max) +) +sm.set_array([]) +fig.colorbar(sm, ax=axes, orientation="vertical", shrink=0.8, label="Percentage Difference (%)") +plt.suptitle("Percentage Difference Maps by Scenario and Model Type", fontsize=16, y=1.02) +plt.savefig(results_folder_to_save / 'percentage_difference_maps_grid.png') +plt.show() + + + +significant_results_year = [] +# +# Assuming 'district' is a column in your data +for scenario in scenarios: + for model_type in model_types: + predictions_from_cmip = pd.read_csv( + f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' + ) + predictions_from_cmip = predictions_from_cmip.loc[predictions_from_cmip['Difference_in_Expectation'] < 0] + predictions_from_cmip_sum = predictions_from_cmip_sum[predictions_from_cmip_sum['Year'] <= 2061] + + predictions_from_cmip_sum = predictions_from_cmip.groupby(['District', 'Year']).sum().reset_index() + for district in predictions_from_cmip_sum['District'].unique(): + district_values = predictions_from_cmip_sum[predictions_from_cmip_sum['District'] == district] + no_weather_model = district_values['Predicted_No_Weather_Model'].values + weather_model = district_values['Predicted_Weather_Model'].values + + # Calculate the difference + difference = no_weather_model - weather_model + + # Perform a one-sample t-test assuming 0 as the null hypothesis mean + t_stat, p_value = ttest_1samp(difference, popmean=0) + # Print results if p-value is below 0.05 (statistically significant) + if p_value < 0.05: + print(f"Scenario: {scenario}, Model Type: {model_type}, District: {district}, " + f"t-stat: {t_stat:.2f}, p-value: {p_value:.4f}") +## now all grids + + + +####### Historical disruptions ########## + + +historical_predictions = pd.read_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/results_of_model_historical_predictions_{service}.csv') +historical_predictions = historical_predictions.loc[historical_predictions['Difference_in_Expectation'] < 0] + +historical_predictions_sum = historical_predictions.groupby('District').sum().reset_index() +historical_predictions_sum['Percentage_Difference'] = ( + historical_predictions_sum['Difference_in_Expectation'] / historical_predictions_sum['Predicted_No_Weather_Model'] +) * 100 + +historical_predictions_sum['District'] = historical_predictions_sum['District'].replace( + {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} +) + +percentage_diff_by_district_historical = historical_predictions_sum.groupby('District')['Percentage_Difference'].mean() +malawi_admin2['Percentage_Difference_historical'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district_historical) +malawi_admin2.loc[malawi_admin2['Percentage_Difference_historical'] > 0, 'Percentage_Difference_historical'] = 0 +percentage_diff_by_district_historical_average = historical_predictions_sum['Percentage_Difference'].mean() +print(malawi_admin2) +filtered_predictions = historical_predictions[historical_predictions['Precipitation'] >= precipitation_threshold] +filtered_predictions_sum = filtered_predictions.groupby('Year').sum().reset_index() +percent_due_to_extreme = filtered_predictions_sum['Difference_in_Expectation'].sum() +percent_due_to_extreme = percent_due_to_extreme/historical_predictions['Difference_in_Expectation'].sum() +print(percent_due_to_extreme) +fig, ax = plt.subplots(figsize=(10, 10)) + +malawi_admin2.dropna(subset=['Percentage_Difference_historical']).plot( + ax=ax, + column='Percentage_Difference_historical', + cmap='Blues_r', + edgecolor='black', + alpha=1, + legend=False, + vmin=global_min, + vmax=0 +) + +ax.set_ylabel("Latitude", fontsize=10) +ax.set_xlabel("Longitude", fontsize=10) + +sm = plt.cm.ScalarMappable( + cmap='Blues_r', + norm=mcolors.Normalize(vmin=global_min, vmax=global_max) +) +sm.set_array([]) +fig.colorbar(sm, ax=ax, orientation="vertical", shrink=0.8, label="Percentage Difference (%)") + +plt.title("", fontsize=16) +plt.savefig(results_folder_to_save / 'percentage_difference_map_historical.png') +plt.show() + +## stacked bar chart + +# Create the figure and axes grid +fig, axes = plt.subplots(3, 3, figsize=(18, 18)) +y_min = float('inf') +y_max = float('-inf') +x_min = float('inf') +x_max = float('-inf') +percentage_diff_by_year_district_all = {} +percentage_diff_by_year_district_scenario = {} +year_groupings = range(2025, 2060, 5) +for i, scenario in enumerate(scenarios): + percentage_diff_by_year_district_all[scenario] = {} + percentage_diff_by_year_district_scenario[scenario] = {} + + for j, model_type in enumerate(model_types): + percentage_diff_by_year_district_all[scenario][model_type] = {} + percentage_diff_by_year_district_scenario[scenario][model_type] = {} + percentage_diff_by_year_district_scenario[scenario][model_type] = 0 + + percentage_diff_by_year_district = {} + + predictions_from_cmip = pd.read_csv( + f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv' + ) + predictions_from_cmip = predictions_from_cmip.loc[predictions_from_cmip['Difference_in_Expectation'] < 0] + predictions_from_cmip_sum = predictions_from_cmip_sum[predictions_from_cmip_sum['Year'] <= 2061] + + predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'District']).sum().reset_index() + predictions_from_cmip_sum = predictions_from_cmip_sum[predictions_from_cmip_sum['Year'] <= 2060] + predictions_from_cmip_sum['Percentage_Difference'] = ( + predictions_from_cmip_sum[ + 'Difference_in_Expectation'] / + predictions_from_cmip_sum['Predicted_No_Weather_Model'] + ) + predictions_from_cmip_sum.loc[ + predictions_from_cmip_sum['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 + predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( + {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} + ) + + for year in year_groupings: + subset = predictions_from_cmip_sum[ + (predictions_from_cmip_sum['Year'] >= year) & + (predictions_from_cmip_sum['Year'] <= year + 5) + ] + for _, row in subset.iterrows(): + district = row['District'] + percentage_diff = row['Percentage_Difference'] + if year not in percentage_diff_by_year_district: + percentage_diff_by_year_district[year] = {} + if district not in percentage_diff_by_year_district[year]: + percentage_diff_by_year_district[year][district] = 0 + percentage_diff_by_year_district[year][district] += (percentage_diff) # 1.4 is conversion factor between births and pregancies + percentage_diff_by_year_district_scenario[scenario][model_type] = (percentage_diff ) + + data_for_plot = pd.DataFrame.from_dict(percentage_diff_by_year_district, orient='index').fillna(0) + y_min = min(y_min, data_for_plot.min().min()) + y_max = max(y_max, data_for_plot.max().max()) + x_min = min(x_min, data_for_plot.index.min()) + x_max = max(x_max, data_for_plot.index.max()) + + ax = axes[i, j] + data_for_plot.plot(kind='bar', stacked=True, ax=ax, cmap='tab20', legend=False) + ax.set_title(f"{scenario}: {model_type}", fontsize=10) + if i == len(scenarios) - 1: + ax.set_xlabel('Year', fontsize=12) + if j == 0: + ax.set_ylabel(f'Deficit of {service} services', fontsize=12) + if (i == 0) & (j == 2): + ax.legend(title="Districts", fontsize=10, title_fontsize=10, bbox_to_anchor=(1., 1)) + percentage_diff_by_year_district_all[scenario][model_type] = percentage_diff_by_year_district +for ax in axes.flatten(): + ax.set_ylim(y_min*15, y_max) +handles, labels = ax.get_legend_handles_labels() +fig.legend(handles, labels, bbox_to_anchor=(1, -10), loc = "center right", fontsize=10, title="Districts") +plt.tight_layout() +plt.savefig(results_folder_to_save / 'stacked_bar_percentage_difference_5_years_grid_single_legend.png') +#plt.show() +# From d447f754bf71c3215131ee8451a7b35919fdf78e Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 4 Feb 2025 14:52:43 +0000 Subject: [PATCH 242/291] Added plot of past vs future precipitation --- src/scripts/climate_change/cohort_model.py | 77 +++++++++- .../climate_change/inpatient_projections.py | 144 +++++++++++++++++- 2 files changed, 216 insertions(+), 5 deletions(-) diff --git a/src/scripts/climate_change/cohort_model.py b/src/scripts/climate_change/cohort_model.py index ddb540ccc5..994930511b 100644 --- a/src/scripts/climate_change/cohort_model.py +++ b/src/scripts/climate_change/cohort_model.py @@ -434,7 +434,7 @@ ####### Historical disruptions ########## -historical_predictions = pd.read_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/results_of_{service}_model_historical_predictions.csv') +historical_predictions = pd.read_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/results_of_model_historical_predictions_{service}.csv') historical_predictions = historical_predictions.loc[historical_predictions['Difference_in_Expectation'] < 0] historical_predictions_sum = historical_predictions.groupby('District').sum().reset_index() @@ -482,3 +482,78 @@ plt.title("", fontsize=16) plt.savefig(results_folder_to_save / 'percentage_difference_map_historical.png') plt.show() + + + +# Define file paths +monthly_reporting_file = "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_ANC_lm.csv" +five_day_max_file = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/historical_daily_total_by_facilities_with_ANC_five_day_cumulative.csv" +precipitation_path = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL" + +# Define scenarios, models, and services +scenarios = ["ssp126", "ssp245", "ssp585"] +model_types = ["lowest", "mean", "highest"] +services = ["ANC"] # Only ANC is used + +def filter_top_20_percent(values): + """Filter values to keep only those in the top 80th percentile.""" + threshold = np.percentile(values, 80) + return values[values >= threshold] + +# Load and filter monthly reporting data +monthly_reporting_df = pd.read_csv(monthly_reporting_file) +monthly_reporting_values = monthly_reporting_df.iloc[:, 1:].values.flatten() +monthly_reporting_values = filter_top_20_percent(monthly_reporting_values) + +# Load and filter 5-day max reporting data +five_day_max_df = pd.read_csv(five_day_max_file) +five_day_max_values = five_day_max_df.iloc[:, 1:].values.flatten() +five_day_max_values = filter_top_20_percent(five_day_max_values) + +# Create a figure with 3 rows (one per scenario) and 2 columns (Monthly, 5-Day Max) +fig, axes = plt.subplots(3, 2, figsize=(14, 12)) + +for i, scenario in enumerate(scenarios): + # Monthly Reporting Distribution + sns.kdeplot(monthly_reporting_values, label="Monthly Reporting ANC", color='black', ax=axes[i, 0], alpha=1) + axes[i, 0].set_title(f"Top 20% Distribution - Monthly ({scenario})") + axes[i, 0].set_xlabel("Precipitation (mm)") + axes[i, 0].set_ylabel("Density") + + # 5-Day Max Reporting Distribution + sns.kdeplot(five_day_max_values, label="5-Day Max Reporting ANC", color='black', ax=axes[i, 1], alpha=1) + axes[i, 1].set_title(f"Top 20% Distribution - 5 Day Max ({scenario})") + axes[i, 1].set_xlabel("Precipitation (mm)") + axes[i, 1].set_ylabel("Density") + + # Loop through model types and services to plot distributions + for model in model_types: + for service in services: + # Monthly Prediction Data + monthly_file_path = os.path.join( + precipitation_path, scenario, f"{model}_monthly_prediction_weather_by_facility_{service}.csv" + ) + if os.path.exists(monthly_file_path): + df = pd.read_csv(monthly_file_path) + values = df.iloc[:, 1:].values.flatten() + values = filter_top_20_percent(values) + if len(values) > 0: + sns.kdeplot(values, label=f"{model} - {service}", alpha=0.4, ax=axes[i, 0]) + + # 5-Day Max Prediction Data + five_day_file_path = os.path.join( + precipitation_path, scenario, f"{model}_window_prediction_weather_by_facility_{service}.csv" + ) + if os.path.exists(five_day_file_path): + df = pd.read_csv(five_day_file_path) + values = df.iloc[:, 1:].values.flatten() + values = filter_top_20_percent(values) + if len(values) > 0: + sns.kdeplot(values, label=f"{model} - {service}", alpha=0.3, ax=axes[i, 1]) + + axes[0, 0].legend() + axes[0, 1].legend() + +plt.tight_layout() +plt.show() +plt.savefig(f"/Users/rem76/Desktop/Climate_change_health/Data/historical_vs_future_precipitation_ANC.png") diff --git a/src/scripts/climate_change/inpatient_projections.py b/src/scripts/climate_change/inpatient_projections.py index 8abb4f530c..51a40cf072 100644 --- a/src/scripts/climate_change/inpatient_projections.py +++ b/src/scripts/climate_change/inpatient_projections.py @@ -9,6 +9,9 @@ import matplotlib.pyplot as plt import pandas as pd import numpy as np +import seaborn as sns +import glob +import os from tlo.analysis.utils import ( extract_results, @@ -55,11 +58,9 @@ difference_lat = lat_data[1] - lat_data[0] difference_long = long_data[1] - long_data[0] - +# # # Get expected disturbance from the model - -results_list = [] - +# results_list = [] #Loop through scenarios and model types @@ -358,3 +359,138 @@ plt.savefig(results_folder_to_save / 'stacked_bar_percentage_difference_5_years_grid_single_legend.png') #plt.show() # + +# Define file paths +monthly_reporting_file = "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_ANC_lm.csv" +five_day_max_file = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/historical_daily_total_by_facilities_with_ANC_five_day_cumulative.csv" +precipitation_path = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL" + +# Define scenarios, models, and services +scenarios = ["ssp126", "ssp245", "ssp585"] +model_types = ["lowest", "mean", "highest"] +services = ["ANC", "Inpatient"] + +# Load the monthly reporting data +monthly_reporting_df = pd.read_csv(monthly_reporting_file) +monthly_reporting_values = monthly_reporting_df.iloc[:, 1:].values.flatten() + +# Load the 5-day max reporting data +five_day_max_df = pd.read_csv(five_day_max_file) +five_day_max_values = five_day_max_df.iloc[:, 1:].values.flatten() + +# Create side-by-side plots +fig, axes = plt.subplots(1, 2, figsize=(14, 6)) + +# Monthly Reporting Distribution +sns.kdeplot(monthly_reporting_values, label="Monthly Reporting ANC", color='#1C6E8C', ax=axes[0]) +axes[0].set_title("Distribution Comparisons - Monthly") +axes[0].set_xlabel("Value") +axes[0].set_ylabel("Density") +axes[0].legend() + +# 5-Day Max Reporting Distribution +sns.kdeplot(five_day_max_values, label="5-Day Max Reporting ANC", color='#1C6E8C', ax=axes[1]) +axes[1].set_title("Distribution Comparisons - 5 Day Max") +axes[1].set_xlabel("Value") +axes[1].set_ylabel("Density") +axes[1].legend() + +# Loop through scenarios, models, and services to plot distributions +for scenario in scenarios: + for model in model_types: + for service in services: + # Monthly Prediction Data + monthly_file_path = os.path.join( + precipitation_path, scenario, f"{model}_monthly_prediction_weather_by_facility_{service}.csv" + ) + if os.path.exists(monthly_file_path): + df = pd.read_csv(monthly_file_path) + values = df.iloc[:, 1:].values.flatten() + sns.kdeplot(values, label=f"{scenario} - {model} - {service}", alpha=0.7, ax=axes[0]) + + # 5-Day Max Prediction Data + five_day_file_path = os.path.join( + precipitation_path, scenario, f"{model}_window_prediction_weather_by_facility_{service}.csv" + ) + if os.path.exists(five_day_file_path): + df = pd.read_csv(five_day_file_path) + values = df.iloc[:, 1:].values.flatten() + sns.kdeplot(values, label=f"{scenario} - {model} - {service}", alpha=0.7, ax=axes[1]) + +plt.tight_layout() +plt.show() + + + +# Define file paths +monthly_reporting_file = "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_ANC_lm.csv" +five_day_max_file = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/historical_daily_total_by_facilities_with_ANC_five_day_cumulative.csv" +precipitation_path = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL" + +# Define scenarios, models, and services +scenarios = ["ssp126", "ssp245", "ssp585"] +model_types = ["lowest", "mean", "highest"] +services = ["Inpatient"] + +def filter_top_20_percent(values): + """Filter values to keep only those in the top 80th percentile.""" + threshold = np.percentile(values, 80) + return values[values >= threshold] + +# Load and filter monthly reporting data +monthly_reporting_df = pd.read_csv(monthly_reporting_file) +monthly_reporting_values = monthly_reporting_df.iloc[:, 1:].values.flatten() +monthly_reporting_values = filter_top_20_percent(monthly_reporting_values) + +# Load and filter 5-day max reporting data +five_day_max_df = pd.read_csv(five_day_max_file) +five_day_max_values = five_day_max_df.iloc[:, 1:].values.flatten() +five_day_max_values = filter_top_20_percent(five_day_max_values) + +# Create a figure with 3 rows (one per scenario) and 2 columns (Monthly, 5-Day Max) +fig, axes = plt.subplots(3, 2, figsize=(14, 12)) + +for i, scenario in enumerate(scenarios): + # Monthly Reporting Distribution + sns.kdeplot(monthly_reporting_values, label="Monthly Reporting ANC", color='black', ax=axes[i, 0], alpha=1) + axes[i, 0].set_title(f"Top 20% Distribution - Monthly ({scenario})") + axes[i, 0].set_xlabel("Precipitation (mm)") + axes[i, 0].set_ylabel("Density") + + # 5-Day Max Reporting Distribution + sns.kdeplot(five_day_max_values, label="5-Day Max Reporting ANC", color='black', ax=axes[i, 1], alpha=1) + axes[i, 1].set_title(f"Top 20% Distribution - 5 Day Max ({scenario})") + axes[i, 1].set_xlabel("Precipitation (mm)") + axes[i, 1].set_ylabel("Density") + + # Loop through model types and services to plot distributions + for model in model_types: + for service in services: + # Monthly Prediction Data + monthly_file_path = os.path.join( + precipitation_path, scenario, f"{model}_monthly_prediction_weather_by_facility_{service}.csv" + ) + if os.path.exists(monthly_file_path): + df = pd.read_csv(monthly_file_path) + values = df.iloc[:, 1:].values.flatten() + values = filter_top_20_percent(values) + if len(values) > 0: + sns.kdeplot(values, label=f"{model} - {service}", alpha=0.4, ax=axes[i, 0]) + + # 5-Day Max Prediction Data + five_day_file_path = os.path.join( + precipitation_path, scenario, f"{model}_window_prediction_weather_by_facility_{service}.csv" + ) + if os.path.exists(five_day_file_path): + df = pd.read_csv(five_day_file_path) + values = df.iloc[:, 1:].values.flatten() + values = filter_top_20_percent(values) + if len(values) > 0: + sns.kdeplot(values, label=f"{model} - {service}", alpha=0.3, ax=axes[i, 1]) + + axes[0, 0].legend() + axes[0, 1].legend() + +plt.tight_layout() +plt.show() +plt.savefig(f"/Users/rem76/Desktop/Climate_change_health/Data/historical_vs_future_precipitation_{service}.png") From 0e21aba62ad55fdad099cdcdd131daf290c47af2 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 11 Feb 2025 13:39:51 +0000 Subject: [PATCH 243/291] Inpatient --- src/scripts/climate_change/inpatient_projections.py | 4 +++- ...odel_historical_realtionship_reporting_precipitation.py | 7 +++++-- 2 files changed, 8 insertions(+), 3 deletions(-) diff --git a/src/scripts/climate_change/inpatient_projections.py b/src/scripts/climate_change/inpatient_projections.py index 51a40cf072..0911a1d077 100644 --- a/src/scripts/climate_change/inpatient_projections.py +++ b/src/scripts/climate_change/inpatient_projections.py @@ -485,6 +485,9 @@ def filter_top_20_percent(values): df = pd.read_csv(five_day_file_path) values = df.iloc[:, 1:].values.flatten() values = filter_top_20_percent(values) + num_events_above_X = (values > 300).sum() + print(f"Number of 5-day max precipitation events above X mm: {num_events_above_X}") + if len(values) > 0: sns.kdeplot(values, label=f"{model} - {service}", alpha=0.3, ax=axes[i, 1]) @@ -492,5 +495,4 @@ def filter_top_20_percent(values): axes[0, 1].legend() plt.tight_layout() -plt.show() plt.savefig(f"/Users/rem76/Desktop/Climate_change_health/Data/historical_vs_future_precipitation_{service}.png") diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index a6941870a8..abab539ddb 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -9,8 +9,8 @@ from statsmodels.stats.outliers_influence import variance_inflation_factor from sklearn.feature_selection import SelectKBest, f_regression -ANC = False -Inpatient = True +ANC = True +Inpatient = False if ANC: service = 'ANC' if Inpatient: @@ -843,3 +843,6 @@ def get_weather_data(ssp_scenario, model_type): # Save to CSV X_basis_weather_filtered.to_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/X_basis_weather_filtered_predictions_{ssp_scenario}_{model_type}_{service}.csv', index=False) + + + From 1454d48d3744bbefc658b75891e84f077ef37108 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 11 Feb 2025 14:14:21 +0000 Subject: [PATCH 244/291] Added graph of difference --- ...al_realtionship_reporting_precipitation.py | 31 ++++++++++++------- 1 file changed, 19 insertions(+), 12 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index abab539ddb..e834b62423 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -228,7 +228,7 @@ def repeat_info(info, num_facilities, year_range, historical): monthly_reporting_by_facility.iloc[covid_months, :] = np.nan # Mask for missing data with Cyclone Freddy monthly_reporting_by_facility.loc[cyclone_freddy_months_phalombe, 'Phalombe Health Centre'] = 0 -monthly_reporting_by_facility.loc[cyclone_freddy_months_phalombe, 'Thumbwe Health Centre'] = 0 +monthly_reporting_by_facility.loc[cyclone_freddy_months_thumbwe, 'Thumbwe Health Centre'] = 0 # Drop September 2024 in ANC/reporting data monthly_reporting_by_facility = monthly_reporting_by_facility.drop(monthly_reporting_by_facility.index[-1]) @@ -544,40 +544,47 @@ def repeat_info(info, num_facilities, year_range, historical): plt.show() ## average of predictions - data_weather_predictions = pd.DataFrame({ 'Year': np.array(year_flattened)[mask_all_data], - 'Year_Month': year_month_labels_filtered, + 'Month': np.array(month_flattened)[mask_all_data], + 'Year_Month': year_month_labels_filtered, # Ensure this is properly formatted 'y_pred_weather': np.exp(matched_y_pred_weather), 'y_pred_no_weather': np.exp(matched_y_pred), 'difference': np.exp(matched_y_pred) - np.exp(matched_y_pred_weather) }) -data_weather_predictions_grouped = data_weather_predictions.groupby('Year', as_index=False).sum() +data_weather_predictions_grouped = data_weather_predictions.groupby('Year_Month', as_index=False).sum() fig, ax = plt.subplots(figsize=(7, 7)) -ax.scatter(data_weather_predictions_grouped['Year'], +ax.scatter(data_weather_predictions_grouped['Year_Month'], data_weather_predictions_grouped['difference'], - color='#823038', alpha=0.7,) + color='#823038', alpha=0.7) ax.axhline(y=0, color='black', linestyle='--', linewidth=1) y_max = max(abs(data_weather_predictions_grouped['difference'])) + 50 ax.set_ylim(-y_max, y_max) -ax.set_xlabel('Year') -ax.set_ylabel(f'Difference in Predicted {service} Services (Without vs. With Precipitation)') +ax.stem(data_weather_predictions_grouped['Year_Month'], + data_weather_predictions_grouped['difference'], + linefmt='gray', markerfmt='o', basefmt="black") +ax.set_xlabel('Year-Month') +ax.set_ylabel(f'Difference in Predicted {service} Services (Without vs. With Precipitation)') +# Ensure 'Year_Month' is properly formatted as strings +ax.set_xticks(data_weather_predictions_grouped['Year_Month']) +ax.set_xticklabels(data_weather_predictions_grouped['Year_Month'], rotation=45, ha='right') -ax.set_xticks(data_weather_predictions_grouped['Year']) -ax.set_xticklabels(data_weather_predictions_grouped['Year'], rotation=45, ha='right') -#ax.legend(loc='upper left') +# Highlight Cyclone Freddy impact in 2023 +ax.axvline(x='2023-03', color='#9AC4F8', linestyle='--', linewidth=1, label="Cyclone Freddy") +plt.tight_layout() +plt.legend() plt.show() +plt.savefig( f'/Users/rem76/Desktop/Climate_change_health/Results/{service}_disruptions/{service}_disruptions_difference_historical_models.png') -plt.tight_layout() plt.show() ## save historical predictions full_data_weather_predictions_historical = pd.DataFrame({ From 24d825997f27dfff2287bf74af92386c4b0f3030 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 12 Feb 2025 09:10:48 +0000 Subject: [PATCH 245/291] Add in calculation of total historical disruptions --- src/scripts/climate_change/cohort_model.py | 59 ++++++++++++++++--- ...al_realtionship_reporting_precipitation.py | 35 +++++------ 2 files changed, 69 insertions(+), 25 deletions(-) diff --git a/src/scripts/climate_change/cohort_model.py b/src/scripts/climate_change/cohort_model.py index 994930511b..caf1d44ae9 100644 --- a/src/scripts/climate_change/cohort_model.py +++ b/src/scripts/climate_change/cohort_model.py @@ -50,13 +50,17 @@ ), do_scaling=True ) + +print(births_results) births_results = births_results.groupby(by=births_results.index).sum() births_results = births_results.replace({0: np.nan}) births_model = summarize(births_results, collapse_columns=True) births_model.columns = ['Model_' + col for col in births_model.columns] births_model_subset = births_model.iloc[15:].copy() # don't want 2010-2024 -# + +print("historical:", births_model.iloc[1:15, 1].sum()) +births_model_subset_historical = births_model.iloc[1:15, 1].sum() # Load map of Malawi for later file_path_historical_data = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/2011/60ab007aa16d679a32f9c3e186d2f744.nc" dataset = Dataset(file_path_historical_data, mode='r') @@ -81,8 +85,6 @@ results_list = [] -results_list = [] - #Loop through scenarios and model types for scenario in scenarios: for model_type in model_types: @@ -485,16 +487,57 @@ +# #### Now do number of births based on the TLO model (2010 - 2024) and 2018 census + +historical_predictions_negative = historical_predictions.loc[historical_predictions['Difference_in_Expectation'] < 0] +historical_predictions_negative = historical_predictions_negative[historical_predictions_negative['Year'] <= 2024] + # total disruptions +historical_predictions_negative_sum = historical_predictions_negative.groupby('Year').sum().reset_index() +historical_predictions_negative_sum['Percentage_Difference'] = ( + historical_predictions_negative_sum['Difference_in_Expectation'] / historical_predictions_negative_sum[ + 'Predicted_No_Weather_Model']) + # Match birth results and predictions +matching_rows_historical = min(len(births_model_subset_historical), len(historical_predictions_negative_sum)) +multiplied_values = births_model_subset_historical.head(matching_rows_historical).iloc[1:15, 1].values * historical_predictions_negative_sum[ + 'Percentage_Difference'].head(matching_rows_historical).values * 1.4 # 1.4 is conversion from births to pregnacnies + +# Check for negative values (missed cases?) +negative_sum_historical = np.sum(multiplied_values[multiplied_values < 0]) + +# now do extreme precipitation by district and year, use original dataframe to get monthly top 10% precip +filtered_predictions_historical = historical_predictions_negative[historical_predictions_negative['Precipitation'] >= precipitation_threshold] +filtered_predictions_sum_historical = filtered_predictions_historical.groupby('Year').sum().reset_index() +percent_due_to_extreme_historical = filtered_predictions_sum_historical['Difference_in_Expectation'] / historical_predictions_negative_sum['Predicted_No_Weather_Model'] +print(percent_due_to_extreme_historical) +multiplied_values_extreme_precip_historical = births_model_subset_historical.head(matching_rows_historical).iloc[:, 1].values * percent_due_to_extreme_historical.head(matching_rows).values * 1.4 +negative_sum_extreme_precip_historical = np.sum(multiplied_values_extreme_precip_historical[multiplied_values_extreme_precip_historical < 0]) +result_df_historical = pd.DataFrame({ + "Negative_Sum": [negative_sum_historical], + "Negative_Percentage": [negative_sum_historical / (births_model_subset_historical['Model_mean'].sum() * 1.4) * 100], + "Extreme_Precip": [negative_sum_extreme_precip_historical], + "Extreme_Precip_Percentage": [(negative_sum_extreme_precip_historical / negative_sum_historical) * 100] + }) + +# Save multiplied values by model and scenario +multiplied_values_df_historical = pd.DataFrame({ + 'Year': year_range[:matching_rows], + 'Scenario': scenario, + 'Model_Type': model_type, + 'Multiplied_Values': multiplied_values, + 'Multiplied_Values_extreme_precip': multiplied_values_extreme_precip + + }) +multiplied_values_df_historical.to_csv(results_folder_to_save/f'multiplied_values_historical.csv', index=False) + +print(result_df_historical) +result_df_historical.to_csv(f'/Users/rem76/Desktop/Climate_change_health/Results/{service}_disruptions/negative_sums_and_percentages_historical.csv', index=False) + + # Define file paths monthly_reporting_file = "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_ANC_lm.csv" five_day_max_file = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/historical_daily_total_by_facilities_with_ANC_five_day_cumulative.csv" precipitation_path = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL" -# Define scenarios, models, and services -scenarios = ["ssp126", "ssp245", "ssp585"] -model_types = ["lowest", "mean", "highest"] -services = ["ANC"] # Only ANC is used - def filter_top_20_percent(values): """Filter values to keep only those in the top 80th percentile.""" threshold = np.percentile(values, 80) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index e834b62423..3a2fe736ac 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -252,7 +252,6 @@ def repeat_info(info, num_facilities, year_range, historical): # Flatten data y = monthly_reporting_by_facility.values.flatten() -#y[np.isnan(y)] = 0 # if all of these are expected to report, then can I assume all 0? if np.nanmin(y) < 1: y += 1 # Shift to ensure positivity as taking log y[y > 4e3] = np.nan @@ -565,27 +564,29 @@ def repeat_info(info, num_facilities, year_range, historical): y_max = max(abs(data_weather_predictions_grouped['difference'])) + 50 ax.set_ylim(-y_max, y_max) - -ax.stem(data_weather_predictions_grouped['Year_Month'], - data_weather_predictions_grouped['difference'], - linefmt='gray', markerfmt='o', basefmt="black") - +# Separate positive and negative values +positive_mask = data_weather_predictions_grouped['difference'] >= 0 +negative_mask = ~positive_mask + +ax.stem(data_weather_predictions_grouped['Year_Month'][positive_mask], + data_weather_predictions_grouped['difference'][positive_mask], + linefmt='#1C6E8C', markerfmt='o', basefmt="black") +ax.stem(data_weather_predictions_grouped['Year_Month'][negative_mask], + data_weather_predictions_grouped['difference'][negative_mask], + linefmt='#823038', markerfmt='o', basefmt="black") ax.set_xlabel('Year-Month') ax.set_ylabel(f'Difference in Predicted {service} Services (Without vs. With Precipitation)') - -# Ensure 'Year_Month' is properly formatted as strings -ax.set_xticks(data_weather_predictions_grouped['Year_Month']) -ax.set_xticklabels(data_weather_predictions_grouped['Year_Month'], rotation=45, ha='right') - -# Highlight Cyclone Freddy impact in 2023 -ax.axvline(x='2023-03', color='#9AC4F8', linestyle='--', linewidth=1, label="Cyclone Freddy") - +january_ticks = data_weather_predictions_grouped[data_weather_predictions_grouped['Year_Month'].str.endswith('-1')] +print(january_ticks) +ax.set_xticks(january_ticks['Year_Month']) +ax.set_xticklabels(january_ticks['Year_Month'].str[:4], rotation=45, ha='right') +ax.axvline(x='2023-3', color='#CDC6AE', linestyle='--', linewidth=1, alpha=0.3, label="Cyclone Freddy") +ax.axvline(x='2023-2', color='#CDC6AE', linestyle='--', linewidth=1, alpha=0.3) +ax.axvspan('2023-2', '2023-3', color='#CDC6AE', alpha=0.3) plt.tight_layout() -plt.legend() -plt.show() plt.savefig( f'/Users/rem76/Desktop/Climate_change_health/Results/{service}_disruptions/{service}_disruptions_difference_historical_models.png') - plt.show() + ## save historical predictions full_data_weather_predictions_historical = pd.DataFrame({ 'Year': np.array(year_flattened)[mask_all_data], From 8013b7da70e44d901912958861e6268fd93bad44 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 12 Feb 2025 11:36:58 +0000 Subject: [PATCH 246/291] Added Lake Malawi --- src/scripts/climate_change/cohort_model.py | 63 ++++++++++++---------- 1 file changed, 36 insertions(+), 27 deletions(-) diff --git a/src/scripts/climate_change/cohort_model.py b/src/scripts/climate_change/cohort_model.py index caf1d44ae9..7706961116 100644 --- a/src/scripts/climate_change/cohort_model.py +++ b/src/scripts/climate_change/cohort_model.py @@ -23,15 +23,13 @@ model_types = ['lowest', 'mean', 'highest'] year_range = range(min_year, max_year) # global min for all heatmaps for same scale -global_min = -5 -global_max = 0 +global_min = 0 +global_max = 5 # service -ANC = False -Inpatient = True +ANC =True if ANC: service = 'ANC' -if Inpatient: - service = 'Inpatient' + ## Get birth results results_folder_to_save = Path(f'/Users/rem76/Desktop/Climate_change_health/Results/{service}_disruptions') results_folder_for_births = Path("/Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-09-25T110820Z") @@ -59,8 +57,8 @@ births_model.columns = ['Model_' + col for col in births_model.columns] births_model_subset = births_model.iloc[15:].copy() # don't want 2010-2024 -print("historical:", births_model.iloc[1:15, 1].sum()) -births_model_subset_historical = births_model.iloc[1:15, 1].sum() +print("historical:", births_model.iloc[2:15, 1].sum()) +births_model_subset_historical = births_model.iloc[2:15, 1] # Load map of Malawi for later file_path_historical_data = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/2011/60ab007aa16d679a32f9c3e186d2f744.nc" dataset = Dataset(file_path_historical_data, mode='r') @@ -71,6 +69,7 @@ malawi = gpd.read_file("/Users/rem76/PycharmProjects/TLOmodel/resources/mapping/ResourceFile_mwi_admbnda_adm0_nso_20181016.shp") malawi_admin2 = gpd.read_file("/Users/rem76/PycharmProjects/TLOmodel/resources/mapping/ResourceFile_mwi_admbnda_adm2_nso_20181016.shp") +water_bodies = gpd.read_file("/Users/rem76/Desktop/Climate_change_health/Data/Water_Supply_Control-Rivers-shp/Water_Supply_Control-Rivers.shp") # # change names of some districts for consistency malawi_admin2['ADM2_EN'] = malawi_admin2['ADM2_EN'].replace('Blantyre City', 'Blantyre') @@ -165,6 +164,7 @@ percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 + malawi_admin2['Percentage_Difference'] = malawi_admin2['Percentage_Difference'].abs() # for mapping, to show % for i, scenario in enumerate(scenarios): @@ -179,18 +179,23 @@ predictions_from_cmip_sum['Percentage_Difference'] = ( predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model'] ) * 100 - predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} ) percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean() + malawi_admin2['Percentage_Difference'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district) malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 + malawi_admin2['Percentage_Difference'] = malawi_admin2['Percentage_Difference'].abs() # for mapping, to show % + ax = axes[i, j] + water_bodies.plot(ax=ax, facecolor="none", edgecolor="#999999", linewidth=0.5, hatch="xxx") + water_bodies.plot(ax=ax, facecolor="none", edgecolor="black", linewidth=1) + malawi_admin2.dropna(subset=['Percentage_Difference']).plot( ax=ax, column='Percentage_Difference', - cmap='Blues_r', + cmap='Blues', edgecolor='black', alpha=1, legend=False, @@ -211,7 +216,7 @@ ax.set_xlabel("Longitude", fontsize=10) sm = plt.cm.ScalarMappable( - cmap='Blues_r', + cmap='Blues', norm=mcolors.Normalize(vmin=global_min, vmax=global_max) ) sm.set_array([]) @@ -293,6 +298,8 @@ ) predictions_from_cmip_sum.loc[ predictions_from_cmip_sum['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 + predictions_from_cmip_sum['Percentage_Difference'] = predictions_from_cmip_sum['Percentage_Difference'].abs() # for mapping, to show % + predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} ) @@ -385,6 +392,8 @@ ) predictions_from_cmip_sum.loc[ predictions_from_cmip_sum['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 + predictions_from_cmip_sum['Percentage_Difference'] = predictions_from_cmip_sum['Percentage_Difference'].abs() # for mapping, to show % + predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} ) @@ -424,7 +433,7 @@ # ax.legend(title="Districts", fontsize=10, title_fontsize=10, bbox_to_anchor=(1., 1)) percentage_diff_by_year_district_all[scenario][model_type] = percentage_diff_by_year_district for ax in axes.flatten(): - ax.set_ylim(y_min*18, y_max) + ax.set_ylim(y_min, y_max*19) handles, labels = ax.get_legend_handles_labels() fig.legend(handles, labels, bbox_to_anchor=(1, -10), loc = "center right", fontsize=10, title="Districts") plt.tight_layout() @@ -451,31 +460,34 @@ percentage_diff_by_district_historical = historical_predictions_sum.groupby('District')['Percentage_Difference'].mean() malawi_admin2['Percentage_Difference_historical'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district_historical) malawi_admin2.loc[malawi_admin2['Percentage_Difference_historical'] > 0, 'Percentage_Difference_historical'] = 0 +malawi_admin2['Percentage_Difference_historical'] = malawi_admin2['Percentage_Difference_historical'].abs() # for mapping, to show % + percentage_diff_by_district_historical_average = historical_predictions_sum['Percentage_Difference'].mean() -print(malawi_admin2) filtered_predictions = historical_predictions[historical_predictions['Precipitation'] >= precipitation_threshold] filtered_predictions_sum = filtered_predictions.groupby('Year').sum().reset_index() percent_due_to_extreme = filtered_predictions_sum['Difference_in_Expectation'].sum() percent_due_to_extreme = percent_due_to_extreme/historical_predictions['Difference_in_Expectation'].sum() print(percent_due_to_extreme) fig, ax = plt.subplots(figsize=(10, 10)) +water_bodies.plot(ax=ax, facecolor="none", edgecolor="#999999", linewidth=0.5, hatch="xxx") +water_bodies.plot(ax=ax, facecolor="none", edgecolor="black", linewidth=1) malawi_admin2.dropna(subset=['Percentage_Difference_historical']).plot( ax=ax, column='Percentage_Difference_historical', - cmap='Blues_r', + cmap='Blues', edgecolor='black', alpha=1, legend=False, vmin=global_min, - vmax=0 + vmax=global_max ) ax.set_ylabel("Latitude", fontsize=10) ax.set_xlabel("Longitude", fontsize=10) sm = plt.cm.ScalarMappable( - cmap='Blues_r', + cmap='Blues', norm=mcolors.Normalize(vmin=global_min, vmax=global_max) ) sm.set_array([]) @@ -497,34 +509,31 @@ historical_predictions_negative_sum['Difference_in_Expectation'] / historical_predictions_negative_sum[ 'Predicted_No_Weather_Model']) # Match birth results and predictions -matching_rows_historical = min(len(births_model_subset_historical), len(historical_predictions_negative_sum)) -multiplied_values = births_model_subset_historical.head(matching_rows_historical).iloc[1:15, 1].values * historical_predictions_negative_sum[ - 'Percentage_Difference'].head(matching_rows_historical).values * 1.4 # 1.4 is conversion from births to pregnacnies +multiplied_values_historical = births_model_subset_historical.values * historical_predictions_negative_sum[ + 'Percentage_Difference'].values * 1.4 # 1.4 is conversion from births to pregnacnies # Check for negative values (missed cases?) -negative_sum_historical = np.sum(multiplied_values[multiplied_values < 0]) +negative_sum_historical = np.sum(multiplied_values_historical[multiplied_values_historical < 0]) # now do extreme precipitation by district and year, use original dataframe to get monthly top 10% precip filtered_predictions_historical = historical_predictions_negative[historical_predictions_negative['Precipitation'] >= precipitation_threshold] filtered_predictions_sum_historical = filtered_predictions_historical.groupby('Year').sum().reset_index() percent_due_to_extreme_historical = filtered_predictions_sum_historical['Difference_in_Expectation'] / historical_predictions_negative_sum['Predicted_No_Weather_Model'] print(percent_due_to_extreme_historical) -multiplied_values_extreme_precip_historical = births_model_subset_historical.head(matching_rows_historical).iloc[:, 1].values * percent_due_to_extreme_historical.head(matching_rows).values * 1.4 +multiplied_values_extreme_precip_historical = births_model_subset_historical.values * percent_due_to_extreme_historical.values * 1.4 negative_sum_extreme_precip_historical = np.sum(multiplied_values_extreme_precip_historical[multiplied_values_extreme_precip_historical < 0]) result_df_historical = pd.DataFrame({ "Negative_Sum": [negative_sum_historical], - "Negative_Percentage": [negative_sum_historical / (births_model_subset_historical['Model_mean'].sum() * 1.4) * 100], + "Negative_Percentage": [negative_sum_historical / (births_model_subset_historical.sum() * 1.4) * 100], "Extreme_Precip": [negative_sum_extreme_precip_historical], "Extreme_Precip_Percentage": [(negative_sum_extreme_precip_historical / negative_sum_historical) * 100] }) # Save multiplied values by model and scenario multiplied_values_df_historical = pd.DataFrame({ - 'Year': year_range[:matching_rows], - 'Scenario': scenario, - 'Model_Type': model_type, - 'Multiplied_Values': multiplied_values, - 'Multiplied_Values_extreme_precip': multiplied_values_extreme_precip + 'Year': range(2012, 2025), + 'Multiplied_Values': multiplied_values_historical, + 'Multiplied_Values_extreme_precip': multiplied_values_extreme_precip_historical }) multiplied_values_df_historical.to_csv(results_folder_to_save/f'multiplied_values_historical.csv', index=False) From ea08aaf6a260f90fdca068d9ee0173a6ba605e5b Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 12 Feb 2025 11:47:16 +0000 Subject: [PATCH 247/291] Added Lake Malawi --- src/scripts/climate_change/plot_raw_reanalysis_data.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/scripts/climate_change/plot_raw_reanalysis_data.py b/src/scripts/climate_change/plot_raw_reanalysis_data.py index fdf7cd2cfd..dea18a1928 100644 --- a/src/scripts/climate_change/plot_raw_reanalysis_data.py +++ b/src/scripts/climate_change/plot_raw_reanalysis_data.py @@ -27,6 +27,7 @@ "/Users/rem76/PycharmProjects/TLOmodel/resources/mapping/ResourceFile_mwi_admbnda_adm1_nso_20181016.shp") malawi_admin2 = gpd.read_file( "/Users/rem76/PycharmProjects/TLOmodel/resources/mapping/ResourceFile_mwi_admbnda_adm2_nso_20181016.shp") +water_bodies = gpd.read_file("/Users/rem76/Desktop/Climate_change_health/Data/Water_Supply_Control-Rivers-shp/Water_Supply_Control-Rivers.shp") difference_lat = lat_data[1] - lat_data[0] # as is a grid, the difference is the same for all sequential coordinates difference_long = long_data[1] - long_data[0] @@ -52,6 +53,9 @@ # Corrected part for processing model files nc_file_directory = "/path/to/your/nc_files" # Define this correctly fig, ax = plt.subplots(figsize=(10, 10)) # Ensure you create the axis before plotting +water_bodies.plot(ax=ax, facecolor="none", edgecolor="#999999", linewidth=0.5, hatch="xxx") +water_bodies.plot(ax=ax, facecolor="none",edgecolor='#1C6E8C', alpha=0.4, linewidth=1) + for idx, file in enumerate(glob.glob(os.path.join(nc_file_directory, "*.nc"))): data_per_model = Dataset(file, mode='r') pr_data_model = data_per_model.variables['pr'][:] # in kg m-2 s-1 = mm s-1 x 86400 to get to day From 5d867c19991e843b5c63ac09292886c9afc0f161 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 13 Feb 2025 11:03:27 +0000 Subject: [PATCH 248/291] Add in LR test --- ...al_realtionship_reporting_precipitation.py | 22 ++++++++++++++++++- 1 file changed, 21 insertions(+), 1 deletion(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 3a2fe736ac..3c5eceea41 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -8,7 +8,7 @@ from sklearn.preprocessing import StandardScaler from statsmodels.stats.outliers_influence import variance_inflation_factor from sklearn.feature_selection import SelectKBest, f_regression - +import scipy.stats as stats ANC = True Inpatient = False if ANC: @@ -609,6 +609,26 @@ def repeat_info(info, num_facilities, year_range, historical): }) full_data_weather_predictions_historical.to_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/results_of_model_historical_predictions_{service}.csv') +############## LR ######################################### + +# Extract log-likelihood values +log_likelihood_null = results.llf # Null model +log_likelihood_full = results_of_weather_model.llf # Full model + +LR_stat = -2 * (log_likelihood_null - log_likelihood_full) +df = len(results_of_weather_model.params) - len(results.params) +p_value = 1 - stats.chi2.cdf(LR_stat, df) + +# Print results +print(f"Likelihood Ratio Test Statistic: {LR_stat:.4f}") +print(f"Degrees of Freedom: {df}") +print(f"P-value: {p_value:.4f}") + +# Interpretation +if p_value < 0.05: + print("The full model is significantly better than the null model (p < 0.05).") +else: + print("No significant improvement by adding weather variables.") ############### ADD IN CMIP DATA ########################### def get_weather_data(ssp_scenario, model_type): From 249d5c984e370919fe0c7fd8af20078455bb6179 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 14 Feb 2025 08:51:19 +0000 Subject: [PATCH 249/291] Added in summary based on zone --- src/scripts/climate_change/cohort_model.py | 156 ++++++++++++++++++--- 1 file changed, 136 insertions(+), 20 deletions(-) diff --git a/src/scripts/climate_change/cohort_model.py b/src/scripts/climate_change/cohort_model.py index 7706961116..1cda9ee778 100644 --- a/src/scripts/climate_change/cohort_model.py +++ b/src/scripts/climate_change/cohort_model.py @@ -258,7 +258,11 @@ # #### Now do number of births based on the TLO model and 2018 census population_file = "/Users/rem76/PycharmProjects/TLOmodel/resources/demography/ResourceFile_PopulationSize_2018Census.csv" population_data = pd.read_csv(population_file) - +population_data = population_data.merge( + predictions_from_cmip[['District', 'Zone']], # need for larger aggregation, equivalent to zones. also invariant across scenarios + on='District', + how='left' +) population_data_grouped = population_data.groupby("District")["Count"].sum() total_population = population_data_grouped.sum() population_proportion = population_data_grouped / total_population @@ -330,33 +334,33 @@ ax = axes[i, j] data_for_plot.plot(kind='bar', stacked=True, ax=ax, cmap='tab20', legend=False) - ax.set_title(f"{scenario}: {model_type}", fontsize=10) + #ax.set_title(f"{scenario}: {model_type}", fontsize=10) if i == len(scenarios) - 1: ax.set_xlabel('Year', fontsize=12) if j == 0: - ax.set_ylabel(f'Deficit of {service} services', fontsize=12) + ax.set_ylabel(f'Distruption of {service} services', fontsize=10) #if (i == 0) & (j == 2): # ax.legend(title="Districts", fontsize=10, title_fontsize=10, bbox_to_anchor=(1., 1)) percentage_diff_by_year_district_all[scenario][model_type] = percentage_diff_by_year_district for ax in axes.flatten(): - ax.set_ylim(y_min*11, y_max) + ax.set_ylim(y_min, y_max*19) + +for j, model_type in enumerate(["Lowest", "Mean", "Highest"]): + axes[0, j].set_title(model_type, fontsize=14, fontweight='bold') +for i, scenario in enumerate(scenarios): + axes[i, 0].annotate(scenario, xy=(-0.3, 0.5), xycoords="axes fraction", + fontsize=14, fontweight='bold', ha='center', va='center', rotation=90) + handles, labels = ax.get_legend_handles_labels() fig.legend(handles, labels, bbox_to_anchor=(1, -10), loc = "center right", fontsize=10, title="Districts") -plt.tight_layout() +#plt.tight_layout() plt.savefig(results_folder_to_save / 'stacked_bar_percentage_difference_5_years_grid_single_legend_with_births.png') #plt.show() -# +# # # ## % of cases that occur due to being in the top 10 percet? # #### Now do number of births based on the TLO model and 2018 census -population_file = "/Users/rem76/PycharmProjects/TLOmodel/resources/demography/ResourceFile_PopulationSize_2018Census.csv" -population_data = pd.read_csv(population_file) - -population_data_grouped = population_data.groupby("District")["Count"].sum() -total_population = population_data_grouped.sum() -population_proportion = population_data_grouped / total_population - # Create the figure and axes grid fig, axes = plt.subplots(3, 3, figsize=(18, 18)) y_min = float('inf') @@ -393,11 +397,11 @@ predictions_from_cmip_sum.loc[ predictions_from_cmip_sum['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 predictions_from_cmip_sum['Percentage_Difference'] = predictions_from_cmip_sum['Percentage_Difference'].abs() # for mapping, to show % - predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} ) + for year in year_groupings: subset = predictions_from_cmip_sum[ (predictions_from_cmip_sum['Year'] >= year) & @@ -424,24 +428,119 @@ ax = axes[i, j] data_for_plot.plot(kind='bar', stacked=True, ax=ax, cmap='tab20', legend=False) - ax.set_title(f"{scenario}: {model_type}", fontsize=10) + #ax.set_title(f"{scenario}: {model_type}", fontsize=10) if i == len(scenarios) - 1: - ax.set_xlabel('Year', fontsize=12) + ax.set_xlabel('Year', fontsize=10) if j == 0: - ax.set_ylabel(f'Deficit of {service} services', fontsize=12) + ax.set_ylabel(f'Distruption of {service} services per 1,000 pregnancies', fontsize=12) #if (i == 0) & (j == 2): # ax.legend(title="Districts", fontsize=10, title_fontsize=10, bbox_to_anchor=(1., 1)) percentage_diff_by_year_district_all[scenario][model_type] = percentage_diff_by_year_district for ax in axes.flatten(): ax.set_ylim(y_min, y_max*19) handles, labels = ax.get_legend_handles_labels() -fig.legend(handles, labels, bbox_to_anchor=(1, -10), loc = "center right", fontsize=10, title="Districts") -plt.tight_layout() + +for j, model_type in enumerate(["Lowest", "Mean", "Highest"]): + axes[0, j].set_title(model_type, fontsize=14, fontweight='bold') +for i, scenario in enumerate(scenarios): + axes[i, 0].annotate(scenario, xy=(-0.3, 0.5), xycoords="axes fraction", + fontsize=14, fontweight='bold', ha='center', va='center', rotation=90) +#plt.tight_layout() plt.savefig(results_folder_to_save / 'stacked_bar_percentage_difference_5_years_grid_single_legend_with_births_per_1000.png') #plt.show() # # +# #### By zone + +population_data_grouped_zone = population_data.groupby("Zone")["Count"].sum() +population_proportion_zone = population_data_grouped_zone / total_population + +# Create the figure and axes grid +fig, axes = plt.subplots(3, 3, figsize=(18.5, 18)) +y_min = float('inf') +y_max = float('-inf') +x_min = float('inf') +x_max = float('-inf') +percentage_diff_by_year_zone_all = {} +percentage_diff_by_year_zone_scenario = {} +year_groupings = range(2025, 2060, 5) +for i, scenario in enumerate(scenarios): + percentage_diff_by_year_zone_all[scenario] = {} + percentage_diff_by_year_zone_scenario[scenario] = {} + + for j, model_type in enumerate(model_types): + percentage_diff_by_year_zone_all[scenario][model_type] = {} + percentage_diff_by_year_zone_scenario[scenario][model_type] = {} + percentage_diff_by_year_zone_scenario[scenario][model_type] = 0 + + percentage_diff_by_year_zone = {} + + predictions_from_cmip = predictions_from_cmip.loc[predictions_from_cmip['Difference_in_Expectation'] < 0] + predictions_from_cmip_sum = predictions_from_cmip_sum[predictions_from_cmip_sum['Year'] <= 2061] + + predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'Zone']).sum().reset_index() + predictions_from_cmip_sum = predictions_from_cmip_sum[predictions_from_cmip_sum['Year'] <= 2060] + predictions_from_cmip_sum['Percentage_Difference'] = ( + predictions_from_cmip_sum[ + 'Difference_in_Expectation'] / + predictions_from_cmip_sum['Predicted_No_Weather_Model']) + predictions_from_cmip_sum.loc[ + predictions_from_cmip_sum['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 + predictions_from_cmip_sum['Percentage_Difference'] = predictions_from_cmip_sum['Percentage_Difference'].abs() # for mapping, to show % + + predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace( + {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} + ) + + for year in year_groupings: + subset = predictions_from_cmip_sum[ + (predictions_from_cmip_sum['Year'] >= year) & + (predictions_from_cmip_sum['Year'] <= year + 5) + ] + for _, row in subset.iterrows(): + zone = row['Zone'] + percentage_diff = row['Percentage_Difference'] + row_index = births_model_subset.index.get_loc(year) + + number_of_births = population_data_grouped_zone[zone] * births_model_subset.iloc[row_index]["Model_mean"] + if year not in percentage_diff_by_year_zone: + percentage_diff_by_year_zone[year] = {} + if zone not in percentage_diff_by_year_zone[year]: + percentage_diff_by_year_zone[year][zone] = 0 + percentage_diff_by_year_zone[year][zone] += ((percentage_diff * number_of_births) * 1.4)/(number_of_births*1.4) * 1000 # 1.4 is conversion factor between births and pregancies + percentage_diff_by_year_zone_scenario[scenario][model_type] = (percentage_diff * number_of_births) * 1.4 + + data_for_plot = pd.DataFrame.from_dict(percentage_diff_by_year_zone, orient='index').fillna(0) + y_min = min(y_min, data_for_plot.min().min()) + y_max = max(y_max, data_for_plot.max().max()) + x_min = min(x_min, data_for_plot.index.min()) + x_max = max(x_max, data_for_plot.index.max()) + + ax = axes[i, j] + data_for_plot.plot(kind='bar', stacked=True, ax=ax, cmap='tab20', legend=False) + #ax.set_title(f"{scenario}: {model_type}", fontsize=10) + if i == len(scenarios) - 1: + ax.set_xlabel('Year', fontsize=12) + if j == 0: + ax.set_ylabel(f'Deficit of {service} services per 1,000 pregnancies', fontsize=10, labelpad=10) + if (i == 0) & (j == 2): + ax.legend(title="Zones", fontsize=10, title_fontsize=10, ncol = 2) + percentage_diff_by_year_zone_all[scenario][model_type] = percentage_diff_by_year_zone +for ax in axes.flatten(): + ax.set_ylim(y_min, y_max*6) + +for j, model_type in enumerate(["Lowest", "Mean", "Highest"]): + axes[0, j].set_title(model_type, fontsize=14, fontweight='bold') +for i, scenario in enumerate(scenarios): + axes[i, 0].annotate(scenario, xy=(-0.3, 0.5), xycoords="axes fraction", + fontsize=13, fontweight='bold', ha='center', va='center', rotation=90) +plt.subplots_adjust(left=0.12) +#plt.tight_layout() +plt.savefig(results_folder_to_save / 'stacked_bar_percentage_difference_5_years_grid_single_legend_with_births_per_1000_ZONE.png') +#plt.show() +# + ####### Historical disruptions ########## @@ -542,6 +641,20 @@ result_df_historical.to_csv(f'/Users/rem76/Desktop/Climate_change_health/Results/{service}_disruptions/negative_sums_and_percentages_historical.csv', index=False) +####### Effect of CYCLONE FREDDY ####### + +# historical_predictions = pd.read_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/results_of_model_historical_predictions_{service}.csv') +# +# # Filter the dataset for Year == 2023, Month == 2 or 3, and District == 'Blantyre' +# filtered_results = historical_predictions[ +# (historical_predictions['Year'] == 2023) & +# (historical_predictions['Month'].isin([2, 3])) & +# (historical_predictions['District'] == 'Blantyre') +# ] +# +# print(filtered_results) + +################## # Define file paths monthly_reporting_file = "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_ANC_lm.csv" five_day_max_file = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/historical_daily_total_by_facilities_with_ANC_five_day_cumulative.csv" @@ -606,6 +719,9 @@ def filter_top_20_percent(values): axes[0, 0].legend() axes[0, 1].legend() -plt.tight_layout() +#plt.tight_layout() plt.show() plt.savefig(f"/Users/rem76/Desktop/Climate_change_health/Data/historical_vs_future_precipitation_ANC.png") + + + From 73e68058f8996b61a2f3c4388662bd1e96db521f Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 14 Feb 2025 08:51:34 +0000 Subject: [PATCH 250/291] format --- ...r_model_historical_realtionship_reporting_precipitation.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 3c5eceea41..58b0579519 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -311,7 +311,7 @@ def repeat_info(info, num_facilities, year_range, historical): X_categorical = np.column_stack([ resid_encoded, zone_encoded, - #dist_encoded, + dist_encoded, owner_encoded, #ftype_encoded, #facility_encoded, @@ -466,7 +466,7 @@ def repeat_info(info, num_facilities, year_range, historical): X_categorical = np.column_stack([ resid_encoded, zone_encoded, - #dist_encoded, + dist_encoded, owner_encoded, #ftype_encoded, #facility_encoded, From c97a49c91324af9d00adefd6259692514f724a60 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 14 Feb 2025 08:51:53 +0000 Subject: [PATCH 251/291] added new years --- .../climate_change/data_retrieval_ERA5_reanalysis_daily.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py b/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py index a4aea25bb2..f582d71cd1 100644 --- a/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py +++ b/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py @@ -4,6 +4,8 @@ years = ["2011", "2012", "2013", "2014", "2015", "2016", "2017", "2018", "2019", "2020", "2021", "2022", "2023", "2024"] +years = range(1940, 1990) +years = [str(year) for year in range(1940, 1990)] base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total" for year in years: From 11aef2a98a8d3934ae381cb057af2fb9f30d69c0 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 14 Feb 2025 14:48:18 +0000 Subject: [PATCH 252/291] added new years --- .../climate_change/data_retrieval_ERA5_reanalysis_daily.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py b/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py index f582d71cd1..f7e12b4ce4 100644 --- a/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py +++ b/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_daily.py @@ -4,7 +4,7 @@ years = ["2011", "2012", "2013", "2014", "2015", "2016", "2017", "2018", "2019", "2020", "2021", "2022", "2023", "2024"] -years = range(1940, 1990) +years = range(1962, 1990) years = [str(year) for year in range(1940, 1990)] base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total" From e29b6881474aff6e2d7e6f5e379ce0d79eecf5ad Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 14 Feb 2025 14:48:55 +0000 Subject: [PATCH 253/291] extracted years to compare with Cyclone Freddy paper --- src/scripts/climate_change/cohort_model.py | 58 +++++++++++++++++----- 1 file changed, 46 insertions(+), 12 deletions(-) diff --git a/src/scripts/climate_change/cohort_model.py b/src/scripts/climate_change/cohort_model.py index 1cda9ee778..312cc05676 100644 --- a/src/scripts/climate_change/cohort_model.py +++ b/src/scripts/climate_change/cohort_model.py @@ -80,7 +80,7 @@ difference_lat = lat_data[1] - lat_data[0] difference_long = long_data[1] - long_data[0] -# # Get expected disturbance from the model +# # # Get expected disturbance from the model results_list = [] @@ -641,18 +641,52 @@ result_df_historical.to_csv(f'/Users/rem76/Desktop/Climate_change_health/Results/{service}_disruptions/negative_sums_and_percentages_historical.csv', index=False) -####### Effect of CYCLONE FREDDY ####### +###### Effect of CYCLONE FREDDY ####### + +historical_predictions = pd.read_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/results_of_model_historical_predictions_{service}.csv') + + +def calculate_percentage_difference(historical_predictions, year, zone=None): + months = [1, 2, 3] + filtered_data = { + month: historical_predictions[ + (historical_predictions['Year'] == year) & (historical_predictions['Month'] == month) + & ((historical_predictions['Zone'] == zone) if zone else True) + ] + for month in months + } + + for month in months[1:]: + if not filtered_data[1].empty and not filtered_data[month].empty: + total_1 = filtered_data[1]['Predicted_Weather_Model'].sum() + total_n = filtered_data[month]['Predicted_Weather_Model'].sum() + percent_difference = ((total_1 - total_n) / total_1) * 100 + print(f"Percentage Difference January and {month} for {zone}: {percent_difference:.2f}%") + else: + print(f"One of the datasets for January or {month} is empty, cannot compute percentage difference.") + + +# Run the function for different zones +calculate_percentage_difference(historical_predictions, 2023, 'South East') +calculate_percentage_difference(historical_predictions, 2023, 'South West') +calculate_percentage_difference(historical_predictions, 2023) # Without zone filter + +### +historical_predictions_negative_freddy = historical_predictions.loc[historical_predictions['Difference_in_Expectation'] < 0] +historical_predictions_negative_freddy = historical_predictions_negative_freddy[historical_predictions_negative_freddy['Year'] == 2023] +historical_predictions_negative_freddy = historical_predictions_negative_freddy[historical_predictions_negative_freddy['Zone'] == "South West"] +historical_predictions_negative_freddy_feb = historical_predictions_negative_freddy[ + historical_predictions_negative_freddy['Month'].isin([2]) +] +print("February mean:", historical_predictions_negative_freddy_feb['Difference_in_Expectation'].mean()) +print("February max:", historical_predictions_negative_freddy_feb['Difference_in_Expectation'].min()) + +historical_predictions_negative_freddy_march = historical_predictions_negative_freddy[ + historical_predictions_negative_freddy['Month'].isin([3]) +] +print("March mean:", historical_predictions_negative_freddy_march['Difference_in_Expectation'].mean(skipna=True)) +print("March max:", historical_predictions_negative_freddy_march['Difference_in_Expectation'].min(skipna=True)) -# historical_predictions = pd.read_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/results_of_model_historical_predictions_{service}.csv') -# -# # Filter the dataset for Year == 2023, Month == 2 or 3, and District == 'Blantyre' -# filtered_results = historical_predictions[ -# (historical_predictions['Year'] == 2023) & -# (historical_predictions['Month'].isin([2, 3])) & -# (historical_predictions['District'] == 'Blantyre') -# ] -# -# print(filtered_results) ################## # Define file paths From 5a6203a1cd0327a68b1808c21f4adcc9d96f4422 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 17 Feb 2025 08:09:25 +0000 Subject: [PATCH 254/291] Added processing and saving of pre-2000 data --- .../process_daily_total_historical_data.py | 50 +++++++++++++------ 1 file changed, 36 insertions(+), 14 deletions(-) diff --git a/src/scripts/climate_change/process_daily_total_historical_data.py b/src/scripts/climate_change/process_daily_total_historical_data.py index bbdb9543d4..d4d87311d9 100644 --- a/src/scripts/climate_change/process_daily_total_historical_data.py +++ b/src/scripts/climate_change/process_daily_total_historical_data.py @@ -58,6 +58,8 @@ base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total" years = range(2011, 2025) +#years = range(1940, 1980) + month_lengths = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] max_average_by_grid = {} @@ -94,7 +96,10 @@ df = pd.DataFrame.from_dict(max_average_by_grid, orient='index') df = df.T -df.to_csv(Path(base_dir)/"historical_daily_total_by_grid.csv") +if max(years) < 2000: + df.to_csv(Path(base_dir)/f"historical_{min(years)}_{max(years)}_daily_total_by_grid.csv") +else: + df.to_csv(Path(base_dir)/"historical_daily_total_by_grid.csv") ########## add in reporting data ################## @@ -152,20 +157,37 @@ df_of_facilities = df_of_facilities.iloc[:, :-3] ## THESE ARE OCT/NOV/DEC OF 2024, and for moment don't have that reporting data df_of_facilities = df_of_facilities.T - -if five_day: - if cumulative: - if ANC: - df_of_facilities.to_csv(Path(base_dir) / "historical_daily_total_by_facilities_with_ANC_five_day_cumulative.csv") +if max(years) > 2000: + if five_day: + if cumulative: + if ANC: + df_of_facilities.to_csv(Path(base_dir) / "historical_daily_total_by_facilities_with_ANC_five_day_cumulative.csv") + else: + df_of_facilities.to_csv(Path(base_dir) / "historical_daily_total_by_facility_five_day_cumulative_inpatient.csv") else: - df_of_facilities.to_csv(Path(base_dir) / "historical_daily_total_by_facility_five_day_cumulative_inpatient.csv") + if ANC: + df_of_facilities.to_csv(Path(base_dir) / "historical_daily_total_by_facilities_with_ANC_five_day_average.csv") + else: + df_of_facilities.to_csv(Path(base_dir) / "historical_daily_total_by_facility_five_day_average_inpatient.csv") else: - if ANC: - df_of_facilities.to_csv(Path(base_dir) / "historical_daily_total_by_facilities_with_ANC_five_day_average.csv") - else: - df_of_facilities.to_csv(Path(base_dir) / "historical_daily_total_by_facility_five_day_average_inpatient.csv") + if ANC: + df_of_facilities.to_csv(Path(base_dir) / "historical_daily_total_by_facilities_with_ANC.csv") + else: + df_of_facilities.to_csv(Path(base_dir) / "historical_daily_total_by_facility_inpatient.csv") else: - if ANC: - df_of_facilities.to_csv(Path(base_dir) / "historical_daily_total_by_facilities_with_ANC.csv") + if five_day: + if cumulative: + if ANC: + df_of_facilities.to_csv(Path(base_dir) / f"historical_{min(years)}_{max(years)}_daily_total_by_facilities_with_ANC_five_day_cumulative.csv") + else: + df_of_facilities.to_csv(Path(base_dir) / f"historical_{min(years)}_{max(years)}_daily_total_by_facility_five_day_cumulative_inpatient.csv") else: - df_of_facilities.to_csv(Path(base_dir) / "historical_daily_total_by_facility_inpatient.csv") + if ANC: + df_of_facilities.to_csv(Path(base_dir) / f"historical_{min(years)}_{max(years)}_daily_total_by_facilities_with_ANC_five_day_average.csv") + else: + df_of_facilities.to_csv(Path(base_dir) / f"historical_{min(years)}_{max(years)}_daily_total_by_facility_five_day_average_inpatient.csv") + else: + if ANC: + df_of_facilities.to_csv(Path(base_dir) / f"historical_{min(years)}_{max(years)}_daily_total_by_facilities_with_ANC.csv") + else: + df_of_facilities.to_csv(Path(base_dir) / f"historical_{min(years)}_{max(years)}_daily_total_by_facility_inpatient.csv") From 8c08a8d30bdd5273425b74b96c117f6013b89002 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 17 Feb 2025 08:20:02 +0000 Subject: [PATCH 255/291] Added processing and saving of pre-2000 data --- .../climate_change/process_daily_total_historical_data.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/scripts/climate_change/process_daily_total_historical_data.py b/src/scripts/climate_change/process_daily_total_historical_data.py index d4d87311d9..25691004e5 100644 --- a/src/scripts/climate_change/process_daily_total_historical_data.py +++ b/src/scripts/climate_change/process_daily_total_historical_data.py @@ -7,7 +7,7 @@ import pandas as pd from netCDF4 import Dataset -ANC = False +ANC = True # facility data multiplier = 1000 five_day = False @@ -57,8 +57,8 @@ # historical weather directory base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total" -years = range(2011, 2025) -#years = range(1940, 1980) +#years = range(2011, 2025) +years = range(1940, 1980) month_lengths = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] max_average_by_grid = {} From 49470a1ae9e81c6983bb73ecaaa14345fa96cdfa Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 17 Feb 2025 08:25:18 +0000 Subject: [PATCH 256/291] Added retrieval of baseline data --- .../data_retrieval_ERA5_reanalysis_monthly.py | 18 +++++++++++------- 1 file changed, 11 insertions(+), 7 deletions(-) diff --git a/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_monthly.py b/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_monthly.py index 1ddcf261de..9b038cdf9b 100644 --- a/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_monthly.py +++ b/src/scripts/climate_change/data_retrieval_ERA5_reanalysis_monthly.py @@ -5,16 +5,20 @@ base_dir = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/monthly_data" os.chdir(base_dir) dataset = "reanalysis-era5-single-levels-monthly-means" +years = range(1940, 1980) +years = [str(year) for year in range(1940, 1980)] + request = { "product_type": ["monthly_averaged_reanalysis"], "variable": ["total_precipitation"], - "year": [ - "2011", "2012", "2013", - "2014", "2015", "2016", - "2017", "2018", "2019", - "2020", "2021", "2022", - "2023", "2024" - ], + # "year": [ + # "2011", "2012", "2013", + # "2014", "2015", "2016", + # "2017", "2018", "2019", + # "2020", "2021", "2022", + # "2023", "2024" + # ], + "year": years, "month": [ "01", "02", "03", "04", "05", "06", From 7df6eb35232f0fe576674f612f79e921c1a50c9d Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 17 Feb 2025 08:35:43 +0000 Subject: [PATCH 257/291] Added in processing of baseline data (from ERA5, earliest is 1940) --- ...d_monthly_weather_data_small_facilities.py | 66 ++++++++++++++----- 1 file changed, 49 insertions(+), 17 deletions(-) diff --git a/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py b/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py index 10fd5e3f02..ed595ff842 100644 --- a/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py +++ b/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py @@ -9,9 +9,10 @@ # Data accessed from https://dhis2.health.gov.mw/dhis-web-data-visualizer/#/YiQK65skxjz # Reporting rate is expected reporting vs actual reporting -ANC = False -Inpatient = True +ANC = True +Inpatient = False multiplier = 1000 +baseline = True if ANC: reporting_data = pd.read_csv('/Users/rem76/Desktop/Climate_change_health/Data/ANC_data/ANC_data_2011_2024.csv') elif Inpatient: @@ -48,7 +49,10 @@ monthly_reporting_by_facility["facility"] = reporting_data["organisationunitname"].values # Weather data -directory = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/monthly_data" # from 2011 on +if baseline: + directory = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/monthly_data/Baseline" # from 2011 on +else: + directory = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/monthly_data" # from 2011 on malawi_grid = gpd.read_file("/Users/rem76/Desktop/Climate_change_health/Data/malawi_grid.shp") # find indices of interest from the malawi file @@ -59,12 +63,12 @@ file_path = os.path.join(directory, file) # Open the NetCDF file - unsure of name, should only be one though weather_monthly_all_grids = Dataset(file_path, mode='r') + print(weather_monthly_all_grids) # the historical data is at a different resolution to the projections. so try and find the closest possible indicses # to create a new grid for the historical data pr_data = weather_monthly_all_grids.variables['tp'][:] # total precipitation in kg m-2 s-1 = mm s-1 x 86400 to get to day lat_data = weather_monthly_all_grids.variables['latitude'][:] long_data = weather_monthly_all_grids.variables['longitude'][:] -date = weather_monthly_all_grids['date'][:] grid = 0 regridded_weather_data = {} days_in_month = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] @@ -141,17 +145,34 @@ monthly_reporting_by_facility = monthly_reporting_by_facility[facilities_with_location] #monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm.csv") -if ANC: - monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_ANC_by_smaller_facility_lm.csv") - weather_df.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_ANC_lm.csv") -if Inpatient: - monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_Inpatient_by_smaller_facility_lm.csv") - weather_df.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_Inpatient_lm.csv") +if baseline: + if ANC: + monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_ANC_by_smaller_facility_lm.csv") + weather_df.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_ANC_lm.csv") + if Inpatient: + monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_Inpatient_by_smaller_facility_lm.csv") + weather_df.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_Inpatient_lm.csv") + else: + monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm.csv") + weather_df.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facility_lm.csv") else: - monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm.csv") - weather_df.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facility_lm.csv") + if ANC: + monthly_reporting_by_facility.to_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_ANC_by_smaller_facility_lm_baseline.csv") + weather_df.to_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_ANC_lm_baseline.csv") + if Inpatient: + monthly_reporting_by_facility.to_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_Inpatient_by_smaller_facility_lm_baseline.csv") + weather_df.to_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_Inpatient_lm_baseline.csv") + else: + monthly_reporting_by_facility.to_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm_baseline.csv") + weather_df.to_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facility_lm_baseline.csv") for facility in facilities_with_location: print(facility) @@ -190,12 +211,23 @@ ) expanded_facility_info = expanded_facility_info.T expanded_facility_info = expanded_facility_info.reindex(columns=facilities_with_location) -if ANC: - expanded_facility_info.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_with_ANC.csv") -elif Inpatient: - expanded_facility_info.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_with_inpatient_days.csv") +if baseline: + if ANC: + expanded_facility_info.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_with_ANC_baseline.csv") + elif Inpatient: + expanded_facility_info.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_with_inpatient_days_baseline.csv") + else: + expanded_facility_info.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_baseline.csv") else: - expanded_facility_info.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm.csv") + if ANC: + expanded_facility_info.to_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_with_ANC_baseline.csv") + elif Inpatient: + expanded_facility_info.to_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_with_inpatient_days_baseline.csv") + else: + expanded_facility_info.to_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_baseline.csv") From a239922221a972f4039ae872ec54484d6a99b1ea Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 17 Feb 2025 08:37:55 +0000 Subject: [PATCH 258/291] Typo --- ...ng_and_monthly_weather_data_small_facilities.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py b/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py index ed595ff842..58eeca9b28 100644 --- a/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py +++ b/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py @@ -12,7 +12,7 @@ ANC = True Inpatient = False multiplier = 1000 -baseline = True +baseline = False if ANC: reporting_data = pd.read_csv('/Users/rem76/Desktop/Climate_change_health/Data/ANC_data/ANC_data_2011_2024.csv') elif Inpatient: @@ -147,15 +147,15 @@ #monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm.csv") if baseline: if ANC: - monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_ANC_by_smaller_facility_lm.csv") - weather_df.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_ANC_lm.csv") + monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_ANC_by_smaller_facility_lm_baseline.csv") + weather_df.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_ANC_lm_baseline.csv") if Inpatient: - monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_Inpatient_by_smaller_facility_lm.csv") - weather_df.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_Inpatient_lm.csv") + monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_Inpatient_by_smaller_facility_lm_baseline.csv") + weather_df.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_Inpatient_lm_baseline.csv") else: - monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm.csv") - weather_df.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facility_lm.csv") + monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm_baseline.csv") + weather_df.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facility_lm_baseline.csv") else: if ANC: monthly_reporting_by_facility.to_csv( From 652afe7803635fead945394abd430097bc660b29 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 17 Feb 2025 09:44:12 +0000 Subject: [PATCH 259/291] Baseline data from 1940 - 1980 --- ...al_realtionship_reporting_precipitation.py | 206 ++++++++++++++++++ 1 file changed, 206 insertions(+) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 58b0579519..d0af3d23f2 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -30,6 +30,10 @@ mask_threshold = -np.inf # accounts for scaling #mask_threshold = 50 use_percentile_mask_threshold = True +baseline_years = range(1940, 1979) +min_year_for_analysis_baseline = min(baseline_years) +absolute_min_year_baseline = min_year_for_analysis_baseline - 1 +max_year_for_analysis_baseline = max(baseline_years) + 1 poisson = False log_y = True @@ -148,6 +152,15 @@ def repeat_info(info, num_facilities, year_range, historical): else: return repeated_info # + +def process_weather_data(weather_df, zero_sum_columns, min_year_for_analysis, absolute_min_year, lags=[1, 2, 3, 4, 9, 12]): + """ + Processes weather data by dropping zero-sum columns, computing lags, and flattening. + """ + weather_df = weather_df.drop(columns=zero_sum_columns, errors='ignore').iloc[:-(2 if 'monthly' in weather_df.columns else 1)] + lags_data = {lag: weather_df.shift(lag).values[(min_year_for_analysis - absolute_min_year) * 12:].flatten() for lag in lags} + return weather_df.iloc[(min_year_for_analysis - absolute_min_year) * 12:], lags_data + ### Try combine weather variables ## if use_all_weather: if ANC: @@ -874,3 +887,196 @@ def get_weather_data(ssp_scenario, model_type): +################# Semi-post industrial, pre-2000 data ################# +if ANC: + # Load data + weather_data_monthly_20th_century = pd.read_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_ANC_lm_baseline.csv", + index_col=0 + ) + + weather_data_five_day_cumulative_20th_century = pd.read_csv( + f"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/historical_{min(baseline_years)}_{max(baseline_years)}_daily_total_by_facilities_with_ANC_five_day_cumulative.csv", + index_col=0 + ) + + # Drop zero-sum columns + weather_data_monthly_20th_century = weather_data_monthly_20th_century.drop(columns=zero_sum_columns, + errors='ignore') + weather_data_five_day_cumulative_20th_century = weather_data_five_day_cumulative_20th_century.drop( + columns=zero_sum_columns, errors='ignore') + + # lags + lags_monthly_baseline = {i: weather_data_monthly_20th_century.shift(i).values for i in [1, 2, 3, 4, 9, 12]} + for key in lags_monthly_baseline: + lags_monthly_baseline[key] = lags_monthly_baseline[key][(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:].flatten() + + lags_five_day_baseline = {i: weather_data_five_day_cumulative_20th_century.shift(i).values for i in [1, 2, 3, 4, 9]} + for key in lags_five_day_baseline: + lags_five_day_baseline[key] = lags_five_day_baseline[key][(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:].flatten() + # process + weather_data_monthly_20th_century = weather_data_monthly_20th_century.iloc[ + (min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:] + weather_data_five_day_cumulative_20th_century = weather_data_five_day_cumulative_20th_century.iloc[ + (min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:] + + weather_data_monthly_flattened = weather_data_monthly_20th_century.values.flatten() + weather_data_five_day_cumulative_flattened = weather_data_five_day_cumulative_20th_century.values.flatten() + print(len(weather_data_five_day_cumulative_flattened)) + weather_data_baseline = np.vstack( + (weather_data_monthly_flattened, weather_data_five_day_cumulative_flattened)).T + +# covariates +year_range_baseline = range(min_year_for_analysis_baseline, max_year_for_analysis_baseline, 1) +year_repeated_baseline = [y for y in year_range_baseline for _ in range(12)] +year_flattened_baseline = year_repeated_baseline*len(monthly_reporting_by_facility.columns) # to get flattened data +month = range(12) +month_repeated = [] +for _ in year_range: + month_repeated.extend(range(1, 13)) +month_flattened_baseline = month*len(monthly_reporting_by_facility.columns) + +zone_info_each_month_baseline = repeat_info(expanded_facility_info["Zonename"], num_facilities, year_range_baseline, historical = False) +zone_encoded_baseline = pd.get_dummies(zone_info_each_month_baseline, drop_first=True) +dist_info_each_month_baseline = repeat_info(expanded_facility_info["Dist"], num_facilities, year_range_baseline, historical = False) +dist_encoded_baseline = pd.get_dummies(dist_info_each_month_baseline, drop_first=True) +resid_info_each_month_baseline = repeat_info(expanded_facility_info['Resid'], num_facilities, year_range_baseline, historical = False) +resid_encoded_baseline = pd.get_dummies(resid_info_each_month_baseline, drop_first=True) +owner_info_each_month_baseline = repeat_info(expanded_facility_info['A105'], num_facilities, year_range_baseline, historical = False) +owner_encoded_baseline = pd.get_dummies(owner_info_each_month_baseline, drop_first=True) +ftype_info_each_month_baseline = repeat_info(expanded_facility_info['Ftype'], num_facilities, year_range_baseline, historical = False) +ftype_encoded_baseline = pd.get_dummies(ftype_info_each_month_baseline, drop_first=True) +altitude_baseline = [float(x) for x in repeat_info(expanded_facility_info['A109__Altitude'], num_facilities, year_range_baseline, historical = False)] +minimum_distance_baseline = [float(x) for x in repeat_info(expanded_facility_info['minimum_distance'], num_facilities, year_range_baseline, historical = False)] + +altitude_baseline = np.array(altitude_baseline) +altitude_baseline = np.where(altitude_baseline < 0, np.nan, altitude_baseline) +mean_altitude = round(np.nanmean(altitude_baseline)) +altitude_baseline = np.where(np.isnan(altitude_baseline), float(mean_altitude), altitude_baseline) +altitude_baseline = np.nan_to_num(altitude_baseline, nan=mean_altitude, posinf=mean_altitude, neginf=mean_altitude) +altitude_baseline = list(altitude_baseline) + +minimum_distance_baseline = np.nan_to_num(minimum_distance_baseline, nan=np.nan, posinf=np.nan, neginf=np.nan) # just in case + + +X_continuous_baseline = np.column_stack([ + year_flattened_baseline, + month_flattened_baseline, + altitude_baseline, + np.array(minimum_distance_baseline) +]) + +X_categorical_baseline = np.column_stack([ + resid_encoded_baseline, + zone_encoded_baseline, + dist_encoded_baseline, + owner_encoded_baseline, + #ftype_encoded, + #facility_encoded, +]) +scaler = StandardScaler() +X_continuous_scaled_baseline = scaler.fit_transform(X_continuous_baseline) +X_continuous_scaled_baseline = X_continuous_baseline +X_ANC_standardized_baseline = np.column_stack([X_continuous_scaled_baseline, X_categorical_baseline]) +X_basis_weather_filtered_baseline = X_ANC_standardized_baseline[X_ANC_standardized_baseline[:, 0] > mask_threshold] + +X_continuous_baseline = np.column_stack([ + weather_data_baseline, + weather_data_baseline[:,0]*weather_data_baseline[:,0], + weather_data_baseline[:,1] * weather_data_baseline[:,1], + weather_data_baseline[:, 0] * weather_data_baseline[:, 0] * weather_data_baseline[:, 0], + weather_data_baseline[:, 1] * weather_data_baseline[:, 1] * weather_data_baseline[:, 1], + weather_data_baseline[:, 1] * weather_data_baseline[:,0], + np.array(year_flattened_baseline), + np.array(month_flattened_baseline), + lags_monthly_baseline, + lags_monthly_baseline, + np.array(altitude_baseline), + np.array(minimum_distance_baseline)] +) + +X_categorical_baseline = np.column_stack([ + resid_encoded_baseline, + zone_encoded_baseline, + dist_encoded_baseline, + owner_encoded_baseline, + ]) + +scaler = StandardScaler() +X_continuous_scaled_baseline = scaler.fit_transform(X_continuous_baseline) +X_continuous_scaled_baseline = X_continuous_baseline +X_bases_ANC_standardized_baseline = np.column_stack([X_continuous_scaled_baseline, X_categorical_baseline]) +X_bases_ANC_standardized_baseline = X_bases_ANC_standardized_baseline[:, included] +X_basis_weather_filtered_baseline = X_basis_weather_filtered_baseline[:,included_weather] + +predictions_weather_baseline = results_of_weather_model.predict(X_basis_weather_filtered_baseline ) +y_pred_ANC_baseline = results.predict(X_bases_ANC_standardized_baseline) + +predictions_baseline = np.exp(predictions_weather_baseline) - np.exp(y_pred_ANC_baseline[X_basis_weather[:, 0] > mask_threshold]) +year_month_labels_baseline = np.array([f"{y}-{m}" for y, m in zip(X_basis_weather_filtered_baseline[:, 2], X_basis_weather_filtered_baseline[:, 3])]) + +data_weather_predictions_baseline = pd.DataFrame({ + 'Year_Month': year_month_labels_baseline, + 'y_pred_weather': np.exp(predictions_weather_baseline) +}) + +data_weather_predictions_baseline['y_pred_no_weather'] = np.exp(y_pred_ANC_baseline[X_basis_weather[:, 0] > mask_threshold]) + +data_weather_predictions_baseline['difference_in_expectation'] = predictions_baseline +data_weather_predictions_baseline['weather'] = X_basis_weather[X_basis_weather[:, 0] > mask_threshold, 0] +data_weather_predictions_grouped_baseline = data_weather_predictions.groupby('Year_Month').mean().reset_index() + +# Plotting results +fig, axs = plt.subplots(1, 2, figsize=(14, 6)) +# axs[0].scatter(data_weather_predictions['Year_Month'], data_weather_predictions['difference_in_expectation'], color='#9AC4F8', alpha=0.1, label ='Predictions from weather model') +axs[0].scatter(data_weather_predictions_grouped_baseline['Year_Month'], + data_weather_predictions_grouped_baseline['difference_in_expectation'], color='red', alpha=0.7, + label='Mean of predictions') +axs[0].set_xlabel('Year/Month') +xticks = data_weather_predictions_baseline['Year_Month'][::len(year_range) * 12 * num_facilities] +axs[0].set_xticks(xticks) +axs[0].set_xticklabels(xticks, rotation=45, ha='right') +axs[0].set_ylabel(f'Difference Predicted {service} visits due to rainfall') +axs[0].legend(loc='upper left') +plt.show() + +fig, axs = plt.subplots(1, 2, figsize=(14, 6)) + +axs[0].scatter(data_weather_predictions_baseline['weather'], data_weather_predictions_baseline['difference_in_expectation'], + color='#9AC4F8', alpha=0.1, + label='Predictions') + +axs[0].set_xlabel('Precipitation (mm)') +axs[0].set_ylabel(f'Difference in of {service} visits between weather and non-weather model') + +plt.tight_layout() +plt.show() +# Format output: Add all relevant X variables +full_data_weather_predictions = pd.DataFrame({ + 'Year': year_flattened_baseline[X_basis_weather[:, 0] > mask_threshold], + 'Month': np.array(month_flattened_baseline)[X_basis_weather[:, 0] > mask_threshold], + 'Facility_ID': facility_flattened_prediction[X_basis_weather[:, 0] > mask_threshold], + 'Altitude': np.array(altitude_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'Zone': np.array(zone_info_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'District': np.array(dist_info_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'Resid': np.array(resid_info_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'Owner': np.array(owner_info_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'Facility_Type': np.array(ftype_info_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'Precipitation': X_basis_weather[X_basis_weather[:, 0] > mask_threshold, 0], + 'Lag_1_Precipitation': np.array(lag_1_month_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'Lag_2_Precipitation': np.array(lag_2_month_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'Lag_3_Precipitation': np.array(lag_3_month_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'Lag_4_Precipitation': np.array(lag_4_month_prediction)[X_basis_weather[:, 0] > mask_threshold], + 'Predicted_Weather_Model': np.exp(predictions_weather), + 'Predicted_No_Weather_Model': np.exp(y_pred_ANC[X_basis_weather[:, 0] > mask_threshold]), + 'Difference_in_Expectation': predictions, +}) + +# Save the results +full_data_weather_predictions.to_csv(f"{data_path}weather_predictions_with_X_baseline_{service}.csv", + index=False) + +X_basis_weather_filtered = pd.DataFrame(X_basis_weather_filtered) + +# Save to CSV +full_data_weather_predictions.to_csv(f"{data_path}weather_predictions_with_X_baseline_{service}.csv", index=False) From 1b3f4d279a198291ce3336e504265a7350e99be3 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 17 Feb 2025 11:30:51 +0000 Subject: [PATCH 260/291] Fixed indentation errors etc --- ...d_monthly_weather_data_small_facilities.py | 161 ++++++++---------- 1 file changed, 73 insertions(+), 88 deletions(-) diff --git a/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py b/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py index 58eeca9b28..cf63dbf43d 100644 --- a/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py +++ b/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py @@ -12,7 +12,7 @@ ANC = True Inpatient = False multiplier = 1000 -baseline = False +baseline = True if ANC: reporting_data = pd.read_csv('/Users/rem76/Desktop/Climate_change_health/Data/ANC_data/ANC_data_2011_2024.csv') elif Inpatient: @@ -29,16 +29,16 @@ monthly_reporting_data_by_facility = {} if ANC: months = set(col.split("HMIS Total Antenatal Visits ")[1] for col in reporting_data.columns if "HMIS Total Antenatal Visits " in col) -if Inpatient: +elif Inpatient: months = set(col.split("HMIS Total # of Admissions (including Maternity) ")[1] for col in reporting_data.columns if "HMIS Total # of Admissions (including Maternity) " in col) else: months = set(col.split(" - Reporting rate ")[1] for col in reporting_data.columns if " - Reporting rate " in col) -#months = set(col.split("HMIS Total Antenatal Visits ")[1] for col in reporting_data.columns if "HMIS Total Antenatal Visits " in col) # put in order months = [date.strip() for date in months] # extra spaces?? dates = pd.to_datetime(months, format='%B %Y', errors='coerce') months = dates.sort_values().strftime('%B %Y').tolist() # puts them in ascending order +print(reporting_data) for month in months: columns_of_interest_all_metrics = [reporting_data.columns[1]] + reporting_data.columns[reporting_data.columns.str.endswith(month)].tolist() data_of_interest_by_month = reporting_data[columns_of_interest_all_metrics] @@ -50,7 +50,7 @@ # Weather data if baseline: - directory = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/monthly_data/Baseline" # from 2011 on + directory = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/monthly_data/Baseline" # from 1940 - 1980 on else: directory = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/monthly_data" # from 2011 on malawi_grid = gpd.read_file("/Users/rem76/Desktop/Climate_change_health/Data/malawi_grid.shp") @@ -63,12 +63,13 @@ file_path = os.path.join(directory, file) # Open the NetCDF file - unsure of name, should only be one though weather_monthly_all_grids = Dataset(file_path, mode='r') - print(weather_monthly_all_grids) # the historical data is at a different resolution to the projections. so try and find the closest possible indicses # to create a new grid for the historical data pr_data = weather_monthly_all_grids.variables['tp'][:] # total precipitation in kg m-2 s-1 = mm s-1 x 86400 to get to day lat_data = weather_monthly_all_grids.variables['latitude'][:] long_data = weather_monthly_all_grids.variables['longitude'][:] +if not baseline: + date = weather_monthly_all_grids['date'][:] grid = 0 regridded_weather_data = {} days_in_month = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] @@ -122,15 +123,15 @@ precip_total_for_month = precip_data_for_facility[i] * days_in_month[month] * multiplier precip_data_monthly_for_facility.append(precip_total_for_month) weather_data_by_facility[reporting_facility] = precip_data_monthly_for_facility # to get from per second to per day -## below are not in facilities file? + ## below are not in facilities file? elif reporting_facility == "Central East Zone": grid = general_facilities[general_facilities["District"] == "Nkhotakota"]["Grid_Index"].iloc[0] # furtherst east zone weather_data_by_facility[reporting_facility] = weather_by_grid[grid] facilities_with_location.append(reporting_facility) elif (reporting_facility == "Central Hospital"): - grid = general_facilities[general_facilities["District"] == "Lilongwe City"]["Grid_Index"].iloc[0] # all labelled X City will be in the same grid - weather_data_by_facility[reporting_facility] = weather_by_grid[grid] - facilities_with_location.append(reporting_facility) + grid = general_facilities[general_facilities["District"] == "Lilongwe City"]["Grid_Index"].iloc[0] # all labelled X City will be in the same grid + weather_data_by_facility[reporting_facility] = weather_by_grid[grid] + facilities_with_location.append(reporting_facility) else: continue @@ -138,96 +139,80 @@ ### Get data ready for linear regression between reporting and weather data weather_df = pd.DataFrame.from_dict(weather_data_by_facility, orient='index').T weather_df.columns = facilities_with_location -monthly_reporting_by_facility = monthly_reporting_by_facility.set_index('facility').T -monthly_reporting_by_facility.index.name = "date" -# ### Save CSVs -monthly_reporting_by_facility = monthly_reporting_by_facility.loc[:, monthly_reporting_by_facility.columns.isin(facilities_with_location)] -monthly_reporting_by_facility = monthly_reporting_by_facility[facilities_with_location] +if not baseline: + monthly_reporting_by_facility = monthly_reporting_by_facility.set_index('facility').T + monthly_reporting_by_facility.index.name = "date" + # ### Save CSVs + monthly_reporting_by_facility = monthly_reporting_by_facility.loc[:, monthly_reporting_by_facility.columns.isin(facilities_with_location)] + monthly_reporting_by_facility = monthly_reporting_by_facility[facilities_with_location] + + #monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm.csv") -#monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm.csv") -if baseline: if ANC: - monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_ANC_by_smaller_facility_lm_baseline.csv") - weather_df.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_ANC_lm_baseline.csv") + monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_ANC_by_smaller_facility_lm.csv") + weather_df.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_ANC_lm.csv") if Inpatient: - monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_Inpatient_by_smaller_facility_lm_baseline.csv") - weather_df.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_Inpatient_lm_baseline.csv") + monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_Inpatient_by_smaller_facility_lm.csv") + weather_df.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_Inpatient_lm.csv") else: - monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm_baseline.csv") - weather_df.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facility_lm_baseline.csv") -else: + monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm.csv") + weather_df.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facility_lm.csv") + + + for facility in facilities_with_location: + print(facility) + ## Get additional data - e.g. which zone it is in, altitude + included_facilities_with_lat_long = facilities_with_lat_long[ + facilities_with_lat_long["Fname"].isin(facilities_with_location) + ] + + unique_columns = set(facilities_with_location) - set(included_facilities_with_lat_long) + print(unique_columns) + additional_rows = ["Zonename", "Resid", "Dist", "A105", "A109__Altitude", "Ftype", 'A109__Latitude', 'A109__Longitude'] + expanded_facility_info = included_facilities_with_lat_long[["Fname"] + additional_rows] + expanded_facility_info['Dist'] = expanded_facility_info['Dist'].replace("Blanytyre", "Blantyre") + expanded_facility_info['Dist'] = expanded_facility_info['Dist'].replace("Nkhatabay", "Nkhata Bay") + + expanded_facility_info.columns = ["Fname"] + additional_rows + expanded_facility_info.set_index("Fname", inplace=True) + # minimum distances between facilities + coordinates = expanded_facility_info[['A109__Latitude', 'A109__Longitude']].values + distances = cdist(coordinates, coordinates, metric='euclidean') + np.fill_diagonal(distances, np.inf) + expanded_facility_info['minimum_distance'] = np.nanmin(distances, axis=1) + + average_precipitation_by_facility = { + facility: np.mean(precipitation) + for facility, precipitation in weather_data_by_facility.items() + } + + average_precipitation_df = pd.DataFrame.from_dict( + average_precipitation_by_facility, orient='index', columns=['average_precipitation'] + ) + + average_precipitation_df.index.name = "Fname" + expanded_facility_info['average_precipitation'] = expanded_facility_info.index.map( + average_precipitation_df['average_precipitation'] + ) + expanded_facility_info = expanded_facility_info.T + expanded_facility_info = expanded_facility_info.reindex(columns=facilities_with_location) if ANC: - monthly_reporting_by_facility.to_csv( - "/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_ANC_by_smaller_facility_lm_baseline.csv") - weather_df.to_csv( + expanded_facility_info.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_with_ANC.csv") + elif Inpatient: + expanded_facility_info.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_with_inpatient_days.csv") + + else: + expanded_facility_info.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm.csv") + +if baseline: + if ANC: + weather_df.to_csv( "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_ANC_lm_baseline.csv") if Inpatient: - monthly_reporting_by_facility.to_csv( - "/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_Inpatient_by_smaller_facility_lm_baseline.csv") weather_df.to_csv( "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_Inpatient_lm_baseline.csv") else: - monthly_reporting_by_facility.to_csv( - "/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm_baseline.csv") weather_df.to_csv( "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facility_lm_baseline.csv") - -for facility in facilities_with_location: - print(facility) -## Get additional data - e.g. which zone it is in, altitude -included_facilities_with_lat_long = facilities_with_lat_long[ - facilities_with_lat_long["Fname"].isin(facilities_with_location) -] - -unique_columns = set(facilities_with_location) - set(included_facilities_with_lat_long) -print(unique_columns) -additional_rows = ["Zonename", "Resid", "Dist", "A105", "A109__Altitude", "Ftype", 'A109__Latitude', 'A109__Longitude'] -expanded_facility_info = included_facilities_with_lat_long[["Fname"] + additional_rows] -expanded_facility_info['Dist'] = expanded_facility_info['Dist'].replace("Blanytyre", "Blantyre") -expanded_facility_info['Dist'] = expanded_facility_info['Dist'].replace("Nkhatabay", "Nkhata Bay") - -expanded_facility_info.columns = ["Fname"] + additional_rows -expanded_facility_info.set_index("Fname", inplace=True) -# minimum distances between facilities -coordinates = expanded_facility_info[['A109__Latitude', 'A109__Longitude']].values -distances = cdist(coordinates, coordinates, metric='euclidean') -np.fill_diagonal(distances, np.inf) -expanded_facility_info['minimum_distance'] = np.nanmin(distances, axis=1) - -average_precipitation_by_facility = { - facility: np.mean(precipitation) - for facility, precipitation in weather_data_by_facility.items() -} - -average_precipitation_df = pd.DataFrame.from_dict( - average_precipitation_by_facility, orient='index', columns=['average_precipitation'] -) - -average_precipitation_df.index.name = "Fname" -expanded_facility_info['average_precipitation'] = expanded_facility_info.index.map( - average_precipitation_df['average_precipitation'] -) -expanded_facility_info = expanded_facility_info.T -expanded_facility_info = expanded_facility_info.reindex(columns=facilities_with_location) -if baseline: - if ANC: - expanded_facility_info.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_with_ANC_baseline.csv") - elif Inpatient: - expanded_facility_info.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_with_inpatient_days_baseline.csv") - - else: - expanded_facility_info.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_baseline.csv") -else: - if ANC: - expanded_facility_info.to_csv( - "/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_with_ANC_baseline.csv") - elif Inpatient: - expanded_facility_info.to_csv( - "/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_with_inpatient_days_baseline.csv") - - else: - expanded_facility_info.to_csv( - "/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_baseline.csv") - From 855443a9fcc6230cc56bbc622815137d415fd6b7 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 17 Feb 2025 11:59:09 +0000 Subject: [PATCH 261/291] did cumulative --- .../climate_change/process_daily_total_historical_data.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/scripts/climate_change/process_daily_total_historical_data.py b/src/scripts/climate_change/process_daily_total_historical_data.py index 25691004e5..06bdea7d96 100644 --- a/src/scripts/climate_change/process_daily_total_historical_data.py +++ b/src/scripts/climate_change/process_daily_total_historical_data.py @@ -10,7 +10,7 @@ ANC = True # facility data multiplier = 1000 -five_day = False +five_day = True cumulative = True general_facilities = gpd.read_file("/Users/rem76/Desktop/Climate_change_health/Data/facilities_with_districts.shp") From c855e6938cad13fd277d19f7a2958947ceff23df Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 17 Feb 2025 15:11:26 +0000 Subject: [PATCH 262/291] Added in historical data Getting odd results on the exponential in the predictions... --- ...al_realtionship_reporting_precipitation.py | 109 ++++++++---------- .../process_daily_total_historical_data.py | 2 +- 2 files changed, 48 insertions(+), 63 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index d0af3d23f2..6a67e4b052 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -29,10 +29,10 @@ absolute_min_year = 2011 mask_threshold = -np.inf # accounts for scaling #mask_threshold = 50 -use_percentile_mask_threshold = True -baseline_years = range(1940, 1979) -min_year_for_analysis_baseline = min(baseline_years) -absolute_min_year_baseline = min_year_for_analysis_baseline - 1 +use_percentile_mask_threshold = False +baseline_years = range(1940, 1980) +min_year_for_analysis_baseline = min(baseline_years) + 1 +absolute_min_year_baseline = min(baseline_years) max_year_for_analysis_baseline = max(baseline_years) + 1 poisson = False @@ -254,7 +254,6 @@ def process_weather_data(weather_df, zero_sum_columns, min_year_for_analysis, ab year_repeated = [y for y in year_range for _ in range(12)] year = year_repeated[:-4] year_flattened = year*len(monthly_reporting_by_facility.columns) # to get flattened data -month = range(12) month_repeated = [] for _ in year_range: month_repeated.extend(range(1, 13)) @@ -324,7 +323,7 @@ def process_weather_data(weather_df, zero_sum_columns, min_year_for_analysis, ab X_categorical = np.column_stack([ resid_encoded, zone_encoded, - dist_encoded, + #dist_encoded, owner_encoded, #ftype_encoded, #facility_encoded, @@ -479,7 +478,7 @@ def process_weather_data(weather_df, zero_sum_columns, min_year_for_analysis, ab X_categorical = np.column_stack([ resid_encoded, zone_encoded, - dist_encoded, + #dist_encoded, owner_encoded, #ftype_encoded, #facility_encoded, @@ -554,7 +553,7 @@ def process_weather_data(weather_df, zero_sum_columns, min_year_for_analysis, ab axs[0].legend(loc='upper left', borderaxespad=0.) -plt.show() +#plt.show() ## average of predictions data_weather_predictions = pd.DataFrame({ 'Year': np.array(year_flattened)[mask_all_data], @@ -598,7 +597,7 @@ def process_weather_data(weather_df, zero_sum_columns, min_year_for_analysis, ab ax.axvspan('2023-2', '2023-3', color='#CDC6AE', alpha=0.3) plt.tight_layout() plt.savefig( f'/Users/rem76/Desktop/Climate_change_health/Results/{service}_disruptions/{service}_disruptions_difference_historical_models.png') -plt.show() +#plt.show() ## save historical predictions full_data_weather_predictions_historical = pd.DataFrame({ @@ -844,7 +843,7 @@ def get_weather_data(ssp_scenario, model_type): axs[0].set_xticklabels(xticks, rotation=45, ha='right') axs[0].set_ylabel(f'Difference Predicted {service} visits due to rainfall') axs[0].legend(loc='upper left') - plt.show() + #plt.show() fig, axs = plt.subplots(1, 2, figsize=(14, 6)) @@ -855,7 +854,7 @@ def get_weather_data(ssp_scenario, model_type): axs[0].set_ylabel(f'Difference in of {service} visits between weather and non-weather model') plt.tight_layout() - plt.show() + #plt.show() # Format output: Add all relevant X variables full_data_weather_predictions = pd.DataFrame({ 'Year': year_flattened_prediction[X_basis_weather[:, 0] > mask_threshold], @@ -903,6 +902,7 @@ def get_weather_data(ssp_scenario, model_type): # Drop zero-sum columns weather_data_monthly_20th_century = weather_data_monthly_20th_century.drop(columns=zero_sum_columns, errors='ignore') + num_facilities_baseline = len(weather_data_monthly_20th_century.columns) weather_data_five_day_cumulative_20th_century = weather_data_five_day_cumulative_20th_century.drop( columns=zero_sum_columns, errors='ignore') @@ -910,7 +910,6 @@ def get_weather_data(ssp_scenario, model_type): lags_monthly_baseline = {i: weather_data_monthly_20th_century.shift(i).values for i in [1, 2, 3, 4, 9, 12]} for key in lags_monthly_baseline: lags_monthly_baseline[key] = lags_monthly_baseline[key][(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:].flatten() - lags_five_day_baseline = {i: weather_data_five_day_cumulative_20th_century.shift(i).values for i in [1, 2, 3, 4, 9]} for key in lags_five_day_baseline: lags_five_day_baseline[key] = lags_five_day_baseline[key][(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:].flatten() @@ -922,32 +921,31 @@ def get_weather_data(ssp_scenario, model_type): weather_data_monthly_flattened = weather_data_monthly_20th_century.values.flatten() weather_data_five_day_cumulative_flattened = weather_data_five_day_cumulative_20th_century.values.flatten() - print(len(weather_data_five_day_cumulative_flattened)) weather_data_baseline = np.vstack( (weather_data_monthly_flattened, weather_data_five_day_cumulative_flattened)).T # covariates year_range_baseline = range(min_year_for_analysis_baseline, max_year_for_analysis_baseline, 1) year_repeated_baseline = [y for y in year_range_baseline for _ in range(12)] -year_flattened_baseline = year_repeated_baseline*len(monthly_reporting_by_facility.columns) # to get flattened data -month = range(12) +year_flattened_baseline = year_repeated_baseline*num_facilities_baseline # to get flattened data + month_repeated = [] -for _ in year_range: +for _ in year_range_baseline: month_repeated.extend(range(1, 13)) -month_flattened_baseline = month*len(monthly_reporting_by_facility.columns) +month_flattened_baseline = month_repeated*num_facilities_baseline -zone_info_each_month_baseline = repeat_info(expanded_facility_info["Zonename"], num_facilities, year_range_baseline, historical = False) +zone_info_each_month_baseline = repeat_info(expanded_facility_info["Zonename"], num_facilities_baseline, year_range_baseline, historical = False) zone_encoded_baseline = pd.get_dummies(zone_info_each_month_baseline, drop_first=True) -dist_info_each_month_baseline = repeat_info(expanded_facility_info["Dist"], num_facilities, year_range_baseline, historical = False) +dist_info_each_month_baseline = repeat_info(expanded_facility_info["Dist"], num_facilities_baseline, year_range_baseline, historical = False) dist_encoded_baseline = pd.get_dummies(dist_info_each_month_baseline, drop_first=True) -resid_info_each_month_baseline = repeat_info(expanded_facility_info['Resid'], num_facilities, year_range_baseline, historical = False) +resid_info_each_month_baseline = repeat_info(expanded_facility_info['Resid'], num_facilities_baseline, year_range_baseline, historical = False) resid_encoded_baseline = pd.get_dummies(resid_info_each_month_baseline, drop_first=True) -owner_info_each_month_baseline = repeat_info(expanded_facility_info['A105'], num_facilities, year_range_baseline, historical = False) +owner_info_each_month_baseline = repeat_info(expanded_facility_info['A105'], num_facilities_baseline, year_range_baseline, historical = False) owner_encoded_baseline = pd.get_dummies(owner_info_each_month_baseline, drop_first=True) -ftype_info_each_month_baseline = repeat_info(expanded_facility_info['Ftype'], num_facilities, year_range_baseline, historical = False) +ftype_info_each_month_baseline = repeat_info(expanded_facility_info['Ftype'], num_facilities_baseline, year_range_baseline, historical = False) ftype_encoded_baseline = pd.get_dummies(ftype_info_each_month_baseline, drop_first=True) -altitude_baseline = [float(x) for x in repeat_info(expanded_facility_info['A109__Altitude'], num_facilities, year_range_baseline, historical = False)] -minimum_distance_baseline = [float(x) for x in repeat_info(expanded_facility_info['minimum_distance'], num_facilities, year_range_baseline, historical = False)] +altitude_baseline = [float(x) for x in repeat_info(expanded_facility_info['A109__Altitude'], num_facilities_baseline, year_range_baseline, historical = False)] +minimum_distance_baseline = [float(x) for x in repeat_info(expanded_facility_info['minimum_distance'], num_facilities_baseline, year_range_baseline, historical = False)] altitude_baseline = np.array(altitude_baseline) altitude_baseline = np.where(altitude_baseline < 0, np.nan, altitude_baseline) @@ -958,7 +956,6 @@ def get_weather_data(ssp_scenario, model_type): minimum_distance_baseline = np.nan_to_num(minimum_distance_baseline, nan=np.nan, posinf=np.nan, neginf=np.nan) # just in case - X_continuous_baseline = np.column_stack([ year_flattened_baseline, month_flattened_baseline, @@ -969,7 +966,7 @@ def get_weather_data(ssp_scenario, model_type): X_categorical_baseline = np.column_stack([ resid_encoded_baseline, zone_encoded_baseline, - dist_encoded_baseline, + #dist_encoded_baseline, owner_encoded_baseline, #ftype_encoded, #facility_encoded, @@ -977,10 +974,10 @@ def get_weather_data(ssp_scenario, model_type): scaler = StandardScaler() X_continuous_scaled_baseline = scaler.fit_transform(X_continuous_baseline) X_continuous_scaled_baseline = X_continuous_baseline -X_ANC_standardized_baseline = np.column_stack([X_continuous_scaled_baseline, X_categorical_baseline]) -X_basis_weather_filtered_baseline = X_ANC_standardized_baseline[X_ANC_standardized_baseline[:, 0] > mask_threshold] +X_standardized_baseline = np.column_stack([X_continuous_scaled_baseline, X_categorical_baseline]) +X_standardized_baseline = X_standardized_baseline[:, included] -X_continuous_baseline = np.column_stack([ +X_continuous_baseline_weather = np.column_stack([ weather_data_baseline, weather_data_baseline[:,0]*weather_data_baseline[:,0], weather_data_baseline[:,1] * weather_data_baseline[:,1], @@ -989,30 +986,23 @@ def get_weather_data(ssp_scenario, model_type): weather_data_baseline[:, 1] * weather_data_baseline[:,0], np.array(year_flattened_baseline), np.array(month_flattened_baseline), - lags_monthly_baseline, - lags_monthly_baseline, + np.column_stack([lags_monthly_baseline[i] for i in sorted(lags_monthly_baseline.keys())]), + np.column_stack([lags_five_day_baseline[i] for i in sorted(lags_five_day_baseline.keys())]), np.array(altitude_baseline), np.array(minimum_distance_baseline)] ) -X_categorical_baseline = np.column_stack([ - resid_encoded_baseline, - zone_encoded_baseline, - dist_encoded_baseline, - owner_encoded_baseline, - ]) - scaler = StandardScaler() X_continuous_scaled_baseline = scaler.fit_transform(X_continuous_baseline) X_continuous_scaled_baseline = X_continuous_baseline -X_bases_ANC_standardized_baseline = np.column_stack([X_continuous_scaled_baseline, X_categorical_baseline]) -X_bases_ANC_standardized_baseline = X_bases_ANC_standardized_baseline[:, included] -X_basis_weather_filtered_baseline = X_basis_weather_filtered_baseline[:,included_weather] +X_basis_weather_standardized_baseline = np.column_stack([X_continuous_baseline_weather, X_categorical_baseline]) +X_basis_weather_filtered_baseline = X_basis_weather_standardized_baseline[:,included_weather] predictions_weather_baseline = results_of_weather_model.predict(X_basis_weather_filtered_baseline ) -y_pred_ANC_baseline = results.predict(X_bases_ANC_standardized_baseline) +y_pred_baseline = results.predict(X_standardized_baseline) +#predictions_baseline = np.exp(predictions_weather_baseline) - np.exp(y_pred_baseline[X_basis_weather_filtered_baseline[:, 0] > mask_threshold]) +predictions_baseline = (predictions_weather_baseline) - (y_pred_baseline[X_basis_weather_filtered_baseline[:, 0] > mask_threshold]) -predictions_baseline = np.exp(predictions_weather_baseline) - np.exp(y_pred_ANC_baseline[X_basis_weather[:, 0] > mask_threshold]) year_month_labels_baseline = np.array([f"{y}-{m}" for y, m in zip(X_basis_weather_filtered_baseline[:, 2], X_basis_weather_filtered_baseline[:, 3])]) data_weather_predictions_baseline = pd.DataFrame({ @@ -1020,10 +1010,10 @@ def get_weather_data(ssp_scenario, model_type): 'y_pred_weather': np.exp(predictions_weather_baseline) }) -data_weather_predictions_baseline['y_pred_no_weather'] = np.exp(y_pred_ANC_baseline[X_basis_weather[:, 0] > mask_threshold]) +data_weather_predictions_baseline['y_pred_no_weather'] = np.exp(y_pred_baseline[X_basis_weather_filtered_baseline[:, 0] > mask_threshold]) data_weather_predictions_baseline['difference_in_expectation'] = predictions_baseline -data_weather_predictions_baseline['weather'] = X_basis_weather[X_basis_weather[:, 0] > mask_threshold, 0] +data_weather_predictions_baseline['weather'] = X_basis_weather_filtered_baseline[X_basis_weather_filtered_baseline[:, 0] > mask_threshold, 0] data_weather_predictions_grouped_baseline = data_weather_predictions.groupby('Year_Month').mean().reset_index() # Plotting results @@ -1053,23 +1043,18 @@ def get_weather_data(ssp_scenario, model_type): plt.show() # Format output: Add all relevant X variables full_data_weather_predictions = pd.DataFrame({ - 'Year': year_flattened_baseline[X_basis_weather[:, 0] > mask_threshold], - 'Month': np.array(month_flattened_baseline)[X_basis_weather[:, 0] > mask_threshold], - 'Facility_ID': facility_flattened_prediction[X_basis_weather[:, 0] > mask_threshold], - 'Altitude': np.array(altitude_prediction)[X_basis_weather[:, 0] > mask_threshold], - 'Zone': np.array(zone_info_prediction)[X_basis_weather[:, 0] > mask_threshold], - 'District': np.array(dist_info_prediction)[X_basis_weather[:, 0] > mask_threshold], - 'Resid': np.array(resid_info_prediction)[X_basis_weather[:, 0] > mask_threshold], - 'Owner': np.array(owner_info_prediction)[X_basis_weather[:, 0] > mask_threshold], - 'Facility_Type': np.array(ftype_info_prediction)[X_basis_weather[:, 0] > mask_threshold], - 'Precipitation': X_basis_weather[X_basis_weather[:, 0] > mask_threshold, 0], - 'Lag_1_Precipitation': np.array(lag_1_month_prediction)[X_basis_weather[:, 0] > mask_threshold], - 'Lag_2_Precipitation': np.array(lag_2_month_prediction)[X_basis_weather[:, 0] > mask_threshold], - 'Lag_3_Precipitation': np.array(lag_3_month_prediction)[X_basis_weather[:, 0] > mask_threshold], - 'Lag_4_Precipitation': np.array(lag_4_month_prediction)[X_basis_weather[:, 0] > mask_threshold], - 'Predicted_Weather_Model': np.exp(predictions_weather), - 'Predicted_No_Weather_Model': np.exp(y_pred_ANC[X_basis_weather[:, 0] > mask_threshold]), - 'Difference_in_Expectation': predictions, + 'Year': year_flattened_baseline[X_basis_weather_filtered_baseline[:, 0] > mask_threshold], + 'Month': np.array(month_flattened_baseline)[X_basis_weather_filtered_baseline[:, 0] > mask_threshold], + 'Altitude': np.array(altitude_baseline)[X_basis_weather_filtered_baseline[:, 0] > mask_threshold], + 'Zone': np.array(zone_info_each_month_baseline)[X_basis_weather_filtered_baseline[:, 0] > mask_threshold], + 'District': np.array(dist_info_each_month_baseline)[X_basis_weather_filtered_baseline[:, 0] > mask_threshold], + 'Resid': np.array(resid_info_each_month_baseline)[X_basis_weather_filtered_baseline[:, 0] > mask_threshold], + 'Owner': np.array(owner_info_each_month_baseline)[X_basis_weather_filtered_baseline[:, 0] > mask_threshold], + 'Facility_Type': np.array(ftype_info_each_month_baseline)[X_basis_weather_filtered_baseline[:, 0] > mask_threshold], + 'Precipitation': X_basis_weather_filtered_baseline[X_basis_weather_filtered_baseline[:, 0] > mask_threshold, 0], + 'Predicted_Weather_Model': np.exp(predictions_weather_baseline), + 'Predicted_No_Weather_Model': np.exp(y_pred_baseline[X_basis_weather_filtered_baseline[:, 0] > mask_threshold]), + 'Difference_in_Expectation': predictions_baseline, }) # Save the results diff --git a/src/scripts/climate_change/process_daily_total_historical_data.py b/src/scripts/climate_change/process_daily_total_historical_data.py index 06bdea7d96..b620d05939 100644 --- a/src/scripts/climate_change/process_daily_total_historical_data.py +++ b/src/scripts/climate_change/process_daily_total_historical_data.py @@ -154,7 +154,7 @@ # df_of_facilities = pd.DataFrame.from_dict(max_average_by_facility, orient='index') -df_of_facilities = df_of_facilities.iloc[:, :-3] ## THESE ARE OCT/NOV/DEC OF 2024, and for moment don't have that reporting data +if max(years) > 2000: df_of_facilities = df_of_facilities.iloc[:, :-3] ## THESE ARE OCT/NOV/DEC OF 2024, and for moment don't have that reporting data df_of_facilities = df_of_facilities.T if max(years) > 2000: From 33581894d96121499dad0eb363213994ac763483 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 17 Feb 2025 18:15:13 +0000 Subject: [PATCH 263/291] Removed loop for lags, was throwing errors --- ...al_realtionship_reporting_precipitation.py | 117 ++++++++++-------- 1 file changed, 68 insertions(+), 49 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 6a67e4b052..7747025984 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -1,4 +1,3 @@ -import joblib import matplotlib.pyplot as plt import numpy as np import pandas as pd @@ -33,7 +32,7 @@ baseline_years = range(1940, 1980) min_year_for_analysis_baseline = min(baseline_years) + 1 absolute_min_year_baseline = min(baseline_years) -max_year_for_analysis_baseline = max(baseline_years) + 1 +max_year_for_analysis_baseline = max(baseline_years) + 1 poisson = False log_y = True @@ -43,20 +42,6 @@ cyclone_freddy_months_thumbwe = range((2023 - min_year_for_analysis)* 12 + 3, (2020 - min_year_for_analysis)* 12 + 3 + 12) # From news report and DHIS2, see disruption from March 2023 - March 2024, 12 months -model_filename = ( - f"best_model_{'ANC' if ANC else 'Reporting'}_prediction_" - f"{'5_day' if five_day else 'monthly'}_" - f"{'cumulative' if cumulative else ('max' if daily_max else 'total')}_" - f"{'poisson' if poisson else 'linear'}_precip.pkl" -) -print(model_filename) -model_filename_weather_model = ( - f"best_model_weather_" - f"{'5_day' if five_day else 'monthly'}_" - f"{'cumulative' if cumulative else ('max' if daily_max else 'total')}_" - f"{'poisson' if poisson else 'linear'}_precip.pkl" -) -print(model_filename_weather_model) # # data is from 2011 - 2024 - for facility if ANC: monthly_reporting_by_facility = pd.read_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_ANC_by_smaller_facility_lm.csv", index_col=0) @@ -153,13 +138,6 @@ def repeat_info(info, num_facilities, year_range, historical): return repeated_info # -def process_weather_data(weather_df, zero_sum_columns, min_year_for_analysis, absolute_min_year, lags=[1, 2, 3, 4, 9, 12]): - """ - Processes weather data by dropping zero-sum columns, computing lags, and flattening. - """ - weather_df = weather_df.drop(columns=zero_sum_columns, errors='ignore').iloc[:-(2 if 'monthly' in weather_df.columns else 1)] - lags_data = {lag: weather_df.shift(lag).values[(min_year_for_analysis - absolute_min_year) * 12:].flatten() for lag in lags} - return weather_df.iloc[(min_year_for_analysis - absolute_min_year) * 12:], lags_data ### Try combine weather variables ## if use_all_weather: @@ -887,6 +865,7 @@ def get_weather_data(ssp_scenario, model_type): ################# Semi-post industrial, pre-2000 data ################# + if ANC: # Load data weather_data_monthly_20th_century = pd.read_csv( @@ -899,20 +878,37 @@ def get_weather_data(ssp_scenario, model_type): index_col=0 ) - # Drop zero-sum columns - weather_data_monthly_20th_century = weather_data_monthly_20th_century.drop(columns=zero_sum_columns, - errors='ignore') num_facilities_baseline = len(weather_data_monthly_20th_century.columns) - weather_data_five_day_cumulative_20th_century = weather_data_five_day_cumulative_20th_century.drop( - columns=zero_sum_columns, errors='ignore') # lags - lags_monthly_baseline = {i: weather_data_monthly_20th_century.shift(i).values for i in [1, 2, 3, 4, 9, 12]} - for key in lags_monthly_baseline: - lags_monthly_baseline[key] = lags_monthly_baseline[key][(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:].flatten() - lags_five_day_baseline = {i: weather_data_five_day_cumulative_20th_century.shift(i).values for i in [1, 2, 3, 4, 9]} - for key in lags_five_day_baseline: - lags_five_day_baseline[key] = lags_five_day_baseline[key][(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:].flatten() + lag_1_month_baseline = weather_data_monthly_20th_century.shift(1).values + lag_2_month_baseline = weather_data_monthly_20th_century.shift(2).values + lag_3_month_baseline = weather_data_monthly_20th_century.shift(3).values + lag_4_month_baseline = weather_data_monthly_20th_century.shift(4).values + lag_9_month_baseline = weather_data_monthly_20th_century.shift(9).values + + lag_1_month_baseline = lag_1_month_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:].flatten() + lag_2_month_baseline = lag_2_month_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:].flatten() + lag_3_month_baseline = lag_3_month_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:].flatten() + lag_4_month_baseline = lag_4_month_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:].flatten() + lag_9_month_baseline = lag_9_month_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:].flatten() + + lag_1_5_day_baseline = weather_data_five_day_cumulative_20th_century.shift(1).values + lag_2_5_day_baseline = weather_data_five_day_cumulative_20th_century.shift(2).values + lag_3_5_day_baseline = weather_data_five_day_cumulative_20th_century.shift(3).values + lag_4_5_day_baseline = weather_data_five_day_cumulative_20th_century.shift(4).values + lag_9_5_day_baseline = weather_data_five_day_cumulative_20th_century.shift(9).values + + lag_1_5_day_baseline = lag_1_5_day_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:].flatten() + lag_2_5_day_baseline = lag_2_5_day_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:].flatten() + lag_3_5_day_baseline = lag_3_5_day_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:].flatten() + lag_4_5_day_baseline = lag_4_5_day_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:].flatten() + lag_9_5_day_baseline = lag_9_5_day_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:].flatten() + + # need for binary + lag_12_month_baseline = weather_data_monthly_20th_century.shift(12).values + lag_12_month_baseline = lag_12_month_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:].flatten() + # process weather_data_monthly_20th_century = weather_data_monthly_20th_century.iloc[ (min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:] @@ -928,7 +924,7 @@ def get_weather_data(ssp_scenario, model_type): year_range_baseline = range(min_year_for_analysis_baseline, max_year_for_analysis_baseline, 1) year_repeated_baseline = [y for y in year_range_baseline for _ in range(12)] year_flattened_baseline = year_repeated_baseline*num_facilities_baseline # to get flattened data - +#year_flattened_baseline = [2015] * len(year_flattened_baseline) month_repeated = [] for _ in year_range_baseline: month_repeated.extend(range(1, 13)) @@ -971,12 +967,12 @@ def get_weather_data(ssp_scenario, model_type): #ftype_encoded, #facility_encoded, ]) -scaler = StandardScaler() -X_continuous_scaled_baseline = scaler.fit_transform(X_continuous_baseline) -X_continuous_scaled_baseline = X_continuous_baseline -X_standardized_baseline = np.column_stack([X_continuous_scaled_baseline, X_categorical_baseline]) + +X_standardized_baseline = np.column_stack([X_continuous_baseline, X_categorical_baseline]) X_standardized_baseline = X_standardized_baseline[:, included] + + X_continuous_baseline_weather = np.column_stack([ weather_data_baseline, weather_data_baseline[:,0]*weather_data_baseline[:,0], @@ -986,23 +982,30 @@ def get_weather_data(ssp_scenario, model_type): weather_data_baseline[:, 1] * weather_data_baseline[:,0], np.array(year_flattened_baseline), np.array(month_flattened_baseline), - np.column_stack([lags_monthly_baseline[i] for i in sorted(lags_monthly_baseline.keys())]), - np.column_stack([lags_five_day_baseline[i] for i in sorted(lags_five_day_baseline.keys())]), + lag_1_month_baseline, + lag_2_month_baseline, + lag_3_month_baseline, + lag_4_month_baseline, + lag_9_month_baseline, + lag_1_5_day_baseline, + lag_2_5_day_baseline, + lag_3_5_day_baseline, + lag_4_5_day_baseline, + lag_9_5_day_baseline, np.array(altitude_baseline), np.array(minimum_distance_baseline)] ) -scaler = StandardScaler() -X_continuous_scaled_baseline = scaler.fit_transform(X_continuous_baseline) -X_continuous_scaled_baseline = X_continuous_baseline X_basis_weather_standardized_baseline = np.column_stack([X_continuous_baseline_weather, X_categorical_baseline]) X_basis_weather_filtered_baseline = X_basis_weather_standardized_baseline[:,included_weather] predictions_weather_baseline = results_of_weather_model.predict(X_basis_weather_filtered_baseline ) y_pred_baseline = results.predict(X_standardized_baseline) -#predictions_baseline = np.exp(predictions_weather_baseline) - np.exp(y_pred_baseline[X_basis_weather_filtered_baseline[:, 0] > mask_threshold]) -predictions_baseline = (predictions_weather_baseline) - (y_pred_baseline[X_basis_weather_filtered_baseline[:, 0] > mask_threshold]) + +predictions_baseline = np.exp(predictions_weather_baseline) - np.exp(y_pred_baseline[X_basis_weather_filtered_baseline[:, 0] > mask_threshold]) +#predictions_baseline = (predictions_weather_baseline) - (y_pred_baseline[X_basis_weather_filtered_baseline[:, 0] > mask_threshold]) +predictions_baseline[predictions_baseline > 10000] = 0 year_month_labels_baseline = np.array([f"{y}-{m}" for y, m in zip(X_basis_weather_filtered_baseline[:, 2], X_basis_weather_filtered_baseline[:, 3])]) data_weather_predictions_baseline = pd.DataFrame({ @@ -1014,7 +1017,20 @@ def get_weather_data(ssp_scenario, model_type): data_weather_predictions_baseline['difference_in_expectation'] = predictions_baseline data_weather_predictions_baseline['weather'] = X_basis_weather_filtered_baseline[X_basis_weather_filtered_baseline[:, 0] > mask_threshold, 0] -data_weather_predictions_grouped_baseline = data_weather_predictions.groupby('Year_Month').mean().reset_index() +data_weather_predictions_grouped_baseline = data_weather_predictions_baseline.groupby('Year_Month').mean().reset_index() + +## plot difference +axs[0].scatter(X_basis_weather_filtered_baseline[:, 0], y_pred_baseline[X_basis_weather_filtered_baseline[:, 0] > mask_threshold], color='red', alpha=0.5, label = 'Non weather model') +axs[0].hlines(y = 0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color = 'black', linestyle = '--') +axs[0].scatter(X_basis_weather_filtered_baseline[:, 0], np.exp(predictions_weather_baseline), label='Weather model', color="blue", alpha = 0.5) +axs[0].hlines(y=0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color='black', linestyle='--') +axs[0].set_ylabel(f'{service} visits') + +axs[0].set_xlabel('Monthly precipitation (mm)') +axs[1].set_xlabel('Monthly precipitation (mm)') + +axs[0].legend(loc='upper left', borderaxespad=0.) + # Plotting results fig, axs = plt.subplots(1, 2, figsize=(14, 6)) @@ -1027,6 +1043,8 @@ def get_weather_data(ssp_scenario, model_type): axs[0].set_xticks(xticks) axs[0].set_xticklabels(xticks, rotation=45, ha='right') axs[0].set_ylabel(f'Difference Predicted {service} visits due to rainfall') +axs[0].set_title('Baseline') + axs[0].legend(loc='upper left') plt.show() @@ -1038,6 +1056,7 @@ def get_weather_data(ssp_scenario, model_type): axs[0].set_xlabel('Precipitation (mm)') axs[0].set_ylabel(f'Difference in of {service} visits between weather and non-weather model') +axs[0].set_title('Baseline') plt.tight_layout() plt.show() @@ -1058,10 +1077,10 @@ def get_weather_data(ssp_scenario, model_type): }) # Save the results -full_data_weather_predictions.to_csv(f"{data_path}weather_predictions_with_X_baseline_{service}.csv", +full_data_weather_predictions.to_csv(f"{data_path_base}weather_predictions_with_X_baseline_{service}.csv", index=False) -X_basis_weather_filtered = pd.DataFrame(X_basis_weather_filtered) +X_basis_weather_filtered = pd.DataFrame(X_basis_weather_filtered_baseline) # Save to CSV full_data_weather_predictions.to_csv(f"{data_path}weather_predictions_with_X_baseline_{service}.csv", index=False) From b4ace7a8c1131f3eef572342a3a42016e6de1588 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 18 Feb 2025 10:03:56 +0000 Subject: [PATCH 264/291] typo --- ...el_historical_realtionship_reporting_precipitation.py | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 7747025984..688158ff66 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -1004,8 +1004,7 @@ def get_weather_data(ssp_scenario, model_type): predictions_baseline = np.exp(predictions_weather_baseline) - np.exp(y_pred_baseline[X_basis_weather_filtered_baseline[:, 0] > mask_threshold]) -#predictions_baseline = (predictions_weather_baseline) - (y_pred_baseline[X_basis_weather_filtered_baseline[:, 0] > mask_threshold]) -predictions_baseline[predictions_baseline > 10000] = 0 +predictions_baseline = (predictions_weather_baseline) - (y_pred_baseline[X_basis_weather_filtered_baseline[:, 0] > mask_threshold]) year_month_labels_baseline = np.array([f"{y}-{m}" for y, m in zip(X_basis_weather_filtered_baseline[:, 2], X_basis_weather_filtered_baseline[:, 3])]) data_weather_predictions_baseline = pd.DataFrame({ @@ -1020,7 +1019,7 @@ def get_weather_data(ssp_scenario, model_type): data_weather_predictions_grouped_baseline = data_weather_predictions_baseline.groupby('Year_Month').mean().reset_index() ## plot difference -axs[0].scatter(X_basis_weather_filtered_baseline[:, 0], y_pred_baseline[X_basis_weather_filtered_baseline[:, 0] > mask_threshold], color='red', alpha=0.5, label = 'Non weather model') +axs[0].scatter(X_basis_weather_filtered_baseline[:, 0], np.exp(y_pred_baseline[X_basis_weather_filtered_baseline[:, 0] > mask_threshold]), color='red', alpha=0.5, label = 'Non weather model') axs[0].hlines(y = 0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color = 'black', linestyle = '--') axs[0].scatter(X_basis_weather_filtered_baseline[:, 0], np.exp(predictions_weather_baseline), label='Weather model', color="blue", alpha = 0.5) axs[0].hlines(y=0, xmin=plt.xlim()[0], xmax=plt.xlim()[1], color='black', linestyle='--') @@ -1062,7 +1061,7 @@ def get_weather_data(ssp_scenario, model_type): plt.show() # Format output: Add all relevant X variables full_data_weather_predictions = pd.DataFrame({ - 'Year': year_flattened_baseline[X_basis_weather_filtered_baseline[:, 0] > mask_threshold], + 'Year': np.array(year_flattened_baseline)[X_continuous_baseline_weather[:, 0] > mask_threshold], 'Month': np.array(month_flattened_baseline)[X_basis_weather_filtered_baseline[:, 0] > mask_threshold], 'Altitude': np.array(altitude_baseline)[X_basis_weather_filtered_baseline[:, 0] > mask_threshold], 'Zone': np.array(zone_info_each_month_baseline)[X_basis_weather_filtered_baseline[:, 0] > mask_threshold], @@ -1077,7 +1076,7 @@ def get_weather_data(ssp_scenario, model_type): }) # Save the results -full_data_weather_predictions.to_csv(f"{data_path_base}weather_predictions_with_X_baseline_{service}.csv", +full_data_weather_predictions.to_csv(f"{data_path}weather_predictions_with_X_baseline_{service}.csv", index=False) X_basis_weather_filtered = pd.DataFrame(X_basis_weather_filtered_baseline) From 479028eb02fea1713e84156d5296f9c0e5147f00 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 18 Feb 2025 10:53:31 +0000 Subject: [PATCH 265/291] plotting precipiation for baseline years (1940 - 1980) --- .../plotting_heavy_precipitation.py | 28 +++++++++++++++---- 1 file changed, 23 insertions(+), 5 deletions(-) diff --git a/src/scripts/climate_change/plotting_heavy_precipitation.py b/src/scripts/climate_change/plotting_heavy_precipitation.py index 5a8a4516c2..0754133cc9 100644 --- a/src/scripts/climate_change/plotting_heavy_precipitation.py +++ b/src/scripts/climate_change/plotting_heavy_precipitation.py @@ -112,15 +112,32 @@ historical_weather = historical_weather.to_frame(name='mean_precipitation') historical_weather.reset_index() historical_weather_sum = historical_weather.groupby(historical_weather.index // 12).sum() + +baseline_weather = pd.read_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_ANC_lm_baseline.csv", + index_col=0) +baseline_weather = baseline_weather.mean(axis = 1) +baseline_weather = baseline_weather.to_frame(name='mean_precipitation') +baseline_weather.reset_index() +baseline_weather_sum = baseline_weather.groupby(baseline_weather.index // 12).sum() + for i, ssp_scenario in enumerate(ssp_scenarios): axes[i].plot( - range(len(historical_weather_sum)), + range(len(baseline_weather_sum),len(baseline_weather_sum) + len(historical_weather_sum)), historical_weather_sum, color="#312F2F", linewidth=2, linestyle='--', label='ERA5' ) + axes[i].plot( + range(len(baseline_weather_sum)), + baseline_weather_sum, + color="#A03E99", + linewidth=2, + linestyle='--', + label='1940-1980' + ) for model in model_types: weather_data_prediction_monthly_original = pd.read_csv( f"{data_path}Precipitation_data/Downscaled_CMIP6_data_CIL/{ssp_scenario}/{model}_monthly_prediction_weather_by_facility.csv", @@ -134,14 +151,15 @@ y_data.index // 12 ).sum() axes[i].plot( - range(len(historical_weather_sum), len(historical_weather_sum) + len(y_data)), + range(len(baseline_weather_sum) + len(historical_weather_sum), len(baseline_weather_sum) + len(historical_weather_sum) + len(y_data)), y_data['mean_precipitation'], label=f"{model}", ) # Fix xticks and labels - axes[i].set_xticks(range(0,len(historical_weather_sum) + len(y_data), 10)) - axes[i].set_xticklabels(range(2010, 2071, 10)) + axes[i].set_xticks(range(0,len(baseline_weather_sum) + len(historical_weather_sum) + len(y_data), 10)) + years = list(range(1940, 1971, 10)) + list(range(2010, 2071, 10)) + axes[i].set_xticklabels(years) axes[i].set_title(ssp_scenario.upper()) axes[i].set_xlabel('Year') if i == 0: @@ -149,4 +167,4 @@ axes[i].legend() plt.tight_layout() -plt.savefig('/Users/rem76/Desktop/Climate_change_health/Results/ANC_disruptions/histroical_future_precip_annual_selected_models.png') +plt.savefig('/Users/rem76/Desktop/Climate_change_health/Results/ANC_disruptions/histroical_baseline_future_precip_annual_selected_models.png') From 4349c6fe8d56a8de8e78ac40a05b34ca88d1930f Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 18 Feb 2025 13:51:13 +0000 Subject: [PATCH 266/291] Added baseline graph of 1940 - 1980 --- src/scripts/climate_change/cohort_model.py | 107 ++++++++++++++++----- 1 file changed, 81 insertions(+), 26 deletions(-) diff --git a/src/scripts/climate_change/cohort_model.py b/src/scripts/climate_change/cohort_model.py index 312cc05676..9c5ab3716c 100644 --- a/src/scripts/climate_change/cohort_model.py +++ b/src/scripts/climate_change/cohort_model.py @@ -544,56 +544,55 @@ ####### Historical disruptions ########## -historical_predictions = pd.read_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/results_of_model_historical_predictions_{service}.csv') -historical_predictions = historical_predictions.loc[historical_predictions['Difference_in_Expectation'] < 0] +baseline_predictions = pd.read_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_baseline_{service}.csv') +baseline_predictions = baseline_predictions.loc[baseline_predictions['Difference_in_Expectation'] < 0] -historical_predictions_sum = historical_predictions.groupby('District').sum().reset_index() -historical_predictions_sum['Percentage_Difference'] = ( - historical_predictions_sum['Difference_in_Expectation'] / historical_predictions_sum['Predicted_No_Weather_Model'] +baseline_predictions_sum = baseline_predictions.groupby('District').sum().reset_index() +baseline_predictions_sum['Percentage_Difference'] = ( + baseline_predictions_sum['Difference_in_Expectation'] / baseline_predictions_sum['Predicted_No_Weather_Model'] ) * 100 -historical_predictions_sum['District'] = historical_predictions_sum['District'].replace( +baseline_predictions_sum['District'] = baseline_predictions_sum['District'].replace( {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} ) -percentage_diff_by_district_historical = historical_predictions_sum.groupby('District')['Percentage_Difference'].mean() -malawi_admin2['Percentage_Difference_historical'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district_historical) -malawi_admin2.loc[malawi_admin2['Percentage_Difference_historical'] > 0, 'Percentage_Difference_historical'] = 0 -malawi_admin2['Percentage_Difference_historical'] = malawi_admin2['Percentage_Difference_historical'].abs() # for mapping, to show % - -percentage_diff_by_district_historical_average = historical_predictions_sum['Percentage_Difference'].mean() -filtered_predictions = historical_predictions[historical_predictions['Precipitation'] >= precipitation_threshold] -filtered_predictions_sum = filtered_predictions.groupby('Year').sum().reset_index() -percent_due_to_extreme = filtered_predictions_sum['Difference_in_Expectation'].sum() -percent_due_to_extreme = percent_due_to_extreme/historical_predictions['Difference_in_Expectation'].sum() -print(percent_due_to_extreme) +percentage_diff_by_district_baseline = baseline_predictions_sum.groupby('District')['Percentage_Difference'].mean() +malawi_admin2['Percentage_Difference_baseline'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district_baseline) +malawi_admin2.loc[malawi_admin2['Percentage_Difference_baseline'] > 0, 'Percentage_Difference_baseline'] = 0 +malawi_admin2['Percentage_Difference_baseline'] = malawi_admin2['Percentage_Difference_baseline'].abs() # for mapping, to show % + +percentage_diff_by_district_baseline_average = baseline_predictions_sum['Percentage_Difference'].mean() +filtered_predictions_baseline = baseline_predictions[baseline_predictions['Precipitation'] >= precipitation_threshold] +filtered_predictions_baseline_sum = filtered_predictions_baseline.groupby('Year').sum().reset_index() +percent_due_to_extreme_baseline = filtered_predictions_baseline_sum['Difference_in_Expectation'].sum() +percent_due_to_extreme_baseline = percent_due_to_extreme_baseline/baseline_predictions['Difference_in_Expectation'].sum() +print(percent_due_to_extreme_baseline) fig, ax = plt.subplots(figsize=(10, 10)) water_bodies.plot(ax=ax, facecolor="none", edgecolor="#999999", linewidth=0.5, hatch="xxx") water_bodies.plot(ax=ax, facecolor="none", edgecolor="black", linewidth=1) - -malawi_admin2.dropna(subset=['Percentage_Difference_historical']).plot( +print(malawi_admin2['Percentage_Difference_baseline']) +malawi_admin2.dropna(subset=['Percentage_Difference_baseline']).plot( ax=ax, - column='Percentage_Difference_historical', + column='Percentage_Difference_baseline', cmap='Blues', edgecolor='black', alpha=1, legend=False, - vmin=global_min, - vmax=global_max + # vmin=0, + # vmax=0.04 ) ax.set_ylabel("Latitude", fontsize=10) ax.set_xlabel("Longitude", fontsize=10) - sm = plt.cm.ScalarMappable( cmap='Blues', - norm=mcolors.Normalize(vmin=global_min, vmax=global_max) + #norm=mcolors.Normalize(vmin=global_min, vmax=global_max) ) sm.set_array([]) fig.colorbar(sm, ax=ax, orientation="vertical", shrink=0.8, label="Percentage Difference (%)") -plt.title("", fontsize=16) -plt.savefig(results_folder_to_save / 'percentage_difference_map_historical.png') +plt.title("Baseline", fontsize=16) +plt.savefig(results_folder_to_save / 'percentage_difference_map_baseline.png') plt.show() @@ -640,6 +639,62 @@ print(result_df_historical) result_df_historical.to_csv(f'/Users/rem76/Desktop/Climate_change_health/Results/{service}_disruptions/negative_sums_and_percentages_historical.csv', index=False) +###### Baseline historical disruptions ####### + +####### Historical disruptions ########## + + +historical_predictions = pd.read_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/results_of_model_historical_predictions_{service}.csv') +historical_predictions = historical_predictions.loc[historical_predictions['Difference_in_Expectation'] < 0] + +historical_predictions_sum = historical_predictions.groupby('District').sum().reset_index() +historical_predictions_sum['Percentage_Difference'] = ( + historical_predictions_sum['Difference_in_Expectation'] / historical_predictions_sum['Predicted_No_Weather_Model'] +) * 100 + +historical_predictions_sum['District'] = historical_predictions_sum['District'].replace( + {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} +) + +percentage_diff_by_district_historical = historical_predictions_sum.groupby('District')['Percentage_Difference'].mean() +malawi_admin2['Percentage_Difference_historical'] = malawi_admin2['ADM2_EN'].map(percentage_diff_by_district_historical) +malawi_admin2.loc[malawi_admin2['Percentage_Difference_historical'] > 0, 'Percentage_Difference_historical'] = 0 +malawi_admin2['Percentage_Difference_historical'] = malawi_admin2['Percentage_Difference_historical'].abs() # for mapping, to show % + +percentage_diff_by_district_historical_average = historical_predictions_sum['Percentage_Difference'].mean() +filtered_predictions = historical_predictions[historical_predictions['Precipitation'] >= precipitation_threshold] +filtered_predictions_sum = filtered_predictions.groupby('Year').sum().reset_index() +percent_due_to_extreme = filtered_predictions_sum['Difference_in_Expectation'].sum() +percent_due_to_extreme = percent_due_to_extreme/historical_predictions['Difference_in_Expectation'].sum() +print(percent_due_to_extreme) +fig, ax = plt.subplots(figsize=(10, 10)) +water_bodies.plot(ax=ax, facecolor="none", edgecolor="#999999", linewidth=0.5, hatch="xxx") +water_bodies.plot(ax=ax, facecolor="none", edgecolor="black", linewidth=1) + +malawi_admin2.dropna(subset=['Percentage_Difference_historical']).plot( + ax=ax, + column='Percentage_Difference_historical', + cmap='Blues', + edgecolor='black', + alpha=1, + legend=False, + vmin=global_min, + vmax=global_max +) + +ax.set_ylabel("Latitude", fontsize=10) +ax.set_xlabel("Longitude", fontsize=10) + +sm = plt.cm.ScalarMappable( + cmap='Blues', + norm=mcolors.Normalize(vmin=global_min, vmax=global_max) +) +sm.set_array([]) +fig.colorbar(sm, ax=ax, orientation="vertical", shrink=0.8, label="Percentage Difference (%)") + +plt.title("", fontsize=16) +plt.savefig(results_folder_to_save / 'percentage_difference_map_historical.png') +plt.show() ###### Effect of CYCLONE FREDDY ####### From 7e3718f35ff9d5d320fb1e6a55ccfe02af1d3b21 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 18 Feb 2025 13:51:21 +0000 Subject: [PATCH 267/291] tidy --- ..._model_historical_realtionship_reporting_precipitation.py | 5 ----- 1 file changed, 5 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 688158ff66..37dca2a88a 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -1078,8 +1078,3 @@ def get_weather_data(ssp_scenario, model_type): # Save the results full_data_weather_predictions.to_csv(f"{data_path}weather_predictions_with_X_baseline_{service}.csv", index=False) - -X_basis_weather_filtered = pd.DataFrame(X_basis_weather_filtered_baseline) - -# Save to CSV -full_data_weather_predictions.to_csv(f"{data_path}weather_predictions_with_X_baseline_{service}.csv", index=False) From cb8f077b0432c0cf1a7e32382ceb3561dc94ffb5 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 18 Feb 2025 14:41:18 +0000 Subject: [PATCH 268/291] allowed saving of expanded info for baseline - the average precip will be different between them --- ...d_monthly_weather_data_small_facilities.py | 66 +++++++++++-------- 1 file changed, 37 insertions(+), 29 deletions(-) diff --git a/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py b/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py index cf63dbf43d..b5b2f0d4d9 100644 --- a/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py +++ b/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py @@ -139,29 +139,17 @@ ### Get data ready for linear regression between reporting and weather data weather_df = pd.DataFrame.from_dict(weather_data_by_facility, orient='index').T weather_df.columns = facilities_with_location -if not baseline: - monthly_reporting_by_facility = monthly_reporting_by_facility.set_index('facility').T - monthly_reporting_by_facility.index.name = "date" - # ### Save CSVs - monthly_reporting_by_facility = monthly_reporting_by_facility.loc[:, monthly_reporting_by_facility.columns.isin(facilities_with_location)] - monthly_reporting_by_facility = monthly_reporting_by_facility[facilities_with_location] - - #monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm.csv") +monthly_reporting_by_facility = monthly_reporting_by_facility.set_index('facility').T +monthly_reporting_by_facility.index.name = "date" +# ### Save CSVs +monthly_reporting_by_facility = monthly_reporting_by_facility.loc[:, + monthly_reporting_by_facility.columns.isin(facilities_with_location)] +monthly_reporting_by_facility = monthly_reporting_by_facility[facilities_with_location] - if ANC: - monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_ANC_by_smaller_facility_lm.csv") - weather_df.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_ANC_lm.csv") - if Inpatient: - monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_Inpatient_by_smaller_facility_lm.csv") - weather_df.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_Inpatient_lm.csv") - - else: - monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm.csv") - weather_df.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facility_lm.csv") +# monthly_reporting_by_facility.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm.csv") - - for facility in facilities_with_location: - print(facility) +for facility in facilities_with_location: + print(facility) ## Get additional data - e.g. which zone it is in, altitude included_facilities_with_lat_long = facilities_with_lat_long[ facilities_with_lat_long["Fname"].isin(facilities_with_location) @@ -197,22 +185,42 @@ ) expanded_facility_info = expanded_facility_info.T expanded_facility_info = expanded_facility_info.reindex(columns=facilities_with_location) - if ANC: - expanded_facility_info.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_with_ANC.csv") - elif Inpatient: - expanded_facility_info.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_with_inpatient_days.csv") - - else: - expanded_facility_info.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm.csv") if baseline: if ANC: weather_df.to_csv( "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_ANC_lm_baseline.csv") + expanded_facility_info.to_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_with_ANC_baseline.csv") + if Inpatient: weather_df.to_csv( "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_Inpatient_lm_baseline.csv") - + expanded_facility_info.to_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_with_Inpatient_baseline.csv") else: weather_df.to_csv( "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facility_lm_baseline.csv") + expanded_facility_info.to_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_baseline.csv") + + + +else: + if ANC: + weather_df.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_ANC_lm.csv") + expanded_facility_info.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_with_ANC.csv") + monthly_reporting_by_facility.to_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_ANC_by_smaller_facility_lm.csv") + + if Inpatient: + weather_df.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_Inpatient_lm.csv") + expanded_facility_info.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_with_inpatient_days.csv") + monthly_reporting_by_facility.to_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_Inpatient_by_smaller_facility_lm.csv") + + else: + weather_df.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facility_lm.csv") + expanded_facility_info.to_csv("/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm.csv") + monthly_reporting_by_facility.to_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/monthly_reporting_by_smaller_facility_lm.csv") From 1d3298d5dc395a9bdfc90656ce55bc9bbddd46da Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 18 Feb 2025 17:16:04 +0000 Subject: [PATCH 269/291] tidied and then transported year --- ...al_realtionship_reporting_precipitation.py | 36 +++++++++++-------- 1 file changed, 22 insertions(+), 14 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 37dca2a88a..cb4c683b71 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -32,7 +32,8 @@ baseline_years = range(1940, 1980) min_year_for_analysis_baseline = min(baseline_years) + 1 absolute_min_year_baseline = min(baseline_years) -max_year_for_analysis_baseline = max(baseline_years) + 1 +max_year_for_analysis_baseline = 1950 #max(baseline_years) + 1 +absolute_max_year_baseline = max(baseline_years) + 1 poisson = False log_y = True @@ -887,33 +888,36 @@ def get_weather_data(ssp_scenario, model_type): lag_4_month_baseline = weather_data_monthly_20th_century.shift(4).values lag_9_month_baseline = weather_data_monthly_20th_century.shift(9).values - lag_1_month_baseline = lag_1_month_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:].flatten() - lag_2_month_baseline = lag_2_month_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:].flatten() - lag_3_month_baseline = lag_3_month_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:].flatten() - lag_4_month_baseline = lag_4_month_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:].flatten() - lag_9_month_baseline = lag_9_month_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:].flatten() + lag_1_month_baseline = lag_1_month_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:(max_year_for_analysis_baseline - absolute_max_year_baseline) * 12].flatten() + lag_2_month_baseline = lag_2_month_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:(max_year_for_analysis_baseline - absolute_max_year_baseline) * 12].flatten() + lag_3_month_baseline = lag_3_month_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:(max_year_for_analysis_baseline - absolute_max_year_baseline) * 12].flatten() + lag_4_month_baseline = lag_4_month_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:(max_year_for_analysis_baseline - absolute_max_year_baseline) * 12].flatten() + lag_9_month_baseline = lag_9_month_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:(max_year_for_analysis_baseline - absolute_max_year_baseline) * 12].flatten() lag_1_5_day_baseline = weather_data_five_day_cumulative_20th_century.shift(1).values lag_2_5_day_baseline = weather_data_five_day_cumulative_20th_century.shift(2).values lag_3_5_day_baseline = weather_data_five_day_cumulative_20th_century.shift(3).values lag_4_5_day_baseline = weather_data_five_day_cumulative_20th_century.shift(4).values lag_9_5_day_baseline = weather_data_five_day_cumulative_20th_century.shift(9).values - lag_1_5_day_baseline = lag_1_5_day_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:].flatten() - lag_2_5_day_baseline = lag_2_5_day_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:].flatten() - lag_3_5_day_baseline = lag_3_5_day_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:].flatten() - lag_4_5_day_baseline = lag_4_5_day_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:].flatten() - lag_9_5_day_baseline = lag_9_5_day_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:].flatten() + lag_1_5_day_baseline = lag_1_5_day_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:(max_year_for_analysis_baseline - absolute_max_year_baseline) * 12].flatten() + lag_2_5_day_baseline = lag_2_5_day_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:(max_year_for_analysis_baseline - absolute_max_year_baseline) * 12].flatten() + lag_3_5_day_baseline = lag_3_5_day_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:(max_year_for_analysis_baseline - absolute_max_year_baseline) * 12].flatten() + lag_4_5_day_baseline = lag_4_5_day_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:(max_year_for_analysis_baseline - absolute_max_year_baseline) * 12].flatten() + lag_9_5_day_baseline = lag_9_5_day_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:(max_year_for_analysis_baseline - absolute_max_year_baseline) * 12].flatten() + print("one month", len(lag_1_5_day_baseline)) # need for binary lag_12_month_baseline = weather_data_monthly_20th_century.shift(12).values - lag_12_month_baseline = lag_12_month_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:].flatten() + lag_12_month_baseline = lag_12_month_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:(max_year_for_analysis_baseline - absolute_max_year_baseline) * 12].flatten() # process weather_data_monthly_20th_century = weather_data_monthly_20th_century.iloc[ (min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:] + weather_data_monthly_20th_century = weather_data_monthly_20th_century.iloc[:(max_year_for_analysis_baseline - absolute_max_year_baseline) * 12] weather_data_five_day_cumulative_20th_century = weather_data_five_day_cumulative_20th_century.iloc[ (min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:] + weather_data_five_day_cumulative_20th_century = weather_data_five_day_cumulative_20th_century.iloc[:(max_year_for_analysis_baseline - absolute_max_year_baseline) * 12] weather_data_monthly_flattened = weather_data_monthly_20th_century.values.flatten() weather_data_five_day_cumulative_flattened = weather_data_five_day_cumulative_20th_century.values.flatten() @@ -922,16 +926,20 @@ def get_weather_data(ssp_scenario, model_type): # covariates year_range_baseline = range(min_year_for_analysis_baseline, max_year_for_analysis_baseline, 1) -year_repeated_baseline = [y for y in year_range_baseline for _ in range(12)] +#year_repeated_baseline = [y for y in year_range_baseline for _ in range(12)] +year_repeated_baseline = [y for y in range(min_year_for_analysis,max_year_for_analysis) for _ in range(12)] # "transpose' + year_flattened_baseline = year_repeated_baseline*num_facilities_baseline # to get flattened data -#year_flattened_baseline = [2015] * len(year_flattened_baseline) + month_repeated = [] for _ in year_range_baseline: month_repeated.extend(range(1, 13)) month_flattened_baseline = month_repeated*num_facilities_baseline +print("month",len(month_flattened_baseline)) zone_info_each_month_baseline = repeat_info(expanded_facility_info["Zonename"], num_facilities_baseline, year_range_baseline, historical = False) zone_encoded_baseline = pd.get_dummies(zone_info_each_month_baseline, drop_first=True) +print("zone",len(zone_encoded_baseline)) dist_info_each_month_baseline = repeat_info(expanded_facility_info["Dist"], num_facilities_baseline, year_range_baseline, historical = False) dist_encoded_baseline = pd.get_dummies(dist_info_each_month_baseline, drop_first=True) resid_info_each_month_baseline = repeat_info(expanded_facility_info['Resid'], num_facilities_baseline, year_range_baseline, historical = False) From 1303222da60358e23d36aff50c758aa72e3114ce Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Tue, 18 Feb 2025 17:22:47 +0000 Subject: [PATCH 270/291] tidied and then transported year --- ...model_historical_realtionship_reporting_precipitation.py | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index cb4c683b71..7189ec974c 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -926,11 +926,9 @@ def get_weather_data(ssp_scenario, model_type): # covariates year_range_baseline = range(min_year_for_analysis_baseline, max_year_for_analysis_baseline, 1) -#year_repeated_baseline = [y for y in year_range_baseline for _ in range(12)] -year_repeated_baseline = [y for y in range(min_year_for_analysis,max_year_for_analysis) for _ in range(12)] # "transpose' - +year_repeated_baseline = [y for y in year_range_baseline for _ in range(12)] year_flattened_baseline = year_repeated_baseline*num_facilities_baseline # to get flattened data - +year_flattened_baseline = [2015] * len(year_flattened_baseline) month_repeated = [] for _ in year_range_baseline: month_repeated.extend(range(1, 13)) From 1ec86a5d27367aab339be680a197fe27a644eb5e Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 19 Feb 2025 09:12:58 +0000 Subject: [PATCH 271/291] made it so the "year" for the baseline analysis was 2012 - 2024 --- ...al_realtionship_reporting_precipitation.py | 46 +++++++++---------- 1 file changed, 21 insertions(+), 25 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 7189ec974c..850d854bbb 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -8,20 +8,15 @@ from statsmodels.stats.outliers_influence import variance_inflation_factor from sklearn.feature_selection import SelectKBest, f_regression import scipy.stats as stats + + ANC = True Inpatient = False if ANC: service = 'ANC' if Inpatient: service = 'Inpatient' -daily_max = False -daily_total = False -if daily_total: - five_day = True - cumulative = True -else: - five_day = False - cumulative = False + feature_selection = False use_all_weather = True min_year_for_analysis = 2012 @@ -29,11 +24,14 @@ mask_threshold = -np.inf # accounts for scaling #mask_threshold = 50 use_percentile_mask_threshold = False -baseline_years = range(1940, 1980) -min_year_for_analysis_baseline = min(baseline_years) + 1 -absolute_min_year_baseline = min(baseline_years) -max_year_for_analysis_baseline = 1950 #max(baseline_years) + 1 -absolute_max_year_baseline = max(baseline_years) + 1 +year_range = range(min_year_for_analysis, 2025, 1) # year as a fixed effect + +baseline_years_for_file = range(1940, 1980) +min_year_for_analysis_baseline = min(baseline_years_for_file) + 1 +absolute_min_year_baseline = min(baseline_years_for_file) +max_year_for_analysis_baseline = 1940 + len(year_range) +absolute_max_year_baseline = max(baseline_years_for_file) + 1 +baseline_years_for_analysis = range(min_year_for_analysis_baseline, max_year_for_analysis_baseline) poisson = False log_y = True @@ -229,7 +227,6 @@ def repeat_info(info, num_facilities, year_range, historical): # Linear regression month_range = range(12) num_facilities = len(monthly_reporting_by_facility.columns) -year_range = range(min_year_for_analysis, 2025, 1) # year as a fixed effect year_repeated = [y for y in year_range for _ in range(12)] year = year_repeated[:-4] year_flattened = year*len(monthly_reporting_by_facility.columns) # to get flattened data @@ -875,7 +872,7 @@ def get_weather_data(ssp_scenario, model_type): ) weather_data_five_day_cumulative_20th_century = pd.read_csv( - f"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/historical_{min(baseline_years)}_{max(baseline_years)}_daily_total_by_facilities_with_ANC_five_day_cumulative.csv", + f"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/historical_{min(baseline_years_for_file)}_{max(baseline_years_for_file)}_daily_total_by_facilities_with_ANC_five_day_cumulative.csv", index_col=0 ) @@ -925,29 +922,28 @@ def get_weather_data(ssp_scenario, model_type): (weather_data_monthly_flattened, weather_data_five_day_cumulative_flattened)).T # covariates -year_range_baseline = range(min_year_for_analysis_baseline, max_year_for_analysis_baseline, 1) -year_repeated_baseline = [y for y in year_range_baseline for _ in range(12)] +year_repeated_baseline = [y for y in baseline_years_for_analysis for _ in range(12)] year_flattened_baseline = year_repeated_baseline*num_facilities_baseline # to get flattened data year_flattened_baseline = [2015] * len(year_flattened_baseline) month_repeated = [] -for _ in year_range_baseline: +for _ in baseline_years_for_analysis: month_repeated.extend(range(1, 13)) month_flattened_baseline = month_repeated*num_facilities_baseline print("month",len(month_flattened_baseline)) -zone_info_each_month_baseline = repeat_info(expanded_facility_info["Zonename"], num_facilities_baseline, year_range_baseline, historical = False) +zone_info_each_month_baseline = repeat_info(expanded_facility_info["Zonename"], num_facilities_baseline, baseline_years_for_analysis, historical = False) zone_encoded_baseline = pd.get_dummies(zone_info_each_month_baseline, drop_first=True) print("zone",len(zone_encoded_baseline)) -dist_info_each_month_baseline = repeat_info(expanded_facility_info["Dist"], num_facilities_baseline, year_range_baseline, historical = False) +dist_info_each_month_baseline = repeat_info(expanded_facility_info["Dist"], num_facilities_baseline, baseline_years_for_analysis, historical = False) dist_encoded_baseline = pd.get_dummies(dist_info_each_month_baseline, drop_first=True) -resid_info_each_month_baseline = repeat_info(expanded_facility_info['Resid'], num_facilities_baseline, year_range_baseline, historical = False) +resid_info_each_month_baseline = repeat_info(expanded_facility_info['Resid'], num_facilities_baseline, baseline_years_for_analysis, historical = False) resid_encoded_baseline = pd.get_dummies(resid_info_each_month_baseline, drop_first=True) -owner_info_each_month_baseline = repeat_info(expanded_facility_info['A105'], num_facilities_baseline, year_range_baseline, historical = False) +owner_info_each_month_baseline = repeat_info(expanded_facility_info['A105'], num_facilities_baseline, baseline_years_for_analysis, historical = False) owner_encoded_baseline = pd.get_dummies(owner_info_each_month_baseline, drop_first=True) -ftype_info_each_month_baseline = repeat_info(expanded_facility_info['Ftype'], num_facilities_baseline, year_range_baseline, historical = False) +ftype_info_each_month_baseline = repeat_info(expanded_facility_info['Ftype'], num_facilities_baseline, baseline_years_for_analysis, historical = False) ftype_encoded_baseline = pd.get_dummies(ftype_info_each_month_baseline, drop_first=True) -altitude_baseline = [float(x) for x in repeat_info(expanded_facility_info['A109__Altitude'], num_facilities_baseline, year_range_baseline, historical = False)] -minimum_distance_baseline = [float(x) for x in repeat_info(expanded_facility_info['minimum_distance'], num_facilities_baseline, year_range_baseline, historical = False)] +altitude_baseline = [float(x) for x in repeat_info(expanded_facility_info['A109__Altitude'], num_facilities_baseline, baseline_years_for_analysis, historical = False)] +minimum_distance_baseline = [float(x) for x in repeat_info(expanded_facility_info['minimum_distance'], num_facilities_baseline, baseline_years_for_analysis, historical = False)] altitude_baseline = np.array(altitude_baseline) altitude_baseline = np.where(altitude_baseline < 0, np.nan, altitude_baseline) From 757ebb5157a17b3ef8bd88e763f8a445924515da Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 19 Feb 2025 10:17:58 +0000 Subject: [PATCH 272/291] made it so the "year" for the baseline analysis was 2012 - 2024 --- ...near_model_historical_realtionship_reporting_precipitation.py | 1 - 1 file changed, 1 deletion(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 850d854bbb..21d0d55858 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -32,7 +32,6 @@ max_year_for_analysis_baseline = 1940 + len(year_range) absolute_max_year_baseline = max(baseline_years_for_file) + 1 baseline_years_for_analysis = range(min_year_for_analysis_baseline, max_year_for_analysis_baseline) - poisson = False log_y = True From 362a972996b1bab8bbd6c4aac083b53674c566ec Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 19 Feb 2025 11:47:31 +0000 Subject: [PATCH 273/291] changed average precipitation for the baseline scenario to be 1941-1953 --- .../plot_raw_reanalysis_data.py | 40 ++++++++++++++++--- ...d_monthly_weather_data_small_facilities.py | 15 ++++--- 2 files changed, 45 insertions(+), 10 deletions(-) diff --git a/src/scripts/climate_change/plot_raw_reanalysis_data.py b/src/scripts/climate_change/plot_raw_reanalysis_data.py index dea18a1928..e9e94e9e90 100644 --- a/src/scripts/climate_change/plot_raw_reanalysis_data.py +++ b/src/scripts/climate_change/plot_raw_reanalysis_data.py @@ -12,6 +12,7 @@ from shapely.geometry import Polygon # Load the dataset and the variable +baseline = True file_path_historical_data = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/2011/60ab007aa16d679a32f9c3e186d2f744.nc" dataset = Dataset(file_path_historical_data, mode='r') print(dataset.variables.keys()) @@ -69,10 +70,16 @@ ax.axhline(y=lat, color=colors(idx), linestyle='--', linewidth=0.5) # Add in facility information -expanded_facility_info = pd.read_csv( - "/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_with_ANC.csv", - index_col=0 -) +if baseline: + expanded_facility_info = pd.read_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_with_ANC_baseline.csv", + index_col=0 + ) +else: + expanded_facility_info = pd.read_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_with_ANC.csv", + index_col=0 + ) long_format = expanded_facility_info.T.reset_index() long_format.columns = [ @@ -108,6 +115,29 @@ cbar.set_label('Mean Monthly Precipitation (mm)') plt.xlabel("Longitude") plt.ylabel("Latitude") -plt.savefig('/Users/rem76/Desktop/Climate_change_health/Results/ANC_disruptions/historical_weather.png') +if baseline: + plt.savefig('/Users/rem76/Desktop/Climate_change_health/Results/ANC_disruptions/baseline_weather.png') + +else: + plt.savefig('/Users/rem76/Desktop/Climate_change_health/Results/ANC_disruptions/historical_weather.png') + +plt.show() + +### compare baseline and non-baseline data + +expanded_facility_info_baseline = pd.read_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_with_ANC_baseline.csv", + index_col=0 + ).T + +expanded_facility_info = pd.read_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/expanded_facility_info_by_smaller_facility_lm_with_ANC.csv", + index_col=0 + ).T +expanded_facility_info_baseline['average_precipitation'] = pd.to_numeric(expanded_facility_info_baseline['average_precipitation'], errors='coerce') +expanded_facility_info['average_precipitation'] = pd.to_numeric(expanded_facility_info['average_precipitation'], errors='coerce') +plt.plot(range(len(expanded_facility_info_baseline['average_precipitation'])), expanded_facility_info_baseline['average_precipitation'], label='baseline') +plt.plot(range(len(expanded_facility_info['average_precipitation'])), expanded_facility_info['average_precipitation'], label='historical') +plt.legend(loc='upper right') plt.show() diff --git a/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py b/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py index b5b2f0d4d9..88589c60db 100644 --- a/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py +++ b/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py @@ -169,11 +169,16 @@ distances = cdist(coordinates, coordinates, metric='euclidean') np.fill_diagonal(distances, np.inf) expanded_facility_info['minimum_distance'] = np.nanmin(distances, axis=1) - - average_precipitation_by_facility = { - facility: np.mean(precipitation) - for facility, precipitation in weather_data_by_facility.items() - } + if baseline: + average_precipitation_by_facility = { + facility: np.mean(precipitation[12: 12*(1953 - 1941)]) + for facility, precipitation in weather_data_by_facility.items() + } + else: + average_precipitation_by_facility = { + facility: np.mean(precipitation) + for facility, precipitation in weather_data_by_facility.items() + } average_precipitation_df = pd.DataFrame.from_dict( average_precipitation_by_facility, orient='index', columns=['average_precipitation'] From 2566b9d524de7b7bca3604069ea530c9f66395dd Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 19 Feb 2025 13:46:46 +0000 Subject: [PATCH 274/291] changed average precipitation for the baseline scenario to be 1941-1953 --- ...r_model_historical_realtionship_reporting_precipitation.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 21d0d55858..c7d0b22eb2 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -921,9 +921,9 @@ def get_weather_data(ssp_scenario, model_type): (weather_data_monthly_flattened, weather_data_five_day_cumulative_flattened)).T # covariates -year_repeated_baseline = [y for y in baseline_years_for_analysis for _ in range(12)] +year_repeated_baseline = [y for y in range(2012, 2012 + len(baseline_years_for_analysis)) for _ in range(12)] year_flattened_baseline = year_repeated_baseline*num_facilities_baseline # to get flattened data -year_flattened_baseline = [2015] * len(year_flattened_baseline) +#year_flattened_baseline = [2015] * len(year_flattened_baseline) month_repeated = [] for _ in baseline_years_for_analysis: month_repeated.extend(range(1, 13)) From e4f2ee0414a27810e3c14c3a198d3289d1892c9a Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 19 Feb 2025 14:00:14 +0000 Subject: [PATCH 275/291] tidied graphs --- src/scripts/climate_change/cohort_model.py | 54 +++++++++++++++++++--- 1 file changed, 47 insertions(+), 7 deletions(-) diff --git a/src/scripts/climate_change/cohort_model.py b/src/scripts/climate_change/cohort_model.py index 9c5ab3716c..e9ad3a97c2 100644 --- a/src/scripts/climate_change/cohort_model.py +++ b/src/scripts/climate_change/cohort_model.py @@ -83,7 +83,7 @@ # # # Get expected disturbance from the model results_list = [] - +# #Loop through scenarios and model types for scenario in scenarios: for model_type in model_types: @@ -541,7 +541,7 @@ #plt.show() # -####### Historical disruptions ########## +####### BASELINE HISTORICAL disruptions ########## baseline_predictions = pd.read_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_baseline_{service}.csv') @@ -584,19 +584,59 @@ ax.set_ylabel("Latitude", fontsize=10) ax.set_xlabel("Longitude", fontsize=10) -sm = plt.cm.ScalarMappable( - cmap='Blues', - #norm=mcolors.Normalize(vmin=global_min, vmax=global_max) -) +sm = plt.cm.ScalarMappable(cmap='Blues', norm=mcolors.Normalize(vmin=malawi_admin2['Percentage_Difference_baseline'].min(), + vmax=malawi_admin2['Percentage_Difference_baseline'].max())) sm.set_array([]) fig.colorbar(sm, ax=ax, orientation="vertical", shrink=0.8, label="Percentage Difference (%)") -plt.title("Baseline", fontsize=16) +#plt.title("Baseline", fontsize=16) plt.savefig(results_folder_to_save / 'percentage_difference_map_baseline.png') plt.show() +# #### Now do number of births based on the TLO model (2010 - 2024) and 2018 census, but with counterfactual precipitation +# i.e. use births_model_subset_historical, as it is what would have been +baseline_predictions_negative = baseline_predictions.loc[baseline_predictions['Difference_in_Expectation'] < 0] +baseline_predictions_negative = baseline_predictions_negative[baseline_predictions_negative['Year'] <= 2024] + # total disruptions +baseline_predictions_negative_sum = baseline_predictions_negative.groupby('Year').sum().reset_index() +baseline_predictions_negative_sum['Percentage_Difference'] = ( + baseline_predictions_negative_sum['Difference_in_Expectation'] / baseline_predictions_negative_sum[ + 'Predicted_No_Weather_Model']) + # Match birth results and predictions +multiplied_values_baseline = births_model_subset_historical.values * baseline_predictions_negative_sum[ + 'Percentage_Difference'].values * 1.4 # 1.4 is conversion from births to pregnacnies + +# Check for negative values (missed cases?) +negative_sum_baseline = np.sum(multiplied_values_baseline[multiplied_values_baseline < 0]) + +# now do extreme precipitation by district and year, use original dataframe to get monthly top 10% precip +filtered_predictions_baseline = baseline_predictions_negative[baseline_predictions_negative['Precipitation'] >= precipitation_threshold] +filtered_predictions_sum_baseline = filtered_predictions_baseline.groupby('Year').sum().reset_index() +percent_due_to_extreme_baseline = filtered_predictions_sum_baseline['Difference_in_Expectation'] / baseline_predictions_negative_sum['Predicted_No_Weather_Model'] +print(percent_due_to_extreme_baseline) +multiplied_values_extreme_precip_baseline = births_model_subset_historical.values * percent_due_to_extreme_baseline.values * 1.4 +negative_sum_extreme_precip_baseline = np.sum(multiplied_values_extreme_precip_baseline[multiplied_values_extreme_precip_baseline < 0]) +result_df_baseline = pd.DataFrame({ + "Negative_Sum": [negative_sum_baseline], + "Negative_Percentage": [negative_sum_baseline / (births_model_subset_historical.sum() * 1.4) * 100], + "Extreme_Precip": [negative_sum_extreme_precip_baseline], + "Extreme_Precip_Percentage": [(negative_sum_extreme_precip_baseline / negative_sum_baseline) * 100] + }) + +# Save multiplied values by model and scenario +multiplied_values_df_baseline = pd.DataFrame({ + 'Year': range(2012, 2025), + 'Multiplied_Values': multiplied_values_baseline, + 'Multiplied_Values_extreme_precip': multiplied_values_extreme_precip_baseline + + }) +multiplied_values_df_baseline.to_csv(results_folder_to_save/f'multiplied_values_baseline.csv', index=False) + +print(result_df_baseline) +result_df_baseline.to_csv(f'/Users/rem76/Desktop/Climate_change_health/Results/{service}_disruptions/negative_sums_and_percentages_baseline.csv', index=False) +### HISTORICAL disruptions ######### # #### Now do number of births based on the TLO model (2010 - 2024) and 2018 census historical_predictions_negative = historical_predictions.loc[historical_predictions['Difference_in_Expectation'] < 0] From a28744885e3dd92967fa118b52536b96011dd96e Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Mon, 24 Feb 2025 13:25:49 +0000 Subject: [PATCH 276/291] Updated years to be the same length --- ...ear_model_historical_realtionship_reporting_precipitation.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index c7d0b22eb2..afde126001 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -29,7 +29,7 @@ baseline_years_for_file = range(1940, 1980) min_year_for_analysis_baseline = min(baseline_years_for_file) + 1 absolute_min_year_baseline = min(baseline_years_for_file) -max_year_for_analysis_baseline = 1940 + len(year_range) +max_year_for_analysis_baseline = 1940 + len(year_range) + 1 absolute_max_year_baseline = max(baseline_years_for_file) + 1 baseline_years_for_analysis = range(min_year_for_analysis_baseline, max_year_for_analysis_baseline) poisson = False From 73a56ade167fa9e3b41d209774735e53ad079955 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 26 Feb 2025 10:54:04 +0000 Subject: [PATCH 277/291] Added legend for difference graph --- ...odel_historical_realtionship_reporting_precipitation.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index afde126001..596125da32 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -557,10 +557,11 @@ def repeat_info(info, num_facilities, year_range, historical): ax.stem(data_weather_predictions_grouped['Year_Month'][positive_mask], data_weather_predictions_grouped['difference'][positive_mask], - linefmt='#1C6E8C', markerfmt='o', basefmt="black") + linefmt='#1C6E8C', markerfmt='o', basefmt="black", label="More appointments projected due to less precipitation") ax.stem(data_weather_predictions_grouped['Year_Month'][negative_mask], data_weather_predictions_grouped['difference'][negative_mask], - linefmt='#823038', markerfmt='o', basefmt="black") + linefmt='#823038', markerfmt='o', basefmt="black", label="Fewer appointments projected due to more precipitation") + ax.set_xlabel('Year-Month') ax.set_ylabel(f'Difference in Predicted {service} Services (Without vs. With Precipitation)') january_ticks = data_weather_predictions_grouped[data_weather_predictions_grouped['Year_Month'].str.endswith('-1')] @@ -570,6 +571,8 @@ def repeat_info(info, num_facilities, year_range, historical): ax.axvline(x='2023-3', color='#CDC6AE', linestyle='--', linewidth=1, alpha=0.3, label="Cyclone Freddy") ax.axvline(x='2023-2', color='#CDC6AE', linestyle='--', linewidth=1, alpha=0.3) ax.axvspan('2023-2', '2023-3', color='#CDC6AE', alpha=0.3) +ax.legend(loc='upper left') + plt.tight_layout() plt.savefig( f'/Users/rem76/Desktop/Climate_change_health/Results/{service}_disruptions/{service}_disruptions_difference_historical_models.png') #plt.show() From 620e0a55be8733a50083c8220d74f4a36e51edc2 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 26 Feb 2025 14:22:51 +0000 Subject: [PATCH 278/291] Added mean difference etc to graphs --- src/scripts/climate_change/cohort_model.py | 23 ++++++++++++++++------ 1 file changed, 17 insertions(+), 6 deletions(-) diff --git a/src/scripts/climate_change/cohort_model.py b/src/scripts/climate_change/cohort_model.py index e9ad3a97c2..efbc6227fd 100644 --- a/src/scripts/climate_change/cohort_model.py +++ b/src/scripts/climate_change/cohort_model.py @@ -166,7 +166,6 @@ malawi_admin2.loc[malawi_admin2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0 malawi_admin2['Percentage_Difference'] = malawi_admin2['Percentage_Difference'].abs() # for mapping, to show % - for i, scenario in enumerate(scenarios): for j, model_type in enumerate(model_types): predictions_from_cmip = pd.read_csv( @@ -202,6 +201,17 @@ vmin=global_min, vmax=global_max ) + mean_diff = malawi_admin2['Percentage_Difference'].mean() + std_diff = malawi_admin2['Percentage_Difference'].std() + + ax.text( + 0.01, 0.1, + f"Mean: {mean_diff:.2f}%\nSD: {std_diff:.2f}%", + transform=ax.transAxes, + fontsize=10, + verticalalignment='top', + bbox=None + ) ax.set_title(f"{scenario}: {model_type}", fontsize=14) @@ -214,16 +224,14 @@ if i == 1: ax.set_xlabel("Longitude", fontsize=10) - sm = plt.cm.ScalarMappable( cmap='Blues', norm=mcolors.Normalize(vmin=global_min, vmax=global_max) ) sm.set_array([]) -fig.colorbar(sm, ax=axes, orientation="vertical", shrink=0.8, label="Percentage Difference (%)") -plt.suptitle("Percentage Difference Maps by Scenario and Model Type", fontsize=16, y=1.02) +fig.colorbar(sm, ax=axes, orientation="vertical", shrink=0.8, label="Potential Disruptions (%)") +#plt.tight_layout() plt.savefig(results_folder_to_save / 'percentage_difference_maps_grid.png') -plt.show() @@ -679,7 +687,6 @@ print(result_df_historical) result_df_historical.to_csv(f'/Users/rem76/Desktop/Climate_change_health/Results/{service}_disruptions/negative_sums_and_percentages_historical.csv', index=False) -###### Baseline historical disruptions ####### ####### Historical disruptions ########## @@ -735,7 +742,11 @@ plt.title("", fontsize=16) plt.savefig(results_folder_to_save / 'percentage_difference_map_historical.png') plt.show() +mean_percentage_diff = malawi_admin2['Percentage_Difference_historical'].mean() +sd_percentage_diff = malawi_admin2['Percentage_Difference_historical'].std() +print("Mean Percentage Difference:", mean_percentage_diff) +print("Standard Deviation of Percentage Difference:", sd_percentage_diff) ###### Effect of CYCLONE FREDDY ####### historical_predictions = pd.read_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/results_of_model_historical_predictions_{service}.csv') From 9d4e13eb9758a57b8f4431cb0d63148b542b521c Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 26 Feb 2025 14:46:34 +0000 Subject: [PATCH 279/291] Fixed slicing --- ...al_realtionship_reporting_precipitation.py | 58 ++++++++++--------- 1 file changed, 30 insertions(+), 28 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 596125da32..473f68ee13 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -620,7 +620,7 @@ def repeat_info(info, num_facilities, year_range, historical): else: print("No significant improvement by adding weather variables.") -############### ADD IN CMIP DATA ########################### +# ############### ADD IN CMIP DATA ########################### def get_weather_data(ssp_scenario, model_type): weather_data_prediction_five_day_cumulative_original = pd.read_csv( f"{data_path}Precipitation_data/Downscaled_CMIP6_data_CIL/{ssp_scenario}/{model_type}_window_prediction_weather_by_facility_{service}.csv", @@ -867,17 +867,15 @@ def get_weather_data(ssp_scenario, model_type): ################# Semi-post industrial, pre-2000 data ################# if ANC: - # Load data weather_data_monthly_20th_century = pd.read_csv( "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_ANC_lm_baseline.csv", index_col=0 ) - + print(len(weather_data_monthly_20th_century)) weather_data_five_day_cumulative_20th_century = pd.read_csv( f"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/historical_{min(baseline_years_for_file)}_{max(baseline_years_for_file)}_daily_total_by_facilities_with_ANC_five_day_cumulative.csv", index_col=0 ) - num_facilities_baseline = len(weather_data_monthly_20th_century.columns) # lags @@ -887,42 +885,49 @@ def get_weather_data(ssp_scenario, model_type): lag_4_month_baseline = weather_data_monthly_20th_century.shift(4).values lag_9_month_baseline = weather_data_monthly_20th_century.shift(9).values - - lag_1_month_baseline = lag_1_month_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:(max_year_for_analysis_baseline - absolute_max_year_baseline) * 12].flatten() - lag_2_month_baseline = lag_2_month_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:(max_year_for_analysis_baseline - absolute_max_year_baseline) * 12].flatten() - lag_3_month_baseline = lag_3_month_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:(max_year_for_analysis_baseline - absolute_max_year_baseline) * 12].flatten() - lag_4_month_baseline = lag_4_month_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:(max_year_for_analysis_baseline - absolute_max_year_baseline) * 12].flatten() - lag_9_month_baseline = lag_9_month_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:(max_year_for_analysis_baseline - absolute_max_year_baseline) * 12].flatten() + # Calculate the start and end indices based on the analysis period + start_index = (min_year_for_analysis_baseline - absolute_min_year_baseline) * 12 + end_index = (absolute_max_year_baseline - max_year_for_analysis_baseline) * 12 + end_index = len(weather_data_monthly_20th_century) - end_index + # Apply the index range and flattening for lag variables + lag_1_month_baseline = lag_1_month_baseline[start_index:end_index].flatten() + lag_2_month_baseline = lag_2_month_baseline[start_index:end_index].flatten() + lag_3_month_baseline = lag_3_month_baseline[start_index:end_index].flatten() + lag_4_month_baseline = lag_4_month_baseline[start_index:end_index].flatten() + lag_9_month_baseline = lag_9_month_baseline[start_index:end_index].flatten() + + # Shift weather data for the 5-day cumulative and flatten after indexing lag_1_5_day_baseline = weather_data_five_day_cumulative_20th_century.shift(1).values lag_2_5_day_baseline = weather_data_five_day_cumulative_20th_century.shift(2).values lag_3_5_day_baseline = weather_data_five_day_cumulative_20th_century.shift(3).values lag_4_5_day_baseline = weather_data_five_day_cumulative_20th_century.shift(4).values lag_9_5_day_baseline = weather_data_five_day_cumulative_20th_century.shift(9).values - lag_1_5_day_baseline = lag_1_5_day_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:(max_year_for_analysis_baseline - absolute_max_year_baseline) * 12].flatten() - lag_2_5_day_baseline = lag_2_5_day_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:(max_year_for_analysis_baseline - absolute_max_year_baseline) * 12].flatten() - lag_3_5_day_baseline = lag_3_5_day_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:(max_year_for_analysis_baseline - absolute_max_year_baseline) * 12].flatten() - lag_4_5_day_baseline = lag_4_5_day_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:(max_year_for_analysis_baseline - absolute_max_year_baseline) * 12].flatten() - lag_9_5_day_baseline = lag_9_5_day_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:(max_year_for_analysis_baseline - absolute_max_year_baseline) * 12].flatten() - print("one month", len(lag_1_5_day_baseline)) + # Apply the index range and flatten for the 5-day lag variables + lag_1_5_day_baseline = lag_1_5_day_baseline[start_index:end_index].flatten() + lag_2_5_day_baseline = lag_2_5_day_baseline[start_index:end_index].flatten() + lag_3_5_day_baseline = lag_3_5_day_baseline[start_index:end_index].flatten() + lag_4_5_day_baseline = lag_4_5_day_baseline[start_index:end_index].flatten() + lag_9_5_day_baseline = lag_9_5_day_baseline[start_index:end_index].flatten() - # need for binary + # For the binary lag variable, process as needed lag_12_month_baseline = weather_data_monthly_20th_century.shift(12).values - lag_12_month_baseline = lag_12_month_baseline[(min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:(max_year_for_analysis_baseline - absolute_max_year_baseline) * 12].flatten() + lag_12_month_baseline = lag_12_month_baseline[start_index:end_index].flatten() - # process - weather_data_monthly_20th_century = weather_data_monthly_20th_century.iloc[ - (min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:] - weather_data_monthly_20th_century = weather_data_monthly_20th_century.iloc[:(max_year_for_analysis_baseline - absolute_max_year_baseline) * 12] + # Process the main weather data + print(len(weather_data_monthly_20th_century)) + weather_data_monthly_20th_century = weather_data_monthly_20th_century.iloc[start_index:end_index] weather_data_five_day_cumulative_20th_century = weather_data_five_day_cumulative_20th_century.iloc[ - (min_year_for_analysis_baseline - absolute_min_year_baseline) * 12:] - weather_data_five_day_cumulative_20th_century = weather_data_five_day_cumulative_20th_century.iloc[:(max_year_for_analysis_baseline - absolute_max_year_baseline) * 12] + start_index:end_index] + # Flatten weather data weather_data_monthly_flattened = weather_data_monthly_20th_century.values.flatten() + print(len(weather_data_monthly_flattened)) weather_data_five_day_cumulative_flattened = weather_data_five_day_cumulative_20th_century.values.flatten() + + # Stack the flattened data weather_data_baseline = np.vstack( (weather_data_monthly_flattened, weather_data_five_day_cumulative_flattened)).T - # covariates year_repeated_baseline = [y for y in range(2012, 2012 + len(baseline_years_for_analysis)) for _ in range(12)] year_flattened_baseline = year_repeated_baseline*num_facilities_baseline # to get flattened data @@ -931,11 +936,8 @@ def get_weather_data(ssp_scenario, model_type): for _ in baseline_years_for_analysis: month_repeated.extend(range(1, 13)) month_flattened_baseline = month_repeated*num_facilities_baseline -print("month",len(month_flattened_baseline)) - zone_info_each_month_baseline = repeat_info(expanded_facility_info["Zonename"], num_facilities_baseline, baseline_years_for_analysis, historical = False) zone_encoded_baseline = pd.get_dummies(zone_info_each_month_baseline, drop_first=True) -print("zone",len(zone_encoded_baseline)) dist_info_each_month_baseline = repeat_info(expanded_facility_info["Dist"], num_facilities_baseline, baseline_years_for_analysis, historical = False) dist_encoded_baseline = pd.get_dummies(dist_info_each_month_baseline, drop_first=True) resid_info_each_month_baseline = repeat_info(expanded_facility_info['Resid'], num_facilities_baseline, baseline_years_for_analysis, historical = False) From a61a711a3ff60e2331e66467fb3c9cb00f8c3478 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 26 Feb 2025 14:50:47 +0000 Subject: [PATCH 280/291] increase dpi --- src/scripts/climate_change/cohort_model.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/scripts/climate_change/cohort_model.py b/src/scripts/climate_change/cohort_model.py index efbc6227fd..059fa9026f 100644 --- a/src/scripts/climate_change/cohort_model.py +++ b/src/scripts/climate_change/cohort_model.py @@ -231,7 +231,7 @@ sm.set_array([]) fig.colorbar(sm, ax=axes, orientation="vertical", shrink=0.8, label="Potential Disruptions (%)") #plt.tight_layout() -plt.savefig(results_folder_to_save / 'percentage_difference_maps_grid.png') +plt.savefig(results_folder_to_save / 'percentage_difference_maps_grid.png',dpi=600) From d0dd96e4ffe7266422ae5c246f6d3406aac59e90 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Wed, 26 Feb 2025 15:03:01 +0000 Subject: [PATCH 281/291] Tidy --- .../reporting_and_monthly_weather_data_small_facilities.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py b/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py index 88589c60db..2accf857b1 100644 --- a/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py +++ b/src/scripts/climate_change/reporting_and_monthly_weather_data_small_facilities.py @@ -19,7 +19,6 @@ reporting_data = pd.read_csv('/Users/rem76/Desktop/Climate_change_health/Data/Inpatient_Data/HMIS_Total_Number_Admissions.csv') else: reporting_data = pd.read_csv('/Users/rem76/Desktop/Climate_change_health/Data/Reporting_Rate/Reporting_Rate_by_smaller_facilities_2011_2024.csv') #January 2011 - January 2024 - # ANALYSIS DONE IN OCTOBER 2024 - so drop October, November, December 2024 columns_to_drop = reporting_data.columns[reporting_data.columns.str.endswith(('October 2024', 'November 2024', 'December 2024'))] reporting_data = reporting_data.drop(columns=columns_to_drop) @@ -38,7 +37,6 @@ months = [date.strip() for date in months] # extra spaces?? dates = pd.to_datetime(months, format='%B %Y', errors='coerce') months = dates.sort_values().strftime('%B %Y').tolist() # puts them in ascending order -print(reporting_data) for month in months: columns_of_interest_all_metrics = [reporting_data.columns[1]] + reporting_data.columns[reporting_data.columns.str.endswith(month)].tolist() data_of_interest_by_month = reporting_data[columns_of_interest_all_metrics] @@ -156,7 +154,6 @@ ] unique_columns = set(facilities_with_location) - set(included_facilities_with_lat_long) - print(unique_columns) additional_rows = ["Zonename", "Resid", "Dist", "A105", "A109__Altitude", "Ftype", 'A109__Latitude', 'A109__Longitude'] expanded_facility_info = included_facilities_with_lat_long[["Fname"] + additional_rows] expanded_facility_info['Dist'] = expanded_facility_info['Dist'].replace("Blanytyre", "Blantyre") From 0f8a2fff7d21164716a964abbe587e54ec04c092 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 27 Feb 2025 09:02:20 +0000 Subject: [PATCH 282/291] Tidy --- src/scripts/climate_change/cohort_model.ipynb | 4159 ----------------- 1 file changed, 4159 deletions(-) delete mode 100644 src/scripts/climate_change/cohort_model.ipynb diff --git a/src/scripts/climate_change/cohort_model.ipynb b/src/scripts/climate_change/cohort_model.ipynb deleted file mode 100644 index 22037e48c5..0000000000 --- a/src/scripts/climate_change/cohort_model.ipynb +++ /dev/null @@ -1,4159 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "id": "initial_id", - "metadata": { - "collapsed": true, - "ExecuteTime": { - "end_time": "2025-01-13T10:17:11.513188Z", - "start_time": "2025-01-13T10:17:10.336338Z" - } - }, - "source": [ - "import datetime\n", - "from pathlib import Path\n", - "\n", - "import imageio\n", - "import numpy as np\n", - "import pandas as pd\n", - "from matplotlib import pyplot as plt\n", - "from matplotlib.ticker import FormatStrFormatter\n", - "\n", - "from tlo.analysis.life_expectancy import get_life_expectancy_estimates\n", - "from tlo.analysis.utils import (\n", - " extract_results,\n", - " format_gbd,\n", - " make_age_grp_lookup,\n", - " make_age_grp_types,\n", - " make_calendar_period_lookup,\n", - " make_calendar_period_type,\n", - " summarize,\n", - " unflatten_flattened_multi_index_in_logging,\n", - ")\n", - "\n", - "min_year = 2020\n", - "max_year = 2070\n", - "\n", - "results_folder = Path(\"/Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-09-25T110820Z\")\n", - "resourcefilepath = Path(\"/Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-09-25T110820Z\")\n", - "agegrps, agegrplookup = make_age_grp_lookup()\n", - "calperiods, calperiodlookup = make_calendar_period_lookup()\n", - "births_results = extract_results(\n", - " results_folder,\n", - " module=\"tlo.methods.demography\",\n", - " key=\"on_birth\",\n", - " custom_generate_series=(\n", - " lambda df: df.assign(year=df['date'].dt.year).groupby(['year'])['year'].count()\n", - " ),\n", - " do_scaling=True\n", - " )\n", - "births_results = births_results.groupby(by=births_results.index).sum()\n", - "births_results = births_results.replace({0: np.nan})\n", - "\n", - "births_model = summarize(births_results, collapse_columns=True)\n", - "births_model.columns = ['Model_' + col for col in births_model.columns]\n", - "\n", - " " - ], - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/rem76/PycharmProjects/TLOmodel/src/tlo/analysis/utils.py:354: FutureWarning: DataFrame.groupby with axis=1 is deprecated. Do `frame.T.groupby(...)` without axis instead.\n", - " 'mean': results.groupby(axis=1, by='draw', sort=False).mean(),\n", - "/Users/rem76/PycharmProjects/TLOmodel/src/tlo/analysis/utils.py:355: FutureWarning: DataFrame.groupby with axis=1 is deprecated. Do `frame.T.groupby(...)` without axis instead.\n", - " 'lower': results.groupby(axis=1, by='draw', sort=False).quantile(0.025),\n", - "/Users/rem76/PycharmProjects/TLOmodel/src/tlo/analysis/utils.py:356: FutureWarning: DataFrame.groupby with axis=1 is deprecated. Do `frame.T.groupby(...)` without axis instead.\n", - " 'upper': results.groupby(axis=1, by='draw', sort=False).quantile(0.975),\n" - ] - } - ], - "execution_count": 52 - }, - { - "metadata": {}, - "cell_type": "markdown", - "source": "Get expected disturbance from the model?", - "id": "aa40455f90215a5d" - }, - { - "metadata": { - "ExecuteTime": { - "end_time": "2025-01-13T10:17:11.625639Z", - "start_time": "2025-01-13T10:17:11.573080Z" - } - }, - "cell_type": "code", - "source": [ - "scenario = 'ssp585'\n", - "model_type = 'median'" - ], - "id": "bbff583692196586", - "outputs": [], - "execution_count": 53 - }, - { - "metadata": { - "ExecuteTime": { - "end_time": "2025-01-13T10:17:13.738496Z", - "start_time": "2025-01-13T10:17:12.468147Z" - } - }, - "cell_type": "code", - "source": "predictions_from_cmip = pd.read_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv')", - "id": "3be0a4515f3e890e", - "outputs": [], - "execution_count": 54 - }, - { - "metadata": { - "ExecuteTime": { - "end_time": "2025-01-13T10:17:14.670960Z", - "start_time": "2025-01-13T10:17:14.235012Z" - } - }, - "cell_type": "code", - "source": [ - "predictions_from_cmip_sum = predictions_from_cmip.groupby('Year').sum().reset_index()\n", - "predictions_from_cmip_sum" - ], - "id": "aa5cab3b8ee058bd", - "outputs": [ - { - "data": { - "text/plain": [ - " Year Month Facility_ID Altitude \\\n", - "0 2025 25584 643536 3435564.0 \n", - "1 2026 25584 643536 3435564.0 \n", - "2 2027 25584 643536 3435564.0 \n", - "3 2028 25584 643536 3435564.0 \n", - "4 2029 25584 643536 3435564.0 \n", - "5 2030 25584 643536 3435564.0 \n", - "6 2031 25584 643536 3435564.0 \n", - "7 2032 25584 643536 3435564.0 \n", - "8 2033 25584 643536 3435564.0 \n", - "9 2034 25584 643536 3435564.0 \n", - "10 2035 25584 643536 3435564.0 \n", - "11 2036 25584 643536 3435564.0 \n", - "12 2037 25584 643536 3435564.0 \n", - "13 2038 25584 643536 3435564.0 \n", - "14 2039 25584 643536 3435564.0 \n", - "15 2040 25584 643536 3435564.0 \n", - "16 2041 25584 643536 3435564.0 \n", - "17 2042 25584 643536 3435564.0 \n", - "18 2043 25584 643536 3435564.0 \n", - "19 2044 25584 643536 3435564.0 \n", - "20 2045 25584 643536 3435564.0 \n", - "21 2046 25584 643536 3435564.0 \n", - "22 2047 25584 643536 3435564.0 \n", - "23 2048 25584 643536 3435564.0 \n", - "24 2049 25584 643536 3435564.0 \n", - "25 2050 25584 643536 3435564.0 \n", - "26 2051 25584 643536 3435564.0 \n", - "27 2052 25584 643536 3435564.0 \n", - "28 2053 25584 643536 3435564.0 \n", - "29 2054 25584 643536 3435564.0 \n", - "30 2055 25584 643536 3435564.0 \n", - "31 2056 25584 643536 3435564.0 \n", - "32 2057 25584 643536 3435564.0 \n", - "33 2058 25584 643536 3435564.0 \n", - "34 2059 25584 643536 3435564.0 \n", - "35 2060 25584 643536 3435564.0 \n", - "36 2061 25584 643536 3435564.0 \n", - "37 2062 25584 643536 3435564.0 \n", - "38 2063 25584 643536 3435564.0 \n", - "39 2064 25584 643536 3435564.0 \n", - "40 2065 25584 643536 3435564.0 \n", - "41 2066 25584 643536 3435564.0 \n", - "42 2067 25584 643536 3435564.0 \n", - "43 2068 25584 643536 3435564.0 \n", - "44 2069 25584 643536 3435564.0 \n", - "45 2070 25584 643536 3435564.0 \n", - "\n", - " Zone \\\n", - "0 Central WestSouth EastNorthernSouth EastNorthe... \n", - "1 Central WestSouth EastNorthernSouth EastNorthe... \n", - "2 Central WestSouth EastNorthernSouth EastNorthe... \n", - "3 Central WestSouth EastNorthernSouth EastNorthe... \n", - "4 Central WestSouth EastNorthernSouth EastNorthe... \n", - "5 Central WestSouth EastNorthernSouth EastNorthe... \n", - "6 Central WestSouth EastNorthernSouth EastNorthe... \n", - "7 Central WestSouth EastNorthernSouth EastNorthe... \n", - "8 Central WestSouth EastNorthernSouth EastNorthe... \n", - "9 Central WestSouth EastNorthernSouth EastNorthe... \n", - "10 Central WestSouth EastNorthernSouth EastNorthe... \n", - "11 Central WestSouth EastNorthernSouth EastNorthe... \n", - "12 Central WestSouth EastNorthernSouth EastNorthe... \n", - "13 Central WestSouth EastNorthernSouth EastNorthe... \n", - "14 Central WestSouth EastNorthernSouth EastNorthe... \n", - "15 Central WestSouth EastNorthernSouth EastNorthe... \n", - "16 Central WestSouth EastNorthernSouth EastNorthe... \n", - "17 Central WestSouth EastNorthernSouth EastNorthe... \n", - "18 Central WestSouth EastNorthernSouth EastNorthe... \n", - "19 Central WestSouth EastNorthernSouth EastNorthe... \n", - "20 Central WestSouth EastNorthernSouth EastNorthe... \n", - "21 Central WestSouth EastNorthernSouth EastNorthe... \n", - "22 Central WestSouth EastNorthernSouth EastNorthe... \n", - "23 Central WestSouth EastNorthernSouth EastNorthe... \n", - "24 Central WestSouth EastNorthernSouth EastNorthe... \n", - "25 Central WestSouth EastNorthernSouth EastNorthe... \n", - "26 Central WestSouth EastNorthernSouth EastNorthe... \n", - "27 Central WestSouth EastNorthernSouth EastNorthe... \n", - "28 Central WestSouth EastNorthernSouth EastNorthe... \n", - "29 Central WestSouth EastNorthernSouth EastNorthe... \n", - "30 Central WestSouth EastNorthernSouth EastNorthe... \n", - "31 Central WestSouth EastNorthernSouth EastNorthe... \n", - "32 Central WestSouth EastNorthernSouth EastNorthe... \n", - "33 Central WestSouth EastNorthernSouth EastNorthe... \n", - "34 Central WestSouth EastNorthernSouth EastNorthe... \n", - "35 Central WestSouth EastNorthernSouth EastNorthe... \n", - "36 Central WestSouth EastNorthernSouth EastNorthe... \n", - "37 Central WestSouth EastNorthernSouth EastNorthe... \n", - "38 Central WestSouth EastNorthernSouth EastNorthe... \n", - "39 Central WestSouth EastNorthernSouth EastNorthe... \n", - "40 Central WestSouth EastNorthernSouth EastNorthe... \n", - "41 Central WestSouth EastNorthernSouth EastNorthe... \n", - "42 Central WestSouth EastNorthernSouth EastNorthe... \n", - "43 Central WestSouth EastNorthernSouth EastNorthe... \n", - "44 Central WestSouth EastNorthernSouth EastNorthe... \n", - "45 Central WestSouth EastNorthernSouth EastNorthe... \n", - "\n", - " District \\\n", - "0 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "1 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "2 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "3 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "4 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "5 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "6 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "7 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "8 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "9 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "10 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "11 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "12 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "13 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "14 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "15 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "16 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "17 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "18 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "19 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "20 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "21 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "22 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "23 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "24 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "25 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "26 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "27 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "28 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "29 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "30 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "31 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "32 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "33 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "34 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "35 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "36 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "37 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "38 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "39 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "40 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "41 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "42 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "43 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "44 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "45 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "\n", - " Resid \\\n", - "0 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "1 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "2 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "3 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "4 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "5 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "6 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "7 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "8 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "9 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "10 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "11 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "12 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "13 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "14 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "15 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "16 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "17 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "18 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "19 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "20 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "21 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "22 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "23 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "24 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "25 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "26 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "27 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "28 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "29 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "30 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "31 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "32 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "33 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "34 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "35 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "36 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "37 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "38 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "39 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "40 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "41 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "42 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "43 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "44 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "45 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "\n", - " Owner \\\n", - "0 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "1 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "2 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "3 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "4 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "5 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "6 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "7 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "8 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "9 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "10 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "11 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "12 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "13 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "14 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "15 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "16 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "17 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "18 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "19 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "20 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "21 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "22 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "23 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "24 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "25 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "26 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "27 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "28 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "29 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "30 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "31 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "32 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "33 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "34 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "35 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "36 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "37 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "38 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "39 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "40 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "41 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "42 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "43 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "44 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "45 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "\n", - " Facility_Type Precipitation \\\n", - "0 ClinicDistrict HospitalRural/Community Hospita... 377371.401757 \n", - "1 ClinicDistrict HospitalRural/Community Hospita... 424179.161524 \n", - "2 ClinicDistrict HospitalRural/Community Hospita... 416785.291442 \n", - "3 ClinicDistrict HospitalRural/Community Hospita... 431174.255009 \n", - "4 ClinicDistrict HospitalRural/Community Hospita... 405743.410420 \n", - "5 ClinicDistrict HospitalRural/Community Hospita... 410793.849551 \n", - "6 ClinicDistrict HospitalRural/Community Hospita... 430219.873937 \n", - "7 ClinicDistrict HospitalRural/Community Hospita... 332427.056762 \n", - "8 ClinicDistrict HospitalRural/Community Hospita... 392896.036283 \n", - "9 ClinicDistrict HospitalRural/Community Hospita... 409775.392632 \n", - "10 ClinicDistrict HospitalRural/Community Hospita... 410851.208278 \n", - "11 ClinicDistrict HospitalRural/Community Hospita... 456535.963741 \n", - "12 ClinicDistrict HospitalRural/Community Hospita... 452334.398335 \n", - "13 ClinicDistrict HospitalRural/Community Hospita... 329049.810569 \n", - "14 ClinicDistrict HospitalRural/Community Hospita... 414644.190834 \n", - "15 ClinicDistrict HospitalRural/Community Hospita... 392121.029719 \n", - "16 ClinicDistrict HospitalRural/Community Hospita... 380754.054252 \n", - "17 ClinicDistrict HospitalRural/Community Hospita... 296596.215293 \n", - "18 ClinicDistrict HospitalRural/Community Hospita... 423715.504984 \n", - "19 ClinicDistrict HospitalRural/Community Hospita... 368319.084368 \n", - "20 ClinicDistrict HospitalRural/Community Hospita... 418134.051457 \n", - "21 ClinicDistrict HospitalRural/Community Hospita... 380622.271982 \n", - "22 ClinicDistrict HospitalRural/Community Hospita... 388922.127329 \n", - "23 ClinicDistrict HospitalRural/Community Hospita... 373888.999201 \n", - "24 ClinicDistrict HospitalRural/Community Hospita... 403081.277311 \n", - "25 ClinicDistrict HospitalRural/Community Hospita... 377526.089751 \n", - "26 ClinicDistrict HospitalRural/Community Hospita... 312891.203066 \n", - "27 ClinicDistrict HospitalRural/Community Hospita... 383090.314471 \n", - "28 ClinicDistrict HospitalRural/Community Hospita... 370916.909122 \n", - "29 ClinicDistrict HospitalRural/Community Hospita... 358979.193679 \n", - "30 ClinicDistrict HospitalRural/Community Hospita... 411059.228901 \n", - "31 ClinicDistrict HospitalRural/Community Hospita... 457632.022035 \n", - "32 ClinicDistrict HospitalRural/Community Hospita... 366158.628623 \n", - "33 ClinicDistrict HospitalRural/Community Hospita... 414749.367352 \n", - "34 ClinicDistrict HospitalRural/Community Hospita... 394182.173776 \n", - "35 ClinicDistrict HospitalRural/Community Hospita... 412930.274807 \n", - "36 ClinicDistrict HospitalRural/Community Hospita... 350708.805302 \n", - "37 ClinicDistrict HospitalRural/Community Hospita... 293182.399170 \n", - "38 ClinicDistrict HospitalRural/Community Hospita... 377478.093086 \n", - "39 ClinicDistrict HospitalRural/Community Hospita... 291362.431282 \n", - "40 ClinicDistrict HospitalRural/Community Hospita... 368970.926878 \n", - "41 ClinicDistrict HospitalRural/Community Hospita... 397265.484764 \n", - "42 ClinicDistrict HospitalRural/Community Hospita... 327967.298680 \n", - "43 ClinicDistrict HospitalRural/Community Hospita... 315778.193228 \n", - "44 ClinicDistrict HospitalRural/Community Hospita... 342508.889264 \n", - "45 ClinicDistrict HospitalRural/Community Hospita... 369080.727151 \n", - "\n", - " Lag_1_Precipitation Lag_2_Precipitation Lag_3_Precipitation \\\n", - "0 398942.636170 404727.057797 405704.571665 \n", - "1 413397.817913 388309.667883 385397.116828 \n", - "2 407187.589904 420216.307417 421615.911783 \n", - "3 406189.704606 403165.981005 401105.177547 \n", - "4 420471.214026 421450.033447 424520.950185 \n", - "5 410824.557725 391493.761671 388196.210212 \n", - "6 432044.900550 456751.262273 456752.721138 \n", - "7 348112.188236 353270.524412 357410.845800 \n", - "8 405019.687496 388565.288508 388245.552346 \n", - "9 372460.875926 375124.877747 371846.112765 \n", - "10 408169.132145 406485.011941 407092.899084 \n", - "11 451325.020396 433158.134992 433133.983599 \n", - "12 481501.033891 524791.840222 527391.207421 \n", - "13 339513.871817 320576.954584 319333.523933 \n", - "14 392029.707764 393257.108114 394526.442838 \n", - "15 371789.329465 387244.681484 386630.546157 \n", - "16 440952.201046 424662.364695 425051.043775 \n", - "17 286935.705860 311049.994112 312185.510318 \n", - "18 392470.951022 356521.858749 353794.312578 \n", - "19 394609.621848 426205.552210 424729.506080 \n", - "20 414178.271428 393702.776056 395566.258413 \n", - "21 385122.990507 393876.211485 395324.082930 \n", - "22 374058.228036 360407.393814 361159.265562 \n", - "23 367702.143527 383792.892262 381569.846621 \n", - "24 406359.400288 413379.564221 402964.624861 \n", - "25 362825.700917 354087.658823 342715.089184 \n", - "26 358797.936758 363399.872412 387024.433983 \n", - "27 375109.947590 372857.980106 358164.961912 \n", - "28 367650.235635 359381.996323 367921.786733 \n", - "29 363845.441546 357419.463077 345612.633741 \n", - "30 398093.244924 420338.093431 427216.475603 \n", - "31 460331.584266 421106.585969 427549.155747 \n", - "32 355110.662118 385804.286252 377495.302483 \n", - "33 404952.222454 380148.672904 390887.435379 \n", - "34 405715.733698 429608.759456 429014.390163 \n", - "35 409799.355286 410974.276816 413298.745816 \n", - "36 353761.775712 344252.932147 343209.200439 \n", - "37 325069.624722 344289.047467 342084.186261 \n", - "38 353257.222779 353764.890202 357823.798670 \n", - "39 302326.827366 304020.083180 303828.779931 \n", - "40 368964.162462 357775.533341 356652.040920 \n", - "41 323346.039126 322784.762289 316952.269236 \n", - "42 383625.207672 394279.969633 398120.412976 \n", - "43 360494.854893 356119.648704 357486.445092 \n", - "44 323961.673652 331898.505904 332841.894862 \n", - "45 347439.884447 315453.846359 311453.513947 \n", - "\n", - " Lag_4_Precipitation Predicted_Weather_Model Predicted_No_Weather_Model \\\n", - "0 404895.268433 388170.416938 388952.687143 \n", - "1 386621.761142 388977.642536 389766.195898 \n", - "2 421535.968891 388911.689878 390581.406135 \n", - "3 400973.159779 389655.410904 391398.321414 \n", - "4 419592.912552 390987.782909 392216.945302 \n", - "5 391638.197677 393005.343703 393037.281371 \n", - "6 456824.623648 393189.485844 393859.333204 \n", - "7 357753.146752 395178.035869 394683.104387 \n", - "8 388673.117569 397007.193660 395508.598518 \n", - "9 373019.671935 395590.239618 396335.819201 \n", - "10 406919.996712 396228.566729 397164.770045 \n", - "11 432861.285260 393402.035448 397995.454671 \n", - "12 527784.234663 390976.277924 398827.876704 \n", - "13 318825.960831 404201.512252 399662.039777 \n", - "14 394260.244027 403020.063982 400497.947534 \n", - "15 387202.538290 401362.282444 401335.603622 \n", - "16 423444.969850 403300.817741 402175.011698 \n", - "17 313717.825313 406220.414477 403016.175427 \n", - "18 353491.313705 404751.067224 403859.098481 \n", - "19 424904.453286 403545.677376 404703.784539 \n", - "20 394030.949034 407191.372127 405550.237289 \n", - "21 396757.245029 407276.140971 406398.460425 \n", - "22 357396.518341 408048.952446 407248.457651 \n", - "23 384605.158226 408947.493196 408100.232678 \n", - "24 402279.134778 408196.179944 408953.789223 \n", - "25 343650.740769 412851.654339 409809.131013 \n", - "26 387553.261741 412999.055953 410666.261781 \n", - "27 357983.056662 412439.576549 411525.185270 \n", - "28 368369.784160 415583.193519 412385.905229 \n", - "29 345685.373340 415439.588486 413248.425414 \n", - "30 426320.093861 411662.387625 414112.749593 \n", - "31 427585.588743 417317.863182 414978.881537 \n", - "32 376728.920725 417068.108674 415846.825027 \n", - "33 392238.633130 416997.538415 416716.583853 \n", - "34 428209.211053 415847.029809 417588.161812 \n", - "35 414461.110789 417671.538047 418461.562707 \n", - "36 343006.625602 422880.625880 419336.790352 \n", - "37 342232.642746 423813.772316 420213.848568 \n", - "38 357126.722312 423217.736245 421092.741184 \n", - "39 303106.289335 426016.517117 421973.472035 \n", - "40 355879.690701 424905.114511 422856.044967 \n", - "41 316486.677194 428467.851539 423740.463833 \n", - "42 400442.667319 425844.848271 424626.732493 \n", - "43 357120.223981 430382.494644 425514.854816 \n", - "44 333370.975675 429356.305250 426404.834679 \n", - "45 310691.844984 430541.830595 427296.675968 \n", - "\n", - " Difference_in_Expectation \n", - "0 -782.270206 \n", - "1 -788.553362 \n", - "2 -1669.716257 \n", - "3 -1742.910510 \n", - "4 -1229.162393 \n", - "5 -31.937669 \n", - "6 -669.847360 \n", - "7 494.931482 \n", - "8 1498.595142 \n", - "9 -745.579583 \n", - "10 -936.203316 \n", - "11 -4593.419222 \n", - "12 -7851.598780 \n", - "13 4539.472475 \n", - "14 2522.116449 \n", - "15 26.678823 \n", - "16 1125.806043 \n", - "17 3204.239050 \n", - "18 891.968743 \n", - "19 -1158.107162 \n", - "20 1641.134838 \n", - "21 877.680546 \n", - "22 800.494794 \n", - "23 847.260518 \n", - "24 -757.609279 \n", - "25 3042.523326 \n", - "26 2332.794171 \n", - "27 914.391279 \n", - "28 3197.288290 \n", - "29 2191.163072 \n", - "30 -2450.361967 \n", - "31 2338.981646 \n", - "32 1221.283647 \n", - "33 280.954562 \n", - "34 -1741.132002 \n", - "35 -790.024660 \n", - "36 3543.835527 \n", - "37 3599.923748 \n", - "38 2124.995061 \n", - "39 4043.045082 \n", - "40 2049.069544 \n", - "41 4727.387706 \n", - "42 1218.115778 \n", - "43 4867.639828 \n", - "44 2951.470571 \n", - "45 3245.154627 " - ], - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
YearMonthFacility_IDAltitudeZoneDistrictResidOwnerFacility_TypePrecipitationLag_1_PrecipitationLag_2_PrecipitationLag_3_PrecipitationLag_4_PrecipitationPredicted_Weather_ModelPredicted_No_Weather_ModelDifference_in_Expectation
02025255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...377371.401757398942.636170404727.057797405704.571665404895.268433388170.416938388952.687143-782.270206
12026255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...424179.161524413397.817913388309.667883385397.116828386621.761142388977.642536389766.195898-788.553362
22027255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...416785.291442407187.589904420216.307417421615.911783421535.968891388911.689878390581.406135-1669.716257
32028255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...431174.255009406189.704606403165.981005401105.177547400973.159779389655.410904391398.321414-1742.910510
42029255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...405743.410420420471.214026421450.033447424520.950185419592.912552390987.782909392216.945302-1229.162393
52030255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...410793.849551410824.557725391493.761671388196.210212391638.197677393005.343703393037.281371-31.937669
62031255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...430219.873937432044.900550456751.262273456752.721138456824.623648393189.485844393859.333204-669.847360
72032255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...332427.056762348112.188236353270.524412357410.845800357753.146752395178.035869394683.104387494.931482
82033255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...392896.036283405019.687496388565.288508388245.552346388673.117569397007.193660395508.5985181498.595142
92034255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...409775.392632372460.875926375124.877747371846.112765373019.671935395590.239618396335.819201-745.579583
102035255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...410851.208278408169.132145406485.011941407092.899084406919.996712396228.566729397164.770045-936.203316
112036255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...456535.963741451325.020396433158.134992433133.983599432861.285260393402.035448397995.454671-4593.419222
122037255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...452334.398335481501.033891524791.840222527391.207421527784.234663390976.277924398827.876704-7851.598780
132038255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...329049.810569339513.871817320576.954584319333.523933318825.960831404201.512252399662.0397774539.472475
142039255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...414644.190834392029.707764393257.108114394526.442838394260.244027403020.063982400497.9475342522.116449
152040255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...392121.029719371789.329465387244.681484386630.546157387202.538290401362.282444401335.60362226.678823
162041255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...380754.054252440952.201046424662.364695425051.043775423444.969850403300.817741402175.0116981125.806043
172042255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...296596.215293286935.705860311049.994112312185.510318313717.825313406220.414477403016.1754273204.239050
182043255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...423715.504984392470.951022356521.858749353794.312578353491.313705404751.067224403859.098481891.968743
192044255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...368319.084368394609.621848426205.552210424729.506080424904.453286403545.677376404703.784539-1158.107162
202045255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...418134.051457414178.271428393702.776056395566.258413394030.949034407191.372127405550.2372891641.134838
212046255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...380622.271982385122.990507393876.211485395324.082930396757.245029407276.140971406398.460425877.680546
222047255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...388922.127329374058.228036360407.393814361159.265562357396.518341408048.952446407248.457651800.494794
232048255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...373888.999201367702.143527383792.892262381569.846621384605.158226408947.493196408100.232678847.260518
242049255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...403081.277311406359.400288413379.564221402964.624861402279.134778408196.179944408953.789223-757.609279
252050255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...377526.089751362825.700917354087.658823342715.089184343650.740769412851.654339409809.1310133042.523326
262051255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...312891.203066358797.936758363399.872412387024.433983387553.261741412999.055953410666.2617812332.794171
272052255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...383090.314471375109.947590372857.980106358164.961912357983.056662412439.576549411525.185270914.391279
282053255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...370916.909122367650.235635359381.996323367921.786733368369.784160415583.193519412385.9052293197.288290
292054255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...358979.193679363845.441546357419.463077345612.633741345685.373340415439.588486413248.4254142191.163072
302055255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...411059.228901398093.244924420338.093431427216.475603426320.093861411662.387625414112.749593-2450.361967
312056255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...457632.022035460331.584266421106.585969427549.155747427585.588743417317.863182414978.8815372338.981646
322057255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...366158.628623355110.662118385804.286252377495.302483376728.920725417068.108674415846.8250271221.283647
332058255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...414749.367352404952.222454380148.672904390887.435379392238.633130416997.538415416716.583853280.954562
342059255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...394182.173776405715.733698429608.759456429014.390163428209.211053415847.029809417588.161812-1741.132002
352060255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...412930.274807409799.355286410974.276816413298.745816414461.110789417671.538047418461.562707-790.024660
362061255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...350708.805302353761.775712344252.932147343209.200439343006.625602422880.625880419336.7903523543.835527
372062255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...293182.399170325069.624722344289.047467342084.186261342232.642746423813.772316420213.8485683599.923748
382063255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...377478.093086353257.222779353764.890202357823.798670357126.722312423217.736245421092.7411842124.995061
392064255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...291362.431282302326.827366304020.083180303828.779931303106.289335426016.517117421973.4720354043.045082
402065255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...368970.926878368964.162462357775.533341356652.040920355879.690701424905.114511422856.0449672049.069544
412066255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...397265.484764323346.039126322784.762289316952.269236316486.677194428467.851539423740.4638334727.387706
422067255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...327967.298680383625.207672394279.969633398120.412976400442.667319425844.848271424626.7324931218.115778
432068255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...315778.193228360494.854893356119.648704357486.445092357120.223981430382.494644425514.8548164867.639828
442069255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...342508.889264323961.673652331898.505904332841.894862333370.975675429356.305250426404.8346792951.470571
452070255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...369080.727151347439.884447315453.846359311453.513947310691.844984430541.830595427296.6759683245.154627
\n", - "
" - ] - }, - "execution_count": 55, - "metadata": {}, - "output_type": "execute_result" - } - ], - "execution_count": 55 - }, - { - "metadata": { - "ExecuteTime": { - "end_time": "2025-01-13T10:17:15.993279Z", - "start_time": "2025-01-13T10:17:15.830390Z" - } - }, - "cell_type": "code", - "source": [ - "predictions_from_cmip_sum['Percentage_Difference'] = (predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model']) \n", - "predictions_from_cmip_sum" - ], - "id": "c5a9dc35ac31e4b7", - "outputs": [ - { - "data": { - "text/plain": [ - " Year Month Facility_ID Altitude \\\n", - "0 2025 25584 643536 3435564.0 \n", - "1 2026 25584 643536 3435564.0 \n", - "2 2027 25584 643536 3435564.0 \n", - "3 2028 25584 643536 3435564.0 \n", - "4 2029 25584 643536 3435564.0 \n", - "5 2030 25584 643536 3435564.0 \n", - "6 2031 25584 643536 3435564.0 \n", - "7 2032 25584 643536 3435564.0 \n", - "8 2033 25584 643536 3435564.0 \n", - "9 2034 25584 643536 3435564.0 \n", - "10 2035 25584 643536 3435564.0 \n", - "11 2036 25584 643536 3435564.0 \n", - "12 2037 25584 643536 3435564.0 \n", - "13 2038 25584 643536 3435564.0 \n", - "14 2039 25584 643536 3435564.0 \n", - "15 2040 25584 643536 3435564.0 \n", - "16 2041 25584 643536 3435564.0 \n", - "17 2042 25584 643536 3435564.0 \n", - "18 2043 25584 643536 3435564.0 \n", - "19 2044 25584 643536 3435564.0 \n", - "20 2045 25584 643536 3435564.0 \n", - "21 2046 25584 643536 3435564.0 \n", - "22 2047 25584 643536 3435564.0 \n", - "23 2048 25584 643536 3435564.0 \n", - "24 2049 25584 643536 3435564.0 \n", - "25 2050 25584 643536 3435564.0 \n", - "26 2051 25584 643536 3435564.0 \n", - "27 2052 25584 643536 3435564.0 \n", - "28 2053 25584 643536 3435564.0 \n", - "29 2054 25584 643536 3435564.0 \n", - "30 2055 25584 643536 3435564.0 \n", - "31 2056 25584 643536 3435564.0 \n", - "32 2057 25584 643536 3435564.0 \n", - "33 2058 25584 643536 3435564.0 \n", - "34 2059 25584 643536 3435564.0 \n", - "35 2060 25584 643536 3435564.0 \n", - "36 2061 25584 643536 3435564.0 \n", - "37 2062 25584 643536 3435564.0 \n", - "38 2063 25584 643536 3435564.0 \n", - "39 2064 25584 643536 3435564.0 \n", - "40 2065 25584 643536 3435564.0 \n", - "41 2066 25584 643536 3435564.0 \n", - "42 2067 25584 643536 3435564.0 \n", - "43 2068 25584 643536 3435564.0 \n", - "44 2069 25584 643536 3435564.0 \n", - "45 2070 25584 643536 3435564.0 \n", - "\n", - " Zone \\\n", - "0 Central WestSouth EastNorthernSouth EastNorthe... \n", - "1 Central WestSouth EastNorthernSouth EastNorthe... \n", - "2 Central WestSouth EastNorthernSouth EastNorthe... \n", - "3 Central WestSouth EastNorthernSouth EastNorthe... \n", - "4 Central WestSouth EastNorthernSouth EastNorthe... \n", - "5 Central WestSouth EastNorthernSouth EastNorthe... \n", - "6 Central WestSouth EastNorthernSouth EastNorthe... \n", - "7 Central WestSouth EastNorthernSouth EastNorthe... \n", - "8 Central WestSouth EastNorthernSouth EastNorthe... \n", - "9 Central WestSouth EastNorthernSouth EastNorthe... \n", - "10 Central WestSouth EastNorthernSouth EastNorthe... \n", - "11 Central WestSouth EastNorthernSouth EastNorthe... \n", - "12 Central WestSouth EastNorthernSouth EastNorthe... \n", - "13 Central WestSouth EastNorthernSouth EastNorthe... \n", - "14 Central WestSouth EastNorthernSouth EastNorthe... \n", - "15 Central WestSouth EastNorthernSouth EastNorthe... \n", - "16 Central WestSouth EastNorthernSouth EastNorthe... \n", - "17 Central WestSouth EastNorthernSouth EastNorthe... \n", - "18 Central WestSouth EastNorthernSouth EastNorthe... \n", - "19 Central WestSouth EastNorthernSouth EastNorthe... \n", - "20 Central WestSouth EastNorthernSouth EastNorthe... \n", - "21 Central WestSouth EastNorthernSouth EastNorthe... \n", - "22 Central WestSouth EastNorthernSouth EastNorthe... \n", - "23 Central WestSouth EastNorthernSouth EastNorthe... \n", - "24 Central WestSouth EastNorthernSouth EastNorthe... \n", - "25 Central WestSouth EastNorthernSouth EastNorthe... \n", - "26 Central WestSouth EastNorthernSouth EastNorthe... \n", - "27 Central WestSouth EastNorthernSouth EastNorthe... \n", - "28 Central WestSouth EastNorthernSouth EastNorthe... \n", - "29 Central WestSouth EastNorthernSouth EastNorthe... \n", - "30 Central WestSouth EastNorthernSouth EastNorthe... \n", - "31 Central WestSouth EastNorthernSouth EastNorthe... \n", - "32 Central WestSouth EastNorthernSouth EastNorthe... \n", - "33 Central WestSouth EastNorthernSouth EastNorthe... \n", - "34 Central WestSouth EastNorthernSouth EastNorthe... \n", - "35 Central WestSouth EastNorthernSouth EastNorthe... \n", - "36 Central WestSouth EastNorthernSouth EastNorthe... \n", - "37 Central WestSouth EastNorthernSouth EastNorthe... \n", - "38 Central WestSouth EastNorthernSouth EastNorthe... \n", - "39 Central WestSouth EastNorthernSouth EastNorthe... \n", - "40 Central WestSouth EastNorthernSouth EastNorthe... \n", - "41 Central WestSouth EastNorthernSouth EastNorthe... \n", - "42 Central WestSouth EastNorthernSouth EastNorthe... \n", - "43 Central WestSouth EastNorthernSouth EastNorthe... \n", - "44 Central WestSouth EastNorthernSouth EastNorthe... \n", - "45 Central WestSouth EastNorthernSouth EastNorthe... \n", - "\n", - " District \\\n", - "0 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "1 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "2 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "3 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "4 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "5 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "6 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "7 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "8 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "9 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "10 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "11 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "12 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "13 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "14 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "15 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "16 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "17 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "18 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "19 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "20 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "21 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "22 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "23 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "24 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "25 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "26 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "27 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "28 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "29 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "30 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "31 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "32 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "33 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "34 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "35 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "36 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "37 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "38 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "39 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "40 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "41 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "42 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "43 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "44 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "45 LilongweBalakaRumphiMulanjeMzimba SouthThyoloN... \n", - "\n", - " Resid \\\n", - "0 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "1 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "2 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "3 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "4 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "5 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "6 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "7 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "8 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "9 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "10 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "11 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "12 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "13 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "14 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "15 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "16 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "17 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "18 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "19 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "20 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "21 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "22 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "23 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "24 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "25 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "26 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "27 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "28 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "29 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "30 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "31 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "32 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "33 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "34 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "35 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "36 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "37 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "38 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "39 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "40 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "41 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "42 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "43 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "44 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "45 UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR... \n", - "\n", - " Owner \\\n", - "0 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "1 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "2 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "3 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "4 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "5 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "6 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "7 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "8 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "9 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "10 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "11 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "12 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "13 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "14 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "15 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "16 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "17 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "18 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "19 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "20 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "21 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "22 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "23 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "24 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "25 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "26 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "27 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "28 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "29 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "30 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "31 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "32 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "33 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "34 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "35 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "36 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "37 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "38 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "39 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "40 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "41 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "42 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "43 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "44 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "45 GovernmentGovernmentGovernmentGovernmentGovern... \n", - "\n", - " Facility_Type Precipitation \\\n", - "0 ClinicDistrict HospitalRural/Community Hospita... 377371.401757 \n", - "1 ClinicDistrict HospitalRural/Community Hospita... 424179.161524 \n", - "2 ClinicDistrict HospitalRural/Community Hospita... 416785.291442 \n", - "3 ClinicDistrict HospitalRural/Community Hospita... 431174.255009 \n", - "4 ClinicDistrict HospitalRural/Community Hospita... 405743.410420 \n", - "5 ClinicDistrict HospitalRural/Community Hospita... 410793.849551 \n", - "6 ClinicDistrict HospitalRural/Community Hospita... 430219.873937 \n", - "7 ClinicDistrict HospitalRural/Community Hospita... 332427.056762 \n", - "8 ClinicDistrict HospitalRural/Community Hospita... 392896.036283 \n", - "9 ClinicDistrict HospitalRural/Community Hospita... 409775.392632 \n", - "10 ClinicDistrict HospitalRural/Community Hospita... 410851.208278 \n", - "11 ClinicDistrict HospitalRural/Community Hospita... 456535.963741 \n", - "12 ClinicDistrict HospitalRural/Community Hospita... 452334.398335 \n", - "13 ClinicDistrict HospitalRural/Community Hospita... 329049.810569 \n", - "14 ClinicDistrict HospitalRural/Community Hospita... 414644.190834 \n", - "15 ClinicDistrict HospitalRural/Community Hospita... 392121.029719 \n", - "16 ClinicDistrict HospitalRural/Community Hospita... 380754.054252 \n", - "17 ClinicDistrict HospitalRural/Community Hospita... 296596.215293 \n", - "18 ClinicDistrict HospitalRural/Community Hospita... 423715.504984 \n", - "19 ClinicDistrict HospitalRural/Community Hospita... 368319.084368 \n", - "20 ClinicDistrict HospitalRural/Community Hospita... 418134.051457 \n", - "21 ClinicDistrict HospitalRural/Community Hospita... 380622.271982 \n", - "22 ClinicDistrict HospitalRural/Community Hospita... 388922.127329 \n", - "23 ClinicDistrict HospitalRural/Community Hospita... 373888.999201 \n", - "24 ClinicDistrict HospitalRural/Community Hospita... 403081.277311 \n", - "25 ClinicDistrict HospitalRural/Community Hospita... 377526.089751 \n", - "26 ClinicDistrict HospitalRural/Community Hospita... 312891.203066 \n", - "27 ClinicDistrict HospitalRural/Community Hospita... 383090.314471 \n", - "28 ClinicDistrict HospitalRural/Community Hospita... 370916.909122 \n", - "29 ClinicDistrict HospitalRural/Community Hospita... 358979.193679 \n", - "30 ClinicDistrict HospitalRural/Community Hospita... 411059.228901 \n", - "31 ClinicDistrict HospitalRural/Community Hospita... 457632.022035 \n", - "32 ClinicDistrict HospitalRural/Community Hospita... 366158.628623 \n", - "33 ClinicDistrict HospitalRural/Community Hospita... 414749.367352 \n", - "34 ClinicDistrict HospitalRural/Community Hospita... 394182.173776 \n", - "35 ClinicDistrict HospitalRural/Community Hospita... 412930.274807 \n", - "36 ClinicDistrict HospitalRural/Community Hospita... 350708.805302 \n", - "37 ClinicDistrict HospitalRural/Community Hospita... 293182.399170 \n", - "38 ClinicDistrict HospitalRural/Community Hospita... 377478.093086 \n", - "39 ClinicDistrict HospitalRural/Community Hospita... 291362.431282 \n", - "40 ClinicDistrict HospitalRural/Community Hospita... 368970.926878 \n", - "41 ClinicDistrict HospitalRural/Community Hospita... 397265.484764 \n", - "42 ClinicDistrict HospitalRural/Community Hospita... 327967.298680 \n", - "43 ClinicDistrict HospitalRural/Community Hospita... 315778.193228 \n", - "44 ClinicDistrict HospitalRural/Community Hospita... 342508.889264 \n", - "45 ClinicDistrict HospitalRural/Community Hospita... 369080.727151 \n", - "\n", - " Lag_1_Precipitation Lag_2_Precipitation Lag_3_Precipitation \\\n", - "0 398942.636170 404727.057797 405704.571665 \n", - "1 413397.817913 388309.667883 385397.116828 \n", - "2 407187.589904 420216.307417 421615.911783 \n", - "3 406189.704606 403165.981005 401105.177547 \n", - "4 420471.214026 421450.033447 424520.950185 \n", - "5 410824.557725 391493.761671 388196.210212 \n", - "6 432044.900550 456751.262273 456752.721138 \n", - "7 348112.188236 353270.524412 357410.845800 \n", - "8 405019.687496 388565.288508 388245.552346 \n", - "9 372460.875926 375124.877747 371846.112765 \n", - "10 408169.132145 406485.011941 407092.899084 \n", - "11 451325.020396 433158.134992 433133.983599 \n", - "12 481501.033891 524791.840222 527391.207421 \n", - "13 339513.871817 320576.954584 319333.523933 \n", - "14 392029.707764 393257.108114 394526.442838 \n", - "15 371789.329465 387244.681484 386630.546157 \n", - "16 440952.201046 424662.364695 425051.043775 \n", - "17 286935.705860 311049.994112 312185.510318 \n", - "18 392470.951022 356521.858749 353794.312578 \n", - "19 394609.621848 426205.552210 424729.506080 \n", - "20 414178.271428 393702.776056 395566.258413 \n", - "21 385122.990507 393876.211485 395324.082930 \n", - "22 374058.228036 360407.393814 361159.265562 \n", - "23 367702.143527 383792.892262 381569.846621 \n", - "24 406359.400288 413379.564221 402964.624861 \n", - "25 362825.700917 354087.658823 342715.089184 \n", - "26 358797.936758 363399.872412 387024.433983 \n", - "27 375109.947590 372857.980106 358164.961912 \n", - "28 367650.235635 359381.996323 367921.786733 \n", - "29 363845.441546 357419.463077 345612.633741 \n", - "30 398093.244924 420338.093431 427216.475603 \n", - "31 460331.584266 421106.585969 427549.155747 \n", - "32 355110.662118 385804.286252 377495.302483 \n", - "33 404952.222454 380148.672904 390887.435379 \n", - "34 405715.733698 429608.759456 429014.390163 \n", - "35 409799.355286 410974.276816 413298.745816 \n", - "36 353761.775712 344252.932147 343209.200439 \n", - "37 325069.624722 344289.047467 342084.186261 \n", - "38 353257.222779 353764.890202 357823.798670 \n", - "39 302326.827366 304020.083180 303828.779931 \n", - "40 368964.162462 357775.533341 356652.040920 \n", - "41 323346.039126 322784.762289 316952.269236 \n", - "42 383625.207672 394279.969633 398120.412976 \n", - "43 360494.854893 356119.648704 357486.445092 \n", - "44 323961.673652 331898.505904 332841.894862 \n", - "45 347439.884447 315453.846359 311453.513947 \n", - "\n", - " Lag_4_Precipitation Predicted_Weather_Model Predicted_No_Weather_Model \\\n", - "0 404895.268433 388170.416938 388952.687143 \n", - "1 386621.761142 388977.642536 389766.195898 \n", - "2 421535.968891 388911.689878 390581.406135 \n", - "3 400973.159779 389655.410904 391398.321414 \n", - "4 419592.912552 390987.782909 392216.945302 \n", - "5 391638.197677 393005.343703 393037.281371 \n", - "6 456824.623648 393189.485844 393859.333204 \n", - "7 357753.146752 395178.035869 394683.104387 \n", - "8 388673.117569 397007.193660 395508.598518 \n", - "9 373019.671935 395590.239618 396335.819201 \n", - "10 406919.996712 396228.566729 397164.770045 \n", - "11 432861.285260 393402.035448 397995.454671 \n", - "12 527784.234663 390976.277924 398827.876704 \n", - "13 318825.960831 404201.512252 399662.039777 \n", - "14 394260.244027 403020.063982 400497.947534 \n", - "15 387202.538290 401362.282444 401335.603622 \n", - "16 423444.969850 403300.817741 402175.011698 \n", - "17 313717.825313 406220.414477 403016.175427 \n", - "18 353491.313705 404751.067224 403859.098481 \n", - "19 424904.453286 403545.677376 404703.784539 \n", - "20 394030.949034 407191.372127 405550.237289 \n", - "21 396757.245029 407276.140971 406398.460425 \n", - "22 357396.518341 408048.952446 407248.457651 \n", - "23 384605.158226 408947.493196 408100.232678 \n", - "24 402279.134778 408196.179944 408953.789223 \n", - "25 343650.740769 412851.654339 409809.131013 \n", - "26 387553.261741 412999.055953 410666.261781 \n", - "27 357983.056662 412439.576549 411525.185270 \n", - "28 368369.784160 415583.193519 412385.905229 \n", - "29 345685.373340 415439.588486 413248.425414 \n", - "30 426320.093861 411662.387625 414112.749593 \n", - "31 427585.588743 417317.863182 414978.881537 \n", - "32 376728.920725 417068.108674 415846.825027 \n", - "33 392238.633130 416997.538415 416716.583853 \n", - "34 428209.211053 415847.029809 417588.161812 \n", - "35 414461.110789 417671.538047 418461.562707 \n", - "36 343006.625602 422880.625880 419336.790352 \n", - "37 342232.642746 423813.772316 420213.848568 \n", - "38 357126.722312 423217.736245 421092.741184 \n", - "39 303106.289335 426016.517117 421973.472035 \n", - "40 355879.690701 424905.114511 422856.044967 \n", - "41 316486.677194 428467.851539 423740.463833 \n", - "42 400442.667319 425844.848271 424626.732493 \n", - "43 357120.223981 430382.494644 425514.854816 \n", - "44 333370.975675 429356.305250 426404.834679 \n", - "45 310691.844984 430541.830595 427296.675968 \n", - "\n", - " Difference_in_Expectation Percentage_Difference \n", - "0 -782.270206 -0.002011 \n", - "1 -788.553362 -0.002023 \n", - "2 -1669.716257 -0.004275 \n", - "3 -1742.910510 -0.004453 \n", - "4 -1229.162393 -0.003134 \n", - "5 -31.937669 -0.000081 \n", - "6 -669.847360 -0.001701 \n", - "7 494.931482 0.001254 \n", - "8 1498.595142 0.003789 \n", - "9 -745.579583 -0.001881 \n", - "10 -936.203316 -0.002357 \n", - "11 -4593.419222 -0.011541 \n", - "12 -7851.598780 -0.019687 \n", - "13 4539.472475 0.011358 \n", - "14 2522.116449 0.006297 \n", - "15 26.678823 0.000066 \n", - "16 1125.806043 0.002799 \n", - "17 3204.239050 0.007951 \n", - "18 891.968743 0.002209 \n", - "19 -1158.107162 -0.002862 \n", - "20 1641.134838 0.004047 \n", - "21 877.680546 0.002160 \n", - "22 800.494794 0.001966 \n", - "23 847.260518 0.002076 \n", - "24 -757.609279 -0.001853 \n", - "25 3042.523326 0.007424 \n", - "26 2332.794171 0.005681 \n", - "27 914.391279 0.002222 \n", - "28 3197.288290 0.007753 \n", - "29 2191.163072 0.005302 \n", - "30 -2450.361967 -0.005917 \n", - "31 2338.981646 0.005636 \n", - "32 1221.283647 0.002937 \n", - "33 280.954562 0.000674 \n", - "34 -1741.132002 -0.004169 \n", - "35 -790.024660 -0.001888 \n", - "36 3543.835527 0.008451 \n", - "37 3599.923748 0.008567 \n", - "38 2124.995061 0.005046 \n", - "39 4043.045082 0.009581 \n", - "40 2049.069544 0.004846 \n", - "41 4727.387706 0.011156 \n", - "42 1218.115778 0.002869 \n", - "43 4867.639828 0.011439 \n", - "44 2951.470571 0.006922 \n", - "45 3245.154627 0.007595 " - ], - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
YearMonthFacility_IDAltitudeZoneDistrictResidOwnerFacility_TypePrecipitationLag_1_PrecipitationLag_2_PrecipitationLag_3_PrecipitationLag_4_PrecipitationPredicted_Weather_ModelPredicted_No_Weather_ModelDifference_in_ExpectationPercentage_Difference
02025255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...377371.401757398942.636170404727.057797405704.571665404895.268433388170.416938388952.687143-782.270206-0.002011
12026255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...424179.161524413397.817913388309.667883385397.116828386621.761142388977.642536389766.195898-788.553362-0.002023
22027255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...416785.291442407187.589904420216.307417421615.911783421535.968891388911.689878390581.406135-1669.716257-0.004275
32028255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...431174.255009406189.704606403165.981005401105.177547400973.159779389655.410904391398.321414-1742.910510-0.004453
42029255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...405743.410420420471.214026421450.033447424520.950185419592.912552390987.782909392216.945302-1229.162393-0.003134
52030255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...410793.849551410824.557725391493.761671388196.210212391638.197677393005.343703393037.281371-31.937669-0.000081
62031255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...430219.873937432044.900550456751.262273456752.721138456824.623648393189.485844393859.333204-669.847360-0.001701
72032255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...332427.056762348112.188236353270.524412357410.845800357753.146752395178.035869394683.104387494.9314820.001254
82033255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...392896.036283405019.687496388565.288508388245.552346388673.117569397007.193660395508.5985181498.5951420.003789
92034255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...409775.392632372460.875926375124.877747371846.112765373019.671935395590.239618396335.819201-745.579583-0.001881
102035255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...410851.208278408169.132145406485.011941407092.899084406919.996712396228.566729397164.770045-936.203316-0.002357
112036255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...456535.963741451325.020396433158.134992433133.983599432861.285260393402.035448397995.454671-4593.419222-0.011541
122037255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...452334.398335481501.033891524791.840222527391.207421527784.234663390976.277924398827.876704-7851.598780-0.019687
132038255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...329049.810569339513.871817320576.954584319333.523933318825.960831404201.512252399662.0397774539.4724750.011358
142039255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...414644.190834392029.707764393257.108114394526.442838394260.244027403020.063982400497.9475342522.1164490.006297
152040255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...392121.029719371789.329465387244.681484386630.546157387202.538290401362.282444401335.60362226.6788230.000066
162041255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...380754.054252440952.201046424662.364695425051.043775423444.969850403300.817741402175.0116981125.8060430.002799
172042255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...296596.215293286935.705860311049.994112312185.510318313717.825313406220.414477403016.1754273204.2390500.007951
182043255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...423715.504984392470.951022356521.858749353794.312578353491.313705404751.067224403859.098481891.9687430.002209
192044255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...368319.084368394609.621848426205.552210424729.506080424904.453286403545.677376404703.784539-1158.107162-0.002862
202045255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...418134.051457414178.271428393702.776056395566.258413394030.949034407191.372127405550.2372891641.1348380.004047
212046255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...380622.271982385122.990507393876.211485395324.082930396757.245029407276.140971406398.460425877.6805460.002160
222047255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...388922.127329374058.228036360407.393814361159.265562357396.518341408048.952446407248.457651800.4947940.001966
232048255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...373888.999201367702.143527383792.892262381569.846621384605.158226408947.493196408100.232678847.2605180.002076
242049255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...403081.277311406359.400288413379.564221402964.624861402279.134778408196.179944408953.789223-757.609279-0.001853
252050255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...377526.089751362825.700917354087.658823342715.089184343650.740769412851.654339409809.1310133042.5233260.007424
262051255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...312891.203066358797.936758363399.872412387024.433983387553.261741412999.055953410666.2617812332.7941710.005681
272052255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...383090.314471375109.947590372857.980106358164.961912357983.056662412439.576549411525.185270914.3912790.002222
282053255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...370916.909122367650.235635359381.996323367921.786733368369.784160415583.193519412385.9052293197.2882900.007753
292054255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...358979.193679363845.441546357419.463077345612.633741345685.373340415439.588486413248.4254142191.1630720.005302
302055255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...411059.228901398093.244924420338.093431427216.475603426320.093861411662.387625414112.749593-2450.361967-0.005917
312056255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...457632.022035460331.584266421106.585969427549.155747427585.588743417317.863182414978.8815372338.9816460.005636
322057255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...366158.628623355110.662118385804.286252377495.302483376728.920725417068.108674415846.8250271221.2836470.002937
332058255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...414749.367352404952.222454380148.672904390887.435379392238.633130416997.538415416716.583853280.9545620.000674
342059255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...394182.173776405715.733698429608.759456429014.390163428209.211053415847.029809417588.161812-1741.132002-0.004169
352060255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...412930.274807409799.355286410974.276816413298.745816414461.110789417671.538047418461.562707-790.024660-0.001888
362061255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...350708.805302353761.775712344252.932147343209.200439343006.625602422880.625880419336.7903523543.8355270.008451
372062255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...293182.399170325069.624722344289.047467342084.186261342232.642746423813.772316420213.8485683599.9237480.008567
382063255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...377478.093086353257.222779353764.890202357823.798670357126.722312423217.736245421092.7411842124.9950610.005046
392064255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...291362.431282302326.827366304020.083180303828.779931303106.289335426016.517117421973.4720354043.0450820.009581
402065255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...368970.926878368964.162462357775.533341356652.040920355879.690701424905.114511422856.0449672049.0695440.004846
412066255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...397265.484764323346.039126322784.762289316952.269236316486.677194428467.851539423740.4638334727.3877060.011156
422067255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...327967.298680383625.207672394279.969633398120.412976400442.667319425844.848271424626.7324931218.1157780.002869
432068255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...315778.193228360494.854893356119.648704357486.445092357120.223981430382.494644425514.8548164867.6398280.011439
442069255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...342508.889264323961.673652331898.505904332841.894862333370.975675429356.305250426404.8346792951.4705710.006922
452070255846435363435564.0Central WestSouth EastNorthernSouth EastNorthe...LilongweBalakaRumphiMulanjeMzimba SouthThyoloN...UrbanUrbanUrbanRuralRuralRuralRuralRuralRuralR...GovernmentGovernmentGovernmentGovernmentGovern...ClinicDistrict HospitalRural/Community Hospita...369080.727151347439.884447315453.846359311453.513947310691.844984430541.830595427296.6759683245.1546270.007595
\n", - "
" - ] - }, - "execution_count": 56, - "metadata": {}, - "output_type": "execute_result" - } - ], - "execution_count": 56 - }, - { - "metadata": { - "ExecuteTime": { - "end_time": "2025-01-13T10:17:18.418410Z", - "start_time": "2025-01-13T10:17:17.079433Z" - } - }, - "cell_type": "code", - "source": "X_Data = pd.read_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/X_basis_weather_filtered_predictions_{scenario}_{model_type}.csv')\n", - "id": "23e931c4a52c75e0", - "outputs": [], - "execution_count": 57 - }, - { - "metadata": { - "ExecuteTime": { - "end_time": "2025-01-13T10:17:18.760024Z", - "start_time": "2025-01-13T10:17:18.505205Z" - } - }, - "cell_type": "code", - "source": "X_Data", - "id": "822d8ced153a3212", - "outputs": [ - { - "data": { - "text/plain": [ - " 0 1 2 3 4 5 \\\n", - "0 227.138960 75.990148 2025.0 1.0 204.619988 28.311729 \n", - "1 317.116784 131.526620 2025.0 2.0 266.829631 48.524785 \n", - "2 266.984248 102.301429 2025.0 3.0 208.849500 100.105702 \n", - "3 368.917876 157.974521 2025.0 4.0 326.411230 79.852705 \n", - "4 314.052188 80.822535 2025.0 5.0 288.847396 61.094069 \n", - "... ... ... ... ... ... ... \n", - "181051 360.420224 125.214790 2070.0 8.0 231.566870 31.007845 \n", - "181052 173.600507 61.389035 2070.0 9.0 102.102642 25.391810 \n", - "181053 173.600507 61.389035 2070.0 10.0 102.102642 25.391810 \n", - "181054 305.104483 88.354924 2070.0 11.0 161.773682 22.511754 \n", - "181055 158.036557 43.802619 2070.0 12.0 102.304400 10.650906 \n", - "\n", - " 6 7 8 9 ... 14 15 \\\n", - "0 11.450683 0.000000 36.713877 48.249343 ... 1099.0 0.084097 \n", - "1 11.257423 1.397600 185.851873 69.883888 ... 632.0 0.089463 \n", - "2 6.713944 3.740560 84.189766 58.672121 ... 873.0 NaN \n", - "3 39.223389 5.977963 165.061924 85.193863 ... 873.0 NaN \n", - "4 19.841130 3.291834 124.108802 96.207108 ... 873.0 NaN \n", - "... ... ... ... ... ... ... ... \n", - "181051 8.802028 28.414062 267.244762 129.043669 ... 485.0 0.162431 \n", - "181052 1.456647 2.846097 47.272313 27.778078 ... 508.0 0.116303 \n", - "181053 1.456647 2.846097 47.272313 27.778078 ... 873.0 NaN \n", - "181054 10.405741 12.275218 169.608339 69.318523 ... 1149.0 0.233156 \n", - "181055 0.000000 0.000000 86.131665 69.405718 ... 873.0 0.098121 \n", - "\n", - " 16 17 18 19 20 21 22 23 \n", - "0 1.0 1.0 0.0 0.0 0.0 1.0 0.0 0.0 \n", - "1 1.0 0.0 0.0 1.0 0.0 1.0 0.0 0.0 \n", - "2 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", - "3 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", - "4 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", - "... ... ... ... ... ... ... ... ... \n", - "181051 0.0 0.0 1.0 0.0 0.0 1.0 0.0 0.0 \n", - "181052 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0 \n", - "181053 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", - "181054 0.0 0.0 1.0 0.0 0.0 1.0 0.0 0.0 \n", - "181055 0.0 0.0 0.0 0.0 0.0 1.0 0.0 0.0 \n", - "\n", - "[181056 rows x 24 columns]" - ], - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
0123456789...14151617181920212223
0227.13896075.9901482025.01.0204.61998828.31172911.4506830.00000036.71387748.249343...1099.00.0840971.01.00.00.00.01.00.00.0
1317.116784131.5266202025.02.0266.82963148.52478511.2574231.397600185.85187369.883888...632.00.0894631.00.00.01.00.01.00.00.0
2266.984248102.3014292025.03.0208.849500100.1057026.7139443.74056084.18976658.672121...873.0NaN0.00.00.00.00.00.00.00.0
3368.917876157.9745212025.04.0326.41123079.85270539.2233895.977963165.06192485.193863...873.0NaN0.00.00.00.00.00.00.00.0
4314.05218880.8225352025.05.0288.84739661.09406919.8411303.291834124.10880296.207108...873.0NaN0.00.00.00.00.00.00.00.0
..................................................................
181051360.420224125.2147902070.08.0231.56687031.0078458.80202828.414062267.244762129.043669...485.00.1624310.00.01.00.00.01.00.00.0
181052173.60050761.3890352070.09.0102.10264225.3918101.4566472.84609747.27231327.778078...508.00.1163030.00.00.01.00.00.00.00.0
181053173.60050761.3890352070.010.0102.10264225.3918101.4566472.84609747.27231327.778078...873.0NaN0.00.00.00.00.00.00.00.0
181054305.10448388.3549242070.011.0161.77368222.51175410.40574112.275218169.60833969.318523...1149.00.2331560.00.01.00.00.01.00.00.0
181055158.03655743.8026192070.012.0102.30440010.6509060.0000000.00000086.13166569.405718...873.00.0981210.00.00.00.00.01.00.00.0
\n", - "

181056 rows × 24 columns

\n", - "
" - ] - }, - "execution_count": 58, - "metadata": {}, - "output_type": "execute_result" - } - ], - "execution_count": 58 - }, - { - "metadata": { - "ExecuteTime": { - "end_time": "2025-01-13T10:17:19.294884Z", - "start_time": "2025-01-13T10:17:19.136951Z" - } - }, - "cell_type": "code", - "source": [ - "births_model_subset = births_model.iloc[15:].copy()\n", - "\n", - "matching_rows = min(len(births_model_subset), len(predictions_from_cmip_sum))\n", - "\n", - "multiplied_values = births_model_subset.head(matching_rows).iloc[:, 1].values * predictions_from_cmip_sum['Percentage_Difference'].head(matching_rows).values\n", - "\n", - "births_model_subset['Multiplied_Values'] = multiplied_values" - ], - "id": "fd6b107fed0933cb", - "outputs": [], - "execution_count": 59 - }, - { - "metadata": { - "ExecuteTime": { - "end_time": "2025-01-13T10:17:21.172464Z", - "start_time": "2025-01-13T10:17:21.002613Z" - } - }, - "cell_type": "code", - "source": [ - "year_range = range(2025, 2061)\n", - "\n", - "plt.plot(year_range, multiplied_values)\n", - "plt.ylabel(\"Change ANC cases due to weather\")\n", - "plt.axhline(y=0, color='black', linestyle='--') " - ], - "id": "c0ed116b28287eaa", - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 60, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "execution_count": 60 - }, - { - "metadata": { - "ExecuteTime": { - "end_time": "2025-01-13T10:17:21.691092Z", - "start_time": "2025-01-13T10:17:21.234583Z" - } - }, - "cell_type": "code", - "source": [ - "plt.plot(year_range, predictions_from_cmip_sum.iloc[0:36, -1]*100)\n", - "plt.xlabel(\"Percentage Change in ANC cases due to weather\")\n", - "plt.axhline(y=0, color='black', linestyle='--') " - ], - "id": "55dba29ded951def", - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 61, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "execution_count": 61 - }, - { - "metadata": {}, - "cell_type": "markdown", - "source": "# Negative values - missed cases?", - "id": "247b1e99fa019564" - }, - { - "metadata": { - "ExecuteTime": { - "end_time": "2025-01-13T10:17:24.698336Z", - "start_time": "2025-01-13T10:17:24.680930Z" - } - }, - "cell_type": "code", - "source": [ - "negative_sum = np.sum(multiplied_values[multiplied_values < 0])\n", - "\n", - "print(\"Sum of values < 0:\", negative_sum)\n", - "print(negative_sum/births_model_subset['Model_mean'].sum() * 100)\n" - ], - "id": "67d8c94409dcd37", - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Sum of values < 0: -53722.68208498721\n", - "-0.18758935119751025\n" - ] - } - ], - "execution_count": 62 - }, - { - "metadata": {}, - "cell_type": "markdown", - "source": "Difference by Zone", - "id": "197776c5bef6b35c" - }, - { - "metadata": { - "ExecuteTime": { - "end_time": "2025-01-09T11:52:20.723816Z", - "start_time": "2025-01-09T11:52:20.533633Z" - } - }, - "cell_type": "code", - "source": [ - "predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'Zone']).sum().reset_index()\n", - "\n", - "# Plot each zone\n", - "plt.figure(figsize=(10, 6))\n", - "for zone in predictions_from_cmip_sum['Zone'].unique():\n", - " zone_data = predictions_from_cmip_sum[predictions_from_cmip_sum['Zone'] == zone]\n", - " zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data['Predicted_No_Weather_Model']) * 100\n", - " plt.plot(zone_data['Year'], zone_data['Percentage_Difference'], label=f'Zone {zone}')\n", - "\n", - "plt.xlabel(\"Year\")\n", - "plt.ylabel(\"Change ANC cases due to weather\")\n", - "plt.axhline(y=0, color='black', linestyle='--')\n", - "plt.ylim(-1.5, 0)\n", - "plt.legend(title='Zones')\n", - "plt.show()" - ], - "id": "8f79bf2846942b7f", - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/4003818095.py:7: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/4003818095.py:7: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/4003818095.py:7: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/4003818095.py:7: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data['Predicted_No_Weather_Model']) * 100\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_17473/4003818095.py:7: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " zone_data['Percentage_Difference'] = (zone_data['Difference_in_Expectation'] / zone_data['Predicted_No_Weather_Model']) * 100\n" - ] - }, - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "execution_count": 36 - }, - { - "metadata": {}, - "cell_type": "markdown", - "source": "District", - "id": "cdb91b16e915cf71" - }, - { - "metadata": { - "ExecuteTime": { - "end_time": "2025-01-09T13:28:18.206069Z", - "start_time": "2025-01-09T13:28:17.922833Z" - } - }, - "cell_type": "code", - "source": [ - "predictions_from_cmip_sum = predictions_from_cmip.groupby(['Year', 'District']).sum().reset_index()\n", - "\n", - "# Plot each zone\n", - "plt.figure(figsize=(10, 6))\n", - "for district in predictions_from_cmip_sum['District'].unique():\n", - " district_data = predictions_from_cmip_sum[predictions_from_cmip_sum['District'] == district]\n", - " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n", - " plt.plot(district_data['Year'], district_data['Percentage_Difference'], label=f'{district}')\n", - "\n", - "plt.xlabel(\"Year\")\n", - "plt.ylabel(\"Change ANC cases due to weather\")\n", - "plt.axhline(y=0, color='black', linestyle='--')\n", - "plt.ylim(-2.5, 0)\n", - "plt.legend(title='Districts')\n", - "plt.show()" - ], - "id": "cce81039627dfb67", - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_18188/3611777628.py:7: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " district_data['Percentage_Difference'] = (district_data['Difference_in_Expectation'] / district_data['Predicted_No_Weather_Model']) * 100\n" - ] - }, - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "execution_count": 35 - }, - { - "metadata": {}, - "cell_type": "markdown", - "source": "# Loop over all ", - "id": "f49ed5d53595c9f0" - }, - { - "metadata": { - "ExecuteTime": { - "end_time": "2025-01-09T13:28:20.701932Z", - "start_time": "2025-01-09T13:28:19.465368Z" - } - }, - "cell_type": "code", - "source": [ - "model_types = ['lowest', 'median', 'highest']\n", - "ssp_scenarios = [\"ssp245\", \"ssp585\"]\n", - "\n", - "results_list = []\n", - "\n", - "for scenario in ssp_scenarios:\n", - " for model_type in model_types:\n", - " predictions_from_cmip = pd.read_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_{scenario}_{model_type}.csv')\n", - " predictions_from_cmip['Percentage_Difference'] = (\n", - " predictions_from_cmip['Difference_in_Expectation'] / \n", - " predictions_from_cmip['Predicted_No_Weather_Model']\n", - " ) * 100\n", - " \n", - " births_model_subset = births_model.iloc[15:].copy()\n", - " matching_rows = min(len(births_model_subset), len(predictions_from_cmip))\n", - " multiplied_values = (\n", - " births_model_subset.head(matching_rows).iloc[:, 1].values *\n", - " predictions_from_cmip['Percentage_Difference'].head(matching_rows).values\n", - " )\n", - " \n", - " births_model_subset['Multiplied_Values'] = multiplied_values\n", - " \n", - " for zone in predictions_from_cmip['Zone'].unique():\n", - " zone_data = predictions_from_cmip[predictions_from_cmip['Zone'] == zone]\n", - " zone_data['Percentage_Difference'] = (\n", - " (zone_data['Difference_in_Expectation'] / zone_data['Predicted_No_Weather_Model']) * 100\n", - " )\n", - " \n", - " results_list.append({\n", - " \"Scenario\": scenario,\n", - " \"Model_Type\": model_type,\n", - " \"Zone\": zone,\n", - " \"Percentage_Difference\": zone_data['Percentage_Difference'].mean(),\n", - " \"Multiplied_Values\": multiplied_values.mean()\n", - " })\n", - "\n", - " " - ], - "id": "a9e5133a6a49985a", - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_18188/3827770855.py:25: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " zone_data['Percentage_Difference'] = (\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_18188/3827770855.py:25: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " zone_data['Percentage_Difference'] = (\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_18188/3827770855.py:25: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " zone_data['Percentage_Difference'] = (\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_18188/3827770855.py:25: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " zone_data['Percentage_Difference'] = (\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_18188/3827770855.py:25: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " zone_data['Percentage_Difference'] = (\n", - "/var/folders/1z/j8w4v5lj4k580xt42fkwh7dw0000gn/T/ipykernel_18188/3827770855.py:25: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " zone_data['Percentage_Difference'] = (\n" - ] - } - ], - "execution_count": 36 - }, - { - "metadata": { - "ExecuteTime": { - "end_time": "2025-01-09T13:28:21.974599Z", - "start_time": "2025-01-09T13:28:21.970166Z" - } - }, - "cell_type": "code", - "source": "results_list", - "id": "bc2715c9d4c9cfd3", - "outputs": [ - { - "data": { - "text/plain": [ - "[{'Scenario': 'ssp245',\n", - " 'Model_Type': 'lowest',\n", - " 'Zone': 'Central West',\n", - " 'Percentage_Difference': -0.1931910818987726,\n", - " 'Multiplied_Values': nan},\n", - " {'Scenario': 'ssp245',\n", - " 'Model_Type': 'lowest',\n", - " 'Zone': 'South East',\n", - " 'Percentage_Difference': -0.3314323561856577,\n", - " 'Multiplied_Values': nan},\n", - " {'Scenario': 'ssp245',\n", - " 'Model_Type': 'lowest',\n", - " 'Zone': nan,\n", - " 'Percentage_Difference': nan,\n", - " 'Multiplied_Values': nan},\n", - " {'Scenario': 'ssp245',\n", - " 'Model_Type': 'lowest',\n", - " 'Zone': 'Northern',\n", - " 'Percentage_Difference': -0.24607017494457492,\n", - " 'Multiplied_Values': nan},\n", - " {'Scenario': 'ssp245',\n", - " 'Model_Type': 'lowest',\n", - " 'Zone': 'South West',\n", - " 'Percentage_Difference': -0.47686076003686034,\n", - " 'Multiplied_Values': nan},\n", - " {'Scenario': 'ssp245',\n", - " 'Model_Type': 'lowest',\n", - " 'Zone': 'Central East',\n", - " 'Percentage_Difference': -0.11908906889403516,\n", - " 'Multiplied_Values': nan},\n", - " {'Scenario': 'ssp245',\n", - " 'Model_Type': 'median',\n", - " 'Zone': 'Central West',\n", - " 'Percentage_Difference': -0.36628333460755774,\n", - " 'Multiplied_Values': nan},\n", - " {'Scenario': 'ssp245',\n", - " 'Model_Type': 'median',\n", - " 'Zone': 'South East',\n", - " 'Percentage_Difference': -0.5370975141167456,\n", - " 'Multiplied_Values': nan},\n", - " {'Scenario': 'ssp245',\n", - " 'Model_Type': 'median',\n", - " 'Zone': nan,\n", - " 'Percentage_Difference': nan,\n", - " 'Multiplied_Values': nan},\n", - " {'Scenario': 'ssp245',\n", - " 'Model_Type': 'median',\n", - " 'Zone': 'Northern',\n", - " 'Percentage_Difference': -0.1767448997486594,\n", - " 'Multiplied_Values': nan},\n", - " {'Scenario': 'ssp245',\n", - " 'Model_Type': 'median',\n", - " 'Zone': 'South West',\n", - " 'Percentage_Difference': -0.535989250210467,\n", - " 'Multiplied_Values': nan},\n", - " {'Scenario': 'ssp245',\n", - " 'Model_Type': 'median',\n", - " 'Zone': 'Central East',\n", - " 'Percentage_Difference': -0.23255844930782898,\n", - " 'Multiplied_Values': nan},\n", - " {'Scenario': 'ssp245',\n", - " 'Model_Type': 'highest',\n", - " 'Zone': 'Central West',\n", - " 'Percentage_Difference': 0.12906250288407198,\n", - " 'Multiplied_Values': nan},\n", - " {'Scenario': 'ssp245',\n", - " 'Model_Type': 'highest',\n", - " 'Zone': 'South East',\n", - " 'Percentage_Difference': 0.036544565987316396,\n", - " 'Multiplied_Values': nan},\n", - " {'Scenario': 'ssp245',\n", - " 'Model_Type': 'highest',\n", - " 'Zone': nan,\n", - " 'Percentage_Difference': nan,\n", - " 'Multiplied_Values': nan},\n", - " {'Scenario': 'ssp245',\n", - " 'Model_Type': 'highest',\n", - " 'Zone': 'Northern',\n", - " 'Percentage_Difference': -0.11865510374052105,\n", - " 'Multiplied_Values': nan},\n", - " {'Scenario': 'ssp245',\n", - " 'Model_Type': 'highest',\n", - " 'Zone': 'South West',\n", - " 'Percentage_Difference': -0.02237424340918628,\n", - " 'Multiplied_Values': nan},\n", - " {'Scenario': 'ssp245',\n", - " 'Model_Type': 'highest',\n", - " 'Zone': 'Central East',\n", - " 'Percentage_Difference': 0.12450572159528503,\n", - " 'Multiplied_Values': nan},\n", - " {'Scenario': 'ssp585',\n", - " 'Model_Type': 'lowest',\n", - " 'Zone': 'Central West',\n", - " 'Percentage_Difference': -0.22897010507117518,\n", - " 'Multiplied_Values': nan},\n", - " {'Scenario': 'ssp585',\n", - " 'Model_Type': 'lowest',\n", - " 'Zone': 'South East',\n", - " 'Percentage_Difference': -0.3152239861164687,\n", - " 'Multiplied_Values': nan},\n", - " {'Scenario': 'ssp585',\n", - " 'Model_Type': 'lowest',\n", - " 'Zone': nan,\n", - " 'Percentage_Difference': nan,\n", - " 'Multiplied_Values': nan},\n", - " {'Scenario': 'ssp585',\n", - " 'Model_Type': 'lowest',\n", - " 'Zone': 'Northern',\n", - " 'Percentage_Difference': -0.15877546019135516,\n", - " 'Multiplied_Values': nan},\n", - " {'Scenario': 'ssp585',\n", - " 'Model_Type': 'lowest',\n", - " 'Zone': 'South West',\n", - " 'Percentage_Difference': -0.4406747802624256,\n", - " 'Multiplied_Values': nan},\n", - " {'Scenario': 'ssp585',\n", - " 'Model_Type': 'lowest',\n", - " 'Zone': 'Central East',\n", - " 'Percentage_Difference': -0.14957537455833142,\n", - " 'Multiplied_Values': nan},\n", - " {'Scenario': 'ssp585',\n", - " 'Model_Type': 'median',\n", - " 'Zone': 'Central West',\n", - " 'Percentage_Difference': -0.314623863084536,\n", - " 'Multiplied_Values': nan},\n", - " {'Scenario': 'ssp585',\n", - " 'Model_Type': 'median',\n", - " 'Zone': 'South East',\n", - " 'Percentage_Difference': -0.33844763980757053,\n", - " 'Multiplied_Values': nan},\n", - " {'Scenario': 'ssp585',\n", - " 'Model_Type': 'median',\n", - " 'Zone': nan,\n", - " 'Percentage_Difference': nan,\n", - " 'Multiplied_Values': nan},\n", - " {'Scenario': 'ssp585',\n", - " 'Model_Type': 'median',\n", - " 'Zone': 'Northern',\n", - " 'Percentage_Difference': -0.08126478735382436,\n", - " 'Multiplied_Values': nan},\n", - " {'Scenario': 'ssp585',\n", - " 'Model_Type': 'median',\n", - " 'Zone': 'South West',\n", - " 'Percentage_Difference': -0.3079082261332242,\n", - " 'Multiplied_Values': nan},\n", - " {'Scenario': 'ssp585',\n", - " 'Model_Type': 'median',\n", - " 'Zone': 'Central East',\n", - " 'Percentage_Difference': -0.19505941246927425,\n", - " 'Multiplied_Values': nan},\n", - " {'Scenario': 'ssp585',\n", - " 'Model_Type': 'highest',\n", - " 'Zone': 'Central West',\n", - " 'Percentage_Difference': -0.053375539588824426,\n", - " 'Multiplied_Values': nan},\n", - " {'Scenario': 'ssp585',\n", - " 'Model_Type': 'highest',\n", - " 'Zone': 'South East',\n", - " 'Percentage_Difference': -0.35838668109186017,\n", - " 'Multiplied_Values': nan},\n", - " {'Scenario': 'ssp585',\n", - " 'Model_Type': 'highest',\n", - " 'Zone': nan,\n", - " 'Percentage_Difference': nan,\n", - " 'Multiplied_Values': nan},\n", - " {'Scenario': 'ssp585',\n", - " 'Model_Type': 'highest',\n", - " 'Zone': 'Northern',\n", - " 'Percentage_Difference': -0.15422680749880371,\n", - " 'Multiplied_Values': nan},\n", - " {'Scenario': 'ssp585',\n", - " 'Model_Type': 'highest',\n", - " 'Zone': 'South West',\n", - " 'Percentage_Difference': -0.33682704005296926,\n", - " 'Multiplied_Values': nan},\n", - " {'Scenario': 'ssp585',\n", - " 'Model_Type': 'highest',\n", - " 'Zone': 'Central East',\n", - " 'Percentage_Difference': -0.08754498899133552,\n", - " 'Multiplied_Values': nan}]" - ] - }, - "execution_count": 37, - "metadata": {}, - "output_type": "execute_result" - } - ], - "execution_count": 37 - }, - { - "metadata": {}, - "cell_type": "markdown", - "source": "# Try add a map ", - "id": "7eefb2b319ba4739" - }, - { - "metadata": {}, - "cell_type": "markdown", - "source": "Change names of some \"districts\" for consistency ", - "id": "16e6ddbdd7d8fc0b" - }, - { - "metadata": {}, - "cell_type": "markdown", - "source": "", - "id": "143a79f7bd3378b" - }, - { - "metadata": { - "ExecuteTime": { - "end_time": "2025-01-09T13:28:24.117221Z", - "start_time": "2025-01-09T13:28:24.113163Z" - } - }, - "cell_type": "code", - "source": [ - "predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace(\"Mzimba North\", \"Mzimba\")\n", - "predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace(\"Mzimba South\", \"Mzimba\")\n" - ], - "id": "4fc203ff0269768", - "outputs": [], - "execution_count": 38 - }, - { - "metadata": { - "ExecuteTime": { - "end_time": "2025-01-09T13:28:25.180232Z", - "start_time": "2025-01-09T13:28:24.547590Z" - } - }, - "cell_type": "code", - "source": [ - "import geopandas as gpd\n", - "from netCDF4 import Dataset\n", - "from shapely.geometry import Polygon\n", - "from matplotlib import colors as mcolors\n", - "import matplotlib.pyplot as plt\n", - "import pandas as pd\n", - "import numpy as np\n", - "\n", - "file_path_historical_data = \"/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/2011/60ab007aa16d679a32f9c3e186d2f744.nc\"\n", - "dataset = Dataset(file_path_historical_data, mode='r')\n", - "pr_data = dataset.variables['tp'][:]\n", - "lat_data = dataset.variables['latitude'][:]\n", - "long_data = dataset.variables['longitude'][:]\n", - "meshgrid_from_netCDF = np.meshgrid(long_data, lat_data)\n", - "\n", - "malawi = gpd.read_file(\"/Users/rem76/PycharmProjects/TLOmodel/resources/mapping/ResourceFile_mwi_admbnda_adm0_nso_20181016.shp\")\n", - "malawi_admin2 = gpd.read_file(\"/Users/rem76/PycharmProjects/TLOmodel/resources/mapping/ResourceFile_mwi_admbnda_adm2_nso_20181016.shp\")\n", - "\n", - "# change names of some districts for consistency \n", - "predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace(\"Mzimba North\", \"Mzimba\")\n", - "predictions_from_cmip_sum['District'] = predictions_from_cmip_sum['District'].replace(\"Mzimba South\", \"Mzimba\")\n", - "malawi_admin2['ADM2_EN'] = malawi_admin2['ADM2_EN'].replace('Blantyre City', 'Blantyre')\n", - "malawi_admin2['ADM2_EN'] = malawi_admin2['ADM2_EN'].replace('Mzuzu City', 'Mzuzu')\n", - "malawi_admin2['ADM2_EN'] = malawi_admin2['ADM2_EN'].replace('Lilongwe City', 'Lilongwe')\n", - "\n", - "difference_lat = lat_data[1] - lat_data[0]\n", - "difference_long = long_data[1] - long_data[0]\n", - "\n", - "polygons = []\n", - "for x in long_data:\n", - " for y in lat_data:\n", - " bottom_left = (x, y)\n", - " bottom_right = (x + difference_long, y)\n", - " top_right = (x + difference_long, y + difference_lat)\n", - " top_left = (x, y + difference_lat)\n", - " polygon = Polygon([bottom_left, bottom_right, top_right, top_left])\n", - " polygons.append(polygon)\n", - "grid = gpd.GeoDataFrame({'geometry': polygons}, crs=malawi.crs)\n", - "\n", - "grid_clipped_ADM2 = gpd.overlay(grid, malawi_admin2, how='intersection')\n", - "\n", - "# Read predictions and calculate Percentage_Difference\n", - "predictions_from_cmip_sum['Percentage_Difference'] = (\n", - " predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model']\n", - ") * 100\n", - "\n", - "percentage_diff_by_district = predictions_from_cmip_sum.groupby('District')['Percentage_Difference'].mean()\n", - "grid_clipped_ADM2['Percentage_Difference'] = grid_clipped_ADM2['ADM2_EN'].map(percentage_diff_by_district)\n", - "\n", - "\n", - "fig, ax = plt.subplots(figsize=(12, 12))\n", - "\n", - "malawi_admin2.plot(ax=ax, edgecolor='black', color='white')\n", - "grid_clipped_ADM2.loc[grid_clipped_ADM2['Percentage_Difference'] > 0, 'Percentage_Difference'] = 0\n", - "\n", - "\n", - "grid_clipped_ADM2.dropna(subset=['Percentage_Difference']).plot(\n", - " ax=ax,\n", - " column='Percentage_Difference',\n", - " cmap='Blues_r',\n", - " edgecolor='black',\n", - " alpha=0.6,\n", - " legend=False\n", - ")\n", - "\n", - "sm = plt.cm.ScalarMappable(cmap='Blues_r', norm=mcolors.Normalize(\n", - " vmin=grid_clipped_ADM2['Percentage_Difference'].min(), vmax=grid_clipped_ADM2['Percentage_Difference'].max()))\n", - "sm.set_array([])\n", - "cbar = plt.colorbar(sm, ax=ax, orientation=\"vertical\", shrink=0.7)\n", - "plt.clim(grid_clipped_ADM2['Percentage_Difference'].min(), 0)\n", - "cbar.set_label(\"Percentage Difference (%)\", fontsize=12)\n", - "\n", - "plt.xlabel(\"Longitude\", fontsize=14)\n", - "plt.ylabel(\"Latitude\", fontsize=14)\n", - "plt.title(\"Malawi Districts by Percentage Difference\", fontsize=16)\n", - "plt.tight_layout()\n", - "\n", - "plt.show()\n" - ], - "id": "1dfcf27d72655955", - "outputs": [ - { - "ename": "RuntimeError", - "evalue": "You must first define an image, e.g., with imshow", - "output_type": "error", - "traceback": [ - "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m", - "\u001B[0;31mRuntimeError\u001B[0m Traceback (most recent call last)", - "Cell \u001B[0;32mIn[39], line 70\u001B[0m\n\u001B[1;32m 68\u001B[0m sm\u001B[38;5;241m.\u001B[39mset_array([])\n\u001B[1;32m 69\u001B[0m cbar \u001B[38;5;241m=\u001B[39m plt\u001B[38;5;241m.\u001B[39mcolorbar(sm, ax\u001B[38;5;241m=\u001B[39max, orientation\u001B[38;5;241m=\u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mvertical\u001B[39m\u001B[38;5;124m\"\u001B[39m, shrink\u001B[38;5;241m=\u001B[39m\u001B[38;5;241m0.7\u001B[39m)\n\u001B[0;32m---> 70\u001B[0m \u001B[43mplt\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mclim\u001B[49m\u001B[43m(\u001B[49m\u001B[43mgrid_clipped_ADM2\u001B[49m\u001B[43m[\u001B[49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[38;5;124;43mPercentage_Difference\u001B[39;49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[43m]\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mmin\u001B[49m\u001B[43m(\u001B[49m\u001B[43m)\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m0\u001B[39;49m\u001B[43m)\u001B[49m\n\u001B[1;32m 71\u001B[0m cbar\u001B[38;5;241m.\u001B[39mset_label(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mPercentage Difference (\u001B[39m\u001B[38;5;124m%\u001B[39m\u001B[38;5;124m)\u001B[39m\u001B[38;5;124m\"\u001B[39m, fontsize\u001B[38;5;241m=\u001B[39m\u001B[38;5;241m12\u001B[39m)\n\u001B[1;32m 73\u001B[0m plt\u001B[38;5;241m.\u001B[39mxlabel(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mLongitude\u001B[39m\u001B[38;5;124m\"\u001B[39m, fontsize\u001B[38;5;241m=\u001B[39m\u001B[38;5;241m14\u001B[39m)\n", - "File \u001B[0;32m/opt/anaconda3/envs/tlo/lib/python3.11/site-packages/matplotlib/pyplot.py:2157\u001B[0m, in \u001B[0;36mclim\u001B[0;34m(vmin, vmax)\u001B[0m\n\u001B[1;32m 2155\u001B[0m im \u001B[38;5;241m=\u001B[39m gci()\n\u001B[1;32m 2156\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m im \u001B[38;5;129;01mis\u001B[39;00m \u001B[38;5;28;01mNone\u001B[39;00m:\n\u001B[0;32m-> 2157\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m \u001B[38;5;167;01mRuntimeError\u001B[39;00m(\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mYou must first define an image, e.g., with imshow\u001B[39m\u001B[38;5;124m'\u001B[39m)\n\u001B[1;32m 2159\u001B[0m im\u001B[38;5;241m.\u001B[39mset_clim(vmin, vmax)\n", - "\u001B[0;31mRuntimeError\u001B[0m: You must first define an image, e.g., with imshow" - ] - }, - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "execution_count": 39 - }, - { - "metadata": {}, - "cell_type": "code", - "source": [ - "# Get unique districts from both sources\n", - "adm2_districts = set(grid_clipped_ADM2['ADM2_EN'].unique())\n", - "prediction_districts = set(predictions_from_cmip_sum['District'].unique())\n", - "\n", - "# Districts in ADM2 but not in predictions\n", - "missing_in_predictions = adm2_districts - prediction_districts\n", - "print(\"Districts in ADM2 but not in predictions:\", missing_in_predictions)\n", - "\n", - "# Districts in predictions but not in ADM2\n", - "missing_in_adm2 = prediction_districts - adm2_districts\n", - "print(\"Districts in predictions but not in ADM2:\", missing_in_adm2)" - ], - "id": "165106827759887c", - "outputs": [], - "execution_count": null - }, - { - "metadata": {}, - "cell_type": "code", - "source": "", - "id": "a835bddc9c0be86f", - "outputs": [], - "execution_count": null - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 2 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From 06b8f72e51d6b281da7caec00dd7b88a2c3c27fb Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 27 Feb 2025 10:02:50 +0000 Subject: [PATCH 283/291] So, from https://dhsprogram.com/publications/publication-fr319-dhs-final-reports.cfm, looks like average number of visits per woman is 3.2. Then, using the 1.4 pregncny:birth conversion from TLO, would mean one birth = 4.4 ANC appointmemts. Moved conversion so it happens at the top of the script --- src/scripts/climate_change/cohort_model.py | 271 ++++++++++++++------- 1 file changed, 183 insertions(+), 88 deletions(-) diff --git a/src/scripts/climate_change/cohort_model.py b/src/scripts/climate_change/cohort_model.py index 059fa9026f..d3c1f84bc9 100644 --- a/src/scripts/climate_change/cohort_model.py +++ b/src/scripts/climate_change/cohort_model.py @@ -1,5 +1,4 @@ from pathlib import Path -from scipy.stats import ttest_rel, wilcoxon, shapiro from scipy.stats import ttest_1samp import geopandas as gpd @@ -9,7 +8,8 @@ import matplotlib.pyplot as plt import pandas as pd import numpy as np - +import seaborn as sns +import os from tlo.analysis.utils import ( extract_results, make_age_grp_lookup, @@ -29,7 +29,8 @@ ANC =True if ANC: service = 'ANC' - +conversion_births_to_pregnancies = 1.4 +converstion_pregnancies_to_ANC = 4.4 # average number of ANC visits ## Get birth results results_folder_to_save = Path(f'/Users/rem76/Desktop/Climate_change_health/Results/{service}_disruptions') results_folder_for_births = Path("/Users/rem76/PycharmProjects/TLOmodel/outputs/rm916@ic.ac.uk/longterm_trends_all_diseases-2024-09-25T110820Z") @@ -39,6 +40,8 @@ print(precipitation_threshold) agegrps, agegrplookup = make_age_grp_lookup() calperiods, calperiodlookup = make_calendar_period_lookup() + +## Organise births births_results = extract_results( results_folder_for_births, module="tlo.methods.demography", @@ -49,10 +52,9 @@ do_scaling=True ) -print(births_results) births_results = births_results.groupby(by=births_results.index).sum() births_results = births_results.replace({0: np.nan}) - +births_results['Model_mean'] = births_results * conversion_births_to_pregnancies / converstion_pregnancies_to_ANC births_model = summarize(births_results, collapse_columns=True) births_model.columns = ['Model_' + col for col in births_model.columns] births_model_subset = births_model.iloc[15:].copy() # don't want 2010-2024 @@ -100,7 +102,7 @@ # Match birth results and predictions matching_rows = min(len(births_model_subset), len(predictions_from_cmip_sum)) multiplied_values = births_model_subset.head(matching_rows).iloc[:, 1].values * predictions_from_cmip_sum[ - 'Percentage_Difference'].head(matching_rows).values * 1.4 # 1.4 is conversion from births to pregnacnies + 'Percentage_Difference'].head(matching_rows).values # Check for negative values (missed cases?) negative_sum = np.sum(multiplied_values[multiplied_values < 0]) @@ -109,14 +111,13 @@ filtered_predictions = predictions_from_cmip[predictions_from_cmip['Precipitation'] >= precipitation_threshold] filtered_predictions_sum = filtered_predictions.groupby('Year').sum().reset_index() percent_due_to_extreme = filtered_predictions_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model'] - print(percent_due_to_extreme) - multiplied_values_extreme_precip = births_model_subset.head(matching_rows).iloc[:, 1].values * percent_due_to_extreme.head(matching_rows).values * 1.4 + multiplied_values_extreme_precip = births_model_subset.head(matching_rows).iloc[:, 1].values * percent_due_to_extreme.head(matching_rows).values negative_sum_extreme_precip = np.sum(multiplied_values_extreme_precip[multiplied_values_extreme_precip < 0]) result_df = pd.DataFrame({ "Scenario": [scenario], "Model_Type": [model_type], "Negative_Sum": [negative_sum], - "Negative_Percentage": [negative_sum / (births_model_subset['Model_mean'].sum() * 1.4) * 100], + "Negative_Percentage": [negative_sum / births_model_subset['Model_mean'].sum() * 100], "Extreme_Precip": [negative_sum_extreme_precip], "Extreme_Precip_Percentage": [(negative_sum_extreme_precip / negative_sum) * 100] }) @@ -236,8 +237,6 @@ significant_results_year = [] -# -# Assuming 'district' is a column in your data for scenario in scenarios: for model_type in model_types: predictions_from_cmip = pd.read_csv( @@ -331,8 +330,8 @@ percentage_diff_by_year_district[year] = {} if district not in percentage_diff_by_year_district[year]: percentage_diff_by_year_district[year][district] = 0 - percentage_diff_by_year_district[year][district] += (percentage_diff * number_of_births) * 1.4 # 1.4 is conversion factor between births and pregancies - percentage_diff_by_year_district_scenario[scenario][model_type] = (percentage_diff * number_of_births) * 1.4 + percentage_diff_by_year_district[year][district] += (percentage_diff * number_of_births) + percentage_diff_by_year_district_scenario[scenario][model_type] = (percentage_diff * number_of_births) data_for_plot = pd.DataFrame.from_dict(percentage_diff_by_year_district, orient='index').fillna(0) y_min = min(y_min, data_for_plot.min().min()) @@ -425,8 +424,8 @@ percentage_diff_by_year_district[year] = {} if district not in percentage_diff_by_year_district[year]: percentage_diff_by_year_district[year][district] = 0 - percentage_diff_by_year_district[year][district] += ((percentage_diff * number_of_births) * 1.4)/(number_of_births*1.4) * 1000 # 1.4 is conversion factor between births and pregancies - percentage_diff_by_year_district_scenario[scenario][model_type] = (percentage_diff * number_of_births) * 1.4 + percentage_diff_by_year_district[year][district] += ((percentage_diff * number_of_births))/(number_of_births) * 1000 + percentage_diff_by_year_district_scenario[scenario][model_type] = (percentage_diff * number_of_births) data_for_plot = pd.DataFrame.from_dict(percentage_diff_by_year_district, orient='index').fillna(0) y_min = min(y_min, data_for_plot.min().min()) @@ -516,8 +515,8 @@ percentage_diff_by_year_zone[year] = {} if zone not in percentage_diff_by_year_zone[year]: percentage_diff_by_year_zone[year][zone] = 0 - percentage_diff_by_year_zone[year][zone] += ((percentage_diff * number_of_births) * 1.4)/(number_of_births*1.4) * 1000 # 1.4 is conversion factor between births and pregancies - percentage_diff_by_year_zone_scenario[scenario][model_type] = (percentage_diff * number_of_births) * 1.4 + percentage_diff_by_year_zone[year][zone] += ((percentage_diff * number_of_births))/(number_of_births) * 1000 + percentage_diff_by_year_zone_scenario[scenario][model_type] = (percentage_diff * number_of_births) data_for_plot = pd.DataFrame.from_dict(percentage_diff_by_year_zone, orient='index').fillna(0) y_min = min(y_min, data_for_plot.min().min()) @@ -549,7 +548,7 @@ #plt.show() # -####### BASELINE HISTORICAL disruptions ########## +####### BASELINE disruptions ########## baseline_predictions = pd.read_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_baseline_{service}.csv') @@ -612,7 +611,7 @@ 'Predicted_No_Weather_Model']) # Match birth results and predictions multiplied_values_baseline = births_model_subset_historical.values * baseline_predictions_negative_sum[ - 'Percentage_Difference'].values * 1.4 # 1.4 is conversion from births to pregnacnies + 'Percentage_Difference'].values # Check for negative values (missed cases?) negative_sum_baseline = np.sum(multiplied_values_baseline[multiplied_values_baseline < 0]) @@ -622,11 +621,11 @@ filtered_predictions_sum_baseline = filtered_predictions_baseline.groupby('Year').sum().reset_index() percent_due_to_extreme_baseline = filtered_predictions_sum_baseline['Difference_in_Expectation'] / baseline_predictions_negative_sum['Predicted_No_Weather_Model'] print(percent_due_to_extreme_baseline) -multiplied_values_extreme_precip_baseline = births_model_subset_historical.values * percent_due_to_extreme_baseline.values * 1.4 +multiplied_values_extreme_precip_baseline = births_model_subset_historical.values * percent_due_to_extreme_baseline.values negative_sum_extreme_precip_baseline = np.sum(multiplied_values_extreme_precip_baseline[multiplied_values_extreme_precip_baseline < 0]) result_df_baseline = pd.DataFrame({ "Negative_Sum": [negative_sum_baseline], - "Negative_Percentage": [negative_sum_baseline / (births_model_subset_historical.sum() * 1.4) * 100], + "Negative_Percentage": [negative_sum_baseline / (births_model_subset_historical.sum()) * 100], "Extreme_Precip": [negative_sum_extreme_precip_baseline], "Extreme_Precip_Percentage": [(negative_sum_extreme_precip_baseline / negative_sum_baseline) * 100] }) @@ -656,7 +655,7 @@ 'Predicted_No_Weather_Model']) # Match birth results and predictions multiplied_values_historical = births_model_subset_historical.values * historical_predictions_negative_sum[ - 'Percentage_Difference'].values * 1.4 # 1.4 is conversion from births to pregnacnies + 'Percentage_Difference'].values # Check for negative values (missed cases?) negative_sum_historical = np.sum(multiplied_values_historical[multiplied_values_historical < 0]) @@ -666,11 +665,11 @@ filtered_predictions_sum_historical = filtered_predictions_historical.groupby('Year').sum().reset_index() percent_due_to_extreme_historical = filtered_predictions_sum_historical['Difference_in_Expectation'] / historical_predictions_negative_sum['Predicted_No_Weather_Model'] print(percent_due_to_extreme_historical) -multiplied_values_extreme_precip_historical = births_model_subset_historical.values * percent_due_to_extreme_historical.values * 1.4 +multiplied_values_extreme_precip_historical = births_model_subset_historical.values * percent_due_to_extreme_historical.values negative_sum_extreme_precip_historical = np.sum(multiplied_values_extreme_precip_historical[multiplied_values_extreme_precip_historical < 0]) result_df_historical = pd.DataFrame({ "Negative_Sum": [negative_sum_historical], - "Negative_Percentage": [negative_sum_historical / (births_model_subset_historical.sum() * 1.4) * 100], + "Negative_Percentage": [negative_sum_historical / (births_model_subset_historical.sum() ) * 100], "Extreme_Precip": [negative_sum_extreme_precip_historical], "Extreme_Precip_Percentage": [(negative_sum_extreme_precip_historical / negative_sum_historical) * 100] }) @@ -683,14 +682,10 @@ }) multiplied_values_df_historical.to_csv(results_folder_to_save/f'multiplied_values_historical.csv', index=False) - -print(result_df_historical) result_df_historical.to_csv(f'/Users/rem76/Desktop/Climate_change_health/Results/{service}_disruptions/negative_sums_and_percentages_historical.csv', index=False) ####### Historical disruptions ########## - - historical_predictions = pd.read_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/results_of_model_historical_predictions_{service}.csv') historical_predictions = historical_predictions.loc[historical_predictions['Difference_in_Expectation'] < 0] @@ -747,6 +742,8 @@ print("Mean Percentage Difference:", mean_percentage_diff) print("Standard Deviation of Percentage Difference:", sd_percentage_diff) + + ###### Effect of CYCLONE FREDDY ####### historical_predictions = pd.read_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/results_of_model_historical_predictions_{service}.csv') @@ -795,73 +792,171 @@ def calculate_percentage_difference(historical_predictions, year, zone=None): ################## -# Define file paths -monthly_reporting_file = "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_ANC_lm.csv" -five_day_max_file = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/historical_daily_total_by_facilities_with_ANC_five_day_cumulative.csv" -precipitation_path = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL" +# # Define file paths +# monthly_reporting_file = "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_ANC_lm.csv" +# five_day_max_file = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/historical_daily_total_by_facilities_with_ANC_five_day_cumulative.csv" +# precipitation_path = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Downscaled_CMIP6_data_CIL" +# services = ["ANC"] +# def filter_top_20_percent(values): +# """Filter values to keep only those in the top 80th percentile.""" +# threshold = np.percentile(values, 80) +# return values[values >= threshold] +# +# # Load and filter monthly reporting data +# monthly_reporting_df = pd.read_csv(monthly_reporting_file) +# monthly_reporting_values = monthly_reporting_df.iloc[:, 1:].values.flatten() +# monthly_reporting_values = filter_top_20_percent(monthly_reporting_values) +# +# # Load and filter 5-day max reporting data +# five_day_max_df = pd.read_csv(five_day_max_file) +# five_day_max_values = five_day_max_df.iloc[:, 1:].values.flatten() +# five_day_max_values = filter_top_20_percent(five_day_max_values) +# +# # Create a figure with 3 rows (one per scenario) and 2 columns (Monthly, 5-Day Max) +# fig, axes = plt.subplots(3, 2, figsize=(14, 12)) +# +# for i, scenario in enumerate(scenarios): +# # Monthly Reporting Distribution +# sns.kdeplot(monthly_reporting_values, label="Monthly Reporting ANC", color='black', ax=axes[i, 0], alpha=1) +# axes[i, 0].set_title(f"Top 20% Distribution - Monthly ({scenario})") +# axes[i, 0].set_xlabel("Precipitation (mm)") +# axes[i, 0].set_ylabel("Density") +# +# # 5-Day Max Reporting Distribution +# sns.kdeplot(five_day_max_values, label="5-Day Max Reporting ANC", color='black', ax=axes[i, 1], alpha=1) +# axes[i, 1].set_title(f"Top 20% Distribution - 5 Day Max ({scenario})") +# axes[i, 1].set_xlabel("Precipitation (mm)") +# axes[i, 1].set_ylabel("Density") +# +# # Loop through model types and services to plot distributions +# for model in model_types: +# for service in services: +# # Monthly Prediction Data +# monthly_file_path = os.path.join( +# precipitation_path, scenario, f"{model}_monthly_prediction_weather_by_facility_{service}.csv" +# ) +# if os.path.exists(monthly_file_path): +# df = pd.read_csv(monthly_file_path) +# values = df.iloc[:, 1:].values.flatten() +# values = filter_top_20_percent(values) +# if len(values) > 0: +# sns.kdeplot(values, label=f"{model} - {service}", alpha=0.4, ax=axes[i, 0]) +# +# # 5-Day Max Prediction Data +# five_day_file_path = os.path.join( +# precipitation_path, scenario, f"{model}_window_prediction_weather_by_facility_{service}.csv" +# ) +# if os.path.exists(five_day_file_path): +# df = pd.read_csv(five_day_file_path) +# values = df.iloc[:, 1:].values.flatten() +# values = filter_top_20_percent(values) +# if len(values) > 0: +# sns.kdeplot(values, label=f"{model} - {service}", alpha=0.3, ax=axes[i, 1]) +# +# axes[0, 0].legend() +# axes[0, 1].legend() +# +# #plt.tight_layout() +# plt.show() +# plt.savefig(f"/Users/rem76/Desktop/Climate_change_health/Data/historical_vs_future_precipitation_ANC.png") +# -def filter_top_20_percent(values): - """Filter values to keep only those in the top 80th percentile.""" - threshold = np.percentile(values, 80) - return values[values >= threshold] -# Load and filter monthly reporting data -monthly_reporting_df = pd.read_csv(monthly_reporting_file) -monthly_reporting_values = monthly_reporting_df.iloc[:, 1:].values.flatten() -monthly_reporting_values = filter_top_20_percent(monthly_reporting_values) +##### Compare expected differences in counterfactuals ########### -# Load and filter 5-day max reporting data -five_day_max_df = pd.read_csv(five_day_max_file) -five_day_max_values = five_day_max_df.iloc[:, 1:].values.flatten() -five_day_max_values = filter_top_20_percent(five_day_max_values) +fig, axes = plt.subplots(1, 2, figsize=(18, 9), sharey=True) +y_min, y_max = float('inf'), float('-inf') -# Create a figure with 3 rows (one per scenario) and 2 columns (Monthly, 5-Day Max) -fig, axes = plt.subplots(3, 2, figsize=(14, 12)) +percentage_diff_by_year_district_all = {} +percentage_diff_by_year_district_scenario = {} -for i, scenario in enumerate(scenarios): - # Monthly Reporting Distribution - sns.kdeplot(monthly_reporting_values, label="Monthly Reporting ANC", color='black', ax=axes[i, 0], alpha=1) - axes[i, 0].set_title(f"Top 20% Distribution - Monthly ({scenario})") - axes[i, 0].set_xlabel("Precipitation (mm)") - axes[i, 0].set_ylabel("Density") - - # 5-Day Max Reporting Distribution - sns.kdeplot(five_day_max_values, label="5-Day Max Reporting ANC", color='black', ax=axes[i, 1], alpha=1) - axes[i, 1].set_title(f"Top 20% Distribution - 5 Day Max ({scenario})") - axes[i, 1].set_xlabel("Precipitation (mm)") - axes[i, 1].set_ylabel("Density") - - # Loop through model types and services to plot distributions - for model in model_types: - for service in services: - # Monthly Prediction Data - monthly_file_path = os.path.join( - precipitation_path, scenario, f"{model}_monthly_prediction_weather_by_facility_{service}.csv" - ) - if os.path.exists(monthly_file_path): - df = pd.read_csv(monthly_file_path) - values = df.iloc[:, 1:].values.flatten() - values = filter_top_20_percent(values) - if len(values) > 0: - sns.kdeplot(values, label=f"{model} - {service}", alpha=0.4, ax=axes[i, 0]) - - # 5-Day Max Prediction Data - five_day_file_path = os.path.join( - precipitation_path, scenario, f"{model}_window_prediction_weather_by_facility_{service}.csv" - ) - if os.path.exists(five_day_file_path): - df = pd.read_csv(five_day_file_path) - values = df.iloc[:, 1:].values.flatten() - values = filter_top_20_percent(values) - if len(values) > 0: - sns.kdeplot(values, label=f"{model} - {service}", alpha=0.3, ax=axes[i, 1]) - - axes[0, 0].legend() - axes[0, 1].legend() +counterfactuals = ["historical", "baseline"] -#plt.tight_layout() +for i, counterfactual in enumerate(counterfactuals): + percentage_diff_by_district = {} + percentage_diff_by_year_district_scenario[counterfactual] = {} + + predictions_from_model = historical_predictions if counterfactual == 'historical' else baseline_predictions + predictions_from_model = predictions_from_model.loc[predictions_from_model['Difference_in_Expectation'] < 0] + + predictions_from_model_sum = predictions_from_model.groupby('District').sum().reset_index() + + predictions_from_model_sum['Percentage_Difference'] = ( + predictions_from_model_sum['Difference_in_Expectation'] / + predictions_from_model_sum['Predicted_No_Weather_Model'] + ).abs() + + predictions_from_model_sum['District'] = predictions_from_model_sum['District'].replace( + {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} + ) + + for _, row in predictions_from_model_sum.iterrows(): + district = row['District'] + percentage_diff = row['Percentage_Difference'] + total_births = population_proportion[district] * births_model_subset["Model_mean"].sum() + + if district not in percentage_diff_by_district: + percentage_diff_by_district[district] = 0 + + percentage_diff_by_district[district] += (percentage_diff * total_births) + percentage_diff_by_year_district_scenario[counterfactual][district] = percentage_diff_by_district[district] + + data_for_plot = pd.DataFrame.from_dict(percentage_diff_by_district, orient='index', columns=['Total Impact']) + data_for_plot = data_for_plot.sort_values(by='Total Impact', ascending=False) + + y_min = min(y_min, data_for_plot.min().min()) + y_max = max(y_max, data_for_plot.max().max()) + + ax = axes[i] + data_for_plot.plot(kind='bar', ax=ax, color='#1C6E8C') + ax.set_title(f'{counterfactual.capitalize()} Scenario') + ax.set_xlabel('District') + ax.set_ylabel(f'Total Disruption of {service} Services') + +for ax in axes: + ax.set_ylim(y_min, y_max * 1.2) + +plt.tight_layout() plt.show() -plt.savefig(f"/Users/rem76/Desktop/Climate_change_health/Data/historical_vs_future_precipitation_ANC.png") +#plt.savefig(results_folder_to_save / 'stacked_bar_percentage_difference_5_years_grid_single_legend_with_births.png') +# # +# +fig, ax = plt.subplots(1, 1, figsize=(10, 6)) +counterfactuals = ["historical", "baseline"] +total_disruption = {} + +for counterfactual in counterfactuals: + predictions_from_model = historical_predictions if counterfactual == 'historical' else baseline_predictions + predictions_from_model = predictions_from_model.loc[predictions_from_model['Difference_in_Expectation'] < 0] + + predictions_from_model_sum = predictions_from_model.groupby('District').sum().reset_index() + + predictions_from_model_sum['Percentage_Difference'] = ( + predictions_from_model_sum['Difference_in_Expectation'] / + predictions_from_model_sum['Predicted_No_Weather_Model'] + ).abs() + + predictions_from_model_sum['District'] = predictions_from_model_sum['District'].replace( + {"Mzimba North": "Mzimba", "Mzimba South": "Mzimba"} + ) + + total_impact = 0 + + for _, row in predictions_from_model_sum.iterrows(): + district = row['District'] + percentage_diff = row['Percentage_Difference'] + total_births = population_proportion[district] * births_model_subset["Model_mean"].sum() + + total_impact += (percentage_diff * total_births) + + total_disruption[counterfactual] = total_impact + +pd.Series(total_disruption).plot(kind='bar', ax=ax, color=['#1C6E8C', '#9AC4F8']) +ax.set_ylabel(f'Total Disruption of {service} Services') +ax.set_xlabel('Scenario') +ax.set_title('Total Impact Across All Districts') + +plt.show() From b600f67b6e7ed0e8d92d30a2975fcfb1c611c5dc Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 27 Feb 2025 10:03:20 +0000 Subject: [PATCH 284/291] So, from https://dhsprogram.com/publications/publication-fr319-dhs-final-reports.cfm, looks like average number of visits per woman is 3.2. Then, using the 1.4 pregncny:birth conversion from TLO, would mean one birth = 4.4 ANC appointmemts. Moved conversion so it happens at the top of the script --- src/scripts/climate_change/cohort_model.py | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/src/scripts/climate_change/cohort_model.py b/src/scripts/climate_change/cohort_model.py index d3c1f84bc9..9fa21753d1 100644 --- a/src/scripts/climate_change/cohort_model.py +++ b/src/scripts/climate_change/cohort_model.py @@ -1,15 +1,16 @@ +import os from pathlib import Path -from scipy.stats import ttest_1samp import geopandas as gpd -from netCDF4 import Dataset -from shapely.geometry import Polygon -from matplotlib import colors as mcolors import matplotlib.pyplot as plt -import pandas as pd import numpy as np +import pandas as pd import seaborn as sns -import os +from matplotlib import colors as mcolors +from netCDF4 import Dataset +from scipy.stats import ttest_1samp +from shapely.geometry import Polygon + from tlo.analysis.utils import ( extract_results, make_age_grp_lookup, From 93a9d6fc3d35bd57802df45d44193991f8d15742 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 27 Feb 2025 10:03:27 +0000 Subject: [PATCH 285/291] isort --- .../CIL_CMIP6_downscaling_accessing_data.py | 35 ++++++++----------- .../climate_change/inpatient_projections.py | 15 ++++---- ...al_realtionship_reporting_precipitation.py | 7 ++-- 3 files changed, 25 insertions(+), 32 deletions(-) diff --git a/src/scripts/climate_change/CIL_CMIP6_downscaling_accessing_data.py b/src/scripts/climate_change/CIL_CMIP6_downscaling_accessing_data.py index 6b27f68bbc..9473fd1cb6 100644 --- a/src/scripts/climate_change/CIL_CMIP6_downscaling_accessing_data.py +++ b/src/scripts/climate_change/CIL_CMIP6_downscaling_accessing_data.py @@ -1,35 +1,30 @@ -import planetary_computer -import pystac_client - -import xarray as xr -import numpy as np -import pandas as pd -from dask.diagnostics import ProgressBar -from tqdm.auto import tqdm - +import difflib +import glob import os import re -import glob import shutil import zipfile from pathlib import Path -import difflib -from scipy.spatial import KDTree - -import matplotlib.pyplot as plt +import cartopy.crs as ccrs +import cmip6_downscaling import geopandas as gpd +import intake +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd +import planetary_computer +import pystac_client import regionmask -import cartopy.crs as ccrs - -from netCDF4 import Dataset - +import xarray as xr from carbonplan import styles # noqa: F401 -import intake -import cmip6_downscaling +from dask.diagnostics import ProgressBar from dask.distributed import Client +from netCDF4 import Dataset from planetary_computer import sign_inplace from pystac_client import Client +from scipy.spatial import KDTree +from tqdm.auto import tqdm # Open the catalog catalog = Client.open( diff --git a/src/scripts/climate_change/inpatient_projections.py b/src/scripts/climate_change/inpatient_projections.py index 0911a1d077..7f456896f9 100644 --- a/src/scripts/climate_change/inpatient_projections.py +++ b/src/scripts/climate_change/inpatient_projections.py @@ -1,17 +1,16 @@ +import glob +import os from pathlib import Path -from scipy.stats import ttest_rel, wilcoxon, shapiro -from scipy.stats import ttest_1samp import geopandas as gpd -from netCDF4 import Dataset -from shapely.geometry import Polygon -from matplotlib import colors as mcolors import matplotlib.pyplot as plt -import pandas as pd import numpy as np +import pandas as pd import seaborn as sns -import glob -import os +from matplotlib import colors as mcolors +from netCDF4 import Dataset +from scipy.stats import shapiro, ttest_1samp, ttest_rel, wilcoxon +from shapely.geometry import Polygon from tlo.analysis.utils import ( extract_results, diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 473f68ee13..2aa483be3c 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -1,14 +1,13 @@ import matplotlib.pyplot as plt import numpy as np import pandas as pd +import scipy.stats as stats import statsmodels.api as sm +from sklearn.feature_selection import SelectKBest, f_regression +from sklearn.preprocessing import StandardScaler from statsmodels.genmod.families import NegativeBinomial, Poisson from statsmodels.genmod.generalized_linear_model import GLM -from sklearn.preprocessing import StandardScaler from statsmodels.stats.outliers_influence import variance_inflation_factor -from sklearn.feature_selection import SelectKBest, f_regression -import scipy.stats as stats - ANC = True Inpatient = False From ea6c7636c968c08103f2593821f66332aead116d Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 27 Feb 2025 11:11:48 +0000 Subject: [PATCH 286/291] Tidied so getting conversion happens up top --- src/scripts/climate_change/cohort_model.py | 33 +++++++++++----------- 1 file changed, 16 insertions(+), 17 deletions(-) diff --git a/src/scripts/climate_change/cohort_model.py b/src/scripts/climate_change/cohort_model.py index 9fa21753d1..436c97fdc2 100644 --- a/src/scripts/climate_change/cohort_model.py +++ b/src/scripts/climate_change/cohort_model.py @@ -55,12 +55,11 @@ births_results = births_results.groupby(by=births_results.index).sum() births_results = births_results.replace({0: np.nan}) -births_results['Model_mean'] = births_results * conversion_births_to_pregnancies / converstion_pregnancies_to_ANC births_model = summarize(births_results, collapse_columns=True) births_model.columns = ['Model_' + col for col in births_model.columns] -births_model_subset = births_model.iloc[15:].copy() # don't want 2010-2024 +births_model['Model_mean'] = births_model['Model_mean'] * conversion_births_to_pregnancies / converstion_pregnancies_to_ANC -print("historical:", births_model.iloc[2:15, 1].sum()) +births_model_subset_projections = births_model.iloc[15:].copy() # don't want 2010-2024 births_model_subset_historical = births_model.iloc[2:15, 1] # Load map of Malawi for later file_path_historical_data = "/Users/rem76/Desktop/Climate_change_health/Data/Precipitation_data/Historical/daily_total/2011/60ab007aa16d679a32f9c3e186d2f744.nc" @@ -101,8 +100,8 @@ predictions_from_cmip_sum['Difference_in_Expectation'] / predictions_from_cmip_sum[ 'Predicted_No_Weather_Model']) # Match birth results and predictions - matching_rows = min(len(births_model_subset), len(predictions_from_cmip_sum)) - multiplied_values = births_model_subset.head(matching_rows).iloc[:, 1].values * predictions_from_cmip_sum[ + matching_rows = min(len(births_model_subset_projections), len(predictions_from_cmip_sum)) + multiplied_values = births_model_subset_projections.head(matching_rows).iloc[:, 1].values * predictions_from_cmip_sum[ 'Percentage_Difference'].head(matching_rows).values # Check for negative values (missed cases?) @@ -112,13 +111,13 @@ filtered_predictions = predictions_from_cmip[predictions_from_cmip['Precipitation'] >= precipitation_threshold] filtered_predictions_sum = filtered_predictions.groupby('Year').sum().reset_index() percent_due_to_extreme = filtered_predictions_sum['Difference_in_Expectation'] / predictions_from_cmip_sum['Predicted_No_Weather_Model'] - multiplied_values_extreme_precip = births_model_subset.head(matching_rows).iloc[:, 1].values * percent_due_to_extreme.head(matching_rows).values + multiplied_values_extreme_precip = births_model_subset_projections.head(matching_rows).iloc[:, 1].values * percent_due_to_extreme.head(matching_rows).values negative_sum_extreme_precip = np.sum(multiplied_values_extreme_precip[multiplied_values_extreme_precip < 0]) result_df = pd.DataFrame({ "Scenario": [scenario], "Model_Type": [model_type], "Negative_Sum": [negative_sum], - "Negative_Percentage": [negative_sum / births_model_subset['Model_mean'].sum() * 100], + "Negative_Percentage": [negative_sum / births_model_subset_projections['Model_mean'].sum() * 100], "Extreme_Precip": [negative_sum_extreme_precip], "Extreme_Precip_Percentage": [(negative_sum_extreme_precip / negative_sum) * 100] }) @@ -324,9 +323,9 @@ for _, row in subset.iterrows(): district = row['District'] percentage_diff = row['Percentage_Difference'] - row_index = births_model_subset.index.get_loc(year) + row_index = births_model_subset_projections.index.get_loc(year) - number_of_births = population_proportion[district] * births_model_subset.iloc[row_index]["Model_mean"] + number_of_births = population_proportion[district] * births_model_subset_projections.iloc[row_index]["Model_mean"] if year not in percentage_diff_by_year_district: percentage_diff_by_year_district[year] = {} if district not in percentage_diff_by_year_district[year]: @@ -418,9 +417,9 @@ for _, row in subset.iterrows(): district = row['District'] percentage_diff = row['Percentage_Difference'] - row_index = births_model_subset.index.get_loc(year) + row_index = births_model_subset_projections.index.get_loc(year) - number_of_births = population_proportion[district] * births_model_subset.iloc[row_index]["Model_mean"] + number_of_births = population_proportion[district] * births_model_subset_projections.iloc[row_index]["Model_mean"] if year not in percentage_diff_by_year_district: percentage_diff_by_year_district[year] = {} if district not in percentage_diff_by_year_district[year]: @@ -509,9 +508,9 @@ for _, row in subset.iterrows(): zone = row['Zone'] percentage_diff = row['Percentage_Difference'] - row_index = births_model_subset.index.get_loc(year) + row_index = births_model_subset_projections.index.get_loc(year) - number_of_births = population_data_grouped_zone[zone] * births_model_subset.iloc[row_index]["Model_mean"] + number_of_births = population_data_grouped_zone[zone] * births_model_subset_projections.iloc[row_index]["Model_mean"] if year not in percentage_diff_by_year_zone: percentage_diff_by_year_zone[year] = {} if zone not in percentage_diff_by_year_zone[year]: @@ -595,7 +594,7 @@ sm = plt.cm.ScalarMappable(cmap='Blues', norm=mcolors.Normalize(vmin=malawi_admin2['Percentage_Difference_baseline'].min(), vmax=malawi_admin2['Percentage_Difference_baseline'].max())) sm.set_array([]) -fig.colorbar(sm, ax=ax, orientation="vertical", shrink=0.8, label="Percentage Difference (%)") +fig.colorbar(sm, ax=ax, orientation="vertical", shrink=0.8, label="Potential Disruptions (%)") #plt.title("Baseline", fontsize=16) plt.savefig(results_folder_to_save / 'percentage_difference_map_baseline.png') @@ -733,7 +732,7 @@ norm=mcolors.Normalize(vmin=global_min, vmax=global_max) ) sm.set_array([]) -fig.colorbar(sm, ax=ax, orientation="vertical", shrink=0.8, label="Percentage Difference (%)") +fig.colorbar(sm, ax=ax, orientation="vertical", shrink=0.8, label="Potential Disruptions (%)") plt.title("", fontsize=16) plt.savefig(results_folder_to_save / 'percentage_difference_map_historical.png') @@ -894,7 +893,7 @@ def calculate_percentage_difference(historical_predictions, year, zone=None): for _, row in predictions_from_model_sum.iterrows(): district = row['District'] percentage_diff = row['Percentage_Difference'] - total_births = population_proportion[district] * births_model_subset["Model_mean"].sum() + total_births = population_proportion[district] * births_model_subset_projections["Model_mean"].sum() if district not in percentage_diff_by_district: percentage_diff_by_district[district] = 0 @@ -949,7 +948,7 @@ def calculate_percentage_difference(historical_predictions, year, zone=None): for _, row in predictions_from_model_sum.iterrows(): district = row['District'] percentage_diff = row['Percentage_Difference'] - total_births = population_proportion[district] * births_model_subset["Model_mean"].sum() + total_births = population_proportion[district] * births_model_subset_projections["Model_mean"].sum() total_impact += (percentage_diff * total_births) From 2035e3a4001794ad0e9f9e8edb9fbc0b5aac0998 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 28 Feb 2025 08:33:25 +0000 Subject: [PATCH 287/291] Plot to see the difference in precipitation between 1940-1950 and 2011 - 2024 --- .../comparing_historical_counterfactuals.py | 61 +++++++++++++++++++ 1 file changed, 61 insertions(+) create mode 100644 src/scripts/climate_change/comparing_historical_counterfactuals.py diff --git a/src/scripts/climate_change/comparing_historical_counterfactuals.py b/src/scripts/climate_change/comparing_historical_counterfactuals.py new file mode 100644 index 0000000000..4004d45d0d --- /dev/null +++ b/src/scripts/climate_change/comparing_historical_counterfactuals.py @@ -0,0 +1,61 @@ +import matplotlib.pyplot as plt +import pandas as pd + +# Load data +service = 'ANC' +historical_predictions = pd.read_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/results_of_model_historical_predictions_{service}.csv') +baseline_predictions = pd.read_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/weather_predictions_with_X_baseline_{service}.csv') + +# Plot the 'Precipitation' column from both datasets +plt.figure(figsize=(10, 6)) +plt.plot(historical_predictions['Precipitation'], label='Historical Predictions', color='#1C6E8C') +plt.plot(baseline_predictions['Precipitation'], label='Baseline Predictions', color='#9AC4F8') +plt.title('Precipitation: Historical vs Baseline Predictions') +plt.xlabel('Time') +plt.ylabel('Precipitation') +plt.legend() +plt.grid(True) +plt.show() + + +weather_data_monthly_original = pd.read_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_ANC_lm.csv", + index_col=0 +) +weather_data_monthly_20th_century = pd.read_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_ANC_lm_baseline.csv", + index_col=0 +) + +# Plot the 'Precipitation' column from both datasets +plt.figure(figsize=(10, 6)) +print(weather_data_monthly_original) +plt.plot(weather_data_monthly_original, label='Original Monthly Weather', color='#1C6E8C') +plt.plot(weather_data_monthly_20th_century, label='20th Century Monthly Weather', color='#9AC4F8') +plt.title('Precipitation: Original vs 20th Century Monthly Weather') +plt.xlabel('Time') +plt.ylabel('Precipitation') +plt.legend() +plt.grid(True) +plt.show() + +weather_data_monthly_original = pd.read_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_ANC_lm.csv", + index_col=0 +) +weather_data_monthly_20th_century = pd.read_csv( + "/Users/rem76/Desktop/Climate_change_health/Data/historical_weather_by_smaller_facilities_with_ANC_lm_baseline.csv", + index_col=0 +) + +# Calculate the difference between the two DataFrames +difference = weather_data_monthly_original - weather_data_monthly_20th_century + +# Calculate the average difference for each column +average_difference = difference.mean() + +# Display the result +print(average_difference) + + + From e891c0e89e395801f3a73de3f8dc6e35dde3193d Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 7 Mar 2025 11:24:27 +0000 Subject: [PATCH 288/291] Updated so now the facility is the facility name, not an id based on the column number --- ...r_model_historical_realtionship_reporting_precipitation.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 2aa483be3c..685380ec4a 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -234,8 +234,8 @@ def repeat_info(info, num_facilities, year_range, historical): month = month_repeated[:-4] month_flattened = month*len(monthly_reporting_by_facility.columns) -facility_flattened = list(range(len(monthly_reporting_by_facility.columns))) * len(month) - +facility_flattened = list(monthly_reporting_by_facility.columns) * len(month) +print(facility_flattened) # Flatten data y = monthly_reporting_by_facility.values.flatten() if np.nanmin(y) < 1: From f17525430f8844cb836ee276f458336e516a3871 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 7 Mar 2025 11:25:34 +0000 Subject: [PATCH 289/291] removed print --- ...near_model_historical_realtionship_reporting_precipitation.py | 1 - 1 file changed, 1 deletion(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index 685380ec4a..db02b84f73 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -235,7 +235,6 @@ def repeat_info(info, num_facilities, year_range, historical): month_flattened = month*len(monthly_reporting_by_facility.columns) facility_flattened = list(monthly_reporting_by_facility.columns) * len(month) -print(facility_flattened) # Flatten data y = monthly_reporting_by_facility.values.flatten() if np.nanmin(y) < 1: From 63dfd2f0afcb6f9c0fc464aec5ed736105827161 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Fri, 7 Mar 2025 11:37:12 +0000 Subject: [PATCH 290/291] changed so that for the future predictions, too, the facility id is replaced with the facility name --- ...r_model_historical_realtionship_reporting_precipitation.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py index db02b84f73..f081cbb84b 100644 --- a/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py +++ b/src/scripts/climate_change/linear_model_historical_realtionship_reporting_precipitation.py @@ -700,7 +700,9 @@ def get_weather_data(ssp_scenario, model_type): month_repeated_prediction = [m for _ in year_range_prediction for m in range(1, 13)] year_flattened_prediction = np.repeat(year_range_prediction, 12 * num_facilities) month_flattened_prediction = month_repeated_prediction * num_facilities - facility_flattened_prediction = np.tile(range(num_facilities), len(year_flattened_prediction) // num_facilities) + facility_flattened_prediction = np.tile(monthly_reporting_by_facility.columns, + len(year_flattened_prediction) // len( + monthly_reporting_by_facility.columns)) # Encode facilities and create above/below average weather data facility_encoded_prediction = pd.get_dummies(facility_flattened_prediction, drop_first=True) From cb46bf5351d4ab58f0c5d31793a84046ee455bf3 Mon Sep 17 00:00:00 2001 From: RachelMurray-Watson Date: Thu, 13 Mar 2025 13:13:39 +0000 Subject: [PATCH 291/291] Add calculating 95% CI --- src/scripts/climate_change/cohort_model.py | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/src/scripts/climate_change/cohort_model.py b/src/scripts/climate_change/cohort_model.py index 436c97fdc2..094c5c3405 100644 --- a/src/scripts/climate_change/cohort_model.py +++ b/src/scripts/climate_change/cohort_model.py @@ -5,6 +5,8 @@ import matplotlib.pyplot as plt import numpy as np import pandas as pd +from scipy import stats + import seaborn as sns from matplotlib import colors as mcolors from netCDF4 import Dataset @@ -743,7 +745,15 @@ print("Mean Percentage Difference:", mean_percentage_diff) print("Standard Deviation of Percentage Difference:", sd_percentage_diff) +n = malawi_admin2['Percentage_Difference_historical'].count() + +t_critical = stats.t.ppf(0.975, df=n-1) # two-tailed t critical value for 95% CI +margin_of_error = t_critical * (sd_percentage_diff / np.sqrt(n)) + +lower_bound = mean_percentage_diff - margin_of_error +upper_bound = mean_percentage_diff + margin_of_error +print(f"95% CI: ({lower_bound:.2f}, {upper_bound:.2f})") ###### Effect of CYCLONE FREDDY ####### historical_predictions = pd.read_csv(f'/Users/rem76/Desktop/Climate_change_health/Data/results_of_model_historical_predictions_{service}.csv')